xhluca
diff --git a/‎doc/modules/linear_model.rst
Lines changed: 6 additions & 8 deletions b/‎doc/modules/linear_model.rst
Lines changed: 6 additions & 8 deletions
diff --git a/‎doc/whats_new/v0.21.rst
Lines changed: 0 additions & 6 deletions b/‎doc/whats_new/v0.21.rst
Lines changed: 0 additions & 6 deletions
diff --git a/‎sklearn/linear_model/logistic.py
Lines changed: 16 additions & 45 deletions b/‎sklearn/linear_model/logistic.py
Lines changed: 16 additions & 45 deletions
diff --git a/‎sklearn/linear_model/tests/test_logistic.py
Lines changed: 1 addition & 35 deletions b/‎sklearn/linear_model/tests/test_logistic.py
Lines changed: 1 addition & 35 deletions
@@ -731,7 +731,7 @@ or the log-linear classifier. In this model, the probabilities describing the po
 The implementation of logistic regression in scikit-learn can be accessed from
 class :class:`LogisticRegression`. This implementation can fit binary, One-vs-
 Rest, or multinomial logistic regression with optional L2, L1 or Elastic-Net
-regularization. Note that regularization is applied by default.
+regularization.
 
 As an optimization problem, binary class L2 penalized logistic regression
 minimizes the following cost function:
@@ -771,11 +771,11 @@ classifiers. For L1 penalization :func:`sklearn.svm.l1_min_c` allows to
 calculate the lower bound for C in order to get a non "null" (all feature
 weights to zero) model.
 
-The "lbfgs", "sag" and "newton-cg" solvers only support L2 penalization or no
-regularization, and are found to converge faster for some high dimensional
-data. Setting `multi_class` to "multinomial" with these solvers learns a true
-multinomial logistic regression model [5]_, which means that its probability
-estimates should be better calibrated than the default "one-vs-rest" setting.
+The "lbfgs", "sag" and "newton-cg" solvers only support L2 penalization and
+are found to converge faster for some high dimensional data. Setting
+`multi_class` to "multinomial" with these solvers learns a true multinomial
+logistic regression model [5]_, which means that its probability estimates
+should be better calibrated than the default "one-vs-rest" setting.
 
 The "sag" solver uses a Stochastic Average Gradient descent [6]_. It is faster
 than other solvers for large datasets, when both the number of samples and the
@@ -808,8 +808,6 @@ The following table summarizes the penalties supported by each solver:
 +------------------------------+-----------------+-------------+-----------------+-----------+------------+
 | Elastic-Net                  |       no        |     no      |       no        |    no     |    yes     |
 +------------------------------+-----------------+-------------+-----------------+-----------+------------+
-| No penalty ('none')          |       no        |     yes     |       yes       |    yes    |    yes     |
-+------------------------------+-----------------+-------------+-----------------+-----------+------------+
 | **Behaviors**                |                                                                          |
 +------------------------------+-----------------+-------------+-----------------+-----------+------------+
 | Penalize the intercept (bad) |       yes       |     no      |       no        |    no     |    no      |
 
@@ -101,12 +101,6 @@ Support for Python 3.4 and below has been officially dropped.
   :class:`linear_model.LogisticRegressionCV` now support Elastic-Net penalty,
   with the 'saga' solver. :issue:`11646` by :user:`Nicolas Hug <NicolasHug>`.
 
-- |Enhancement| :class:`linear_model.LogisticRegression` now supports an
-  unregularized objective by setting ``penalty`` to ``'none'``. This is
-  equivalent to setting ``C=np.inf`` with l2 regularization. Not supported
-  by the liblinear solver. :issue:`12860` by :user:`Nicolas Hug
-  <NicolasHug>`.
-
 - |Fix| Fixed a bug in :class:`linear_model.LogisticRegression` and
   :class:`linear_model.LogisticRegressionCV` with 'saga' solver, where the
   weights would not be correctly updated in some cases.
 
@@ -437,13 +437,13 @@ def _check_solver(solver, penalty, dual):
         raise ValueError("Logistic Regression supports only solvers in %s, got"
                          " %s." % (all_solvers, solver))
 
-    all_penalties = ['l1', 'l2', 'elasticnet', 'none']
+    all_penalties = ['l1', 'l2', 'elasticnet']
     if penalty not in all_penalties:
         raise ValueError("Logistic Regression supports only penalties in %s,"
                          " got %s." % (all_penalties, penalty))
 
