Toggle Menu
Prev Up Next

scikit-learn 1.3.2
Other versions

Please cite us if you use the software.

# `sklearn.multioutput`.ClassifierChain

class sklearn.multioutput.ClassifierChain(base_estimator, *, order=None, cv=None, random_state=None, verbose=False)

  A multi-label model that arranges binary classifiers into a chain.

  Each model makes a prediction in the order specified by the chain using all of the available features provided to the model plus the predictions of models that are earlier in the chain.

  For an example of how to use `ClassifierChain` and benefit from its ensemble, see ClassifierChain on a yeast dataset example.

  Read more in the User Guide.

  New in version 0.19.

  Parameters:
    base_estimator estimator

      The base estimator from which the classifier chain is built.

    order array-like of shape (n_outputs,) or ‘random’, default=None

      If `None`, the order will be determined by the order of columns in the label matrix Y.:

          order = [0, 1, 2, ..., Y.shape[1] - 1]

      The order of the chain can be explicitly set by providing a list of integers. For example, for a chain of length 5.:

          order = [1, 3, 2, 4, 0]

      means that the first model in the chain will make predictions for column 1 in the Y matrix, the second model will make predictions for column 3, etc.

      If order is `random` a random ordering will be used.

    cv int, cross-validation generator or an iterable, default=None

      Determines whether to use cross validated predictions or true labels for the results of previous estimators in the chain. Possible inputs for cv are:

      - None, to use true labels when fitting,

      - integer, to specify the number of folds in a (Stratified)KFold,

      - CV splitter,

      - An iterable yielding (train, test) splits as arrays of indices.

    random_state int, RandomState instance or None, optional (default=None)

      If `order='random'`, determines random number generation for the chain order. In addition, it controls the random seed given at each `base_estimator` at each chaining iteration. Thus, it is only used when `base_estimator` exposes a `random_state`. Pass an int for reproducible output across multiple function calls. See Glossary.

    verbose bool, default=False

      If True, chain progress is output as each model is completed.

      New in version 1.2.

  Attributes:
    classes_list

      A list of arrays of length `len(estimators_)` containing the class labels for each estimator in the chain.

    estimators_list

      A list of clones of base_estimator.

    order_list

      The order of labels in the classifier chain.

    n_features_in_int

      Number of features seen during fit. Only defined if the underlying `base_estimator` exposes such an attribute when fit.

      New in version 0.24.

    feature_names_in_ndarray of shape (`n_features_in_`,)

      Names of features seen during fit. Defined only when `X` has feature names that are all strings.

      New in version 1.0.

  See also

  `RegressorChain`

    Equivalent for regression.

  `MultiOutputClassifier`

    Classifies each output independently rather than chaining.

  References

  Jesse Read, Bernhard Pfahringer, Geoff Holmes, Eibe Frank, “Classifier Chains for Multi-label Classification”, 2009.

  Examples

      >>> from sklearn.datasets import make_multilabel_classification
      >>> from sklearn.linear_model import LogisticRegression
      >>> from sklearn.model_selection import train_test_split
      >>> from sklearn.multioutput import ClassifierChain
      >>> X, Y = make_multilabel_classification(
      ...    n_samples=12, n_classes=3, random_state=0
      ... )
      >>> X_train, X_test, Y_train, Y_test = train_test_split(
      ...    X, Y, random_state=0
      ... )
      >>> base_lr = LogisticRegression(solver='lbfgs', random_state=0)
      >>> chain = ClassifierChain(base_lr, order='random', random_state=0)
      >>> chain.fit(X_train, Y_train).predict(X_test)
      array([[1., 1., 0.],
             [1., 0., 0.],
             [0., 1., 0.]])
      >>> chain.predict_proba(X_test)
      array([[0.8387..., 0.9431..., 0.4576...],
             [0.8878..., 0.3684..., 0.2640...],
             [0.0321..., 0.9935..., 0.0625...]])

  Methods

  `decision_function`(X) | Evaluate the decision_function of the models in the chain.
  `fit`(X, Y, **fit_params) | Fit the model to data matrix X and targets Y.
  `get_metadata_routing`() | Get metadata routing of this object.
  `get_params`([deep]) | Get parameters for this estimator.
  `predict`(X) | Predict on the data matrix X using the ClassifierChain model.
  `predict_proba`(X) | Predict probability estimates.
  `score`(X, y[, sample_weight]) | Return the mean accuracy on the given test data and labels.
  `set_params`(**params) | Set the parameters of this estimator.
  `set_score_request`(*[, sample_weight]) | Request metadata passed to the `score` method.

  decision_function(X)

    Evaluate the decision_function of the models in the chain.

    Parameters:
      X array-like of shape (n_samples, n_features)

        The input data.

    Returns:
      Y_decision array-like of shape (n_samples, n_classes)

        Returns the decision function of the sample for each model in the chain.

  fit(X, Y, **fit_params)

    Fit the model to data matrix X and targets Y.

    Parameters:
      X{array-like, sparse matrix} of shape (n_samples, n_features)

        The input data.

      Y array-like of shape (n_samples, n_classes)

        The target values.

      **fit_params dict of string -> object

        Parameters passed to the `fit` method of each step.

        Only available if `enable_metadata_routing=True`. See the User Guide.

        New in version 1.3.

    Returns:
      self object

        Class instance.

  get_metadata_routing()

    Get metadata routing of this object.

    Please check User Guide on how the routing mechanism works.

    New in version 1.3.

    Returns:
      routing MetadataRouter

        A `MetadataRouter` encapsulating routing information.

  get_params(deep=True)

    Get parameters for this estimator.

    Parameters:
      deep bool, 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(X)

    Predict on the data matrix X using the ClassifierChain model.

    Parameters:
      X{array-like, sparse matrix} of shape (n_samples, n_features)

        The input data.

    Returns:
      Y_pred array-like of shape (n_samples, n_classes)

        The predicted values.

  predict_proba(X)

    Predict probability estimates.

    Parameters:
      X{array-like, sparse matrix} of shape (n_samples, n_features)

        The input data.

    Returns:
      Y_prob array-like of shape (n_samples, n_classes)

        The predicted probabilities.

  score(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`.

  set_params(**params)

    Set the parameters of this estimator.

    The method works on simple estimators as well as on nested objects (such as `Pipeline`). The latter have parameters of the form `<component>__<parameter>` so that it’s possible to update each component of a nested object.

    Parameters:
      **params dict

        Estimator parameters.

    Returns:
      self estimator instance

        Estimator instance.

  set_score_request(*, sample_weight: bool | None | str = '$UNCHANGED$') → ClassifierChain

    Request metadata passed to the `score` method.

    Note that this method is only relevant if `enable_metadata_routing=True` (see `sklearn.set_config`). Please see User Guide 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.

    New in version 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 `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.

## Examples using `sklearn.multioutput.ClassifierChain`

Classifier Chain

Classifier Chain