a  do@s\ddlZddlZddlZddlmZmZmZmZmZm Z m Z m Z ddl Z ddlZddlmZddlmZddlmZddlmZddlmZmZmZddlmZdd lmZdd lmZm Z m!Z!dd l"m#Z#m$Z$esd gZ%e!rdd l&m'Z'n dZ'gdZ%e r$ddl(m)Z*ddl+m,Z,ddl-m.Z.nd\Z,Z.dZ*gdZ%GdddeZ/e0ddddZ1dS)N)AnyCallableDictListOptionalSequenceTupleUnion)apply_to_collection)Tensor) distributed)Literal)_fix_empty_tensors_input_validator_validate_iou_type_arg)Metric)rank_zero_warn)_MATPLOTLIB_AVAILABLE_PYCOCOTOOLS_AVAILABLE_TORCHVISION_GREATER_EQUAL_0_8)_AX_TYPE_PLOT_OUT_TYPEMeanAveragePrecision.plot) box_convert)rMeanAveragePrecisionMeanAveragePrecision.tm_to_cocoMeanAveragePrecision.coco_to_tm)COCO)COCOeval)NNc seZdZUdZdZeed<dZeeed<dZ eed<dZ e ed<d Z e ed <e eed <e eed <e eed <e eed<e eed<e eed<e eed<e eed<e eed<dZeed<dFedeedeefee e ee e ee eeeededd fdd Ze eeefe eeefddd d!Zed"d#d$Zedeeefd%d&d'Zee e eeeefd(d)d*ZedGeeeede efee eeefe eeeffd+d,d-ZdHedd/d0d1Z dIeeefeeeeeefd2d3d4Z!e d"d5d6Z"dJe e#jee e#jee e#jee e#jee e#jee e#jed7d8d9Z$dKeeeeefe%eeeffee&e'd:d;d<Z(e)e#j*j+d=fd>d? Z,dLee)eedd@fdAdB Z-edMe eeee edCdDdEZ.Z/S)Nra2Compute the `Mean-Average-Precision (mAP) and Mean-Average-Recall (mAR)`_ for object detection predictions. .. math:: \text{mAP} = \frac{1}{n} \sum_{i=1}^{n} AP_i where :math:`AP_i` is the average precision for class :math:`i` and :math:`n` is the number of classes. The average precision is defined as the area under the precision-recall curve. For object detection the recall and precision are defined based on the intersection of union (IoU) between the predicted bounding boxes and the ground truth bounding boxes e.g. if two boxes have an IoU > t (with t being some threshold) they are considered a match and therefore considered a true positive. The precision is then defined as the number of true positives divided by the number of all detected boxes and the recall is defined as the number of true positives divided by the number of all ground boxes. As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~List`): A list consisting of dictionaries each containing the key-values (each dictionary corresponds to a single image). Parameters that should be provided per dict - ``boxes`` (:class:`~torch.Tensor`): float tensor of shape ``(num_boxes, 4)`` containing ``num_boxes`` detection boxes of the format specified in the constructor. By default, this method expects ``(xmin, ymin, xmax, ymax)`` in absolute image coordinates, but can be changed using the ``box_format`` parameter. Only required when `iou_type="bbox"`. - ``scores`` (:class:`~torch.Tensor`): float tensor of shape ``(num_boxes)`` containing detection scores for the boxes. - ``labels`` (:class:`~torch.Tensor`): integer tensor of shape ``(num_boxes)`` containing 0-indexed detection classes for the boxes. - ``masks`` (:class:`~torch.Tensor`): boolean tensor of shape ``(num_boxes, image_height, image_width)`` containing boolean masks. Only required when `iou_type="segm"`. - ``target`` (:class:`~List`): A list consisting of dictionaries each containing the key-values (each dictionary corresponds to a single image). Parameters that should be provided per dict: - ``boxes`` (:class:`~torch.Tensor`): float tensor of shape ``(num_boxes, 4)`` containing ``num_boxes`` ground truth boxes of the format specified in the constructor. only required when `iou_type="bbox"`. By default, this method expects ``(xmin, ymin, xmax, ymax)`` in absolute image coordinates. - ``labels`` (:class:`~torch.Tensor`): integer tensor of shape ``(num_boxes)`` containing 0-indexed ground truth classes for the boxes. - ``masks`` (:class:`~torch.Tensor`): boolean tensor of shape ``(num_boxes, image_height, image_width)`` containing boolean masks. Only required when `iou_type="segm"`. - ``iscrowd`` (:class:`~torch.Tensor`): integer tensor of shape ``(num_boxes)`` containing 0/1 values indicating whether the bounding box/masks indicate a crowd of objects. Value is optional, and if not provided it will automatically be set to 0. - ``area`` (:class:`~torch.Tensor`): float tensor of shape ``(num_boxes)`` containing the area of the object. Value is optional, and if not provided will be automatically calculated based on the bounding box/masks provided. Only affects which samples contribute to the `map_small`, `map_medium`, `map_large` values As output of ``forward`` and ``compute`` the metric returns the following output: - ``map_dict``: A dictionary containing the following key-values: - map: (:class:`~torch.Tensor`), global mean average precision - map_small: (:class:`~torch.Tensor`), mean average precision for small objects - map_medium:(:class:`~torch.Tensor`), mean average precision for medium objects - map_large: (:class:`~torch.Tensor`), mean average precision for large objects - mar_1: (:class:`~torch.Tensor`), mean average recall for 1 detection per image - mar_10: (:class:`~torch.Tensor`), mean average recall for 10 detections per image - mar_100: (:class:`~torch.Tensor`), mean average recall for 100 detections per image - mar_small: (:class:`~torch.Tensor`), mean average recall for small objects - mar_medium: (:class:`~torch.Tensor`), mean average recall for medium objects - mar_large: (:class:`~torch.Tensor`), mean average recall for large objects - map_50: (:class:`~torch.Tensor`) (-1 if 0.5 not in the list of iou thresholds), mean average precision at IoU=0.50 - map_75: (:class:`~torch.Tensor`) (-1 if 0.75 not in the list of iou thresholds), mean average precision at IoU=0.75 - map_per_class: (:class:`~torch.Tensor`) (-1 if class metrics are disabled), mean average precision per observed class - mar_100_per_class: (:class:`~torch.Tensor`) (-1 if class metrics are disabled), mean average recall for 100 detections per image per observed class - classes (:class:`~torch.Tensor`), list of all observed classes For an example on how to use this metric check the `torchmetrics mAP example`_. .. note:: ``map`` score is calculated with @[ IoU=self.iou_thresholds | area=all | max_dets=max_detection_thresholds ]. Caution: If the initialization parameters are changed, dictionary keys for mAR can change as well. .. note:: This metric utilizes the official `pycocotools` implementation as its backend. This means that the metric requires you to have `pycocotools` installed. In addition we require `torchvision` version 0.8.0 or newer. Please install with ``pip install torchmetrics[detection]``. Args: box_format: Input format of given boxes. Supported formats are: - 'xyxy': boxes are represented via corners, x1, y1 being top left and x2, y2 being bottom right. - 'xywh' : boxes are represented via corner, width and height, x1, y2 being top left, w, h being width and height. This is the default format used by pycoco and all input formats will be converted to this. - 'cxcywh': boxes are represented via centre, width and height, cx, cy being center of box, w, h being width and height. iou_type: Type of input (either masks or bounding-boxes) used for computing IOU. Supported IOU types are ``"bbox"`` or ``"segm"`` or both as a tuple. iou_thresholds: IoU thresholds for evaluation. If set to ``None`` it corresponds to the stepped range ``[0.5,...,0.95]`` with step ``0.05``. Else provide a list of floats. rec_thresholds: Recall thresholds for evaluation. If set to ``None`` it corresponds to the stepped range ``[0,...,1]`` with step ``0.01``. Else provide a list of floats. max_detection_thresholds: Thresholds on max detections per image. If set to `None` will use thresholds ``[1, 10, 100]``. Else, please provide a list of ints. class_metrics: Option to enable per-class metrics for mAP and mAR_100. Has a performance impact that scales linearly with the number of classes in the dataset. extended_summary: Option to enable extended summary with additional metrics including IOU, precision and recall. The output dictionary will contain the following extra key-values: - ``ious``: a dictionary containing the IoU values for every image/class combination e.g. ``ious[(0,0)]`` would contain the IoU for image 0 and class 0. Each value is a tensor with shape ``(n,m)`` where ``n`` is the number of detections and ``m`` is the number of ground truth boxes for that image/class combination. - ``precision``: a tensor of shape ``(TxRxKxAxM)`` containing the precision values. Here ``T`` is the number of IoU thresholds, ``R`` is the number of recall thresholds, ``K`` is the number of classes, ``A`` is the number of areas and ``M`` is the number of max detections per image. - ``recall``: a tensor of shape ``(TxKxAxM)`` containing the recall values. Here ``T`` is the number of IoU thresholds, ``K`` is the number of classes, ``A`` is the number of areas and ``M`` is the number of max detections per image. average: Method for averaging scores over labels. Choose between "``macro``"" and "``micro``". Default is "macro" kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ModuleNotFoundError: If ``pycocotools`` is not installed ModuleNotFoundError: If ``torchvision`` is not installed or version installed is lower than 0.8.0 ValueError: If ``box_format`` is not one of ``"xyxy"``, ``"xywh"`` or ``"cxcywh"`` ValueError: If ``iou_type`` is not one of ``"bbox"`` or ``"segm"`` ValueError: If ``iou_thresholds`` is not None or a list of floats ValueError: If ``rec_thresholds`` is not None or a list of floats ValueError: If ``max_detection_thresholds`` is not None or a list of ints ValueError: If ``class_metrics`` is not a boolean Example:: Basic example for when `iou_type="bbox"`. In this case the ``boxes`` key is required in the input dictionaries, in addition to the ``scores`` and ``labels`` keys. >>> from torch import tensor >>> from torchmetrics.detection import MeanAveragePrecision >>> preds = [ ... dict( ... boxes=tensor([[258.0, 41.0, 606.0, 285.0]]), ... scores=tensor([0.536]), ... labels=tensor([0]), ... ) ... ] >>> target = [ ... dict( ... boxes=tensor([[214.0, 41.0, 562.0, 285.0]]), ... labels=tensor([0]), ... ) ... ] >>> metric = MeanAveragePrecision(iou_type="bbox") >>> metric.update(preds, target) >>> from pprint import pprint >>> pprint(metric.compute()) {'classes': tensor(0, dtype=torch.int32), 'map': tensor(0.6000), 'map_50': tensor(1.), 'map_75': tensor(1.), 'map_large': tensor(0.6000), 'map_medium': tensor(-1.), 'map_per_class': tensor(-1.), 'map_small': tensor(-1.), 'mar_1': tensor(0.6000), 'mar_10': tensor(0.6000), 'mar_100': tensor(0.6000), 'mar_100_per_class': tensor(-1.), 'mar_large': tensor(0.6000), 'mar_medium': tensor(-1.), 'mar_small': tensor(-1.)} Example:: Basic example for when `iou_type="segm"`. In this case the ``masks`` key is required in the input dictionaries, in addition to the ``scores`` and ``labels`` keys. >>> from torch import tensor >>> from torchmetrics.detection import MeanAveragePrecision >>> mask_pred = [ ... [0, 0, 0, 0, 0], ... [0, 0, 1, 1, 0], ... [0, 0, 1, 1, 0], ... [0, 0, 0, 0, 0], ... [0, 0, 0, 0, 0], ... ] >>> mask_tgt = [ ... [0, 0, 0, 0, 0], ... [0, 0, 1, 0, 0], ... [0, 0, 1, 1, 0], ... [0, 0, 1, 0, 0], ... [0, 0, 0, 0, 0], ... ] >>> preds = [ ... dict( ... masks=tensor([mask_pred], dtype=torch.bool), ... scores=tensor([0.536]), ... labels=tensor([0]), ... ) ... ] >>> target = [ ... dict( ... masks=tensor([mask_tgt], dtype=torch.bool), ... labels=tensor([0]), ... ) ... ] >>> metric = MeanAveragePrecision(iou_type="segm") >>> metric.update(preds, target) >>> from pprint import pprint >>> pprint(metric.compute()) {'classes': tensor(0, dtype=torch.int32), 'map': tensor(0.2000), 'map_50': tensor(1.), 'map_75': tensor(0.), 'map_large': tensor(-1.), 'map_medium': tensor(-1.), 'map_per_class': tensor(-1.), 'map_small': tensor(0.2000), 'mar_1': tensor(0.2000), 'mar_10': tensor(0.2000), 'mar_100': tensor(0.2000), 'mar_100_per_class': tensor(-1.), 'mar_large': tensor(-1.), 'mar_medium': tensor(-1.), 'mar_small': tensor(0.2000)} Fis_differentiableThigher_is_betterfull_state_updateplot_lower_bound?plot_upper_bound detection_boxdetection_maskdetection_scoresdetection_labelsgroundtruth_boxgroundtruth_maskgroundtruth_labelsgroundtruth_crowdsgroundtruth_areawarn_on_many_detectionsxyxybboxNmacror0xywhZcxcywh)r1segmr2micro) box_formatiou_typeiou_thresholdsrec_thresholdsmax_detection_thresholds class_metricsextended_summaryaveragekwargsreturnc  stjfi| tstdts*tdd} || vrJtd| d|||_t||_|durzt |t sztd||pt ddt d d |_|durt |t std ||pt d d t dd |_|durt |t std|t t j|pgdt jd\} } | |_t |ts=0.8` or `pip install torchmetrics[detection]`.r3z,Expected argument `box_format` to be one of z but got zSExpected argument `iou_thresholds` to either be `None` or a list of floats but got g?gffffff?g!@zSExpected argument `rec_thresholds` to either be `None` or a list of floats but got r"r$gY@z[Expected argument `max_detection_thresholds` to either be `None` or a list of ints but got )rB dZdtypez1Expected argument `class_metrics` to be a booleanz4Expected argument `extended_summary` to be a booleanr6zDExpected argument `average` to be one of ('macro', 'micro') but got r&)defaultZdist_reduce_fxr'r(r)r*r+r,r-r.)super__init__rModuleNotFoundErrorr ValueErrorr8rr9 isinstancelisttorchZlinspaceroundtolistr:r;sorttensorintr<boolr=r>r?Z add_state) selfr8r9r:r;r<r=r>r?r@Zallowed_box_formatsZ max_det_thr_ __class__g/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/detection/mean_ap.pyrHFsd    $    zMeanAveragePrecision.__init__)predstargetrAc Cst|||jd|D]`}|j||jd\}}|dur@|j||durT|j||j|d|j|dq|D]}||\}}|dur|j ||dur|j ||j |d|j | dt|d|j| dt|dqzdS)aPUpdate metric state. Raises: ValueError: If ``preds`` is not of type (:class:`~List[Dict[str, Tensor]]`) ValueError: If ``target`` is not of type ``List[Dict[str, Tensor]]`` ValueError: If ``preds`` and ``target`` are not of the same length ValueError: If any of ``preds.boxes``, ``preds.scores`` and ``preds.labels`` are not of the same length ValueError: If any of ``target.boxes`` and ``target.labels`` are not of the same length ValueError: If any box is not type float and of length 4 ValueError: If any class is not type int and of length 1 ValueError: If any score is not type float and of length 1 )r9)warnNlabelsscoresiscrowdarea)rr9_get_safe_item_valuesr/r&appendr'r)r(r*r+r,r-getrM zeros_liker.)rTrZr[itemZbbox_detectionZmask_detectionZbbox_groundtruthZmask_groundtruthrXrXrYupdates$    zMeanAveragePrecision.update)rAc Cs |j|jd\}}i}tt|jD]}t|jdkrFdn|d}t|jdkr|jdD]}|d||d<qht |||d}t j |j t j d |j_t j |jt j d |j_|j|j_||||j}||j||d i} |jrL|d t|jt jd d |dt|j d|dt|j di} || |j!r||jdkr|jdd\}}t |||d}t j |j t j d |j_t j |jt j d |j_|j|j_g} g} |"D]} | g|j_#tt.||||j} Wdn1s 0Y| $t| dg| $t| dgqtj| tj%d }tj| tj%d }n$tjdgtj%d }tjdgtj%d }t|jdkrdn|d}||d||d|iq.Wdn1s0Y|dtj|"tj&d i|S)zComputes the metric.)r?rBrU annotationsZarea_r`)ZiouTyperE)prefixiouscSstj|tjdS)NrErMrQfloat32xrXrXrYz.MeanAveragePrecision.compute..Z precisionZrecallr7r2NrZ map_per_classZmar_100_per_classclasses)'_get_coco_datasetsr? contextlibredirect_stdoutioStringIOr9lendatasetrnparrayr:float64paramsZiouThrsr;ZrecThrsr<ZmaxDetsevaluate accumulateZ summarizestatsrf_coco_stats_to_tensor_dictr>r rjZndarrayrMrQevalr= _get_classesZcatIdsrbrlint32)rT coco_preds coco_targetZ result_dictZi_typeriannoZ coco_evalrsummaryZmap_per_class_listZmar_100_per_class_listZclass_idZ class_statsZmap_per_class_valuesZmar_100_per_class_valuesrXrXrYcomputesp        &  &zMeanAveragePrecision.compute)r?rAcCs|dkr.t|jtdd}t|jtdd}n |j}|j}tt}}|j|t|jdkrb|jndt|jdkrx|jnd|j |j d|_ |j|t|j dkr|j ndt|j dkr|j nd|jd|_ tt ||Wdn1s0Y||fS) z=Returns the coco datasets for the target and the predictions.r7cSs t|SNrMrdrmrXrXrYro rpz9MeanAveragePrecision._get_coco_datasets..cSs t|SrrrmrXrXrYro rprNr]boxesmaskscrowdsr`)r]rrr^)r r,r r)r_get_coco_formatryr*r+r-r.rzr&r'r(rurvrwrxZ createIndex)rTr?r,r)rrrXrXrYrts.&z'MeanAveragePrecision._get_coco_datasets)rrirAcCsT|dtj|dgtjd|dtj|dgtjd|dtj|dgtjd|dtj|d gtjd|d tj|d gtjd|d tj|d gtjd|dtj|dgtjd|dtj|dgtjd|dtj|dgtjd|dtj|dgtjd|dtj|dgtjd|dtj|dgtjdi S)z;Converts the output of COCOeval.stats to a dict of tensors.maprrEZmap_50rBZmap_75Z map_smallZ map_mediumZ map_largeZmar_1Zmar_10Zmar_100rqZ mar_small Z mar_mediumrCZ mar_large rk)rrirXrXrYr'sz/MeanAveragePrecision._coco_stats_to_tensor_dict)rrr9rAcCst|}tt"t|}||}Wdn1s>0Y|jd}|jd}i}|D]}|d|vrgggd||d<d|vrg||dd<d|vrg||dd<d|vr||dd|dd|vr||dd| |||dd |d ||dd |d ||dd |d qdi} |D]} | d| vrggd | | d<d|vrg| | dd<d|vrg| | dd<d|vr| | dd| dd|vr| | dd| | | | dd| d| | dd | d qV|D]J} | | vr4ggd | | <d|vrfg| | d<d|vr4g| | d<q4gg} } |D]>}t j | |dt j dt j | |d t j dd }d|vrt j t| |dt j d|d<d|vrt j t| |dt jd|d<| |t j ||d t j dt j ||d t j dt j ||d t j dd}d|vrt j ||dt j d|d<d|vrt j t||dt jd|d<| |q| | fS)amUtility function for converting .json coco format files to the input format of this metric. The function accepts a file for the predictions and a file for the target in coco format and converts them to a list of dictionaries containing the boxes, labels and scores in the input format of this metric. Args: coco_preds: Path to the json file containing the predictions in coco format coco_target: Path to the json file containing the targets in coco format iou_type: Type of input, either `bbox` for bounding boxes or `segm` for segmentation masks Returns: A tuple containing the predictions and targets in the input format of this metric. Each element of the tuple is a list of dictionaries containing the boxes, labels and scores. Example: >>> # File formats are defined at https://cocodataset.org/#format-data >>> # Example files can be found at >>> # https://github.com/cocodataset/cocoapi/tree/master/results >>> from torchmetrics.detection import MeanAveragePrecision >>> preds, target = MeanAveragePrecision.coco_to_tm( ... "instances_val2014_fakebbox100_results.json.json", ... "val2014_fake_eval_res.txt.json" ... iou_type="bbox" ... ) # doctest: +SKIP Nrhimage_id)r]r_r`r1rr5rr] category_idr_r`)r^r]r^scorerE)rrurvrwrxrZloadResrzrbZ annToMaskrMrQrlrr{r|Zuint8)rrr9gtdtZ gt_datasetZ dt_datasetr[trZpkZ batched_predsZbatched_targetkeyZbpZbtrXrXrY coco_to_tm9s (              " "   "r tm_map_input)namerAcCs|j|j|j|j|j|jd}|j|j|j|jd}t j |ddd}t j |dd}t |dd}| |Wdn1s0Yt |d d}| |Wdn1s0YdS) aUtility function for converting the input for this metric to coco format and saving it to a json file. This function should be used after calling `.update(...)` or `.forward(...)` on all data that should be written to the file, as the input is then internally cached. The function then converts to information to coco format a writes it to json files. Args: name: Name of the output file, which will be appended with "_preds.json" and "_target.json" Example: >>> from torch import tensor >>> from torchmetrics.detection import MeanAveragePrecision >>> preds = [ ... dict( ... boxes=tensor([[258.0, 41.0, 606.0, 285.0]]), ... scores=tensor([0.536]), ... labels=tensor([0]), ... ) ... ] >>> target = [ ... dict( ... boxes=tensor([[214.0, 41.0, 562.0, 285.0]]), ... labels=tensor([0]), ... ) ... ] >>> metric = MeanAveragePrecision() >>> metric.update(preds, target) >>> metric.tm_to_coco("tm_map_input") # doctest: +SKIP r)r]rrrhr)indentz _preds.jsonwNz _target.json) rr,r*r+r-r.r)r&r'jsondumpsopenwrite)rTrZtarget_datasetZ preds_datasetZ preds_jsonZ target_jsonfrXrXrY tm_to_cocos  (r)rer\rAcCsddg}d|jvrBt|d}|dkr:t||jdd}||d<d|jvrg}|dD].}tt |}| t |d |d fq`t ||d <|ddurt |d|jd ks|d durt |d |jd krt|jd |S) aVConvert and return the boxes or masks from the item depending on the iou_type. Args: item: input dictionary containing the boxes or masks warn: whether to warn if the number of boxes or masks exceeds the max_detection_thresholds Returns: boxes or masks depending on the iou_type Nr1rrr4)Zin_fmtZout_fmtr5rsizecountsrBrr)r9rZnumelrr8cpunumpy mask_utilsencoder{Zasfortranarrayrbtupleryr<_warning_on_too_many_detections)rTrer\outputrriZrlerXrXrYras&      " z*MeanAveragePrecision._get_safe_item_valuescCs>t|jdkst|jdkr:t|j|jSgS)zIReturn a list of unique classes found in ground truth and detection data.r)ryr)r,rMcatuniquerrO)rTrXrXrYrsz!MeanAveragePrecision._get_classes)r]rrr^rr`rAc Csg}g}d} t|D]\} } |dur:|| } | } |dur`|| } t| dkr`|dur`q| } |d| id|jvrt| dkr| ddd| ddd|dd<|dd<t| D]\}}|dur| |}|durt| dkr| |}|d|dd }d |jvrPt|d krPtd | d |dt|dt|tkr~td| d |dt|dd}d}|dur|| |dkr|| |}nPd|jvrt |n|d|d}t|jdkr|d|d}t |}| | |||dur6|| |ndd}|durX||d<||d<|durj||d <|dur|||d<|dur|| |}t|t krtd| d |dt|d||d<||| d7} qqdd| D}|||dS)zTransforms and returns all cached targets or predictions in COCO format. Format is defined at https://cocodataset.org/#format-data rBNridr5rrheightwidth)rrr1rzInvalid input box of sample z , element z (expected 4 values, got )zInvalid input class of sample z+ (expected value of type integer, got type rr)rrr`rr_Z area_bboxZ area_segmZ segmentationzInvalid input score of sample z) (expected value of type float, got type rcSsg|]}|t|dqS))rr)str).0rrXrXrY Vrpz9MeanAveragePrecision._get_coco_format..)imagesrh categories) enumeraterrOryrbr9rJtyperRrr`floatr)rTr]rrr^rr`rrhZ annotation_idrZ image_labelsZ image_boxesZ image_masksrZ image_labelZ image_boxZ image_maskZ area_stat_boxZarea_stat_maskZ area_stat annotationrrsrXrXrYrs  2$&        z%MeanAveragePrecision._get_coco_format)valaxrAcCs |||S)aPlot a single or multiple values from the metric. Args: val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results. If no value is provided, will automatically call `metric.compute` and plot that result. ax: An matplotlib axis object. If provided will add plot to that axis Returns: Figure object and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> from torch import tensor >>> from torchmetrics.detection.mean_ap import MeanAveragePrecision >>> preds = [dict( ... boxes=tensor([[258.0, 41.0, 606.0, 285.0]]), ... scores=tensor([0.536]), ... labels=tensor([0]), ... )] >>> target = [dict( ... boxes=tensor([[214.0, 41.0, 562.0, 285.0]]), ... labels=tensor([0]), ... )] >>> metric = MeanAveragePrecision() >>> metric.update(preds, target) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> import torch >>> from torchmetrics.detection.mean_ap import MeanAveragePrecision >>> preds = lambda: [dict( ... boxes=torch.tensor([[258.0, 41.0, 606.0, 285.0]]) + torch.randint(10, (1,4)), ... scores=torch.tensor([0.536]) + 0.1*torch.rand(1), ... labels=torch.tensor([0]), ... )] >>> target = [dict( ... boxes=torch.tensor([[214.0, 41.0, 562.0, 285.0]]), ... labels=torch.tensor([0]), ... )] >>> metric = MeanAveragePrecision() >>> vals = [] >>> for _ in range(20): ... vals.append(metric(preds(), target)) >>> fig_, ax_ = metric.plot(vals) )Z_plot)rTrrrXrXrYplotYs9r)fnrAcstj|ddS)zCustom apply function. Excludes the detections and groundtruths from the casting when the iou_type is set to `segm` as the state is no longer a tensor but a tuple. )r'r+)Z exclude_state)rG_apply)rTrrVrXrYrszMeanAveragePrecision._apply) dist_sync_fn process_grouprAcs>tj||dd|jvr:||j||_||j||_dS)zCustom sync function. For the iou_type `segm` the detections and groundtruths are no longer tensors but tuples. Therefore, we need to gather the list of tuples and then convert it back to a list of tuples. )rrr5N)rG _sync_distr9_gather_tuple_listr'r+)rTrrrVrXrYrs zMeanAveragePrecision._sync_dist)list_to_gatherrrAcsZtj|dtj|dddtDtj||dfddttdDS)a*Gather a list of tuples over multiple devices. Args: list_to_gather: input list of tuples that should be gathered across devices process_group: process group to gather the list of tuples Returns: list of tuples gathered across devices )groupcSsg|]}dqSrrX)rrUrXrXrYrrpz;MeanAveragePrecision._gather_tuple_list..cs&g|]}tD]}||qqSrX)range)ridxZrankZ list_gatheredZ world_sizerXrYrrpr)distZget_world_sizeZbarrierrZall_gather_objectry)rrrXrrYrs  z'MeanAveragePrecision._gather_tuple_list)r0r1NNNFFr2)r1)r)F)NNNNN)NN)NN)N)0__name__ __module__ __qualname____doc__rrS__annotations__r rr!r#rr%rr r/r r rrrRrrHrrfdictrrrt staticmethodrrrrarrMrrrrrrnnModulerrr __classcell__rXrXrVrYrCs q                 J*+L  "l4         \( ? r)limitrAcCstd|dtdS)NzEncountered more than aY detections in a single image. This means that certain detections with the lowest scores will be ignored, that may have an undesirable impact on performance. Please consider adjusting the `max_detection_threshold` to suit your use case. To disable this warning, set attribute class `warn_on_many_detections=False`, after initializing the metric.)r UserWarning)rrXrXrYrs r)2rurwrtypingrrrrrrrr rr{rMZlightning_utilitiesr r r rZtyping_extensionsr Ztorchmetrics.detection.helpersrrrZtorchmetrics.metricrZtorchmetrics.utilitiesrZtorchmetrics.utilities.importsrrrZtorchmetrics.utilities.plotrrZ__doctest_skip__Ztorchvision.opsrZpycocotools.maskmaskrZpycocotools.cocorZpycocotools.cocoevalrrrRrrXrXrXrYsH(