a MSic?@szddlZddlZddlZddlZddlZddlmZmZmZddl m Z m Z m Z m Z mZmZmZddlmZmZmZmZmZddlmZddlmZedd Gd d d Zedd Gd d d eZedd ddZedd GdddeZedd GdddZ edd Gddde Z!edd Gddde Z"eD]Z#ddZ$e$e#qBddZ%eD]Z&e%e&qfdS)N) magic_methodsreflectable_magic_methodsGraph)TupleDictOptionalIterableAnyIteratorCallable)TargetNodeArgument base_types map_aggregate) compatibility)check_for_mutable_operationTis_backward_compatiblec @sbeZdZUeed<dZeed<dZeed<dZeed<dZ eed<dZ e ed<e d d d#e e eed fee efee eeed ddZe d d eddddZe d d d$e e eed fee efee eeeegdfdddZddZe d d eedddZe d d dedddZe d d deddd Ze d d dedd!d"Zd S)% TracerBasegraphFrecord_stack_tracescheck_mutable_operations trace_assertsproxy_buffer_attributesforwardtraced_func_nameTrN.)kindtargetargskwargsname type_exprreturncCs0|dkr|jrt||||j||||||S)a' Inserts a graph node given target, args, kwargs, and name. This method can be overridden to do extra checking, validation, or modification of values used in node creation. For example, one might want to disallow in-place operations from being recorded. call_function)rrr create_node)selfrrr r!r"r#r(J/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/fx/proxy.pyr&s  zTracerBase.create_nodeProxy)noder$cCs t||SN)r*)r'r+r(r(r)proxy-szTracerBase.proxy)rrr r!r"r#proxy_factory_fncCs||}||} t|ts"Jt| ts0J||||| ||} |sT|| } n|| } |jr|} | rt | } tj | }| }d || j_| S)ao Create a Node from the given arguments, then return the Node wrapped in a Proxy object. If kind = 'placeholder', then we're creating a Node that represents the parameter of a function. If we need to encode a default parameter, we use the ``args`` tuple. ``args`` is otherwise empty for ``placeholder`` Nodes. ) create_arg isinstancetupledictr&r-r_find_user_frame traceback walk_stack StackSummaryextractformatjoinr+ stack_trace)r'rrr r!r"r#r.args_Zkwargs_r+r-Z user_frameZwalk_stack_gensummaryZtb_linesr(r(r) create_proxy1s      zTracerBase.create_proxycsDtddg}r8jrtfdd|Drq8qs@dSS)zf Find the Python stack frame executing the user code during symbolic tracing. ztorch/fx/proxy.pyztorch/fx/symbolic_trace.pyc3s|]}jj| VqdSr,)f_code co_filenameendswith).0fileframer(r) cz.TracerBase._find_user_frame..N)inspect currentframef_backall)r'Zfx_filesr(rDr)r4VszTracerBase._find_user_frame)ar$csFt|tst|dr|St|trTt|drTtfdd|D}t||St|ttfr|t|fdd|DSt|tri}|D]2\}} |}dd}t || |||<q|St|t rt |j  |j  |jSt|tr |jSt|ts,|dus,|d ur0|Std t|dS) z A method that lowers the objects seen as arguments during symbolic evaluation into Argument types that can be stored in IR. Can be override to support more trace-specific types. __fx_create_arg___fieldsc3s|]}|VqdSr,r0rBelemr'r(r)rFzrGz(TracerBase.create_arg..c3s|]}|VqdSr,rOrPrRr(r)rF}rGcSst|trtddS)NzMKeys for dictionaries used as an argument cannot contain a Node. Got key: {k})r1r RuntimeError)argr(r(r)no_nodes z&TracerBase.create_arg..no_nodeN.zargument of type: )r1r*hasattrrMr2typelistr3itemsr0rslicestartstopstepr+rNotImplementedError)r'rLr rkvrUr(rRr)r0ks,      $  zTracerBase.create_arg)objr$cCs tddS)aFCalled when a proxy object is being converted to a boolean, such as when used in control flow. Normally we don't know what to do because we don't know the value of the proxy, but a custom tracer can attach more information to the graph node using create_node and can choose to return a value. zFsymbolically traced variables cannot be used as inputs to control flowN TraceErrorr'rbr(r(r)to_boolszTracerBase.to_boolcCs tddS)aACalled when a proxy object is being iterated over, such as when used in control flow. Normally we don't know what to do because we don't know the value of the proxy, but a custom tracer can attach more information to the graph node using create_node and can choose to return an iterator. aHProxy object cannot be iterated. This can be attempted when the Proxy is used in a loop or as a *args or **kwargs function argument. See the torch.fx docs on pytorch.org for a more detailed explanation of what types of control flow can be traced, and check out the Proxy docstring for help troubleshooting Proxy iteration errorsNrcrer(r(r)iterszTracerBase.itercCs t|dS)zCalled when a proxy object is has the keys() method called. This is what happens when ** is called on a proxy. This should return an iterator it ** is suppose to work in your custom tracer. keys Attributerer(r(r)rhszTracerBase.keys)NN)NNN)__name__ __module__ __qualname__r__annotations__rboolrrrrstrrr rrrrr rr&r-r r>r4r0rfr rgrhr(r(r(r)r s>        $-rcs"eZdZedfdd ZZS)GraphAppendingTracer)rcst||_dSr,)super__init__r)r'r __class__r(r)rss zGraphAppendingTracer.__init__)rkrlrmrrs __classcell__r(r(rtr)rqsrqFcCs |sJdSr,r()xr(r(r) assert_fnsrxc@s eZdZdS)rdN)rkrlrmr(r(r(r)rdsrdc@seZdZdZedddeddddZed d d Zd d d dZ dd ddZ e dd ddZ e d ddZeddddZddZedddZdS)r*a ``Proxy`` objects are ``Node`` wrappers that flow through the program during symbolic tracing and record all the operations (``torch`` function calls, method calls, operators) that they touch into the growing FX Graph. If you're doing graph transforms, you can wrap your own ``Proxy`` method around a raw ``Node`` so that you can use the overloaded operators to add additional things to a ``Graph``. ``Proxy`` objects cannot be iterated. In other words, the symbolic tracer will throw an error if a ``Proxy`` is used in a loop or as an ``*args``/``**kwargs`` function argument. There are two main ways around this: 1. Factor out the untraceable logic into a top-level function and use ``fx.wrap`` on it. 2. If the control flow is static (i.e. the loop trip count is based on some hyperparameter), the code can be kept in its original position and refactored into something like:: for i in range(self.some_hyperparameter): indexed_item = proxied_value[i] For a more detailed description into the Proxy internals, check out the "Proxy" section in `torch/fx/OVERVIEW.md` TrNzOptional[TracerBase])r+tracercCs"|durt|j}||_||_dSr,)rqrryr+)r'r+ryr(r(r)rss zProxy.__init__r$cCsd|jjdS)NzProxy())r+r"rRr(r(r)__repr__szProxy.__repr__rjcCs t||Sr,ri)r'r`r(r(r) __getattr__szProxy.__getattr__cOs|jdd|f||S)N call_method__call__)ryr>r'r r!r(r(r)rszProxy.__call__csnt}|dusJ|j}|dus&Jtt|j|jd}|jdkrbfddt |j DSj S)NUNPACK_SEQUENCEc3s|]}|VqdSr,r()rBirRr(r)rFrGz!Proxy.__iter__..) rHrIrJrXdisget_instructionsr?f_lastiopnamerangeargvalryrg)r'rE calling_frameinstr(rRr)__iter__s   zProxy.__iter__c Cs|jjrt}|dusJ|j}|dus.Jtt|j}|j d}||}|j dkr||d}|j dustJ||j dd}|j dkr|j dkp|j dk}|r|j dkr|j dt|fid S|j|S) NrPOP_JUMP_IF_TRUEr LOAD_GLOBALAssertionErrorLOAD_ASSERTION_ERROR RAISE_VARARGSr%T)ryrrHrIrJrXrrr?rrrTrr>rxrf) r'rErZinstscurrfirstlastZstarts_with_assertr(r(r)__bool__s&     zProxy.__bool__cCs |j|Sr,)ryrhrRr(r(r)rhsz Proxy.keyscCs tddS)Nz'len' is not supported in symbolic tracing by default. If you want this call to be recorded, please call torch.fx.wrap('len') at module scope)rSrRr(r(r)__len__"sz Proxy.__len__cs|r|nd}|r|ni}ifdd}tjj||tjj||tdkrrtdtd|tt }t |tj j r|j f|}|d|j||Stj|r|d|j||S|jd||||j|jd SdS) Nr(cst|rd|j<dSr,)r1ry)rLclsZtracersr(r) find_tracer.s z-Proxy.__torch_function__..find_tracerrz!Found multiple different tracers z" while trying to trace operations r~r%r")torchfxr+rlenrSrXrhnextrgr1_C ScriptMethodownerr>r" overridesis_tensor_method_or_propertyrkr_target_to_str)r orig_methodtypesr r!rryr(rr)__torch_function__'s&       zProxy.__torch_function__)N)NN)rkrlrm__doc__rrrsrpr|r}rr rrorrhr classmethodrr(r(r(r)r*s  r*c@s:eZdZeddeedddZeddZdd Z d S) rjTr)rootattrcCs||_||_|j|_d|_dSr,)rrry_node)r'rrr(r(r)rsEszAttribute.__init__cCs.|jdur(|jdt|j|jfij|_|jSNr%)rryr>getattrrrr+rRr(r(r)r+Ls zAttribute.nodecOs|jd|j|jf||S)Nr~)ryr>rrrr(r(r)rTszAttribute.__call__N) rkrlrmrr*rprspropertyr+rr(r(r(r)rjCs  rjcsneZdZdZeedfdd ZedddZe dd Z d d Z d d Z e ddZ ddZddZZS)ParameterProxyz A special proxy which lets "shape", "size", "dim", and a few other attribute accesses pass through to the underlying module parameter object, so that conditional tests on these attributes will not throw exception during tracing )ryr+cs0t||t|tjjs J||_||_dSr,)rrrsr1rnn Parameterparamr")r'ryr+r"rrtr(r)rs_szParameterProxy.__init__rzcCsd|jdS)NzParameterProxy(r{rrRr(r(r)r|eszParameterProxy.__repr__cCs|jjSr,)rshaperRr(r(r)rhszParameterProxy.shapecCs |jSr,)rsizerRr(r(r)rlszParameterProxy.sizecCs |jSr,)rdimrRr(r(r)roszParameterProxy.dimcCs|jjSr,)rndimrRr(r(r)rrszParameterProxy.ndimcCs |jSr,)rnumelrRr(r(r)rvszParameterProxy.numelcCs |jSr,)rnelementrRr(r(r)ryszParameterProxy.nelement)rkrlrmrrrrsrpr|rrrrrrrrvr(r(rtr)rXs  rcs4fdd}|_ddd}tt||dS)Ncs$|dj}tt}|d|||S)Nrr%)ryroperatorr>)r r!ryrmethodr(r)impls  z_scope..impl___)rkstripsetattrr*)rrZas_magicr(rr)_scope~s rcs:ddd}fdd}||_||_tt||dS)N__rrrcs tt}|jd|||fiSr)rrryr>)r'rhsrorig_method_namer(r)rs z!_define_reflectable..impl)rrkrmrr*)r method_namerr(rr)_define_reflectables  r)'rrrHrr5rrrrtypingrrrr r r r r+r rrrr_compatibilityroperator_schemasrrrqrx ValueErrorrdr*rjrrrrrr(r(r(r)s<$  / x$