§
    ­¸jS½  ã                  ó„  — d Z ddlmZ ddlmZ ddlmZmZmZm	Z	 ddl
Z
ddl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 ddlmZ ddlmZ ddlmZmZ ddlmZ ddl m!Z! ddl"m#Z# ddl$m%Z%m&Z&  e#¦   «         Z'dZ(erddl)m*Z* dd„Z+d d„Z, G d„ de
j-        j.        j/        e         ¦  «        Z0 G d„ de¦  «        Z1dS )!zALightningDataModule for RF-DETR dataset construction and loaders.é    )Úannotations)ÚPath)ÚTYPE_CHECKINGÚAnyÚLiteralÚcastN)ÚLightningDataModule)Ú
DataLoader)Ú_namespace_from_configs)ÚAugmentationBackendÚModelConfigÚTrainConfig)Úbuild_dataset)Ú
AUG_CONFIG)ÚWebDatasetSplitUnavailableError)ÚWebDatasetDetectionÚbuild_webdataset_loader)ÚYoloSplitUnavailableError)Úbox_xyxy_to_cxcywh)Ú
get_logger)ÚPackedTargetsÚmake_collate_fné   )ÚFigureÚ	worker_idÚintÚreturnÚNonec                ó    — ddl }ddl}t          j        ¦   «         dz  }|j                              |¦  «         |                     |¦  «         dS )a@  Seed NumPy and the ``random`` module per DataLoader worker.

    PyTorch seeds ``torch``'s RNG per worker automatically but leaves NumPy and the stdlib ``random`` module unseeded,
    so without this hook every worker would draw identical NumPy/``random`` sequences (a well-known augmentation
    duplication footgun). Deriving the seed from ``torch.initial_seed()`` keeps augmentation reproducible while still
    giving each worker a distinct stream.

    Args:
        worker_id: Index of the DataLoader worker (unused; seed is derived from the per-worker torch seed).
    r   Nl        )ÚrandomÚnumpyÚtorchÚinitial_seedÚseed)r   r    Únpr$   s       úk/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/rfdetr/training/module_data.pyÚ_worker_init_fnr'   %   sX   € ð €M€M€MàÐÐÐåÔÑÔ 5Ñ)€DØ„I‡N‚N�4ÑÔÐØ
‡K‚K�ÑÔÐÐÐó    Úboolc                 óR   — ddl m}  t          | ¦  «                             d¦  «        S )zûReturn ``True`` when the runtime has a CUDA accelerator available.

    Uses the fork-safe global ``DEVICE`` constant instead of direct ``torch.cuda.is_available()`` calls to avoid
    creating a CUDA context in fork-based notebook/DDP workflows.
    r   ©ÚDEVICEÚcuda)Úrfdetr.configr,   ÚstrÚ
startswithr+   s    r&   Ú_has_cuda_devicer1   9   s0   € ð %Ð$Ð$Ð$Ð$Ð$åˆv‰;Œ;×!Ò! &Ñ)Ô)Ð)r(   c                  ó0   — e Zd ZdZ	 	 ddd„Zdd„Zdd„ZdS )ÚGradAccumAlignedDatasetuW  Dataset wrapper that pads length to a multiple of ``effective_batch_size * world_size``, optionally above a
    minimum.

    Workaround for https://github.com/Lightning-AI/pytorch-lightning/issues/19987: PTL fires the optimizer on partial
    accumulation windows at the tail of the dataset, causing the last optimizer step to be under-scaled.  Padding the
    dataset to a multiple of ``effective_batch_size * world_size`` ensures that ``drop_last=True`` on the DataLoader
    becomes a true no-op â€” every accumulation window is always complete.

    Padding indices are drawn randomly from the original dataset.  Because RF-DETR uses online augmentation, each padded
    sample receives a fresh random augmentation at ``__getitem__`` time, so it behaves like a new training example
    rather than a true duplicate.

    This wrapper can be removed once the upstream PTL issue is resolved.

    Args:
        dataset: The underlying dataset to wrap.
        effective_batch_size: ``batch_size * grad_accum_steps``.
        world_size: Number of DDP processes (default 1 for single-GPU/CPU).
            The alignment unit is ``effective_batch_size * world_size`` so that after PTL's ``DistributedSampler``
            splits samples across ranks each rank still receives an exact multiple of ``effective_batch_size``.
        minimum_length: Optional minimum padded length before alignment. This lets DDP repeat short datasets through a
            dataset wrapper that Lightning can safely partition instead of a replacement sampler that Lightning would
            discard when injecting ``DistributedSampler``.
    é   NÚdatasetútorch.utils.data.Dataset[Any]Úeffective_batch_sizer   Ú
world_sizeÚminimum_lengthú
int | Noner   r   c                óì  — |dk     rt          d|› �¦  «        ‚|dk     rt          d|› �¦  «        ‚|| _        t          |¦  «        | _        ||z  }t	          | j        |pd¦  «        }||||z  z
  |z  z   }|| j        z
  }t          j        ¦   «         }	|	                     d¦  «         |dk    r0t          j        d| j        |f|	¬¦  «         	                    ¦   «         ng | _
        | j        |z   | _        d S )Nr4   z'effective_batch_size must be >= 1, got zworld_size must be >= 1, got r   )Ú	generator)Ú
