^jbdZddlmZdgZddlmZmZmZmZm Z m Z ddl Z ddl m Z ddlmZmZddlmZmZerdd l mZGd dZeZd d Zdd Zy)z=ModelContext and model-context builder for RF-DETR inference.) annotations ModelContext) TYPE_CHECKINGAnyCallableListOptionalcastN) TrainConfig) PostProcess build_model) apply_loraload_pretrain_weights) ModelConfigc>eZdZdZ d ddZddZy)rasLightweight model wrapper returned by RFDETR.get_model(). Provides the same attribute interface as the legacy ``main.py:Model`` but without importing or depending on ``populate_args()`` or the legacy stack. Args: model: The underlying ``nn.Module`` (LWDETR instance). postprocess: PostProcess instance for converting raw outputs to boxes. device: Device the model lives on. resolution: Input resolution (square side length in pixels). args: Namespace produced by :func:`build_namespace`. class_names: Optional list of class name strings loaded from checkpoint. Ncf||_||_||_||_||_||_d|_yN)model postprocessdevice resolutionargs class_namesinference_model)selfrrrrrrs [/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/inference.py__init__zModelContext.__init__'s8 & $ &#ctttgdft|jd}||||j _y)zReinitialize the detection head for a different number of classes. Args: num_classes: New number of output classes (including background). Nreinitialize_detection_head)r rintgetattrrr num_classes)rr#reinitialize_heads rr z(ModelContext.reinitialize_detection_head8s< !3%+!6 Li8jk+& + rr)rztorch.nn.Modulerr rz torch.devicerr!rrrzOptional[List[str]]returnNone)r#r!r%r&)__name__ __module__ __qualname____doc__rr rrrrsZ *,0$$!$ $  $  $)$ $",rc|dk(r|S|dk(r|jddS|dzdz}tj|g|zdddd|f}|d|z z}|S) aqAdapt a 3-channel pretrained conv weight tensor to *num_channels* input channels. When ``num_channels == 3``: returns the weight unchanged. When ``num_channels == 1``: averages weights across the original 3 channels. Otherwise (``num_channels != 1`` and ``num_channels != 3``): tiles the 3-channel pattern and scales by ``3 / num_channels`` to preserve activation magnitude. Args: num_channels: Target number of input channels. conv_weight: Original weight tensor of shape ``[out_ch, 3, H, W]``. Returns: Adapted weight tensor of shape ``[out_ch, num_channels, H, W]``. T)dimkeepdim)r/Ng@)meantorchcat) num_channels conv_weightrepeats weight_outs r_adapt_input_convr9FsyqqAt44aA%GK=72:1m|m;KLJs\12J rc Nddlm}tdd}|||}t|}g}|jt ||}t |dr*t|d|jk7r|j|_tt|dgxsg}t |dr$tt|dgxsg|k7r||_ |jr t||jdk7rRddl}|jdj j j"j$j&}|j)|} |j| _t-|j|j.} t0j2j5| | _|j.j6| j._| |jdj j j"j$_|j|jdj j j"j$_ t1j8|j8} t;|j<t|dgt|d d  } t?|| | |j@||xsd S) aBuild a ModelContext from ModelConfig without using legacy main.py:Model. Replicates ``Model.__init__`` logic: builds the nn.Module, optionally loads pretrain weights and applies LoRA. The model is intentionally kept on CPU; :func:`_ensure_model_on_device` in ``detr.py`` performs the deferred ``.to(device)`` on the first ``predict()`` / ``export()`` / ``optimize_for_inference()`` call. Keeping construction CPU-only prevents CUDA initialisation during ``__init__``, which would block DDP strategies (``ddp_notebook``, ``ddp_spawn``) from spawning child processes in notebook environments. Args: model_config: Architecture configuration. Returns: ModelContext with the model on CPU, ready for lazy device placement. r)_namespace_from_configs.) dataset_dir output_dirNr#num_keypoints_per_classr-postprocess_trace_alphag?) num_selectr? trace_alpha)rrrrrr)!rfdetr._namespacer;r r pretrain_weightsrhasattrr"r#listr? backbone_lorarr5copybackboneencoder embeddingspatch_embeddings projectiondeepcopy in_channelsr9weightr3nn Parameter requires_gradrr rArr) model_configr;dummy_train_configrnn_modelr_mc_kprHprojnew_proj new_weightrrs r_build_model_contextr[`s7:%E "<1C DD4 HK$$0+HlC  4 'GD-,HLLdLd,d+77D gl,ErJPbQ D3 4WT#>OOZZ==&+88&|'@'@$++N ((,,Z8(, (A(A%V^!$$,,77HHSXdXqXq!$$,,77HHU \\$++ &F ?? '.G LD";SA K ** '4  r)r5r!r6 torch.Tensorr%r\)rTrr%r)r* __future__r__all__typingrrrrr r r3 rfdetr.configr rfdetr.modelsr r rfdetr.models.weightsrrrr _ModelContextr9r[r+rrrdsK D"  EE %2C)(,(,V 4Jr