tjUddlmZddlZddlZddlZddlZddlZddlZddlZddl 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 dle?Z@gdZAerddlBZBd dlCmDZDd dlEmFZFeGejHeIejJeKejLeMejNeOejPiZQeIRgdZSeeGeTgeGeTfZUGddeZVdejWDZXeXYejZiZ[de\d<dd"Z]e]d#d$e j^e]d%d&e j_e]d'd(e`de]d)d*e e]d+d,e jae]d-d.e1e]d/d0e$dd3Zbdd5Zcejde jed6jfd7Zge jed8Zhe jed9Zie jed:jjZkdd;ZlGd<d=Zme3d>?eGd@dAZnddDZoGdEdFZpGdGdHZqGdIdJeZred>KGdLdMZs dddRZte3dS?GdTdUZuGdVdWeuZvGdXdYeuZwGdZd[ewZxGd\d]Zye3d>?Gd^d_ZzeddcZ{dddZ|ddgZ}dhdidjdkdldmdndodpZ~dqe~DZe jedrZdsdtdudvdwdwdxdydzd{d|d}d~dddZdddddddddd eZdddddddddddddddZdS)) 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<dS)_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__L/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/fx/graph.pyr-r-Fs.OOOKKKKKr9r-c,i|]}|tSr8)r0).0ks r: r>Us666!!VXX666r9zdict[str, _CustomBuiltin]_custom_builtinsnamer.r/r1r0returnNonecJt||t|<|t|<dSN)r-r?_illegal_names)r@r/r1s r:_register_custom_builtinrF[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 pytreexboolcV|do|dS)N__) startswithendswithrNs r: _is_magicrUis% <<   2!**T"2"22r9scDt|S)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)rVs r: _snake_caserZms 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}|7|dkr1ttjjfD]}t||d|urdSdS)Nr4r3rJTF)getattr_torch_but_not_dynamorJnn functional)r1 module_namer@guesss r:_is_from_torchrbs#|T22K$[11== 3 D ) )D DGOOUX01  EudD))S00tt1 5r9c2eZdZdZddZdd Zdd Zdd ZdS) _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. rArBcHi|_t|_i|_dSrD) _obj_to_nameset _used_names _base_countselfs r:__init__z_Namespace.__init__s$/1%(UU+-r9 candidater.r1 object | Nonec|||jvr |j|St|}|ltd|}|sd}|drd|}t|}|t d||dd\}}| ||jvrE|j |d}t |||ur |dz }|d|}nt|}||jvr|dz }|d|}||jv|j |||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. N__unnamedrz&Name regex failed to match candidate: r)rf _name_regexmatch_illegal_char_regexsubisdigitAssertionErrorgrouprhrigetrEintadd)rkrmr1rtbasenums r: create_namez_Namespace.create_names ?sd&777$S) )!!),, =+//Y??I '& |##%% ,+ OO %%i00E}$HYHHKK1%% c ;)t'777"&&tQ//C!!)S11<<q#OOcOO c((C4+++ 1HC#I4+++ Y'''!$ ?%.D c "r9r@r0cb|j||}||urtddS)zpAssociate a unique name with an object. Neither `name` nor `obj` should be associated already. zobj is already associatedN)rf setdefaultrx)rkr@r1maybe_existings r:associate_name_with_objz"_Namespace.associate_name_with_objs> *55c4@@  % % !<== = & %r9c||jvrtd|d||j|<|j|dS)NzObject z is not in _obj_to_name)rfrxrhr|)rkr1r@s r:_rename_objectz_Namespace._rename_objectsT d' ' ' !G3!G!G!GHH H!%# T"""""r9NrArB)rmr.r1rnrAr.)r@r.r1r0rArB)r1r0r@r.rArB)r3r4r5r6rlrrrr8r9r:rdrdso.... 1111f>>>>######r9rdTis_backward_compatiblec@eZdZUdZded<ded<ded<dZd ed <d S) 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_maprr{_prologue_startN)r3r4r5r6r7rr8r9r:r!r!sR  HHH.---Or9r!r}targetc|d}|}|D]'}|s d|d|d} |d|}(|S)N.zgetattr(z, ""))split isidentifier)r}relemsres r:_format_targetrsi LL  E A ~~ &1&&&&&AA q AA Hr9c&eZdZddZddZddZdS) _InsertPointgraphr# new_insertCallable[..., None]rArBc<||_|j|c|_|_dSrD)r_insert orig_insert)rkrrs r:rlz_InsertPoint.__init__ s  */-'%---r9cdSrDr8rjs r: __enter__z_InsertPoint.__enter__s r9typetype[BaseException] | NonevalueBaseException | Nonetbtypes.TracebackType | Nonec(|j|j_dSrD)rrr)rkrrrs r:__exit__z_InsertPoint.__exit__s "- r9N)rr#rrrArBr)rrrrrrrArB)r3r4r5rlrrr8r9r:rr sTDDDD    ......r9rc2eZdZ dddZdd Zdd Zdd ZdS) _node_list_nextrr# directionLiteral['_prev', '_next']rArBcN|dvrtd|||_||_dS)N)r_prevz*direction must be '_next' or '_prev', got )rxrr)rkrrs r:rlz_node_list.__init__sA . . . HYHH  "r9r{c|jjSrD)r_lenrjs r:__len__z_node_list.__len__%s zr9 Iterator[Any]cHt|jj|jdkS)Nrrr_rootrrjs r:__iter__z_node_list.__iter__-)4>W+DEEEr9cHt|jj|jdkS)Nrrrjs r: __reversed__z_node_list.__reversed__0rr9N)r)rr#rrrArB)rAr{)rAr)r3r4r5rlrrrr8r9r:rrsvCJ#####FFFFFFFFFFr9rc2eZdZUdZded<ded<ded<dS) _PyTreeInfoz= Contains extra info stored when we're using Pytrees list[str] orig_argszpytree.TreeSpecin_speczpytree.TreeSpec | Noneout_specNr2r8r9r:rr4sB$$$$$$r9r)frozencDeZdZUdZded<ded<ded<ded<d dZd S) _ParsedStackTracez? Represents the top-most frame of a parsed stack trace r.filelinenor@coderAcFd|jd|jd|jd|jS)NzFile: :z in z, code: )rrr@rrjs r:get_summary_strz!_ParsedStackTrace.get_summary_strIs0S SSDKSSTYSS SSSr9NrAr.)r3r4r5r6r7rr8r9r:rr>s`IIIKKK III IIITTTTTTr9r stack_trace filter_fn&Callable[[str, str, str], bool] | None_ParsedStackTrace | Nonec.|dStjd}|d}t t |dz ddD]}||}||}|r|d}|d}|d} ||dz} |r||| | st||| | cSdS)Nz$^File \"(.+)\", line (\d+), in (.+)$ rrr) recompilestriprrangelenrtryr) rrpatternlinesidxlinematchesrrr@rs r:_parse_stack_tracerNs%tj@AAG      % %d + +ESZZ!^R,, ? ?Sz!!--%%  ?==##D]]1%%F==##Dq>''))D 4t!> > > > ? 4r9FceZdZUdZded<d?dZd@d ZdAd ZdBdZ dCdDdZ dEdZ dFdZ d d!dGd&Z ddd'dHd*Z dId+ZdJd-ZdKd/Zd d d d d d dd0dLd>ZdS)Mr"c t|SrDreprrTs r:zCodeGen.js $q''r9&Callable[[torch.types.PySymType], str] _sym_reprrArBc"d|_d|_dS)Nforward)_body_transformer _func_namerjs r:rlzCodeGen.__init__ls;?(r9argsrr.cFdfd|DS)zAHelper to format function arguments in expanded multiline format.c3BK|]}|VdSrD)_format_single_arg)r<argrks r: z1CodeGen._format_multiline_args..rs1DDt..s33DDDDDDr9joinrkrs` r:_format_multiline_argszCodeGen._format_multiline_argsps*wwDDDDtDDDDDDr9rcd|vrF|dd\}}d|d|dSd|dS)z9Helper to format a single argument with optional comment.#r z, # rz, )rrstriplstrip)rkrarg_part comment_parts r:rzCodeGen._format_single_argts` #::%(YYsA%6%6 "HlK(//++KK,2E2E2G2GKKK K"#??? "r9 containerSequence[object]tuple[str, str]c4t|trdndS)z.sV!D'3wwt}}22w222r9)r_get_desc_trailersrrzip)rkrrr r ldelimrdelim desc_trailerss ` r:_format_multiline_containerz#CodeGen._format_multiline_containers--e44//u== ?G !v ! ! !gg%( %>%>  k   r9cD|dgt|zSd|DS)z2Helper to generate description trailers for items.Nrcg|]}d|S) # r8)r<descs r: z.CodeGen._get_desc_trailers..s000$ t 000r9)r)rkrrs r:rzCodeGen._get_desc_trailerss0 =4#e**$ $00%0000r9methodCallable[..., Any]r kwargsc|tj|fd|D}||i|S)zDHelper to call a method with optional parameters based on signature.c.i|]\}}|jv||Sr8) parameters)r<r=vsigs r:r>z=CodeGen._call_method_with_signature_check..s+RRRDAqa3>>Q>Q1a>Q>Q>Qr9)inspect signaturer)rkrrrfiltered_kwargsr$s @r:!_call_method_with_signature_checkz)CodeGen._call_method_with_signature_checksK''RRRRFLLNNRRRvt////r9F expanded_def free_varsmaybe_return_annotationr*rOct|dks |ddkr|dd|r&||}d|jd|d|dSd|jdd|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):'` rrkdef z( rrr, )rinsertrrr)rkr+r,r*args_formatteds r: gen_fn_defzCodeGen.gen_fn_defs y>>Q  )A,&"8"8   Q ' ' '  ^!88CCNVtVV>VV#$%fd #d?#fd "i.i3d@.3fd }t|D]}|jD]}|||dA&'3fd! }d/dB &'/fd# }dCd&1dB"#$%&()*,-0125fd' }| r& d(t|D]\}}r ||& d)|d*| o|j d+v}|r)& d,|j d-|d.|j d/|||||r& d,|j d0| r& d1t&d2kr& d3t5d2kr=$d4tjj4d*4fd55D}nd}jr&&D]\} }$| |j*-d26}i}|d*d7z}g}d}d&d*D]k}t0|}|#t5|d7}A||t||z<| |ld*|d*}d*d8|d*D}d*|d9|d*|} |d*d:z}!t;| +||!;S)DNrFX_GRAPH_SHOW_STRIDE01FX_GRAPH_SHOW_DEVICEFX_GRAPH_SHOW_META name_hintr.r1r rAct|r|tjkrt|S||}|vr!||krt d|d|S||<|S)a Add an obj to be tracked as a global. We call this for names that reference objects external to the Graph, like functions or types. Returns: the global name that should be used to reference 'obj' in generated source. z Global name z% already assigned to different object)rbrJrKrrrx)rRr1 global_nameglobals_rJs r: add_globalz,CodeGen._gen_python_code..add_global ss## 0(+u|(;(; +3///$// 3??Kh&&K(C//(Y{YYY#"$'H[ ! r9or0cn|dkrdSt|}t|tjr9d|vr5fdt j|D}d|St|ddx}rt|tjrt ||}t||}t|tr|j }nt j|}|r)fd|D}|dd|d S|S||S) Nr8z()|c&g|] }|Sr8r8r<r type_reprs r:rz?CodeGen._gen_python_code..type_repr..3s!EEE3 #EEEr9 __origin__c&g|] }|Sr8r8r[s r:rz?CodeGen._gen_python_code..type_repr..Ds!@@@sIIcNN@@@r9rrr) rrtypes UnionTypetypingget_argsrr\ _GenericAlias_origin_type_maprzr dims)rWtypenamer origin_typeorigin_typename type_argsrVr\s r:r\z+CodeGen._gen_python_code..type_repr+sPBwwt!!}}H!U_-- &#//EEEE&/!2D2DEEExx~~%%at<<<{ +a!566Q"2"6"6{K"P"PK",*Z -D-Dk"R"Ra,,3 !II & 2 2I+@@@@i@@@D-AAAAAA**:h** *r9red dim_greendimdim_bluebluerct|trt|St|tret |drUt t |} |t |}|tt|St|tjj tjj frt |} ||}|St|tj r$|j } |j|}|d|jSt|tjrWt#|}t'|jdd}d|d|dSt|trOt-|dkrd |d d Sdd  fd |DzdzSt|t"r'd d  fd|DzdzSt|t0r6d |jd  |jd  |jdSt9t |r:t;|\}}|D]\} }  | | |S t|S)N_fieldsrrztorch.Tensor(size=z, dtype=rrrrz,)r/c3.K|]}|VdSrDr8r<a _get_reprs r:rz>CodeGen._gen_python_code.._get_repr..ss+*E*EA99Q<<*E*E*E*E*E*Er9rc3.K|]}|VdSrDr8rrs r:rz>CodeGen._gen_python_code.._get_repr..us+&A&Ayy||&A&A&A&A&A&Ar9rzslice()rrrrhasattrrrrJ_ops OpOverloadHigherOrderOperatorenumEnum __class__r3r@Tensorr7sizer.dtyperrrslicestartstopsteprrr)rqualified_namerTclsclsnamer~robj_repr opaque_typesntrtrVrns r:rtz+CodeGen._gen_python_code.._get_reprYs#t$$$ 'Cyy C''" 'GC,C,C" '!4T#YY!?!?(jcCC %9tE#JJ'7'7999ej+UZ-KL '"5S!9!9(j== %''C++ 'm$*S\377!..CH...C.. 'CHHJJ''CI,,S11"5BDBB%BBBBC'' 's88q==4yyQ004444*E*E*E*E*E*E*E!E!EEKKC&& 'TYY&A&A&A&AS&A&A&AAAACGGC'' 'e #) 4 4ee #(8K8KeeyyY\YaObObeeee%d3ii00 ')._format_args..s!...A99Q<<...r9c6g|]\}}|d|S) = r8)r<r=r#rts r:rzBCodeGen._gen_python_code.._format_args..s3KKKDAq1//1//KKKr9r/)extendrr)rrresrts r: _format_argsz.CodeGen._gen_python_code.._format_argss]/......C JJKKKKFLLNNKKK L L L99S>> !r9rruserrBcp|vr0||<|g|dSdSrD)rappend)rrnode_to_last_useuser_to_last_usess r:register_last_usesz4CodeGen._gen_python_code..register_last_usessL(((&* #!,,T266==a@@@@@)(r9c|jdkrdS|jdkrddS|g}t|jdkr||t|rGdd|Ddgz}d |ddSddS) 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+rrrc,g|]}t|Sr8rr<rs r:rzJCodeGen._gen_python_code..delete_unused_values..s666T!WW666r9rB; )oprrzruserskeysr)rnodes_to_delete to_delete_strbodyrlrs r:delete_unused_valuesz6CodeGen._gen_python_code..delete_unused_valuess w-''w("" D!!!/33D"==O4:??$$%%** &&t,,,?## " % 66o666&A!!  8##m"4"488899999 D!!!!!r9nodec |jdvrd}rPg}D]0}||jvr%||d|j|1|rdd|d}d}|jdi}i}|rW|D]=\}}t |}t|dkr|d dd z||<8|||<>d |}d } |jx} r%t| x} r| } d} t|d r|jr|jdd } |jdd }| *|(dt |dt | j } n.| dt | j } n|dt |} d|d|| d| d}|kr||d Sd Sd S)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) rrrrrzrr.rrrrrvr@)radditional_meta_strpartskeyannotation_str annotationannotation_truncr value_strstack_trace_strrparsed_stack_tracemaybe_recompute_inforr summary_strrGrrlprev_summary_strs r:append_stacktrace_summaryz;CodeGen._gen_python_code..append_stacktrace_summarysw777&(#"G')E.EE$)++!LLC)C)C49S>)C)CDDDG.F499U3C3C.F.F.F+!#!Y]]8R88 #% H&0&6&6&8&8:: U$'JJ y>>B..4=crcNU4J,S1149,S11%G5E%G%GN"K"&"22;O-? -L-LL)O*<*L*L*N*N')$4((STYS!% k4 @ @I"&)-- t"D"DK ,1HWS-=-=WW#inBUBUWW-,#./Sc).>Q>Q/S/S,,$0/RK@P@P/R/R,}33*='x'x'xPd'x'xgv'x'x#y#y}}} "222'2$KK ,,,,,a87\32r9shapeIterable[object]cHddd|DdS)Nrr/c,g|]}t|Sr8r.r<rNs r:rzECodeGen._gen_python_code..stringify_shape..s!8!8!8Q#a&&!8!8!8r9rr)rs r:stringify_shapez1CodeGen._gen_python_code..stringify_shapes..emit_node.._tensor_annotation sCodeGen._gen_python_code..emit_node..rs-GhGhYZ RS GhGhGhGhGhGhr9c3.K|]}|VdSrDr8rrs r:rz>CodeGen._gen_python_code..emit_node..}s-IjIj[\))TU,,IjIjIjIjIjIjr9rr\rr 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 -> r3znode: r)rrrAr.)9rtorch.distributed.tensor._apirrformat_shard_order_strModuleNotFoundError"torch.fx.experimental.proxy_tensorrtorch.fx.passes.shape_proprrrzrrJr}layout sparse_csc sparse_csr _subclasses FakeTensorrx_spec placements shard_orderr|r3r"rrrrrrvrrpprintpformatr.rrreplacerrrcallabler\ magic_methodsrformatinplace_methodsrrrrr(r8NotImplementedError)*rmaybe_type_annotation maybe_commentrr"dtensorspec_format_shard_order_strrrmeta_valris_plaincore dtensor_metarval_strrr=r#maybe_default_argraw_namerrTrrtrVrnrrmrkr*r+rD include_metarCr,rjrIrkrr\rB wrapped_fnss* r: emit_nodez+CodeGen._gen_python_code..emit_nodes3 i'-I99TY3G3G-I-I "M? r>RRRRRRRR$:76+>>>"G9=666>LKKKKKEEEEEE9==IMM-PT1U1UVV h 55!r(/$$R;; $H~~=  %"3">BBH.-h77DE0=d --h722=E"0 X##(J'I$N5$N6(( '09K#KKKK ,0G0GKKK.-'090Dc0D0DD0D0D0D--,77r%//99G,Ag,A,A,A)).99r,q+hn2M,q_g_mOnOn,q,q,q)D 3y}}VT22#=(@(@!]D]]2M %f 5 5 %$) % G$$$ IOO--DAqKKRRs1vvR N N NRRR G$$$w-''!$+s33(RtDK?P?PRR#iLBB-L99TYq\3J3J-L-L"  {]$9];L]m]] ;..sB77tDzz))KK4:: > >( > > >???M))!$+s33(btTXT_O`O`bb DzzD#8DD^IIVZV_`aVbLcLceiep=q=qDD$ TYqrr]DK@@DDDO++ ,,(WDDUDUWW DKr::kII , ==%di77,T4 ??TTKK::l'<ll()=>EGhGhGhGh^b^gGhGhGhillF DKr::kII ,??KK*4;+?@GIjIjIjIj`d`iIjIjIjk[[::['<[[AJ49UV.s*#U#U#Uy$<$.s&DD4$DDDDDDr9z )rr)rRr.r1r rAr.)rWr0rAr.)rr0rAr.)rrrrrAr.)rrrrrArB)rrrArBrrrArB)rrrAr.)osenvironrzr?r _color_fns _identityreversed _input_nodesr enumeraterr@rrJfxrrrr@r(r2countr_counter_regexpsearchr{ryrr!)6rkrHrIrJrBrCrDrEr*rFrGr@rpr1rr input_noderrri do_record wrap_stmtsrprologue lineno_map prologue_len new_linescur_idxrcounterrfn_codeprologue_startrrtrVrnrrlrmrkr+rUrr,rrrjrr\rrrs6` ````` ` ` @@@@@@@@@@@@@@@@@@@@r:_gen_python_codezCodeGen._gen_python_codes " #%') /1T' JNN13 7 73 > ( JNN13 7 73 > z~~&:C@@CG        :/4466 " "ND(1c JtS ! ! ! ! + + + + + + +B  U#C";/IU#C!*-Hf%DDC!IC HD% '% '% '% '% '% '% '% 'N " " " " " ".046 A A A A A A A UOO 5 5D"/ 5 5 "":t4444 5 " " " " " " " "6 7 -7 -7 -7 -7 -7 -7 -7 -7 -r = = = =F HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HF HP   KKv   !'' M MGAt 0))$/// KK+a+++ , , ,#4)I   {49{{TU{{bfbk{{{ IdOOO  & & & M K49KKKLLL  < KK: ; ; ; t99>> KK ! ! ! {  a  " 658=99I#U#U#U#U#U#U#UVVJJJ  ! 0))$//D2244 $ $KD% JtU # # # #99 O  #A &% :  -/ ~~d++a/ ! GGDMM''-- ' 'D%,,T22G"gmmA..//>L89  &&&&yy##**400yyDD4::d3C3CDDDDD           $))$//!3  "*     r9r)rrrAr.)rr.rAr.)rrrAr)NrN) rrrr r r.r r rAr.)rrrr rAr)rrrr rr rAr r+rr,r.r*rOrAr.r4rrr r r rAr.rr rAr )r;r rAr )rAr>)rHrrIr.rJrdrBrOrCrOrDrOrErOr*rOrFrOrGrKrAr!)r3r4r5rr7rlrrrrrr(r2r8r:r=r@rr8r9r:r"r"gs9J8IIIIII))))EEEE####JJJJ'+26      ,11110000# ^^^^^^8'+26 444444(    $$"!,0^ ^ ^ ^ ^ ^ ^ ^ r9r"c eZdZdZddd d Zd S) _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. Fr)r+rr,r.r*rOrAcrd|jd|d}|r&d|D}|r|dz }|D] }|d|dz } |dz }|S) 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. r.z(self, args_list)rcg|]N}|dk|ddddOS)rkrr=)rr)r<r#s r:rz,_BoxedCodeGen.gen_fn_def..1sR   :;AQWKK Q%%c**1-3355KKKr9z args_iter = iter(args_list) z = next(args_iter)z args_list.clear())r)rkr+r,r*fn_defplaceholder_varsvars r:r2z_BoxedCodeGen.gen_fn_defsUTT:QTTT  4  ?H      4==+??C>s>>>>FF33 r9Nr)r3r4r5r6r2r8r9r:rrsA# r9rcfeZdZd fd Zd!dZd"d Zd#dZd$dZddd%fdZdddd&fdZ xZ S)'_PyTreeCodeGen pytree_inforrArBcVt||_dSrD)superrlr&)rkr&r|s r:rlz_PyTreeCodeGen.__init__?s' (3r9inputsr c"tj|}|SrD)rMarg_tree_leaves)rkr) flat_argss r:r:z_PyTreeCodeGen.process_inputsCs*F3 r9outc|j |jj|St|ttfs|g}|jjt dt j||jjS)Nzpytree_info.out_spec is None)r&rrr7rrxrMtree_unflattenrkr-s r:r=z_PyTreeCodeGen.process_outputsGsl   #t'7'@'HJ#e}-- %C   $ , !?@@ @$S$*:*CDDDr9r+rr*rOr.c|sdSd|D}|sdS|rdd|zSddd|DzdzS)z=Helper to format annotations for variables in pytree codegen.rcg|]}d|v| S)rr8rs r:rz6_PyTreeCodeGen._format_annotations..Us;;;#((!(((r9r c3 K|] }|dzV dS)z; Nr8rs r:rz5_PyTreeCodeGen._format_annotations..\s&%G%G1a$h%G%G%G%G%G%Gr9rr)rkr+r*has_annotations r:_format_annotationsz"_PyTreeCodeGen._format_annotationsPsz 2;;Y;;; 2  OhmmN;;; ;bgg%G%G%G%G%GGGG$N Nr9fn_argsc |jj}|jtuoL|jdkoA|djtuo |djt u}d}dd|d}|r|dj}|jjd|}ddd t|dj |jj|dDzd z}d d|d |d }d|D} | ||} | dd| d|dz } | S)Nrrrrz{}rr/z], self._in_spec{c3,K|]\}}d|d|VdS)'z':Nr8r<r=r#s r:rz2_PyTreeCodeGen.gen_var_bindings..psF1!LLQLLr9}z([z], z), self._in_speccvg|]6}|dddd7Srrrrrs r:rz3_PyTreeCodeGen.gen_var_bindings..9OOOaggcll1o33C88;OOOr9r z , = fx_pytree.tree_flatten_spec(r) r&rrr num_childrenchilddictrrrcontextr5) rkr6r+r*rhas_args_kwargs_tuple fn_kwargs fn_signature count_argswithout_annotationbindingss r:gen_var_bindingsz_PyTreeCodeGen.gen_var_bindings^s"* LE ! .$) . a  %. . a  %-   ?499W--???  S q))6J&0*=G)) # a((0(2:;;?!! S ' 2 2RRyRRRL POYOOO++I|DDV YY!""VVDPVVV Vr9Fr)r,c|j$t|||S|jj}t |dkr |ddknd}|r|ddt|dd||}t |dkr|||||z }|S)Nr)rrkF)r&r(r2rrr0rK)rkr+r,r*r6 has_orig_self fn_definitionr|s r:r2z_PyTreeCodeGen.gen_fn_defs,   #77%%2& ",25g,,2B2Bv--  (   Q ' ' '** AAAJ/l+   y>>A   T227I|TT TMr9Nr3r4rrr r r c|t}|jrU|jjrI|8t|tt fr|||d|dzSd||dSt|||S)Nreturn pytree.tree_unflatten(r6, self._out_spec)r3) rr&rrr7rrr(r8)rkr4rr r|s r:r8z_PyTreeCodeGen.generate_outputs ?G   V 0 9 V Z dE]%K%K 44#7 ' 5 * *_ww{7K7K^^^^77**;eW*UU Ur9)r&rrArBr)r rAr r-r rAr )r+rr*rOrAr.r6rr+rr*rOrAr.rr) r3r4r5rlr:r=r5rKr2r8 __classcell__r|s@r:r%r%>s444444EEEE O O O O%%%%X# %%%%%%%%V'+26 VVVVVVVVVVVVr9r%cTeZdZdfd Zdfd Zd fd Zd!fd Zd"dZd#dZxZ S)$_ExportCodeGenr&rin_shuffle_graphr%out_shuffle_graphtree_leaf_namesrroottorch.nn.Module | NonerArBct|||_||_||_||_dSrD)r(rlrYrZr[r\)rkr&rYrZr[r\r|s r:rlz_ExportCodeGen.__init__s@ %%% 0!2. r9r)r cvtj|}|j |jg|R}||_|j|SrD)r(r:r\r,rY)rkr)r,r|s r:r:z_ExportCodeGen.process_inputssG*EGG*F3 9 /Y//I"$t$i00r9r-cv|jg|j|R}|`t|}|SrD)rZr,r(r=)rkr- flat_outsretr|s r:r=z_ExportCodeGen.process_outputssC*D*ADNASAAA Ngg%%i00 r9rrr.c:tj|i|}|SrD)r(r2)rkrrr!r|s r:r2z_ExportCodeGen.gen_fn_defs###T4V44 r9r6r+r*rOc d|D}d|}|jd|}dd|jd|dd|dd|jd S) Ncvg|]6}|dddd7Sr>r?rs r:rz3_ExportCodeGen.gen_var_bindings..r@r9r/zself, r z, = pytree.tree_leaves((z,)) z, = self._in_shuffle_graph(r)rr\r[)rkr6r+r*rIrGs r:rKz_ExportCodeGen.gen_var_bindingssPOYOOO#yy113 9 2L22Ld YYt#$$dd>Jdd YY!""dd?CyyI]?^?^ddd dr9r4rct|ttfstdt |dd|jddd|Dd}d|dS)Nz,Expected list or tuple for output_args, got zself._out_shuffle_graph(r/c,g|]}t|Sr8rr<rss r:rz2_ExportCodeGen.generate_output..s#YvYvYvefZ]^_Z`Z`YvYvYvr9rrPrQ)rr7r TypeErrorrrr[)rkr4rrr+s r:r8z_ExportCodeGen.generate_outputs+e}55 RtK?P?PRR {DIId6J,K,KzztyyYvYvjuYvYvYvOwOwzzzHvHHHHr9) r&rrYr%rZr%r[rr\r]rArBrRrS)rr rr rAr.rT)r4rrr rr rAr.) r3r4r5rlr:r=r2rKr8rUrVs@r:rXrXs      111111  d d d dIIIIIIIIr9rXcHeZdZdZddZddZdd Zdd Zdd Zd dddZ d S)_FindNodesLookupTablezH Side table for the graph for the purpose of doing fast queries rArBc8tt|_dSrD)rrCtablerjs r:rlz_FindNodesLookupTable.__init__sHS I I  r9rrtuple[str, Target | None]c8|j|jdkr|jndfS)Nr&rrrkrs r:_keyz_FindNodesLookupTable._keys!?(B(BMMr9rOcF||j||vSrDrmrrrqs r: __contains__z"_FindNodesLookupTable.__contains__stz$))D//222r9cLd|j|||<dSrDrtrqs r:r0z_FindNodesLookupTable.insert s#,0 499T??#D)))r9cl|j|||dSrD)rmrrpoprqs r:removez_FindNodesLookupTable.remove s- 499T??#''-----r9Nrrr.r Target | None list[Any]c|dkr4tdg|j|fS#g|j|dfSfd|j|dfDS)Nr&z,target must not be None for call_function opc*g|]}|jk |Sr8rz)r<rrs r:rz4_FindNodesLookupTable.find_nodes..s%QQQ4;&;P;P;P;P;Pr9)rxrmr)rkrrs `r: find_nodesz _FindNodesLookupTable.find_nodess  ~$%STTT5TZV -22445 5 >3TZT +00223 3RQQQRJ!7QQQQr9r)rrrArnrrrArOr)rr.rr{rAr|) r3r4r5r6rlrrrur0ryrr8r9r:rkrks    NNNN33331111....>B R R R R R R R Rr9rkc ,eZdZdZed ddd ZeddZejddZeddZ edddZ eddddddZ ed ddd$Z ddd'Z ed ddd1Zeddd3Zeddd5Zeddd7Zedddd;Zedddd<Zeddejjfdd>Zedddd@Zed dddBZed dddDZed dddGZeddJZedddMZedddNZedddOZ edddUZ!edddYZ"eddd]Z#edd^fddbZ$ed dddeZ%ddfZ&edddddddddgddrZ'ddddddddgdduZ(ddvZ)edddwZ*edddxZ+ed ddd{Z,eddd~Z-edddZ.ddZ/dS)r#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`. TrN owning_moduleGraphModule | None tracer_clstype[Tracer] | None tracer_extrasdict[str, Any] | NonerArBc t|ddddi|_i|_|jj|_d|_t |_||_||_ ||_ t|_ i|_ t|_dS)z+ Construct an empty Graph. rr\r8rN)rrrhprependrrrd_graph_namespace_owning_module _tracer_cls_tracer_extrasr"_codegen _co_fieldsrk_find_nodes_lookup_table)rkrrrs r:rlzGraph.__init__Os b&"b"== +-z)  * +%+  *,(=(?(?%%%r9c|jSrDrrjs r:rzGraph.owning_modulees ""r9modc||_dSrDr)rkrs r:rzGraph.owning_moduleis!r9rc t|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. )rrjs r:rHz Graph.nodesms$r9Frcttt|j}|jdkrt d|j|S)Nr+zExpected output node, got op=)nextiterrrHrrx)rk output_nodes r:rzGraph.output_node|sM4 4 45566 >X % % !Q!Q!QRR Rr9)rsortrr.rr{rrOr|c`|j||}|rt|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. rp)rrsorted)rkrrr node_lists r:rzGraph.find_nodess;,1<<6<RR  %)$$ $r9gval_mapdict[Node, Node]return_output_nodeArgument | Nonec|jD]V}|vr|jdkr(t|jdfd}|s|n||fcS||fd|<WdS)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|SrDr8rrs r:rz"Graph.graph_copy..s WQZr9c|SrDr8rs r:rz"Graph.graph_copy..s 71:r9N)rHrmap_argr node_copy)rkrrrrrvs ` r: graph_copyzGraph.graph_copys(G G GDww(""TYq\+?+?+?+?@@!3Crr"dCCC NN41E1E1E1EFFGDMMtr9memodict[int, Any] | Nonec|r|ni}t|j}|||d}tj|j|_|}t |tstdt||\}}| |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. )rT)rrNz&Expected output_vals to be tuple, got r type_expr) r#rrcopydeepcopyrrrrxrr+r\r)rkrr output_vals output_valold_output_nodenew_output_nodes r: __deepcopy__zGraph.__deepcopy__s#tt T- . . .ll ##  ]4=11  "k511 $PT+=N=NPP+6 'Jhh!/64@@'O $(9_-A#B#BO r9rrtuple[Argument, ...] | Nonerdict[str, Argument] | Noner@ str | Noner Any | Nonec |sd}n4t|tstdt||st }n4t|t stdt||dvr|s|rt j||fD]j}t|tj tj tj fr7tj dt|jd|d|d|d d nk||n||}|j|d }t%|||||||} |j0t)|jd d |jjD] } | | |j|| || |j| |xjdz c_| S)a& Create a ``Node`` and add it to the ``Graph`` at the current insert-point. Note that the current insert-point can be set via :meth:`Graph.inserting_before` and :meth:`Graph.inserting_after`. Args: op (str): the opcode for this Node. One of 'call_function', 'call_method', 'get_attr', 'call_module', 'placeholder', or 'output'. The semantics of these opcodes are described in the ``Graph`` docstring. args (Optional[Tuple[Argument, ...]]): is a tuple of arguments to this node. kwargs (Optional[Dict[str, Argument]]): the kwargs of this Node name (Optional[str]): an optional string name for the ``Node``. This will influence the name of the value assigned to in the Python generated code. 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 node. r8zargs must be a tuple, got zkwargs must be a dict, got rzRaw z value (z.) passed as argument to Graph.create_node(op='z ', target=zu). Use create_*_node() helpers for tensor metadata queries or materialize_symints() for general symbolic expressions.rr stacklevelN_create_node_hooksr)rrrxrrrCrM tree_iterrJSymIntSymFloatSymBoolwarningswarnr3_target_to_strrrrrr\rrrrr0r) rkrrrrr@rrrmrfs r: create_nodezGraph.create_nodes@H PDDdE** P$%N$t**%N%NOOO S#%%FFfd++ S$%Q4<<%Q%QRRR @ @ @d @f @'v77  cEL%.%-#PQQMVtCyy1VV3VV13VV?EVVV$% E!,DD$2E2Ef2M2M $00DAA tRvy A A   **,@$GGS':  ! 55dA>>> Q %,,Q/// Q r9r c |jj|S)zL Processes args so that they can be passed to the FX graph. )rr:rs r:r:zGraph.process_inputs)s ,t}+T22r9r-c6|j|SrD)rr=r0s r:r=zGraph.process_outputs0s},,S111r9to_erasec t|jdkr0td|dt|jd|jd|j|krtd|d|jrt jd|d d S|j0t|jd d |jj D] }|||j || d |_|xj d zc_ |t|jdt|jdd S)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_hooksTrcdSrDr8rs r:rz"Graph.erase_node..Ysdr9cdSrDr8rs r:rz"Graph.erase_node..Zsr9)rr RuntimeErrorr_erasedrrrr\rrry_remove_from_listr_update_args_kwargsr_args_kwargs)rkrrs r: erase_nodezGraph.erase_node4s x~   " "9x993x~CVCV99'/~999  >T ! !SxSSSTT T    MMMMM N N N F   **,?FFR'9  (  %,,X666""$$$ Q  $$ HNNN 3 3 H$nn 5 5     r9r Node | Nonerc|||jS|j|krtdt ||jS)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__``. Nz&Node to insert before is not in graph.)inserting_afterrrrxrrrkrs r:inserting_beforezGraph.inserting_before]sK& 9'' 33 3 7d?? !IJJ JD!),,,r9c|||jS|j|krtdt ||jS)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__``. Nz%Node to insert after is not in graph.)rrrrxrrrs r:rzGraph.inserting_aftervsK& 9((44 4 7d?? !HII ID!(+++r9 default_valuecd|tjjurdn|f}|d|||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)rkr@rrrs r:r*zGraph.placeholders=<#g&7&===rrMCS t$)TTTr9rcdd}|j'||j|stjd d |d || 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``. rtorch.nn.Modulerr.rArOc|d\}}} ||}n)#t$rtjd|dYdSwxYwt ||sdSt ||}t|tj j s*t|tj j s ||j vrdSdS)NrzFailed to fetch module rFT) rpartition get_submoduleAttributeErrorrrrvr\rrJr^Module Parameter_buffers)rr module_pathrpr@submodrs r:_get_attr_reference_existsz2Graph.get_attr.._get_attr_reference_existss$2#<#._node_val$s3&**U##C 6::o.. .r9rrBcn||jd<td|jDr ||jd<dSdS)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.rc3RK|]"}t|tod|jvV#dS)rN)rrrrhs r:rzCGraph.materialize_symints.._set_node_val../s8UU:a&&D?af+DUUUUUUr9rN)ranyrr"s r: _set_node_valz0Graph.materialize_symints.._set_node_val*sL AF5MUUafUUUUU .*-''' . .r9expr sympy.Exprrrlr{c t|jr|||dfdSt|jrt |jdkr|j\}}t|jrt|jr||}}t|jrTt|jrAt|dkr0|||t|fdSdSdSdSdSdS)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). rNrrr)rSymbolrMulrrIntegerr{)r(rrlrsbsym_size_sourcessympys r:_record_shape_sourcez7Graph.materialize_symints.._record_shape_sourceFs1$ --  ++D4a.AAA$ ** Hs49~~/B/By1a.. :a3O3O aqAq%,//H"1em44HA $//D#s1vv3FGGGGG H H/B/BHHHH# r9r*tracerunbacked_bindings) BooleanAtom)rfree_unbacked_symbolsrsc\t|tjjr |S|SrD)rrJrr)rsr#s r: _arg_meta_valz0Graph.materialize_symints.._arg_meta_valts,!UX]++ $ y||#Hr9cx | vr |St|jjjfr  |S  fd|jD|}t|t jjs|S| |<|j}|j }t|s|S t fd|jD} fd|j D} |||i|n@#ttt f$r&}t"d||Yd}~nd}~wwxYw|S)Nc&g|] }|Sr8r8)r<r_sympy_interp_cacheds r:rzKGraph.materialize_symints.._sympy_interp_cached..s%@@@s%%c**@@@r9c3.K|]}|VdSrDr8)r<rsr8s r:rzJGraph.materialize_symints.._sympy_interp_cached..s-!F!Fq--"2"2!F!F!F!F!F!Fr9c.i|]\}}||Sr8r8)r<r=r#r8s r:r>zKGraph.materialize_symints.._sympy_interp_cached..s)SSStq!q--"2"2SSSr9z8materialize_symints: skipping meta annotation for %s: %s)rr-Numberr+rrJrProxyrrrrrrri ValueErrorrlogdebug)r(resultrr fake_args fake_kwargsrr5r r8rr'r; expr_to_proxyr0rs r:r;z7Graph.materialize_symints.._sympy_interp_cachedys}$$$T**u}elEL+N R$|$;]DQQQ'''@@@@di@@@F fehn55  "(M$ ;D[FF##   !!F!F!F!FDI!F!F!FFF SSSSt{?P?P?R?RSSS  dFFI$E$E$EFFFFz>:    N  Ms"AC::D7D22D7d torch.SymInt Node | intc~|jj}t|tjjr|jn|SrD)rr(rrJrr?)rGrr;s r:_lower_symint_divisorz8Graph.materialize_symints.._lower_symint_divisors6$$QV[11A'58>::A166 Ar9sym sympy.Symbolc |vrdS|vr|\}}}tjjjj||f}|}t |tjr||j||dkrvj ||f}t |tjr||j||ztj ||<n$tj ||<dS|vr|std|d|\}}|D]U} t | rCt | j tjr$| j jjjD] }  | V||} tj | |<dStd|)Nrr2z#materialize_symints: backed symbol zV has no input producer (backed symbols cannot be recovered from non-placeholder nodes))r z%materialize_symints: no producer for )r&rJrrrr{rr}rrrr?rxrrrr( free_symbolsr)rLphrlrsym_nodetensordiv_node producer_noderr=s2rr_ensure_producedrKr#r'rFr6rrkr/sym_to_bindingr3s r:rVz3Graph.materialize_symints.._ensure_producedsNm##&&C#8 C--ein.E.IBPS9UU"2fel33?!M(FL,=>>>a<< $11 )Hg+>  H"&%,77N% h S0AW0LMMM).)P)PM#&&).)P)PM#&n$$,,S11(7c777 *8)<& w 11A!![111j 5<771#$)."5"B11B,,R000099!79N:&+X^^HV^%L%L c" !N!N!NOO Or9z1materialize_symints: expected SymInt or int, got z (rz&materialize_symints: non-Proxy result z for non-constant target )rrrAr )rrrr rArB)r(r)rrrlr{rArB)rsr rAr )r(r)rAr )rGrHrArI)rLrMrArB)*rr0torch.utils._sympy.interprrtorch.utils._sympy.referencer rJrproxyGraphAppendingTracerrHrrrrr(r+r?r}rrrrrzrrrsympy.logic.boolalgr5rrr6r{rrirr3 is_numberrOrOrx)!rkrr1rrr(rlrVrJrLrr- target_exprrCout_noder5rr r8rVrKr#rr'r;rFr6rr/rWr0rr3s!` @@@@@@@@@@@@@@@@@@r:materialize_symintszGraph.materialize_symintss\  NNNNNNNNHHHHHH / / / /  . . . .44T:::< GINP H H H H H H H,J O ODw-''iooc<00I8=D!$ 55R$m:S:S.3hnnT&n.Q.Q d+U\22I"+CI"6"6IIQ%a66I00dCHHH9==)<==O(0(8(8OO W&11#eGnn7MNNNN333333                            D B B B B B B) P) P) P) P) P) P) P) P) P) P) P) P) P) P) P) P) PV!# ! !A!U\** As##  1 2Aww'22+,222&+K$  3q66""""/ & &  %%%%))+66Ffehn55 "&3+66(???/:?? 3v;;'''{H M(A & & & JJx  r9rtorch.SymInt | intrIc:||gdS)zDSingle-value convenience wrapper around :meth:`materialize_symints`.r)r`)rkrs r:materialize_symintzGraph.materialize_symints''0033r9c|SrDr8rTs r:rzGraph.sPQr9r arg_transformCallable[[Node], Argument]ct|j|}t|j|}t|tst dt |t|tst dt |||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 )rrrrrrxrrCrrrr@rr)rkrrerr result_nodes r:rzGraph.node_copys2ty-00m44$&& Q !O4::!O!OPP P&$'' T !RDLL!R!RSS S&& GT[$ 49   9TY// r9rCrc6|dd|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+)rrrrr)rkrCrs r:r+z Graph.output s,,yI    r9ct|r|j}nOt|tst dt ||}t |r |dd}t|}|S)NzExpected target to be str, got rr)rr3rr.rxrrUrZ)rkrrs r:rzGraph._target_to_str: s{ F   BBfc** W$%UtF||%U%UVVVB}} "X __ r9rArIrBrCrDrEr*rFrGrKr!c  t d fd td fd } | |5|| ||||||| cd d d S#1swxYwYd S)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. rrrAr.c:|j|SrD)rr@)rrJs r: node_reprz$Graph.python_code..node_repr| s((33 3r9rr#Generator[None, None, None]c3Ki}|jD]}|j||<|_ dV|jD]}|||_dS#|jD]}|||_wxYwrD)rH_repr_fn)r orig_repr_fnsrrns r:override_node_reprz-Graph.python_code..override_node_repr sM  * *&*m d# )  8 "K88D$1$$7DMM88EK88D$1$$7DMM8s ?ArAN)rrrAr.)rr#rAro)rdr _python_code) rkrIrBrCrDrEr*rFrGrsrJrns @@r: python_codezGraph.python_codeF s^LL  4 4 4 4 4 4  8 8 8 8 8  8  % %  $$--)' /%                    sA  A$'A$rJrdc T|j|j|||||||||  S)NrA)rrrH) rkrIrJrBrCrDrEr*rFrGs r:rtzGraph._python_code sC}-- J  ))%#+.   r9cgdg}fd|jD}d}d|d|dd}|D] }|r|d|zz } |S) zl Return a human-readable (not machine-readable) string representation of this Graph rc:g|]}|Sr8) format_node)r<rplaceholder_namess r:rz!Graph.__str__.. s(PPPTT%%&788PPPr9r/zgraph(rrrr )rHr)rkmaybe_return_typename node_strs param_strrVnode_strrzs @r:__str__z Graph.__str__ s (*-/4PPPPTZPPP II/00 . s-UUUQqtQVQXqvqx@UUUr9)opcoder@rrr)headersN)r ImportErrorprintrH)rkr node_specss r: print_tabularzGraph.print_tabular s  ) ) ) ) ) ) )    <      VU$*UUU  HZ)W)W)W X X X     s $c   dd fd }t}t jD]}|jtvrt d |d |jd |jurt d |d |jvrt d |d|jD]}||| ||j |vrt d|j d ||j ʉj rjD]}|jdkrJt|j s5td |d|j dtj|j dnOt!|j t"s5td |d|j dtj|j d|jdvr|j d}j }t'|D]\}}t)||d} d|d|} | t d |d|j d|d| |jdkr@t!| tjjs!t d |d|j d|d| d | }dSdS)aJ Runs various checks on this Graph to make sure it is well-formed. In particular: - Checks Nodes have correct ownership (owned by this graph) - Checks Nodes appear in topological order - If this Graph has an owning GraphModule, checks that targets exist in that GraphModule NrrrrrArBc|rd|dnd}|jurtd|d|d|vrtd|d|ddS)Nz of Node 'z' rz Argument 'r:zdoes not belong to this Graph, but was used as an argument! If you are copying nodes from another graph, make sure to use ``arg_transform`` on node_copy() to remap values zdwas used before it has been defined! Please check that Nodes in the graph are topologically ordered )rr)rr context_str seen_valuesrks r: check_argzGraph.lint..check_arg s01:,q,,,,sKy$$"\\\{\\UY\\ +%%"ggg{gg`dgg&%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.ModulerD)rrrrrArB)rgrHr _legal_opsrrrrr|r@rrrr@rJrfrr.rrr\rr^r) rkr seen_namesrr target_atomsm_itrr atom new_m_itr seen_qualnamers ` @r:lintz Graph.lint s         #uu !$ J & &Dwj(("#O4#O#OTW#O#O#OPPPz%%"#RD#R#R#RSSS4888"#RD#R#R#RSSS( % % #t$$$$ OOD ! ! !yJ&&"#F$)#F#F#FGGG NN49 % % % %  " * ! *! *7o--#DK00(5D55$+55X\XcIdId555 &dk377(0D00$+00X\XcIdId0007999#';#4#4S#9#9L .E#,\#:#:**4$+E4$>$> (+bqb1A(B(B $,".!=!=!=dk!=!=#'!=!=-:!=!=## 7m33J%ux==3#/!=!=!=dk!=!=D!=!=m!=!=!=## !*E" *" *! *! *r9is_impure_nodeCallable[[Node], bool] | NonecT ddlm}|d tjjrtjjj d fd }t}t|j D]T}||sGt|jdkr/||||jUt|dk}|rt$d ||j|d |d D}|jD]X\}} ||vrOt/| tjjr0|| jz}| Y|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) OrderedSetTrrrArOcH |S|SrD) is_impure)r impure_randomrs r:has_side_effectz2Graph.eliminate_dead_code..has_side_effectb s+)%~d+++>>-00 0r9z1The following nodes were dead code eliminated: %sNc3$K|] }|jV dSrDrzrs r:rz,Graph.eliminate_dead_code..v s5((((((((r9r()rr)torch.utils._ordered_setrrrJ_guardsTracingContexttry_get _inductorconfigfallback_randomrgrrHrrrr|r@rAinforrnamed_childrenrrr%reliminate_dead_code recompile) rkrrr removed_nodesrchangedsubgraph_names child_name child_modulers ` @r:rzGraph.eliminate_dead_code+ sZ 877777  = ' / / 1 1 C!O2BM 1 1 1 1 1 1 1 TZ(( - -D"?4(( -S__-A-A%%%!!$),,,m$$q(  Y HHH- X X X   )'Z(("&//Z/"@"@(((N-1,>,M,M,O,O - -( L//J %("655/|1EEGGGG **,,,r9codegenr"c||_dSrD)r)rkrs r: set_codegenzGraph.set_codegen s  r9make_transformer7Callable[[TransformCodeFunc | None], TransformCodeFunc]'contextlib.AbstractContextManager[None]cjj|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()`). rAroc3PK dVj_dS#j_wxYwrD)rr)on_gen_code_oldrksr: on_generate_code_context_managerz@Graph.on_generate_code..on_generate_code_context_manager s< B2A //// /AAAAs%)rAro)rr contextlibr )rkrrrs` @r:on_generate_codezGraph.on_generate_code soR-9*:*:?*K*K '  " B B B B B B # " B 0/111r9ct|jD]0}|j||1dSrD)rrHrclearrrqs r: _clear_nodeszGraph._clear_nodes sLTZ(( " "D IOO    OOD ! ! ! ! " "r9)NNN)rrrrrrrArB)rAr)rrrArB)rAr)rAr)rr.rr{rrOrAr|)F)rr#rrrrOrArrD)rrrAr#)NNNN)rr.rrrrrrr@rrrrArrrS)rrrArB)rrrAr)r@r.rrrr rAr)rr.rrrAr) r`r.rrrrrrrAr) rr.rrrrrrrAr) rrrrrrrrr@rrAr)rrrAr)rrrlr{rAr)rrrAr)rrrrr r rAr)rrrAr)rrarArI)rrrerfrAr)rCrrr)rr{rAr.)rIr.rBrOrCrOrDrOrErOr*rOrFrOrGrKrAr!)rIr.rJrdrBrOrCrOrDrOrErOr*rOrFrOrGrKrAr!rr)rrrArO)rr"rArB)rrrAr)0r3r4r5r6rrlpropertyrsetterrHrrrrrr:r=rrrr%rrr*r(r)r'r& staticmethodrrrrrr`rcrr+rrurtrrrrrrrr8r9r:r#r#so--^]$///-1*./3 @@@@0/@*###X#""""    X  ]%00010 ]%00037T102]$///NS0/8>]$/// -1-1 $LLLL0/L\]%000333103 ]%000222102]$///& & & 0/& P]$///----0/-0]$///,,,,0/,0]$///!%$.4 UUUU0/U@]$///AQAQAQAQ0/AQF]$///-1-1 $ 2 2 2 2 0/2 h]$///-1-1 $ $ $ $ $ 0/$ L]$///-1-1 $ ' ' ' ' 0/' R\ ]%00010]%00010]%00010]%000<<<10<|]%000LLL10L\]%000444104]$///FQk""""0/"H]$///9=    0/ 0    ]$/// $$"!,0PPPPP0/Pn$$"!,0      4$]$///   0/ *]$///M*M*M*0/M*^]$///>BVVVV0/Vp]%000   10 ]%000R2R2R210R2h""""""r9r#overriderroc#~Ktj} |t_dV|t_dS#|t_wxYwrD)r"r)rtmps r:_override_sym_reprr sH  C $ Cs.<c|SrDr8rTs r:rr s Hr9rCallable[[str], str]cdfd }|S)NrVr.rAcd}||S)Nzr8)rVresetrs r:rz_make_color_fn..f s""5"""r9rVr.rAr.r8)rrs` r:_make_color_fnr s(###### Hr9zzzzzzz z )yellowcyangreenrnrjrlrmrkc4i|]\}}|t|Sr8)rr;s r:r>r> s& D D Dtq!a"" D D Dr9z# COUNTER: (\d+)z{} + {}z{} - {}z{} * {}z{} // {}z{} / {}z{} % {}z{} ** {}z{} << {}z{} >> {}z{} & {}z{} | {}z{} ^ {}z{}[{}]z{} @ {})r|rvmulrtruedivdivrpowlshiftrshiftand_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.r1r0rArB)rNr.rArOr)r1r0rArO)r}r.rr.rAr.rD)rr.rrrAr)rrrAro)rNr.rAr.)rr.rAr) __future__rbuiltinsrrrz functoolsr%keywordloggingmathrrrr_rar collectionsrcollections.abcrrrrr r dataclassesr r r rrrJtorch.utils._pytreeutilsrrMtorch._Crrrtorch._library.opaque_objectrr torch.typesrtorch.utils._dtype_abbrsrrrL_compatibilityrimmutable_collectionsrrrrrrr tensor_typer getLoggerr3rA__all__r0_symbolic_tracer$ graph_moduler%r7ListrCDictrgSet frozenset FrozenSetrTuplerdfromkeysrr.TransformCodeFuncr-kwlistrEupdate__dict__r?r7rFrGrHrrKrUrZpartialrrvrXrurs fullmatchr]rbrdr!rrrrrrr"rr%rXrkr#rrr _color_codesrrr reflectable_magic_methodsrrr8r9r:rs"""""""  ######MMMMMMMMMMMMMM%%%%%%!!!!!!:::::::::::: $$$$$$$$$66666666RRRRRRRR$$$$$$000000""""""))))))111111IIIIIIIIIIIIII######g!! , , ,*LLL''''''))))))  &+&+ v 6< ]]XXX d3i[$s)34     Z   76w~666h'(((.00000  6AAA 6AAA%