Fix: classification models output correct shapes

Author: PrimozGodec

Orange/base.py

@@ -320,12 +320,55 @@ def backmap_probs(self, probs, n_values, backmappers):
         new_probs = new_probs / tots[:, None]
         return new_probs
 
+    def data_to_model_domain(self, data: Table) -> Table:
+        """
+        Transforms data to the model domain if possible.
+
+        Parameters
+        ----------
+        data
+            Data to be transformed to the model domain
+
+        Returns
+        -------
+        Transformed data table
+
+        Raises
+        ------
+        DomainTransformationError
+            Error indicates that transformation is not possible since domains
+            are not compatible
+        """
+        if data.domain == self.domain:
+            return data
+
+        if self.original_domain.attributes != data.domain.attributes \
+                and data.X.size \
+                and not all_nan(data.X):
+            new_data = data.transform(self.original_domain)
+            if all_nan(new_data.X):
+                raise DomainTransformationError(
+                    "domain transformation produced no defined values")
+            return new_data.transform(self.domain)
+
+        return data.transform(self.domain)
+
     def __call__(self, data, ret=Value):
         multitarget = len(self.domain.class_vars) > 1
 
         def one_hot_probs(value):
             if not multitarget:
-                return one_hot(value)
+                probs = one_hot(value)
+                # sometimes a maximum class value(s) are not predicted and
+                # those probs.shape[1] does not match to the length of values
+                # in the domain - here we add missing dimension if required
+                num_val = (
+                    len(self.original_domain.class_var.values)
+                    if self.original_domain is not None else probs.shape[0]
+                )
+                return np.hstack((
+                    probs, np.zeros((probs.shape[0], num_val - probs.shape[1]))
+                ))
 
             max_card = max(len(c.values) for c in self.domain.class_vars)
             probs = np.zeros(value.shape + (max_card,), float)
@@ -336,21 +379,6 @@ def one_hot_probs(value):
         def fix_dim(x):
             return x[0] if one_d else x
 
-        def data_to_model_domain():
-            if data.domain == self.domain:
-                return data
-
-            if self.original_domain.attributes != data.domain.attributes \
-                    and data.X.size \
-                    and not all_nan(data.X):
-                new_data = data.transform(self.original_domain)
-                if all_nan(new_data.X):
-                    raise DomainTransformationError(
-                        "domain transformation produced no defined values")
-                return new_data.transform(self.domain)
-
-            return data.transform(self.domain)
-
         if not 0 <= ret <= 2:
             raise ValueError("invalid value of argument 'ret'")
         if ret > 0 and any(v.is_continuous for v in self.domain.class_vars):
@@ -368,14 +396,18 @@ def data_to_model_domain():
         else:
             one_d = False
 
+        # if sparse convert to csr_matrix
+        if scipy.sparse.issparse(data):
+            data = data.tocsr()
+
         # Call the predictor
         backmappers = None
         n_values = []
         if isinstance(data, (np.ndarray, scipy.sparse.csr.csr_matrix)):
             prediction = self.predict(data)
         elif isinstance(data, Table):
             backmappers, n_values = self.get_backmappers(data)
-            data = data_to_model_domain()
+            data = self.data_to_model_domain(data)
             prediction = self.predict_storage(data)
         elif isinstance(data, (list, tuple)):
             data = Table.from_list(self.original_domain, data)

Orange/classification/softmax_regression.py

@@ -70,7 +70,9 @@ def cost_grad(self, Theta_flat, X, Y):
 
         return cost, grad.ravel()
 
-    def fit(self, X, y, W):
+    def fit_storage(self, data):
+        X, y = data.X, data.Y
+
         if len(y.shape) > 1:
             raise ValueError('Softmax regression does not support '
                              'multi-label classification')
@@ -81,7 +83,7 @@ def fit(self, X, y, W):
 
         X = np.hstack((X, np.ones((X.shape[0], 1))))
 
-        self.num_classes = np.unique(y).size
+        self.num_classes = len(data.domain.class_var.values)
         Y = np.eye(self.num_classes)[y.ravel().astype(int)]
 
         theta = np.zeros(self.num_classes * X.shape[1])

Orange/classification/svm.py

