# 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))