DŽgV4ddlmZddlmZddlmZddlmZmZm Z m Z m Z ddl m Z ddlmZddlmZddlmZd d lmcmZd d lZd d lmZmZmZmZmZmZm Z d d l!Z!d d l"m#Z#d d l$m%Z%ddgZ&edGddZ'edGdde'Z(y )) GraphModule)_make_graph_module)Graph)ArgumentNodeTargetmap_arg map_aggregate)Proxy)Tracer) compatibility)configN)AnyDictIteratorListOptionalTupleUnion)contextmanager)tqdm Interpreter TransformerTis_backward_compatiblec eZdZdZedd dej jdede e fdZ edddd d e e e efd ed efd ZeddZedZedde d efdZeddddeedfde eefd efdZeddddeedfde eefd efdZeddddeedfde eefd efdZeddddeedfde eefd efdZeddddeedfde eefd efdZeddddeedfde eefd efdZeddefdZedde d eee ffdZeddede d efdZy)!ra\ An Interpreter executes an FX graph Node-by-Node. This pattern can be useful for many things, including writing code transformations as well as analysis passes. Methods in the Interpreter class can be overridden to customize the behavior of execution. The map of overrideable methods in terms of call hierarchy:: run() +-- run_node +-- placeholder() +-- get_attr() +-- call_function() +-- call_method() +-- call_module() +-- output() Example: Suppose we want to swap all instances of ``torch.neg`` with ``torch.sigmoid`` and vice versa (including their ``Tensor`` method equivalents). We could subclass Interpreter like so:: class NegSigmSwapInterpreter(Interpreter): def call_function(self, target : Target, args : Tuple, kwargs : Dict) -> Any: if target == torch.sigmoid: return torch.neg(*args, **kwargs) return super().call_function(n) def call_method(self, target : Target, args : Tuple, kwargs : Dict) -> Any: if target == 'neg': call_self, *args_tail = args return call_self.sigmoid(*args_tail, **kwargs) return super().call_method(n) def fn(x): return torch.sigmoid(x).neg() gm = torch.fx.symbolic_trace(fn) input = torch.randn(3, 4) result = NegSigmSwapInterpreter(gm).run(input) torch.testing.assert_close(result, torch.neg(input).sigmoid()) Args: module (torch.nn.Module): The module to be executed garbage_collect_values (bool): Whether to delete values after their last use within the Module's execution. This ensures optimal memory usage during execution. This can be disabled to, for example, examine all of the intermediate values in the execution by looking at the ``Interpreter.env`` attribute. graph (Optional[Graph]): If passed, the interpreter will execute this graph instead of `module.graph`, using the provided `module` argument to satisfy any requests for state. TrNmodulegarbage_collect_valuesgraphc|_tjj_||_njj_i_d_|_d_jruii_ dtdtffd tjjD]6tjfdtjfd8yy)NrTnusercp|vr1||<jj|gj|yyN)user_to_last_uses setdefaultappend)r"r#node_to_last_useselfs \/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/torch/fx/interpreter.pyregister_last_usesz0Interpreter.__init__..register_last_usesbs=,,*.$Q'**55dB?FFqI-c|Sr%r"noder,s r+z&Interpreter.__init__..hs-?4-Hr-c|Sr%r/r0s r+r2z&Interpreter.__init__..is/A!T/Jr-)rdict named_modules submodulesr envnamerextra_tracebackr&rreversednodesr argskwargs)r*rrr r1r)r,s` @@@r+__init__zInterpreter.__init__Ms t{{88:;  DJ**DJ%'! &<##  & & 35 >@D " Jt JD J !!1!12 L #HI %JK L 'r-) initial_envenable_io_processingr?r@returnc t||ni|_|r|jj|}t||_t t |jj|jdtjr(tt|jjnddddtjd}|jjD]}|jd||jvr# |j||j|<|j0r.|j2j5|gD]}|j|=|j6d k(s|j|} |r|jj9| cS| cSy#t $r}|j"rd|j%}|j&r|j&dd |n t|}|d |j(z }|f|j&ddz|_t+|t,rt/|j&|d}~wwxYw) a Run `module` via interpretation and return the result. Args: *args: The arguments to the Module to run, in positional order initial_env (Optional[Dict[Node, Any]]): An optional starting environment for execution. This is a dict mapping `Node` to any value. This can be used, for example, to pre-populate results for certain `Nodes` so as to do only partial evaluation within the interpreter. enable_io_processing (bool): If true, we process the inputs and outputs with graph's process_inputs and process_outputs function first before using them. Returns: Any: The value returned from executing the Module Nz: rT)totaldescinitialpositionleavedisabledelayrzWhile executing z z Original traceback: output)r7r process_inputsiter args_iterrlenr;r8rverbose_progressstrlistdisable_progressupdaterun_node Exceptionr9 format_noder< stack_trace isinstanceKeyError RuntimeErrorrr&getopprocess_outputs) r*r?r@r<pbarr1emsg to_delete output_vals r+runzInterpreter.runks"#."9;r ,4::,,d3D)-d#djj../ II;bH_H_T$**2B2B-C)Deg(hiv?V?V^_aJJ$$ fD KKNtxx  !%t!4**!%!7!7!;!;D"!E,I+,ww("!XXd^ AUtzz11*=e[ee7 f '',T-=-=-?,@AC56VVQVVAYKtC51SC4T5E5E4FGGC!VaffQRj0AF!!X.*AFF3: s5F H7BH22H7ct|}i}|jjD] }|jdk(st |||<"|j |j |S)a  Run `module` via interpretation and return the result. This uses the "boxed" calling convention, where you pass a list of arguments, which will be cleared by the interpreter. This ensures that input tensors are promptly deallocated. placeholder)r?)rMr r;r]nextclearrd)r* args_listrNr7r"s r+ boxed_runzInterpreter.boxed_runsaO !! )Att}$iA ) xxCx((r-c#hKtj|5ddddy#1swYyxYwwr%) fx_tracebackset_current_meta)r*r1s r+_set_current_nodezInterpreter._set_current_nodes+  * *4 0     s2& 2/2r"c|j|5|j|\}}t|tsJt|tsJt ||j |j||cdddS#1swYyxYw)aB Run a specific node ``n`` and return the result. Calls into placeholder, get_attr, call_function, call_method, call_module, or output depending on ``node.op`` Args: n (Node): The Node to execute Returns: Any: The result of executing ``n`` N)rnfetch_args_kwargs_from_envrYtupler4getattrr]targetr*r"r<r=s r+rUzInterpreter.run_nodesx # #A & ?::1=LD&dE* **fd+ ++&74&qxxv>  ? ? ?s A A<<Brsrr<.r=ct|tsJ|jdrt|jS t |jS#t $r-}t|dkDr |dcYd}~Std|d|d}~wwxYw)a Execute a ``placeholder`` node. Note that this is stateful: ``Interpreter`` maintains an internal iterator over arguments passed to ``run`` and this method returns next() on that iterator. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation Returns: Any: The argument value that was retrieved. *rNz+Expected positional argument for parameter z, but one was not passed in!) rYrQ startswithrRrNrg StopIterationrOr[)r*rsr<r=sis r+rfzInterpreter.placeholders$&#&&&   S !' ' CDNN++  Ct9q=7N&)TU[T\\x'yzACC  Cs#A BB*B0BBcHt|tsJ|j|S)a0 Execute a ``get_attr`` node. Will retrieve an attribute value from the ``Module`` hierarchy of ``self.module``. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation Return: Any: The value of the attribute that was retrieved rYrQ fetch_attrr*rsr<r=s r+get_attrzInterpreter.get_attrs# &#&&&v&&r-c6t|trJ||i|S)a Execute a ``call_function`` node and return the result. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation Return Any: The value returned by the function invocation )rYrQr}s r+ call_functionzInterpreter.call_functions&fc***t&v&&r-cR|^}}t|tsJt|||i|S)a Execute a ``call_method`` node and return the result. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation Return Any: The value returned by the method invocation )rYrQrr)r*rsr<r=self_obj args_tails r+ call_methodzInterpreter.call_methods9 $9&#&&&(wx()>v>>r-cXt|tsJ|j|}||i|S)a Execute a ``call_module`` node and return the result. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation Return Any: The value returned by the module invocation r{r*rsr<r=submods r+ call_modulezInterpreter.call_module+s2$&#&&&(t&v&&r-c |dS)a4 Execute an ``output`` node. This really just retrieves the value referenced by the ``output`` node and returns it. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation Return: Any: The return value referenced by the output node rr/r}s r+rKzInterpreter.outputBs Awr-c |jd}|j}t|D]@\}}t||s#t ddj |d|dzt ||}B|S)z Fetch an attribute from the ``Module`` hierarchy of ``self.module``. Args: target (str): The fully-qualified name of the attribute to fetch Return: Any: The value of the attribute. .z#Node referenced nonexistent target Nr)splitr enumeratehasattrr[joinrr)r*rs target_atomsattr_itriatoms r+r|zInterpreter.fetch_attrUs}||C( ;; . /GAt8T*"%HR^_c`abc`cRdIeHf#ghhx.H /r-c|j|j|}t|tsJ|j|j|}t|t sJ||fS)aP Fetch the concrete values of ``args`` and ``kwargs`` of node ``n`` from the current execution environment. Args: n (Node): The node for which ``args`` and ``kwargs`` should be fetched. Return: Tuple[Tuple, Dict]: ``args`` and ``kwargs`` with concrete values for ``n``. )map_nodes_to_valuesr<rYrqr=r4rts r+rpz&Interpreter.fetch_args_kwargs_from_envhsZ''2$&&&))!((A6&$'''V|r-cDdtdtffd }t||S)aV Recursively descend through ``args`` and look up the concrete value for each ``Node`` in the current execution environment. Args: args (Argument): Data structure within which to look up concrete values n (Node): Node to which ``args`` belongs. This is only used for error reporting. n_argrAcb|jvrtdd|dj|S)NzNode z referenced nonexistent value z*! Run Graph.lint() to diagnose such issues)r7r[)rr"r*s r+load_argz1Interpreter.map_nodes_to_values..load_argsBDHH$"U1#-KE7S=$>??88E? "r-)rrr )r*r<r"rs` ` r+rzInterpreter.map_nodes_to_valueszs% #T #c # tX&&r-)TN) __name__ __module__ __qualname____doc__r torchnnModuleboolrrr>rrrrdrjrrnrUrrrQrfr~rrrrKr|rprr/r-r+rrs17p$/LuxxLL\dej\kL0L:$/CGgk7fxT3Y'@7f`d7fps7f07fr$/ )0 )$/?4?C?0?($/C8CE(C-4HCSWX[]`X`SaCfiC0C>$/''x}1E'PTUXZ]U]P^'cf'0'$$/'X'eHcM6J'UYZ]_bZbUc'hk'0'&$/?8?E(C-4H?SWX[]`X`Sa?fi?0?*$/'8'E(C-4H'SWX[]`X`Sa'fi'0',$/huXs]/CdSVX[S[nad0$$/#0$$/TeE4K6H0"$/''t''0'r-c reZdZdZedfdZeddddeedfd ee e fd e fd Z eddddeedfd ee e fd e fd Z eddddeedfd ee e fd e fd Zeddddeedfd ee e fd e fdZedd effd ZxZS)ra6 ``Transformer`` is a special type of interpreter that produces a new ``Module``. It exposes a ``transform()`` method that returns the transformed ``Module``. ``Transformer`` does not require arguments to run, as ``Interpreter`` does. ``Transformer`` works entirely symbolically. Example: Suppose we want to swap all instances of ``torch.neg`` with ``torch.sigmoid`` and vice versa (including their ``Tensor`` method equivalents). We could subclass ``Transformer`` like so:: class NegSigmSwapXformer(Transformer): def call_function(self, target : 'Target', args : Tuple[Argument, ...], kwargs : Dict[str, Any]) -> Any: if target == torch.sigmoid: return torch.neg(*args, **kwargs) return super().call_function(n) def call_method(self, target : 'Target', args : Tuple[Argument, ...], kwargs : Dict[str, Any]) -> Any: if target == 'neg': call_self, *args_tail = args return call_self.sigmoid(*args_tail, **kwargs) return super().call_method(n) def fn(x): return torch.sigmoid(x).neg() gm = torch.fx.symbolic_trace(fn) transformed : torch.nn.Module = NegSigmSwapXformer(gm).transform() input = torch.randn(3, 4) torch.testing.assert_close(transformed(input), torch.neg(input).sigmoid()) Args: module (GraphModule): The ``Module`` to be transformed. Trct||t|_|jj |j j Gddt}||j|_||j_ y)Nc0eZdZdeffd ZdefdZxZS)/Transformer.__init__..TransformerTracerr c>t|||_i|_yr%)superr>r tensor_attrs)r*r __class__s r+r>z8Transformer.__init__..TransformerTracer.__init__s "" =?!r-rAcy)NTr/)r*___s r+is_leaf_modulez>Transformer.__init__..TransformerTracer.is_leaf_modulesr-)rrrrr>rr __classcell__rs@r+TransformerTracerrs @e @  t r-r) rr>r new_graph set_codegenr _codegenr tracerroot)r*rrrs r+r>zTransformer.__init__s_   ""6<<#8#89  (7 ! r-rsrr<.r=rAct|tsJ|rtt|ntj j }t|jj|||jS)a Execute a ``placeholder`` node. In ``Transformer``, this is overridden to insert a new ``placeholder`` into the output graph. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation ) default_value) rYrQrgrMinspect Signatureemptyr rrfr)r*rsr<r=rs r+rfzTransformer.placeholdersZ&#&&&,0T$Z(g6G6G6M6M T^^//m/TVZVaVabbr-cbt|tsJ|jjd|||S)a Execute a ``get_attr`` node. In ``Transformer``, this is overridden to insert a new ``get_attr`` node into the output graph. Args: target (Target): The call target for this node. See `Node `__ for details on semantics args (Tuple): Tuple of positional args for this invocation kwargs (Dict): Dict of keyword arguments for this invocation r~)rYrQr create_proxyr}s r+r~zTransformer.get_attrs/&#&&&{{'' FD&IIr-ct|tsJ|j|}|jj ||j ||Sr%)rYrQr|rrforwardrs r+rzTransformer.call_modulesA&#&&&({{&&vv~~tVLLr-c>|jjd|||S)Nr)rrr}s r+rzTransformer.call_functions{{''vNNr-ctj5t| d}ddddtt t fdtfd}|jjt||}t|jjd}|jdk(sJ|jj!D]\}}||j|<t#|j$|jS#1swYxYw) z_ Transform ``self.module`` and return the transformed ``GraphModule``. F)r@NarAc>t|tr |jS|Sr%)rYr r1)rs r+ strip_proxyz*Transformer.transform..strip_proxys!+Au!5qvv<1> = =s C77D)rrrrr r>rrrrQrr rfr~rrrrrrs@r+rrs$L$/"0""$/c8cE(C-4HcSWX[]`X`Sacfkc0c"$/JJx}1EJPTUXZ]U]P^JchJ0J $/M8ME(C-4HMSWX[]`X`SaMfiM0M $/OXOeHcM6JOUYZ]_bZbUcOhkO0O$/?;?0?r-)) graph_moduler_lazy_graph_modulerr rr1rrrr r proxyr _symbolic_tracer _compatibilityr rCrtorch.fx.tracebackfx tracebackrlrtypingrrrrrrrr contextlibr torch.hubr__all__rrr/r-r+rs%2@@#))) DDD% - (d+v'v',v'p d+{?+{?,{?r-