def fit(self, X, y, sample_weight=None): """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 sample_weight : float or array-like of shape [n_samples] Sample weight Returns ------- self : Returns self. """ X, y = check_X_y(X, y, ['csr', 'csc', 'coo'], dtype=np.float64, multi_output=True, y_numeric=True) n_samples, n_features = X.shape if hasattr(LinearModel, '_preprocess_data'): # Scikit-learn 0.18 and up 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) else: X, y, X_offset, y_offset, X_scale = LinearModel._center_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: # FIXME non-uniform sample weights not yet supported 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': # assert n_samples >= n_features _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) # Ensure that y is a 2D array: n_samples x n_targets flat_y = y.ndim == 1 if flat_y: y = np.atleast_2d(y).T n_targets = y.shape[1] centered_kernel = not sparse.issparse(X) and self.fit_intercept v, Q, QT_y = _pre_compute(X, y, centered_kernel) cv_values = np.zeros((n_samples, n_targets, 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 C.append(c) if self.store_cv_values: self.cv_values_ = cv_values if error: if self.alpha_per_target: # Find the best alpha for each target best = cv_values.mean(axis=0).argmin(axis=1) else: # Find the best alpha overall best = np.mean(cv_values.reshape(-1, len(self.alphas)), axis=0).argmin() else: # The scorer wants an object that will make the predictions, but # they are already computed efficiently by RidgeGCV. This # identity_estimator will just return them def identity_estimator(): pass identity_estimator.decision_function = lambda y_predict: y_predict identity_estimator.predict = lambda y_predict: y_predict if self.alpha_per_target: out = [ scorer(identity_estimator, target, cv_values[:, i, j]) for j in range(len(self.alphas)) for i, target in enumerate(y.T) ] best = np.argmax(out, axis=1) else: out = [ scorer(identity_estimator, y.ravel(), cv_values[:, :, i].ravel()) for i in range(len(self.alphas)) ] best = np.argmax(out) self.alpha_ = self.alphas[best] if self.alpha_per_target: self.dual_coef_ = np.vstack( [C[j][:, i] for i, j in enumerate(best)]).T else: self.dual_coef_ = C[best] self.coef_ = safe_sparse_dot(self.dual_coef_.T, X) # If the original y was flat, remove some dimensions to match if flat_y: if self.store_cv_values: self.cv_values_ = cv_values.reshape(n_samples, len(self.alphas)) self.coef_ = self.coef_.ravel() self._set_intercept(X_offset, y_offset, X_scale) return self