Merge pull request scikit-learn#1187 from ogrisel/bugfix-logistic-ovr-probabilities

MRG: FIX: wrong probabilities for OvR LogisticRegression

Author: ogrisel

sklearn/linear_model/logistic.py

@@ -122,7 +122,7 @@ def predict_proba(self, X):
             return np.vstack([1 - prob, prob]).T
         else:
             # OvR, not softmax, like Liblinear's predict_probability
-            prob /= prob.sum(axis=0)
+            prob /= prob.sum(axis=1).reshape((prob.shape[0], -1))
             return prob
 
     def predict_log_proba(self, X):

sklearn/linear_model/tests/test_logistic.py

@@ -2,6 +2,7 @@
 import scipy.sparse as sp
 
 from numpy.testing import assert_array_equal
+from numpy.testing import assert_array_almost_equal
 import nose
 from nose.tools import assert_equal, assert_raises, raises
 
@@ -17,34 +18,39 @@
 iris = datasets.load_iris()
 
 
+def check_predictions(clf, X, y):
+    """Check that the model is able to fit the classification data"""
+    n_samples = len(y)
+    classes = np.unique(y)
+    n_classes = classes.shape[0]
+
+    predicted = clf.fit(X, y).predict(X)
+    assert_array_equal(clf.classes_, classes)
+
+    assert_equal(predicted.shape, (n_samples,))
+    assert_array_equal(predicted, y)
+
+    probabilities = clf.predict_proba(X)
+    assert_equal(probabilities.shape, (n_samples, n_classes))
+    assert_array_almost_equal(probabilities.sum(axis=1), np.ones(n_samples))
+    assert_array_equal(probabilities.argmax(axis=1), y)
+
+
 def test_predict_2_classes():
     """Simple sanity check on a 2 classes dataset
 
     Make sure it predicts the correct result on simple datasets.
     """
-    clf = logistic.LogisticRegression().fit(X, Y1)
-    assert_array_equal(clf.predict(X), Y1)
-    assert_array_equal(clf.predict_proba(X).argmax(axis=1), Y1)
+    check_predictions(logistic.LogisticRegression(), X, Y1)
+    check_predictions(logistic.LogisticRegression(), X_sp, Y1)
 
-    clf = logistic.LogisticRegression().fit(X_sp, Y1)
-    assert_array_equal(clf.predict(X_sp), Y1)
-    assert_array_equal(clf.predict_proba(X_sp).argmax(axis=1), Y1)
+    check_predictions(logistic.LogisticRegression(C=100), X, Y1)
+    check_predictions(logistic.LogisticRegression(C=100), X_sp, Y1)
 
-    clf = logistic.LogisticRegression(C=100).fit(X, Y1)
-    assert_array_equal(clf.predict(X), Y1)
-    assert_array_equal(clf.predict_proba(X).argmax(axis=1), Y1)
-
-    clf = logistic.LogisticRegression(C=100).fit(X_sp, Y1)
-    assert_array_equal(clf.predict(X_sp), Y1)
-    assert_array_equal(clf.predict_proba(X_sp).argmax(axis=1), Y1)
-
-    clf = logistic.LogisticRegression(fit_intercept=False).fit(X, Y1)
-    assert_array_equal(clf.predict(X), Y1)
-    assert_array_equal(clf.predict_proba(X).argmax(axis=1), Y1)
-
-    clf = logistic.LogisticRegression(fit_intercept=False).fit(X_sp, Y1)
-    assert_array_equal(clf.predict(X_sp), Y1)
-    assert_array_equal(clf.predict_proba(X_sp).argmax(axis=1), Y1)
+    check_predictions(logistic.LogisticRegression(fit_intercept=False),
+                      X, Y1)
+    check_predictions(logistic.LogisticRegression(fit_intercept=False),
+                      X_sp, Y1)
 
 
 def test_error():
@@ -53,26 +59,25 @@ def test_error():
 
 
 def test_predict_3_classes():
