'Fit 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. Will be cast to X\'s dtype if necessary
sample_weight : float or array-like of shape [n_samples]
Sample weight
Returns
self : Returns self.'

def fit(self, X, y, sample_weight=None):

    (X, y) = check_X_y(X, y, ['csr', 'csc', 'coo'], dtype=np.float64, multi_output=True, y_numeric=True)
    if ((sample_weight is not None) and (not isinstance(sample_weight, float))):
        sample_weight = check_array(sample_weight, ensure_2d=False)
    (n_samples, n_features) = X.shape
    (X, y, X_offset, y_offset, X_scale) = LinearModel._preprocess_data(X, y, self.fit_intercept, self.normalize, self.copy_X, sample_weight=sample_weight)
    gcv_mode = self.gcv_mode
    with_sw = len(np.shape(sample_weight))
    if ((gcv_mode is None) or (gcv_mode == 'auto')):
        if (sparse.issparse(X) or (n_features > n_samples) or with_sw):
            gcv_mode = 'eigen'
        else:
            gcv_mode = 'svd'
    elif ((gcv_mode == 'svd') and with_sw):
        warnings.warn('non-uniform    sample    weights    unsupported    for    svd,    forcing    usage    of    eigen')
        gcv_mode = 'eigen'
    if (gcv_mode == 'eigen'):
        _pre_compute = self._pre_compute
        _errors = self._errors
        _values = self._values
    elif (gcv_mode == 'svd'):
        _pre_compute = self._pre_compute_svd
        _errors = self._errors_svd
        _values = self._values_svd
    else:
        raise ValueError(('bad    gcv_mode    "%s"' % gcv_mode))
    if (sample_weight is not None):
        (X, y) = _rescale_data(X, y, sample_weight)
    centered_kernel = ((not sparse.issparse(X)) and self.fit_intercept)
    (v, Q, QT_y) = _pre_compute(X, y, centered_kernel)
    n_y = (1 if (len(y.shape) == 1) else y.shape[1])
    cv_values = np.zeros(((n_samples * n_y), len(self.alphas)))
    C = []
    scorer = check_scoring(self, scoring=self.scoring, allow_none=True)
    error = (scorer is None)
    for (i, alpha) in enumerate(self.alphas):
        if error:
            (out, c) = _errors(alpha, y, v, Q, QT_y)
        else:
            (out, c) = _values(alpha, y, v, Q, QT_y)
        cv_values[:, i] = out.ravel()
        C.append(c)
    if error:
        best = cv_values.mean(axis=0).argmin()
    else:
        def identity_estimator():
            pass
        identity_estimator.decision_function = (lambda y_predict: y_predict)
        identity_estimator.predict = (lambda y_predict: y_predict)
        out = [scorer(identity_estimator, y.ravel(), cv_values[:, i]) for i in range(len(self.alphas))]
        best = np.argmax(out)
    self.alpha_ = self.alphas[best]
    self.dual_coef_ = C[best]
    self.coef_ = safe_sparse_dot(self.dual_coef_.T, X)
    self._set_intercept(X_offset, y_offset, X_scale)
    if self.store_cv_values:
        if (len(y.shape) == 1):
            cv_values_shape = (n_samples, len(self.alphas))
        else:
            cv_values_shape = (n_samples, n_y, len(self.alphas))
        self.cv_values_ = cv_values.reshape(cv_values_shape)
    return self
