§
    ­¸jN= ã                  óœ  — d Z ddlmZ ddlZddlZddlZddlZddlZddlm	Z	m
Z
 ddlmZmZ ddlZddlZddlmZ ddlmc mZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lm Z  ddl!m"Z" ddl#m$Z$m%Z%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7 ddl8m9Z9  e9¦   «         Z:d!d„Z;d"d„Z<d#d„Z=d$d„Z> G d„ d e¦  «        Z?dS )%u>   COCOEvalCallback â€” torchmetrics-based mAP and F1 evaluation.é    )ÚannotationsN)ÚCallableÚMapping)ÚAnyÚcast)ÚCallback)ÚTensor)ÚDistributedSampler)ÚCocoEvalBackend)Úget_coco_api_from_dataset)Úsweep_confidence_thresholds)ÚDEFAULT_KEYPOINT_MAX_DETSÚMetricKeypointOKSÚOKSKey)Úbuild_matching_dataÚdistributed_merge_matching_dataÚinit_matching_accumulatorÚmerge_matching_data)ÚOnePassCocoMeanAveragePrecision)Úbox_cxcywh_to_xyxy)Ú_IS_RICH_AVAILABLEÚ_get_rich_consoleÚ_has_progress_barÚ_render_overall_mergedÚ_render_summary_tables)Úis_dist_avail_and_initialized)Ú
get_loggerÚwarning_emittedÚboolÚreturnc                óB   — | rdS t                                d¦  «         dS )zýWarn once when metric table rendering is skipped because Rich is unavailable.

    Args:
        warning_emitted: Whether this warning has already been emitted.

    Returns:
        Always ``True``; caller assigns back to suppress future warnings.
    TzXRich is not installed; skipping metric table rendering. Install `rich` to enable tables.)ÚloggerÚwarning)r   s    ús/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/rfdetr/training/callbacks/coco_eval.pyÚ_warn_missing_rich_oncer%   7   s)   € ð ð ØˆtÝ
‡N‚NÐmÑnÔnÐnØˆ4ó    Úema_cbr   c                óV   — | €dS t          | dd¦  «        }|€dS t          |d|¦  «        S )ur  Return the inner ``nn.Module`` wrapped by an EMA callback.

    ``RFDETREMACallback._average_model`` is a private attribute holding a ``torch.optim.swa_utils.AveragedModel``
    (which exposes the actual module on ``.module``).  This helper centralises the access so that consumers degrade
    gracefully when the EMA model has not yet been initialised â€” preferable to reaching through two layers of
    private attributes at every call site.

    Args:
        ema_cb: EMA callback instance (or ``None``).

    Returns:
        The inner module wrapped by ``AveragedModel``, or ``None`` when no EMA model is available.
    NÚ_average_modelÚmodule)Úgetattr)r'   Úaverageds     r$   Ú_get_ema_inner_moduler-   F   s=   € ð €~ØˆtÝ�vÐ/°Ñ6Ô6€HØÐØˆtÝ�8˜X xÑ0Ô0Ð0r&   c                 ó  — t          j        t          ¦  «        5  t          j        d¦  «        } t          t          g t          f         t          | d¦  «        ¦  «        } |¦   «         ducddd¦  «         S # 1 swxY w Y   dS )z4Return whether an active IPython shell is available.ÚIPythonÚget_ipythonNF)	Ú
contextlibÚsuppressÚImportErrorÚ	importlibÚimport_moduler   r   r   r+   )Úipythonr0   s     r$   Ú_is_running_in_notebookr7   \   s´   € å	Ô	�[Ñ	)Ô	)ð )ð )ÝÔ)¨)Ñ4Ô4ˆÝ�8 B­ GÔ,­g°g¸}Ñ.MÔ.MÑNÔNˆØˆ{‰}Œ} DÐ(ð)ð )ð )ð )ñ )ô )ð )ð )ð )ð )ð )ð )øøøð )ð )ð )ð )ð ˆ5s   šAA7Á7A;Á>A;Úeval_base_modelúbool | NoneÚeval_ema_onlyc                ó2   — | �t          | ¦  «        S |�| S dS )a   Resolve current and deprecated evaluation flags.

    Examples:
        >>> _resolve_eval_base_model(True, None)
        True
        >>> _resolve_eval_base_model(None, True)
        False
        >>> _resolve_eval_base_model(None, None)
        False
    NF)r   )r8   r:   s     r$   Ú_resolve_eval_base_modelr<   e   s,   € ð Ð"Ý�OÑ$Ô$Ð$ØÐ Ø Ð Ð Øˆ5r&   c            	      óŽ  ‡ — e Zd ZdZeddddddddf	dlˆ fd„Zdmd„Zdmd„Zdnd„Zdnd „Z	dnd!„Z
dod"„Zdnd#„Zdnd$„Zdpd(„Zdnd)„Zdqd*„Z	 drdsd.„Zdnd/„Z	 drdsd0„Zdnd1„Zdtd3„Zdud6„Zedvd7„¦   «         Zdwd<„Zdxd=„ZdydA„ZdzdC„ZddDœd{dF„Zd|dG„Zd}dH„Zd~dJ„Z dodK„Z!ddL„Z"d€dN„Z#d|dO„Z$d�dQ„Z%ddRdSœd‚dW„Z&dƒd]„Z'	 d„d…db„Z(d†de„Z)d‡dh„Z*	 dˆd‰dk„Z+ˆ xZ,S )ŠÚCOCOEvalCallbackaO
  Validation callback that computes mAP (via torchmetrics) and macro-F1.

    Accumulates predictions and targets across validation batches, then at epoch end computes:

    - ``val/mAP_50_95``, ``val/mAP_50``, ``val/mAP_75``, ``val/mAR`` using
      ``torchmetrics.detection.MeanAveragePrecision``.
    - Per-class ``val/AP/<name>`` when class names are available.
    - ``val/F1``, ``val/precision``, ``val/recall`` from a confidence-threshold
      sweep over compact per-class matching data (DDP-safe).

    For segmentation models (``segmentation=True``) additional metrics ``val/segm_mAP_50_95`` and ``val/segm_mAP_50``
    are logged.

    Args:
        max_dets: Maximum detections per image passed to
            ``MeanAveragePrecision``. Defaults to :data:`~rfdetr.evaluation.keypoint_oks.DEFAULT_KEYPOINT_MAX_DETS`.
        segmentation: When ``True``, evaluate both bbox and segm IoU. Defaults to ``False``.
        eval_interval: Run validation metrics every N epochs. Test metrics are
            always computed when ``trainer.test()`` is called.
        log_per_class_metrics: When ``False``, skip per-class AP computation
            (``MeanAveragePrecision(class_metrics=False)``) as well as the per-class logging/table.
        eval_ema_only: Deprecated compatibility flag from the pre-1.10 callback API. When explicitly supplied,
            ``True`` selects EMA-only evaluation and ``False`` selects base-plus-EMA evaluation, preserving the old
            keyword and positional behavior. Omit it for the new default.
        eval_base_model: When ``False`` (default), ``validation_step`` already forwarded through
            the EMA model directly (see ``TrainConfig.eval_base_model``), so the independent
            duplicate EMA forward pass this callback would otherwise run every validation batch
            is skipped and its predictions are routed to the EMA track. When ``True``,
            ``validation_step`` forwards the base model and this callback runs the second, EMA
            forward pass, so both models are evaluated from independent predictions.
        eval_backend: COCO evaluation backend, mirroring :attr:`~rfdetr.config.TrainConfig.eval_backend`.
            ``"vernier"`` is the default and computes fastest, ``"faster_coco_eval"`` is the previous
            evaluator and ``"ufcoco"`` selects ultrafast-pycocotools; all four ship with ``rfdetr[train]`` and return
            identical metrics.
            Appended after the existing parameters rather than grouped with the other evaluation knobs, so that
            positional callers keep binding the arguments they always did.
    Fé   TNÚvernierÚmax_detsÚintÚsegmentationr   Úeval_intervalÚlog_per_class_metricsÚkeypoint_oks_sigmasúlist[float] | NoneÚin_notebookr9   r:   r8   Úeval_backendr   r    ÚNonec
                óž  •— t          ¦   «                              ¦   «          || _        || _        t	          dt          |¦  «        ¦  «        | _        t          |¦  «        | _        |	| _	        |�t          j        dt          d¬¦  «         |�|�t          d¦  «        ‚t          ||¦  «        | _        g | _        i | _        t%          ¦   «         | _        t%          ¦   «         | _        d| _        d| _        d | _        d| _        || _        d| _        i | _        || _        i | _        i | _        |  |€t?          ¦   «         | _         d S || _         d S )Nr?   zdCOCOEvalCallback.eval_ema_only is deprecated; use eval_base_model to opt into base-model evaluation.é   )Ú
stacklevelz9eval_ema_only and eval_base_model cannot both be suppliedF)!ÚsuperÚ__init__Ú	_max_detsÚ_segmentationÚmaxrB   Ú_eval_intervalr   Ú_log_per_class_metricsÚ_eval_backendÚwarningsÚwarnÚFutureWarningÚ
ValueErrorr<   Ú_eval_base_modelÚ_class_namesÚ_cat_id_to_namer   Ú	_f1_localÚ_f1_train_localÚ_ema_has_updatesÚ_missing_rich_warning_emittedÚ_output_widgetÚ_keypoint_modeÚ_use_segm_metricsÚ_train_segm_skip_warnedÚ_keypoint_oks_metricsÚ_keypoint_oks_sigmasÚ_eval_paddingÚ_eval_samples_seenr7   Ú_in_notebook)ÚselfrA   rC   rD   rE   rF   rH   r:   r8   rI   Ú	__class__s             €r$   rO   zCOCOEvalCallback.__init__ž   sa  ø€ õ 	‰Œ×ÒÑÔÐØ!ˆŒØ)ˆÔÝ! !¥S¨Ñ%7Ô%7Ñ8Ô8ˆÔÝ&*Ð+@Ñ&AÔ&AˆÔ#Ø)ˆÔØÐ$ÝŒMØvÝØðñ ô ð ð
 Ð$¨Ð)DÝÐXÑYÔYÐYÝ 8¸È-Ñ XÔ XˆÔØ')ˆÔØ/1ˆÔÝ4MÑ4OÔ4OˆŒÝ:SÑ:UÔ:UˆÔð ',ˆÔØ38ˆÔ*Ø#'ˆÔØ$)ˆÔØ'3ˆÔØ-2ˆÔ$ØCEˆÔ"Ø$7ˆÔ!ð ?AˆÔØ24ˆÔØÐØÐÝ 7Ñ 9Ô 9ˆDÔÐÐà +ˆDÔÐÐr&   Útrainerr   Ú	pl_moduleÚstageÚstrc                óR  — t          |dd¦  «        }|�t          |dd¦  «        nd}|du | _        | j        o| j         | _        | j        rddgnd}t	          | j        dd	| j        gd¬
¦  «        }| j        |d<   t          dd|i|¤Ž| _	        t          dd|i|¤Ž| _
        d| _        dS )zúInstantiate ``MeanAveragePrecision`` after DDP device placement.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            stage: One of ``"fit"``, ``"validate"``, ``"test"``, ``"predict"``.
        Úmodel_configNÚuse_grouppose_keypointsFTÚbboxÚsegmr?   é
   )Úclass_metricsÚmax_detection_thresholdsÚsync_on_computeÚbackendÚiou_type© )r+   rb   rQ   rc   ÚdictrT   rP   rU   r   Ú
map_metricÚmap_metric_trainÚmap_metric_ema)rj   rl   rm   rn   rq   rr   rz   Úkwargss           r$   ÚsetupzCOCOEvalCallback.setupÕ   s÷   € õ ˜y¨.¸$Ñ?Ô?ˆð HTÐG_�G�LÐ";¸UÑCÔCÐCÐejð 	 ð 6¸Ð=ˆÔØ!%Ô!3Ð!O¸DÔ<OÐ8OˆÔØ,0Ô,BÐN˜ Ð(Ð(ÈˆÝ!%ð Ô5Ø&'¨¨T¬^Ð%<ð "ð"
ñ "
ô "
ˆð !Ô.ˆˆyÑÝ9ÐVÐVÀ8ÐVÈvÐVÐVˆŒÝ ?Ð \Ð \ÈÐ \ÐU[Ð \Ð \ˆÔð $(ˆÔÐÐr&   c                ó   — d| _         dS )zôRelease the notebook output widget when the trainer exits.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            stage: One of ``"fit"``, ``"validate"``, ``"test"``, ``"predict"``.
        N)ra   )rj   rl   rm   rn   s       r$   ÚteardownzCOCOEvalCallback.teardownû   s   € ð #ˆÔÐÐr&   c                ó0   — |                       |¦  «         dS )z¯Resolve per-class names from the DataModule at the start of training.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        N)Ú_resolve_class_names©rj   rl   rm   s      r$   Úon_fit_startzCOCOEvalCallback.on_fit_start  s   € ð 	×!Ò! 'Ñ*Ô*Ð*Ð*Ð*r&   c                óB   — | j         s|                      |¦  «         dS dS )az  Resolve per-class names for a standalone ``trainer.validate()`` run.

        ``on_fit_start`` does not fire on validate-only runs, so per-class AP would otherwise be labelled by numeric id.
        Skipped when names are already resolved (e.g. validation inside ``fit``).

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        N©r\   r…   r†   s      r$   Úon_validation_startz$COCOEvalCallback.on_validation_start  ó3   € ð Ô#ð 	/Ø×%Ò% gÑ.Ô.Ð.Ð.Ð.ð	/ð 	/r&   c                óB   — | j         s|                      |¦  «         dS dS )a|  Resolve per-class names for a standalone ``trainer.test()`` run.

        ``on_fit_start`` does not fire on test-only runs (e.g. :meth:`rfdetr.detr.RFDETR.evaluate`), so per-class AP
        would otherwise be labelled by numeric id. Skipped when names are already resolved.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        Nr‰   r†   s      r$   Úon_test_startzCOCOEvalCallback.on_test_start  r‹   r&   c                óä  ‡— |j         }|€dS t          |d¦  «        r|j        pg | _        dD ]Ÿ}t	          ||d¦  «        }|€Œt	          |dd¦  «        Š‰�vt          ‰d¦  «        rft          ‰d¦  «        r+ˆfd„‰j                             ¦   «         D ¦   «         | _        n(d„ ‰j                             ¦   «         D ¦   «         | _         dS Œ d	„ t          | j        ¦  «        D ¦   «         | _        dS )
