Multi-label F1 score (#11)

This patch adds support of multi-label F1 score as well as unit test
to ensure that F1 is calculated correctly.

Author: ybubnov

keras_metrics/metrics.py

@@ -218,21 +218,21 @@ def __call__(self, y_true, y_pred):
 
 
 class f1_score(layer):
-    """Create  a metric for the model's F1 score calculation.
+    """Create a metric for the model's F1 score calculation.
 
     The F1 score is the harmonic mean of precision and recall.
     """
 
-    def __init__(self, name="f1_score", **kwargs):
-        super(f1_score, self).__init__(name=name, **kwargs)
+    def __init__(self, name="f1_score", label=None, **kwargs):
+        super(f1_score, self).__init__(name=name, label=label, **kwargs)
 
-        self.pr = precision()
-        self.rec = recall()
+        self.precision = precision(label=label)
+        self.recall = recall(label=label)
 
     def reset_states(self):
         """Reset the state of the metrics."""
-        self.pr.reset_states()
-        self.rec.reset_states()
+        self.precision.reset_states()
+        self.recall.reset_states()
 
     def __call__(self, y_true, y_pred):
         pr = self.precision(y_true, y_pred)

tests/test_metrics.py

@@ -13,14 +13,15 @@ def test_metrics(self):
 
         precision = keras_metrics.precision()
         recall = keras_metrics.recall()
+        f1 = keras_metrics.f1_score()
 
         model = keras.models.Sequential()
         model.add(keras.layers.Dense(1, activation="sigmoid", input_dim=2))
         model.add(keras.layers.Dense(1, activation="softmax"))
 
         model.compile(optimizer="sgd",
                       loss="binary_crossentropy",
-                      metrics=[tp, fp, fn, precision, recall])
+                      metrics=[tp, fp, fn, precision, recall, f1])
 
         samples = 1000
         x = numpy.random.random((samples, 2))
@@ -35,12 +36,18 @@ def test_metrics(self):
 
         precision = metrics[3]
         recall = metrics[4]
+        f1 = metrics[5]
 
         expected_precision = tp_val / (tp_val + fp_val)
         expected_recall = tp_val / (tp_val + fn_val)
 
+        f1_divident = (expected_precision*expected_recall)
+        f1_divisor = (expected_precision+expected_recall)
+        expected_f1 = (2 * f1_divident / f1_divisor)
+
         self.assertAlmostEqual(expected_precision, precision, delta=0.05)
         self.assertAlmostEqual(expected_recall, recall, delta=0.05)
+        self.assertAlmostEqual(expected_f1, f1, delta=0.05)
 
 
 if __name__ == "__main__":