f^(hk>ddlZddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z ddlmZmZmZddlZddlmcmZddlmZmZddlmZdd lmZdd l m!Z!m"Z"m#Z#dd l$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-gdZ.ej^e0Z1edGddZ2edGddZ3gdZ4edGddZ5edGdde5Z6eddZ7edGdde8Z9edGddZ:edGd d!e:Z;edGd"d#e:Z<edGd$d%e:Z=e"D] Z>d&Z?e?e>d'Z@e#D] ZAe@eA d(ZBd)ZCge)eDdeDd*ejjejjDcic]}|d+c}ZHd,eHe:<d-eHeI<d.eHeJ<eCeHeK<eHeJeHe&<eHeKeHe%<ycc}w)/N) OrderedDict)Iterator)fields is_dataclass)AnyCallableOptional)_fx_map_aggregate _fx_map_arg)CapturedTraceback) compatibility)Graph magic_methodsreflectable_magic_methods)immutable_dictimmutable_list)Argument base_typesNodeTarget)check_for_mutable_operation) TracerBaseGraphAppendingTracer TraceErrorProxy MetaProxy AttributeParameterProxyScopeScopeContextManagerFis_backward_compatiblec,eZdZdZdedeffd ZxZS)r a7Scope object that records the module path and the module type of a module. Scope is used to track the information of the module that contains a Node in a Graph of GraphModule. For example:: class Sub(torch.nn.Module): def forward(self, x): # This will be a call_method Node in GraphModule, # scope for this would be (module_path="sub", module_type=Sub) return x.transpose(1, 2) class M(torch.nn.Module): def __init__(self) -> None: self.sub = Sub() def forward(self, x): # This will be a call_method Node as well, # scope for this would be (module_path="", None) x = x.transpose(1, 2) x = self.sub(x) return x module_path module_typec>t|||_||_yN)super__init__r%r&)selfr%r& __class__s L/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/fx/proxy.pyr*zScope.__init__Fs &&)__name__ __module__ __qualname____doc__strrr* __classcell__r,s@r-r r ,s 0'C'c''r.r c8eZdZdZdedeffd ZdZdZxZS)r!zA context manager to track the Scope of Node during symbolic tracing. When entering a forward function of a Module, we'll update the scope information of the current module, and when we exit, we'll restore the previous scope information. scope current_scopect|tj||_|j|_|j |_||_yr()r)r*copy _prev_scoper%r&_scope)r+r7r8r,s r-r*zScopeContextManager.__init__SsD 99U+)55)55 r.c|jSr()r<r+s r- __enter__zScopeContextManager.__enter__as {{r.c|jj|j_|jj|j_yr()r;r%r<r&)r+argss r-__exit__zScopeContextManager.__exit__ds5"&"2"2">"> "&"2"2">"> r.) r/r0r1r2r r*r?rBr4r5s@r-r!r!Ls)   r.r!) nn_module_stacktorch_fnsource_fn_stack original_aten recompute ac_graph_idhas_backward_hook from_nodequantization_tag_numeric_debug_handlecustompartitioner_tagarg_kwarg_valsTcDeZdZUeed<dZeed<dZeed<dZeed<dZ eed<dZ e ed<e ed <e e ee effed <ee ee effed <ed  d$de dedeedfdee efdee deedefdZed deddfdZed  d%de dedeedfdee efdee deedeegdffdZdZed dedefdZed d ddefd!Zed d ddefd"Zed d ddefd#Z y)&rgraphFrecord_stack_tracescheck_mutable_operations trace_assertsproxy_buffer_attributesforwardtraced_func_namer7 module_stacknode_name_to_scopeTr"NkindtargetrA.kwargsname type_exprreturnc.|dk(r|jr t||||jj||||||}|jj |jj f|j|j<tjrtj}|jd} | r| |_ tD],} | |vstj|| |j | <.t"j$j'dz } |jdddkDr|dd} | |j d<n8|j(r,tj|j(|j d <t*j-d ||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 stack_tracer in_grad_fnrgrad_fn_seq_nrseq_nrrCzcreate_node %s)rSrrQ create_noder7r%r&rYr] fx_tracebackhas_preserved_node_metaget_current_metagetrb_COPY_META_FIELDSr:metatorchautograd_get_sequence_nrrXlogdebug) r+rZr[rAr\r]r^node current_metarbfield new_seq_nrs r-rgzTracerBase.create_nodesg$ ? "t'D'D 'f =zz%%dFD&$ R JJ " " JJ " ".  *  / / 1+7+H+H+JL&**=9K#. + FL('+yye1D'EDIIe$ F 88:Q>J a014)*:;B? ",DIIh    +/99T5F5F+GDII' ( "D) r.rsrct||Sr()r)r+rss r-proxyzTracerBase.proxysT4  r.proxy_factory_fnc|j|}|j|} t|tsJt| tsJ|j |||| ||} |s|j | } n|| } |j rV| jjs@djtjj| 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 isinstancetupledictrgrxrRrsrbjoinr extractformat) r+rZr[rAr\r]r^ryargs_kwargs_rsrxs r- create_proxyzTracerBase.create_proxys,%//&)%''''4(((feWdINJJt$E$T*E  # #EJJ,B,B%'WW->-F-F-H-O-O-Q%REJJ " r.ctjgd}r&jrtfd|Drnr&syS)zf Find the Python stack frame executing the user code during symbolic tracing. ) ztorch/fx/proxy.pyztorch/fx/_symbolic_trace.pyz%torch/fx/experimental/proxy_tensor.pyz torch/_ops.pyztorch/_tensor.pyztorch/utils/_python_dispatch.pyztorch/_prims_common/wrappers.pyztorch/_refs/__init__.pyz%torch/_refs/nn/functional/__init__.pyztorch/utils/_stats.pyc3jK|]*}jjj| ,ywr()f_code co_filenameendswith).0fileframes r- z.TracerBase._find_user_frame..s.@DELL,,55d;;s03N)inspect currentframef_backall)r+pt_filesrs @r-_find_user_framezTracerBase._find_user_framesV$$&  LLEHP  r.ac tjt|}| |||St|tr |j St |dr|j|St|trft |dr,|Dcgc]}|j|}}t||St||Dcgc]}|j|c}St|tr|Dcgc]}|j|c}St|tr t||St|trXt|j|j|j|j|j|j St|t"rXt#|j|j|j|j|j|j St|t$j&j(t$j&j*fr|St-|rdt/|Dcic]2}|j0|jt3||j04}}|j5d|j6d|St|gt8t:j<s||dur|St?dt|cc}wcc}wcc}wcc}w)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___fieldsra.zargument of type: ) _create_arg_bypassrktyper}rrshasattrrr~r|listr_create_arg_dictslicestartstopsteprangern_ops OpOverloadHigherOrderOperatorrrr]getattrrgr,renumEnumNotImplementedError)r+rhandlerelemrArur\s r-r|zTracerBase.create_argsl&%((a1  4# # a 66M Q+ ,&&t, , 5 !q)$;<<$-<<tAw~%47a@dDOOD1@A A 4 678dDOOD)8 8 4 #D!, , 5 !(''  5 !(''  EJJ115::3Q3QR SH !_$AY DOOGAuzz,BCCF##OQ[["fM M 3Z33 4 Q#XH!$6tAwi"@AAE=@8*sK%:K*-K/ 7K4objctd)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 flowrr+rs r-to_boolzTracerBase.to_boolgs T  r.ctd)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 errorsrrs r-iterzTracerBase.iterrs %  r.c$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. keysrrs r-rzTracerBase.keyss &yf%''r.NN)NNN)!r/r0r1r__annotations__rRboolrSrTrUrWr3r rr~rrrrrrr rrgrxrrrr|rrrrrr.r-rr{sY L %%&+d*M4$)T)&c% Lc5c?233S%T "2233$/##';;;HcM" ; S(]# ; sm ;C=; ;0;z$/!$!7!0!$/##'6:$$$CHo $ S#X $ sm $C=$#D67?3$0$L D$/EBCEBHEB0EBN$/ 7 t 0 $/  H 0 "$/((C(0(r.rc$eZdZdeffd ZxZS)rrQct|||_tdd|_t j |_i|_y)Nr{) r)r*rQr r7 collectionsrrXrY)r+rQr,s r-r*zGraphAppendingTracer.__init__s;  2t_ '335"$r.)r/r0r1rr*r4r5s@r-rrs%e%%r.rc |sJyr(rxs r- assert_fnrs H1r.c eZdZy)rN)r/r0r1rr.r-rrsr.rceZdZdZedddeddfdZd efd Zdd Z d e fd Z d e fd Z dZ ddZd edfdZdZd efdZeddZdZeddZy)ra ``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/README.md` Tr"NrstracerOptional[TracerBase]cN|t|j}||_||_yr()rrQrrs)r+rsrs r-r*zProxy.__init__s# >)$**5F  r.r_c6d|jjdS)NzProxy()rsr]r>s r-__repr__zProxy.__repr__s 'q))r.ct||Sr(r)r+ks r- __getattr__zProxy.__getattr__sq!!r.c|jSr(__dict__r>s r- __getstate__zProxy.__getstate__s }}r.cddl}i}|jjD]\}} |j||}|||< d|vsJd|vsJt|d|d}|jD]\}}||j|<|S#t$r@t j d||jj|j|}YwxYw)NrzVShallow copy %s of Proxy because it cannot be deepcopied. Proxy is created for node %srsr) r:ritemsdeepcopy Exceptionrqwarningrsr]r)r+memor:new_dictrvnew_obj new_proxys r- __deepcopy__zProxy.__deepcopy__s MM'') "DAq ''$--40"HQK "!!!8###(6*HX,>? NN$ &DAq$%I  q ! & ' 3IINN  $$))A, 'sB  ACCc||_yr(r)r+ds r- __setstate__zProxy.__setstate__s  r.cF|jjdd|f|z|S)N call_method__call__)rrr+rAr\s r-rzProxy.__call__s({{'' :w~v  r.ctj}|J|j}|Jtt j |j }tjdk\rddl m }|||jd}n|jdz}||}|jdk(rfdt|jDSjj!S) N r bisect_leftc|jSr(offsetrs r-z Proxy.__iter__..s r.keyUNPACK_SEQUENCEc3(K|] }| ywr(r)rir+s r-rz!Proxy.__iter__..s8DG8s)rrrrdisget_instructionsrsys version_infobisectrf_lastiopnamerargvalrr)r+r calling_frame inst_listrinst_idxinsts` r-__iter__zProxy.__iter__s$$&    (((--m.B.BCD   w & *"=006HH%,,1H" ;;+ +8U4;;%78 8{{%%r.c\|jjdtj|fiSNra)rroperatorabsr>s r-__abs__z Proxy.__abs__ s${{''wPRSSr.c|jjr4tj}|J|j}|Jt t j|j}tjdk\rddl m }|||jd}n|jdz}||}|jdk(r||dz}|jJ||jdzdz }|jd k(xr|j d k(xs|jd k(} | r3|jd k(r$|jj#d t$|fiy|jj'|S)Nrrrc|jSr(rrs r-rz Proxy.__bool__..s ahhr.rrPOP_JUMP_IF_TRUEr LOAD_GLOBALAssertionErrorLOAD_ASSERTION_ERROR RAISE_VARARGSraT)rrTrrrrrrrrrrrrrargrrrr) r+rrinstsrcurrfirstlaststarts_with_asserts r-__bool__zProxy.__bool__ sS ;; $ $((*E$ $$!LLM , ,,--m.B.BCDE7*.!%)>)>DVW#++q0:D{{00cAgxx+++TXX]Q./LLM19 (88>||'==# &$++*HKK,,_i$RTU{{""4((r.c8|jj|Sr()rrr>s r-rz Proxy.keys-s{{%%r.ctd)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 RuntimeErrorr>s r-__len__z Proxy.__len__1s   r.c |r|nd}|r|ni}ifd}t||t||tdkDr(tdtj d|t t j }t|tjjr.|jf|z}|jd|j||Stjj|r|jd|j ||St|tj"j$r td|jd||||j&j)|j  S) Nrc>t|rd|j<yyr()r}r)rclstracerss r- find_tracerz-Proxy.__torch_function__..find_tracer?s !S!$(!"r.r z!Found multiple different tracers z" while trying to trace operations rz1Unable to symbolically trace HigherOrderOperatorsrar]) map_aggregatelenrrrnextrr}rn_C ScriptMethodownerrr] overridesis_tensor_method_or_propertyr/rrrQ_target_to_str)r orig_methodtypesrAr\rrrs` @r-__torch_function__zProxy.__torch_function__8s^t!r#% ) dK(fk* w*+ k588#8#8 9%%'$.D&&}k6F6FfU U ?? 7 7 D&&{33T6 +uzz'E'EF"#VWW&&\\001E1EF ' r.r()r_r)r_rr)r/r0r1r2rrr*r3rrrrrrrrrrrrrr classmethodr)rr.r-rrs8$/T+A0*#*" dD4 &(7+&(T)$)@$/&0& %%r.rcReZdZdZ d deddffd ZdefdZed fd Z xZ S) rzW A Proxy subclass that propagates metadata (meta['val']) during graph tracing. rsrrc4t|||||_yr()r)r* fake_mode)r+rsrr-r,s r-r*zMetaProxy.__init__gs v&"r.r_c6d|jjdS)Nz MetaProxy(rrr>s r-rzMetaProxy.__repr__msDIINN+1--r.c |r|nd}|r|ni}d}|D]}t|ts|}n|Jdt | ||||}|j5||Dcgc]-}t|t r|j jdn|/c}i||j jd<dddt|j |j|jScc}w#1swY9xYw)Nrz5No MetaProxy found in arguments, but one is expected.val) r}rr)r)r-rrsrmr) rr'r(rAr\ meta_proxyr rxrr,s r-r)zMetaProxy.__torch_function__pst!r  C#y)    " C B C "*;tVL  ! ! %0MQR 1e(s r-rszAttribute.nodesN :: 11499dii*@"d Jzzr.cn|jjd|j|jf|z|S)Nr)rrr4r3rs r-rzAttribute.__call__s1{{'' 499tyylT&96  r.N) r/r0r1rrr3r*propertyrsrrr.r-rrs@$/*U*#*0*  r.rcpeZdZdZdedeffd ZdefdZe dZ dZ d Z e d Z d Zd ZxZS) rz 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 rrsct|||t|tjj sJ||_||_yr()r)r*r}rnnn Parameterparamr])r+rrsr]r>r,s r-r*zParameterProxy.__init__s: v&%!3!3444  r.r_c"d|jdS)NzParameterProxy(rrr>s r-rzParameterProxy.__repr__s  1--r.c.|jjSr()r>shaper>s r-rAzParameterProxy.shapeszzr.c6|jjSr()r>sizer>s r-rCzParameterProxy.sizeszz  r.c6|jjSr()r>dimr>s r-rEzParameterProxy.dimszz~~r.c.|jjSr()r>ndimr>s r-rGzParameterProxy.ndimszzr.c6|jjSr()r>numelr>s r-rIzParameterProxy.numelszz!!r.c6|jjSr()r>nelementr>s r-rKzParameterProxy.nelementszz""$$r.)r/r0r1r2rrr*r3rr9rArCrErGrIrKr4r5s@r-rrsc z .#.  ! "%r.rcjfd}|_djdd}tt||y)Ncj|dj}tt}|jd|||S)Nrra)rrrr)rAr\rr[methods r-implz_scope..impls3!W^^FXv.F&&fM Mr.___)r/stripsetattrr)rNrOas_magics` r-r<r<s6 N   S)*"-x&r.cxdjdd}fd}||_||_tt||y)N__rrQrPcdtt}|jjd|||fiSr)rrrr)r+rhsr[orig_method_names r-rOz!_define_reflectable..impls/#34{{''#tbQQr.)rRr/r1rSr)rY method_namerOs` r-_define_reflectabler[sA(..s34B7KR DM#D E;%r.ctd|)NzJKeys for dictionaries used as an argument cannot contain a Node. Got key: r)r s r-_no_nodes_errorr]s    r.ci}|jD]J\}}t|ts!|j|}t |t |j|||<L|Sr()rr}r3r|map_argr])r+rrrrs r-rrs] A "1!S!"A A 'q!!" Hr..c|Sr(rr+rs r-rrsqr.c|jSr()rsrbs r-rrs AFFr.c\t|Dcgc]}|j|c}Scc}wr()r~r|r+rrs r-rrs#EUV2WT4??43H2W,X2Ws)cJ|Dcgc]}|j|c}Scc}wr()r|res r-rrsa+PdDOOD,A+P+Ps )Lrr:rrrloggingrrrcollections.abcr dataclassesrrtypingrrr rntorch.fx.tracebackfx tracebackrhtorch._Cr rr r_torch.utils._tracebackr _compatibilityrrQrrrimmutable_collectionsrrrsrrrroperator_schemasr__all__ getLoggerr/rqr r!rlrrr ValueErrorrrrrrrNr<r[rYr]rrrrrrr~rr)ts0r-rws  #$,** ))O4)BBA449 g!e,''-'>e,-:"d+N(N(,N(dd+%:%,%e, - d+  , d+{{,{|e,#I#I-#ILd+  , 0e,"%U"%-"%J F' 6N  &2*()*    T  S      &&    35X5P4+4%7%=>"%7%=>" s$ H