u´  Build the ``category_id â†’ name`` mapping from the DataModule's COCO metadata.

        Resolves names from the first available dataset split (train, val, or test) so per-class AP is logged under the
        class name regardless of whether the dataset uses sequential or non-sequential category IDs, and regardless of
        which loop (fit / validate / test) is running.

        Args:
            trainer: The PTL Trainer.
        NÚclass_names)Ú_dataset_trainÚ_dataset_valÚ_dataset_testÚcocoÚcatsÚ	label2catc                ó>   •— i | ]\  }}|‰j         |         d          “ŒS ©Úname)r”   )Ú.0ÚlabelÚcat_idr“   s      €r$   ú
<dictcomp>z9COCOEvalCallback._resolve_class_names.<locals>.<dictcomp>B  s8   ø€ ð ,ð ,ð ,Ù=J¸UÀF˜˜tœy¨Ô0°Ô8ð,ð ,ð ,r&   c                ó&   — i | ]\  }}||d          “ŒS r—   r{   )r™   ÚkÚvs      r$   rœ   z9COCOEvalCallback._resolve_class_names.<locals>.<dictcomp>G  s"   € Ð+WÐ+WÐ+W¹T¸QÀ¨A¨q°¬yÐ+WÐ+WÐ+Wr&   c                ó   — i | ]\  }}||“Œ	S r{   r{   )r™   Úir˜   s      r$   rœ   z9COCOEvalCallback._resolve_class_names.<locals>.<dictcomp>J  s   € ÐTÐTÐT©G¨A¨t  4ÐTÐTÐTr&   )
Ú
datamoduleÚhasattrr�   r[   r+   r•   Úitemsr\   r”   Ú	enumerate)rj   rl   ÚdmÚattrÚdatasetr“   s        @r$   r…   z%COCOEvalCallback._resolve_class_names(  s)  ø€ ð ÔˆØˆ:ØˆFÝ�2�}Ñ%Ô%ð 	5Ø "¤Ð 4°"ˆDÔàGð 	ð 	ˆDÝ˜b $¨Ñ-Ô-ˆGØˆØÝ˜7 F¨DÑ1Ô1ˆDØÐ¥G¨D°&Ñ$9Ô$9ÐÝ˜4 Ñ-Ô-ð 	Xð,ð ,ð ,ð ,ØNRÌn×NbÒNbÑNdÔNdð,ñ ,ô ,�DÔ(Ð(ð
 ,XÐ+WÀTÄYÇ_Â_ÑEVÔEVÐ+WÑ+WÔ+W�DÔ(Ø��øàTÐTµyÀÔARÑ7SÔ7SÐTÑTÔTˆÔÐÐr&   c                ó$  — | j                              ¦   «          t          ¦   «         | _        |                      d¦  «         |                      d¦  «         |                      t          |dd¦  «        ¦  «         |                      |¦  «         dS )zÃPrepare the EMA metric on every rank before validation (keeps DDP collectives symmetric).

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        ÚvalÚval_emaÚval_dataloadersN©r}   Úresetr   r]   Ú_reset_keypoint_splitÚ_reset_padding_filterr+   Ú_prepare_ema_metricr†   s      r$   Úon_validation_epoch_startz*COCOEvalCallback.on_validation_epoch_startL  sˆ   € ð 	Œ×ÒÑÔÐÝ2Ñ4Ô4ˆŒØ×"Ò" 5Ñ)Ô)Ð)Ø×"Ò" 9Ñ-Ô-Ð-Ø×"Ò"¥7¨7Ð4EÀtÑ#LÔ#LÑMÔMÐMØ× Ò  Ñ)Ô)Ð)Ð)Ð)r&   c                óú   — | j                              ¦   «          t          ¦   «         | _        |                      d¦  «         |                      t          |dd¦  «        ¦  «         |                      |¦  «         dS )a¹  Reset ``_ema_has_updates`` before test to prevent stale validation state from triggering EMA compute.

        ``on_test_batch_end`` never sets ``_ema_has_updates = True``, so EMA compute is always skipped during
        test (test metrics already reflect the EMA model via checkpoint loading in
        :class:`~rfdetr.training.callbacks.best_model.BestModelCallback`).  Without this hook a stale ``True`` value
        left by a preceding validation epoch would make ``_should_compute_ema`` return ``True``, causing an
        empty-state EMA compute pass that logs sentinel ``-1`` values.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        ÚtestÚtest_dataloadersNr­   r†   s      r$   Úon_test_epoch_startz$COCOEvalCallback.on_test_epoch_startZ  st   € ð 	Œ×ÒÑÔÐÝ2Ñ4Ô4ˆŒØ×"Ò" 6Ñ*Ô*Ð*Ø×"Ò"¥7¨7Ð4FÈÑ#MÔ#MÑNÔNÐNØ× Ò  Ñ)Ô)Ð)Ð)Ð)r&   ÚoutputsÚbatchÚ	batch_idxc                ó¬  — t          t          |dd¦  «        dd¦  «        durdS | j        dk    r|                      |¦  «        sdS t          |t          ¦  «        rd|vsd|vrdS |                      |¦  «         |                      |d         ¦  «        }|                      |d         ¦  «        }| j        r6|r4d	|d
         vr*| j	        s!t                               d¦  «         d| _	        dS | j                             ||¦  «         | j        rdnd}t          ||d|¬¦  «        }	t          | j        |	¦  «         |                      ||d¬¦  «         dS )aa  Accumulate train predictions for optional train-split mAP logging.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            outputs: Return value of ``training_step``.
            batch: The device-transferred batch (unused here).
            batch_idx: Batch index within the training epoch.
        Útrain_configNÚcompute_train_metricsFTr?   ÚresultsÚtargetsÚmasksr   z‰Train-split segmentation mAP skipped: pred_masks is a sparse dict during training (sparse_forward).  Only val/test segm mAP is available.rt   rs   ç      à?©Úiou_thresholdrz   Útrain©Úsplit)r+   rS   Ú_is_metric_epochÚ
isinstancer|   Ú_sync_xla_metric_inputsÚ_convert_predsÚ_convert_targetsrc   rd   r"   Úinfor~   Úupdater   r   r^   Ú_update_keypoint_oks_metric)
rj   rl   rm   r·   r¸   r¹   Úpredsr¾   rz   Úbatch_matchings
             r$   Úon_train_batch_endz#COCOEvalCallback.on_train_batch_endm  s’  € õ" •7˜9 n°dÑ;Ô;Ð=TÐV[Ñ\Ô\ÐdhÐhÐhØˆFØÔ Ò"Ð"¨4×+@Ò+@ÀÑ+IÔ+IÐ"ØˆFÝ˜'¥4Ñ(Ô(ð 	¨I¸WÐ,DÐ,DÈ	ÐY`ÐH`ÐH`ØˆFà×$Ò$ YÑ/Ô/Ð/Ø)-×)<Ò)<¸WÀYÔ=OÑ)PÔ)Pˆà×'Ò'¨°	Ô(:Ñ;Ô;ˆð Ô!ð 	 eð 	°¸uÀQ¼xÐ0GÐ0GØÔ/ð 4Ý—’ðNñô ð ð 04�Ô,ØˆFØÔ×$Ò$ U¨GÑ4Ô4Ð4à!Ô3Ð?�6�6¸ˆÝ,¨U°GÈ3ÐYaÐbÑbÔbˆÝ˜DÔ0°.ÑAÔAÐAØ×(Ò(¨°'ÀÐ(ÑIÔIÐIÐIÐIr&   c                óÒ  — t          t          |dd¦  «        dd¦  «        durC| j                             ¦   «          t          ¦   «         | _        |                      d¦  «         dS | j        dk    rX|                      |¦  «        sC| j                             ¦   «          t          ¦   «         | _        |                      d¦  «         dS |                      ||d| j        ¬¦  «         dS )	z¬Compute optional train-split mAP at the end of the training epoch.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        r»   Nr¼   FTrÃ   r?   ©Úmetric)	r+   r~   r®   r   r^   r¯   rS   rÆ   Ú_compute_and_logr†   s      r$   Úon_train_epoch_endz#COCOEvalCallback.on_train_epoch_endš  sé   € õ •7˜9 n°dÑ;Ô;Ð=TÐV[Ñ\Ô\ÐdhÐhÐhØÔ!×'Ò'Ñ)Ô)Ð)Ý#<Ñ#>Ô#>ˆDÔ Ø×&Ò& wÑ/Ô/Ð/ØˆFØÔ Ò"Ð"¨4×+@Ò+@ÀÑ+IÔ+IÐ"ØÔ!×'Ò'Ñ)Ô)Ð)Ý#<Ñ#>Ô#>ˆDÔ Ø×&Ò& wÑ/Ô/Ð/ØˆFØ×Ò˜g y°'À$ÔBWÐÑXÔXÐXÐXÐXr&   c                óÈ   — t          t          |dd¦  «        ¦  «        dz   }t          |dd¦  «        }t          |t           ¦  «        o|dk    o||k    }|| j        z  dk    p|S )a®  Decide whether the current epoch falls on an ``_eval_interval`` boundary (or is the final epoch).

        Shared by :meth:`on_train_batch_end` (skip accumulation on non-eval epochs) and
        :meth:`on_train_epoch_end` (skip compute/log and reset accumulators instead).

        Args:
            trainer: The PTL Trainer.

        Returns:
            ``True`` when this epoch should accumulate and log train metrics.
        Úcurrent_epochr   r?   Ú
max_epochsN)rB   r+   rÇ   rS   )rj   rl   r×   rØ   Úis_last_epochs        r$   rÆ   z!COCOEvalCallback._is_metric_epoch­  sn   € õ �G G¨_¸aÑ@Ô@ÑAÔAÀAÑEˆÝ˜W l°DÑ9Ô9ˆ
Ý" :­sÑ3Ô3Ðf¸
ÀQºÐfÈ=Ð\fÒKfˆØ˜tÔ2Ñ2°aÒ7ÐH¸=ÐHr&   r   ú!Tensor | Mapping[str, Any] | NoneÚdataloader_idxc                óJ  — t          |t          ¦  «        sdS |d         }|                      t          |¦  «        |¦  «        }t	          |¦  «        s;d„ t          |d         |¦  «        D ¦   «         d„ t          ||¦  «        D ¦   «         dœ}|                      |¦  «         |                      |d         ¦  «        }	|                      |d         | j	        r|	nd¦  «        }
|  
                    |¦  «        }t          |¦  «        }| j         o|du}|r*| j        �"| j                             |	|
¦  «         d| _        n| j                             |	|
¦  «         | j	        rdnd	}t#          |	|
d
|¬¦  «        }t%          | j        |¦  «         |                      |||rdnd¬¦  «         | j        �rm|��l|��k| j        ��e|\  }}t+          j        d„ |D ¦   «         ¦  «                             |j        ¦  «        }|j        }t+          j        ¦   «         5  |                     ¦   «           ||¦  «        }|                     ||¦  «        }ddd¦  «         n# 1 swxY w Y   t	          |¦  «        sd„ t          ||¦  «        D ¦   «         }|                      |¦  «         |                      |¦  «        }| j	        r|                      |d         |¦  «        n|
}| j                             ||¦  «         |                      |||d         dœd¬¦  «         d| _        dS dS dS dS dS )u  Accumulate predictions and matching data for one validation batch.

        Expects ``outputs`` to be the dict returned by ``RFDETRModelModule.validation_step``: ``{"results": list[dict],
        "targets": list[dict]}``.

        When an EMA callback is present the EMA model is run on the same batch in a separate ``torch.no_grad()`` forward
        pass so that base and EMA metrics are computed from independent predictions.

        Unless ``eval_base_model`` is set, and once the EMA model has warmed up, ``validation_step`` already
        forwarded through the EMA-averaged weights (see ``RFDETRModelModule._resolve_eval_model``) â€” these
        predictions are routed to the EMA mAP/checkpoint track (``map_metric_ema`` / ``val/ema_*``) instead of
        the regular one, which never ran a base-model forward pass this batch. Without this routing, the regular
        ``val/mAP_50_95`` key would silently reflect EMA quality while ``BestModelCallback`` checkpoints the
        (unevaluated) base weights under that key â€” a metric/weights mismatch. ``_compute_and_log`` then mirrors
        the EMA score onto the primary key so monitors keep receiving a real number, and ``BestModelCallback``
        suppresses its base-weights track for the same reason (see its ``evaluates_base_model`` argument).

        The macro-F1 sweep (``val/F1``) has no parallel EMA-tracked accumulator and always follows
        ``validation_step``'s own forward â€” which under the default is the same EMA model the mirrored
        ``val/mAP_50_95`` reports, so the two agree. Under ``eval_base_model=True`` both follow the base model
        instead, and the EMA track has no F1 counterpart.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            outputs: Return value of ``validation_step``.
            batch: The device-transferred batch ``(samples, targets)``.
            batch_idx: Batch index within the validation epoch.
            dataloader_idx: Index selecting the validation loader's padding rule.
        Nr¾   c                ó   — g | ]	\  }}|¯|‘Œ
