val of_pyobject : Py.Object.t -> tval to_pyobject : t -> Py.Object.tval create :
?alphas:Ndarray.t ->
?fit_intercept:bool ->
?normalize:bool ->
?scoring:[ `String of string | `Callable of Py.Object.t ] ->
?cv:
[ `Int of int | `CrossValGenerator of Py.Object.t | `Ndarray of Ndarray.t ] ->
?class_weight:[ `DictIntToFloat of (int * float) list | `Balanced ] ->
?store_cv_values:bool ->
unit ->
tRidge 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:
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:[ `Ndarray of Ndarray.t | `SparseMatrix of Csr_matrix.t ] ->
t ->
Ndarray.tPredict 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:[ `Float of float | `Ndarray of Ndarray.t ] ->
x:Ndarray.t ->
y:Ndarray.t ->
t ->
tFit 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 -> t -> Py.Object.tGet 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:[ `Ndarray of Ndarray.t | `SparseMatrix of Csr_matrix.t ] ->
t ->
Ndarray.tPredict 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.
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 -> t -> tSet 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 alpha_ : t -> floatAttribute alpha_: see constructor for documentation
val to_string : t -> stringPrint the object to a human-readable representation.
val show : t -> stringPrint the object to a human-readable representation.
val pp : Format.formatter -> t -> unitPretty-print the object to a formatter.