Table (transpose): Use heuristic to guess data type of attributes of attributes

Author: VesnaT

Orange/data/table.py

@@ -13,6 +13,7 @@
 import bottleneck as bn
 from scipy import sparse as sp
 
+from Orange import data  # import for io.py
 from Orange.data import (
     _contingency, _valuecount,
     Domain, Variable, Storage, StringVariable, Unknown, Value, Instance,
@@ -1453,6 +1454,7 @@ def transpose(cls, table, feature_names_column="",
             feature names are mapped
         :return: Table - transposed table
         """
+
         self = cls()
         n_cols, self.n_rows = table.X.shape
         old_domain = table.attributes.get("old_domain")
@@ -1521,10 +1523,22 @@ def get_table_from_attributes_of_attributes(_vars, _dtype=float):
         names = chain.from_iterable(list(attr.attributes)
                                     for attr in table.domain.attributes)
         names = sorted(set(names) - {var.name for var in class_vars})
+
+        def guessed_var(i, var_name):
+            orig_values = M[:, i]
+            value_map, values, var_type = data.io.guess_data_type(orig_values)
+            values, variable = data.io.sanitize_variable(
+                value_map, values, orig_values, var_type,
+                {}, _metas, None, var_name)
+            M[:, i] = values
+            return variable
+
         _metas = [StringVariable(n) for n in names]
         if old_domain:
             _metas = [m for m in old_domain.metas if m.name != meta_attr_name]
         M = get_table_from_attributes_of_attributes(_metas, _dtype=object)
+        if not old_domain:
+            _metas = [guessed_var(i, m.name) for i, m in enumerate(_metas)]
         if _metas:
             self.metas = np.hstack((self.metas, M))
             metas.extend(_metas)

Orange/tests/test_table.py

@@ -2449,7 +2449,7 @@ def test_transpose_class_and_metas(self):
         # original should not change
         self.assertDictEqual(data.domain.attributes[0].attributes, {})
 
-    def test_transpose_attributes_of_attributes(self):
+    def test_transpose_attributes_of_attributes_discrete(self):
         attrs = [ContinuousVariable("c1"), ContinuousVariable("c2")]
         attrs[0].attributes = {"attr1": "a", "attr2": "aa"}
         attrs[1].attributes = {"attr1": "b", "attr2": "bb"}
@@ -2458,11 +2458,12 @@ def test_transpose_attributes_of_attributes(self):
 
         att = [ContinuousVariable("Feature 1"), ContinuousVariable("Feature 2"),
                ContinuousVariable("Feature 3"), ContinuousVariable("Feature 4")]
-        metas = [StringVariable("Feature name"), StringVariable("attr1"),
-                 StringVariable("attr2")]
+        metas = [StringVariable("Feature name"),
+                 DiscreteVariable("attr1", values=("a", "b")),
+                 DiscreteVariable("attr2", values=("aa", "bb"))]
         domain = Domain(att, metas=metas)
-        result = Table(domain, np.arange(8).reshape((4, 2)).T,
-                       metas=np.array([["c1", "a", "aa"], ["c2", "b", "bb"]]))
+        M = np.array([["c1", 0, 0], ["c2", 1, 1]], dtype=object)
+        result = Table(domain, np.arange(8).reshape((4, 2)).T, metas=M)
 
         # transpose and compare
         self._compare_tables(result, Table.transpose(data))
@@ -2475,6 +2476,33 @@ def test_transpose_attributes_of_attributes(self):
         self.assertDictEqual(data.domain.attributes[0].attributes,
                              {"attr1": "a", "attr2": "aa"})
 
+    def test_transpose_attributes_of_attributes_continuous(self):
+        attrs = [ContinuousVariable("c1"), ContinuousVariable("c2")]
+        attrs[0].attributes = {"attr1": "1.100", "attr2": "1.300"}
+        attrs[1].attributes = {"attr1": "2.200", "attr2": "2.300"}
+        domain = Domain(attrs)
+        data = Table(domain, np.arange(8).reshape((4, 2)))
+
+        att = [ContinuousVariable("Feature 1"), ContinuousVariable("Feature 2"),
+               ContinuousVariable("Feature 3"), ContinuousVariable("Feature 4")]
+        metas = [StringVariable("Feature name"), ContinuousVariable("attr1"),
+                 ContinuousVariable("attr2")]
+        domain = Domain(att, metas=metas)
+        result = Table(domain, np.arange(8).reshape((4, 2)).T,
+                       metas=np.array([["c1", 1.1, 1.3],
+                                       ["c2", 2.2, 2.3]], dtype=object))
+
+        # transpose and compare
+        self._compare_tables(result, Table.transpose(data))
+
+        # transpose of transpose
+        t = Table.transpose(Table.transpose(data), "Feature name")
+        self._compare_tables(data, t)
+
+        # original should not change
+        self.assertDictEqual(data.domain.attributes[0].attributes,
+                             {"attr1": "1.100", "attr2": "1.300"})
+
     def test_transpose_attributes_of_attributes_missings(self):
         attrs = [ContinuousVariable("c1"), ContinuousVariable("c2")]
         attrs[0].attributes = {"attr1": "a", "attr2": "aa"}
@@ -2484,11 +2512,12 @@ def test_transpose_attributes_of_attributes_missings(self):
 
         att = [ContinuousVariable("Feature 1"), ContinuousVariable("Feature 2"),
                ContinuousVariable("Feature 3"), ContinuousVariable("Feature 4")]
-        metas = [StringVariable("Feature name"), StringVariable("attr1"),
-                 StringVariable("attr2")]
+        metas = [StringVariable("Feature name"),
+                 DiscreteVariable("attr1", values=("a", "b")),
+                 DiscreteVariable("attr2", values=("aa",))]
         domain = Domain(att, metas=metas)
-        result = Table(domain, np.arange(8).reshape((4, 2)).T,
-                       metas=np.array([["c1", "a", "aa"], ["c2", "b", ""]]))
+        M = np.array([["c1", 0, 0], ["c2", 1, np.nan]], dtype=object)
+        result = Table(domain, np.arange(8).reshape((4, 2)).T, metas=M)
 
         # transpose and compare
         self._compare_tables(result, Table.transpose(data))
@@ -2517,10 +2546,11 @@ def test_transpose_class_metas_attributes(self):
         att[1].attributes = {"cls": "2.000", "m1": "bb", "m2": "bbb"}
         att[2].attributes = {"cls": "3.000", "m1": "cc", "m2": "ccc"}
         att[3].attributes = {"cls": "4.000", "m1": "dd", "m2": "ddd"}
-        metas = [StringVariable("Feature name"), StringVariable("attr1"),
-                 StringVariable("attr2")]
+        metas = [StringVariable("Feature name"),
+                 DiscreteVariable("attr1", values=("a1", "b1")),
+                 DiscreteVariable("attr2", values=("aa1", "bb1"))]
         domain = Domain(att, metas=metas)
-        M = np.array([["c1", "a1", "aa1"], ["c2", "b1", "bb1"]])
+        M = np.array([["c1", 0, 0], ["c2", 1, 1]], dtype=object)
         result = Table(domain, np.arange(8).reshape((4, 2)).T, metas=M)
 
         # transpose and compare
@@ -2546,7 +2576,7 @@ def _compare_tables(self, table1, table2):
         self.assertEqual(table1.n_rows, table2.n_rows)
         np.testing.assert_array_equal(table1.X, table2.X)
         np.testing.assert_array_equal(table1.Y, table2.Y)
-        np.testing.assert_array_equal(table1.metas, table2.metas)
+        self.assertTrue((table1.metas == table2.metas).all())
         np.testing.assert_array_equal(table1.W, table2.W)
 
         self.assertEqual([(type(x), x.name, x.attributes)