[Th V%SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK J r JrJr SSKJrJrJrJrJr SSKrSSKJs Jr SSKJr SSKJr SSKJ r SS K!J"r" SS K#J$r$J%r%J&r& SS K'J(r( SS K)J*r*J+r+J,r, SS K-J.r.J/r/J0r0J1r1J2r2 \Rf\Rh-r5\RlRnRpr9\\:S'\RlRnRvr<\\:S'0r=\>\?S4\:S'Sq@SrA\ "SS9"SS\?55rBS\S\CS\4SjrD\ "SS9"SS55rE\E"5rF\ "SS9"SS\E55rGSrH\ "SS9"S S!\255rI0rJ\>\K\C\L4\>4\:S"'/rM\N\K\?\L4\:S#'\RRS$5S%:Xa\MR\RS&45 S'rSS(rTS)rU"S*S+\5rV"S,S-\V5rW"S.S/\V5rX"S0S1\V5rY"S2S35rZSq[\\Z\:S4'\RS55r]\RS65r^S7\Z4S8jr_S7\ZS9\>\L\4S:\`\C4S;jra\ "SS9S<\\L\44S=j5rb\ "SS9SCS>\\RlRn\S?\44S@\\>\L\4S\(4SAjj5rc\bSB5rdg)DN)chain)CodeType FunctionType ModuleType)AnyCallable NamedTupleOptionalUnion) ScriptObject)FakeScriptObject) compatibility)_make_graph_module)_PyTreeCodeGen _PyTreeInfoGraph) GraphModule)Argument base_types map_aggregate)ParameterProxyProxyScopeScopeContextManager TracerBase_orig_module_call_orig_module_getattr_proxyable_classesFc[$N)_is_fx_tracing_flagP/var/www/auris/envauris/lib/python3.13/site-packages/torch/fx/_symbolic_trace.py is_fx_tracingr&(s r$Tis_backward_compatiblec2^\rSrSrSrU4SjrSrSrU=r$)ProxyableClassMeta,aF ProxyableClassMeta allows you to make construction of a given Python class symbolically traceable. For example:: import torch import torch.fx class TensorPair(metaclass=torch.fx.ProxyableClassMeta): def __init__(self, left, right): self.left, self.right = left, right def add(self, other): l = self.left + other.left r = self.right + other.right return TensorPair(l, r) def mul(self, other): l = self.left * other.left r = self.right * other.right return TensorPair(l, r) def use_tensor_pair_ctor(x: TensorPair, y: torch.Tensor): s = x.add(TensorPair(y, y)) return s.mul(x) x = TensorPair(torch.randn(5, 3), torch.randn(5, 3)) y = torch.randn(5, 3) ref_out = use_tensor_pair_ctor(x, y) traced = torch.fx.symbolic_trace(use_tensor_pair_ctor) print(traced.code) ''' def forward(self, x : __main___TensorPair, y : torch.Tensor): tensor_pair = __main___TensorPair(y, y); y = None add = x.add(tensor_pair); tensor_pair = None mul = add.mul(x); add = x = None return mul ''' From this example, we can see that construction of a class (``TensorPair``) defined with ``ProxyableClassMeta`` as metaclass can be recorded in symbolic tracing. cP>[RU5 [TU] XU5 gr!)r setdefaultsuper__init__)clsnamebasesattrs __class__s r%r/ProxyableClassMeta.__init__]s %%c* e,r$cB^URU5n[5(dUR"U/UQ70UD6 U$/mU4Sjn[X5 [X$5 [ T5S:wa"TSR nUR SXU5$UR"U/UQ70UD6 U$)NcT>[U[5(aTRU5 ggr!) isinstancerappend)a found_proxiess r% check_proxy0ProxyableClassMeta.__call__..check_proxyjs#!U##$$Q'$r$r call_function)__new__r&r/rlentracer create_proxy)r0argskwargsinstancer<rAr;s @r%__call__ProxyableClassMeta.__call__as;;s# LL 3D 3F 3O  ( d(f* }  ""1%,,F&&6J J LL 3D 3F 3Or$r#) __name__ __module__ __qualname____firstlineno____doc__r/rF__static_attributes__ __classcell__r4s@r%r*r*,s-^-r$r*fnnargsreturncnURnUR[)-n[US5(aUSSURUR UUR URURURURURURURURURUR UR"4nGO%[US5(aUSSURUR UUR URURURURURURURUR UR"4nOUSURUR UUR URURURURURURURUR UR"4n[%U6n['XPR(UR*UR,UR.5$)N co_qualnamerco_posonlyargcount)__code__co_flags HAS_VARSTUFFhasattr co_nlocals co_stacksizeco_code co_constsco_names co_varnames co_filenameco_namerTco_firstlineno co_lnotabco_exceptiontable co_freevars co_cellvarsrr __globals__rH __defaults__ __closure__)rPrQcorWco_argsnew_codes r%_patch_functionrmys B{{l]*Hr=!!  MM OO  JJ LL KK NN NN JJ NN    LL  NN NN% ( ) * *  MM OO  JJ LL KK NN NN JJ    LL NN NN! (  MM OO  JJ LL KK NN NN JJ    LL NN NN "!H .."++r r$c\rSrSrSrSrSrg)PHBase= Object representing an input placeholder to `concrete_args` cg)NPHr#selfs r%__repr__PHBase.__repr__sr$r#N)rHrIrJrKrLrvrMr#r$r%roros r$roc>^\rSrSrSrSS\\4U4SjjjrSrU=r $) PHWithMetarqph_keyc.>[TU]5 Xlgr!)r.r/r{)rur{r4s r%r/PHWithMeta.__init__s  r$)r{r!) rHrIrJrKrLr strr/rMrNrOs@r%ryrysx}r$ryc[U5HVn[X5n[U5(aM URS5(aM8[ X5(aMJ[ XU5 MX g)N__)dirgetattrcallable startswithrYsetattr)frto attr_nameattr_vals r%_transfer_attrsrsKW 2)""((..B** B8 ,r$c ^\rSrSr%Sr\"SS9\4SS4S\\S\\ S 4S \ S S 4U4S jjj5r \ R"\5r\\\4\S'\"SS9S\S \4Sj5r\"SS9S\S S4U4Sjj5r\"SS9S\R.R0S\S \ 4Sj5r\"SS9S\R.R0S \4Sj5r\"SS9S\R.R0S\ S \4S\\S 4S\\\4S \4 Sj5r\"SS9S\S\S\\\44S j5r\"SS9S(S!j5r\"SS9S(S"\\R.R0\ S \44S#\\\\4S \ 4S$jj5r!S%r"S&r#S'r$U=r%$))TraceraTracer(autowrap_modules=(math,), autowrap_functions=()) ``Tracer`` is the class that implements the symbolic tracing functionality of ``torch.fx.symbolic_trace``. A call to ``symbolic_trace(m)`` is equivalent to ``Tracer().trace(m)``. Tracer can be subclassed to override various behaviors of the tracing process. The different behaviors that can be overridden are described in the docstrings of the methods on this class. Tr'r#Fautowrap_modulesautowrap_functions.param_shapes_constantrRNc0>[TU]5 [R"SU55VVs1sH:upEUR S5(aM[ U5(dM/[ U5iM< snnUlURRUVs1sHn[ U5iM sn5 [U5Ul X0l SUl SUl [SS5Ul[ R""5Ul0Ul0Ulgs snnfs snf)aG Construct a Tracer object. Args: autowrap_modules (Tuple[ModuleType]): defaults to `(math, )`, Python modules whose functions should be wrapped automatically without needing to use fx.wrap(). Backward-compatibility for this parameter is guaranteed. autowrap_functions (Tuple[Callable, ...]): defaults to `()`, Python functions that should be wrapped automatically without needing to use fx.wrap(). Backward compatibility for this parameter is guaranteed. param_shapes_constant (bool): When this flag is set, calls to shape, size and a few other shape like attributes of a module's parameter will be evaluated directly, rather than returning a new Proxy value for an attribute access. Backward compatibility for this parameter is guaranteed. c3T# UHoRR5v M g7fr!)__dict__items).0ms r% "Tracer.__init__..#s"3,^[U[RR5(aHTRR 5Hup#XLdM TR SUS05s $ [S5e[U[R5(a>TRR5HupEXLdM TR SUS05s $ Of[U[RR5(a=TRR5HupEXLdM TR SUS05s $ [U[5(aD[US5(a3[U4SjU55nTR SURU05$[U[R[[ 45(aTR"R%U5nU(dp[U[R5(aSOSnTR'U5n[U[(5(deUTR"U'[+TRXq5 TR SUS05$[-U5[.;ajTR'S URR0S 35n[U[(5(de[+TRXq5 TR SUS05$[2T T]iU5$) a- A method to specify the behavior of tracing when preparing values to be used as arguments to nodes in the ``Graph``. By default, the behavior includes: #. Iterate through collection types (e.g. tuple, list, dict) and recursively call ``create_args`` on the elements. #. Given a Proxy object, return a reference to the underlying IR ``Node`` #. Given a non-Proxy Tensor object, emit IR for various cases: * For a Parameter, emit a ``get_attr`` node referring to that Parameter * For a non-Parameter Tensor, store the Tensor away in a special attribute referring to that attribute. This method can be overridden to support more types. Args: a (Any): The value to be emitted as an ``Argument`` in the ``Graph``. Returns: The value ``a`` converted into the appropriate ``Argument`` get_attrr#z(parameter is not a member of this module_fieldsc3F># UHnTRU5v M g7fr!) create_arg)relemrus r%r$Tracer.create_arg..s=14..1s!r>_tensor_constant_torchbind_objr _constant_)r8torchnn Parameterrnamed_parameters create_node NameErrorTensor named_buffersModule named_modulestuplerYr4r r tensor_attrsgetrr~rtyperrHr.r) rur:npn_p_rCr base_namer4s ` r%rTracer.create_argUsc@ a++ , , 2246++J2rBB5FG G 5<< ( ())1137++JBCC4588?? + +))1137++JBCC4 a  GAy$9$9=1==D##OQ[[$K K a%,, 6FG H H&*&7&7&;&;A&>H"!U\\22')  229=!(C0000'/!!!$ 8/##J"bA A 7( ( ..1;;3G3G2H /STHh,, ,, DIIx +##J"bA Aw!!$$r$rmodule_qualified_namecURRS5=(d URRS5=(a) [U[RR 5(+$)a A method to specify whether a given ``nn.Module`` is a "leaf" module. Leaf modules are the atomic units that appear in the IR, referenced by ``call_module`` calls. By default, Modules in the PyTorch standard library namespace (torch.nn) are leaf modules. All other modules are traced through and their constituent ops are recorded, unless specified otherwise via this parameter. Args: m (Module): The module being queried about module_qualified_name (str): The path to root of this module. For example, if you have a module hierarchy where submodule ``foo`` contains submodule ``bar``, which contains submodule ``baz``, that module will appear with the qualified name ``foo.bar.baz`` here. ztorch.nnz torch.ao.nn)rIrr8rr Sequential)rurrs r%is_leaf_moduleTracer.is_leaf_modulesP* LL # #J / 6||&&}55Q 3 344 5r$modcUR(aBURRU5nUc [S5e[U[5(deU$UR R 5H up4XLdM Us $ [S5e)aF Helper method to find the qualified name of ``mod`` in the Module hierarchy of ``root``. For example, if ``root`` has a submodule named ``foo``, which has a submodule named ``bar``, passing ``bar`` into this function will return the string "foo.bar". Args: mod (str): The ``Module`` to retrieve the qualified name for. z&module is not installed as a submodule)rrrr8r~rr)rurpathrrs r%path_of_moduleTracer.path_of_modules   ''++C0D| HIIdC(( ((K //18H2DE Er$forwardrCrDc @URU5n[UR[U[ U555nUR R US5nUS:aURSU3O URnXVR4URU'US-UR U'URX5(d U"U0UD6n OURSXSU5n URRSS9upX:Xd SU 35eSSS5 U $!,(df  W $=f) a Method that specifies the behavior of this ``Tracer`` when it encounters a call to an ``nn.Module`` instance. By default, the behavior is to check if the called module is a leaf module via ``is_leaf_module``. If it is, emit a ``call_module`` node referring to ``m`` in the ``Graph``. Otherwise, call the ``Module`` normally, tracing through the operations in its ``forward`` function. This method can be overridden to--for example--create nested traced GraphModules, or any other behavior you would want while tracing across ``Module`` boundaries. Args: m (Module): The module for which a call is being emitted forward (Callable): The forward() method of the ``Module`` to be invoked args (Tuple): args of the module callsite kwargs (Dict): kwargs of the module callsite Return: The return value from the Module call. In the case that a ``call_module`` node was emitted, this is a ``Proxy`` value. Otherwise, it is whatever value was returned from the ``Module`` invocation. r@r call_moduleT)lastz Unexpected key N) rrrrrrr module_path module_typerrrBpopitem) rurrrCrDr_scoper module_keyret_valkeyrs r%rTracer.call_modules8D!% 3 3A 6 JJ3T!W= **+@!DIq=%%&a {3''  .CDVDV,WD  j )4=MDNN0 1&&q@@!4262++!#8&&..D.9FC$ >(8&> >$) ,-  ,s CD Dattrrparameter_proxy_cachecb^U4Sjn[U[RR5(a'U"UTRR 5U5nUbU$TR (aF[U[R5(a'U"UTRR5U5nUbU$U$)a Method that specifies the behavior of this ``Tracer`` when we call getattr on a call to an ``nn.Module`` instance. By default, the behavior is to return a proxy value for the attribute. It also stores the proxy value in the ``parameter_proxy_cache``, so that future calls will reuse the proxy rather than creating a new one. This method can be overridden to --for example-- not return proxies when querying parameters. Args: attr (str): The name of the attribute being queried attr_val (Any): The value of the attribute parameter_proxy_cache (Dict[str, Any]): A cache of attr names to proxies Return: The return value from the getattr call. c>^^UHumnTULdM TU;ah0nS[R"TR5R;aTR(dSOUUU4SjUS'TR"STS040UD6nXRT'UTs $ g)Nproxy_factory_fnc >[TUTT5$r!)r)noderrrus r%BTracer.getattr..maybe_get_proxy_for_attr..Cs.$($83"r$rr#)inspect signaturerB parametersr)rcollection_to_searchrrrD val_proxyrrus` @r%maybe_get_proxy_for_attr0Tracer.getattr..maybe_get_proxy_for_attr5s-1q= 55!#.&001B1BCNNO (,'A'A!%&"##56%)$5$5j!R$Vv$V 3"[U55unm[ASTRB55(d4[E[GUSUTS55TRHl%UUU4SjnUU4$TU4$s sn f)z Create ``placeholder`` nodes corresponding to the signature of the ``root`` Module. This method introspects root's signature and emits those nodes accordingly, also supporting ``*args`` and ``**kwargs``. rz4``self`` argument cannot be part of *args expansion!r placeholderinput_r#rrzTracing expected z arguments but got z concrete argumentsc,>TRUTTT5$r!)_proxy_placeholder)r1 concrete_argsfn_for_analysisrusigs r%proxy_placeholder6Tracer.create_args_for_root..proxy_placeholders**4_U Ur$c34># UH nT"U5v M g7fr!r#)rnamesrs r%r.Tracer.create_args_for_root..sD)%e,,)s*z**c3@# UHoR5v M g7fr!)is_leaf)rchilds r%rr sG0Fu==??0FsNcd>[R"[U5T5nT"U6n[R"U5up4[ TR R [5(deTR R RRUS9TR R lU$)N)out_spec) pytreetree_unflattenr tree_flattenr8graph_codegenr pytree_info_replace)rC tree_argstree_outout_argsrin_specroot_fnrus r% flatten_fn/Tracer.create_args_for_root..flatten_fns"11$t*gF "I.%+%8%8%B"!$**"5"5~FFFFJJ''33<?M V V D)DD  ! #r{{\'A{{W/// -cD4D.DEF{{W333 -dT*5E.EFG%gs4y9G#00t= 7G0F0FGGG#1Ikz2GTB#DJJ  y( (}SRsM'rrc l^^^^[nSq[U[RR5(aSSKJn URU5 UTl[[U5TR5(d*STRS[U5R35e[[U5TR5nUR5TlUR!5VVs0sHupgXv_M snnTlO%[RR 5TlUn[TSS5n[%US9Tl[US 5(a?UR(n U R*U R,U R.S .TR&l0TlS [RRS [4[64UU4S jjmT"TR/5 [U[85(deUR:n TR=U[U[RR5U5up[0m[>R@"[B5UU4Sj5n [>R@"[D5UU4Sj5n [G5mTRI[RRSU SS9 TRI[RRSU SS9 [KT5 [MTU TRN5 TRPH$n[MTURRTRN5 M& TRUSSTRWU"U 6540URXR[SS5S9 SSS5 STlUqTR&$s snnf!,(df  N*=f![\axn[UR^S[65(aPSUR^S;a=[aSTR&RcSSS9Rd-[fRhS9 eSnAff=f!Uqf=f)aQ Trace ``root`` and return the corresponding FX ``Graph`` representation. ``root`` can either be an ``nn.Module`` instance or a Python callable. Note that after this call, ``self.root`` may be different from the ``root`` passed in here. For example, when a free function is passed to ``trace()``, we will create an ``nn.Module`` instance to use as the root and add embedded constants to. Args: root (Union[Module, Callable]): Either a ``Module`` or a function to be traced through. Backwards-compatibility for this parameter is guaranteed. concrete_args (Optional[Dict[str, any]]): Concrete arguments that should not be treated as Proxies. This parameter is experimental and its backwards-compatibility is *NOT* guaranteed. Returns: A ``Graph`` representing the semantics of the passed-in ``root``. Tr)_LazyGraphModuleztraced_func_name=z doesn't exist in r4N) tracer_clsrV)rar`rbr prefix_atomsc0>URR5HRup#[U[R[ [ 45(dM1SRX/-5TRU'MT UR5Hup#T"X1U/-5 M g)N.) rrr8rrr r joinrnamed_children)rr>kvcollect_tensor_attrsrus r%rE*Tracer.trace..collect_tensor_attrssyJJ,,.DA!!ellLBR%STT/2xx s8J/K))!,/,,.DA(A3,>?/r$c>>[X5nTRXT5$r!)rr)rrrrrus r%module_getattr_wrapper,Tracer.trace..module_getattr_wrappers/:||D4IJJr$c >^U4Sjn[T[[TST5S05TR5 TRTX1U5$)Nc">[T/UQ70UD6$r!)r)rCrDrs r%r:Tracer.trace..module_call_wrapper..forward%s,SB4B6BBr$rrg)_autowrap_checkrrr)rrCrDrpatcherrus` r%module_call_wrapper)Tracer.trace..module_call_wrapper#sKC GCC8-L// ''WFCCr$ __getattr__F) deduplicaterFoutputrR type_exprzdata-dependent ru) root_moduleverbose)file)5r"r8rrrtorch.fx._lazy_graph_moduler<force_recompilerrYrtraced_func_namerHr _get_namerrrrrrVrar`rb _co_fieldsrrr~rrgr9 functoolswrapsrr _new_patcher patch_method_patch_wrapped_functionsrMrrrrr__annotations__rr$rCprint python_codesrcsysstderr)rurrold_is_fx_tracing_flagr<rPr1rr=code fn_globalsrCrHrOmoduleerErrNs` @@@r%trace Tracer.traces<"5"z 9$00 I 006  J 5 5f&t'<'<&==OPTUYPZPcPcOdefT$Z)>)>?(,(8%CGCUCUCW'XCWid CW'X$!HHOO- 18{D1QJ*5DJr:&&{{#||#'#3#3&*&9&9) %   @ @tCy @ @ !B /b,// //J00JtUXX__5}HB  " __1 2 K3 K__. / D0 D7$$HHOO!* % % $$HHOO' % % )1T5P5PQ"33F#$2M2M4  __RY/1 0044XtD !) 8$(D #9 zzS(Y| : !&&)S)).>!&&).Kjj,,$* $-c     #9 sQCN**N8FN* C+N5N*N* N'#N** P,4A3P''P,,P//P3c[R[5nURR5HFup4US;a[R"U5nO[R "XA5nXRRU'MH U$)N>r)rr?rrcopydeepcopy)rumemo new_tracerrCrDnew_objs r% __deepcopy__Tracer.__deepcopy__\sc^^F+ MM'')DA(())A,--0%,   " *r$c `^^^^Ub*TU;a$SmUUUU4Sjn[R"XRT5$TSS:XaSnOETRTnUR[R R LaSO UR4nTRSTU0URRTS5S9$)Nrc>TS- mTRTnUR[RRLaSO UR4nTR STS[ T53U05n[U[5(aU[:wa[XRS9 U$[U5[:Xd0[U5[;a>[U5[R :wa![R""X0:HTSUS35 U$Uc!UTS34nTR S [$U05 U$[&R("S TS 35 U$) Nrr#rrrz$ has been specialized to have value z but got another valuez> has been specialized to have value None but got another valuer>z9Was not able to add assertion to guarantee correct input z to specialized function. It is up to the user to make sure that your inputs match the inputs you specialized the function with.)rdefaultrremptyrBr~r8rorsrrrboolrrr_assert_assert_is_nonewarningswarn) xparamr{r5rCcntr1rurs r% replace_ph-Tracer._proxy_placeholder..replace_phnsHqt,--7+<+<+B+BBBHX''!dV1SXJ#7"a((Bw(1:J7d?d1g&;Q5<<@WMM& DQCG]^"Y& ^_D%%obQ MMSTXSYZDE r$r r#rrT) rtree_maprr{rrr|rBrdr) rur1rrrrr{rrs `` ` @r%rTracer._proxy_placeholderjs  $)>C) ) V??:T/BC C 7c>')GNN4(Emmw'8'8'>'>>U]]DT      %5599$E !  r$) rrrrrrrrrrrrr!)&rHrIrJrKrLrmathrrrr}r/r defaultdictintrr'r~rdrrrrrrrrrrr9r r rrorwrrMrNrOs@r%rrsz $/04g35&+ :B +:B"(C-0:B $ :B  :B0:Bx)4(?(?(DtCH~D$/02$/V%CV%JV%0V%p$/555PT5050$/F%((//FcF0F4$/8 88??8#s(#8CHo 8 S#X 8 808t%0<C<3<tCQTH~<1<~%0_1_B$/37ZEHHOOXc3h%778Z S#X/Z  Z0Zx = = r$r_wrapped_fns_to_patch_wrapped_methods_to_patchFX_PATCH_GETITEM1 __getitem__c.^SmU4Sjn[X5 T$)z\ Recursively search a data structure for a Proxy() and return it, return None if not found. Nc6>[U[5(aUmggr!)r8r)rproxys r% find_proxy_find_proxy..find_proxys a  E r$)r)objects_to_searchrrs @r% _find_proxyrs E #0 Lr$cF^[R"T5U4Sj5nU$)Nc>[X5nUb8URRSTX5nSURRS'U$T"U0UD6$)a& Given an closed-over ``orig_function`` to invoke, search the args and kwargs for a Proxy object. If there is one, emit a ``call_function`` node to preserve the call to this leaf function directly. Otherwise, just return the results of this function call, as this function is not being traced. r>T is_wrapped)rrArBrmeta)rCrDr return_proxyorig_fns r%wrapped%_create_wrapped_func..wrappeds^D)   <<44$L48L   " "< 0 '''r$)r_r`)rrs` r%_create_wrapped_funcrs%__W(( Nr$cb^^[UT5m[R"T5UU4Sj5nU$)Ncj>[X5nUbURRSTX5$T"U0UD6$)z Search the args and kwargs for a Proxy object. If there is one, emit a ``call_method`` node to preserve the call to this method directly. Otherwise, just return the results of this function call, as this function is not being traced. call_method)rrArB)rCrDrr1rs r%r'_create_wrapped_method..wrappeds>D)  <<,,]D$O O'''r$)rr_r`)r0r1rrs ` @r%_create_wrapped_methodrs1c4 G__W ( ( Nr$cJ\rSrSr%\\S'\\S'\\S'\\S'SrSrSr g ) _PatchedFni frame_dictfn_namernew_fnc[er!NotImplementedErrorrts r%revert_PatchedFn.revert!!r$c[er!rrts r%patch_PatchedFn.patchrr$r#N) rHrIrJrKrrdr~rrrMr#r$r%rrs O L L K""r$rc \rSrSrSrSrSrg)_PatchedFnSetItemicJURURUR'gr!)rrrrts r%r_PatchedFnSetItem.reverts(,  %r$cJURURUR'gr!rrrrts r%r_PatchedFnSetItem.patch(,  %r$r#NrHrIrJrKrrrMr#r$r%rrs 54r$rc \rSrSrSrSrSrg) _PatchedFnDeli c2URUR gr!)rrrts r%r_PatchedFnDel.revert s OODLL )r$cJURURUR'gr!rrts r%r_PatchedFnDel.patchrr$r#Nrr#r$r%rr s *4r$rc \rSrSrSrSrSrg)_PatchedFnSetAttricZ[URURUR5 gr!)rrrrrts r%r_PatchedFnSetAttr.revertst||[TU]5 /Ul[5Ulgr!)r.r/ patches_madesetvisited)rur4s r%r/_Patcher.__init__s .0!$ r$rr1rrRcXClX!;aY[[U5(aDURR [ XSU55 URSR 5 g[XSS5(agURR [XXU55 URSR 5 g)zI Replace frame_dict[name] with new_fn until we exit the context manager. N__fx_already_patchedF) _Patcher__fx_already_patchedrYbuiltinsrr9rrrr)rurr1rrRs r%r_Patcher.patch s'2#  !gh&=&=    $ $]:T6%R S   b ! ' ' ) Z%'=u E E     $ $!*J4DfM    b ! ' ' )r$r0cXCl[X5n[USS5(agURR[ XXS55 URSR 5 g)zL Replace object_or_dict.name with new_fn until we exit the context manager. rFNr)rrrr9rr)rur0r1rrRrs r%rb_Patcher.patch_method6sZ '2##$ 72E : :    !23g!NO "##%r$thingcp[U5nX R;agURRU5 g)z>@L  + E D E +  &*>>@L  + E D E +s A)A A)!A&&A)rNc H[R5R5HRuupnX#;a&[[U5(a[ [U5nOX2nUR X2[U55 MT [H upRURXR[XR55 M" g)z Go through ``_wrapped_fn_patch_table`` and, for each frame object, wrap the listed global functions in the `_create_wrapped_func` wrapper. N) rrrrrYrrrrrrbr)rNrr1rrr0s r%rcrcs "7!;!;!=!C!C!E :  !gh&=&=h-G &G j(s(IJ/r$r function_idscURU5(apUR5H[up4URS5(aM[U5(dM/[ U5U;dM@UR X[ U55 M] gg)z Some methods, like `math.sqrt` are common enough we want to automatically wrap them as we see them. This method searches a scope for them and patches them if found. rN)rrrrrrr)rNrrr1rs r%rMrMsg*%%%++-KDOOC((UOOuI- j0DU0KL .&r$ fn_or_namec[U5(d [U[5(d [S5e[U5(a$[U[5(aeURnO[U[5(dS5eUn[ R "5nUceURnUceURRS:wa [S5eUR[[UR5U4'U$)a This function can be called at module-level scope to register fn_or_name as a "leaf function". A "leaf function" will be preserved as a CallFunction node in the FX trace instead of being traced through:: # foo/bar/baz.py def my_custom_function(x, y): return x * x + y * y torch.fx.wrap("my_custom_function") def fn_to_be_traced(x, y): # When symbolic tracing, the below call to my_custom_function will be inserted into # the graph rather than tracing it. return my_custom_function(x, y) This function can also equivalently be used as a decorator:: # foo/bar/baz.py @torch.fx.wrap def my_custom_function(x, y): return x * x + y * y A wrapped function can be thought of a "leaf function", analogous to the concept of "leaf modules", that is, they are functions that are left as calls in the FX trace rather than traced through. Args: fn_or_name (Union[str, Callable]): The function or name of the global function to insert into the graph when it's called zNUnsupported type for global function! Must be either a callable or string namez3fn_or_name must be a global function or string namezz0wrap must be called at the top level of a module)rr8r~r$rHr currentframef_backf_coderar f_globalsrr)rrrrs r%wraprsH J   :s(C(C    j#....%%    A @ A '')L  ## #A ==xx:%!"TUU9: 2akk?G45 r$r.rc[5nURX5n[U[RR 5(aUR RO URn[URX45$)a Symbolic tracing API Given an ``nn.Module`` or function instance ``root``, this function will return a ``GraphModule`` constructed by recording operations seen while tracing through ``root``. ``concrete_args`` allows you to partially specialize your function, whether it's to remove control flow or data structures. For example:: def f(a, b): if b == True: return a else: return a * 2 FX can typically not trace through this due to the presence of control flow. However, we can use `concrete_args` to specialize on the value of `b` to trace through this:: f = fx.symbolic_trace(f, concrete_args={"b": False}) assert f(3, False) == 6 Note that although you can still pass in different values of `b`, they will be ignored. We can also use `concrete_args` to eliminate data-structure handling from our function. This will use pytrees to flatten your input. To avoid overspecializing, pass in `fx.PH` for values that shouldn't be specialized. For example:: def f(x): out = 0 for v in x.values(): out += v return out f = fx.symbolic_trace(f, concrete_args={"x": {"a": fx.PH, "b": fx.PH, "c": fx.PH}}) assert f({"a": 1, "b": 2, "c": 4}) == 7 Args: root (Union[torch.nn.Module, Callable]): Module or function to be traced and converted into a Graph representation. concrete_args (Optional[Dict[str, any]]): Inputs to be partially specialized Returns: GraphModule: a Module created from the recorded operations from ``root``. ) rror8rrrr4rHrr)rrrArr1s r%symbolic_tracersYlXF LL -E#-dEHHOO#D#D$--  fkk5 77r$cUbU5egr!r#)rmsgs r%rr)s =#=r$r!)err contextlibrrr_rrosrhr itertoolsrtypesrrrtypingrrr r r rtorch.utils._pytreeutils_pytreertorch._Cr "torch._library.fake_class_registryr _compatibilityr_lazy_graph_modulerrrrr graph_modulerrrrrrrrrrrr*r+rXrrrFrrdrQrrr'rr"r&r*rrmrorsryrrrrr~rrenvironrr9rrrrrrrrrrcontextmanagerrarrcrrMrrrr#r$r%rsP  44== $$!?)255%55PP!!G$:$:: $hhoo6686!&!>$%, $$ellM%BC  *& " "4 44J4< <KK\'+(#*  ( (  E E Kh K M M#'S>MADSM"d+<U3=)<,<~d+/3:8 #s(!33 4:8DcN+:8:8,:8zr$