scikit-learn
diff --git a/‎sklearn/linear_model/ridge.py
Lines changed: 36 additions & 9 deletions b/‎sklearn/linear_model/ridge.py
Lines changed: 36 additions & 9 deletions
diff --git a/‎sklearn/linear_model/tests/test_ridge.py
Lines changed: 16 additions & 0 deletions b/‎sklearn/linear_model/tests/test_ridge.py
Lines changed: 16 additions & 0 deletions
@@ -194,7 +194,7 @@ def _solve_svd(X, y, alpha):
 
 def ridge_regression(X, y, alpha, sample_weight=None, solver='auto',
                      max_iter=None, tol=1e-3, verbose=0, random_state=None,
-                     return_n_iter=False):
+                     return_n_iter=False, return_intercept=False):
     """Solve the ridge equation by the method of normal equations.
 
     Read more in the :ref:`User Guide <ridge_regression>`.
@@ -268,6 +268,11 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto',
         If True, the method also returns `n_iter`, the actual number of
         iteration performed by the solver.
 
+    return_intercept : boolean, default False
+        If True, 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.
+
     Returns
     -------
     coef : array, shape = [n_features] or [n_targets, n_features]
@@ -281,6 +286,9 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto',
     -----
     This function won't compute the intercept.
     """
+    if return_intercept:
+        solver = 'sag'
+
     # SAG needs X and y columns to be C-contiguous and np.float64
     if solver == 'sag':
         X = check_array(X, accept_sparse=['csr'],
@@ -375,12 +383,18 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto',
 
         coef = np.empty((y.shape[1], n_features))
         n_iter = np.empty(y.shape[1], dtype=np.int32)
+        intercept = np.zeros((y.shape[1], ))
         for i, (alpha_i, target) in enumerate(zip(alpha, y.T)):
+            start = {'coef': np.zeros(n_features + int(return_intercept))}
             coef_, n_iter_, _ = sag_solver(
                 X, target.ravel(), sample_weight, 'squared', alpha_i,
                 max_iter, tol, verbose, random_state, False, max_squared_sum,
-                dict())
-            coef[i] = coef_
+                start)
+            if return_intercept:
+                coef[i] = coef_[:-1]
+                intercept[i] = coef_[-1]
+            else:
+                coef[i] = coef_
             n_iter[i] = n_iter_
 
         coef = np.asarray(coef)
@@ -395,7 +409,11 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto',
         # When y was passed as a 1d-array, we flatten the coefficients.
         coef = coef.ravel()
 
-    if return_n_iter:
+    if return_n_iter and return_intercept:
+        return coef, n_iter, intercept
+    elif return_intercept:
+        return coef, intercept
+    elif return_n_iter:
         return coef, n_iter
     else:
         return coef
@@ -428,12 +446,21 @@ def fit(self, X, y, sample_weight=None):
             X, y, self.fit_intercept, self.normalize, self.copy_X,
             sample_weight=sample_weight)
 
-        self.coef_, self.n_iter_ = ridge_regression(
-            X, y, alpha=self.alpha, sample_weight=sample_weight,
-            max_iter=self.max_iter, tol=self.tol, solver=self.solver,
-            random_state=self.random_state, return_n_iter=True)
+        if sparse.issparse(X) and self.fit_intercept:
+            self.coef_, self.n_iter_, self.intercept_ = ridge_regression(
+                X, y, alpha=self.alpha, sample_weight=sample_weight,
+                max_iter=self.max_iter, tol=self.tol, solver=self.solver,
+                random_state=self.random_state, return_n_iter=True,
+                return_intercept=True)
+            self.intercept_ += y_mean
+        else:
+            self.coef_, self.n_iter_ = ridge_regression(
+                X, y, alpha=self.alpha, sample_weight=sample_weight,
+                max_iter=self.max_iter, tol=self.tol, solver=self.solver,
+                random_state=self.random_state, return_n_iter=True,
+                return_intercept=False)
+            self._set_intercept(X_mean, y_mean, X_std)
 
-        self._set_intercept(X_mean, y_mean, X_std)
         return self
 
 
 
@@ -694,3 +694,19 @@ def test_n_iter():
         reg = Ridge(solver=solver, max_iter=1, tol=1e-1)
         reg.fit(X, y_n)
         assert_equal(reg.n_iter_, None)
+
+
+def test_ridge_fit_intercept_sparse():
+    r = np.random.RandomState(42)
+    X = r.randn(1000, 2)
+    w = r.randn(2)
+    i = 10
+    y = np.dot(X, w) + i
+    X_csr = sp.csr_matrix(X)
+
+    dense = Ridge(alpha=1., tol=1.e-15, solver='sag', fit_intercept=True)
+    sparse = Ridge(alpha=1., tol=1.e-15, solver='sag', fit_intercept=True)
+    dense.fit(X, y)
+    sparse.fit(X_csr, y)
+    assert_almost_equal(dense.intercept_, sparse.intercept_)
+    assert_array_almost_equal(dense.coef_, sparse.coef_)