j3UddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddlm Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZddlZddlmcm Z!ddl"m#Z#ddl$m Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.gd Z/er dd l0m1Z1dd l2m3Z3e4ee5ee6ee7ee8eiZ9e5:gdZ;eee<gee<fZ=GddeZ>iZ?eefe@d<deej_d?ej`d@ejadAejbdBiZce'dCDeGdEdFZddGe ``mod.snake_case`` ``mod.pascalCase``-> ``mod.pascal_case`` ``mod.ALL_CAPS`` -> ``mod.all_caps`` )_snake_case_sublower)rHs r3 _snake_caserLds 1   # # % %%r2z(?<=[a-z])([A-Z])z_\1cZt|dd}|M|dd}|dko+|d o|d St|dd}|7|dkr1ttjjfD]}t||d|urdSd S) Nr,.rr<ztorch._dynamo.ztorch._inductor.r+TF)getattr partitionrDr<nn functional)r* module_name base_moduler5guesss r3_is_from_torchrVts#|T22K!++C003 7 " ?**+;<<< ?**+=>>> 3 D ) )D DGOOUX01  EudD))S00tt1 5r2cleZdZdZdZdedeedefdZdedefdZ dedede fd Z dedefd Z d S) _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. ci|_t|_t|_t t |_tjd|_ tjd|_ dS)Nz[^0-9a-zA-Z_]+z (.*)_(\d+)$) _obj_to_nameset_unassociated_names _used_namesrint _base_countrecompile_illegal_char_regex_name_suffix_regexselfs r3__init__z_Namespace.__init__s],.#&55 %(UU+6s+;+;#%:.>#?#? "$*^"<"<r2 candidater*rAc|||jvr |j|S|jd|}|sd}|drd|}|j|}||}d}n(|dd\}}t|}||n|d|}|s |j|}||j vs| ||r+|dz }|d|}||j v| ||+|j |||j|<||j |n ||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__unnamedrr) rZrbsubisdigitrcmatchgroupr^r_r]_is_illegal_nameaddr\)rergr*rnbasenumnum_strs r3 create_namez_Namespace.create_names ?sd&777$S) ),00i@@  #"I Q<   ! ! ('II'--i88 =DCC!KK1--MD'g,,CKDD__s__  )"4(C4+++t/D/DYPS/T/T+ 1HC#I4+++t/D/DYPS/T/T+ Y'''!$ ;  $ ( ( 3 3 3 3%.D c "r2r5cz||jvsJ||jvsJ||j|<|j|dS)zpAssociate a unique name with an object. Neither `name` nor `obj` should be associated already. N)rZr\removerer5r*s r3associate_name_with_objz"_Namespace.associate_name_with_objsV $+++++t/////!%#  ''-----r2c|tjvrdS|tjvr|tj|uS|tvr|t|juSdS)NTF)keywordkwlistbuiltins__dict__r4r*rxs r3rpz_Namespace._is_illegal_names^ 7> ! !4 8$ $ $h/55 5 # # #.t488 8ur2cd||jvsJ||j|<|j|dSr7)rZr]rq)rer*r5s r3_rename_objectz_Namespace._rename_objects@d'''''!%# T"""""r2N) r+r,r-r.rfr/r rruryboolrprr1r2r3rXrXs===)S)x})))))V.C.c.... S s t    ###S######r2rXbf16f64f32f16f8e4m3fnf8e5m2 f8e4m3fnuz f8e5m2fnuzc32c64c128i8i16i32i64b8u8u16u32u64b16Tis_backward_compatiblecjeZdZUdZeed<eeefed<eee ee fed<dS)rzZ Represents all the information necessary to exec or save a graph as Python code. srcglobals _lineno_mapN) r+r,r-r.r/r0rrr r^r1r2r3rrs\ HHH #s(^$sHSM12333333r2rrrtargetc|d}|}|D]'}|s d|d|d} |d|}(|S)NrNzgetattr(z, ""))split isidentifier)rrrelemsres r3_format_targetr si LL  E A ~~ &1&&&&&AA q AA Hr2c eZdZdZdZdZdS) _InsertPointc<||_|j|c|_|_dSr7)graph_insert orig_insert)rer new_inserts r3rfz_InsertPoint.__init__s  */-'%---r2cdSr7r1rds r3 __enter__z_InsertPoint.__enter__s r2c(|j|j_dSr7)rrr)retypevaluetbs r3__exit__z_InsertPoint.__exit__ s!- r2N)r+r,r-rfrrr1r2r3rrsDDDD   .....r2rc2eZdZd dddefdZdZdZdZd S) _node_list_nextrr directionc.|dvsJ||_||_dS)N)r_prev)rr)rerrs r3rfz_node_list.__init__%s&..... "r2c|jjSr7)r_lenrds r3__len__z_node_list.__len__*s zr2c#K|jdks |jdksJt|jj|jdkEd{VdSNrr)rrr_rootrds r3__iter__z_node_list.__iter__-sY~((DNg,E,E,EETZ-t~/HIIIIIIIIIIIr2cFt|j|jdkrdndSr)rrrrds r3 __reversed__z_node_list.__reversed__1s%$*71J1JggPWXXXr2N)r)r+r,r-r/rfrrrr1r2r3rr$sp##g###### JJJYYYYYr2rc^eZdZUdZeeed<ejed<e ejed<dS) _PyTreeInfoz= Contains extra info stored when we're using Pytrees orig_argsin_specout_specN) r+r,r-r.r r/r0r?TreeSpecr r1r2r3rr5sOCy _v''''''r2r)frozencBeZdZUdZeed<eed<eed<eed<dZdS)_ParsedStackTracez? Represents the top-most frame of a parsed stack trace filelinenor5codecFd|jd|jd|jd|jS)NzFile: :z in z, code: )rrr5rrds r3get_summary_strz!_ParsedStackTrace.get_summary_strJs0S SSDKSSTYSS SSSr2N)r+r,r-r.r/r0rr1r2r3rr?sZ III KKK III IIITTTTTr2r stack_tracec|dStjd}|d}t t |dz ddD]}||}||}|rp|d}|d}|d}||dz} t|||| cSdS)Nz$^File \"(.+)\", line (\d+), in (.+)$ rkr) r`rastriprrangelenrnror) rpatternlinesidxlinematchesrrr5rs r3_parse_stack_tracerOstj@AAG      % %d + +ESZZ!^R,, ? ?Sz!!--%%  ?==##D]]1%%F==##Dq>''))D$T64>> > > >  ? 4r2FceZdZdZdeededefdZdedefdZde de fd Z d e de fd Z dee ee ffd Z d d d d ddededededededefdZdS)rc"d|_d|_dS)Nforward)_body_transformer _func_namerds r3rfzCodeGen.__init__fs>B(r2 free_varsmaybe_return_annotationrAct|dks |ddkr|ddd|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):'` rrezdef (, )r)rinsertrjoin)rerrs r3 gen_fn_defzCodeGen.gen_fn_defjsk y>>Q  )A,&"8"8   Q ' ' ' V4? V VTYYy%9%9 V V.add_globalss## 0(+u|(;(; +3///$// 3??Kh&& ,3333""$'H[ ! r2oc|dkrdSt|}t|drt|j|j}t||}t|drCfd|jD}t |dkr|S|dd|d S|S||S) Nr1z() __origin____args__c&g|] }|Sr1r1).0arg type_reprs r3 z?CodeGen._gen_python_code..type_repr..s!AAAsIIcNNAAAr2r[,])rhasattr_origin_type_mapgetrrrr)rtypename origin_typeorigin_typenamerr rs r3rz+CodeGen._gen_python_code..type_reprsBwwt!!}}Hq,'' +.221<NN ",*Z -D-Dk"R"R1j)) +AAAAajAAAD4yyA~~ /.-AAAAAA+*:h** *r2zzzzzzz z z) yellowcyangreenbluereddimdim_blue dim_greenresetcfd}|S)Nc4r|dS|S)Nr(r1)rHcodesrr5s r3fz>CodeGen._gen_python_code..make_wrapper_func..fs.?#Dk>1>eGn>>>r2r1)r5r,r+rs` r3make_wrapper_funcz3CodeGen._gen_python_code..make_wrapper_funcs.        Hr2r r!r$r"r'r%r&r#rrAc@t|tret|drUtt |}|t |}|t t|St|t jjt jj frt|}||}|St|tj r$|j }|j |}|d|jSt|trt |St|t jrWt#|}t'|jdd}d|d|dSt|trOt-|dkrd|d d Sdd fd |DzdzSt|t"r'd d fd|DzdzSt|t0r6d|jd |jd |jdS t |S)N_fieldsrNrztorch.Tensor(size=z, dtype=rrrrz,)rc3.K|]}|VdSr7r1ra _get_reprs r3 z>CodeGen._gen_python_code.._get_repr..#s+*E*EA99Q<<*E*E*E*E*E*Er2rc3.K|]}|VdSr7r1r1s r3r4z>CodeGen._gen_python_code.._get_repr..%s+&A&Ayy||&A&A&A&A&A&Ar2rzslice() isinstancetuplerrrrr<_ops OpOverloadHigherOrderOperatorenumEnum __class__r+r5rTensorlistsizer/dtyperrrslicestartstopstep) rqualified_namer clsclsnamer@rAr3r r#s r3r3z+CodeGen._gen_python_code.._get_repr s#u%% ''#y*A*A '!4T#YY!?!?(jcCC %9tE#JJ'7'7999ej+UZ-KL '"5S!9!9(j== %''C++ 'm$*S\377!..CH...C&& 'Cyy 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\YaObObeeeetDII&r2r.kwargscdfd|D}dfd|D}|r |r|d|S|p|S)Nrc3.K|]}|VdSr7r1r1s r3r4zACodeGen._gen_python_code.._format_args...s+::yy||::::::r2c3>K|]\}}|d|VdS) = Nr1)rkvr3s r3r4zACodeGen._gen_python_code.._format_args../s= T TTQA!8!8))A,,!8!8 T T T T T Tr2)ritems)rrIargs_skwargs_sr3s r3 _format_argsz.CodeGen._gen_python_code.._format_args+sYY::::T:::::Fyy T T T TV\\^^ T T TTTH /( / ..H...%X %r2nusercp|vr0||<|g|dSdSr7) setdefaultappend)rTrUnode_to_last_useuser_to_last_usess r3register_last_usesz4CodeGen._gen_python_code..register_last_uses;sL(((&* #!,,T266==a@@@@@)(r2c|Sr7r1rTnoder[s r3z*CodeGen._gen_python_code..As););At)D)Dr2c|Sr7r1r]s r3r_z*CodeGen._gen_python_code..Bs+=+=a+F+Fr2c|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&rrrMc,g|]}t|Sr1rrrTs r3rzJCodeGen._gen_python_code..delete_unused_values..Ys666T!WW666r2None; )oprXrruserskeysr)rUnodes_to_delete to_delete_strbodyr%rZs r3delete_unused_valuesz6CodeGen._gen_python_code..delete_unused_valuesDs w-''w("" D!!!/33D"==O4:??$$%%** &&t,,,?## " % 66o666&A!!  8##m"4"488899999 D!!!!!r2r^cV|jdvr|jrg|jkrZ|jd}t|jx}r|}dd|zddSdSdkr*dd}d|ddSdSdS)z} Append a summary of the stacktrace to the generated code. This is useful for debugging. >r&r%rz z# rz)# No stacktrace found for following nodesN)rfrrrrX)r^ summary_strparsed_stack_traceno_stacktrace_msgrkr%prev_stacktraces r3append_stacktrace_summaryz;CodeGen._gen_python_code..append_stacktrace_summaryasw777# A'?::*.*:&( 1CDDT1U1UU-O*<*L*L*N*NK $E##d[.@*A*A$E$E$EFFFFF;:%**&(O(S%KK ?SS):%;%; ? ? ?@@@@@87+*r2shapecHddd|DdS)Nrrc34K|]}t|VdSr7)r/rr@s r3r4zDCodeGen._gen_python_code..stringify_shape..xs( 7 7AQ 7 7 7 7 7 7r2r)r)rss r3stringify_shapez1CodeGen._gen_python_code..stringify_shapews.:tyy 7 7 7 7 777::: :r2c  |jdnd|j}r=ddlm}ddlm}|jd|jd|jdd}t|tj r}r| nd}r|j nd}d t|j |j||d }nMt||rd |d }n6t||r&d t|j |jd }|jd krt|jt"sJ|jsdnd |jd}|j|||jdd}|t+|kr(t+|d|ddS|jdkrt|jt"sJt+||dt- |jd|jd |jdd|jddS|jdkrt1|jsJt3|jdddkr|jjt6vrtt|jt8sJt+||dt7|jjj fd|jDdSt3|jdddkr|jjt<vrot=|jjj fd|jDdt+||d |jddSt?|j}  | |j} | dkrt|jt8rt|jdt"r|jd rptC|jdkrXt+||dt- |jd|jddSt+||d| d |j|jd|jddr"| dS|jdkrrt|jt"sJt+||dt-|jd |j|jddS|jd krZt|jt"sJt+||dt-|jdS|jd!krR|jd"|jd<#|jddStId#|jd$|j)%Nrz : r) py_sym_types)TensorMetadataval tensor_meta example_valuez: ""z: "Sym(z)"r%rM*rr"rrrr!r, _operatorc3.K|]}|VdSr7r1r1s r3r4z>CodeGen._gen_python_code..emit_node..s-GhGhYZ RS GhGhGhGhGhGhr2c3.K|]}|VdSr7r1r1s r3r4z>CodeGen._gen_python_code..emit_node..s-IjIj[\))TU,,IjIjIjIjIjIjr2rerOrk is_wrappedFr$r#r&z -> znode:  )%r"torch.fx.experimental.proxy_tensorrytorch.fx.passes.shape_proprzmetarr6r<r>strider= dtype_abbrsrArsrfrr/rrXreplacerrrIcallablerOr+ magic_methodsr7formatinplace_methodsrrrrWrNotImplementedError)r^maybe_type_annotationryrzmeta_valstride_annotationdevice_annotationmaybe_default_argraw_namerFr rSr3r r#rkr&r'rrrrr$rrerwrr wrapped_fnss r3 emit_nodez+CodeGen._gen_python_code..emit_nodezsi'-I99TY3G3G-I-I " rKKKKKKEEEEEE9==IMM-PT1U1UVV h 55r* ??8??+<+<==??& AO(V8?(<(>X__U]UcEdEd@e@eX#8$566X8A BS8T8TXXX*) ,77r,Bh,B,B,B)).99r,q+hn2M,q_g_mOnOn,q,q,q)w-''!$+s33333"iLBB-L99TYq\3J3J-L-L"  {N$9N;LNN ;..sB77tDzz))KK4:: > >( > > >???M))!$+s33333 DzzD#8DD^IIVZV_`aVbLcLceiep=q=qDD$ TYqrr]DK@@DDDO++ ,,,,,DKr::kII , ==%di77777KK::l'<ll()=>EGhGhGhGh^b^gGhGhGhillF DKr::kII ,??KK*4;+?@GIjIjIjIj`d`iIjIjIjk[[::['<[[AJ49UV>???%&Ftw&F&F&F&FGG Gr2z # COUNTER: rrzpass wrapc g|] }d|d S)z("rr1)rr5 wrap_names r3rz,CodeGen._gen_python_code..s*#U#U#Uy$<$.s&DD4$DDDDDDr2z )r)"osenvironrr/rr4rPrrrrreversedrrrIr enumeraterXrr<fxrrrrrcountrr`searchror^lstripr)4renodesrrrrrrr5rir*r-r r!r"rlrrri wrap_stmtsrprologue lineno_map prologue_len new_linescur_idxrcounterrfn_coderSr3r r#rkr+r%r&r'rr rr^rYrqr$r[rwrrZrrs4` `````` @@@@@@@@@@@@@@@@@@@@@@r3_gen_python_codezCodeGen._gen_python_codes " #%') /1T' JNN13 7 73 > ( JNN13 7 73 >  # C       4/4466 " "ND(1c JtS ! ! ! ! + + + + + + + +>!)*         #"8,,  ((&&!!'**%%k22 &&$$Z00  (( '3 '3 ' ' ' ' ' ' ' 'D &# & &04S(]0C &  & & & & & &.046 A$ Ad A A A A A A A UOO H HD DIDDDDD E E E DK!F!F!F!F!F G G G G "t " " " " " " " "6 AD A A A A A A A A, ;8 ; ; ; ; ;t HDt Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Ht Hl!'' ' 'GAt 0))$/// KK+a+++ , , , IdOOO  & & & & t99>> KK ! ! ! {  a  " 658=99I#U#U#U#U#U#U#UVVJJJ  ! 0))$//D2244 $ $KD% JtU # # # #??9.Ea.HII02 ~~d++a/ ! GGDMM''-- ' 'Di 3T::G '7==++7gmmA..//>L89  &&&&yy##**400yyDD4::d3C3CDDDDD           '8DDDDr2N)r+r,r-rfr r/rrrrrrrrrXrrrr1r2r3rrdso)))  DI    PS     -8----- C C    ssDsCx$9$$MEMEMEME ME  MEMEMEME MEMEMEMEMEMEr2rcXeZdZdeffd ZdedefdZdedefdZfdZfd Z xZ S) _PyTreeCodeGen pytree_infocVt||_dSr7)superrfr)rerr=s r3rfz_PyTreeCodeGen.__init__/s' (3r2inputsrAc"tj|}|Sr7)r?arg_tree_leaves)rer flat_argss r3rz_PyTreeCodeGen.process_inputs3s*F3 r2outc|j |jj|St|ttfs|g}|jjJt j||jjSr7)rrr6r?r7r?tree_unflattenrers r3rz_PyTreeCodeGen.process_outputs7sc   #t'7'@'HJ#e}-- %C(444$S$*:*CDDDr2c |j"t||S|jj}t |dkr |ddknd}|r|ddt|dd|}t |dkr|jjjtko^|jjj dkoI|jjj djtko$|jjj djtk}d}dd |d }|r|jjj dj } |jjd| }d d d t|jjj dj|jj| dDzd z}d d |d|d}d|D} d|D} t | dkr|dd | zdzz }|dd | d|dz }|S)NrreFrkrz{}rrz], self._in_spec{c3,K|]\}}d|d|VdS)'z':Nr1)rrNrOs r3r4z,_PyTreeCodeGen.gen_fn_def..gsF   Aq%A        r2}z([z], z), self._in_speccDg|]}|ddS)rr)rrvs r3rz-_PyTreeCodeGen.gen_fn_def..vs&!E!E!Ea!''#,,q/!E!E!Er2c g|] }d|v|dz S)rz; r1rvs r3rz-_PyTreeCodeGen.gen_fn_def..ws!FFF1SAXXa$hXXXr2 rrz , = fx_pytree.tree_flatten_spec(r)rrrrrrrrr7 num_childrenchildren_specsdictrzipcontext) rerrfn_args has_orig_self fn_definitionhas_args_kwargs_tuple fn_kwargs fn_signature count_argswithout_annotationhas_annotationr=s r3rz_PyTreeCodeGen.gen_fn_def?s   #77%%i1HII I",25g,,2B2Bv--  (   Q ' ' '**7111:7NOO y>>A   (-6L$,9Q>L$,;A>CuLL$,;A>CtK " ICtyy11CCCL$ W!-5DQGT *4[j[Aii  $' ,4CAFN ,6z{{C%%    WDIIg$6$6VV9VVV "F!E9!E!E!E FF FFFN>""Q&&BGGN,C,C!Cd!JJ V YY!""VVDPVVV VMr2c|jr|jjrdt|dSt|S)Nzreturn pytree.tree_unflatten(z, self._out_spec))rrrrr)rerr=s r3rz_PyTreeCodeGen.generate_output~sL   8 0 9 8W4 3D3DWWW W77**;77 7r2) r+r,r-rrfrrrrr __classcell__)r=s@r3rr.s4K444444ccE3E3EEEE=====~888888888r2rceZdZdZdZdeeeeffdZ de fdZ de ddfdZ de ddfd Zdd d ed ed fdZdS)_FindNodesLookupTablezH Side table for the graph for the purpose of doing fast queries c8tt|_dSr7)rrtablerds r3rfz_FindNodesLookupTable.__init__sKV L L  r2rAc8|j|jdkr|jndfS)Nr!rfrrer^s r3_keyz_FindNodesLookupTable._keys!?(B(BMMr2cF||j||vSr7rrrs r3 __contains__z"_FindNodesLookupTable.__contains__stz$))D//222r2r^NcLd|j|||<dSr7rrs r3rz_FindNodesLookupTable.inserts#,0 499T??#D)))r2cl|j|||dSr7)rrpoprs r3rwz_FindNodesLookupTable.removes- 499T??#''-----r2rrfrrc|dkr'Jg|j|fS#g|j|dfSfd|j|dfDS)Nr!c*g|]}|jk |Sr1r)rr^rs r3rz4_FindNodesLookupTable.find_nodes..s&XXX$+QWBWBWBWBWBWr2)rrh)rerfrs `r3 find_nodesz _FindNodesLookupTable.find_nodess  %%%5TZV -22445 5 >3TZT +00223 3YXXXRJ!7!!>XXXXr2)r+r,r-r.rfrr/r rrrrrrrwrr1r2r3rrs   NE#x'7"78NNNN3D3333141D1111.4.D....CG Y Y Y YXh-? Y Y Y Y Y Yr2rceZdZdZed dOdeddeedd eeee ffd Z e d Z e j d edfd Z e defdZeddefdZedddddededdefdZed dPdddeeefddfdZdQdRdZed dSdedddeeddeeed fd!eed"ee defd#Zedd$Zedd%Zedd&eddfd'ZeddQd(eefd)ZeddQd(eefd*Zeddejjfd!ed"ee d+e defd,Z eddQd-ed"ee defd.Z!ed dOd/edeeddeeed fd"ee def d0Z"ed dOd1edeeddeeed fd"ee def d2Z#ed dOd3e$d4e fdeeddeeed fd"ee def d5Z%edd6fd7ed8e$egd fdefd9Z&eddQd:d d"ee fd;Z'de(defd<Z)edddddd=d>ed?ed@edAedBede*f dCZ+ddddd=d>edDe,d?ed@edAedBede*fdEZ-defdFZ.eddGZ/eddHZ0ed dQdIee$egefdefdJZ1eddKe2fdLZ3eddMe$ee4ge4ffdNZ5dS)Tra ``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_moduler tracer_clsr tracer_extrasc t|ddddi|_i|_|jj|_d|_t |_||_||_ ||_ t|_ i|_ t|_dS)z+ Construct an empty Graph. rrootr1rN)rrr]prependrrrX_graph_namespace_owning_module _tracer_cls_tracer_extrasr_codegen _co_fieldsr_find_nodes_lookup_table)rerrrs r3rfzGraph.__init__s b&"b"== +-z)  * +%+  *,(=(?(?%%%r2c|jSr7rrds r3rzGraph.owning_modules ""r2modc||_dSr7r)rers r3rzGraph.owning_modules!r2rAc 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. )rrds r3rz Graph.nodess$r2Fc|ttt|j}|jdksJ|S)Nr&)nextiterrrrf)re output_nodes r3rzGraph.output_nodes:4 4 45566 ~))))r2)rsortrfrrrc`|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: Iteratable of nodes with the requested op and target. r)rrsorted)rerfrr node_lists r3rzGraph.find_nodes s;*1<<6<RR  %)$$ $r2gval_mapzOptional[Argument]c|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|Sr7r1rTrs r3r_z"Graph.graph_copy..=s WQZr2c|Sr7r1rs r3r_z"Graph.graph_copy..?s 71:r2N)rrfrr node_copy)rerrreturn_output_noder^rvs ` r3 graph_copyzGraph.graph_copy%s(G G GDww(""TYq\+?+?+?+?@@!3Crr"dCCC NN41E1E1E1EFFGDMMtr2cl|r|ni}t|j}|||d}tj|j|_|`t |tsJ|\}}||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)rrNr type_expr) rrr copydeepcopyrr6r7r&rOr)rememor output_vals output_valold_output_nodenew_output_nodes r3 __deepcopy__zGraph.__deepcopy__Bs#tt T- . . .ll4$lOO ]4=11  "k511 1 11*5 'Jhhgovt&L&L'O$(9_-A#B#BO r2r)r.rIrr5r c d|tvsJ|dn|}|in|}t|ts Jdt|ts Jd||n||}|j|d}t|||||||}|j0t|jdd|jj D] } | ||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. Nr1zargs must be a tuplezkwargs must be a dict_create_node_hooksr) _legal_opsr6r7r_target_to_strrrurrrOrryrrrr) rerfrrrIr5r rgrTr,s r3 create_nodezGraph.create_nodeWsSFZ\rrt~6$&&>>(>>>&&$''@@)@@@' ,DD$2E2Ef2M2M $00DAA tRvy A A   **,@$GGS':  ! 55dA>>> Q %,,Q/// Q r2c |jj|S)zL Processes args so that they can be passed to the FX graph. )rrrs r3rzGraph.process_inputss ,t}+T22r2c6|j|Sr7)rrrs r3rzGraph.process_outputss},,S111r2to_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|jd}t!|t"sJ||_t|jd}t!|t&sJ||_d 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_hooksTrcdSr7r1rTs r3r_z"Graph.erase_node..sDr2cdSr7r1r"s r3r_z"Graph.erase_node..sr2)rrg RuntimeErrorr_erasedwarningswarnrrOr rrw_remove_from_listrrrr6r7rIr)rerr,new_args new_kwargss r3 erase_nodezGraph.erase_nodes x~   " "9x993x~CVCV99'/~999  >T ! !SxSSSTT T    MMMMM N N N F   **,?FFR'9  (  %,,X666""$$$ Q 8=..99(E*****  X_nn== *d+++++$r2rTc|||jS|j|ks Jdt||jS)aSet the point at which create_node and companion methods will insert into the graph. When used within a 'with' statement, this will temporary 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_afterrrrrrerTs r3inserting_beforezGraph.inserting_beforesG& 9'' 33 3w$ HD!),,,r2c|||jS|j|ks Jdt||jS)aSet the point at which create_node and companion methods will insert into the graph. When used within a 'with' statement, this will temporary 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.)r/rrrrXr.s r3r-zGraph.inserting_aftersG& 9((44 4w$ GD!(+++r2 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``. r1r%)rr )inspect Signatureemptyr)rer5r r1rs r3r%zGraph.placeholders=<#g&7&===rrMCS t$)TTTr2rFcdtjjdtdtfd}|jr'||j|st jdd|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``. rrFrAc|d\}}} ||}n)#t$rtjd|dYdSwxYwt ||sdSt ||}t|tj j s*t|tj j s ||j vrdSdS)NrNzFailed to fetch module rFT) rpartition get_submoduleAttributeErrorr&r'rrOr6r<rQModule Parameter_buffers)rrF module_pathrir5submodress r3_get_attr_reference_existsz2Graph.get_attr.._get_attr_reference_exists2s$2#<#sRSr2r^ arg_transformcNt|j|}t|j|}t|tsJt|t sJ||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``. ) rrrIr6r7rrrfrr5rrr)rer^rJrrI result_nodes r3rzGraph.node_copys2ty-00m44$&&&&&&$'''''&& GT[$ 49   9TY// r2resultc6|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&)rfrrr rF)rerMr s r3r&z Graph.outputs,&yI    r2ct|r|j}n2t|tsJ|}t |r |dd}t |}|S)Nrk)rr+r6r/rGrL)rerrfs r3rzGraph._target_to_strsa F   BBfc** * **B}} "X __ r2rrrrrrc tdtffd tdtffd }||5||||||cdddS#1swxYwYdS)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. rTc:|j|Sr7)rur5)rTrs r3 node_reprz$Graph.python_code..node_reprTs((33 3r2rc3Ki}|jD]}|j||<|_ dV|jD]}|||_dS#|jD]}|||_wxYwr7)r_repr_fn)r orig_repr_fnsr^rSs r3override_node_reprz-Graph.python_code..override_node_reprWsM  * *&*m d# )  8 "K88D$1$$7DMM88EK88D$1$$7DMM8s ?ArN)rXrrr _python_code) rerrrrrrWrrSs @@r3 python_codezGraph.python_code!sXLL  4 4 4 4 4 4 4  8e 8 8 8 8 8  8  % %  $$-- %                  sA++A/2A/rc N|j|j||||||S)Nr)rrr)rerrrrrrs r3rXzGraph._python_codens:}-- J  )).   r2cgdg}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|]}|Sr1) format_node)rr^placeholder_namess r3rz!Graph.__str__..s(PPPTT%%&788PPPr2rzgraph(rrrr)rr)remaybe_return_typename node_strs param_strrHnode_strr^s @r3__str__z Graph.__str__s (*-/4PPPPTZPPP II/00 .s-UUUQqtQVQXqvqx@UUUr2)opcoder5rrrI)headersN)re ImportErrorprintr)rere node_specss r3 print_tabularzGraph.print_tabulars  ) ) ) ) ) ) )    <      VU$*UUU  HZ)W)W)W X X X     s $c  d#dtdttddf fd t}t jD] jdvrt d d jd  jurt d d  jvrt d d t j fd t j fd  j |vrt d j d | j j r;d}d}jD] jdkrJt js5t!d d jdt#j jdnOt' jt(s5t!d d jdt#j jd jdvrZ jd}j }t-|D](\}}t/||d}d|d|} | t d d jd|d|  jdkr@t'|t"jjs!t d d jd|d| d  jdkrzt'|t"jjs[t'|t"jjs<||jvr3||kr&t;jd d jd|d| d |d z }&|}* ||krt;jd!||z d"dSdSdS)$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 NrrTrAc|rd|dnd}|jurtd|d|d|vrtd|d|ddS)Nz of Node 'z' rz Argument 'rzdoes 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$)rrT context_str seen_valuesres r3 check_argzGraph.lint..check_args01:,q,,,,sKy$$"\\\{\\UY\\ +%%"ggg{gg`dgg&%r2)r%r"r$r!r#r&zNode z had unknown opcode rzNode 'z ' does not belong to this Graph!z ' is not added to the side tablec|Sr7r1rrqr^s r3r_zGraph.lint..s99S$+?+?r2c|Sr7r1rss r3r_zGraph.lint..sYYsD-A-Ar2zNode redefined name rr!z target z has type z but a Callable is expectedz but a str is expected)r#r$rNz" references nonexistent attribute z of r$rz does not reference an nn.Moduler#zj does not reference an nn.Module, nn.Parameter, or buffer, which is what 'get_attr' Nodes typically targetrz Additional z. warnings suppressed about get_attr referencesr7)rr r[rrfr$rrrrrIrqr5rrr ValueErrorr<rr6r/rrrOrrQr;r<r=r&r') re seen_names num_warnings MAX_WARNINGS target_atomsm_itrratom new_m_itr seen_qualnamerqr^rps ` @@@r3lintz Graph.lints  4 HTN d        #uu !$ J & &Dw##O4#O#OTW#O#O#OPPPz%%"#RD#R#R#RSSS4888"#RD#R#R#RSSS DI????? @ @ @ DK!A!A!A!A!A B B B OOD ! ! !yJ&&"#F$)#F#F#FGGG NN49 % % % %  8 LL 0 .0 .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!=!=!=## !Gz11$.y%(/$J$J2$.y%(:L$M$M2!%EN : :+l::!) %MD%M%M$+%M%M%M%MR_%M%M%M!"!"!" )A-LL$-EEl** ;,"=;;;k8 8 h+*r2is_impure_nodec|fd}d}t|jD]<}||s/t|jdkr||d}=|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. cF |S|Sr7) is_impure)r^rs r3has_side_effectz2Graph.eliminate_dead_code..has_side_effectHs))%~d+++>>## #r2FrT)rrrrrgr+)rerrchangedr^s ` r3eliminate_dead_codezGraph.eliminate_dead_codes^  $ $ $ $ $TZ((  D"?4(( S__-A-A%%%r2codegenc||_dSr7)r)rers r3 set_codegenzGraph.set_codegenXs  r2make_transformercjj|j_tjfd}|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()`). c3PK dVj_dS#j_wxYwr7)rr)on_gen_code_oldresr3 on_generate_code_context_managerz@Graph.on_generate_code..on_generate_code_context_managers< B2A //// /AAAAs%)rr contextlibr)rerrrs` @r3on_generate_codezGraph.on_generate_code\siN-9*:*:?*K*K '  " B B B B B # " B 0/111r2)NNN)Fr7)rAr)NNNN)6r+r,r-r.rr rrr/rrfpropertyrsetterrrrrrrr rrrrrr+r/r-r3r4r5r%r#r$r"rr!rr&rrrrYrXrXrcrlrrrrTransformCodeFuncrr1r2r3rrsJ --^]$///26/326 @@ .@T(^,@ S#X/ @@@0/@*##X#"-!8""""  z    X  ]%000T10 ]%0007;$"*8"4CG102]$///HM#'d #3 0/8*]$/// 2626"#'88 88u_-. 8 c:o./ 8 sm 8C=8 8880/8t]%00033103 ]%00022102]$///'%4'%D'%'%'%0/'%R]$///--(4.---0/-.]$///,,$,,,0/,.]$///$($.4 UUUC=U U  UUU0/U@]$///AQAQsAQx}AQPTAQAQAQ0/AQF]$///2626#' / / / u_-./ c:o./ / C= /  / / / 0// b]$///2626#' $ $ $ u_-.$ c:o./ $ C= $  $ $ $ 0/$ L]$///2626#' $ $ sCx($ u_-.$ c:o./ $ C= $  $ $ $ 0/$ L]$///HS    )14&*2D)E     0/ D]$///  Z HSM   0/ , V     ]$/// $$JJJJ J  J  JJ JJJ0/Jb$$                ($]$///  0/ *]$///jj0/jX]$///AE>>&x '=>> >>>0/>@]%000 7   10 ]%000P2"H->$?#@BS#STP2P2P210P2P2P2r2rz{} + {}z{} - {}z{} * {}z{} // {}z{} / {}z{} % {}z{} ** {}z{} << {}z{} >> {}z{} & {}z{} | {}z{} ^ {}z{}[{}]z{} @ {})rqrlmulfloordivtruedivdivrpowlshiftrshiftand_or_xorgetitemmatmulz{} == {}z{} != {}z{} < {}z{} > {}z{} <= {}z{} >= {}z+{}z-{}z~{}) eqneltgtlegeposneginvertz{} += {}z{} &= {}z {} //= {}z {} <<= {}z{} %= {}z{} *= {}z{} @= {}z{} |= {}z {} **= {}z {} >>= {}z{} -= {}z{} /= {}z{} ^= {}z {}[{}] = {})iaddiand ifloordivilshiftimodimulimatmulioripowirshiftisubitruedivixorsetitem)rr}rrr; functoolsr3r{mathrr`r& collectionsrr dataclassesrtypingrrrr r r r r rrrrr<torch.utils._pytreeutilsrr?torch._Crrr>_compatibilityrr^rrrrrr__all___symbolic_tracer graph_moduler r?rr[ frozensetr7rfromkeysrr/rr(r4r0r8r9r:rr=rrGrLpartialrarlrJrVrXbfloat16float64float32float16 float8_e4m3fn float8_e5m2float8_e4m3fnuzfloat8_e5m2fnuz complex32 complex64 complex128int8int16int32int64uint8uint16uint32uint64bits16rrrrrrrrrrrrreflectable_magic_methodsrrr1r2r3rse  ######%%%%%%!!!!!!                             $$$$$$$$$""""""))))))RRRRRRRRRRRRRRRR - , ,*''''''))))))  $$ y 5 ]]XXX d3i[$s)34      Z    /1$sN*+000=3=C=c==== 6AAA 6AAA%