ɯwgddlZddlmZmZddlmZmZddlmZm Z m Z m Z m Z m Z mZddlmZddlZddlZddlmZddlmcmZddlZddlmZddlmZmZddlmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&dd l'm(Z(dd l)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ejdjge4dZ5ddl6m7Z7ddl8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHddlImJZJmKZKmLZLmMZMmNZNddlOmPZPmQZQmRZRddlSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_ddl`maZambZbddlcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqddlrmsZsmtZtmuZumvZvmwZwddlxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZddlmZmZmZmZmZmZmZmZmZmZmZmZddlmZeZej ZiZe d e eZd!e ed"edd#e+d$e e/d%ef d&Zd!e ed"edd%ee+e e/ffd'Zd(ed"edd#e+d$e e/d%ee eqff d)Zd(ed"edd#e+d$e e/d%ee eqff d*Zdeddd+dfd+d,d-d.e d/e d0e e d1e d2e e d3ed4ed5e e d%e fd6Zd7ej6d%ej6fd8Zdedd+ddfd7ej6d/e d0e e d1e d2e e d5e e d9e e(d%ej6fd:Zddd+ddd;d7ej6d2e e ded?e ed%eej<j>eiffd@ZdddAdBe df dCZddd+d+dddDdBe d3ed2e e dEed>ed?e ed%eej<j>eqejDejDffdFZed7ej(j6fdGZeZeZy)HN)contextmanager nullcontext)partialwraps)AnyCallableDictListNewTypeOptionalTuple)patch)Tensor)PhiloxStateTrackerrng_decompositions)enable_python_dispatcher)compiled_autograd) dynamo_timedpreserve_rng_state)detect_fake_mode) BoxedBool) FakeTensorFakeTensorMode)make_fx)ShapeEnv)is_traceable_wrapper_subclasscudagraph_static_inputs)config)AOTAutogradCacheautograd_cache_key)*run_functionalized_fw_and_collect_metadata) "_check_if_mutation_can_be_in_graph&are_all_mutations_hidden_from_autograd1are_all_mutations_under_no_grad_or_inference_modeassert_functional_graphfrom_fungen_alias_from_basehas_data_mutationhas_metadata_mutationis_funsync_functional_tensorto_fun)"_tensors_definitely_do_not_overlapcompute_overlapping_inputscreate_graph_signaturecreate_synthetic_base_metadataremove_dupe_metadata)aot_dispatch_autogradaot_dispatch_baseaot_dispatch_export) callback_setdescribe_inputformat_guard_bug_msgget_aot_compilation_contextget_aot_graph_nameget_graph_being_compiledgraph_being_compiled model_name nth_graphset_model_name#setup_stacktrace_preservation_hookstrack_graph_compiling)AOTDedupeWrapperAOTSyntheticBaseWrapper) AOTConfigBackwardSignatureFQNGraphInputNameGraphOutputNameGraphSignatureInputAliasInfo MutationTypeOutputAliasInfo OutputTypeSubclassCreationMeta SubclassMeta TensorAliasViewAndMutationMeta)create_metadata_for_subclassrequires_subclass_dispatchunwrap_tensor_subclasseswrap_tensor_subclasses"wrap_tensor_subclasses_maybe_joint)aot_dispatch_subclasscreate_functional_callcreate_functionalized_fn%create_functionalized_rng_ops_wrapper create_jointfn_input_mutations_to_outputsfn_prepped_for_autograd) _get_autocast_states_get_symint_hintscall_func_at_runtime_with_argscreate_tree_flattened_fn KNOWN_TYPESmake_boxed_compilermake_boxed_funcmaybe_to_fresh_inputnormalize_as_listpartial_flatten_asdict%root_module_when_exporting_non_strict strict_zip)default_partitionFakifiedFlatArgs flat_args aot_config fake_mode shape_envreturnc 5fd}tt|Dcgc]\}}|||c}}cdddScc}}w#1swYyxYw)Nc Sddlm}ttr= jrS|d|} j j ||Sttjr*tjjj SttjsSttrj usJStr@j!\}}t#fd|Drt# fd|DsJSd}d}d}tj$j&j)x}r+|j*vr|j*}|j,}d}| j.kr%t0j2r|s j5d S j5d||| S) Nr)ConstantSourcesym_)hintsourcec3RK|]}tt|t ywN) isinstancegetattrr).0attrxs b/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/torch/_functorch/aot_autograd.py z2process_inputs..convert..sRDz'!T"2J?Rs$'c3NK|]}t|juywrx)rzrn)r{r|rnr}s r~rz2process_inputs..convert..s(DH4(22i?s"%TF) static_shapes)rsymbolic_contextrvtrace)torch._dynamo.sourcersryint is_exportcreate_symintnode create_symboltorch ScriptObject_libraryfake_class_registrymaybe_to_fake_objrrrnr__tensor_flatten__all_guardsTracingContexttry_gettensor_to_context tensor_sourcenum_params_buffersrstatic_weight_shapes from_tensor) idxr}rsrvattrs_rrtracing_contextrmrnros ` r~convertzprocess_inputs..converts$?a%!++ +d3%L9F$66!//6:67!U//0~~99KKqa.!Z({{i///,Q///1qRERRLQH $ FE"'--">">"F"F"HHH999'6'H'H'K$-;;F"Ej333//(!,,Qd,CC((#!1 ) )rk enumerate)rlrmrnrorrr}s ``` r~process_inputsrsZ ;V7 r y?S TVS!a TUw;V;Vv!Uw;V;VsA A A A  Act|}|(|jr tnd}t|}||fS|j}||fS)N)ro)rdynamic_shapesrrro)rlrmrnros r~construct_fake_modersT!+I",";";HJ "Y7  y !!'' y !!rfake_flat_argscbtd5t|||||cdddS#1swYyxYw)Ncreate_aot_dispatcher_function)r_create_aot_dispatcher_function)flat_fnrrmrnros r~rrs5 6 7 . ^ZI    s%.cH |ji|_it|j|_tjrit|j|_| t n t }tjjd5t5|5|5t5tjjj5ddlmmfd}t%d|D}t 5t'dd5t)|}| t+|} n t } | 5t-||j.|j0||j2 ||dddt5|} t%fd j6D xrt%d j8D } |r| rd}| r2t-||j0d|j2|j. |nzt;j8j6j<|j0j>j@jBjDdjFj. ddddddj<dkDr< r:JddjI|D cgc]} tKtM| c} d|jNrtQj8D cgc]} | jRs| c} dk7rtUdtKtQj8D cgc]} | jVr| jXr| c} dk7rtUdtK r tUdtjr tUdd} | ||}|||||\}|fcdddcdddcdddcdddcdddcdddS#1swYxYw#1swYxYw#1swYxYwcc} wcc} wcc} w#1swYnxYwdddn #1swYnxYwdddn #1swYnxYwdddn #1swYnxYwdddn #1swYnxYwdddy#1swYyxYw)a( Traces the forward and backward graphs of the attr:`flat_fn` to generate a joint graph. The joint graph is an Fx graph with Aten ops. Please refer to the tracing mechanism to understand the graph capturing details. The joint graph is then passed through attr:`partition_fn` to isolate the forward and backward portions, which are then respectively compiled via the provided attr:`fw_compiler` and attr:`bw_compiler`. The resulting compiled forward and backward graphs are then wrapped up in a ``torch.autograd.Function`` object. The calling convention here is that the first aot_config.num_params_buffers inputs in flat_args are parameters and buffers, and the rest are inputs. We use this to assume that parameters/buffer's shapes don't change. Note: this function is used both by aot_function and aot_export (controlled by aot_config.is_export) When aot_config.is_export is True, we return an FX graph + metadata When aot_config.is_export is False, we return an ordinary runtime function NFr)FakeScriptObjectrc~|Dcgc],}t|rt||jn|.c}Scc}wrx)ryrreal_obj)rargrrs r~_dup_fake_script_objz=_create_aot_dispatcher_function.._dup_fake_script_objYsM * c#34""2>"BCLLQ s1:c3VK|]!}t|ts|j#ywrx)ryr requires_gradr{r}s r~rz2_create_aot_dispatcher_function..as" !z!V7LAOO s))ztorch.cuda.set_rng_statecyrx)argss r~z1_create_aot_dispatcher_function..hsr)static_input_indiceskeep_input_mutationsis_train pre_dispatchc3K|]d}|jxrR|jtjtjfvxr#j |j j fywrx)r output_typerMalias_of_inputis_input input_infobase_idx)r{r} fw_metadatas r~rz2_create_aot_dispatcher_function..{so 3OO   &55z7J7JKLM'221::>LL  3sA*A-c3K|]<}|jxr*|jxr|j xr |j >ywrx)r mutates_data)mutations_under_no_grad_or_inference_modemutations_hidden_from_autogradrs r~rz2_create_aot_dispatcher_function..sS  OO==GGG=<<<=sAA)rrrr) r output_infonum_intermediate_basesrtraced_tangentssubclass_inp_metasubclass_fw_graph_out_metasubclass_tangent_metartokensrzCtorch.compile is currently being used with tensor subclass inputs: ,z. We are attempting to a compile a graph with two graph outputs that alias one another, which is currently unsupported in the subclass use case. If you run into this, please file a github issuezFound an input that received a metadata mutation, through e.g. a call to `.resize_()` or `.transpose_()`. This is currently banned in the aot_export workflow. If you need this functionality, please file a github issue. fw_metadata=zFound a graph input that requires gradients, and received a mutation. This is currently banned in the aot_export workflow. If you need this functionality, please file a github issue. fw_metadata=zaot_export is not currently supported with traceable tensor subclass. If you need this feature, please comment on zFunctionalized RNG is not currently supported in the aot_export workflow. Please file a github issue, or otherwise set torch._functorch.config.functionalize_rng_ops = False.cp|jrtt|S|r|jstSt S)zF Pick a dispatcher based on the config rules. )needs_autograd)rrr5rr3r4)rrms r~choose_dispatcherz:_create_aot_dispatcher_function..choose_dispatchers4##2>RR (?(?,,((r)r)-decompositionsaot_autograd_decompositionsrfunctionalize_rng_opsrrrrautogradset_multithreading_enabledrr_dynamoutils+_disable_saved_tensors_hooks_during_tracing"torch._library.fake_class_registryrranyrrh_detect_attribute_assignmentr"rkeep_inference_input_mutationsrrSrrrQrrrrrrjoinstrtyperlenmutates_metadata RuntimeErrorrr)rrrmrnropython_dispatcher_moderrmodctxreq_subclass_dispatchoutput_and_mutation_safer}r compiler_fn compiled_fnrrrs @@@r~rrsB  ($& !! %!  # #!J ##%  % ''% !'0&; "  2 2  s(s( s(  s(  s( #]]00\\^ s(   %3  & 'I 13EFF ;GD?6s;C%-C=#"L-7-L-L-7-V-V!/%/%<%< # ,N; #=K=)C"K)%03 3)44 3 0 ,, )33 )("&>&+N -'&P#1;1Z1Z%*)3)@)@1;1P1P ' * '+ ':'2'='=(3(?(?3>3U3U1;1Z1Z,7,G,G.9.K.K7B7]7]2=2S2S%*#.#5#51<1Q1Q ' uF I V  - - 1, 3 0A3tAw< 0123/ ,   {55L!9K9KALMQRR"    ""-!7!7??q~~#    "%"C++"K )( C #.   0 # $  [ K'gs(s(s(s(s(s(s(H== F F I I \ 1Ms(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s RRQ. Q *)Q +P/ >P &P28O9*DP0P8*P/ "P =-P/ *P%<P%4P/ 4!P*A-P/  Q Q  Q. R& R9P>PP PPP/ /P84Q ; Q Q  Q  Q.Q" Q.% R.Q7 3R: RR RR!FT)dynamic enable_logfn fw_compiler bw_compiler partition_fnrrrinference_compilerc ||}||}t||||||tt||ddd|  d t fd} | S)a Traces the forward and backward graph of :attr:`fn` using torch dispatch mechanism, and then compiles the generated forward and backward graphs through :attr:`fw_compiler` and :attr:`bw_compiler`. :func:`aot_function` traces the forward and backward graph ahead of time, and generates a joint forward and backward graph. :attr:`partition_fn` is then used to separate out forward and backward graphs. The partitioner function can be used to perform optimizations such as recomputation. One can set `decompositions` dictionary to decompose the operators into a sequence of core or simpler operators supported by the backend compilers. .. warning:: This API is experimental and likely to change. Args: fn (Callable): A Python function that takes one ore more arguments. Must return one or more Tensors. fw_compiler (Callable): A Python function that accepts an Fx graph with Aten ops and input args, and returns a Callable that semantically is equivalent to the input Fx graph. bw_compiler (Optional[Callable]): A Python function that accepts an Fx graph with Aten ops and input args, and returns a Callable that semantically is equivalent to the input Fx graph. Default: None (when None, it defaults to the :attr:`fw_compiler`) partition_fn (Callable): A Python function that takes a joint forward and backward graph, and partitions it into separate forward and backward graphs. decompositions (Dict): A dictionary to define the decomposition of larger Aten ops into simpler or core Aten ops. inference_compiler (Optional[Callable]): A Python function that accepts an Fx graph with Aten ops and input args, and returns a Callable that semantically is equivalent to the input Fx graph. inference_compiler is invoked if no autograd is needed. Default: None (when None, it defaults to the :attr:`fw_compiler`) Returns: Returns a ``Callable`` that retains the eager behavior of the original :attr:`fn`, but with forward and backward graph compiled via :attr:`fw_compile` and :attr:`bw_compile`. A simple example usage of :func:`aot_function` is as follows. This example will print the forward and backward graphs of the function ``fn`` >>> fn = lambda x : x.sin().cos() >>> def print_compile_fn(fx_module, args): >>> print(fx_module) >>> return fx_module >>> aot_fn = aot_function(fn, print_compile_fn) >>> x = torch.randn(4, 5, requires_grad=True) >>> aot_fn(x) NF) rrrrrraot_idrraot_autograd_arg_pos_to_sourcer no_tangentsrctj|i|} Ct||\}}t| \}}t | ||}t || ||\}} ||f \} }| |} |j | Srx)pytreearg_tree_leavesrarrr unflatten)rkwargsrlrout_specrnrorrr cached_fnoutrm cached_resrs r~returned_functionz'aot_function..returned_functionWs**D;F;    8T6 J GX%8J%O "Y /=:y)0N< NK&x0J( 8 "!!#&&r)rDnext AOT_COUNTERr) rrrrrrrrrrrrmrs ` @@r~ aot_functionrsxD! !(-!%-K 'E'+JJ 2Y''2 rrcltjjjfd}t j dt j dttz}t|g|d|i|Gfddtj}|S)a Traces the forward and backward graph of :attr:`mod` using torch dispatch tracing mechanism. It is wrapper function, that underneath uses :func:`aot_function` to perform tracing and compilation. :func:`aot_module` lifts the parameters and buffers of ``nn.Module`` as inputs to a new callable which is then compiled through :func:`aot_function`. .. warning:: This API is experimental and likely to change. Args: mod (Callable): A ``nn.Module`` module. args : args to be passed to :func:`aot_function` kwargs : kwargs to be passed to :func:`aot_function` Returns: Returns a ``nn.Module`` that retains the eager behavior of the original :attr:`mod`, but with forward and backward graph compiled. cTi||}tjj|||Srx)rfuncfunctional_call) named_params named_buffersrrparams_and_buffersrs r~rz#aot_module..functional_calls/> > >zz))#/A4PPrFremove_duplicaterc2eZdZdfd ZfdZxZS)aot_module..AOTModulec0t||_yrx)super__init__ orig_module)self __class__rs r~r z&aot_module..AOTModule.__init__s G  "D rcg|i|Srxr)rrr compiled_frrs r~forwardz%aot_module..AOTModule.forwards*  r)rpN)__name__ __module__ __qualname__r r __classcell__)rrrrrs@r~ AOTModuler s #  rr) rrr assert_no_fake_params_or_buffersdictnamed_parametersrrrnnModule) rrrrrrrrrs ` @@@r~ aot_modulerts. MM88=Q,,e,DEL**E*BCM\*S-??3EIOJ  BII  ;r cudagraphsc L itjdtjd} tj| \t t |7ttjjjj}||}||}t} g} | jtjj j#x} r| _d} t'drkg} | j)D]V}|j*vs J|dj*|}|| vsJ|| j-|| j/|X| j|g}t'drt1j2j5dD]\}}t'|d s| g} |j6}|| vsJ|| j-|| j/||r|j9n t;|}d |j<vrH|j<d j?d dr)t@jCd |||j/|t@jCd ||| t | t | k(sJd}| D],}tE|tFs|jHjJdu}ntM|||||tOtP||| |dddtS| \ tU|   fd}tjVrtYjZ||n|tEtj\j^j`rIdtbtdffd }jf|_3j|_j|_|Sdthtdffd }jf|_3j|_j|_|S)a This is the simplified or low overhead version of aot_module. For frontends like TorchDynamo, the input functions/modules to AOT are static and have unpacked inputs/outputs. This gives us an opportunity to remove the (1) pytree overhead to parse inputs/outputs, (2) AOT Autograd cache, (3) Reading of params/buffers in every forward call :func:`aot_module_simplified` removes these overheads. FrN_param_name_to_sourcez not found.graph placeholder)op_dynamo_source tensor_dict_dynamo_static_input_typez(Adding static input pos %s for source %sz%Non-static input pos %s for source %s)rrrrrrrrrrrrr cache_keyct}tj5t| \}}ddd|S#1swYSxYwrx)rXrdisabler) rrrrmrrnr params_len params_specros r~dispatch_and_compilez3aot_module_simplified..dispatch_and_compilesZ0k:N  & & ( ; NK  s AA  runtime_argsc|g}|j|j||j|Srx)extendclear)r.rlr params_flats r~ boxed_forwardz,aot_module_simplified..boxed_forward6s;I   [ )   \ *    y) )rc\g}|j|j||Srx)r0)r. full_argsrr2s r~rz&aot_module_simplified..forwardHs/ %&9%%r)5rrrr tree_flattenlistrrr _inductorrtritonrsetr0rrrr2hasattrkeysr!addappendrr" find_nodesr%namermetagetstatic_inputs_logdebugryrrnrorDrrrrenable_autograd_cacher loadrr GmWrapperr r zero_gradr )!rrrrrrrrrparams seen_sourcesr5rrr@rvrposnode source_namerr}r-r3rrmrrrnr2r+r,ros!` @@@@@@@@r~aot_module_simplifiedrNs * s##U#; < s  % 8 9F &226:K{#K[!Ju55<<GGH ! !(5LI [!--66>>@@@&1#%)"s+,)+&KKM :D3444 Jk6J J4..t4F- 5v 5-   V $ * 1 1& 9  :TsG"399#7#7=#7#IJ ICt-.19572,,\19691  (.55f=/5fkkm3v;  DII-$))M2J2N2N/3&++BC)//4%++?k' .&19~%C!DDDDN  a $[[22$>N  -!%%K 'E%'E1J /y*EIy#Iz9iPN  ##&++ #~z: +, #u}}**445  *S  *#&-- ),)=)= &&)&7&7 #&uSz& G"33G--G Nr)routput_loss_indexrrr trace_jointrOrrc6|r |r tdt|jd}t|jd} it|t| } t j | \} } t | } t| } |xsi}t|| | dd|rfd}t}n|rtntj}}g}|j| |j||5t|||| d|||\}}ddd|rfd }t||t j|i|}t!|| t#|j%t#| j%| fS#1swYzxYw) a This function takes in a module, and returns: (1) an FX graph that can be exported (2) some metadata about the graph If `trace_joint=True` we will return a joint graph of the forward + backward. The traced FX graph will have the following properties compared to the original module: (1) Inputs and outputs to the module will be pytree-flattened (2) Parameters and buffers on the module will be lifted into graph inputs, graph_inputs = (*parameters, *buffers, *user_inputs) (3) The graph will be fully functionalized (4) Any input mutations will be converted into additional outputs in the graph, meaning whoever calls this graph is responsible for applying the mutations back to the original inputs. (5) If is_joint is provided the graph will return parameter gradients in addition to user outputs. The graph output will look like: graph_outputs = (*updated_inputs, *user_outputs, *param_gradients) There are also several restrictions on what modules can use this API. In particular: (1) If trace_joint is specified, we expect the loss function to be **fused** into the module forward. One of the outputs to the forward must be a scalar loss, which is specified with `output_loss_index`. All other outputs to the forward are presumed to not require gradients. (2) This API cannot capture optimizers (although in theory we could build an API for this). (3) Metadata mutations on params/buffers/inputs are banned. (4) Data mutations on anything that requires gradients are banned (parameters) (5) If an input is mutated, it is not allowed to alias any other inputs. (6) Parameters must not be duplicated. z7pre_dispatch is not supported when trace_joint is True.FrT)store_orig_modNc|} tdt|tjr|f}t|tt fstdt |t|D])\}}|js|k7stdd|d|}t||jstdd|jdk7rtd d |j|S) NzIf trace_joint=Trueit is required that one of your forward outputs must be a scalar loss. You must specify the which (index) output is the loss with output_loss_index.zPExpected forward output to be either a tensor or a list/tuple of tensors. found auFound an output of the forward that requires gradients, that was not the scalar loss. We require all outputs to the forward that are not the scalar loss to not require gradient, because we will only compute a backward graph against the scalar loss. You can fix this by calling .detach() on each of your forward outputs that is not the loss. You specified that output index z4 is the loss, but we found that the output at index z requires gradients.zThe output at index z: was marked as the loss, but it does not require gradientsrz3We require the output marked as the loss (at index z#) to be a scalar, but it has shape ) rryrrtupler7rrrrnumelshape)rrioout_lossr num_fw_outsrOs r~ fn_to_tracez&aot_export_module..fn_to_tracesE!4(C ("Q # .fcE4=1"fgklogpfqr"# 1 ??q,='=&! "3 34C+ /  ,-Hc(K))"&''ae~~1$"44E3FFijrjxjxiy}Jr)rrrrrrct j jzDcgc]}d}} ||\}}t|t|k(sJg}t t ||D]M\}\}}t |tjr'|jr|Jd|j|J|MJg||Scc}w)NzFound a parameter that did not receive a gradient. "This is most likely a bug, but if this needs to be supported please comment on this Github issue: https://github.com/pytorch/pytorch/issues/101192 ) range num_outputsnum_mutated_inp_runtime_indicesrrzipryrrrr>) rr fake_tangentsfw_outs gradientsoutput_gradientsrWagradfx_gmetadatas r~flattened_jointz*aot_export_module..flattened_joints&((8+S+SSM "&dM!: GYy>SY. ..!  )#dI*> ? ( 9Ata.1??(( %++D1<'< (/G... .+s C)user_args_flatparams_and_buffers_flat param_names buffer_namesrPnum_user_fw_outs loss_index)rrrrrr6rTrrXrrno_gradr0_aot_export_functionrrr0r7r<)rrrrPrOrrrrrrrkr,r+r[rr5in_specrrirjrrgrhrZs ` @@@@r~aot_export_modulersVs\ TUUC00%0HI**E*BCM   } ,2+>+>?Q+R([#$;<,-J \rF, [*TOK , \*ku}}% I ,- T   ,@  ))%) - )h  & /P(w'3++T.gsC5u}}CzNaot_export_joint_simple requires individual inputs not to be pytrees. in_spec=zMaot_export_joint_simple requires outputs to be a single list/tuple. out_spec=c3<K|]}|jywrxrvrxs r~rz*aot_export_joint_simple..osD5u}}DrzzPaot_export_joint_simple requires individual outputs not to be pytrees. out_spec=)num_fwd_outputs)rrrprqchildren_specsrrrrrrrrrM non_aliasrwrr debug_assertrmrjr output_infosrr)rrrPrrrrgrhrrr _kw_in_specr} fw_module bw_modulerns r~aot_export_joint_simpler$sK8mm 6,@  )- )h '55 6 ++ T1q~~ASASQ TU  HX X  ,, V1 AUAU0UQ VW  RSVW_S`Ra b  YZ]^eZfYg h   CG,B,BC C\]`ah]i\j k  [\_`h\i[j k   DH,C,CD D^_bck_l^m n  );; $K,D,D(E <  9%T*  &(I   t   K4Kw66 U WF  Ks/#HH+=H+5"H0H0 H5H(5H?)rrrrrrrc|xsi}t|||\}} tj||f\} } |t| } | t |drt |j tjjrS|j jjD cgc]} d| jvr| jd!}} t|} | duxr| jdu}tdddd||tt d|dd|| }t#| |\} }t%| || |}t'|||| |\}}||| | j(fScc} w)N _orig_modvalFT) rrrrrrrrrrrrr)rarr6rr;ryrrfx GraphModuler"nodesrArorDrrrrrspec)rrrrrrrrrrrlrrrnrLvalsrmrorrgrAs r~rqrqsp&\rF0tVDGX,,dF^<Iw$Y/  k*4>>588+?+?@!NN0066DII% % D ).I"$.R93F3Fd3R %-K (-%'+!!J$/y*EIy#Iz9iPN/ JD$ w --Os$Ec #hKhdfd}tjd||} dgfd}tj|||||jj |r=t dkDrd\}}nd\}}t d|d d jd |d y#gfd}tj|||||jj |r=t dkDrd\}}nd\}}t d|d d jd |d wxYww) N>_buffers_modulestraining _parameters_forward_hooks_backward_hooks_state_dict_hooks_forward_pre_hooks_backward_pre_hooks_state_dict_pre_hooks_is_full_backward_hook_forward_hooks_with_kwargs_load_state_dict_pre_hooks_load_state_dict_post_hooks_non_persistent_buffers_set_forward_hooks_always_called_forward_pre_hooks_with_kwargscv|jjDcic] \}}|vs ||c}}Scc}}wrx)__dict__items)rkv STD_ATTRSs r~_get_attributesz5_detect_attribute_assignment.._get_attributess3!$!3!3!5LA)9K1LLLs 55c|Srxr)r}s r~rz._detect_attribute_assignment..src||urS|^}}t|tjr4jd|jt j |yyy)Nzself.)ryrrr>keyrkeystr)kpr_vr|restassigned_tensor_attributess r~#_collect_assigned_tensor_attributeszI_detect_attribute_assignment.._collect_assigned_tensor_attributessU{ ta..55z&--*=)>?/rr) attributeswere) attributewasz The tensor  z, z assigned during export. Such attributes must be registered as buffers using the `register_buffer` API (https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.register_buffer).)rtree_maptree_map_with_pathrupdater ValueErrorr)rrsnapshotrnounverbrrs @@r~rrsn I(M {OC,@AH  &("  !! /?3;O  H% %-.21 d/ ddV1TYY/I%J$K1TFStt  &%&("  !! /?3;O  H% %-.21 d/ ddV1TYY/I%J$K1TFStt  &s'D2B/A?D2/BD//D2) itertools contextlibrr functoolsrrtypingrrr r r r r unittest.mockrrtorch._dynamo.loggingtorch.nnrtorch.utils._pytreer_pytreertorch.utils.dlpackr$torch._decomp.decompositions_for_rngrrtorch._dispatch.pythonr torch._dynamortorch._dynamo.utilsrr torch._guardsrtorch._inductor.utilsrtorch._subclassesrr"torch.fx.experimental.proxy_tensorr%torch.fx.experimental.symbolic_shapesrtorch.utils._python_dispatchr_logginggetArtifactLoggerrrCr_aot_autograd.autograd_cacher r!'_aot_autograd.collect_metadata_analysisr"_aot_autograd.functional_utilsr#r$r%r&r'r(r)r*r+r,r-#_aot_autograd.input_output_analysisr.r/r0r1r2*_aot_autograd.jit_compile_runtime_wrappersr3r4r5_aot_autograd.logging_utilsr6r7r8r9r:r;r<r=r>r?r@rA_aot_autograd.runtime_wrappersrBrC_aot_autograd.schemasrDrErFrGrHrIrJrKrLrMrNrOrPrQ_aot_autograd.subclass_utilsrRrSrTrUrV(_aot_autograd.traced_function_transformsrWrXrYrZr[r\r]_aot_autograd.utilsr^r_r`rarbrcrdrerfrgrhri partitionersrjr`countrrrkrrrrrboolrrrrNrrrsrTreeSpecrqrcompiled_functioncompiled_modulerrr~rs2$FFF $$W;+@*+86:FNN44 '             ,ioo z!-tCy9AVCyAVAVAV! AV  AVH "Cy "&/ " >8H- -. "  $      !   8( ()  n($n(n( n( ! n(  8( () n(h'+.%)+0-1q qqq(#q q TN q  q%)q!*qqh1BII12991p'+.%)#(-1&*k kk(# k  k TN k!*k#kYYkd&* (,%) K KTN KK }KKTNK 588   /0Kl %)] ] ]]TN] XX]P %)%) #G. G. G. TN G.G.G. TN!G.$ 588  !4foov VW%G.T>ehhoo>>B!r