g^(h\ddlZddlmZmZddlmZmZddlmZm Z ddl m Z m Z m Z mZmZmZddlmZddlZddlZddlmZddlmcmZddlZddlmZddlmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*dd l+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ejrjue;dZZ>ddl?m@Z@mAZAmBZBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQddlRmSZSmTZTmUZUmVZVddlWmXZXmYZYmZZZddl[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgddlhmiZimjZjddlkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZyddlzm{Z{m|Z|m}Z}m~Z~mZddlmZmZmZmZmZmZmZdd lmZmZmZmZmZmZmZmZmZmZmZmZdd!lmZeZej0ZiZe d"ee Zed#e,$ZGd%d&eZGd'd(eZd)ee d*eld+e2d,ee6d-ef d.Zd)ee d*eld-ee2ee6ffd/Zd0ed*eld+e2d,ee6d-ee eyff d1Zd0ed*eld+e2d,ee6d-ee eyff d2Zdeddd3dfd3d4d5d6e d7e d8ee d9e d:eed;edZd?ejRd-ejRfd@Zd?ej,jRdAeedBed-eeeejXjZeeffdCZdedd3ddfd?ejRd7ed8eed9e d:eed=eedDee.d-ejRfdEZddd3dddFd?ejRd:eedGedHeedIedJeed-eej`jbeqffdKZdddLdMe dGed;ed:eed-ej`jbf dNZddd3d3dddOdMe d;ed:eedPedIedJeed-eej`jbeyejhejhffdQZed?ej,jRfdRZeZeZy)SN)KeysViewSequence)contextmanager nullcontext)partialwraps)AnyCallableNewTypeOptionalProtocolTypeVar)patch)Tensor)PhiloxStateTrackerrng_decompositions)enable_python_dispatcher)compiled_autograd)CompileEventLogger dynamo_timedpreserve_rng_stateset_feature_use)detect_fake_mode) OutputCode) BoxedBool InputType) FakeTensorFakeTensorMode)make_fx)ShapeEnv)is_traceable_wrapper_subclasscudagraph_static_inputs)config)AOTAutogradCacheautograd_cache_keyshould_use_local_autograd_cache should_use_remote_autograd_cache)*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)compute_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)requires_subclass_dispatchunwrap_tensor_subclasses1unwrap_tensor_subclasses_with_indices_to_originalwrap_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 TOutputCode)boundcReZdZdZdej j deede fdZ y)AOTDispatchCompilerz? Represents a fw or bw_compiler passed to AOTAutograd. gmexample_inputsreturncyNselfrvrws [/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/_functorch/aot_autograd.py__call__zAOTDispatchCompiler.__call__s N) __name__ __module__ __qualname____doc__torchfx GraphModulerrr rr{rr~rurus7 HH  !+   rruceZdZdZdeedeejje e geffdZ dejjde e de fdZy ) SerializableAOTDispatchCompilera) Represents an AOTDispatchCompiler that returns an OutputCode, and is therefore cacheable. SerializableAOTDispatchCompiler always return an OutputCode. A _CompileFxCallable usually gets converted into an AOTDispatchCompiler after binding all of the kwargs in _CompileFxKwargs. output_code_ty compiler_fnc ||_||_yrz)rr)r}rrs r~__init__z(SerializableAOTDispatchCompiler.__init__s -&rrvrwrxc&|j||Srz)rr|s r~rz(SerializableAOTDispatchCompiler.__call__s N33rN)rrrrtyperrr rrrrrrrrr{rr~rrsq'[)'uxx33Xi5HI;VW'4 HH 4!+4  4rr flat_args aot_config fake_mode shape_envrxc 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 ywrz) isinstancegetattrr).0attrxs r~ z2process_inputs..convert..sRDz'!T"2J?Rs$'c3NK|]}t|juywrz)rr)rrrrs r~rz2process_inputs..convert..s(DH4(22i?s"%TF) static_shapes)rsymbolic_contextrtrace)torch._dynamo.sourcerrint is_exportcreate_symintnode create_symbolr ScriptObject_libraryfake_class_registrymaybe_to_fake_objrrrr!__tensor_flatten__all_guardsTracingContexttry_gettensor_to_context tensor_sourcenum_params_buffersr$static_weight_shapes from_tensor) idxrrrattrs_rrtracing_contextrrrs ` 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 ) r)rq enumerate)rrrrrrrs ``` 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)r)rdynamic_shapesr rr)rrrrs r~construct_fake_moder&sT!+I",";";HJ "Y7  y !!'' y !!rfake_flat_argscftdd5t|||||cdddS#1swYyxYw)Ncreate_aot_dispatcher_functionT)log_pt2_compile_event)r_create_aot_dispatcher_function)flat_fnrrrrs r~rr2s7 6d S . ^ZI    s'0c |ji|_it|j|_tjrit|j|_| t n t }tjjd5t5|5|5t5tjjj5ddlmmfd}t%d|D}t 5t'dd5t)|}| t+|} n t } | 5t-||j.|j0||j2|j4 ||dddt7|} t9j:d | t%fd j<D xrt%d j>D } |r| rd}| r2t-||j0d|j2|j.|nztAj>j<jB|j0jDjFjHjJdjLj. ddddddjBdkDr< r:JddjO|D cgc]} tQtS| c} d|j4rtUj>D cgc]} | jVs| c} dk7rtYdtQtUj>D cgc]} | jZr| j\r| c} dk7rtYdtQ r tYdtjr tYdd} | ||}|||||\}|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}wrz)rrreal_obj)rargrrs r~_dup_fake_script_objz=_create_aot_dispatcher_function.._dup_fake_script_objsM * c#34""2>"BCLLQ s1:c3VK|]!}t|ts|j#ywrz)rr requires_gradrrs r~rz2_create_aot_dispatcher_function..s" !z!V7LAOO s))ztorch.cuda.set_rng_statecyrzr{)argss r~z1_create_aot_dispatcher_function..sr)static_input_indiceskeep_input_mutationsis_train pre_dispatchrbackend_compile)rXc3K|]d}|jxrR|jtjtjfvxr#j |j j fywrz)r output_typerSalias_of_inputis_input input_infobase_idx)rr fw_metadatas r~rz2_create_aot_dispatcher_function..so 3OO   &55z7J7JKLM'221::>LL  3sA*A-c3K|]<}|jxr*|jxr|j xr |j >ywrz)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.c|jr(tjddtt|S|r)|j stjddt StjddtS)zF Pick a dispatcher based on the config rules. rexport) dispatch_mode)needs_autogradautograd inference)rrtry_add_pt2_compilerr;rr9r:)rrs r~choose_dispatcherz:_create_aot_dispatcher_function..choose_dispatcherss###66%X2>RR (?(?"66%Z-,"66%[)(r)r)/decompositionsaot_autograd_decompositionsr$functionalize_rng_opsrrrrrset_multithreading_enabledrr_dynamoutils+_disable_saved_tensors_hooks_during_tracing"torch._library.fake_class_registryrranyrrn_detect_attribute_assignmentr)rkeep_inference_input_mutationsrrrXrrrrrWrrrrrrjoinstrrlenmutates_metadata RuntimeErrorrr)rrrrrpython_dispatcher_moderrmodctxreq_subclass_dispatchoutput_and_mutation_saferrr compiled_fnrrrs @@@r~rr?s0B  ($& !! %!  # #!J ##%  % ''% !'0&; "  2 2  @(@( @(  @(  @( #]]00\\^ @(   %3  & 'M 13EFJ ;GD?6s;C%-C=#"L-7-L-L-7-V-V!/%/%<%<","6"6 #,N;#=K=)C"K)%#66%BW03 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 ' }J M ^  - - 1, 3 0A3tAw< 0123/ ,   {55L!9K9KALMQRR"    ""-!7!7??q~~#    "%"C++"K  ),( C #.   0 # $  [ K'A@(@(@(@(@(@(@(H== J J M M d 1MG@(@(@(@(@(@(@(@(@(@(@(@(@(@(@(@(@(s R:R%R Q; *)Q& +Q >P5 &P(2AP5DP(P5*Q Q-Q QQ"4Q !Q 7A-Q $ Q& - Q; 6 R? R% R:P% P((P2-P55P?:Q QQ&  Q; &Q/+Q; 2 R;R R R%R R% R:%R. *R::SFT)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) r rrrrraot_idrraot_autograd_arg_pos_to_sourcer no_tangentsr ctj|i|} Ct||\}}t| \}}t | ||}t || ||\}} ||f \} }| |} |j | Srz)pytreearg_tree_leavesrgrrr unflatten)rkwargsrrout_specrrrr r cached_fnoutr cached_resr s r~returned_functionz'aot_function..returned_functions**D;F;    8T6 J GX%8J%O "Y /=:y)0N< NK&x0J( 8 "!!#&&r)rJnext AOT_COUNTERr) r r rrrrrrr r rrrs ` @@r~ aot_functionr!=sxD! !(-!%-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|||Srz)rfuncfunctional_call) named_params named_buffersrrparams_and_buffersrs r~r%z#aot_module..functional_calls/> > >zz))#/A4PPrFremove_duplicaterc2eZdZdfd ZfdZxZS)aot_module..AOTModulec0t||_yrz)superr orig_module)r} __class__rs r~rz&aot_module..AOTModule.__init__s G  "D rcg|i|Srzr{)r}rr compiled_fr'r&s r~forwardz%aot_module..AOTModule.forwards*  r)rxN)rrrrr3 __classcell__)r0r2rr'r&s@r~ AOTModuler,s #  rr5) rrr assert_no_fake_params_or_buffersdictnamed_parametersr'rr!nnModule) rrrr%rr5r2r'r&s ` @@@r~ aot_moduler;s. MM88=Q,,e,DEL**E*BCM\*S-??3EIOJ  BII  ;r param_keys full_args_numctt|tjjrd|jvsdgfSt |dsdgfS|j }t}g}|D]B}||vs J|d||}||vsJ||j||j|Dg}t|jjdD]\} } t | dsJ| j}||vsJ||j||j||r|jn t|} d| jvrH| jdj!d dr)t"j%d | | |j| t"j%d | | |t'|k(sJ||fS) au Metadata is forwarded from Dynamo to AOTDispatch via special fields on GraphModule. We first verify that `mod` does come from Dynamo, then we handle cases where metadata might be missing. Returns: aot_autograd_arg_pos_to_source: used to dedup params and their guards static_input_indices: used to identify static inputs for cudagraphs dynamo_compile_idN_param_name_to_sourcez not found. 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)rrrrmetahasattrr@setaddappendrgraph find_nodesrCnamergetstatic_inputs_logdebugr) rr<r=param_name_to_source seen_sourcesrrMrrposnode source_names r~_try_get_metadata_from_dynamorVs sEHH00 16ISXX6URx 3/ 0Rx 445L%'"6++Av[-AA+%d+\)161) &--f5 6syy33}3EF Tt-...$$\)161) &--f5'-fkkm3v; DII %$))M*B*F*F '+   # #:C  ! ' ' ,  # #7k !( C >? ?? ? )+? ??r cudagraphsc itjdtjd} tj| \t t |7ttjjjj}||}||}g} | jtjjj!x} r| _t%\| _| _| j|t+| j-t | \} } d}| D],}t/|t0s|j2j4du}nt7|||||t9t:||| | dddt=| \t?| fd}t/|t@rHtC}tE}|s|r(tGd|tIjJ||||n|n|t/tjLjNjPrIdt tRffd }jT|_*j|_j|_|SdtVtRffd }jT|_*j|_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. Fr)N)r rrrrrrrrrrrr cache_infoct}tj5t| \}}ddd|S#1swYSxYwrz)r^r_disabler) r%r rrrrr params_len params_specrs r~dispatch_and_compilez3aot_module_simplified..dispatch_and_compilevsZ0k:N  ' ' ) ; NK  s AA aot_autograd_remote_cache runtime_argsc|g}|j|j||j|Srz)extendclear)r`rr  params_flats r~ boxed_forwardz,aot_module_simplified..boxed_forwards;I   [ )   \ *    y) )rc\g}|j|j||Srz)rb)r` full_argsr rds r~r3z&aot_module_simplified..forwards/ %&9%%r),r7r8r'r tree_flattenlistrrr _inductorr$tritonrWrbrrrrdrZparams_flat_unwrap_subclassesparams_unwrapped_to_flat_indexrVkeysrrrrrJrr rrrr'r(rr%loadrr GmWrapperr zero_gradtuple)rrr rrrrrrWparamsrgrrrrrr^localremoterer3rr rrrdr\r]rs` @@@@@@@@r~aot_module_simplifiedrv%s* s##U#; < s  % 8 9F &226:K{#K[!Ju55<<GGH ! !(I [!--66>>@@@&1# >k J  9  :T &c6;;=#i.I&N  a $[[22$>N  -!%%K 'E%'E1J /y*EIy#Iz9iPN  +>?/113 F 7 @*//$K/0K*, #u}}**445  *S  *#&-- ),)=)= &&)&7&7 #&uSz& G"33G--G Nr)routput_loss_indexrrr trace_jointrwrrcV|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|r$tfd }t|d |t j |i|}t#|| t%|j't%| j'| fS#1swYxYw) 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.Fr)T)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 gradientsr#z3We require the output marked as the loss (at index z#) to be a scalar, but it has shape ) rrrrrrrirrrrnumelshape)rrioout_lossr% num_fw_outsrws 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)rrrrrrczt j jzDcgc]}d}}||\}}t|t|k(sJg}t ||D]J\}}t |t jr'|jr|Jd|j|G|JJg||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_indicesrziprrrrrJ) rr fake_tangentsfw_outs gradientsoutput_gradientsagradfx_gmetadatas r~flattened_jointz*aot_export_module..flattened_jointOs(((8+S+SSM "&dM!: GYy>SY. ..! tY/ (4a.1??(( %++D1<'< (/G... .+s B8)record_module_stack)user_args_flatparams_and_buffers_flat param_names buffer_namesrxnum_user_fw_outs loss_index)rr7r8r'rrhrrrr^rrno_gradrb_aot_export_functionrrrr6rirn)rrrrxrwrrrr8r'r(rr]r\rrrgin_specrrrr%rrrs ` @@@@r~aot_export_modulers\ TUUC00%0HI**E*BCM   } ,2+>+>?Q+R([#$;<,-J \rF, [*TOK , \*ku}}% I ,- T   ,@  ))%) - )h    & / & /PBwDA9M++T.sC5u}}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|]}|jywrzrrs r~rz*aot_export_joint_simple..sD5u}}DrzPaot_export_joint_simple requires individual outputs not to be pytrees. out_spec=)num_fwd_outputs)rrrrchildren_specsrrrrrrrrrS non_aliasrrr$ debug_assertrrpr output_infosrr)r$rrxrrrrrrr _kw_in_specr fw_module _bw_modulers r~aot_export_joint_simplersK8mm 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!=!  :%T*  &(I   t   K4Kw66 U WF  Ks/#HH+=H+5"H0H0 H5H(5H?)rrrrrrrc|xsi}t|||\}} tj||f\} } d} |t| } | t |drt |j tjjrS|j jjD cgc]} d| jvr| jd!}} t|} | duxr| jdu}tdddd||tt d|dd|| }| t#| |\} }n | j}t%| || |}t'|||| |\}}||| | j(fScc} w)N _orig_modvalFT) r rrrrrrrrrrrr)rgrrhrrGrrrrrrKnodesrFrrJrr rrrspec)r$rrrrrrrrrrrrrTvalsrrrrrFs r~rrs&\rF0tVDGX,,dF^<IwI$Y/  k*4>>588+?+?@!NN0066DII% % D ).I"$.R93F3Fd3R %-K (-%'+!!J$29jI 9'' #Iz9iPN/ JD$ w --Us$Ec # Kgd}ddg}h|| fd}d}tjd|||} dg fd}tj|||||jj | r=t d kDrd \}}nd \}}t d |d dj d |dy#g fd}tj|||||jj | r=t d kDrd \}}nd \}}t d |d dj d |dwxYww)N)_backward_hooks_backward_pre_hooks_buffers_forward_hooks_forward_hooks_always_called_forward_hooks_with_kwargs_forward_pre_hooks_forward_pre_hooks_with_kwargs_is_full_backward_hook_load_state_dict_post_hooks_load_state_dict_pre_hooks_modules_non_persistent_buffers_set _parameters_state_dict_hooks_state_dict_pre_hookstraining_initialize_hook _load_hookcv|jjDcic] \}}|vs ||c}}Scc}}wrz)__dict__items)rkv STD_ATTRSs r~_get_attributesz5_detect_attribute_assignment.._get_attributes]s3!$!3!3!5LA)9K1LLLs 55c<tjf}t||Srz)rSizer)rknown_subclasses_that_lose_infos r~rz-_detect_attribute_assignment..is_leafas# JJ+ '!<==rc|Srzr{)rs r~rz._detect_attribute_assignment..lsrrc||urS|^}}t|tjr4jd|jt j |yyy)Nzself.)rrrrJkeyrkeystr)kpr_vrrestassigned_tensor_attributess r~#_collect_assigned_tensor_attributeszI_detect_attribute_assignment.._collect_assigned_tensor_attributestsU{ 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) rNN_MODULE_STD_ATTRSNN_MODULE_LAZY_STD_ATTRSrrsnapshotrnounverbrrs @@r~rr<s (    !I M>{OC,@'RH  &("  !! /?3;O  H% %-.21 d/ ddV1TYY/I%J$K1TFStt  &%&("  !! /?3;O  H% %-.21 d/ ddV1TYY/I%J$K1TFStt  &s6EB>A?E>BD>>E) itertoolscollections.abcrr contextlibrr functoolsrrtypingr r r r r r unittest.mockrrtorch._dynamo.loggingtorch.nnr9torch.utils._pytreer_pytreertorch.utils.dlpackr$torch._decomp.decompositions_for_rngrrtorch._dispatch.pythonr torch._dynamortorch._dynamo.utilsrrrr torch._guardsrtorch._inductor.output_codertorch._inductor.utilsrrtorch._subclassesrr"torch.fx.experimental.proxy_tensorr%torch.fx.experimental.symbolic_shapesr torch.utils._python_dispatchr!_logginggetArtifactLoggerrrOr$_aot_autograd.autograd_cacher%r&r'r('_aot_autograd.collect_metadata_analysisr)_aot_autograd.functional_utilsr*r+r,r-r.r/r0r1r2r3r4#_aot_autograd.input_output_analysisr5r6r7r8*_aot_autograd.jit_compile_runtime_wrappersr9r:r;_aot_autograd.logging_utilsr<r=r>r?r@rArBrCrDrErFrG_aot_autograd.runtime_wrappersrHrI_aot_autograd.schemasrJrKrLrMrNrOrPrQrRrSrTrUrVrW_aot_autograd.subclass_utilsrXrYrZr[r\(_aot_autograd.traced_function_transformsr]r^r_r`rarbrc_aot_autograd.utilsrdrerfrgrhrirjrkrlrmrnro partitionersrprcountr rrirqrrrurrrrrrrr7rboolr!r:r;rrSourcerVrvrrrrTreeSpecrrcompiled_functioncompiled_moduler{rr~rs.2$FF $$W;+ +2686:FNN44 '               ,ioo z!-tCy9m:6   (  4&940AVCyAVAVAV! AV  AVH "Cy "&/ " >8H- -. "  $      !   8( ()  {(${({( {( ! {(  8( () {(B'+.%)+0-1q qqq(#q q TN q  q%)q!*qqh1BII12991h=@ =@&.sm=@DG=@ 8D--. /c :;=@H26.%)#(8<&*S S%S-. S  S TN S!!45S#SYYSt&* (,%) L LTN LL }LLTNL 588   /0Ln %)] ] ]]TN] XX]P %)%) #K. K. K. TN K.K.K. TN!K.$ 588  !4foov VW%K.\PehhooPPf!r