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

Fixed handling of unknown values.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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.