sklearn.linear_model
.RidgeClassifier¶

class
sklearn.linear_model.
RidgeClassifier
(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, class_weight=None, solver='auto', random_state=None)[source]¶ Classifier using Ridge regression.
Read more in the User Guide.
Parameters: alpha : float
Small positive values of alpha improve the conditioning of the problem and reduce the variance of the estimates. Alpha corresponds to
C^1
in other linear models such as LogisticRegression or LinearSVC.class_weight : dict or ‘balanced’, optional
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))
copy_X : boolean, optional, default True
If True, X will be copied; else, it may be overwritten.
fit_intercept : boolean
Whether to calculate the intercept for this model. If set to false, no intercept will be used in calculations (e.g. data is expected to be already centered).
max_iter : int, optional
Maximum number of iterations for conjugate gradient solver. The default value is determined by scipy.sparse.linalg.
normalize : boolean, optional, default False
If True, the regressors X will be normalized before regression.
solver : {‘auto’, ‘svd’, ‘cholesky’, ‘lsqr’, ‘sparse_cg’, ‘sag’}
Solver to use in the computational routines:
‘auto’ chooses the solver automatically based on the type of data.
‘svd’ uses a Singular Value Decomposition of X to compute the Ridge coefficients. More stable for singular matrices than ‘cholesky’.
‘cholesky’ uses the standard scipy.linalg.solve function to obtain a closedform solution.
‘sparse_cg’ uses the conjugate gradient solver as found in scipy.sparse.linalg.cg. As an iterative algorithm, this solver is more appropriate than ‘cholesky’ for largescale data (possibility to set tol and max_iter).
‘lsqr’ uses the dedicated regularized leastsquares routine scipy.sparse.linalg.lsqr. It is the fatest but may not be available in old scipy versions. It also uses an iterative procedure.
‘sag’ uses a Stochastic Average Gradient descent. It also uses an iterative procedure, and is faster than other solvers when both n_samples and n_features are large.
New in version 0.17: Stochastic Average Gradient descent solver.
tol : float
Precision of the solution.
random_state : int seed, RandomState instance, or None (default)
The seed of the pseudo random number generator to use when shuffling the data. Used in ‘sag’ solver.
Attributes: coef_ : array, shape (n_features,) or (n_classes, n_features)
Weight vector(s).
intercept_ : float  array, shape = (n_targets,)
Independent term in decision function. Set to 0.0 if
fit_intercept = False
.n_iter_ : array or None, shape (n_targets,)
Actual number of iterations for each target. Available only for sag and lsqr solvers. Other solvers will return None.
See also
Notes
For multiclass classification, n_class classifiers are trained in a oneversusall approach. Concretely, this is implemented by taking advantage of the multivariate response support in Ridge.
Methods
decision_function
(X)Predict confidence scores for samples. fit
(X, y[, sample_weight])Fit Ridge regression model. get_params
([deep])Get parameters for this estimator. predict
(X)Predict class labels for samples in X. score
(X, y[, sample_weight])Returns the mean accuracy on the given test data and labels. set_params
(**params)Set the parameters of this estimator. 
__init__
(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, class_weight=None, solver='auto', random_state=None)[source]¶

decision_function
(X)[source]¶ Predict confidence scores for samples.
The confidence score for a sample is the signed distance of that sample to the hyperplane.
Parameters: X : {arraylike, 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.

fit
(X, y, sample_weight=None)[source]¶ Fit Ridge regression model.
Parameters: X : {arraylike, sparse matrix}, shape = [n_samples,n_features]
Training data
y : arraylike, shape = [n_samples]
Target values
sample_weight : float or numpy array of shape (n_samples,)
Sample weight.
New in version 0.17: sample_weight support to Classifier.
Returns: self : returns an instance of self.

get_params
(deep=True)[source]¶ Get parameters for this estimator.
Parameters: deep: boolean, optional :
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.

predict
(X)[source]¶ Predict class labels for samples in X.
Parameters: X : {arraylike, sparse matrix}, shape = [n_samples, n_features]
Samples.
Returns: C : array, shape = [n_samples]
Predicted class label per sample.

score
(X, y, sample_weight=None)[source]¶ Returns the mean accuracy on the given test data and labels.
In multilabel 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 : arraylike, shape = (n_samples, n_features)
Test samples.
y : arraylike, shape = (n_samples) or (n_samples, n_outputs)
True labels for X.
sample_weight : arraylike, shape = [n_samples], optional
Sample weights.
Returns: score : float
Mean accuracy of self.predict(X) wrt. y.

set_params
(**params)[source]¶ Set the parameters of this estimator.
The method works on simple estimators as well as on nested objects (such as pipelines). The former have parameters of the form
<component>__<parameter>
so that it’s possible to update each component of a nested object.Returns: self :