Merge pull request #1981 from VesnaT/svm_coeff

[ENH] OWSGD: Output coefficients

Author: astaric

Orange/classification/__init__.py

@@ -14,3 +14,4 @@
 from .simple_random_forest import *
 from .elliptic_envelope import *
 from .rules import *
+from .sgd import *

Orange/classification/sgd.py

@@ -1,14 +1,17 @@
 from sklearn.linear_model import SGDClassifier
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import StandardScaler
 
 from Orange.base import SklLearner
+from Orange.preprocess import Normalize
 from Orange.regression.linear import LinearModel
 
+__all__ = ["SGDClassificationLearner"]
+
 
 class SGDClassificationLearner(SklLearner):
     name = 'sgd'
     __wraps__ = SGDClassifier
+    __returns__ = LinearModel
+    preprocessors = SklLearner.preprocessors + [Normalize()]
 
     def __init__(self, loss='squared_loss',penalty='l2', alpha=0.0001,
                  l1_ratio=0.15,fit_intercept=True, n_iter=5, shuffle=True,
@@ -17,9 +20,3 @@ def __init__(self, loss='squared_loss',penalty='l2', alpha=0.0001,
                  preprocessors=None):
         super().__init__(preprocessors=preprocessors)
         self.params = vars()
-
-    def fit(self, X, Y, W):
-        sk = self.__wraps__(**self.params)
-        clf = Pipeline([('scaler', StandardScaler()), ('sgd', sk)])
-        clf.fit(X, Y.ravel())
-        return LinearModel(clf)

Orange/regression/linear.py

@@ -1,11 +1,10 @@
 import numpy as np
 
 import sklearn.linear_model as skl_linear_model
-import sklearn.pipeline as skl_pipeline
 import sklearn.preprocessing as skl_preprocessing
 
 from Orange.data import Variable, ContinuousVariable
-from Orange.preprocess import Continuize, Normalize, RemoveNaNColumns, SklImpute
+from Orange.preprocess import Normalize
 from Orange.preprocess.score import LearnerScorer
 from Orange.regression import Learner, Model, SklLearner, SklModel
 
@@ -82,6 +81,7 @@ def __init__(self, l1_ratio=0.5, eps=0.001, n_alphas=100, alphas=None,
 
 class SGDRegressionLearner(LinearRegressionLearner):
     __wraps__ = skl_linear_model.SGDRegressor
+    preprocessors = SklLearner.preprocessors + [Normalize()]
 
     def __init__(self, loss='squared_loss',penalty='l2', alpha=0.0001,
                  l1_ratio=0.15, fit_intercept=True, n_iter=5, shuffle=True,
@@ -92,13 +92,6 @@ def __init__(self, loss='squared_loss',penalty='l2', alpha=0.0001,
         super().__init__(preprocessors=preprocessors)
         self.params = vars()
 
-    def fit(self, X, Y, W):
-        sk = self.__wraps__(**self.params)
-        clf = skl_pipeline.Pipeline(
-            [('scaler', skl_preprocessing.StandardScaler()), ('sgd', sk)])
-        clf.fit(X, Y.ravel())
-        return LinearModel(clf)
-
 
 class PolynomialLearner(Learner):
     """Generate polynomial features and learn a prediction model

Orange/tests/test_sgd.py

@@ -5,15 +5,39 @@
 
 import numpy as np
 
-import Orange
+from Orange.data import Table
+from Orange.classification import SGDClassificationLearner
+from Orange.regression import SGDRegressionLearner
+from Orange.evaluation import CrossValidation, RMSE, AUC
 
 
 class TestSGDRegressionLearner(unittest.TestCase):
     def test_SGDRegression(self):
         nrows, ncols = 500, 5
         X = np.random.rand(nrows, ncols)
         y = X.dot(np.random.rand(ncols))
-        data = Orange.data.Table(X, y)
-        sgd = Orange.regression.SGDRegressionLearner()
-        res = Orange.evaluation.CrossValidation(data, [sgd], k=3)
-        self.assertLess(Orange.evaluation.RMSE(res)[0], 0.1)
+        data = Table(X, y)
+        sgd = SGDRegressionLearner()
+        res = CrossValidation(data, [sgd], k=3)
+        self.assertLess(RMSE(res)[0], 0.1)
+
+    def test_coefficients(self):
+        lrn = SGDRegressionLearner()
+        mod = lrn(Table("housing"))
+        self.assertEqual(len(mod.coefficients), len(mod.domain.attributes))
+
+
+class TestSGDClassificationLearner(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.iris = Table('iris')
+
+    def test_SGDClassification(self):
+        sgd = SGDClassificationLearner()
+        res = CrossValidation(self.iris, [sgd], k=3)
+        self.assertGreater(AUC(res)[0], 0.85)
+
+    def test_coefficients(self):
+        lrn = SGDClassificationLearner()
+        mod = lrn(self.iris)
+        self.assertEqual(len(mod.coefficients[0]), len(mod.domain.attributes))

Orange/widgets/classify/tests/test_owsgd.py

@@ -1,5 +1,6 @@
 # Test methods with long descriptive names can omit docstrings
 # pylint: disable=missing-docstring
+from Orange.data import Table
 from Orange.widgets.classify.owsgd import OWSGD
 from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin, \
     ParameterMapping
@@ -23,3 +24,16 @@ def setUp(self):
             ParameterMapping.from_attribute(self.widget, 'eta0'),
             ParameterMapping.from_attribute(self.widget, 'power_t'),
         ]
+
+    def test_output_coefficients(self):
+        """Check if coefficients are on output after apply"""
+        self.assertIsNone(self.get_output("Coefficients"))
+        self.send_signal("Data", self.data)
+        self.widget.apply_button.button.click()
+        coeffs = self.get_output("Coefficients")
+        self.assertIsInstance(coeffs, Table)
+        domain = self.data.domain
+        self.assertEqual(coeffs.X.shape, (len(domain.attributes) + 1,
+                                          len(domain.class_var.values)))
+        self.send_signal("Data", None)
+        self.assertIsNone(self.get_output("Coefficients"))

Orange/widgets/model/owsgd.py

@@ -3,8 +3,10 @@
 from AnyQt.QtCore import Qt
 
 from Orange.canvas.report import bool_str
+from Orange.data import ContinuousVariable, StringVariable, Domain, Table
 from Orange.modelling.linear import SGDLearner
-from Orange.widgets import gui
+from Orange.widgets import gui, widget
+from Orange.widgets.classify.owlogisticregression import create_coef_table
 from Orange.widgets.settings import Setting
 from Orange.widgets.utils.owlearnerwidget import OWBaseLearner
 
@@ -20,6 +22,8 @@ class OWSGD(OWBaseLearner):
 
     LEARNER = SGDLearner
 
+    outputs = [("Coefficients", Table, widget.Explicit)]
+
     reg_losses = (
         ('Squared Loss', 'squared_loss'),
         ('Huber', 'huber'),
@@ -281,6 +285,22 @@ def get_learner_parameters(self):
 
         return list(params.items())
 
+    def update_model(self):
+        super().update_model()
+        coeffs = None
+        if self.model is not None:
+            if self.model.domain.class_var.is_discrete:
+                coeffs = create_coef_table(self.model)
+            else:
+                attrs = [ContinuousVariable("coef", number_of_decimals=7)]
+                domain = Domain(attrs, metas=[StringVariable("name")])
+                cfs = list(self.model.intercept) + list(self.model.coefficients)
+                names = ["intercept"] + \
+                        [attr.name for attr in self.model.domain.attributes]
+                coeffs = Table(domain, list(zip(cfs, names)))
+                coeffs.name = "coefficients"
+        self.send("Coefficients", coeffs)
+
 
 if __name__ == '__main__':
     import sys

Orange/widgets/regression/tests/test_owsgdregression.py

@@ -1,5 +1,6 @@
 # Test methods with long descriptive names can omit docstrings
 # pylint: disable=missing-docstring
+from Orange.data import Table
 from Orange.widgets.regression.owsgdregression import OWSGD
 from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin, \
     ParameterMapping
@@ -24,3 +25,15 @@ def setUp(self):
             ParameterMapping.from_attribute(self.widget, 'eta0'),
             ParameterMapping.from_attribute(self.widget, 'power_t'),
         ]
+
+    def test_output_coefficients(self):
+        """Check if coefficients are on output after apply"""
+        self.assertIsNone(self.get_output("Coefficients"))
+        self.send_signal("Data", self.data)
+        self.widget.apply_button.button.click()
+        coeffs = self.get_output("Coefficients")
+        self.assertIsInstance(coeffs, Table)
+        self.assertEqual(coeffs.X.shape,
+                         (len(self.data.domain.attributes) + 1, 1))
+        self.send_signal("Data", None)
+        self.assertIsNone(self.get_output("Coefficients"))