ValueErrorÚ_datasetÚlenÚ_dataset_lengthÚmaxr"   Ú	GeneratorÚmanual_seedÚrandintÚtolistÚ_pad_indicesÚ_length)
Úselfr5   r7   r8   r9   Úpad_unitÚtarget_lengthÚaligned_lengthÚ	pad_countÚpad_index_generators
             r&   Ú__init__z GradAccumAlignedDataset.__init__^   s%  € ð   !Ò#Ð#ÝÐ]ÐG[Ð]Ð]Ñ^Ô^Ð^Ø˜Š>ˆ>ÝÐI¸ZÐIÐIÑJÔJÐJàˆŒÝ" 7™|œ|ˆÔØ'¨*Ñ4ˆÝ˜DÔ0°.Ð2EÀAÑFÔFˆØ&¨(°]ÀXÑ5MÑ*MÐQYÑ)YÑYˆØ" TÔ%9Ñ9ˆ	Ý#œoÑ/Ô/ÐØ×'Ò'¨Ñ*Ô*Ð*ð ˜1Š}ˆ}õ ŒMØØÔ$Ø�Ø-ð	ñ ô ÷
 Šf‰hŒhˆhàð 	Ôð Ô+¨iÑ7ˆŒˆˆr(   c                ó   — | j         S )zKReturn the padded dataset length (always a multiple of the alignment unit).)rG   )rH   s    r&   Ú__len__zGradAccumAlignedDataset.__len__~   s
   € àŒ|Ðr(   Úidxr   c                ó`   — || j         k     r|n| j        || j         z
           }| j        |         S )z1Return the item at the (possibly remapped) index.)r@   rF   r>   )rH   rQ   Údataset_idxs      r&   Ú__getitem__z#GradAccumAlignedDataset.__getitem__‚   s8   € ð ! 4Ô#7Ò7Ð7�c�c¸TÔ=NÈsÐUYÔUiÑOiÔ=jˆØŒ}˜[Ô)Ð)r(   )r4   N)
r5   r6   r7   r   r8   r   r9   r:   r   r   ©r   r   )rQ   r   r   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__rN   rP   rT   © r(   r&   r3   r3   D   sh   € € € € € ðð ð: Ø%)ð8ð 8ð 8ð 8ð 8ð@ð ð ð ð*ð *ð *ð *ð *ð *r(   r3   c                  ó
  ‡ — e Zd ZdZd@ˆ fd„ZdAd„ZdBd„ZdCd„ZdCd„Ze	dDd„¦   «         Z
dEd„ZdCd„ZdFd„ZdFd „ZdFd!„ZdFd"„Z	 dGd$d%d&œdHd-„Ze	dIdJd1„¦   «         ZdKd2„Ze	dLd5„¦   «         ZdMd6„ZdNd:„ZedOd<„¦   «         ZdPd?„Zˆ xZS )QÚRFDETRDataModulea  LightningDataModule wrapping RF-DETR dataset construction and data loading.

    Args:
        model_config: Architecture configuration (used for resolution, patch_size, etc.).
        train_config: Training hyperparameter configuration (used for dataset params).
    Úmodel_configr   Útrain_configr   r   r   c           	     ór  •— t          ¦   «                              ¦   «          || _        || _        |j        |j        z  }|dk    r#t          d|› d|j        › d|j        › d�¦  «        ‚t          ||j        ¬¦  «        | _	        t          ||j        |j
        ¬¦  «        | _        d | _        d | _        d | _        d | _        d | _        d | _        d| _        | j        j        | _        dd	lm} t/          | j        j        ¦  «                             ¦   «         }|d
v }| j        j        €|dk    o|nt7          | j        j        ¦  «        | _        | j        j        €| j        dk    nt7          | j        j        ¦  «        | _        |  | j        dk    r!| j        j        �| j        j        nd| _         d S d | _         d S )Nr   z-Computed collate block_size must be > 0, got z from patch_size=z and num_windows=ú.)Ú
block_sizeÚpack)ra   rb   Úpad_targets_toFr+   >   ÚgpuÚautor-   r-   é   )!ÚsuperrN   r]   r^   Ú
patch_sizeÚnum_windowsr=   r   Úpack_targetsÚ_collate_fnrc   Ú_collate_fn_trainÚ_dataset_trainÚ_dataset_valÚ_dataset_testÚ_kornia_pipelineÚ_kornia_normalizeÚ_resolved_augmentation_backendÚ_kornia_setup_doneÚnum_workersÚ_num_workersr.   r,   r/   ÚacceleratorÚlowerÚ
pin_memoryr)   Ú_pin_memoryÚpersistent_workersÚ_persistent_workersÚprefetch_factorÚ_prefetch_factor)rH   r]   r^   ra   r,   rv   Úuses_cuda_acceleratorÚ	__class__s          €r&   rN   zRFDETRDataModule.__init__’   s%  ø€ Ý‰Œ×ÒÑÔÐØ(ˆÔØ(ˆÔð "Ô,¨|Ô/GÑGˆ
Ø˜Š?ˆ?Ýð?Øð?ð ?Ø0<Ô0Gð?ð ?à#/Ô#;ð?ð ?ð ?ñô ð õ
 +Ø!ØÔ*ð
ñ 
ô 
ˆÔõ "1Ø!ØÔ*Ø'Ô6ð"
ñ "
ô "
ˆÔð EIˆÔØBFˆÔØCGˆÔð -1ˆÔØ-1ˆÔð KOˆÔ+ð ).ˆÔà!%Ô!2Ô!>ˆÔð 	)Ð(Ð(Ð(Ð(Ð(å˜$Ô+Ô7Ñ8Ô8×>Ò>Ñ@Ô@ˆØ +Ð/FÐ FÐð Ô Ô+Ð3ð �vÒÐ7Ð"7øå�dÔ'Ô2Ñ3Ô3ð 	Ôð Ô Ô3Ð;ð Ô Ò!Ð!å�dÔ'Ô:Ñ;Ô;ð 	Ô ð
 	Ð)ØÔ˜qÒ Ð à59Ô5FÔ5VÐ5b�Ô!Ô1Ð1Ðhið Ô!Ð!Ð!ð %)ˆDÔ!Ð!Ð!r(   Ústager/   c                ó4  — | j         j        }t          | j         | j        ¦  «        }|dk    �rp| j        j        }| j         j        r$|t          j        ddfv rt          d|›d�¦  «        ‚ddl	m
}m}m}  ||t          ¦   «         ¬¦  «          ||t          ¦   «         ¬¦  «        }||k    r ||¦  «        rdnd	|_        |t          j        k    r|j        €t           |_        | j         j        r ||¦  «        rt          d|› d�¦  «        ‚| j        j        � ||¦  «        rt          d|› d�¦  «        ‚| j        €t'          d||¦  «        | _        | j        €t'          d||¦  «        | _        | j        s$|| _        |                      ¦   «          d| _        d
S d
S |dk    r!| j        €t'          d||¦  «        | _        d
S d
S |dk    r&| j        €|                      ||¦  «        | _        d
S d
S |dk    r| j        €t'          d||¦  «        | _        d
S d
S d
S )u†  Build datasets for the requested stage.

        PTL calls this on every process before the corresponding dataloader method.  Datasets are built lazily â€” a
        dataset is only constructed once even if ``setup`` is called multiple times.

        Args:
            stage: PTL stage identifier â€” one of ``"fit"``, ``"validate"``,
                ``"test"``, or ``"predict"``.
        ÚfitÚkorniard   zaugmentation_backend=z| does not support keypoint transforms. Set augmentation_backend='cpu' or 'albumentations' when use_grouppose_keypoints=True.r   )Úis_gpu_postprocessÚrequire_gpu_backend_readyÚresolve_augmentation_backend)Úhas_cudaÚcpuNzaugmentation_backend='z}' does not support keypoint transforms. Set augmentation_backend='cpu' or 'albumentations' when use_grouppose_keypoints=True.zj' does not support pad_targets_to. Set pad_targets_to=None or augmentation_backend='cpu'/'albumentations'.ÚtrainÚvalTÚvalidateÚtestÚpredict)r]   Ú
resolutionr   r^   Úaugmentation_backendÚuse_grouppose_keypointsr   ÚKORNIAr=   Ú!rfdetr.datasets.kornia_transformsr„   r…   r†   r1   ÚALBUÚ
aug_configr   rc   rm   r   rn   rs   rr   Ú_setup_kornia_pipelinero   Ú_build_test_dataset)	rH   r€   rŽ   ÚnsÚrequested_backendr„   r…   r†   Úresolveds	            r&   ÚsetupzRFDETRDataModule.setupÞ   s  € ð Ô&Ô1ˆ
Ý$ TÔ%6¸Ô8IÑJÔJˆØ�EŠ>‰>Ø $Ô 1Ô FÐð
 Ô Ô8ð Ð=NÝ#Ô*ØØðSð >ð >õ
 !ðlÐ,=ð lð lð lñô ð ðð ð ð ð ð ð ð ð ð ð &Ð%Ð&7ÕBRÑBTÔBTÐUÑUÔUÐUð 4Ð3Ð4EÕP`ÑPbÔPbÐcÑcÔcˆHØÐ,Ò,Ð,ð 7IÐ6HÈÑ6RÔ6RÐ*]¨(¨(ÐX]�Ô'àÕ.Ô3Ò3Ð3¸¼Ð8MÝ *�”ØÔ Ô8ð Ð=OÐ=OÐPXÑ=YÔ=Yð Ý ðl¨Xð lð lð lñô ð ð Ô Ô/Ð;Ð@RÐ@RÐS[Ñ@\Ô@\Ð;õ !ð^¨Xð ^ð ^ð ^ñô ð ð Ô"Ð*Ý&3°G¸RÀÑ&LÔ&L�Ô#ØÔ Ð(Ý$1°%¸¸ZÑ$HÔ$H�Ô!ð Ô*ð /Ø6>�Ô3Ø×+Ò+Ñ-Ô-Ð-Ø*.�Ô'Ð'Ð'ð/ð /ð �jÒ Ð ØÔ Ð(Ý$1°%¸¸ZÑ$HÔ$H�Ô!Ð!Ð!ð )Ð(à�fŠ_ˆ_ØÔ!Ð)Ø%)×%=Ò%=¸bÀ*Ñ%MÔ%M�Ô"Ð"Ð"ð *Ð)à�iÒÐØÔ Ð(Ý$1°%¸¸ZÑ$HÔ$H�Ô!Ð!Ð!ð  ÐØ(Ð(r(   r—   r   rŽ   r   r6   c                ó˜  — | j         j        }|dk    rG	 t          d||¦  «        S # t          $ r( t                               d| j         j        ¦  «         Y nw xY w|dv r]	 t          d||¦  «        S # t          $ r>}dddœ|         }t                               d|t          |¦  «        ¦  «         Y d}~nd}~ww xY wt          d	||¦  «        S )
