def test_confusion_call(self):
# Also tests for the consistency of the labels as
# either provided or collected by ConfusionMatrix through its lifetime
self.assertRaises(RuntimeError, ConfusionMatrix(), [1], [1])
self.assertRaises(ValueError, ConfusionMatrix(labels=[2]), [1], [1])
# Now lets test proper matrix and either we obtain the same
t = ['ho', 'ho', 'ho', 'fa', 'fa', 'ho', 'ho']
p = ['ho', 'ho', 'ho', 'ho', 'fa', 'fa', 'fa']
cm1 = ConfusionMatrix(labels=['ho', 'fa'])
cm2 = ConfusionMatrix(labels=['fa', 'ho'])
assert_array_equal(cm1(p, t), [[3, 1], [2, 1]])
assert_array_equal(cm2(p, t),
[[1, 2], [1, 3]]) # reverse order of labels
cm1_ = ConfusionMatrix(labels=['ho', 'fa'], sets=[(t, p)])
assert_array_equal(cm1(p, t), cm1_.matrix) # both should be identical
# Lets provoke "mother" CM to get to know more labels which could get ahead
# of the known ones
cm1.add(['ho', 'aa'], ['ho', 'aa'])
# compare and cause recomputation so .__labels get reassigned
assert_equal(cm1.labels, ['ho', 'fa', 'aa'])
assert_array_equal(cm1(p, t), [[3, 1, 0], [2, 1, 0], [0, 0, 0]])
assert_equal(len(cm1.sets),
1) # just 1 must be known atm from above add
assert_array_equal(cm1(p, t, store=True),
[[3, 1, 0], [2, 1, 0], [0, 0, 0]])
assert_equal(len(cm1.sets), 2) # and now 2
assert_array_equal(cm1(p + ['ho', 'aa'], t + ['ho', 'aa']), cm1.matrix)
def test_confusion_call(self):
# Also tests for the consistency of the labels as
# either provided or collected by ConfusionMatrix through its lifetime
self.assertRaises(RuntimeError, ConfusionMatrix(), [1], [1])
self.assertRaises(ValueError, ConfusionMatrix(labels=[2]), [1], [1])
# Now lets test proper matrix and either we obtain the same
t = ['ho', 'ho', 'ho', 'fa', 'fa', 'ho', 'ho']
p = ['ho','ho', 'ho', 'ho', 'fa', 'fa', 'fa']
cm1 = ConfusionMatrix(labels=['ho', 'fa'])
cm2 = ConfusionMatrix(labels=['fa', 'ho'])
assert_array_equal(cm1(p, t), [[3, 1], [2, 1]])
assert_array_equal(cm2(p, t), [[1, 2], [1, 3]]) # reverse order of labels
cm1_ = ConfusionMatrix(labels=['ho', 'fa'], sets=[(t,p)])
assert_array_equal(cm1(p, t), cm1_.matrix) # both should be identical
# Lets provoke "mother" CM to get to know more labels which could get ahead
# of the known ones
cm1.add(['ho', 'aa'], ['ho', 'aa'])
# compare and cause recomputation so .__labels get reassigned
assert_equal(cm1.labels, ['ho', 'fa', 'aa'])
assert_array_equal(cm1(p, t), [[3, 1, 0], [2, 1, 0], [0, 0, 0]])
assert_equal(len(cm1.sets), 1) # just 1 must be known atm from above add
assert_array_equal(cm1(p, t, store=True), [[3, 1, 0], [2, 1, 0], [0, 0, 0]])
assert_equal(len(cm1.sets), 2) # and now 2
assert_array_equal(cm1(p + ['ho', 'aa'], t + ['ho', 'aa']), cm1.matrix)
def test_confusion_matrix(self):
data = np.array([1, 2, 1, 2, 2, 2, 3, 2, 1], ndmin=2).T
reg = [1, 1, 1, 2, 2, 2, 3, 3, 3]
regl = [1, 2, 1, 2, 2, 2, 3, 2, 1]
correct_cm = [[2, 0, 1], [1, 3, 1], [0, 0, 1]]
# Check if we are ok with any input type - either list, or np.array, or tuple
for t in [reg, tuple(reg), list(reg), np.array(reg)]:
for p in [regl, tuple(regl), list(regl), np.array(regl)]:
cm = ConfusionMatrix(targets=t, predictions=p)
# check table content
self.assertTrue((cm.matrix == correct_cm).all())
# Do a bit more thorough checking
cm = ConfusionMatrix()
self.assertRaises(ZeroDivisionError, lambda x: x.percent_correct, cm)
"""No samples -- raise exception"""
cm.add(reg, regl)
self.assertEqual(len(cm.sets),
1,
msg="Should have a single set so far")
self.assertEqual(
cm.matrix.shape, (3, 3),
msg="should be square matrix (len(reglabels) x len(reglabels)")
self.assertRaises(ValueError, cm.add, reg, np.array([1]))
"""ConfusionMatrix must complaint if number of samples different"""
# check table content
self.assertTrue((cm.matrix == correct_cm).all())
# lets add with new labels (not yet known)
cm.add(reg, np.array([1, 4, 1, 2, 2, 2, 4, 2, 1]))
self.assertEqual(cm.labels, [1, 2, 3, 4],
msg="We should have gotten 4th label")
matrices = cm.matrices # separate CM per each given set
self.assertEqual(len(matrices), 2, msg="Have gotten two splits")
self.assertTrue(
(matrices[0].matrix + matrices[1].matrix == cm.matrix).all(),
msg="Total votes should match the sum across split CMs")
# check pretty print
# just a silly test to make sure that printing works
self.assertTrue(
len(cm.as_string(header=True, summary=True, description=True)) >
100)
self.assertTrue(len(str(cm)) > 100)
# and that it knows some parameters for printing
self.assertTrue(len(cm.as_string(summary=True, header=False)) > 100)
# lets check iadd -- just itself to itself
cm += cm
self.assertEqual(len(cm.matrices), 4, msg="Must be 4 sets now")
# lets check add -- just itself to itself
cm2 = cm + cm
self.assertEqual(len(cm2.matrices), 8, msg="Must be 8 sets now")
self.assertEqual(cm2.percent_correct,
cm.percent_correct,
msg="Percent of corrrect should remain the same ;-)")
self.assertEqual(cm2.error,
1.0 - cm.percent_correct / 100.0,
msg="Test if we get proper error value")
def test_confusion_matrix(self):
data = np.array([1,2,1,2,2,2,3,2,1], ndmin=2).T
reg = [1,1,1,2,2,2,3,3,3]
regl = [1,2,1,2,2,2,3,2,1]
correct_cm = [[2,0,1],[1,3,1],[0,0,1]]
# Check if we are ok with any input type - either list, or np.array, or tuple
for t in [reg, tuple(reg), list(reg), np.array(reg)]:
for p in [regl, tuple(regl), list(regl), np.array(regl)]:
cm = ConfusionMatrix(targets=t, predictions=p)
# check table content
self.assertTrue((cm.matrix == correct_cm).all())
# Do a bit more thorough checking
cm = ConfusionMatrix()
self.assertRaises(ZeroDivisionError, lambda x:x.percent_correct, cm)
"""No samples -- raise exception"""
cm.add(reg, regl)
self.assertEqual(len(cm.sets), 1,
msg="Should have a single set so far")
self.assertEqual(cm.matrix.shape, (3,3),
msg="should be square matrix (len(reglabels) x len(reglabels)")
self.assertRaises(ValueError, cm.add, reg, np.array([1]))
"""ConfusionMatrix must complaint if number of samples different"""
# check table content
self.assertTrue((cm.matrix == correct_cm).all())
# lets add with new labels (not yet known)
cm.add(reg, np.array([1,4,1,2,2,2,4,2,1]))
self.assertEqual(cm.labels, [1,2,3,4],
msg="We should have gotten 4th label")
matrices = cm.matrices # separate CM per each given set
self.assertEqual(len(matrices), 2,
msg="Have gotten two splits")
self.assertTrue((matrices[0].matrix + matrices[1].matrix == cm.matrix).all(),
msg="Total votes should match the sum across split CMs")
# check pretty print
# just a silly test to make sure that printing works
self.assertTrue(len(cm.as_string(
header=True, summary=True,
description=True))>100)
self.assertTrue(len(str(cm))>100)
# and that it knows some parameters for printing
self.assertTrue(len(cm.as_string(summary=True,
header=False))>100)
# lets check iadd -- just itself to itself
cm += cm
self.assertEqual(len(cm.matrices), 4, msg="Must be 4 sets now")
# lets check add -- just itself to itself
cm2 = cm + cm
self.assertEqual(len(cm2.matrices), 8, msg="Must be 8 sets now")
self.assertEqual(cm2.percent_correct, cm.percent_correct,
msg="Percent of corrrect should remain the same ;-)")
self.assertEqual(cm2.error, 1.0-cm.percent_correct/100.0,
msg="Test if we get proper error value")
