`i*ddlZddlmZddlmZmZddlmZmZm Z m Z ddl Z ddl m Z eGddZGdde ZGd d ZGd d ZdS) N)contextmanager) dataclassfield)AnyCallable NamedTupleOptionalceZdZUdZeejjZejje d<dZ e e e efe d<dS) TracingConfiga 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_factorytracerN concrete_args)__name__ __module__ __qualname____doc__rtorchfxTracerr __annotations__rr dictstrrw/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/torch/distributed/fsdp/_trace_utils.pyr r s`$$eEHODDDFEHODDD.2M8DcN+22222rr cXeZdZUdZejed<eee ej fed<dS)_ParamUsageInfoa6 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. module named_paramsN) rrrrnnModulerlisttupler Parameterrrrrr#sI$ IuS",./000000rrc,eZdZdZdejddfdZdS)_ExecutionInfoa1 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``. root_modulereturnNcj||_|g|_|gi|_g|_t |_dSN) curr_modulemodule_forward_ordermodule_to_param_usage_infosparam_forward_ordersetvisited_params)selfr's r__init__z_ExecutionInfo.__init__Ps@&16A]! T (8: 14r)rrrrr r!r2rrrr&r&:sB*7BI7$777777rr&ceZdZddZedejjdej fdZ de de d ej d e d e ed fd eeefdefdZ dde de deeejfdedejjjd e ed fd eeefdeedeedee ejjgejjfdejjfdZdS)_ExecOrderTracerr(Ncd|_dSr*) exec_info)r1s rr2z_ExecOrderTracer.__init__[s 37rr r'c#rKt||_|j}|j}t j|j||j|_t|}t j|j ||j||_ dV||_||_dS#||_||_wxYwr*) r&r6 call_module create_proxy functoolspartial_patched_call_modulernamed_parameters_patched_create_proxy)r1r r'orig_call_moduleorig_create_proxy fqn_to_params r patch_tracerz_ExecOrderTracer.patch_tracer^s' 44!-"/&.  %'7  K88::;; '/  &  N      4 EEE!1F "3F   "2F "3F  3 3 3 3s B&&B6r8r6rforwardargs.kwargscj|j|t|}|j}|rF||jvs Jd|j|jt |||} ||_g|j|<|||||} | |_| S)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`)r,appendr"r=r+r-r) r1r8r6rrCrDrErr+prev_curr_moduleoutputs rr<z%_ExecOrderTracer._patched_call_moduless6 &--f555F335566 +  )"GGGGbHGG  1)2G H O O 55   ' & 8: -f5VWdF;; 0  rr9rAkindtargetname type_exprproxy_factory_fnc $||||||| | } |j} |dvr|g} |D]}t|tjjr~|jj|vrp||jj}| |jj|f||jvr4|j ||j || r.|j | t| | n|dkrt| } | r.|j | t| | | D]B\}}||jvr4|j ||j |C| S)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. ) call_function call_methodNr8)r+ isinstancerrProxynoderKrGr0addr.r-rr"r=)r1r9r6rArJrKrDrErLrMrNproxyr+rargparam_s rr>z&_ExecOrderTracer._patched_create_proxys` &$i9I   + 3 3 3?A  H HC"377HHO|;; ,SX_ =$++SX_e,DEEE (@@@%488???%9@@GGG9+FMM' \BB] " " < < > >??L 5kBII#K>>) @ @5 888,00777188??? r)r(N)NNN)rrrr2rrrrr r!rBrr&r#rrrr<r$rTTargetr NoderSr>rrrr4r4Zs8888458?4444^4(**"*  *  *CHo*S#X* ****l##'PTOOO"O3 ,- O  O $OCHoOS#XOsmOC=O#8UX]OUX^,K#LMO OOOOOOrr4)r: contextlibr dataclassesrrtypingrrrr rtorch.nnr r rr&r4rrrr`s=%%%%%%((((((((666666666666  3333333 3.11111j111.77777777@TTTTTTTTTTr