uø  Build the dataset backing ``setup("test")``, preferring a real test split.

        ``roboflow`` and ``yolo`` datasets carry a labelled ``test`` split, so it is used directly.  A YOLO-format
        dataset is not required to declare one: a ``roboflow`` dataset whose detected format is YOLO-style routes
        through the same builder as ``dataset_file="yolo"`` (:func:`rfdetr.datasets.build_roboflow` ->
        ``build_roboflow_from_yolo``), and Roboflow's export UI does not require a test split any more than a
        hand-built YOLO dataset does. When that YOLO-style split cannot be resolved, the ``val`` split is used
        instead and the substitution is logged, because falling back silently reports validation numbers under
        the name "test".  A ``roboflow`` export in COCO format still has to ship ``test/_annotations.coco.json``:
        its absence raises a plain ``FileNotFoundError`` from the COCO builder, which this fallback does not catch.

        ``webdataset`` uses a packed ``test`` split when the shard directory has one, and falls back to ``val`` with a
        log line when it does not â€” a split is only present there if someone packed it deliberately, so evaluating
        ``val`` under the name "test" without saying so would be the same silent substitution.

        ``coco`` falls back to ``val`` because its ``test`` split is unlabelled COCO test-dev and cannot be scored
        locally.  ``o365`` also falls back because its dataset builder exposes only ``train`` and ``val`` splits.

        Args:
            ns: Merged model/train config namespace forwarded to :func:`build_dataset`.
            resolution: Target square resolution in pixels.

        Returns:
            The dataset to evaluate during the ``test`` stage.
        Ú
webdatasetrŒ   z@No 'test' shard index in %s; evaluating the 'val' split instead.)ÚroboflowÚyoloÚRoboflowÚYOLOzXNo resolvable 'test' split for this %s dataset (%s); evaluating the 'val' split instead.NrŠ   )	r^   Údataset_filer   r   ÚloggerÚwarningÚdataset_dirr   r/   )rH   r—   rŽ   r¡   ÚexcÚdataset_labels         r&   r–   z$RFDETRDataModule._build_test_dataset4  s   € ð4 Ô(Ô5ˆØ˜<Ò'Ð'ðÝ$ V¨R°Ñ<Ô<Ð<øÝ2ð ð ð Ý—’ØVØÔ%Ô1ñô ð ð ð ðøøøð
 Ð/Ð/Ð/ðÝ$ V¨R°Ñ<Ô<Ð<øÝ,ð ð ð Ø-7ÀÐ HÐ HÈÔ V�Ý—’ØnØ!Ý˜‘H”Hñô ð ð ð ð ð ð øøøøðøøøõ ˜U B¨
Ñ3Ô3Ð3s'   ”% ¥/AÁAÁA0 Á0
B8Á:4B3Â3B8c                óH   — | j         j        }|dk    rt          d¦  «        ‚|S )a‘  Return the concrete training batch size.

        Raises:
            RuntimeError: If ``train_config.batch_size == "auto"`` was never resolved. Auto-batch sizing
                probes the live model and is only performed by ``RFDETR.train()``
                (:func:`rfdetr.training.auto_batch.resolve_auto_batch_config`); the PTL CLI path does not
                resolve it automatically.
        re   zõtrain_config.batch_size='auto' was not resolved before dataloader construction. Auto-batch sizing requires probing the live model and is only performed by RFDETR.train(); set batch_size to a concrete integer when using the PTL CLI path directly.)r^   Ú
batch_sizeÚRuntimeError)rH   r¨   s     r&   Ú_resolve_batch_sizez$RFDETRDataModule._resolve_batch_sizec  s:   € ð Ô&Ô1ˆ
Ø˜ÒÐÝðmñô ð ð
 Ðr(   c                óJ   — | j         j        }|�|S |                      ¦   «         S )a¯  Return the batch size for the validation, test and predict dataloaders.

        An explicit ``train_config.eval_batch_size`` wins; ``None`` (the default) falls back to the resolved
        training batch size, preserving the historical behavior of tying eval batches to the train micro-batch.
        The explicit value is returned without consulting ``batch_size``, so it stays usable even on the
        ``batch_size="auto"`` path where :meth:`_resolve_batch_size` would raise.

        Raises:
            RuntimeError: If ``eval_batch_size`` is None and ``train_config.batch_size == "auto"`` was never
                resolved (propagated from :meth:`_resolve_batch_size`).
        )r^   Úeval_batch_sizerª   )rH   r¬   s     r&   Ú_resolve_eval_batch_sizez)RFDETRDataModule._resolve_eval_batch_sizeu  s-   € ð Ô+Ô;ˆØÐ&Ø"Ð"Ø×'Ò'Ñ)Ô)Ð)r(   r5   ú$torch.utils.data.Dataset[Any] | NoneÚsplitc                ó4   — | €t          |› d|›d�¦  «        ‚| S )z>Return *dataset*, raising if ``setup()`` has not built it yet.Nz# dataset was not built; call setup(z!) before requesting a dataloader.)r©   )r5   r¯   s     r&   Ú_require_datasetz!RFDETRDataModule._require_dataset†  s-   € ð ˆ?Ý %ÐvÐvÈEÐvÐvÐvÑwÔwÐwØˆr(   r   r¨   Úfixed_epochr)   úDataLoader[Any]c               ó.  — | j         rt          | j         dd¦  «        nd}| j         rt          | j         dd¦  «        nd}t          |||r| j        n| j        | j        | j        | j        | j        t          ||||r|  
                    ¦   «         nd¬¦  «        S )u©  Return the streaming loader for a WebDataset-backed split.

        A shard-streaming dataset carries its own shard-to-worker split, so it takes no sampler and no
        :class:`GradAccumAlignedDataset` wrapper; the fixed-length epoch that ``fixed_epoch`` requests is what plays
        the alignment role there â€” floored to a whole number of *accumulation windows* (``batch_size *
        grad_accum_steps``) for training, so PTL never fires the optimizer on a partial one
        (https://github.com/Lightning-AI/pytorch-lightning/issues/19987), the same guarantee
        :class:`GradAccumAlignedDataset` gives the map-style path. Collation, ``pin_memory`` and the worker knobs
        stay the ones configured for every other loader, so the batch reaching ``on_after_batch_transfer`` is
        indistinguishable from a map-style one.

        Args:
            dataset: The streaming dataset to wrap.
            batch_size: Per-rank micro-batch size.
            fixed_epoch: Plan a fixed-length epoch and drop partial batches (training), rather than passing over
                every sample exactly once (evaluation).

        Returns:
            The streaming DataLoader.
        r8   r4   Úglobal_rankr   )r¨   Ú
collate_fnrt   rx   rz   r|   Úworker_init_fnr²   r8   ÚrankÚgrad_accum_steps)ÚtrainerÚgetattrr   rl   rk   ru   ry   r{   r}   r'   Ú_effective_grad_accum_steps)rH   r5   r¨   r²   r8   r¸   s         r&   Ú_webdataset_loaderz#RFDETRDataModule._webdataset_loader�  s¶   € ð. EIÄLÐW�' $¤,°¸aÑ@Ô@Ð@ÐVWˆ
Ø?C¼|ÐR•G˜DœL¨-¸Ñ;Ô;Ð;ÐQRˆÝ&ØØ!ð 2=ÐR�tÔ-Ð-À$ÔBRØÔ)ØÔ'Ø#Ô7Ø Ô1Ý*Ø#Ø!ØØCNÐU˜T×=Ò=Ñ?Ô?Ð?ÐTUð
ñ 
ô 
ð 	
r(   c                óR   — | j         }|�| j        j        r| j        j        S |j        S )ap  Return the accumulation count that owns optimizer stepping for this training route.

        Keypoint models accumulate manually from ``TrainConfig`` while Lightning owns accumulation for detection and
        segmentation, including caller overrides passed directly to ``Trainer``.

        Returns:
            The number of microbatches per optimizer step.
        )rº   r]   r�   r^   r¹   Úaccumulate_grad_batches)rH   rº   s     r&   r¼   z,RFDETRDataModule._effective_grad_accum_steps¸  s/   € ð ”,ˆØˆ?˜dÔ/ÔGˆ?ØÔ$Ô5Ð5ØÔ.Ð.r(   c                óR  — |                       | j        d¦  «        }|                      ¦   «         }t          |t          ¦  «        r|                      ||d¬¦  «        S ||                      ¦   «         z  }| j        }| j        rt          | j        dd¦  «        nd}t          |¦  «        }|t          z  }||k     rz|dk    rtt                               d||¦  «         t          j        j                             |d|¬¦  «        }t%          |||| j        || j        | j        | j        t.          ¬¦	  «	        S ||z  }	d	}
