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 = [

| `RidgeClassifierCV

]

type t =
  [ `BaseEstimator
  | `ClassifierMixin
  | `LinearClassifierMixin
  | `Object
  | `RidgeClassifierCV ]
    Obj.t

val of_pyobject : Py.Object.t -> t

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

val as_classifier : t -> [ `ClassifierMixin ] Obj.t

val as_linear_classifier : t -> [ `LinearClassifierMixin ] Obj.t

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

val create : 
  ?alphas:[> `ArrayLike ] Np.Obj.t ->
  ?fit_intercept:bool ->
  ?normalize:bool ->
  ?scoring:
    [ `Max_error
    | `Mutual_info_score
    | `Homogeneity_score
    | `Roc_auc
    | `Neg_mean_squared_error
    | `Recall_micro
    | `Neg_mean_poisson_deviance
    | `Neg_log_loss
    | `F1_macro
    | `Neg_mean_gamma_deviance
    | `Neg_median_absolute_error
    | `Callable of Py.Object.t
    | `Neg_brier_score
    | `Neg_mean_squared_log_error
    | `Recall_macro
    | `Explained_variance
    | `Roc_auc_ovr_weighted
    | `Adjusted_rand_score
    | `Precision_macro
    | `Jaccard_samples
    | `Roc_auc_ovo_weighted
    | `Jaccard_macro
    | `Precision
    | `Balanced_accuracy
    | `Precision_micro
    | `Precision_weighted
    | `V_measure_score
    | `Normalized_mutual_info_score
    | `F1_weighted
    | `Neg_root_mean_squared_error
    | `Neg_mean_absolute_error
    | `F1
    | `Roc_auc_ovo
    | `Jaccard_micro
    | `Average_precision
    | `Adjusted_mutual_info_score
    | `R2
    | `F1_samples
    | `Fowlkes_mallows_score
    | `Accuracy
    | `Recall_weighted
    | `Jaccard_weighted
    | `Roc_auc_ovr
    | `F1_micro
    | `Precision_samples
    | `Jaccard
    | `Completeness_score
    | `Recall_samples
    | `Recall ] ->
  ?cv:
    [ `Arr of [> `ArrayLike ] Np.Obj.t
    | `BaseCrossValidator of [> `BaseCrossValidator ] Np.Obj.t
    | `I of int ] ->
  ?class_weight:[ `DictIntToFloat of (int * float) list | `Balanced ] ->
  ?store_cv_values:bool ->
  unit ->
  t

Ridge classifier with built-in cross-validation.

See glossary entry for :term:`cross-validation estimator`.

By default, it performs Generalized Cross-Validation, which is a form of efficient Leave-One-Out cross-validation. Currently, only the n_features > n_samples case is handled efficiently.

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

Parameters ---------- alphas : ndarray of shape (n_alphas,), default=(0.1, 1.0, 10.0) Array of alpha values to try. Regularization strength; must be a positive float. Regularization improves the conditioning of the problem and reduces the variance of the estimates. Larger values specify stronger regularization. Alpha corresponds to ``C^-1`` in other linear models such as LogisticRegression or LinearSVC.

fit_intercept : bool, default=True Whether to calculate the intercept for this model. If set to false, no intercept will be used in calculations (i.e. data is expected to be centered).

normalize : bool, default=False This parameter is ignored when ``fit_intercept`` is set to False. If True, the regressors X will be normalized before regression by subtracting the mean and dividing by the l2-norm. If you wish to standardize, please use :class:`sklearn.preprocessing.StandardScaler` before calling ``fit`` on an estimator with ``normalize=False``.

scoring : string, callable, default=None A string (see model evaluation documentation) or a scorer callable object / function with signature ``scorer(estimator, X, y)``.

cv : int, cross-validation generator or an iterable, default=None Determines the cross-validation splitting strategy. Possible inputs for cv are:

None, to use the efficient Leave-One-Out cross-validation
integer, to specify the number of folds.
:term:`CV splitter`,
An iterable yielding (train, test) splits as arrays of indices.

Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here.

class_weight : dict or 'balanced', default=None Weights associated with classes in the form ``class_label: weight``. If not given, all classes are supposed to have weight one.

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))``

store_cv_values : bool, default=False Flag indicating if the cross-validation values corresponding to each alpha should be stored in the ``cv_values_`` attribute (see below). This flag is only compatible with ``cv=None`` (i.e. using Generalized Cross-Validation).

Attributes ---------- cv_values_ : ndarray of shape (n_samples, n_targets, n_alphas), optional Cross-validation values for each alpha (if ``store_cv_values=True`` and ``cv=None``). After ``fit()`` has been called, this attribute will contain the mean squared errors (by default) or the values of the ``loss,score_func`` function (if provided in the constructor). This attribute exists only when ``store_cv_values`` is True.

coef_ : ndarray of shape (1, n_features) or (n_targets, n_features) Coefficient of the features in the decision function.

``coef_`` is of shape (1, n_features) when the given problem is binary.

intercept_ : float or ndarray of shape (n_targets,) Independent term in decision function. Set to 0.0 if ``fit_intercept = False``.

alpha_ : float Estimated regularization parameter

classes_ : ndarray of shape (n_classes,) The classes labels.

Examples -------- >>> from sklearn.datasets import load_breast_cancer >>> from sklearn.linear_model import RidgeClassifierCV >>> X, y = load_breast_cancer(return_X_y=True) >>> clf = RidgeClassifierCV(alphas=1e-3, 1e-2, 1e-1, 1).fit(X, y) >>> clf.score(X, y) 0.9630...

See also -------- Ridge : Ridge regression RidgeClassifier : Ridge classifier RidgeCV : Ridge regression with built-in cross validation

Notes ----- For multi-class classification, n_class classifiers are trained in a one-versus-all approach. Concretely, this is implemented by taking advantage of the multi-variate response support in Ridge.

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

Predict confidence scores for samples.

The confidence score for a sample is the signed distance of that sample to the hyperplane.

Parameters ---------- X : array_like or sparse matrix, shape (n_samples, n_features) Samples.

Returns ------- array, shape=(n_samples,) if n_classes == 2 else (n_samples, n_classes) Confidence scores per (sample, class) combination. In the binary case, confidence score for self.classes_1 where >0 means this class would be predicted.

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

Fit Ridge classifier with cv.

Parameters ---------- X : ndarray of shape (n_samples, n_features) Training vectors, where n_samples is the number of samples and n_features is the number of features. When using GCV, will be cast to float64 if necessary.

y : ndarray of shape (n_samples,) Target values. Will be cast to X's dtype if necessary.

sample_weight : float or ndarray of shape (n_samples,), default=None Individual weights for each sample. If given a float, every sample will have the same weight.

Returns ------- self : object

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

Predict class labels for samples in X.

Parameters ---------- X : array_like or sparse matrix, shape (n_samples, n_features) Samples.

Returns ------- C : array, shape n_samples Predicted class label per sample.

val score : 
  ?sample_weight:[> `ArrayLike ] Np.Obj.t ->
  x:[> `ArrayLike ] Np.Obj.t ->
  y:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  float

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) wrt. y.

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

Attribute cv_values_: get value or raise Not_found if None.

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

Attribute cv_values_: get value as an option.

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

Attribute coef_: get value or raise Not_found if None.

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

Attribute coef_: get value as an option.

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

Attribute intercept_: get value or raise Not_found if None.

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

Attribute intercept_: get value as an option.

val alpha_ : t -> float

Attribute alpha_: get value or raise Not_found if None.

val alpha_opt : t -> float option

Attribute alpha_: get value as an option.

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 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.