All Downloads are FREE. Search and download functionalities are using the official Maven repository.

co.elastic.clients.elasticsearch.ml.DataframeAnalysisBase Maven / Gradle / Ivy

There is a newer version: 8.17.0
Show newest version
/*
 * Licensed to Elasticsearch B.V. under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch B.V. licenses this file to you under
 * the Apache License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

//----------------------------------------------------
// THIS CODE IS GENERATED. MANUAL EDITS WILL BE LOST.
//----------------------------------------------------

package co.elastic.clients.elasticsearch.ml;

import co.elastic.clients.json.JsonpDeserializable;
import co.elastic.clients.json.JsonpDeserializer;
import co.elastic.clients.json.JsonpMapper;
import co.elastic.clients.json.JsonpSerializable;
import co.elastic.clients.json.ObjectBuilderDeserializer;
import co.elastic.clients.json.ObjectDeserializer;
import co.elastic.clients.util.ApiTypeHelper;
import co.elastic.clients.util.ObjectBuilder;
import co.elastic.clients.util.WithJsonObjectBuilderBase;
import jakarta.json.stream.JsonGenerator;
import java.lang.Boolean;
import java.lang.Double;
import java.lang.Integer;
import java.lang.String;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import javax.annotation.Nullable;

// typedef: ml._types.DataframeAnalysis

/**
 *
 * @see API
 *      specification
 */

public abstract class DataframeAnalysisBase implements JsonpSerializable {
	@Nullable
	private final Double alpha;

	private final String dependentVariable;

	@Nullable
	private final Double downsampleFactor;

	@Nullable
	private final Boolean earlyStoppingEnabled;

	@Nullable
	private final Double eta;

	@Nullable
	private final Double etaGrowthRatePerTree;

	@Nullable
	private final Double featureBagFraction;

	private final List featureProcessors;

	@Nullable
	private final Double gamma;

	@Nullable
	private final Double lambda;

	@Nullable
	private final Integer maxOptimizationRoundsPerHyperparameter;

	@Nullable
	private final Integer maxTrees;

	@Nullable
	private final Integer numTopFeatureImportanceValues;

	@Nullable
	private final String predictionFieldName;

	@Nullable
	private final Double randomizeSeed;

	@Nullable
	private final Integer softTreeDepthLimit;

	@Nullable
	private final Double softTreeDepthTolerance;

	@Nullable
	private final String trainingPercent;

	// ---------------------------------------------------------------------------------------------

	protected DataframeAnalysisBase(AbstractBuilder builder) {

		this.alpha = builder.alpha;
		this.dependentVariable = ApiTypeHelper.requireNonNull(builder.dependentVariable, this, "dependentVariable");
		this.downsampleFactor = builder.downsampleFactor;
		this.earlyStoppingEnabled = builder.earlyStoppingEnabled;
		this.eta = builder.eta;
		this.etaGrowthRatePerTree = builder.etaGrowthRatePerTree;
		this.featureBagFraction = builder.featureBagFraction;
		this.featureProcessors = ApiTypeHelper.unmodifiable(builder.featureProcessors);
		this.gamma = builder.gamma;
		this.lambda = builder.lambda;
		this.maxOptimizationRoundsPerHyperparameter = builder.maxOptimizationRoundsPerHyperparameter;
		this.maxTrees = builder.maxTrees;
		this.numTopFeatureImportanceValues = builder.numTopFeatureImportanceValues;
		this.predictionFieldName = builder.predictionFieldName;
		this.randomizeSeed = builder.randomizeSeed;
		this.softTreeDepthLimit = builder.softTreeDepthLimit;
		this.softTreeDepthTolerance = builder.softTreeDepthTolerance;
		this.trainingPercent = builder.trainingPercent;

	}

