package sklearn

You can search for identifiers within the package.

in-package search v0.2.0

sklearn
- Sklearn

Legend:
Library
Module
Module type
Parameter
Class
Class type

type tag = [

| `LabelBinarizer

]

type t =
  [ `BaseEstimator | `LabelBinarizer | `Object | `TransformerMixin ] Obj.t

val of_pyobject : Py.Object.t -> t

val to_pyobject : [> tag ] Obj.t -> Py.Object.t

val as_transformer : t -> [ `TransformerMixin ] Obj.t

val as_estimator : t -> [ `BaseEstimator ] Obj.t

val create : 
  ?neg_label:int ->
  ?pos_label:int ->
  ?sparse_output:bool ->
  unit ->
  t

Binarize labels in a one-vs-all fashion

Several regression and binary classification algorithms are available in scikit-learn. A simple way to extend these algorithms to the multi-class classification case is to use the so-called one-vs-all scheme.

At learning time, this simply consists in learning one regressor or binary classifier per class. In doing so, one needs to convert multi-class labels to binary labels (belong or does not belong to the class). LabelBinarizer makes this process easy with the transform method.

At prediction time, one assigns the class for which the corresponding model gave the greatest confidence. LabelBinarizer makes this easy with the inverse_transform method.

Read more in the :ref:`User Guide <preprocessing_targets>`.

Parameters ----------

neg_label : int (default: 0) Value with which negative labels must be encoded.

pos_label : int (default: 1) Value with which positive labels must be encoded.

sparse_output : boolean (default: False) True if the returned array from transform is desired to be in sparse CSR format.

Attributes ----------

classes_ : array of shape n_class Holds the label for each class.

y_type_ : str, Represents the type of the target data as evaluated by utils.multiclass.type_of_target. Possible type are 'continuous', 'continuous-multioutput', 'binary', 'multiclass', 'multiclass-multioutput', 'multilabel-indicator', and 'unknown'.

sparse_input_ : boolean, True if the input data to transform is given as a sparse matrix, False otherwise.

Examples -------- >>> from sklearn import preprocessing >>> lb = preprocessing.LabelBinarizer() >>> lb.fit(1, 2, 6, 4, 2) LabelBinarizer() >>> lb.classes_ array(1, 2, 4, 6) >>> lb.transform(1, 6) array([1, 0, 0, 0], [0, 0, 0, 1])

Binary targets transform to a column vector

>>> lb = preprocessing.LabelBinarizer() >>> lb.fit_transform('yes', 'no', 'no', 'yes') array([1], [0], [0], [1])

Passing a 2D matrix for multilabel classification

>>> import numpy as np >>> lb.fit(np.array([0, 1, 1], [1, 0, 0])) LabelBinarizer() >>> lb.classes_ array(0, 1, 2) >>> lb.transform(0, 1, 2, 1) array([1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 1, 0])

See also -------- label_binarize : function to perform the transform operation of LabelBinarizer with fixed classes. sklearn.preprocessing.OneHotEncoder : encode categorical features using a one-hot aka one-of-K scheme.

val fit : y:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> t

Fit label binarizer

Parameters ---------- y : array of shape n_samples, or n_samples, n_classes Target values. The 2-d matrix should only contain 0 and 1, represents multilabel classification.

Returns ------- self : returns an instance of self.

val fit_transform : 
  y:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Fit label binarizer and transform multi-class labels to binary labels.

The output of transform is sometimes referred to as the 1-of-K coding scheme.

Parameters ---------- y : array or sparse matrix of shape n_samples, or n_samples, n_classes Target values. The 2-d matrix should only contain 0 and 1, represents multilabel classification. Sparse matrix can be CSR, CSC, COO, DOK, or LIL.

Returns ------- Y : array or CSR matrix of shape n_samples, n_classes Shape will be n_samples, 1 for binary problems.

val get_params : ?deep:bool -> [> tag ] Obj.t -> Dict.t

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 : mapping of string to any Parameter names mapped to their values.

val inverse_transform : 
  ?threshold:float ->
  y:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  Py.Object.t

Transform binary labels back to multi-class labels

Parameters ---------- Y : numpy array or sparse matrix with shape n_samples, n_classes Target values. All sparse matrices are converted to CSR before inverse transformation.

threshold : float or None Threshold used in the binary and multi-label cases.

Use 0 when ``Y`` contains the output of decision_function (classifier). Use 0.5 when ``Y`` contains the output of predict_proba.

If None, the threshold is assumed to be half way between neg_label and pos_label.

Returns ------- y : numpy array or CSR matrix of shape n_samples Target values.

Notes ----- In the case when the binary labels are fractional (probabilistic), inverse_transform chooses the class with the greatest value. Typically, this allows to use the output of a linear model's decision_function method directly as the input of inverse_transform.

val set_params : ?params:(string * Py.Object.t) list -> [> tag ] Obj.t -> t

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). 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 : object Estimator instance.

val transform : 
  y:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Transform multi-class labels to binary labels

The output of transform is sometimes referred to by some authors as the 1-of-K coding scheme.

Returns ------- Y : numpy array or CSR matrix of shape n_samples, n_classes Shape will be n_samples, 1 for binary problems.

val classes_ : t -> [> `ArrayLike ] Np.Obj.t

Attribute classes_: get value or raise Not_found if None.

val classes_opt : t -> [> `ArrayLike ] Np.Obj.t option

Attribute classes_: get value as an option.

val y_type_ : t -> string

Attribute y_type_: get value or raise Not_found if None.

val y_type_opt : t -> string option

Attribute y_type_: get value as an option.

val sparse_input_ : t -> bool

Attribute sparse_input_: get value or raise Not_found if None.

val sparse_input_opt : t -> bool option

Attribute sparse_input_: get value as an option.

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Format.formatter -> t -> unit

Pretty-print the object to a formatter.