@@ -1,20 +1,20 @@
+import warnings
+
+import numpy as np
 import sklearn.svm as skl_svm
 
-from Orange.classification import SklLearner, SklModel
+from Orange.classification import SklLearner, SklModel, MajorityLearner
+from Orange.evaluation import CrossValidation, CA
 from Orange.preprocess import AdaptiveNormalize
 
 __all__ = ["SVMLearner", "LinearSVMLearner", "NuSVMLearner"]
 
 svm_pps = SklLearner.preprocessors + [AdaptiveNormalize()]
 
 
-class SVMClassifier(SklModel):
-    pass
-
-
 class SVMLearner(SklLearner):
     __wraps__ = skl_svm.SVC
-    __returns__ = SVMClassifier
+    __returns__ = SklModel
     preprocessors = svm_pps
 
     def __init__(self, C=1.0, kernel='rbf', degree=3, gamma="auto",
@@ -24,6 +24,14 @@ def __init__(self, C=1.0, kernel='rbf', degree=3, gamma="auto",
         super().__init__(preprocessors=preprocessors)
         self.params = vars()
 
+    def __call__(self, data, progress_callback=None):
+        if len(np.unique(data.Y)) > 1:
+            return super().__call__(data, progress_callback)
+        else:
+            warnings.warn("Single class in data, returning Constant Model.")
+            maj = MajorityLearner()
+            return maj(data)
+
 
 class LinearSVMLearner(SklLearner):
     __wraps__ = skl_svm.LinearSVC
@@ -36,20 +44,18 @@ def __init__(self, penalty='l2', loss='squared_hinge', dual=True,
         super().__init__(preprocessors=preprocessors)
         self.params = vars()
 
-
-class NuSVMClassifier(SklModel):
-
-    def predict(self, X):
-        value = self.skl_model.predict(X)
-        if self.skl_model.probability:
-            prob = self.skl_model.predict_proba(X)
-            return value, prob
-        return value
+    def __call__(self, data, progress_callback=None):
+        if len(np.unique(data.Y)) > 1:
+            return super().__call__(data, progress_callback)
+        else:
+            warnings.warn("Single class in data, returning Constant Model.")
+            maj = MajorityLearner()
+            return maj(data)
 
 
 class NuSVMLearner(SklLearner):
     __wraps__ = skl_svm.NuSVC
-    __returns__ = NuSVMClassifier
+    __returns__ = SklModel
     preprocessors = svm_pps
 
     def __init__(self, nu=0.5, kernel='rbf', degree=3, gamma="auto", coef0=0.0,
@@ -58,12 +64,22 @@ def __init__(self, nu=0.5, kernel='rbf', degree=3, gamma="auto", coef0=0.0,
         super().__init__(preprocessors=preprocessors)
         self.params = vars()
 
+    def __call__(self, data, progress_callback=None):
+        if len(np.unique(data.Y)) > 1:
+            return super().__call__(data, progress_callback)
+        else:
+            warnings.warn("Single class in data, returning Constant Model.")
+            maj = MajorityLearner()
+            return maj(data)
+
 
 if __name__ == '__main__':
     import Orange
 
-    data = Orange.data.Table('iris')
+    data_ = Orange.data.Table('iris')
     learners = [SVMLearner(), NuSVMLearner(), LinearSVMLearner()]
-    res = Orange.evaluation.CrossValidation(data, learners)
-    for l, ca in zip(learners, Orange.evaluation.CA(res)):
+    cv = CrossValidation()
+    res = cv(data_, learners)
+    ca = CA()
+    for l, ca in zip(learners, ca(res)):
         print("learner: {}\nCA: {}\n".format(l, ca))

Orange/classification/tests/test_base.py

@@ -186,6 +186,17 @@ def test_no_common_values(self):
             self.assertTrue(np.all(val <= 2))
             np.testing.assert_array_equal(prob, 1 / 3)
 
+    def test_sparse_matrix(self):
+        iris_sparse = self.iris.to_sparse()
+        for lrn in [TreeLearner, LogisticRegressionLearner]:  # skl and non-skl
+            model = lrn()(iris_sparse)
+            pred = model(iris_sparse.X.tocsc())
+            self.assertTupleEqual((len(self.iris),), pred.shape)
+            pred = model(iris_sparse.X.tolil())
+            self.assertTupleEqual((len(self.iris),), pred.shape)
+            pred = model(iris_sparse.X.tocoo())
+            self.assertTupleEqual((len(self.iris),), pred.shape)
+
 
 if __name__ == '__main__':
     unittest.main()

Orange/tests/test_classification.py

@@ -18,13 +18,16 @@
 import Orange.classification
 from Orange.classification import (
     Learner, Model,
-    NaiveBayesLearner, LogisticRegressionLearner, NuSVMLearner, MajorityLearner,
+    NaiveBayesLearner, LogisticRegressionLearner, NuSVMLearner,
+    MajorityLearner,
     RandomForestLearner, SimpleTreeLearner, SoftmaxRegressionLearner,
     SVMLearner, LinearSVMLearner, OneClassSVMLearner, TreeLearner, KNNLearner,
-    SimpleRandomForestLearner, EllipticEnvelopeLearner)
+    SimpleRandomForestLearner, EllipticEnvelopeLearner, SklTreeLearner,
+    NNClassificationLearner, CN2Learner, CN2UnorderedLearner,
+    CN2SDUnorderedLearner)
 from Orange.classification.rules import _RuleLearner
 from Orange.data import (ContinuousVariable, DiscreteVariable,
-                         Domain, Table, Variable)
+                         Domain, Table)
 from Orange.data.table import DomainTransformationError
 from Orange.evaluation import CrossValidation
 from Orange.tests.dummy_learners import DummyLearner, DummyMulticlassLearner
@@ -190,6 +193,76 @@ def test_incompatible_domain(self):
         with self.assertRaises(DomainTransformationError):
             clf(titanic)
 
+    LEARNERS_CLASSIFICATION = [
+        LogisticRegressionLearner(),
+        RandomForestLearner(),
+        SimpleRandomForestLearner(),
+        SoftmaxRegressionLearner(),
+        KNNLearner(),
+        NaiveBayesLearner(),
+        SVMLearner(probability=True),
+        SVMLearner(),
+        LinearSVMLearner(),
+        NuSVMLearner(probability=True),
+        NuSVMLearner(),
+        TreeLearner(),
+        SklTreeLearner(),
+        SimpleTreeLearner(),
+        MajorityLearner(),
+        NNClassificationLearner(),
+        CN2Learner(),
+        CN2UnorderedLearner(),
+        CN2SDUnorderedLearner()
+    ]
+
+    def test_result_shape(self):
+        """
+        Test if the results shapes are correct
+        """
+        iris = Table('iris')
+        for learner in self.LEARNERS_CLASSIFICATION:
+            with self.subTest(learner.name):
+                # model trained on only one value (but three in the domain)
+                model = learner(iris[0:50])
+
+                res = model(iris[0:50])
+                self.assertTupleEqual((50, ), res.shape)
+
+                # probabilities must still be for three classes
+                res = model(iris[0:50], model.Probs)
+                self.assertTupleEqual((50, 3), res.shape)
+
+                # model trained on all classes and predicting with one class
+                model = learner(iris)
+                res = model(iris[0:50], model.Probs)
+                self.assertTupleEqual((50, 3), res.shape)
+
+    def test_result_shape_numpy(self):
+        """
+        Test whether results shapes are correct when testing on numpy data
+        """
+        iris = Table('iris')
+        for learner in self.LEARNERS_CLASSIFICATION:
+            with self.subTest(learner.name):
+                model = learner(iris)
+                transformed_iris = model.data_to_model_domain(iris)
+
+                res = model(transformed_iris.X[0:5])
+                self.assertTupleEqual((5, ), res.shape)
+
+                res = model(transformed_iris.X[0:1], model.Probs)
+                self.assertTupleEqual((1, 3), res.shape)
+
+    def test_fit_one_class(self):
+        """
+        Test whether the fitting with one class only pass - before it failed
+        for some models.
+        """
+        iris = Table('iris')
+        for learner in self.LEARNERS_CLASSIFICATION:
+            with self.subTest(learner.name):
+                learner(iris[0:50])
+
 
 class ExpandProbabilitiesTest(unittest.TestCase):
     def prepareTable(self, rows, attr, vars, class_var_domain):