-    clf = logistic.LogisticRegression(C=10).fit(X, Y2)
-    assert_array_equal(clf.predict(X), Y2)
-    assert_array_equal(clf.predict_proba(X).argmax(axis=1), Y2)
-
-    clf = logistic.LogisticRegression(C=10).fit(X_sp, Y2)
-    assert_array_equal(clf.predict(X_sp), Y2)
-    assert_array_equal(clf.predict_proba(X_sp).argmax(axis=1), Y2)
+    check_predictions(logistic.LogisticRegression(C=10), X, Y2)
+    check_predictions(logistic.LogisticRegression(C=10), X_sp, Y2)
 
 
 def test_predict_iris():
     """Test logisic regression with the iris dataset"""
+    n_samples, n_features = iris.data.shape
 
     target = iris.target_names[iris.target]
     clf = logistic.LogisticRegression(C=len(iris.data)).fit(iris.data, target)
-    assert_equal(set(target), set(clf.classes_))
+    assert_array_equal(np.unique(target), clf.classes_)
 
     pred = clf.predict(iris.data)
     assert_greater(np.mean(pred == target), .95)
 
-    pred = iris.target_names[clf.predict_proba(iris.data).argmax(axis=1)]
+    probabilities = clf.predict_proba(iris.data)
+    assert_array_almost_equal(probabilities.sum(axis=1), np.ones(n_samples))
+
+    pred = iris.target_names[probabilities.argmax(axis=1)]
     assert_greater(np.mean(pred == target), .95)
 
 

sklearn/tests/test_common.py

@@ -314,7 +314,8 @@ def test_classifiers_train():
     X_b = X_m[y_m != 2]
     for (X, y) in [(X_m, y_m), (X_b, y_b)]:
         # do it once with binary, once with multiclass
-        n_labels = len(np.unique(y))
+        classes = np.unique(y)
+        n_classes = len(classes)
         n_samples, n_features = X.shape
         for name, Clf in classifiers:
             if Clf in dont_test or Clf in meta_estimators:
@@ -341,13 +342,13 @@ def test_classifiers_train():
                 try:
                     # decision_function agrees with predict:
                     decision = clf.decision_function(X)
-                    if n_labels is 2:
+                    if n_classes is 2:
                         assert_equal(decision.ravel().shape, (n_samples,))
                         dec_pred = (decision.ravel() > 0).astype(np.int)
                         assert_array_equal(dec_pred, y_pred)
-                    if n_labels is 3 and not isinstance(clf, BaseLibSVM):
+                    if n_classes is 3 and not isinstance(clf, BaseLibSVM):
                         # 1on1 of LibSVM works differently
-                        assert_equal(decision.shape, (n_samples, n_labels))
+                        assert_equal(decision.shape, (n_samples, n_classes))
                         assert_array_equal(np.argmax(decision, axis=1), y_pred)
 
                     # raises error on malformed input
@@ -360,15 +361,30 @@ def test_classifiers_train():
                 try:
                     # predict_proba agrees with predict:
                     y_prob = clf.predict_proba(X)
-                    assert_equal(y_prob.shape, (n_samples, n_labels))
+                    assert_equal(y_prob.shape, (n_samples, n_classes))
+                    assert_array_equal(np.argmax(y_prob, axis=1), y_pred)
+                    # check that probas for all classes sum to one
+                    assert_array_almost_equal(
+                        np.sum(y_prob, axis=1), np.ones(n_samples))
                     # raises error on malformed input
                     assert_raises(ValueError, clf.predict_proba, X.T)
-                    assert_array_equal(np.argmax(y_prob, axis=1), y_pred)
                     # raises error on malformed input for predict_proba
                     assert_raises(ValueError, clf.predict_proba, X.T)
                 except NotImplementedError:
                     pass
 
+            if hasattr(clf, "classes_"):
+                if hasattr(clf, "n_outputs_"):
+                    assert_equal(clf.n_outputs_, 1)
+                    assert_array_equal(
+                        clf.classes_, [classes],
+                        "Unexpected classes_ attribute for %r" % clf)
+                else:
+                    # flat classes array: XXX inconsistent
+                    assert_array_equal(
+                        clf.classes_, classes,
+                        "Unexpected classes_ attribute for %r" % clf)
+
 
 def test_classifiers_classes():
     # test if classifiers can cope with non-consecutive classes