lightgbm.LGBMModel¶

class
lightgbm.
LGBMModel
(boosting_type='gbdt', num_leaves=31, max_depth=1, learning_rate=0.1, n_estimators=100, subsample_for_bin=200000, objective=None, class_weight=None, min_split_gain=0.0, min_child_weight=0.001, min_child_samples=20, subsample=1.0, subsample_freq=0, colsample_bytree=1.0, reg_alpha=0.0, reg_lambda=0.0, random_state=None, n_jobs=1, silent=True, importance_type='split', **kwargs)[source]¶ Bases:
object
Implementation of the scikitlearn API for LightGBM.

__init__
(boosting_type='gbdt', num_leaves=31, max_depth=1, learning_rate=0.1, n_estimators=100, subsample_for_bin=200000, objective=None, class_weight=None, min_split_gain=0.0, min_child_weight=0.001, min_child_samples=20, subsample=1.0, subsample_freq=0, colsample_bytree=1.0, reg_alpha=0.0, reg_lambda=0.0, random_state=None, n_jobs=1, silent=True, importance_type='split', **kwargs)[source]¶ Construct a gradient boosting model.
Parameters:  boosting_type (string, optional (default='gbdt')) – ‘gbdt’, traditional Gradient Boosting Decision Tree. ‘dart’, Dropouts meet Multiple Additive Regression Trees. ‘goss’, Gradientbased OneSide Sampling. ‘rf’, Random Forest.
 num_leaves (int, optional (default=31)) – Maximum tree leaves for base learners.
 max_depth (int, optional (default=1)) – Maximum tree depth for base learners, <=0 means no limit.
 learning_rate (float, optional (default=0.1)) – Boosting learning rate.
