1st commit

app.py

@@ -0,0 +1,6 @@
+import evaluate
+from evaluate.utils import launch_gradio_widget
+
+
+module = evaluate.load("SEA-AI/mot-metrics")
+launch_gradio_widget(module)

mot-metrics.py

@@ -0,0 +1,187 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import evaluate
+import datasets
+import motmetrics as mm
+import numpy as np
+
+_CITATION = """\
+@InProceedings{huggingface:module,
+title = {A great new module},
+authors={huggingface, Inc.},
+year={2020}
+}\
+@article{milan2016mot16,
+  title={MOT16: A benchmark for multi-object tracking},
+  author={Milan, Anton and Leal-Taix{\'e}, Laura and Reid, Ian and Roth, Stefan and Schindler, Konrad},
+  journal={arXiv preprint arXiv:1603.00831},
+  year={2016}
+}
+"""
+
+_DESCRIPTION = """\
+The MOT Metrics module is designed to evaluate multi-object tracking (MOT) 
+algorithms by computing various metrics based on predicted and ground truth bounding 
+boxes. It serves as a crucial tool in assessing the performance of MOT systems, 
+aiding in the iterative improvement of tracking algorithms."""
+
+
+_KWARGS_DESCRIPTION = """
+
+Calculates how good are predictions given some references, using certain scores
+Args:
+    predictions: list of predictions to score. Each predictions
+        should be a string with tokens separated by spaces.
+    references: list of reference for each prediction. Each
+        reference should be a string with tokens separated by spaces.
+    max_iou (`float`, *optional*):
+        If specified, this is the minimum Intersection over Union (IoU) threshold to consider a detection as a true positive.
+        Default is 0.5.
+Returns:
+    summary: pandas.DataFrame with the following columns:
+        - idf1 (IDF1 Score): The F1 score for the identity assignment, computed as 2 * (IDP * IDR) / (IDP + IDR).
+        - idp (ID Precision): Identity Precision, representing the ratio of correctly assigned identities to the total number of predicted identities.
+        - idr (ID Recall): Identity Recall, representing the ratio of correctly assigned identities to the total number of ground truth identities.
+        - recall: Recall, computed as the ratio of the number of correctly tracked objects to the total number of ground truth objects.
+        - precision: Precision, computed as the ratio of the number of correctly tracked objects to the total number of predicted objects.
+        - num_unique_objects: Total number of unique objects in the ground truth.
+        - mostly_tracked: Number of objects that are mostly tracked throughout the sequence.
+        - partially_tracked: Number of objects that are partially tracked but not mostly tracked.
+        - mostly_lost: Number of objects that are mostly lost throughout the sequence.
+        - num_false_positives: Number of false positive detections (predicted objects not present in the ground truth).
+        - num_misses: Number of missed detections (ground truth objects not detected in the predictions).
+        - num_switches: Number of identity switches.
+        - num_fragmentations: Number of fragmented objects (objects that are broken into multiple tracks).
+        - mota (MOTA - Multiple Object Tracking Accuracy): Overall tracking accuracy, computed as 1 - ((num_false_positives + num_misses + num_switches) / num_unique_objects).
+        - motp (MOTP - Multiple Object Tracking Precision): Average precision of the object localization, computed as the mean of the localization errors of correctly detected objects.
+        - num_transfer: Number of track transfers.
+        - num_ascend: Number of ascended track IDs.
+        - num_migrate: Number of track ID migrations.
+
+Examples:
+    >>> import numpy as np
+    >>> module = evaluate.load("bascobasculino/mot-metrics")
+
+    >>> predicted =[
+            [1,1,10,20,30,40,0.85],
+            [1,2,50,60,70,80,0.92],
+            [1,3,80,90,100,110,0.75],
+            [2,1,15,25,35,45,0.78],
+            [2,2,55,65,75,85,0.95],
+            [3,1,20,30,40,50,0.88],
+            [3,2,60,70,80,90,0.82],
+            [4,1,25,35,45,55,0.91],
+            [4,2,65,75,85,95,0.89]
+        ]
+
+    >>> ground_truth = [
+            [1, 1, 10, 20, 30, 40],
+            [1, 2, 50, 60, 70, 80],
+            [1, 3, 85, 95, 105, 115],
+            [2, 1, 15, 25, 35, 45],
+            [2, 2, 55, 65, 75, 85],
+            [3, 1, 20, 30, 40, 50],
+            [3, 2, 60, 70, 80, 90],
+            [4, 1, 25, 35, 45, 55],
+            [5, 1, 30, 40, 50, 60],
+            [5, 2, 70, 80, 90, 100]
+        ]
+    >>> predicted = [np.array(a) for a in predicted]
+    >>> ground_truth = [np.array(a) for a in ground_truth]
+
+    >>> results = module._compute(predictions=predicted, references=ground_truth, max_iou=0.5)
+    >>> print(results)
+    {'idf1': 0.8421052631578947, 'idp': 0.8888888888888888, 'idr': 0.8, 'recall': 0.8, 'precision': 0.8888888888888888,
+    'num_unique_objects': 3,'mostly_tracked': 2, 'partially_tracked': 1, 'mostly_lost': 0, 'num_false_positives': 1, 
+    'num_misses': 2, 'num_switches': 0, 'num_fragmentations': 0, 'mota': 0.7, 'motp': 0.02981870229007634,
+    'num_transfer': 0, 'num_ascend': 0, 'num_migrate': 0}
+"""
+
+
+@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class MotMetrics(evaluate.Metric):
+    """TODO: Short description of my evaluation module."""
+
+    def _info(self):
+        # TODO: Specifies the evaluate.EvaluationModuleInfo object
+        return evaluate.MetricInfo(
+            # This is the description that will appear on the modules page.
+            module_type="metric",
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            # This defines the format of each prediction and reference
+            features=datasets.Features({
+                "predictions": datasets.Sequence(
+                                datasets.Sequence(datasets.Value("float"))
+                            ),
+                "references": datasets.Sequence(
+                                datasets.Sequence(datasets.Value("float"))
+                            )
+            }),
+            # Additional links to the codebase or references
+            codebase_urls=["http://github.com/path/to/codebase/of/new_module"],
+            reference_urls=["http://path.to.reference.url/new_module"]
+        )
+
+    def _download_and_prepare(self, dl_manager):
+        """Optional: download external resources useful to compute the scores"""
+        # TODO: Download external resources if needed
+        pass
+
+    def _compute(self, predictions, references, max_iou: float = 0.5):
+        """Returns the scores"""
+        # TODO: Compute the different scores of the module
+
+        return calculate(predictions, references, max_iou)
+
+def calculate(predictions, references, max_iou: float = 0.5):
+    """Returns the scores"""
+    try: 
+        np_predictions = np.array(predictions)
+    except:
+        raise ValueError("The predictions should be a list of np.arrays in the format [frame number, object id, bb_left, bb_top, bb_width, bb_height, confidence]")
+    
+    try:
+        np_references = np.array(references)
+    except:
+        raise ValueError("The references should be a list of np.arrays in the format [frame number, object id, bb_left, bb_top, bb_width, bb_height]")
+    
+    if np_predictions.shape[1] != 7:
+        raise ValueError("The predictions should be a list of np.arrays in the format [frame number, object id, bb_left, bb_top, bb_width, bb_height, confidence]")
+    if np_references.shape[1] != 6:
+        raise ValueError("The references should be a list of np.arrays in the format [frame number, object id, bb_left, bb_top, bb_width, bb_height]")
+
+    if np_predictions[:, 0].min() <= 0:
+        raise ValueError("The frame number in the predictions should be a positive integer")
+    if np_references[:, 0].min() <= 0:
+        raise ValueError("The frame number in the references should be a positive integer")
+
+
+    num_frames = max(np_references[:, 0].max(), np_predictions[:, 0].max())
+
+    acc = mm.MOTAccumulator(auto_id=True)
+    for i in range(1, num_frames+1):
+        preds = np_predictions[np_predictions[:, 0] == i, 1:6]
+        refs = np_references[np_references[:, 0] == i, 1:6]
+        C = mm.distances.iou_matrix(refs[:,1:], preds[:,1:], max_iou = max_iou)
+        acc.update(refs[:,0].astype('int').tolist(), preds[:,0].astype('int').tolist(), C)
+
+    mh = mm.metrics.create()
+    summary = mh.compute(acc).to_dict()
+    for key in summary:
+        summary[key] = summary[key][0]
+    
+    return summary

