in lightgbm/src/main/scala/com/microsoft/azure/synapse/ml/lightgbm/params/LightGBMParams.scala [330:484]
def getNumIterations: Int = $(numIterations)
def setNumIterations(value: Int): this.type = set(numIterations, value)
val learningRate = new DoubleParam(this, "learningRate", "Learning rate or shrinkage rate")
setDefault(learningRate -> 0.1)
def getLearningRate: Double = $(learningRate)
def setLearningRate(value: Double): this.type = set(learningRate, value)
val numLeaves = new IntParam(this, "numLeaves", "Number of leaves")
setDefault(numLeaves -> 31)
def getNumLeaves: Int = $(numLeaves)
def setNumLeaves(value: Int): this.type = set(numLeaves, value)
val baggingFreq = new IntParam(this, "baggingFreq", "Bagging frequency")
setDefault(baggingFreq->0)
def getBaggingFreq: Int = $(baggingFreq)
def setBaggingFreq(value: Int): this.type = set(baggingFreq, value)
val baggingSeed = new IntParam(this, "baggingSeed", "Bagging seed")
setDefault(baggingSeed->3)
def getBaggingSeed: Int = $(baggingSeed)
def setBaggingSeed(value: Int): this.type = set(baggingSeed, value)
val maxDepth = new IntParam(this, "maxDepth", "Max depth")
setDefault(maxDepth-> -1)
def getMaxDepth: Int = $(maxDepth)
def setMaxDepth(value: Int): this.type = set(maxDepth, value)
val minSumHessianInLeaf = new DoubleParam(this, "minSumHessianInLeaf", "Minimal sum hessian in one leaf")
setDefault(minSumHessianInLeaf -> 1e-3)
def getMinSumHessianInLeaf: Double = $(minSumHessianInLeaf)
def setMinSumHessianInLeaf(value: Double): this.type = set(minSumHessianInLeaf, value)
val modelString = new Param[String](this, "modelString", "LightGBM model to retrain")
setDefault(modelString -> "")
def getModelString: String = $(modelString)
def setModelString(value: String): this.type = set(modelString, value)
val verbosity = new IntParam(this, "verbosity",
"Verbosity where lt 0 is Fatal, eq 0 is Error, eq 1 is Info, gt 1 is Debug")
setDefault(verbosity -> -1)
def getVerbosity: Int = $(verbosity)
def setVerbosity(value: Int): this.type = set(verbosity, value)
val boostFromAverage = new BooleanParam(this, "boostFromAverage",
"Adjusts initial score to the mean of labels for faster convergence")
setDefault(boostFromAverage -> true)
def getBoostFromAverage: Boolean = $(boostFromAverage)
def setBoostFromAverage(value: Boolean): this.type = set(boostFromAverage, value)
val boostingType = new Param[String](this, "boostingType",
"Default gbdt = traditional Gradient Boosting Decision Tree. Options are: " +
"gbdt, gbrt, rf (Random Forest), random_forest, dart (Dropouts meet Multiple " +
"Additive Regression Trees), goss (Gradient-based One-Side Sampling). ")
setDefault(boostingType -> "gbdt")
def getBoostingType: String = $(boostingType)
def setBoostingType(value: String): this.type = set(boostingType, value)
val lambdaL1 = new DoubleParam(this, "lambdaL1", "L1 regularization")
setDefault(lambdaL1 -> 0.0)
def getLambdaL1: Double = $(lambdaL1)
def setLambdaL1(value: Double): this.type = set(lambdaL1, value)
val lambdaL2 = new DoubleParam(this, "lambdaL2", "L2 regularization")
setDefault(lambdaL2 -> 0.0)
def getLambdaL2: Double = $(lambdaL2)
def setLambdaL2(value: Double): this.type = set(lambdaL2, value)
val isProvideTrainingMetric = new BooleanParam(this, "isProvideTrainingMetric",
"Whether output metric result over training dataset.")
setDefault(isProvideTrainingMetric -> false)
def getIsProvideTrainingMetric: Boolean = $(isProvideTrainingMetric)
def setIsProvideTrainingMetric(value: Boolean): this.type = set(isProvideTrainingMetric, value)
val metric = new Param[String](this, "metric",
"Metrics to be evaluated on the evaluation data. Options are: " +
"empty string or not specified means that metric corresponding to specified " +
"objective will be used (this is possible only for pre-defined objective functions, " +
"otherwise no evaluation metric will be added). " +
"None (string, not a None value) means that no metric will be registered, a" +
"liases: na, null, custom. " +
"l1, absolute loss, aliases: mean_absolute_error, mae, regression_l1. " +
"l2, square loss, aliases: mean_squared_error, mse, regression_l2, regression. " +
"rmse, root square loss, aliases: root_mean_squared_error, l2_root. " +
"quantile, Quantile regression. " +
"mape, MAPE loss, aliases: mean_absolute_percentage_error. " +
"huber, Huber loss. " +
"fair, Fair loss. " +
"poisson, negative log-likelihood for Poisson regression. " +
"gamma, negative log-likelihood for Gamma regression. " +
"gamma_deviance, residual deviance for Gamma regression. " +
"tweedie, negative log-likelihood for Tweedie regression. " +
"ndcg, NDCG, aliases: lambdarank. " +
"map, MAP, aliases: mean_average_precision. " +
"auc, AUC. " +
"binary_logloss, log loss, aliases: binary. " +
"binary_error, for one sample: 0 for correct classification, 1 for error classification. " +
"multi_logloss, log loss for multi-class classification, aliases: multiclass, softmax, " +
"multiclassova, multiclass_ova, ova, ovr. " +
"multi_error, error rate for multi-class classification. " +
"cross_entropy, cross-entropy (with optional linear weights), aliases: xentropy. " +
"cross_entropy_lambda, intensity-weighted cross-entropy, aliases: xentlambda. " +
"kullback_leibler, Kullback-Leibler divergence, aliases: kldiv. ")
setDefault(metric -> "")
def getMetric: String = $(metric)
def setMetric(value: String): this.type = set(metric, value)
val minGainToSplit = new DoubleParam(this, "minGainToSplit",
"The minimal gain to perform split")
setDefault(minGainToSplit -> 0.0)
def getMinGainToSplit: Double = $(minGainToSplit)
def setMinGainToSplit(value: Double): this.type = set(minGainToSplit, value)
val maxDeltaStep = new DoubleParam(this, "maxDeltaStep",
"Used to limit the max output of tree leaves")
setDefault(maxDeltaStep -> 0.0)
def getMaxDeltaStep: Double = $(maxDeltaStep)
def setMaxDeltaStep(value: Double): this.type = set(maxDeltaStep, value)
val maxBinByFeature = new IntArrayParam(this, "maxBinByFeature",
"Max number of bins for each feature")
setDefault(maxBinByFeature -> Array.empty)
def getMaxBinByFeature: Array[Int] = $(maxBinByFeature)
def setMaxBinByFeature(value: Array[Int]): this.type = set(maxBinByFeature, value)
val minDataInLeaf = new IntParam(this, "minDataInLeaf",
"Minimal number of data in one leaf. Can be used to deal with over-fitting.")
setDefault(minDataInLeaf -> 20)
def getMinDataInLeaf: Int = $(minDataInLeaf)
def setMinDataInLeaf(value: Int): this.type = set(minDataInLeaf, value)
var delegate: Option[LightGBMDelegate] = None
def getDelegate: Option[LightGBMDelegate] = delegate
def setDelegate(delegate: LightGBMDelegate): this.type = {
this.delegate = Option(delegate)
this
}