S r{   r{   ©r™   ÚitemÚreals      r$   ú
<listcomp>z<COCOEvalCallback.on_validation_batch_end.<locals>.<listcomp>î  ó"   € ÐYÐYÐY¡Z T¨4ÐTXÐY˜DÐYÐYÐYr&   r½   c                ó   — g | ]	\  }}|¯|‘Œ
S r{   r{   rÞ   s      r$   rá   z<COCOEvalCallback.on_validation_batch_end.<locals>.<listcomp>ï  s!   € ÐTÐTÐT¡Z T¨4ÈtÐT˜DÐTÐTÐTr&   ©r½   r¾   Trt   rs   rÀ   rÁ   r«   rª   rÄ   c                ó   — g | ]
}|d          ‘ŒS ©Ú	orig_sizer{   ©r™   Úts     r$   rá   z<COCOEvalCallback.on_validation_batch_end.<locals>.<listcomp>  s   € Ð%LÐ%LÐ%L¸ a¨¤nÐ%LÐ%LÐ%Lr&   c                ó   — g | ]	\  }}|¯|‘Œ
S r{   r{   rÞ   s      r$   rá   z<COCOEvalCallback.on_validation_batch_end.<locals>.<listcomp>  s"   € ÐUÐUÐU©
¨¨dÐPTÐU˜tÐUÐUÐUr&   )rÇ   r   Ú_next_real_sample_maskÚlenÚallÚziprÈ   rÉ   rÊ   rc   Ú_get_ema_callbackr-   rZ   r   rÌ   r_   r}   r   r   r]   rÍ   ÚtorchÚstackÚtoÚdeviceÚmodelÚno_gradÚevalÚpostprocess)rj   rl   rm   r·   r¸   r¹   rÛ   Úbatch_targetsÚkeeprÎ   r¾   r'   Ú	ema_innerÚused_ema_forwardrz   rÏ   ÚsamplesÚ_Ú
orig_sizesÚema_underlyingÚema_outputsÚema_resultsÚ	ema_predsÚema_targetss                           r$   Úon_validation_batch_endz(COCOEvalCallback.on_validation_batch_end¾  sÖ  € õN ˜'¥7Ñ+Ô+ð 	ØˆFØ 	Ô*ˆØ×*Ò*­3¨}Ñ+=Ô+=¸~ÑNÔNˆÝ�4‰yŒyð 	ð
 ZÐYµ3°w¸yÔ7IÈ4Ñ3PÔ3PÐYÑYÔYØTÐTµ3°}ÀdÑ3KÔ3KÐTÑTÔTðð ˆGð 	×$Ò$ YÑ/Ô/Ð/Ø)-×)<Ò)<¸WÀYÔ=OÑ)PÔ)PˆØ×'Ò'¨°	Ô(:ÀTÔE[Ð<e¸E¸EÐaeÑfÔfˆð ×'Ò'¨Ñ0Ô0ˆÝ)¨&Ñ1Ô1ˆ	Ø#Ô4Ð4ÐN¸È$Ð9NÐØð 	3ØÔ"Ð.ØÔ#×*Ò*¨5°'Ñ:Ô:Ð:Ø(,�Ô%øàŒO×"Ò" 5¨'Ñ2Ô2Ð2à!Ô3Ð?�6�6¸ˆÝ,¨U°GÈ3ÐYaÐbÑbÔbˆÝ˜DœN¨NÑ;Ô;Ð;Ø×(Ò(¨°'ÐN^ÐAiÀÀÐdiÐ(ÑjÔjÐjð Ô ñ 	) VÑ%7¸IÑ<QÐVZÔViÑVuØ‰JˆG�Qõ œÐ%LÐ%L¸mÐ%LÑ%LÔ%LÑMÔM×PÒPÐQZÔQaÑbÔbˆJØ&œ_ˆNÝ”‘”ð Mð MØ×#Ò#Ñ%Ô%Ð%Ø,˜n¨WÑ5Ô5�Ø'×3Ò3°KÀÑLÔL�ðMð Mð Mñ Mô Mð Mð Mð Mð Mð Mð Møøøð Mð Mð Mð Mõ �t‘9”9ð VØUÐUµc¸+ÀtÑ6LÔ6LÐUÑUÔU�Ø×(Ò(¨Ñ3Ô3Ð3Ø×+Ò+¨KÑ8Ô8ˆIð SWÔRhÐu˜$×/Ò/°¸	Ô0BÀIÑNÔNÐNÐnuˆKØÔ×&Ò& y°+Ñ>Ô>Ð>Ø×,Ò,ØØ'°G¸IÔ4FÐGÐGØð -ñ ô ð ð
 %)ˆDÔ!Ð!Ð!ð5	)ð 	)Ð%7Ð%7Ð<QÐ<QÐVuÐVus   È6IÉIÉIc                ó   — | j         dk    rÛt          t          |dd¦  «        ¦  «        dz   }t          |dd¦  «        }t          |t          ¦  «        o|dk    o||k    }|| j         z  dk    rz|sx| j                             ¦   «          | j        �| j                             ¦   «          t          ¦   «         | _        |  	                    d¦  «         |  	                    d¦  «         dS |  
                    ||d¦  «         dS )z°Compute and log mAP and F1 metrics at the end of the validation epoch.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        r?   r×   r   rØ   Nrª   r«   )rS   rB   r+   rÇ   r}   r®   r   r   r]   r¯   rÔ   )rj   rl   rm   r×   rØ   rÙ   s         r$   Úon_validation_epoch_endz(COCOEvalCallback.on_validation_epoch_end*  s  € ð Ô Ò"Ð"Ý¥¨°À!Ñ DÔ DÑEÔEÈÑIˆMÝ  ¨,¸Ñ=Ô=ˆJÝ& zµ3Ñ7Ô7Ðj¸JÈºNÐjÈ}Ð`jÒOjˆMØ˜tÔ2Ñ2°aÒ7Ð7ÀÐ7Ø”×%Ò%Ñ'Ô'Ð'ØÔ&Ð2ØÔ'×-Ò-Ñ/Ô/Ð/Ý!:Ñ!<Ô!<�”Ø×*Ò*¨5Ñ1Ô1Ð1Ø×*Ò*¨9Ñ5Ô5Ð5Ø�Ø×Ò˜g y°%Ñ8Ô8Ð8Ð8Ð8r&   c                óœ  — t          |t          ¦  «        sdS |                      t          |d         ¦  «        |¦  «        }t	          |¦  «        sAd„ t          |d         |¦  «        D ¦   «         d„ t          |d         |¦  «        D ¦   «         dœ}|                      |¦  «         |                      |d         ¦  «        }|                      |d         | j	        r|nd¦  «        }	| j
                             ||	¦  «         | j	        rdnd}
t          ||	d	|
¬
¦  «        }t          | j        |¦  «         |                      ||d¬¦  «         dS )a  Accumulate predictions and matching data for one test batch.

        Mirrors :meth:`on_validation_batch_end` for the test evaluation loop triggered by ``trainer.test()`` at the end
        of training.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            outputs: Return value of ``test_step``.
            batch: Raw batch (unused here).
            batch_idx: Batch index within the test epoch.
            dataloader_idx: Index selecting the test loader's padding rule.
        Nr¾   c                ó   — g | ]	\  }}|¯|‘Œ
S r{   r{   rÞ   s      r$   rá   z6COCOEvalCallback.on_test_batch_end.<locals>.<listcomp>\  râ   r&   r½   c                ó   — g | ]	\  }}|¯|‘Œ
S r{   r{   rÞ   s      r$   rá   z6COCOEvalCallback.on_test_batch_end.<locals>.<listcomp>]  râ   r&   rä   rt   rs   rÀ   rÁ   r´   rÄ   )rÇ   r   rë   rì   rí   rî   rÈ   rÉ   rÊ   rc   r}   rÌ   r   r   r]   rÍ   )rj   rl   rm   r·   r¸   r¹   rÛ   rù   rÎ   r¾   rz   rÏ   s               r$   Úon_test_batch_endz"COCOEvalCallback.on_test_batch_end?  sb  € õ, ˜'¥7Ñ+Ô+ð 	ØˆFØ×*Ò*­3¨w°yÔ/AÑ+BÔ+BÀNÑSÔSˆÝ�4‰yŒyð 	ð ZÐYµ3°w¸yÔ7IÈ4Ñ3PÔ3PÐYÑYÔYØYÐYµ3°w¸yÔ7IÈ4Ñ3PÔ3PÐYÑYÔYðð ˆGð 	×$Ò$ YÑ/Ô/Ð/Ø)-×)<Ò)<¸WÀYÔ=OÑ)PÔ)PˆØ×'Ò'¨°	Ô(:ÀTÔE[Ð<e¸E¸EÐaeÑfÔfˆàŒ×Ò˜u gÑ.Ô.Ð.à!Ô3Ð?�6�6¸ˆÝ,¨U°GÈ3ÐYaÐbÑbÔbˆÝ˜DœN¨NÑ;Ô;Ð;Ø×(Ò(¨°'ÀÐ(ÑHÔHÐHÐHÐHr&   c                ó4   — |                       ||d¦  «         dS )a   Compute and log mAP and F1 under ``test/`` prefix at end of test epoch.

        Mirrors :meth:`on_validation_epoch_end` for the test evaluation loop.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
        r´   N)rÔ   r†   s      r$   Úon_test_epoch_endz"COCOEvalCallback.on_test_epoch_endj  s"   € ð 	×Ò˜g y°&Ñ9Ô9Ð9Ð9Ð9r&   Údataloadersc                ód  — i | _         i | _        t          |t          t          f¦  «        r|n|g}t          |¦  «        D ]p\  }}t          |dd¦  «        }t          |t          ¦  «        r|j        s|j	        rŒ:t          |j        ¦  «        }|j        |k    r|j        |j        |f| j        |<   ŒqdS )a�  Derive this epoch's DistributedSampler padding rule from the evaluation loader and reset the counter.

        Lightning replaces the evaluation loader's ``SequentialSampler`` with a ``DistributedSampler`` that pads the
        index list to a multiple of ``world_size`` by repeating the leading indices, so up to ``world_size - 1``
        images are forwarded twice per epoch. Rank ``r`` receives global positions ``r, r + W, r + 2W, ...`` in order
        (``shuffle=False``), and a position at or past the dataset length is such a repeat. The forward still runs
        on those samples (keeping every rank's batch count equal, which the epoch-end collectives rely on); only the
        metric accumulators skip them, so each image is scored exactly once across ranks.

        Args:
            dataloaders: ``trainer.val_dataloaders`` or ``trainer.test_dataloaders`` (a loader or a list of them).
        ÚsamplerN)rh   rg   rÇ   ÚlistÚtupler¥   r+   r
   ÚshuffleÚ	drop_lastrì   r¨   Ú
total_sizeÚrankÚnum_replicas)rj   r  ÚloadersrÛ   Úloaderr  Údataset_lens          r$   r°   z&COCOEvalCallback._reset_padding_filtery  sÏ   € ð #%ˆÔØˆÔÝ!+¨K½$Å¸Ñ!GÔ!GÐZ�+�+ÈkÈ]ˆÝ&/°Ñ&8Ô&8ð 	gð 	gÑ"ˆN˜FÝ˜f i°Ñ6Ô6ˆGÝ˜gÕ'9Ñ:Ô:ð ¸g¼oð ÐQXÔQbð ØÝ˜gœoÑ.Ô.ˆKØÔ! KÒ/Ð/Ø6=´lÀGÔDXÐZeÐ5f�Ô" >Ñ2øð	gð 	gr&   Úcountú
list[bool]c                óæ   ‡‡‡‡— | j                              |d¦  «        Š‰|z   | j         |<   | j                             |¦  «        }|€dg|z  S |\  ŠŠŠˆˆˆˆfd„t          |¦  «        D ¦   «         S )a£  Return, for the next ``count`` samples on this rank, whether each is a real image rather than padding.

        Args:
            count: Number of samples in the batch being accumulated.
            dataloader_idx: Index selecting the evaluation loader's independent sample position and sampler rule.

        Returns:
            One flag per sample, in batch order; all ``True`` when the split is not padded.
        r   NTc                ó.   •— g | ]}‰‰|z   ‰z  z   ‰k     ‘ŒS r{   r{   )r™   Úoffsetr  Úfirstr  r  s     €€€€r$   rá   z;COCOEvalCallback._next_real_sample_mask.<locals>.<listcomp>¡  s,   ø€ Ð`Ð`Ð`È�˜ ™¨,Ñ6Ñ6¸ÒDÐ`Ð`Ð`r&   )rh   Úgetrg   Úrange)rj   r  rÛ   Úpaddingr  r  r  r  s       @@@@r$   rë   z'COCOEvalCallback._next_real_sample_mask‘  s‘   øøøø€ ð Ô'×+Ò+¨N¸AÑ>Ô>ˆØ27¸%±-ˆÔ Ñ/ØÔ$×(Ò(¨Ñ8Ô8ˆØˆ?Ø�6˜E‘>Ð!Ø*1Ñ'ˆˆl˜KØ`Ð`Ð`Ð`Ð`Ð`Ð`ÕSXÐY^ÑS_ÔS_Ð`Ñ`Ô`Ð`r&   c                ó†   — t          t          | dd¦  «        dd¦  «        dk    rdS ddl}|                     d¬¦  «         dS )at  Materialize all live XLA outputs before metric code starts reading individual tensors on the host.

        COCO accumulation keeps CPU-owned state, and target conversion, mAP, F1, and keypoint paths each read
        different leaves from the same lazy evaluation graph. Without one shared boundary, the first ``.tolist()``
        or ``.cpu()`` compiles only the requested leaf; later reads then compile overlapping graph fragments. A
        single XLA step boundary makes those reads transfers from one materialized result instead.

        Args:
            pl_module: Lightning module supplying the active device.
        ró   NÚtypeÚxlar   T©Úwait)r+   Ú	torch_xlaÚsync)rm   r(  s     r$   rÈ   z(COCOEvalCallback._sync_xla_metric_inputs£  sR   € õ •7˜9 h°Ñ5Ô5°v¸tÑDÔDÈÒMÐMØˆFØÐÐÐà�Š˜DˆÑ!Ô!Ð!Ð!Ð!r&   rÅ   ÚpfxÚmar_keyú"tuple[bool, dict[str, Any] | None]c                ó¢  — |                       |¦  «        }d}|�r‹| j                             ¦   «          |                      || j        ¦  «        }|                     |› d�||› d�         dddd¬¦  «         |                     |› d�||› d�         ddd¬	¦  «         |                     |› d
�||› d�         ddd¬	¦  «         |                     |› d�||         ddd¬	¦  «         ||› d�                              ¦   «                              ¦   «         |j        |› d�<   ||› d�                              ¦   «                              ¦   «         |j        |› d�<   ||› d�                              ¦   «                              ¦   «         |j        |› d
�<   ||                              ¦   «                              ¦   «         |j        |› d�<   | j        r´|                     |› d�|d         ddd¬	¦  «         |                     |› d�|d         ddd¬	¦  «         |d                              ¦   «                              ¦   «         |j        |› d�<   |d                              ¦   «                              ¦   «         |j        |› d�<   | j         	                    ¦   «          d| _
        n'| j        � | j         	                    ¦   «          d| _
        ||fS )uƒ  Compute, log, and reset ``map_metric_ema`` if every rank agrees it has data this epoch.

        Extracted out of :meth:`_compute_and_log` so its early-return branch (base ``metric`` empty)
        can call it too â€” when the base model is not evaluated it never accumulates updates (see
        ``on_validation_batch_end``), so gating EMA logging on the base metric's own guard silently
        drops the EMA metrics as well, leaving the epoch with no validation output at all (#1285).

        The EMA ``compute()`` triggers a cross-rank metric sync, so it must be issued by EVERY rank
        or none: a rank whose EMA metric is empty/absent would otherwise skip this collective and
        desync the DDP collective sequence, deadlocking validation (#931 / #449).
        ``_should_compute_ema`` makes the decision unanimous across ranks.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            split: Metric namespace â€” ``"val"`` or ``"test"``.
            pfx: torchmetrics key prefix (``"bbox_"`` when ``iou_type`` is a list, else ``""``).
            mar_key: Prefixed AR metric key for ``self._max_dets``.

        Returns:
            ``(should_compute_ema, ema_metrics)`` â€” whether the EMA metrics were actually computed
            and logged this call (callers use this to decide whether the parallel EMA keypoint split
            should also be logged or reset), and the raw ``compute()`` output when they were, else
            ``None``. Callers that also need per-class EMA data (see ``_print_ema_only_summary``)
            reuse this instead of calling ``compute()`` a second time.
        Nz/ema_mAP_50_95ÚmapTF©Úprog_barr"   Úon_stepÚon_epochz/ema_mAP_50Úmap_50©r"   r1  r2  z/ema_mAP_75Úmap_75z/ema_mARz/ema_segm_mAP_50_95Úsegm_mapz/ema_segm_mAP_50Úsegm_map_50)Ú_should_compute_emar   Úmerge_distributed_stateÚ_compute_map_metricÚlogÚdetachÚcpuÚcallback_metricsrc   r®   r_   )rj   rl   rm   rÅ   r*  r+  Úshould_compute_emaÚema_metricss           r$   Ú_compute_and_log_ema_metricsz-COCOEvalCallback._compute_and_log_ema_metricsµ  sA  € ð: "×5Ò5°iÑ@Ô@ÐØ-1ˆØñ !	*ØÔ×7Ò7Ñ9Ô9Ð9Ø×2Ò2°7¸DÔ<OÑPÔPˆKØ�MŠMØÐ(Ð(Ð(Ø˜s˜K˜K˜KÔ(ØØØØð ñ ô ð ð �MŠM˜UÐ/Ð/Ð/°À¸^¸^¸^Ô1LÐUYÐchÐswˆMÑxÔxÐxØ�MŠM˜UÐ/Ð/Ð/°À¸^¸^¸^Ô1LÐUYÐchÐswˆMÑxÔxÐxØ�MŠM˜UÐ,Ð,Ð,¨k¸'Ô.BÈ4ÐY^ÐimˆMÑnÔnÐnØALÐPSÈ[È[È[ÔAY×A`ÒA`ÑAbÔAb×AfÒAfÑAhÔAhˆGÔ$¨Ð%=Ð%=Ð%=Ñ>Ø>IÈSÈ.È.È.Ô>Y×>`Ò>`Ñ>bÔ>b×>fÒ>fÑ>hÔ>hˆGÔ$¨Ð%:Ð%:Ð%:Ñ;Ø>IÈSÈ.È.È.Ô>Y×>`Ò>`Ñ>bÔ>b×>fÒ>fÑ>hÔ>hˆGÔ$¨Ð%:Ð%:Ð%:Ñ;Ø;FÀwÔ;O×;VÒ;VÑ;XÔ;X×;\Ò;\Ñ;^Ô;^ˆGÔ$¨Ð%7Ð%7Ð%7Ñ8ØÔ%ð qØ—’ØÐ1Ð1Ð1°;¸zÔ3JÐSWÐafÐquð ñ ô ð ð —’ØÐ.Ð.Ð.°¸MÔ0JÐSWÐafÐquð ñ ô ð ð KVÐV`ÔJa×JhÒJhÑJjÔJj×JnÒJnÑJpÔJp�Ô(¨EÐ)FÐ)FÐ)FÑGØGRÐS`ÔGa×GhÒGhÑGjÔGj×GnÒGnÑGpÔGp�Ô(¨EÐ)CÐ)CÐ)CÑDØÔ×%Ò%Ñ'Ô'Ð'Ø$)ˆDÔ!Ð!ØÔ Ð,ð Ô×%Ò%Ñ'Ô'Ð'Ø$)ˆDÔ!Ø! ;Ð.Ð.r&   c           	     ó,  ‡	— |› d�Š	ˆ	fd„|j         D ¦   «         D ]y}|t          ‰	¦  «        d…         }|› d|› �}|j         |         }||j         |<   |                     ¦   «                              d¦  «        }|                     |||ddd¬¦  «         ŒzdS )	ug  Copy every ``{split}/ema_<name>`` scalar onto ``{split}/<name>`` when the EMA track is the only one.

        Called only from the branch where the base ``metric`` accumulated nothing, so the primary keys are
        genuinely unwritten this epoch and nothing can be overwritten. Without the mirror, the epoch's real
        score reaches ``val/ema_mAP_50_95`` alone and every scheduler, early-stopping hook, checkpoint monitor
        and dashboard watching ``val/mAP_50_95`` silently sees nothing â€” tolerable for the opt-in
        ``eval_ema_only`` flag this replaces, not for a default (``TrainConfig.eval_base_model``).

        Mirroring the whole ``ema_`` prefix rather than an enumerated key list keeps the primary namespace in
        step with whatever the EMA track logged for the task at hand â€” box, segmentation and keypoint keys
        alike, including the task-specific key ``BestModelCallback``/``RFDETREarlyStopping`` monitor. Per-class AP is
        mirrored separately in the EMA-only summary because it is logged outside ``trainer.callback_metrics``.

        The mirrored score comes from the EMA weights, so ``BestModelCallback`` must not run its base-weights
        track against it â€” see its ``evaluates_base_model`` argument, which trainer.py wires from the same
        config field.

        Args:
            trainer: The PTL Trainer, whose ``callback_metrics`` supplies and receives the mirrored values.
            pl_module: The LightningModule used to log the mirrored scalars to external loggers.
            split: Metric namespace â€” ``"val"`` (the only split that reaches this method).
        z/ema_c                ó>   •— g | ]}|                      ‰¦  «        ¯|‘ŒS r{   )Ú
