*iddlZddlZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z ddl mZmZddlmZmZmZddlZddlmcmZddlmZddlmZddlmZdd lm Z dd l!m"Z"d d l#m$Z$d d l%m&Z&m'Z'm(Z(d dl)m*Z*m+Z+d dl,m-Z-m.Z.m/Z/m0Z0d dl1m2Z2gdZ3ejhe5Z6ee5dZ7de8de9fdZ:de;e8dfdee$dGddZ?e$dGddZ@gd ZAe$d!Gd"d#ZBd;d$e=fd%ZCe$d!Gd&d'eBZDe$dd(ZEe$d!Gd)d*eFZGe$d!Gd+d,ZHe$dGd-d.eHZIe$d!Gd/d0eHZJe$dGd1d2eHZKe'D] ZLd3ZMeMeLd4ZNe(D] ZOeNeO d5ZPd6ZQge.eRdeRdejjejjDcic]}|d7c}ZVd8eVeH<d9eVe;<d:eVeW<eQeVe<<eVeWeVe+<eVe<eVe*<ycc}w)<N) OrderedDict)CallableIterator)fields is_dataclass)AnyOptionalTypeVar) _fx_map_arg)is_opaque_value_type)getArtifactLogger) tree_map_)CapturedTraceback) compatibility)Graph magic_methodsreflectable_magic_methods)immutable_dictimmutable_list)Argument base_typesNodeTarget)check_for_mutable_operation) TracerBaseGraphAppendingTracer TraceErrorProxy MetaProxy AttributeParameterProxyScopeScopeContextManager annotationobjreturncddl}ddl}t||j|j|j |j |jfS)z Returns True if obj is an arbitrary callable (function, lambda, method, etc.) that requires special tracing to handle. These cannot be symbolically traced using the standard Proxy mechanism. rN) functoolstypes isinstance FunctionType MethodTypeBuiltinFunctionTypeBuiltinMethodTypepartial)r&r)r*s P/var/www/pod-logistic/pod-ai/venv/lib/python3.12/site-packages/torch/fx/proxy.py_is_arbitrary_callabler21sL          % %  # #       args.kwargscfdtd}d|d|ffd }t||t||S)z Recursively searches args and kwargs for any arbitrary callable. Returns the first arbitrary callable found, or None if none exist. N_Tr&r'c*|St|r||SN)r2)r&founds r1checkz'_find_arbitrary_callable..checkQs  J !# &E r3)r r)r4r5r7r;r:s @r1_find_arbitrary_callabler<FsA E B2"eT eV Lr3Fis_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|||_||_yr9)super__init__r@rA)selfr@rA __class__s r1rDzScope.__init__xs &&r3)__name__ __module__ __qualname____doc__strrrD __classcell__rFs@r1r#r#^s 0'C'c''r3r#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 |_||_yr9)rCrDcopy _prev_scoper@rA_scope)rErOrPrFs r1rDzScopeContextManager.__init__sD 99U+)55)55 r3c|jSr9)rTrEs r1 __enter__zScopeContextManager.__enter__s {{r3c|jj|j_|jj|j_yr9)rSr@rTrA)rEr4s r1__exit__zScopeContextManager.__exit__s5"&"2"2">"> "&"2"2">"> r3) rGrHrIrJr#rDrWrYrLrMs@r1r$r$~s)   r3r$) nn_module_stacktorch_fnsource_fn_stack original_aten recompute ac_graph_idhas_backward_hook from_nodequantization_tag_numeric_debug_handlecustompartitioner_tagTceZdZUeed<dZeed<dZeed<dZeed<dZ eed<dZ eed<dZ e ed <e ed <ee ee effed <ee ee effed <ed  d'de dedeedfdee efdee deedefdZdej4dej4fdZed deddfdZed  d(de dedeedfdee efdee deedeegdffdZd Zed d!edefd"Z ed d#ddefd$Z!ed d#dde"fd%Z#ed d#ddefd&Z$y))rgraphFrecord_stack_traces!_record_forward_stack_traces_onlycheck_mutable_operations trace_assertsproxy_buffer_attributesforwardtraced_func_namerO module_stacknode_name_to_scopeTr=Nkindtargetr4.r5name type_exprr'cz|dk(r|jr t||||jj||||||}|jj |jj f|j|j<tjrUtj}|jd} | r(| |_ tj| vrd|jd<t D],} | |vst#j"|| |j| <.t%|j} | 0t&j)d| |j| |jd<tj*} | d|jd<d| jvr(| jjd|jd<d| jvrY| jjd|_ n8|j,r,t#j"|j,|jd <|j.ru|jsit1j2j5} | rE|j7| } | r2d j9| j;j=|_ 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_traceTis_gradient_acczAssigning new_seq_nr %s to %sseq_nris_functional_regeneratedrdrZzcreate_node %s) rjrrg create_noderOr@rArprs fx_tracebackhas_preserved_node_metaget_current_metagetrwGRADIENT_ACC_SPECIAL_STACKmeta_COPY_META_FIELDSrR _get_seq_nrannotation_logdebugget_current_replay_noderorhrextractsummary_filter_traceback_framesjoinformatstriplog)rErqrrr4r5rsrtnode current_metarwfield new_seq_nr replay_nodeuser_stack_summarys r1r|zTracerBase.create_nodesS$ ? "t'D'D 'f =zz%%dFD&$ R JJ " " JJ " ".  *  / / 1+7+H+H+JL&**=9K#. ::kI37DII/0+ FL('+yye1D'EDIIe$ F%TYY/J%$$3Z'1 (# !- D D FK&9= 56{///*5*:*:*>*>x*HDIIh' K$4$44'2'7'7';';M'JD$   +/99T5F5F+GDII' (  # #D,<,z.TracerBase._find_user_frame..~s.@DELL,,55d;;s03N)inspect currentframef_backall)rEpt_filesrs @r1_find_user_framezTracerBase._find_user_framefsV$$&  LLEHP  r3ac 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-t|r|St/|rdt1|Dcic]2}|j2|jt5||j24}}|j7d|j8d|St|gt:t<j>s||dur|StAdt|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___fieldsrv.zargument of type: )!_create_arg_bypassrrr+rrhasattrrrrlistr_create_arg_dictslicestartstopsteprangetorch_ops OpOverloadHigherOrderOperatorr rrrsgetattrr|rFrenumEnumNotImplementedError)rErhandlerelemr4rr5s r1rzTracerBase.create_args}&%((a1  4# # a 66M Q+ ,&&t, , 5 !q)$;<<$-<<tAw~%47a@dDOOD1@A A 4 678dDOOD)8 8 4 #D!, , 5 !(''  5 !(''  EJJ115::3Q3QR SH !$q' *H !_$AY DOOGAuzz,BCCF##OQ[["fM M 3Z33 4 Q#XH!$6tAwi"@AAK=@80sK;:L-L"7L r&ctd)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 flowrrEr&s r1to_boolzTracerBase.to_bools T  r3ctd)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 r1iterzTracerBase.iters %  r3c$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. keysr!rs r1rzTracerBase.keyss &yf%''r3NN)NNN)%rGrHrIr__annotations__rhboolrirjrkrlrnrKr#rrrrrrrrr rr|rrrrrrrrrrrrrr3r1rrs L %%/4%t3&+d*M4$)T)&c% Lc5c?233S%T "2233$/##'JJJHcM" J S(]# J sm JC=J J0JX$="+"8"8$=   $=L$/!$!7!0!$/##'6:###CHo # S#X # sm #C=##D67?3#0#J D$/HBCHBHHB0HBT$/ 7 t 0 $/  H 0 "$/((C(0(r3r node_namec^tj}d}|jdddkDrtj d||dd}nqt j jjr(tj d||jd}n!t jjd z }t j jjsItj}|3d|jvr%tj d ||jd}|S) a: Returns the seq_nr node meta for the current proxy node that we're creating. The seq_nr number in node meta is related to but not the same as the "sequence number" in autograd. We use the seq_nr to correlate forward and backward nodes in the traced FX graphs (e.g. in copy_fwd_metadata_to_bw_nodes). The corresponding forward and backward FX graph nodes should have the same seq_nr. The ordering of the seq_nr in the graph does not indicate when the node is executed. For example, the nodes in the invoke_subgraph HOP's subgraph may be called multiple times by different HOP nodes, but these nodes only have a single seq_nr, which may be smaller, the same, or larger than the calling HOP. `node_name` is the name of the node that we're creating. It is used for logging only. N in_grad_fnrz+%s: seq_nr from current_meta grad_fn_seq_nrgrad_fn_seq_nrrz#%s: seq_nr from current_meta seq_nrryrz%s: seq_nr from replay_node) r}rrrrrfxr_is_preserving_node_seq_nrautograd_get_sequence_nrrr)rrrrs r1rrs $0#@#@#BLJ a(1,JIV!"23B7    6 6 8 BIN!%%h/ ^^446: 88   8 8 :)@@B  ";+++$$%BIN(--h7 r3c$eZdZdeffd ZxZS)rrgct|||_tdd|_t j |_i|_y)Nr{) rCrDrgr#rO collectionsrrorp)rErgrFs r1rDzGraphAppendingTracer.__init__2s;  2t_ '335"$r3)rGrHrIrrDrLrMs@r1rr0s%e%%r3rc|s tdy)NzAssertion failed)rxs r1 assert_fnr:s /00 r3c eZdZy)rN)rGrHrIrr3r1rr@sr3rceZdZdZedddeddfdZd 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=NrtracerOptional[TracerBase]cN|t|j}||_||_yr9)rrgrr)rErrs r1rDzProxy.__init__cs# >)$**5F  r3r'c6d|jjdS)NzProxy()rrsrVs r1__repr__zProxy.__repr__ks 'q))r3ct||Sr9r)rEks r1 __getattr__zProxy.__getattr__nsq!!r3c|jSr9__dict__rVs r1 __getstate__zProxy.__getstate__ss }}r3cddl}i}|jjD]\}} |j||}|||< d|vr tdd|vr tdt|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 %srz.'node' not in new_dict during proxy unpicklingrz0'tracer' not in new_dict during proxy unpickling) rRritemsdeepcopy Exceptionrwarningrrsrr)rEmemorRnew_dictrvnew_obj new_proxys r1 __deepcopy__zProxy.__deepcopy__vs MM'') "DAq ''$--40"HQK "  ! !QR R 8 # !ST T(6*HX,>? NN$ &DAq$%I  q ! &! ' 3IINN  $$))A, 'sBAC$#C$c||_yr9r)rEds r1 __setstate__zProxy.__setstate__s  r3cF|jjdd|f|z|S)N call_method__call__)rrrEr4r5s r1rzProxy.__call__s({{'' :w~v  r3ctj}| td|j}| tdt t j |j}tjdk\rddl m }|||jd}n|jdz}||}|jd k(rfd t|jDSj j#S) N$inspect.currentframe() returned Noneframe.f_back is None r bisect_leftc|jSr9offsetrs r1z Proxy.__iter__..s r3keyUNPACK_SEQUENCEc3(K|] }| ywr9r)rrrEs r1rz!Proxy.__iter__..s8DG8s)rrrrrdisget_instructionsrsys version_infobisectrf_lastiopnamerargvalrr)rEr calling_frame inst_listrinst_idxinsts` r1__iter__zProxy.__iter__s$$& = !GH H   !78 8--m.B.BCD   w & *"=006HH%,,1H" ;;+ +8U4;;%78 8{{%%r3c\|jjdtj|fiSNrv)rroperatorabsrVs r1__abs__z Proxy.__abs__s${{''wPRSSr3c|jjrOtj}| t d|j }| t dt tj|j}tjdk\rddl m }|||jd}n|jdz}||}|jd k(r||d z}|j t d ||j dzd z }|jd k(xr|j"d k(xs|jdk(} | r3|jdk(r$|jj%dt&|fiy|jj)|S)Nrrrrrc|jSr9rrs r1rz Proxy.__bool__..s ahhr3rrPOP_JUMP_IF_TRUErz%inst.arg is None for POP_JUMP_IF_TRUE LOAD_GLOBALrLOAD_ASSERTION_ERROR RAISE_VARARGSrvT)rrkrrrrrr"r#rr$r%r&rr'r(argr)rrr) rErr*instsrcurr-firstlaststarts_with_asserts r1__bool__zProxy.__bool__sd ;; $ $((*E}$%KLL!LLM$$%;<<--m.B.BCDE7*.!%)>)>DVW#++q0:D{{00cAg88#()PQQTXX]Q./LLM19 (88>||'==# &$++*HKK,,_i$RTU{{""4((r3c8|jj|Sr9)rrrVs r1rz Proxy.keyss{{%%r3ctd)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 RuntimeErrorrVs r1__len__z Proxy.__len__s   r3c :|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*t'||}|td|j(d|d |jd ||||j*j-|j  S) Nrc>t|rd|j<yyr9)r+r)rclstracerss r1 find_tracerz-Proxy.__torch_function__..find_tracers !S!$(!"r3rz!Found multiple different tracers z" while trying to trace operations rz5Unable to symbolically trace the HigherOrderOperator z4 because it received an arbitrary callable argument z(. Use make_fx or dynamo tracing instead.rvrs)rlenrDrrnextrr+r_C ScriptMethodownerrrs overridesis_tensor_method_or_propertyrGrrr<_namerg_target_to_str) rH orig_methodr*r4r5rJr bad_callablerIs ` @r1__torch_function__zProxy.__torch_function__st!r#% ) +t$+v& w*+ k588#8#8 9%%'$.D&&}k6F6FfU U ?? 7 7 D&&{33T6 +uzz'E'EF7fE +&O&,,-.--9N;+, &&\\001E1EF ' r3r9)r'r!)r'rr)rGrHrIrJrrrDrKrrrrr r rrr.r3rr@rrE classmethodrWrr3r1rrEs8$/T+A0*#*" dD8 &(7+&,T!)$!)F$/&0& ++r3rcReZdZdZ d deddffd ZdefdZed fd Z xZ S) r zW A Proxy subclass that propagates metadata (meta['val']) during graph tracing. rrrc4t|||||_yr9)rCrD fake_mode)rErrr[rFs r1rDzMetaProxy.__init__s v&"r3r'c6d|jjdS)Nz MetaProxy(rrrVs r1rzMetaProxy.__repr__sDIINN+1--r3c |r|nd}|r|ni}d}|D]}t|ts|}n| tdt |||||}|j 5||Dcgc]-}t|t r|jjdn|/c}i||jjd<dddt|j|j|j Scc}w#1swY9xYw)Nrz5No MetaProxy found in arguments, but one is expected.val) r+r rrCrWr[rrrr) rHrUr*r4r5 meta_proxyr:rrrFs r1rWzMetaProxy.__torch_function__ st!r  C#y)     G *;tVL  ! ! %0MQR 1e(.impl|s3!W^^FXv.F&&fM Mr3___)rGrsetattrr)r|r}as_magics` r1rTrT{s6 N   S)*"-x&r3cxdjdd}fd}||_||_tt||y)N__rrr~cdtt}|jjd|||fiSr0)rr1rr)rErhsrrorig_method_names r1r}z!_define_reflectable..impls/#34{{''#tbQQr3)rrGrIrr)r method_namer}s` r1_define_reflectablersA(..s34B7KR DM#D E;%r3ctd|)NzJKeys for dictionaries used as an argument cannot contain a Node. Got key: rC)r:s r1_no_nodes_errorrs    r3ci}|jD]J\}}t|ts!|j|}t |t |j|||<L|Sr9)rr+rKrmap_argr)rErrrrs r1rrs] A "1!S!"A A 'q!!" Hr3c|Sr9rrErs r1rrsqr3c|jSr9)rrs r1rrs AFFr3c,tfd|DS)Nc3@K|]}j|ywr9r)rrrEs r1rz..s1VD$//$2G1Vs)rrs` r1rrsE1VTU1V,Vr3cJ|Dcgc]}|j|c}Scc}wr9r)rErrs r1rrsa+PdDOOD,A+P+Ps )r{)XrrRr"rrloggingr1r$rrcollections.abcrr dataclassesrrtypingrr r rtorch.fx.tracebackrr}torch._Cr rtorch._library.opaque_objectr torch._loggingr torch.utils._pytreertorch.utils._tracebackr_compatibilityrrgrrrimmutable_collectionsrrrrrrroperator_schemasr__all__ getLoggerrGrrobjectrr2rrrKr<r#r$rrrrr ValueErrorrrr r!r"r|rTrrrrrrrrrr)ts0r1rs!  #.,)) ))+=,)4)BBA449 g!"8\:4*  &*3;&7 0e,''-'>e,-:  d+I(I(,I(X 333nd+%:%,%e,1-1 d+  , d+HH,HVe,$I$I-$INd+  , 0e,#%U#%-#%L F' 6N  &2*()*    T  S      &&    35V5P4+4%7%=>"%7%=>" s& I