U yh@sUddlZddlZddlZddlZddlZddlZddlZddlmZm Z ddl m Z m Z m Z mZmZmZmZmZddlZddlZddlZddlmmZddlmZmZddlmZmZm Z m!Z!m"Z"m#Z#ddl$m%Z%m&Z&ddl'm(Z(ddl)m*Z*dd l+m,Z,m-Z-m.Z.dd l/m0Z0m1Z1dd l2m3Z3dd l4m5Z5dd l6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>ddl?m@Z@ddlAmBZBddlCmDZDddlEmFZFddlGmHZHmIZImJZJmKZKddlLmMZMmNZNddlOmPZPddlmQZQddlRmSZSddlTmUZUddlVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdeeefZgejhGdddZiejhGd d!d!ZjeiZkejlejmejnejoejpejgejqerejsh ek_ted"d#Zud$d%Zvd&d'Zwd(d)Zxd*d+Zyd,d-Zzd.d/Z{d0d1Z|d2d3Z}ej~jej~je eefd4d5d6Ze,eae eeejejffdd7d8d9Zejjeadd:d;d<Zej~jejjdd4d=d>Zej~je eefd?d@dAZe eefeQeQe ee[feeZdBdCdDZddEdFdFdGdGdGdHe ee dIfee ee feee ee fee ee feedIfeeeeeejjdJ dKdLZdMdNdFdFdOej~je,dPdQdRZej~je eejfd?dSdTZdej~jee dIfee ee feedUdVdWZeeje eejfeae eeejejffdXdYdZZej~jeae eeejejffd[d\d]Zejjdd^d_d`Zejjdd^dadbZejjeadcdddeZeXe ee fdfdgdhZdaeeeedi<daee eefedj<dkdlZdmdnZeej~jdodpdqZedrdsZGdtduduej~jZddvdwZej~jee dIfe ee feee ee fee ee feedIfee ee feQeeeedx dydzZej~jee dIfe ee feee ee fee ee feedIfee ee feQeeeedx d{d|ZeeWddGdEdFdFdFdFd}ej~jee dIfee ee feee ee fee ee feeedIfeeeeeeXd~ ddZdS)N)contextmanager nullcontext)AnyCallableDictListOptionalSetTupleUnion) UserError UserErrorType)_fakify_script_objects_gather_constant_attrsmake_constraintsmake_fake_inputsmake_fake_params_buffers$produce_guards_and_solve_constraints)_node_metadata_hook_set_node_metadata_hook)-_AddRuntimeAssertionsForInlineConstraintsPass)CollectTracepointsPass)ConstantAttrMaplift_constants_passrewrite_script_object_meta)placeholder_naming_passplaceholder_prefixes)SpecViolationError)_wrap_submodules)aot_export_moduledetect_fake_mode)FakeScriptObject) FakeTensorFakeTensorMode)log_export_usage) _combine_args) OutputKind)#first_call_function_nn_module_stack)ConstraintViolationErrorfree_unbacked_symbolsGuardOnDataDependentSymNodeShapeEnv)_PyTreeCodeGen _PyTreeInfo)insert_deferred_runtime_asserts)TreeSpec)ValueRangeError)AutogradStateOpsFailSafeguard)_disable_prexisiting_fake_modeExportedProgram InputKindModuleCallEntryModuleCallSignature) _sig_to_specs ArgumentSpecConstantArgumentCustomObjArgumentExportGraphSignatureSymIntArgumentTensorArgument TokenArgumentc@s6eZdZUdZdZeed<eje dZ e e ed<dS)ExportDynamoConfigz: Manage Export-specific configurations of Dynamo. T allow_rnn)default_factoryreorderable_logging_functionsN) __name__ __module__ __qualname____doc__rBbool__annotations__ dataclassesfieldsetrDr rrNrNE/var/www/html/venv/lib/python3.8/site-packages/torch/export/_trace.pyrAUs  rAc@seZdZUejjed<eed<ee e ej e ej ffed<dZeeed<dZeeed<dZeee ee ejffed<dS)ExportedArtifactgmsig constantsNout_spec fake_modemodule_call_specs)rErFrGtorchfx GraphModulerJr=rstrr Tensorr" ScriptObjectrTrr0rUr$rVpytreerNrNrNrOrPas  rPccsJtjjd}tjjd}z dVW5tjjj|tjjj|XdSNF)rWbackendsZmkldnnZ set_flagsZnnpack)Zorig_mkldnn_flagZorig_nnpack_flagrNrNrO_ignore_backend_decompss  r`cCs dt|S)NZ L__self__) _strip_rootxrNrNrO _fixup_keysrdcCsBt|tr>|dr>|tdd}|dr:|ddS|S|S)N _export_root.r2) isinstancerZ startswithlen)rcstrippedrNrNrOrasrac Csbt|dkr^d}|2t|tjt|dt||}W5QRXW5QRX|dk sXt|j}dS)NrzFile "torch/_export/passes/add_runtime_assertions_for_constraints_pass.py", line 46, in _AddRuntimeAssertionsForInlineConstraintsPass stack_trace)rir functoolspartialrrAssertionError graph_module)range_constraintsrQrUrlresrNrNrO+_add_runtime_assertions_to_cond_in_subgraphs    rsc Cs|jjD]}|jtjjjkrd|jkrt|jd}|j |L|jj dtjjj|j ||jddd}|j |_ | ||j|W5QRXqdS)Npath call_functionkind)rtrv)argskwargs)graphnodestargetrWZopsZ higher_orderZ_export_tracepointrxraZinserting_beforeZ create_noderwmetaZreplace_all_uses_withZ erase_node)rQnodertnew_noderNrNrO _rewrite_nodes     rc st|}g|jjD]@}|jdkrd|jkr|jd}|dk rt|tjr|qt }rh|}nt t dd}t |dkrt |dkrdi||fSdfdd}t tj||} t tj|j|} t tjtj|jdd |} | | | |fS) N placeholdervalT) shape_envexportrrNcs}d7|S)Nr2rN)rcrcountZ fake_inpsrNrOconvert_to_fakesz/_convert_input_to_fake..convert_to_fakeZ static_shapes)_get_params_buffersryrzopr|rgrWr[appendr!r$r,rir]Z tree_map_only from_tensorrmrn) rQrwrxparams_buffersr}Zfake_valZdetected_fake_moderUr fake_args fake_kwargsfake_params_buffersrNrrO_convert_input_to_fakes,     rcCsX|jD]"}|jtjtjfkr||j|_q|jD]"}|jtjtj fkr0||j|_q0dSN) input_specsrvr6Z PARAMETERBUFFERr{ output_specsr'ZBUFFER_MUTATIONZGRADIENT_TO_PARAMETER)param_buffer_tablerRspecrNrNrO_replace_param_buffer_namess  rcsft|t|tks@tdt|dt|dtdfdd|t|dD}||S)Nz,Total number of arg names is expected to be z but got z positional args, z kwargs.csg|] }|qSrNrN).0Zkw_namerxrNrO sz/_convert_to_positional_args..)riro)orig_arg_namesrwrxZreordered_kwargsrNrrO_convert_to_positional_argss"rc sd}tdd|}|D]}t|tjjs.q|jjD]}|j dkrFq6d}|j di}rt t |\}} t| rt| tjjr||kr| |krd}nt| tst|r6dd |||jd |jfi|}fd d |D|j d<q6qdS) Nz L['self']z [^a-zA-Z0-9]_routputTnn_module_stackFcsTz6gGfddd}t|dd|iidWStk rN|YSXdS)Ncs$eZdZfddZfddZdS)z@_normalize_nn_module_stack..normalize_path..Pathcs||Sr)r)selfnamepartsrNrO __getattr__s zL_normalize_nn_module_stack..normalize_path..Path.__getattr__cst||Sr)rrZ)ridxrrNrO __getitem__szL_normalize_nn_module_stack..normalize_path..Path.__getitem__N)rErFrGrrrNrrNrOPaths rLrrf)evaljoin Exception)rtrrNrrOnormalize_paths  z2_normalize_nn_module_stack..normalize_pathrfcs"i|]\}\}}|||fqSrNrN)rkeyrttyrrNrO 's z._normalize_nn_module_stack..)resubmodulesrgrWrXrYryrzrr|getnextitervaluesinspectisclass issubclassnnModulerZrorFrGitems) gm_torch_levelZroot_clsrootZroot_keyrQr}Zadd_rootrrtrrNrrO_normalize_nn_module_stacks2    r)original_module traced_modulereturnc Cs6i}i}|jddD]\}}|t|g|q|jddD]\}}|t|g|q@|D]\}}|ddd||<qh|D]\}}|ddd||<qi}|jddD]4\} } | |kstt| |kr|t| || <q|jddD]6\} } | |kstt| |kr|t| || <q|S)z Returns a mapping of parameter/buffer names from the new module to the original model. This is to help with restoring the FQN for parameter/buffers of a traced module to what the original module contains. Fremove_duplicateN)named_parameters setdefaultidr named_buffersrropop) rrZ param_lookupZ buffer_lookuprparambufferZfqnsrZ dynamo_nameZ dynamo_paramZ dynamo_bufferrNrNrO_get_param_buffer_mapping-s0    r)orig_constant_attrsgraph_signaturerSrc Csi}|D]\}}||kr ||||<q |jD]`}|jtjtjfkr0|j}|dk sXt|||g}|d|_||} ||=|D] } | || <qq0dS)zXRewrite the graph signature and constants table to use the FQN from the original module.Nr) rrrvr6CONSTANT_TENSORZ CUSTOM_OBJr{ror) rrrSZ remap_tablervaluerZ orig_targettargetsZconstantr{rNrNrO_remap_constantsVs"   r)rQrrc s(dd|jjDfdd}ttj}ttj}i}|jD]n}|jtjkr<|jj |s<|jj |r|||jj t |d}n|||jj }|||jj <||j_ q<|j D] }|jj |kr||jj |j_ q| D]F}t|tjjsq|jjD] } | j |kr|| j | _ | _q|qdS)z\ For strict mode, rename constants nodes that were previously annotated as buffers. cSsh|] }|jqSrNr)rr}rNrNrO ysz*_rename_constants_nodes..cs>|kr0d}|d|}kr,|d7}q |}||S)Nr2r)add)rnZdup_nameZ node_namesrNrOrename_constant{s  z0_rename_constants_nodes..rename_constantN)ryrzrr6rrrrvargrrhrirrrgrWrXrYr{ recompile) rQrrZ buffer_prefixZ const_prefixZbuffer_to_constantrZc_namemodr}rNrrO_rename_constants_nodesqs4          rcCst||}|D]\}}|dd||<q|D]\\}}t||sHq4t||}t|tjrzt|tjj sz| ||n t |||t ||q4|j jD]&}|jdkr|j}||kr|||_q|dS)zV Restores the state dict of the traced module to that of the original module. rfrget_attrN)rrreplacehasattrgetattrrgrWr[r ParameterZregister_buffersetattrdelattrryrzrr{r)rrrrfqnattrr} attr_namerNrNrO_restore_state_dicts"        r)rrcCsdd|jddDS)NcSsi|]\}}|t|jqSrN)typerE)rrmrNrNrOrsz)_get_module_hierarchy..Fr)Z named_modules)rrNrNrO_get_module_hierarchys r)module_hierarchyin_specrTmodule_call_signaturesrcs>fdd|D}|djdks$ttgg||d|d_|S)Ncsg|]}t||dqS))r signature)r7r)rrrrNrOrsz+_make_module_call_graph..r)inputsoutputsrrT)rror8r)rrrTrretrNrrO_make_module_call_graphs  rrNFT)preserve_module_call_signaturedisable_constraint_solver(_allow_complex_guards_as_runtime_asserts restore_fqn_log_export_usagesame_signature.) frwrxdynamic_shapesrrrrrrrcCsV|rtddhdt|ts2ttjdt||p8i}tjj t t zZi} t||| @t.tjj||dd||||| d ||\} } W5QRXW5QRXWnrttfk r} zttjt| W5d} ~ XYn>tk r} zttjd t| d d W5d} ~ XYnXW5QRX| | jd <t|tjjrR|rRt|| | S) z Traces either an nn.Module's forward function or just a callable with PyTorch operations inside and produce a torch.fx.GraphModule in torch IR. zexport.private_api_export_to_torch_ireventflagsAExpecting `args` to be a tuple of example positional inputs, got TZsymbolic)rZassume_static_by_defaultZ tracing_moderZ+prefer_deferred_runtime_asserts_over_guardsrrrNz5Consider annotating your code using torch._check*(). Zconstrain_as_size_example)Z case_namerV)r%rgtupler r INVALID_INPUTrrWZ_dynamoconfigpatchrKasdictDEFAULT_EXPORT_DYNAMO_CONFIGrr`rr)r1CONSTRAINT_VIOLATIONrZr+Z ANTI_PATTERNr|rrr)rrwrxrrrrrrrrVrrerNrNrOrsX      "  rcCs|SrrNrbrNrNrO(r ) transform pre_dispatch_is_torch_jit_trace)rconstant_attrscs2tj}t} |s|rt} tdd} tjjjj ||ddddT| Dt 2| |t ||d||d\} W5QRXW5QRXW5QRXW5QRXt |tj jrt|dr| j|jtdfd d jdk } t||f} d }tjtjtj}| jjD]H}|jd kr||krV| ||}t |tjsV||jd <|d7}qttj j!j"tj#j$j%| rjj&ni| rjj'ni| rjj(ndfddt)| jjDfddt)tt*t+t,| jjj-Djj.d \}}t/||d}d dl0m1}|| }d dl2m3}|j4sd}t5| t6j7t8|d$t9| |j:dt;| jddW5QRX|rd dlD]R}t |tj jsq|jjD].}|jdkr|j?dd|j?ddqĐqt@| }|tA| ||tB| ||||||tC| ||S)Ncss*tjj}zdtj_dVW5|tj_XdS)NT)rWcompilerZ_is_compiling_flag) old_valuerNrNrO_compiling_state_context4s  z4_export_to_aten_ir.._compiling_state_contextT)Z tie_weightsstrictZ stack_weightsF)Z trace_jointrrxr|)rcst|ttttdfr"td|dSd|jks:t|d|jd}|tj kr^t |j dSt|t rtt |j dSt|tjrt|j dSt|tjrt|j |dSt|trt|j |jdSt|tttttdfrt|j |dStdt|ddS) Nr)rrrz8 is not a constant or a node with a 'val' metadata fieldr)rZ class_fqnz*Encountered an unsupported object of type z0 while writing the metadata for exported program)rgintrIfloatrr;r|rori input_tokensr@rr#r?rWZSymIntr>r\r<_typeZqualified_namer"Zscript_class_namerZ)ir}r)rrNrOmake_argument_specTs,         z._export_to_aten_ir..make_argument_specrrrr2cs$g|]\}}|jdkr||qS)r)rrrr}rrNrOrs z&_export_to_aten_ir..csg|]\}}||qSrNrNrrrNrOrs) user_inputsinputs_to_parametersinputs_to_buffers user_outputsZbuffer_mutationsZuser_input_mutationsZ grad_paramsZgrad_user_inputs loss_outputrrr output_tokens)rrr )rzUFile "torch/fx/passes/runtime_assert.py", line 24, in insert_deferred_runtime_assertsrkzexported program: )r)replace_set_grad_with_hop_passrrrl)DrW_Cis_grad_enabledrr3rrutilsZ statelessZ_reparametrize_moduler`rrgrXrYrr|updater:Zbackward_signaturer]Z tree_leavesri parametersbuffersrryrzrr[r9rMrr r!r"buffers_to_mutateZuser_inputs_to_mutateZgradients_to_parametersZgradients_to_user_inputsr# enumeraterrreversedrwr$r= torch._guardsr! torch._dynamorZdo_not_emit_runtime_assertsrrmrnrr/rr(Z3torch._export.passes.replace_set_grad_with_hop_passr%rrrrrrP)rrrrrrrrr'Zgrad_safe_guardrrQZis_joint flat_argsindexZtotal_non_user_inputsr}Zuser_argrrexport_graph_signaturer!rUZ_dynamo_configrlr%_modrSrN)rrrO_export_to_aten_ir!s  2                     r5cCsDi}|jddD]\}}|||<q|jddD]\}}|||<q.|S)NFr)rr)rrrrrrNrNrOrs   r)rrwrxrcst|j}|j|j}g}|D]D\}|jjtjj kr^| fddt |Dq$| q$|r| dd|D|S)a Gets the argument names to forward that are used, for restoring the original signature when unlifting the exported program module. - Positional args: retain the original argument names, and enumerate *args as args_0, args_1, ... - Keyword args: retain the original kwarg names in the order specified by the user. This order seems to matter for the current state of export lifted modules. csg|]\}}d|qS)rrN)rrrrrNrOrsz*_get_forward_arg_names..cSsg|] \}}|qSrNrN)rkwargrrNrNrOrs) rrforward bind_partial argumentsrr*rv_ParameterKindVAR_POSITIONALextendr-r)rrwrxrR_argsnamesrrNrrO_get_forward_arg_namess   r?orig_mod_bufferstraced_mod_buffersrrScCsN|jD]B}|jtjkr|jdk s$t||j}||krtj|_|||j<qdS)zrDynamo erroneously marks tensor attributes on modules as a buffers. Rewrite them to be tensor constants. N)rrvr6rr{ror)rArBrrSrrrNrNrO _rewrite_dynamo_tensor_constantss   rC)orig_modrrScCsb|}|jD]N}|jtjkr|jdk s,t|j|kr|j|ksDtd|_||j||j<qdS)zDynamo erroneously drops the persistent flag on buffers. Rewrite non-persistent buffers to reflect the original module. NF) state_dictrrvr6rr{ro persistentZ get_buffer)rDrrSrErrNrNrO_rewrite_non_persistent_bufferss    rG)rprc Cst|gt|D]\}}t|tjjs.q|jjD]}|j dkr|dkr|j dd}dkrzt d|d|j dt dd |Dst d|d|j d |q6|j d kr6|j ddr6t d|d|j d q6qdS) a Perform nn_module_stack checks on the graph. Current constraints: For the top level graph: - populated for 'call_function', 'get_attr' - None for 'placeholder', 'output' For submodule graphs: - None for 'placeholder', output' TODO(pianpwk): make this a consistent node-level check once nn_module_stack is populated for cond submodules. rurrrNNode of type z$ is missing nn_module_stack metadatacssD|]<\}}t|to:t|to:t|dko:tdd|DVqdS)css|]}t|tVqdSr)rgrZ)rrcrNrNrO Hsz4_verify_nn_module_stack...N)rgrZrriallrkvrNrNrOrLDs  z*_verify_nn_module_stack..z[ has incorrect nn_module_stack metadata formatexpected Dict[str, Tuple[str, str]], but got rz7 contains nn_module_stack metadata, this should be None)r-listrrgrWrXrYryrzrr|rrrMr)rprrr}rrNrNrO_verify_nn_module_stack+s.    rRc Cst|gt|D]\}}t|tjjs.q|jjD]v}|j dd}|j dkr|dkst|t st d|d|j d|q6|j dkr6|r6t d|d|j d|q6qdS) z Perform stack trace checks on the graph. Constraints: - None or non-empty str for 'call_function', 'get_attr' - None for 'placeholder', 'output' rlNrHrIrJzP has invalid stack_trace metadata, expected a string or None but instead found: rzA contains stack_trace metadata, expected None but instead found: )r-rQrrgrWrXrYryrzr|rrrZr)rprrr}rlrNrNrO_verify_stack_traceVs   rS)rQrRc Csdd|jD}|D]r}t|tjjs,q|jjD]T}|jdkr4|j |krNq4||j }t |}|j |s4t d|j d|d|q4qdS)a  Performs a sanity check on the placeholder node names. - User input nodes: no restrictions, should match the original forward() signature - Params/buffers/constants/custom_obj/token nodes: should start with prefixes defined in cSsi|]}|jj|jqSrN)rrrv)rrrNrNrOrvsz-_verify_placeholder_names..rzPlaceholder node name z does not follow spec for z, name should have prefix: N) rrrgrWrXrYryrzrrrrhr)rQrRZ name_to_kindrr}Z node_kindprefixrNrNrO_verify_placeholder_namesps      rU)eprcCsd}t}|jD]r}t|tjjs(q|jjD]T}|j dkr@q0|d7}t |j dsXt t |j dsht | |j jd|j jq0q||dS)Nrrur2rFrErf)op_countop_set)rMrprrgrWrXrYryrzrrr{rorrFrE)rVrWrXrr}rNrNrO get_ep_statss   rY _EXPORT_FLAGS_EXPORT_MODULE_HIERARCHYcstfdd}|S)Nc szz.wrapper)rmwraps)rbrcrNrarO_log_export_wrappersrecCs^t|tttfs|f}n2t|tr,t|}nt|tjtfrJ|dkrJ|f}|dkrVi}||fSr)rgrrQdictrWr[)example_inputsZexample_kwarg_inputsrNrNrO$_process_jit_trace_inputs_for_exports  rh)objccs.|j}|||j|_z dVW5||_XdS)znHelper method to make it easier to cleanly torch.export() a method on a module that is not `forward`. N)r7__get__ __class__)riZ new_methodZoriginal_methodrNrNrO patch_forwards  rlc cs4tj}tjdz dVW5tj|XdSr^)rWr&Z_jit_texpr_fuser_enabledZ_jit_set_texpr_fuser_enabled)Zoriginal_staterNrNrO_temp_disable_texpr_fusers    rmcs$eZdZfddZddZZS)_WrapperModulecst||_dSr)super__init__r)rrrkrNrOrps z_WrapperModule.__init__cOs |j||Sr)r)rrwrxrNrNrOr7sz_WrapperModule.forwardrErFrGrpr7 __classcell__rNrNrqrOrns rnc Cstddlm}t||\}}t||tjjfrVt|||ddd W5QRSt|tj rt| tjjtj j frt| |4t| ||ddd W5QRW5QRSQRXn&tt|||ddd W5QRSW5QRXdS)Nr)TopLevelTracedModuleFT)rr)rmZtorch.jit._tracertrhrgrWr&Z ScriptModule_exportmoduleZ ScriptMethodownerrrrlrn)Ztraced_callablerwrxrtZ export_argsZ export_kwargsrNrNrO"_convert_ts_to_export_experimentals< * rx) rrwrxrrroriginal_state_dict orig_in_specr_disable_forced_specializationsrc ( Cst|||||d|dd} t| ||\} } }}| jjD]V}|jdkr4d|jkr4t| |j}t|t j j s4|dk svt d|j |dd|jd<q4i}| jjD]}|j}|j}|jdkr"t| |}t|t j j r"|jddd D]\}}|||d |<q|jddd D]\}}|||d |<q|jdkrPt| |}t|t jjsP|||<|jd krt|jt jjs|jD]@}|jdkrpt jjjD]"}||kr||||j|<qqpq| j}}|dk st |jttfkrttd|g}| jjjj}t t!|| j"|| j_| #t$| t|t%|}|"t&| t'|| | i|||d }W5QRX|j(}|j)} |j*}!|+D]}"|",d d|",ddqr|jjD]}|jdkr|j| j-kr| j-|j}#|#|kr||#.D]\}$}%|%|j|$<q|j| j/kr| j/|j}&|&|kr||&.D]\}$}%|%|j|$<q qt0t1|2t3| | |!dt4|| }'t5|'| t6|| |!t7|| |!t8|| ||_9||_:| jd|_;|S)NF)rrrrrrzbCannot find dynamo_fake_mode. This could be due to the exported graph module have no placeholders.TrZ call_module)recurserrfru)rrrlrr@rV)._tuplify_outputs.._aot_export_non_strict..Wrappercst||_dSr)rorpre)rrrqrNrOrps zf_non_strict_export.._tuplify_outputs.._aot_export_non_strict..Wrapper.__init__c sbt|jtjjr@tjjtj|jj||}W5QRXn |j||}t |\}t |Sr) rgrerWrXrY tracebackZpreserve_node_metaZ Interpreterrunr] tree_flattenr)rrwrxZtree_outZ flat_outsrTrNrOr7s ze_non_strict_export.._tuplify_outputs.._aot_export_non_strict..Wrapper.forwardrrrNrrqrOWrappers rcSsg|] }d|qS)z _export_root.rN)rrrNrNrOrsz`_non_strict_export.._tuplify_outputs.._aot_export_non_strict..rxz%Exported program from AOTAutograd: %srcSsi|]\}}t||qSrN)rd)rrrrNrNrOrsz`_non_strict_export.._tuplify_outputs.._aot_export_non_strict..)rWrrrlogdebugr]Ztree_maprar*r+r!r r,ryrzr|r) rrwrxrrZ wrapped_modZnew_preserved_call_signaturesrQrRr}r) aot_exportrVrTrrNrO_aot_export_non_stricts>   zL_non_strict_export.._tuplify_outputs.._aot_export_non_strict)NrN)rr)rVrTr)rrO_tuplify_outputss3z,_non_strict_export.._tuplify_outputs)rr)rrrcs(i|] \}}|t|tr |n|qSrN)rgr")rrri)map_fake_to_realrNrOr0sz&_non_strict_export..)r{r)rrrrr5rSrrrQr)r1r r r rZrGrRrTrUrV)rrwrxrrrryrzrr{rrrUrrZequalities_inputsZoriginal_signaturerZ patched_modZ new_fake_argsZnew_fake_kwargsZnew_fake_constant_attrsrr rN)rrVrTrrO_non_strict_exportsv <   "r)rrrrr{r) rrwrxrrrrrr{rrc Csnt|ts ttjdt||r4|r4ttjdt|at} | |rNdnd| |r`dndt d| d| a |p|i}t|t j jr||||}t||f\} } |jd d } | st|||}nd }|rtnt}|||||||| | ||| }|j}|j}|j}|j}|j}|j}||jd <d d|jjD|jd<t ddt!|j"Dt#|j"}t$|||| d}t%|||||}|rt&|||i}|D]4\}}|st'|n|}t(fggd|||<qt#|dkr|st)|t*|||}|d k s t+|j,}|d k s t+t-|t.|| s@t/||t0||j1|| |t2t| ||||f|jd}|S)a Traces either an nn.Module's forward function or just a callable with PyTorch operations inside and produce a ExportedProgram. Args: f: the `nn.Module` to trace. args: example positional inputs. kwargs: optional example keyword inputs. dynamic_shapes: An optional argument where the type should either be: 1) a dict from argument names of ``f`` to their dynamic shape specifications, 2) a tuple that specifies dynamic shape specifications for each input in original order. If you are specifying dynamism on keyword args, you will need to pass them in the order that is defined in the original function signature. The dynamic shape of a tensor argument can be specified as either (1) a dict from dynamic dimension indices to :func:`Dim` types, where it is not required to include static dimension indices in this dict, but when they are, they should be mapped to None; or (2) a tuple / list of :func:`Dim` types or None, where the :func:`Dim` types correspond to dynamic dimensions, and static dimensions are denoted by None. Arguments that are dicts or tuples / lists of tensors are recursively specified by using mappings or sequences of contained specifications. preserve_module_call_signature: A list of submodule paths for which the original calling conventions are preserved as metadata. _allow_complex_guards_as_runtime_asserts: With the current dynamic shapes language for dims and derived dims, we can run into constraints that are not expressible with the language. For example, flattening a matrix and adding to a vector, both fully dynamic (i.e. x.reshape([-1]) + y) emits a guard s0 * s1 = s2, which is not expressible. By default, we either raise a constraint violation error or specialize to static values. If this flag is set to True, we avoid erroring out and instead allow complex constraints to exist as runtime assertions in the graph. The sympy interpreter (torch/utils/_sympy/interp.py) will produce the math ops required to compute and assert the value of the guard (e.g. sym_size_int, eq, _assert_scalar). Additionally, if TORCH_DYNAMO_DO_NOT_EMIT_RUNTIME_ASSERTS=1 is specified, we will allow complex constraints while not emitting runtime asserts, returning a cleaner graph with lesser guarantees around dynamic shapes. _disable_forced_specializations: Similar to _allow_complex_guards_as_runtime_asserts, but only avoids specializing to static values if set to True. For complex guards that don't specialize, this flag doesn't have any effect. Ideally this would be subsumed by _allow_complex_guards_as_runtime_asserts, but this handles one additional case: single-variable equalities where the symbol is solvable for a concrete value (e.g. Eq(s0 // 4, 400) -> s0 = 1600). If set to True, this flag will avoid specializations. Direct equalities (e.g. s0 = 4), will still specialize. Returns: An ExportedProgram containing the traced method. rzL_disable_forced_specializations can be only be specified in non-strict mode.rZ non_strictrZ aot_dispatchz export.enterrT)Z keep_varsNforward_arg_namescSsi|]\}}t|r||qSrN)r*rNrNrNrOrsz_export..Zinline_constraintscss"|]\}}|jtjkr|VqdSr)rvr6Z USER_INPUT)rrsrNrNrOrLs z_export..)r)rrr)rryrrErqZmodule_call_graphrgrS)3rgrr r rrrr[rMrr%rZrWrZShapesCollectionrr]rrEr?rrrQrRrTrSrUrVr|rZ var_to_rangerrr-rrir&rrsrar8rrrorprRrSrUr5ryr) rrwrxrrrrrr{rrr1rzryrZ export_funcrrQr3rTrSrUrVZ num_liftedZ combined_argsrqrrspecsZmod_fqnrrexported_programrNrNrOruLsA        ru)NN)N)N)NN)rKrmrloggingrr]warnings contextlibrrtypingrrrrrr r r rWr0Ztorch.fxZtorch.utils._pytreer(Z_pytreer]Ztorch._dynamo.excr r Ztorch._export.non_strict_utilsrrrrrrZ(torch._export.passes._node_metadata_hookrrZ@torch._export.passes.add_runtime_assertions_for_constraints_passrZ-torch._export.passes.collect_tracepoints_passrZ(torch._export.passes.lift_constants_passrrrZtorch._export.utilsrrZtorch._export.verifierrZtorch._export.wrappersrZtorch._functorch.aot_autogradrr/r!Z"torch._library.fake_class_registryr"Ztorch._subclasses.fake_tensorr#r$Ztorch._utils_internalr%Ztorch.export.dynamic_shapesr&Ztorch.export.exported_programr'Ztorch.fx._utilsr(Z%torch.fx.experimental.symbolic_shapesr)r*r+r,Ztorch.fx.graphr-r.Ztorch.fx.passes.runtime_assertr/r0Ztorch.utils._sympy.value_rangesr1Z _safeguardr3rr4r5r6r7r8rr9r:r;r<r=r>r?r@ getLoggerrEr dataclassrArPr criticalrerror exceptioninfowarningprintwarnrDr`rdrarsrrrrrrrrZrr[r\rrXrYrrrrrIrr5rr?rCrGrRrSrUrYrZrJr[rerhrlrmrnrxrrrurNrNrNrOs(                (    $ 4 *  2 $       K 9      +!  &      0