startswith)r™   rž   Ú
ema_prefixs     €r$   rá   zHCOCOEvalCallback._mirror_ema_metrics_to_primary_keys.<locals>.<listcomp>  s*   ø€ ÐTÐTÐT˜!¸1¿<º<È
Ñ;SÔ;SÐT�AÐTÐTÐTr&   Nú/Ú	map_50_95TFr/  )r>  rì   ÚlowerÚendswithr;  )
rj   rl   rm   rÅ   ÚkeyÚmetric_nameÚprimary_keyÚvaluer0  rE  s
            @r$   Ú#_mirror_ema_metrics_to_primary_keysz4COCOEvalCallback._mirror_ema_metrics_to_primary_keysø  sË   ø€ ð. �_�_�_ˆ
ØTÐTÐTÐT˜wÔ7ÐTÑTÔTð 	lð 	lˆCØ�c *™oœoÐ/Ð/Ô0ˆKØ"Ð2Ð2 [Ð2Ð2ˆKØÔ,¨SÔ1ˆEØ49ˆGÔ$ [Ñ1ð #×(Ò(Ñ*Ô*×3Ò3°KÑ@Ô@ˆHØ�MŠM˜+ u°xÈÐV[ÐfjˆMÑkÔkÐkÐkð	lð 	lr&   Úf1_localúdict[int, dict[str, Any]]ú4tuple[dict[str, float], dict[int, dict[str, float]]]c                óF  ‡— t          |¦  «        Ši }‰�r*t          ‰                     ¦   «         ¦  «        }ˆfd„|D ¦   «         }ˆfd„t          |¦  «        D ¦   «         }t	          |t          j        ddd¦  «        |¦  «        }	t          |	d„ ¬¦  «        }
t          |
d         ¦  «        t          |
d	         ¦  «        t          |
d
         ¦  «        dœ}t          |¦  «        D ]Y\  }}t          |
d         |         ¦  «        t          |
d         |         ¦  «        t          |
d         |         ¦  «        dœ||<   ŒZnddddœ}| 	                    |› d�|d         dddd¬¦  «         | 	                    |› d�|d         ddd¬¦  «         | 	                    |› d�|d         ddd¬¦  «         t          j        |d         ¦  «        |j        |› d�<   t          j        |d         ¦  «        |j        |› d�<   t          j        |d         ¦  «        |j        |› d�<   ||fS )u?  Sweep confidence thresholds over ``f1_local``, log ``{split}/F1`` (+precision/recall), return per-class F1.

        Independent of ``self.map_metric``/``self.map_metric_ema``: ``f1_local`` accumulates every batch's matching
        data via ``merge_matching_data`` in ``on_validation_batch_end`` unconditionally, regardless of which mAP
        track (base vs EMA) that batch's predictions were routed to. Extracted so the empty-``metric`` early-return
        branch of :meth:`_compute_and_log` can also call it â€” when the base model is not evaluated ``f1_local`` is the
        only accumulator with real data this epoch, so discarding it via ``_reset_f1_local`` without computing would
        silently drop ``val/F1`` too, even though real matching data was collected (#1285).

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            split: Metric namespace â€” ``"val"``, ``"test"``, or ``"train"``.
            f1_local: Per-category matching accumulator for this split.

        Returns:
            ``(overall, f1_by_cid)`` â€” ``overall`` has keys ``"F1"``, ``"Precision"``, ``"Recall"``; ``f1_by_cid``
            maps category_id to its per-class ``f1``/``precision``/``recall`` at the best macro-F1 threshold
            (empty when no matching data was accumulated).
        c                ó    •— g | ]
}‰|         ‘ŒS r{   r{   )r™   ÚcidÚmergeds     €r$   rá   z@COCOEvalCallback._compute_and_log_f1_metrics.<locals>.<listcomp>5  s   ø€ Ð@Ð@Ð@¨c˜f SœkÐ@Ð@Ð@r&   c                ó>   •— g | ]\  }}‰|         d          dk    ¯|‘ŒS )Útotal_gtr   r{   )r™   r¡   rT  rU  s      €r$   rá   z@COCOEvalCallback._compute_and_log_f1_metrics.<locals>.<listcomp>6  s2   ø€ ÐdÐdÐd¡V Q¨ÈÈsÌÐT^ÔH_ÐbcÒHcÐHc˜qÐHcÐHcÐHcr&   r   r?   ée   c                ó   — | d         S )NÚmacro_f1r{   )Úxs    r$   ú<lambda>z>COCOEvalCallback._compute_and_log_f1_metrics.<locals>.<lambda>8  s
   € °°:´€ r&   )rJ  rZ  Úmacro_precisionÚmacro_recall)ÚF1Ú	PrecisionÚRecallÚper_class_f1Úper_class_precÚper_class_rec©Úf1Ú	precisionÚrecallg        z/F1r_  TFr/  z
