pifXddlZddlZddlmZddlmZddlmZmZmZddl m Z ddl Z ddl Z ddl mZddlmcmZddlZ ddl mZddlmZmZddlmZdd lmZdd lmZmZmZm Z dd l!m"Z"dd l#m$Z$dd l%m&Z&ddl'm(Z(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/e j`jce2dZ3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEmFZFddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRddlSmTZTmUZUmVZVmWZWmXZXmYZYmZZZddl[m\Z\m]Z]m^Z^ddl_m`Z`maZambZbmcZcddldmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpddlqmrZrmsZsddltmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZdd lmZmZmZmZmZdd!lmZmZmZmZmZmZmZmZmZmZmZmZmZdd"lmZeZej@ZiZd#ejFd$ezd%ee>d&eud'e)d(ee/d)exfd*Zdeddd+dfd+d,d-d.ed/ed0eed1ed2eed3ed4ed5eed)efd6Zd7ejTd)ejTfd8Zd+d9d7ejTd/eevd0eevd1ed2ed5eevd:e$d;edZdedd+dddd+fd7ejTd/evd0eevd1ed2eed5eevd?ee&d:ee$d;ed)ejTfd@ZdAZ dSdd+d+eedBd#ejFd7ejTd2eed/eevd0eevd)ef dCZdDed)efdEZddd+dddFd7ejTd2eedGedHeedIedJeed)ee jfjhe~ffdKZdddLdMedGed3ed2eed)e jfjhf dNZddd+d+dd+d+ddOdMed3ed2eedPedIedJeedQedGed)ee jfjheejnejnffdRZeZeZy)TN) nullcontext)wraps)AnyCallableOptional)patch)Tensor)PhiloxStateTrackerrng_decompositions)enable_python_dispatcher)compiled_autograd)CompileEventLogger dynamo_timedpreserve_rng_stateset_feature_use)detect_fake_mode)BoxedDeviceIndex) BoxedBool) FakeTensorFakeTensorMode)reorder_kwargs)make_fx)ShapeEnvcudagraph_static_inputs)config)AOTAutogradCacheautograd_cache_keyshould_use_local_autograd_cache should_use_remote_autograd_cache)*run_functionalized_fw_and_collect_metadata)AOTInputBufferAOTInput ParamAOTInput PlainAOTInput)_detect_attribute_assignment_try_get_metadata_from_dynamoconstruct_fake_modeprocess_inputs) "_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)aot_dispatch_subclasscreate_functional_callcreate_functionalized_fn%create_functionalized_rng_ops_wrapper create_jointfn_input_mutations_to_outputsfn_prepped_for_autograd)aot_stage1_graph_captureaot_stage2_compileaot_stage2_export)compute_overlapping_inputscreate_graph_signaturecreate_synthetic_base_metadataremove_dupe_metadata) 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) AOTConfigAOTDispatchCompilerAOTGraphCaptureAOTStateBackwardSignatureFakifiedFlatArgsFQNGraphInputNameGraphOutputNameGraphSignatureInputAliasInfoJointWithDescriptors MutationTypeOutputAliasInfo OutputTypeSerializableAOTDispatchCompilerSubclassCreationMeta SubclassMeta TensorAliasViewAndMutationMeta)requires_subclass_dispatchunwrap_tensor_subclasses1unwrap_tensor_subclasses_with_indices_to_originalwrap_tensor_subclasses"wrap_tensor_subclasses_maybe_joint) _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 simple_wraps strict_zip)default_partitionstackfake_flat_argsflat_args_descs aot_config fake_mode shape_envreturnc |jtdd|ji|_it|j|_tj rit |j|_| tn t}|jtjjd|jt|j||j||jt|jtjjj!ddlmmfd}t)d |D} t5t+d d 5t-|} | t/| } n t} tj0jj2r t} n td d} | 5| 5t5|||j6|j8| |j:|j< ||ddddddt?|} tAjBd| t)fdjDD xrt)djFD }| r|rd} | r3t5|||j8d|j:|j6|ntIjFjDjJ|j8jLjNjPjRjTdjVj6 ddddddjJdkDrQ rOJdtYjDDcgc]%\}}|jZt\j^k(s$|'c}}d|j<rtajFDcgc]}|jbs|c}dk7rtedtgtajFDcgc]}|jhr|jjr|c}dk7r#|jlrtedtg r tedtj r tedto| |||||S#1swYxYw#1swYxYw#1swYxYw#1swYxYwcc}}wcc}wcc}w)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. create_aot_dispatcher_functionT)log_pt2_compile_eventNFr)FakeScriptObjectmaybe_to_fake_objc~|Dcgc],}t|rt||jn|.c}Scc}wN) isinstancerreal_obj)ryargrrs _/opt/services/ai/voice_agent/venv/lib/python3.12/site-packages/torch/_functorch/aot_autograd.py_dup_fake_script_objz.create_aot_state.._dup_fake_script_objsM &  #/0 .~> M    s1:c3VK|]!}t|ts|j#ywr)rr requires_grad.0xs r z#create_aot_state..s":a3Hs))ztorch.cuda.set_rng_statecyr)argss rz"create_aot_state..&saot_collect_metadata)rzstatic_input_indiceskeep_input_mutationsis_train pre_dispatch is_exportbackend_compile)rec3K|]d}|jxrR|jtjtjfvxr#j |j j fywr)r output_typer_alias_of_inputis_input input_infobase_idx)rr fw_metadatas rrz#create_aot_state..Hsk / MMj&?&?ATAT%UUI#..qzz:HH  /sA*A-c3K|]<}|jxr*|jxr|j xr |j >ywr)r mutates_data)mutations_under_no_grad_or_inference_modemutations_hidden_from_autogradrs rrz#create_aot_state..SsS  9NN9CCC98889sAA)rzrrrr) r output_infonum_intermediate_basesrtraced_tangentstraced_tangents_descssubclass_inp_metasubclass_fw_graph_out_metasubclass_tangent_metartokensrztorch.compile is currently being used with tensor subclass inputs. We are attempting to a compile a graph with two graph outputs that alias one another, specifically output indices: z ANY output aliasing (even for regular tensors) is currently unsupported if there are any subclass outputs. 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.)needs_autograd flat_argsrzrr{rx)8 enter_contextrdecompositionsaot_autograd_decompositionsrfunctionalize_rng_opsr r rtorchautogradset_multithreading_enabledrr _dynamoutils+_disable_saved_tensors_hooks_during_tracing"torch._library.fake_class_registryrranyrrtr& _functorch"fake_tensor_propagate_real_tensorsr!rkeep_inference_input_mutationsrrrertry_add_pt2_compilerrrdrrrrrrr enumeraterr_alias_of_intermediatelenmutates_metadata RuntimeErrorstrrrexport_trace_jointrT)rxflat_fnryrzr{r|r}python_dispatcher_moderrmodctxdynamo_timed_ctxreq_subclass_dispatchoutput_and_mutation_safeirrrrs @@@rcreate_aot_staters&: 5TR  ($& !! %!  # #!J ##%  % ''% !'0&; " AA%HI *,-  " ./ *,-  GGIW  !/N " #Y-/A BV 7@C237!m&&II$/= #/*$$ " 93 9H$3)3)H)H)3)R)R+!+!8!8(22(79  9 9%? % !  2 2!>S ,/ /%00 / , (( %//  %&":"' )#"L(7-7-V-V!&%/%<%<-7-L-L #&#'K#6#.#9#9$/$;$;/:/Q/Q-7-V-V(3(C(C.9.O.O*5*G*G3>3Y3Y.9.O.O!&*11-8-M-M #KSV Yv))A-( / k556lDAq!--:KkKk:kalmn + ( ;11HaQ5G5GH IQ N    "  )331>>  --    "  !C   ' 'K  %&~6' M 9 9 9 9!V V YYBmIsu.S#>> 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_idrdynamic_shapesaot_autograd_arg_pos_to_sourcer no_tangentsrc tj|i|}t||\}}t|\}}t |||}t t |Dcgc] }t|} }tj5} t| ||| ||} t| |} t| | \} }ddd |f\}}||}|j|Scc}w#1swY0xYwr)pytreearg_tree_leavesrmr(r)rangerr% contextlib ExitStackrr<r= unflatten)rkwargsrrout_specr|r}ryrfake_flat_args_descsrx aot_stateaot_graph_capture compiled_fn_ cached_fnoutr{ cached_resrs rreturned_functionz'aot_function..returned_functions#**D;F;    8T6 J GX%8J%O "Y /=:y)0N +0N0C*D$%& a $ $%%' R5,"( %=Y$P!!3I?P!Q Q R&x0J( 8 "!!#&&'$ R RsC-C  C))rQnext AOT_COUNTERr) rrrrrrrrrrrr{rs ` @@r aot_functionrsyD! !(-!%-K 'E'+JJ 2Y!'!'F 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|||Sr)rfuncfunctional_call) named_params named_buffersrrparams_and_buffersrs rrz#aot_module..functional_call^s/> > >zz))#/A4PPrFremove_duplicaterc2eZdZdfd ZfdZxZS)aot_module..AOTModulec0t||_yr)super__init__ orig_module)self __class__rs rrz&aot_module..AOTModule.__init__js G  "D rcg|i|Srr)rrr compiled_frrs rforwardz%aot_module..AOTModule.forwardns*  r)r~N)__name__ __module__ __qualname__rr __classcell__)rrrrrs@r AOTModuleris #  rr ) rrr assert_no_fake_params_or_buffersdictnamed_parametersrrrnnModule) rrrrrr rrrs ` @@@r aot_modulerEs. MM88=Q,,e,DEL**E*BCM\*S-??3EIOJ  BII  ;r) force_non_lazy_backward_loweringboxed_forward_device_indexignore_shape_envflattenrc  \| s|J|i}t|jd} tt|jd}t| j t| j }}t |}t|j t|j }}t |}i| |}||z}||z}t||||z| }g|||}d\}}| r*t|||\}}tj||f\}}~g}|jd|D|jd|D|jdtt |t |z Dtjjj!x}r||_t%|\|_|_t+||j t |\}}d} |D],}!t-|!t.s|!j0j2du} nt5did|d |d |d |d |d ||zdt7t8d|d| d|d|ddddddd| dt;|ddd| }"t=||"\}#}$t?||"|#|$| }%|||||%||"|#|$||f S)NFr)strict_out_tuple)NNc32K|]}t|ywr)r$rfqns rrz0prepare_aot_module_simplified..sE#=-Ec32K|]}t|ywr)r#rs rrz0prepare_aot_module_simplified..sG3>#.Grc32K|]}t|ywr)r%)rrs rrz0prepare_aot_module_simplified..s arrrrrrrrrrrrrr cache_inforprecompile_backend_id _backend_idrr) rrrlistvalueskeysrr6rmr tree_flattenextendrr_guardsTracingContexttry_get params_flatrgparams_flat_unwrap_subclassesparams_unwrapped_to_flat_indexr'rrr|r}rQrrgetattrr(r))&rrrrrrrrrrrrrparamsbuffersr* params_spec params_len buffers_flat buffers_spec buffers_lenparams_buffersparams_buffers_flatparams_buffers_specr full_argsin_specrfull_args_descstracing_contextrrrrr{r|r}rys& rprepare_aot_module_simplifiedr<ys^ ~~ #&&&> ?F4))5)ABCG#FMMO4d6;;=6IK[!J!%gnn&6!7glln9M,Ll#K**'*N% 4% 4 - *{":QX[O5+4 4t4I"GX$< Y% !$00)V1DE 7OEEEG,GG"'I_9M(M"N  --66>>@@@':# >>Q R  9  : &c>+>+>+@#i.Q&N  a $[[22$>N  ."  &  & 3 K (F&(F2* &c=$?!"*J#J&/y*EIy#:y)5EN   r cudagraphsc ||7ttjjjj }||}||}t j5} t||d||||||| | d \ } } }}}}}}}}dt|tr?t}t}|s|r'td|tj||||| ||O| j!t#j$t'| | |||||}t)|| }t+||\}dddt|tj,j.j0rdt2t4ffd }ndt6t4ffd }|j8|_|j:|_|j<|_|S#1swYxYw)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. NF)raot_autograd_remote_cache runtime_argsc|g}|j|j||j|Sr)r&clear)r@rrr6s rrz&aot_module_simplified..forwardYs<I   0 1   \ *    y) )rc\g}|j|j||Sr)r&)r@r8rr6s rrz&aot_module_simplified..forwardfs0I   0 1   \ *y) )r)rr _inductorrtritonr=rrr<rr`rr rrtry_loadrr _disablerr<r=rr GmWrapperr"rtuple zero_gradrr)rrrrrrrrr=rrrxr _params_spec _buffers_specryr:r{r|r}_in_spec _out_speclocalremoterrrrrr6s @@raot_module_simplifiedrQs4u55<<GGH ! !(    9N5 *        *  &               k#B C35E57F ;VD.77".       1 : : < =(I!9O T / ;LMNKs9Nv#u}}**445  *$s) * *5: * G"33G--G Nq9N9Ns CF22F;c fd}d|_|S)Nctjjj5tjj j |cdddS#1swYyxYwr)rfx tracebackpreserve_node_meta Interpreter boxed_run)rfx_gs rrunz)boxed_nop_preserve_node_meta..runusK XX   2 2 4 >88''-77= > > >s .A""A+T) _boxed_call)rYexample_inputsrZs` rboxed_nop_preserve_node_metar]ts>CO Jr)rrrrrc$t|||||t||dd|dd \ } } } } } }}}}}}|jtjt || | ||||}t || }|jJt||| | ||jS)a This API captures the joint graph for an nn.Module. However, unlike aot_export_joint_simple or aot_export_module(trace_joint=True), the calling convention of the produced joint graph follows no fixed positional schema; for example, you cannot rely on the second argument of the traced joint graph to correspond to the second argument of the module you traced. However, the inputs and outputs of the traced graph are schematized with **descriptors**, annotated on meta['desc'] on the placeholder and return FX nodes, which you can use to determine the meaning of arguments. The major benefit of using this export rather than aot_export_joint_simple is that we have feature parity with all situations that torch.compile supports (via aot_module_simplified), including handling for more complicated cases such as multiple differentiable outputs, input mutations that must be handled outside of the graph, tensor subclasses, etc. What can you do with one of these joint graphs with descriptors? The motivating use case (autoparallel) involves taking the joint graph, doing optimizations on it, and then turning it back into a callable so it can be torch.compile'd at a later point in time. This cannot be done as a traditional torch.compile joint graph pass for two reasons: 1. The sharding of parameters must be decided before parameter initialization / checkpoint load, far before torch.compile would ordinarily run. 2. We need to change the meaning of parameters (e.g., we might replace a replicated parameter with a sharded version of it, changing its input size). torch.compile is ordinarily semantics preserving, and not allowed to change the meaning of inputs. Some descriptors can be quite exotic, so we recommend thinking carefully if there is a safe fallback you can apply to descriptors you don't understand. For example, you should have some way to handle not finding a particular input exactly as is in the final FX graph inputs. Note: When using this API, you must create and enter an ExitStack context manager, which will be passed into this function. This context manager must remain active if you call the compile function to finish compilation. (TODO: We may relax this requirement by having AOTAutograd keep track of how to reconstruct all the context managers at a later point in time.) NB: You're not obligated to do a /full/ compile in stage2; instead you can leave the forward/backward compilers unspecified in which case the partitioned FX graphs will directly run. The overall autograd Function can be allowed in graph so you can reprocess it in the context of a (potentially larger) compiled region later. NB: These APIs do NOT hit cache, as we only ever cache the final compile results, not the intermediate export result. NB: If the passed nn.Module has parameters and buffers on it, we will generate extra implicit parameter/buffer arguments and assign ParamAOTInput and BufferAOTInput descriptors to them. However, if you generate the input nn.Module from a mechanism like Dynamo, you will NOT get these descriptors (because Dynamo will already have taken care of lifting the parameters/buffers into arguments!) In that case, it would be necessary to analyze the Sources of the inputs to determine if inputs are parameters and their FQNs. NT)rr) _aot_state_aot_graph_capturer0r3r9r) r<rwrr rGrr<specr\)rxrrrrrrrrr_params_buffers_flatr0r3ryr:r{r|r}r9rrrs r!aot_export_joint_with_descriptorsrc}sh &  &   *.%  0 )2245  I1OL == $$ $ ,!  rjdctjj\}ttj j fd}|S)a Companion function for aot_export_joint_with_descriptors which compiles the joint graph into a callable function that follows a standard calling convention. params_flat all are arguments. Note: We do NOT instantiate the module; this gives you the flexibility to subclass it and customize its behavior without having to worry about FQN rebinding. TODO: Consider if we should allow_in_graph the result by default. ctj|t|jfd}|}tj|j S)Nr)rr%rr9tree_unflattenr)rr flat_inputs flat_outputsrrds runflattened_compiled_fnzCaot_compile_joint_with_descriptors..unflattened_compiled_fnsL))4 1S*TUVWX ";/ $$\2;;??r)r=r_r`rurrnonstrict_trace)rdrrjrs` @r"aot_compile_joint_with_descriptorsrlsT( r7L7LMNK+ ]]""@#@ #"r)routput_loss_indexrrr trace_jointrmrrcX|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.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 ) rrrr rIr"typerrrnumelshape)rrroout_lossr num_fw_outsrms r fn_to_tracez&aot_export_module..fn_to_tracedsE!4(C ("Q # .fcE4=1"fgklogpfqr"# 1 ??q,='=&! "3 34C+ /  ,-Hc(K))"&''ae~~1$"44E3FFijrjxjxiy}Jr)rrrrrrnrczt 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 ) r num_outputsnum_mutated_inp_runtime_indicesrziprrr rappend) rr fake_tangentsfw_outs gradientsoutput_gradientsagradrYmetadatas rflattened_jointz*aot_export_module..flattened_joints(((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_namesrnnum_user_fw_outs loss_index)rrrrrr%rIrr6rrno_gradr&_aot_export_functionrrrr@r"r$)rrrrnrmrrrrrrrr0r1rxrr8r9rrrrrYrrws ` @@@@raot_export_modulers\ TUUC00%0HI**E*BCM   } ,2+>+>?Q+R([#$;<,-J \rF, [*TOK , \*ku}}% I ,- T   ,@  ))%)# - )h    $ / $ /LBwDA9M++T.0sC5u}}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|]}|jywrrrs rrz*aot_export_joint_simple..8sD5u}}DrzPaot_export_joint_simple requires individual outputs not to be pytrees. out_spec=)num_fwd_outputs)rrrrchildren_specsrrrrrrrrr_ non_aliasrallr debug_assertr{rwr output_infosrr)rrrnrrrrYrr9r _kw_in_specr fw_module _bw_moduler|s raot_export_joint_simplersP8mm 6,@  )# - )h '556 ++ 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   * < <   8 89!=!  : %T*  &(I   t   K4K}66 U WJ  Ks/$H H,>H,6"H1H1 H6H)6I)rrrrrrrnrrrc| xsi} t||| \} } tj|| f\} } d}|t| }|t |drt |j tjjrS|j jjDcgc]}d|jvr|jd!}}t|}|duxr|jdu}tdddd||tt ||dd|||}|t#| |\}}n |j}t%| |||}t't)|Dcgc] }t+|}}t-j.5}t1|| |||||}t3|| }t5||\}}ddd| | j6fScc}wcc}w#1swY#xYw)N _orig_modvalT)rrrrrrrrrrrrrr)rmrr%rhasattrrrrrT GraphModulegraphnodesmetar}rQrrr(r)rrr%rrrr<r>ra)rrrrrrrrrnrrrrr9r|nodevalsr{r}ryrrrxrrrYrs rrrSs,\rF0tVDGX,,dF^<IwI$Y/  k*4>>588+?+?@!NN0066DII% % D ).I"$.R93F3Fd3R %-K (<%'+!&#J&29jI 9'' #Iz9iPN6;C#_aot_autograd.input_output_analysisr?r@rArB_aot_autograd.logging_utilsrCrDrErFrGrHrIrJrKrLrMrN_aot_autograd.runtime_wrappersrOrP_aot_autograd.schemasrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrd_aot_autograd.subclass_utilsrerfrgrhri_aot_autograd.utilsrjrkrlrmrnrorprqrrrsrtrurv partitionersrwr|countrrrr"rrintboolrrrr<rQr]rccallablerlrIrTrrrTreeSpecrcompiled_functioncompiled_modulerrrrs"** $$W;+ +<+836:NN44 '           ,,ioo z!z   z%z(^ z  z  z!zz@'+.%)+0-1{ {{{(#{ { TN {  {%){!*{{|1BII12991D.3| |-. | -. |  ||!!45|!1|||'+|F26.%)#(8<'+=A"y y%y-. y  y TN y!!45y#y!))9 :yyYYyx  C &*#(1M1MC   C C TN C-.C-.CCL#+?#H#:&* (,%) M MTN MM }MMTNM 588   /0Mp %)` ` ``TN` XX`V %)%)!& )W. W. W. TN W.W.W. TN!W."#W.&'W.* 588  !4foov VW+W.t!r