package sklearn

  1. Overview
  2. Docs
package sklearn
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `RFE
]
type t = [ `BaseEstimator | `MetaEstimatorMixin | `Object | `RFE | `SelectorMixin | `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_meta_estimator : t -> [ `MetaEstimatorMixin ] Obj.t
val as_selector : t -> [ `SelectorMixin ] Obj.t
val as_estimator : t -> [ `BaseEstimator ] Obj.t
val create : ?n_features_to_select:int -> ?step:[ `I of int | `F of float ] -> ?verbose:int -> estimator:[> `BaseEstimator ] Np.Obj.t -> unit -> t

Feature ranking with recursive feature elimination.

Given an external estimator that assigns weights to features (e.g., the coefficients of a linear model), the goal of recursive feature elimination (RFE) is to select features by recursively considering smaller and smaller sets of features. First, the estimator is trained on the initial set of features and the importance of each feature is obtained either through a ``coef_`` attribute or through a ``feature_importances_`` attribute. Then, the least important features are pruned from current set of features. That procedure is recursively repeated on the pruned set until the desired number of features to select is eventually reached.

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

Parameters ---------- estimator : object A supervised learning estimator with a ``fit`` method that provides information about feature importance either through a ``coef_`` attribute or through a ``feature_importances_`` attribute.

n_features_to_select : int or None (default=None) The number of features to select. If `None`, half of the features are selected.

step : int or float, optional (default=1) If greater than or equal to 1, then ``step`` corresponds to the (integer) number of features to remove at each iteration. If within (0.0, 1.0), then ``step`` corresponds to the percentage (rounded down) of features to remove at each iteration.

verbose : int, (default=0) Controls verbosity of output.

Attributes ---------- n_features_ : int The number of selected features.

support_ : array of shape n_features The mask of selected features.

ranking_ : array of shape n_features The feature ranking, such that ``ranking_i`` corresponds to the ranking position of the i-th feature. Selected (i.e., estimated best) features are assigned rank 1.

estimator_ : object The external estimator fit on the reduced dataset.

Examples -------- The following example shows how to retrieve the 5 most informative features in the Friedman #1 dataset.

>>> from sklearn.datasets import make_friedman1 >>> from sklearn.feature_selection import RFE >>> from sklearn.svm import SVR >>> X, y = make_friedman1(n_samples=50, n_features=10, random_state=0) >>> estimator = SVR(kernel='linear') >>> selector = RFE(estimator, n_features_to_select=5, step=1) >>> selector = selector.fit(X, y) >>> selector.support_ array( True, True, True, True, True, False, False, False, False, False) >>> selector.ranking_ array(1, 1, 1, 1, 1, 6, 4, 3, 2, 5)

Notes ----- Allows NaN/Inf in the input if the underlying estimator does as well.

See also -------- RFECV : Recursive feature elimination with built-in cross-validated selection of the best number of features

References ----------

.. 1 Guyon, I., Weston, J., Barnhill, S., & Vapnik, V., 'Gene selection for cancer classification using support vector machines', Mach. Learn., 46(1-3), 389--422, 2002.

val decision_function : x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Compute the decision function of ``X``.

Parameters ---------- X : array-like or sparse matrix of shape (n_samples, n_features) The input samples. Internally, it will be converted to ``dtype=np.float32`` and if a sparse matrix is provided to a sparse ``csr_matrix``.

Returns ------- score : array, shape = n_samples, n_classes or n_samples The decision function of the input samples. The order of the classes corresponds to that in the attribute :term:`classes_`. Regression and binary classification produce an array of shape n_samples.

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

Fit the RFE model and then the underlying estimator on the selected features.

Parameters ---------- X : array-like, sparse matrix of shape (n_samples, n_features) The training input samples.

y : array-like of shape (n_samples,) The target values.

val fit_transform : ?y:[> `ArrayLike ] Np.Obj.t -> ?fit_params:(string * Py.Object.t) list -> x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Fit to data, then transform it.

Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.

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

y : ndarray of shape (n_samples,), default=None Target values.

**fit_params : dict Additional fit parameters.

Returns ------- X_new : ndarray array of shape (n_samples, n_features_new) Transformed array.

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 get_support : ?indices:bool -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Get a mask, or integer index, of the features selected

Parameters ---------- indices : boolean (default False) If True, the return value will be an array of integers, rather than a boolean mask.

Returns ------- support : array An index that selects the retained features from a feature vector. If `indices` is False, this is a boolean array of shape # input features, in which an element is True iff its corresponding feature is selected for retention. If `indices` is True, this is an integer array of shape # output features whose values are indices into the input feature vector.

val inverse_transform : x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Reverse the transformation operation

Parameters ---------- X : array of shape n_samples, n_selected_features The input samples.

Returns ------- X_r : array of shape n_samples, n_original_features `X` with columns of zeros inserted where features would have been removed by :meth:`transform`.

val predict : x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Reduce X to the selected features and then predict using the underlying estimator.

Parameters ---------- X : array of shape n_samples, n_features The input samples.

Returns ------- y : array of shape n_samples The predicted target values.

val predict_log_proba : x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Predict class log-probabilities for X.

Parameters ---------- X : array of shape n_samples, n_features The input samples.

Returns ------- p : array of shape (n_samples, n_classes) The class log-probabilities of the input samples. The order of the classes corresponds to that in the attribute :term:`classes_`.

val predict_proba : x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Predict class probabilities for X.

Parameters ---------- X : array-like or sparse matrix of shape (n_samples, n_features) The input samples. Internally, it will be converted to ``dtype=np.float32`` and if a sparse matrix is provided to a sparse ``csr_matrix``.

Returns ------- p : array of shape (n_samples, n_classes) The class probabilities of the input samples. The order of the classes corresponds to that in the attribute :term:`classes_`.

val score : x:[> `ArrayLike ] Np.Obj.t -> y:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> Py.Object.t

Reduce X to the selected features and then return the score of the underlying estimator.

Parameters ---------- X : array of shape n_samples, n_features The input samples.

y : array of shape n_samples The target values.

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 : x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Reduce X to the selected features.

Parameters ---------- X : array of shape n_samples, n_features The input samples.

Returns ------- X_r : array of shape n_samples, n_selected_features The input samples with only the selected features.

val n_features_ : t -> int

Attribute n_features_: get value or raise Not_found if None.

val n_features_opt : t -> int option

Attribute n_features_: get value as an option.

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

Attribute support_: get value or raise Not_found if None.

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

Attribute support_: get value as an option.

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

Attribute ranking_: get value or raise Not_found if None.

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

Attribute ranking_: get value as an option.

val estimator_ : t -> Py.Object.t

Attribute estimator_: get value or raise Not_found if None.

val estimator_opt : t -> Py.Object.t option

Attribute estimator_: 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 : Stdlib.Format.formatter -> t -> unit

Pretty-print the object to a formatter.