9jldZddlZddlZddlZddlZddlmZddlmZm Z m Z m Z ddl Z ddl Z ddlmZddlmZddlmZmZmZmZmZddlmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z#m$Z$ddl%m&Z&ddl'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z7ddl8m9Z9e rddl:m;Z;ddlZ>ej~e@ZAe jje@dZDGddejZFGdde ZGdedeFdzfd ZHd!d"d#ed$eIeJefdeGfd%ZKd#edeGfd&ZLd!d"d#ed$eIeJefdeGfd'ZMd(eGdeNe4fd)ZOeGd*d+ZPeGd,d-ZQeGd.d/ZReGd0d1ZSePeQzeRzeSzZTd2edejdzfd3ZVd!d"d4e9e.deWfd5ZX dYd!d"d6ed(eGd7d8d4e9e.dzd9eWdeWfd:ZYd!d"d(eGd4e9e.de,dzfd;ZZdZ[d!d"d?d@d(eGdAe-deWf dBZ\d!d"d2edeWfdCZ]d!d"d2ed(eGde-dzfdDZ^ dZd!d"d2ed(eGdEeJdFe jjddGe0dzdHe`edIfd6edJedKead?dLdMeadzddfdNZbd!d"dOed#dPd$eIeJefdeaf dQZcd!d"d2edMeade-dzfdRZdd!d"d(eGdSe-defdTZed!d"dHe`edIfdUeNe`eFefdeNeTfdVZfGdWdXe!Zgy)[z This module contains the InvokeSubgraphHigherOrderVariable class and its supporting helpers for subgraph reuse (auto-cache) in Dynamo's invoke_subgraph higher-order operator. N) dataclass)Anycast NamedTuple TYPE_CHECKING)graph_break_hints) unimplemented)extract_tensor_metadataGUARD_VALUE_DISPATCHGuardCheckSpec SKIP_GUARDUnsupportedGuardCheckSpec)SyntheticLocalSource)VariableTracker)ConstantVariable)UserFunctionVariable)WrapHigherOrderVariable) ListVariable TupleVariable)UnspecializedNNModuleVariable)SymNodeVariableTensorVariable)GuardInvokeSubgraphReuseConditionInvokeSubgraphReuseEntrySource)NestedCompileRegionOptions) GraphModule)Proxy)_pytree) OrderedSet)Sequence)InstructionTranslator)SubgraphTracingInfohierarchical_compileceZdZdZdZdZdZy)InputTagtensorsymnodeconstantmoduleN)__name__ __module__ __qualname__TENSORSYMNODECONSTANTMODULEg/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/torch/_dynamo/variables/invoke_subgraph.pyr'r's FGH Fr4r'cteZdZUeeeefed<eedzed<dZ e ed<dZ e jdzed<y)InputFingerprintflat_vtsN arg_sourcesF has_unknowntreespec)r,r-r.listtupler'r__annotations__rr:boolr;pytreeTreeSpecr3r4r5r7r7sC5?2344ftm$$K'+Hfoo$+r4r7vtreturnct|trtjSt|trtj St|t rtjSt|trtjSy)z5Return the tag for a leaf VT, or None if unsupported.N) isinstancerr'r/rr0rr1rr2)rBs r5 classify_vtrFs["n% B ( B( )   B5 6 r4txr# fn_args_vtkwargscj|s%d}|D]}t|d}n|r t|St|||S)aBuild an InputFingerprint by flattening (args, kwargs) via pytree. Uses _make_inlined(tx, pytree.tree_flatten) to recursively flatten the argument structure into leaf VTs, classifying each leaf as tensor/symnode/constant/module. Also records the TreeSpec so that cache lookups can verify structural equivalence. Fast path: when kwargs is empty and all args are already leaf VTs (tensor/symnode/constant/module), skip the expensive pytree flatten. TF)rFbuild_fingerprint_fastbuild_fingerprint_with_pytree)rGrHrIall_leafrBs r5build_input_fingerprintrNsL  B2&   )*5 5 (Z @@r4cg}g}|D]@}t|}|J|j||f|jt|ddBt||S)zCBuild fingerprint for the common case of flat leaf args, no kwargs.Nsource)rFappendgetattrr7)rHr8r9rBtags r5rKrKsf79H')K8"ob " 72x67 8 Hk 22r4cddlm}ddlm}|j |t ||f}||t j|j|\}}|j}g} g} d} |j|D]B} t| } | | j| | fnd} '| jt| ddDt| | | |S)z=Build fingerprint via pytree flatten for nested/kwargs cases.rSourcelessBuilder _make_inlinedFNTrP)torch._dynamo.variables.builderrV(torch._dynamo.variables.higher_order_opsrXcreater<r@ tree_flattenunpack_var_sequenceas_python_constantrFrQrRr7)rGrHrIrVrX container_vt flat_list_vt treespec_vtr;r8r9r:rBrSs r5rLrLs BF$++Bj1A60JKL F b&2E2E F!"L+--/H79H')KK..r2 8"o ? OOS"I &K  72x67 8 Hk; IIr4 fingerprintc"t}g}|jD]s\}}|tjtjfvs)|j }|j |vsH|j|j |j|u|S)z8Collect deduplicated proxies from tensor/symnode leaves.) setr8r'r/r0as_proxynodeaddrQ)rbseen flat_proxiesrSrBproxys r5get_flat_proxiesrks{"uD "L''+R 8??H$4$45 5KKMEzz%$##E* + r4ceZdZUdZeed<y) LiftedUserArgzVLifted arg that came from a user argument (intermediate activation or explicit input).indexN)r,r-r.__doc__intr>r3r4r5rmrm"s ` Jr4rmceZdZUdZeed<y)LiftedCapturedSourcezRLifted arg that is a captured variable (e.g. a weight or parameter) with a Source.rPNr,r-r.rorr>r3r4r5rrrr)s \ Kr4rrcJeZdZUdZeed<eedfed<eedfdzed<y)LiftedSyntheticObjectzCLifted arg that is a TorchScriptObject with a SyntheticLocalSource.ctor_fn. ctor_argsNctor_arg_sources)r,r-r.rorr>r=r3r4r5ruru0s+M LS#XCHo,,r4ruceZdZUdZeed<y)LiftedBoundSymbolaLifted arg that is a SymInt already bound as a graph input. SymInt graph inputs are created during tensor wrapping (not through VariableBuilder.wrap_symint), so they aren't registered in unspec_variable_map or variable_tracker_cache. Using LiftedCapturedSource for these would resolve the source to a concrete Python int via source.get_value() instead of reusing the existing symbolic proxy. exprNrsr3r4r5rzrz9s Ir4rzfn_varct|tr|jjSt|tr*|j j jjSyN)rEr get_function__code__rvalueforward__func__)r|s r5 get_fn_coderLsP&./""$--- F9 : LL ) ) 2 2  r4traced_sourcesc||jjj|z}|rtj d|yy)aCheck if any source accessed by the subgraph has been mutated. SideEffects.mutated_sources records the exact AttrSource for every store_attr call. A simple set intersection with traced_sources tells us whether any source the subgraph read was later written to. z.subgraph_reuse: mutated sources detected -- %sTF)output side_effectsmutated_sourceshc_logdebug)rGroverlaps r5has_mutated_varsrVs;ii$$44~EG <   r4body_r tracing_infor$has_reuse_hash_fnch|sc|jHddjtj|jz}tj d|y|r t ||ryt|trnt|ttfrU|jDcgc]'}t|tst|j)}}|rAtj d|ytj dt|jy|jrtj dyycc}w) uABest-effort check for whether a traced subgraph result can be reused. It is possible that a subgraph is morally reusable but does not fall into the limited support that Dynamo has today. Current limitations: - The subgraph must not have side effects. - No sourceful variable accessed by the subgraph may have been mutated, because guards are snapshotted on source values at trace time — if the underlying object changed since then, the cached guards would silently evaluate against stale values. - Output must be a single tensor, or a tuple/list of plain tensors. - All flattened inputs must be one of: tensor, symnode, constant, unspecialized NN module — for sourceless or other input types we rely on the treespec and tags for structural matching, so only types with well-defined comparison semantics are supported. When ``has_reuse_hash_fn`` is True, side-effect and mutation checks are skipped because the hash key replaces guards — there are no guards to go stale from mutations.  z;subgraph_reuse: not eligible -- subgraph has side effects%sFzDsubgraph_reuse: not eligible -- output contains non-tensor types: %szJsubgraph_reuse: not eligible -- output type %s is not tensor or tuple/listz:subgraph_reuse: not eligible -- unsupported input VT typesT)side_effect_stackjoin traceback format_listrrrrErrritemstyper,r:) rGrrbrrr stack_msgitem non_tensors r5is_reuse_eligiblerjs6   ) ) 5rww%%l&D&DE I LLM  .r>B&.) F]L9 :  dN3 J     LLV  X L ! !  H  1 s,D/c ddlm}g}|jD]\}}|tjk(rt |t sJ|jjjjdd}|tjdy|jtjt|f|tjk(r>t |t sJ|jtj|j"f|tj$k(r?t |t&sJ|jtj$|j(fC|tj*k(r#|jtj*dfyt-d|dt/|j0dt3|}|j5d |j6Dt3} |D]6} | j5|j8j:j=| 8g} | D]} | j>} | jA} tCj| }|tDur=|t |tFrtId | d | jJd  |j8jM| }tQtR|}|jU| |}| j| ||| ftjdtW| ||| |jX|S#tN$rtId | jJd| ddwxYw)aBuild an InvokeSubgraphReuseCondition from a traced subgraph. A reuse condition is a mix of two kinds of checks: 1. **Input tag checks** (from flat_vts): For each flattened leaf VT, we record its tag (_VtTag.TENSOR/SYMNODE/CONSTANT/MODULE) and metadata (e.g. tensor shape/stride/dtype/device/requires_grad). At lookup time, the treespec ensures structural equivalence, and then we compare tags and metadata leaf-by-leaf. 2. **Guard checks** (from traced_sources): During the subgraph trace, every source accessed via VariableBuilder is recorded. We look up all guards installed on those sources (and on the arg_sources) to build the set of guards that must be re-evaluated on cache hit. This is more robust than guard diffing because it catches guards that were already installed before the subgraph trace began. Raise if any guard type is unsupported, as a feedback for compiler developers to support that guard type. r)r example_valueNzKsubgraph_reuse: cannot build condition -- tensor input has no example_valuezUnexpected input tag 'z' for z/ -- is_reuse_eligible should have rejected thisc3&K|] }|| ywr~r3).0ss r5 z(build_reuse_condition..sKQQ]qKsz(subgraph_reuse: unsupported guard type 'z ' on source ''z*subgraph_reuse: failed to resolve source 'z guardzNumber of guards %s) input_checksguardsr;r)- torch._guardsrr8r'r/rErrjrfmetagetrrrQr r0rsym_numr1rrr2AssertionErrorrr,rdupdater9rrget_guards_for_sourceoriginating_sourcecreate_fn_namer r r RuntimeErrornameresolve_source_value Exceptionrr get_metadata_fnlenr;)rGrbrrrrSrBexample all_sourcesall_relevant_guardsrP guard_tuplesguardtype_strhandlerrexpecteds r5build_reuse_conditionrs2;24L''R (// !b.1 11hhmm((,,_dCG a   2I'2R S T H$$ $b/2 22   !1!12:: > ? H%% %b"23 33   !2!2BHH = > HOO #   $ 7 8 (VDH4E4E3FG>? /<n%KK+"9"9KK&)eS""299#3#3#I#I&#QRSHJL$@))'')&**84 j  ?j2KL:8*MRXR]R]Q^^_`  II226:E~w/**5%8VWh>?7@: LL&L(9: '!%%%  ! tjdt|jt|j yt t|j|j D]\}\\}}\}}||k7rtjd|||y|tjk(rt|tsJ|jjjjdd} | tjd|yt!| } | |k7stjd|y|tj"k(r#t|t$sJ|j&|usy|tj(k(st|t*sJ|j,|k7s5|t|j.kr|j.|nd} |t|j.kr|j.|nd} | | yt1|j.|j.d t2d t2ffd rt5fd |j6D} n |j6} t9|| rysy |j:j<j>|j:j<j@d}i}i}|jBD]\}}}}|jE}||k(r |jG|||}|jU||rFtjd|jK||jL|||jNr/djQ|jNjSydyy #tH$rjtjd|jK||jL|jNr)djQ|jNjSndYywxYw)uCheck if a cached subgraph can be reused for the current call. Three-phase check: (1) Verify that intermediates (tensor metadata, symnode types, constant values) match the cached input_checks — these are lightweight structural comparisons that don't require source resolution. (2) Check for mutations on the remapped traced_sources — if any source the subgraph read has been mutated since the original trace, the cached guards would evaluate against stale values. (3) Build a source replacement mapping (old sources → new sources) and re-evaluate the snapshotted guards under the new sources. Nz1subgraph_reuse: reuse failed -- treespec mismatchFzMsubgraph_reuse: reuse failed -- input count mismatch: cached %d vs current %dzRsubgraph_reuse: reuse failed -- input %d tag mismatch: cached '%s' vs current '%s'rzDsubgraph_reuse: reuse failed -- input %d tensor has no example_valuezAsubgraph_reuse: reuse failed -- input %d tensor metadata mismatchrrCc(j||Sr~rrsource_replacements r5replacement_fnz#is_reusable..replacement_fns!%%a++r4c3@K|]}|jywr~)clone)rrrs r5rzis_reusable..sX!aggn5XsTGLzsubgraph_reuse: reuse failed -- cannot resolve source guard type: %s guard source: %s guard source name: %s user stack: %srz zsubgraph_reuse: reuse failed -- guard type: %s guard source: %s guard source name: %s expected: %s got: %s user stack: %s)+r;rrrrr8 enumeraterr'r/rErrjrfrrr r0rrr1rrr9rrr!rrrroot_tx f_globalsf_localsrr get_valuerrr user_stackrformateval_fn)rGrrbri cached_tag cached_valcur_tagcur_vtrcur_meta cached_srcnew_srcremappedresolve_globalsresolve_locals resolve_cacherPrrr new_sourcerrrs @@r5 is_reusabler%s&%+*>*>)BTBT*T ?  9 ! !"c+*>*>&?? [  && '  $$ % .evaluators2t[%88r4)rrrrrrrrrrErrr?find_reuse_entry)rGr|rbrrrrs` ` r5find_reuse_matchrs 2II55LLVV // +-@ A&!G 9,95M9 9 ! 1 1'9 EEr4 body_name body_gmodconfigp_args.rmax_reuse_entriesz#InvokeSubgraphReuseCondition | Nonehash_keyc ddlm} | du| duk7sJd|jjjj t jj} t| | syt|}|yt|||j}t|t}gtjfd|t!}|Dcgc]Y}t|t j"r=|j$|j'|j(|j*|j,f[}}t/|||||||j0|}| | j3|| || y| J| j5|| || ycc}w)a<Save a traced subgraph into the reuse cache for future cache hits. Builds an InvokeSubgraphReuseEntry with the freevar mapping (how each lifted arg maps back to user inputs or captured variables), output metadata, and arg sources. On a future cache hit, stamp_out_subgraph uses this entry to emit a new invoke_subgraph call without re-tracing. Exactly one of ``condition`` or ``hash_key`` must be provided. ``condition`` stores the entry in the guard-based cache (linear scan); ``hash_key`` stores it in the hash-key cache (O(1) lookup). rrNz5Exactly one of condition or hash_key must be providedcj|jst|trj|SdSr~) is_tensorrErrQ)rBuser_output_vtss r5z"save_reuse_entry..-s/ <<>ZO<#))"- r4)rrrsubgraph_input_mappingsingle_tensor_outputoutput_metadatar9num_user_outputs)rrrrrrrrrrErbuild_subgraph_input_mappingr8rrvisitrTensorshapestridedtypedevice requires_gradrr9add_reuse_entryadd_reuse_entry_by_key)rGr|rbrrrrrrrrrrrrrr r tr rrs @r5save_reuse_entryrs22  8t#3 4? 4II55LLVV // +-@ A&!G9 FK((&fn= .0O    ?+ a & !((*aggqxxAO %51' ++) E-- Y'8 ###44 Xu&7 3s AE8 reuse_hash_fnSequence[VariableTracker]cddlm}ddlm}|jj j j5 ||||i|} dddttrt|jtstd||jS#|$r}td||d}~wwxYw#1swYixYw)uTrace the user's reuse_hash_fn to get a constant integer hash key. Guards installed during the hash function tracing are skipped — the hash key itself is the reuse condition, not the guards. r) UnsupportedrWzAreuse_hash_fn must be fully traceable without graph breaks. Got: Nz2reuse_hash_fn must return a constant integer, got ) torch._dynamo.excrtorch._dynamo.utilsrXrrguards_contextskip_guard_installrrErrrp)rGrrHrIrrXresultes r5trace_reuse_hash_fnr"Xs.1  " " 1 1 D D F 5]2}5zLVLF f. /z&,,PS7T@ I   << STUSVW  s(B5BB2B--B22B55B>cddlm}|jjjj t jj}t||syt|}|y|j||S)Nrr) rrrrrrrrrrErfind_reuse_entry_by_key)rGr|rrrrs r5r$r$vsm 2II55LLVV // +-@ A&!G 8 8( KKr4cachedc ddlm}ddlm}m}t |}|j }t|j | g}|jjj|jjjd} i} i} |jD]+} t| tr|j|| j 3t| t"rddlm} |jj(j*| j,}t|| r4|}||jj(j*| j,<|j|t| t.r| j0}| j2}|r} r{g}g}t5||D]R\}}|)|j7 fd}|j9| | | }|}|j||j|Tt;|}t;|}|jj=| j>||}|j|jAt| tBs| jD} r|j7 fd}|j9| | | }||||}|j|jA.|jFJ|jF5t;d |jHD}ddd|||jJ}||jJg|}||tLjNjPt;|i|jR}|jTrD|jV}t|dtXs Jd t[|dj\|dS|jV}|j^}|dkDr2|ta|kr$d d l1m2}|jg|t;|d|S|S#1swYxYw) aBEmit a new invoke_subgraph call by stamping out a cached subgraph. Sources in the cached entry are parameterized: they refer to the original call's sources and must be rewritten to the current call's sources via source replacement before we can look up or create the corresponding graph placeholders. r)VariableBuilder)add_call_function make_attrr) LazyProxyNc(j||Sr~rrs r5rz$stamp_out_subgraph..s:L:P:PQRTU:Vr4c(j||Sr~rrs r5rz$stamp_out_subgraph..s8J8N8NqRS8Tr4c3\K|]$\}}}}}tj|||||&yw))rrrN)r empty_strided)rrrrrreq_grads r5rz%stamp_out_subgraph..sC  7vufh   &     s*,zExpected tensor output but got rU)4rYr'rZr(r)rkr9rrrrrrrErmrQrnrztorch._dynamo.output_graphr*current_tracer bound_symbolsr{rurwrxrrrr=synthetic_graph_inputrvrerrrP fake_moder rrrrrr rrrr,r rbuilderrVr[)!rGrbr%r'r(r)rirnew_lifted_argsrrrsubgraph_inputr*rjrwrx new_ctor_argsnew_ctor_arg_sourcesvalarg_srcrrBrrr body_noder flat_variablernrVrs! @r5stamp_out_subgraphr@s@U#K0L!--O1&2D2DoVOYY   ( ( YY   ' ''O&(N')M!77(2 nm 4  " "<0D0D#E F (9 : <II,,::>;N;NOE%+NS ((66~7J7JK  " "5 ) (= >&00I->> $6 " ')$$' 3C$D9LC*")--0V"W%//+^]#*!((-(//89"-0 #()=#> 00&& 3CB  " "2;;= 1 (< ='..J!'--.TU ((.-XE0Z07B  " "2;;= 1Q(2V << ## #     ;A:P:P     "f../I)) v*F GG#HH "!r4ceZdZdZdZdZdZdZdZddde ddd e e e fd e d e d e ffd Z ddddd e e e fd e fdZxZS)!InvokeSubgraphHigherOrderVariablez&torch.ops.higher_order.invoke_subgraphFTrGr#fn_vtrHrrIr attr_namerCc t|ttfs(tdt |dgt j |jjjjtjj}t|tr5|jj}|jj } n\t|tsJ|j"j$j&j}|j"j$j } g} |r|j)|} |} t+| D]b} | |jj,vsJ|jj,| } |j.sJddlm}|| | | |j.s`| cSt4|m|||||d}t8j;d| || t=| dz|r|j?|||S) NzIEncountered non user function variable during invoke_subgraph HOP tracingz;invoke_subgraph does not support non user function variablegb_typecontext explanationhintsr)are_same_graph_modulessubgraphzZ%s: Installing subgraph with identifier '%s', bringing total count for '%s' function to %sr0) rErrr strr SUPPORTABLErrrrrrrrrr,rrrget_dynamo_installed_submodulesreversed nn_modulesr5rZrWsuper install_subgraph_in_output_graphrrradd_dynamo_installed_submodule)selfrGrOrHrIrrPrrfn_namepreviously_installed_submodules current_modsubmodule_name previous_modrWr __class__s r5r_zBInvokeSubgraphHigherOrderVariable.install_subgraph_in_output_graphKs%"?AU!VW cE Y6)556   II % % < < F F''77   e1 2((*33G((*33Ge%BC CCkk))22;;Gkk))22G*,' %EEgN ,$K#++J"K *%)=)====!yy33NC ||#|*\; *) *G< z69j   h    / 01 4   ! ! @ @) Tr4argsc ddlm}ddlm}|d}|dd}d}d} d} t |dr8 |j } t | dd}t | dd} t | d d} |jj } | r~| ||d 5t|| ||} dddt|| }|tjd| ||j t#|||}|d5t%|||cdddS| ryt'||rm|d5t#|||}t)|||}ddd@tjd||j |d5t%||cdddS|j*J|d5|j-|||||j*\}}}}}}}}dddt/dkDr%t1dd|d|dgt2j4t7|t8r|j:d<dg|dd}| rt#|||}| ?j<}t?||||d s tAdtC||||||||   n@j<}t?||||r%tE|||}|tC|||||||| | ||tFjHjJtM|||S#t$rtjd d wxYw#1swYnxYw#1swYxYw#1swYxYw#1swYxYw#1swYxYw)Nr) dynamo_timed)*_call_function_with_auto_output_flatteningr0r __marked_compile_region_config__+__marked_compile_region_max_reuse_entries__'__marked_compile_region_reuse_hash_fn__zYFailed to extract nested_compile_region() config from InvokeSubgraphHigherOrderVariable. T)exc_infoinvoke_subgraph_reuse_hash_fnz?subgraph_reuse: hash key %d hit for '%s', reusing subgraph '%s'invoke_subgraph_reuse_stamp_outinvoke_subgraph_reuse_lookupz9subgraph_reuse: cache hit for '%s', reusing subgraph '%s'invoke_subgraph_tracez"invoke_subgraph: kwargs unexpectedzargs: z , kwargs: z3kwargs should have been flattened into lifted args.rRnested_region_config)rzreuse_hash_fn was provided but the subgraph is not eligible for reuse. Check the logs with TORCH_LOGS='+hierarchical_compile' for details.)r)r)r)'rrjrZrkhasattrrrRrlogwarningrexportr"r$rrrrNr@rr _HOP_NAMEcreate_wrapped_noderr r DYNAMO_BUGrErrrrrrrrrrr=)rarGrhrIrjrkr|rHrrrfnreuserr%rbmatchrp_kwargsrrrrbody_graph_output_vtsrrrs r5_call_functionz0InvokeSubgraphHigherOrderVariable._call_functions& 5 a!"X  6> * ((* %GN$+Eq%!!(A4! II$$$ ].=> V.r=*fU V-RBF! U$$  6b*fM !"CDG-b+vFGG (V4<= 5b*fM (   OOO ""CDF-b+uEFF~~))) 1 2 Y((VZX % Y x=1  < j9Q&11   f8 95;INN1 2 1I  ABZ  1"j&IK(!-!!6#&!I !,("'%%""")-&/ :   # # 3 3 &M    !  S  o!   V VGG  FF Y YsG7KK?! L L L& )L3"K<?L  LL#&L03L=)r,r-r.rz_ALLOW_FALLBACK_TO_EAGERsupports_input_mutationsupports_aliasingallow_side_effectsfilter_aliased_intermediatesrdictrYrr_r __classcell__)rgs@r5rNrN?s8I$"$( F #FF0 F S/)* F  FF FPm #m *m S/)* m  m r4rN)NF)rlNN)hroenumloggingrtypes dataclassesrtypingrrrrrtorch._higher_order_ops torch._dynamorrr torch._dynamo.guardsr r r r rtorch._dynamo.sourcertorch._dynamo.variables.baser torch._dynamo.variables.constantr!torch._dynamo.variables.functionsrrZrtorch._dynamo.variables.listsrr!torch._dynamo.variables.nn_modulertorch._dynamo.variables.tensorrrrrrrr'torch._higher_order_ops.invoke_subgraphrtorch.fx.graph_modulertorch.fx.proxyr torch.utilsr r@torch.utils._ordered_setr!collections.abcr"torch._dynamo.symbolic_convertr#r$ getLoggerr,rw_logginggetArtifactLoggerrEnumr'r7rFrrYrNrKrLr<rkrmrrrurzLiftedArgOriginCodeTyperr?rrrrrrrfxr=rprr"r$r@r rNr3r4r5rsC   !77 ++68=BLEKJ O- )/(DLg!  ) )(4J Kltyy,z, C HtO AAA cNA A8 3s 3/? 3JJJ cNJ JB "2 tE{        -- -     ((+@@CTT  5v& 215# DD D"D( D v&- D  D DNee!ev&e"D( eP &4-( &4-(  &&. gg-g"g+ g  gT Y Y  Y  Y FF F"F$ FJ7;[ [ [ "[  [ xx## [ ' - [  #s(O[  [ [ [ 5[ Dj[  [ |, o% &   <LL LL$ L$ss!s %s sl>">" #s(O>"5?234>" / >"BA (?A r4