Add DeepGini Quantifier (#92)

This adds the *DeepGini* uncertainty quantifier.

The implementation and this PR are part of the following paper:

> Michael Weiss and Paolo Tonella, **Simple Techniques Work Surprisingly Well for Neural Network Test Prioritization and Active Learning (Replication Paper)**, Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis. 2021. (forthcoming)

DeepGini was proposed in the following paper:

> Feng, Yang, et al. **Deepgini: prioritizing massive tests to enhance the robustness of deep neural networks.**, Proceedings of the 29th ACM SIGSOFT International Symposium on Software Testing and Analysis. 2020.

Author: MiWeiss

.gitignore

@@ -16,3 +16,4 @@
 /uncertainty_wizard.egg-info/
 /examples/temp-ensemble.txt
 **/__pycache__/
+/lf_logs/*

tests_unit/quantifiers_tests/test_one_shot_classifiers.py

@@ -8,9 +8,51 @@
     QuantifierRegistry,
     SoftmaxEntropy,
 )
+from uncertainty_wizard.quantifiers.one_shot_classifiers import DeepGini
 from uncertainty_wizard.quantifiers.quantifier import ProblemType
 
 
+class TestDeepGini(TestCase):
+    def test_string_representation(self):
+        self.assertTrue(isinstance(QuantifierRegistry.find("DeepGini"), DeepGini))
+        self.assertTrue(isinstance(QuantifierRegistry.find("deep_gini"), DeepGini))
+
+    def test_is_confidence(self):
+        self.assertFalse(DeepGini.is_confidence())
+        self.assertFalse(DeepGini().is_confidence())
+
+    def test_samples_type_declaration(self):
+        self.assertFalse(DeepGini.takes_samples())
+
+    def test_problem_type(self):
+        self.assertEqual(DeepGini.problem_type(), ProblemType.CLASSIFICATION)
+
+    def test_quantification(self):
+        input_batch = np.array(
+            [
+                [0.1, 0.2, 0.3, 0.4],
+                [0.5, 0.1, 0.1, 0.3],
+                [0.25, 0.25, 0.25, 0.25],
+                [1.0, 0, 0, 0],
+                [0, 1.0, 0, 0],
+            ]
+        )
+
+        expected = np.array(
+            [
+                0.7,  # https://bit.ly/301vmQ3
+                0.64,  # https://bit.ly/3qkHuGm
+                0.75,  # https://bit.ly/3wrPI0h
+                0,  # Trivial
+                0,  # Re-Ordering of previous
+            ]
+        )
+
+        pred, unc = DeepGini.calculate(input_batch)
+        assert np.all(pred == np.array([3, 0, 0, 0, 1]))
+        assert np.all(unc == expected)
+
+
 class TestPCS(TestCase):
 
     # =================

uncertainty_wizard/quantifiers/one_shot_classifiers.py

@@ -142,3 +142,43 @@ def calculate(cls, nn_outputs: np.ndarray):
         entropies = uwiz.quantifiers.predictive_entropy.entropy(nn_outputs, axis=1)
 
         return calculated_predictions, entropies
+
+
+class DeepGini(UncertaintyQuantifier):
+    """DeepGini - Uncertainty (1 minus sum of squared softmax outputs).
+
+
+    See Feng. et. al., "Deepgini: prioritizing massive tests to enhance
+    the robustness of deep neural networks" for more information. ISSTA 2020.
+
+    The implementation is part of our paper:
+    Michael Weiss and Paolo Tonella, Simple Techniques Work Surprisingly Well
+    for Neural Network Test Prioritization and Active Learning (Replication Paper),
+    ISSTA 2021. (forthcoming)"""
+
+    # docstr-coverage:inherited
+    @classmethod
+    def aliases(cls) -> List[str]:
+        return ["deep_gini", "DeepGini"]
+
+    # docstr-coverage:inherited
+    @classmethod
+    def takes_samples(cls) -> bool:
+        return False
+
+    # docstr-coverage:inherited
+    @classmethod
+    def is_confidence(cls) -> bool:
+        return False
+
+    # docstr-coverage:inherited
+    @classmethod
+    def calculate(cls, nn_outputs: np.ndarray):
+        predictions, _ = MaxSoftmax.calculate(nn_outputs)
+        gini = 1 - np.sum(nn_outputs * nn_outputs, axis=1)
+        return predictions, gini
+
+    # docstr-coverage:inherited
+    @classmethod
+    def problem_type(cls) -> ProblemType:
+        return ProblemType.CLASSIFICATION

uncertainty_wizard/quantifiers/quantifier_registry.py

@@ -1,6 +1,11 @@
 from .mean_softmax import MeanSoftmax
 from .mutual_information import MutualInformation
-from .one_shot_classifiers import MaxSoftmax, PredictionConfidenceScore, SoftmaxEntropy
+from .one_shot_classifiers import (
+    DeepGini,
+    MaxSoftmax,
+    PredictionConfidenceScore,
+    SoftmaxEntropy,
+)
 from .predictive_entropy import PredictiveEntropy
 from .quantifier import Quantifier
 from .regression_quantifiers import StandardDeviation
@@ -51,6 +56,7 @@ def find(cls, alias: str) -> Quantifier:
 QuantifierRegistry.register(MaxSoftmax())
 QuantifierRegistry.register(PredictionConfidenceScore())
 QuantifierRegistry.register(SoftmaxEntropy())
+QuantifierRegistry.register(DeepGini())
 QuantifierRegistry.register(VariationRatio())
 QuantifierRegistry.register(PredictiveEntropy())
 QuantifierRegistry.register(MutualInformation())