Changeset 10644:68e7c096ec40 in orange


Ignore:
Timestamp:
03/22/12 14:14:00 (2 years ago)
Author:
anze <anze.staric@…>
Branch:
default
Message:

Fixed handling of unknown values.

Location:
Orange
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Orange/projection/linear.py

    r10613 r10644  
    12571257            dataset = data.Table(self.input_domain, dataset) 
    12581258 
    1259         X, = dataset.to_numpy("a") 
     1259        X, = dataset.to_numpy_MA("a") 
    12601260        Xm, U = self.mean, self.projection 
    12611261        n, m = X.shape 
     
    12701270 
    12711271        self.A = numpy.dot(Xd, U.T) 
    1272  
    1273         # TODO: Delete when orange will support creating data.Table from masked array. 
    1274         self.A = self.A.filled(0.) if isinstance(self.A, numpy.ma.core.MaskedArray) else self.A 
    1275         # append class variable 
    12761272 
    12771273        class_, classes = dataset.to_numpy("c")[0], dataset.to_numpy("m")[0] 
     
    13551351        if not len(dataset) or not len(dataset.domain.features): 
    13561352            raise ValueError("Empty dataset") 
    1357         X = dataset.to_numpy("a")[0] 
     1353        X = dataset.to_numpy_MA("a")[0] 
    13581354 
    13591355        Xm = numpy.mean(X, axis=0) 
  • Orange/testing/unit/tests/test_projection_linear.py

    r10612 r10644  
    2828 
    2929 
     30 
    3031class TestPca(unittest.TestCase): 
    3132    def create_normal_dataset(self): 
     
    4344        self.dataset = data.Table(*prepare_dataset(components=([0, 0, 0, 0, 0],))) 
    4445 
    45     def create_dataset_with_classes(self): 
    46         domain, features = prepare_dataset(components=[[random.randint(0, 5) for _ in range(10)]]) 
    47         domain = data.Domain(domain.features, 
    48                              feature.Discrete("C", values=["F", "T"]), 
    49                              class_vars=[feature.Discrete("MC%i" % i, values=["F", "T"]) for i in range(4)]) 
     46    def create_dataset_with_unknowns(self, percentage=0.05): 
     47        self.principal_component = normalize([random.randint(0, 5) for _ in range(10)]) 
     48        self.dataset = data.Table(*prepare_dataset(components=[self.principal_component])) 
    5049 
    51         self.dataset = data.Table(domain, np.hstack((features, np.random.random((len(features), 5))))) 
     50        for ex in self.dataset: 
     51            for i, _ in enumerate(ex): 
     52                if random.random() < percentage: 
     53                    ex[i] = "?" 
    5254 
    5355 
     
    9799        self.assertEqual(nvectors, max_components) 
    98100 
    99     def test_pca_converts_domain(self): 
    100         self.create_dataset_with_classes() 
    101         pca = linear.Pca(variance_covered=.99)(self.dataset) 
     101    def test_pca_handles_unknowns(self): 
     102        self.create_dataset_with_unknowns() 
     103        print self.dataset[0] 
    102104 
    103         projected_data = pca(self.dataset) 
    104         converted_data = data.Table(projected_data.domain, self.dataset) 
     105        pca = linear.Pca()(self.dataset) 
    105106 
    106         self.assertItemsEqual(projected_data, converted_data) 
    107  
    108     def test_pca_converts_classless_domain(self): 
    109         self.create_normal_dataset() 
    110         pca = linear.Pca(variance_covered=.99)(self.dataset) 
    111  
    112         projected_data = pca(self.dataset) 
    113         converted_data = data.Table(projected_data.domain, self.dataset) 
    114  
    115         self.assertItemsEqual(projected_data, converted_data) 
    116  
    117     def test_pca_keeps_class_vars(self): 
    118         self.create_dataset_with_classes() 
    119  
    120         pca = linear.Pca(variance_covered=.99)(self.dataset) 
    121         projected_data = pca(self.dataset) 
    122  
    123         self.assertIn(self.dataset.domain.class_var, projected_data.domain) 
    124         for class_ in self.dataset.domain.class_vars: 
    125             self.assertIn(class_, projected_data.domain) 
    126         for ex1, ex2 in zip(self.dataset, projected_data): 
    127             self.assertEqual(ex1.get_class(), ex2.get_class()) 
    128             for v1, v2 in zip(ex1.get_classes(), ex2.get_classes()): 
    129                 self.assertEqual(v2, v2) 
    130107 
    131108 
     
    143120 
    144121 
     122class TestProjector(unittest.TestCase): 
     123    def create_normal_dataset(self): 
     124        self.principal_component = normalize([random.randint(0, 5) for _ in range(10)]) 
     125        self.dataset = data.Table(*prepare_dataset(components=[self.principal_component])) 
     126 
     127    def create_dataset_with_classes(self): 
     128        domain, features = prepare_dataset(components=[[random.randint(0, 5) for _ in range(10)]]) 
     129        domain = data.Domain(domain.features, 
     130                             feature.Discrete("C", values=["F", "T"]), 
     131                             class_vars=[feature.Discrete("MC%i" % i, values=["F", "T"]) for i in range(4)]) 
     132 
     133        self.dataset = data.Table(domain, np.hstack((features, np.random.random((len(features), 5))))) 
     134 
     135 
     136    def test_projected_domain_can_convert_data_with_class(self): 
     137        self.create_dataset_with_classes() 
     138        projector = linear.Pca(variance_covered=.99)(self.dataset) 
     139 
     140        projected_data = projector(self.dataset) 
     141        converted_data = data.Table(projected_data.domain, self.dataset) 
     142 
     143        self.assertItemsEqual(projected_data, converted_data) 
     144 
     145    def test_projected_domain_can_convert_data_without_class(self): 
     146        self.create_normal_dataset() 
     147        projector = linear.Pca(variance_covered=.99)(self.dataset) 
     148 
     149        projected_data = projector(self.dataset) 
     150        converted_data = data.Table(projected_data.domain, self.dataset) 
     151 
     152        self.assertItemsEqual(projected_data, converted_data) 
     153 
     154    def test_projected_domain_contains_class_vars(self): 
     155        self.create_dataset_with_classes() 
     156 
     157        projector = linear.Pca(variance_covered=.99)(self.dataset) 
     158        projected_data = projector(self.dataset) 
     159 
     160        self.assertIn(self.dataset.domain.class_var, projected_data.domain) 
     161        for class_ in self.dataset.domain.class_vars: 
     162            self.assertIn(class_, projected_data.domain) 
     163        for ex1, ex2 in zip(self.dataset, projected_data): 
     164            self.assertEqual(ex1.get_class(), ex2.get_class()) 
     165            for v1, v2 in zip(ex1.get_classes(), ex2.get_classes()): 
     166                self.assertEqual(v2, v2) 
     167 
     168 
     169    def test_projects_example(self): 
     170        self.create_normal_dataset() 
     171        projector = linear.Pca(variance_covered=.99)(self.dataset) 
     172 
     173        projector(self.dataset[0]) 
     174 
     175    def test_projects_data_table(self): 
     176        self.create_normal_dataset() 
     177        projector = linear.Pca(variance_covered=.99)(self.dataset) 
     178 
     179        projector(self.dataset) 
     180 
     181    def test_converts_input_domain_if_needed(self): 
     182        self.create_normal_dataset() 
     183        projector = linear.Pca(variance_covered=.99)(self.dataset) 
     184 
     185        new_examples = data.Table(data.Domain(self.dataset.domain.features[:5]), [[1.,2.,3.,4.,5.]]) 
     186 
     187        projector(new_examples) 
     188 
     189 
    145190class TestFda(unittest.TestCase): 
    146191    pass 
Note: See TracChangeset for help on using the changeset viewer.