lightgbm API Reference
Full documentation for lightgbm (4.7.0)
lightgbm.Booster
Python Library Documentation: class Booster in module lightgbm.basic
class Booster(builtins.object)
| Booster(params: Optional[Dict[str, Any]] = None, train_set: Optional[lightgbm.basic.Dataset] = None, model_file: Union[str, pathlib.Path, NoneType] = None, model_str: Optional[str] = None)
|
| Booster in LightGBM.
|
| Methods defined here:
|
| __copy__(self) -> 'Booster'
|
| __deepcopy__(self, *args: Any, **kwargs: Any) -> 'Booster'
|
| __del__(self) -> None
|
| __getstate__(self) -> Dict[str, Any]
| Helper for pickle.
|
| __init__(self, params: Optional[Dict[str, Any]] = None, train_set: Optional[lightgbm.basic.Dataset] = None, model_file: Union[str, pathlib.Path, NoneType] = None, model_str: Optional[str] = None)
| Initialize the Booster.
|
| Parameters
| ----------
| params : dict or None, optional (default=None)
| Parameters for Booster.
| train_set : Dataset or None, optional (default=None)
| Training dataset.
| model_file : str, pathlib.Path or None, optional (default=None)
| Path to the model file.
| model_str : str or None, optional (default=None)
| Model will be loaded from this string.
|
| __setstate__(self, state: Dict[str, Any]) -> None
|
| add_valid(self, data: lightgbm.basic.Dataset, name: str) -> 'Booster'
| Add validation data.
|
| Parameters
| ----------
| data : Dataset
| Validation data.
| name : str
| Name of validation data.
|
| Returns
| -------
| self : Booster
| Booster with set validation data.
|
| current_iteration(self) -> int
| Get the index of the current iteration.
|
| Returns
| -------
| cur_iter : int
| The index of the current iteration.
|
| dump_model(self, num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split', object_hook: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None) -> Dict[str, Any]
| Dump Booster to JSON format.
|
| Parameters
| ----------
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be dumped.
| If None, if the best iteration exists, it is dumped; otherwise, all iterations are dumped.
| If <= 0, all iterations are dumped.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be dumped.
| importance_type : str, optional (default="split")
| What type of feature importance should be dumped.
| 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.
| object_hook : callable or None, optional (default=None)
| If not None, ``object_hook`` is a function called while parsing the json
| string returned by the C API. It may be used to alter the json, to store
| specific values while building the json structure. It avoids
| walking through the structure again. It saves a significant amount
| of time if the number of trees is huge.
| Signature is ``def object_hook(node: dict) -> dict``.
| None is equivalent to ``lambda node: node``.
| See documentation of ``json.loads()`` for further details.
|
| Returns
| -------
| json_repr : dict
| JSON format of Booster.
|
| eval(self, data: lightgbm.basic.Dataset, name: str, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None) -> List[lightgbm.basic.EvalResult]
| Evaluate for data.
|
| Parameters
| ----------
| data : Dataset
| Data for the evaluating.
| name : str
| Name of the data.
| feval : callable, list of callable, or None, optional (default=None)
| Customized evaluation function.
| Each evaluation function should accept two parameters: preds, eval_data,
| and return (metric_name, metric_value, maximize) or list of such tuples.
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
| If custom objective function is used, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| eval_data : Dataset
| A ``Dataset`` to evaluate.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| Returns
| -------
| result : list[EvalResult]
| List of ``lightgbm.EvalResult`` objects, named tuples of the form
| (dataset_name, metric_name, metric_value, maximize).
|
| eval_train(self, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None) -> List[lightgbm.basic.EvalResult]
| Evaluate for training data.
|
| Parameters
| ----------
| feval : callable, list of callable, or None, optional (default=None)
| Customized evaluation function.
| Each evaluation function should accept two parameters: preds, eval_data,
| and return (metric_name, metric_value, maximize) or list of such tuples.
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
| If custom objective function is used, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| eval_data : Dataset
| The training dataset.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| Returns
| -------
| result : list[EvalResult]
| List of ``lightgbm.EvalResult`` objects, named tuples of the form
| (dataset_name, metric_name, metric_value, maximize).
|
| eval_valid(self, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None) -> List[lightgbm.basic.EvalResult]
| Evaluate for validation data.
|
| Parameters
| ----------
| feval : callable, list of callable, or None, optional (default=None)
| Customized evaluation function.
| Each evaluation function should accept two parameters: preds, eval_data,
| and return (metric_name, metric_value, maximize) or list of such tuples.
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
| If custom objective function is used, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| eval_data : Dataset
| The validation dataset.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| Returns
| -------
| result : list
| List of ``lightgbm.EvalResult`` objects, named tuples of the form
| (dataset_name, metric_name, metric_value, maximize).
|
| feature_importance(self, importance_type: str = 'split', iteration: Optional[int] = None) -> numpy.ndarray
| Get feature importances.
|
| Parameters
| ----------
| importance_type : str, optional (default="split")
| How the importance is calculated.
| 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.
| iteration : int or None, optional (default=None)
| Limit number of iterations in the feature importance calculation.
| If None, if the best iteration exists, it is used; otherwise, all trees are used.
| If <= 0, all trees are used (no limits).
|
| Returns
| -------
| result : numpy array
| Array with feature importances.
|
| feature_name(self) -> List[str]
| Get names of features.
|
| Returns
| -------
| result : list of str
| List with names of features.
|
| free_dataset(self) -> 'Booster'
| Free Booster's Datasets.
|
| Returns
| -------
| self : Booster
| Booster without Datasets.
|
| free_network(self) -> 'Booster'
| Free Booster's network.
|
| Returns
| -------
| self : Booster
| Booster with freed network.
|
| get_leaf_output(self, tree_id: int, leaf_id: int) -> float
| Get the output of a leaf.
|
| Parameters
| ----------
| tree_id : int
| The index of the tree.
| leaf_id : int
| The index of the leaf in the tree.
|
| Returns
| -------
| result : float
| The output of the leaf.
|
| get_split_value_histogram(self, feature: Union[int, str], bins: Union[int, str, NoneType] = None, xgboost_style: bool = False) -> Union[Tuple[numpy.ndarray, numpy.ndarray], numpy.ndarray, pandas.core.frame.DataFrame]
| Get split value histogram for the specified feature.
|
| Parameters
| ----------
| feature : int or str
| The feature name or index the histogram is calculated for.
| If int, interpreted as index.
| If str, interpreted as name.
|
| .. warning::
|
| Categorical features are not supported.
|
| bins : int, str or None, optional (default=None)
| The maximum number of bins.
| If None, or int and > number of unique split values and ``xgboost_style=True``,
| the number of bins equals number of unique split values.
| If str, it should be one from the list of the supported values by ``numpy.histogram()`` function.
| xgboost_style : bool, optional (default=False)
| Whether the returned result should be in the same form as it is in XGBoost.
| If False, the returned value is tuple of 2 numpy arrays as it is in ``numpy.histogram()`` function.
| If True, the returned value is matrix, in which the first column is the right edges of non-empty bins
| and the second one is the histogram values.
|
| Returns
| -------
| result_tuple : tuple of 2 numpy arrays
| If ``xgboost_style=False``, the values of the histogram of used splitting values for the specified feature
| and the bin edges.
| result_array_like : numpy array or pandas DataFrame (if pandas is installed)
| If ``xgboost_style=True``, the histogram of used splitting values for the specified feature.
|
| lower_bound(self) -> float
| Get lower bound value of a model.
|
| Returns
| -------
| lower_bound : float
| Lower bound value of the model.
|
| model_from_string(self, model_str: str) -> 'Booster'
| Load Booster from a string.
|
| Parameters
| ----------
| model_str : str
| Model will be loaded from this string.
|
| Returns
| -------
| self : Booster
| Loaded Booster object.
|
| model_to_string(self, num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> str
| Save Booster to string.
|
| Parameters
| ----------
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be saved.
| If None, if the best iteration exists, it is saved; otherwise, all iterations are saved.
| If <= 0, all iterations are saved.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be saved.
| importance_type : str, optional (default="split")
| What type of feature importance should be saved.
| 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.
|
| Returns
| -------
| str_repr : str
| String representation of Booster.
|
| num_feature(self) -> int
| Get number of features.
|
| Returns
| -------
| num_feature : int
| The number of features.
|
| num_model_per_iteration(self) -> int
| Get number of models per iteration.
|
| Returns
| -------
| model_per_iter : int
| The number of models per iteration.
|
| num_trees(self) -> int
| Get number of weak sub-models.
|
| Returns
| -------
| num_trees : int
| The number of weak sub-models.
|
| predict(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, narwhals._native.NativeDataFrame], start_iteration: int = 0, num_iteration: Optional[int] = None, raw_score: bool = False, pred_leaf: bool = False, pred_contrib: bool = False, data_has_header: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Make a prediction.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, pyarrow Table or polars DataFrame
| Data source for prediction.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` are used (no limits).
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| 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.
|
| data_has_header : bool, optional (default=False)
| Whether the data has header.
| Used only if data is str.
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| result : numpy array, scipy.sparse or list of scipy.sparse
| Prediction result.
| Can be sparse or a list of sparse objects (each element represents predictions for one class) for feature contributions (when ``pred_contrib=True``).
|
| refit(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], decay_rate: float = 0.9, reference: Optional[lightgbm.basic.Dataset] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', dataset_params: Optional[Dict[str, Any]] = None, free_raw_data: bool = True, validate_features: bool = False, **kwargs: Any) -> 'Booster'
| Refit the existing Booster by new data.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table or polars DataFrame
| Data source for refit.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None
| Label for refit.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| decay_rate : float, optional (default=0.9)
| Decay rate of refit,
| will use ``leaf_output = decay_rate * old_leaf_output + (1.0 - decay_rate) * new_leaf_output`` to refit trees.
| reference : Dataset or None, optional (default=None)
| Reference for ``data``.
|
| .. versionadded:: 4.0.0
|
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Weight for each ``data`` instance. Weights should be non-negative.
|
| .. versionadded:: 4.0.0
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Group/query size for ``data``.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.0.0
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None, optional (default=None)
| Init score for ``data``.
|
| .. versionadded:: 4.0.0
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| feature_name : list of str, or 'auto', optional (default="auto")
| Feature names for ``data``.
| If 'auto' and data is pandas DataFrame, data columns names are used.
|
| .. versionadded:: 4.0.0
|
| categorical_feature : list of str or int, or 'auto', optional (default="auto")
| Categorical features for ``data``.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
|
| .. versionadded:: 4.0.0
|
| dataset_params : dict or None, optional (default=None)
| Other parameters for Dataset ``data``.
|
| .. versionadded:: 4.0.0
|
| free_raw_data : bool, optional (default=True)
| If True, raw data is freed after constructing inner Dataset for ``data``.
|
| .. versionadded:: 4.0.0
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to refit the model match the original ones.
| Used only if data is pandas DataFrame.
|
| .. versionadded:: 4.0.0
|
| **kwargs
| Other parameters for refit.
| These parameters will be passed to ``predict`` method.
|
| Returns
| -------
| result : Booster
| Refitted Booster.
|
| reset_parameter(self, params: Dict[str, Any]) -> 'Booster'
| Reset parameters of Booster.
|
| Parameters
| ----------
| params : dict
| New parameters for Booster.
|
| Returns
| -------
| self : Booster
| Booster with new parameters.
|
| rollback_one_iter(self) -> 'Booster'
| Rollback one iteration.
|
| Returns
| -------
| self : Booster
| Booster with rolled back one iteration.
|
| save_model(self, filename: Union[str, pathlib.Path], num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> 'Booster'
| Save Booster to file.
|
| Parameters
| ----------
| filename : str or pathlib.Path
| Filename to save Booster.
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be saved.
| If None, if the best iteration exists, it is saved; otherwise, all iterations are saved.
| If <= 0, all iterations are saved.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be saved.
| importance_type : str, optional (default="split")
| What type of feature importance should be saved.
| 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.
|
| Returns
| -------
| self : Booster
| Returns self.
|
| set_leaf_output(self, tree_id: int, leaf_id: int, value: float) -> 'Booster'
| Set the output of a leaf.
|
| .. versionadded:: 4.0.0
|
| Parameters
| ----------
| tree_id : int
| The index of the tree.
| leaf_id : int
| The index of the leaf in the tree.
| value : float
| Value to set as the output of the leaf.
|
| Returns
| -------
| self : Booster
| Booster with the leaf output set.
|
| set_network(self, machines: Union[List[str], Set[str], str], local_listen_port: int = 12400, listen_time_out: int = 120, num_machines: int = 1) -> 'Booster'
| Set the network configuration.
|
| Parameters
| ----------
| machines : list, set or str
| Names of machines.
| local_listen_port : int, optional (default=12400)
| TCP listen port for local machines.
| listen_time_out : int, optional (default=120)
| Socket time-out in minutes.
| num_machines : int, optional (default=1)
| The number of machines for distributed learning application.
|
| Returns
| -------
| self : Booster
| Booster with set network.
|
| set_train_data_name(self, name: str) -> 'Booster'
| Set the name to the training Dataset.
|
| Parameters
| ----------
| name : str
| Name for the training Dataset.
|
| Returns
| -------
| self : Booster
| Booster with set training Dataset name.
|
| shuffle_models(self, start_iteration: int = 0, end_iteration: int = -1) -> 'Booster'
| Shuffle models.
|
| Parameters
| ----------
| start_iteration : int, optional (default=0)
| The first iteration that will be shuffled.
| end_iteration : int, optional (default=-1)
| The last iteration that will be shuffled.
| If <= 0, means the last available iteration.
|
| Returns
| -------
| self : Booster
| Booster with shuffled models.
|
| trees_to_dataframe(self) -> pandas.core.frame.DataFrame
| Parse the fitted model and return in an easy-to-read pandas DataFrame.
|
| The returned DataFrame has the following columns.
|
| - ``tree_index`` : int64, which tree a node belongs to. 0-based, so a value of ``6``, for example, means "this node is in the 7th tree".
| - ``node_depth`` : int64, how far a node is from the root of the tree. The root node has a value of ``1``, its direct children are ``2``, etc.
| - ``node_index`` : str, unique identifier for a node.
| - ``left_child`` : str, ``node_index`` of the child node to the left of a split. ``None`` for leaf nodes.
| - ``right_child`` : str, ``node_index`` of the child node to the right of a split. ``None`` for leaf nodes.
| - ``parent_index`` : str, ``node_index`` of this node's parent. ``None`` for the root node.
| - ``split_feature`` : str, name of the feature used for splitting. ``None`` for leaf nodes.
| - ``split_gain`` : float64, gain from adding this split to the tree. ``NaN`` for leaf nodes.
| - ``threshold`` : float64, value of the feature used to decide which side of the split a record will go down. ``NaN`` for leaf nodes.
| - ``decision_type`` : str, logical operator describing how to compare a value to ``threshold``.
| For example, ``split_feature = "Column_10", threshold = 15, decision_type = "<="`` means that
| records where ``Column_10 <= 15`` follow the left side of the split, otherwise follows the right side of the split. ``None`` for leaf nodes.
| - ``missing_direction`` : str, split direction that missing values should go to. ``None`` for leaf nodes.
| - ``missing_type`` : str, describes what types of values are treated as missing.
| - ``value`` : float64, predicted value for this leaf node, multiplied by the learning rate.
| - ``weight`` : float64 or int64, sum of Hessian (second-order derivative of objective), summed over observations that fall in this node.
| - ``count`` : int64, number of records in the training data that fall into this node.
|
| Returns
| -------
| result : pandas DataFrame
| Returns a pandas DataFrame of the parsed model.
|
| update(self, train_set: Optional[lightgbm.basic.Dataset] = None, fobj: Optional[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[numpy.ndarray, numpy.ndarray]]] = None) -> bool
| Update Booster for one iteration.
|
| Parameters
| ----------
| train_set : Dataset or None, optional (default=None)
| Training data.
| If None, last training data is used.
| fobj : callable or None, optional (default=None)
| Customized objective function.
| Should accept two parameters: preds, train_data,
| and return (grad, hess).
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| train_data : Dataset
| The training dataset.
| grad : numpy 1-D array or numpy 2-D array (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of preds for each sample point.
| hess : numpy 1-D array or numpy 2-D array (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of preds for each sample point.
|
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| Returns
| -------
| produced_empty_tree : bool
| ``True`` if the tree(s) produced by this iteration did not have any splits.
| This usually means that training is "finished" (calling ``update()`` again
| will not change the model's predictions). However, that is not always the
| case. For example, if you have added any randomness (like column sampling by
| setting ``feature_fraction_bynode < 1.0``), it is possible that another call
| to ``update()`` would produce a non-empty tree.
|
| upper_bound(self) -> float
| Get upper bound value of a model.
|
| Returns
| -------
| upper_bound : float
| Upper bound value of the model.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
lightgbm.CVBooster
Python Library Documentation: class CVBooster in module lightgbm.engine class CVBooster(builtins.object) | CVBooster(model_file: Union[str, pathlib.Path, NoneType] = None) | | CVBooster in LightGBM. | | Auxiliary data structure to hold and redirect all boosters of ``cv()`` function. | This class has the same methods as Booster class. | All method calls, except for the following methods, are actually performed for underlying Boosters and | then all returned results are returned in a list. | | - ``model_from_string()`` | - ``model_to_string()`` | - ``save_model()`` | | Attributes | ---------- | boosters : list of Booster | The list of underlying fitted models. | best_iteration : int | The best iteration of fitted model. | | Methods defined here: | | __getattr__(self, name: str) -> Callable[[Any, Any], List[Any]] | Redirect methods call of CVBooster. | | __getstate__(self) -> Dict[str, Any] | Helper for pickle. | | __init__(self, model_file: Union[str, pathlib.Path, NoneType] = None) | Initialize the CVBooster. | | Parameters | ---------- | model_file : str, pathlib.Path or None, optional (default=None) | Path to the CVBooster model file. | | __setstate__(self, state: Dict[str, Any]) -> None | | model_from_string(self, model_str: str) -> 'CVBooster' | Load CVBooster from a string. | | Parameters | ---------- | model_str : str | Model will be loaded from this string. | | Returns | ------- | self : CVBooster | Loaded CVBooster object. | | model_to_string(self, num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> str | Save CVBooster to JSON string. | | Parameters | ---------- | num_iteration : int or None, optional (default=None) | Index of the iteration that should be saved. | If None, if the best iteration exists, it is saved; otherwise, all iterations are saved. | If <= 0, all iterations are saved. | start_iteration : int, optional (default=0) | Start index of the iteration that should be saved. | importance_type : str, optional (default="split") | What type of feature importance should be saved. | 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. | | Returns | ------- | str_repr : str | JSON string representation of CVBooster. | | save_model(self, filename: Union[str, pathlib.Path], num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> 'CVBooster' | Save CVBooster to a file as JSON text. | | Parameters | ---------- | filename : str or pathlib.Path | Filename to save CVBooster. | num_iteration : int or None, optional (default=None) | Index of the iteration that should be saved. | If None, if the best iteration exists, it is saved; otherwise, all iterations are saved. | If <= 0, all iterations are saved. | start_iteration : int, optional (default=0) | Start index of the iteration that should be saved. | importance_type : str, optional (default="split") | What type of feature importance should be saved. | 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. | | Returns | ------- | self : CVBooster | Returns self. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
lightgbm.DaskLGBMClassifier
Python Library Documentation: class DaskLGBMClassifier in module lightgbm.dask
class DaskLGBMClassifier(lightgbm.sklearn.LGBMClassifier, _DaskLGBMModel)
| DaskLGBMClassifier(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
|
| Distributed version of lightgbm.LGBMClassifier.
|
| Method resolution order:
| DaskLGBMClassifier
| lightgbm.sklearn.LGBMClassifier
| sklearn.base.ClassifierMixin
| lightgbm.sklearn.LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| _DaskLGBMModel
| builtins.object
|
| Methods defined here:
|
| __getstate__(self) -> Dict[Any, Any]
| Helper for pickle.
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
| client : distributed.Client or None, optional (default=None)
| Dask client.
| If ``None``, ``distributed.default_client()`` will be used at runtime.
| The Dask client used by this class will not be saved if the model object is pickled.
| **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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')], sample_weight: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, init_score: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), NoneType] = None, eval_set: Optional[List[Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_class_weight: Optional[List[Union[dict, str]]] = None, eval_init_score: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, *, eval_X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')]], NoneType] = None, eval_y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]], NoneType] = None, **kwargs: Any) -> 'DaskLGBMClassifier'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : Dask Array, Dask DataFrame or Dask Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : Dask Array or Dask Series of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task), or Dask Array or Dask DataFrame of shape = [n_samples, n_classes] (for multi-class task), or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of Dask Array or Dask Series, or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_class_weight : list or None, optional (default=None)
| Class weights of eval data.
| eval_init_score : list of Dask Array, Dask Series or Dask DataFrame (for multi-class task), or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| **kwargs
| Other parameters passed through to ``LGBMClassifier.fit()``.
|
| Returns
| -------
| self : lightgbm.DaskLGBMClassifier
| Returns self.
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : Dask Array of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : Dask Array 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 : Dask Array of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or (if multi-class and using sparse inputs) a list of ``n_classes`` Dask Arrays of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| predict_proba(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted probability for each class for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_probability : Dask Array of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : Dask Array 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 : Dask Array of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or (if multi-class and using sparse inputs) a list of ``n_classes`` Dask Arrays of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_decision_function_request(self: lightgbm.dask.DaskLGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``decision_function`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``decision_function`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``decision_function``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``decision_function``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``decision_function``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``decision_function``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_fit_request(self: lightgbm.dask.DaskLGBMClassifier, *, eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_class_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_class_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_class_weight`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_proba_request(self: lightgbm.dask.DaskLGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict_proba`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict_proba`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict_proba``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict_proba``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict_proba``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict_proba``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict_proba``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict_proba``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict_proba``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.dask.DaskLGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.dask.DaskLGBMClassifier, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| to_local(self) -> lightgbm.sklearn.LGBMClassifier
| Create regular version of lightgbm.LGBMClassifier from the distributed version.
|
| Returns
| -------
| model : lightgbm.LGBMClassifier
| Local underlying model.
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMClassifier:
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| decision_function(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], *, start_iteration: int = 0, num_iteration: Optional[int] = None, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the raw margin score for each sample.
|
| .. versionadded:: 4.7.0
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` are used (no limits).
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters forwarded to ``predict()``.
|
| Returns
| -------
| raw_score : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMClassifier:
|
| classes_
| :obj:`array` of shape = [n_classes]: The class label array.
|
| n_classes_
| :obj:`int`: The number of classes.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.ClassifierMixin:
|
| score(self, X, y, sample_weight=None)
| Return the mean accuracy on the given test data and labels.
|
| In multi-label classification, this is the subset accuracy
| which is a harsh metric since you require for each sample that
| each label set be correctly predicted.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True labels for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| Mean accuracy of ``self.predict(X)`` w.r.t. `y`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.ClassifierMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from lightgbm.sklearn.LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _DaskLGBMModel:
|
| client_
| :obj:`distributed.Client`: Dask client.
|
| This property can be passed in the constructor or updated
| with ``model.set_params(client=client)``.
lightgbm.DaskLGBMRanker
Python Library Documentation: class DaskLGBMRanker in module lightgbm.dask
class DaskLGBMRanker(lightgbm.sklearn.LGBMRanker, _DaskLGBMModel)
| DaskLGBMRanker(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
|
| Distributed version of lightgbm.LGBMRanker.
|
| Method resolution order:
| DaskLGBMRanker
| lightgbm.sklearn.LGBMRanker
| lightgbm.sklearn.LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| _DaskLGBMModel
| builtins.object
|
| Methods defined here:
|
| __getstate__(self) -> Dict[Any, Any]
| Helper for pickle.
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
| client : distributed.Client or None, optional (default=None)
| Dask client.
| If ``None``, ``distributed.default_client()`` will be used at runtime.
| The Dask client used by this class will not be saved if the model object is pickled.
| **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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')], sample_weight: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, init_score: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, group: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, eval_set: Optional[List[Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_init_score: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_group: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, eval_at: Union[List[int], Tuple[int, ...]] = (1, 2, 3, 4, 5), *, eval_X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')]], NoneType] = None, eval_y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]], NoneType] = None, **kwargs: Any) -> 'DaskLGBMRanker'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : Dask Array, Dask DataFrame or Dask Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : Dask Array or Dask Series or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of Dask Array or Dask Series, or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of Dask Array or Dask Series, or None, optional (default=None)
| Init score of eval data.
| eval_group : list of Dask Array or Dask Series, or None, optional (default=None)
| Group data of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| eval_at : list or tuple of int, optional (default=(1, 2, 3, 4, 5))
| The evaluation positions of the specified metric.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| **kwargs
| Other parameters passed through to ``LGBMRanker.fit()``.
|
| Returns
| -------
| self : lightgbm.DaskLGBMRanker
| Returns self.
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : Dask Array of shape = [n_samples]
| The predicted values.
| X_leaves : Dask Array of shape = [n_samples, n_trees]
| If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
| X_SHAP_values : Dask Array of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_fit_request(self: lightgbm.dask.DaskLGBMRanker, *, eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_at: Union[bool, NoneType, str] = '$UNCHANGED$', eval_group: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', group: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_at : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_at`` parameter in ``fit``.
|
| eval_group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_group`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``group`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.dask.DaskLGBMRanker, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| to_local(self) -> lightgbm.sklearn.LGBMRanker
| Create regular version of lightgbm.LGBMRanker from the distributed version.
|
| Returns
| -------
| model : lightgbm.LGBMRanker
| Local underlying model.
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| __sklearn_tags__(self) -> Optional[ForwardRef('_sklearn_Tags')]
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from lightgbm.sklearn.LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _DaskLGBMModel:
|
| client_
| :obj:`distributed.Client`: Dask client.
|
| This property can be passed in the constructor or updated
| with ``model.set_params(client=client)``.
lightgbm.DaskLGBMRegressor
Python Library Documentation: class DaskLGBMRegressor in module lightgbm.dask
class DaskLGBMRegressor(lightgbm.sklearn.LGBMRegressor, _DaskLGBMModel)
| DaskLGBMRegressor(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
|
| Distributed version of lightgbm.LGBMRegressor.
|
| Method resolution order:
| DaskLGBMRegressor
| lightgbm.sklearn.LGBMRegressor
| sklearn.base.RegressorMixin
| lightgbm.sklearn.LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| _DaskLGBMModel
| builtins.object
|
| Methods defined here:
|
| __getstate__(self) -> Dict[Any, Any]
| Helper for pickle.
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
| client : distributed.Client or None, optional (default=None)
| Dask client.
| If ``None``, ``distributed.default_client()`` will be used at runtime.
| The Dask client used by this class will not be saved if the model object is pickled.
| **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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')], sample_weight: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, init_score: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, eval_set: Optional[List[Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_init_score: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, *, eval_X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')]], NoneType] = None, eval_y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]], NoneType] = None, **kwargs: Any) -> 'DaskLGBMRegressor'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : Dask Array, Dask DataFrame or Dask Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of Dask Array or Dask Series, or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of Dask Array or Dask Series, or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| **kwargs
| Other parameters passed through to ``LGBMRegressor.fit()``.
|
| Returns
| -------
| self : lightgbm.DaskLGBMRegressor
| Returns self.
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : Dask Array of shape = [n_samples]
| The predicted values.
| X_leaves : Dask Array of shape = [n_samples, n_trees]
| If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
| X_SHAP_values : Dask Array of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_fit_request(self: lightgbm.dask.DaskLGBMRegressor, *, eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.dask.DaskLGBMRegressor, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.dask.DaskLGBMRegressor, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| to_local(self) -> lightgbm.sklearn.LGBMRegressor
| Create regular version of lightgbm.LGBMRegressor from the distributed version.
|
| Returns
| -------
| model : lightgbm.LGBMRegressor
| Local underlying model.
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMRegressor:
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.RegressorMixin:
|
| score(self, X, y, sample_weight=None)
| Return the coefficient of determination of the prediction.
|
| The coefficient of determination :math:`R^2` is defined as
| :math:`(1 - \frac{u}{v})`, where :math:`u` is the residual
| sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`
| is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.
| The best possible score is 1.0 and it can be negative (because the
| model can be arbitrarily worse). A constant model that always predicts
| the expected value of `y`, disregarding the input features, would get
| a :math:`R^2` score of 0.0.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples. For some estimators this may be a precomputed
| kernel matrix or a list of generic objects instead with shape
| ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``
| is the number of samples used in the fitting for the estimator.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True values for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| :math:`R^2` of ``self.predict(X)`` w.r.t. `y`.
|
| Notes
| -----
| The :math:`R^2` score used when calling ``score`` on a regressor uses
| ``multioutput='uniform_average'`` from version 0.23 to keep consistent
| with default value of :func:`~sklearn.metrics.r2_score`.
| This influences the ``score`` method of all the multioutput
| regressors (except for
| :class:`~sklearn.multioutput.MultiOutputRegressor`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.RegressorMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from lightgbm.sklearn.LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _DaskLGBMModel:
|
| client_
| :obj:`distributed.Client`: Dask client.
|
| This property can be passed in the constructor or updated
| with ``model.set_params(client=client)``.
lightgbm.Dataset
Python Library Documentation: class Dataset in module lightgbm.basic
class Dataset(builtins.object)
| Dataset(data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, reference: Optional[ForwardRef('Dataset')] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', params: Optional[Dict[str, Any]] = None, free_raw_data: bool = True, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None)
|
| Dataset in LightGBM.
|
| LightGBM does not train on raw data.
| It discretizes continuous features into histogram bins, tries to combine categorical features,
| and automatically handles missing and infinite values.
|
| This class handles that preprocessing, and holds that alternative representation of the input data.
|
| Methods defined here:
|
| __del__(self) -> None
|
| __init__(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, reference: Optional[ForwardRef('Dataset')] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', params: Optional[Dict[str, Any]] = None, free_raw_data: bool = True, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None)
| Initialize Dataset.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table or polars DataFrame
| Data source of Dataset.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM) or a LightGBM Dataset binary file.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Label of the data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| reference : Dataset or None, optional (default=None)
| If this is Dataset for validation, training data should be used as reference.
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Weight for each instance. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None, optional (default=None)
| Init score for Dataset.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| feature_name : list of str, or 'auto', optional (default="auto")
| Feature names.
| If 'auto' and data is pandas DataFrame, pyarrow Table, or polars DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default="auto")
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| params : dict or None, optional (default=None)
| Other parameters for Dataset.
| free_raw_data : bool, optional (default=True)
| If True, raw data is freed after constructing inner Dataset.
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Position of items used in unbiased learning-to-rank task.
|
| add_features_from(self, other: 'Dataset') -> 'Dataset'
| Add features from other Dataset to the current Dataset.
|
| Both Datasets must be constructed before calling this method.
|
| Parameters
| ----------
| other : Dataset
| The Dataset to take features from.
|
| Returns
| -------
| self : Dataset
| Dataset with the new features added.
|
| construct(self) -> 'Dataset'
| Lazy init.
|
| Returns
| -------
| self : Dataset
| Constructed Dataset object.
|
| create_valid(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, params: Optional[Dict[str, Any]] = None, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None) -> 'Dataset'
| Create validation data align with current Dataset.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table or polars DataFrame
| Data source of Dataset.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM) or a LightGBM Dataset binary file.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Label of the data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Weight for each instance. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None, optional (default=None)
| Init score for Dataset.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| params : dict or None, optional (default=None)
| Other parameters for validation Dataset.
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Position of items used in unbiased learning-to-rank task.
|
| Returns
| -------
| valid : Dataset
| Validation Dataset with reference to self.
|
| feature_num_bin(self, feature: Union[int, str]) -> int
| Get the number of bins for a feature.
|
| .. versionadded:: 4.0.0
|
| Parameters
| ----------
| feature : int or str
| Index or name of the feature.
|
| Returns
| -------
| number_of_bins : int
| The number of constructed bins for the feature in the Dataset.
|
| get_data(self) -> Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame, NoneType]
| Get the raw data of the Dataset.
|
| Returns
| -------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table, polars DataFrame, or None
| Raw data used in the Dataset construction.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_feature_name(self) -> List[str]
| Get the names of columns (features) in the Dataset.
|
| Returns
| -------
| feature_names : list of str
| The names of columns (features) in the Dataset.
|
| get_field(self, field_name: str) -> Optional[numpy.ndarray]
| Get property from the Dataset.
|
| Can only be run on a constructed Dataset.
|
| Unlike ``get_group()``, ``get_init_score()``, ``get_label()``, ``get_position()``, and ``get_weight()``,
| this method ignores any raw data passed into ``lgb.Dataset()`` on the Python side, and will only read
| data from the constructed C++ ``Dataset`` object.
|
| Parameters
| ----------
| field_name : str
| The field name of the information.
|
| Returns
| -------
| info : numpy array or None
| A numpy array with information from the Dataset.
|
| get_group(self) -> Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]
| Get the group of the Dataset.
|
| Returns
| -------
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_init_score(self) -> Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]
| Get the initial score of the Dataset.
|
| Returns
| -------
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None
| Init score of Booster.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_label(self) -> Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]
| Get the label of the Dataset.
|
| Returns
| -------
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None
| The label information from the Dataset.
| For a constructed ``Dataset``, this will only return a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_params(self) -> Dict[str, Any]
| Get the used parameters in the Dataset.
|
| Returns
| -------
| params : dict
| The used parameters in this Dataset object.
|
| get_position(self) -> Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]
| Get the position of the Dataset.
|
| Returns
| -------
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Position of items used in unbiased learning-to-rank task.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| get_ref_chain(self, ref_limit: int = 100) -> Set[ForwardRef('Dataset')]
| Get a chain of Dataset objects.
|
| Starts with r, then goes to r.reference (if exists),
| then to r.reference.reference, etc.
| until we hit ``ref_limit`` or a reference loop.
|
| Parameters
| ----------
| ref_limit : int, optional (default=100)
| The limit number of references.
|
| Returns
| -------
| ref_chain : set of Dataset
| Chain of references of the Datasets.
|
| get_weight(self) -> Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]
| Get the weight of the Dataset.
|
| Returns
| -------
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Weight for each data point from the Dataset. Weights should be non-negative.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| num_data(self) -> int
| Get the number of rows in the Dataset.
|
| Returns
| -------
| number_of_rows : int
| The number of rows in the Dataset.
|
| num_feature(self) -> int
| Get the number of columns (features) in the Dataset.
|
| Returns
| -------
| number_of_columns : int
| The number of columns (features) in the Dataset.
|
| save_binary(self, filename: Union[str, pathlib.Path]) -> 'Dataset'
| Save Dataset to a binary file.
|
| .. note::
|
| Please note that `init_score` is not saved in binary file.
| If you need it, please set it again after loading Dataset.
|
| Parameters
| ----------
| filename : str or pathlib.Path
| Name of the output file.
|
| Returns
| -------
| self : Dataset
| Returns self.
|
| set_categorical_feature(self, categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")]) -> 'Dataset'
| Set categorical features.
|
| Parameters
| ----------
| categorical_feature : list of str or int, or 'auto'
| Names or indices of categorical features.
|
| Returns
| -------
| self : Dataset
| Dataset with set categorical features.
|
| set_feature_name(self, feature_name: Union[List[str], ForwardRef("Literal['auto']")]) -> 'Dataset'
| Set feature name.
|
| Parameters
| ----------
| feature_name : list of str
| Feature names.
|
| Returns
| -------
| self : Dataset
| Dataset with set feature name.
|
| set_field(self, field_name: str, data: Union[List[List[float]], List[List[int]], List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, NoneType]) -> 'Dataset'
| Set property into the Dataset.
|
| Parameters
| ----------
| field_name : str
| The field name of the information.
| data : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None
| The data to be set.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set property.
|
| set_group(self, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]) -> 'Dataset'
| Set group size of Dataset (used for ranking).
|
| Parameters
| ----------
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set group.
|
| set_init_score(self, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]) -> 'Dataset'
| Set init score of Booster to start from.
|
| Parameters
| ----------
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None
| Init score for Booster.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set init score.
|
| set_label(self, label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]) -> 'Dataset'
| Set label of Dataset.
|
| Parameters
| ----------
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None
| The label information to be set into Dataset.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set label.
|
| set_position(self, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]) -> 'Dataset'
| Set position of Dataset (used for ranking).
|
| Parameters
| ----------
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Position of items used in unbiased learning-to-rank task.
|
| Returns
| -------
| self : Dataset
| Dataset with set position.
|
| set_reference(self, reference: 'Dataset') -> 'Dataset'
| Set reference Dataset.
|
| Parameters
| ----------
| reference : Dataset
| Reference that is used as a template to construct the current Dataset.
|
| Returns
| -------
| self : Dataset
| Dataset with set reference.
|
| set_weight(self, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]) -> 'Dataset'
| Set weight of each instance.
|
| Parameters
| ----------
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Weight to be set for each data point. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set weight.
|
| subset(self, used_indices: List[int], params: Optional[Dict[str, Any]] = None) -> 'Dataset'
| Get subset of current Dataset.
|
| Parameters
| ----------
| used_indices : list of int
| Indices used to create the subset.
| params : dict or None, optional (default=None)
| These parameters will be passed to Dataset constructor.
|
| Returns
| -------
| subset : Dataset
| Subset of the current Dataset.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
lightgbm.EarlyStopException
Python Library Documentation: class EarlyStopException in module lightgbm.callback class EarlyStopException(builtins.Exception) | EarlyStopException(best_iteration: int, best_score: Union[List[lightgbm.basic.EvalResult], List[Tuple[str, str, float, bool]], List[Tuple[str, str, float, bool, float]]]) -> None | | Exception of early stopping. | | Raise this from a callback passed in via keyword argument ``callbacks`` | in ``cv()`` or ``train()`` to trigger early stopping. | | Method resolution order: | EarlyStopException | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, best_iteration: int, best_score: Union[List[lightgbm.basic.EvalResult], List[Tuple[str, str, float, bool]], List[Tuple[str, str, float, bool, float]]]) -> None | Create early stopping exception. | | Parameters | ---------- | best_iteration : int | The best iteration stopped. | 0-based... pass ``best_iteration=2`` to indicate that the third iteration was the best one. | best_score : list of (dataset_name, metric_name, metric_value, maximize) tuple, (dataset_name, metric_name, metric_value, maximize, metric_std_dev) tuple, or ``lightgbm.EvalResult`` | Scores for each metric, on each validation set, as of the best iteration. | | Notes | ----- | | .. versionadded:: 4.7.0 | ``best_score`` is stored on the instance as a list of ``lightgbm.EvalResult`` objects. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
lightgbm.EvalResult
Python Library Documentation: class EvalResult in module lightgbm.basic
class EvalResult(builtins.tuple)
| EvalResult(dataset_name: str, metric_name: str, metric_value: float, maximize: bool, metric_std_dev: Optional[float] = None)
|
| Result from computing an evaluation metric on a dataset.
|
| In ``lightgbm<4.7.0``, evaluation results were stored in tuples like this:
|
| * train(): ``(dataset_name, metric_name, metric_value, maximize)``
| * cv(): ``(dataset_name, metric_name, mean(metric_value), maximize, std_dev(metric_value))``
|
| Parameters
| ----------
| dataset_name : str
| Unique identifier for the dataset this result was computed on.
| metric_name : str
| Unique identifier for the metric (e.g. "rmse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
| metric_std_dev : float or None
| If not ``None``, the standard deviation of metric values computed over a range of results.
| For example, used when aggregating over cross-validation folds in ``cv()``.
|
| Method resolution order:
| EvalResult
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.EvalResult
| Return self as a plain tuple. Used by copy and pickle.
|
| __iter__(self) -> Any
| Implement iter(self).
|
| __len__(self) -> int
| Return len(self).
|
| __repr__(self) from collections.EvalResult
| Return a nicely formatted representation string
|
| _asdict(self) from collections.EvalResult
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.EvalResult
| Return a new EvalResult object replacing specified fields with new values
|
| is_cv_result(self) -> bool
| Whether the result was created by ``cv()``.
|
| If ``True``:
|
| * ``metric_value`` = mean of ``metric_name`` over CV folds
| * ``metric_std_dev`` = standard deviation of ``metric_name`` over CV folds
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.EvalResult
| Make a new EvalResult object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, dataset_name: str, metric_name: str, metric_value: float, maximize: bool, metric_std_dev: Optional[float] = None) from namedtuple_EvalResult.EvalResult
| Create new instance of EvalResult(dataset_name, metric_name, metric_value, maximize, metric_std_dev)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| dataset_name
| Alias for field number 0
|
| metric_name
| Alias for field number 1
|
| metric_value
| Alias for field number 2
|
| maximize
| Alias for field number 3
|
| metric_std_dev
| Alias for field number 4
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'dataset_name': <class 'str'>, 'maximize': <class '...
|
| __match_args__ = ('dataset_name', 'metric_name', 'metric_value', 'maxi...
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {'metric_std_dev': None}
|
| _fields = ('dataset_name', 'metric_name', 'metric_value', 'maximize', ...
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
lightgbm.LGBMClassifier
Python Library Documentation: class LGBMClassifier in module lightgbm.sklearn
class LGBMClassifier(sklearn.base.ClassifierMixin, LGBMModel)
| LGBMClassifier(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
|
| LightGBM classifier.
|
| Method resolution order:
| LGBMClassifier
| sklearn.base.ClassifierMixin
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| decision_function(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], *, start_iteration: int = 0, num_iteration: Optional[int] = None, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the raw margin score for each sample.
|
| .. versionadded:: 4.7.0
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` are used (no limits).
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters forwarded to ``predict()``.
|
| Returns
| -------
| raw_score : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_class_weight: Optional[List[float]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel, NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMClassifier'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_class_weight : list or None, optional (default=None)
| Class weights of eval data.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMClassifier
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| predict_proba(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted probability for each class for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_probability : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_decision_function_request(self: lightgbm.sklearn.LGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``decision_function`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``decision_function`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``decision_function``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``decision_function``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``decision_function``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``decision_function``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_fit_request(self: lightgbm.sklearn.LGBMClassifier, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_class_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_class_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_class_weight`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_proba_request(self: lightgbm.sklearn.LGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict_proba`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict_proba`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict_proba``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict_proba``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict_proba``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict_proba``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict_proba``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict_proba``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict_proba``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.sklearn.LGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.sklearn.LGBMClassifier, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| classes_
| :obj:`array` of shape = [n_classes]: The class label array.
|
| n_classes_
| :obj:`int`: The number of classes.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.ClassifierMixin:
|
| score(self, X, y, sample_weight=None)
| Return the mean accuracy on the given test data and labels.
|
| In multi-label classification, this is the subset accuracy
| which is a harsh metric since you require for each sample that
| each label set be correctly predicted.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True labels for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| Mean accuracy of ``self.predict(X)`` w.r.t. `y`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.ClassifierMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
lightgbm.LGBMModel
Python Library Documentation: class LGBMModel in module lightgbm.sklearn
class LGBMModel(sklearn.base.BaseEstimator)
| LGBMModel(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any)
|
| Implementation of the scikit-learn API for LightGBM.
|
| Method resolution order:
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| __sklearn_is_fitted__(self) -> bool
|
| __sklearn_tags__(self) -> Optional[ForwardRef('_sklearn_Tags')]
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_class_weight: Optional[List[float]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_group: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, ForwardRef('LGBMModel'), NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMModel'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : numpy array, pandas Series, pyarrow ChunkedArray, polars Series, list of int or float, or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_class_weight : list or None, optional (default=None)
| Class weights of eval data.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_group : list of array (same types as ``group`` supports), or None, optional (default=None)
| Group data of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMModel
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_fit_request(self: lightgbm.sklearn.LGBMModel, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_class_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_group: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', group: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMModel from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_class_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_class_weight`` parameter in ``fit``.
|
| eval_group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_group`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``group`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| set_predict_request(self: lightgbm.sklearn.LGBMModel, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMModel from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
lightgbm.LGBMRanker
Python Library Documentation: class LGBMRanker in module lightgbm.sklearn
class LGBMRanker(LGBMModel)
| LGBMRanker(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
|
| LightGBM ranker.
|
| .. warning::
|
| scikit-learn doesn't support ranking applications yet,
| therefore this class is not really compatible with the sklearn ecosystem.
| Please use this class mainly for training and applying ranking models in common sklearnish way.
|
| Method resolution order:
| LGBMRanker
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_group: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, eval_at: Union[List[int], Tuple[int, ...]] = (1, 2, 3, 4, 5), feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel, NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMRanker'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : numpy array, pandas Series, pyarrow ChunkedArray, polars Series, list of int or float, or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_group : list of array (same types as ``group`` supports), or None, optional (default=None)
| Group data of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| eval_at : list or tuple of int, optional (default=(1, 2, 3, 4, 5))
| The evaluation positions of the specified metric.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMRanker
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| set_fit_request(self: lightgbm.sklearn.LGBMRanker, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_at: Union[bool, NoneType, str] = '$UNCHANGED$', eval_group: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', group: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_at : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_at`` parameter in ``fit``.
|
| eval_group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_group`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``group`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.sklearn.LGBMRanker, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Methods inherited from LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| __sklearn_tags__(self) -> Optional[ForwardRef('_sklearn_Tags')]
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
lightgbm.LGBMRegressor
Python Library Documentation: class LGBMRegressor in module lightgbm.sklearn
class LGBMRegressor(sklearn.base.RegressorMixin, LGBMModel)
| LGBMRegressor(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
|
| LightGBM regressor.
|
| Method resolution order:
| LGBMRegressor
| sklearn.base.RegressorMixin
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel, NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMRegressor'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMRegressor
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| set_fit_request(self: lightgbm.sklearn.LGBMRegressor, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.sklearn.LGBMRegressor, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.sklearn.LGBMRegressor, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.RegressorMixin:
|
| score(self, X, y, sample_weight=None)
| Return the coefficient of determination of the prediction.
|
| The coefficient of determination :math:`R^2` is defined as
| :math:`(1 - \frac{u}{v})`, where :math:`u` is the residual
| sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`
| is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.
| The best possible score is 1.0 and it can be negative (because the
| model can be arbitrarily worse). A constant model that always predicts
| the expected value of `y`, disregarding the input features, would get
| a :math:`R^2` score of 0.0.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples. For some estimators this may be a precomputed
| kernel matrix or a list of generic objects instead with shape
| ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``
| is the number of samples used in the fitting for the estimator.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True values for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| :math:`R^2` of ``self.predict(X)`` w.r.t. `y`.
|
| Notes
| -----
| The :math:`R^2` score used when calling ``score`` on a regressor uses
| ``multioutput='uniform_average'`` from version 0.23 to keep consistent
| with default value of :func:`~sklearn.metrics.r2_score`.
| This influences the ``score`` method of all the multioutput
| regressors (except for
| :class:`~sklearn.multioutput.MultiOutputRegressor`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.RegressorMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
lightgbm.Path
Python Library Documentation: class Path in module pathlib
class Path(PurePath)
| Path(*args, **kwargs)
|
| PurePath subclass that can make system calls.
|
| Path represents a filesystem path but unlike PurePath, also offers
| methods to do system calls on path objects. Depending on your system,
| instantiating a Path will return either a PosixPath or a WindowsPath
| object. You can also instantiate a PosixPath or WindowsPath directly,
| but cannot instantiate a WindowsPath on a POSIX system or vice versa.
|
| Method resolution order:
| Path
| PurePath
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
|
| __exit__(self, t, v, tb)
|
| __init__(self, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| absolute(self)
| Return an absolute version of this path by prepending the current
| working directory. No normalization or symlink resolution is performed.
|
| Use resolve() to get the canonical path to a file.
|
| chmod(self, mode, *, follow_symlinks=True)
| Change the permissions of the path, like os.chmod().
|
| exists(self, *, follow_symlinks=True)
| Whether this path exists.
|
| This method normally follows symlinks; to check whether a symlink exists,
| add the argument follow_symlinks=False.
|
| expanduser(self)
| Return a new path with expanded ~ and ~user constructs
| (as returned by os.path.expanduser)
|
| glob(self, pattern, *, case_sensitive=None)
| Iterate over this subtree and yield all existing files (of any
| kind, including directories) matching the given relative pattern.
|
| group(self)
| Return the group name of the file gid.
|
| hardlink_to(self, target)
| Make this path a hard link pointing to the same file as *target*.
|
| Note the order of arguments (self, target) is the reverse of os.link's.
|
| is_block_device(self)
| Whether this path is a block device.
|
| is_char_device(self)
| Whether this path is a character device.
|
| is_dir(self)
| Whether this path is a directory.
|
| is_fifo(self)
| Whether this path is a FIFO.
|
| is_file(self)
| Whether this path is a regular file (also True for symlinks pointing
| to regular files).
|
| is_junction(self)
| Whether this path is a junction.
|
| is_mount(self)
| Check if this path is a mount point
|
| is_socket(self)
| Whether this path is a socket.
|
| is_symlink(self)
| Whether this path is a symbolic link.
|
| iterdir(self)
| Yield path objects of the directory contents.
|
| The children are yielded in arbitrary order, and the
| special entries '.' and '..' are not included.
|
| lchmod(self, mode)
| Like chmod(), except if the path points to a symlink, the symlink's
| permissions are changed, rather than its target's.
|
| lstat(self)
| Like stat(), except if the path points to a symlink, the symlink's
| status information is returned, rather than its target's.
|
| mkdir(self, mode=511, parents=False, exist_ok=False)
| Create a new directory at this given path.
|
| open(self, mode='r', buffering=-1, encoding=None, errors=None, newline=None)
| Open the file pointed to by this path and return a file object, as
| the built-in open() function does.
|
| owner(self)
| Return the login name of the file owner.
|
| read_bytes(self)
| Open the file in bytes mode, read it, and close the file.
|
| read_text(self, encoding=None, errors=None)
| Open the file in text mode, read it, and close the file.
|
| readlink(self)
| Return the path to which the symbolic link points.
|
| rename(self, target)
| Rename this path to the target path.
|
| The target path may be absolute or relative. Relative paths are
| interpreted relative to the current working directory, *not* the
| directory of the Path object.
|
| Returns the new Path instance pointing to the target path.
|
| replace(self, target)
| Rename this path to the target path, overwriting if that path exists.
|
| The target path may be absolute or relative. Relative paths are
| interpreted relative to the current working directory, *not* the
| directory of the Path object.
|
| Returns the new Path instance pointing to the target path.
|
| resolve(self, strict=False)
| Make the path absolute, resolving all symlinks on the way and also
| normalizing it.
|
| rglob(self, pattern, *, case_sensitive=None)
| Recursively yield all existing files (of any kind, including
| directories) matching the given relative pattern, anywhere in
| this subtree.
|
| rmdir(self)
| Remove this directory. The directory must be empty.
|
| samefile(self, other_path)
| Return whether other_path is the same or not as this file
| (as returned by os.path.samefile()).
|
| stat(self, *, follow_symlinks=True)
| Return the result of the stat() system call on this path, like
| os.stat() does.
|
| symlink_to(self, target, target_is_directory=False)
| Make this path a symlink pointing to the target path.
| Note the order of arguments (link, target) is the reverse of os.symlink.
|
| touch(self, mode=438, exist_ok=True)
| Create this file with the given access mode, if it doesn't exist.
|
| unlink(self, missing_ok=False)
| Remove this file or link.
| If the path is a directory, use rmdir() instead.
|
| walk(self, top_down=True, on_error=None, follow_symlinks=False)
| Walk the directory tree from this directory, similar to os.walk().
|
| write_bytes(self, data)
| Open the file in bytes mode, write to it, and close the file.
|
| write_text(self, data, encoding=None, errors=None, newline=None)
| Open the file in text mode, write to it, and close the file.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| cwd()
| Return a new path pointing to the current working directory.
|
| home()
| Return a new path pointing to the user's home directory (as
| returned by os.path.expanduser('~')).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, *args, **kwargs)
| Construct a PurePath from one or several strings and or existing
| PurePath objects. The strings and path objects are combined so as
| to yield a canonicalized path, which is incorporated into the
| new PurePath object.
|
| ----------------------------------------------------------------------
| Methods inherited from PurePath:
|
| __bytes__(self)
| Return the bytes representation of the path. This is only
| recommended to use under Unix.
|
| __eq__(self, other)
| Return self==value.
|
| __fspath__(self)
|
| __ge__(self, other)
| Return self>=value.
|
| __gt__(self, other)
| Return self>value.
|
| __hash__(self)
| Return hash(self).
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __reduce__(self)
| Helper for pickle.
|
| __repr__(self)
| Return repr(self).
|
| __rtruediv__(self, key)
|
| __str__(self)
| Return the string representation of the path, suitable for
| passing to system calls.
|
| __truediv__(self, key)
|
| as_posix(self)
| Return the string representation of the path with forward (/)
| slashes.
|
| as_uri(self)
| Return the path as a 'file' URI.
|
| is_absolute(self)
| True if the path is absolute (has both a root and, if applicable,
| a drive).
|
| is_relative_to(self, other, /, *_deprecated)
| Return True if the path is relative to another path or False.
|
| is_reserved(self)
| Return True if the path contains one of the special names reserved
| by the system, if any.
|
| joinpath(self, *pathsegments)
| Combine this path with one or several arguments, and return a
| new path representing either a subpath (if all arguments are relative
| paths) or a totally different path (if one of the arguments is
| anchored).
|
| match(self, path_pattern, *, case_sensitive=None)
| Return True if this path matches the given pattern.
|
| relative_to(self, other, /, *_deprecated, walk_up=False)
| Return the relative path to another path identified by the passed
| arguments. If the operation is not possible (because this is not
| related to the other path), raise ValueError.
|
| The *walk_up* parameter controls whether `..` may be used to resolve
| the path.
|
| with_name(self, name)
| Return a new path with the file name changed.
|
| with_segments(self, *pathsegments)
| Construct a new path object from any number of path-like objects.
| Subclasses may override this method to customize how new path objects
| are created from methods like `iterdir()`.
|
| with_stem(self, stem)
| Return a new path with the stem changed.
|
| with_suffix(self, suffix)
| Return a new path with the file suffix changed. If the path
| has no suffix, add given suffix. If the given suffix is an empty
| string, remove the suffix from the path.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from PurePath:
|
| anchor
| The concatenation of the drive and root, or ''.
|
| drive
| The drive prefix (letter or UNC path), if any.
|
| name
| The final path component, if any.
|
| parent
| The logical parent of the path.
|
| parents
| A sequence of this path's logical parents.
|
| parts
| An object providing sequence-like access to the
| components in the filesystem path.
|
| root
| The root of the path, if any.
|
| stem
| The final path component, minus its last suffix.
|
| suffix
| The final component's last suffix, if any.
|
| This includes the leading period. For example: '.txt'
|
| suffixes
| A list of the final component's suffixes, if any.
|
| These include the leading periods. For example: ['.tar', '.gz']
lightgbm.Sequence
Python Library Documentation: class Sequence in module lightgbm.basic
class Sequence(abc.ABC)
| Generic data access interface.
|
| Object should support the following operations:
|
| .. code-block::
|
| # Get total row number.
| >>> len(seq)
| # Random access by row index. Used for data sampling.
| >>> seq[10]
| # Range data access. Used to read data in batch when constructing Dataset.
| >>> seq[0:100]
| # Optionally specify batch_size to control range data read size.
| >>> seq.batch_size
|
| - With random access, **data sampling does not need to go through all data**.
| - With range data access, there's **no need to read all data into memory thus reduce memory usage**.
|
| .. versionadded:: 3.3.0
|
| Attributes
| ----------
| batch_size : int
| Default size of a batch.
|
| Method resolution order:
| Sequence
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, idx: Union[int, slice, List[int]]) -> numpy.ndarray
| Return data for given row index.
|
| A basic implementation should look like this:
|
| .. code-block:: python
|
| if isinstance(idx, numbers.Integral):
| return self._get_one_line(idx)
| elif isinstance(idx, slice):
| return np.stack([self._get_one_line(i) for i in range(idx.start, idx.stop)])
| elif isinstance(idx, list):
| # Only required if using ``Dataset.subset()``.
| return np.array([self._get_one_line(i) for i in idx])
| else:
| raise TypeError(f"Sequence index must be integer, slice or list, got {type(idx).__name__}")
|
| Parameters
| ----------
| idx : int, slice[int], list[int]
| Item index.
|
| Returns
| -------
| result : numpy 1-D array or numpy 2-D array
| 1-D array if idx is int, 2-D array if idx is slice or list.
|
| __len__(self) -> int
| Return row count of this sequence.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__getitem__', '__len__'})
|
| batch_size = 4096
lightgbm.basic
Python Library Documentation: module lightgbm.basic in lightgbm
NAME
lightgbm.basic - Wrapper for C API of LightGBM.
CLASSES
abc.ABC(builtins.object)
Sequence
builtins.Exception(builtins.BaseException)
LightGBMError
builtins.FutureWarning(builtins.Warning)
LGBMDeprecationWarning
builtins.object
Booster
Dataset
class Booster(builtins.object)
| Booster(params: Optional[Dict[str, Any]] = None, train_set: Optional[lightgbm.basic.Dataset] = None, model_file: Union[str, pathlib.Path, NoneType] = None, model_str: Optional[str] = None)
|
| Booster in LightGBM.
|
| Methods defined here:
|
| __copy__(self) -> 'Booster'
|
| __deepcopy__(self, *args: Any, **kwargs: Any) -> 'Booster'
|
| __del__(self) -> None
|
| __getstate__(self) -> Dict[str, Any]
| Helper for pickle.
|
| __init__(self, params: Optional[Dict[str, Any]] = None, train_set: Optional[lightgbm.basic.Dataset] = None, model_file: Union[str, pathlib.Path, NoneType] = None, model_str: Optional[str] = None)
| Initialize the Booster.
|
| Parameters
| ----------
| params : dict or None, optional (default=None)
| Parameters for Booster.
| train_set : Dataset or None, optional (default=None)
| Training dataset.
| model_file : str, pathlib.Path or None, optional (default=None)
| Path to the model file.
| model_str : str or None, optional (default=None)
| Model will be loaded from this string.
|
| __setstate__(self, state: Dict[str, Any]) -> None
|
| add_valid(self, data: lightgbm.basic.Dataset, name: str) -> 'Booster'
| Add validation data.
|
| Parameters
| ----------
| data : Dataset
| Validation data.
| name : str
| Name of validation data.
|
| Returns
| -------
| self : Booster
| Booster with set validation data.
|
| current_iteration(self) -> int
| Get the index of the current iteration.
|
| Returns
| -------
| cur_iter : int
| The index of the current iteration.
|
| dump_model(self, num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split', object_hook: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None) -> Dict[str, Any]
| Dump Booster to JSON format.
|
| Parameters
| ----------
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be dumped.
| If None, if the best iteration exists, it is dumped; otherwise, all iterations are dumped.
| If <= 0, all iterations are dumped.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be dumped.
| importance_type : str, optional (default="split")
| What type of feature importance should be dumped.
| 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.
| object_hook : callable or None, optional (default=None)
| If not None, ``object_hook`` is a function called while parsing the json
| string returned by the C API. It may be used to alter the json, to store
| specific values while building the json structure. It avoids
| walking through the structure again. It saves a significant amount
| of time if the number of trees is huge.
| Signature is ``def object_hook(node: dict) -> dict``.
| None is equivalent to ``lambda node: node``.
| See documentation of ``json.loads()`` for further details.
|
| Returns
| -------
| json_repr : dict
| JSON format of Booster.
|
| eval(self, data: lightgbm.basic.Dataset, name: str, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None) -> List[lightgbm.basic.EvalResult]
| Evaluate for data.
|
| Parameters
| ----------
| data : Dataset
| Data for the evaluating.
| name : str
| Name of the data.
| feval : callable, list of callable, or None, optional (default=None)
| Customized evaluation function.
| Each evaluation function should accept two parameters: preds, eval_data,
| and return (metric_name, metric_value, maximize) or list of such tuples.
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
| If custom objective function is used, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| eval_data : Dataset
| A ``Dataset`` to evaluate.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| Returns
| -------
| result : list[EvalResult]
| List of ``lightgbm.EvalResult`` objects, named tuples of the form
| (dataset_name, metric_name, metric_value, maximize).
|
| eval_train(self, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None) -> List[lightgbm.basic.EvalResult]
| Evaluate for training data.
|
| Parameters
| ----------
| feval : callable, list of callable, or None, optional (default=None)
| Customized evaluation function.
| Each evaluation function should accept two parameters: preds, eval_data,
| and return (metric_name, metric_value, maximize) or list of such tuples.
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
| If custom objective function is used, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| eval_data : Dataset
| The training dataset.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| Returns
| -------
| result : list[EvalResult]
| List of ``lightgbm.EvalResult`` objects, named tuples of the form
| (dataset_name, metric_name, metric_value, maximize).
|
| eval_valid(self, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None) -> List[lightgbm.basic.EvalResult]
| Evaluate for validation data.
|
| Parameters
| ----------
| feval : callable, list of callable, or None, optional (default=None)
| Customized evaluation function.
| Each evaluation function should accept two parameters: preds, eval_data,
| and return (metric_name, metric_value, maximize) or list of such tuples.
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
| If custom objective function is used, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| eval_data : Dataset
| The validation dataset.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| Returns
| -------
| result : list
| List of ``lightgbm.EvalResult`` objects, named tuples of the form
| (dataset_name, metric_name, metric_value, maximize).
|
| feature_importance(self, importance_type: str = 'split', iteration: Optional[int] = None) -> numpy.ndarray
| Get feature importances.
|
| Parameters
| ----------
| importance_type : str, optional (default="split")
| How the importance is calculated.
| 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.
| iteration : int or None, optional (default=None)
| Limit number of iterations in the feature importance calculation.
| If None, if the best iteration exists, it is used; otherwise, all trees are used.
| If <= 0, all trees are used (no limits).
|
| Returns
| -------
| result : numpy array
| Array with feature importances.
|
| feature_name(self) -> List[str]
| Get names of features.
|
| Returns
| -------
| result : list of str
| List with names of features.
|
| free_dataset(self) -> 'Booster'
| Free Booster's Datasets.
|
| Returns
| -------
| self : Booster
| Booster without Datasets.
|
| free_network(self) -> 'Booster'
| Free Booster's network.
|
| Returns
| -------
| self : Booster
| Booster with freed network.
|
| get_leaf_output(self, tree_id: int, leaf_id: int) -> float
| Get the output of a leaf.
|
| Parameters
| ----------
| tree_id : int
| The index of the tree.
| leaf_id : int
| The index of the leaf in the tree.
|
| Returns
| -------
| result : float
| The output of the leaf.
|
| get_split_value_histogram(self, feature: Union[int, str], bins: Union[int, str, NoneType] = None, xgboost_style: bool = False) -> Union[Tuple[numpy.ndarray, numpy.ndarray], numpy.ndarray, pandas.core.frame.DataFrame]
| Get split value histogram for the specified feature.
|
| Parameters
| ----------
| feature : int or str
| The feature name or index the histogram is calculated for.
| If int, interpreted as index.
| If str, interpreted as name.
|
| .. warning::
|
| Categorical features are not supported.
|
| bins : int, str or None, optional (default=None)
| The maximum number of bins.
| If None, or int and > number of unique split values and ``xgboost_style=True``,
| the number of bins equals number of unique split values.
| If str, it should be one from the list of the supported values by ``numpy.histogram()`` function.
| xgboost_style : bool, optional (default=False)
| Whether the returned result should be in the same form as it is in XGBoost.
| If False, the returned value is tuple of 2 numpy arrays as it is in ``numpy.histogram()`` function.
| If True, the returned value is matrix, in which the first column is the right edges of non-empty bins
| and the second one is the histogram values.
|
| Returns
| -------
| result_tuple : tuple of 2 numpy arrays
| If ``xgboost_style=False``, the values of the histogram of used splitting values for the specified feature
| and the bin edges.
| result_array_like : numpy array or pandas DataFrame (if pandas is installed)
| If ``xgboost_style=True``, the histogram of used splitting values for the specified feature.
|
| lower_bound(self) -> float
| Get lower bound value of a model.
|
| Returns
| -------
| lower_bound : float
| Lower bound value of the model.
|
| model_from_string(self, model_str: str) -> 'Booster'
| Load Booster from a string.
|
| Parameters
| ----------
| model_str : str
| Model will be loaded from this string.
|
| Returns
| -------
| self : Booster
| Loaded Booster object.
|
| model_to_string(self, num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> str
| Save Booster to string.
|
| Parameters
| ----------
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be saved.
| If None, if the best iteration exists, it is saved; otherwise, all iterations are saved.
| If <= 0, all iterations are saved.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be saved.
| importance_type : str, optional (default="split")
| What type of feature importance should be saved.
| 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.
|
| Returns
| -------
| str_repr : str
| String representation of Booster.
|
| num_feature(self) -> int
| Get number of features.
|
| Returns
| -------
| num_feature : int
| The number of features.
|
| num_model_per_iteration(self) -> int
| Get number of models per iteration.
|
| Returns
| -------
| model_per_iter : int
| The number of models per iteration.
|
| num_trees(self) -> int
| Get number of weak sub-models.
|
| Returns
| -------
| num_trees : int
| The number of weak sub-models.
|
| predict(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, narwhals._native.NativeDataFrame], start_iteration: int = 0, num_iteration: Optional[int] = None, raw_score: bool = False, pred_leaf: bool = False, pred_contrib: bool = False, data_has_header: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Make a prediction.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, pyarrow Table or polars DataFrame
| Data source for prediction.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` are used (no limits).
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| 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.
|
| data_has_header : bool, optional (default=False)
| Whether the data has header.
| Used only if data is str.
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| result : numpy array, scipy.sparse or list of scipy.sparse
| Prediction result.
| Can be sparse or a list of sparse objects (each element represents predictions for one class) for feature contributions (when ``pred_contrib=True``).
|
| refit(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], decay_rate: float = 0.9, reference: Optional[lightgbm.basic.Dataset] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', dataset_params: Optional[Dict[str, Any]] = None, free_raw_data: bool = True, validate_features: bool = False, **kwargs: Any) -> 'Booster'
| Refit the existing Booster by new data.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table or polars DataFrame
| Data source for refit.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None
| Label for refit.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| decay_rate : float, optional (default=0.9)
| Decay rate of refit,
| will use ``leaf_output = decay_rate * old_leaf_output + (1.0 - decay_rate) * new_leaf_output`` to refit trees.
| reference : Dataset or None, optional (default=None)
| Reference for ``data``.
|
| .. versionadded:: 4.0.0
|
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Weight for each ``data`` instance. Weights should be non-negative.
|
| .. versionadded:: 4.0.0
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Group/query size for ``data``.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.0.0
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None, optional (default=None)
| Init score for ``data``.
|
| .. versionadded:: 4.0.0
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| feature_name : list of str, or 'auto', optional (default="auto")
| Feature names for ``data``.
| If 'auto' and data is pandas DataFrame, data columns names are used.
|
| .. versionadded:: 4.0.0
|
| categorical_feature : list of str or int, or 'auto', optional (default="auto")
| Categorical features for ``data``.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
|
| .. versionadded:: 4.0.0
|
| dataset_params : dict or None, optional (default=None)
| Other parameters for Dataset ``data``.
|
| .. versionadded:: 4.0.0
|
| free_raw_data : bool, optional (default=True)
| If True, raw data is freed after constructing inner Dataset for ``data``.
|
| .. versionadded:: 4.0.0
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to refit the model match the original ones.
| Used only if data is pandas DataFrame.
|
| .. versionadded:: 4.0.0
|
| **kwargs
| Other parameters for refit.
| These parameters will be passed to ``predict`` method.
|
| Returns
| -------
| result : Booster
| Refitted Booster.
|
| reset_parameter(self, params: Dict[str, Any]) -> 'Booster'
| Reset parameters of Booster.
|
| Parameters
| ----------
| params : dict
| New parameters for Booster.
|
| Returns
| -------
| self : Booster
| Booster with new parameters.
|
| rollback_one_iter(self) -> 'Booster'
| Rollback one iteration.
|
| Returns
| -------
| self : Booster
| Booster with rolled back one iteration.
|
| save_model(self, filename: Union[str, pathlib.Path], num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> 'Booster'
| Save Booster to file.
|
| Parameters
| ----------
| filename : str or pathlib.Path
| Filename to save Booster.
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be saved.
| If None, if the best iteration exists, it is saved; otherwise, all iterations are saved.
| If <= 0, all iterations are saved.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be saved.
| importance_type : str, optional (default="split")
| What type of feature importance should be saved.
| 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.
|
| Returns
| -------
| self : Booster
| Returns self.
|
| set_leaf_output(self, tree_id: int, leaf_id: int, value: float) -> 'Booster'
| Set the output of a leaf.
|
| .. versionadded:: 4.0.0
|
| Parameters
| ----------
| tree_id : int
| The index of the tree.
| leaf_id : int
| The index of the leaf in the tree.
| value : float
| Value to set as the output of the leaf.
|
| Returns
| -------
| self : Booster
| Booster with the leaf output set.
|
| set_network(self, machines: Union[List[str], Set[str], str], local_listen_port: int = 12400, listen_time_out: int = 120, num_machines: int = 1) -> 'Booster'
| Set the network configuration.
|
| Parameters
| ----------
| machines : list, set or str
| Names of machines.
| local_listen_port : int, optional (default=12400)
| TCP listen port for local machines.
| listen_time_out : int, optional (default=120)
| Socket time-out in minutes.
| num_machines : int, optional (default=1)
| The number of machines for distributed learning application.
|
| Returns
| -------
| self : Booster
| Booster with set network.
|
| set_train_data_name(self, name: str) -> 'Booster'
| Set the name to the training Dataset.
|
| Parameters
| ----------
| name : str
| Name for the training Dataset.
|
| Returns
| -------
| self : Booster
| Booster with set training Dataset name.
|
| shuffle_models(self, start_iteration: int = 0, end_iteration: int = -1) -> 'Booster'
| Shuffle models.
|
| Parameters
| ----------
| start_iteration : int, optional (default=0)
| The first iteration that will be shuffled.
| end_iteration : int, optional (default=-1)
| The last iteration that will be shuffled.
| If <= 0, means the last available iteration.
|
| Returns
| -------
| self : Booster
| Booster with shuffled models.
|
| trees_to_dataframe(self) -> pandas.core.frame.DataFrame
| Parse the fitted model and return in an easy-to-read pandas DataFrame.
|
| The returned DataFrame has the following columns.
|
| - ``tree_index`` : int64, which tree a node belongs to. 0-based, so a value of ``6``, for example, means "this node is in the 7th tree".
| - ``node_depth`` : int64, how far a node is from the root of the tree. The root node has a value of ``1``, its direct children are ``2``, etc.
| - ``node_index`` : str, unique identifier for a node.
| - ``left_child`` : str, ``node_index`` of the child node to the left of a split. ``None`` for leaf nodes.
| - ``right_child`` : str, ``node_index`` of the child node to the right of a split. ``None`` for leaf nodes.
| - ``parent_index`` : str, ``node_index`` of this node's parent. ``None`` for the root node.
| - ``split_feature`` : str, name of the feature used for splitting. ``None`` for leaf nodes.
| - ``split_gain`` : float64, gain from adding this split to the tree. ``NaN`` for leaf nodes.
| - ``threshold`` : float64, value of the feature used to decide which side of the split a record will go down. ``NaN`` for leaf nodes.
| - ``decision_type`` : str, logical operator describing how to compare a value to ``threshold``.
| For example, ``split_feature = "Column_10", threshold = 15, decision_type = "<="`` means that
| records where ``Column_10 <= 15`` follow the left side of the split, otherwise follows the right side of the split. ``None`` for leaf nodes.
| - ``missing_direction`` : str, split direction that missing values should go to. ``None`` for leaf nodes.
| - ``missing_type`` : str, describes what types of values are treated as missing.
| - ``value`` : float64, predicted value for this leaf node, multiplied by the learning rate.
| - ``weight`` : float64 or int64, sum of Hessian (second-order derivative of objective), summed over observations that fall in this node.
| - ``count`` : int64, number of records in the training data that fall into this node.
|
| Returns
| -------
| result : pandas DataFrame
| Returns a pandas DataFrame of the parsed model.
|
| update(self, train_set: Optional[lightgbm.basic.Dataset] = None, fobj: Optional[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[numpy.ndarray, numpy.ndarray]]] = None) -> bool
| Update Booster for one iteration.
|
| Parameters
| ----------
| train_set : Dataset or None, optional (default=None)
| Training data.
| If None, last training data is used.
| fobj : callable or None, optional (default=None)
| Customized objective function.
| Should accept two parameters: preds, train_data,
| and return (grad, hess).
|
| preds : numpy 1-D array or numpy 2-D array (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| train_data : Dataset
| The training dataset.
| grad : numpy 1-D array or numpy 2-D array (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of preds for each sample point.
| hess : numpy 1-D array or numpy 2-D array (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of preds for each sample point.
|
| For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| Returns
| -------
| produced_empty_tree : bool
| ``True`` if the tree(s) produced by this iteration did not have any splits.
| This usually means that training is "finished" (calling ``update()`` again
| will not change the model's predictions). However, that is not always the
| case. For example, if you have added any randomness (like column sampling by
| setting ``feature_fraction_bynode < 1.0``), it is possible that another call
| to ``update()`` would produce a non-empty tree.
|
| upper_bound(self) -> float
| Get upper bound value of a model.
|
| Returns
| -------
| upper_bound : float
| Upper bound value of the model.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Dataset(builtins.object)
| Dataset(data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, reference: Optional[ForwardRef('Dataset')] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', params: Optional[Dict[str, Any]] = None, free_raw_data: bool = True, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None)
|
| Dataset in LightGBM.
|
| LightGBM does not train on raw data.
| It discretizes continuous features into histogram bins, tries to combine categorical features,
| and automatically handles missing and infinite values.
|
| This class handles that preprocessing, and holds that alternative representation of the input data.
|
| Methods defined here:
|
| __del__(self) -> None
|
| __init__(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, reference: Optional[ForwardRef('Dataset')] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', params: Optional[Dict[str, Any]] = None, free_raw_data: bool = True, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None)
| Initialize Dataset.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table or polars DataFrame
| Data source of Dataset.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM) or a LightGBM Dataset binary file.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Label of the data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| reference : Dataset or None, optional (default=None)
| If this is Dataset for validation, training data should be used as reference.
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Weight for each instance. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None, optional (default=None)
| Init score for Dataset.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| feature_name : list of str, or 'auto', optional (default="auto")
| Feature names.
| If 'auto' and data is pandas DataFrame, pyarrow Table, or polars DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default="auto")
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| params : dict or None, optional (default=None)
| Other parameters for Dataset.
| free_raw_data : bool, optional (default=True)
| If True, raw data is freed after constructing inner Dataset.
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Position of items used in unbiased learning-to-rank task.
|
| add_features_from(self, other: 'Dataset') -> 'Dataset'
| Add features from other Dataset to the current Dataset.
|
| Both Datasets must be constructed before calling this method.
|
| Parameters
| ----------
| other : Dataset
| The Dataset to take features from.
|
| Returns
| -------
| self : Dataset
| Dataset with the new features added.
|
| construct(self) -> 'Dataset'
| Lazy init.
|
| Returns
| -------
| self : Dataset
| Constructed Dataset object.
|
| create_valid(self, data: Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame], label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, params: Optional[Dict[str, Any]] = None, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None) -> 'Dataset'
| Create validation data align with current Dataset.
|
| Parameters
| ----------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table or polars DataFrame
| Data source of Dataset.
| If str or pathlib.Path, it represents the path to a text file (CSV, TSV, or LibSVM) or a LightGBM Dataset binary file.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Label of the data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Weight for each instance. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None, optional (default=None)
| Init score for Dataset.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| params : dict or None, optional (default=None)
| Other parameters for validation Dataset.
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Position of items used in unbiased learning-to-rank task.
|
| Returns
| -------
| valid : Dataset
| Validation Dataset with reference to self.
|
| feature_num_bin(self, feature: Union[int, str]) -> int
| Get the number of bins for a feature.
|
| .. versionadded:: 4.0.0
|
| Parameters
| ----------
| feature : int or str
| Index or name of the feature.
|
| Returns
| -------
| number_of_bins : int
| The number of constructed bins for the feature in the Dataset.
|
| get_data(self) -> Union[str, pathlib.Path, numpy.ndarray, pandas.core.frame.DataFrame, scipy.sparse._matrix.spmatrix, ForwardRef('Sequence'), List[ForwardRef('Sequence')], List[numpy.ndarray], narwhals._native.NativeDataFrame, NoneType]
| Get the raw data of the Dataset.
|
| Returns
| -------
| data : str, pathlib.Path, numpy array, pandas DataFrame, scipy.sparse, Sequence, list of Sequence, list of numpy array, pyarrow Table, polars DataFrame, or None
| Raw data used in the Dataset construction.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_feature_name(self) -> List[str]
| Get the names of columns (features) in the Dataset.
|
| Returns
| -------
| feature_names : list of str
| The names of columns (features) in the Dataset.
|
| get_field(self, field_name: str) -> Optional[numpy.ndarray]
| Get property from the Dataset.
|
| Can only be run on a constructed Dataset.
|
| Unlike ``get_group()``, ``get_init_score()``, ``get_label()``, ``get_position()``, and ``get_weight()``,
| this method ignores any raw data passed into ``lgb.Dataset()`` on the Python side, and will only read
| data from the constructed C++ ``Dataset`` object.
|
| Parameters
| ----------
| field_name : str
| The field name of the information.
|
| Returns
| -------
| info : numpy array or None
| A numpy array with information from the Dataset.
|
| get_group(self) -> Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]
| Get the group of the Dataset.
|
| Returns
| -------
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_init_score(self) -> Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]
| Get the initial score of the Dataset.
|
| Returns
| -------
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None
| Init score of Booster.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_label(self) -> Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]
| Get the label of the Dataset.
|
| Returns
| -------
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None
| The label information from the Dataset.
| For a constructed ``Dataset``, this will only return a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| get_params(self) -> Dict[str, Any]
| Get the used parameters in the Dataset.
|
| Returns
| -------
| params : dict
| The used parameters in this Dataset object.
|
| get_position(self) -> Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]
| Get the position of the Dataset.
|
| Returns
| -------
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Position of items used in unbiased learning-to-rank task.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| get_ref_chain(self, ref_limit: int = 100) -> Set[ForwardRef('Dataset')]
| Get a chain of Dataset objects.
|
| Starts with r, then goes to r.reference (if exists),
| then to r.reference.reference, etc.
| until we hit ``ref_limit`` or a reference loop.
|
| Parameters
| ----------
| ref_limit : int, optional (default=100)
| The limit number of references.
|
| Returns
| -------
| ref_chain : set of Dataset
| Chain of references of the Datasets.
|
| get_weight(self) -> Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]
| Get the weight of the Dataset.
|
| Returns
| -------
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Weight for each data point from the Dataset. Weights should be non-negative.
| For a constructed ``Dataset``, this will only return ``None`` or a numpy array.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| num_data(self) -> int
| Get the number of rows in the Dataset.
|
| Returns
| -------
| number_of_rows : int
| The number of rows in the Dataset.
|
| num_feature(self) -> int
| Get the number of columns (features) in the Dataset.
|
| Returns
| -------
| number_of_columns : int
| The number of columns (features) in the Dataset.
|
| save_binary(self, filename: Union[str, pathlib.Path]) -> 'Dataset'
| Save Dataset to a binary file.
|
| .. note::
|
| Please note that `init_score` is not saved in binary file.
| If you need it, please set it again after loading Dataset.
|
| Parameters
| ----------
| filename : str or pathlib.Path
| Name of the output file.
|
| Returns
| -------
| self : Dataset
| Returns self.
|
| set_categorical_feature(self, categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")]) -> 'Dataset'
| Set categorical features.
|
| Parameters
| ----------
| categorical_feature : list of str or int, or 'auto'
| Names or indices of categorical features.
|
| Returns
| -------
| self : Dataset
| Dataset with set categorical features.
|
| set_feature_name(self, feature_name: Union[List[str], ForwardRef("Literal['auto']")]) -> 'Dataset'
| Set feature name.
|
| Parameters
| ----------
| feature_name : list of str
| Feature names.
|
| Returns
| -------
| self : Dataset
| Dataset with set feature name.
|
| set_field(self, field_name: str, data: Union[List[List[float]], List[List[int]], List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, NoneType]) -> 'Dataset'
| Set property into the Dataset.
|
| Parameters
| ----------
| field_name : str
| The field name of the information.
| data : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None
| The data to be set.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set property.
|
| set_group(self, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]) -> 'Dataset'
| Set group size of Dataset (used for ranking).
|
| Parameters
| ----------
| group : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set group.
|
| set_init_score(self, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]) -> 'Dataset'
| Set init score of Booster to start from.
|
| Parameters
| ----------
| init_score : list, list of lists (for multi-class task), numpy array, pandas Series, pandas DataFrame (for multi-class task), pyarrow ChunkedArray, pyarrow Table (for multi-class task), polars Series, polars DataFrame (for multi-class task) or None
| Init score for Booster.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set init score.
|
| set_label(self, label: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType]) -> 'Dataset'
| Set label of Dataset.
|
| Parameters
| ----------
| label : list, numpy 1-D array, pandas Series / one-column DataFrame, pyarrow ChunkedArray, polars Series or None
| The label information to be set into Dataset.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set label.
|
| set_position(self, position: Union[numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]) -> 'Dataset'
| Set position of Dataset (used for ranking).
|
| Parameters
| ----------
| position : numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None, optional (default=None)
| Position of items used in unbiased learning-to-rank task.
|
| Returns
| -------
| self : Dataset
| Dataset with set position.
|
| set_reference(self, reference: 'Dataset') -> 'Dataset'
| Set reference Dataset.
|
| Parameters
| ----------
| reference : Dataset
| Reference that is used as a template to construct the current Dataset.
|
| Returns
| -------
| self : Dataset
| Dataset with set reference.
|
| set_weight(self, weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType]) -> 'Dataset'
| Set weight of each instance.
|
| Parameters
| ----------
| weight : list, numpy 1-D array, pandas Series, pyarrow ChunkedArray, polars Series or None
| Weight to be set for each data point. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| Returns
| -------
| self : Dataset
| Dataset with set weight.
|
| subset(self, used_indices: List[int], params: Optional[Dict[str, Any]] = None) -> 'Dataset'
| Get subset of current Dataset.
|
| Parameters
| ----------
| used_indices : list of int
| Indices used to create the subset.
| params : dict or None, optional (default=None)
| These parameters will be passed to Dataset constructor.
|
| Returns
| -------
| subset : Dataset
| Subset of the current Dataset.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LGBMDeprecationWarning(builtins.FutureWarning)
| Custom deprecation warning.
|
| Method resolution order:
| LGBMDeprecationWarning
| builtins.FutureWarning
| builtins.Warning
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.FutureWarning:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.FutureWarning:
|
| __new__(*args, **kwargs) class method of builtins.FutureWarning
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class LightGBMError(builtins.Exception)
| Error thrown by LightGBM.
|
| Method resolution order:
| LightGBMError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class Sequence(abc.ABC)
| Generic data access interface.
|
| Object should support the following operations:
|
| .. code-block::
|
| # Get total row number.
| >>> len(seq)
| # Random access by row index. Used for data sampling.
| >>> seq[10]
| # Range data access. Used to read data in batch when constructing Dataset.
| >>> seq[0:100]
| # Optionally specify batch_size to control range data read size.
| >>> seq.batch_size
|
| - With random access, **data sampling does not need to go through all data**.
| - With range data access, there's **no need to read all data into memory thus reduce memory usage**.
|
| .. versionadded:: 3.3.0
|
| Attributes
| ----------
| batch_size : int
| Default size of a batch.
|
| Method resolution order:
| Sequence
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, idx: Union[int, slice, List[int]]) -> numpy.ndarray
| Return data for given row index.
|
| A basic implementation should look like this:
|
| .. code-block:: python
|
| if isinstance(idx, numbers.Integral):
| return self._get_one_line(idx)
| elif isinstance(idx, slice):
| return np.stack([self._get_one_line(i) for i in range(idx.start, idx.stop)])
| elif isinstance(idx, list):
| # Only required if using ``Dataset.subset()``.
| return np.array([self._get_one_line(i) for i in idx])
| else:
| raise TypeError(f"Sequence index must be integer, slice or list, got {type(idx).__name__}")
|
| Parameters
| ----------
| idx : int, slice[int], list[int]
| Item index.
|
| Returns
| -------
| result : numpy 1-D array or numpy 2-D array
| 1-D array if idx is int, 2-D array if idx is slice or list.
|
| __len__(self) -> int
| Return row count of this sequence.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__getitem__', '__len__'})
|
| batch_size = 4096
FUNCTIONS
register_logger(logger: Any, info_method_name: str = 'info', warning_method_name: str = 'warning') -> None
Register custom logger.
Parameters
----------
logger : Any
Custom logger.
info_method_name : str, optional (default="info")
Method used to log info messages.
warning_method_name : str, optional (default="warning")
Method used to log warning messages.
DATA
__all__ = ['Booster', 'Dataset', 'LGBMDeprecationWarning', 'LightGBMEr...
__annotations__ = {'_LOGGER': typing.Any}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\basic.py
lightgbm.callback
Python Library Documentation: module lightgbm.callback in lightgbm
NAME
lightgbm.callback - Callbacks library.
CLASSES
builtins.Exception(builtins.BaseException)
EarlyStopException
class EarlyStopException(builtins.Exception)
| EarlyStopException(best_iteration: int, best_score: Union[List[lightgbm.basic.EvalResult], List[Tuple[str, str, float, bool]], List[Tuple[str, str, float, bool, float]]]) -> None
|
| Exception of early stopping.
|
| Raise this from a callback passed in via keyword argument ``callbacks``
| in ``cv()`` or ``train()`` to trigger early stopping.
|
| Method resolution order:
| EarlyStopException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, best_iteration: int, best_score: Union[List[lightgbm.basic.EvalResult], List[Tuple[str, str, float, bool]], List[Tuple[str, str, float, bool, float]]]) -> None
| Create early stopping exception.
|
| Parameters
| ----------
| best_iteration : int
| The best iteration stopped.
| 0-based... pass ``best_iteration=2`` to indicate that the third iteration was the best one.
| best_score : list of (dataset_name, metric_name, metric_value, maximize) tuple, (dataset_name, metric_name, metric_value, maximize, metric_std_dev) tuple, or ``lightgbm.EvalResult``
| Scores for each metric, on each validation set, as of the best iteration.
|
| Notes
| -----
|
| .. versionadded:: 4.7.0
| ``best_score`` is stored on the instance as a list of ``lightgbm.EvalResult`` objects.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
FUNCTIONS
early_stopping(stopping_rounds: int, first_metric_only: bool = False, verbose: bool = True, min_delta: Union[float, List[float]] = 0.0) -> lightgbm.callback._EarlyStoppingCallback
Create a callback that activates early stopping.
Activates early stopping.
The model will train until the validation score doesn't improve by at least ``min_delta``.
Validation score needs to improve at least every ``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 ``first_metric_only`` to True.
The index of iteration that has the best performance will be saved in the ``best_iteration`` attribute of a model.
.. note::
If using ``boosting_type="dart"``, this callback has no effect and early stopping
will not be performed.
Parameters
----------
stopping_rounds : int
The possible number of rounds without the trend occurrence.
first_metric_only : bool, optional (default=False)
Whether to use only the first metric for early stopping.
verbose : bool, optional (default=True)
Whether to log message with early stopping information.
By default, standard output resource is used.
Use ``register_logger()`` function to register a custom logger.
min_delta : float or list of float, optional (default=0.0)
Minimum improvement in score to keep training.
If float, this single value is used for all metrics.
If list, its length should match the total number of metrics.
.. versionadded:: 4.0.0
Returns
-------
callback : _EarlyStoppingCallback
The callback that activates early stopping.
log_evaluation(period: int = 1, show_stdv: bool = True) -> lightgbm.callback._LogEvaluationCallback
Create a callback that logs the evaluation results.
By default, standard output resource is used.
Use ``register_logger()`` function to register a custom logger.
Note
----
Requires at least one validation data.
Parameters
----------
period : int, optional (default=1)
The period to log the evaluation results.
The last boosting stage or the boosting stage found by using ``early_stopping`` callback is also logged.
show_stdv : bool, optional (default=True)
Whether to log stdv (if provided).
Returns
-------
callback : _LogEvaluationCallback
The callback that logs the evaluation results every ``period`` boosting iteration(s).
record_evaluation(eval_result: Dict[str, Dict[str, List[Any]]]) -> Callable
Create a callback that records the evaluation history into ``eval_result``.
Parameters
----------
eval_result : dict
Dictionary used to store all evaluation results of all validation sets.
This should be initialized outside of your call to ``record_evaluation()`` and should be empty.
Any initial contents of the dictionary will be deleted.
.. rubric:: Example
With two validation sets named 'eval' and 'train', and one evaluation metric named 'logloss'
this dictionary after finishing a model training process will have the following structure:
.. code-block::
{
'train':
{
'logloss': [0.48253, 0.35953, ...]
},
'eval':
{
'logloss': [0.480385, 0.357756, ...]
}
}
Returns
-------
callback : _RecordEvaluationCallback
The callback that records the evaluation history into the passed dictionary.
reset_parameter(**kwargs: Union[list, Callable]) -> Callable
Create a callback that resets the parameter after the first iteration.
.. note::
The initial parameter will still take in-effect on first iteration.
Parameters
----------
**kwargs : value should be list or callable
List of parameters for each boosting round
or a callable that calculates the parameter in terms of
current number of round (e.g. yields learning rate decay).
If list lst, parameter = lst[current_round].
If callable func, parameter = func(current_round).
Returns
-------
callback : _ResetParameterCallback
The callback that resets the parameter after the first iteration.
DATA
__all__ = ['EarlyStopException', 'early_stopping', 'log_evaluation', '...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\callback.py
lightgbm.compat
Python Library Documentation: module lightgbm.compat in lightgbm
NAME
lightgbm.compat - Compatibility library.
DATA
__all__ = []
__annotations__ = {'__all__': typing.List[str]}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\compat.py
lightgbm.create_tree_digraph
Python Library Documentation: function create_tree_digraph in module lightgbm.plotting
create_tree_digraph(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], tree_index: int = 0, show_info: Optional[List[str]] = None, precision: Optional[int] = 3, orientation: str = 'horizontal', example_case: Union[numpy.ndarray, pandas.core.frame.DataFrame, NoneType] = None, max_category_values: int = 10, **kwargs: Any) -> Any
Create a digraph representation of specified tree.
Each node in the graph represents a node in the tree.
Non-leaf nodes have labels like ``Column_10 <= 875.9``, which means
"this node splits on the feature named "Column_10", with threshold 875.9".
Leaf nodes have labels like ``leaf 2: 0.422``, which means "this node is a
leaf node, and the predicted value for records that fall into this node
is 0.422". The number (``2``) is an internal unique identifier and doesn't
have any special meaning.
.. note::
For more information please visit
https://graphviz.readthedocs.io/en/stable/api.html#digraph.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance to be converted.
tree_index : int, optional (default=0)
The index of a target tree to convert.
show_info : list of str, or None, optional (default=None)
What information should be shown in nodes.
- ``'split_gain'`` : gain from adding this split to the model
- ``'internal_value'`` : raw predicted value that would be produced by this node if it was a leaf node
- ``'internal_count'`` : number of records from the training data that fall into this non-leaf node
- ``'internal_weight'`` : total weight of all nodes that fall into this non-leaf node
- ``'leaf_count'`` : number of records from the training data that fall into this leaf node
- ``'leaf_weight'`` : total weight (sum of Hessian) of all observations that fall into this leaf node
- ``'data_percentage'`` : percentage of training data that fall into this node
precision : int or None, optional (default=3)
Used to restrict the display of floating point values to a certain precision.
orientation : str, optional (default='horizontal')
Orientation of the tree.
Can be 'horizontal' or 'vertical'.
example_case : numpy 2-D array, pandas DataFrame or None, optional (default=None)
Single row with the same structure as the training data.
If not None, the plot will highlight the path that sample takes through the tree.
.. versionadded:: 4.0.0
max_category_values : int, optional (default=10)
The maximum number of category values to display in tree nodes, if the number of thresholds is greater than this value, thresholds will be collapsed and displayed on the label tooltip instead.
.. warning::
Consider wrapping the SVG string of the tree graph with ``IPython.display.HTML`` when running on JupyterLab to get the `tooltip <https://graphviz.org/docs/attrs/tooltip>`_ working right.
Example:
.. code-block:: python
from IPython.display import HTML
graph = lgb.create_tree_digraph(clf, max_category_values=5)
HTML(graph._repr_image_svg_xml())
.. versionadded:: 4.0.0
**kwargs
Other parameters passed to ``Digraph`` constructor.
Check https://graphviz.readthedocs.io/en/stable/api.html#digraph for the full list of supported parameters.
Returns
-------
graph : graphviz.Digraph
The digraph representation of specified tree.
lightgbm.cv
Python Library Documentation: function cv in module lightgbm.engine
cv(params: Dict[str, Any], train_set: lightgbm.basic.Dataset, num_boost_round: int = 100, folds: Union[Iterable[Tuple[numpy.ndarray, numpy.ndarray]], sklearn.model_selection._split.BaseCrossValidator, NoneType] = None, nfold: int = 5, stratified: bool = True, shuffle: bool = True, metrics: Union[str, List[str], NoneType] = None, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, NoneType] = None, fpreproc: Optional[Callable[[lightgbm.basic.Dataset, lightgbm.basic.Dataset, Dict[str, Any]], Tuple[lightgbm.basic.Dataset, lightgbm.basic.Dataset, Dict[str, Any]]]] = None, seed: int = 0, callbacks: Optional[List[Callable]] = None, eval_train_metric: bool = False, return_cvbooster: bool = False) -> Dict[str, Union[List[float], lightgbm.engine.CVBooster]]
Perform the cross-validation with given parameters.
Parameters
----------
params : dict
Parameters for training. Values passed through ``params`` take precedence over those
supplied via arguments.
train_set : Dataset
Data to be trained on.
num_boost_round : int, optional (default=100)
Number of boosting iterations.
folds : generator or iterator of (train_idx, test_idx) tuples, scikit-learn splitter object or None, optional (default=None)
If generator or iterator, it should yield the train and test indices for each fold.
If object, it should be one of the scikit-learn splitter classes
(https://scikit-learn.org/stable/modules/classes.html#splitter-classes)
and have ``split`` method.
This argument has highest priority over other data split arguments.
nfold : int, optional (default=5)
Number of folds in CV.
stratified : bool, optional (default=True)
Whether to perform stratified sampling.
shuffle : bool, optional (default=True)
Whether to shuffle before splitting data.
metrics : str, list of str, or None, optional (default=None)
Evaluation metrics to be monitored while CV.
If not None, the metric in ``params`` will be overridden.
feval : callable, list of callable, or None, optional (default=None)
Customized evaluation function.
Each evaluation function should accept two parameters: preds, eval_data,
and return (metric_name, metric_value, maximize) or list of such tuples.
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
If custom objective function is used, predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task in this case.
eval_data : Dataset
A ``Dataset`` to evaluate.
metric_name : str
Unique identifier for the metric (e.g. "custom_adjusted_mse").
metric_value : float
Value of the evaluation metric.
maximize : bool
Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
To ignore the default metric corresponding to the used objective,
set ``metrics`` to the string ``"None"``.
init_model : str, pathlib.Path, Booster or None, optional (default=None)
Filename of LightGBM model or Booster instance used for continue training.
fpreproc : callable or None, optional (default=None)
Preprocessing function that takes (dtrain, dtest, params)
and returns transformed versions of those.
seed : int, optional (default=0)
Seed used to generate the folds (passed to numpy.random.seed).
callbacks : list of callable, or None, optional (default=None)
List of callback functions that are applied at each iteration.
See Callbacks in Python API for more information.
eval_train_metric : bool, optional (default=False)
Whether to display the train metric in progress.
The score of the metric is calculated again after each training step, so there is some impact on performance.
return_cvbooster : bool, optional (default=False)
Whether to return Booster models trained on each fold through ``CVBooster``.
Note
----
A custom objective function can be provided for the ``objective`` parameter.
It should accept two parameters: preds, train_data and return (grad, hess).
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
Predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task.
train_data : Dataset
The training dataset.
grad : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the first order derivative (gradient) of the loss
with respect to the elements of preds for each sample point.
hess : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the second order derivative (Hessian) of the loss
with respect to the elements of preds for each sample point.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes],
and grad and hess should be returned in the same format.
Returns
-------
eval_results : dict
History of evaluation results of each metric.
The dictionary has the following format:
{'valid metric1-mean': [values], 'valid metric1-stdv': [values],
'valid metric2-mean': [values], 'valid metric2-stdv': [values],
...}.
If ``return_cvbooster=True``, also returns trained boosters wrapped in a ``CVBooster`` object via ``cvbooster`` key.
If ``eval_train_metric=True``, also returns the train metric history.
In this case, the dictionary has the following format:
{'train metric1-mean': [values], 'valid metric1-mean': [values],
'train metric2-mean': [values], 'valid metric2-mean': [values],
...}.
lightgbm.dask
Python Library Documentation: module lightgbm.dask in lightgbm
NAME
lightgbm.dask - Distributed training with LightGBM and dask.distributed.
DESCRIPTION
This module enables you to perform distributed training with LightGBM on
dask.Array and dask.DataFrame collections.
It is based on dask-lightgbm, which was based on dask-xgboost.
CLASSES
_DaskLGBMModel(builtins.object)
DaskLGBMClassifier(lightgbm.sklearn.LGBMClassifier, _DaskLGBMModel)
DaskLGBMRanker(lightgbm.sklearn.LGBMRanker, _DaskLGBMModel)
DaskLGBMRegressor(lightgbm.sklearn.LGBMRegressor, _DaskLGBMModel)
lightgbm.sklearn.LGBMClassifier(sklearn.base.ClassifierMixin, lightgbm.sklearn.LGBMModel)
DaskLGBMClassifier(lightgbm.sklearn.LGBMClassifier, _DaskLGBMModel)
lightgbm.sklearn.LGBMRanker(lightgbm.sklearn.LGBMModel)
DaskLGBMRanker(lightgbm.sklearn.LGBMRanker, _DaskLGBMModel)
lightgbm.sklearn.LGBMRegressor(sklearn.base.RegressorMixin, lightgbm.sklearn.LGBMModel)
DaskLGBMRegressor(lightgbm.sklearn.LGBMRegressor, _DaskLGBMModel)
class DaskLGBMClassifier(lightgbm.sklearn.LGBMClassifier, _DaskLGBMModel)
| DaskLGBMClassifier(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
|
| Distributed version of lightgbm.LGBMClassifier.
|
| Method resolution order:
| DaskLGBMClassifier
| lightgbm.sklearn.LGBMClassifier
| sklearn.base.ClassifierMixin
| lightgbm.sklearn.LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| _DaskLGBMModel
| builtins.object
|
| Methods defined here:
|
| __getstate__(self) -> Dict[Any, Any]
| Helper for pickle.
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
| client : distributed.Client or None, optional (default=None)
| Dask client.
| If ``None``, ``distributed.default_client()`` will be used at runtime.
| The Dask client used by this class will not be saved if the model object is pickled.
| **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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')], sample_weight: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, init_score: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), NoneType] = None, eval_set: Optional[List[Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_class_weight: Optional[List[Union[dict, str]]] = None, eval_init_score: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, *, eval_X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')]], NoneType] = None, eval_y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]], NoneType] = None, **kwargs: Any) -> 'DaskLGBMClassifier'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : Dask Array, Dask DataFrame or Dask Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : Dask Array or Dask Series of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task), or Dask Array or Dask DataFrame of shape = [n_samples, n_classes] (for multi-class task), or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of Dask Array or Dask Series, or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_class_weight : list or None, optional (default=None)
| Class weights of eval data.
| eval_init_score : list of Dask Array, Dask Series or Dask DataFrame (for multi-class task), or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| **kwargs
| Other parameters passed through to ``LGBMClassifier.fit()``.
|
| Returns
| -------
| self : lightgbm.DaskLGBMClassifier
| Returns self.
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : Dask Array of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : Dask Array 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 : Dask Array of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or (if multi-class and using sparse inputs) a list of ``n_classes`` Dask Arrays of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| predict_proba(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted probability for each class for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_probability : Dask Array of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : Dask Array 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 : Dask Array of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or (if multi-class and using sparse inputs) a list of ``n_classes`` Dask Arrays of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_decision_function_request(self: lightgbm.dask.DaskLGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``decision_function`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``decision_function`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``decision_function``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``decision_function``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``decision_function``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``decision_function``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_fit_request(self: lightgbm.dask.DaskLGBMClassifier, *, eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_class_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_class_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_class_weight`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_proba_request(self: lightgbm.dask.DaskLGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict_proba`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict_proba`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict_proba``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict_proba``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict_proba``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict_proba``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict_proba``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict_proba``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict_proba``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.dask.DaskLGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.dask.DaskLGBMClassifier, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| to_local(self) -> lightgbm.sklearn.LGBMClassifier
| Create regular version of lightgbm.LGBMClassifier from the distributed version.
|
| Returns
| -------
| model : lightgbm.LGBMClassifier
| Local underlying model.
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMClassifier:
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| decision_function(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], *, start_iteration: int = 0, num_iteration: Optional[int] = None, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the raw margin score for each sample.
|
| .. versionadded:: 4.7.0
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` are used (no limits).
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters forwarded to ``predict()``.
|
| Returns
| -------
| raw_score : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMClassifier:
|
| classes_
| :obj:`array` of shape = [n_classes]: The class label array.
|
| n_classes_
| :obj:`int`: The number of classes.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.ClassifierMixin:
|
| score(self, X, y, sample_weight=None)
| Return the mean accuracy on the given test data and labels.
|
| In multi-label classification, this is the subset accuracy
| which is a harsh metric since you require for each sample that
| each label set be correctly predicted.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True labels for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| Mean accuracy of ``self.predict(X)`` w.r.t. `y`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.ClassifierMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from lightgbm.sklearn.LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _DaskLGBMModel:
|
| client_
| :obj:`distributed.Client`: Dask client.
|
| This property can be passed in the constructor or updated
| with ``model.set_params(client=client)``.
class DaskLGBMRanker(lightgbm.sklearn.LGBMRanker, _DaskLGBMModel)
| DaskLGBMRanker(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
|
| Distributed version of lightgbm.LGBMRanker.
|
| Method resolution order:
| DaskLGBMRanker
| lightgbm.sklearn.LGBMRanker
| lightgbm.sklearn.LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| _DaskLGBMModel
| builtins.object
|
| Methods defined here:
|
| __getstate__(self) -> Dict[Any, Any]
| Helper for pickle.
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
| client : distributed.Client or None, optional (default=None)
| Dask client.
| If ``None``, ``distributed.default_client()`` will be used at runtime.
| The Dask client used by this class will not be saved if the model object is pickled.
| **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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')], sample_weight: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, init_score: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, group: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, eval_set: Optional[List[Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_init_score: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_group: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, eval_at: Union[List[int], Tuple[int, ...]] = (1, 2, 3, 4, 5), *, eval_X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')]], NoneType] = None, eval_y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]], NoneType] = None, **kwargs: Any) -> 'DaskLGBMRanker'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : Dask Array, Dask DataFrame or Dask Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : Dask Array or Dask Series or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of Dask Array or Dask Series, or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of Dask Array or Dask Series, or None, optional (default=None)
| Init score of eval data.
| eval_group : list of Dask Array or Dask Series, or None, optional (default=None)
| Group data of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| eval_at : list or tuple of int, optional (default=(1, 2, 3, 4, 5))
| The evaluation positions of the specified metric.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| **kwargs
| Other parameters passed through to ``LGBMRanker.fit()``.
|
| Returns
| -------
| self : lightgbm.DaskLGBMRanker
| Returns self.
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : Dask Array of shape = [n_samples]
| The predicted values.
| X_leaves : Dask Array of shape = [n_samples, n_trees]
| If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
| X_SHAP_values : Dask Array of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_fit_request(self: lightgbm.dask.DaskLGBMRanker, *, eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_at: Union[bool, NoneType, str] = '$UNCHANGED$', eval_group: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', group: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_at : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_at`` parameter in ``fit``.
|
| eval_group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_group`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``group`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.dask.DaskLGBMRanker, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| to_local(self) -> lightgbm.sklearn.LGBMRanker
| Create regular version of lightgbm.LGBMRanker from the distributed version.
|
| Returns
| -------
| model : lightgbm.LGBMRanker
| Local underlying model.
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| __sklearn_tags__(self) -> Optional[ForwardRef('_sklearn_Tags')]
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from lightgbm.sklearn.LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _DaskLGBMModel:
|
| client_
| :obj:`distributed.Client`: Dask client.
|
| This property can be passed in the constructor or updated
| with ``model.set_params(client=client)``.
class DaskLGBMRegressor(lightgbm.sklearn.LGBMRegressor, _DaskLGBMModel)
| DaskLGBMRegressor(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
|
| Distributed version of lightgbm.LGBMRegressor.
|
| Method resolution order:
| DaskLGBMRegressor
| lightgbm.sklearn.LGBMRegressor
| sklearn.base.RegressorMixin
| lightgbm.sklearn.LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| _DaskLGBMModel
| builtins.object
|
| Methods defined here:
|
| __getstate__(self) -> Dict[Any, Any]
| Helper for pickle.
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, ForwardRef('np.random.Generator'), NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', client: Optional[ForwardRef('distributed.Client')] = None, **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
| client : distributed.Client or None, optional (default=None)
| Dask client.
| If ``None``, ``distributed.default_client()`` will be used at runtime.
| The Dask client used by this class will not be saved if the model object is pickled.
| **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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')], sample_weight: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, init_score: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series'), NoneType] = None, eval_set: Optional[List[Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_init_score: Optional[List[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.Series')]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, *, eval_X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')]], NoneType] = None, eval_y: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series'), Tuple[Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame'), ForwardRef('dask.dataframe.Series')]], NoneType] = None, **kwargs: Any) -> 'DaskLGBMRegressor'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : Dask Array, Dask DataFrame or Dask Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of Dask Array or Dask Series, or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of Dask Array or Dask Series, or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| **kwargs
| Other parameters passed through to ``LGBMRegressor.fit()``.
|
| Returns
| -------
| self : lightgbm.DaskLGBMRegressor
| Returns self.
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[ForwardRef('dask.array.Array'), ForwardRef('dask.dataframe.DataFrame')], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> 'dask.array.Array'
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : Dask Array or Dask DataFrame of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : Dask Array of shape = [n_samples]
| The predicted values.
| X_leaves : Dask Array of shape = [n_samples, n_trees]
| If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
| X_SHAP_values : Dask Array of shape = [n_samples, n_features + 1]
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_fit_request(self: lightgbm.dask.DaskLGBMRegressor, *, eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.dask.DaskLGBMRegressor, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.dask.DaskLGBMRegressor, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.dask.DaskLGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| to_local(self) -> lightgbm.sklearn.LGBMRegressor
| Create regular version of lightgbm.LGBMRegressor from the distributed version.
|
| Returns
| -------
| model : lightgbm.LGBMRegressor
| Local underlying model.
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMRegressor:
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.RegressorMixin:
|
| score(self, X, y, sample_weight=None)
| Return the coefficient of determination of the prediction.
|
| The coefficient of determination :math:`R^2` is defined as
| :math:`(1 - \frac{u}{v})`, where :math:`u` is the residual
| sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`
| is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.
| The best possible score is 1.0 and it can be negative (because the
| model can be arbitrarily worse). A constant model that always predicts
| the expected value of `y`, disregarding the input features, would get
| a :math:`R^2` score of 0.0.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples. For some estimators this may be a precomputed
| kernel matrix or a list of generic objects instead with shape
| ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``
| is the number of samples used in the fitting for the estimator.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True values for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| :math:`R^2` of ``self.predict(X)`` w.r.t. `y`.
|
| Notes
| -----
| The :math:`R^2` score used when calling ``score`` on a regressor uses
| ``multioutput='uniform_average'`` from version 0.23 to keep consistent
| with default value of :func:`~sklearn.metrics.r2_score`.
| This influences the ``score`` method of all the multioutput
| regressors (except for
| :class:`~sklearn.multioutput.MultiOutputRegressor`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.RegressorMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from lightgbm.sklearn.LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from lightgbm.sklearn.LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from lightgbm.sklearn.LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
|
| ----------------------------------------------------------------------
| Readonly properties inherited from _DaskLGBMModel:
|
| client_
| :obj:`distributed.Client`: Dask client.
|
| This property can be passed in the constructor or updated
| with ``model.set_params(client=client)``.
DATA
__all__ = ['DaskLGBMClassifier', 'DaskLGBMRanker', 'DaskLGBMRegressor'...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\dask.py
lightgbm.early_stopping
Python Library Documentation: function early_stopping in module lightgbm.callback
early_stopping(stopping_rounds: int, first_metric_only: bool = False, verbose: bool = True, min_delta: Union[float, List[float]] = 0.0) -> lightgbm.callback._EarlyStoppingCallback
Create a callback that activates early stopping.
Activates early stopping.
The model will train until the validation score doesn't improve by at least ``min_delta``.
Validation score needs to improve at least every ``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 ``first_metric_only`` to True.
The index of iteration that has the best performance will be saved in the ``best_iteration`` attribute of a model.
.. note::
If using ``boosting_type="dart"``, this callback has no effect and early stopping
will not be performed.
Parameters
----------
stopping_rounds : int
The possible number of rounds without the trend occurrence.
first_metric_only : bool, optional (default=False)
Whether to use only the first metric for early stopping.
verbose : bool, optional (default=True)
Whether to log message with early stopping information.
By default, standard output resource is used.
Use ``register_logger()`` function to register a custom logger.
min_delta : float or list of float, optional (default=0.0)
Minimum improvement in score to keep training.
If float, this single value is used for all metrics.
If list, its length should match the total number of metrics.
.. versionadded:: 4.0.0
Returns
-------
callback : _EarlyStoppingCallback
The callback that activates early stopping.
lightgbm.engine
Python Library Documentation: module lightgbm.engine in lightgbm
NAME
lightgbm.engine - Library with training routines of LightGBM.
CLASSES
builtins.object
CVBooster
class CVBooster(builtins.object)
| CVBooster(model_file: Union[str, pathlib.Path, NoneType] = None)
|
| CVBooster in LightGBM.
|
| Auxiliary data structure to hold and redirect all boosters of ``cv()`` function.
| This class has the same methods as Booster class.
| All method calls, except for the following methods, are actually performed for underlying Boosters and
| then all returned results are returned in a list.
|
| - ``model_from_string()``
| - ``model_to_string()``
| - ``save_model()``
|
| Attributes
| ----------
| boosters : list of Booster
| The list of underlying fitted models.
| best_iteration : int
| The best iteration of fitted model.
|
| Methods defined here:
|
| __getattr__(self, name: str) -> Callable[[Any, Any], List[Any]]
| Redirect methods call of CVBooster.
|
| __getstate__(self) -> Dict[str, Any]
| Helper for pickle.
|
| __init__(self, model_file: Union[str, pathlib.Path, NoneType] = None)
| Initialize the CVBooster.
|
| Parameters
| ----------
| model_file : str, pathlib.Path or None, optional (default=None)
| Path to the CVBooster model file.
|
| __setstate__(self, state: Dict[str, Any]) -> None
|
| model_from_string(self, model_str: str) -> 'CVBooster'
| Load CVBooster from a string.
|
| Parameters
| ----------
| model_str : str
| Model will be loaded from this string.
|
| Returns
| -------
| self : CVBooster
| Loaded CVBooster object.
|
| model_to_string(self, num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> str
| Save CVBooster to JSON string.
|
| Parameters
| ----------
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be saved.
| If None, if the best iteration exists, it is saved; otherwise, all iterations are saved.
| If <= 0, all iterations are saved.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be saved.
| importance_type : str, optional (default="split")
| What type of feature importance should be saved.
| 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.
|
| Returns
| -------
| str_repr : str
| JSON string representation of CVBooster.
|
| save_model(self, filename: Union[str, pathlib.Path], num_iteration: Optional[int] = None, start_iteration: int = 0, importance_type: str = 'split') -> 'CVBooster'
| Save CVBooster to a file as JSON text.
|
| Parameters
| ----------
| filename : str or pathlib.Path
| Filename to save CVBooster.
| num_iteration : int or None, optional (default=None)
| Index of the iteration that should be saved.
| If None, if the best iteration exists, it is saved; otherwise, all iterations are saved.
| If <= 0, all iterations are saved.
| start_iteration : int, optional (default=0)
| Start index of the iteration that should be saved.
| importance_type : str, optional (default="split")
| What type of feature importance should be saved.
| 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.
|
| Returns
| -------
| self : CVBooster
| Returns self.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
cv(params: Dict[str, Any], train_set: lightgbm.basic.Dataset, num_boost_round: int = 100, folds: Union[Iterable[Tuple[numpy.ndarray, numpy.ndarray]], sklearn.model_selection._split.BaseCrossValidator, NoneType] = None, nfold: int = 5, stratified: bool = True, shuffle: bool = True, metrics: Union[str, List[str], NoneType] = None, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, NoneType] = None, fpreproc: Optional[Callable[[lightgbm.basic.Dataset, lightgbm.basic.Dataset, Dict[str, Any]], Tuple[lightgbm.basic.Dataset, lightgbm.basic.Dataset, Dict[str, Any]]]] = None, seed: int = 0, callbacks: Optional[List[Callable]] = None, eval_train_metric: bool = False, return_cvbooster: bool = False) -> Dict[str, Union[List[float], lightgbm.engine.CVBooster]]
Perform the cross-validation with given parameters.
Parameters
----------
params : dict
Parameters for training. Values passed through ``params`` take precedence over those
supplied via arguments.
train_set : Dataset
Data to be trained on.
num_boost_round : int, optional (default=100)
Number of boosting iterations.
folds : generator or iterator of (train_idx, test_idx) tuples, scikit-learn splitter object or None, optional (default=None)
If generator or iterator, it should yield the train and test indices for each fold.
If object, it should be one of the scikit-learn splitter classes
(https://scikit-learn.org/stable/modules/classes.html#splitter-classes)
and have ``split`` method.
This argument has highest priority over other data split arguments.
nfold : int, optional (default=5)
Number of folds in CV.
stratified : bool, optional (default=True)
Whether to perform stratified sampling.
shuffle : bool, optional (default=True)
Whether to shuffle before splitting data.
metrics : str, list of str, or None, optional (default=None)
Evaluation metrics to be monitored while CV.
If not None, the metric in ``params`` will be overridden.
feval : callable, list of callable, or None, optional (default=None)
Customized evaluation function.
Each evaluation function should accept two parameters: preds, eval_data,
and return (metric_name, metric_value, maximize) or list of such tuples.
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
If custom objective function is used, predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task in this case.
eval_data : Dataset
A ``Dataset`` to evaluate.
metric_name : str
Unique identifier for the metric (e.g. "custom_adjusted_mse").
metric_value : float
Value of the evaluation metric.
maximize : bool
Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
To ignore the default metric corresponding to the used objective,
set ``metrics`` to the string ``"None"``.
init_model : str, pathlib.Path, Booster or None, optional (default=None)
Filename of LightGBM model or Booster instance used for continue training.
fpreproc : callable or None, optional (default=None)
Preprocessing function that takes (dtrain, dtest, params)
and returns transformed versions of those.
seed : int, optional (default=0)
Seed used to generate the folds (passed to numpy.random.seed).
callbacks : list of callable, or None, optional (default=None)
List of callback functions that are applied at each iteration.
See Callbacks in Python API for more information.
eval_train_metric : bool, optional (default=False)
Whether to display the train metric in progress.
The score of the metric is calculated again after each training step, so there is some impact on performance.
return_cvbooster : bool, optional (default=False)
Whether to return Booster models trained on each fold through ``CVBooster``.
Note
----
A custom objective function can be provided for the ``objective`` parameter.
It should accept two parameters: preds, train_data and return (grad, hess).
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
Predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task.
train_data : Dataset
The training dataset.
grad : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the first order derivative (gradient) of the loss
with respect to the elements of preds for each sample point.
hess : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the second order derivative (Hessian) of the loss
with respect to the elements of preds for each sample point.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes],
and grad and hess should be returned in the same format.
Returns
-------
eval_results : dict
History of evaluation results of each metric.
The dictionary has the following format:
{'valid metric1-mean': [values], 'valid metric1-stdv': [values],
'valid metric2-mean': [values], 'valid metric2-stdv': [values],
...}.
If ``return_cvbooster=True``, also returns trained boosters wrapped in a ``CVBooster`` object via ``cvbooster`` key.
If ``eval_train_metric=True``, also returns the train metric history.
In this case, the dictionary has the following format:
{'train metric1-mean': [values], 'valid metric1-mean': [values],
'train metric2-mean': [values], 'valid metric2-mean': [values],
...}.
train(params: Dict[str, Any], train_set: lightgbm.basic.Dataset, num_boost_round: int = 100, valid_sets: Optional[List[lightgbm.basic.Dataset]] = None, valid_names: Optional[List[str]] = None, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, NoneType] = None, keep_training_booster: bool = False, callbacks: Optional[List[Callable]] = None) -> lightgbm.basic.Booster
Perform the training with given parameters.
Parameters
----------
params : dict
Parameters for training. Values passed through ``params`` take precedence over those
supplied via arguments.
train_set : Dataset
Data to be trained on.
num_boost_round : int, optional (default=100)
Number of boosting iterations.
valid_sets : list of Dataset, or None, optional (default=None)
List of data to be evaluated on during training.
valid_names : list of str, or None, optional (default=None)
Names of ``valid_sets``.
feval : callable, list of callable, or None, optional (default=None)
Customized evaluation function.
Each evaluation function should accept two parameters: preds, eval_data,
and return (metric_name, metric_value, maximize) or list of such tuples.
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
If custom objective function is used, predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task in this case.
eval_data : Dataset
A ``Dataset`` to evaluate.
metric_name : str
Unique identifier for the metric (e.g. "custom_adjusted_mse").
metric_value : float
Value of the evaluation metric.
maximize : bool
Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
To ignore the default metric corresponding to the used objective,
set the ``metric`` parameter to the string ``"None"`` in ``params``.
init_model : str, pathlib.Path, Booster or None, optional (default=None)
Filename of LightGBM model or Booster instance used for continue training.
keep_training_booster : bool, optional (default=False)
Whether the returned Booster will be used to keep training.
If False, the returned value will be converted into _InnerPredictor before returning.
This means you won't be able to use ``eval``, ``eval_train`` or ``eval_valid`` methods of the returned Booster.
When your model is very large and cause the memory error,
you can try to set this param to ``True`` to avoid the model conversion performed during the internal call of ``model_to_string``.
You can still use _InnerPredictor as ``init_model`` for future continue training.
callbacks : list of callable, or None, optional (default=None)
List of callback functions that are applied at each iteration.
See Callbacks in Python API for more information.
Note
----
A custom objective function can be provided for the ``objective`` parameter.
It should accept two parameters: preds, train_data and return (grad, hess).
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
Predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task.
train_data : Dataset
The training dataset.
grad : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the first order derivative (gradient) of the loss
with respect to the elements of preds for each sample point.
hess : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the second order derivative (Hessian) of the loss
with respect to the elements of preds for each sample point.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes],
and grad and hess should be returned in the same format.
Returns
-------
booster : Booster
The trained Booster model.
DATA
__all__ = ['cv', 'CVBooster', 'train']
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\engine.py
lightgbm.libpath
Python Library Documentation: module lightgbm.libpath in lightgbm
NAME
lightgbm.libpath - Find the path to LightGBM dynamic library files.
DATA
__all__ = []
__annotations__ = {'_LIB': <class 'ctypes.CDLL'>, '__all__': typing.Li...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\libpath.py
lightgbm.log_evaluation
Python Library Documentation: function log_evaluation in module lightgbm.callback
log_evaluation(period: int = 1, show_stdv: bool = True) -> lightgbm.callback._LogEvaluationCallback
Create a callback that logs the evaluation results.
By default, standard output resource is used.
Use ``register_logger()`` function to register a custom logger.
Note
----
Requires at least one validation data.
Parameters
----------
period : int, optional (default=1)
The period to log the evaluation results.
The last boosting stage or the boosting stage found by using ``early_stopping`` callback is also logged.
show_stdv : bool, optional (default=True)
Whether to log stdv (if provided).
Returns
-------
callback : _LogEvaluationCallback
The callback that logs the evaluation results every ``period`` boosting iteration(s).
lightgbm.plot_importance
Python Library Documentation: function plot_importance in module lightgbm.plotting
plot_importance(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], ax: 'Optional[matplotlib.axes.Axes]' = None, height: float = 0.2, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None, title: Optional[str] = 'Feature importance', xlabel: Optional[str] = 'Feature importance', ylabel: Optional[str] = 'Features', importance_type: str = 'auto', max_num_features: Optional[int] = None, ignore_zero: bool = True, figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, grid: bool = True, precision: Optional[int] = 3, **kwargs: Any) -> Any
Plot model's feature importances.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance which feature importance should be plotted.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
height : float, optional (default=0.2)
Bar height, passed to ``ax.barh()``.
xlim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.xlim()``.
ylim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.ylim()``.
title : str or None, optional (default="Feature importance")
Axes title.
If None, title is disabled.
xlabel : str or None, optional (default="Feature importance")
X-axis title label.
If None, title is disabled.
@importance_type@ placeholder can be used, and it will be replaced with the value of ``importance_type`` parameter.
ylabel : str or None, optional (default="Features")
Y-axis title label.
If None, title is disabled.
importance_type : str, optional (default="auto")
How the importance is calculated.
If "auto", if ``booster`` parameter is LGBMModel, ``booster.importance_type`` attribute is used; "split" otherwise.
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.
max_num_features : int or None, optional (default=None)
Max number of top features displayed on plot.
If None or <1, all features will be displayed.
ignore_zero : bool, optional (default=True)
Whether to ignore features with zero importance.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
grid : bool, optional (default=True)
Whether to add a grid for axes.
precision : int or None, optional (default=3)
Used to restrict the display of floating point values to a certain precision.
**kwargs
Other parameters passed to ``ax.barh()``.
Returns
-------
ax : matplotlib.axes.Axes
The plot with model's feature importances.
lightgbm.plot_metric
Python Library Documentation: function plot_metric in module lightgbm.plotting
plot_metric(booster: Union[Dict, lightgbm.sklearn.LGBMModel], metric: Optional[str] = None, dataset_names: Optional[List[str]] = None, ax: 'Optional[matplotlib.axes.Axes]' = None, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None, title: Optional[str] = 'Metric during training', xlabel: Optional[str] = 'Iterations', ylabel: Optional[str] = '@metric@', figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, grid: bool = True) -> Any
Plot one metric during training.
Parameters
----------
booster : dict or LGBMModel
Dictionary returned from ``lightgbm.train()`` or LGBMModel instance.
metric : str or None, optional (default=None)
The metric name to plot.
Only one metric supported because different metrics have various scales.
If None, first metric picked from dictionary (according to hashcode).
dataset_names : list of str, or None, optional (default=None)
List of the dataset names which are used to calculate metric to plot.
If None, all datasets are used.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
xlim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.xlim()``.
ylim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.ylim()``.
title : str or None, optional (default="Metric during training")
Axes title.
If None, title is disabled.
xlabel : str or None, optional (default="Iterations")
X-axis title label.
If None, title is disabled.
ylabel : str or None, optional (default="@metric@")
Y-axis title label.
If 'auto', metric name is used.
If None, title is disabled.
@metric@ placeholder can be used, and it will be replaced with metric name.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
grid : bool, optional (default=True)
Whether to add a grid for axes.
Returns
-------
ax : matplotlib.axes.Axes
The plot with metric's history over the training.
lightgbm.plot_split_value_histogram
Python Library Documentation: function plot_split_value_histogram in module lightgbm.plotting
plot_split_value_histogram(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], feature: Union[int, str], bins: Union[int, str, NoneType] = None, ax: 'Optional[matplotlib.axes.Axes]' = None, width_coef: float = 0.8, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None, title: Optional[str] = 'Split value histogram for feature with @index/name@ @feature@', xlabel: Optional[str] = 'Feature split value', ylabel: Optional[str] = 'Count', figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, grid: bool = True, **kwargs: Any) -> Any
Plot split value histogram for the specified feature of the model.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance of which feature split value histogram should be plotted.
feature : int or str
The feature name or index the histogram is plotted for.
If int, interpreted as index.
If str, interpreted as name.
bins : int, str or None, optional (default=None)
The maximum number of bins.
If None, the number of bins equals number of unique split values.
If str, it should be one from the list of the supported values by ``numpy.histogram()`` function.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
width_coef : float, optional (default=0.8)
Coefficient for histogram bar width.
xlim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.xlim()``.
ylim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.ylim()``.
title : str or None, optional (default="Split value histogram for feature with @index/name@ @feature@")
Axes title.
If None, title is disabled.
@feature@ placeholder can be used, and it will be replaced with the value of ``feature`` parameter.
@index/name@ placeholder can be used,
and it will be replaced with ``index`` word in case of ``int`` type ``feature`` parameter
or ``name`` word in case of ``str`` type ``feature`` parameter.
xlabel : str or None, optional (default="Feature split value")
X-axis title label.
If None, title is disabled.
ylabel : str or None, optional (default="Count")
Y-axis title label.
If None, title is disabled.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
grid : bool, optional (default=True)
Whether to add a grid for axes.
**kwargs
Other parameters passed to ``ax.bar()``.
Returns
-------
ax : matplotlib.axes.Axes
The plot with specified model's feature split value histogram.
lightgbm.plot_tree
Python Library Documentation: function plot_tree in module lightgbm.plotting
plot_tree(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], ax: 'Optional[matplotlib.axes.Axes]' = None, tree_index: int = 0, figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, show_info: Optional[List[str]] = None, precision: Optional[int] = 3, orientation: str = 'horizontal', example_case: Union[numpy.ndarray, pandas.core.frame.DataFrame, NoneType] = None, **kwargs: Any) -> Any
Plot specified tree.
Each node in the graph represents a node in the tree.
Non-leaf nodes have labels like ``Column_10 <= 875.9``, which means
"this node splits on the feature named "Column_10", with threshold 875.9".
Leaf nodes have labels like ``leaf 2: 0.422``, which means "this node is a
leaf node, and the predicted value for records that fall into this node
is 0.422". The number (``2``) is an internal unique identifier and doesn't
have any special meaning.
.. note::
It is preferable to use ``create_tree_digraph()`` because of its lossless quality
and returned objects can be also rendered and displayed directly inside a Jupyter notebook.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance to be plotted.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
tree_index : int, optional (default=0)
The index of a target tree to plot.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
show_info : list of str, or None, optional (default=None)
What information should be shown in nodes.
- ``'split_gain'`` : gain from adding this split to the model
- ``'internal_value'`` : raw predicted value that would be produced by this node if it was a leaf node
- ``'internal_count'`` : number of records from the training data that fall into this non-leaf node
- ``'internal_weight'`` : total weight of all nodes that fall into this non-leaf node
- ``'leaf_count'`` : number of records from the training data that fall into this leaf node
- ``'leaf_weight'`` : total weight (sum of Hessian) of all observations that fall into this leaf node
- ``'data_percentage'`` : percentage of training data that fall into this node
precision : int or None, optional (default=3)
Used to restrict the display of floating point values to a certain precision.
orientation : str, optional (default='horizontal')
Orientation of the tree.
Can be 'horizontal' or 'vertical'.
example_case : numpy 2-D array, pandas DataFrame or None, optional (default=None)
Single row with the same structure as the training data.
If not None, the plot will highlight the path that sample takes through the tree.
.. versionadded:: 4.0.0
**kwargs
Other parameters passed to ``Digraph`` constructor.
Check https://graphviz.readthedocs.io/en/stable/api.html#digraph for the full list of supported parameters.
Returns
-------
ax : matplotlib.axes.Axes
The plot with single tree.
lightgbm.plotting
Python Library Documentation: module lightgbm.plotting in lightgbm
NAME
lightgbm.plotting - Plotting library.
FUNCTIONS
create_tree_digraph(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], tree_index: int = 0, show_info: Optional[List[str]] = None, precision: Optional[int] = 3, orientation: str = 'horizontal', example_case: Union[numpy.ndarray, pandas.core.frame.DataFrame, NoneType] = None, max_category_values: int = 10, **kwargs: Any) -> Any
Create a digraph representation of specified tree.
Each node in the graph represents a node in the tree.
Non-leaf nodes have labels like ``Column_10 <= 875.9``, which means
"this node splits on the feature named "Column_10", with threshold 875.9".
Leaf nodes have labels like ``leaf 2: 0.422``, which means "this node is a
leaf node, and the predicted value for records that fall into this node
is 0.422". The number (``2``) is an internal unique identifier and doesn't
have any special meaning.
.. note::
For more information please visit
https://graphviz.readthedocs.io/en/stable/api.html#digraph.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance to be converted.
tree_index : int, optional (default=0)
The index of a target tree to convert.
show_info : list of str, or None, optional (default=None)
What information should be shown in nodes.
- ``'split_gain'`` : gain from adding this split to the model
- ``'internal_value'`` : raw predicted value that would be produced by this node if it was a leaf node
- ``'internal_count'`` : number of records from the training data that fall into this non-leaf node
- ``'internal_weight'`` : total weight of all nodes that fall into this non-leaf node
- ``'leaf_count'`` : number of records from the training data that fall into this leaf node
- ``'leaf_weight'`` : total weight (sum of Hessian) of all observations that fall into this leaf node
- ``'data_percentage'`` : percentage of training data that fall into this node
precision : int or None, optional (default=3)
Used to restrict the display of floating point values to a certain precision.
orientation : str, optional (default='horizontal')
Orientation of the tree.
Can be 'horizontal' or 'vertical'.
example_case : numpy 2-D array, pandas DataFrame or None, optional (default=None)
Single row with the same structure as the training data.
If not None, the plot will highlight the path that sample takes through the tree.
.. versionadded:: 4.0.0
max_category_values : int, optional (default=10)
The maximum number of category values to display in tree nodes, if the number of thresholds is greater than this value, thresholds will be collapsed and displayed on the label tooltip instead.
.. warning::
Consider wrapping the SVG string of the tree graph with ``IPython.display.HTML`` when running on JupyterLab to get the `tooltip <https://graphviz.org/docs/attrs/tooltip>`_ working right.
Example:
.. code-block:: python
from IPython.display import HTML
graph = lgb.create_tree_digraph(clf, max_category_values=5)
HTML(graph._repr_image_svg_xml())
.. versionadded:: 4.0.0
**kwargs
Other parameters passed to ``Digraph`` constructor.
Check https://graphviz.readthedocs.io/en/stable/api.html#digraph for the full list of supported parameters.
Returns
-------
graph : graphviz.Digraph
The digraph representation of specified tree.
plot_importance(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], ax: 'Optional[matplotlib.axes.Axes]' = None, height: float = 0.2, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None, title: Optional[str] = 'Feature importance', xlabel: Optional[str] = 'Feature importance', ylabel: Optional[str] = 'Features', importance_type: str = 'auto', max_num_features: Optional[int] = None, ignore_zero: bool = True, figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, grid: bool = True, precision: Optional[int] = 3, **kwargs: Any) -> Any
Plot model's feature importances.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance which feature importance should be plotted.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
height : float, optional (default=0.2)
Bar height, passed to ``ax.barh()``.
xlim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.xlim()``.
ylim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.ylim()``.
title : str or None, optional (default="Feature importance")
Axes title.
If None, title is disabled.
xlabel : str or None, optional (default="Feature importance")
X-axis title label.
If None, title is disabled.
@importance_type@ placeholder can be used, and it will be replaced with the value of ``importance_type`` parameter.
ylabel : str or None, optional (default="Features")
Y-axis title label.
If None, title is disabled.
importance_type : str, optional (default="auto")
How the importance is calculated.
If "auto", if ``booster`` parameter is LGBMModel, ``booster.importance_type`` attribute is used; "split" otherwise.
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.
max_num_features : int or None, optional (default=None)
Max number of top features displayed on plot.
If None or <1, all features will be displayed.
ignore_zero : bool, optional (default=True)
Whether to ignore features with zero importance.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
grid : bool, optional (default=True)
Whether to add a grid for axes.
precision : int or None, optional (default=3)
Used to restrict the display of floating point values to a certain precision.
**kwargs
Other parameters passed to ``ax.barh()``.
Returns
-------
ax : matplotlib.axes.Axes
The plot with model's feature importances.
plot_metric(booster: Union[Dict, lightgbm.sklearn.LGBMModel], metric: Optional[str] = None, dataset_names: Optional[List[str]] = None, ax: 'Optional[matplotlib.axes.Axes]' = None, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None, title: Optional[str] = 'Metric during training', xlabel: Optional[str] = 'Iterations', ylabel: Optional[str] = '@metric@', figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, grid: bool = True) -> Any
Plot one metric during training.
Parameters
----------
booster : dict or LGBMModel
Dictionary returned from ``lightgbm.train()`` or LGBMModel instance.
metric : str or None, optional (default=None)
The metric name to plot.
Only one metric supported because different metrics have various scales.
If None, first metric picked from dictionary (according to hashcode).
dataset_names : list of str, or None, optional (default=None)
List of the dataset names which are used to calculate metric to plot.
If None, all datasets are used.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
xlim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.xlim()``.
ylim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.ylim()``.
title : str or None, optional (default="Metric during training")
Axes title.
If None, title is disabled.
xlabel : str or None, optional (default="Iterations")
X-axis title label.
If None, title is disabled.
ylabel : str or None, optional (default="@metric@")
Y-axis title label.
If 'auto', metric name is used.
If None, title is disabled.
@metric@ placeholder can be used, and it will be replaced with metric name.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
grid : bool, optional (default=True)
Whether to add a grid for axes.
Returns
-------
ax : matplotlib.axes.Axes
The plot with metric's history over the training.
plot_split_value_histogram(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], feature: Union[int, str], bins: Union[int, str, NoneType] = None, ax: 'Optional[matplotlib.axes.Axes]' = None, width_coef: float = 0.8, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None, title: Optional[str] = 'Split value histogram for feature with @index/name@ @feature@', xlabel: Optional[str] = 'Feature split value', ylabel: Optional[str] = 'Count', figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, grid: bool = True, **kwargs: Any) -> Any
Plot split value histogram for the specified feature of the model.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance of which feature split value histogram should be plotted.
feature : int or str
The feature name or index the histogram is plotted for.
If int, interpreted as index.
If str, interpreted as name.
bins : int, str or None, optional (default=None)
The maximum number of bins.
If None, the number of bins equals number of unique split values.
If str, it should be one from the list of the supported values by ``numpy.histogram()`` function.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
width_coef : float, optional (default=0.8)
Coefficient for histogram bar width.
xlim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.xlim()``.
ylim : tuple of 2 elements or None, optional (default=None)
Tuple passed to ``ax.ylim()``.
title : str or None, optional (default="Split value histogram for feature with @index/name@ @feature@")
Axes title.
If None, title is disabled.
@feature@ placeholder can be used, and it will be replaced with the value of ``feature`` parameter.
@index/name@ placeholder can be used,
and it will be replaced with ``index`` word in case of ``int`` type ``feature`` parameter
or ``name`` word in case of ``str`` type ``feature`` parameter.
xlabel : str or None, optional (default="Feature split value")
X-axis title label.
If None, title is disabled.
ylabel : str or None, optional (default="Count")
Y-axis title label.
If None, title is disabled.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
grid : bool, optional (default=True)
Whether to add a grid for axes.
**kwargs
Other parameters passed to ``ax.bar()``.
Returns
-------
ax : matplotlib.axes.Axes
The plot with specified model's feature split value histogram.
plot_tree(booster: Union[lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel], ax: 'Optional[matplotlib.axes.Axes]' = None, tree_index: int = 0, figsize: Optional[Tuple[float, float]] = None, dpi: Optional[int] = None, show_info: Optional[List[str]] = None, precision: Optional[int] = 3, orientation: str = 'horizontal', example_case: Union[numpy.ndarray, pandas.core.frame.DataFrame, NoneType] = None, **kwargs: Any) -> Any
Plot specified tree.
Each node in the graph represents a node in the tree.
Non-leaf nodes have labels like ``Column_10 <= 875.9``, which means
"this node splits on the feature named "Column_10", with threshold 875.9".
Leaf nodes have labels like ``leaf 2: 0.422``, which means "this node is a
leaf node, and the predicted value for records that fall into this node
is 0.422". The number (``2``) is an internal unique identifier and doesn't
have any special meaning.
.. note::
It is preferable to use ``create_tree_digraph()`` because of its lossless quality
and returned objects can be also rendered and displayed directly inside a Jupyter notebook.
Parameters
----------
booster : Booster or LGBMModel
Booster or LGBMModel instance to be plotted.
ax : matplotlib.axes.Axes or None, optional (default=None)
Target axes instance.
If None, new figure and axes will be created.
tree_index : int, optional (default=0)
The index of a target tree to plot.
figsize : tuple of 2 elements or None, optional (default=None)
Figure size.
dpi : int or None, optional (default=None)
Resolution of the figure.
show_info : list of str, or None, optional (default=None)
What information should be shown in nodes.
- ``'split_gain'`` : gain from adding this split to the model
- ``'internal_value'`` : raw predicted value that would be produced by this node if it was a leaf node
- ``'internal_count'`` : number of records from the training data that fall into this non-leaf node
- ``'internal_weight'`` : total weight of all nodes that fall into this non-leaf node
- ``'leaf_count'`` : number of records from the training data that fall into this leaf node
- ``'leaf_weight'`` : total weight (sum of Hessian) of all observations that fall into this leaf node
- ``'data_percentage'`` : percentage of training data that fall into this node
precision : int or None, optional (default=3)
Used to restrict the display of floating point values to a certain precision.
orientation : str, optional (default='horizontal')
Orientation of the tree.
Can be 'horizontal' or 'vertical'.
example_case : numpy 2-D array, pandas DataFrame or None, optional (default=None)
Single row with the same structure as the training data.
If not None, the plot will highlight the path that sample takes through the tree.
.. versionadded:: 4.0.0
**kwargs
Other parameters passed to ``Digraph`` constructor.
Check https://graphviz.readthedocs.io/en/stable/api.html#digraph for the full list of supported parameters.
Returns
-------
ax : matplotlib.axes.Axes
The plot with single tree.
DATA
__all__ = ['create_tree_digraph', 'plot_importance', 'plot_metric', 'p...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\plotting.py
lightgbm.record_evaluation
Python Library Documentation: function record_evaluation in module lightgbm.callback
record_evaluation(eval_result: Dict[str, Dict[str, List[Any]]]) -> Callable
Create a callback that records the evaluation history into ``eval_result``.
Parameters
----------
eval_result : dict
Dictionary used to store all evaluation results of all validation sets.
This should be initialized outside of your call to ``record_evaluation()`` and should be empty.
Any initial contents of the dictionary will be deleted.
.. rubric:: Example
With two validation sets named 'eval' and 'train', and one evaluation metric named 'logloss'
this dictionary after finishing a model training process will have the following structure:
.. code-block::
{
'train':
{
'logloss': [0.48253, 0.35953, ...]
},
'eval':
{
'logloss': [0.480385, 0.357756, ...]
}
}
Returns
-------
callback : _RecordEvaluationCallback
The callback that records the evaluation history into the passed dictionary.
lightgbm.register_logger
Python Library Documentation: function register_logger in module lightgbm.basic
register_logger(logger: Any, info_method_name: str = 'info', warning_method_name: str = 'warning') -> None
Register custom logger.
Parameters
----------
logger : Any
Custom logger.
info_method_name : str, optional (default="info")
Method used to log info messages.
warning_method_name : str, optional (default="warning")
Method used to log warning messages.
lightgbm.reset_parameter
Python Library Documentation: function reset_parameter in module lightgbm.callback
reset_parameter(**kwargs: Union[list, Callable]) -> Callable
Create a callback that resets the parameter after the first iteration.
.. note::
The initial parameter will still take in-effect on first iteration.
Parameters
----------
**kwargs : value should be list or callable
List of parameters for each boosting round
or a callable that calculates the parameter in terms of
current number of round (e.g. yields learning rate decay).
If list lst, parameter = lst[current_round].
If callable func, parameter = func(current_round).
Returns
-------
callback : _ResetParameterCallback
The callback that resets the parameter after the first iteration.
lightgbm.sklearn
Python Library Documentation: module lightgbm.sklearn in lightgbm
NAME
lightgbm.sklearn - Scikit-learn wrapper interface for LightGBM.
CLASSES
sklearn.base.BaseEstimator(sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin, sklearn.utils._metadata_requests._MetadataRequester)
LGBMModel
LGBMClassifier(sklearn.base.ClassifierMixin, LGBMModel)
LGBMRanker
LGBMRegressor(sklearn.base.RegressorMixin, LGBMModel)
sklearn.base.ClassifierMixin(builtins.object)
LGBMClassifier(sklearn.base.ClassifierMixin, LGBMModel)
sklearn.base.RegressorMixin(builtins.object)
LGBMRegressor(sklearn.base.RegressorMixin, LGBMModel)
class LGBMClassifier(sklearn.base.ClassifierMixin, LGBMModel)
| LGBMClassifier(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
|
| LightGBM classifier.
|
| Method resolution order:
| LGBMClassifier
| sklearn.base.ClassifierMixin
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| decision_function(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], *, start_iteration: int = 0, num_iteration: Optional[int] = None, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the raw margin score for each sample.
|
| .. versionadded:: 4.7.0
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` are used (no limits).
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters forwarded to ``predict()``.
|
| Returns
| -------
| raw_score : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_class_weight: Optional[List[float]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel, NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMClassifier'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_class_weight : list or None, optional (default=None)
| Class weights of eval data.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMClassifier
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| predict_proba(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted probability for each class for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_probability : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_decision_function_request(self: lightgbm.sklearn.LGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``decision_function`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``decision_function`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``decision_function``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``decision_function``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``decision_function``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``decision_function``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_fit_request(self: lightgbm.sklearn.LGBMClassifier, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_class_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_class_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_class_weight`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_proba_request(self: lightgbm.sklearn.LGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict_proba`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict_proba`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict_proba``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict_proba``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict_proba``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict_proba``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict_proba``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict_proba``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict_proba``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.sklearn.LGBMClassifier, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.sklearn.LGBMClassifier, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMClassifier from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| classes_
| :obj:`array` of shape = [n_classes]: The class label array.
|
| n_classes_
| :obj:`int`: The number of classes.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.ClassifierMixin:
|
| score(self, X, y, sample_weight=None)
| Return the mean accuracy on the given test data and labels.
|
| In multi-label classification, this is the subset accuracy
| which is a harsh metric since you require for each sample that
| each label set be correctly predicted.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True labels for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| Mean accuracy of ``self.predict(X)`` w.r.t. `y`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.ClassifierMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
class LGBMModel(sklearn.base.BaseEstimator)
| LGBMModel(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any)
|
| Implementation of the scikit-learn API for LightGBM.
|
| Method resolution order:
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any)
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| __sklearn_is_fitted__(self) -> bool
|
| __sklearn_tags__(self) -> Optional[ForwardRef('_sklearn_Tags')]
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_class_weight: Optional[List[float]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_group: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, ForwardRef('LGBMModel'), NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMModel'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : numpy array, pandas Series, pyarrow ChunkedArray, polars Series, list of int or float, or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_class_weight : list or None, optional (default=None)
| Class weights of eval data.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_group : list of array (same types as ``group`` supports), or None, optional (default=None)
| Group data of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMModel
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_fit_request(self: lightgbm.sklearn.LGBMModel, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_class_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_group: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', group: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMModel from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_class_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_class_weight`` parameter in ``fit``.
|
| eval_group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_group`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``group`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| set_predict_request(self: lightgbm.sklearn.LGBMModel, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMModel from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
class LGBMRanker(LGBMModel)
| LGBMRanker(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
|
| LightGBM ranker.
|
| .. warning::
|
| scikit-learn doesn't support ranking applications yet,
| therefore this class is not really compatible with the sklearn ecosystem.
| Please use this class mainly for training and applying ranking models in common sklearnish way.
|
| Method resolution order:
| LGBMRanker
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, group: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_group: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, eval_at: Union[List[int], Tuple[int, ...]] = (1, 2, 3, 4, 5), feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel, NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMRanker'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| group : numpy array, pandas Series, pyarrow ChunkedArray, polars Series, list of int or float, or None, optional (default=None)
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_group : list of array (same types as ``group`` supports), or None, optional (default=None)
| Group data of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| eval_at : list or tuple of int, optional (default=(1, 2, 3, 4, 5))
| The evaluation positions of the specified metric.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMRanker
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| set_fit_request(self: lightgbm.sklearn.LGBMRanker, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_at: Union[bool, NoneType, str] = '$UNCHANGED$', eval_group: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', group: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_at : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_at`` parameter in ``fit``.
|
| eval_group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_group`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| group : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``group`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.sklearn.LGBMRanker, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRanker from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Methods inherited from LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| __sklearn_tags__(self) -> Optional[ForwardRef('_sklearn_Tags')]
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
class LGBMRegressor(sklearn.base.RegressorMixin, LGBMModel)
| LGBMRegressor(*, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
|
| LightGBM regressor.
|
| Method resolution order:
| LGBMRegressor
| sklearn.base.RegressorMixin
| LGBMModel
| sklearn.base.BaseEstimator
| sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin
| sklearn.utils._metadata_requests._MetadataRequester
| builtins.object
|
| Methods defined here:
|
| __init__(self, *, boosting_type: str = 'gbdt', num_leaves: int = 31, max_depth: int = -1, learning_rate: float = 0.1, n_estimators: int = 100, subsample_for_bin: int = 200000, objective: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[numpy.ndarray, numpy.ndarray]], NoneType] = None, class_weight: Union[Dict, str, NoneType] = None, min_split_gain: float = 0.0, min_child_weight: float = 0.001, min_child_samples: int = 20, subsample: float = 1.0, subsample_freq: int = 0, colsample_bytree: float = 1.0, reg_alpha: float = 0.0, reg_lambda: float = 0.0, random_state: Union[int, numpy.random.mtrand.RandomState, numpy.random._generator.Generator, NoneType] = None, n_jobs: Optional[int] = None, importance_type: str = 'split', **kwargs: Any) -> None
| Construct a gradient boosting model.
|
| Parameters
| ----------
| boosting_type : str, optional (default='gbdt')
| 'gbdt', traditional Gradient Boosting Decision Tree.
| 'dart', Dropouts meet Multiple Additive Regression Trees.
| '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.
| If setting this to a positive value, consider also changing ``num_leaves`` to ``<= 2^max_depth``.
| learning_rate : float, optional (default=0.1)
| Boosting learning rate.
| You can use ``callbacks`` parameter of ``fit`` method to shrink/adapt learning rate
| in training using ``reset_parameter`` callback.
| Note, that this will ignore the ``learning_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 : str, 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 multi-class classification task;
| for binary classification task you may use ``is_unbalance`` or ``scale_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://scikit-learn.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 as ``n_samples / (n_classes * np.bincount(y))``.
| If None, all classes are supposed to have weight one.
| Note, that these weights will be multiplied with ``sample_weight`` (passed through the ``fit`` method)
| if ``sample_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=1e-3)
| 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)
| Frequency 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, RandomState object or None, optional (default=None)
| Random number seed.
| If int, this number is used to seed the C++ code.
| If RandomState or Generator object (numpy), a random integer is picked based on its state to seed the C++ code.
| If None, default seeds in C++ code are used.
| n_jobs : int or None, optional (default=None)
| Number of parallel threads to use for training (can be changed at prediction time by
| passing it as an extra keyword argument).
|
| For better performance, it is recommended to set this to the number of physical cores
| in the CPU.
|
| Negative integers are interpreted as following joblib's formula (n_cpus + 1 + n_jobs), just like
| scikit-learn (so e.g. -1 means using all threads). A value of zero corresponds the default number of
| threads configured for OpenMP in the system. A value of ``None`` (the default) corresponds
| to using the number of physical cores in the system (its correct detection requires
| either the ``joblib`` or the ``psutil`` util libraries to be installed).
|
| .. versionchanged:: 4.0.0
|
| importance_type : str, 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.
|
| Note
| ----
| A custom objective function can be provided for the ``objective`` parameter.
| In this case, it should have the signature
| ``objective(y_true, y_pred) -> grad, hess``,
| ``objective(y_true, y_pred, weight) -> grad, hess``
| or ``objective(y_true, y_pred, weight, group) -> grad, hess``:
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| Predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| grad : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the first order derivative (gradient) of the loss
| with respect to the elements of y_pred for each sample point.
| hess : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The value of the second order derivative (Hessian) of the loss
| with respect to the elements of y_pred for each sample point.
|
| For multi-class task, y_pred is a numpy 2-D array of shape = [n_samples, n_classes],
| and grad and hess should be returned in the same format.
|
| __sklearn_tags__(self) -> '_sklearn_Tags'
|
| fit(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame], sample_weight: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries, NoneType] = None, init_score: Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, NoneType] = None, eval_set: Optional[List[Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]]] = None, eval_names: Optional[List[str]] = None, eval_sample_weight: Optional[List[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, narwhals._native.NativeSeries]]] = None, eval_init_score: Optional[List[Union[List[float], List[List[float]], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]]] = None, eval_metric: Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], List[Union[str, Callable[[Optional[numpy.ndarray], numpy.ndarray], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray]], List[Tuple[str, float, bool]]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], Tuple[str, float, bool]], Callable[[Optional[numpy.ndarray], numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray]], List[Tuple[str, float, bool]]]]], NoneType] = None, feature_name: Union[List[str], ForwardRef("Literal['auto']")] = 'auto', categorical_feature: Union[List[str], List[int], ForwardRef("Literal['auto']")] = 'auto', callbacks: Optional[List[Callable]] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, lightgbm.sklearn.LGBMModel, NoneType] = None, *, eval_X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix, Tuple[Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix]], NoneType] = None, eval_y: Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame, Tuple[Union[List[float], List[int], numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame, narwhals._native.NativeSeries, narwhals._native.NativeDataFrame]], NoneType] = None) -> 'LGBMRegressor'
| Build a gradient boosting model from the training set (X, y).
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input feature matrix.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples]
| The target values (class labels in classification, real numbers in regression).
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| sample_weight : numpy array, pandas Series, list of int or float, pyarrow ChunkedArray, polars Series of shape = [n_samples] or None, optional (default=None)
| Weights of training data. Weights should be non-negative.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| init_score : numpy array, pandas DataFrame, pandas Series, list of int or float, list of lists, pyarrow ChunkedArray, pyarrow Table, polars Series, polars DataFrame of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task) or shape = [n_samples, n_classes] (for multi-class task) or None, optional (default=None)
| Init score of training data.
|
| .. versionadded:: 4.2.0
| Support for ``pyarrow`` inputs
|
| .. versionadded:: 4.7.0
| Support for ``polars`` inputs
|
| eval_set : list or None, optional (default=None)
| .. deprecated:: 4.7.0
| A list of (X, y) tuple pairs to use as validation sets.
| Use ``eval_X`` and ``eval_y`` instead.
| eval_names : list of str, or None, optional (default=None)
| Unique identifiers for each evaluation dataset.
| Should be the same length as ``eval_set`` / ``eval_X``.
| eval_sample_weight : list of array (same types as ``sample_weight`` supports), or None, optional (default=None)
| Weights of eval data. Weights should be non-negative.
| eval_init_score : list of array (same types as ``init_score`` supports), or None, optional (default=None)
| Init score of eval data.
| eval_metric : str, callable, list or None, optional (default=None)
| If str, it should be a built-in evaluation metric to use.
| If callable, it should be a custom evaluation metric, see note below for more details.
| If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both.
| 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.
| feature_name : list of str, or 'auto', optional (default='auto')
| Feature names.
| If 'auto' and data is pandas DataFrame, data columns names are used.
| categorical_feature : list of str or int, or 'auto', optional (default='auto')
| Categorical features.
| If list of int, interpreted as indices.
| If list of str, 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 will be cast to int32 and thus 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.
| Floating point numbers in categorical features will be rounded towards 0.
| callbacks : list of callable, 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 : str, pathlib.Path, Booster, LGBMModel or None, optional (default=None)
| Filename of LightGBM model, Booster instance or LGBMModel instance used for continue training.
| eval_X : numpy array, pandas DataFrame, pyarrow Table, polars DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features], or tuple of such inputs, or None, optional (default=None)
| Feature matrix or tuple thereof, e.g. ``(X_val0, X_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| eval_y : numpy array, pandas DataFrame, pandas Series, list of int or float, pyarrow ChunkedArray or polars Series of shape = [n_samples], or tuple of such inputs, or None, optional (default=None)
| Target values or tuple thereof, e.g. ``(y_val0, y_val1)``, to use as validation sets.
|
| .. versionadded:: 4.7.0
|
| Returns
| -------
| self : LGBMRegressor
| Returns self.
|
|
|
| Note
| ----
| Custom eval function expects a callable with following signatures:
| ``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
| ``func(y_true, y_pred, weight, group)``
| and returns (metric_name, metric_value, maximize) or
| list of (metric_name, metric_value, maximize):
|
| y_true : numpy 1-D array of shape = [n_samples]
| The target values.
| y_pred : numpy 1-D array of shape = [n_samples] or numpy 2-D array of shape = [n_samples, n_classes] (for multi-class task)
| The predicted values.
| In case of custom ``objective``, predicted values are returned before any transformation,
| e.g. they are raw margin instead of probability of positive class for binary task in this case.
| weight : numpy 1-D array of shape = [n_samples]
| The weight of samples. Weights should be non-negative.
| group : numpy 1-D array
| Group/query data.
| Only used in the learning-to-rank task.
| sum(group) = n_samples.
| For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups,
| where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc.
| metric_name : str
| Unique identifier for the metric (e.g. "custom_adjusted_mse").
| metric_value : float
| Value of the evaluation metric.
| maximize : bool
| Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
|
| set_fit_request(self: lightgbm.sklearn.LGBMRegressor, *, callbacks: Union[bool, NoneType, str] = '$UNCHANGED$', categorical_feature: Union[bool, NoneType, str] = '$UNCHANGED$', eval_X: Union[bool, NoneType, str] = '$UNCHANGED$', eval_init_score: Union[bool, NoneType, str] = '$UNCHANGED$', eval_metric: Union[bool, NoneType, str] = '$UNCHANGED$', eval_names: Union[bool, NoneType, str] = '$UNCHANGED$', eval_sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$', eval_set: Union[bool, NoneType, str] = '$UNCHANGED$', eval_y: Union[bool, NoneType, str] = '$UNCHANGED$', feature_name: Union[bool, NoneType, str] = '$UNCHANGED$', init_model: Union[bool, NoneType, str] = '$UNCHANGED$', init_score: Union[bool, NoneType, str] = '$UNCHANGED$', sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``fit`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| callbacks : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``callbacks`` parameter in ``fit``.
|
| categorical_feature : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``categorical_feature`` parameter in ``fit``.
|
| eval_X : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_X`` parameter in ``fit``.
|
| eval_init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_init_score`` parameter in ``fit``.
|
| eval_metric : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_metric`` parameter in ``fit``.
|
| eval_names : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_names`` parameter in ``fit``.
|
| eval_sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_sample_weight`` parameter in ``fit``.
|
| eval_set : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_set`` parameter in ``fit``.
|
| eval_y : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``eval_y`` parameter in ``fit``.
|
| feature_name : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``feature_name`` parameter in ``fit``.
|
| init_model : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_model`` parameter in ``fit``.
|
| init_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``init_score`` parameter in ``fit``.
|
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``fit``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_predict_request(self: lightgbm.sklearn.LGBMRegressor, *, num_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', pred_contrib: Union[bool, NoneType, str] = '$UNCHANGED$', pred_leaf: Union[bool, NoneType, str] = '$UNCHANGED$', raw_score: Union[bool, NoneType, str] = '$UNCHANGED$', start_iteration: Union[bool, NoneType, str] = '$UNCHANGED$', validate_features: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``predict`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``predict`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``predict``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| num_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``num_iteration`` parameter in ``predict``.
|
| pred_contrib : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_contrib`` parameter in ``predict``.
|
| pred_leaf : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``pred_leaf`` parameter in ``predict``.
|
| raw_score : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``raw_score`` parameter in ``predict``.
|
| start_iteration : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``start_iteration`` parameter in ``predict``.
|
| validate_features : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``validate_features`` parameter in ``predict``.
|
| Returns
| -------
| self : object
| The updated object.
|
| set_score_request(self: lightgbm.sklearn.LGBMRegressor, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> lightgbm.sklearn.LGBMRegressor from sklearn.utils._metadata_requests.RequestMethod.__get__.<locals>
| Request metadata passed to the ``score`` method.
|
| Note that this method is only relevant if
| ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).
| Please see :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| The options for each parameter are:
|
| - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.
|
| - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.
|
| - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
|
| - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.
|
| The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the
| existing request. This allows you to change the request for some
| parameters and not others.
|
| .. versionadded:: 1.3
|
| .. note::
| This method is only relevant if this estimator is used as a
| sub-estimator of a meta-estimator, e.g. used inside a
| :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.
|
| Parameters
| ----------
| sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
| Metadata routing for ``sample_weight`` parameter in ``score``.
|
| Returns
| -------
| self : object
| The updated object.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.RegressorMixin:
|
| score(self, X, y, sample_weight=None)
| Return the coefficient of determination of the prediction.
|
| The coefficient of determination :math:`R^2` is defined as
| :math:`(1 - \frac{u}{v})`, where :math:`u` is the residual
| sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`
| is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.
| The best possible score is 1.0 and it can be negative (because the
| model can be arbitrarily worse). A constant model that always predicts
| the expected value of `y`, disregarding the input features, would get
| a :math:`R^2` score of 0.0.
|
| Parameters
| ----------
| X : array-like of shape (n_samples, n_features)
| Test samples. For some estimators this may be a precomputed
| kernel matrix or a list of generic objects instead with shape
| ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``
| is the number of samples used in the fitting for the estimator.
|
| y : array-like of shape (n_samples,) or (n_samples, n_outputs)
| True values for `X`.
|
| sample_weight : array-like of shape (n_samples,), default=None
| Sample weights.
|
| Returns
| -------
| score : float
| :math:`R^2` of ``self.predict(X)`` w.r.t. `y`.
|
| Notes
| -----
| The :math:`R^2` score used when calling ``score`` on a regressor uses
| ``multioutput='uniform_average'`` from version 0.23 to keep consistent
| with default value of :func:`~sklearn.metrics.r2_score`.
| This influences the ``score`` method of all the multioutput
| regressors (except for
| :class:`~sklearn.multioutput.MultiOutputRegressor`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from sklearn.base.RegressorMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from LGBMModel:
|
| __sklearn_is_fitted__(self) -> bool
|
| get_params(self, deep: bool = True) -> Dict[str, Any]
| 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 : dict
| Parameter names mapped to their values.
|
| predict(self, X: Union[List[Union[List[float], List[int]]], numpy.ndarray, pandas.core.frame.DataFrame, narwhals._native.NativeDataFrame, scipy.sparse._matrix.spmatrix], raw_score: bool = False, start_iteration: int = 0, num_iteration: Optional[int] = None, pred_leaf: bool = False, pred_contrib: bool = False, validate_features: bool = False, **kwargs: Any) -> Union[numpy.ndarray, scipy.sparse._matrix.spmatrix, List[scipy.sparse._matrix.spmatrix]]
| Return the predicted value for each sample.
|
| Parameters
| ----------
| X : numpy array, pandas DataFrame, scipy.sparse, list of lists of int or float of shape = [n_samples, n_features]
| Input features matrix.
| raw_score : bool, optional (default=False)
| Whether to predict raw scores.
| start_iteration : int, optional (default=0)
| Start index of the iteration to predict.
| If <= 0, starts from the first iteration.
| num_iteration : int or None, optional (default=None)
| Total number of iterations used in the prediction.
| If None, if the best iteration exists and start_iteration <= 0, the best iteration is used;
| otherwise, all iterations from ``start_iteration`` are used (no limits).
| If <= 0, all iterations from ``start_iteration`` 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.
|
| validate_features : bool, optional (default=False)
| If True, ensure that the features used to predict match the ones used to train.
| Used only if data is pandas DataFrame.
| **kwargs
| Other parameters for the prediction.
|
| Returns
| -------
| predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
| The predicted values.
| X_leaves : array-like 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 : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or list with n_classes length of such objects
| If ``pred_contrib=True``, the feature contributions for each sample.
|
| set_params(self, **params: Any) -> 'LGBMModel'
| Set the parameters of this estimator.
|
| Parameters
| ----------
| **params
| Parameter names with their new values.
|
| Returns
| -------
| self : object
| Returns self.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from LGBMModel:
|
| best_iteration_
| :obj:`int`: The best iteration of fitted model if ``early_stopping()`` callback has been specified.
|
| best_score_
| :obj:`dict`: The best score of fitted model.
|
| booster_
| Booster: The underlying Booster of this model.
|
| evals_result_
| :obj:`dict`: The evaluation results if validation sets have been specified.
|
| feature_importances_
| :obj:`array` of shape = [n_features]: The feature importances (the higher, the more important).
|
| .. note::
|
| ``importance_type`` attribute is passed to the function
| to configure the type of importance values to be extracted.
|
| feature_name_
| :obj:`list` of shape = [n_features]: The names of features.
|
| .. note::
|
| If input does not contain feature names, they will be added during fitting in the format ``Column_0``, ``Column_1``, ..., ``Column_N``.
|
| feature_names_in_
| :obj:`array` of shape = [n_features]: scikit-learn compatible version of ``.feature_name_``.
|
| Only available when training data had feature names (e.g. a pandas DataFrame).
| When training was done with data without feature names (e.g. a numpy array),
| accessing this attribute raises ``AttributeError``.
|
| .. versionadded:: 4.5.0
|
| n_estimators_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| n_features_
| :obj:`int`: The number of features of fitted model.
|
| n_iter_
| :obj:`int`: True number of boosting iterations performed.
|
| This might be less than parameter ``n_estimators`` if early stopping was enabled or
| if boosting stopped early due to limits on complexity like ``min_gain_to_split``.
|
| .. versionadded:: 4.0.0
|
| objective_
| :obj:`str` or :obj:`callable`: The concrete objective used while fitting this model.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from LGBMModel:
|
| n_features_in_
| :obj:`int`: The number of features of fitted model.
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.base.BaseEstimator:
|
| __getstate__(self)
| Helper for pickle.
|
| __repr__(self, N_CHAR_MAX=700)
| Return repr(self).
|
| __setstate__(self, state)
|
| __sklearn_clone__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| get_metadata_routing(self)
| Get metadata routing of this object.
|
| Please check :ref:`User Guide <metadata_routing>` on how the routing
| mechanism works.
|
| Returns
| -------
| routing : MetadataRequest
| A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating
| routing information.
|
| ----------------------------------------------------------------------
| Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:
|
| __init_subclass__(**kwargs)
| Set the ``set_{method}_request`` methods.
|
| This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It
| looks for the information available in the set default values which are
| set using ``__metadata_request__*`` class attributes, or inferred
| from method signatures.
|
| The ``__metadata_request__*`` class attributes are used when a method
| does not explicitly accept a metadata through its arguments or if the
| developer would like to specify a request value for those metadata
| which are different from the default ``None``.
|
| References
| ----------
| .. [1] https://www.python.org/dev/peps/pep-0487
DATA
__all__ = ['LGBMClassifier', 'LGBMModel', 'LGBMRanker', 'LGBMRegressor...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\lightgbm\sklearn.py
lightgbm.train
Python Library Documentation: function train in module lightgbm.engine
train(params: Dict[str, Any], train_set: lightgbm.basic.Dataset, num_boost_round: int = 100, valid_sets: Optional[List[lightgbm.basic.Dataset]] = None, valid_names: Optional[List[str]] = None, feval: Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]], List[Union[Callable[[numpy.ndarray, lightgbm.basic.Dataset], Tuple[str, float, bool]], Callable[[numpy.ndarray, lightgbm.basic.Dataset], List[Tuple[str, float, bool]]]]], NoneType] = None, init_model: Union[str, pathlib.Path, lightgbm.basic.Booster, NoneType] = None, keep_training_booster: bool = False, callbacks: Optional[List[Callable]] = None) -> lightgbm.basic.Booster
Perform the training with given parameters.
Parameters
----------
params : dict
Parameters for training. Values passed through ``params`` take precedence over those
supplied via arguments.
train_set : Dataset
Data to be trained on.
num_boost_round : int, optional (default=100)
Number of boosting iterations.
valid_sets : list of Dataset, or None, optional (default=None)
List of data to be evaluated on during training.
valid_names : list of str, or None, optional (default=None)
Names of ``valid_sets``.
feval : callable, list of callable, or None, optional (default=None)
Customized evaluation function.
Each evaluation function should accept two parameters: preds, eval_data,
and return (metric_name, metric_value, maximize) or list of such tuples.
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes].
If custom objective function is used, predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task in this case.
eval_data : Dataset
A ``Dataset`` to evaluate.
metric_name : str
Unique identifier for the metric (e.g. "custom_adjusted_mse").
metric_value : float
Value of the evaluation metric.
maximize : bool
Are higher values better? e.g. ``True`` for AUC and ``False`` for binary error.
To ignore the default metric corresponding to the used objective,
set the ``metric`` parameter to the string ``"None"`` in ``params``.
init_model : str, pathlib.Path, Booster or None, optional (default=None)
Filename of LightGBM model or Booster instance used for continue training.
keep_training_booster : bool, optional (default=False)
Whether the returned Booster will be used to keep training.
If False, the returned value will be converted into _InnerPredictor before returning.
This means you won't be able to use ``eval``, ``eval_train`` or ``eval_valid`` methods of the returned Booster.
When your model is very large and cause the memory error,
you can try to set this param to ``True`` to avoid the model conversion performed during the internal call of ``model_to_string``.
You can still use _InnerPredictor as ``init_model`` for future continue training.
callbacks : list of callable, or None, optional (default=None)
List of callback functions that are applied at each iteration.
See Callbacks in Python API for more information.
Note
----
A custom objective function can be provided for the ``objective`` parameter.
It should accept two parameters: preds, train_data and return (grad, hess).
preds : numpy 1-D array or numpy 2-D array (for multi-class task)
The predicted values.
Predicted values are returned before any transformation,
e.g. they are raw margin instead of probability of positive class for binary task.
train_data : Dataset
The training dataset.
grad : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the first order derivative (gradient) of the loss
with respect to the elements of preds for each sample point.
hess : numpy 1-D array or numpy 2-D array (for multi-class task)
The value of the second order derivative (Hessian) of the loss
with respect to the elements of preds for each sample point.
For multi-class task, preds are numpy 2-D array of shape = [n_samples, n_classes],
and grad and hess should be returned in the same format.
Returns
-------
booster : Booster
The trained Booster model.