/precisionr`  r4  z/recallra  )r   ÚsortedÚkeysr¥   r   ÚnpÚlinspacerR   Úfloatr;  rð   Útensorr>  )rj   rl   rm   rÅ   rO  Ú	f1_by_cidÚ
sorted_idsÚper_class_listÚclasses_with_gtÚ
f1_resultsÚbestÚoverallrž   rT  rU  s                 @r$   Ú_compute_and_log_f1_metricsz,COCOEvalCallback._compute_and_log_f1_metrics  sb  ø€ õ. 1°Ñ:Ô:ˆØ13ˆ	Øñ 	CÝ §¢¡¤Ñ.Ô.ˆJØ@Ð@Ð@Ð@°ZÐ@Ñ@Ô@ˆNØdÐdÐdÐd­y¸Ñ/DÔ/DÐdÑdÔdˆOÝ4°^ÅRÄ[ÐQRÐTUÐWZÑE[ÔE[Ð]lÑmÔmˆJÝ�zÐ'>Ð'>Ð?Ñ?Ô?ˆDå˜D Ô,Ñ-Ô-Ý" 4Ð(9Ô#:Ñ;Ô;Ý  ^Ô 4Ñ5Ô5ðð ˆGõ
 $ JÑ/Ô/ð ð ‘��3å  ^Ô 4°QÔ 7Ñ8Ô8Ý!& tÐ,<Ô'=¸aÔ'@Ñ!AÔ!AÝ# D¨Ô$9¸!Ô$<Ñ=Ô=ð"ð "�	˜#‘�ðð !¨s¸cÐBÐBˆGØ�Š˜�m�m�m W¨T¤]¸TÈ$ÐX]ÐhlˆÑmÔmÐmØ�Š˜Ð*Ð*Ð*¨G°KÔ,@ÈÐW\ÐgkˆÑlÔlÐlØ�Š˜Ð'Ð'Ð'¨°Ô):À4ÐQVÐaeˆÑfÔfÐfÝ27´,¸wÀt¼}Ñ2MÔ2MˆÔ  E   Ñ/Ý9>¼ÀgÈkÔFZÑ9[Ô9[ˆÔ  EÐ!5Ð!5Ð!5Ñ6Ý6;´lÀ7È8ÔCTÑ6UÔ6UˆÔ  EÐ!2Ð!2Ð!2Ñ3Ø˜	Ð!Ð!r&   rÓ   c                ó*  — |j         rdnd}t          ¦   «         rlt          j        |gt	          |dd¦  «        ¬¦  «        }t          j        |t
          j        j        ¬¦  «         t          | 
                    ¦   «         ¦  «        }t          |¦  «        S )uY  Vote â€” identically on every rank â€” whether *any* rank has updates for *metric*.

        ``metric.has_updates`` only reflects local per-rank state; branching on it directly lets ranks
        diverge on whether they enter ``merge_distributed_state()``'s ``all_gather`` collectives next,
        desynchronising the DDP collective sequence and deadlocking validation. This makes the decision
        collectively instead. Unlike ``_should_compute_ema``'s ``all_reduce(MIN)`` (unanimous â€” skip
        whenever any rank is empty, intentionally conservative to avoid discarding EMA state on an
        uneven epoch), this uses ``all_reduce(MAX)``: the base/train mAP path must not silently drop a
        populated rank's data just because a sibling rank's shard was empty, so any single rank voting 1
        makes every rank enter the merge (``merge_distributed_state()`` treats an empty local shard as a
        no-op contribution to the gather).

        Args:
            metric: The mAP accumulator to check (``self.map_metric`` or a split-specific variant).
            pl_module: The LightningModule (provides the device for the reduction).

        Returns:
            ``True`` iff at least one rank accumulated updates this epoch, making it safe â€” and
            necessary â€” for every rank to enter ``merge_distributed_state()`` identically.
        r?   r   ró   r=  ©ró   ©Úop)Úhas_updatesr   rð   rn  r+   ÚdistÚ
all_reduceÚReduceOpÚMAXrB   rß   r   )rj   rÓ   rm   ÚvoteÚflags        r$   Ú_any_rank_has_updatesz&COCOEvalCallback._any_rank_has_updatesN  s€   € ð* Ô&Ð-ˆqˆq¨AˆÝ(Ñ*Ô*ð 	$Ý”<  ­w°yÀ(ÈEÑ/RÔ/RÐSÑSÔSˆDÝŒO˜D¥T¤]Ô%6Ð7Ñ7Ô7Ð7Ý�t—y’y‘{”{Ñ#Ô#ˆDÝ�D‰zŒzÐr&   rÒ   ú
Any | Nonec               óz  — |€| j         n|}|dk    r| j        n| j        }| j        rdnd}|› d| j        › �}|                      ||¦  «        �s|                     ¦   «          |                      |¦  «         |dk    r |                      |||||¦  «        \  }}	|r2|  	                    d||dd¬	¦  «         |  
                    |||¦  «         n|                      d¦  «         |                      ||||¦  «        \  }
}|r|	�|                      ||||||	|
|¦  «         |                      |¦  «         t                               d
|¦  «         dS |                     ¦   «          |                      ||¦  «        }dt%          ||› d�         ¦  «        dt%          ||› d�         ¦  «        dt%          ||› d�         ¦  «        d| j        › �t%          ||         ¦  «        i}|                     |› d�||› d�         dddd¬¦  «         |                     |› d�||› d�         dddd¬¦  «         |                     |› d�||› d�         ddd¬¦  «         |                     |› d�||         ddd¬¦  «         ||› d�                              ¦   «                              ¦   «         |j        |› d�<   ||› d�                              ¦   «                              ¦   «         |j        |› d�<   ||› d�                              ¦   «                              ¦   «         |j        |› d�<   ||                              ¦   «                              ¦   «         |j        |› d�<   |                      |||||¦  «        \  }}| j        rät%          |d         ¦  «        |d<   t%          |d         ¦  «        |d<   |                     |› d�|d         ddd¬¦  «         |                     |› d�|d         ddd¬¦  «         |d                              ¦   «                              ¦   «         |j        |› d�<   |d                              ¦   «                              ¦   «         |j        |› d�<   |                      ||||¦  «        \  }
}|                     |
¦  «         d |v r”|d          j        d!k    rƒt3          |¦  «        }|d                               d!¦  «        |d <   t7          |¦  «        D ]F}||         }t9          |t:          ¦  «        r'|j        d!k    rd"|v r|                     d!¦  «        ||<   ŒG|› d| j        › d#�}i }| j        rI||v rEd |v rAt?          |d          ||         ¦  «        D ]$\  }}t%          |¦  «        |tA          |¦  «        <   Œ%|  !                    ||||||¬$¦  «        }|  "                    ||||¦  «         |  	                    |||¦  «         |dk    r|r|  	                    d||dd¬	¦  «         n|dk    r|                      d¦  «         |                     ¦   «          |                      |¦  «         dS )%u  Shared epoch-end logic for validation and test evaluation loops.

        Computes mAP (via ``self.map_metric``), runs the F1 confidence-threshold sweep, logs all scalar metrics via
        ``pl_module.log``, prints two summary tables to the terminal, and resets internal accumulators.  When
        ``self.map_metric_ema`` is set, EMA variants of all metrics (including ``ema_segm_mAP_50_95`` and
        ``ema_segm_mAP_50`` for segmentation models) are logged under the same ``split/`` namespace.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            split: Metric namespace â€” ``"val"`` or ``"test"``.
            metric: Optional split-specific mAP accumulator. Defaults to the validation/test accumulator.
        NrÃ   Úbbox_Ú Úmar_rª   r«   Úema_©Ú	log_splitÚmetric_prefixzHSkipping %s COCO metric compute because no predictions were accumulated.ú	mAP 50:95r.  úmAP 50r3  úmAP 75r5  úmAR @z
/mAP_50_95TFr/  z/mAP_50z/mAP_75r4  z/mARr6  úsegm mAP 50:95r7  úsegm mAP 50z/segm_mAP_50_95z/segm_mAP_50Úclassesr   Ú	per_classÚ
_per_class)Úmetricsr*  rÅ   rm   Ú	ar_by_cidro  )#r}   r^   r]   rc   rP   r‚  r®   r¯   rA  Ú_compute_and_log_keypoint_maprN  rv  Ú_print_ema_only_summaryÚ_reset_f1_localr"   Údebugr9  r:  rm  r;  r<  r=  r>  rÌ   Úndimr|   Ú	unsqueezer  rÇ   r	   rT   rî   rB   Ú_build_per_class_rowsÚ_print_metrics_tables)rj   rl   rm   rÅ   rÓ   rO  r*  r+  r?  r@  Ú
f1_overallro  r•  ru  Ú_ema_metricsÚ
metric_keyrM  Ú	ar_pc_keyr–  Úclass_idÚarr“  s                         r$   rÔ   z!COCOEvalCallback._compute_and_logj  sL  € ð %+ N�”�¸ˆØ+0°GÒ+;Ð+;�4Ô'Ð'ÀÄˆð Ô/Ð7ˆgˆg°RˆØÐ.Ð.˜dœnÐ.Ð.ˆØ×)Ò)¨&°)Ñ<Ô<ñ %	Ø�LŠL‰NŒNˆNØ×&Ò& uÑ-Ô-Ð-ð ˜Š~ˆ~Ø26×2SÒ2SØ˜Y¨¨s°Gñ3ô 3Ñ/Ð" Kð &ð :Ø×6Ò6Ø! 9¨gÀÐV\ð 7ñ ô ð ð ×<Ò<¸WÀiÐQVÑWÔWÐWÐWà×.Ò.¨yÑ9Ô9Ð9ð )-×(HÒ(HÈÐR[Ð]bÐdlÑ(mÔ(mÑ%�
˜Ið &ð ¨+Ð*AØ×0Ò0Ø ¨E°3¸ÀÈjÐZcñô ð ð × Ò  Ñ'Ô'Ð'Ý�LŠLÐcÐejÑkÔkÐkØˆFð 	×&Ò&Ñ(Ô(Ð(Ø×*Ò*¨7°FÑ;Ô;ˆð �˜w¨# { { {Ô3Ñ4Ô4Ø•e˜G s N N NÔ3Ñ4Ô4Ø•e˜G s N N NÔ3Ñ4Ô4Ø$�D”NÐ$Ð$¥e¨G°GÔ,<Ñ&=Ô&=ð	%
ˆð 	�ŠØÐ Ð Ð  '¨S¨+¨+¨+Ô"6ÀÈdÐ\aÐlpð 	ñ 	
ô 	
ð 	
ð 	�ŠØÐÐÐ˜w¨# ~ ~ ~Ô6ÀÈdÐ\aÐlpð 	ñ 	
ô 	
ð 	
ð 	�Š˜Ð'Ð'Ð'¨°C°°°Ô)@ÈÐW\ÐgkˆÑlÔlÐlØ�Š˜�n�n�n g¨gÔ&6¸tÈUÐ]aˆÑbÔbÐbð :AÀCÀÀÀÔ9M×9TÒ9TÑ9VÔ9V×9ZÒ9ZÑ9\Ô9\ˆÔ  EÐ!5Ð!5Ð!5Ñ6Ø6=À¸n¸n¸nÔ6M×6TÒ6TÑ6VÔ6V×6ZÒ6ZÑ6\Ô6\ˆÔ  EÐ!2Ð!2Ð!2Ñ3Ø6=À¸n¸n¸nÔ6M×6TÒ6TÑ6VÔ6V×6ZÒ6ZÑ6\Ô6\ˆÔ  EÐ!2Ð!2Ð!2Ñ3Ø3:¸7Ô3C×3JÒ3JÑ3LÔ3L×3PÒ3PÑ3RÔ3RˆÔ  E   Ñ0à+/×+LÒ+LÈWÐV_ÐafÐhkÐmtÑ+uÔ+uÑ(Ð˜LàÔ!ð 	eÝ(-¨g°jÔ.AÑ(BÔ(BˆGÐ$Ñ%Ý%*¨7°=Ô+AÑ%BÔ%BˆG�MÑ"Ø�MŠM˜UÐ3Ð3Ð3°W¸ZÔ5HÐQUÐ_dÐosˆMÑtÔtÐtØ�MŠM˜UÐ0Ð0Ð0°'¸-Ô2HÐQUÐ_dÐosˆMÑtÔtÐtØBIÈ*ÔBU×B\ÒB\ÑB^ÔB^×BbÒBbÑBdÔBdˆGÔ$¨Ð%>Ð%>Ð%>Ñ?Ø?FÀ}Ô?U×?\Ò?\Ñ?^Ô?^×?bÒ?bÑ?dÔ?dˆGÔ$¨Ð%;Ð%;Ð%;Ñ<ð !%× @Ò @ÀÈ)ÐUZÐ\dÑ eÔ eÑˆ
�IØ�Š�zÑ"Ô"Ð"ð ˜ÐÐ G¨IÔ$6Ô$;¸qÒ$@Ð$@Ý˜7‘m”mˆGØ!(¨Ô!3×!=Ò!=¸aÑ!@Ô!@ˆG�IÑÝ" 7™mœmð =ð =�
Ø 
Ô+�Ý˜e¥VÑ,Ô,ð =°´¸q²°À[ÐT^ÐE^ÐE^Ø*/¯/ª/¸!Ñ*<Ô*<�G˜JÑ'øð Ð:Ð: ¤Ð:Ð:Ð:ˆ	Ø&(ˆ	ØÔ&ð 	5¨9¸Ð+?Ð+?ÀIÐQXÐDXÐDXÝ # G¨IÔ$6¸À	Ô8JÑ KÔ Kð 5ð 5‘�˜"Ý+0°©9¬9�	�#˜h™-œ-Ñ(Ð(ð ×.Ò.Ø ¨E¸YÐR[Ðgpð /ñ 
ô 
ˆ	ð 	×"Ò" 7¨E°7¸IÑFÔFÐFØ×*Ò*¨5°)¸WÑEÔEÐEØ�EŠ>ˆ>Ð0ˆ>Ø×.Ò.¨y¸)ÀWÐX]ÐmsÐ.ÑtÔtÐtÐtØ�eŠ^ˆ^Ø×&Ò& yÑ1Ô1Ð1Ø�Š‰ŒˆØ×Ò˜UÑ#Ô#Ð#Ð#Ð#r&   c                ób   — |dk    rt          ¦   «         | _        dS t          ¦   «         | _        dS )z,Reset the F1 accumulator for a metric split.rÃ   N)r   r^   r]   )rj   rÅ   s     r$   r™  z COCOEvalCallback._reset_f1_local  s2   € à�GÒÐÝ#<Ñ#>Ô#>ˆDÔ Ð Ð å6Ñ8Ô8ˆDŒNˆNˆNr&   c                ór   — t          |dg ¦  «        D ]$}t          t          |dd¦  «        ¦  «        r|c S Œ%dS )z=Return the EMA callback instance, or ``None`` if not present.Ú	callbacksÚget_ema_model_state_dictN)r+   Úcallable)rj   rl   Úcallbacks      r$   rï   z"COCOEvalCallback._get_ema_callback  sM   € å ¨°bÑ9Ô9ð 	 ð 	 ˆHÝ� Ð*DÀdÑKÔKÑLÔLð  Ø���ð àˆtr&   údict[str, Any]c                óB  — t          |¦  «        s|                     ¦   «         }|S t          t          j        d¦  «        t          j        d¦  «        f}d„ |D ¦   «         }	 |D ]C}|                     ¦   «         t          j        k     r|                     t          j        ¦  «         ŒDt          j	        t          j        ¦   «         ¦  «        5  t          j        t          j        ¦   «         ¦  «        5  |                     ¦   «         }|cddd¦  «         cddd¦  «         |D ]\  }}|                     |¦  «         ŒS # 1 swxY w Y   ddd¦  «         n# 1 swxY w Y   |D ]\  }}|                     |¦  «         ŒdS # |D ]\  }}|                     |¦  «         Œw xY w)zeCompute a torchmetrics mAP metric while suppressing duplicate terminal summaries under progress bars.Úfaster_coco_evalzfaster_coco_eval.corec                ó    — g | ]}||j         f‘ŒS r{   )Úlevel)r™   Úmetric_loggers     r$   rá   z8COCOEvalCallback._compute_map_metric.<locals>.<listcomp>  s    € ÐdÐdÐdÀM˜M¨=Ô+>Ð?ÐdÐdÐdr&   N)r   Úcomputer"   ÚloggingÚ	getLoggerÚgetEffectiveLevelÚWARNINGÚsetLevelr1   Úredirect_stdoutÚioÚStringIOÚredirect_stderr)rj   rl   rÓ   ÚresultÚmetric_loggersÚprevious_levelsr°  Úprevious_levels           r$   r:  z$COCOEvalCallback._compute_map_metric  sP  € å  Ñ)Ô)ð 	Ø%+§^¢^Ñ%5Ô%5ˆFØˆMå ¥'Ô"3Ð4FÑ"GÔ"GÍÔIZÐ[rÑIsÔIsÐtˆØdÐdÐUcÐdÑdÔdˆð		7Ø!/ð <ð <�Ø ×2Ò2Ñ4Ô4µw´ÒFÐFØ!×*Ò*­7¬?Ñ;Ô;Ð;øÝÔ+­B¬K©M¬MÑ:Ô:ð ð ½JÔ<VÕWYÔWbÑWdÔWdÑ<eÔ<eð ð ØŸšÑ)Ô)�Øðð ð ð ñ ô ð ð ð ð ð ñ ô ð ð 2Að 7ð 7Ñ-�˜~Ø×&Ò& ~Ñ6Ô6Ð6Ð6ð7ð	ð ð ð øøøð ð ð ð ð ð ð ñ ô ð ð ð ð ð ð øøøð ð ð ð ð 2Að 7ð 7Ñ-�˜~Ø×&Ò& ~Ñ6Ô6Ð6Ð6ð7ð 7ø°ð 7ð 7Ñ-�˜~Ø×&Ò& ~Ñ6Ô6Ð6Ð6ð7øøøs[   Á!A+E? Ã&EÃ2D>ÄEÄE? Ä>E	ÅEÅE	ÅEÅ	E? ÅEÅE? ÅEÅE? Å?Fc                ó  — d| _         |                      |¦  «        €	d| _        dS | j        €:| j        rddgnd}t	          || j        dd| j        g| j        d¬¦  «        | _        dS | j                             ¦   «          dS )a:  Ensure ``map_metric_ema`` exists (and is reset) on EVERY rank when EMA is active.

        Driven by the rank-invariant presence of the EMA callback rather than by per-batch state, so any cross-rank
        state merge (via the metric adapter) is issued symmetrically across DDP ranks. Previously
        the metric was created lazily in :meth:`on_validation_batch_end`, so a rank with an empty/uneven shard could
        finish without it, skip the merge/compute path, and deadlock validation (#931 / #449).

        Args:
            trainer: The PTL Trainer.
        FNrs   rt   r?   ru   )rz   rv   rw   ry   rx   )	r_   rï   r   rc   r   rT   rP   rU   r®   )rj   rl   Úema_iou_types      r$   r±   z$COCOEvalCallback._prepare_ema_metric"  s¦   € ð !&ˆÔØ×!Ò! 'Ñ*Ô*Ð2Ø"&ˆDÔØˆFØÔÐ&Ø48Ô4JÐ V ¨Ð 0Ð 0ÐPVˆLÝ"AØ%Ø"Ô9Ø*+¨R°´Ð)@ØÔ*Ø %ð#ñ #ô #ˆDÔÐÐð Ô×%Ò%Ñ'Ô'Ð'Ð'Ð'r&   c                ó@  — | j         duo| j        }|rdnd}t          ¦   «         rlt          j        |gt          |dd¦  «        ¬¦  «        }t          j        |t          j        j	        ¬¦  «         t          |                     ¦   «         ¦  «        }t          |¦  «        S )uá  Decide â€” identically on every rank â€” whether to run the EMA metric ``compute()``.

        Under DDP, ``map_metric_ema.merge_distributed_state()`` issues cross-rank collectives that every rank must
        participate in, or none may â€” a rank that skips desynchronises the NCCL collective sequence and deadlocks
        validation (#931 / #449).  Each rank votes ``1`` only when its EMA metric exists and received at least
        one batch update this epoch; a cross-rank ``all_reduce(MIN)`` makes the decision unanimous â€” a single
        rank voting 0 suppresses EMA compute on all ranks.

        Args:
            pl_module: The LightningModule (provides the device for the reduction).

        Returns:
            ``True`` iff every rank both holds an EMA metric object and received at least one batch update this
            epoch, making ``compute()`` safe to run identically on all ranks; ``False`` otherwise (EMA compute
            skipped uniformly on all ranks).
        Nr?   r   ró   r=  rx  ry  )r   r_   r   rð   rn  r+   r|  r}  r~  ÚMINrB   rß   r   )rj   rm   Úhas_emar€  r�  s        r$   r8  z$COCOEvalCallback._should_compute_ema=  s’   € ð" Ô%¨TÐ1ÐK°dÔ6KˆØÐ"ˆqˆq ˆÝ(Ñ*Ô*ð 	$Ý”<  ­w°yÀ(ÈEÑ/RÔ/RÐSÑSÔSˆDÝŒO˜D¥T¤]Ô%6Ð7Ñ7Ô7Ð7Ý�t—y’y‘{”{Ñ#Ô#ˆDÝ�D‰zŒzÐr&   úMetricKeypointOKS | Nonec                ób  — || j         v r| j         |         S t          |dd¦  «        }|€dS |                     d¦  «        }ddddœ                     |d¦  «        }|D ]Q}t          ||d¦  «        }|€Œt	          |¦  «        }|€Œ(t          || j        | j        ¬	¦  «        }	|	| j         |<   |	c S dS )
a}  Return the :class:`~rfdetr.evaluation.keypoint_oks.MetricKeypointOKS` for *split*, creating it if needed.

        The metric is created lazily on first access per split and reused across epochs (state is reset
        at epoch boundaries via :meth:`_reset_keypoint_split`).

        Args:
            trainer: The PTL Trainer (provides access to the datamodule).
            split: One of ``"train"``, ``"val"``, ``"val_ema"``, or ``"test"``.

        Returns:
            A :class:`~rfdetr.evaluation.keypoint_oks.MetricKeypointOKS` bound to the split's COCO
            ground-truth, or ``None`` when no dataset is available.
        r¢   NÚ_ema)r�   )r‘   )r’   )rÃ   rª   r´   )r‘   r’   r�   )rF   rA   )re   r+   Úremovesuffixr   r   r   rf   rP   )
rj   rl   rÅ   r¢   Úsource_splitÚsplit_attrsr§   r¨   Úcoco_apirÓ   s
             r$   Ú"_get_or_create_keypoint_oks_metricz3COCOEvalCallback._get_or_create_keypoint_oks_metricV  sø   € ð �DÔ.Ð.Ð.ØÔ-¨eÔ4Ð4å˜W l°DÑ9Ô9ˆ
ØÐØ�4à×)Ò)¨&Ñ1Ô1ˆà(Ø$Ø&ð
ð 
÷ Š#ˆlÐOÑ
PÔ
Pð	 	ð
  ð 	ð 	ˆDÝ˜j¨$°Ñ5Ô5ˆGØˆØÝ0°Ñ9Ô9ˆHØÐØÝ&ØØ$(Ô$=Øœðñ ô ˆFð
 17ˆDÔ& uÑ-ØˆMˆMˆMØˆtr&   c                ój   — | j                              |¦  «        }|�|                     ¦   «          dS dS )z›Reset accumulated keypoint predictions for *split*.

        Args:
            split: One of ``"train"``, ``"val"``, ``"val_ema"``, or ``"test"``.
        N)re   r   r®   )rj   rÅ   rÓ   s      r$   r¯   z&COCOEvalCallback._reset_keypoint_split�  s9   € ð Ô+×/Ò/°Ñ6Ô6ˆØÐØ�LŠL‰NŒNˆNˆNˆNð Ðr&   úMapping[str, Any]c                ó  — | j         sdS |                      ||¦  «        }|€dS i }|d         }|d         }t          ||¦  «        D �]\  }}	|	                     d¦  «        }
|
€Œt	          j        |
¦  «        r!t          |
                     ¦   «         ¦  «        nt          |
¦  «        }d|vri ||<   Œl|d                              ¦   «          	                    ¦   «         |d                              ¦   «          	                    ¦   «         |d                              ¦   «          	                    ¦   «         |d                              ¦   «          	                    ¦   «         d	œ||<   �Œ |s|rdS | 
                    |¦  «         dS )
a"  Accumulate batch predictions into the keypoint OKS metric.

        Args:
            trainer: The PTL Trainer.
            outputs: Batch output dict with ``"results"`` and ``"targets"`` keys.
            split: Metric split (``"train"``, ``"val"``, ``"val_ema"``, or ``"test"``).
        Nr½   r¾   Úimage_idÚ	keypointsÚboxesÚscoresÚlabels)rÑ  rÒ  rÓ  rÐ  )rb   rË  rî   r   rð   Ú	is_tensorrB   rß   r<  r=  rÌ   )rj   rl   r·   rÅ   rÓ   Úpredictionsr½   r¾   r»  ÚtargetÚimage_id_tensorrÏ  s               r$   rÍ   z,COCOEvalCallback._update_keypoint_oks_metric‹  s“  € ð Ô"ð 	ØˆFà×8Ò8¸À%ÑHÔHˆØˆ>ØˆFà46ˆØ˜)Ô$ˆØ˜)Ô$ˆÝ! '¨7Ñ3Ô3ð 	ñ 	‰NˆF�FØ$Ÿjšj¨Ñ4Ô4ˆOØÐ&ØÝ6;´oÀoÑ6VÔ6VÐp•s˜?×/Ò/Ñ1Ô1Ñ2Ô2Ð2Õ\_Ð`oÑ\pÔ\pˆHØ &Ð(Ð(Ø(*�˜HÑ%Øà œ×/Ò/Ñ1Ô1×5Ò5Ñ7Ô7Ø  Ô*×1Ò1Ñ3Ô3×7Ò7Ñ9Ô9Ø  Ô*×1Ò1Ñ3Ô3×7Ò7Ñ9Ô9Ø# KÔ0×7Ò7Ñ9Ô9×=Ò=Ñ?Ô?ð	%ð %ˆK˜Ñ!Ñ!ð ð 	˜wð 	ØˆFØ�Š�kÑ"Ô"Ð"Ð"Ð"r&   r†  r‰  rŠ  ú
str | Noner‹  c          	     óV  — | j                              |¦  «        }| j        r|€dS |j        rdnd}t	          ¦   «         rlt          j        |gt          |dd¦  «        ¬¦  «        }t          j	        |t          j
        j        ¬¦  «         t          |                     ¦   «         ¦  «        }|sdS |€|n|}	 |                     ¦   «         }	t          j        dft          j        dft          j        d	ft          j        d	fd
