o Zh @szddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddlm Z ddl m Z mZmZmZmZmZddlmZddlmZddlmZmZmZdd lmZdd lmZdd lm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&erddl'Z'ddl(m)Z)ddl*Z*ddl+m,m-Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZBddlmCZCddlDmEZEmFZFddlGmHZHddlImJZJddlKmLZLddlMmNZNddlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\gdZ]ee*j^j_geeLfZ`ejaGdddZbejaGdddZcdd Zdd!eeed"e.jfd#eeed$e.jfd%egf d&d'Zhe*jijjjke*jijjjle*jijjjme*jijjjne*jijjjoe*jijjjpe*jijjjqe*jijjjre*jijjjse*jijjjte*jijjjue*jijjjvg Zwe*jijjjxe*jijjjye*jijjjze*jijjj{e*jijjj|e*jijjj}e*jijjj~e*jijjje*jijjjg Ze dPd)d*Ze d+d,Zd-ee*jjefd%eee*jjefd.ffd/d0ZdQd2d3Zd4ee*jjefd5ee*jjefd6eefd7d8Zd9e*j^j_d:eSd%ee*j^j_eSffd;d<Zd9e*j^j_fd=d>Zd9e*j^j_d?eecfd@dAZd4ee*jjefd5ee*jjefd6eedBegfdCdDZGdEdFdFZdGdHZ dRd9e*j^j_dIdJd%dKfdLdMZdNdOZdS)SN) namedtuple)Iterator)contextmanager)AnyCallablefinalOptional TYPE_CHECKINGUnion)autograd_not_implemented)FakeScriptObject)_deregister_op_impl_is_op_registered_to_fake_ruleregister_op_impl)FakeTensorMode)#first_call_function_nn_module_stack)_PyTreeCodeGen _PyTreeInfo)immutable_dictimmutable_list)insert_deferred_runtime_asserts) ValueRanges)_collect_all_valid_cia_ops_collect_and_set_constant_attrs_collect_param_buffer_metadata_detect_fake_mode_from_gm_fakify_params_buffers_get_decomp_for_cia_is_preservable_cia_op_name_hoo_subgraph_placeholders7_override_graph_signature_for_temp_registered_constants/_overwrite_signature_for_non_persistent_buffers)_populate_param_buffer_metadata_to_new_gm_register_constants_as_buffers_rename_without_collisions_special_op_to_preserve_ciaplaceholder_naming_pass)Verifierdetect_fake_modeunset_fake_temporarily) is_equivalentreorder_kwargsCustomDecompTable) compatibility) PassResult) PassManager) ArgumentSpecConstantArgumentCustomObjArgumentExportGraphSignature InputKind InputSpec OutputKind OutputSpecSymBoolArgumentSymFloatArgumentSymIntArgumentTensorArgument TokenArgument)ExportedProgramModuleCallEntryModuleCallSignaturedefault_decompositionsc@sVeZdZUeeed<eeed<ejed<ejed<dZe ee ed<ddZ dS) rCinputsoutputsin_specout_specNforward_arg_namescCsD|jD] }|j|jkr|j|_q|jD] }|j|jkr|j|_qdSN)rEnamerF)selfZ original_nodenew_nodeiorPL/var/www/auris/lib/python3.10/site-packages/torch/export/exported_program.pyreplace_all_uses_withfs    z)ModuleCallSignature.replace_all_uses_with) __name__ __module__ __qualname__listr4__annotations__pytreeTreeSpecrIrstrrRrPrPrPrQrC^s     rCc@s&eZdZUeed<dZeeed<dS)rBfqnN signature)rSrTrUrZrWr\rrCrPrPrPrQrBos rBcstfdd}|S)Ncs8t|i|WdS1swYdSrJr*)argskwargsfnrPrQwrappervs $z/_disable_prexisiting_fake_mode..wrapper) functoolswraps)r`rarPr_rQ_disable_prexisiting_fake_modeusrd spec1_type spec1_context spec2_type spec2_contextreturncCsx|dus|dur||uo||kSt|ttfr"t|ttfr"||kSt|ttfr4t|ttfr4||kS||uo;||kS)zeTreat containers and their immutable variants as the same type. Otherwise compare as normal. N) issubclassdictrrVr)rerfrgrhrPrPrQ_fx_collection_equivalence_fn~s rlTc csbi}t}|D]h\}}|j||<||tD]}||jvr.||t|ddqt|}t j j j |jvrB|jt j j j =|rN|t j j j |dd}t |sat|tj||dtD]} | |jvrq|| |qcq z!dVW|D]} | j| j|| | jt| qzdS|D]} | j| j|| | jt| qw)NT)Zdeferred_errorc_sD|d}|d=|||i|WdS1swYdS)Noriginal_callablerP)Zfake_tensor_modeopr]r^orig_cia_callablerPrPrQ$_force_dispatch_to_orig_cia_callables  $zQ_override_composite_implicit_decomp.._force_dispatch_to_orig_cia_callable)rm)setitemsZ py_kernelscopyadd(_AUTOGRAD_ALIAS_BACKEND_KEYS_TO_OVERRIDEZpy_implr rtorch_C DispatchKeyZCompositeImplicitAutogradrrrbpartial_BACKEND_KEYS_TO_OVERRIDEclearupdateZ_dispatch_cacher ) cia_ops_to_callablesafeZ saved_tablesZ patched_opsZ op_overloadZdecomp_callableZoverride_dispatch_keyrorpkeyrnrPrPrQ#_override_composite_implicit_decompsZ          rccsRttjjjjttjjjjtidd dVWddS1s"wYdS)NF)r~)rrvopsatentoZ dtype_layoutr%ZdtyperPrPrPrQ!_override_decomp_aten_to_variantss  "r decomp_table.cCstt}i}t|D],}||vr"||||<||||=q t|r9|}|dr3Jd||||<q |D]}t||<q<||fS)NrzThis should be a custom op) rqrrVkeysremoverrK startswithr%)rZall_preservable_cia_opsr}rnZop_namekrPrPrQ,_split_decomp_table_to_cia_and_python_decomp's     rr/cCstS)z This is the default decomposition table which contains decomposition of all ATEN operators to core aten opset. Use this API together with :func:`run_decompositions()` r.rPrPrPrQrDSsrD cia_to_decomppython_decomp_tablejoint_loss_indexcJs ddlm}ddlm}ddlm}m}m} m} m } m } ddl m } dd}|||s| }it|jdd t|jdd }dd lm}||it|jdd t|jdd }t|j}|durnt| d d }|j}|jjjj}|jttfvrttd|g}t t!||j"||j_|#t$|j%|j&|t'||j(|j%j)}t*||}t+|}dd l,m-}m.}g}|jj/D]8}|j0dkrt1|j2dt3rd}|j2dj4dur|j&|j2dj5}n|j2dj4j6}|7|q|7|j2dq|t8t9|||j:xt;||j"}||g|d|d<Ri|N\}} }!}"||| |!||"|dd|d }#fdd|#j&=D|#_&|#j>}$|#j?}%t@|%|}%tA||$|%tB|j%|%}%||$|%|"}&tC|$|%|| |!||&Wdn 1sswYWdn 1swYWdn 1swYWdn 1swYWdn 1swY| |$| |$| |$|%tD|$|%\}$}%|=D]\}'}(|'|vr|(|j(|'<q|=D]&\}'}(|'|j(vrt1|(tEjFjGrJ|'|j(vr |'|vr |j(H|'q|$|%|j(fSdd|jjj/D})dd|)D}*dd|jD}+|+D] }'tI|j|'q.tJ|*}|durEtKLn|}|rMtKjLn|},| c|Pt9|;|,'||j|*||durkd nd|durs|ndd\}$|$jMWdn 1swYWdn 1swYWdn 1swYWdn 1swYdddd|$jj/Dt|$jj/djNd}-tOtO|)ksJtP|)D] \}.}/|.j5|/_5|/_QqddD}0|$jj/D]}|j0dkrqtR|0|j5|j5|_5qtS|$ddlTmU}1mV}2ddlWmX}3tEjYjZj[s_d }4t\|$}5|5dur_|2|$t]j^|1|4d!t_|$|5d"t`|$jd d#Wdn 1sZwY|$#ta|3|$D]\}6}'t1|-|6tEjbjcr||'|-|6_5qifd$dta|j%jdD}7fd%dta|j%jdD}8g}9d&dtajeD}:tjfg};|;d'd|-dtO|;DksJjf=D]C\}<}=|:|=}6|j%jd|6}>|>jhtijjtijkfvsJ|>jhtijkkrtljmntljn}?|>jhtijkkr|>jQn|>joj5}@|97tp|?tq|\}6}|B|j5}D|C|D}A|Ajhtijwkrtljx}E|AjQ}@n|Ajhtijjkrtljy}E|D}@ntzd+|Ajh|97tp|Etq|j5d(|@qktOtO|)ksJt{|8|9d,}%tP|)D]5\}F}Gt1|Fj2dtEj|s|Fj2d|Gj2d<|GjQ|%j}vs|GjQ|%j~vr|Fj2=D] \}H}I|I|Gj2|H<qq|$|%|j(fS)-Nr)_materialize_and_lift_constants)aot_export_module)2_disable_custom_triton_op_functional_decomposition_export_to_aten_ir_ignore_backend_decomps_verify_nn_module_stack_verify_placeholder_names_verify_stack_trace)ShapeEnvcSs|dup |jjduSrJ)graph_signaturebackward_signature)eprrPrPrQ_is_joint_ir_decompps zO_decompose_and_get_gm_with_new_signature_constants.._is_joint_ir_decompF)Zremove_duplicate)!unwrap_tensor_subclass_parametersT) shape_envexport)&_enable_graph_inputs_of_type_nn_module_fakify_script_objects placeholdervalr3)rZ_check_autograd_stateZ_prettify_placeholder_namesdecompose_custom_triton_opscs(i|]\}}|t|tr|n|qSrP) isinstancer ).0r[obj)map_fake_to_realrPrQ s zF_decompose_and_get_gm_with_new_signature_constants..cSg|] }|jdkr|qSrrnrnoderPrPrQ AszF_decompose_and_get_gm_with_new_signature_constants..cSsg|]}|jdqS)r)metarrPrPrQrDcSsg|]\}}|qSrPrP)rrK_rPrPrQrFs)ZdecompositionsZ trace_jointZoutput_loss_indexcSsxt|tr|St|trt|jdSt|trt|jdSt|tr(t|jdSt|tr3t|jdStdt|)NrKzType of old_arg not supported: ) rr5r?rKr>r=r< RuntimeErrortype)Zold_argnew_phrPrPrQ update_argbs         zF_decompose_and_get_gm_with_new_signature_constants..update_argcSrrrrrPrPrQrocSsi|]}|j|jqSrPr)rphrPrPrQrxr)_node_metadata_hook_set_node_metadata_hook)_graph_output_nameszUFile "torch/fx/passes/runtime_assert.py", line 24, in insert_deferred_runtime_asserts) stack_tracezexported program: )rcs,i|]\}}t|jts|jj|jqSrP)rargr5rKrrNspec)new_placeholdersrPrQrs  cs0g|]\}}t|j|j||j|jqSrP)r9kindrtarget persistentr)rrrPrQrscSsi|]\}}||qSrPrP)rrNrKrPrPrQrrcSsg|]}|jqSrPrrrPrPrQrsr)rrrcs(i|]\}}t|jtrj||qSrP)rrr? user_inputsr)rrPrQrs   zUnknown input kind:  input_specs output_specs)Z(torch._export.passes.lift_constants_passrZtorch._functorch.aot_autogradrtorch.export._tracerrrrrrZ%torch.fx.experimental.symbolic_shapesrmodulerknamed_parameters named_buffersZ7torch._functorch._aot_autograd.subclass_parametrizationrr graph_modulerZ _out_specgraph_codegenZ pytree_info orig_argsrrVtuplerXrYrrZ_in_spec recompilerr constantsr# state_dictnon_persistent_buffersrrZtorch._export.non_strict_utilsrrnodesrnrrr6Zfake_valrKZreal_objappendrrexample_inputstree_unflattenvaluesrrgmsigr r"r!r&!_remove_unneccessary_copy_op_passrvnn Parameterpopdelattrr) contextlib nullcontextZeliminate_dead_coder]lenziprr$rZ(torch._export.passes._node_metadata_hookrrZ4torch._functorch._aot_autograd.input_output_analysisrZ_dynamoconfigZdo_not_emit_runtime_asserts_get_shape_envrbryrr enumeratefxNoderruser_inputs_to_mutaterrr8 USER_INPUTBUFFERr:BUFFER_MUTATIONUSER_INPUT_MUTATIONrr;r?rZ LOSS_OUTPUTgetrZgradients_to_user_inputs PARAMETERZGRADIENT_TO_PARAMETERZGRADIENT_TO_USER_INPUTAssertionErrorr7TensorZinputs_to_parametersZinputs_to_buffers)JrrrrrrrrrrrrrrrmodZwrapped_params_buffersrZunwrapped_params_buffers fake_moderHZorig_arg_namesZtemp_registered_constantsZfake_params_buffersZparams_buffers_to_node_metarrZretracing_argsrZreal_script_objZretracing_args_unwrappedZ patched_modZ new_fake_argsZnew_fake_kwargsZnew_fake_constant_attrsZaten_export_artifactrnew_graph_signaturerrKpZold_placeholdersZ fake_argsZbuffers_to_removeZ#custom_triton_ops_decomposition_ctxZ new_outputsZold_phrZname_maprrrrrrNZold_new_placeholder_maprrZuser_inputs_indexZmutation_namesZ output_nameZ input_nameZ input_specZ output_kindrrZ gradientsspecssourcerold_noderMrvrP)rrrrrQ2_decompose_and_get_gm_with_new_signature_constants\sB                 R                       $        rrrcCs||Q|jjD]=}|jdkrIt|j\}}|D]+}t|t j j rH|j |j vrH|jdkrH|jt jjjjkrH||jd|j|qq |Wd||fS1s[wY||fS)zQ Removes redundant copy_ node that was introduced due to mutated buffer. output call_functionr3N)_set_replace_hookget_replace_hookrrrnrX tree_flattenr]rrvrrrKbuffers_to_mutaterrrrsdefaultrR erase_noder)rrrr]routrPrPrQrs$        rc Cs||q|D]c}t|tjjsq i}i}t|jj D]N}|j dkri|j t j kri|j\}}||d|} | |vr`||| |D]} | jdurX| j||| qH|j|q ||| <| ||<q |j||<q q WddS1s{wYdS)Nr.)rrmodulesrrvr GraphModulerVrrrnroperatorgetitemr]rRr\rrK) rrmodule_call_graphrZnode_idZgetitemsrridxZnew_identryrPrPrQ _common_getitem_elimination_pass's2     "r old_module_call_graphc Cst|}i}|jjD]}|jdg}r|j||dj<q |D]}|j}|dur+q!g|j|j D] }||j|j|_q3q!|S)NZ from_noder) rsdeepcopyrrrrrKr\rErF) rrnew_module_call_graphZ provenancerhistoryr r\xrPrPrQ_get_updated_module_call_graphDs  rrc Csbt|||||d\}}}t||j}|j|jjt||j} t||j ||| ||j |j d} | S)Nrrrr)rootrrrrange_constraintsr rr) rrr rr|r_get_updated_range_constraintsrrArrr) rrrrrrrrrZnew_range_constraintsZexported_programrPrPrQ_decompose_exported_program\s>   rc@seZdZdZ  dcdddeejjee e ffdej j de dee eejejjffdd d eed eeee d fee e ffd eee eejeejjffdeeeefddZeeddddZejeddddZeeddddZejeddddZeeddddZejeddddZeeddddZ e jeddddZ eddde!ejjfd d!Z"eddde!ee ejjffd"d#Z#eddde!ejfd$d%Z$eddde!ee ejffd&d'Z%eeddd(d)Z&e&jeddd*d)Z&eeddd+d,Z'e'jeddd-d,Z'eeddd.d/Z(e(jeddd0d/Z(eeddd1d2Z)e)jeddd3d2Z)eeddde fd4d5Z*e*jeddd6d5Z*eeddde fd7d8Z+e+jeddd9d8Z+eeddd:d;Z,e,jedddZ-e-jeddd?d>Z-eeddd@dAZ.e.jedddBdAZ.dCdDZ/dEe dFe de fdGdHZ0dEe dFe de fdIdJZ1dKdLZ2de fdMdNZ3dejjfdOdPZ4dQdRZ5e6  dddSeeej7j8e9fdTe:ddfdUdVZ;dWeeddd\d]Z?e@d^d_ZAdddd` dedadbZBdS)frAa Package of a program from :func:`export`. It contains an :class:`torch.fx.Graph` that represents Tensor computation, a state_dict containing tensor values of all lifted parameters and buffers, and various metadata. You can call an ExportedProgram like the original callable traced by :func:`export` with the same calling convention. To perform transformations on the graph, use ``.module`` property to access an :class:`torch.fx.GraphModule`. You can then use `FX transformation `_ to rewrite the graph. Afterwards, you can simply use :func:`export` again to construct a correct ExportedProgram. N) verifiersrrrrrdict[sympy.Symbol, Any]r r.rrc  Cstjj|_t|||_t|tjjr|jj |j t |j||||_ ||_ ||_|dus2J||_||_|p;i|_| pAtg} tdd| DsMJ| |_|dS)Ncss|]}t|tVqdSrJ)rjr')rrrPrPrQ sz+ExportedProgram.__init__..)rvrrZCodeGenr_create_graph_module_for_export _graph_modulerrrr|r _graph_signature _state_dict_range_constraints_module_call_graph_example_inputs _constantsr'all _verifiersvalidate) rLrrrrrr rrrrPrPrQ__init__s$     zExportedProgram.__init__F)Zis_backward_compatiblecC|jSrJ)rrLrPrPrQrzExportedProgram.graph_modulecCtd)Nz7Unable to set ExportedProgram's graph_module attribute.rrLvaluerPrPrQrcCs|jjSrJ)rrr)rPrPrQrr/zExportedProgram.graphcCr+)Nz0Unable to set ExportedProgram's graph attribute.r,r-rPrPrQrr/cCr(rJ)rr)rPrPrQrr*zExportedProgram.graph_signaturecCr+)Nz:Unable to set ExportedProgram's graph_signature attribute.r,r-rPrPrQrr/cCr(rJ)rr)rPrPrQrr*zExportedProgram.state_dictcCr+)Nz5Unable to set ExportedProgram's state_dict attribute.r,r-rPrPrQrr/ricc|D]\}}|VqdS)zH Returns an iterator over original module's parameters. N)r)rLrparamrPrPrQ parameterszExportedProgram.parametersccs$|jjD] }||j|fVqdS)z Returns an iterator over original module parameters, yielding both the name of the parameter as well as the parameter itself. N)rr2r)rL param_namerPrPrQrs z ExportedProgram.named_parametersccr0)zC Returns an iterator over original module buffers. N)r)rLrbufrPrPrQbuffersr3zExportedProgram.buffersccsJt|jj}|jjD]}||vr||j|fVq ||j|fVq dS)z Returns an iterator over original module buffers, yielding both the name of the buffer as well as the buffer itself. N)rqrrr6rr)rLrZ buffer_namerPrPrQrs  zExportedProgram.named_bufferscCr(rJ)r r)rPrPrQrr*z!ExportedProgram.range_constraintscCr+)Nz.)r<rGr-rXZtree_flatten_with_path_check_input_constraintsr)rLr]r^rGflat_args_with_path received_spec flat_argsrPrPrQ_get_flat_args_with_checks   z)ExportedProgram._get_flat_args_with_checkr]r^cCs|jj}|||\}}|dur t||ts td|d|g}|jjD]=}|jt j kr/q&|jt j t j fvrQ|j durG||j|jq&||j|jq&|jt jt jfvrc||j|jq&t|}||S)a,Transform args, kwargs of __call__ to args for graph_module. self.graph_module takes stuff from state dict as inputs. The invariant is for ep: ExportedProgram is ep(args, kwargs) == ep.postprocess(ep.graph_module(ep.graph_module_flat_inputs(args, kwargs))) Nz>Trying to flatten user inputs with exported input tree spec: z- but actually got inputs with tree spec of: F)r<rGrIr,rlr:rrrr8rrrrrrrrZCONSTANT_TENSORZ CUSTOM_OBJr)rLr]r^rGrHrGZadditional_inputsZinput_rPrPrQ_graph_module_flat_inputss>     z)ExportedProgram._graph_module_flat_inputscOr+)Nz\Unable to call ExportedProgram directly. You should use `exported_program.module()` instead.r,)rLr]r^rPrPrQ__call__szExportedProgram.__call__c sFddlmm}|||\}}|jjdur!|jj}|jj}t |t |} |d| } |jj } | durDt t | } |d| }|| d}z~z t||jj}Wntypt|\}} |d|jjd| wWdd|jjD}t| D]G\}}|jj|jtjkrjdusJ||jj<qjtjkrjdusJt fddt|D}|||qtd j|Sdd|jjD}t| D]I\}}|jj|jtjkrjdusJ||jj<qֈjtjkrjdusJt fddt|D}|||qtd jw|S) zProcess potential mutations to the input. Because self.graph_module is functional, so mutations has to be written back after execution of graph_module. rNz@Trying to flatten user outputs with exported output tree spec: z. but actually got outputs with tree spec of: cSsg|] }|jtjkr|qSrPrr8r)rrrPrPrQrs  zEExportedProgram._postprocess_graph_module_outputs..c3s&|]\}}|jjjkr|VqdSrJ)rrKrrZ output_specrPrQr szDExportedProgram._postprocess_graph_module_outputs..zUnexpected kind: )Ztorch._export.errorZ_exporterrorrIr<rHrrrrassertion_dep_tokennextiterrrXr ExceptionrZ InternalErrorrrrrr:rrrrZcopy_r)rLresrZ orig_kwargsrNrHrZbuffer_mutationZuser_input_mutationZ num_mutatedZmutated_valuesrOZassertion_dep_token_indexrGrrNr.indexrPrMrQ!_postprocess_graph_module_outputsst            z1ExportedProgram._postprocess_graph_module_outputscCs8|jjddddd}d|d|jd|jd}|S)NF)Z print_outputZcolored z zExportedProgram: z Graph signature: z Range constraints: )rZprint_readablereplacerr)rLrstringrPrPrQ__str__szExportedProgram.__str__cCsTddlm}||}d dtfdd}d dtfdd}t|||_t|||_|S) z_ Returns a self contained GraphModule with all the parameters/buffers inlined. r3)&_unlift_exported_program_lifted_statesTmodecSr+)Nz%Calling train() is not supported yet.NotImplementedErrorrLr[rPrPrQ_train*z&ExportedProgram.module.._traincSr+)Nz$Calling eval() is not supported yet.r\r^rPrPrQ_eval-r`z%ExportedProgram.module.._evalNT)r;rZbooltypes MethodTypetraineval)rLrZrr_rarPrPrQr"s zExportedProgram.modulecCs$tddt|jjDt|jjS)Ncss$|] \}}|jtjkr|VqdSrJrL)rrNsrPrPrQr6s z=ExportedProgram._num_lifted_params_buffers..)rPrrrrr)rPrPrQ_num_lifted_params_buffers4s   z*ExportedProgram._num_lifted_params_buffersrrcCsF|durtnt|}t|tr|}t|\}}t|||d|dS)a Run a set of decompositions on the exported program and returns a new exported program. By default we will run the Core ATen decompositions to get operators in the `Core ATen Operator Set `_. For now, we do not decompose joint graphs. Args: decomp_table: An optional argument that specifies decomp behaviour for Aten ops (1) If None, we decompose to core aten decompositions (2) If empty, we don't decompose any operator Some examples: If you don't want to decompose anything .. code-block:: python ep = torch.export.export(model, ...) ep = ep.run_decompositions(decomp_table={}) If you want to get a core aten operator set except for certain operator, you can do following: .. code-block:: python ep = torch.export.export(model, ...) decomp_table = torch.export.default_decompositions() decomp_table[your_op] = your_custom_decomp ep = ep.run_decompositions(decomp_table=decomp_table) Nr)rDrkrr/Z materializerr)rLrrZ _decomp_tablerrrPrPrQrun_decompositions>s( z"ExportedProgram.run_decompositionspassesc Gstt|}ddlm}| ||j}Wdn1swY|dur+|jn|j}|dus4J||jur>|js>|Sdtdtjj dtfdd}t ||j ||j ||j t||jt|j|j|j|jd }|jj|jj|jj|jj|S) Nr)r old_signaturenew_gmric Ss.g}t|jjD];\}}|jdkrn1|t|jksJd|j|}t|jtt fr.|jnt |j|j }| t |j||j|jqt|jjd}|jdksSJg}t|jdD]2\}}|t|jkskJd|j|} t| jtt fr{| jnt | j|j }| t| j|| jq\t||d} | S)zO Update the graph signature's user_input/user_outputs. rz-Number of inputs changed after transformationrrrz.Number of outputs changed after transformationr)rrrrnrrrrr5r6rrKrr9rrrrVr]rr;r7) rlrmZnew_input_specsrNrZold_input_specrZ output_nodeZnew_output_specsZold_output_specZ new_signaturerPrPrQ_get_updated_graph_signatures^      zKExportedProgram._transform_do_not_use.._get_updated_graph_signature rrrrrr rrr)r2rVrrrmodifiedr7rvrrrArrrrrrsrr!rrrrr|)rLrkpmrrSZtransformed_gmrnZtransformed_eprPrPrQ_transform_do_not_usesF     9 z%ExportedProgram._transform_do_not_usecCsHddlm}dd|jjD}ddt||jjD}||||jdS)Nr)"_check_input_constraints_for_graphcSrrr)rrrPrPrQrrz.cSs g|] \}}|jtjkr|qSrPrL)rrrhrPrPrQrs  )torch._export.utilsrsrrrrrr)rLrFrsZ placeholdersZinput_placeholdersrPrPrQrEs  z(ExportedProgram._check_input_constraintscCs |dSrJ) _validater)rPrPrQr&s zExportedProgram.validatecCs2t|jdks Jd|jD]}||qdS)Nrz0ExportedProgram must have at least one verifier.)rrcheck)rLrrPrPrQrus  zExportedProgram._validate)rrrc Cs\t||j||dur |n|jt|jt|j|j|dur|n|j|dur)|d S|j d S)Nro) rArrrsrrr!rrr)rLrrrrrrPrPrQ_updates     zExportedProgram._update)NN)NF)rirA)CrSrTrU__doc__r rvrModulerkrZrrGraphr7rrrVrBrrr rwZ ScriptObjectrr'r'propertyr0rsetterrrrrr2rr6rrr rr<rArBrrDrrIrJrKrUrYrrird_ops OperatorBaserrcrjPassTyperrrEr&rrurwrPrPrPrQrAs   '                           .7   F\   rAcCsZdd|jjD}ddlm}||}|dur|jS|D]}t|tjr*|jjSqdS)NcSs(g|]}|jdddur|jdqS)rN)rrrrPrPrQrs z"_get_shape_env..rr() rr torch._guardsr)rrrvZSymIntr)rvalsr)rrrPrPrQrs   rold_range_constraintsz!Optional[dict[sympy.Symbol, Any]]rcsr|dusJt|duriSt|}fdd|D}jD]\}}|jvr6||vr6|||<q%|S)Ncs i|] \}}|jvr||qSrP) replacements)rrrrrPrQr-sz2_get_updated_range_constraints..)rrsrrZ var_to_ranger)rrrrrrPrrQr"s   rcCsNz tj||}W|Sty&tdtj|tj}||_Y|Sw)NzUnable to execute the generated python source code from the graph. The graph module will no longer be directly callable, but you can still run the ExportedProgram, and if needed, you can run the graph module eagerly using torch.fx.Interpreter.)rvrr SyntaxErrorwarningswarnrzZ_graph)rrrrPrPrQr9s rrb)rir/rJ)rrs dataclassesrbrrdr collectionsrcollections.abcrrtypingrrrrr r Ztorch._higher_order_ops.utilsr Z"torch._library.fake_class_registryr Ztorch._subclasses.fake_implsr rrZtorch._subclasses.fake_tensorrZtorch.fx._utilsrZtorch.fx.graphrrZtorch.fx.immutable_collectionsrrZtorch.fx.passes.runtime_assertrZsympyZtorch.utils._sympy.value_rangesrrvZtorch.utils._pytreeutilsZ_pytreerXrtrrrrrrrrr r!r"r#r$r%r&Ztorch._export.verifierr'rr)r+Ztorch.export._tree_utilsr,r-Ztorch.export.decomp_utilsr/Ztorch.fx._compatibilityr0Ztorch.fx.passes.infra.pass_baser1Z"torch.fx.passes.infra.pass_managerr2rr4r5r6r7r8r9r:r;r<r=r>r?r@__all__rrr dataclassrCrBrdrContextrcrlrwrxZ AutogradCPUZ AutogradCUDAZ AutogradMetaZ AutogradXLAZ AutogradLazyZ AutogradIPUZ AutogradXPUZ AutogradMPSZ AutogradHPUZAutogradPrivateUse1ZAutogradPrivateUse2ZAutogradPrivateUse3ruZCPUCUDAZMetaZXLAZLazyZIPUZXPUZMPSZHPUrzrrrkr}r~rrrDintrrr rVrrrArrrrPrPrPrQs          D       <   [  ,  5    4