^j{NUdZddlmZddlZddlZddlmZmZddlZddl m cm Z ddl mZmZddlmZmZddlmZddlmZdd lmZmZmZeZgd Zd Zd Zd ed< ddZ ddZ!ddZ" ddZ#edddiddd d d dZ$d!dZ%y)"a8Shared weight-loading and LoRA application utilities. Provides the canonical implementations of pretrained checkpoint loading and LoRA adapter injection, used by both the L1 inference facade (``rfdetr.detr``) and the L2 LightningModule (``rfdetr.training.module_model``). The weight-loading logic is taken from ``RFDETRModelModule._load_pretrain_weights`` in ``module_model.py`` (more complete: Pydantic-aware user-override detection, auto-alignment for fine-tuned checkpoints) and augmented with class- name extraction from ``detr.py:_load_pretrain_weights_into``. ) annotationsN)AnyList)download_pretrain_weightsvalidate_pretrain_weights) ModelConfig TrainConfig) deprecated) get_logger)_ckpt_args_getremap_projector_to_cross_attn!validate_checkpoint_compatibility)load_pretrain_weights apply_lorainterpolate_position_embeddingszembeddings.position_embeddings)zrefpoint_embed.weightzquery_feat.weightztuple[str, ...]_QUERY_PARAM_SUFFIXESc |dks|dks |dks|dkrtd|d|d|d|d ||z}|jd|k7r.tjd||||jd|d||zS||k(r||k(r|St ||}t ||}t |Dcgc]}|||z||z|z} }t j| d Scc}w) u Slice a ``refpoint_embed`` / ``query_feat`` weight preserving per-group structure. ``LWDETR`` packs query embeddings as ``nn.Embedding(num_queries * group_detr, ...)`` where group ``g`` occupies the contiguous slot range ``[g * num_queries, (g + 1) * num_queries)`` (see ``LWDETR.__init__`` and ``LWDETR.forward`` in ``models/lwdetr.py``). When ``num_queries`` decreases and ``group_detr > 1``, a flat ``tensor[: target_num_queries * target_group_detr]`` slice silently scrambles groups: the tail of group 0 winds up in what should be group 1's slots, and so on. At inference only group 0 is read so the bug is invisible, but for training-resume it corrupts groups 1+. This helper does the right thing per group: * ``num_queries`` decrease (``target_num_queries < ckpt_num_queries``) → keep the first ``target_num_queries`` slots of each retained group. * ``group_detr`` decrease (``target_group_detr < ckpt_group_detr``) → drop tail groups; retained groups stay pretrained. * Either dimension expands, or one shrinks while the other expands → return whatever per-group sub-tensor can be built (``min(target, ckpt)`` along each axis). The result has fewer rows than the model expects, so ``load_state_dict`` will raise a shape mismatch immediately. When the tensor's flat length disagrees with ``ckpt_num_queries * ckpt_group_detr`` (corrupt or unexpected checkpoint shape), fall back to the legacy flat slice so loading continues with the same behavior the codebase had before this fix. Args: tensor: The checkpoint tensor for ``refpoint_embed.weight`` or ``query_feat.weight``. ckpt_num_queries: ``num_queries`` recorded in the checkpoint's training args. ckpt_group_detr: ``group_detr`` recorded in the checkpoint's training args. target_num_queries: ``num_queries`` configured for the model. target_group_detr: ``group_detr`` configured for the model. Returns: A tensor whose layout matches the model's configured packing for the decrease-or-equal cases, or a per-group sub-tensor built from ``min(target, ckpt)`` along each axis for the expansion case (which ``load_state_dict`` will then reject on shape mismatch). Raises: ValueError: If any of ``ckpt_num_queries``, ``ckpt_group_detr``, ``target_num_queries``, or ``target_group_detr`` is ≤ 0. rzX_slice_query_param_per_group: all dimension args must be positive; got ckpt_num_queries=z, ckpt_group_detr=z, target_num_queries=z, target_group_detr=.u_slice_query_param_per_group: checkpoint args claim %d × %d = %d rows but tensor has %d rows; falling back to flat slice. Per-group structure may be scrambled if group_detr > 1.Ndim) ValueErrorshapeloggerwarningminrangetorchcat) tensorckpt_num_queriesckpt_group_detrtarget_num_queriestarget_group_detrexpected_total keep_groupskeep_per_groupgpiecess `/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/models/weights.py_slice_query_param_per_groupr**s7^11 48Ja8OSdhiSi$$4#55GGXY""4!55IJ[I\\] _  &7N ||A.( 2    LLO >*->>??--2C2V '9K+-=>N\abm\n oWXfQ))A0@,@>,QR oF o 99V ##ps#Ccjddgtdddfd }|Dcgc] }||r |c}Scc}w)u;Return *keys* with intentional-reinit/trim entries removed. Matching is boundary-aware: a pattern matches a key when the pattern appears at the start of the key or immediately after a module separator (``.``). This prevents substring collisions where a pattern like ``"class_embed."`` would inadvertently match a key belonging to an unrelated module (e.g. ``"class_embed_projection.weight"`` is safe because ``class_embed_projection.`` ≠ ``class_embed.``, but using a plain ``in`` check against longer ambiguous strings is fragile by design). z class_embed.z bbox_embed.zenc_out_class_embed.zenc_out_bbox_embed.c.tfdDS)Nc3RK|]}j|xsd|v yw)rN) startswith).0patkeys r) zD_filter_intentional_keys.._is_intentional..s-[s3>>#&:AcU)s*::[s$')any)r1intentional_patternss`r)_is_intentionalz1_filter_intentional_keys.._is_intentionals[FZ[[[)r1strreturnbool)r)keysr5kr4s @r)_filter_intentional_keysr<wsT - -  -  -\ 6!?1#5A 66 6s 00ct|dd}t|dd} |r|Dcgc] }t|c}ng}|r|Dcgc] }t|c}ng}t|}t|}|s|syg} |rGdj |dd} t |dkDr| dz } | j t |d| d|rGdj |dd} t |dkDr| dz } | j t |d | dtjd |d j | ycc}wcc}w#t$rYywxYw) uPEmit a ``logger.warning`` when ``load_state_dict`` left non-trivial gaps. ``load_state_dict(strict=False)`` silently ignores keys that the model has but the checkpoint does not (``missing_keys``) and keys present in the checkpoint but absent from the model (``unexpected_keys``). When this happens for parameters outside the head / query embeddings — which the loader intentionally reinitialises or trims — the corresponding model weights were left at their random initial values and the user is silently getting a much weaker model. This helper surfaces that condition with a single, actionable warning. Same-key shape mismatches do not reach this function — they raise :class:`RuntimeError` directly from ``load_state_dict`` and are therefore impossible to miss. Args: incompatible: The ``_IncompatibleKeys`` namedtuple returned by :meth:`torch.nn.Module.load_state_dict`. pretrain_weights_path: Path to the checkpoint that was loaded; included in the warning so the user can identify which load partially succeeded. missing_keysNunexpected_keysz, z, ...z> model parameter(s) not in checkpoint (left at random init): []z+ checkpoint key(s) not consumed by model: [uPretrained weights at %r loaded only partially — this typically produces lower accuracy. %s. Check that the model configuration (encoder, hidden_dim, out_feature_indexes, projector_scale, ...) matches the architecture the checkpoint was trained with. ) getattrr7 TypeErrorr<joinlenappendrr) incompatiblepretrain_weights_pathmissing_keys_rawunexpected_keys_rawr;r>r?missing unexpectedpartssamples r)_warn_on_partial_loadrPsW"|^TB!,0A4H=M(891A9SU CV+>?a3q6?\^'|4G)/:J :E72A;' w* z?Q  g F J((STZS[[\]^ NN '   -:? s,D6D, D6D1D6, D66 EEc ||z}|Dcgc]}|jts|}}|D]}||}|jddz }||k(r!tt j |}tt j |} ||z|k7s| | z|k7r t jd|d|d|d|jd} |ddddf} |ddddf} | jd||| jdd dd } tj| j| | fd d | jjd k7j|j } | jdd d djd|| } t#j$| | gd||<t j'd|t)|jt)||jycc}w)utInterpolate DINOv2 positional embeddings in *checkpoint_state* to match *pe_size*. When the model is configured with a custom ``resolution`` that differs from the checkpoint's training resolution, the DINOv2 backbone's ``position_embeddings`` parameter has an incompatible shape. ``load_state_dict(strict=False)`` does **not** skip shape mismatches on matching keys — it raises ``RuntimeError``. This function bicubic-interpolates every PE tensor in the checkpoint whose shape differs from the target grid, modifying *checkpoint_state* in-place before ``load_state_dict`` is called. Args: checkpoint_state: The ``"model"`` sub-dict from a loaded checkpoint. pe_size: Target grid side length in patches (number of patches per spatial dimension, assuming a square grid). Typically ``model_config.positional_encoding_size``. zSkipping PE interpolation for z,: grid size is not a perfect square (source z , target z).NrbicubicFmps)sizemode align_corners antialiasru1Interpolated positional embeddings %s: %s → %s.)endswith_PE_KEY_SUFFIXrintmathisqrtrrreshapepermuteF interpolatefloatdevicetypetodtyperrdebugtuple) checkpoint_statepe_sizen_targetr;pe_keysr1ckpt_pen_sourceh_srch_tgtr class_tokenpatch_pes r)rrs$ H*IQajj.HqIGI# "3'==#a' x  DJJx()DJJx() 5=H $ (A NN06>>FZyQYPZZ\^  mmBa!en 1ab5>##AueS9AA!Q1M== NN oo**e3  "W]]  ##Aq!Q/778SI % ;*Aq I ?  '-- "3'-- .  =# Js G%G%T train_configz1.7.0z1.9.0rS)target args_mapping deprecated_in remove_in num_warnsc |}|j}|gSg}t|tjj |s#t j dt|ddt|d tj|dd}d |vrd |vrt jd d }d}i} |d jD]I\} } | j|s| t|d} | j|r| t|d} | | | <K| st!d|d| |d <d|vr d|vr|d|d<d|vrQt#|dd} | r@t%| t&r| g}n, t)| }|Dcgc]}t%|t&s|}}t-||dt/|dt1v}|j2}|d dj4d}|dz}||k7r&||kr|s|dz }|}||_|j7||j9d}| t#|dnd}| t#|dnd} | t;|nd}| t;|nd}|du|duk7rt=d|d Dd}|s|d |j4d}d}||dkDr||zdk(r||z}d|d|f\}}}}n||dkDr||zdk(r||z}d|d|f\}}}}|t j d||||j>dkDr$|| t j d|j>tA|d jCD]ttEfdtFDs|d }|-|+tI||||jJ|j> |d <S|d|jJ|j>z|d <vtM|d ||d <d!t/|dt1v} | s8t/|d"dr*tO|d!r|d j9d#}!t%|!tjPr|!jRd$k(r|!jUd%jWD"cgc] }"t;|"}#}"tAt/|d!gxsg}$tEd&|#Dst j d'|#ng|#|$k7rbt jd(|$|#|#|_,nCt%|!tjPr)t j d)t[|!j4tAt/|d!gxsg}%d}&d}'t/|d"drtO|d*ru|j]|d }&|&r_t/|d+d}(t_|(r|(n|%})|&|)k7r9tO|d,r-t j d-|)|&|ja|&|&|%k7}'|d j9d#}*tO|d r|jcni}+t%|+tdr|+j9d#nd},t%|*tjPrt%|,tjPrm|*j4|,j4k7rT|'sRt j d.t[|*j4t[|,j4|d jgd#dti|d |jj|jm|d d}-to|-||'r3tO|d,r't j d/|%|ja|%||kr|r|j7||dz|kr|j7|dz|S#t$r?t jd t|ddtj|dd}YwxYwcc}w#t*$rg}Y(wxYw#t*t f$rt j dd}d}YwxYwcc}"w)0uLoad pretrained checkpoint weights into *nn_model* in-place. Canonical implementation shared by the L1 facade (``_build_model_context`` in ``rfdetr.detr``) and the L2 LightningModule (``RFDETRModelModule.__init__`` in ``rfdetr.training.module_model``). Uses the Pydantic-aware logic from ``module_model.py``: - When the user did **not** explicitly set ``num_classes`` (it is left unset), the checkpoint class count is treated as authoritative and the model head is auto-aligned to it. - When the user **did** explicitly set ``num_classes`` (to any value, including the class default) larger than the checkpoint provides, the head is temporarily aligned to the checkpoint for loading, then expanded back to the configured size. - When the checkpoint has more classes than configured (backbone-pretrain scenario), both reinitializations are applied: expand to checkpoint size for loading, then trim to configured size. Class names stored in the checkpoint ``args`` are extracted and returned. Args: nn_model: The model whose weights will be updated in-place. model_config: Pydantic ``ModelConfig`` instance. Must have ``pretrain_weights``, ``num_classes``, ``num_queries``, and ``group_detr`` attributes. train_config: Deprecated since v1.7.0 — no longer used internally. Passing a non-``None`` value emits a ``DeprecationWarning``. Omit the argument; it will be removed in v1.9.0. Returns: List of class name strings from the checkpoint, or an empty list if none are present or if ``model_config.pretrain_weights`` is ``None``. Raises: Exception: If the checkpoint file cannot be loaded even after a re-download. NzSPretrain weights not found after initial download; retrying without MD5 validation.TF) redownload validate_md5)strictcpu) map_location weights_onlyz/Failed to load pretrain weights, re-downloadingmodel state_dictz=Normalizing PTL .ckpt checkpoint format (state_dict -> model)zmodel.z _orig_mod.zThe checkpoint at z appears to be in PyTorch Lightning format ('state_dict' key present, 'model' key absent), but 'state_dict' contains no keys with the expected 'model.' prefix. The checkpoint may be corrupt or in an unsupported format.argshyper_parameters class_names num_classesmodel_fields_setzclass_embed.biasrrR num_queries group_detrz}load_pretrain_weights: checkpoint args.num_queries / args.group_detr not coercible to int; falling back to legacy flat slice.c3TK|]tfdtDs!yw)c3@K|]}j|ywNr\)r/sr;s r)r2z2load_pretrain_weights...s2`Q1::a=2`N)r3r)r/r;s @r)r2z(load_pretrain_weights..s a1s2`J_2`/`Q as((u]load_pretrain_weights: args.%s absent; inferred ckpt_%s=%d from tensor rows %d ÷ ckpt_%s=%d.zload_pretrain_weights: checkpoint lacks args.num_queries / args.group_detr; falling back to flat slice. With group_detr=%d this may scramble per-group query structure if the checkpoint was trained with group_detr > 1.c3@K|]}j|ywrr)r/xnames r)r2z(load_pretrain_weights..s?At}}Q?r)r r!r"r#num_keypoints_per_classuse_grouppose_keypoints_kp_active_maskrUrc3&K|] }|dkD yw)rN)r/ns r)r2z(load_pretrain_weights..s6q1u6suload_pretrain_weights: _kp_active_mask in checkpoint has no active slots (schema=%s) — skipping auto-align to avoid overwriting config with empty schema.uload_pretrain_weights: auto-aligning num_keypoints_per_class %s → %s (inferred from checkpoint _kp_active_mask; user did not set explicitly).uload_pretrain_weights: _kp_active_mask has unexpected shape %s (expected 2-D) — skipping auto-align; schema mismatch may cause AP≈0 on keypoint models.+get_num_keypoints_per_class_from_checkpointget_num_keypoints_per_classreinitialize_keypoint_headz\load_pretrain_weights: temporarily resizing keypoint schema from %s to checkpoint schema %s.zload_pretrain_weights: dropping checkpoint _kp_active_mask with shape %s because current model expects %s (derived from current keypoint schema).zUload_pretrain_weights: restoring configured keypoint schema %s after checkpoint load.)8pretrain_weightsrospathisfilerrrrload Exceptioninforjitemsr.rFrr isinstancer7iterrDrrCsetrrreinitialize_detection_headgetr^nextrlistr:r3rr*rr hasattrTensorndimsumtolistrrkrcallablerrdictpoprpositional_encoding_sizeload_state_dictrP).nn_model model_configrvmcrr checkpointprefixcompile_prefix model_stater;vstrippedraw_class_namesiteratorr user_overrodercheckpoint_num_classesconfigured_num_classes_plus_bg ckpt_argsckpt_num_queries_rawckpt_group_detr_rawr r!_first_query_key_n_absent _inferred_known _known_valr_user_overrode_kp_schema_early_kp_maskr_ckpt_kp_schema_cfg_kp_schemaconfigured_keypoint_schemacheckpoint_keypoint_schema%should_restore_config_keypoint_schemaget_model_schemamodel_keypoint_schemackpt_kp_active_maskmodel_state_dictmodel_kp_active_maskrHs. ` r)rrsN B** K./ 77>>* +lm!"2tRWX.u=ZZZ 0uSXY j \Z%? TU& |,224 *DAq||F#S[]+&&~6'N(;(=>H() H%  * $%5$89MM  * 7  #(:j(H!+,>!?Jv (F);]K /3/./ W#O4H 5="VD 4QT@U4"VK"V%j"5"WR1CSU%KKM..K'01CDJJ1M%01_"!?? !$B B 5q8 1G.!, ,,-CD v&IGPG\>)]CbfENEZ.LA`d 8L8X334^b6I6U#12[_ D o&=> a 7+ a    'G$%56< MM  Z(--/0U ?)>? ?(.F+0K,H%5$3')~~&(mm - 7#D)-33SR^^bmm5S,T 7#D)#U&8 78KXVJw 9GBHZ\_\a>=,,-KLQ//,,[1_=  Z EF!"2tRWXZZ 0uSXY Zh#W !%"$K%V z " 9   ^SsI1] ^ *^^,^2 _!A^^ ^/.^/2(__c ddlm}m}|dddgd}||jdj ||jd_y#t$r}td|d}~wwxYw) aApply LoRA adapters to the backbone encoder of *nn_model*. Replaces ``nn_model.backbone[0].encoder`` in-place with a PEFT-wrapped encoder using DoRA with rank 16 and alpha 16. Args: nn_model: LWDETR model whose backbone encoder will receive LoRA adapters. Raises: ImportError: If ``peft`` is not installed. Install via the RF-DETR extras, for example:: pip install "rfdetr[lora]" # or pip install "rfdetr[train]" r) LoraConfigget_peft_modelzLoRA requires the 'peft' dependency. Install it via RF-DETR extras, e.g.: pip install "rfdetr[lora]" or pip install "rfdetr[train]".NT) q_projv_projk_projqkvqueryr1value cls_tokenregister_tokens)r lora_alphause_doratarget_modules)peftrr ImportErrorbackboneencoder)rrrexc lora_configs r)rr=s| 3   K $2(2C2CA2F2N2NP[#\Ha /  I   sA A% A  A%) r torch.Tensorr r^r!r^r"r^r#r^r8r)r: list[str]r8r)rHrrIr7r8None)rlrrmr^r8rr)rtorch.nn.ModulerrrvzTrainConfig | Noner8z List[str])rrr8r)&__doc__ __future__rr_rtypingrrrtorch.nn.functionalnn functionalrcrfdetr.assets.model_weightsrr rfdetr.configrr rfdetr.utilities.decoratorsr rfdetr.utilities.loggerr rfdetr.utilities.state_dictr r rr__all__r]r__annotations__r*r<rPrrrrr6r)rs! #  \22.xx  T1*XWJ$ J$J$J$ J$  J$  J$Z781h8 8 8  8 v 4~t&