+ j.*^RIt^RIHt^RIHt^RIHtHt^RIH t H t ^RI t ^RI H t ]!RR44t!RR ] 4t!R R 4t!R R 4tR#)N)Callable)contextmanager) dataclassfield)Any NamedTuplecna]tRt^ toRt]!]PPR7t Rt V3Rlt Rt Vt R#) TracingConfigau This represents a symbolic tracing configuration. Args: tracer (torch.fx.Tracer): An instance of :class:`torch.fx.Tracer` to use for symbolic tracing. The default value is the native :class:`torch.fx.Tracer` constructed with default arguments. However, the user may want to pass a different value such as the ``HFTracer`` for models in the HuggingFace Transformers_ library. .. _Transformers: https://huggingface.co/docs/transformers/index concrete_args (Optional[Dict[str, Any]]): Concrete arguments that should not be treated as ``torch.fx.Proxy`` when tracing the module ``forward()``. Passing ``concrete_args`` allows partially specializing the forward, e.g. to remove control flow or data structures. This ``concrete_args`` here is the same argument used in :meth:`~torch.fx.Tracer.trace`. )default_factoryNc~<V^8dQh/S[PP;R&S[S[S[3,R,;R&#)tracerN concrete_args)torchfxTracerdictstrr)format __classdict__s"d/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/distributed/fsdp/_trace_utils.py __annotate__TracingConfig.__annotate__ s4( HHOOD)*S>D(/+)__name__ __module__ __qualname____firstlineno____doc__rrrrrr__annotate_func____static_attributes____classdictcell__rs@rr r s*$$EHHOODF+/M+rr c0a]tRt^$toRtV3RltRtVtR#)_ParamUsageInfoa This is used for ``_ExecutionInfo.module_to_param_usage_infos`` to record execution information. The ``dict`` maps modules to a list of these ``_ParamUsageInfo`` instances, where each instance represents a group of parameters used together. Specifically, for each module key in the ``dict``, each instance of this class represents either: (1) the module and some sublist of its ``named_parameters()`` used together in execution (see ``_patched_create_proxy()``), or (2) a submodule and all of ``submodule.named_parameters()`` (see ``_patched_call_module()``). Type (1) corresponds to directly using parameters in ops without calling ``forward()``, and type (2) corresponds to calling ``forward()``. The mapped-to lists in the ``dict`` follow the execution order. c<V^8dQh/S[P;R&S[S[S[S[P 3,,;R&#)r module named_params)nnModulelisttupler Parameter)rrs"rr_ParamUsageInfo.__annotate__$s6& II'(uS",,./00)rrN)rrrrr r!r"r#r$s@rr&r&$srr&c6a]tRt^;toRtV3RlRltRtVtR#)_ExecutionInfoa This represents the execution order information from the forward pass. Attributes: curr_module (nn.Module): Current module being traced. module_forward_order (List[nn.Module]): The modules in (pre-)forward order, i.e. the order in which their ``forward()`` methods are called. Each call to a module's ``forward()`` corresponds to one element in the list. module_to_param_usage_infos (Dict[nn.Module, List[_ParamUsageInfo]]): Maps a module to a list of module execution infos. See :class:`_ParamUsageInfo` for details. param_forward_order (List[nn.Parameter]): The parameters in forward execution order, where only a parameter's first participation is included. visited_params (Set[nn.Parameter]): The parameters visited so far during the trace. This is only used during tracing for fast membership check. Invariant: The parameters in ``param_forward_order`` are exactly those in ``visited_params``. c8<V^8dQhRS[PRR/#)r root_modulereturnN)r*r+)rrs"rr_ExecutionInfo.__annotate__Qs77BII7$7rc`WnV.VnV./Vn.Vn\ 4VnR#N) curr_modulemodule_forward_ordermodule_to_param_usage_infosparam_forward_ordersetvisited_params)selfr3s&&r__init___ExecutionInfo.__init__Qs6&16A]! T (8: 14r)r8r9r:r;r=N)rrrrr r?r"r#r$s@rr1r1;s*77rr1cva]tRt^[toV3RlRlt]V3RlRl4tV3RlRltR V3RlR lltR t Vt R#) _ExecOrderTracerc<V^8dQhRR/#)r r4Nr)rrs"rr_ExecOrderTracer.__annotate__\s55$5rcRVnR#r7 exec_info)r>s&rr?_ExecOrderTracer.__init__\s 04rcb<V^8dQhRS[PPRS[P/#)r rr3)rrrr*r+)rrs"rrrD`s'44588??44rc#"\V4VnVPpVPp\P !VP W0P4Vn\VP44p\P !VPVVPV4VnRxW1nWAnR# Y1nYAni;i5ir7) r1rG call_module create_proxy functoolspartial_patched_call_modulernamed_parameters_patched_create_proxy)r>rr3orig_call_moduleorig_create_proxy fqn_to_params&&& r patch_tracer_ExecOrderTracer.patch_tracer_s' 4!--"//&..  % %'7 K88:; '//  & &  NN     4 !1 "3 "2 "3 sB$C 'B9+C 9CC c<V^8dQhRS[RS[RS[PRS[RS[S[R3,RS[S[S[3,RS[/#) r rKrGr(forwardargs.kwargsr4)rr1r*r+r-rrr)rrs"rrrDtse+++"+  +  +CHo+S#X+ +rc VPPV4\VP44pVPpV'dQWP 9d \ R4hVP VP,P\W744Tp W2n.VP V&V!W4WV4p WnV #)a Overrides ``call_module`` to save execution information to ``exec_info``. Note that ``call_module`` is called during symbolic tracing for each non-root module. Args: call_module (Callable): Original ``call_module`` to override. exec_info (_ExecutionInfo): Used to record execution information. module (nn.Module): Module corresponding to this ``call_module``. forward (Callable): ``forward()`` method of ``module`` to be called for this ``call_module``. args (Tuple[Any, ...]): Positional arguments for ``forward``. kwargs (Dict[str, Any]): Keyword arguments for ``forward``. Returns: Same return value as ``call_module``. zPThe current module should have already been processed by a patched `call_module`)r9appendr,rPr8r:AssertionErrorr&) r>rKrGr(rXrYrZr)r8prev_curr_moduleoutputs &&&&&&& rrO%_ExecOrderTracer._patched_call_modulets6 &&--f5F3356 ++ "G"GG$f  1 1)2G2G H O O5 ' &8: --f5Vd; 0 rNc<V^8dQhRS[RS[RS[S[S[P 3,RS[RS[PPPRS[ S[ R3,RS[S[S[ 3,R S[R ,R S[ R ,R S[S[PP.S[PP3,R ,R S[PP/ #)r rLrGrTkindtargetrY.rZnameN type_exprproxy_factory_fnr4)rr1rrr*r.rrnodeTargetr-rNodeProxy)rrs"rrrDsOOO"O3 ,- O  O $$OCHoOS#XODjO:O#EHHMM?EHHNN#BCdJO Orc  V!WEWgWV 4p VPp VR9EdVEe.p VFp\V\PP4'gK/VP P V9gKLW>P P ,pV PVP P V34WP9gKVPPV4VPPV4K V 'd,VPV ,P\W44V #VR8Xd\V P44p V 'd,VPV ,P\W44V FNwppWP9gKVPPV4VPPV4KP V #)a Overrides ``create_proxy`` to save execution information to ``exec_info``. Note that ``create_proxy`` is called during symbolic tracing for each leaf function/method/module. Args: create_proxy (Callable): Original ``create_proxy`` to override. exec_info (_ExecutionInfo): Used to record execution information. fqn_to_param (Dict[str, nn.Parameter]): ``dict`` version of the root module's ``named_parameters()`` with FQN as key and parameter as value. kind (str): Kind of the target method ('call_function', 'call_method', 'get_attr', 'call_module', 'placeholder', or 'output'). See :class:`torch.fx.Graph` for details. This is passed to ``create_proxy``. target (torch.fx.node.Target): Contains the string name of the function/method/module. This is passed to ``create_proxy``. args (Tuple[Any, ...]): Positional arguments for the function/ method/module. This is passed to ``create_proxy``. kwargs (Dict[str, Any]): Keyword arguments for the function/method/ module. This is passed to ``create_proxy`` name (Optional[str]): An optional string name for the ``Node`` created in ``create_proxy``. This is passed to ``create_proxy``. type_expr (Optional[Any]): An optional type annotation representing the Python type that the output of the node has. This is passed to ``create_proxy``. proxy_factory_fn (Callable[[torch.fx.Node], torch.fx.Proxy]): An alternative proxy constructor used in ``create_proxy``. This is passed to ``create_proxy``. Returns: torch.fx.Proxy: Created ``Node`` wrapped in a ``Proxy`` object. rK) call_function call_method)r8 isinstancerrrjrgrcr\r=addr;r:r&r,rP)r>rLrGrTrbrcrYrZrdrerfproxyr8r)argparam_s&&&&&&&&&&& rrQ&_ExecOrderTracer._patched_create_proxys` $9I  ++ 3 3?A C"377HHOO|; ,XX__ =$++SXX__e,DE (@(@@%4488?%99@@G  99+FMM' B ] " < < >?L55kBII#K>)5 8 88,,0071188?) rrF)NNN) rrrrr?rrUrOrQr"r#r$s@rrBrB[s@5544(++ZOOOrrB)rMcollections.abcr contextlibr dataclassesrrtypingrrrtorch.nnr*r r&r1rBrrrrzsV$%("  00 0.1j1.77@UUr