requirements.txt

@@ -0,0 +1,3 @@
+git+https://github.com/huggingface/evaluate@main
+numpy
+motmetrics

tests.py

@@ -0,0 +1,37 @@
+import numpy as np
+test_cases = [
+    {
+        "predictions": [np.array(a) for a in [
+                            [1,1,10,20,30,40,0.85],
+                            [1,2,50,60,70,80,0.92],
+                            [1,3,80,90,100,110,0.75],
+                            [2,1,15,25,35,45,0.78],
+                            [2,2,55,65,75,85,0.95],
+                            [3,1,20,30,40,50,0.88],
+                            [3,2,60,70,80,90,0.82],
+                            [4,1,25,35,45,55,0.91],
+                            [4,2,65,75,85,95,0.89]
+                        ]],
+        "references": [np.array(a) for a in [
+                            [1, 1, 10, 20, 30, 40],
+                            [1, 2, 50, 60, 70, 80],
+                            [1, 3, 85, 95, 105, 115],
+                            [2, 1, 15, 25, 35, 45],
+                            [2, 2, 55, 65, 75, 85],
+                            [3, 1, 20, 30, 40, 50],
+                            [3, 2, 60, 70, 80, 90],
+                            [4, 1, 25, 35, 45, 55],
+                            [5, 1, 30, 40, 50, 60],
+                            [5, 2, 70, 80, 90, 100]
+                        ]],
+        "result": {'idf1': 0.8421052631578947, 'idp': 0.8888888888888888,
+                    'idr': 0.8, 'recall': 0.8, 'precision': 0.8888888888888888,
+                    'num_unique_objects': 3,'mostly_tracked': 2,
+                    'partially_tracked': 1, 'mostly_lost': 0,
+                    'num_false_positives': 1, 'num_misses': 2,
+                    'num_switches': 0, 'num_fragmentations': 0,
+                    'mota': 0.7, 'motp': 0.02981870229007634,
+                    'num_transfer': 0, 'num_ascend': 0,
+                    'num_migrate': 0}
+    },   
+]