def test_classify_missing_label(self):
ccol = ClassifierCollection({
'subjectA': DummyClassifier(),
'subjectB': DummyClassifier(),
})
d_v = [0, 1, 2, 3, 4]
d = DescriptorMemoryElement('memory', '0')
d.set_vector(d_v)
# Should throw a MissingLabelError
with self.assertRaises(MissingLabelError) as cm:
ccol.classify(d, labels=['subjectC'])
self.assertSetEqual(cm.exception.labels, {'subjectC'})
# Should throw a MissingLabelError
with self.assertRaises(MissingLabelError) as cm:
ccol.classify(d, labels=['subjectA', 'subjectC'])
self.assertSetEqual(cm.exception.labels, {'subjectC'})
# Should throw a MissingLabelError
with self.assertRaises(MissingLabelError) as cm:
ccol.classify(d, labels=['subjectC', 'subjectD'])
self.assertSetEqual(cm.exception.labels, {'subjectC', 'subjectD'})
# Should throw a MissingLabelError
with self.assertRaises(MissingLabelError) as cm:
ccol.classify(d, labels=['subjectA', 'subjectC', 'subjectD'])
self.assertSetEqual(cm.exception.labels, {'subjectC', 'subjectD'})
def test_classify_subset(self):
ccol = ClassifierCollection({
'subjectA': DummyClassifier(),
'subjectB': DummyClassifier(),
})
classifierB = ccol._label_to_classifier['subjectB']
classifierB.classify_one_element = mock.Mock()
d_v = [0, 1, 2, 3, 4]
d = DescriptorMemoryElement('memory', '0')
d.set_vector(d_v)
result = ccol.classify(d, labels=['subjectA'])
# Should contain one entry for each requested classifier.
self.assertEqual(len(result), 1)
self.assertIn('subjectA', result)
self.assertNotIn('subjectB', result)
classifierB.classify_one_element.assert_not_called()
# Each key should map to a classification element (memory in this case
# because we're using the default factory)
self.assertIsInstance(result['subjectA'], MemoryClassificationElement)
# We know the dummy classifier outputs "classifications" in a
# deterministic way: class label is descriptor UUID and classification
# value is its vector as a list.
self.assertDictEqual(result['subjectA'].get_classification(),
{'test': 0})
def test_classify(self):
""" Test invoking `classify` in a valid manner. """
ccol = ClassifierCollection({
'subjectA': DummyClassifier(),
'subjectB': DummyClassifier(),
})
d_v = [0, 1, 2, 3, 4]
d = DescriptorMemoryElement('memory', '0')
d.set_vector(d_v)
result = ccol.classify(d)
# Should contain one entry for each configured classifier.
self.assertEqual(len(result), 2)
self.assertIn('subjectA', result)
self.assertIn('subjectB', result)
# Each key should map to a classification element (memory in this case
# because we're using the default factory)
self.assertIsInstance(result['subjectA'], MemoryClassificationElement)
self.assertIsInstance(result['subjectB'], MemoryClassificationElement)
# We know the dummy classifier outputs "classifications" in a
# deterministic way: class label is "test" and classification
# value is the index of the descriptor .
self.assertDictEqual(result['subjectA'].get_classification(),
{'test': 0})
self.assertDictEqual(result['subjectB'].get_classification(),
{'test': 0})
def test_classify_empty_subset(self):
ccol = ClassifierCollection({
'subjectA': DummyClassifier(),
'subjectB': DummyClassifier(),
})
classifierA = ccol._label_to_classifier['subjectA']
classifierA.classify_one_element = mock.Mock()
classifierB = ccol._label_to_classifier['subjectB']
classifierB.classify_one_element = mock.Mock()
d_v = [0, 1, 2, 3, 4]
d = DescriptorMemoryElement('memory', '0')
d.set_vector(d_v)
result = ccol.classify(d, labels=[])
# Should contain no entries.
self.assertEqual(len(result), 0)
self.assertNotIn('subjectA', result)
classifierA.classify_one_element.assert_not_called()
self.assertNotIn('subjectB', result)
classifierB.classify_one_element.assert_not_called()