^jUddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlmZddlmZmZmZmZmZddlmZddlmZddlmZmZmZmZddl Z ddl!m"cm#Z$ddl%m&Z'm(Z(dd l)m*Z*m+Z+dd l,m-Z-dd l.m/Z/d d l0m#Z1d dl2m3Z3d dl4m5Z5d dl6m7Z7m8Z8m9Z9m:Z:m;Z;d dlGd?d@Zt d ddAZue3dB4GdCdDZvGdEdFevZwGdGdHevZxGdIdJexZyGdKdLZze3d34GdMdNZ{e ddOZ|ddPZ}ddQZ~dRdSdTdUdVdWdXdYdZZejDcic]\}}|e~|c}}Ze jd[Zd\d]d^d_d`d`dadbdcdddedfdgdhdidjZdkdldmdndodpdqdrdsdt eZdudvdwdxdydzd{d|d}d~dddddZycc}wcc}}w)) annotationsN) defaultdict)Callable GeneratorIterableIteratorSequence)contextmanager) dataclass)AnyLiteral NamedTuple TYPE_CHECKING) _fx_map_arg _NodeIter)get_opaque_obj_repris_opaque_value_type py_sym_types) dtype_abbrs)_pytree) compatibility)immutable_dict)_get_qualified_name _type_reprArgumentNodeTarget) TensorType) PythonCodeCodeGenGraph)Tracer) GraphModule) call_function call_methodget_attr call_module placeholderoutputc&eZdZUdZded<ded<y)_CustomBuiltinzAdditional objs that we add to every graph's globals. The repr() for some standard library objects is not valid Python code without an import. For common objects of this sort, we bundle them in the globals of every FX graph. str import_strobjectobjN__name__ __module__ __qualname____doc____annotations__Y/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/fx/graph.pyr-r-FsO Kr9r-zdict[str, _CustomBuiltin]_custom_builtinsc<t||t|<|t|<yN)r-r;_illegal_names)namer/r1s r:_register_custom_builtinr@[s+J<TN4r9infzfrom math import infnanzfrom math import nanNoneTypezNoneType = type(None)torchz import torchdevicezfrom torch import device fx_pytreez$import torch.fx._pytree as fx_pytreepytreez$import torch.utils._pytree as pytreecJ|jdxr|jdS)N__) startswithendswithxs r: _is_magicrNis <<  2!**T"22r9c4t|jS)z Transforms the given string ``s`` to a Python-style variable name Examples: ``mod.snake_case`` -> ``mod.snake_case`` ``mod.pascalCase``-> ``mod.pascal_case`` ``mod.ALL_CAPS`` -> ``mod.all_caps`` )_snake_case_sublower)ss r: _snake_caserSms 1  # # %%r9z(?<=[a-z])([A-Z])z_\1z[^0-9a-zA-Z_]+z&^([a-zA-Z_][0-9a-zA-Z_]*?)(?:_(\d+))?$z,^torch(?:\.(?!_dynamo\.|_inductor\.)[^.]+)*$ct|dd}| t|duSt|dd}|;|dk7r6ttjjfD]}t||d|usyy)Nr4r3rDTF)getattr_torch_but_not_dynamorDnn functional)r1 module_namer?guesss r:_is_from_torchr[sw#|T2K$[1== 3 D )D DGOUXX001 EudD)S0  r9c0eZdZdZddZddZd dZd dZy) _NamespaceaA context for associating names uniquely with objects. The following invariants are enforced: - Each object gets a single name. - Each name is unique within a given namespace. - Names generated do not shadow builtins, unless the object is indeed that builtin. c>i|_t|_i|_yr=) _obj_to_nameset _used_names _base_countselfs r:__init__z_Namespace.__init__s/1%(U+-r9c|||jvr|j|Stj|}|Wtj d|}|sd}|dj rd|}tj|}|t d||jdd\}}|||jvrA|jj|d}tj|||ur|dz }|d|}n t|}||jvr|dz }|d|}||jvr|jj|||j|<|||j|<|S)zCreate a unique name. Arguments: candidate: used as the basis for the unique name, relevant to the user. obj: If not None, an object that will be associated with the unique name. __unnamedrz&Name regex failed to match candidate: r)r_ _name_regexmatch_illegal_char_regexsubisdigitAssertionErrorgrouprarbgetr>intadd)rd candidater1rkbasenums r: create_namez_Namespace.create_names ?sd&7&77$$S) )!!), =+//Y?I& |##% {O %%i0E}$#r9r]Tis_backward_compatiblec>eZdZUdZded<ded<ded<dZd ed <y ) r!zZ Represents all the information necessary to exec or save a graph as Python code. r.srczdict[str, Any]globalszdict[int, int | None] | None _lineno_maprrr_prologue_startN)r3r4r5r6r7rr8r9r:r!r!s& H .-OSr9r!c||jd}|}|D]#}|js d|d|d}|d|}%|S)N.zgetattr(z, ""))split isidentifier)rutargetelemsres r:_format_targetrsX LL E A ~~1#S2&A#Qqc A  Hr9c4eZdZddZddZ ddZy) _InsertPointcD||_|j|c|_|_yr=)graph_insert orig_insert)rdr new_inserts r:rez_InsertPoint.__init__ s */--'%-r9cyr=r8rcs r: __enter__z_InsertPoint.__enter__s r9c:|j|j_yr=)rrr)rdtypevaluetbs r:__exit__z_InsertPoint.__exit__s "-- r9N)rr#rzCallable[..., None]rrr~)rztype[BaseException] | NonerzBaseException | Nonerztypes.TracebackType | Nonerr)r3r4r5rerrr8r9r:rr s8D .(.$. ' .  .r9rc:eZdZ d ddZddZd dZd dZy) _node_listcD|dvrtd|||_||_y)N)_next_prevz*direction must be '_next' or '_prev', got )ror direction)rdrrs r:rez_node_list.__init__s4 . . >W+DEEr9c\t|jj|jdk(S)Nrrrcs r: __reversed__z_node_list.__reversed__0rr9N)r)rr#rzLiteral['_prev', '_next']rr)rrr)rz Iterator[Any])r3r4r5rerrrr8r9r:rrs3CJ##'@# #FFr9rc0eZdZUdZded<ded<ded<y) _PyTreeInfoz= Contains extra info stored when we're using Pytrees list[str] orig_argszpytree.TreeSpecin_speczpytree.TreeSpec | Noneout_specNr2r8r9r:rr4s $$r9r)frozencBeZdZUdZded<ded<ded<ded<d dZy) _ParsedStackTracez? Represents the top-most frame of a parsed stack trace r.filelinenor?codecnd|jd|jd|jd|jS)NzFile: :z in z, code: )rrr?rrcs r:get_summary_strz!_ParsedStackTrace.get_summary_strIs1 {!DKK=TYYKx {SSr9Nrr.)r3r4r5r6r7rr8r9r:rr>s# I K I ITr9rc|ytjd}|jjd}t t |dz ddD]}||j}|j |}|s*|jd}|jd}|jd} ||dzj} |r ||| | st||| | cSy)Nz$^File \"(.+)\", line (\d+), in (.+)$ rir) recompilestriprrangelenrkrpr) stack_trace filter_fnpatternlinesidxlinematchesrrr?rs r:_parse_stack_tracerNsjj@AG     % %d +ESZ!^R, ?Sz!--% ==#D]]1%F==#Dq>'')D4t!<$T64> > ? r9Fc"eZdZUdZded<ddZddZddZddZ d dd Z dd Z dd Z d d  ddZ ddd ddZ d dZd!dZd"dZd d d d d d dd d#dZy)$r"ct|Sr=)reprrLs r:zCodeGen.js $q'r9&Callable[[torch.types.PySymType], str] _sym_reprc d|_d|_y)Nforward)_body_transformer _func_namercs r:rezCodeGen.__init__ls;?(r9c8djfd|DS)zAHelper to format function arguments in expanded multiline format.c3@K|]}j|ywr=)_format_single_arg).0argrds r: z1CodeGen._format_multiline_args..rsDt..s3Dsjoinrdargss` r:_format_multiline_argszCodeGen._format_multiline_argspswwDtDDDr9cd|vr:|jdd\}}d|jd|jdSd|dS)z9Helper to format a single argument with optional comment.#r z, # rz, )rrstriplstrip)rdrarg_part comment_parts r:rzCodeGen._format_single_argtsS #:%(YYsA%6 "Hl(//+,E,2E2E2G1HK K#c? "r9c*t|trdSdS)z.s0!D'wt}oQwir2s)r_get_desc_trailersrrzip)rditemsdescsprefixrldelimrdelim desc_trailerss ` r:_format_multiline_containerz#CodeGen._format_multiline_containers{--e4//u= ?Ghvhb !gg%( %>     r9cT|dgt|zS|Dcgc]}d| c}Scc}w)z2Helper to generate description trailers for items.r # )r)rdrrdescs r:rzCodeGen._get_desc_trailerss4 =4#e*$ $*/0$$tf 000s %ctj|}|jDcic]\}}||jvs||}}}||i|Scc}}w)zDHelper to call a method with optional parameters based on signature.)inspect signaturer parameters)rdmethodrkwargssigkvfiltered_kwargss r:!_call_method_with_signature_checkz)CodeGen._call_method_with_signature_checksV',2LLNRDAqa3>>>Q1a4RRt///Ss AAF expanded_defct|dk(s|ddk7r|jdd|r'|j|}d|jd|d|dSd|jddj |d|dS) z Given the free variables and a return annotation, generates the beginning of the FX function. By default, `gen_fn_def(['a', 'b'], '') == 'def {self._func_name}(a, b):'` rrddef z( rrr, )rinsertrrr)rd free_varsmaybe_return_annotationrargs_formatteds r: gen_fn_defzCodeGen.gen_fn_defs y>Q )A,&"8   Q ' !88CNt's>*:!.add_global ss#u||(; +3//$// 3?Kh&K(C/(&{m3XY#"$'H[ ! r9c`|dk(ryt|}t|tjr=d|vr9t j |Dcgc] }| }}dj |St|ddx}rt|tjrtj||}t||}t|tr |j}nt j |}|r,|Dcgc] }| }}|ddj |dS|S||Scc}wcc}w)Nr8z()| __origin__rrr) rrtypes UnionTypetypingget_argsrrU _GenericAlias_origin_type_maprqr dims) otypenamerr origin_typeorigin_typename type_argsr= type_reprs r:rMz+CodeGen._gen_python_code..type_repr+sBw!!}H!U__-#/28//!2DE3 #EExx~%%at<<{<a!5!56"2"6"6{K"PK",Z -Dk"Ra, !I & 2I6?@sIcN@D@-.a/?qAA**h* */F"As D&3D+red dim_greendimdim_bluebluec0t|tr t|St|trJt |dr>t t |} |t |}|tt|St|tjjtjjfrt |} ||}|St|tjr0|j} |j|}|d|jSt|tj rIt#|j%}t'|j(j+dd}d|d|dSt|tr=t-|dk(rd |d d Sdd j/ fd |DzdzSt|t"r d d j/ fd|DzdzSt|t0rCodeGen._gen_python_code.._get_repr..ss*EA9Q<*Erc3.K|] }|ywr=r8rVs r:rz>CodeGen._gen_python_code.._get_repr..us&Ay|&ArYrzslice()rrrrhasattrrrrD_ops OpOverloadHigherOrderOperatorenumEnum __class__r3r?Tensorr!sizer.dtyperrrslicestartstopsteprrr)rqualified_namer:clsclsnamercrdobj_repr opaque_typesntrXr=rRs r:rXz+CodeGen._gen_python_code.._get_reprYsD#t$Cy C'GC,C!4T#Y!?(cC %tE#J'7&899ejj++UZZ-K-KL"5S!9(= %'C+mm$S\\37!!CHH:..C.CHHJ'CII,,S1"5+D6%BBC's8q=yQ0144*E*E!EEKKC&TYY&AS&AAACGGC' #)) 45R #((8K7LByY\YaYaObNccdee%d3i0)._format_argssb*..A9Q<.C. JJFLLNKDAq1#S1/K L99S> !/Ks A%A* c\|vr'||<j|gj|yyr=)ryappend)rnusernode_to_last_useuser_to_last_usess r:register_last_usesz4CodeGen._gen_python_code..register_last_usess7((&* #!,,T26==a@)r9c|jdk(ry|jdk(rjdyj|g}t|jj dk(r|j|t|rHdj |Dcgc] }t|c}dgz}jd|dyjdycc}w) z Delete values after their last use. This ensures that values that are not used in the remainder of the code are freed and the memory usage of the code is optimal. r*Nr+rrrqr; )oprvrqruserskeysrr)rwnodes_to_deletern to_delete_strbodyrPrys r:delete_unused_valuesz6CodeGen._gen_python_code..delete_unused_valuess ww-'ww(" D!/33D"=O4::??$%* &&t,?# % &56T!W6&A!  c#m"4!5R89 D! 7sC!c |jdvrd}rRg}D]4}||jvs|j|d|j|6|rddj|d}d}|jj di}i}|rG|j D]/\}}t |}t|dkDr |d dd z||<+|||<1d |}d } |jx} rt| x} r| j} d} t|d r|jr|jj dd } |jj dd }| '|%dt |dt | j} n+| dt | j} n|dt |} d|d|| d| d}|k7r|j|y y y )z} Append a summary of the stacktrace to the generated code. This is useful for debugging. >r+r*r: z# r custom(Nz...z Annotation: z'No stacktrace found for following nodesmeta recompute ac_graph_idz ac_graph_id: z - z recompute: rr) r}rrvrrqrr.rrrrr[r?)nodeadditional_meta_strpartskeyannotation_str annotationannotation_truncr value_strstack_trace_strrparsed_stack_tracemaybe_recompute_inforr summary_strr1rrPprev_summary_strs r:append_stacktrace_summaryz;CodeGen._gen_python_code..append_stacktrace_summarys4ww77&(#"')E.E$))+!LLC5499S>2B)CDE02499U3C2DA.F+!#!YY]]8R8 #% &0&6&6&8: U$'J y>B.4=crNU4J,S149,S1 : (55E4F%GN"K"&"2"22;2-? -LL)L*<*L*L*N')$4(TYY!% k4 @I"&))-- t"DK ,1H,S-=,>c#innBUAVW-#.1=c)..>Q=R/S,$01?K@P?Q/R, "3*=)>a?OPdOeefgvfw'x#y"zz|} "22'2$KK ,3]8r9c dddj|Dcgc] }t|c}dScc}w)Nrrr)rr.)shaperMs r:stringify_shapez1CodeGen._gen_python_code..stringify_shapes-tyy%!8Q#a&!89:!< dk(r|d|z } rtA|dr|jrzjCd|jjED];\}}jC|dtGjHtK|ddd=jCd|j>dk(rt|jLtJs!t)dt|jL|jNsdnd|jNd}jC|jL||||jLjQdd}|tS|k7r jCtS|d|dy|j>dk(rt|jLtJs!t)d t|jLjCtS||dtU|jNd|jLd|jNd!d|jVd"y|j>d#k(rtY|jLs!t)d$t|jLt[|jLd%dd&k(r|jLj2t\vrt|jNt^s!t)d't|jNjCtS||dt]|jLj2j`fd(|jNDyt[|jLd%dd&k(r|jLj2tbvrrjCtc|jLj2j`fd)|jNDd*tS||d|jNdyte|jL}||jL}|d+k(rt|jNt^rt|jNd!tJr|jNd!jgrdti|jNd,k(rLjCtS||dtU|jNd|jNd!yjCtS||d|d|jN|jVd"|jjd-d.r)jk|y|j>d/k(rt|jLtJs!t)d0t|jLjCtS||dtU$|jLd|jN|jVd"y|j>d1k(rqt|jLtJs!t)d2t|jLjCtS||dtU$|jLy|j>d3k(rd|jd4'|j"d<jC%jm%jn|jNdr|nd5ytqd6|j>d7|jL#t $rd}d}Y 'wxYw)9Nrz : r)DTensor DTensorSpecr)TensorMetadataval tensor_meta example_valuecr |jnd}r |jnd}t|j |j||S)Nr)striderErrdr) rorrErRrQrOr.r-rNrs r:_tensor_annotationzGCodeGen._gen_python_code..emit_node.._tensor_annotation soCodeGen._gen_python_code..emit_node..rsGhYZ RS GhrYc3.K|] }|ywr=r8rVs r:rz>CodeGen._gen_python_code..emit_node..}sIj[\)TU,IjrYr|rUri is_wrappedFr)z4Expected node.target to be str for call_module, got r(z1Expected node.target to be str for get_attr, got r+z -> rznode: r)roz torch.Tensorrr.)9rtorch.distributed.tensor._apirrformat_shard_order_strModuleNotFoundError"torch.fx.experimental.proxy_tensorrtorch.fx.passes.shape_proprrrqrrDrblayout sparse_csc sparse_csr _subclasses FakeTensorro_spec placements shard_orderrar3r"rrrdrr}r[rvrpprintpformatr.rrreplacerrrcallablerU magic_methodsrformatinplace_methodsrrrryrr#NotImplementedError)*rmaybe_type_annotation maybe_commentrr"dtensorspec_format_shard_order_strrrmeta_valris_plaincore dtensor_metarjval_strrrrmaybe_default_argraw_namerir:rtrXr=rRrrQrOrrr. include_metar-rrN root_modulerdrrMr, wrapped_fnss* r: emit_nodez+CodeGen._gen_python_code..emit_nodesii's9TYY3G2H-I "M>R$::7 LE99==IIMM-PT1UV h 5(//$$$$R; $H~=  %"3"3">">BH.h7D25dV1 -h72=E"0 X#(J$NN55$NN66( '0099!#avR ,0G/HK.'009925cU!D60D-,7%//9G.5gYb,A).9.1+hnn2M1N_g_m_mOnNoop,q)Dyy}}VT2#=(@!tD6]2Mf 5$)) G$ IIOO-DAqKK#Rs1vR NOrR  G$ww-'!$++s3(>tDKK?P>QR#iiBs9TYYq\3J2K-L"  {{m$9#:;L:Mm_] ;;..sB7tDz)KK4:,c(2 >?M)!$++s3(NtTXT_T_O`Nab Dzl#8"9^IVZV_V_`aVbLceiepep=qEEGh^b^g^gGhijl DKKr:kI ,,?KK*4;;+?+?@GGIj`d`i`iIjkllo:,'<&=S499UV"G9=6>se e'&e'zc_rf = torch._C._profiler._RecordFunctionFast('## ENTER_GRAPH_PLACEHOLDER_KEY ##'); _rf.__enter__() z # COUNTER: rr&r'r)_rf_z. = torch._C._profiler._RecordFunctionFast('## z ##'); _rf_z .__enter__() z.__exit__(None, None, None) z_rf.__exit__(None, None, None) rzpass wrapz("rrrc3&K|] }d|z yw)rNr8)rrs r:rz+CodeGen._gen_python_code..sD4$Dz )rr)r9r.r1r rr.)rHr0rr.)rr0rr.)rztuple[Argument, ...]rzdict[str, Argument]rr.)rnrrwrrr)rwrrrrrrr)rzIterable[object]rr.)osenvironrqr;r _color_fns _identityreversed _input_nodesrv enumerater}r?rrDfxrrrr*rrcountr_counter_regexpsearchrrrprr!)6rdnodesrr<r,r-r.r/rr0r1r?rgr1rzr input_noderrri do_record wrap_name wrap_stmtsrprologue lineno_map prologue_len new_linescur_idxrcounterrfn_codeprologue_startrtrXr=rRrrPrQrOrr;rrrxrrNrrMryrs6` ````` ` ` @@@@@@@@@@@@@@@@@@@r:_gen_python_codezCodeGen._gen_python_codes " #%') /1T' JJNN13 73 > ( JJNN13 73 > zz~~&:C@CG  :/446 "ND(1c tS ! " +B U#C";/IU#C!*-Hf%DC!IC HD% 'N "& "0C "  ".046 A UO 5D"// 5 ":t4 5 5 "6 7 -7 -r =F HF HF HF HP  KKv !' MGAt)$/ KK+aS+ ,#4)I  499+%STUSVVabfbkbkallz{ dO  & d499+-JKL- M.  KK: ; t9> KK ! { a "6588==9I#UykD6$<#UVJJ  ! !))$/D224 $KD% tU # $99 OO  #A &% : -/ ~~d+a/ ! GGDM''- 'D%,,T2G"gmmA./L89  &  'yy#**40yyD4::d3CDD       $))$/!3  "*   Q$Vs?Qr~)rrrr.)rr.rr.)rSequence[object]rztuple[str, str])NrN) rrrSequence[str] | Nonerr.rCallable[[object], str] | Nonerr.)rrrrrr)r Callable[..., Any]rr rr rr rrrr.rboolrr.r"rrrrrrr.rr rr )r'r rr )rzlist[tuple[str, Any]])rrrr.r<r]r,rr-rr.rr/rrrr0rr1list[str] | Nonerr!)r3r4r5rr7rerrrrrrrr#r%r(r*rr8r9r:r"r"gs9JI5I)E#J'+26   $   0   ,1%1.B1 10(0140@C0 0# ^^"%^  ^ ^8'+26 44$ 4 0 4 4( $$"!,0^ ^ ^  ^  ^ ^ ^ ^ ^ ^ *^  ^ r9r"c,eZdZdZdd ddZy) _BoxedCodeGenz CodeGen subclass that generates code using the "boxed" calling convention. The boxed calling convention takes a single list argument and clears it after extracting the arguments, which allows for early deallocation of input tensors. Frcd|jd|d}|rc|Dcgc]<}|dk7s |jddjddj>}}|r|dz }|D] }|d|d z } |d z }|Scc}w) a Generate function definition for boxed calling convention. Instead of taking individual arguments, the generated function takes a single 'args_list' parameter, extracts placeholder values from it, and clears the list. rz(self, args_list)rrdr=z args_iter = iter(args_list) z = next(args_iter)z args_list.clear())rrr)rdrrrfn_defrplaceholder_varsvars r:rz_BoxedCodeGen.gen_fn_defs((9:Q9RRST @I :;AQWK Q%%c*1-335    ==+?Cse+=>>F?33  s A;6A;Nr)r3r4r5r6rr8r9r:rrs7# "%   r9rceZdZd fd Zd dZddZddZ ddZdd dfdZd d d  dfd Z xZ S)_PyTreeCodeGenc0t|||_yr=)superre pytree_info)rdr ras r:rez_PyTreeCodeGen.__init__?s (3r9c*tj|}|Sr=)rGarg_tree_leaves)rdinputs flat_argss r:r%z_PyTreeCodeGen.process_inputsCs**F3 r9c|j|jj|St|ttfs|g}|jj t dt j||jjS)Nzpytree_info.out_spec is None)r rrr!rrorGtree_unflattenrdouts r:r(z_PyTreeCodeGen.process_outputsGsv    #t'7'7'@'@'HJ#e}-%C    $ $ , !?@ @$$S$*:*:*C*CDDr9c|sy|Dcgc] }d|vs| }}|sy|rddj|zSddjd|DzdzScc}w)z=Helper to format annotations for variables in pytree codegen.rrrc3&K|] }|dz yw)z; Nr8rrMs r:rz5_PyTreeCodeGen._format_annotations..\s%G1a$h%Grrr)rdrrrMhas_annotations r:_format_annotationsz"_PyTreeCodeGen._format_annotationsPsb%.;#(!;; hmmN;; ;bgg%G%GGG$N N.ps(1s"QCLs}z([z], z), self._in_specrrrz , = fx_pytree.tree_flatten_spec(r) r rrr num_childrenchilddictrrrcontextrr) rdfn_argsrrrhas_args_kwargs_tuple fn_kwargs fn_signature count_argsrMwithout_annotationbindingss r:gen_var_bindingsz_PyTreeCodeGen.gen_var_bindings^s""** LLE ! .$$) . a %%. . a %%-   499W-..>?  q)66J&&00*=G)) # a(00((22:;?!   ' 233ykAQRL FOOaggcl1o33C8;OO++I|D YY!"##CL>QRV V Ps-FFrc:|jt| |||S|jj}t |dkDr|ddk(nd}|r|j ddt| |dd||}t |dkDr||j |||z }|S)NrrrdF)r rrrrrr')rdrrrr  has_orig_self fn_definitionras r:rz_PyTreeCodeGen.gen_fn_defs,    #7%2& "",,25g,2Bv-    Q '* AJ/l+  y>A  T227I|T TMr9Nrc|t}|jrR|jjr<|.t|tt fr|j ||d|dzSd||dSt|!|||S)Nreturn pytree.tree_unflatten(r , self._out_spec)r) rr rrr!rrrr#)rdr"rrras r:r#z_PyTreeCodeGen.generate_outputs ?G    0 0 9 9 Z dE]%K44#7 ' 5 * *7w{7K6LL]^^7*;eW*U Ur9)r rrrr r rr rr rr )rrrrrr.r rrrrrrr.rr) r3r4r5rer%r(rr'rr# __classcell__ras@r:rr>s4E O% %-6%FJ% %X# %%"%%  % %V'+26 VV$ V 0 V VVr9rc|eZdZ dfd Zdfd Zd fd Zd fd Z d dZd dZxZ S) _ExportCodeGenc\t||||_||_||_||_yr=)rrein_shuffle_graphout_shuffle_graphtree_leaf_namesroot)rdr r6r7r8r9ras r:rez_ExportCodeGen.__init__s1 % 0!2. r9ct||}|j|jg|}||_|j|Sr=)rr%r9r r6)rdr r ras r:r%z_ExportCodeGen.process_inputssGG*F3 99 /Y/I"$t$$i00r9cf|jg|j|}|`t| |}|Sr=)r7r rr()rdr flat_outsretras r:r(z_ExportCodeGen.process_outputss:*D**ADNNASA Ng%i0 r9c&t||i|}|Sr=)rr)rdrrrras r:rz_ExportCodeGen.gen_fn_defs#T4V4 r9c X|Dcgc](}|jddjdd*}}dj|}|jd|}ddj|jd|ddj|d dj|jd Scc}w) Nrrrrzself, rz, = pytree.tree_leaves((z,)) z, = self._in_shuffle_graph(r)rrr9r8)rdr rrrMr%r#s r:r'z_ExportCodeGen.gen_var_bindingssFOOaggcl1o33C8;OO#yy12 99 #L>2L YYt##$%%=l^L YY!"##>tyyI]I]?^>__`d d Ps-B'c t|ttfstdt |ddj |j ddj |Dcgc] }t|c}d}d|dScc}w)Nz,Expected list or tuple for output_args, got zself._out_shuffle_graph(rrr,r-)rr!r TypeErrorrrr8r.)rdr"rrrWr+s r:r#z_ExportCodeGen.generate_outputs+e}5>tK?P>QR ,DIId6J6J,K+LBtyyjuYvefZ]^_Z`YvOwNxxyz.vh6GHHZwsA<) r rr6r%r7r%r8rr9ztorch.nn.Module | Nonerrr.r/)rr rr rr.r0)r"rrr rr rr.) r3r4r5rer%r(rr'r#r1r2s@r:r4r4s   & '  #  %   1  d  d-6 dFJ d  dIr9r4cFeZdZdZd dZd dZd dZd dZd dZdddd Z y)_FindNodesLookupTablezH Side table for the graph for the purpose of doing fast queries c,tt|_yr=)rrtablercs r:rez_FindNodesLookupTable.__init__sHS I  r9cV|j|jdk(r |jfSdfS)Nr&r}rrdrs r:_keyz_FindNodesLookupTable._keys(?(BMMMMr9cB||j|j|vSr=rErIrHs r: __contains__z"_FindNodesLookupTable.__contains__stzz$))D/222r9cFd|j|j||<yr=rKrHs r:rz_FindNodesLookupTable.insert s,0 499T?#D)r9c^|j|j|j|yr=)rErIpoprHs r:removez_FindNodesLookupTable.remove s! 499T?#''-r9Nrc|dk(r.| tdg|j||fjS|!g|j|dfjS|j|dfDcgc]}|j|k(s|c}Scc}w)Nr&z,target must not be None for call_function op)rorErr)rdr}rrs r: find_nodesz _FindNodesLookupTable.find_nodess  ~$%STT5TZZV -2245 5 >3TZZT +0023 3"&RJ!7Q4;;&;PQQQs *B?Br~)rrrztuple[str, Target | None]rrrrr)r}r.r Target | Noner list[Any]) r3r4r5r6rerIrLrrPrSr8r9r:rCrCs- N31.>B Rr9rCc eZdZdZed d/ d0dZed1dZejd2dZed3dZ ed d4d Z ed ddd  d5d Z ed d6 d7d Z d8d9dZ ed d: d;dZed ddZedd8d?dZedd8d?dZeddej*j,f d@dZedd8dAdZed d/ dBdZed d/ dCdZed d: dDdZedEdZed dFdZed dFdZed dGdZ ed  dHdZ!ed  dIdZ"ed dJd Z#edd!f dKd"Z$ed d8 dLd#Z%dMd$Z&edd d d d d d dd% dNd&Z'd d d d d d dd% dOd'Z(dPd(Z)eddQd)Z*eddQd*Z+ed d8 dRd+Z,ed dSd,Z-ed  dTd-Z.dQd.Z/y)Ur#a ``Graph`` is the main data structure used in the FX Intermediate Representation. It consists of a series of ``Node`` s, each representing callsites (or other syntactic constructs). The list of ``Node`` s, taken together, constitute a valid Python function. For example, the following code .. code-block:: python import torch import torch.fx class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x): return torch.topk( torch.sum(self.linear(x + self.linear.weight).relu(), dim=-1), 3 ) m = MyModule() gm = torch.fx.symbolic_trace(m) Will produce the following Graph:: print(gm.graph) .. code-block:: text graph(x): %linear_weight : [num_users=1] = self.linear.weight %add_1 : [num_users=1] = call_function[target=operator.add](args = (%x, %linear_weight), kwargs = {}) %linear_1 : [num_users=1] = call_module[target=linear](args = (%add_1,), kwargs = {}) %relu_1 : [num_users=1] = call_method[target=relu](args = (%linear_1,), kwargs = {}) %sum_1 : [num_users=1] = call_function[target=torch.sum](args = (%relu_1,), kwargs = {dim: -1}) %topk_1 : [num_users=1] = call_function[target=torch.topk](args = (%sum_1, 3), kwargs = {}) return topk_1 For the semantics of operations represented in the ``Graph``, please see :class:`Node`. TrNct|ddddi|_i|_|jj|_d|_t |_||_||_ ||_ t|_ i|_ t|_y)z+ Construct an empty Graph. rr9r8rN)rrraprependrrr]_graph_namespace_owning_module _tracer_cls_tracer_extrasr"_codegen _co_fieldsrC_find_nodes_lookup_table)rd owning_module tracer_cls tracer_extrass r:rezGraph.__init__Osw b&"b"= +-zz))  * +%+  *,(=(?%r9c|jSr=r[rcs r:razGraph.owning_modulees"""r9c||_yr=re)rdmods r:razGraph.owning_moduleis !r9ct|S)av Get the list of Nodes that constitute this Graph. Note that this ``Node`` list representation is a doubly-linked list. Mutations during iteration (e.g. delete a Node, add a Node) are safe. Returns: A doubly-linked list of Nodes. Note that ``reversed`` can be called on this list to switch iteration order. )rrcs r:rz Graph.nodesms$r9Fcttt|j}|jdk7rt d|j|S)Nr+zExpected output node, got op=)nextiterrrr}ro)rd output_nodes r:rlzGraph.output_node|sD4 456 >>X % #@@P!QR Rr9)rsortcZ|jj||}|r t|S|S)a Allows for fast query of nodes Args: op (str): the name of the operation target (Optional[Target]): the target of the node. For call_function, the target is required. For other ops, the target is optional. sort (bool): whether to return nodes in the order they appear on on the graph. Returns: Iterable of nodes with the requested op and target. rG)r`rSsorted)rdr}rrm node_lists r:rSzGraph.find_nodess3,11<<6<R )$ $r9c|jD]V}|vr|jdk(r(t|jdfd}|s|cS||fcS|j |fd|<Xy)aM Copy all nodes from a given graph into ``self``. Args: g (Graph): The source graph from which to copy Nodes. val_map (Dict[Node, Node]): a dictionary that will be populated with a mapping from nodes in ``g`` to nodes in ``self``. Note that ``val_map`` can be passed in with values in it already to override copying of certain values. Returns: The value in ``self`` that is now equivalent to the output value in ``g``, if ``g`` had an ``output`` node. ``None`` otherwise. r+rc|Sr=r8rnval_maps r:rz"Graph.graph_copy..s WQZr9c|Sr=r8rss r:rz"Graph.graph_copy..s 71:r9N)rr}map_argr node_copy)rdgrtreturn_output_noderrvs ` r: graph_copyzGraph.graph_copysp(GG GDwww("TYYq\+?@!3rC"dC NN41EFGDM  Gr9c|r|ni}t|j}|j||d}tj|j |_|nt |tstdt||\}}|j|t|dd}tj|j|_ |S)a Explicitly implement __deepcopy__ to prevent excessive recursion depth from the default implementation. This uses graph_copy to copy the nodes in an iterative way, rather than recursive. It also populates the memoization table to prevent unnecessary copies (e.g. references to nodes or other parts of the Graph from a custom GraphModule implementation. )rbT)rtryNz&Expected output_vals to be tuple, got r type_expr) r#r\r{copydeepcopyr^rrrorr+rUr)rdmemorx output_vals output_valold_output_nodenew_output_nodes r: __deepcopy__zGraph.__deepcopy__st T-- .ll ## ]]4==1  "k51$ Q %%,,Q/ Q r9c4|jj|S)zL Processes args so that they can be passed to the FX graph. )r^r%rs r:r%zGraph.process_inputs)s ,t}}++T22r9c8|jj|Sr=)r^r(rs r:r(zGraph.process_outputs0s}},,S11r9c t|jdkDr2td|dt|jd|jd|j|k7rtd|d|jrt j d|d y |j:t|jd d #|jjD] }|| |jj||jd |_|xjd zc_ |jt|j dt|j"dy )z Erases a ``Node`` from the ``Graph``. Throws an exception if there are still users of that node in the ``Graph``. Args: to_erase (Node): The ``Node`` to erase from the ``Graph``. rzTried to erase Node z but it still had z users in the graph: !zAttempting to remove z from wrong graph!z erase_node(z) on an already erased nodeN_erase_node_hooksTrcyr=r8rns r:rz"Graph.erase_node..Yr9cyr=r8rs r:rz"Graph.erase_node..Zrr9)rr~ RuntimeErrorr_erasedrrrarUrr`rP_remove_from_listr_update_args_kwargsrv_args_kwargs)rdto_erasers r: erase_nodezGraph.erase_node4sB x~~  "&xj0B3x~~CVBWX''/~~&6a9  >>T !!6xj@RST T    MMKz1LM N     ***,?FR''99 (   %%,,X6""$ Q  $$ HNNN 3 H$$n 5 r9c||j|jS|j|k7r tdt ||j S)aSet the point at which create_node and companion methods will insert into the graph. When used within a 'with' statement, this will temporarily set the insert point and then restore it when the with statement exits:: with g.inserting_before(n): ... # inserting before node n ... # insert point restored to what it was previously g.inserting_before(n) # set the insert point permanently Args: n (Optional[Node]): The node before which to insert. If None this will insert before the beginning of the entire graph. Returns: A resource manager that will restore the insert point on ``__exit__``. z&Node to insert before is not in graph.)inserting_afterrrrorrYrdrns r:inserting_beforezGraph.inserting_before]sF& 9'' 3 3 77d? !IJ JD!)),,r9c||j|jS|j|k7r tdt ||j S)aSet the point at which create_node and companion methods will insert into the graph. When used within a 'with' statement, this will temporarily set the insert point and then restore it when the with statement exits:: with g.inserting_after(n): ... # inserting after node n ... # insert point restored to what it was previously g.inserting_after(n) # set the insert point permanently Args: n (Optional[Node]): The node before which to insert. If None this will insert after the beginning of the entire graph. Returns: A resource manager that will restore the insert point on ``__exit__``. z%Node to insert after is not in graph.)rrrrorrvrs r:rzGraph.inserting_aftervsF& 9((4 4 77d? !HI ID!((++r9cn|tjjurdn|f}|jd|||S)a% Insert a ``placeholder`` node into the Graph. A ``placeholder`` represents a function input. Args: name (str): A name for the input value. This corresponds to the name of the positional argument to the function this ``Graph`` represents. type_expr (Optional[Any]): an optional type annotation representing the Python type the output of this node will have. This is needed in some cases for proper code generation (e.g. when the function is used subsequently in TorchScript compilation). default_value (Any): The default value this function argument should take on. NOTE: to allow for `None` as a default value, `inspect.Signature.empty` should be passed as this argument to specify that the parameter does _not_ have a default value. .. note:: The same insertion point and type expression rules apply for this method as ``Graph.create_node``. r8r*)rr~)r  Signatureemptyr)rdr?r~ default_valuers r:r*zGraph.placeholders;<#g&7&7&=&==rMCS t$)TTr9c dd}|j*||j|stjdd|jd||S)a Insert a ``get_attr`` node into the Graph. A ``get_attr`` ``Node`` represents the fetch of an attribute from the ``Module`` hierarchy. Args: qualified_name (str): the fully-qualified name of the attribute to be retrieved. For example, if the traced Module has a submodule named ``foo``, which has a submodule named ``bar``, which has an attribute named ``baz``, the qualified name ``foo.bar.baz`` should be passed as ``qualified_name``. type_expr (Optional[Any]): an optional type annotation representing the Python type the output of this node will have. Returns: The newly-created and inserted ``get_attr`` node. .. note:: The same insertion point and type expression rules apply for this method as ``Graph.create_node``. c|jd\}}} |j|}t ||syt ||}t|tjjs3t|tjjs||jvryy#t$rtjd|dYywxYw)NrzFailed to fetch module rFT) rpartition get_submoduleAttributeErrorrrr[rUrrDrWModule Parameter_buffers)rgri module_pathrgr?submodrss r:_get_attr_reference_existsz2Graph.get_attr.._get_attr_reference_existss$2#<#=B>a Attempted to insert a get_attr Node with no underlying reference in the owning GraphModule! Call GraphModule.add_submodule to add the necessary submodule, GraphModule.add_parameter to add the necessary Parameter, or nn.Module.register_buffer to add the necessary bufferrirr(r})rgztorch.nn.Modulerir.rr)rarrr)rdrir~rs r:r(zGraph.get_attrsr4   25   2    )2L   3  MM#  NiPPr9c|j0|jj|tjd|j d||||S)a Insert a ``call_module`` ``Node`` into the ``Graph``. A ``call_module`` node represents a call to the forward() function of a ``Module`` in the ``Module`` hierarchy. Args: module_name (str): The qualified name of the ``Module`` in the ``Module`` hierarchy to be called. For example, if the traced ``Module`` has a submodule named ``foo``, which has a submodule named ``bar``, the qualified name ``foo.bar`` should be passed as ``module_name`` to call that module. args (Optional[Tuple[Argument, ...]]): The positional arguments to be passed to the called method. Note that this should *not* include a ``self`` argument. kwargs (Optional[Dict[str, Argument]]): The keyword arguments to be passed to the called method type_expr (Optional[Any]): an optional type annotation representing the Python type the output of this node will have. Returns: The newly-created and inserted ``call_module`` node. .. note:: The same insertion point and type expression rules apply for this method as :meth:`Graph.create_node`. zAttempted to insert a call_module Node with no underlying reference in the owning GraphModule! Call GraphModule.add_submodule to add the necessary submoduler)r})rarrrr)rdrYrrr~s r:r)zGraph.call_modules^N    *""00=E MM&  ;f    r9c.|jd||||S)aj Insert a ``call_method`` ``Node`` into the ``Graph``. A ``call_method`` node represents a call to a given method on the 0th element of ``args``. Args: method_name (str): The name of the method to apply to the self argument. For example, if args[0] is a ``Node`` representing a ``Tensor``, then to call ``relu()`` on that ``Tensor``, pass ``relu`` to ``method_name``. args (Optional[Tuple[Argument, ...]]): The positional arguments to be passed to the called method. Note that this *should* include a ``self`` argument. kwargs (Optional[Dict[str, Argument]]): The keyword arguments to be passed to the called method type_expr (Optional[Any]): an optional type annotation representing the Python type the output of this node will have. Returns: The newly created and inserted ``call_method`` node. .. note:: The same insertion point and type expression rules apply for this method as :meth:`Graph.create_node`. r'r}r)rd method_namerrr~s r:r'zGraph.call_method)s(F ;f    r9c0|jd|||||S)ag Insert a ``call_function`` ``Node`` into the ``Graph``. A ``call_function`` node represents a call to a Python callable, specified by ``the_function``. Args: the_function (Callable[..., Any]): The function to be called. Can be any PyTorch operator, Python function, or member of the ``builtins`` or ``operator`` namespaces. args (Optional[Tuple[Argument, ...]]): The positional arguments to be passed to the called function. kwargs (Optional[Dict[str, Argument]]): The keyword arguments to be passed to the called function type_expr (Optional[Any]): an optional type annotation representing the Python type the output of this node will have. name (Optional[str]): The name of the node. If not specified, set to None Returns: The newly created and inserted ``call_function`` node. .. note:: The same insertion point and type expression rules apply for this method as :meth:`Graph.create_node`. r&)r?r~r)rd the_functionrrr~r?s r:r&zGraph.call_functionPs*L \4di   r9cd|jvr|jddfSd|jvr|jddfSy)aRead the example tensor stored on ``tensor_node`` under either ``meta['val']`` (export / proxy_tensor convention) or ``meta['example_value']`` (dynamo convention). Returns ``(value, key)`` where ``key`` is the meta key the value was found under (defaulting to ``"val"`` if no meta is present). Callers that emit a new node should mirror ``key`` so the new node matches the surrounding graph's convention. rr)Nr)r) tensor_nodes r:_get_tensor_meta_valzGraph._get_tensor_meta_valzsO K$$ $##E*E1 1 k.. .##O4oE Er9c|j|\}}|jtjjj j ||f}||j||j|<|S)z0Create an FX node for ``tensor_node.size(dim)``.) rr&rDopsatensym_sizerrrcrrdrrPrrrs r:create_size_nodezGraph.create_size_nodesb,,[9S!!%)).."9"9"="= S?QR ? XXc]DIIcN r9c|j|\}}|jtjjj j ||f}||j||j|<|S)z2Create an FX node for ``tensor_node.stride(dim)``.) rr&rDrr sym_striderrrrrs r:create_stride_nodezGraph.create_stride_nodesb,,[9S!!%))..";";"?"?+sAST ? ZZ_DIIcN r9c|j|\}}|jtjjj j |f}||j|j|<|S)z7Create an FX node for ``tensor_node.storage_offset()``.) rr&rDrrsym_storage_offsetdefaultstorage_offsetr)rdrrrrs r:create_storage_offset_nodez Graph.create_storage_offset_nodese,,[9S!! IINN - - 5 5 ~  ? //1DIIcN r9cddl}ddlm}m}m}m}|} d} | t |kr9|| } | dzt |kr|| dznd} t| |rt| tjru| j} | jdk(r|j| | } n@| jdk(r|j| | } n|j| j| | f} | dz } nnt| |rE| jdk(r|j| } n|j| j| f} | dz } nt| tjr.|j!|j"| | jf} | dz } nt| |r)|j!t$j&| ddf} | dz } nt| |rR| j(}t|t$j*r||}|j!|j,| |f} | dz } nBt| |r(|j!t.| | j0f} | dz } nt3d | | t |kr9| S) aWalk an ``unbacked_bindings`` keypath, emitting FX ops on this graph to recover the bound SymInt from ``producer``'s result. ``lower_symint`` is invoked for the only keypath component that may carry a non-literal value: ``DivideByKey`` with a SymInt divisor. Callers must provide one (e.g. a wrapper around their sympy interp cache). rN) CallMethodKey ConvertIntKey DivideByKeyInnerTensorKeyrrcrrirzunrecognized keypath component )operator%torch.fx.experimental.symbolic_shapesrrrrrrrG SequenceKeyrr?rrr'rr&getitemrDsym_itedivisorrfloordivrU inner_namero)rdproducerkeypath lower_symintrrrrrrrrnxtrrs r:_resolve_unbacked_bindingzGraph._resolve_unbacked_bindings)    #g, A$%ECL$8'!a%.dC!]+ 3@R@R0Sgg66V#00s;DVVx'224=D++AFFT3K@DQA}-66--::4@D++AFFTG\}}t|tj,s!||jj ||@|j.j1d }|s|j3D]"\} } j5| |t7| f$Jdd lmdd lmm dfd df d dfd d f d g} |D]P}t|tj,rnGt|tBr| jE|AtGdtI|jJd|d|jj } | jLr| jEtC|| jND] } |  | } t| tjj$sCt| tBtPfstSd| d| | jEtC| +| j}||| jE|S| S)ay Materialize a list of ``SymInt``/``int`` values as FX subgraphs rooted at existing nodes in this graph whose meta produces the referenced symbols (typically SymInt placeholders or other sym ops). consider a graph with a tensor placeholder ``%x`` of shape ``(s32, s32)`` and we want to record this stride as an FX value to pass to a later op, two ways to do it. * ``g.create_stride_node(%x, 0)`` emits ``%t = aten.sym_stride.int(%x, 0)``. The semantics of this op are "ask ``%x`` for its current stride at dim 0". If a later pass (e.g. mkldnn channels-last conversion) mutates ``%x``'s layout, re-running ``FakeTensorProp`` will overwrite ``%t.meta["val"]`` with the NEW stride. This is the right behavior when you want a *live* query on the producer. * ``g.materialize_symints([%x.meta["val"].stride(0)])`` walks the sympy expression ``s32`` and emits an FX subgraph that recomputes it from the existing producer of ``s32`` (here the placeholder ``%x`` itself via ``aten.sym_size.int(%x, 0)``, or a SymInt placeholder if one exists). The resulting node's value is "what ``s32`` is at runtime" -- which is determined by the input's shape and is INDEPENDENT of any layout change to ``%x``. This is the right behavior when you want to *freeze* the trace-time stride into the graph. Note: like other ``Graph`` node-creation APIs (``call_function``, ``create_size_node``, etc.), nodes are emitted at the graph's current insertion point. The default insertion point (``Graph._root.prepend``) appends new nodes to the end of the graph, which on a graph that already has an ``output`` node means they land *after* ``return`` (orphaned). Callers typically scope this in ``with graph.inserting_before(graph.output_node()):`` so the new nodes land in the body. Performance: each call performs an O(graph_size) producer-discovery scan and builds a per-call ``expr_to_proxy`` hash-cons cache. Prefer batching every SymInt you need to lift into a single call (or as few calls as possible) over calling it once per value -- this amortises the graph scan and lets symints with shared sub-expressions get hash-consed into a single subgraph. rN)_run_sympy_handler sympy_interp)PythonReferenceAnalysiscv|jjd}||S|jjdS)Nrr)rrqrnrs r: _node_valz,Graph.materialize_symints.._node_val$s1&&**U#C 66::o. .r9cz||jd<td|jDr||jd<yy)zSet ``n.meta['val']`` and, if any of ``n``'s input nodes carry ``"example_value"``, mirror it there too so the new node matches the surrounding graph's meta-key convention.rc3\K|]$}t|txrd|jv&yw)rN)rrr)rrWs r:rzCGraph.materialize_symints.._set_node_val../s(U:a&D?aff+DDUs*,rN)ranyrrs r: _set_node_valz0Graph.materialize_symints.._set_node_val*s7 AFF5MUaffUU*-'Vr9ct|jrj|||dfyt|jrt |j dk(r|j \}}t|jrt|j r||}}t|jrEt|j r.t|dkDrj|||t|fyyyyyy)aCRegister ``(node, dim)`` as a recoverable source for ``expr``. - bare ``Symbol``: divisor = 1. - ``Symbol * c`` (positive integer constant): divisor = c. Recovery is ``sym_size.int(ph, dim) // c``. - anything else: skipped (general inverse needs sympy.solve). rNrir)rSymbolryMulrrIntegerrr)exprrrPrWbsym_size_sourcessympys r:_record_shape_sourcez7Graph.materialize_symints.._record_shape_sourceFs$ - ++D4a.A$ *s499~/Byy1a.:a3OaqAq%,,/"1emm4A $//D#s1v3FG#50 0C*r9r*tracerunbacked_bindings) BooleanAtom)rfree_unbacked_symbolsc`t|tjjr|S|Sr=)rrDrr)rWrs r: _arg_meta_valz0Graph.materialize_symints.._arg_meta_valts$!UXX]]+ |#Hr9c  |vr|St|jjj fr  |S |jDcgc] }| c}|}t|t j js|S||<|j}|j}t|s|S t fd|jD}|jjDcic]\}}| |}}}|||i||Scc}wcc}}w#ttt f$r"} t"j%d|| Yd} ~ |Sd} ~ wwxYw)Nc3.K|] }|ywr=r8)rrWrs r:rzJGraph.materialize_symints.._sympy_interp_cached..s!Fq-"2!FrYz8materialize_symints: skipping meta annotation for %s: %s)rrNumberrrrDrProxyrrrrrrrA ValueErrorrlogdebug)rrresultrr fake_argsrr fake_kwargsrrrrrr_sympy_interp_cached expr_to_proxyrrs r:rz7Graph.materialize_symints.._sympy_interp_cachedysZ}$$T**u}}ellELL+N$$;]DQQ''6:ii@s%c*@F fehhnn5 "(M$ ;;D[[FF#  !!FDII!FF ?C{{?P?P?RStq!q-"22S SdFI$E$EFM)ATz>:  N M  s0D <;D)7D# D)#D))E=EEc|jj}t|tjj r |jS|Sr=)rrrrDrr)drrs r:_lower_symint_divisorz8Graph.materialize_symints.._lower_symint_divisors5$QVV[[1A'588>>:166 A Ar9c |vry|vr!|\}}}jtjjjj ||f}|}t |tjr||j||dk7rvjj||f}t |tjr||j||ztjj||<ytjj||<y|vr|std|d|\}}|D]k} t | st | jtjs5| jjj j"D] }  |  mj%||} tjj| |<ytd|)Nrrz#materialize_symints: backed symbol zV has no input producer (backed symbols cannot be recovered from non-placeholder nodes))rz%materialize_symints: no producer for )r&rDrrrrrrrbrrrrrorrrr free_symbolsr)symphrPrsym_nodetensordiv_node producer_noderrs2rr_ensure_producedr rrrrrrdrsym_to_bindingrs r:rz3Graph.materialize_symints.._ensure_producedsm#&C#8 C--eiinn.E.E.I.IBPS9U"2fell3!(FLL,=>a< $11 ))Hg+> H"&%,,7%h S0AW0LM).)PM#&*/)PM#&n$,S1(=cUC67 *8)<& w 1A!![1j 5<<7#$)).."5"5"B"B1B,R01 1  99!79N:&+XX^^HV^%L c" #H!NO Or9z1materialize_symints: expected SymInt or int, got z (rz&materialize_symints: non-Proxy result z for non-constant target )rnrrr )rnrrr rr)r sympy.ExprrrrPrrrr)rWr rr )rrrr )r z torch.SymIntr Node | int)rz sympy.Symbolrr)*rrtorch.utils._sympy.interprrtorch.utils._sympy.referencerrDrproxyGraphAppendingTracerrr}rrrrrrrbrrrrrqrryrsympy.logic.boolalgrrrrrrrvrArr3 is_numberr rro)!rdvaluesrrrrrPrRr&rrr target_exprrout_noderrrrrr rrrrrrrrrrrrs!` @@@@@@@@@@@@@@@@@@r:materialize_symintszGraph.materialize_symintss\ NH /  .44T::< GINP H,JJ ODww-'oc<088==D!$ 5$m:S.3hhnnT&n.Q d+U\\2"+CII"6IQ%a60dCHI 99==)<=(0(8O W&11#eGn7MNO O" 4    D B) P) P) PV!# !A!U\\*As# 1 GAw''(1%q2&&++K$$ 3q6""// & % &)+6Ffehhnn5"&3+6(@ K//:o? 3v;'{{H (A & JJx = !> r9c,|j|gdS)zDSingle-value convenience wrapper around :meth:`materialize_symints`.r)r")rdrs r:materialize_symintzGraph.materialize_symints''033r9c|Sr=r8rLs r:rzGraph.sPQr9ct|j|}t|j|}t|tst dt |t|tst dt ||j|j|j|||j|j }tj|j|_ |S)aw Copy a node from one graph into another. ``arg_transform`` needs to transform arguments from the graph of node to the graph of self. Example:: # Copying all the nodes in `g` into `new_graph` g: torch.fx.Graph = ... new_graph = torch.fx.graph() value_remap = {} for node in g.nodes: value_remap[node] = new_graph.node_copy(node, lambda n: value_remap[n]) Args: node (Node): The node to copy into ``self``. arg_transform (Callable[[Node], Argument]): A function that transforms ``Node`` arguments in node's ``args`` and ``kwargs`` into the equivalent argument in ``self``. In the simplest case, this should retrieve a value out of a table mapping Nodes in the original graph to ``self``. zExpected args to be tuple, got z Expected kwargs to be dict, got )rvrrrrrorrrr}rr?rr)rdr arg_transformrr result_nodes r:rwzGraph.node_copys2tyy-0m4$& #B4:,!OP P&$' #CDL>!RS S&& GGT[[$ 499  99TYY/ r9c.|jdd|f|S)a5 Insert an ``output`` ``Node`` into the ``Graph``. An ``output`` node represents a ``return`` statement in Python code. ``result`` is the value that should be returned. Args: result (Argument): The value to be returned. type_expr (Optional[Any]): an optional type annotation representing the Python type the output of this node will have. .. note:: The same insertion point and type expression rules apply for this method as ``Graph.create_node``. r+)r}rrr~r)rdrr~s r:r+z Graph.output s',yI   r9ct|r |j}n9t|tst dt ||}t |r|dd}t|}|S)NzExpected target to be str, got ri)rr3rr.rorrNrS)rdrr}s r:rzGraph._target_to_str: sY F Bfc*$'FtF|n%UVVB}"X _ r9r+c  t d fd td fd } | |5|j| ||||||| cdddS#1swYyxYw)a Turn this ``Graph`` into valid Python code. Args: root_module (str): The name of the root module on which to look-up qualified name targets. This is usually 'self'. Returns: A PythonCode object, consisting of two fields: src: the Python source code representing the object globals: a dictionary of global names in `src` -> the objects that they reference. c<j|j|Sr=)rwr?)rnr<s r: node_reprz$Graph.python_code..node_repr| s((3 3r9c3Ki}|jD]}|j||<|_ d|jD] }|||_y#|jD] }|||_wxYwwr=)r_repr_fn)r orig_repr_fnsrr.s r:override_node_reprz-Graph.python_code..override_node_repr s~M  *&*mm d# )  * 8 "KK8D$1$$7DM8EKK8D$1$$7DM8s*A.AA.A++A.r+N)rnrrr.)rr#rGenerator[None, None, None])r]r _python_code) rdrr,r-r.r/rr0r1r2r<r.s @@r: python_codezGraph.python_codeF ss^L  4  8  8  % $$--)' /%    s AAc `|jj|j|||||||||  S)Nr+)r^rr) rdrr<r,r-r.r/rr0r1s r:r4zGraph._python_code sB}}-- JJ  ))%#+.  r9cg}dg}|jDcgc]}|j|}}dj|}d|d|dd}|D] }|s|d|zz }|Scc}w)zl Return a human-readable (not machine-readable) string representation of this Graph rrzgraph(rrrr)r format_noder)rdplaceholder_namesmaybe_return_typenamer node_strs param_strrRnode_strs r:__str__z Graph.__str__ s (*-/4EIZZPTT%%&78P PII/0 YKq!6q!9 :! <! )HX(( ) QsAc ddlm}|jDcgc];}|j|j |j |j|jg=}}t||gdy#t$r tdwxYwcc}w)z Prints the intermediate representation of the graph in tabular format. Note that this API requires the ``tabulate`` module to be installed. r)tabulatez`print_tabular` relies on the library `tabulate`, which could not be found on this machine. Run `pip install tabulate` to install the library.)opcoder?rrr)headersN) r@ ImportErrorprintrr}r?rrr)rdr@rn node_specss r: print_tabularzGraph.print_tabular s  )KO**UQqttQVVQXXqvvqxx@U U Z)W X   <    VsA.AB.Bc  dd fd }t}t jD]}|jtvrt d|d|jd|j urt d|d|j vrt d|d|jD] }|||  j||j|vrt d |jd|j|jjrjD]}|jd k(rQt|jstd|d |jd tj|jd t!|jt"s.check_arg s01Jqc,sKyy$" Q{m4UUYTZ\ +%" Q{m4``d_eg&r9zNode z had unknown opcode rzNode 'z ' does not belong to this Graph!z ' is not added to the side tablezNode redefined name r&z target z has type z but a Callable is expectedz but a str is expected)r(r)rz" references nonexistent attribute z of r)rz does not reference an nn.Moduler=)rrrn Node | Nonerr)r`rr} _legal_opsrrr`rrsr?rarrrrDrIrr.rrrUrrWr) rdrK seen_namesrr target_atomsm_itrratom new_m_itr seen_qualnamerJs ` @r:lintz Graph.lint s  #u !$ JJ &Dwwj("U4&0DTWWIQ#OPPzz%"VD61Q#RSS4888"VD61Q#RSS(( %#t$ % OOD !yyJ&"%9$))A#FGG NN499 % &    ! *77o-#DKK0(#D6$++jX\XcXcIdHef55 &dkk37(#D6$++jX\XcXcIdHef007799#';;#4#4S#9L ..E#,\#:*4$+E4$> (+bq1A(B $,"."'vXdkk]Bd#'&]O!=# 77m3J%uxx=#/"'vXdkk]!D6m_]=!=# !*!*#! * r9cX ddlm}|jd tjj j r$tjjj d fd }t}t|jD]P}||r t|jdk(s%|j||j!|j"Rt|dkD}|rt$j'd||j(|d|j+dD}|j(j-D]\\}} ||vs t/| tj0j2s0|| j4j7z}| j9^|S) a Remove all dead code from the graph, based on each node's number of users, and whether the nodes have any side effects. The graph must be topologically sorted before calling. Args: is_impure_node (Optional[Callable[[Node], bool]]): A function that returns whether a node is impure. If this is None, then the default behavior is to use Node.is_impure. Returns: bool: Whether the graph was changed as a result of the pass. Example: Before dead code is eliminated, `a` from `a = x + 1` below has no users and thus can be eliminated from the graph without having an effect. .. code-block:: python def forward(self, x): a = x + 1 return x + self.attr_1 After dead code is eliminated, `a = x + 1` has been removed, and the rest of `forward` remains. .. code-block:: python def forward(self, x): return x + self.attr_1 .. warning:: Dead code elimination has some heuristics to avoid removing side-effectful nodes (see Node.is_impure) but in general coverage is very bad, so you should assume that this method is not sound to call unless you know that your FX graph consists entirely of functional operations or you supply your own custom function for detecting side-effectful nodes. r) OrderedSetTc:|S|jSr=) is_impure)r impure_randomis_impure_nodes r:has_side_effectz2Graph.eliminate_dead_code..has_side_effectb s#)%d++>>-0 0r9z1The following nodes were dead code eliminated: %sc34K|]}|jywr=rQrs r:rz,Graph.eliminate_dead_code..v s((sr()r}rT)torch.utils._ordered_setrVrTrD_guardsTracingContexttry_get _inductorconfigfallback_randomr`rrrr~rrsr?rinforarSnamed_childrenrrr%reliminate_dead_code recompile) rdrZrVr[ removed_nodesrchangedsubgraph_names child_name child_modulerYs ` @r:rfzGraph.eliminate_dead_code+ seZ 8  == ' ' / / 1!OO22BBM 1 TZZ( -D"4(S_-A%!!$)), - m$q(  HHH- X    )'("&//Z/"@(N-1,>,>,M,M,O -( L/J %(("6"65|11EEGGG **, -r9c||_yr=)r^)rdcodegens r: set_codegenzGraph.set_codegen s  r9cjj|j_tjdfd }|S)a- Register a transformer function when python code is generated Args: make_transformer (Callable[[Optional[TransformCodeFunc]], TransformCodeFunc]): a function that returns a code transformer to be registered. This function is called by `on_generate_code` to obtain the code transformer. This function is also given as its input the currently registered code transformer (or None if nothing is registered), in case it is not desirable to overwrite it. This is useful to chain code transformers together. Returns: a context manager that when used in a `with` statement, to automatically restore the previously registered code transformer. Example: .. code-block:: python gm: fx.GraphModule = ... # This is a code transformer we want to register. This code # transformer prepends a pdb import and trace statement at the very # beginning of the generated torch.fx code to allow for manual # debugging with the PDB library. def insert_pdb(body): return ["import pdb; pdb.set_trace()\n", *body] # Registers `insert_pdb`, and overwrites the current registered # code transformer (given by `_` to the lambda): gm.graph.on_generate_code(lambda _: insert_pdb) # Or alternatively, registers a code transformer which first # runs `body` through existing registered transformer, then # through `insert_pdb`: gm.graph.on_generate_code( lambda current_trans: ( lambda body: insert_pdb( current_trans(body) if current_trans else body ) ) ) gm.recompile() gm(*inputs) # drops into pdb This function can also be used as a context manager, with the benefit to automatically restores the previously registered code transformer: .. code-block:: python # ... continue from previous example with gm.graph.on_generate_code(lambda _: insert_pdb): # do more stuff with `gm`... gm.recompile() gm(*inputs) # drops into pdb # now previous code transformer is restored (but `gm`'s code with pdb # remains - that means you can run `gm` with pdb here too, until you # run next `recompile()`). c3fK dj_y#j_wxYwwr=)r^r)on_gen_code_oldrdsr: on_generate_code_context_managerz@Graph.on_generate_code..on_generate_code_context_manager s( B2A // /s11.1)rr3)r^r contextlibr )rdmake_transformerrsrrs` @r:on_generate_codezGraph.on_generate_code sKR--99*:?*K '  " " B # B 011r9ct|jD]-}|jj|j |/yr=)rrrclearrrHs r: _clear_nodeszGraph._clear_nodes s4TZZ( "D IIOO  OOD ! "r9)NNN)raGraphModule | Nonerbztype[Tracer] | Nonerczdict[str, Any] | Nonerr)rrz)rgrzrr)rr)rr)r}r.rrUrmrrrV)F)rxr#rtzdict[Node, Node]ryrrzArgument | Noner=)rzdict[int, Any] | Nonerr#)NNNN)r}r.rrrtuple[Argument, ...] | Nonerdict[str, Argument] | Noner? str | Noner~ Any | Nonerrrr/)rrrr)rnrLrr)r?r.r~r~rr rr)rir.r~r~rr) rYr.rr{rr|r~r~rr) rr.rr{rr|r~r~rr) rrrr{rr|r~r~r?r}rr)rrrztuple[Any, str])rrrPrrrr)rrrr)rrrztuple[object, ...]rz$Callable[[torch.SymInt], Node | int]rr)rzSequence[torch.SymInt | int]rzlist[Node | int])rztorch.SymInt | intrr)rrr'zCallable[[Node], Argument]rr)rrr~r~)rrUrr.)rr.r,rr-rr.rr/rrrr0rr1rrr!)rr.r<r]r,rr-rr.rr/rrrr0rr1rrr!rr~)rZzCallable[[Node], bool] | Nonerr)rnr"rr)ruz7Callable[[TransformCodeFunc | None], TransformCodeFunc]rz'contextlib.AbstractContextManager[None])0r3r4r5r6rrepropertyrasetterrrlrSr{rrr%r(rrrr rrr*r(r)r'r& staticmethodrrrrrr"r$rwr+rr5r4r>rFrTrfrorvryr8r9r:r#r#s-^$/-1*./3 @)@(@- @  @0@*##""    %01 %037T"/>B 12$/NS!1GK 08>$/ -1-1 $L LL* L + L  LL L0L\%0313 %0212$/& 0& P$/-0-0$/,0,0$/!%$..44 UUU U  U0U@$/AQ0AQF$/-1-1 $ 2 2 *2 + 2  2  2 02 h$/-1-1 $ $ $ *$ + $  $  $ 0$ L$/-1-1 $ ' (' *' + '  '  '  ' 0' R %01%01%01%0<<$<; <  <1<|%0L2L L1L\%0414$/FQ"")C" "0"H$/9=  +5 0 0 $/ $$"!,0PP P  P  PPPP*P P0Pn$$"!,0           *   4$$/ 0 *$/M*0M*^$/>BV;V V0Vp%0 1 %0R2QR2 1R21R2h"r9r#c#Ktj} |t_d|t_y#|t_wxYwwr=)r"r)overridetmps r:_override_sym_reprr s3   C $ Cs?/ ? <?c|Sr=r8rLs r:rr s Hr9cdfd }|S)Ncd}||S)Nzr8)rRresetrs r:rz_make_color_fn..f ss5'""r9rRr.rr.r8)rrs` r:_make_color_fnr s# Hr9zzzzzzz z )yellowcyangreenrRrNrPrQrOz# COUNTER: (\d+)z{} + {}z{} - {}z{} * {}z{} // {}z{} / {}z{} % {}z{} ** {}z{} << {}z{} >> {}z{} & {}z{} | {}z{} ^ {}z{}[{}]z{} @ {})rsrmmulrtruedivdivrgpowlshiftrshiftand_or_xorrmatmulz{} == {}z{} != {}z{} < {}z{} > {}z{} <= {}z{} >= {}z+{}z-{}z~{}) eqneltgtlegeposneginvertz{} += {}z{} &= {}z {} //= {}z {} <<= {}z{} %= {}z{} *= {}z{} @= {}z{} |= {}z {} **= {}z {} >>= {}z{} -= {}z{} /= {}z{} ^= {}z {}[{}] = {})iaddiand ifloordivilshiftimodimulimatmulioripowirshiftisubitruedivixorsetitem)r?r.r/r.r1r0rr)rMr.rrr)r1r0rr)rur.rr.rr.r=)rr.rz&Callable[[str, str, str], bool] | Nonerz_ParsedStackTrace | None)rrrr3)rMr.rr.)rr.rzCallable[[str], str]) __future__rbuiltinsrtrr_ functoolsr keywordloggingmathrrrrArCr collectionsrcollections.abcrrrrr r dataclassesr r r rrrDtorch.utils._pytreeutilsrrGtorch._Crrvrtorch._library.opaque_objectrr torch.typesrtorch.utils._dtype_abbrsrrrF_compatibilityrimmutable_collectionsrrrrrrr tensor_typer getLoggerr3r__all__r_symbolic_tracer$ graph_moduler%r!ListrDictr`Set frozenset FrozenSetrTuplerFfromkeysrMr.TransformCodeFuncr-kwlistr0r>update__dict__r;r7r@rArBrrErNrSpartialrrmrPrlrj fullmatchrVr[r]r!rrrrrrr"rrr4rCr#rrr _color_codesrrrreflectable_magic_methodsrr)rrs00r:rs"  #MM%!:: $$6R$0")1II#g! ,')  &++&++ v 6<< ]]X d3i[$s)34 Z (/~~6!!VX+6h''(.0+0  6A 6A%