kernc
diff --git a/‎sklearn/linear_model/base.py
Lines changed: 5 additions & 2 deletions b/‎sklearn/linear_model/base.py
Lines changed: 5 additions & 2 deletions
diff --git a/‎sklearn/linear_model/logistic.py
Lines changed: 30 additions & 5 deletions b/‎sklearn/linear_model/logistic.py
Lines changed: 30 additions & 5 deletions
@@ -269,12 +269,15 @@ def predict(self, X):
 
     _preprocess_data = staticmethod(_preprocess_data)
 
-    def _set_intercept(self, X_offset, y_offset, X_scale):
+    def _set_intercept(self, X_offset, y_offset, X_scale, intercept_=None):
         """Set the intercept_
         """
         if self.fit_intercept:
             self.coef_ = self.coef_ / X_scale
-            self.intercept_ = y_offset - np.dot(X_offset, self.coef_.T)
+            if intercept_ is None:
+                self.intercept_ = y_offset - np.dot(X_offset, self.coef_.T)
+            else:
+                self.intercept_ = y_offset - intercept_
         else:
             self.intercept_ = 0.
 
 
@@ -16,7 +16,8 @@
 import numpy as np
 from scipy import optimize, sparse
 
-from .base import LinearClassifierMixin, SparseCoefMixin, BaseEstimator
+from .base import (LinearClassifierMixin, SparseCoefMixin, BaseEstimator,
+                   LinearModel)
 from .sag import sag_solver
 from ..feature_selection.from_model import _LearntSelectorMixin
 from ..preprocessing import LabelEncoder, LabelBinarizer
@@ -987,7 +988,9 @@ class LogisticRegression(BaseEstimator, LinearClassifierMixin,
 
     fit_intercept : bool, default: True
         Specifies if a constant (a.k.a. bias or intercept) should be
-        added to the decision function.
+        added to the decision function. If set to false, no intercept
+        will be used in calculations (e.g. data is expected to be already
+        centered).
 
     intercept_scaling : float, default: 1
         Useful only if solver is liblinear.
@@ -1001,6 +1004,19 @@ class LogisticRegression(BaseEstimator, LinearClassifierMixin,
         To lessen the effect of regularization on synthetic feature weight
         (and therefore on the intercept) intercept_scaling has to be increased.
 
+    normalize : boolean, optional, default: False
+        If True, the regressors X will be normalized before regression.
+        This parameter is ignored when `fit_intercept` is set to False.
+        When the regressors are normalized, note that this makes the
+        hyperparameters learnt more robust and almost independent of the number
+        of samples. The same property is not valid for standardized data.
+        However, if you wish to standardize, please use
+        `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.
+
     class_weight : dict or 'balanced', default: None
         Weights associated with classes in the form ``{class_label: weight}``.
         If not given, all classes are supposed to have weight one.
@@ -1114,16 +1130,19 @@ class LogisticRegression(BaseEstimator, LinearClassifierMixin,
     """
 
     def __init__(self, penalty='l2', dual=False, tol=1e-4, C=1.0,
-                 fit_intercept=True, intercept_scaling=1, class_weight=None,
-                 random_state=None, solver='liblinear', max_iter=100,
-                 multi_class='ovr', verbose=0, warm_start=False, n_jobs=1):
+                 fit_intercept=True, intercept_scaling=1, normalize=False,
+                 copy_X=True, class_weight=None, random_state=None,
+                 solver='liblinear', max_iter=100, multi_class='ovr',
+                 verbose=0, warm_start=False, n_jobs=1):
 
         self.penalty = penalty
         self.dual = dual
         self.tol = tol
         self.C = C
         self.fit_intercept = fit_intercept
         self.intercept_scaling = intercept_scaling
+        self.normalize = normalize
+        self.copy_X = copy_X
         self.class_weight = class_weight
         self.random_state = random_state
         self.solver = solver
@@ -1176,13 +1195,18 @@ def fit(self, X, y, sample_weight=None):
         _check_solver_option(self.solver, self.multi_class, self.penalty,
                              self.dual)
 
+        X, y, X_offset, y_offset, X_scale = self._preprocess_data(
+            X, y, self.fit_intercept, self.normalize, self.copy_X,
+            sample_weight=sample_weight)
+
         if self.solver == 'liblinear':
             self.coef_, self.intercept_, n_iter_ = _fit_liblinear(
                 X, y, self.C, self.fit_intercept, self.intercept_scaling,
                 self.class_weight, self.penalty, self.dual, self.verbose,
                 self.max_iter, self.tol, self.random_state,
                 sample_weight=sample_weight)
             self.n_iter_ = np.array([n_iter_])
+            self._set_intercept(X_offset, y_offset, X_scale, self.intercept_)
             return self
 
         if self.solver == 'sag':
@@ -1251,6 +1275,7 @@ def fit(self, X, y, sample_weight=None):
         if self.fit_intercept:
             self.intercept_ = self.coef_[:, -1]
             self.coef_ = self.coef_[:, :-1]
+            self._set_intercept(X_offset, y_offset, X_scale, self.intercept_)
 
         return self