œ}
|
                     ¦   «         D ]e\  }\  }}|	                     |d¦  «        }|dk     rŒ%|› d|› |› �}|                     |||dd	d¬¦  «         t          j        |¦  «        |j        |<   Œf	 |                     ¦   «          dS # |                     ¦   «          w xY w)aõ  Compute and log OKS keypoint AP/AR metrics when keypoint mode is active.

        Args:
            split: Internal metric split (``"val"``, ``"val_ema"``, ``"train"``, ``"test"``).
            pl_module: The LightningModule used to log scalar metrics.
            trainer: The PTL Trainer (provides ``callback_metrics``).
            log_split: Namespace prefix for logged keys. Defaults to *split*.
            metric_prefix: Optional string prepended to each metric name (e.g. ``"ema_"``).
        Nr?   r   ró   r=  rx  ry  TF)Úkeypoint_map_50_95Úkeypoint_map_50Úkeypoint_map_75Úkeypoint_mARg      ð¿rF  r/  )re   r   rb   r{  r   rð   rn  r+   r|  r}  r~  rÂ  rB   rß   r±  r   ÚMAPÚMAP_50ÚMAP_75ÚMARr¤   r;  r>  r®   )rj   rÅ   rm   rl   rŠ  r‹  rÓ   Úhas_updates_voter�  ÚstatsÚkeypoint_metricsrK  Ústat_keyr0  rM  Úlog_keys                   r$   r—  z.COCOEvalCallback._compute_and_log_keypoint_map²  sÏ  € ð$ Ô+×/Ò/°Ñ6Ô6ˆØÔ"ð 	 f nØˆFð
 !'Ô 2Ð9˜1˜1¸ÐÝ(Ñ*Ô*ð 	0Ý”<Ð!1Ð 2½7À9ÈhÐX]Ñ;^Ô;^Ð_Ñ_Ô_ˆDÝŒO˜D¥T¤]Ô%6Ð7Ñ7Ô7Ð7Ý" 4§9¢9¡;¤;Ñ/Ô/ÐØð 	ØˆFà&Ð.�E�E°Iˆ	ð	Ø—N’NÑ$Ô$ˆEå'-¤z°4Ð&8Ý$*¤M°4Ð#8Ý$*¤M°5Ð#9Ý!'¤¨UÐ 3ð	 ð  Ðð 6F×5KÒ5KÑ5MÔ5Mð Hð HÑ1�Ñ1˜h¨ØŸ	š	 (¨DÑ1Ô1�Ø˜1’9�9ØØ&ÐEÐE¨ÐE¸ÐEÐE�Ø—’˜g u°xÈÐV[Ðfj�ÑkÔkÐkÝ49´LÀÑ4GÔ4G�Ô(¨Ñ1Ð1ðHð �LŠL‰NŒNˆNˆNˆNøˆF�LŠL‰NŒNˆNˆNøøøs   Â6CF ÆF(r@  rŸ  údict[str, float]ro  údict[int, dict[str, float]]c	                ó*  — d|v r”|d         j         dk    rƒt          |¦  «        }|d                              d¦  «        |d<   t          |¦  «        D ]F}	||	         }
