Merge pull request #2457 from pavlin-policar/table-sparse-target

[FIX] Table: Fix printing data with sparse Y

Author: nikicc

Orange/data/table.py

@@ -114,24 +114,35 @@ def __setitem__(self, key, value):
     def _str(self, limit):
         def sp_values(matrix, variables):
             if not sp.issparse(matrix):
+                if matrix.ndim == 1:
+                    matrix = matrix[:, np.newaxis]
                 return Instance.str_values(matrix[row], variables, limit)
-            begptr, endptr = matrix.indptr[row:row + 2]
-            rendptr = endptr if not limit else min(endptr, begptr + 5)
-            variables = [variables[var]
-                         for var in matrix.indices[begptr:rendptr]]
-            s = ", ".join(
-                "{}={}".format(var.name, var.str_val(val))
-                for var, val in zip(variables, matrix.data[begptr:rendptr]))
-            if limit and rendptr != endptr:
+
+            row_entries, idx = [], 0
+            while idx < len(variables):
+                # Make sure to stop printing variables if we limit the output
+                if limit and len(row_entries) >= 5:
+                    break
+
+                var = variables[idx]
+                if var.is_discrete or matrix[row, idx]:
+                    row_entries.append("%s=%s" % (var.name, var.str_val(matrix[row, idx])))
+
+                idx += 1
+
+            s = ", ".join(row_entries)
+
+            if limit and idx < len(variables):
                 s += ", ..."
+
             return s
 
         table = self.table
         domain = table.domain
         row = self.row_index
         s = "[" + sp_values(table.X, domain.attributes)
         if domain.class_vars:
-            s += " | " + sp_values(table._Y, domain.class_vars)
+            s += " | " + sp_values(table.Y, domain.class_vars)
         s += "]"
         if self._domain.metas:
             s += " {" + sp_values(table.metas, domain.metas) + "}"
@@ -178,6 +189,8 @@ def Y(self):
     def Y(self, value):
         if len(value.shape) == 1:
             value = value[:, None]
+        if sp.issparse(value) and len(self) != value.shape[0]:
+            value = value.T
         self._Y = value
 
     def __new__(cls, *args, **kwargs):
@@ -825,7 +838,7 @@ def __len__(self):
         return self.X.shape[0]
 
     def __str__(self):
-        return "[" + ",\n ".join(str(ex) for ex in self)
+        return "[" + ",\n ".join(str(ex) for ex in self) + "]"
 
     def __repr__(self):
         head = 5
@@ -1498,10 +1511,8 @@ def _compute_contingency(self, col_vars=None, row_var=None):
 
                 for col_i, arr_i, _ in cont_vars:
                     if sp.issparse(arr):
-                        col_data = arr.data[
-                                   arr.indptr[arr_i]:arr.indptr[arr_i + 1]]
-                        rows = arr.indices[
-                               arr.indptr[arr_i]:arr.indptr[arr_i + 1]]
+                        col_data = arr.data[arr.indptr[arr_i]:arr.indptr[arr_i + 1]]
+                        rows = arr.indices[arr.indptr[arr_i]:arr.indptr[arr_i + 1]]
                         W_ = None if W is None else W[rows]
                         classes_ = classes[rows]
                     else:

Orange/tests/test_sparse_table.py

@@ -1,9 +1,11 @@
 # Test methods with long descriptive names can omit docstrings
 # pylint: disable=missing-docstring
 
+import numpy as np
 from scipy.sparse import csr_matrix
 
 from Orange import data
+from Orange.data import Table
 from Orange.tests import test_table as tabletests
 
 
@@ -41,3 +43,34 @@ def test_row_assignment(self):
 
     def test_value_assignment(self):
         super().test_value_assignment()
+
+    def test_str(self):
+        iris = Table('iris')
+        iris.X, iris.Y = csr_matrix(iris.X), csr_matrix(iris.Y)
+        str(iris)
+
+    def test_Y_setter_1d(self):
+        iris = Table('iris')
+        assert iris.Y.shape == (150,)
+        iris.Y = csr_matrix(iris.Y)
+        # We expect the Y shape to match the X shape, which is (150, 4) in iris
+        self.assertEqual(iris.Y.shape, (150, 1))
+
+    def test_Y_setter_2d(self):
+        iris = Table('iris')
+        assert iris.Y.shape == (150,)
+        # Convert iris.Y to (150, 1) shape
+        new_y = iris.Y[:, np.newaxis]
+        iris.Y = np.hstack((new_y, new_y))
+        iris.Y = csr_matrix(iris.Y)
+        # We expect the Y shape to match the X shape, which is (150, 4) in iris
+        self.assertEqual(iris.Y.shape, (150, 2))
+
+    def test_Y_setter_2d_single_instance(self):
+        iris = Table('iris')[:1]
+        # Convert iris.Y to (1, 1) shape
+        new_y = iris.Y[:, np.newaxis]
+        iris.Y = np.hstack((new_y, new_y))
+        iris.Y = csr_matrix(iris.Y)
+        # We expect the Y shape to match the X shape, which is (1, 4) in iris
+        self.assertEqual(iris.Y.shape, (1, 2))