|dk    r$||	k     rt                               d
||	¦  «         |	}
t1          ||||
¬¦  «        }t%          ||dd| j        || j        | j        | j        t.          ¬¦
  «
        S )a  Return the training DataLoader.

        On one process, uses a replacement sampler when the dataset is too small to fill ``_MIN_TRAIN_BATCHES``
        effective batches (matching legacy behaviour in ``main.py``). In DDP, repeats short datasets through
        :class:`GradAccumAlignedDataset` so that Lightning can safely inject ``DistributedSampler`` without discarding
        the requested sample count. The wrapper also ensures the length is an exact multiple of
        ``effective_batch_size * world_size`` (workaround for
        https://github.com/Lightning-AI/pytorch-lightning/issues/19987).

        Returns:
            DataLoader for the training dataset. With ``TrainConfig.pack_targets=True`` (the default), its collated
            batches contain ``PackedTargets`` for losslessly packable target batches. With
            ``TrainConfig.pad_targets_to`` set, every target is padded to that row count before packing, so a
            batch always packs (every sample already shares one shape) and every packed shape is fixed too.
        r‚   T©r¨   r²   r8   r4   zCTraining with uniform sampler because dataset is too small: %d < %d)ÚreplacementÚnum_samples)r¨   Úsamplerr¶   rt   rx   rz   r|   r·   NzHRepeating training samples because dataset is too small for DDP: %d < %d)r9   )	r¨   ÚshuffleÚ	drop_lastr¶   rt   rx   rz   r|   r·   )r±   rm   rª   Ú
isinstancer   r½   r¼   ru   rº   r»   r?   Ú_MIN_TRAIN_BATCHESr¢   Úinfor"   ÚutilsÚdataÚRandomSamplerr
   rl   ry   r{   r}   r'   r3   )rH   r5   r¨   r7   rt   r8   Údataset_lengthÚminimum_length_per_processrÄ   Úminimum_distributed_lengthr9   Úaligned_datasets               r&   Útrain_dataloaderz!RFDETRDataModule.train_dataloaderÆ  s  € ð  26×1FÒ1FÀtÔGZÐ\aÑ1bÔ1bˆØ×-Ò-Ñ/Ô/ˆ
Ý�gÕ2Ñ3Ô3ð 	]Ø×*Ò*¨7¸zÐW[Ð*Ñ\Ô\Ð\Ø)¨D×,LÒ,LÑ,NÔ,NÑNÐØÔ'ˆàDHÄLÐW�' $¤,°¸aÑ@Ô@Ð@ÐVWˆ
Ý˜W™œˆØ%9Õ<NÑ%NÐ"ØÐ6Ò6Ð6¸:Èº?¸?Ý�KŠKØUØØ*ñô ð õ
 ”kÔ&×4Ò4ØØ Ø6ð 5ñ ô ˆGõ
 ØØ%ØØÔ1Ø'ØÔ+Ø#'Ô#;Ø $Ô 5Ý.ð
ñ 
ô 
ð 
ð &@À*Ñ%LÐ"Ø%)ˆØ˜Š>ˆ>˜nÐ/IÒIÐIÝ�KŠKØZØØ*ñô ð ð
 8ˆNõ 2ØØ ØØ)ð	
ñ 
ô 
ˆõ ØØ!ØØØÔ-Ø#ØÔ'Ø#Ô7Ø Ô1Ý*ð
ñ 
ô 
ð 	
r(   c                óŒ  — |                       | j        d¦  «        }t          |t          ¦  «        r*|                      ||                      ¦   «         d¬¦  «        S t          ||                      ¦   «         t          j        j	         
                    |¦  «        d| j        | j        | j        | j        | j        t           ¬¦
  «
        S )a!  Return the validation DataLoader.

        Returns:
            DataLoader for the validation dataset with sequential sampling. With ``TrainConfig.pack_targets=True``
            (the default), its collated batches contain ``PackedTargets`` for losslessly packable target batches.
        r‹   FrÁ   ©	r¨   rÄ   rÆ   r¶   rt   rx   rz   r|   r·   ©r±   rn   rÇ   r   r½   r­   r
   r"   rÊ   rË   ÚSequentialSamplerrk   ru   ry   r{   r}   r'   ©rH   r5   s     r&   Úval_dataloaderzRFDETRDataModule.val_dataloader  s»   € ð ×'Ò'¨Ô(9¸:ÑFÔFˆÝ�gÕ2Ñ3Ô3ð 	sØ×*Ò*¨7¸t×?\Ò?\Ñ?^Ô?^ÐlqÐ*ÑrÔrÐrÝØØ×4Ò4Ñ6Ô6Ý”KÔ$×6Ò6°wÑ?Ô?ØØÔ'ØÔ)ØÔ'Ø#Ô7Ø Ô1Ý*ð
ñ 
ô 
ð 	
r(   c                óŒ  — |                       | j        d¦  «        }t          |t          ¦  «        r*|                      ||                      ¦   «         d¬¦  «        S t          ||                      ¦   «         t          j        j	         
                    |¦  «        d| j        | j        | j        | j        | j        t           ¬¦
  «
        S )a  Return the test DataLoader.

        Returns:
            DataLoader for the test dataset with sequential sampling. With ``TrainConfig.pack_targets=True`` (the
            default), its collated batches contain ``PackedTargets`` for losslessly packable target batches.
        rŒ   FrÁ   rÓ   )r±   ro   rÇ   r   r½   r­   r
   r"   rÊ   rË   rÕ   rk   ru   ry   r{   r}   r'   rÖ   s     r&   Útest_dataloaderz RFDETRDataModule.test_dataloader0  s»   € ð ×'Ò'¨Ô(:¸FÑCÔCˆÝ�gÕ2Ñ3Ô3ð 	sØ×*Ò*¨7¸t×?\Ò?\Ñ?^Ô?^ÐlqÐ*ÑrÔrÐrÝØØ×4Ò4Ñ6Ô6Ý”KÔ$×6Ò6°wÑ?Ô?ØØÔ'ØÔ)ØÔ'Ø#Ô7Ø Ô1Ý*ð
ñ 
ô 
ð 	
r(   c                óŒ  — |                       | j        d¦  «        }t          |t          ¦  «        r*|                      ||                      ¦   «         d¬¦  «        S t          ||                      ¦   «         t          j        j	         
                    |¦  «        d| j        | j        | j        | j        | j        t           ¬¦
  «
        S )aO  Return the predict DataLoader (reuses the validation dataset, no augmentation).

        Returns:
            DataLoader for the validation dataset with sequential sampling. With ``TrainConfig.pack_targets=True``
            (the default), its collated batches contain ``PackedTargets`` for losslessly packable target batches.
        r�   FrÁ   rÓ   rÔ   rÖ   s     r&   Úpredict_dataloaderz#RFDETRDataModule.predict_dataloaderG  s»   € ð ×'Ò'¨Ô(9¸9ÑEÔEˆÝ�gÕ2Ñ3Ô3ð 	sØ×*Ò*¨7¸t×?\Ò?\Ñ?^Ô?^ÐlqÐ*ÑrÔrÐrÝØØ×4Ò4Ñ6Ô6Ý”KÔ$×6Ò6°wÑ?Ô?ØØÔ'ØÔ)ØÔ'Ø#Ô7Ø Ô1Ý*ð