t	          |
t
          ¦  «        r'|
j         dk    rd|	v r|
                     d¦  «        ||	<   ŒGdt          ||› d�         ¦  «        dt          ||› d�         ¦  «        dt          ||› d	�         ¦  «        d
| j        › �t          ||         ¦  «        i}| j        r4d|v r0t          |d         ¦  «        |d<   t          |d         ¦  «        |d<   | 	                    |¦  «         |› d| j        › d�}i }| j
        rI||v rEd|v rAt          |d         ||         ¦  «        D ]$\  }}t          |¦  «        |t          |¦  «        <   Œ%|                      ||||||d¬¦  «        }|D ]-}|                     |› d|d         › �|d         ddd¬¦  «         Œ.|                      |d||¦  «         dS )uÓ  Print the Rich summary table from ``ema_metrics`` when it is the epoch's only track with data.

        The normal table/per-class path in :meth:`_compute_and_log` only ever reads from the base
        ``metric`` â€” when the base model is not evaluated that metric never accumulates a single update (see the
        early-return branch), so that path never runs and no table is ever printed for the entire run,
        even though ``map_metric_ema`` has real per-class data (built with the same ``class_metrics``
        setting as the base metric). Without this, fixing the logged scalars alone leaves the console
        table half of the original "no validation output at all" complaint (#1285) unfixed. Per-class AP is logged
        under both ``ema_`` and primary keys when this is the only validation track, keeping the default namespace
        complete while preserving the explicit EMA namespace.

        Args:
            trainer: The PTL Trainer.
            pl_module: The LightningModule.
            split: Metric namespace â€” ``"val"`` (the only split that reaches this method).
            pfx: torchmetrics key prefix (``"bbox_"`` when ``iou_type`` is a list, else ``""``).
            mar_key: Prefixed AR metric key for ``self._max_dets``.
            ema_metrics: Raw ``map_metric_ema.compute()`` output, from ``_compute_and_log_ema_metrics``.
            f1_overall: ``{"F1", "Precision", "Recall"}`` from ``_compute_and_log_f1_metrics``; not
                EMA-prefixed by existing design (see ``TrainConfig.eval_base_model`` docstring) since
                ``f1_local`` has no parallel EMA-tracked accumulator.
            f1_by_cid: Per-class F1/precision/recall keyed by ``category_id``, from the same call.
        r’  r   r“  rŒ  r.  r�  r3  rŽ  r5  r�  r6  r�  r7  r‘  r‡  r”  rˆ  )r•  r*  rÅ   rm   r–  ro  r‹  z/AP/r˜   ÚapTFr4  z	val (ema)N)r›  r|   rœ  r  rÇ   r	   rm  rP   rc   rÌ   rT   rî   rB   r�  r;  rž  )rj   rl   rm   rÅ   r*  r+  r@  rŸ  ro  r¡  rM  Úoverall_emar¢  r–  r£  r¤  Úper_class_emaÚrows                     r$   r˜  z(COCOEvalCallback._print_ema_only_summaryæ  sŒ  € ðD ˜Ð#Ð#¨°IÔ(>Ô(CÀqÒ(HÐ(HÝ˜{Ñ+Ô+ˆKØ%0°Ô%;×%EÒ%EÀaÑ%HÔ%HˆK˜	Ñ"Ý" ;Ñ/Ô/ð Að A�
Ø# JÔ/�Ý˜e¥VÑ,Ô,ð A°´¸q²°À[ÐT^ÐE^ÐE^Ø.3¯oªo¸aÑ.@Ô.@�K 
Ñ+øð �˜{¨c¨;¨;¨;Ô7Ñ8Ô8Ø•e˜K¨3¨¨¨Ô7Ñ8Ô8Ø•e˜K¨3¨¨¨Ô7Ñ8Ô8Ø$�D”NÐ$Ð$¥e¨K¸Ô,@Ñ&AÔ&Að	)
ˆð Ô!ð 	K j°KÐ&?Ð&?Ý,1°+¸jÔ2IÑ,JÔ,JˆKÐ(Ñ)Ý).¨{¸=Ô/IÑ)JÔ)JˆK˜Ñ&Ø×Ò˜:Ñ&Ô&Ð&àÐ:Ð: ¤Ð:Ð:Ð:ˆ	Ø&(ˆ	ØÔ&ð 	5¨9¸Ð+CÐ+CÈ	ÐU`ÐH`ÐH`Ý # K°	Ô$:¸KÈ	Ô<RÑ SÔ Sð 5ð 5‘�˜"Ý+0°©9¬9�	�#˜h™-œ-Ñ(Ð(à×2Ò2ØØØØØØØ ð 3ñ 
ô 
ˆð !ð 	mð 	mˆCØ�MŠM˜UÐ5Ð5¨¨F¬Ð5Ð5°s¸4´yÈÐW\ÐgkˆMÑlÔlÐlÐlØ×"Ò" 7¨K¸ÀmÑTÔTÐTÐTÐTr&   r•  r–  údict[int, float]úlist[dict[str, Any]]c                ó®  — g }| j         s|S |› d�}	|	|vsd|vr|S t          |d         ||	         ¦  «        D �]\  }
}t          |¦  «        }|                     t	          |
¦  «        t          d¦  «        ¦  «        }|dk     r||k    s|dk     rŒXt	          |
¦  «        }| j                             |t          |¦  «        ¦  «        }|                     |› d|› d|› �|¦  «         |||dœ}|                     |                     |t          d¦  «        t          d¦  «        t          d¦  «        dœ¦  «        ¦  «         | 	                    |¦  «         �Œ|S )	a8  Build per-class rows and emit per-class AP metrics.

        Args:
            metrics: Output of ``MeanAveragePrecision.compute()``.
            pfx: Key prefix for bbox metrics when segmentation mode is enabled.
            split: Metric namespace (``"val"`` or ``"test"``).
            pl_module: LightningModule used for metric logging.
            ar_by_cid: Per-class AR keyed by ``category_id``.
            f1_by_cid: Per-class F1/precision/recall keyed by ``category_id``.
            metric_prefix: Prepended to the logged key (``f"{split}/{metric_prefix}AP/{name}"``), e.g.
                ``"ema_"`` so per-class EMA AP (see ``_print_ema_only_summary``) never collides with
                the regular track's ``{split}/AP/{name}`` keys.

        Returns:
            Per-class rows for table rendering.
        Úmap_per_classr’  Únanr   rF  zAP/)r˜   rê  r¤  re  )
rT   rî   rm  r   rB   r\   ro   r;  rÌ   Úappend)rj   r•  r*  rÅ   rm   r–  ro  r‹  r“  Úpc_keyr£  rê  Úap_fÚar_fÚidxr˜   rí  s                    r$   r�  z&COCOEvalCallback._build_per_class_rows.  so  € ð4 +-ˆ	ØÔ*ð 	ØÐàÐ&Ð&Ð&ˆØ˜Ð Ð  I°WÐ$<Ð$<ØÐå ¨	Ô 2°G¸F´OÑDÔDð 
	"ñ 
	"‰LˆH�bÝ˜‘9”9ˆDØ—=’=¥ X¡¤µ°e±´Ñ=Ô=ˆDØ�aŠxˆx˜T Tš\˜\¨T°AªX¨XØÝ�h‘-”-ˆCØÔ'×+Ò+¨Cµ°S±´Ñ:Ô:ˆDØ�MŠM˜UÐ=Ð= ]Ð=Ð=°tÐ=Ð=¸rÑBÔBÐBØ+/°tÀ4Ð"HÐ"HˆCØ�JŠJ�y—}’} Sµ°u±´ÍEÐRWÉLÌLÕdiÐjoÑdpÔdpÐ*qÐ*qÑrÔrÑsÔsÐsØ×Ò˜SÑ!Ô!Ð!Ñ!ØÐr&   ru  r“  c                ó  — t          |dd¦  «        sdS t          st          | j        ¦  «        | _        dS t	          |¦  «        }t          t          |dd¦  «        ¦  «        dz   }t          |dd¦  «        }t          |t
          ¦  «        r|dk    r	d|› d	|› d
�nd|› d
�}|                     ¦   «         |z   }	t          |	|| j	        ¦  «        }
| j
        �r£| j        €²t          j        t          ¦  «        5  t          j        d¦  «        }t          j        d¦  «        }t#          t$          dt&          f         t          |d¦  «        ¦  «        }|                     ¦   «         | _         || j        ¦  «         ddd¦  «         n# 1 swxY w Y   | j        �N| j                             d¬¦  «         | j        5  t-          ||	|
|¦  «         ddd¦  «         n# 1 swxY w Y   dS t          j        t          ¦  «        5  t          j        d¦  «        }t#          t$          dt&          f         t          |d¦  «        ¦  «        } |d¬¦  «         ddd¦  «         n# 1 swxY w Y   t-          ||	|
|¦  «         dS t-          ||	|
|¦  «         dS )uz  Print two tables to the terminal: overall metrics and per-class metrics.

        The overall table is transposed (metrics as columns, one value row) with true merged group-header cells rendered
        via box-drawing characters: ``mAP`` spans sub-columns 50:95 / 50 / 75, ``mAR`` spans ``@N``, and ``F1 sweep``
        spans F1 / Prec / Recall.  The per-class table uses a standard Rich ``Table`` with columns for AP 50:95, AR, F1,
        Prec, Recall.

        Only runs on the global-zero rank to avoid duplicate output in DDP.

        Args:
            trainer: The PTL Trainer (used to check ``is_global_zero``).
            split: ``"val"`` or ``"test"``.
            overall: Ordered mapping of metric label â†’ scalar value.
            per_class: Per-class dicts with keys ``name``, ``ap``, ``ar``,
                ``f1``, ``precision``, ``recall``; skipped when empty.
        Úis_global_zeroTNr×   r   r?   rØ   z (Epoch rF  ú)Ú
ipywidgetszIPython.display.Údisplayr&  Úclear_output)r+   r   r%   r`   r   rB   rÇ   Ú
capitalizer   rP   ri   ra   r1   r2   r3   r4   r5   r   r   r   ÚOutputrý  r   )rj   rl   rÅ   ru  r“  Úconsoler×   rØ   Ú	epoch_sfxÚ	title_pfxÚoverall_renderedÚwidgetsÚipython_displayrü  rý  s                  r$   rž  z&COCOEvalCallback._print_metrics_tables]  sm  € õ. �wÐ 0°$Ñ7Ô7ð 	ØˆFÝ!ð 	Ý1HÈÔIkÑ1lÔ1lˆDÔ.ØˆFå# GÑ,Ô,ˆÝ�G G¨_¸aÑ@Ô@ÑAÔAÀAÑEˆÝ˜W l°DÑ9Ô9ˆ
õ ˜*¥cÑ*Ô*ð-Ø/9¸Aª~¨~ð 5�}Ð4Ð4 zÐ4Ð4Ð4Ð4à,˜MÐ,Ð,Ð,ð 	ð
 ×$Ò$Ñ&Ô&¨Ñ2ˆ	Ý1°)¸WÀdÄnÑUÔUÐàÔñ 	ð
 Ô"Ð*ÝÔ(­Ñ5Ô5ð 1ð 1Ý'Ô5°lÑCÔC�Gå&/Ô&=Ð>OÑ&PÔ&P�OÝ"¥8¨Cµ¨HÔ#5µw¸ÐPYÑ7ZÔ7ZÑ[Ô[�Gà*1¯.ª.Ñ*:Ô*:�DÔ'Ø�G˜DÔ/Ñ0Ô0Ð0ð1ð 1ð 1ñ 1ô 1ð 1ð 1ð 1ð 1ð 1ð 1øøøð 1ð 1ð 1ð 1ð Ô"Ð.ØÔ#×0Ò0°dÐ0Ñ;Ô;Ð;ØÔ(ð \ð \Ý*¨7°IÐ?OÐQZÑ[Ô[Ð[ð\ð \ð \ñ \ô \ð \ð \ð \ð \ð \ð \øøøð \ð \ð \ð \à�õ Ô$¥[Ñ1Ô1ð (ð (Ý"+Ô"9Ð:KÑ"LÔ"L�Ý#¥H¨Sµ#¨XÔ$6½ÀÐQ_Ñ8`Ô8`ÑaÔa�Ø� $Ð'Ñ'Ô'Ð'ð(ð (ð (ñ (ô (ð (ð (ð (ð (ð (ð (øøøð (ð (ð (ð (õ # 7¨IÐ7GÈÑSÔSÐSØˆFõ 	˜w¨	Ð3CÀYÑOÔOÐOÐOÐOs8   Ã6BFÆFÆFÆ8GÇGÇGÇ=AIÉIÉ!IrÎ   úlist[dict[str, Tensor]]c                óð   — g }|D ]p}t          |¦  «        }d|v rF|d         j        dk    r5|d         j        d         dk    r|d                              d¦  «        |d<   |                     |¦  «         Œq|S )až  Normalise prediction dicts from ``PostProcess`` for torchmetrics.

        ``PostProcess.forward`` returns masks with shape ``[K, 1, H, W]`` (the extra channel is introduced by
        ``F.interpolate`` which requires 4-D input).  Both ``torchmetrics.MeanAveragePrecision`` and
        ``engine.build_matching_data`` expect ``[K, H, W]``, so squeeze the channel dim when present.

        ``PostProcess.forward`` currently returns ``[K, 1, H, W]`` masks. Keep this callback-local squeeze for metric
        code paths because ``RFDETR.predict`` and other inference-facing callers still consume the 4-D representation
        and apply ``.squeeze(1)`` at their boundary.

        Args:
            preds: Raw per-image prediction dicts from ``PostProcess``.

        Returns:
            Per-image dicts with ``masks`` squeezed to ``[K, H, W]`` when applicable; all other keys are passed through
            unchanged.
        r¿   é   r?   )r|   r›  ÚshapeÚsqueezeró  )rj   rÎ   ÚoutÚpÚentrys        r$   rÉ   zCOCOEvalCallback._convert_preds©  sŒ   € ð$ ˆØð 	ð 	ˆAÝ˜‘G”GˆEØ˜%ÐÐ E¨'¤NÔ$7¸1Ò$<Ð$<ÀÀwÄÔAUÐVWÔAXÐ\]ÒA]ÐA]Ø!& w¤×!7Ò!7¸Ñ!:Ô!:��g‘Ø�JŠJ�uÑÔÐÐØˆ