-    if solver not in ['liblinear', 'saga'] and penalty not in ('l2', 'none'):
-        raise ValueError("Solver %s supports only 'l2' or 'none' penalties, "
+    if solver not in ['liblinear', 'saga'] and penalty != 'l2':
+        raise ValueError("Solver %s supports only l2 penalties, "
                          "got %s penalty." % (solver, penalty))
     if solver != 'liblinear' and dual:
         raise ValueError("Solver %s supports only "
@@ -452,12 +452,6 @@ def _check_solver(solver, penalty, dual):
     if penalty == 'elasticnet' and solver != 'saga':
         raise ValueError("Only 'saga' solver supports elasticnet penalty,"
                          " got solver={}.".format(solver))
-
-    if solver == 'liblinear' and penalty == 'none':
-        raise ValueError(
-            "penalty='none' is not supported for the liblinear solver"
-        )
-
     return solver
 
 
@@ -1211,27 +1205,24 @@ class LogisticRegression(BaseEstimator, LinearClassifierMixin,
     'sag', 'saga' and 'newton-cg' solvers.)
 
     This class implements regularized logistic regression using the
-    'liblinear' library, 'newton-cg', 'sag', 'saga' and 'lbfgs' solvers. **Note
-    that regularization is applied by default**. It can handle both dense
-    and sparse input. Use C-ordered arrays or CSR matrices containing 64-bit
-    floats for optimal performance; any other input format will be converted
-    (and copied).
+    'liblinear' library, 'newton-cg', 'sag', 'saga' and 'lbfgs' solvers. It can
+    handle both dense and sparse input. Use C-ordered arrays or CSR matrices
+    containing 64-bit floats for optimal performance; any other input format
+    will be converted (and copied).
 
     The 'newton-cg', 'sag', and 'lbfgs' solvers support only L2 regularization
-    with primal formulation, or no regularization. The 'liblinear' solver
-    supports both L1 and L2 regularization, with a dual formulation only for
-    the L2 penalty. The Elastic-Net regularization is only supported by the
-    'saga' solver.
+    with primal formulation. The 'liblinear' solver supports both L1 and L2
+    regularization, with a dual formulation only for the L2 penalty. The
+    Elastic-Net regularization is only supported by the 'saga' solver.
 
     Read more in the :ref:`User Guide <logistic_regression>`.
 
     Parameters
     ----------
-    penalty : str, 'l1', 'l2', 'elasticnet' or 'none', optional (default='l2')
+    penalty : str, 'l1', 'l2', or 'elasticnet', optional (default='l2')
         Used to specify the norm used in the penalization. The 'newton-cg',
         'sag' and 'lbfgs' solvers support only l2 penalties. 'elasticnet' is
-        only supported by the 'saga' solver. If 'none' (not supported by the
-        liblinear solver), no regularization is applied.
+        only supported by the 'saga' solver.
 
         .. versionadded:: 0.19
            l1 penalty with SAGA solver (allowing 'multinomial' + L1)
@@ -1298,10 +1289,8 @@ class LogisticRegression(BaseEstimator, LinearClassifierMixin,
         - For multiclass problems, only 'newton-cg', 'sag', 'saga' and 'lbfgs'
           handle multinomial loss; 'liblinear' is limited to one-versus-rest
           schemes.
-        - 'newton-cg', 'lbfgs', 'sag' and 'saga' handle L2 or no penalty
-        - 'liblinear' and 'saga' also handle L1 penalty
-        - 'saga' also supports 'elasticnet' penalty
-        - 'liblinear' does not handle no penalty
+        - 'newton-cg', 'lbfgs' and 'sag' only handle L2 penalty, whereas
+          'liblinear' and 'saga' handle L1 penalty.
 
         Note that 'sag' and 'saga' fast convergence is only guaranteed on
         features with approximately the same scale. You can
@@ -1502,18 +1491,6 @@ def fit(self, X, y, sample_weight=None):
             warnings.warn("l1_ratio parameter is only used when penalty is "
                           "'elasticnet'. Got "
                           "(penalty={})".format(self.penalty))
-        if self.penalty == 'none':
-            if self.C != 1.0:  # default values
-                warnings.warn(
-                    "Setting penalty='none' will ignore the C and l1_ratio "
-                    "parameters"
-                )
-                # Note that check for l1_ratio is done right above
-            C_ = np.inf
-            penalty = 'l2'
-        else:
-            C_ = self.C
-            penalty = self.penalty
         if not isinstance(self.max_iter, numbers.Number) or self.max_iter < 0:
             raise ValueError("Maximum number of iteration must be positive;"
                              " got (max_iter=%r)" % self.max_iter)
@@ -1593,13 +1570,13 @@ def fit(self, X, y, sample_weight=None):
             prefer = 'processes'
         fold_coefs_ = Parallel(n_jobs=self.n_jobs, verbose=self.verbose,
                                **_joblib_parallel_args(prefer=prefer))(
-            path_func(X, y, pos_class=class_, Cs=[C_],
+            path_func(X, y, pos_class=class_, Cs=[self.C],
                       l1_ratio=self.l1_ratio, fit_intercept=self.fit_intercept,
                       tol=self.tol, verbose=self.verbose, solver=solver,
                       multi_class=multi_class, max_iter=self.max_iter,
                       class_weight=self.class_weight, check_input=False,
                       random_state=self.random_state, coef=warm_start_coef_,
-                      penalty=penalty, max_squared_sum=max_squared_sum,
+                      penalty=self.penalty, max_squared_sum=max_squared_sum,
                       sample_weight=sample_weight)
             for class_, warm_start_coef_ in zip(classes_, warm_start_coef))
 
@@ -1991,12 +1968,6 @@ def fit(self, X, y, sample_weight=None):
 
             l1_ratios_ = [None]
 
-        if self.penalty == 'none':
-            raise ValueError(
-                "penalty='none' is not useful and not supported by "
-                "LogisticRegressionCV."
-            )
-
         X, y = check_X_y(X, y, accept_sparse='csr', dtype=np.float64,
                          order="C",
                          accept_large_sparse=solver != 'liblinear')
 
@@ -234,7 +234,7 @@ def test_check_solver_option(LR):
 
     # all solvers except 'liblinear' and 'saga'
     for solver in ['newton-cg', 'lbfgs', 'sag']:
-        msg = ("Solver %s supports only 'l2' or 'none' penalties," %
+        msg = ("Solver %s supports only l2 penalties, got l1 penalty." %
                solver)
         lr = LR(solver=solver, penalty='l1', multi_class='ovr')
         assert_raise_message(ValueError, msg, lr.fit, X, y)
@@ -253,11 +253,6 @@ def test_check_solver_option(LR):
         lr = LR(solver=solver, penalty='elasticnet')
         assert_raise_message(ValueError, msg, lr.fit, X, y)
 
-    # liblinear does not support penalty='none'
-    msg = "penalty='none' is not supported for the liblinear solver"
-    lr = LR(penalty='none', solver='liblinear')
-    assert_raise_message(ValueError, msg, lr.fit, X, y)
-
 
 @pytest.mark.parametrize('model, params, warn_solver',
                          [(LogisticRegression, {}, True),
@@ -1759,32 +1754,3 @@ def test_logistic_regression_path_deprecation():
     assert_warns_message(DeprecationWarning,
                          "logistic_regression_path was deprecated",
                          logistic_regression_path, X, Y1)
-
-
-@pytest.mark.parametrize('solver', ('lbfgs', 'newton-cg', 'sag', 'saga'))
-def test_penalty_none(solver):
-    # - Make sure warning is raised if penalty='none' and C is set to a
-    #   non-default value.
-    # - Make sure setting penalty='none' is equivalent to setting C=np.inf with
-    #   l2 penalty.
-    X, y = make_classification(n_samples=1000, random_state=0)
-
-    msg = "Setting penalty='none' will ignore the C"
-    lr = LogisticRegression(penalty='none', solver=solver, C=4)
-    assert_warns_message(UserWarning, msg, lr.fit, X, y)
-
-    lr_none = LogisticRegression(penalty='none', solver=solver,
-                                 random_state=0)
-    lr_l2_C_inf = LogisticRegression(penalty='l2', C=np.inf, solver=solver,
-                                     random_state=0)
-    pred_none = lr_none.fit(X, y).predict(X)
-    pred_l2_C_inf = lr_l2_C_inf.fit(X, y).predict(X)
-    assert_array_equal(pred_none, pred_l2_C_inf)
-
-    lr = LogisticRegressionCV(penalty='none')
-    assert_raise_message(
-        ValueError,
-        "penalty='none' is not useful and not supported by "
-        "LogisticRegressionCV",
-        lr.fit, X, y
-    )