ñ 
ô 
ð 	
r(   r‰   é   N)ÚcolumnsÚfigure_sizeÚcountúLiteral['train', 'val', 'test']rÝ   rÞ   útuple[float, float] | Noneú'Figure'c          
     óÄ  ‡-— 	 ddl m} ddl}ddl}ddlm} n"# t          $ r}	t          d¦  «        |	‚d}	~	ww xY wddlm}
 |dk    rt          d|› d�¦  «        ‚|dk    rt          d|› d�¦  «        ‚|�Qt          |¦  «        dk    rt          d	|› d�¦  «        ‚|d         dk    s|d
         dk    rt          d|› d�¦  «        ‚|                      |¦  «        }|€t          d|›d�¦  «        ‚t          |t          ¦  «        rt          d¦  «        ‚|                     g d¢g d¢¬¦  «        }t          |¦  «        }t#          d
t%          ||¦  «        |z   d
z
  |z  ¦  «        }|                     |||p	d|z  d|z  f¬¦  «        \  }}|                     |t*          ¬¦  «                             d¦  «        }|D ]}|                     d¦  «         Œ| j        Š-t3          |t5          t%          ||¦  «        ¦  «        d¬¦  «        D �]Ä\  }}||         \  }}|                      ||¦  «        } ||¦  «        }|                     ¦   «                              ¦   «                              ¦   «         }|                     |                     |                      d
dd¦  «        dd¦  «        dz   !                    |j"        ¦  «        ¦  «        }| #                    d¦  «        }t          |tH          j%        ¦  «        r+tM          |d         ¦  «        tM          |d
         ¦  «        }}n4tM          |j'        d         ¦  «        tM          |j'        d         ¦  «        }}| #                    dtI          j(        dtH          j)        ¬¦  «        ¦  «        }| #                    d tI          j(        d!tH          j*        ¬¦  «        ¦  «        }| +                    ¦   «         dk    �r'tI          j,        ||||gtH          j)        ¬¦  «        } |
|                     ¦   «                              ¦   «         ¦  «        |z  } |                     ¦   «                              ¦   «                              ¦   «          !                    tL          ¦  «        }!| #                    d"¦  «        }"|"�P|" +                    ¦   «         dk    r8|"                     ¦   «                              ¦   «                              ¦   «         nd}#| -                    |                      ¦   «          !                    |j)        ¦  «        |!|#¬#¦  «        }$ˆ-fd$„|!D ¦   «         }%|#�)| .                    ¦   «          /                    ||$¬%¦  «        }| 0                    d
¬&¦  «         /                    ||$¬%¦  «        }| 1                    d'd¬(¦  «        }&te          |j3        th          |j5        th                   f         |& /                    te          th          |¦  «        |$|%¬)¦  «        ¦  «        }| #                    d*¦  «        }'|'��M|' +                    ¦   «         dk    �r4|'                     ¦   «                              ¦   «                              ¦   «          !                    |j)        ¦  «        }(|(d+dd…f         |                     ||g|j)        ¬¦  «        z  })|(d,         dk    }*| 6                    |)|* !                    |j)        ¦  «        |                     ¦   «                              ¦   «                              ¦   «          !                    tL          ¦  «        |*d-|*i¬.¦  «        }+| 7                    d/¬0¦  «         /                    ||+¬1¦  «        }| 8                    |¦  «         |�|j9        n|› d2|› d3�},| :                    |  ;                    |,¦  «        d4¬5¦  «         |                     d¦  «         �ŒÆ| <                    ¦   «          |S )6aø  Build a private diagnostic figure for transformed dataset samples.

        Samples the dataset after RF-DETR dataset transforms, so boxes and
        keypoints match the model input tensors rather than raw annotation JSON.

        Args:
            count: Maximum number of samples to render.
            split: Dataset split to visualize.
            columns: Number of subplot columns.
            figure_size: Optional Matplotlib figure size ``(width, height)`` in
                inches. When omitted, the size is derived from the grid shape.

        Returns:
            Matplotlib figure containing the annotated sample grid. When the
            dataset includes instance masks, they are rendered as coloured
            overlays before bounding boxes and labels.

        Raises:
            ValueError: If ``count`` or ``columns`` is not positive.

        Example:
            >>> # dm = RFDETRDataModule(model_config, train_config)
            >>> # figure = dm._show_samples(3, split="train")
        r   NzwRFDETRDataModule._show_samples() requires visualization dependencies. Install them with `pip install 'rfdetr[visual]'`.)Úbox_cxcywh_to_xyxyzcount must be positive, got r`   zcolumns must be positive, got rf   z)figure_size must contain two values, got r4   z)figure_size values must be positive, got zCould not build dataset split z for visualization.z¶Sample grids need a map-style dataset, and dataset_file='webdataset' streams shards instead. Point dataset_dir at the loose files the shards were packed from to visualize this split.)g:ÜŸ�wñ Àg’$I’$I ÀgŠgE#ßü¿)g!:ÜŸ�w@g·mÛ¶mÛ@grÇqÇ@)ÚmeanÚstdr   )Úfigsize)ÚdtypeéÿÿÿÿÚoffF)Ústrictg        g      ð?éÿ   ÚsizeéþÿÿÿÚboxes)r   é   Úlabels)r   Úmasks)ÚxyxyÚclass_idÚmaskc                óh   •— g | ].}‰�|t          ‰¦  «        k     r‰|         nt          |¦  «        ‘Œ/S )N)r?   r/   )Ú.0rô   Úclass_namess     €r&   ú
<listcomp>z2RFDETRDataModule._show_samples.<locals>.<listcomp>Å  sV   ø€ ð ð ð à ð .9Ð-DÈÕTWÐXcÑTdÔTdÒIdÐId�K Ô)Ð)ÕjmÐnvÑjwÔjwðð ð r(   )ÚsceneÚ
detections)Ú	thicknessgš™™™™™Ù?)Ú
text_scaleÚtext_padding)rú   rû   rñ   Ú	keypoints.).rf   Úvisible)ÚxyÚkeypoint_confidencerô   r   rË   rÜ   )Úradius)rú   Ú
key_pointsú[ú]é
   )Úfontsize)=Úmatplotlib.pyplotÚpyplotr!   ÚsupervisionÚtorchvision.transformsÚ
transformsÚImportErrorÚrfdetr.utilities.box_opsrä   r=   r?   Ú_get_dataset_for_visualizationr©   rÇ   r   Ú	TypeErrorÚ	NormalizerA   ÚminÚsubplotsÚasarrayÚobjectÚreshapeÚaxisrø   ÚzipÚrangeÚ_source_image_pathÚdetachrˆ   ÚascontiguousarrayÚclipÚ	transposeÚastypeÚuint8Úgetr"   ÚTensorr   ÚshapeÚzerosÚfloat32Úint64ÚnumelÚtensorÚ
DetectionsÚMaskAnnotatorÚannotateÚBoxAnnotatorÚLabelAnnotatorr   Úndarrayr   rè   Ú	KeyPointsÚVertexAnnotatorÚimshowÚnameÚ	set_titleÚ_ellipsize_sample_titleÚtight_layout).rH   rß   r¯   rÝ   rÞ   Úpltr%   ÚsvÚTÚerrrä   r5   Úinv_normalizerÍ   ÚrowsÚfigureÚaxesÚ
axes_arrayr  Úsample_indexÚimage_tensorÚtargetÚ
image_pathÚimageÚimage_arrayrú   rí   ÚheightÚwidthrï   rñ   Úscaleró   Ú	class_idsÚmasks_tensorÚ
mask_arrayrû   Úlabels_textÚlabel_annotatorrÿ   Úkeypoints_arrayÚkeypoint_xyÚkeypoint_visibilityr  Útitlerø   s.                                                @r&   Ú_show_sampleszRFDETRDataModule._show_samples^  sã  ø€ ð@		Ø+Ð+Ð+Ð+Ð+Ð+ØÐÐÐØ$Ð$Ð$Ð$Ø.Ð.Ð.Ð.Ð.Ð.Ð.øÝð 	ð 	ð 	ÝðDñô ð ðøøøøð	øøøð 	@Ð?Ð?Ð?Ð?Ð?à�AŠ:ˆ:ÝÐD¸EÐDÐDÐDÑEÔEÐEØ�aŠ<ˆ<ÝÐH¸gÐHÐHÐHÑIÔIÐIØÐ"Ý�;ÑÔ 1Ò$Ð$Ý Ð![È[Ð![Ð![Ð![Ñ\Ô\Ð\Ø˜1Œ~ Ò"Ð" k°!¤n¸Ò&9Ð&9Ý Ð![È[Ð![Ð![Ð![Ñ\Ô\Ð\à×5Ò5°eÑ<Ô<ˆØˆ?ÝÐ\ÀÐ\Ð\Ð\Ñ]Ô]Ð]Ý�gÕ2Ñ3Ô3ð 	åðlñô ð ð
 ŸšØAÐAÐAØ1Ð1Ð1ð $ñ 
ô 
ˆõ ˜W™œˆÝ�1•s˜5 .Ñ1Ô1°GÑ;¸aÑ?ÀGÑKÑLÔLˆØ—|’| D¨'¸;Ð;aÈ1ÈwÉ;ÐXYÐ\`ÑX`ÐJa�|ÑbÔb‰ˆ�Ø—Z’Z ­F�ZÑ3Ô3×;Ò;¸BÑ?Ô?ˆ
Øð 	ð 	ˆDØ�IŠI�eÑÔÐÐàÔ&ˆÝ"% jµ%½¸EÀ>Ñ8RÔ8RÑ2SÔ2SÐ\aÐ"bÑ"bÔ"bð >	ñ >	ÑˆD�,Ø#*¨<Ô#8Ñ ˆL˜&Ø×0Ò0°¸,ÑGÔGˆJØ!�M ,Ñ/Ô/ˆEØŸ,š,™.œ.×,Ò,Ñ.Ô.×4Ò4Ñ6Ô6ˆKØ×(Ò(¨"¯'ª'°+×2GÒ2GÈÈ1ÈaÑ2PÔ2PÐRUÐWZÑ*[Ô*[Ð^aÑ*a×)iÒ)iÐjlÔjrÑ)sÔ)sÑtÔtˆEà—:’:˜fÑ%Ô%ˆDÝ˜$¥¤Ñ-Ô-ð YÝ # D¨¤G¡¤­c°$°q´'©l¬l˜��å # LÔ$6°rÔ$:Ñ ;Ô ;½SÀÔASÐTVÔAWÑ=XÔ=X˜�à—J’J˜w­¬°FÅ%Ä-Ð(PÑ(PÔ(PÑQÔQˆEØ—Z’Z ­%¬+°dÅ%Ä+Ð*NÑ*NÔ*NÑOÔOˆFØ�{Š{‰}Œ}˜qÒ Ñ Ýœ e¨V°U¸FÐ%CÍ5Ì=ÐYÑYÔY�Ø)Ð)¨%¯,ª,©.¬.×*<Ò*<Ñ*>Ô*>Ñ?Ô?À%ÑG�Ø"ŸMšM™OœO×/Ò/Ñ1Ô1×7Ò7Ñ9Ô9×@Ò@ÅÑEÔE�	Ø%Ÿzšz¨'Ñ2Ô2�ð $Ð/°L×4FÒ4FÑ4HÔ4HÈ1Ò4LÐ4Lð !×'Ò'Ñ)Ô)×-Ò-Ñ/Ô/×5Ò5Ñ7Ô7Ð7àð ð
  Ÿ]š]°·
