\c @sydZddlmZmZddlZddlZddlmZddlm Z ddl mZ ddl m Z mZmZddlmZd d l mZd d lmZd d lmZd d lmZd dlmZd dlmZd dlmZd dlmZd dlmZd dlmZd dl m!Z!d dl"m#Z#d dl$m%Z%e&dddZ'e&ddZ(dZ)e&e*dZ+dZ,e&de&dde&e*e*dZ-d e!j.eefd!YZ/d"e/efd#YZ0d$e e/fd%YZ1d&efd'YZ2d(efd)YZ3d*e3efd+YZ4d,e e3fd-YZ5dS(.s Ridge regression i(tABCMetatabstractmethodN(tlinalg(tsparsei(tLinearClassifierMixint LinearModelt _rescale_data(t sag_solveri(tRegressorMixin(tsafe_sparse_dot(t row_norms(t check_X_y(t check_array(tcheck_consistent_length(tcompute_sample_weight(t column_or_1d(tLabelBinarizer(t GridSearchCV(tsix(t check_scoring(tConvergenceWarninggMbP?ic sM|j\}}tj|tj|jd|fd|j}||krafd} nfd} xt|jdD]} |dd| f} | || } ||krPtj||fd| d|j} y(tj| | d|dd\}}Wn/t k r9tj| | d|\}}nXj ||| `. Parameters ---------- X : {array-like, sparse matrix, LinearOperator}, shape = [n_samples, n_features] Training data y : array-like, shape = [n_samples] or [n_samples, n_targets] Target values alpha : {float, array-like}, shape = [n_targets] if array-like 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. If an array is passed, penalties are assumed to be specific to the targets. Hence they must correspond in number. sample_weight : float or numpy array of shape [n_samples] Individual weights for each sample. If sample_weight is not None and solver='auto', the solver will be set to 'cholesky'. .. versionadded:: 0.17 solver : {'auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg', 'sag', 'saga'} 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 closed-form solution via a Cholesky decomposition of dot(X.T, X) - '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 large-scale data (possibility to set `tol` and `max_iter`). - 'lsqr' uses the dedicated regularized least-squares routine scipy.sparse.linalg.lsqr. It is the fastest and uses an iterative procedure. - 'sag' uses a Stochastic Average Gradient descent, and 'saga' uses its improved, unbiased version named SAGA. Both methods also use an iterative procedure, and are often faster than other solvers when both n_samples and n_features are large. Note that 'sag' and 'saga' fast convergence is only guaranteed on features with approximately the same scale. You can preprocess the data with a scaler from sklearn.preprocessing. All last five solvers support both dense and sparse data. However, only 'sag' and 'saga' supports sparse input when`fit_intercept` is True. .. versionadded:: 0.17 Stochastic Average Gradient descent solver. .. versionadded:: 0.19 SAGA solver. max_iter : int, optional Maximum number of iterations for conjugate gradient solver. For the 'sparse_cg' and 'lsqr' solvers, the default value is determined by scipy.sparse.linalg. For 'sag' and saga solver, the default value is 1000. tol : float Precision of the solution. verbose : int Verbosity level. Setting verbose > 0 will display additional information depending on the solver used. random_state : int, RandomState instance or None, optional, default None The seed of the pseudo random number generator to use when shuffling the data. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``solver`` == 'sag'. return_n_iter : boolean, default False If True, the method also returns `n_iter`, the actual number of iteration performed by the solver. .. versionadded:: 0.17 return_intercept : boolean, default False If True and if X is sparse, the method also returns the intercept, and the solver is automatically changed to 'sag'. This is only a temporary fix for fitting the intercept with sparse data. For dense data, use sklearn.linear_model._preprocess_data before your regression. .. versionadded:: 0.17 Returns ------- coef : array, shape = [n_features] or [n_targets, n_features] Weight vector(s). n_iter : int, optional The actual number of iteration performed by the solver. Only returned if `return_n_iter` is True. intercept : float or array, shape = [n_targets] The intercept of the model. Only returned if `return_intercept` is True and if X is a scipy sparse array. Notes ----- This function won't compute the intercept. tsagRwsIn Ridge, only 'sag' solver can currently fit the intercept when X is sparse. Solver has been automatically changed into 'sag'.tsagat accept_sparsetcsrRtorderR9t ensure_2dtFtcsctcooisTarget y has the wrong shape %siis:Number of samples in X and y does not correspond: %d != %dtcholeskyt sparse_cgs)Sample weights must be 1D array or scalarsENumber of targets and number of penalties do not correspond: %d != %dRjRBsSolver %s not understoodRFtsquaredR:itis_sagas3SVD solver does not support sparse inputs currentlyN(RxRy(RxRy(RRRjRBRxRy(RxRy(+RtissparseR,R-R$tfloat64tfloat32R RPRR R!tndimR*tstrtreshapeRJR+RZRtasarrayRQRmtrepeatR<RER RIRhRR`RXR tmaxR%R@Rlt enumerateROtintRR)Rv(R.R/R0RctsolverR1RR2t random_statet return_n_itertreturn_interceptt_dtypeR3R4RQt n_samples_RRRdRCR:RbRftmax_squared_sumt interceptR6talpha_iRVtinittcoef_tn_iter_t_((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pytridge_regressionsz!   $            !     +&       t _BaseRidgec Bs;eZedeeedddddZddZRS(g?gMbP?Rwc CsL||_||_||_||_||_||_||_||_dS(N(R0t fit_interceptt normalizetcopy_XR1RRR( tselfR0RRRR1RRR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyt__init__s       cCs|jdkrtj}ntjtjg}t||dddgd|dtdt\}}|dk rtj|jd krt d n|j |||j |j |j d |\}}}}}tj|rV|j rVt||d |jd |d |jd|jd|jd|jdtdt\|_|_|_|j|7_nmt||d |jd |d |jd|jd|jd|jdtdt\|_|_|j||||S(NRxRyR{RRRt multi_outputt y_numericis)Sample weights must be 1D array or scalarRcR0R1RRRRR(RxRy(RR$RRR RJR+RZRR*t_preprocess_dataRRRRRRR0R1RRRRt intercept_RPt_set_intercept(RR.R/RcRtX_offsetty_offsettX_scale((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pytfits2  N(t__name__t __module__RRJRPR+RR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs    tRidgec Bs;eZdZdeeedddddZddZRS(sLinear least squares with l2 regularization. Minimizes the objective function:: ||y - Xw||^2_2 + alpha * ||w||^2_2 This model solves a regression model where the loss function is the linear least squares function and regularization is given by the l2-norm. Also known as Ridge Regression or Tikhonov regularization. This estimator has built-in support for multi-variate regression (i.e., when y is a 2d-array of shape [n_samples, n_targets]). Read more in the :ref:`User Guide `. Parameters ---------- alpha : {float, array-like}, shape (n_targets) 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. If an array is passed, penalties are assumed to be specific to the targets. Hence they must correspond in number. 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). normalize : boolean, optional, 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``. copy_X : boolean, optional, default True If True, X will be copied; else, it may be overwritten. max_iter : int, optional Maximum number of iterations for conjugate gradient solver. For 'sparse_cg' and 'lsqr' solvers, the default value is determined by scipy.sparse.linalg. For 'sag' solver, the default value is 1000. tol : float Precision of the solution. solver : {'auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg', 'sag', 'saga'} 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 closed-form 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 large-scale data (possibility to set `tol` and `max_iter`). - 'lsqr' uses the dedicated regularized least-squares routine scipy.sparse.linalg.lsqr. It is the fastest and uses an iterative procedure. - 'sag' uses a Stochastic Average Gradient descent, and 'saga' uses its improved, unbiased version named SAGA. Both methods also use an iterative procedure, and are often faster than other solvers when both n_samples and n_features are large. Note that 'sag' and 'saga' fast convergence is only guaranteed on features with approximately the same scale. You can preprocess the data with a scaler from sklearn.preprocessing. All last five solvers support both dense and sparse data. However, only 'sag' and 'saga' supports sparse input when `fit_intercept` is True. .. versionadded:: 0.17 Stochastic Average Gradient descent solver. .. versionadded:: 0.19 SAGA solver. random_state : int, RandomState instance or None, optional, default None The seed of the pseudo random number generator to use when shuffling the data. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``solver`` == 'sag'. .. versionadded:: 0.17 *random_state* to support Stochastic Average Gradient. Attributes ---------- coef_ : array, shape (n_features,) or (n_targets, 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. .. versionadded:: 0.17 See also -------- RidgeClassifier : Ridge classifier RidgeCV : Ridge regression with built-in cross validation :class:`sklearn.kernel_ridge.KernelRidge` : Kernel ridge regression combines ridge regression with the kernel trick Examples -------- >>> from sklearn.linear_model import Ridge >>> import numpy as np >>> n_samples, n_features = 10, 5 >>> np.random.seed(0) >>> y = np.random.randn(n_samples) >>> X = np.random.randn(n_samples, n_features) >>> clf = Ridge(alpha=1.0) >>> clf.fit(X, y) # doctest: +NORMALIZE_WHITESPACE Ridge(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=None, normalize=False, random_state=None, solver='auto', tol=0.001) g?gMbP?Rwc CsGtt|jd|d|d|d|d|d|d|d|dS( NR0RRRR1RRR(tsuperRR( RR0RRRR1RRR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs cCstt|j||d|S(sFit Ridge regression model Parameters ---------- X : {array-like, sparse matrix}, shape = [n_samples, n_features] Training data y : array-like, shape = [n_samples] or [n_samples, n_targets] Target values sample_weight : float or numpy array of shape [n_samples] Individual weights for each sample Returns ------- self : returns an instance of self. Rc(RRR(RR.R/Rc((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRsN(RRt__doc__RJRPR+RR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs    tRidgeClassifierc BsMeZdZdeeedddddd ZddZedZ RS(seClassifier using Ridge regression. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float 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 : 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). normalize : boolean, optional, 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``. copy_X : boolean, optional, default True If True, X will be copied; else, it may be overwritten. max_iter : int, optional Maximum number of iterations for conjugate gradient solver. The default value is determined by scipy.sparse.linalg. tol : float Precision of the solution. 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))`` solver : {'auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg', 'sag', 'saga'} 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 closed-form 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 large-scale data (possibility to set `tol` and `max_iter`). - 'lsqr' uses the dedicated regularized least-squares routine scipy.sparse.linalg.lsqr. It is the fastest and uses an iterative procedure. - 'sag' uses a Stochastic Average Gradient descent, and 'saga' uses its unbiased and more flexible version named SAGA. Both methods use an iterative procedure, and are often faster than other solvers when both n_samples and n_features are large. Note that 'sag' and 'saga' fast convergence is only guaranteed on features with approximately the same scale. You can preprocess the data with a scaler from sklearn.preprocessing. .. versionadded:: 0.17 Stochastic Average Gradient descent solver. .. versionadded:: 0.19 SAGA solver. random_state : int, RandomState instance or None, optional, default None The seed of the pseudo random number generator to use when shuffling the data. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``solver`` == 'sag'. 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. Examples -------- >>> from sklearn.datasets import load_breast_cancer >>> from sklearn.linear_model import RidgeClassifier >>> X, y = load_breast_cancer(return_X_y=True) >>> clf = RidgeClassifier().fit(X, y) >>> clf.score(X, y) # doctest: +ELLIPSIS 0.9595... See also -------- Ridge : Ridge regression RidgeClassifierCV : Ridge classifier 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. g?gMbP?Rwc CsPtt|jd|d|d|d|d|d|d|d| ||_dS( NR0RRRR1RRR(RRRt class_weight( RR0RRRR1RRRR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyR#s cCst||ddddgdttdddd |_|jj|}|jjjd svt|d t}ntd |j j |j r|dkrd }n|t |j |}ntt|j||d||S(sFit Ridge regression model. Parameters ---------- X : {array-like, sparse matrix}, shape = [n_samples,n_features] Training data y : array-like, shape = [n_samples] Target values sample_weight : float or numpy array of shape (n_samples,) Sample weight. .. versionadded:: 0.17 *sample_weight* support to Classifier. Returns ------- self : returns an instance of self. RzR{RRRt pos_labelit neg_labelit multilabelR-s-%s doesn't support multi-label classificationg?RcN(R RJRt_label_binarizert fit_transformty_type_t startswithRR*t __class__RRR+RRRR(RR.R/RctY((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyR,s    cCs |jjS(N(Rtclasses_(R((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRXsN( RRRRJRPR+RRtpropertyR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs v   ,t _RidgeGCVcBseZdZdeedededZedZdZdZ dZ d Z d Z ed Z d Zd ZdZddZRS(s,Ridge regression with built-in Generalized Cross-Validation It allows efficient Leave-One-Out cross-validation. This class is not intended to be used directly. Use RidgeCV instead. Notes ----- We want to solve (K + alpha*Id)c = y, where K = X X^T is the kernel matrix. Let G = (K + alpha*Id)^-1. Dual solution: c = Gy Primal solution: w = X^T c Compute eigendecomposition K = Q V Q^T. Then G = Q (V + alpha*Id)^-1 Q^T, where (V + alpha*Id) is diagonal. It is thus inexpensive to inverse for many alphas. Let loov be the vector of prediction values for each example when the model was fitted with all examples but this example. loov = (KGY - diag(KG)Y) / diag(I-KG) Let looe be the vector of prediction errors for each example when the model was fitted with all examples but this example. looe = y - loov = c / diag(G) References ---------- http://cbcl.mit.edu/publications/ps/MIT-CSAIL-TR-2007-025.pdf https://www.mit.edu/~9.520/spring07/Classes/rlsslides.pdf g?g?g$@cCsLtj||_||_||_||_||_||_||_dS(N( R$RtalphasRRtscoringRtgcv_modetstore_cv_values(RRRRRRRR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs     cCskt||jdt}|r4|tj|7}ntj|\}}tj|j|}|||fS(NRF(R RIRJR$t ones_likeRteighRk(RR.R/tcentered_kernelRbtvtQtQT_y((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyt _pre_computes cCs||djddS(Nitaxisi(tsum(Rtv_primeR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyt _decomp_diagscCsNt|jdkrF|tdftjft|jd}n||S(Ni(RLR!tsliceR+R$R^(RtDtB((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyt _diag_dots1c Csd||}tj|ddk}d||?scSs|S(N((R((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyR@s(5R R$RRJR+R\tfloatR RPR!RRRRRRRLRRR,R-RRRRRRR*RRlRRRtanytformatRRQtappendtmeantargmintdecision_functiontpredictR&targmaxtalpha_t dual_coef_R RIRRRRt cv_values_(RR.R/RcR3R4RRRRtwith_swRRRRRRRtn_yt cv_valuesR9tscorerterrorR6R0toutRtbestRtcv_values_shape((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs|! !             ("  '$   G  (g?g?g$@N(RRRRJRPR+RRRRRRRRRRRR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyR]s %        t _BaseRidgeCVcBs2eZdeedddedZddZRS(g?g?g$@cCsLtj||_||_||_||_||_||_||_dS(N( R$RRRRRtcvRR(RRRRRRRR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRWs     c Cs0|jd krt|jd|jd|jd|jd|jd|j}|j ||d||j |_ |jr|j |_ qn|jrt dni|jd6}t td|jd|j|d |jd|j}|j ||d||j}|jj|_ |j|_|j|_|S( sFit Ridge regression model Parameters ---------- X : array-like, shape = [n_samples, n_features] Training data y : array-like, shape = [n_samples] or [n_samples, n_targets] Target values. Will be cast to X's dtype if necessary sample_weight : float or array-like of shape [n_samples] Sample weight Returns ------- self : object RRRRRRcs3cv!=None and store_cv_values=True are incompatibleR0RN(RR+RRRRRRRRRRR*RRtbest_estimator_R0RR(RR.R/Rct estimatort parameterstgs((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRcs.             (g?g?g$@N(RRRJRPR+RR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRVs   tRidgeCVcBseZdZRS(sRidge regression 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. Read more in the :ref:`User Guide `. Parameters ---------- alphas : numpy array of shape [n_alphas] 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 : 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). normalize : boolean, optional, 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 or None, optional, 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, optional 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. For integer/None inputs, if ``y`` is binary or multiclass, :class:`sklearn.model_selection.StratifiedKFold` is used, else, :class:`sklearn.model_selection.KFold` is used. Refer :ref:`User Guide ` for the various cross-validation strategies that can be used here. gcv_mode : {None, 'auto', 'svd', eigen'}, optional Flag indicating which strategy to use when performing Generalized Cross-Validation. Options are:: 'auto' : use svd if n_samples > n_features or when X is a sparse matrix, otherwise use eigen 'svd' : force computation via singular value decomposition of X (does not work for sparse matrices) 'eigen' : force computation via eigendecomposition of X^T X The 'auto' mode is the default and is intended to pick the cheaper option of the two depending upon the shape and format of the training data. store_cv_values : boolean, 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_ : array, shape = [n_samples, n_alphas] or 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). coef_ : array, shape = [n_features] or [n_targets, n_features] Weight vector(s). intercept_ : float | array, shape = (n_targets,) Independent term in decision function. Set to 0.0 if ``fit_intercept = False``. alpha_ : float Estimated regularization parameter. Examples -------- >>> from sklearn.datasets import load_diabetes >>> from sklearn.linear_model import RidgeCV >>> X, y = load_diabetes(return_X_y=True) >>> clf = RidgeCV(alphas=[1e-3, 1e-2, 1e-1, 1]).fit(X, y) >>> clf.score(X, y) # doctest: +ELLIPSIS 0.5166... See also -------- Ridge : Ridge regression RidgeClassifier : Ridge classifier RidgeClassifierCV : Ridge classifier with built-in cross validation (RRR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRsktRidgeClassifierCVcBsGeZdZdeedddedZddZedZ RS( sRidge 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 `. Parameters ---------- alphas : numpy array of shape [n_alphas] 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 : 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). normalize : boolean, optional, 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 or None, optional, 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, optional 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 ` for the various cross-validation strategies that can be used here. 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))`` store_cv_values : boolean, 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_ : array, 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). coef_ : array, shape = [n_features] or [n_targets, n_features] Weight vector(s). intercept_ : float | array, shape = (n_targets,) Independent term in decision function. Set to 0.0 if ``fit_intercept = False``. alpha_ : float Estimated regularization parameter 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) # doctest: +ELLIPSIS 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. g?g?g$@c CsDtt|jd|d|d|d|d|d|||_dS(NRRRRRR(RRRR(RRRRRRRR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRjscCst||ddddgdttdddd |_|jj|}|jjjd svt|d t}n|jr|dkrd }n|t |j|}nt j |||d ||S(sFit the ridge classifier. Parameters ---------- X : array-like, shape (n_samples, n_features) Training vectors, where n_samples is the number of samples and n_features is the number of features. y : array-like, shape (n_samples,) Target values. Will be cast to X's dtype if necessary sample_weight : float or numpy array of shape (n_samples,) Sample weight. Returns ------- self : object RzR{RRRRiRiRR-g?RcN( R RJRRRRRRRR+RRR(RR.R/RcR((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRrs   cCs |jjS(N(RR(R((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs(g?g?g$@N( RRRRJRPR+RRRR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pyRs g   %(6RtabcRRR,tnumpyR$tscipyRRt scipy.sparseR"tbaseRRRRxRRt utils.extmathR R tutilsR R R RRt preprocessingRtmodel_selectionRt externalsRtmetrics.scorerRt exceptionsRR+R<RERXRPRhRvRtwith_metaclassRRRRRRR(((s9lib/python2.7/site-packages/sklearn/linear_model/ridge.pytsJ   9 =  "5<o