r&   r¾   úlist[dict[str, Tensor]] | Nonec                ó  — |�Kt          |¦  «        t          |¦  «        k    s+J dt          |¦  «        › dt          |¦  «        › d�¦   «         ‚g }|r0t          j        d„ |D ¦   «         ¦  «                             ¦   «         ng }t	          |¦  «        D �]u\  }}||         \  }}|d                              ||||g¦  «        }	t          |d         ¦  «        |	z  }
|
|d         dœ}d	|v rú|d	                              ¦   «         }t          |¦  «        t          |¦  «        f}|�Gd	||         v r=||         d	         j	        }t          |d
         ¦  «        t          |d         ¦  «        f}|j	        d
d…         |k    rat          j        |                     ¦   «                              d¦  «        |d¬¦  «                             d¦  «                             ¦   «         }||d	<   d|v r|d         |d<   |                     |¦  «         �Œw|S )av  Convert targets from normalised CxCyWH to absolute xyxy boxes.

        Masks use each prediction's pixel grid when available, avoiding a lossy
        model-resolution -> original-resolution -> mask-head-resolution round trip.

        Args:
            targets: Per-image target dicts with ``boxes`` in normalised
                CxCyWH format and ``orig_size`` as ``[H, W]``.
            preds: Converted per-image predictions. Their mask shapes select the
                target mask grid during segmentation evaluation. When provided,
                ``preds`` must have the same length and order as ``targets``:
                the two are paired positionally 1:1 (``preds[i]`` describes the
                same image as ``targets[i]``).

        Returns:
            Per-image dicts with ``boxes`` in absolute xyxy, ``labels``, and optionally ``masks`` and ``iscrowd``.
        Nz7preds and targets must be positionally paired 1:1; got z
 preds vs z targetsc                ó   — g | ]
}|d          ‘ŒS ræ   r{   rè   s     r$   rá   z5COCOEvalCallback._convert_targets.<locals>.<listcomp>Þ  s   € Ð&GÐ&GÐ&G¸! q¨¤~Ð&GÐ&GÐ&Gr&   rÑ  rÓ  )rÑ  rÓ  r¿   éþÿÿÿéÿÿÿÿr?   Únearest)ÚsizeÚmodeÚiscrowd)rì   rð   rñ   Útolistr¥   Ú
new_tensorr   r   rB   r	  ÚFÚinterpolaterm  rœ  r
  ró  )rj   r¾   rÎ   r  Úorig_sizes_listÚindexré   ÚhÚwÚscalerÑ  r  r¿   Ú	mask_sizeÚpred_mask_shapes                  r$   rÊ   z!COCOEvalCallback._convert_targetsÃ  s!  € ð( ÐÝ�u‘:”:¥ W¡¤Ò-Ð-Ð-ØvÍ#ÈeÉ*Ì*ÐvÐvÕ`cÐdkÑ`lÔ`lÐvÐvÐvñ .Ô-Ð-ð ˆð V]Ðd�%œ+Ð&GÐ&G¸wÐ&GÑ&GÔ&GÑHÔH×OÒOÑQÔQÐQÐbdˆÝ! 'Ñ*Ô*ð 	ñ 	‰HˆE�1Ø" 5Ô)‰DˆAˆqØ�g”J×)Ò)¨1¨a°°A¨,Ñ7Ô7ˆEÝ& q¨¤zÑ2Ô2°UÑ:ˆEØ16À!ÀHÄ+Ð'NÐ'NˆEØ˜!ˆ|ˆ|Ø˜'œ
ŸšÑ)Ô)�Ý  ™VœV¥S¨¡V¤VÐ,�	ð Ð$¨°E¸%´LÐ)@Ð)@Ø&+¨E¤l°7Ô&;Ô&A�OÝ!$ _°RÔ%8Ñ!9Ô!9½3¸ÈrÔ?RÑ;SÔ;SÐ T�IØ”;˜r˜s˜sÔ# yÒ0Ð0åœØ!ŸKšK™MœM×3Ò3°AÑ6Ô6Ø!*Ø!*ðñ ô ÷
 !š ™œßš™œð ð "'��g‘Ø˜Aˆ~ˆ~Ø#$ Y¤<��iÑ Ø�JŠJ�uÑÔÐÑØˆ
r&   )rA   rB   rC   r   rD   rB   rE   r   rF   rG   rH   r9   r:   r9   r8   r9   rI   r   r    rJ   )rl   r   rm   r   rn   ro   r    rJ   )rl   r   rm   r   r    rJ   )rl   r   r    rJ   )rl   r   rm   r   r·   r   r¸   r   r¹   rB   r    rJ   )rl   r   r    r   )r   )rl   r   rm   r   r·   rÚ   r¸   r   r¹   rB   rÛ   rB   r    rJ   )r  r   r    rJ   )r  rB   rÛ   rB   r    r  )rm   r   r    rJ   )rl   r   rm   r   rÅ   ro   r*  ro   r+  ro   r    r,  )rl   r   rm   r   rÅ   ro   r    rJ   )
rl   r   rm   r   rÅ   ro   rO  rP  r    rQ  )rÓ   r   rm   r   r    r   )
rl   r   rm   r   rÅ   ro   rÓ   rƒ  r    rJ   )rÅ   ro   r    rJ   )rl   r   r    r   )rl   r   rÓ   r   r    r«  )rm   r   r    r   )rl   r   rÅ   ro   r    rÄ  )rl   r   r·   rÍ  rÅ   ro   r    rJ   )rÅ   ro   rm   r   rl   r   rŠ  rØ  r‹  ro   r    rJ   )rl   r   rm   r   rÅ   ro   r*  ro   r+  ro   r@  r«  rŸ  rç  ro  rè  r    rJ   )r†  )r•  r«  r*  ro   rÅ   ro   rm   r   r–  rî  ro  rè  r‹  ro   r    rï  )
rl   r   rÅ   ro   ru  rç  r“  rï  r    rJ   )rÎ   r  r    r  )N)r¾   r  rÎ   r  r    r  )-Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   rO   r�   rƒ   r‡   rŠ   r�   r…   r²   r¶   rÐ   rÕ   rÆ   r  r  r
  r  r°   rë   ÚstaticmethodrÈ   rA  rN  rv  r‚  rÔ   r™  rï   r:  r±   r8  rË  r¯   rÍ   r—  r˜  r�  rž  rÉ   rÊ   Ú__classcell__)rk   s   @r$   r>   r>   w   s÷  ø€ € € € € ð$ð $ðP 2Ø"ØØ&*Ø26Ø#'Ø%)Ø'+Ø(1ð1,ð 1,ð 1,ð 1,ð 1,ð 1,ð 1,ðn$(ð $(ð $(ð $(ðL#ð #ð #ð #ð+ð +ð +ð +ð/ð /ð /ð /ð/ð /ð /ð /ð"Uð "Uð "Uð "UðH*ð *ð *ð *ð*ð *ð *ð *ð&+Jð +Jð +Jð +JðZYð Yð Yð Yð&Ið Ið Ið Ið0  ðj)ð j)ð j)ð j)ð j)ðX9ð 9ð 9ð 9ð8  ð)Ið )Ið )Ið )Ið )IðV	:ð 	:ð 	:ð 	:ðgð gð gð gð0að að að að$ ð"ð "ð "ñ „\ð"ð"A/ð A/ð A/ð A/ðF lð  lð  lð  lðD2"ð 2"ð 2"ð 2"ðhð ð ð ð8 bfð U$ð U$ð U$ð U$ð U$ð U$ðn9ð 9ð 9ð 9ðð ð ð ð7ð 7ð 7ð 7ð&(ð (ð (ð (ð6ð ð ð ð2)ð )ð )ð )ðVð ð ð ð%#ð %#ð %#ð %#ðZ !%Øð2ð 2ð 2ð 2ð 2ð 2ðhFUð FUð FUð FUð`  ð-ð -ð -ð -ð -ð^JPð JPð JPð JPðXð ð ð ð6 Y]ð:ð :ð :ð :ð :ð :ð :ð :ð :r&   r>   )r   r   r    r   )r'   r   r    r   )r    r   )r8   r9   r:   r9   r    r   )@r%  Ú
__future__r   r1   r4   r¸  r²  rV   Úcollections.abcr   r   Útypingr   r   Únumpyrk  rð   Útorch.distributedÚdistributedr|  Útorch.nn.functionalÚnnÚ
functionalr  Úpytorch_lightningr   r	   Útorch.utils.datar
   Úrfdetr.configr   Úrfdetr.datasetsr   Úrfdetr.evaluation.f1_sweepr   Úrfdetr.evaluation.keypoint_oksr   r   r   Úrfdetr.evaluation.matchingr   r   r   r   Úrfdetr.training.coco_mapr   Úrfdetr.utilities.box_opsr   Úrfdetr.utilities.consoler   r   r   r   r   Úrfdetr.utilities.distributedr   Úrfdetr.utilities.loggerr   r"   r%   r-   r7   r<   r>   r{   r&   r$   ú<module>r=     sÌ  ðð EÐ Dà "Ð "Ð "Ð "Ð "Ð "à Ð Ð Ð Ø Ð Ð Ð Ø 	€	€	€	Ø €€€Ø €€€Ø -Ð -Ð -Ð -Ð -Ð -Ð -Ð -Ø Ð Ð Ð Ð Ð Ð Ð à Ð Ð Ð Ø €€€Ø  Ð  Ð  Ð  Ð  Ð  Ø Ð Ð Ð Ð Ð Ð Ð Ð Ø &Ð &Ð &Ð &Ð &Ð &Ø Ð Ð Ð Ð Ð Ø /Ð /Ð /Ð /Ð /Ð /à )Ð )Ð )Ð )Ð )Ð )Ø 5Ð 5Ð 5Ð 5Ð 5Ð 5Ø BÐ BÐ BÐ BÐ BÐ Bðð ð ð ð ð ð ð ð ð ð
ð ð ð ð ð ð ð ð ð ð ð ð EÐ DÐ DÐ DÐ DÐ DØ 7Ð 7Ð 7Ð 7Ð 7Ð 7ðð ð ð ð ð ð ð ð ð ð ð ð ð ð GÐ FÐ FÐ FÐ FÐ FØ .Ð .Ð .Ð .Ð .Ð .à	ˆ‰Œ€ðð ð ð ð1ð 1ð 1ð 1ð,ð ð ð ðð ð ð ð$Fð Fð Fð Fð F�xñ Fô Fð Fð Fð Fr&   