§
    ­¸jÂV  ã                  ó¾   — d Z ddlmZ ddlZddlZddlmZ ddlmZm	Z	m
Z
 ddl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 erddlmZ  G d„ de¦  «        ZdS )zAExponential Moving Average callback compatible with ``ModelEma``.é    )ÚannotationsN)Údeepcopy)ÚTYPE_CHECKINGÚAnyÚcast)ÚCallbackÚLightningModuleÚTrainer)ÚTensor)Ú	Optimizer)ÚAveragedModel)ÚRemovableHandle)ÚRFDETRModelModulec                  óô   ‡ — e Zd ZdZ	 	 	 	 dDdEˆ fd„ZdFd„ZdGd„ZdHd„ZdId„ZdJd „Z	e
dKd"„¦   «         ZdLd%„ZdMd(„ZdNd+„ZdNd,„ZdNd-„ZdOd/„Z	 	 dPdQd4„ZdJd5„ZdRd:„ZdNd;„ZdNd<„ZdNd=„ZdSd?„ZdTd@„ZdUdA„ZdVdC„Zˆ xZS )WÚRFDETREMACallbackud  Exponential Moving Average with optional tau-based warm-up.

    Drop-in replacement for ``rfdetr.util.utils.ModelEma`` implemented as a plain Lightning callback around
    :class:`torch.optim.swa_utils.AveragedModel`. The ``_avg_fn`` reproduces the exact same formula as ``ModelEma``
    (1-indexed ``updates`` counter, optional ``tau`` warm-up).

    Args:
        decay: Base EMA decay factor. Corresponds to ``TrainConfig.ema_decay``.
        tau: Warm-up time constant (in optimizer steps). When > 0 the
            effective decay ramps from 0 towards *decay* following ``decay * (1 - exp(-updates / tau))``. Corresponds to
            ``TrainConfig.ema_tau``.
        use_buffers: Whether buffers are averaged in addition to parameters.
        update_interval_steps: Update EMA every N optimizer steps.

    Attributes:
        suppress_test_swap: When ``True`` the test-epoch hooks skip the EMA weight swap.  Set (and restored) by
            :class:`~rfdetr.training.callbacks.best_model.BestModelCallback` around its fit-end ``trainer.test()``
            run, which has already loaded the best checkpoint weights into the module â€” swapping in the final EMA
            weights there would make the reported ``test/*`` metrics reflect the wrong model.  Standalone
            ``trainer.test()`` runs keep the default ``False`` and evaluate EMA weights as before.
    ç-²�ï§Æï?éd   Té   ÚdecayÚfloatÚtauÚintÚuse_buffersÚboolÚupdate_interval_stepsÚreturnÚNonec                ó
  •— t          ¦   «                              ¦   «          || _        || _        || _        t          dt          |¦  «        ¦  «        | _        d| _        d | _	        d| _
        d | _        d | _        d | _        d S )Nr   Fr   )ÚsuperÚ__init__Ú_decayÚ_tauÚ_use_buffersÚmaxr   Ú_update_interval_stepsÚsuppress_test_swapÚ_average_modelÚ_latest_update_stepÚ_swapped_state_dictÚ_pending_average_state_dictÚ_xla_optimizer_hook)Úselfr   r   r   r   Ú	__class__s        €úm/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/rfdetr/training/callbacks/ema.pyr    zRFDETREMACallback.__init__1   s‚   ø€ õ 	‰Œ×ÒÑÔÐØˆŒØˆŒ	Ø'ˆÔÝ&)¨!­SÐ1FÑ-GÔ-GÑ&HÔ&HˆÔ#Ø"'ˆÔà48ˆÔØ#$ˆÔ Ø:>ˆÔ ØBFˆÔ(Ø;?ˆÔ Ð Ð ó    Úaveraged_paramr   Úmodel_paramÚnum_averagedúTensor | intc                ó¸   — t          |t          ¦  «        r|                     ¦   «         n|}|                      t	          |¦  «        ¦  «        }||z  |d|z
  z  z   S )aè  Compute the EMA update for a single parameter tensor.

        Matches the ``ModelEma`` formula where ``updates`` is 1-indexed: PTL's ``num_averaged`` starts at 0 (incremented
        *after* calling ``avg_fn``), so ``updates = num_averaged + 1`` reproduces the same sequence of effective decay
        values.

        Args:
            averaged_param: Current EMA parameter value.
            model_param: Corresponding live model parameter value.
            num_averaged: Number of models averaged so far (0-indexed). ``AveragedModel`` always passes this as a
                0-dim tensor; the ``int`` branch only matches the declared ``torch.optim.swa_utils`` signature.

        Returns:
            Updated EMA parameter tensor.
        ç      ð?)Ú
isinstancer   ÚitemÚ_effective_decayr   )r,   r0   r1   r2   Únum_averaged_valueÚeffective_decays         r.   Ú_avg_fnzRFDETREMACallback._avg_fnG   sa   € õ* 5?¸|ÍVÑ4TÔ4TÐf˜\×.Ò.Ñ0Ô0Ð0ÐZfÐØ×/Ò/µÐ4FÑ0GÔ0GÑHÔHˆØ Ñ/°+ÀÀÑAVÑ2WÑWÐWr/   c                ó€   — |dz   }| j         dk    r(| j        dt          j        | | j         z  ¦  «        z
  z  S | j        S )zöReturn the effective decay for the given 0-indexed average counter.

        Args:
            num_averaged: Number of models averaged so far (0-indexed).

        Returns:
            Effective decay after the optional tau warm-up ramp.
        r   r   )r"   r!   ÚmathÚexp)r,   r2   Úupdatess      r.   r8   z"RFDETREMACallback._effective_decay`   sF   € ð  Ñ"ˆØŒ9�qŠ=ˆ=Ø”; !¥d¤h°¨x¸$¼)Ñ/CÑ&DÔ&DÑ"DÑEÐEØŒ{Ðr/   Úaveraged_paramsú!tuple[Tensor, ...] | list[Tensor]Úmodel_paramsc                óš  — |sdS |                       ||d         j        j        ¦  «        }|                      |¦  «        }|d                              ¦   «         sBt          ||¦  «        D ]/\  }}|                     |                      |||¦  «        ¦  «         Œ0dS t          j	        ||¦  «         t          j
        ||d|z
  ¬¦  «         dS )uV  Update a (device, dtype) group of EMA tensors in-place via foreach kernels.

        ``AveragedModel.update_parameters`` routes to this grouped path when ``multi_avg_fn`` is set, replacing the
        per-tensor ``avg_fn`` loop that performed one ``num_averaged.item()`` deviceâ†’CPU sync *per tensor* per step with
        a single sync per eager-device group and a host counter on XLA. The float path applies
        ``ema * decay + model * (1 - decay)``, numerically equivalent within floating-point tolerance to ``_avg_fn``
        (``torch._foreach_add_(..., alpha=)`` may lower to an FMA instruction, so the result can differ from separate
        mul-then-add by ~1 ULP); non-floating-point groups (e.g. integer buffers when averaging buffers) fall back to
        the per-tensor formula to preserve its cast semantics.

        Args:
            averaged_params: EMA tensors of one device/dtype group, updated in-place.
            model_params: Matching live model tensors.
            num_averaged: Number of models averaged so far (0-indexed); passed by ``AveragedModel`` as a 0-dim tensor.
        Nr   r5   )Úalpha)Ú_num_averaged_valueÚdeviceÚtyper8   Úis_floating_pointÚzipÚcopy_r;   ÚtorchÚ_foreach_mul_Ú_foreach_add_)r,   r@   rB   r2   r9   r:   r0   r1   s           r.   Ú_multi_avg_fnzRFDETREMACallback._multi_avg_fnn   så   € ð* ð 	ØˆFØ!×5Ò5°lÀOÐTUÔDVÔD]ÔDbÑcÔcÐØ×/Ò/Ð0BÑCÔCˆØ˜qÔ!×3Ò3Ñ5Ô5ð 	Ý/2°?ÀLÑ/QÔ/Qð dð dÑ+� Ø×$Ò$ T§\¢\°.À+ÐOaÑ%bÔ%bÑcÔcÐcÐcØˆFõ 	Ô˜O¨_Ñ=Ô=Ð=ÝÔ˜O¨\ÀÀÑAVÐWÑWÔWÐWÐWÐWr/   Údevice_typeÚstrc                ó  — |dk    rA| j         €t          d¦  «        ‚t          | j         j                             ¦   «         ¦  «        S t          |t          ¦  «        r!t          |                     ¦   «         ¦  «        nt          |¦  «        S )a‘  Read the EMA counter without materializing a lazy XLA scalar.

        Args:
            num_averaged: Per-device counter supplied by ``AveragedModel``.
            device_type: Device type of the parameter group being averaged.

        Returns:
            Number of completed EMA updates.

        Raises:
            RuntimeError: If XLA averaging starts before the averaged model exists.
        ÚxlaNzDXLA EMA averaging started before the averaged model was initialized.)r'   ÚRuntimeErrorr   Ú
n_averagedr7   r6   r   )r,   r2   rO   s      r.   rE   z%RFDETREMACallback._num_averaged_value‘   s   € ð ˜%ÒÐØÔ"Ð*Ý"Ð#iÑjÔjÐjÝ�tÔ*Ô5×:Ò:Ñ<Ô<Ñ=Ô=Ð=Ý+5°lÅFÑ+KÔ+KÐb�s�<×$Ò$Ñ&Ô&Ñ'Ô'Ð'ÕQTÐUaÑQbÔQbÐbr/   Ú	pl_moduler	   c                óV  ‡ — ‰ j         €dS ‰ j        �)‰                      ‰ j         ‰ j        ¦  «         d‰ _        dS t          |d¦  «        sdS |j        }t          |t          ¦  «        r°t          d‰ j         j        ¦  «        }|j	         
                    ‰                      |¦  «        d¬¦  «        }ˆ fd„|j        D ¦   «         }ˆ fd„|j        D ¦   «         }|s|r=t          j        dt!          |¦  «        › d	t!          |¦  «        › d
�t"          d¬¦  «         t%          |d¦  «         dS )a9  Restore a callback or legacy EMA state after constructing the averaged model.

        Current callback state takes precedence over the legacy model-only state
        when a checkpoint supplies both formats.

        Args:
            pl_module: The live module that may hold a stashed legacy EMA state.
        NÚ_pending_legacy_ema_stater   F©Ústrictc                ó>   •— g | ]}‰                      |¦  «        °|‘ŒS © ©Ú_is_extra_state_key©Ú.0Úkeyr,   s     €r.   ú
<listcomp>zDRFDETREMACallback._restore_pending_average_state.<locals>.<listcomp>¼   s-   ø€ ÐjÐjÐj CÈD×LdÒLdÐehÑLiÔLiÐj˜CÐjÐjÐjr/   c                ó>   •— g | ]}‰                      |¦  «        °|‘ŒS r[   r\   r^   s     €r.   ra   zDRFDETREMACallback._restore_pending_average_state.<locals>.<listcomp>½   s.   ø€ ÐpÐpÐp sÐRV×RjÒRjÐknÑRoÔRoÐp˜sÐpÐpÐpr/   z?Legacy EMA checkpoint loaded with non-exact key match; missing=z unexpected=ú.é   )Ú
stacklevel)r'   r*   Ú_load_ema_weightsÚhasattrrW   r6   Údictr   ÚmoduleÚmodelÚload_state_dictÚ_without_extra_stateÚmissing_keysÚunexpected_keysÚwarningsÚwarnÚlenÚUserWarningÚdelattr)r,   rU   Úlegacy_ema_stateÚaverage_moduleÚincompatiblerm   rn   s   `      r.   Ú_restore_pending_average_statez0RFDETREMACallback._restore_pending_average_state¤   sy  ø€ ð ÔÐ&ØˆFØÔ+Ð7Ø×"Ò" 4Ô#6¸Ô8XÑYÔYÐYØ/3ˆDÔ,ØˆFÝ�yÐ"=Ñ>Ô>ð 	ØˆFà$Ô>ÐÝÐ&­Ñ-Ô-ð 	Ý!Ð"5°tÔ7JÔ7QÑRÔRˆNØ)Ô/×?Ò?Ø×)Ò)Ð*:Ñ;Ô;ÀEð @ñ ô ˆLð kÐjÐjÐj¨<Ô+DÐjÑjÔjˆLØpÐpÐpÐp¨lÔ.JÐpÑpÔpˆOØð ˜ð Ý”ð:Ý" <Ñ0Ô0ð:ð :å"% oÑ"6Ô"6ð:ð :ð :õ  Ø ðñ ô ð õ 	�	Ð6Ñ7Ô7Ð7Ð7Ð7r/   r`   c                óD   — |                       dd¬¦  «        d         dk    S )zæReturn whether *key* identifies a module extra-state payload.

        Args:
            key: Fully qualified state-dict key.

        Returns:
            ``True`` only when the final key component is ``"_extra_state"``.
        rc   r   )ÚmaxsplitéÿÿÿÿÚ_extra_state)Úrsplit)r`   s    r.   r]   z%RFDETREMACallback._is_extra_state_keyÈ   s$   € ð �zŠz˜#¨ˆzÑ*Ô*¨2Ô.°.Ò@Ð@r/   Ú
state_dictúdict[str, Any]c                ó¬   ‡ — ˆ fd„|D ¦   «         }|s|S |                      ¦   «         }|D ]}||= Œt          |dd¦  «        }|�t          |d|¦  «         |S )aK  Return *state_dict* without module extra-state entries or metadata loss.

        Args:
            state_dict: Source module state dictionary.

        Returns:
            The original state dictionary when no extra state exists, otherwise a
            metadata-preserving shallow copy without ``_extra_state`` entries.
        c                ó>   •— g | ]}‰                      |¦  «        ¯|‘ŒS r[   r\   r^   s     €r.   ra   z:RFDETREMACallback._without_extra_state.<locals>.<listcomp>Þ   s-   ø€ ÐWÐWÐW C¸×9QÒ9QÐRUÑ9VÔ9VÐW˜CÐWÐWÐWr/   Ú	_metadataN)ÚcopyÚgetattrÚsetattr)r,   r}   Úextra_state_keysÚfiltered_state_dictr`   Úmetadatas   `     r.   rl   z&RFDETREMACallback._without_extra_stateÔ   sˆ   ø€ ð XÐWÐWÐW¨:ÐWÑWÔWÐØð 	ØÐà(ŸošoÑ/Ô/ÐØ#ð 	)ð 	)ˆCØ# CÐ(Ð(Ý˜: {°DÑ9Ô9ˆØÐÝÐ'¨°hÑ?Ô?Ð?Ø"Ð"r/   ri   útorch.nn.Modulec                óú  ‡ — |                      ‰                      |¦  «        d¬¦  «        }ˆ fd„|j        D ¦   «         }ˆ fd„|j        D ¦   «         }|s|sdS g }|r6|                     dd                     d„ |D ¦   «         ¦  «        › d	�¦  «         |r6|                     d
d                     d„ |D ¦   «         ¦  «        › d	�¦  «         t          d|j        j        › d�d                     |¦  «        z   ¦  «        ‚)a  Copy EMA weights without deserializing module extra-state payloads.

        Transformer Engine records FP8 scaling history in ``_extra_state`` entries
        and intentionally rejects their pickle deserialization by default. The
        EMA copy is in-process and needs only parameters and buffers, so it omits
        exactly those entries while retaining strict errors for all other keys.

        Args:
            module: Module receiving the EMA or restored live weights.
            state_dict: Source module state dictionary.

        Raises:
            RuntimeError: If any non-extra-state key is missing or unexpected.
        FrX   c                ó>   •— g | ]}‰                      |¦  «        °|‘ŒS r[   r\   r^   s     €r.   ra   z7RFDETREMACallback._load_ema_weights.<locals>.<listcomp>ú   s-   ø€ ÐfÐfÐf È×H`ÒH`ÐadÑHeÔHeÐf˜ÐfÐfÐfr/   c                ó>   •— g | ]}‰                      |¦  «        °|‘ŒS r[   r\   r^   s     €r.   ra   z7RFDETREMACallback._load_ema_weights.<locals>.<listcomp>û   s-   ø€ ÐlÐlÐl 3Èd×NfÒNfÐgjÑNkÔNkÐl˜3ÐlÐlÐlr/   NzMissing key(s) in state_dict: z, c              3  ó4   K  — | ]}t          |¦  «        V — Œd S ©N©Úrepr©r_   r`   s     r.   ú	<genexpr>z6RFDETREMACallback._load_ema_weights.<locals>.<genexpr>  s*   è è € ÐLoÐLoÐ[^ÍTÐRUÉYÌYÐLoÐLoÐLoÐLoÐLoÐLor/   rc   z!Unexpected key(s) in state_dict: c              3  ó4   K  — | ]}t          |¦  «        V — Œd S r�   rŽ   r�   s     r.   r‘   z6RFDETREMACallback._load_ema_weights.<locals>.<genexpr>  s(   è è € Ð=cÐ=cÈC½dÀ3¹i¼iÐ=cÐ=cÐ=cÐ=cÐ=cÐ=cr/   z#Error(s) in loading state_dict for z:
	z
	)	rk   rl   rm   rn   ÚappendÚjoinrS   r-   Ú__name__)r,   ri   r}   rv   rm   rn   Úerror_messagess   `      r.   rf   z#RFDETREMACallback._load_ema_weightsê   sI  ø€ ð ×-Ò-¨d×.GÒ.GÈ
Ñ.SÔ.SÐ\aÐ-ÑbÔbˆØfÐfÐfÐf |Ô'@ÐfÑfÔfˆØlÐlÐlÐl¨,Ô*FÐlÑlÔlˆØð 	 Oð 	ØˆFàˆØð 	tØ×!Ò!Ð"rÀ4Ç9Â9ÐLoÐLoÐbnÐLoÑLoÔLoÑCoÔCoÐ"rÐ"rÐ"rÑsÔsÐsØð 	Ø×!Ò!Øf°D·I²IÐ=cÐ=cÐSbÐ=cÑ=cÔ=cÑ4cÔ4cÐfÐfÐfñô ð õ ØR°&Ô2BÔ2KÐRÐRÐRÐU[×U`ÒU`ÐaoÑUpÔUpÑpñ
ô 
ð 	
r/   Útrainerr
   c                óP  — |j         }t          |t          j         ¦  «        s%t          dt	          |¦  «        j        › d�¦  «        ‚|j        dk    rdn|}t          ||| j        | j        ¬¦  «        | _	        | j	         
                    ¦   «          |                      |¦  «         dS )zÞInitialise EMA after Lightning applies precision conversion and device placement.

        Args:
            trainer: The Lightning Trainer instance.
            pl_module: The ``RFDETRModelModule`` being trained.
        z7Expected a torch.device from the Lightning module, got rc   rR   N)rj   rF   r   Úmulti_avg_fn)rF   r6   rK   Ú	TypeErrorrG   r•   r   r#   rN   r'   Úevalrw   )r,   r—   rU   rF   Úaveraged_model_devices        r.   Úon_fit_startzRFDETREMACallback.on_fit_start
  sº   € ð Ô!ˆÝ˜&¥%¤,Ñ/Ô/ð 	pÝÐnÕVZÐ[aÑVbÔVbÔVkÐnÐnÐnÑoÔoÐoð )/¬°uÒ(<Ð(<  À&ÐÝ+ØØ(ØÔ)ØÔ+ð	
ñ 
ô 
ˆÔð 	Ô× Ò Ñ"Ô"Ð"à×+Ò+¨IÑ6Ô6Ð6Ð6Ð6r/   c                ó¸   — |j         | j        k     r|j         | _        |                      |¦  «         |j        j        dk    r|                      ||¦  «         dS dS )ag  Apply resumed EMA state that arrived after ``on_fit_start()``.

        Standard strategies restore callback and module checkpoint state before
        ``on_fit_start()``, so that hook restores the EMA state immediately after
        constructing its precision-matched averaged model. Strategies that restore
        after their setup may deliver callback or legacy EMA state later; this hook
        is the first point after restoration where the same state can be applied.

        Args:
            trainer: The Lightning Trainer instance.
            pl_module: The ``RFDETRModelModule`` being trained.
        rR   N)Úglobal_stepr(   rw   rF   rG   Ú_register_xla_optimizer_hook©r,   r—   rU   s      r.   Úon_train_startz RFDETREMACallback.on_train_start%  si   € ð Ô Ô!9Ò9Ð9Ø'.Ô':ˆDÔ$Ø×+Ò+¨IÑ6Ô6Ð6ØÔÔ  EÒ)Ð)Ø×-Ò-¨g°yÑAÔAÐAÐAÐAð *Ð)r/   c                óª   ‡ ‡‡— ‰ j         �‰ j                              ¦   «          ‰j        d         }dˆˆ ˆfd„}|                     |¦  «        ‰ _         dS )a,  Queue EMA inside the optimizer step, before Lightning's XLA step marker.

        Registers on ``trainer.optimizers[0]``, the raw ``torch.optim.Optimizer`` that both the automatic-
        optimization path and ``LightningOptimizer.step()`` (the manual-optimization keypoint path) ultimately
        call ``.step()`` on, so the hook fires for either lifecycle.

        Args:
            trainer: The Lightning Trainer instance; supplies the raw optimizer and the current step count.
            pl_module: The ``RFDETRModelModule`` being trained.
        Nr   Ú	optimizerr   Úargsútuple[Any, ...]Úkwargsr~   r   r   c                óJ   •— ~ ~~‰                      ‰‰j        dz   ¦  «         dS )aƒ  Optimizer step-post-hook callback: update EMA for the step that just completed.

            Args:
                optimizer: The optimizer instance the hook fired on (unused; closed over instead).
                args: Positional arguments passed to the wrapped ``step`` call (unused).
                kwargs: Keyword arguments passed to the wrapped ``step`` call (unused).
            r   N)Ú_update_ema_for_steprŸ   )r¤   r¥   r§   rU   r,   r—   s      €€€r.   Ú
update_emazBRFDETREMACallback._register_xla_optimizer_hook.<locals>.update_emaJ  s0   ø€ ð ˜4 Ø×%Ò% i°Ô1DÀqÑ1HÑIÔIÐIÐIÐIr/   )r¤   r   r¥   r¦   r§   r~   r   r   )r+   ÚremoveÚ
optimizersÚregister_step_post_hook)r,   r—   rU   r¤   rª   s   ```  r.   r    z.RFDETREMACallback._register_xla_optimizer_hook:  s€   øøø€ ð Ô#Ð/ØÔ$×+Ò+Ñ-Ô-Ð-àÔ& qÔ)ˆ	ð	Jð 	Jð 	Jð 	Jð 	Jð 	Jð 	Jð 	Jð $-×#DÒ#DÀZÑ#PÔ#PˆÔ Ð Ð r/   rŸ   c                óÊ   — | j         �|| j        k    rdS || _        || j        z  dk    }|r5|                      |dz
  ¬¦  «        r| j                              |¦  «         dS dS dS )aË  Update EMA once for an eligible optimizer step.

        Args:
            pl_module: The ``RFDETRModelModule`` being trained.
            global_step: Optimizer step count to evaluate for eligibility, already resolved to its post-step value
                by the caller (eager accelerators pass ``trainer.global_step`` directly; the XLA hook passes
                ``trainer.global_step + 1`` since it runs before Lightning's own counter advances).
        Nr   r   )Ústep_idx)r'   r(   r%   Úshould_updateÚupdate_parameters)r,   rU   rŸ   Úshould_update_steps       r.   r©   z&RFDETREMACallback._update_ema_for_step[  s�   € ð ÔÐ&¨+¸Ô9QÒ*QÐ*QØˆFà#.ˆÔ Ø(¨4Ô+FÑFÈ!ÒKÐØð 	= $×"4Ò"4¸kÈA¹oÐ"4Ñ"NÔ"Nð 	=ØÔ×1Ò1°)Ñ<Ô<Ð<Ð<Ð<ð	=ð 	=ð 	=ð 	=r/   Nr¯   ú
int | NoneÚ	epoch_idxc                ó   — |dup|duS )aÏ  Return whether either trigger index is present.

        ``epoch_idx`` remains part of the callback interface for backwards compatibility and still counts as a
        trigger when supplied. The callback invokes this method from its optimizer-step lifecycle with ``step_idx``;
        it no longer dispatches an epoch-end EMA update, which previously double-counted the last step of each epoch
        and bypassed ``update_interval_steps``.

        Args:
            step_idx: Index of the last optimizer step, or ``None``.
            epoch_idx: Index of the last epoch, or ``None``. Retained for backwards API compatibility.

        Returns:
            ``True`` when either trigger index is not ``None``.
        Nr[   )r,   r¯   r´   s      r.   r°   zRFDETREMACallback.should_updatel  s   € ð& ˜tÐ#Ð< y¸Ð'<Ð<r/   c                óD  — | j         €dS | j        €mt          |                      |                     ¦   «         ¦  «        ¦  «        | _        |                      || j         j                             ¦   «         ¦  «         dS |                      || j        ¦  «         d| _        dS )z2Swap live model weights with averaged EMA weights.N)r'   r)   r   rl   r}   rf   ri   )r,   rU   s     r.   Ú_swap_modelszRFDETREMACallback._swap_models�  s—   € àÔÐ&ØˆFØÔ#Ð+Ý'/°×0IÒ0IÈ)×J^ÒJ^ÑJ`ÔJ`Ñ0aÔ0aÑ'bÔ'bˆDÔ$Ø×"Ò" 9¨dÔ.AÔ.H×.SÒ.SÑ.UÔ.UÑVÔVÐVØˆFØ×Ò˜y¨$Ô*BÑCÔCÐCØ#'ˆÔ Ð Ð r/   Úoutputsr   ÚbatchÚ	batch_idxc                ó`   — |j         j        dk    rdS |                      ||j        ¦  «         dS )z7Update EMA after optimizer steps on eager accelerators.rR   N)rF   rG   r©   rŸ   )r,   r—   rU   r¸   r¹   rº   s         r.   Úon_train_batch_endz$RFDETREMACallback.on_train_batch_endŒ  s9   € ð ÔÔ  EÒ)Ð)ØˆFØ×!Ò! )¨WÔ-@ÑAÔAÐAÐAÐAr/   c                óB   — | j         rdS |                      |¦  «         dS )zHEvaluate tests using averaged EMA weights unless the swap is suppressed.N©r&   r·   r¡   s      r.   Úon_test_epoch_startz%RFDETREMACallback.on_test_epoch_start™  ó,   € àÔ"ð 	ØˆFØ×Ò˜)Ñ$Ô$Ð$Ð$Ð$r/   c                óB   — | j         rdS |                      |¦  «         dS )zIRestore live weights after test evaluation unless the swap is suppressed.Nr¾   r¡   s      r.   Úon_test_epoch_endz#RFDETREMACallback.on_test_epoch_endŸ  rÀ   r/   c                ó†   — | j         �2|                      || j         j                             ¦   «         ¦  «         d| _        dS )z6Leave the module in EMA state after training finishes.N)r'   rf   ri   r}   r)   r¡   s      r.   Úon_train_endzRFDETREMACallback.on_train_end¥  sA   € àÔÐ*Ø×"Ò" 9¨dÔ.AÔ.H×.SÒ.SÑ.UÔ.UÑVÔVÐVØ#'ˆÔ Ð Ð r/   Ústagec                ó^   — ~~~| j         �"| j                              ¦   «          d| _         dS dS )a]  Remove the XLA optimizer hook when the fit lifecycle ends.

        Args:
            trainer: The Lightning Trainer instance (unused; the hook handle already closes over what it needs).
            pl_module: The ``RFDETRModelModule`` being trained (unused).
            stage: The lifecycle stage being torn down, e.g. ``"fit"`` (unused).
        N)r+   r«   )r,   r—   rU   rÅ   s       r.   ÚteardownzRFDETREMACallback.teardown«  s?   € ð �Y ØÔ#Ð/ØÔ$×+Ò+Ñ-Ô-Ð-Ø'+ˆDÔ$Ð$Ð$ð 0Ð/r/   c                ó„   — d| j         i}| j        �/|                      | j                             ¦   «         ¦  «        |d<   |S )z(Return callback state for checkpointing.Úlatest_update_stepNÚaverage_model_state_dict)r(   r'   rl   r}   )r,   Ústates     r.   r}   zRFDETREMACallback.state_dict¸  sK   € ð ! $Ô":ð!
ˆð ÔÐ*Ø04×0IÒ0IÈ$ÔJ]×JhÒJhÑJjÔJjÑ0kÔ0kˆEÐ,Ñ-Øˆr/   c                óp   — |                      dd¦  «        | _        |                      d¦  «        | _        dS )z(Restore callback state from checkpoints.rÉ   r   rÊ   N)Úgetr(   r*   )r,   r}   s     r.   rk   z!RFDETREMACallback.load_state_dictÁ  s4   € à#-§>¢>Ð2FÈÑ#JÔ#JˆÔ Ø+5¯>ª>Ð:TÑ+UÔ+UˆÔ(Ð(Ð(r/   údict[str, Tensor] | Nonec                óÎ  — | j         �t          | j         j        d¦  «        sdS t          d| j         j        ¦  «        }|                      |j                             ¦   «         ¦  «        }|                     ¦   «         }|                     ¦   «         D ].\  }}| 	                    ¦   «          
                    ¦   «         ||<   Œ/t          |dd¦  «        }|�t          |d|¦  «         |S )z;Expose EMA model weights for external checkpoint callbacks.Nrj   r   r�   )r'   rg   ri   r   rl   rj   r}   r‚   ÚitemsÚdetachÚclonerƒ   r„   )r,   ru   r}   Úcloned_state_dictr`   Úvaluer‡   s          r.   Úget_ema_model_state_dictz*RFDETREMACallback.get_ema_model_state_dictÆ  sß   € àÔÐ&­g°dÔ6IÔ6PÐRYÑ.ZÔ.ZÐ&Ø�4ÝÐ1°4Ô3FÔ3MÑNÔNˆØ×.Ò.¨~Ô/C×/NÒ/NÑ/PÔ/PÑQÔQˆ
Ø&ŸOšOÑ-Ô-ÐØ+×1Ò1Ñ3Ô3ð 	<ð 	<‰JˆC�Ø%*§\¢\¡^¤^×%9Ò%9Ñ%;Ô%;Ð˜cÑ"Ð"Ý˜: {°DÑ9Ô9ˆØÐÝÐ% {°HÑ=Ô=Ð=Ø Ð r/   )r   r   Tr   )
r   r   r   r   r   r   r   r   r   r   )r0   r   r1   r   r2   r3   r   r   )r2   r   r   r   )r@   rA   rB   rA   r2   r3   r   r   )r2   r3   rO   rP   r   r   )rU   r	   r   r   )r`   rP   r   r   )r}   r~   r   r~   )ri   rˆ   r}   r~   r   r   )r—   r
   rU   r	   r   r   )rU   r	   rŸ   r   r   r   )NN)r¯   r³   r´   r³   r   r   )r—   r
   rU   r	   r¸   r   r¹   r   rº   r   r   r   )r—   r
   rU   r	   rÅ   rP   r   r   )r   r~   )r}   r~   r   r   )r   rÎ   )r•   Ú
__module__Ú__qualname__Ú__doc__r    r;   r8   rN   rE   rw   Ústaticmethodr]   rl   rf   r�   r¢   r    r©   r°   r·   r¼   r¿   rÂ   rÄ   rÇ   r}   rk   rÕ   Ú__classcell__)r-   s   @r.   r   r      sV  ø€ € € € € ðð ð0 ØØ Ø%&ð@ð @ð @ð @ð @ð @ð @ð,Xð Xð Xð Xð2ð ð ð ð!Xð !Xð !Xð !XðFcð cð cð cð&"8ð "8ð "8ð "8ðH ð	Að 	Að 	Añ „\ð	Að#ð #ð #ð #ð,
ð 
ð 
ð 
ð@7ð 7ð 7ð 7ð6Bð Bð Bð Bð*Qð Qð Qð QðB=ð =ð =ð =ð&  $Ø $ð=ð =ð =ð =ð =ð*	(ð 	(ð 	(ð 	(ðBð Bð Bð Bð%ð %ð %ð %ð%ð %ð %ð %ð(ð (ð (ð (ð,ð ,ð ,ð ,ðð ð ð ðVð Vð Vð Vð
!ð !ð !ð !ð !ð !ð !ð !r/   r   )rØ   Ú
__future__r   r=   ro   r‚   r   Útypingr   r   r   rK   Úpytorch_lightningr   r	   r
   r   Útorch.optimr   Útorch.optim.swa_utilsr   Útorch.utils.hooksr   Úrfdetr.training.module_modelr   r   r[   r/   r.   ú<module>râ      s)  ðð HÐ Gà "Ð "Ð "Ð "Ð "Ð "à €€€Ø €€€Ø Ð Ð Ð Ð Ð Ø +Ð +Ð +Ð +Ð +Ð +Ð +Ð +Ð +Ð +à €€€Ø @Ð @Ð @Ð @Ð @Ð @Ð @Ð @Ð @Ð @Ø Ð Ð Ð Ð Ð Ø !Ð !Ð !Ð !Ð !Ð !Ø /Ð /Ð /Ð /Ð /Ð /Ø -Ð -Ð -Ð -Ð -Ð -àð ?Ø>Ð>Ð>Ð>Ð>Ð>ðx!ð x!ð x!ð x!ð x!˜ñ x!ô x!ð x!ð x!ð x!r/   