²
±´×0CÒ0CÀBÄJÑ0OÔ0OÐZcÐjt˜]ÑuÔu�
ðð ð ð à$-ðñ ô �ð Ð)Ø×,Ò,Ñ.Ô.×7Ò7¸eÐPZÐ7Ñ[Ô[�EØŸš°!˜Ñ4Ô4×=Ò=ÀEÐV`Ð=ÑaÔa�ð #%×"3Ò"3¸sÐQRÐ"3Ñ"SÔ"S�ÝØ”J�s B¤H­S¤MÐ1Ô2Ø#×,Ò,Ý"¥3¨Ñ.Ô.Ø#-Ø*ð -ñ ô ñô �ð Ÿ
š
 ;Ñ/Ô/ˆIØÑ$¨¯ªÑ):Ô):¸QÒ)>Ñ)>Ø"+×"2Ò"2Ñ"4Ô"4×"8Ò"8Ñ":Ô":×"@Ò"@Ñ"BÔ"B×"IÒ"IÈ"Ì*Ñ"UÔ"U�Ø-¨c°2°A°2¨gÔ6¸¿ºÀUÈFÀOÐ[]Ô[e¸Ñ9fÔ9fÑf�Ø&5°fÔ&=ÀÒ&AÐ#ØŸ\š\Ø"Ø(;×(BÒ(BÀ2Ä:Ñ(NÔ(NØ#Ÿ]š]™_œ_×0Ò0Ñ2Ô2×8Ò8Ñ:Ô:×AÒAÅ#ÑFÔFØ/Ø#Ð%8Ð9ð *ñ ô �
ð ×*Ò*°!Ð*Ñ4Ô4×=Ò=ÀEÐV`Ð=ÑaÔa�à�KŠK˜ÑÔÐØ'1Ð'=�J”O�OÀeÐC]ÐC]ÈlÐC]ÐC]ÐC]ˆEØ�NŠN˜4×7Ò7¸Ñ>Ô>ÈˆNÑLÔLÐLØ�IŠI�eÑÔÐÑà×ÒÑÔÐØˆs   ƒ ˜
7¢2²7é0   rQ  Ú
max_lengthc                ó®   — t          | ¦  «        |k    r| S |dk    rd|z  S t          d|dz
  dz  ¦  «        }|dz
  |z
  }| d|…         › d| | d…         › �S )a‚  Shorten long sample titles so subplot grids do not overflow.

        Args:
            title: Raw title text, usually an image file name.
            max_length: Maximum returned character count including the ellipsis.

        Returns:
            Original title when it already fits, otherwise a middle-ellipsized
            string that preserves the start and file suffix.
        rÜ   r`   r4   rf   Nz...)r?   rA   )rQ  rT  Ú	keep_leftÚ
keep_rights       r&   r5  z(RFDETRDataModule._ellipsize_sample_titleî  s|   € õ ˆu‰:Œ:˜Ò#Ð#ØˆLØ˜Š?ˆ?Ø˜Ñ#Ð#Ý˜˜J¨™N¨qÑ0Ñ1Ô1ˆ	Ø !‘^ iÑ/ˆ
Ø˜
˜˜
Ô#Ð=Ð=¨¨z¨k¨l¨lÔ(;Ð=Ð=Ð=r(   c                óô   — |dk    r|                       d¦  «         | j        S |dk    r|                       d¦  «         | j        S |dk    r|                       d¦  «         | j        S t	          d|›d�¦  «        ‚)z7Return a built dataset split for private visualization.r‰   r‚   rŠ   r‹   rŒ   zUnsupported split r`   )rš   rm   rn   ro   r=   )rH   r¯   s     r&   r  z/RFDETRDataModule._get_dataset_for_visualization  sŒ   € ð
 �GÒÐØ�JŠJ�uÑÔÐØÔ&Ð&Ø�EŠ>ˆ>Ø�JŠJ�zÑ"Ô"Ð"ØÔ$Ð$Ø�FŠ?ˆ?Ø�JŠJ�vÑÔÐØÔ%Ð%ÝÐ8¨eÐ8Ð8Ð8Ñ9Ô9Ð9r(   r@  úPath | Nonec                óî   — t          | dd¦  «        }t          | dd¦  «        }t          | dd¦  «        }|�|�|€dS ||         }|                     |¦  «        d         }t          |¦  «        |d         z  S )z:Return a source image path for common COCO-style datasets.ÚrootNÚidsÚcocor   Ú	file_name)r»   ÚloadImgsr   )r5   r@  Úimage_folderÚ	image_idsr]  Úimage_idÚ
