DŽg UddlmZddlmZmZmZmZmZmZddl m cm Z ddl m ZddlmZddlmZddlZddlZddlmZmZmZmZmZmZmZmZmZmZm Z m!Z!dd l"m#Z#dd lm$Z$ddl%Z%ddl&Z&ddl'Z'ddl(Z(ddl)Z)ddl*Z*ddl+Z+ddl,Z,ddl-Z-gd Z.er dd l/m0Z0dd l1m2Z2e3ee4ee5ee6ee7eiZ8eee9gee9fZ:GddeZ;iZe>dde+j~e>dde+je>ddeAde>dde'e>dde'je>dd ee>d!d"e d#e9d$eCfd%ZDd&e9d$e9fd'ZEded$eCfd(ZFGd)d*ZGie'jd+e'jd,e'jd-e'jd.e'jd/e'jd0e'jd1e'jd2e'jd3e'jd4e'jd5e'jd6e'jd7e'jd8e'jd9e'jd:e'jd;e'jde'jd?iZ\ed@Ae#GdBdCZ]dDe9dEe9d$e9fdFZ^GdGdHZ_GdIdJZ`GdKdLeZae#d@MGdNdOZbdPe9fdQZcedRAGdSdTZdGdUdVedZeGdWdXZfed@AGdYdZZgd[d\d]d^d_d_d`dadbdcdddedfdgdhdiZhe4djdkdldmdndodpdqdrds fiehZidtdudvdwdxdydzd{d|d}d~ddddZjy)) defaultdict)NodeArgumentTargetmap_arg _type_repr_get_qualified_nameN)_pytree) compatibility) _NodeIter) TYPE_CHECKINGCallableAnyListDict NamedTupleOptionalTupleSet FrozenSetTypeIterable) dataclass)contextmanager) PythonCodeCodeGenGraph) GraphModule)Tracerc&eZdZUdZeed<eed<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. import_strobjN)__name__ __module__ __qualname____doc__str__annotations__rV/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/torch/fx/graph.pyr"r".sO Hr,r"_custom_builtinsnamer#r$c*t||t|<yN)r"r.)r/r#r$s r-_register_custom_builtinr2=s+J<Tr,infzfrom 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 pytreexreturncJ|jdxr|jdS)N__) startswithendswithr:s r- _is_magicrAJs <<  2!**T"22r,scg}d}|D]T}|r!|jr|jd|j|j|j}Vdj |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`` F_)isupperappendlowerislowerjoin)rBchars prev_lowercs r- _snake_caserNNsa EJ ! !))+ LL  QWWYYY[ ! 775>r,c8t|dd}|A|jdd}|dk(xr&|jd xr|jd St|dd}|;|dk7r6ttjj fD]}t||d|usyy ) Nr&.rr6ztorch._dynamo.ztorch._inductor.r%TF)getattr partitionr>r6nn functional)r$ module_name base_moduler/guesss r-_is_from_torchrXas#|T2K!++C03 7 " ;&&'78 8 ;&&'9: : 3 D )D DGOUXX001 EudD)S0  r,cdeZdZdZdZdedeedefdZdedefdZ dedede fd Z dedefd Z y ) _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|_ y)Nz[^0-9a-zA-Z_]+z (.*)_(\d+)$) _obj_to_nameset_unassociated_names _used_namesrint _base_countrecompile_illegal_char_regex_name_suffix_regexselfs r-__init__z_Namespace.__init__}sN,.#&5 %(U+6s+;#%::.>#? "$**^"<r, candidater$r;c|||jvr|j|S|jjd|}|sd}|djrd|}|jj |}||}d}n |j dd\}}t|}||n|d|}|s|j|}||jvs|j||r.|dz }|d|}||jvr|j||r.|jj|||j|<||jj||S||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. NrD_unnamedrr) r\rdsubisdigitrematchgroupr`rar__is_illegal_nameaddr^)rgrir$robasenumnum_strs r- create_namez_Namespace.create_names ?sd&7&77$$S) ),,00i@ "I Q<   !I;I''--i8 =DC!KK1-MD'g,CKDvQse_ ""4(C4+++t/D/DYPS/T 1HC&#I4+++t/D/DYPS/T Y'!$ ;  $ $ ( ( 3&/D  c "r,r/c||jvsJ||jvsJ||j|<|jj|y)zpAssociate a unique name with an object. Neither `name` nor `obj` should be associated already. N)r\r^removergr/r$s r-associate_name_with_objz"_Namespace.associate_name_with_objsP $+++++t/////!%#   ''-r,c|tjvry|tjvr|tj|uS|tvr|t|j uSy)NTF)keywordkwlistbuiltins__dict__r.r$rys r-rqz_Namespace._is_illegal_names\ 7>> ! 8$$ $h//55 5 # #.t4888 8r,cx||jvsJ||j|<|jj|yr1)r\r_rr)rgr$r/s r-_rename_objectz_Namespace._rename_objects:d'''''!%# T"r,N) r%r&r'r(rhr)rrrvrzboolrqrr+r,r-rZrZusk=)S)x}))V.C.c. S s t ###S#r,rZbf16f64f32f16f8e4m3fnf8e5m2 f8e4m3fnuz f8e5m2fnuzc32c64c128i8i16i32i64b8u8u16u32u64b16Tis_backward_compatiblecPeZdZUdZeed<eeefed<eee ee fed<y)rzZ Represents all the information necessary to exec or save a graph as Python code. srcglobals _lineno_mapN) r%r&r'r(r)r*rrrr`r+r,r-rrs7 H #s(^$sHSM1233r,rrstargetc||jd}|}|D]#}|js d|d|d}|d|}%|S)NrPzgetattr(z, ""))split isidentifier)rsrelemsres r-_format_targetrsX LL E A ~~1#S2&A#Qqc A  Hr,ceZdZdZdZdZy) _InsertPointcD||_|j|c|_|_yr1)graph_insert orig_insert)rgr new_inserts r-rhz_InsertPoint.__init__s */--'%-r,cyr1r+rfs r- __enter__z_InsertPoint.__enter__s r,c:|j|j_yr1)rrr)rgtypevaluetbs r-__exit__z_InsertPoint.__exit__s!-- r,N)r%r&r'rhrrr+r,r-rrsD .r,rc0eZdZd dddefdZdZdZdZy) _node_listrr directionc,|dvsJ||_||_y)N)_next_prev)rr)rgrrs r-rhz_node_list.__init__ s.... "r,c.|jjSr1)r_lenrfs r-__len__z_node_list.__len__szzr,c#K|jdk(s|jdk(sJt|jj|jdk(Ed{y7wNrr)rr r_rootrfs r-__iter__z_node_list.__iter__sF~~(DNNg,EEETZZ--t~~/HIIIsAAAAcXt|j|jdk(rdSdSr)rrrrfs r- __reversed__z_node_list.__reversed__s'$**71JgXXPWXXr,N)r)r%r&r'r)rhrrrr+r,r-rr s&#g### JYr,rcdeZdZUdZeeed<ejed<e ejed<y) _PyTreeInfoz= Contains extra info stored when we're using Pytrees orig_argsin_specout_specN) r%r&r'r(rr)r*r9TreeSpecrr+r,r-rrs,Cy __v''r,r)frozenc@eZdZUdZeed<eed<eed<eed<dZy)_ParsedStackTracez? Represents the top-most frame of a parsed stack trace filelinenor/codecnd|jd|jd|jd|jS)NzFile: :z in z, code: )rrr/rrfs r-get_summary_strz!_ParsedStackTrace.get_summary_str-s1 {!DKK=TYYKx {SSr,N)r%r&r'r(r)r*rr+r,r-rr#s# I K I ITr,r stack_tracec|ytjd}|jjd}d}t t |dz ddD]}||j}|j |}|s*|jd}|jd}|jd} ||dzj} t||| | cSy)Nz$^File \"(.+)\", line (\d+), in (.+)$ rErlr) rbrcstriprrangelenrorpr) rpatternlines summary_stridxlinematchesrrr/rs r-_parse_stack_tracer1sjj@AG     % %d +EKSZ!^R, ?Sz!--% ==#D]]1%F==#Dq>'')D$T64> > ? r,FceZdZdZdeededefdZdedefdZde de fd Z d e de fd Z dee ee ffd Z d d d d ddededededededefdZy)rc d|_d|_y)Nforward)_body_transformer _func_namerfs r-rhzCodeGen.__init__Hs>B(r, free_varsmaybe_return_annotationr;ct|dk(s|ddk7r|jddd|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):'` rrgzdef (, )r)rinsertrrJ)rgrrs r- gen_fn_defzCodeGen.gen_fn_defLsX y>Q )A,&"8   Q 'doo&a )(<'=Q?V>WWXYYr, output_argscdt|S)z Given the output arguments, generates the return statement of the FX function. Note: The returned statement should not be indented. zreturn )repr)rgrs r-generate_outputzCodeGen.generate_outputWs k*+,,r,argsc|S)a{ Transforms the inputs so that the graph can take them as arguments, as non-default codegen may result in the inputs to the function being different from the inputs to the graph. If the graph was directly runnable, this invariant should hold true `f.graph.process_outputs(f.graph(*f.graph.process_inputs(*inputs))) == f(*inputs)` r+rgrs r-process_inputszCodeGen.process_inputs^s  r,outputsc|S)z Transforms the outputs of the graph to be identical to the codegen. See ``process_inputs`` for more details. r+)rgrs r-process_outputszCodeGen.process_outputsis r,cgS)z If your codegen uses extra global values, add tuples of (identifier,reference to the value) here. For example, return ['List', typing.List] if you need ``List`` in the global context. r+rfs r-additional_globalszCodeGen.additional_globalsqs  r,Fverboseinclude_strideinclude_devicecolored root_module namespacerrrrc !"#$%&'()*+,-./0123g(g#i)i3dg*xs#tjjdddk(xs#tjjdddk(dtdtf)fd !t j D]\}\} } !|| d tf!1fd 1d d d ddddddd $$fd} | d} | d} | d.| d}| d'| d%| d&| d"dtdtf!"fd d!ttd"fd#tttfdtf fd$ i,i2d%td&tf,2fd' /t|D]6+t+j+/fd(t+j+/fd)8d&tf#%2fd* }d-d+tf#%-fd, }d-tdtfd.0d+tf !"#&'(*.013fd/ }t!|D]4\}+r|+#j#d0|d1|+|+6t%#d2k(r#j#d3t%3d2kDrG!d4t&j(j*}d1j-3Dcgc] }|d5|d6 c}}nd}j.rj/##j1D]\}}!||j3(*d2}i}|j5d1d7z}g}d}dj-#j7d1D]h}t9j:d8|}|r,|j=d7t?|j=d7}G||t%||z<|j#|jd1j-|jAd1}d1j-d9|j7d1D}d1|d:|d1|}tC|)|;Scc}w).add_globalsjc"sell':+3//$// 3?Kh& ,333""$'H[ ! r,ocz|dk(ryt|}t|drtj|j|j}t||}t|drF|j Dcgc] }| }}t |dk(r|S|ddj|dS|S||Scc}w) Nr+z() __origin____args__r[,])r hasattr_origin_type_mapgetrrrrJ)r typename origin_typeorigin_typenameargrr  type_reprs r-rz+CodeGen._gen_python_code..type_reprsBw!!}Hq,'.221<<N ",Z -Dk"R1j)67jjAsIcNADA4yA~ /.-.a/?qAA+*h* *Bs5B8zzzzzzz z z) yellowcyangreenbluereddimdim_blue dim_greenresetcfd}|S)Nc(r|dS|S)Nr$r+)rBcodesrr/s r-fz>CodeGen._gen_python_code..make_wrapper_func..fs'#Dk]1#eGn-=>>r,r+)r/r(r'rs` r-make_wrapper_funcz3CodeGen._gen_python_code..make_wrapper_funcs Hr,rrr rr#r!r"rrr;ct|trJt|dr>tt |}|t |}|t t|St|t jjt jjfrt|}||}|St|tjr0|j}|j|}|d|jSt|tr t |St|t j rIt#|j%}t'|j(j+dd}d|d|dSt |S)N_fieldsrPrztorch.Tensor(size=z, dtype=r) isinstancetuplerr rrr6_ops OpOverloadHigherOrderOperatorenumEnum __class__r%r/rTensorlistsizer)dtyper) rqualified_namer clsclsnamer6r7r rs r- _get_reprz+CodeGen._gen_python_code.._get_reprs<#u%'#y*A!4T#Y!?(cC %tE#J'7&899C%**"7"79W9W!XY!4S!9(= %'C+mm$S\\37!!CHH:..C&Cy C.CHHJ'CII,,S1"5+D6%BBDI&r,r.kwargscdjfd|D}djfd|jD}|r |r|d|S|xs|S)Nrc3.K|] }|ywr1r+.0ar;s r- zACodeGen._gen_python_code.._format_args..s:y|:c3>K|]\}}|d|yw) = Nr+)r@kvr;s r-rBzACodeGen._gen_python_code.._format_args..s$ TTQA3c)A,!8 Ts)rJitems)rr<args_skwargs_sr;s r- _format_argsz.CodeGen._gen_python_code.._format_argssRYY:T::Fyy TV\\^ TTH( H:..%X %r,nuserc\|vr'||<j|gj|yyr1) setdefaultrG)rLrMnode_to_last_useuser_to_last_usess r-register_last_usesz4CodeGen._gen_python_code..register_last_usess7((&* #!,,T26==a@)r,c|Sr1r+rLnoderRs r-z*CodeGen._gen_python_code..s);At)Dr,c|Sr1r+rTs r-rVz*CodeGen._gen_python_code..s+=a+Fr,c|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. placeholderNoutputrrrENone; )oprGrruserskeysrJr)rMnodes_to_deleterL to_delete_strbodyr!rQs r-delete_unused_valuesz6CodeGen._gen_python_code..delete_unused_values s ww-'ww(" D!/33D"=O4::??$%* &&t,?# % _+MDG+MQWPX+X Y  c#m"4!5R89 D!,NsC!rUcN|jdvr|jrd|jk7rT|jd}t|jx}r|j}j dd|zdyydk7r dd}j d|dyyy)z} Append a summary of the stacktrace to the generated code. This is useful for debugging. >rZrYrEz z# rz)# No stacktrace found for following nodesN)r]rrrrG)rUrparsed_stack_traceno_stacktrace_msgrbr!prev_stacktraces r-append_stacktrace_summaryz;CodeGen._gen_python_code..append_stacktrace_summary%sww77##''?:*.*:*:&( 1CDDTDT1UU-U*<*L*L*NK c#d[.@*A)B"$EF;%*&(O(S%KK"S):%;$.stringify_shape..<s 7AQ 7r)rJ)ris r-stringify_shapez1CodeGen._gen_python_code..stringify_shape;s!tyy 7 778: :r,c  |jdnd|j}r0ddlm}ddlm}|j j d|j j d|j j dd}t|tjrrr|jnd}r |jnd}d t|j|j||d }nHt||rd |d }n5t||r)d t|j|jd }|jd k(rt|j t"sJ|j$sdnd |j$d}j'|j |||j j)dd}|t+|k7r j't+|d|dy|jdk(rt|j t"sJj't+||dt- |j$d|j d |j$dd|j.dy|jdk(rt1|j sJt3|j dddk(r|j j4t6vrxt|j$t8sJj't+||dt7|j j4j: fd|j$Dyt3|j dddk(r|j j4t<vrrj't=|j j4j: fd|j$Ddt+||d |j$dyt?|j }  | |j } | dk(rt|j$t8rt|j$dt"r|j$djArdtC|j$dk(rLj't+||dt- |j$d|j$dyj't+||d| d |j$|j.d|j j ddrjE| y|jdk(rqt|j t"sJj't+||dt-|j d |j$|j.dy|jd k(rRt|j t"sJj't+||dt-|j y|jd!k(rR|jd"|jd<j'jG|j$dytId#|jd$|j )%NrEz : r) py_sym_types)TensorMetadataval tensor_meta example_valuez: ""z: "Sym(z)"rYrE*r call_methodrrr call_functionr& _operatorc3.K|] }|ywr1r+r?s r-rBz>CodeGen._gen_python_code..emit_node..hsOpabPYZ[P\OprCc3.K|] }|ywr1r+r?s r-rBz>CodeGen._gen_python_code..emit_node..nsQrcdR[\]R^QrrCr\rQrl is_wrappedF call_moduleget_attrrZz -> znode:  )%r"torch.fx.experimental.proxy_tensorrotorch.fx.passes.shape_proprpmetarr,r6r4strider7 dtype_abbrsr7rir]rr)rrGreplacerrr<callablerQr% magic_methodsr-formatinplace_methodsr rrrOrNotImplementedError)rUmaybe_type_annotationrorpmeta_valstride_annotationdevice_annotationmaybe_default_argraw_namer8r rKr;r rrbr"r#rrrrr rrgrmrr wrapped_fnss r- emit_nodez+CodeGen._gen_python_code..emit_node>s*.))*;B3yQUQZQZG[F\A] !KE99== mTYY]][jlpMq0rsh 5Sa?8??;L+M*Ngi%@N8??*;TV%c+hnn"=>?_U]UcUcEd@e?f#$567 BS8T7UUVX* ,7.5hZr,B).9.1+hnn2M1N_g_m_mOnNoop,q)ww-'!$++s333.2iiBs9TYYWX\CZB[=\!  DKK=1F0GHYGZ![\;;..sB7tDz)KK4:,c(2 >?M)!$++s333 Dzl#8"9^IVZV_V_`aVbLceiepep=qQ&KK4:,/D.ESXabfbkbklmbnXoquqzqz{|q}I~H!AB tDzl+@*A[MQRS_`d`i`ikokvkvSwRxxyz{99==u5**;7M)!$++s333 tDzl+@*A-k4;;GH,W[W`W`bfbmbmJnIooprsJ&!$++s333 tDzl+@*A^T_aealalEmDnopH$99(37 $))8L7M1N+A. D001>?%twwiq &FG Gr,z # COUNTER: rrzpass wrapz("rrz# COUNTER: (\d+)c3&K|] }d|z yw)z Nr+)r@rs r-rBz+CodeGen._gen_python_code..sD4$Dsz )r)"osenvironrr)rr.rHrrrrreversedrrr<r enumeraterGrr6fxrrJrrrcountrrbsearchrpr`lstripr)4rgnodesrrrrrrr/rDr$r)rrrrcrhri wrap_name wrap_stmtsrprologue lineno_map prologue_len new_linescur_idxrcounterrfn_coderKr;r rrbr'r!r"r#rr rrUrPrgr rRrmrrQrs4` `````` @@@@@@@@@@@@@@@@@@@@@r-_gen_python_codezCodeGen._gen_python_codexs8 " #%') 02d'_BJJNN;QSV,W[^,^'_BJJNN;QSV,W[^,^ # C 0/446 "ND(1c tS ! " +# +>!)*   #8, (&!'*%k2 &$Z0 ( '3 '3 '0 &uXs]3 &T#x-=P &UX &/157 A4 A A UO HD DIID E DKK!F G H " "2 AT A, ;H ; ;Q HTQ HQ HQ Hf!' 'GAt)$/ KK+aS+ , dO  & ' t9> KK ! { a "6588==9I#UykD6$<#UVJJ  ! !))$/D224 $KD% tU # $??9.Ea.HI02 ~~d+a/ ! GGDM''- 'Dii 3T:G7==+7gmmA./L89  &  'yy#**40yyD4::d3CDD       '8DDC$VsPN)r%r&r'rhrr)rrrrrrrrrZrrrr+r,r-rrFs) ZDI Z ZPS Z-8-- C C ssDsCx$9eTYkpPE"%PE2<PEPE/3PEMQPEdhPE PEr,rcXeZdZdeffd ZdedefdZdedefdZfdZfd Z xZ S) _PyTreeCodeGen pytree_infoc0t|||_yr1)superrhr)rgrr3s r-rhz_PyTreeCodeGen.__init__s (3r,inputsr;c*tj|}|Sr1)r9arg_tree_leaves)rgr flat_argss r-rz_PyTreeCodeGen.process_inputss**F3 r,outc|j|jj|St|ttfs|g}|jjJt j ||jjSr1)rrr,r5r-r9tree_unflattenrgrs r-rz_PyTreeCodeGen.process_outputssp    #t'7'7'@'@'HJ#e}-%C((444$$S$*:*:*C*CDDr,c D|jt | ||S|jj}t |dkDr|ddk(nd}|r|j ddt | |dd|}t |dkDr|jj jtk(xr|jj jdk(xrj|jj jdjtk(xr4|jj jdjtk(}d}ddj|d }|r|jj jdj} |jjd| }d djd t|jj jdj|jj| dDzd z}d dj|d|d}|D cgc]} | jdd} } |D cgc] } d| vs| dz} } t | dkDr|ddj| zdzz }|ddj| d|dz }|Scc} wcc} w)NrrgFrlrz{}rrz], self._in_spec{c32K|]\}}d|d|yw)'z':Nr+)r@rFrGs r-rBz,_PyTreeCodeGen.gen_fn_def..s&,LTQas"QCL,Lrl}z([z], z), self._in_specrz;  rErz , = fx_pytree.tree_flatten_spec(r)rrrrrrrrr- num_childrenchildren_specsdictrJzipcontextr)rgrrfn_args has_orig_self fn_definitionhas_args_kwargs_tuple fn_kwargs fn_signature count_argsr:without_annotationhas_annotationr3s r-rz_PyTreeCodeGen.gen_fn_defs    #7%i1HI I"",,25g,2Bv-    Q '*71:7NO y>A $($4$4$<$<$A$AU$J%H  ((55:%H  ((77:??5H%H  ((77:??4G "Ityy122BCL$!--55DDQGTT **44[jA$)),LS"&"2"2":":"I"I!"L"T"T"&"2"2"<""Q&BGGN,C!Cd!JJ " YY!"##CL>QRV VM "FFsJ J Jc|jr%|jjrdt|dSt||S)Nzreturn pytree.tree_unflatten(z, self._out_spec))rrrrr)rgrr3s r-rz_PyTreeCodeGen.generate_outputs@    0 0 9 924 3D2EEVW W7*;7 7r,) r%r&r'rrhrrrrr __classcell__)r3s@r-rrsH4K4ccE3E3E3j88r,rczeZdZdZdZdeeeeffdZ de fdZ de ddfdZ de ddfd Zdd d ed ed fdZy)_FindNodesLookupTablezH Side table for the graph for the purpose of doing fast queries c,tt|_yr1)rrtablerfs r-rhz_FindNodesLookupTable.__init__!sKVW[K\ r,r;cV|j|jdk(r |jfSdfSNrwr]rrgrUs r-_keyz_FindNodesLookupTable._key$s(?(BMMMMr,cB||j|j|vSr1rrrs r- __contains__z"_FindNodesLookupTable.__contains__'stzz$))D/222r,rUNcFd|j|j||<yr1rrs r-rz_FindNodesLookupTable.insert*s,0 499T?#D)r,c^|j|j|j|yr1)rrpoprs r-rxz_FindNodesLookupTable.remove-s! 499T?#''-r,)rr]rrc<|dk(r,|Jt|j||fjS|(t|j|dfjS|j|dfjDcgc]}|j|k(s|c}Scc}wr)rrr_r)rgr]rrUs r- find_nodesz _FindNodesLookupTable.find_nodes0s  % %% B<01668 8 > B:./446 6"&RJ!7!X$++QWBWXXXs =BB)r%r&r'r(rhrr)rrrrrrrrxrr+r,r-rrs~]NE#x'7"78N3D3141D1.4.D.CG Y YXh-? Yr,rceZdZdZed dNdeddeedd eeee ffd Z e d Z e jd edfd Z e defdZedddddededdefdZeddOdddeeefddfdZdPdQdZed dRdedddeeddeeedfd eed!ee defd"Zedd#Zedd$Zedd%eddfd&ZeddPd'eefd(ZeddPd'eefd)Zeddej:j<fd ed!ee d*e defd+ZeddPd,ed!ee defd-Z ed dNd.edeeddeeedfd!ee def d/Z!ed dNd0edeeddeeedfd!ee def d1Z"ed dNd2e#d3e fdeeddeeedfd!ee def d4Z$edd5fd6ed7e#egdfdefd8Z%eddPd9dd!ee fd:Z&de'defd;Z(edddddd<d=ed>ed?ed@edAede)f dBZ*ddddd<d=edCe+d>ed?ed@edAede)fdDZ,defdEZ-eddFZ.eddGZ/eddPdHee#egeffdIZ0eddJe1fdKZ2eddLe#ee3ge3ffdMZ4y)Sra] ``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_extrasct|ddddi|_i|_|jj|_d|_t |_||_||_ ||_ t|_ i|_ t|_y)z+ Construct an empty Graph. rErootr+rN)rrr_prependrrrZ_graph_namespace_owning_module _tracer_cls_tracer_extrasr_codegen _co_fieldsr_find_nodes_lookup_table)rgrrrs r-rhzGraph.__init__hsw !r62r2> ,.zz))  * +%+  +-(=(?%r,c|jSr1rrfs r-rzGraph.owning_modulezs"""r,modc||_yr1r)rgrs r-rzGraph.owning_module~s !r,r;ct|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. )rrfs r-rz Graph.nodess$r,F)rsortr]rrrcZ|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: Iteratable of nodes with the requested op and target. r)rrsorted)rgr]rr node_lists r-rzGraph.find_nodess3&11<<6<R )$ $r,gval_mapzOptional[Argument]c|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. rZrc|Sr1r+rLrs r-rVz"Graph.graph_copy..s WQZr,c|Sr1r+rs r-rVz"Graph.graph_copy..s GAJr,N)rr]rr node_copy)rgrrreturn_output_noderUrvs ` r- graph_copyzGraph.graph_copysp$GG HDwww("TYYq\+?@!3rC"dC NN41FGGDM  Hr,c`|r|ni}t|j}|j||d}tj|j |_t |tsJ|\}}|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. )rT)rrrN type_expr) rrrcopydeepcopyrr,r-rZrQr)rgmemor output_vals output_valold_output_nodenew_output_nodes r- __deepcopy__zGraph.__deepcopy__st T-- .ll4$lO ]]4==1 +u---&1# O((:RXZ^9_(`#yy)=)=>r,r)r.r<rr/rc P|dvsJ|dn|}|in|}t|tsJdt|tsJd||n|j|}|jj |d}t |||||||}|j:t|jdd#|jjD] } | | |jj|||j||jj||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. )rwrvr}r|rYrZNr+zargs must be a tuplezkwargs must be a dict_create_node_hooksr)r,r-r_target_to_strrrvrrrQr rzrrrr) rgr]rrr<r/rrirLr(s r- create_nodezGraph.create_nodes'>iiii\rt~6$&>(>>&&$'@)@@' ,D$2E2Ef2M $$00DA tRvy A    )gd6H6HJ^`d.e.q'':: !  55dA> Q %%,,Q/ Q r,c4|jj|S)zL Processes args so that they can be passed to the FX graph. )rrrs r-rzGraph.process_inputs s ,t}}++T22r,c8|jj|Sr1)rrrs r-rzGraph.process_outputss}},,S11r,to_erasec t|jdkDr2td|dt|jd|jd|j|k7rtd|d|jrt j d|d y |j:t|jd d #|jjD] }|| |jj||jd |_|xjd zc_ t|jd}t!|t"sJ||_t|j$d}t!|t&sJ||_y )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_hooksTrcyr1r+rLs r-rVz"Graph.erase_node..4r,cyr1r+rs r-rVz"Graph.erase_node..7rr,)rr^ RuntimeErrorr_erasedwarningswarnrrQrrrx_remove_from_listrrrr,r-r<r)rgrr(new_args new_kwargss r- erase_nodezGraph.erase_nodesg x~~  "!5hZ?QRUV^VdVdReQfg66>nn5EQ HI I >>T !!6xj@RST T    MMKz1LM N     )gd6H6HJ]_c.d.p''99 (   %%,,X6""$ Q 8==.9(E***  X__n= *d+++$r,rLc||j|jS|j|k(sJdt||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__``. z&Node to insert before is not in graph.)inserting_afterrrrrrgrLs r-inserting_beforezGraph.inserting_before;sE& 9'' 3 3ww$H HHD!)),,r,c||j|jS|j|k(sJdt||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__``. z%Node to insert after is not in graph.)r!rrrrGr s r-rzGraph.inserting_afterSsE& 9((4 4ww$G GGD!((++r, default_valuecn|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``. r+rY)rr)inspect Signatureemptyr )rgr/rr#rs r-rYzGraph.placeholderks;4#g&7&7&=&==rMCS t$)TTr,r8cdtjjdtdtfd}|j r*||j |st jdd|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``. rr8r;c|jd\}}} |j|}t ||syt ||}t|tjjs3t|tjjs||jvryy#t$rtjd|dYywxYw)NrPzFailed to fetch module rFT) rpartition get_submoduleAttributeErrorrrrrQr,r6rSModule Parameter_buffers)rr8 module_pathrDr/submodress r-_get_attr_reference_existsz2Graph.get_attr.._get_attr_reference_existss#1#<#,>?FOO3"  7 }AFG sB"B>=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 bufferrl) stacklevelr}r) r6rSr-r)rrrrr )rgr8rr3s r-r}zGraph.get_attrsp2 EHHOO S UY *   .t/A/A>R MM-:; < NiPPr,rUc|jr0|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)rr+rrr )rgrUrr<rs r-r|zGraph.call_modulesUH   ""00=E MM0 1  {D&T]^^r, method_namec.|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`. rvrr )rgr6rr<rs r-rvzGraph.call_methods"B {D&T]^^r, the_function.c.|jd||||S)a 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. 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`. rwrr8)rgr9rr<rs r-rwzGraph.call_functions"BtVW`aar,c|Sr1r+r@s r-rVzGraph.7s\]r,rU arg_transformcjt|j|}t|j|}t|tsJt|t sJ|j |j|j|||j|j}tj|j|_ |S)ay 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``. ) rrr<r,r-rr r]rr/rrr)rgrUr<rr< result_nodes r-rzGraph.node_copy6s.tyy-0m4$&&&&$'''&&tww T6499VZV_V_` 99TYY/ r,resultc.|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``. rZ)r]rrrr8)rgr?rs r-rZz Graph.outputUs!&8HF9Xabbr,ct|r |j}n$t|tsJ|}t |r|dd}t |}|S)Nrl)rr%r,r)rArN)rgrr]s r-r zGraph._target_to_strjsH F Bfc* **B}"X _ r,rrrrrrc tdtffd tdtffd }||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. rLc<j|j|Sr1)rvr/)rLrs r- node_reprz$Graph.python_code..node_reprs((3 3r,rc3Ki}|jD]}|j||<|_ d|jD] }|||_y#|jD] }|||_wxYwwr1)r_repr_fn)r orig_repr_fnsrUrEs r-override_node_reprz-Graph.python_code..override_node_reprs~M  *&*mm d# )  * 8 "KK8D$1$$7DM8EKK8D$1$$7DM8s*A.AA.A++A.rN)rZrrr _python_code) rgrrrrrrIrrEs @@r- python_codezGraph.python_codeusuNL  4 4  8e 8  8  % $$Y~gn%   s AA rc Z|jj|j||||||S)Nr)rrr)rgrrrrrrs r-rJzGraph._python_codes5}}-- JJ YN>cj.  r,cg}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 rErzgraph(rrrr)r format_noderJ)rgplaceholder_namesmaybe_return_typenamerU node_strs param_strrBnode_strs r-__str__z Graph.__str__s )+.0DEIZZPTT%%&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) rV ImportErrorprintrr]r/rrr<)rgrVrL node_specss r- print_tabularzGraph.print_tabulars  ) $zz+ttQVVQXXqvvqxx@+ + hzDF G  > ?    +sA.AB.Bc f d#dtdttddf fd t}t jD] jdvrt d d jd  j urt d d  jvrt d d t j fd t j fd j  j|vrt d jd |j jjrsd}d}jD]< jdk(rQt jst!d d jdt#j$ jdt' jt(s\}}t/||d}dj1|d|} |!t d d jd|d|  jdk(rFt'|t"j2j4s"t d d jd|d| d  jdk(rt'|t"j2j4sjt'|t"j2j6sF||j8vr8||kr,t;j<d d jd|d| d |d z }=|}A?||kDrt;j<d!||z d"yyy)$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 NrrLr;c|rd|dnd}|jurtd|d|d|vrtd|d|dy)Nz of Node 'z' r~z 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)rrL context_str seen_valuesrgs r- check_argzGraph.lint..check_args23Ks#.Kyy$"[R }Eddhci$kll+%"[R }Eoosnt$vww&r,)rYrvr|rwr}rZzNode z had unknown opcode rzNode 'z ' does not belong to this Graph!z ' is not added to the side tablec|Sr1r+rrarUs r-rVzGraph.lint..s9S$+?r,c|Sr1r+rcs r-rVzGraph.lint.. sYsD-Ar,zNode redefined name rrwz target z has type z but a Callable is expectedz but a str is expected)r}r|rPz" references nonexistent attribute z of r|r~z 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 referencesr1)rrr]rr]rrrrrr<rrr/rrr ValueErrorr6rr,r)rrrQrJrSr-r.r/rr) rg seen_names num_warnings MAX_WARNINGS target_atomsm_itrratom new_m_itr seen_qualnamerarUr`s ` @@@r-lintz Graph.lints wD whtn w w!$ "%% JJ &Dwwrr"U4&0DTWWIQ#OPPzz%"WTF2S#TUU4888"VD61Q#RSS DII? @ DKK!A B OOD !yyJ&"%9$))A#FGG NN499 % &   LL # .77o-#DKK0(5ht{{m:V[VdVdeiepepVqUrsB*BCC&dkk37(5ht{{m:V[VdVdeiepepVqUrs=*=>>7799#';;#4#4S#9L ..E#,\#:.4$+E4$> (+bq1A(B $,".tfHT[[MQs26tM?0L#MM GG}4(29ehhoo(N".tfHT[[MQRSWRXX\]j\klL0L#MM"gg3&0EHHOO&L&0EHH?;;+O r,is_impure_nodec|jfd}d}t|jD]7}||r t|jdk(s%|j |d}9|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. c8|S|jSr1) is_impure)rUrps r-has_side_effectz2Graph.eliminate_dead_code..has_side_effectms!)%d++>># #r,FrT)rorrrr^r)rgrprtchangedrUs ` r-eliminate_dead_codezGraph.eliminate_dead_code>sbZ  $TZZ( D"4(S_-A%  r,codegenc||_yr1)r)rgrws r- set_codegenzGraph.set_codegen}s  r,make_transformercjj|j_tjfd}|S)aa 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_wxYwwr1)rr)on_gen_code_oldrgsr- on_generate_code_context_managerz@Graph.on_generate_code..on_generate_code_context_managers( B2A // /s11.1)rr contextlibr)rgrzr~r}s` @r-on_generate_codezGraph.on_generate_codesKT--99*:?*K '  " " B # B 011r,)NNN)Fr1)r;r)NNNN)5r%r&r'r(r rrrr)rrhpropertyrsetterrrrrrrrrr rrrr!rr%r&r'rYr}r|rvrrwrrZrr rrKrZrJrTr\rorvrryTransformCodeFuncrr+r,r-rr;sD)V$/mq;?@h}&=@RZ[_`h[iRj@ (c3h 8@0@"##"-!8""  z    %0BFUYXh-?d1.$/WT4Z0@_s04$$/=A>B*./3 1c181"5#9:1$T#z/%:;1#3-1 (} 19= 101f%0313 %0212$/"%D"%T"%0"%H$/-(4.-0-.$/,$,0,.$/@D*1*;*;*A*AUU U$'UFJU0U8$/8Qs8Qx}8QPT8Q08Qt$/>B>B/3 *_!$*_"5#9:*_%T#z/%:;*_ (} *_9= *_0*_X$/>B>B/3 _!$ _"5#9: _%T#z/%:; _ (} _9= _0 _D$/@D@D15 b$,S#X$6 b$U?%;< b'tCO'<= b"*# b;? b0 bD$/R]d8TFJ$?#@BS#STS21S2r,rz{} + {}z{} - {}z{} * {}z{} // {}z{} / {}z{} % {}z{} ** {}z{} << {}z{} >> {}z{} & {}z{} | {}z{} ^ {}z{}[{}]z{} @ {})rrrmmulfloordivtruedivdivrpowlshiftrshiftand_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)k collectionsrrUrrrrr r torch.utils._pytreeutilsr r9rEr8_compatibilityr torch._Cr rrtypingrrrrrrrrrrrr dataclassesrrrr1r6r|rbr~mathrr%__all__ graph_moduler_symbolic_tracer r5rr] frozensetr-rr)rr"r.r*r2r3r4rr7rrArNrXrZbfloat16float64float32float16 float8_e4m3fn float8_e5m2float8_e4m3fnuzfloat8_e5m2fnuz complex32 complex64 complex128int8int16int32int64uint8uint16uint32uint64bits16rrrrrrrrrrrrreflectable_magic_methodsrrr+r,r-rse#RR$$") xxxx!%    ,)'  $$ y 5 d3i[$s)34  Z  /1$sN*+0=3=C=c= 6A 6A%