^jSH &dZddlZddlZddlmZddlmZddlmZeZ dZ de de d dfd Z dd ed e d ed efdZde d efdZde ej"e zd dfdZdee efd ee effdZdee efded ee effdZdee efded dfdZy)z"Checkpoint and state-dict helpers.N) OrderedDict)Any) get_logger) state_dict global_stepzpytorch-lightning_versionloopsoptimizer_states lr_schedulersckpt_patch_sizemodel_patch_sizereturnc&td|d|d)uHRaise a descriptive ValueError for a patch_size incompatibility. Args: ckpt_patch_size: patch_size recorded in (or inferred from) the checkpoint. model_patch_size: patch_size the current model is configured with. Raises: ValueError: Always — describes the mismatch and how to resolve it. z+The checkpoint was trained with patch_size=z(, but the current model uses patch_size=z. The checkpoint is incompatible with this model architecture. To resolve this, either instantiate/configure the model with the checkpoint's patch_size or use a checkpoint that was trained with the same patch_size as the current model.) ValueError)r r s f/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/utilities/state_dict.py_raise_patch_size_mismatchrs1  5o5FG&'([ [ argsfielddefaultc`t|tr|j||St|||S)adGet a field from checkpoint ``"args"``, handling both dict and attribute access. New checkpoints (PTL training stack) store ``"args"`` as a plain ``dict`` (via ``TrainConfig.model_dump()``). Legacy checkpoints (pre-PTL engine or the pre-release PTL code) stored it as a ``Namespace``-like object. This helper abstracts both so callers do not need to branch on the type. Args: args: The ``checkpoint["args"]`` value. field: Field name to retrieve. default: Value returned when the field is absent. Returns: The field value, or ``default`` if not found. ) isinstancedictgetgetattr)rrrs r_ckpt_args_getr/s.$xxw'' 4 ((repochc |dz}ddddd}dddd}ddd}||||d}iddii|i|ddi|i|d id i|i|d i|i|d d iii|i|d ii|i|ddi|i|d d S) uBuild a minimal ``fit_loop`` state dict that restores the epoch counter. ``BestModelCallback`` stores ``trainer.current_epoch`` as ``"epoch"`` in the checkpoint. That value is captured during ``on_validation_end``, which fires *before* the loop's epoch-end hooks increment the counter. To resume training *after* that epoch, PTL's epoch-progress counter must be set to ``epoch + 1`` so that ``trainer.current_epoch == epoch + 1`` when the new ``trainer.fit()`` call begins. Optimizer and scheduler states are intentionally omitted — loading a ``.pth`` file starts a fresh optimizer for the new training phase. Args: epoch: The ``"epoch"`` value from the checkpoint (``trainer.current_epoch`` at the time of ``on_validation_end``). Returns: A ``fit_loop`` state dict compatible with :meth:`pytorch_lightning.loops._FitLoop.load_state_dict`. r)readystarted processed completed)rr r")rr"_batches_that_steppedF)totalcurrent is_last_batch)r$r% optimizer)step zero_grad) rzepoch_loop.state_dictzepoch_loop.batch_progresszepoch_loop.scheduler_progressz,epoch_loop.automatic_optimization.state_dictz0epoch_loop.automatic_optimization.optim_progressz)epoch_loop.manual_optimization.state_dictz2epoch_loop.manual_optimization.optim_step_progresszepoch_loop.val_loop.state_dictz"epoch_loop.val_loop.batch_progressepoch_progress)rnzero4zero3zero2n4s r_make_fit_loop_stater1Cs$  AAAA FEAA 6Ea (E CB"91!=Y %y"& Y %y* 9; &Y(%y 'Y(%y  = 68Y %y? +-Y %y"/ V"v I( (r checkpointc ddl}|j|dd}|d|dd}d |vr|d |d <d |vr|d |d <tD]}||vs||||<d |vr|d }d D]}||vsd ii||<tjj tjj tj|}tj|d5}|j} ddd |j| tj| |tjj| rtj| yy#1swYhxYw#tjj rtj| wwxYw)aStrip a checkpoint file down to ``model``, ``args``, and PTL-compatible keys. Preserves ``model_name`` (when present) so that ``RFDETR.from_checkpoint()`` can still resolve the model class from the stripped file. Also preserves ``rfdetr_version`` (when present) for provenance tracking. Also preserves ``state_dict``, ``global_step``, ``pytorch-lightning_version``, ``loops``, ``optimizer_states``, and ``lr_schedulers`` when present so the stripped checkpoint can still be used directly with ``trainer.fit(ckpt_path=...)``. Overwrites the file atomically so a partial write cannot corrupt it. Args: checkpoint: Path to the ``.pth`` checkpoint file to strip in place. rNcpuF) map_location weights_onlymodelr)r7r model_namerfdetr_versionr) validate_loop test_loopr)dirdelete)torchload_PTL_COMPAT_KEYSospathdirnameabspathfspathtempfileNamedTemporaryFilenamesavereplaceexistsremove) r2r>rnew_state_dictkeyrloop_keycheckpoint_dirtmp_filetmp_paths rstrip_checkpointrSs JUOJG$6"N z!'1,'?|$:%+56F+G'(2 * ",S/N3 2 . w'6 5Hu$#/"4h 5WW__RWW__RYYz5J%KLN  $ $ F!(==!  >8, 8Z( 77>>( # IIh  $!! 77>>( # IIh  $s E ,(E E7F rcnt}|jD]\}}|dddk(r|dd}|||<|S)a Remove the ``module.`` prefix added by ``DataParallel`` / ``DistributedDataParallel``. Args: state_dict: State dict potentially containing ``module.``-prefixed keys. Returns: New ``OrderedDict`` with ``module.`` stripped from all keys. Nzmodule.)ritems)rrMkvs rclean_state_dictrYsR!]N  "1 Ra5I !"Aq rr7ct|dr|jdnd}||St|dddu}tt|ddxs|}|s|St d|Dr|S|j Dcic]\}}|j ds||}}}|s|Stjd t||j D]+\}}|jdd d }|j||<-|Scc}}w) a7Clone backbone projector weights into ``cross_attn_projector`` for dual-projector models. Older checkpoints can contain only ``backbone.0.projector.*`` keys. Dual-projector models expect an additional ``backbone.0.cross_attn_projector.*`` branch; this helper seeds it by cloning projector weights when missing. Args: state_dict: Checkpoint model-state dictionary (mutated in place). model: Instantiated model used to detect whether dual projector mode is active. Returns: The same ``state_dict`` object for convenience. backbonerNcross_attn_projectordual_projectorFc3>K|]}|jdyw) backbone.0.cross_attn_projector.N) startswith).0rNs r z0remap_projector_to_cross_attn..s T#3>>< = Tszbackbone.0.projector.z`Cloning %d backbone projector key(s) into cross_attn_projector for dual-projector compatibility.r_r) hasattrr[rboolanyrVr`loggerinfolenrJclone) rr7r[has_cross_attn_projectordual_projector_enabledrNvalueprojector_keysnew_keys rremap_projector_to_cross_attnros%,E:$>u~~a DH 'x1GNVZZ!'(4De"LMiQi ! T TT3=3C3C3EqZS%XoIpc5jqNq  KKj N%**,, U++57Y[\]#kkm 7, rs 6C;C; model_argsc|jdijdd}|l|jd}t|dd}|N||dzk7rF|dz|krtj d|dz ||n"tj d|dz ||dz |dz |jd }d}| t |d }|yd }|jdij|}t|d d} | Gt | d k(r9| d| dk(r.t| d} t|d d} | | | k7r t| | d |vry|d } t | d} t|dd}| || |k7r| r tdtdt | d }t|d d}||||k7r t||t | d}t|dd}|!|||k7r|r tdtdyyy)uy Validate that a checkpoint is compatible with the model configuration. Checks for mismatches in ``segmentation_head`` and ``patch_size`` between the checkpoint's saved training arguments and the current model configuration. Raises a descriptive :class:`ValueError` before ``load_state_dict`` fires so that users receive a clear, actionable message instead of a cryptic tensor size mismatch error. If either side is missing an attribute (e.g. a legacy checkpoint saved before ``segmentation_head`` or ``patch_size`` was added to ``args``), that specific check is skipped silently — this preserves backwards compatibility with pre-existing checkpoints. Args: checkpoint: Loaded checkpoint dictionary, expected to contain an optional ``"args"`` key with training namespace attributes or a plain dict. model_args: Namespace (e.g. ``types.SimpleNamespace``) with at least ``segmentation_head`` and ``patch_size`` attributes describing the current model. Raises: ValueError: If ``segmentation_head`` or ``patch_size`` in the checkpoint args do not match those of the model, or if the ``patch_size`` inferred from the DINOv2 projection weight shape differs from ``model_args.patch_size`` when no explicit ``args.patch_size`` is present. Note: This helper does not mutate ``model_args``. It emits ``logger.warning`` (not an exception) for class-count mismatches so that callers can still proceed with reinitialization or weight loading. When ``"args"`` is absent or ``args.patch_size`` is not set, a fallback infers ``patch_size`` from the DINOv2 patch-embedding projection weight shape (key ``backbone.0.encoder.encoder.embeddings.patch_embeddings.projection.weight``). This fallback **can raise** :class:`ValueError` on a mismatch, providing a clear error before the cryptic :class:`RuntimeError` from :meth:`~torch.nn.Module.load_state_dict` would otherwise fire. For all other attributes (e.g. ``segmentation_head``), if either side is missing, that check is skipped silently — preserving backward compatibility. Two class-count scenarios are distinguished: * Backbone pretrain: the checkpoint head was trained with more classes than the current ``model_args.num_classes``. In this case the detection head is typically reinitialized or trimmed externally to match the configured number of classes. * Fine-tuned checkpoint: the checkpoint head was trained with fewer classes than the current ``model_args.num_classes``. If you intend to reuse the checkpoint's classification head as-is, set ``model_args.num_classes`` to ``ckpt_num_classes - 1`` (the value reported in the warning) before loading the state dict to align the configuration and silence the warning. r7zclass_embed.biasNr num_classesrzrCheckpoint has %d classes but model is configured for %d. The detection head will be re-initialized to %d classes.zCheckpoint has %d classes but model is configured for %d. Using checkpoint class count (%d). Pass num_classes=%d to suppress this warning.r patch_sizezHbackbone.0.encoder.encoder.embeddings.patch_embeddings.projection.weightshapesegmentation_headzThe checkpoint was trained with a segmentation head, but the current model does not have one. Load the weights into a segmentation model (e.g. RFDETRSegNano) instead of a detection model.zThe current model has a segmentation head, but the checkpoint was trained without one. Load the weights into a detection model (e.g. RFDETRNano) instead of a segmentation model.use_grouppose_keypointszThe checkpoint was trained with a keypoint head, but the current model does not have one. Load the weights into a keypoint model (e.g. RFDETRKeypointPreview) instead of a detection model.zThe current model has a keypoint head, but the checkpoint was trained without one. Load the weights into a detection model (e.g. RFDETRNano) instead of a keypoint model.) rrtrrfwarningrrhintrr)r2rpckpt_class_biasckpt_num_classesmodel_num_classes _ckpt_args_ckpt_patch_size_from_args_patch_proj_key _ckpt_proj_w_ckpt_proj_shape _inferred_ps _model_ps ckpt_argsckpt_segmentation_headmodel_segmentation_headr r ckpt_keypoint_headmodel_keypoint_heads r!validate_checkpoint_compatibilityrsZ!nnWb1556H$OO"*003(/ M4(P  (-=ARUVAV-V 1$'77O$q(%% D%q(%$q($q($'J-1%3J %M"!)d!~~gr266G "<$?  'C0@,AQ,FK[\]K^brstbuKu/34L$+J d$KI$)B*<C Z6"I*8DW*X+2:?RTX+Y * # / "&= = !p  m  #1L"IO#*:|T#J"'7'C[kHk"?4DE&4Y@Y&Z'.z;TVZ'[%*=*IN`dwNw t  i Ox*I%r)N)__doc__rArF collectionsrtypingrrfdetr.utilities.loggerrrfr@r|rstrrrr1PathLikerSrYobjectrorr+rrrs ) #. st$))S)3)#)(???D6 r{{3'7!76 D6 rc3hKS4I"&d38n&V&PTUXZ]U]P^&RF$sCx.FcFVZFr