image_infos          r&   r  z#RFDETRDataModule._source_image_path  sƒ   € õ ˜w¨°Ñ5Ô5ˆÝ˜G U¨DÑ1Ô1ˆ	Ý�w ¨Ñ-Ô-ˆØÐ 9Ð#4¸¸Ø�4Ø˜\Ô*ˆØ—]’] 8Ñ,Ô,¨QÔ/ˆ
Ý�LÑ!Ô! J¨{Ô$;Ñ;Ð;r(   c                óp  — ddl m} | j        }|� ||¦  «        sdS t          j                             ¦   «         st          d¦  «        ‚ddl m}m}  || j	        j
        �| j	        j
        nt          | j        j        d¬¦  «        | _         |¦   «         | _        t                                d|¦  «         dS )	aÃ  Build the Kornia pipeline for ``self._resolved_augmentation_backend``.

        ``TV`` and ``ALBU`` are no-ops.  ``KORNIA`` validates that kornia is installed then builds the pipeline on
        whatever device the batch arrives on.

        ``self._resolved_augmentation_backend`` (set by :meth:`setup` just before this call) is the concrete backend
        returned by :func:`rfdetr.datasets.kornia_transforms.resolve_augmentation_backend`.
        r   )r„   NzPKornia augmentation requires kornia. Install with: pip install 'rfdetr[augment]')Úbuild_kornia_pipelineÚbuild_normalizeT)Ú
with_masksz0Kornia augmentation pipeline built (resolved=%s))r’   r„   rr   r   r‘   Ú_is_availabler  re  rf  r^   r”   r   r]   rŽ   rp   rq   r¢   rÉ   )rH   r„   r™   re  rf  s        r&   r•   z'RFDETRDataModule._setup_kornia_pipeline  sç   € ð 	IÐHÐHÐHÐHÐHàÔ6ˆØÐÐ#5Ð#5°hÑ#?Ô#?ÐØˆFå"Ô)×7Ò7Ñ9Ô9ð 	rÝÐpÑqÔqÐqà\Ð\Ð\Ð\Ð\Ð\Ð\Ð\à 5Ð 5Ø,0Ô,=Ô,HÐ,TˆDÔÔ(Ð(ÕZdØÔÔ(àð	!
ñ !
ô !
ˆÔð "1 Ñ!2Ô!2ˆÔÝ�ŠÐFÈÑQÔQÐQÐQÐQr(   Úbatchútuple[Any, Any]Údataloader_idxc                ó"  — | j         }| j        }| j        �| j        j        r|�|€|S ddlm}m}m} ddlm	} |\  }	}
|	j
        }|                     |j        ¦  «         |                     |j        ¦  «          ||
|j        ¦  «        \  }}|	j        }|€=t          j        |j        d         g|j        dd…         ¢R t          j        |j        dœŽ}|                     d¦  «                             t          j        ¦  «        }| j        j        r¾|j        dd…         \  }} ||
|j        |j        d         ||¬¦  «        }t          j        ||fd¬	¦  «        } ||||¦  «        \  }}}|dd…d|j        d         …f         }|dd…|j        d         f         d
k    } ||¦  «        }|j        dd…         \  }} ||||
|||¬¦  «        }
nM ||||¦  «        \  }}}|dd…df         d
k    } ||¦  «        }|j        dd…         \  }} ||||
||¦  «        }
|j        dd…         \  }}|
D ]Q}|d         }|                     ¦   «         dk    rŒ#|                     ||||g¦  «        } t3          |¦  «        | z  |d<   ŒR |||¦  «        |
f}|S )a!  Apply Kornia GPU augmentation after the batch is transferred to device.

        When ``_kornia_pipeline`` is set and the trainer is in training mode, augmentation and normalization are applied
        on the GPU.  Validation and test batches pass through unchanged.

        The pipeline carries the ``NestedTensor`` padding mask with every batch, so geometric transforms keep valid
        image regions and padding aligned. Segmentation batches concatenate their instance masks before that final
        padding-mask channel, then split it back out before target unpacking.

        Args:
            batch: Tuple of ``(NestedTensor, list[dict])`` already on device.
            dataloader_idx: Index of the current dataloader.

        Returns:
            The (possibly augmented) batch.
        Nr   )Úcollate_boxesÚcollate_masksÚunpack_boxes)ÚNestedTensorrî   )rè   Údevicer4   )Ún_maxÚimage_heightÚimage_width)Údimg      à?)Ú	masks_augrï   )rp   rq   rº   Útrainingr’   rm  rn  ro  Úrfdetr.utilities.tensorsrp  ÚtensorsÚtorq  rõ   r"   r%  r$  r)   Ú	unsqueezer&  r]   Úsegmentation_headÚcatr(  Ú
new_tensorr   )!rH   ri  rk  Úkornia_pipelineÚkornia_normalizerm  rn  ro  rp  ÚsamplesÚtargetsÚimgÚboxes_paddedÚvalidÚpadding_maskÚpadding_masksrs  rt  Úmasks_paddedÚauxiliary_masksÚimg_augÚ	boxes_augÚauxiliary_masks_augrv  Úpadding_mask_augÚ
aug_heightÚ	aug_widthÚpadding_masks_augrF  rG  rB  rï   rH  s!                                    r&   Úon_after_batch_transferz(RFDETRDataModule.on_after_batch_transfer;  s/  € ð" Ô/ˆØÔ1ÐØŒ<Ð t¤|Ô'<ÐÀÐ@WÐ[kÐ[sØˆLà`Ð`Ð`Ð`Ð`Ð`Ð`Ð`Ð`Ð`Ø9Ð9Ð9Ð9Ð9Ð9à Ñˆ�ØŒoˆð 	×Ò˜3œ:Ñ&Ô&Ð&Ø×Ò˜CœJÑ'Ô'Ð'Ø+˜m¨G°S´ZÑ@Ô@Ñˆ�eØ”|ˆØÐÝ œ; s¤y°¤|Ðj°c´iÀÀÀ´nÐjÐjÍEÌJÐ_bÔ_iÐjÐjÐjˆLØ$×.Ò.¨qÑ1Ô1×4Ò4µU´]ÑCÔCˆàÔÔ.ð 	UØ(+¬	°"°#°#¬Ñ%ˆL˜+Ø(˜=Ø˜œ¨5¬;°q¬>ÈÐbmðñ ô ˆLõ $œi¨°}Ð(EÈ1ÐMÑMÔMˆOØ6E°oÀcÈ<ÐYhÑ6iÔ6iÑ3ˆG�YÐ 3Ø+¨A¨A¨AÐ/?°´¸Q´Ð/?Ð,?Ô@ˆIØ2°1°1°1°e´kÀ!´nÐ3DÔEÈÒKÐØ&Ð& wÑ/Ô/ˆGØ$+¤M°"°#°#Ô$6Ñ!ˆJ˜	Ø"�l 9¨e°W¸jÈ)Ð_hÐiÑiÔiˆGˆGà4C°OÀCÈÐWdÑ4eÔ4eÑ1ˆG�YÐ 1Ø0°°°°A°Ô6¸Ò<ÐØ&Ð& wÑ/Ô/ˆGØ$+¤M°"°#°#Ô$6Ñ!ˆJ˜	Ø"�l 9¨e°W¸jÈ)ÑTÔTˆGàœ b c cÔ*‰ˆ�Øð 	@ð 	@ˆFØ˜7”OˆEØ�{Š{‰}Œ} Ò!Ð!ØØ×$Ò$ e¨V°U¸FÐ%CÑDÔDˆEÝ0°Ñ7Ô7¸%Ñ?ˆF�7‰OˆOØ�˜gÐ'7Ñ8Ô8¸'ÐBˆØˆr(   úlist[str] | Nonec                ó|  ‡	— | j         | j        | j        fD �]$}|€Œt          |t          ¦  «        r|j        }|r|c S t          |dd¦  «        Š	‰	�ét          ‰	d¦  «        rÙt          |dd¦  «        }|€t          ‰	dd¦  «        }t          |t          ¦  «        rl|rjt          |¦  «        }dg|dz   z  }t          |                     ¦   «         ¦  «        D ],\  }}‰	j                             |¦  «        }|�|d         ||<   Œ-|c S ˆ	fd„t          ‰	j                             ¦   «         ¦  «        D ¦   «         c S �Œ&dS )	aa  Class names from the training or validation dataset annotation file.

        Reads category names from the first available COCO-style dataset. Returns ``None`` if no dataset has been set up
        yet or the dataset does not expose COCO-style category information.

        Returns:
            Sorted list of class name strings, or ``None``.
        Nr]  ÚcatsÚ	label2catÚ r4   r3  c                ó6   •— g | ]}‰j         |         d          ‘ŒS )r3  )r”  )r÷   Úkr]  s     €r&   rù   z0RFDETRDataModule.class_names.<locals>.<listcomp>¡  s$   ø€ ÐOÐOÐO°˜œ	 !œ VÔ,ÐOÐOÐOr(   )rm   rn   ro   rÇ   r   rø   r»   ÚhasattrÚdictrA   ÚsortedÚitemsr”  r"  Úkeys)
