fix typos, comments

Author: AndrejaKovacic

Orange/preprocess/preprocess.py

@@ -572,44 +572,42 @@ def __call__(self, data):
 
 class RemoveSparse(Preprocess):
     """
-    Filter out the features with too many nan's or 0. Threshold is user defined.
+    Filter out the features with too many (>threshold) zeros or missing values. Threshold is user defined.
 
     Parameters
     ----------
-    filter_0: bool
-        filter out by zeros or nan's
-    fixed_threshold: bool
-        threshold is either a fixed number of elements or percentage
-    threshold: int
-        kept as is if fixed threshold or the percent is used to calculate
-        the appropriate number of elements
+    threshold: int or float
+        if >= 1, the argument represents the allowed number of 0s or NaNs;
+        if below 1, it represents the allowed proportion of 0s or NaNs
+    filter0: bool
+        if True (default), preprocessor counts 0s, otherwise NaNs
     """
-
-    def __init__(self, filter_0=True, fixed_threshold=False, threshold=5):
-        self.filter_0 = filter_0
-        self.fixed_threshold = fixed_threshold
+    def __init__(self, threshold=0.05, filter0=True):
+        self.filter0 = filter0
         self.threshold = threshold
 
     def __call__(self, data):
-        if self.fixed_threshold:
-            tailored_threshold = self.threshold
-        else:
-            tailored_threshold = np.ceil(self.threshold/100 * data.X.shape[0])
+        threshold = self.threshold
+        if self.threshold < 1:
+            threshold *= data.X.shape[0]
 
-        if self.filter_0:
+        if self.filter0:
             if sp.issparse(data.X):
                 data_csc = sp.csc_matrix(data.X)
                 h, w = data_csc.shape
-                sparsness = [(h - data_csc[:, i].count_nonzero()) for i in range(w)]
+                sparseness = [h - data_csc[:, i].count_nonzero()
+                              for i in range(w)]
             else:
-                sparsness = data.X.shape[0] - np.count_nonzero(data.X, axis=0)
-        else: # filter by nans
+                sparseness = data.X.shape[0] - np.count_nonzero(data.X, axis=0)
+        else:  # filter by nans
             if sp.issparse(data.X):
                 data_csc = sp.csc_matrix(data.X)
-                sparsness = [np.sum(np.isnan(data.X[:, i].data)) for i in range(data_csc.shape[1])]
+                sparseness = [np.sum(np.isnan(data.X[:, i].data))
+                              for i in range(data_csc.shape[1])]
             else:
-                sparsness = np.sum(np.isnan(data.X), axis=0)
-        att = [a for a, s in zip(data.domain.attributes, sparsness) if s <= tailored_threshold]
+                sparseness = np.sum(np.isnan(data.X), axis=0)
+        att = [a for a, s in zip(data.domain.attributes, sparseness)
+               if s <= threshold]
         domain = Orange.data.Domain(att, data.domain.class_vars,
                                     data.domain.metas)
         return data.transform(domain)

Orange/tests/test_preprocess.py

@@ -1,7 +1,6 @@
 # Test methods with long descriptive names can omit docstrings
 # pylint: disable=missing-docstring
 
-import os
 import pickle
 import unittest
 from unittest.mock import Mock
@@ -15,7 +14,6 @@
     EqualWidth, SelectBestFeatures, RemoveNaNRows, Preprocess, Scale, \
     Randomize, Continuize, Discretize, Impute, SklImpute, Normalize, \
     ProjectCUR, ProjectPCA, RemoveConstant, AdaptiveNormalize, RemoveSparse
-from Orange.util import OrangeDeprecationWarning
 
 
 class TestPreprocess(unittest.TestCase):
@@ -54,7 +52,7 @@ def test_remove_columns(self):
         X[3, 1] = np.nan
         X[1, 1] = np.nan
         X[:, 4] = np.nan
-        data = Table(X)
+        data = Table.from_numpy(None, X)
         d = RemoveConstant()(data)
         self.assertEqual(len(d.domain.attributes), 2)
 
