def test_predictDiscrete(self):
s1 = self.createSignature(1, -1)
s2 = self.createSignature(2, -2)
s3 = self.createSignature(3, -3)
s4 = self.createSignature(4, -4)
trainFts = FeatureSet_Discrete()
trainFts.AddSignature(s1, 0)
trainFts.AddSignature(s2, 0)
trainFts.AddSignature(s3, 1)
trainFts.AddSignature(s4, 1)
tmp = trainFts.ContiguousDataMatrix()
# Values are chosen so that different weights give different predictions
s5 = self.createSignature(0, -5)
s6 = self.createSignature(5, 0)
testFts = FeatureSet_Discrete()
testFts.AddSignature(s5, 0)
testFts.AddSignature(s6, 0)
tmp = testFts.ContiguousDataMatrix()
weights = FisherFeatureWeights()
weights.names = ['ft [0]', 'ft [1]']
weights.values = [2.0, 1.0]
pred = DiscreteBatchClassificationResult.New(trainFts, testFts,
weights)
self.assertEqual(len(pred.individual_results), 2)
r1, r2 = pred.individual_results
np.testing.assert_almost_equal(r1.marginal_probabilities,
[0.975, 0.025],
decimal=3)
np.testing.assert_almost_equal(r2.marginal_probabilities,
[0.025, 0.975],
decimal=3)
weights = FisherFeatureWeights()
weights.names = ['ft [0]', 'ft [1]']
weights.values = [1.0, 2.0]
pred = DiscreteBatchClassificationResult.New(trainFts, testFts,
weights)
self.assertEqual(len(pred.individual_results), 2)
r1, r2 = pred.individual_results
np.testing.assert_almost_equal(r1.marginal_probabilities,
[0.025, 0.975],
decimal=3)
np.testing.assert_almost_equal(r2.marginal_probabilities,
[0.975, 0.025],
decimal=3)
def test_fisherFeatureWeights(self):
sig1, sig2, sig3, sig4 = self.createSignatures()
fts = FeatureSet_Discrete()
fts.AddSignature(sig1, 0)
fts.AddSignature(sig2, 0)
fts.AddSignature(sig3, 1)
fts.AddSignature(sig4, 1)
tmp = fts.ContiguousDataMatrix()
# TODO: weight[1]==0, presumably because the intra-class variance=0,
# even though feature[1] is a perfect discriminator?
fts.Normalize()
wts = FisherFeatureWeights.NewFromFeatureSet(fts)
np.testing.assert_almost_equal(wts.values, [4.0, 0.0])
self.assertEqual(wts.names, ['ft [0]', 'ft [1]'])
def test_createFeatureSet(self):
sig1, sig2, sig3, sig4 = self.createSignatures()
fts = FeatureSet_Discrete()
# Add classes out of order
fts.AddSignature(sig3, 1)
self.assertEqual(fts.num_classes, 2)
self.assertEqual(fts.num_features, 2)
self.assertEqual(fts.num_images, 1)
self.assertEqual(len(fts.data_list), 2)
self.assertIsNone(fts.data_list[0])
#self.assertSequenceEqual
np.testing.assert_almost_equal(fts.data_list[1], sig3.values)
self.assertEqual(fts.classsizes_list, [0, 1])
self.assertEqual(fts.classnames_list, ['UNKNOWN1', 'UNKNOWN2'])
fts.AddSignature(sig1, 0)
self.assertEqual(fts.num_classes, 2)
self.assertEqual(fts.num_features, 2)
self.assertEqual(fts.num_images, 2)
self.assertEqual(len(fts.data_list), 2)
np.testing.assert_almost_equal(fts.data_list[0], sig1.values)
np.testing.assert_almost_equal(fts.data_list[1], sig3.values)
self.assertEqual(fts.classsizes_list, [1, 1])
self.assertEqual(fts.classnames_list, ['UNKNOWN1', 'UNKNOWN2'])
# fts.ContiguousDataMatrix() fails unless there are at least two images
# per class, is this really necessary?
#tmp = fts.ContiguousDataMatrix()
fts.AddSignature(sig2, 0)
fts.AddSignature(sig4, 1)
self.assertEqual(fts.classsizes_list, [2, 2])
self.assertEqual(fts.num_images, 4)
tmp = fts.ContiguousDataMatrix()
self.assertEqual(fts.data_matrix.shape, (4, 2))
np.testing.assert_almost_equal(fts.data_matrix[0], sig1.values)
np.testing.assert_almost_equal(fts.data_matrix[1], sig2.values)
np.testing.assert_almost_equal(fts.data_matrix[2], sig3.values)
np.testing.assert_almost_equal(fts.data_matrix[3], sig4.values)