rH   r5   Ú	own_namesr•  Ú	max_labelÚnamesÚlabelÚcategory_idÚcategoryr]  s
            @r&   rø   zRFDETRDataModule.class_names�  sr  ø€ ð Ô+¨TÔ->ÀÔ@RÐSð 	Pñ 	PˆGØˆØõ ˜'Õ#6Ñ7Ô7ð %Ø#Ô/�	Øð %Ø$Ð$Ð$Ð$Ý˜7 F¨DÑ1Ô1ˆDØÐ¥G¨D°&Ñ$9Ô$9ÐÝ# G¨[¸$Ñ?Ô?�	ØÐ$Ý '¨¨k¸4Ñ @Ô @�IÝ˜i­Ñ.Ô.ð !°9ð !Ý # I¡¤�IØ˜D I°¡MÑ2�EÝ.4°Y·_²_Ñ5FÔ5FÑ.GÔ.Gð <ð <Ñ*˜˜{Ø#'¤9§=¢=°Ñ#=Ô#=˜Ø#Ð/Ø+3°FÔ+;˜E %™LøØ �L�L�LØOÐOÐOÐOµf¸T¼Y¿^º^Ñ=MÔ=MÑ6NÔ6NÐOÑOÔOÐOÐOÐOùØˆtr(   rq  útorch.devicec                óÔ   ‡‡— |\  }}‰j         dk    Š|                     ‰‰¬¦  «        }t          |t          ¦  «        r|                     ‰‰¬¦  «        }nˆˆfd„|D ¦   «         }||fS )a   Move a ``(NestedTensor, targets)`` batch to *device*.

        PTL's default iterates tuple elements and calls ``.to(device)``; that works for plain tensors but
        ``NestedTensor`` must be moved explicitly.

        Args:
            batch: Tuple of ``NestedTensor`` samples and targets that are either a collated ``PackedTargets`` object
                or an unpacked tuple of target dicts. Packed targets are materialized to a plain list of dicts after
                transfer.
            device: Target device.
            dataloader_idx: Index of the dataloader providing this batch.

        Returns:
            Batch with all tensors on ``device``.
        r-   ©Únon_blockingc                óR   •— g | ]#}ˆˆfd „|                      ¦   «         D ¦   «         ‘Œ$S )c                óF   •— i | ]\  }}||                      ‰‰¬ ¦  «        “ŒS )r¦  )rz  )r÷   r˜  Úvrq  r§  s      €€r&   ú
<dictcomp>zHRFDETRDataModule.transfer_batch_to_device.<locals>.<listcomp>.<dictcomp>¾  s/   ø€ ÐYÐYÐYÁtÀqÈ!˜˜1Ÿ4š4 °\˜4ÑBÔBÐYÐYÐYr(   )rœ  )r÷   Útrq  r§  s     €€r&   rù   z=RFDETRDataModule.transfer_batch_to_device.<locals>.<listcomp>¾  s:   ø€ ÐkÐkÐkÐ^_ÐYÐYÐYÐYÐYÈqÏwÊwÉyÌyÐYÑYÔYÐkÐkÐkr(   )Útyperz  rÇ   r   Úto_list)rH   ri  rq  rk  r�  r‚  r§  s     `   @r&   Útransfer_batch_to_devicez)RFDETRDataModule.transfer_batch_to_device¤  s…   øø€ ð$ !Ñˆ�Ø”{ fÒ,ˆØ—*’*˜V°,�*Ñ?Ô?ˆÝ�g�}Ñ-Ô-ð 	lð —o’o f¸<�oÑHÔHˆGˆGàkÐkÐkÐkÐkÐcjÐkÑkÔkˆGØ˜ÐÐr(   )r]   r   r^   r   r   r   )r€   r/   r   r   )r—   r   rŽ   r   r   r6   rU   )r5   r®   r¯   r/   r   r6   )r5   r   r¨   r   r²   r)   r   r³   )r   r³   )r‰   )
rß   r   r¯   rà   rÝ   r   rÞ   rá   r   râ   )rS  )rQ  r/   rT  r   r   r/   )r¯   rà   r   r®   )r5   r6   r@  r   r   rY  )r   r   )ri  rj  rk  r   r   rj  )r   r’  )ri  rj  rq  r¤  rk  r   r   rj  )rV   rW   rX   rY   rN   rš   r–   rª   r­   Ústaticmethodr±   r½   r¼   rÑ   r×   rÙ   rÛ   rR  r5  r  r  r•   r‘  Úpropertyrø   r¯  Ú__classcell__)r   s   @r&   r\   r\   Š   s=  ø€ € € € € ðð ðF)ð F)ð F)ð F)ð F)ð F)ðXTIð TIð TIð TIðl-4ð -4ð -4ð -4ð^ð ð ð ð$*ð *ð *ð *ð" ðð ð ñ „\ðð)
ð )
ð )
ð )
ðV/ð /ð /ð /ðQ
ð Q
ð Q
ð Q
ðf
ð 
ð 
ð 
ð.
ð 
ð 
ð 
ð.
ð 
ð 
ð 
ð4 29ðNð
 Ø26ðNð Nð Nð Nð Nð Nð` ð>ð >ð >ð >ñ „\ð>ð&:ð :ð :ð :ð  ð	<ð 	<ð 	<ñ „\ð	<ðRð Rð Rð Rð:@ð @ð @ð @ðL ð ð  ð  ñ „Xð ðD ð  ð  ð  ð  ð  ð  ð  r(   r\   )r   r   r   r   )r   r)   )2rY   Ú
__future__r   Úpathlibr   Útypingr   r   r   r   r"   Útorch.utils.dataÚpytorch_lightningr	   r
   Úrfdetr._namespacer   r.   r   r   r   Úrfdetr.datasetsr   Úrfdetr.datasets.aug_configsr   Ú rfdetr.datasets.webdataset.indexr   Úrfdetr.datasets.webdataset.loadr   r   Úrfdetr.datasets.yolor   r  r   Úrfdetr.utilities.loggerr   rx  r   r   r¢   rÈ   Úmatplotlib.figurer   r'   r1   rÊ   rË   ÚDatasetr3   r\   rZ   r(   r&   ú<module>rÁ     s-  ðð HÐ Gà "Ð "Ð "Ð "Ð "Ð "à Ð Ð Ð Ð Ð Ø 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4à €€€Ø Ð Ð Ð Ø 1Ð 1Ð 1Ð 1Ð 1Ð 1Ø 'Ð 'Ð 'Ð 'Ð 'Ð 'à 5Ð 5Ð 5Ð 5Ð 5Ð 5Ø GÐ GÐ GÐ GÐ GÐ GÐ GÐ GÐ GÐ GØ )Ð )Ð )Ð )Ð )Ð )Ø 2Ð 2Ð 2Ð 2Ð 2Ð 2Ø LÐ LÐ LÐ LÐ LÐ LØ XÐ XÐ XÐ XÐ XÐ XÐ XÐ XØ :Ð :Ð :Ð :Ð :Ð :Ø 7Ð 7Ð 7Ð 7Ð 7Ð 7Ø .Ð .Ð .Ð .Ð .Ð .Ø CÐ CÐ CÐ CÐ CÐ CÐ CÐ Cà	ˆ‰Œ€àÐ àð )Ø(Ð(Ð(Ð(Ð(Ð(ðð ð ð ð(*ð *ð *ð *ðC*ð C*ð C*ð C*ð C*˜eœkÔ.Ô6°sÔ;ñ C*ô C*ð C*ðLu ð u ð u ð u ð u Ð*ñ u ô u ð u ð u ð u r(   