Added support for sparse labels (#30)

This patch provides support for sparse labels.

Author: aronhoff

keras_metrics/metrics.py

@@ -6,11 +6,12 @@
 
 class layer(Layer):
 
-    def __init__(self, label=None, name=None, **kwargs):
+    def __init__(self, label=None, name=None, sparse=False, **kwargs):
         super(layer, self).__init__(name=name, **kwargs)
         self.stateful = True
         self.epsilon = K.constant(K.epsilon(), dtype="float64")
         self.__name__ = name
+        self.sparse = sparse
 
         # If layer metric is explicitly created to evaluate specified class,
         # then use a binary transformation of the output arrays, otherwise
@@ -30,7 +31,10 @@ def _binary(self, y_true, y_pred, dtype, label=0):
         column = slice(label, label+1)
 
         # Slice a column of the output array.
-        y_true = y_true[...,column]
+        if self.sparse:
+            y_true = K.cast(K.equal(y_true, label), dtype=dtype)
+        else:
+            y_true = y_true[...,column]
         y_pred = y_pred[...,column]
         return self._categorical(y_true, y_pred, dtype)
 
@@ -65,8 +69,8 @@ class true_positive(layer):
     positive class.
     """
 
-    def __init__(self, name="true_positive", **kwargs):
-        super(true_positive, self).__init__(name=name, **kwargs)
+    def __init__(self, name="true_positive", label=None, sparse=False, **kwargs):
+        super(true_positive, self).__init__(name=name, label=label, sparse=sparse, **kwargs)
         self.tp = K.variable(0, dtype="int32")
 
     def reset_states(self):
@@ -92,8 +96,8 @@ class true_negative(layer):
     negative class.
     """
 
-    def __init__(self, name="true_negative", **kwargs):
-        super(true_negative, self).__init__(name=name, **kwargs)
+    def __init__(self, name="true_negative", label=None, sparse=False, **kwargs):
+        super(true_negative, self).__init__(name=name, label=label, sparse=sparse, **kwargs)
         self.tn = K.variable(0, dtype="int32")
 
     def reset_states(self):
@@ -122,8 +126,8 @@ class false_negative(layer):
     negative class.
     """
 
-    def __init__(self, name="false_negative", **kwargs):
-        super(false_negative, self).__init__(name=name, **kwargs)
+    def __init__(self, name="false_negative", label=None, sparse=False, **kwargs):
+        super(false_negative, self).__init__(name=name, label=label, sparse=sparse, **kwargs)
         self.fn = K.variable(0, dtype="int32")
 
     def reset_states(self):
@@ -150,8 +154,8 @@ class false_positive(layer):
     positive class.
     """
 
-    def __init__(self, name="false_positive", **kwargs):
-        super(false_positive, self).__init__(name=name, **kwargs)
+    def __init__(self, name="false_positive", label=None, sparse=False, **kwargs):
+        super(false_positive, self).__init__(name=name, label=label, sparse=sparse, **kwargs)
         self.fp = K.variable(0, dtype="int32")
 
     def reset_states(self):
@@ -177,11 +181,11 @@ class recall(layer):
     Recall measures proportion of actual positives that was identified correctly.
     """
 
-    def __init__(self, name="recall", **kwargs):
-        super(recall, self).__init__(name=name, **kwargs)
+    def __init__(self, name="recall", label=None, sparse=False, **kwargs):
+        super(recall, self).__init__(name=name, label=label, sparse=sparse, **kwargs)
 
-        self.tp = true_positive()
-        self.fn = false_negative()
+        self.tp = true_positive(label=label, sparse=sparse)
+        self.fn = false_negative(label=label, sparse=sparse)
 
     def reset_states(self):
         """Reset the state of the metrics."""
@@ -208,11 +212,11 @@ class precision(layer):
     actually correct.
     """
 
-    def __init__(self, name="precision", **kwargs):
-        super(precision, self).__init__(name=name, **kwargs)
+    def __init__(self, name="precision", label=None, sparse=False, **kwargs):
+        super(precision, self).__init__(name=name, label=label, sparse=sparse, **kwargs)
 
-        self.tp = true_positive()
-        self.fp = false_positive()
+        self.tp = true_positive(label=label, sparse=sparse)
+        self.fp = false_positive(label=label, sparse=sparse)
 
     def reset_states(self):
         """Reset the state of the metrics."""
@@ -238,11 +242,11 @@ class f1_score(layer):
     The F1 score is the harmonic mean of precision and recall.
     """
 
-    def __init__(self, name="f1_score", label=None, **kwargs):
-        super(f1_score, self).__init__(name=name, label=label, **kwargs)
+    def __init__(self, name="f1_score", label=None, sparse=False, **kwargs):
+        super(f1_score, self).__init__(name=name, label=label, sparse=sparse, **kwargs)
 
-        self.precision = precision(label=label)
-        self.recall = recall(label=label)
+        self.precision = precision(label=label, sparse=sparse)
+        self.recall = recall(label=label, sparse=sparse)
 
     def reset_states(self):
         """Reset the state of the metrics."""

tests/test_metrics.py

@@ -9,38 +9,52 @@
 
 class TestMetrics(unittest.TestCase):
 
+    def __init__(self, methodName, sparse=False):
+        super(TestMetrics, self).__init__(methodName=methodName)
+        self.sparse = sparse
+
     def setUp(self):
-        tp = keras_metrics.true_positive()
-        tn = keras_metrics.true_negative()
-        fp = keras_metrics.false_positive()
-        fn = keras_metrics.false_negative()
+        tp = keras_metrics.true_positive(sparse=self.sparse)
+        tn = keras_metrics.true_negative(sparse=self.sparse)
+        fp = keras_metrics.false_positive(sparse=self.sparse)
+        fn = keras_metrics.false_negative(sparse=self.sparse)
 
-        precision = keras_metrics.precision()
-        recall = keras_metrics.recall()
-        f1 = keras_metrics.f1_score()
+        precision = keras_metrics.precision(sparse=self.sparse)
+        recall = keras_metrics.recall(sparse=self.sparse)
+        f1 = keras_metrics.f1_score(sparse=self.sparse)
 
         self.model = keras.models.Sequential()
         self.model.add(keras.layers.Activation(keras.backend.sin))
         self.model.add(keras.layers.Activation(keras.backend.abs))
 
+        if self.sparse:
+            loss = "sparse_categorical_crossentropy"
+        else:
+            loss = "binary_crossentropy"
+
         self.model.compile(optimizer="sgd",
-                           loss="binary_crossentropy",
+                           loss=loss,
                            metrics=[tp, tn, fp, fn, precision, recall, f1])
 
     def samples(self, n):
-        x = numpy.random.uniform(0, numpy.pi/2, (n, 1))
-        y = numpy.random.randint(2, size=(n, 1))
+        if self.sparse:
+            categories = 2
+            x = numpy.random.uniform(0, numpy.pi/2, (n, categories))
+            y = numpy.random.randint(categories, size=(n, 1))
+        else:
+            x = numpy.random.uniform(0, numpy.pi/2, (n, 1))
+            y = numpy.random.randint(2, size=(n, 1))
         return x, y
 
     def test_save_load(self):
         custom_objects = {
-            "true_positive": keras_metrics.true_positive(),
-            "true_negative": keras_metrics.true_negative(),
-            "false_positive": keras_metrics.false_positive(),
-            "false_negative": keras_metrics.false_negative(),
-            "precision": keras_metrics.precision(),
-            "recall": keras_metrics.recall(),
-            "f1_score": keras_metrics.f1_score(),
+            "true_positive": keras_metrics.true_positive(sparse=self.sparse),
+            "true_negative": keras_metrics.true_negative(sparse=self.sparse),
+            "false_positive": keras_metrics.false_positive(sparse=self.sparse),
+            "false_negative": keras_metrics.false_negative(sparse=self.sparse),
+            "precision": keras_metrics.precision(sparse=self.sparse),
+            "recall": keras_metrics.recall(sparse=self.sparse),
+            "f1_score": keras_metrics.f1_score(sparse=self.sparse),
             "sin": keras.backend.sin,
             "abs": keras.backend.abs,
         }
@@ -97,5 +111,16 @@ def test_metrics(self):
         self.assertAlmostEqual(expected_f1, f1, places=places)
 
 
+def suite():
+    s = unittest.TestSuite()
+    s.addTests(TestMetrics(methodName=method, sparse=sparse)
+               for method in unittest.defaultTestLoader.getTestCaseNames(TestMetrics)
+               for sparse in (False, True))
+    return s
+
+
 if __name__ == "__main__":
-    unittest.main()
+    import sys
+    result = unittest.TextTestRunner().run(suite())
+    sys.exit(not result.wasSuccessful())
+    # unittest.main()