^jۇUdZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZej"eZerddlZdd lmZdd lmZmZmZmZmZmZiZd ed <iZ d ed<iZ!d ed<ejDd:dZ#ejDd;dZ$ejDddZ)d?dZ*d=dZ+e,fZ-ded<er1e-ej\ej^ej`ejbfz Z-d@dZ2dAdBdZ3dCdZ4dDdZ5dEdZ6dFd Z7dGd!Z8d"Z9 dHd#Z:dId$Z;iZe=d*dKd+Z?e=d,d-dKd.Z@e=d,d/dKd0ZAdKd1ZBejDdLd2ZC dMd3ZDd4ZEd5ZFdNd6ZGdOd7ZHdMd8ZI dMd9ZJy)PuShared export utilities used by all exporter backends. Organised into five sections (search for the `# ── Name ──` banners): - **Patch and fix registries** — backend-keyed `_PATCHES` / `_FX_NODE_FIXES` / `_FX_PROGRAM_FIXES` populated via `@register_patch(backend, *paths)` / `@register_fx_node_fix` / `@register_fx_program_fix`, applied via `apply_patches` / `apply_fx_node_fixes` / `apply_fx_program_fixes`. - **Recursive structure traversal** — internal helpers (`_map_leaf_tensors`, `_iter_leaf_tensors`) that drive every other tensor utility. - **Public tensor utilities** — `get_leaf_tensors`, `duplicate_leaf_tensors`, `cast_leaf_tensors`, and `prepare_for_export` (sets attention/experts impl, patches non-exportable patterns, strips output flags). - **Export input preparers** — `@register_export_input_preparer(marker)` registry that precomputes the per-encoder kwargs (`cu_seqlens`, `position_ids`, audio chunks, …) the model would otherwise need data-dependent ops for. - **Decomposition** — `decompose_prefill_decode` (split a generative forward into prefill + decode) and `decompose_multimodal` + `is_multimodal` (split a multimodal forward into one entry per submodule), backed by `_capture_forward`. ) annotationsN)MutableMapping)Any)logging)is_torch_available)PreTrainedModel)'get_vision_bilinear_indices_and_weightsget_vision_cu_seqlensget_vision_merged_shapeget_vision_nearest_position_idsget_vision_position_idsget_vision_window_indexz*dict[str, list[tuple[Any, str, callable]]]_PATCHESzdict[str, list[callable]]_FX_NODE_FIXES_FX_PROGRAM_FIXESc#Kt||}t|||| dt|||y#t|||wxYww)zNSwap `obj.` with `factory(original)` for the duration of the block.N)getattrsetattr)obj attributefactoryoriginals g/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/exporters/utils.pypatch_attributerQsEsI&H CGH-.* Y)Y)s A5AAAc #Ktj5}|D]"\}}}|jt|||$ddddy#1swYyxYww)uInstall `(obj, attribute, factory)` patches for the duration of the block. Plural form of `patch_attribute` — each `factory(original)` returns the replacement callable. Originals are restored on exit, even if the body raises. N) contextlib ExitStack enter_contextr)patchesstackrrrs rpatch_attributesr"\s\    5'. J #CG   Y H I J sA,A  A AAc#|Kttj|g5ddddy#1swYyxYww)z:Install `_PATCHES[backend]` for the duration of the block.N)r"rget)backends r apply_patchesr&is2 (,,w3 4 s <0 <9<cfd}|S)zKAppend the decorated `(gm, node) -> bool` fix to `_FX_NODE_FIXES[backend]`.cRtjgj||SN)r setdefaultappendfnr%s r decoratorz'register_fx_node_fix..decoratorss#!!'2.55b9 r%r.s` rregister_fx_node_fixr2ps r/cfd}|S)uAppend the decorated `(exported_program) -> None` fix to `_FX_PROGRAM_FIXES[backend]`. Use this for fixes that need program-level context (range_constraints, graph_signature, state_dict) — the per-node `_FX_NODE_FIXES` shape only sees one node at a time. cRtjgj||Sr))rr*r+r,s rr.z*register_fx_program_fix..decorators#$$Wb188< r/r0r1s` rregister_fx_program_fixr5zs r/cJtj|gD] }|| y)zDApply `_FX_PROGRAM_FIXES[backend]` to `exported_program` (in place).N)rr$)r%exported_programfixs rapply_fx_program_fixesr9s' $$Wb1 r/cfd}|S)umAppend the decorated `factory(original)` to `_PATCHES[backend]`, once per `path`. Each `path` is a dotted Python path like `"torch.where"`, `"torch.Tensor.unsqueeze"`, or `"transformers.models.nllb_moe.modeling_nllb_moe.NllbMoeTop2Router._cast_classifier"`. The rightmost segment is the attribute to swap; the rest is the object that owns it. Paths are resolved at decoration time — submodules are imported as needed, falling back to `getattr` for class attributes. A path that fails to resolve (e.g. the backend isn't installed) is silently skipped so the module still imports. Passing multiple paths registers the SAME factory against each — useful for swapping the same method or torch op across several call sites (e.g. ``torch.unsqueeze`` + ``torch.Tensor.unsqueeze``, or one vision-attention forward across N model classes). cD]M}|jd\}}}t|}|&tjgj |||fO|S)N.) rpartition_resolve_dotted_pathrr*r+)r-pathobj_path_rrr%pathss rr.z!register_patch..decoratorsd JD%)__S%9 "Ha&x0C{    , 3 3S)R4H I  J  r/r0)r%rBr.s`` rregister_patchrCs r/cddl}|jd} |j|d}|ddD]#} |j|jd|}%|S#tt f$rt ||}YEwxYw#tt f$rYywxYw)uResolve a dotted Python path to the actual object — importing submodules where possible, falling back to `getattr` for class attributes (e.g. `torch.Tensor`). Returns `None` if the path can't be resolved (e.g. the backend isn't installed).rNr<) importlibsplit import_module__name__ ImportErrorAttributeErrorr)r?rFpartsrparts rr>r>s JJsOE %%eAh/!"I )D )--av.FG )   0 )c4( )  (s4A9 AA9A63A95A66A99B  B ctj|g}|jD]}t|tj j s(t|jjD]$}|jdk7r|D] }|||s $& |jj|jy#ttf$rYwxYw)uWalk every call_function node and apply the first matching `_FX_NODE_FIXES[backend]` fix, then DCE. Each fix has signature `(gm, node) -> bool`. Returning `True` means the fix consumed the node — no further fixes run against it. Fixes are expected to be disjoint by `node.target`; if multiple could apply, list order decides. After the walk, `Graph.eliminate_dead_code` runs on every sub-GraphModule and `gm.recompile()` is called once. PyTorch DCE occasionally raises `SystemError` / `KeyError` from `erase_node._update_args_kwargs` on orphaned symbolic-size nodes — we swallow both; any survivors are handled by the downstream backend optimizer. call_functionN)rr$modules isinstancetorchfx GraphModulelistgraphnodesopeliminate_dead_code recompile SystemErrorKeyError)r% graph_modulefixesgmnoder8s rapply_fx_node_fixesras   w +E""$ "ehh223 ( Dww/) r4=     HH ( ( * LLN X&   s*CCCztuple[type, ...]_LEAF_SKIP_TYPESc t|tr|St|tjr|St|tt t frt|fd|DSt|tr$t |D]}t||||<|St|dr8t|jD]\}}t||t||S)uApply `fn` to every tensor in a nested structure, preserving container types. Mutates dicts and `__dict__`-bearing objects in place (preserving identity — callers rely on this so downstream pops/mutations propagate back to the original mapping); rebuilds lists/tuples/sets/frozensets (immutable or order-sensitive containers). Skips non-traversable leaf types (enum, SymInt, etc.). c36K|]}t|ywr)_map_leaf_tensors).0itemr-s r z$_map_leaf_tensors..sE*44Es__dict__)rQrbrRTensorrUtuplesettypedictrfhasattrvarsitemsr)rr-kattrattr_vals ` rrfrfs#'( #u||$#w#eS)*tCyEEEE#tc 3A&s1vr2CF 3 sJ"3ioo/ @ND( C02> ? @ Jr/c#Kt|tryt|tjr |xsd|fyt|tt t fr 6KE4*0fXQug&c%jD)$5 5 5 6 C ))+ 7JC(.fXQse$CD)%6 6 6 7 j !%d3i888 " 6 78s7BD D AD D+D <D=D D D c*tt|S)aRecursively retrieve all leaf tensors from a potentially nested structure. Args: obj (`Any`): A tensor, dataclass, dict, list, tuple, or any nesting thereof. Returns: `dict[str, torch.Tensor]`: Flat mapping from dotted path strings to tensors. )rorz)rs rget_leaf_tensorsrs "3' ((r/c<tdfd }t||S)aClone tensors that appear more than once in an output structure. When a model returns the same tensor under two output names (e.g. `last_hidden_state` and `hidden_states[0]`), the ONNX optimizer deduplicates the two output nodes and renames one, breaking the expected name mapping. Cloning duplicates gives each output leaf a distinct identity so the optimizer has nothing to merge. cvt|vr|jSjt||Sr))idcloneadd)tensorseens r_dedupz&duplicate_leaf_tensors.._dedup+s0 f: <<> ! F r/r torch.Tensorreturnr)rmrf)rrrs @rduplicate_leaf_tensorsr!s  5D S& ))r/c,dfd }t||S)zJRecursively cast all floating-point tensors to the given dtype and device.cn|jr|jS|jS)Ndtypedevice)r)is_floating_pointto)rrrs r_castz cast_leaf_tensors.._cast7s68>8P8P8RvyyuVy4pX^XaXaioXaXppr/rre)rrrrs `` rcast_leaf_tensorsr4sq S% ((r/ct|dr |jS t|jjS#t$rYywxYw)a#`.device` for any `nn.Module`. `PreTrainedModel` exposes it directly via `ModuleUtilsMixin`; for plain submodules (e.g. a `Linear` or `MultiModalProjector` from a decomposed multimodal model) we fall back to the first parameter. Returns `None` if the module has no parameters at all.rN)rprnext parameters StopIterationmodels r module_devicer=sIuh||E$$&'... "= A A ct|dr |jS t|jjS#t$rYywxYw)zE`.dtype` for any `nn.Module`. Same fallback story as `module_device`.rN)rprrrrrs r module_dtyperIsGug{{E$$&'--- r) use_cacheoutput_attentionsoutput_hidden_states return_dict return_losscdD](}|j|d}|td|d|dt|dr"t|jddr td |j ddr td t Dcic]}||vs||j|}}tj5t||dddt|}t|}||t||| }|||fScc}w#1swY;xYw) u6Configure model and inputs for export. Mutates both `model` and `inputs` in place, returning `(model, inputs, output_flags)` where `output_flags` holds the values popped from `inputs` for `use_cache`, `return_dict`, etc. (to be applied reversibly onto `model.config` by `patch_model_config` during the trace). - Strips label inputs (`labels`, `future_values`) — loss computation is unsupported. - Pops output flags (`use_cache`, `return_dict`, …) from `inputs` so they don't appear as traced kwargs; the values are returned for the trace block to apply onto `model.config`. - Pre-computes data-dependent vision/audio kwargs registered via `@register_export_input_preparer` and writes them into `inputs`. - Casts input tensors to match the model's `dtype` / `device`. )labels future_valuesNzFound 'zM' in inputs. Loss computation is not supported during export. Please remove 'z+' from your inputs before calling export().configrFzFound 'model.config.return_loss=True'. Loss computation is not supported during export. Please set 'model.config.return_loss=False' before calling export().zFound 'return_loss=True' in inputs. Loss computation is not supported during export. Please remove 'return_loss' from your inputs or set it to False.r) pop ValueErrorrprrr$ _OUTPUT_FLAGSrRno_gradprecompute_export_inputsrrr)rinputs label_keyr~flag output_flagsrrs rprepare_for_exportrWs8"1  9d+  )%""+,WY uhGELL-$O S  zz-' O  8EWtPVD&**T**WLW 0 /0  E 5 !F F."6vF &, &&X 00s C7 C75 C<<DcT|jD]}t||dx}|cSy)zTReturn the first non-None value of `name` found on `model` or any of its submodules.N)rPr)rnamemoduler~s r_find_submodule_attrrs5--/VT40 0E =L r/zdict[tuple[str, ...], callable]_EXPORT_INPUT_PREPARERScfd}|S)u4Register `fn(model, inputs) -> None`. Dispatched when every `marker` is a key in `inputs` with a non-`None` value — no model_type list to maintain. Use multiple markers to narrow the match when a single kwarg is too ambiguous (e.g. `("input_features", "feature_lens")` for omni audio encoders).c|t<|Sr))r)r-markerss rr.z1register_export_input_preparer..decorators+-( r/r0)rr.s` rregister_export_input_preparerrs  r/grid_thwcX|d}t|d}||jdd}t||d<t|ddu}t||||d <t|d }t|d }||t ||||\|d <|d <t|d}|t |||\|d<|d<yy)aPrecompute helpers driven by `grid_thw`: `cu_seqlens`, `position_ids`, plus optional `window_index`/`cu_window_seqlens` (XNet-style window attn) and `bilinear_indices`/`bilinear_weights` (interpolation-based merging). Optional helpers are gated by the presence of their config attribute on the encoder (`window_size`+`patch_size` for window attention, `num_grid_per_side` for bilinear), so a model that doesn't use that feature won't get its kwarg injected. rspatial_merge_sizeN merge_sizesrE cu_seqlensaxis_dim)include_temporal position_ids window_size patch_size window_indexcu_window_seqlensnum_grid_per_sidebilinear_indicesbilinear_weights)rr$r rrr )rrrrrrrrs r_prepare_grid_thw_vision_inputsrsj!H-e5IJ!$ZZ q90:F<,E:>dJ4X?QdtuF>&umU (+z? ;~': ;-U4GH$Ah ');B >!"F+=$>%r/ target_sizesc|d}t|d}|t|||d<t|d}|Wtjjj |dd}t |d|d d \|d <|d <t|||d <yy)a NaViT-style packed encoders carry per-image `(h, w)` as `target_sizes` instead of `grid_thw`. Synthesise `grid_thw = [1, h, w]` and run the nearest-position-id / window-index / merged-shape helpers so the per-image Python loops move outside the traced graph.rnum_patches_per_sideNrwindow_kernel_size)rErrE)r~r)rrrrr merged_shape)rr rRnn functionalpadrr )rrrrrrs r_prepare_navit_vision_inputsrs .)L/7MN'!@Oc!d~-e5IJ%88&&**<q*I>U 8J18MZ[? ;~': ;"9GY!Z~ &r/input_features feature_lensc|d}|d}tjt|j}t |d}t |d}t |d}||||j \}} ||d<| |d<t |dr9|| ||j|j |d <|| |j |d <y || |d <|| |d <t |d ||d <y )uReplace `input_features`/`feature_lens` with precomputed `padded_feature`, `chunk_lengths`, `cu_seqlens`, `valid_indices` (+ `pool_indices` on Qwen2.5-Omni-style encoders) so the encoder's `.split(.tolist(), dim=0)` and related data-dependent ops happen outside the traced graph. The helpers (`chunk_and_pad_features`, `get_audio_cu_seqlens`, …) all live in the model's own ``modeling_*.py`` module, so we resolve them via ``type(model).__module__`` rather than hard-coding one Omni variant. ``n_window_infer`` selects the Qwen3-Omni-style four-arg ``get_audio_cu_seqlens`` over the Qwen2.5-Omni-style single-arg form. rrchunk_and_pad_featuresget_audio_cu_seqlensget_valid_indicespadded_feature chunk_lengthsn_window_inferr valid_indicesget_pool_indices pool_indicesN)sysrPrn __module__rn_windowrpr) rrrrrrrrrrs r_prepare_omni_audio_inputsrs.)L,-N [[e// 0F$V-EF"6+AB(;<$:>>"R3MB|"3M"B!D1C!D\!R~r/input_features_maskcddlm}t|d}t|d}||y|d}|j\}}||dzz}|j dj t j} |j||dj djdj t j} || | |||d <y) u4Precompute `cu_seqlens` for Qwen3-ASR — the encoder's call to ``get_audio_cu_seqlens`` has a data-dependent Python loop that we evaluate here so the encoder pops the result from ``kwargs``. Mirrors the few lines that build ``feature_lens``/``chunk_lengths`` in ``Qwen3ASREncoder.forward``. r)rrrNr)dimr) #models.qwen3_asr.modeling_qwen3_asrrrshapesumrrRlongviewreshape) rrrrrr batch_sizepadded_feature_length num_chunksrrs r_prepare_qwen3_asr_audio_inputsrsK#E:6H)%1ABN>1 !67(;(A(A%J%&8a<8J&**2.11%**=L',,ZRHLLQSLT\\]_`ccdidndnoM/ |^]efF<r/c$jdt|drjd}jd}|duxs%|duxs|jd|jdk(}|rdtt j |j j}|Dcic] }|vs||}}|j di|\}} |d<tjD]#\} } tfd| Ds| |%ycc}w) uInject precomputed tensors for data-dependent ops the model would otherwise hit during tracing. Two layers: - Outer LLM rope index (`get_rope_index`) — generic `hasattr` probe; covers Qwen-VL / GLM-4V etc. - Per-encoder preparer dispatched by marker kwargs present in `inputs` (e.g. `grid_thw`, `target_sizes`, `(input_features, feature_lens)`) — see `register_export_input_preparer`. A preparer fires only when every one of its markers is present in `inputs`. rNget_rope_index input_idsattention_maskrEc3DK|]}j|duywr))r$)rgmrs rriz+precompute_export_inputs..3s:Qvzz!}D(:s r0) r$rprrminspect signaturerrrrrall) rrr attn_mask is_prefill rope_paramsrs rope_inputsrrArpreparers ` rrrszz.!)ge=M.NJJ{+ JJ/0 $&g)t*;gyq?QU^UdUdefUg?g g//0D0DEPPQK1<LAV 1fQi<LKL2e22A[AOL!%1F> "5::<$ :': : UF #$ Ms $ D .D c#Kg|jtjtjfd}||_ |_y#|_wxYww)zCapture forward call kwargs into a list (one dict per call). Positional args are normalised to kwargs via `inspect.signature` so the captured dicts can be passed directly as `kwargs=inputs` to `torch.export`. ci} j|i|}|jjD]\}} j|}|jt j jk(r%|jtj|a|jt j jk7stj|||<j||i|Sr)) bind argumentsrrrkindr Parameter VAR_KEYWORDupdatecopydeepcopyVAR_POSITIONALr+) argskwargscapturedboundrr~paramcallsrsigs rwrapperz!_capture_forward..wrapperKs$)&) ??002 6KD%NN4(EzzW..::: e 45w00???!%u!5  6  X(((r/N)forwardrr functoolswraps)rrrrrs @@@r_capture_forwardr?scE~~H   H %C__X ) )FN" !sA A(AA( A%%A(c  t|5}|jd itj|ddddddtdkr.t dt |jdt|d tj||d ftj||d fd S#1swYzxYw#t$rB}t dt |jdt|jd|d}~wwxYw)uRun `model.generate()` for 2 tokens and capture prefill and decode inputs. Reuses the full generation machinery so every architecture (decoder-only, SSM, encoder-decoder, multi-modal, …) gets correct inputs without reimplementing the loop. Returns: `dict[str, tuple[torch.nn.Module, dict]]`: `{"prefill": (model, prefill_inputs), "decode": (model, decode_inputs)}` r)max_new_tokensmin_new_tokensNz$decompose_prefill_decode failed for . Inputs passed: z<. Make sure the inputs are compatible with model.generate().z6decompose_prefill_decode expected at least 2 calls to z;.forward() during generate(max_new_tokens=2), but captured z. This likely means generate() bypasses the top-level forward() (e.g. delegates to an inner model), so prefill/decode decomposition is not supported for this architecture.rrE)prefilldecoder0) rgenerater r  Exception RuntimeErrorrnrIrUkeyslen)rrres rdecompose_prefill_decoder$_s  e $ X ENN WT]]62 W1UV W X 5zA~DT%[EYEYDZ[??B5zlKV V  IIe$eAh/99U#U1X. # X X 24;3G3G2HI"6;;=123I J   s- B=+B1B=1B:6B== D=DD)multi_modal_projector connector embed_vision embed_audio)lm_headc8i}d}dD]&}|j|}|||us|||d<d}(|j}| ||ur||d<||jhD]6}ttzD]$}||vst ||dt ||||<&8|rd|vriS|S)uReturn `{attr_name: module}` for multi-modal submodules found on `model`. Uses the canonical `PreTrainedModel.get_encoder("image"/"audio")` and `get_decoder()` accessors for encoders and the language model. Projectors and `lm_head` are looked up by name on `model` and its `base_model` (e.g. `LlavaModel` under `LlavaForConditionalGeneration`). Only returns results when at least one modal encoder AND a language model are found — otherwise the model is not multi-modal and should be exported as a single unit. F)imageaudio)modalityN_encoderTlanguage_model) get_encoder get_decoder base_model_MULTIMODAL_PROJECTOR_NAMES_MULTIMODAL_LM_HEAD_NAMESr)rfound has_encoderr-encoderdecoderrootrs r_find_multimodal_submodulesr:s)+EK&##X#6  7%#7+2EXJh' (K!Gwe3")(()2/2KK 2D5 WT4%>%J%dD1d  22 *%7 Lr/c*tt|S)zTReturns `True` if the model is multi-modal with modal encoders and a language model.)boolr:rs r is_multimodalr=s +E2 33r/c t|}|s"tdt|jd t j 5}t j5|jDcic] \}}||jt|"}}}|ditj|dddddd|jDcic]\}}|r ||||dfc}}Scc}}w#1swYHxYw#1swYLxYw#t$rB}tdt|jdt|j!d|d}~wwxYwcc}}w) uCapture inputs to each multi-modal submodule via a single forward pass. Detects all known multi-modal submodules by attribute name (vision tower, projector, language model, lm_head, …) and captures their forward kwargs during one `model(**inputs)` call. Each submodule is returned as a separate `name: (module, inputs)` entry for independent export. The token-merge step (e.g. `masked_scatter` for multi-modal models) is intentionally left outside the exported graphs — it is the caller's responsibility to assemble `inputs_embeds` from the encoder outputs before running the decoder. Returns: `dict[str, tuple[torch.nn.Module, dict]]`: One `name: (module, inputs)` entry per detected submodule (image/audio encoder, projector, language model, lm_head). Raises: `ValueError`: if no known multi-modal submodules are found on the model. z8decompose_multimodal found no multi-modal submodules on zB. Expected an image/audio encoder + language model, found neither.Nz decompose_multimodal failed for rr<rr0)r:rrnrIrrrRrrrrrr r rr rUr!)rr submodulesr!rrsubmodule_inputsr#s rdecompose_multimodalrAsw&-U3J FtE{G[G[F\]O P    ! ! # +uemmo +XbXhXhXj HTfe))*:6*BCC     *DMM&) *  + +',,.  D& D ! v'-b122   + + + + .tE{/C/C.DDUVZ[a[f[f[hViUjjk l    s_DDC8.%C2 C81D9DE2C88D =DD  D E=EEcpt||}|d\}}t|s|St||}|d|d<|S)uDecompose a generative model into independently exportable `(model, forward_inputs)` pairs. Runs `decompose_prefill_decode` to capture prefill and decode forward kwargs from a real `model.generate(**inputs, max_new_tokens=2)`. If the prefill is multi-modal (per `is_multimodal`), further splits it into one entry per submodule (vision/audio encoder, projector, language model, `lm_head`) via `decompose_multimodal`. Args: model: Generative model. Must support `model.generate(**inputs)`. inputs: **Generate** kwargs — what you'd pass to `model.generate(**inputs)`. Returns: `{component_name: (submodel, forward_inputs)}`. Keys are `"prefill"` / `"decode"` for plain generative models and `"_encoder"` / `"multi_modal_projector"` / `"language_model"` / `"lm_head"` / `"decode"` for multi-modal generative models. rr)r$r=rA)rrstages prefill_modelprefill_inputs componentss rdecompose_for_generationrGsM&&eV 4F$*9$5!M>  ' %m^DJ!(+Jx r/)rrrryrr)r zlist[tuple[Any, str, callable]])r%ry)r%ryrNone)r%ryrBry)r?ry)rrr-callablerr))rrr{ry)rrrzdict[str, torch.Tensor])rrrr)rrrz torch.dtyperz torch.devicerr)r!PreTrainedModel | torch.nn.Modulerztorch.device | None)rrKrztorch.dtype | None)rrKrzMutableMapping[str, Any]rzRtuple[PreTrainedModel | torch.nn.Module, MutableMapping[str, Any], dict[str, Any]])rtorch.nn.Modulerryrz Any | None)rry)rrLrdict[str, Any]rrH)rrL)rr rrMrz'dict[str, tuple[torch.nn.Module, dict]])rr rzdict[str, torch.nn.Module])rr rr<)K__doc__ __future__rrr enumrrrcollections.abcrtypingrutilsrutils.import_utilsr get_loggerrIloggerrRmodeling_utilsr vision_utilsr r r r rrr__annotations__rrcontextmanagerrr"r&r2r5r9rCr>rarnrbEnumSymIntSymFloatSymBoolrfrzrrrrrrrrrrrrrrrrr$r3r4r:r=rArGr0r/rr_sv *#  *3   H %0"8: 49,.)./1,1 **       6&J'+W",ELL%..%--PP09, )*&) i 4' ,4'6N4'W4'|<>8=  +! ,! H /[0[$ 0.ASBS> 02GHgIg*$H "">" " "-"Nd("J4 )X $2,r/