You can use
callbacks
parameter offit
method to shrink/adapt learning rate in training usingreset_parameter
callback. Note, that this will ignore thelearning_rate
argument in training.  n_estimators (int, optional (default=100)) – Number of boosted trees to fit.
 subsample_for_bin (int, optional (default=200000)) – Number of samples for constructing bins.
 objective (string, callable or None, optional (default=None)) – Specify the learning task and the corresponding learning objective or a custom objective function to be used (see note below). Default: ‘regression’ for LGBMRegressor, ‘binary’ or ‘multiclass’ for LGBMClassifier, ‘lambdarank’ for LGBMRanker.
 class_weight (dict, 'balanced' or None, optional (default=None)) – Weights associated with classes in the form
{class_label: weight}
. Use this parameter only for multiclass classification task; for binary classification task you may useis_unbalance
orscale_pos_weight
parameters. Note, that the usage of all these parameters will result in poor estimates of the individual class probabilities. You may want to consider performing probability calibration (https://scikitlearn.org/stable/modules/calibration.html) of your model. The ‘balanced’ mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data asn_samples / (n_classes * np.bincount(y))
. If None, all classes are supposed to have weight one. Note, that these weights will be multiplied withsample_weight
(passed through thefit
method) ifsample_weight
is specified.  min_split_gain (float, optional (default=0.)) – Minimum loss reduction required to make a further partition on a leaf node of the tree.
 min_child_weight (float, optional (default=1e3)) – Minimum sum of instance weight (hessian) needed in a child (leaf).
 min_child_samples (int, optional (default=20)) – Minimum number of data needed in a child (leaf).
 subsample (float, optional (default=1.)) – Subsample ratio of the training instance.
 subsample_freq (int, optional (default=0)) – Frequence of subsample, <=0 means no enable.
 colsample_bytree (float, optional (default=1.)) – Subsample ratio of columns when constructing each tree.
 reg_alpha (float, optional (default=0.)) – L1 regularization term on weights.
 reg_lambda (float, optional (default=0.)) – L2 regularization term on weights.
 random_state (int or None, optional (default=None)) – Random number seed. If None, default seeds in C++ code will be used.
 n_jobs (int, optional (default=1)) – Number of parallel threads.
 silent (bool, optional (default=True)) – Whether to print messages while running boosting.
 importance_type (string, optional (default='split')) – The type of feature importance to be filled into
feature_importances_
. If ‘split’, result contains numbers of times the feature is used in a model. If ‘gain’, result contains total gains of splits which use the feature.  **kwargs –
Other parameters for the model. Check http://lightgbm.readthedocs.io/en/latest/Parameters.html for more parameters.
Warning
**kwargs is not supported in sklearn, it may cause unexpected issues.

n_features_
¶ The number of features of fitted model.
Type: int

classes_
¶ The class label array (only for classification problem).
Type: array of shape = [n_classes]

n_classes_
¶ The number of classes (only for classification problem).
Type: int

best_score_
¶ The best score of fitted model.
Type: dict or None

best_iteration_
¶ The best iteration of fitted model if
early_stopping_rounds
has been specified.Type: int or None

objective_
¶ The concrete objective used while fitting this model.
Type: string or callable

evals_result_
¶ The evaluation results if
early_stopping_rounds
has been specified.Type: dict or None

feature_importances_
¶ The feature importances (the higher, the more important the feature).
Type: array of shape = [n_features]
Note
A custom objective function can be provided for the
objective
parameter. In this case, it should have the signatureobjective(y_true, y_pred) > grad, hess
orobjective(y_true, y_pred, group) > grad, hess
: y_true : arraylike of shape = [n_samples]
 The target values.
 y_pred : arraylike of shape = [n_samples] or shape = [n_samples * n_classes] (for multiclass task)
 The predicted values.
 group : arraylike
 Group/query data, used for ranking task.
 grad : arraylike of shape = [n_samples] or shape = [n_samples * n_classes] (for multiclass task)
 The value of the first order derivative (gradient) for each sample point.
 hess : arraylike of shape = [n_samples] or shape = [n_samples * n_classes] (for multiclass task)
 The value of the second order derivative (Hessian) for each sample point.
For multiclass task, the y_pred is group by class_id first, then group by row_id. If you want to get ith row y_pred in jth class, the access way is y_pred[j * num_data + i] and you should group grad and hess in this way as well.
Methods
__init__
([boosting_type, num_leaves, …])Construct a gradient boosting model. fit
(X, y[, sample_weight, init_score, …])Build a gradient boosting model from the training set (X, y). get_params
([deep])Get parameters for this estimator. predict
(X[, raw_score, num_iteration, …])Return the predicted value for each sample. set_params
(**params)Set the parameters of this estimator. Attributes
best_iteration_
Get the best iteration of fitted model. best_score_
Get the best score of fitted model. booster_
Get the underlying lightgbm Booster of this model. evals_result_
Get the evaluation results. feature_importances_
Get feature importances. n_features_
Get the number of features of fitted model. objective_
Get the concrete objective used while fitting this model. 
best_iteration_
Get the best iteration of fitted model.

best_score_
Get the best score of fitted model.

booster_
Get the underlying lightgbm Booster of this model.

evals_result_
Get the evaluation results.

feature_importances_
Get feature importances.
Note
importance_type
attribute is passed to the function to configure the type of importance values to be extracted.

fit
(X, y, sample_weight=None, init_score=None, group=None, eval_set=None, eval_names=None, eval_sample_weight=None, eval_class_weight=None, eval_init_score=None, eval_group=None, eval_metric=None, early_stopping_rounds=None, verbose=True, feature_name='auto', categorical_feature='auto', callbacks=None, init_model=None)[source]¶ Build a gradient boosting model from the training set (X, y).
Parameters:  X (arraylike or sparse matrix of shape = [n_samples, n_features]) – Input feature matrix.
 y (arraylike of shape = [n_samples]) – The target values (class labels in classification, real numbers in regression).
 sample_weight (arraylike of shape = [n_samples] or None, optional (default=None)) – Weights of training data.
 init_score (arraylike of shape = [n_samples] or None, optional (default=None)) – Init score of training data.
 group (arraylike or None, optional (default=None)) – Group data of training data.
 eval_set (list or None, optional (default=None)) – A list of (X, y) tuple pairs to use as validation sets.
 eval_names (list of strings or None, optional (default=None)) – Names of eval_set.
 eval_sample_weight (list of arrays or None, optional (default=None)) – Weights of eval data.
 eval_class_weight (list or None, optional (default=None)) – Class weights of eval data.
 eval_init_score (list of arrays or None, optional (default=None)) – Init score of eval data.
 eval_group (list of arrays or None, optional (default=None)) – Group data of eval data.
 eval_metric (string, list of strings, callable or None, optional (default=None)) – If string, it should be a builtin evaluation metric to use.
If callable, it should be a custom evaluation metric, see note below for more details.
In either case, the
metric
from the model parameters will be evaluated and used as well. Default: ‘l2’ for LGBMRegressor, ‘logloss’ for LGBMClassifier, ‘ndcg’ for LGBMRanker.  early_stopping_rounds (int or None, optional (default=None)) – Activates early stopping. The model will train until the validation score stops improving.
Validation score needs to improve at least every
early_stopping_rounds
round(s) to continue training. Requires at least one validation data and one metric. If there’s more than one, will check all of them. But the training data is ignored anyway. To check only the first metric, set thefirst_metric_only
parameter toTrue
in additional parameters**kwargs
of the model constructor.  verbose (bool or int, optional (default=True)) –
Requires at least one evaluation data. If True, the eval metric on the eval set is printed at each boosting stage. If int, the eval metric on the eval set is printed at every
verbose
boosting stage. The last boosting stage or the boosting stage found by usingearly_stopping_rounds
is also printed.Example
With
verbose
= 4 and at least one item ineval_set
, an evaluation metric is printed every 4 (instead of 1) boosting stages.  feature_name (list of strings or 'auto', optional (default='auto')) – Feature names. If ‘auto’ and data is pandas DataFrame, data columns names are used.
 categorical_feature (list of strings or int, or 'auto', optional (default='auto')) – Categorical features.
If list of int, interpreted as indices.
If list of strings, interpreted as feature names (need to specify
feature_name
as well). If ‘auto’ and data is pandas DataFrame, pandas unordered categorical columns are used. All values in categorical features should be less than int32 max value (2147483647). Large values could be memory consuming. Consider using consecutive integers starting from zero. All negative values in categorical features will be treated as missing values. The output cannot be monotonically constrained with respect to a categorical feature.  callbacks (list of callback functions or None, optional (default=None)) – List of callback functions that are applied at each iteration. See Callbacks in Python API for more information.
 init_model (string, Booster, LGBMModel or None, optional (default=None)) – Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
Returns: self – Returns self.
Return type: object
Note
Custom eval function expects a callable with following signatures:
func(y_true, y_pred)
,func(y_true, y_pred, weight)
orfunc(y_true, y_pred, weight, group)
and returns (eval_name, eval_result, is_higher_better) or list of (eval_name, eval_result, is_higher_better): y_true : arraylike of shape = [n_samples]
 The target values.
 y_pred : arraylike of shape = [n_samples] or shape = [n_samples * n_classes] (for multiclass task)
 The predicted values.
 weight : arraylike of shape = [n_samples]
 The weight of samples.
 group : arraylike
 Group/query data, used for ranking task.
 eval_name : string
 The name of evaluation function (without whitespaces).
 eval_result : float
 The eval result.
 is_higher_better : bool
 Is eval result higher better, e.g. AUC is
is_higher_better
.
For multiclass task, the y_pred is group by class_id first, then group by row_id. If you want to get ith row y_pred in jth class, the access way is y_pred[j * num_data + i].

get_params
(deep=True)[source]¶ Get parameters for this estimator.
Parameters: deep (bool, optional (default=True)) – If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns: params – Parameter names mapped to their values. Return type: dict

n_features_
Get the number of features of fitted model.

objective_
Get the concrete objective used while fitting this model.

predict
(X, raw_score=False, num_iteration=None, pred_leaf=False, pred_contrib=False, **kwargs)[source]¶ Return the predicted value for each sample.
Parameters:  X (arraylike or sparse matrix of shape = [n_samples, n_features]) – Input features matrix.
 raw_score (bool, optional (default=False)) – Whether to predict raw scores.
 num_iteration (int or None, optional (default=None)) – Limit number of iterations in the prediction. If None, if the best iteration exists, it is used; otherwise, all trees are used. If <= 0, all trees are used (no limits).
 pred_leaf (bool, optional (default=False)) – Whether to predict leaf index.
 pred_contrib (bool, optional (default=False)) –
Whether to predict feature contributions.
Note
If you want to get more explanations for your model’s predictions using SHAP values, like SHAP interaction values, you can install the shap package (https://github.com/slundberg/shap). Note that unlike the shap package, with
pred_contrib
we return a matrix with an extra column, where the last column is the expected value.  **kwargs – Other parameters for the prediction.
Returns:  predicted_result (arraylike of shape = [n_samples] or shape = [n_samples, n_classes]) – The predicted values.
 X_leaves (arraylike of shape = [n_samples, n_trees] or shape = [n_samples, n_trees * n_classes]) – If
pred_leaf=True
, the predicted leaf of every tree for each sample.  X_SHAP_values (arraylike of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes]) – If
pred_contrib=True
, the feature contributions for each sample.