	/**
	 * Advanced configuration option. Machine learning uses loss guided tree
	 * growing, which means that the decision trees grow where the regularized loss
	 * decreases most quickly. This parameter affects loss calculations by acting as
	 * a multiplier of the tree depth. Higher alpha values result in shallower trees
	 * and faster training times. By default, this value is calculated during
	 * hyperparameter optimization. It must be greater than or equal to zero.
	 * 

* API name: {@code alpha} */ @Nullable public final Double alpha() { return this.alpha; } /** * Required - Defines which field of the document is to be predicted. It must * match one of the fields in the index being used to train. If this field is * missing from a document, then that document will not be used for training, * but a prediction with the trained model will be generated for it. It is also * known as continuous target variable. For classification analysis, the data * type of the field must be numeric (integer, short, * long, byte), categorical (ip or * keyword), or boolean. There must be no more than 30 * different values in this field. For regression analysis, the data type of the * field must be numeric. *

* API name: {@code dependent_variable} */ public final String dependentVariable() { return this.dependentVariable; } /** * Advanced configuration option. Controls the fraction of data that is used to * compute the derivatives of the loss function for tree training. A small value * results in the use of a small fraction of the data. If this value is set to * be less than 1, accuracy typically improves. However, too small a value may * result in poor convergence for the ensemble and so require more trees. By * default, this value is calculated during hyperparameter optimization. It must * be greater than zero and less than or equal to 1. *

* API name: {@code downsample_factor} */ @Nullable public final Double downsampleFactor() { return this.downsampleFactor; } /** * Advanced configuration option. Specifies whether the training process should * finish if it is not finding any better performing models. If disabled, the * training process can take significantly longer and the chance of finding a * better performing model is unremarkable. *

* API name: {@code early_stopping_enabled} */ @Nullable public final Boolean earlyStoppingEnabled() { return this.earlyStoppingEnabled; } /** * Advanced configuration option. The shrinkage applied to the weights. Smaller * values result in larger forests which have a better generalization error. * However, larger forests cause slower training. By default, this value is * calculated during hyperparameter optimization. It must be a value between * 0.001 and 1. *

* API name: {@code eta} */ @Nullable public final Double eta() { return this.eta; } /** * Advanced configuration option. Specifies the rate at which eta * increases for each new tree that is added to the forest. For example, a rate * of 1.05 increases eta by 5% for each extra tree. By default, * this value is calculated during hyperparameter optimization. It must be * between 0.5 and 2. *

* API name: {@code eta_growth_rate_per_tree} */ @Nullable public final Double etaGrowthRatePerTree() { return this.etaGrowthRatePerTree; } /** * Advanced configuration option. Defines the fraction of features that will be * used when selecting a random bag for each candidate split. By default, this * value is calculated during hyperparameter optimization. *

* API name: {@code feature_bag_fraction} */ @Nullable public final Double featureBagFraction() { return this.featureBagFraction; } /** * Advanced configuration option. A collection of feature preprocessors that * modify one or more included fields. The analysis uses the resulting one or * more features instead of the original document field. However, these features * are ephemeral; they are not stored in the destination index. Multiple * feature_processors entries can refer to the same document * fields. Automatic categorical feature encoding still occurs for the fields * that are unprocessed by a custom processor or that have categorical values. * Use this property only if you want to override the automatic feature encoding * of the specified fields. *

* API name: {@code feature_processors} */ public final List featureProcessors() { return this.featureProcessors; } /** * Advanced configuration option. Regularization parameter to prevent * overfitting on the training data set. Multiplies a linear penalty associated * with the size of individual trees in the forest. A high gamma value causes * training to prefer small trees. A small gamma value results in larger * individual trees and slower training. By default, this value is calculated * during hyperparameter optimization. It must be a nonnegative value. *

* API name: {@code gamma} */ @Nullable public final Double gamma() { return this.gamma; } /** * Advanced configuration option. Regularization parameter to prevent * overfitting on the training data set. Multiplies an L2 regularization term * which applies to leaf weights of the individual trees in the forest. A high * lambda value causes training to favor small leaf weights. This behavior makes * the prediction function smoother at the expense of potentially not being able * to capture relevant relationships between the features and the dependent * variable. A small lambda value results in large individual trees and slower * training. By default, this value is calculated during hyperparameter * optimization. It must be a nonnegative value. *

* API name: {@code lambda} */ @Nullable public final Double lambda() { return this.lambda; } /** * Advanced configuration option. A multiplier responsible for determining the * maximum number of hyperparameter optimization steps in the Bayesian * optimization procedure. The maximum number of steps is determined based on * the number of undefined hyperparameters times the maximum optimization rounds * per hyperparameter. By default, this value is calculated during * hyperparameter optimization. *

* API name: {@code max_optimization_rounds_per_hyperparameter} */ @Nullable public final Integer maxOptimizationRoundsPerHyperparameter() { return this.maxOptimizationRoundsPerHyperparameter; } /** * Advanced configuration option. Defines the maximum number of decision trees * in the forest. The maximum value is 2000. By default, this value is * calculated during hyperparameter optimization. *

* API name: {@code max_trees} */ @Nullable public final Integer maxTrees() { return this.maxTrees; } /** * Advanced configuration option. Specifies the maximum number of feature * importance values per document to return. By default, no feature importance * calculation occurs. *

* API name: {@code num_top_feature_importance_values} */ @Nullable public final Integer numTopFeatureImportanceValues() { return this.numTopFeatureImportanceValues; } /** * Defines the name of the prediction field in the results. Defaults to * <dependent_variable>_prediction. *

* API name: {@code prediction_field_name} */ @Nullable public final String predictionFieldName() { return this.predictionFieldName; } /** * Defines the seed for the random generator that is used to pick training data. * By default, it is randomly generated. Set it to a specific value to use the * same training data each time you start a job (assuming other related * parameters such as source and analyzed_fields are * the same). *

* API name: {@code randomize_seed} */ @Nullable public final Double randomizeSeed() { return this.randomizeSeed; } /** * Advanced configuration option. Machine learning uses loss guided tree * growing, which means that the decision trees grow where the regularized loss * decreases most quickly. This soft limit combines with the * soft_tree_depth_tolerance to penalize trees that exceed the * specified depth; the regularized loss increases quickly beyond this depth. By * default, this value is calculated during hyperparameter optimization. It must * be greater than or equal to 0. *

* API name: {@code soft_tree_depth_limit} */ @Nullable public final Integer softTreeDepthLimit() { return this.softTreeDepthLimit; } /** * Advanced configuration option. This option controls how quickly the * regularized loss increases when the tree depth exceeds * soft_tree_depth_limit. By default, this value is calculated * during hyperparameter optimization. It must be greater than or equal to 0.01. *

* API name: {@code soft_tree_depth_tolerance} */ @Nullable public final Double softTreeDepthTolerance() { return this.softTreeDepthTolerance; } /** * Defines what percentage of the eligible documents that will be used for * training. Documents that are ignored by the analysis (for example those that * contain arrays with more than one value) won’t be included in the calculation * for used percentage. *

* API name: {@code training_percent} */ @Nullable public final String trainingPercent() { return this.trainingPercent; } /** * Serialize this object to JSON. */ public void serialize(JsonGenerator generator, JsonpMapper mapper) { generator.writeStartObject(); serializeInternal(generator, mapper); generator.writeEnd(); } protected void serializeInternal(JsonGenerator generator, JsonpMapper mapper) { if (this.alpha != null) { generator.writeKey("alpha"); generator.write(this.alpha); } generator.writeKey("dependent_variable"); generator.write(this.dependentVariable); if (this.downsampleFactor != null) { generator.writeKey("downsample_factor"); generator.write(this.downsampleFactor); } if (this.earlyStoppingEnabled != null) { generator.writeKey("early_stopping_enabled"); generator.write(this.earlyStoppingEnabled); } if (this.eta != null) { generator.writeKey("eta"); generator.write(this.eta); } if (this.etaGrowthRatePerTree != null) { generator.writeKey("eta_growth_rate_per_tree"); generator.write(this.etaGrowthRatePerTree); } if (this.featureBagFraction != null) { generator.writeKey("feature_bag_fraction"); generator.write(this.featureBagFraction); } if (ApiTypeHelper.isDefined(this.featureProcessors)) { generator.writeKey("feature_processors"); generator.writeStartArray(); for (DataframeAnalysisFeatureProcessor item0 : this.featureProcessors) { item0.serialize(generator, mapper); } generator.writeEnd(); } if (this.gamma != null) { generator.writeKey("gamma"); generator.write(this.gamma); } if (this.lambda != null) { generator.writeKey("lambda"); generator.write(this.lambda); } if (this.maxOptimizationRoundsPerHyperparameter != null) { generator.writeKey("max_optimization_rounds_per_hyperparameter"); generator.write(this.maxOptimizationRoundsPerHyperparameter); } if (this.maxTrees != null) { generator.writeKey("max_trees"); generator.write(this.maxTrees); } if (this.numTopFeatureImportanceValues != null) { generator.writeKey("num_top_feature_importance_values"); generator.write(this.numTopFeatureImportanceValues); } if (this.predictionFieldName != null) { generator.writeKey("prediction_field_name"); generator.write(this.predictionFieldName); } if (this.randomizeSeed != null) { generator.writeKey("randomize_seed"); generator.write(this.randomizeSeed); } if (this.softTreeDepthLimit != null) { generator.writeKey("soft_tree_depth_limit"); generator.write(this.softTreeDepthLimit); } if (this.softTreeDepthTolerance != null) { generator.writeKey("soft_tree_depth_tolerance"); generator.write(this.softTreeDepthTolerance); } if (this.trainingPercent != null) { generator.writeKey("training_percent"); generator.write(this.trainingPercent); } } protected abstract static class AbstractBuilder> extends WithJsonObjectBuilderBase { @Nullable private Double alpha; private String dependentVariable; @Nullable private Double downsampleFactor; @Nullable private Boolean earlyStoppingEnabled; @Nullable private Double eta; @Nullable private Double etaGrowthRatePerTree; @Nullable private Double featureBagFraction; @Nullable private List featureProcessors; @Nullable private Double gamma; @Nullable private Double lambda; @Nullable private Integer maxOptimizationRoundsPerHyperparameter; @Nullable private Integer maxTrees; @Nullable private Integer numTopFeatureImportanceValues; @Nullable private String predictionFieldName; @Nullable private Double randomizeSeed; @Nullable private Integer softTreeDepthLimit; @Nullable private Double softTreeDepthTolerance; @Nullable private String trainingPercent; /** * Advanced configuration option. Machine learning uses loss guided tree * growing, which means that the decision trees grow where the regularized loss * decreases most quickly. This parameter affects loss calculations by acting as * a multiplier of the tree depth. Higher alpha values result in shallower trees * and faster training times. By default, this value is calculated during * hyperparameter optimization. It must be greater than or equal to zero. *

* API name: {@code alpha} */ public final BuilderT alpha(@Nullable Double value) { this.alpha = value; return self(); } /** * Required - Defines which field of the document is to be predicted. It must * match one of the fields in the index being used to train. If this field is * missing from a document, then that document will not be used for training, * but a prediction with the trained model will be generated for it. It is also * known as continuous target variable. For classification analysis, the data * type of the field must be numeric (integer, short, * long, byte), categorical (ip or * keyword), or boolean. There must be no more than 30 * different values in this field. For regression analysis, the data type of the * field must be numeric. *

* API name: {@code dependent_variable} */ public final BuilderT dependentVariable(String value) { this.dependentVariable = value; return self(); } /** * Advanced configuration option. Controls the fraction of data that is used to * compute the derivatives of the loss function for tree training. A small value * results in the use of a small fraction of the data. If this value is set to * be less than 1, accuracy typically improves. However, too small a value may * result in poor convergence for the ensemble and so require more trees. By * default, this value is calculated during hyperparameter optimization. It must * be greater than zero and less than or equal to 1. *

* API name: {@code downsample_factor} */ public final BuilderT downsampleFactor(@Nullable Double value) { this.downsampleFactor = value; return self(); } /** * Advanced configuration option. Specifies whether the training process should * finish if it is not finding any better performing models. If disabled, the * training process can take significantly longer and the chance of finding a * better performing model is unremarkable. *

* API name: {@code early_stopping_enabled} */ public final BuilderT earlyStoppingEnabled(@Nullable Boolean value) { this.earlyStoppingEnabled = value; return self(); } /** * Advanced configuration option. The shrinkage applied to the weights. Smaller * values result in larger forests which have a better generalization error. * However, larger forests cause slower training. By default, this value is * calculated during hyperparameter optimization. It must be a value between * 0.001 and 1. *

* API name: {@code eta} */ public final BuilderT eta(@Nullable Double value) { this.eta = value; return self(); } /** * Advanced configuration option. Specifies the rate at which eta * increases for each new tree that is added to the forest. For example, a rate * of 1.05 increases eta by 5% for each extra tree. By default, * this value is calculated during hyperparameter optimization. It must be * between 0.5 and 2. *

* API name: {@code eta_growth_rate_per_tree} */ public final BuilderT etaGrowthRatePerTree(@Nullable Double value) { this.etaGrowthRatePerTree = value; return self(); } /** * Advanced configuration option. Defines the fraction of features that will be * used when selecting a random bag for each candidate split. By default, this * value is calculated during hyperparameter optimization. *

* API name: {@code feature_bag_fraction} */ public final BuilderT featureBagFraction(@Nullable Double value) { this.featureBagFraction = value; return self(); } /** * Advanced configuration option. A collection of feature preprocessors that * modify one or more included fields. The analysis uses the resulting one or * more features instead of the original document field. However, these features * are ephemeral; they are not stored in the destination index. Multiple * feature_processors entries can refer to the same document * fields. Automatic categorical feature encoding still occurs for the fields * that are unprocessed by a custom processor or that have categorical values. * Use this property only if you want to override the automatic feature encoding * of the specified fields. *

* API name: {@code feature_processors} *

* Adds all elements of list to featureProcessors. */ public final BuilderT featureProcessors(List list) { this.featureProcessors = _listAddAll(this.featureProcessors, list); return self(); } /** * Advanced configuration option. A collection of feature preprocessors that * modify one or more included fields. The analysis uses the resulting one or * more features instead of the original document field. However, these features * are ephemeral; they are not stored in the destination index. Multiple * feature_processors entries can refer to the same document * fields. Automatic categorical feature encoding still occurs for the fields * that are unprocessed by a custom processor or that have categorical values. * Use this property only if you want to override the automatic feature encoding * of the specified fields. *

* API name: {@code feature_processors} *

* Adds one or more values to featureProcessors. */ public final BuilderT featureProcessors(DataframeAnalysisFeatureProcessor value, DataframeAnalysisFeatureProcessor... values) { this.featureProcessors = _listAdd(this.featureProcessors, value, values); return self(); } /** * Advanced configuration option. A collection of feature preprocessors that * modify one or more included fields. The analysis uses the resulting one or * more features instead of the original document field. However, these features * are ephemeral; they are not stored in the destination index. Multiple * feature_processors entries can refer to the same document * fields. Automatic categorical feature encoding still occurs for the fields * that are unprocessed by a custom processor or that have categorical values. * Use this property only if you want to override the automatic feature encoding * of the specified fields. *

* API name: {@code feature_processors} *

* Adds a value to featureProcessors using a builder lambda. */ public final BuilderT featureProcessors( Function> fn) { return featureProcessors(fn.apply(new DataframeAnalysisFeatureProcessor.Builder()).build()); } /** * Advanced configuration option. Regularization parameter to prevent * overfitting on the training data set. Multiplies a linear penalty associated * with the size of individual trees in the forest. A high gamma value causes * training to prefer small trees. A small gamma value results in larger * individual trees and slower training. By default, this value is calculated * during hyperparameter optimization. It must be a nonnegative value. *

* API name: {@code gamma} */ public final BuilderT gamma(@Nullable Double value) { this.gamma = value; return self(); } /** * Advanced configuration option. Regularization parameter to prevent * overfitting on the training data set. Multiplies an L2 regularization term * which applies to leaf weights of the individual trees in the forest. A high * lambda value causes training to favor small leaf weights. This behavior makes * the prediction function smoother at the expense of potentially not being able * to capture relevant relationships between the features and the dependent * variable. A small lambda value results in large individual trees and slower * training. By default, this value is calculated during hyperparameter * optimization. It must be a nonnegative value. *

* API name: {@code lambda} */ public final BuilderT lambda(@Nullable Double value) { this.lambda = value; return self(); } /** * Advanced configuration option. A multiplier responsible for determining the * maximum number of hyperparameter optimization steps in the Bayesian * optimization procedure. The maximum number of steps is determined based on * the number of undefined hyperparameters times the maximum optimization rounds * per hyperparameter. By default, this value is calculated during * hyperparameter optimization. *

* API name: {@code max_optimization_rounds_per_hyperparameter} */ public final BuilderT maxOptimizationRoundsPerHyperparameter(@Nullable Integer value) { this.maxOptimizationRoundsPerHyperparameter = value; return self(); } /** * Advanced configuration option. Defines the maximum number of decision trees * in the forest. The maximum value is 2000. By default, this value is * calculated during hyperparameter optimization. *

* API name: {@code max_trees} */ public final BuilderT maxTrees(@Nullable Integer value) { this.maxTrees = value; return self(); } /** * Advanced configuration option. Specifies the maximum number of feature * importance values per document to return. By default, no feature importance * calculation occurs. *

* API name: {@code num_top_feature_importance_values} */ public final BuilderT numTopFeatureImportanceValues(@Nullable Integer value) { this.numTopFeatureImportanceValues = value; return self(); } /** * Defines the name of the prediction field in the results. Defaults to * <dependent_variable>_prediction. *

* API name: {@code prediction_field_name} */ public final BuilderT predictionFieldName(@Nullable String value) { this.predictionFieldName = value; return self(); } /** * Defines the seed for the random generator that is used to pick training data. * By default, it is randomly generated. Set it to a specific value to use the * same training data each time you start a job (assuming other related * parameters such as source and analyzed_fields are * the same). *

* API name: {@code randomize_seed} */ public final BuilderT randomizeSeed(@Nullable Double value) { this.randomizeSeed = value; return self(); } /** * Advanced configuration option. Machine learning uses loss guided tree * growing, which means that the decision trees grow where the regularized loss * decreases most quickly. This soft limit combines with the * soft_tree_depth_tolerance to penalize trees that exceed the * specified depth; the regularized loss increases quickly beyond this depth. By * default, this value is calculated during hyperparameter optimization. It must * be greater than or equal to 0. *

* API name: {@code soft_tree_depth_limit} */ public final BuilderT softTreeDepthLimit(@Nullable Integer value) { this.softTreeDepthLimit = value; return self(); } /** * Advanced configuration option. This option controls how quickly the * regularized loss increases when the tree depth exceeds * soft_tree_depth_limit. By default, this value is calculated * during hyperparameter optimization. It must be greater than or equal to 0.01. *

* API name: {@code soft_tree_depth_tolerance} */ public final BuilderT softTreeDepthTolerance(@Nullable Double value) { this.softTreeDepthTolerance = value; return self(); } /** * Defines what percentage of the eligible documents that will be used for * training. Documents that are ignored by the analysis (for example those that * contain arrays with more than one value) won’t be included in the calculation * for used percentage. *

* API name: {@code training_percent} */ public final BuilderT trainingPercent(@Nullable String value) { this.trainingPercent = value; return self(); } protected abstract BuilderT self(); } // --------------------------------------------------------------------------------------------- protected static > void setupDataframeAnalysisBaseDeserializer( ObjectDeserializer op) { op.add(AbstractBuilder::alpha, JsonpDeserializer.doubleDeserializer(), "alpha"); op.add(AbstractBuilder::dependentVariable, JsonpDeserializer.stringDeserializer(), "dependent_variable"); op.add(AbstractBuilder::downsampleFactor, JsonpDeserializer.doubleDeserializer(), "downsample_factor"); op.add(AbstractBuilder::earlyStoppingEnabled, JsonpDeserializer.booleanDeserializer(), "early_stopping_enabled"); op.add(AbstractBuilder::eta, JsonpDeserializer.doubleDeserializer(), "eta"); op.add(AbstractBuilder::etaGrowthRatePerTree, JsonpDeserializer.doubleDeserializer(), "eta_growth_rate_per_tree"); op.add(AbstractBuilder::featureBagFraction, JsonpDeserializer.doubleDeserializer(), "feature_bag_fraction"); op.add(AbstractBuilder::featureProcessors, JsonpDeserializer.arrayDeserializer(DataframeAnalysisFeatureProcessor._DESERIALIZER), "feature_processors"); op.add(AbstractBuilder::gamma, JsonpDeserializer.doubleDeserializer(), "gamma"); op.add(AbstractBuilder::lambda, JsonpDeserializer.doubleDeserializer(), "lambda"); op.add(AbstractBuilder::maxOptimizationRoundsPerHyperparameter, JsonpDeserializer.integerDeserializer(), "max_optimization_rounds_per_hyperparameter"); op.add(AbstractBuilder::maxTrees, JsonpDeserializer.integerDeserializer(), "max_trees", "maximum_number_trees"); op.add(AbstractBuilder::numTopFeatureImportanceValues, JsonpDeserializer.integerDeserializer(), "num_top_feature_importance_values"); op.add(AbstractBuilder::predictionFieldName, JsonpDeserializer.stringDeserializer(), "prediction_field_name"); op.add(AbstractBuilder::randomizeSeed, JsonpDeserializer.doubleDeserializer(), "randomize_seed"); op.add(AbstractBuilder::softTreeDepthLimit, JsonpDeserializer.integerDeserializer(), "soft_tree_depth_limit"); op.add(AbstractBuilder::softTreeDepthTolerance, JsonpDeserializer.doubleDeserializer(), "soft_tree_depth_tolerance"); op.add(AbstractBuilder::trainingPercent, JsonpDeserializer.stringDeserializer(), "training_percent"); } }





© 2015 - 2025 Weber Informatics LLC | Privacy Policy