mot-metrics.py

# 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"""
    print("predictions", predictions)
    print("references", references)
    
    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

def parse_standard_payload(payload: dict):
    gt_field_name = payload['gt_field_name']
    models = payload['models']
    sequence_list = payload['sequence_list']

    for sequence in sequence_list:
        for model in models:
            frames = payload['sequences'][sequence][model]
            formated_predictions = []
            for frame_id, frame in enumerate(frames):
                for detection in frame:
                    id = detection['index']
                    x, y, w, h = detection['bounding_box']
                    confidence = detection['confidence']
                    confidence = 1  #TODO: remove this line
                    formated_predictions.append([frame_id, id, x, y, w, h, confidence])

        frames = payload['sequences'][sequence][gt_field_name]
        formatted_references = []
        for frame_id, frame in enumerate(frames):
            for detection in frame:
                id = detection['index']
                x, y, w, h = detection['bounding_box']
                formatted_references.append([frame_id, id, x, y, w, h])    

    print(calculate(formated_predictions, formatted_references, max_iou=0.5))