Merge pull request scikit-learn#4770 from TomDLT/logistic

ogrisel · ogrisel · commit 4eda9e6bcf1a · 2015-05-27T15:12:07.000+02:00
[MRG+3] improve parameter check in LogisticRegression
diff --git a/sklearn/linear_model/logistic.py b/sklearn/linear_model/logistic.py
@@ -391,6 +391,28 @@ def hessp(v):
     return grad, hessp
 
 
+def _check_solver_option(solver, multi_class, penalty, dual):
+    if solver not in ['liblinear', 'newton-cg', 'lbfgs']:
+        raise ValueError("Logistic Regression supports only liblinear,"
+                         " newton-cg and lbfgs solvers, got %s" % solver)
+
+    if multi_class not in ['multinomial', 'ovr']:
+        raise ValueError("multi_class should be either multinomial or "
+                         "ovr, got %s" % multi_class)
+
+    if multi_class == 'multinomial' and solver == 'liblinear':
+        raise ValueError("Solver %s does not support "
+                         "a multinomial backend." % solver)
+
+    if solver != 'liblinear':
+        if penalty != 'l2':
+            raise ValueError("Solver %s supports only l2 penalties, "
+                             "got %s penalty." % (solver, penalty))
+        if dual:
+            raise ValueError("Solver %s supports only "
+                             "dual=False, got dual=%s" % (solver, dual))
+
+
 def logistic_regression_path(X, y, pos_class=None, Cs=10, fit_intercept=True,
                              max_iter=100, tol=1e-4, verbose=0,
                              solver='lbfgs', coef=None, copy=True,
@@ -501,25 +523,8 @@ def logistic_regression_path(X, y, pos_class=None, Cs=10, fit_intercept=True,
     if isinstance(Cs, numbers.Integral):
         Cs = np.logspace(-4, 4, Cs)
 
-    if multi_class not in ['multinomial', 'ovr']:
-        raise ValueError("multi_class can be either 'multinomial' or 'ovr'"
-                         "got %s" % multi_class)
-
-    if solver not in ['liblinear', 'newton-cg', 'lbfgs']:
-        raise ValueError("Logistic Regression supports only liblinear,"
-                         " newton-cg and lbfgs solvers. got %s" % solver)
-
-    if multi_class == 'multinomial' and solver == 'liblinear':
-        raise ValueError("Solver %s cannot solve problems with "
-                         "a multinomial backend." % solver)
+    _check_solver_option(solver, multi_class, penalty, dual)
 
-    if solver != 'liblinear':
-        if penalty != 'l2':
-            raise ValueError("newton-cg and lbfgs solvers support only "
-                             "l2 penalties, got %s penalty." % penalty)
-        if dual:
-            raise ValueError("newton-cg and lbfgs solvers support only "
-                             "dual=False, got dual=%s" % dual)
     # Preprocessing.
     X = check_array(X, accept_sparse='csr', dtype=np.float64)
     y = check_array(y, ensure_2d=False, copy=copy, dtype=None)
@@ -781,6 +786,7 @@ def _log_reg_scoring_path(X, y, train, test, pos_class=None, Cs=10,
     scores : ndarray, shape (n_cs,)
         Scores obtained for each Cs.
     """
+    _check_solver_option(solver, multi_class, penalty, dual)
 
     log_reg = LogisticRegression(fit_intercept=fit_intercept)
 
@@ -1015,18 +1021,9 @@ def fit(self, X, y):
 
         X, y = check_X_y(X, y, accept_sparse='csr', dtype=np.float64, order="C")
         self.classes_ = np.unique(y)
-        if self.solver not in ['liblinear', 'newton-cg', 'lbfgs']:
-            raise ValueError(
-                "Logistic Regression supports only liblinear, newton-cg and "
-                "lbfgs solvers, Got solver=%s" % self.solver
-                )
 
-        if self.solver == 'liblinear' and self.multi_class == 'multinomial':
-            raise ValueError("Solver %s does not support a multinomial "
-                             "backend." % self.solver)
-        if self.multi_class not in ['ovr', 'multinomial']:
-            raise ValueError("multi_class should be either ovr or multinomial "
-                             "got %s" % self.multi_class)
+        _check_solver_option(self.solver, self.multi_class, self.penalty,
+                             self.dual)
 
         if self.solver == 'liblinear':
             self.coef_, self.intercept_, self.n_iter_ = _fit_liblinear(
@@ -1308,22 +1305,19 @@ def fit(self, X, y):
         self : object
             Returns self.
         """
-        if self.solver != 'liblinear':
-            if self.penalty != 'l2':
-                raise ValueError("newton-cg and lbfgs solvers support only "
-                                 "l2 penalties.")
-            if self.dual:
-                raise ValueError("newton-cg and lbfgs solvers support only "
-                                 "the primal form.")
+        _check_solver_option(self.solver, self.multi_class, self.penalty,
+                             self.dual)
+
+        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)
+        if not isinstance(self.tol, numbers.Number) or self.tol < 0:
+            raise ValueError("Tolerance for stopping criteria must be "
+                             "positive; got (tol=%r)" % self.tol)
 
         X = check_array(X, accept_sparse='csr', dtype=np.float64)
         y = check_array(y, ensure_2d=False, dtype=None)
 
-        if self.multi_class not in ['ovr', 'multinomial']:
-            raise ValueError("multi_class backend should be either "
-                             "'ovr' or 'multinomial'"
-                             " got %s" % self.multi_class)
-
         if y.ndim == 2 and y.shape[1] == 1:
             warnings.warn(
                 "A column-vector y was passed when a 1d array was"
diff --git a/sklearn/linear_model/tests/test_logistic.py b/sklearn/linear_model/tests/test_logistic.py
@@ -5,7 +5,6 @@
 from sklearn.utils.testing import assert_almost_equal
 from sklearn.utils.testing import assert_array_equal
 from sklearn.utils.testing import assert_array_almost_equal
-from sklearn.utils.testing import assert_raises_regexp
 from sklearn.utils.testing import assert_equal
 from sklearn.utils.testing import assert_greater
 from sklearn.utils.testing import assert_raises
@@ -69,22 +68,19 @@ def test_predict_2_classes():
 def test_error():
     # Test for appropriate exception on errors
     msg = "Penalty term must be positive"
-    assert_raises_regexp(ValueError, msg,
+    assert_raise_message(ValueError, msg,
                          LogisticRegression(C=-1).fit, X, Y1)
-    assert_raises_regexp(ValueError, msg,
+    assert_raise_message(ValueError, msg,
                          LogisticRegression(C="test").fit, X, Y1)
 
-    msg = "Tolerance for stopping criteria must be positive"
-    assert_raises_regexp(ValueError, msg,
-                         LogisticRegression(tol=-1).fit, X, Y1)
-    assert_raises_regexp(ValueError, msg,
-                         LogisticRegression(tol="test").fit, X, Y1)
+    for LR in [LogisticRegression, LogisticRegressionCV]:
+        msg = "Tolerance for stopping criteria must be positive"
+        assert_raise_message(ValueError, msg, LR(tol=-1).fit, X, Y1)
+        assert_raise_message(ValueError, msg, LR(tol="test").fit, X, Y1)
 
-    msg = "Maximum number of iteration must be positive"
-    assert_raises_regexp(ValueError, msg,
-                         LogisticRegression(max_iter=-1).fit, X, Y1)
-    assert_raises_regexp(ValueError, msg,
-                         LogisticRegression(max_iter="test").fit, X, Y1)
+        msg = "Maximum number of iteration must be positive"
+        assert_raise_message(ValueError, msg, LR(max_iter=-1).fit, X, Y1)
+        assert_raise_message(ValueError, msg, LR(max_iter="test").fit, X, Y1)
 
 
 def test_predict_3_classes():
@@ -126,6 +122,39 @@ def test_multinomial_validation():
         assert_raises(ValueError, lr.fit, [[0, 1], [1, 0]], [0, 1])
 
 
+def test_check_solver_option():
+    X, y = iris.data, iris.target
+    for LR in [LogisticRegression, LogisticRegressionCV]:
+
+        msg = ("Logistic Regression supports only liblinear, newton-cg and"
+               " lbfgs solvers, got wrong_name")
+        lr = LR(solver="wrong_name")
+        assert_raise_message(ValueError, msg, lr.fit, X, y)
+
+        msg = "multi_class should be either multinomial or ovr, got wrong_name"
+        lr = LR(solver='newton-cg', multi_class="wrong_name")
+        assert_raise_message(ValueError, msg, lr.fit, X, y)
+
+        # all solver except 'newton-cg' and 'lfbgs'
+        for solver in ['liblinear']:
+            msg = ("Solver %s does not support a multinomial backend." %
+                   solver)
+            lr = LR(solver=solver, multi_class='multinomial')
+            assert_raise_message(ValueError, msg, lr.fit, X, y)
+
+        # all solvers except 'liblinear'
+        for solver in ['newton-cg', 'lbfgs']:
+            msg = ("Solver %s supports only l2 penalties, got l1 penalty." %
+                   solver)
+            lr = LR(solver=solver, penalty='l1')
+            assert_raise_message(ValueError, msg, lr.fit, X, y)
+
+            msg = ("Solver %s supports only dual=False, got dual=True" %
+                   solver)
+            lr = LR(solver=solver, dual=True)
+            assert_raise_message(ValueError, msg, lr.fit, X, y)
+
+
 def test_multinomial_binary():
     # Test multinomial LR on a binary problem.
     target = (iris.target > 0).astype(np.intp)