@@ -103,10 +101,10 @@ def test_column_filtering_sparse(self):
 class TestScaling(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.table = Table([[1, 2, 3],
-                           [2, 3, 4],
-                           [3, 4, 5],
-                           [4, 5, 6]])
+        cls.table = Table.from_numpy(None, [[1, 2, 3],
+                                            [2, 3, 4],
+                                            [3, 4, 5],
+                                            [4, 5, 6]])
 
     def test_scaling_mean_span(self):
         table = Scale(center=Scale.Mean, scale=Scale.Span)(self.table)
@@ -188,32 +186,32 @@ def test_0_dense(self):
         self.data[1:, 1] = 7
         true_out = self.data[:, 1]
         true_out.X = true_out.X.reshape(-1, 1)
-        out = RemoveSparse(True, False, 0.5)(self.data)
+        out = RemoveSparse(0.5, True)(self.data)
         np.testing.assert_array_equal(out, true_out)
 
-        out = RemoveSparse(True, True, 2)(self.data)
+        out = RemoveSparse(2, True)(self.data)
         np.testing.assert_array_equal(out, true_out)
 
     def test_0_sparse(self):
         self.data[1:, 1] = 7
         true_out = self.data[:, 1]
         self.data.X = csr_matrix(self.data.X)
         true_out.X = csr_matrix(true_out.X)
-        out = RemoveSparse(True, False, 0.5)(self.data).X
+        out = RemoveSparse(0.5, True)(self.data).X
         np.testing.assert_array_equal(out, true_out)
 
-        out = RemoveSparse(True, True, 1)(self.data).X
+        out = RemoveSparse(1, True)(self.data).X
         np.testing.assert_array_equal(out, true_out)
 
     def test_nan_dense(self):
         self.data[1:, 1] = np.nan
         self.data.X[:, 0] = 7
         true_out = self.data[:, 0]
         true_out.X = true_out.X.reshape(-1, 1)
-        out = RemoveSparse(False, False, 0.5)(self.data)
+        out = RemoveSparse(0.5, False)(self.data)
         np.testing.assert_array_equal(out, true_out)
 
-        out = RemoveSparse(False, True, 1)(self.data)
+        out = RemoveSparse(1, False)(self.data)
         np.testing.assert_array_equal(out, true_out)
 
     def test_nan_sparse(self):
@@ -223,11 +221,12 @@ def test_nan_sparse(self):
         true_out.X = true_out.X.reshape(-1, 1)
         self.data.X = csr_matrix(self.data.X)
         true_out.X = csr_matrix(true_out.X)
-        out = RemoveSparse(False, False, 0.5)(self.data)
+        out = RemoveSparse(0.5, False)(self.data)
         np.testing.assert_array_equal(out, true_out)
 
-        out = RemoveSparse(False, True, 1)(self.data)
+        out = RemoveSparse(1, False)(self.data)
         np.testing.assert_array_equal(out, true_out)
 
+
 if __name__ == '__main__':
     unittest.main()

Orange/widgets/data/owpreprocess.py

@@ -262,18 +262,19 @@ def __init__(self, parent=None, **kwargs):
         self.filter0 = True
         self.setLayout(QVBoxLayout())
 
-        choose_filts = QGroupBox(title='Filter out features with too many:')
-        choose_filts.setLayout(QVBoxLayout())
+        self.layout().addWidget(QLabel("Remove features with too many"))
+        options = ["missing values",
+                   "zeros"]
         self.filter_buttons = QButtonGroup(exclusive=True)
         self.filter_buttons.buttonClicked.connect(self.filterByClicked)
-        for option, idx in zip(self.options, range(len(self.options))):
+        for idx, option, in enumerate(options):
             btn = QRadioButton(self, text=option, checked=idx == 0)
             self.filter_buttons.addButton(btn, id=idx)
-            choose_filts.layout().addWidget(btn)
-        self.layout().addWidget(choose_filts)
+            self.layout().addWidget(btn)
 
+        self.layout().addSpacing(20)
 
-        filter_settings = QGroupBox(title='Threshold settings:', flat=True)
+        filter_settings = QGroupBox(title='Threshold:', flat=True)
         filter_settings.setLayout(QFormLayout())
         self.settings_buttons = QButtonGroup(exclusive=True)
         self.settings_buttons.buttonClicked.connect(self.filterSettingsClicked)
@@ -347,8 +348,8 @@ def createinstance(params):
         if useFixedThreshold:
             threshold = params.pop('fixedThresh', 50)
         else:
-            threshold = params.pop('percThresh', 5)
-        return RemoveSparse(filter0, useFixedThreshold, threshold=threshold)
+            threshold = params.pop('percThresh', 5) / 100
+        return RemoveSparse(threshold, filter0)
 
 class ImputeEditor(BaseEditor):
     (NoImputation, Constant, Average,

Orange/widgets/data/tests/test_owpreprocess.py

@@ -284,25 +284,22 @@ class TestRemoveSparseEditor(WidgetTest):
 
     def test_editor(self):
         widget = owpreprocess.RemoveSparseEditor()
-        self.assertEqual(widget.parameters(), {"fixedThresh" : 50,
-                                               "percThresh": 5,
-                                               "filter0" : True,
-                                               "useFixedThreshold": False})
+        self.assertEqual(
+            widget.parameters(),
+            dict(fixedThresh=50, percThresh=5, filter0=True,
+                 useFixedThreshold=False))
 
         p = widget.createinstance(widget.parameters())
         widget.filterSettingsClicked()
         self.assertTrue(widget.percSpin.isEnabled())
         self.assertFalse(widget.fixedSpin.isEnabled())
         self.assertIsInstance(p, RemoveSparse)
-        self.assertEqual(p.fixed_threshold, False)
-        self.assertEqual(p.filter_0, True)
-        self.assertEqual(p.threshold, 5)
+        self.assertEqual(p.filter0, True)
+        self.assertEqual(p.threshold, 0.05)
 
-        widget.setParameters({"useFixedThreshold" : True,
-                              "fixedThresh" : 30,
-                              "filter0" : False})
+        widget.setParameters(
+            dict(useFixedThreshold=True, fixedThresh=30, filter0=False))
         p = widget.createinstance(widget.parameters())
         self.assertIsInstance(p, RemoveSparse)
-        self.assertEqual(p.fixed_threshold, True)
         self.assertEqual(p.threshold, 30)
-        self.assertFalse(p.filter_0)
+        self.assertFalse(p.filter0)