¯wg3dZddlmZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZddlZddlmcmZddlZddlZddlmZddlmZmZmZmZmZddlmZddlmZm Z m!Z!m"Z"gd Z#dAd Z$iZ%ejLdBd Z'ejLdCd Z(ejLdDd Z)ejLdEdZ* dFdZ+dddejXjZddej\j^dddddddd dGdZ0dZ1dZ2 dH dIdZ3dZ4dZ5 dJdZ6dZ7dZ8dKdZ9dZ: dL dMdZ;dNdZd"Z? dOd#Z@d$ZAd%ZBejejejejejejejejiZJdPd&ZKd'ZLdddej\j^dddejXjZdf dQd(ZMejejd)d*d+ddejXjZddej\j^ddddddddfd,ZPejd)d*d-ejXjZdf dRd.ZQ dSd/ZRd0ZSd1ZTddejXjZddej\j^dddddddddddf dTd2ZUd3ZVd4ZWd5ZXdUd6ZYdVd7ZZdWd8Z[ dXd9Z\dYd:Z]ej\j^f dZd;Z^d[d<Z_ d\d=Z`d]d>Zad?Zbd^d@Zcy)_zFunctions to export models into the ONNX IR format. These models can be loaded with the ONNX library and then converted to models which run on other deep learning frameworks. ) annotationsN)AnyCallablecast CollectionMappingSequence)_C) _constants _deprecation_exporter_stateserrorssymbolic_helper)GLOBALS) diagnostics jit_utilsonnx_proto_utils registration) is_in_onnx_exportselect_model_mode_for_exportdisable_apex_o2_state_dict_hooksetup_onnx_loggingexporter_contextexportmodel_signaturewarn_on_static_input_changeunpack_quantized_tensorexport_to_pretty_stringunconvertible_opsregister_custom_op_symbolicunregister_custom_op_symbolicc"tjS)z3Returns whether it is in the middle of ONNX export.)rin_onnx_exportU/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/torch/onnx/utils.pyrr3s  ! !!r%c#Kt|tjstdt |dd}t |dr|j }|tjjk(s|tjjk(rH|rFdt_ tjdkr3tjdtjdn dt_ |t_|tjjk(r|jdn.|tjj k(r|jd d t |dr0|tjjk(s|j|y y y #t |dr0|tjjk(s|j|wwwxYww) a"A context manager to temporarily set the training mode of ``model`` to ``mode``, resetting it when we exit the with-block. Args: model: Same type and meaning as ``model`` arg to :func:`export`. mode: Same type and meaning as ``training`` arg to :func:`export`. z:'mode' should be a torch.onnx.TrainingMode enum, but got 'z'.FtrainingT zEYou are exporting the model in training mode with onnx opset version zn. Opset versions lower than opset 12 will not be able to export nodes such as Dropout and BatchNorm correctly.N) isinstance_C_onnx TrainingMode TypeErrortypehasattrr(TRAININGPRESERVErexport_trainingexport_onnx_opset_versionwarningswarn training_modetrainEVAL)modelmodeoriginally_trainings r&rr=s dG00 1Hd TV W  !&uj!#nn 7''00 0 G((11 16I&*G #0025 &@@ABEE',G # $ 7''00 0 KK  W)).. . KK - 5* %dg6J6J6S6S.S KK+ ,/T %75* %dg6J6J6S6S.S KK+ ,/T %sEGF =G>GGc#Kt|tjjsi}|j D]x}|j j D]/\}}t|jdk(s||vri||<||||<1||vsT||D]}|j j|z d|j D],\}}|j D]\}}||j |<.y dy#|j D],\}}|j D]\}}||j |<.wxYw#wxYww)NO2StateDictHook) r*torchjitScriptFunctionmodules_state_dict_hooksitemsr.__name__pop)r9 model_hooksmodulekeyhookm_maps r&rrmsf eUYY55 6 mmo 6F#55;;= 4 T:&&*;;[0.0 F+/3K',  4 $&v.6C,,0056 6 9 "-!2!2!4 9 !&9IC48F,,S19 9   "-!2!2!4 9 !&9IC48F,,S19 9 sDA2E5E 'E5C?9AE:E>E?AEEEEc#$Ktjj}|s|rtjj d|stjj yy#|stjj wwxYwwN)r>onnxis_onnx_log_enabled enable_log disable_log)verboseis_originally_enableds r&rrsg!JJ::< % $ JJ " " $%$ JJ " " $%sABA*"B*#B  Bc #0Kt||5}t|5}t|5}tj5}||||fddddddddddddy#1swY"xYw#1swY&xYw#1swY*xYw#1swYyxYwwrL)rrrr create_export_diagnostic_context)r9r:rQmode_ctxapex_ctxlog_ctxdiagnostic_ctxs r&rrs % t < 2 < % < +>>@ < ES7N;;<<<<<<<<<<<A2 A& A2 A>B  B&A/ +A22A; 7A>>B B  BBcL|s|rt|dtr |d}|dd}||fS)zRObtain the arguments for torch.onnx.export from the model and the input arguments.N)r*dict)argskwargss r&_get_torch_export_argsr^s4 dz$r(D9bCRy <r%TF)r] export_paramsrQr( input_names output_namesoperator_export_type opset_versiondo_constant_folding dynamic_axeskeep_initializers_as_inputs custom_opsetsexport_modules_as_functionsautograd_inliningch| tjjk7rtjdt |tj jk(rtjdt t|tjr|fn|}|||fz}t||||||||| | | | | |||y)a5Exports a model into ONNX format. If ``model`` is not a :class:`torch.jit.ScriptModule` nor a :class:`torch.jit.ScriptFunction`, this runs ``model`` once in order to convert it to a TorchScript graph to be exported (the equivalent of :func:`torch.jit.trace`). Thus this has the same limited support for dynamic control flow as :func:`torch.jit.trace`. Args: model: The model to be exported. args: args can be structured either as: 1. ONLY A TUPLE OF ARGUMENTS:: args = (x, y, z) The tuple should contain model inputs such that ``model(*args)`` is a valid invocation of the model. Any non-Tensor arguments will be hard-coded into the exported model; any Tensor arguments will become inputs of the exported model, in the order they occur in the tuple. 2. A TENSOR:: args = torch.Tensor([1]) This is equivalent to a 1-ary tuple of that Tensor. 3. A TUPLE OF ARGUMENTS ENDING WITH A DICTIONARY OF NAMED ARGUMENTS:: args = (x, {"y": input_y, "z": input_z}) All but the last element of the tuple will be passed as non-keyword arguments, and named arguments will be set from the last element. If a named argument is not present in the dictionary, it is assigned the default value, or None if a default value is not provided. .. warning:: This behavior will be deprecated in a future release. Please use the kwargs argument instead. .. note:: If a dictionary is the last element of the args tuple, it will be interpreted as containing named arguments. In order to pass a dict as the last non-keyword arg, provide an empty dict as the last element of the args tuple. For example, instead of:: torch.onnx.export( model, ( x, # WRONG: will be interpreted as named arguments {y: z}, ), "test.onnx.pb", ) Write:: torch.onnx.export(model, (x, {y: z}, {}), "test.onnx.pb") f: Path to the output ONNX model file. E.g. "model.onnx". kwargs: Named arguments to the model. export_params: If True, all parameters will be exported. Set this to False if you want to export an untrained model. In this case, the exported model will first take all of its parameters as arguments, with the ordering as specified by ``model.state_dict().values()`` verbose: if True, prints a description of the model being exported to stdout. In addition, the final ONNX graph will include the field ``doc_string``` from the exported model which mentions the source code locations for ``model``. If True, ONNX exporter logging will be turned on. training: * ``TrainingMode.EVAL``: export the model in inference mode. * ``TrainingMode.PRESERVE``: export the model in inference mode if model.training is False and in training mode if model.training is True. * ``TrainingMode.TRAINING``: export the model in training mode. Disables optimizations which might interfere with training. input_names (list of str, default empty list): names to assign to the input nodes of the graph, in order. output_names (list of str, default empty list): names to assign to the output nodes of the graph, in order. operator_export_type (enum, default OperatorExportTypes.ONNX): .. warning:: This option will be deprecated in a future release. Future exported graphs will always use the default opset domain. * ``OperatorExportTypes.ONNX``: Export all ops as regular ONNX ops (in the default opset domain). * ``OperatorExportTypes.ONNX_FALLTHROUGH``: Try to convert all ops to standard ONNX ops in the default opset domain. If unable to do so (e.g. because support has not been added to convert a particular torch op to ONNX), fall back to exporting the op into a custom opset domain without conversion. Applies to `custom ops `_ as well as ATen ops. For the exported model to be usable, the runtime must support these non-standard ops. * ``OperatorExportTypes.ONNX_ATEN``: All ATen ops (in the TorchScript namespace "aten") are exported as ATen ops (in opset domain "org.pytorch.aten"). `ATen `_ is PyTorch's built-in tensor library, so this instructs the runtime to use PyTorch's implementation of these ops. .. warning:: Models exported this way are probably runnable only by Caffe2. This may be useful if the numeric differences in implementations of operators are causing large differences in behavior between PyTorch and Caffe2 (which is more common on untrained models). * ``OperatorExportTypes.ONNX_ATEN_FALLBACK``: Try to export each ATen op (in the TorchScript namespace "aten") as a regular ONNX op. If we are unable to do so (e.g. because support has not been added to convert a particular torch op to ONNX), fall back to exporting an ATen op. See documentation on OperatorExportTypes.ONNX_ATEN for context. For example:: graph(%0 : Float): %3 : int = prim::Constant[value=0]() # conversion unsupported %4 : Float = aten::triu(%0, %3) # conversion supported %5 : Float = aten::mul(%4, %0) return (%5) Assuming ``aten::triu`` is not supported in ONNX, this will be exported as:: graph(%0 : Float): %1 : Long() = onnx::Constant[value={0}]() # not converted %2 : Float = aten::ATen[operator="triu"](%0, %1) # converted %3 : Float = onnx::Mul(%2, %0) return (%3) .. warning:: Models exported this way are probably runnable only by Caffe2. opset_version (int, default 17): The version of the `default (ai.onnx) opset `_ to target. Must be >= 7 and <= 17. do_constant_folding: Apply the constant-folding optimization. Constant-folding will replace some of the ops that have all constant inputs with pre-computed constant nodes. dynamic_axes: By default the exported model will have the shapes of all input and output tensors set to exactly match those given in ``args``. To specify axes of tensors as dynamic (i.e. known only at run-time), set ``dynamic_axes`` to a dict with schema: * KEY (str): an input or output name. Each name must also be provided in ``input_names`` or ``output_names``. * VALUE (dict or list): If a dict, keys are axis indices and values are axis names. If a list, each element is an axis index. For example:: class SumModule(torch.nn.Module): def forward(self, x): return torch.sum(x, dim=1) torch.onnx.export( SumModule(), (torch.ones(2, 2),), "onnx.pb", input_names=["x"], output_names=["sum"], ) Produces:: input { name: "x" ... shape { dim { dim_value: 2 # axis 0 } dim { dim_value: 2 # axis 1 ... output { name: "sum" ... shape { dim { dim_value: 2 # axis 0 ... While:: torch.onnx.export( SumModule(), (torch.ones(2, 2),), "onnx.pb", input_names=["x"], output_names=["sum"], dynamic_axes={ # dict value: manually named axes "x": {0: "my_custom_axis_name"}, # list value: automatic names "sum": [0], }, ) Produces:: input { name: "x" ... shape { dim { dim_param: "my_custom_axis_name" # axis 0 } dim { dim_value: 2 # axis 1 ... output { name: "sum" ... shape { dim { dim_param: "sum_dynamic_axes_1" # axis 0 ... keep_initializers_as_inputs: If True, all the initializers (typically corresponding to parameters) in the exported graph will also be added as inputs to the graph. If False, then initializers are not added as inputs to the graph, and only the non-parameter inputs are added as inputs. This may allow for better optimizations (e.g. constant folding) by backends/runtimes. If True, `deduplicate_initializers` pass will not be executed. This means initializers with duplicated values will not be deduplicated and will be treated as distinct inputs to the graph. This allows different input initializers to be supplied at the runtime following export. If ``opset_version < 9``, initializers MUST be part of graph inputs and this argument will be ignored and the behavior will be equivalent to setting this argument to True. custom_opsets (dict[str, int], default empty dict): A dict with schema: * KEY (str): opset domain name * VALUE (int): opset version If a custom opset is referenced by ``model`` but not mentioned in this dictionary, the opset version is set to 1. Only custom opset domain name and version should be indicated through this argument. export_modules_as_functions: Flag to enable exporting all ``nn.Module`` forward calls as local functions in ONNX. Or a set to indicate the particular types of modules to export as local functions in ONNX. This feature requires ``opset_version`` >= 15, otherwise the export will fail. This is because ``opset_version`` < 15 implies IR version < 8, which means no local function support. Module variables will be exported as function attributes. There are two categories of function attributes. 1. Annotated attributes: class variables that have type annotations via `PEP 526-style `_ will be exported as attributes. Annotated attributes are not used inside the subgraph of ONNX local function because they are not created by PyTorch JIT tracing, but they may be used by consumers to determine whether or not to replace the function with a particular fused kernel. 2. Inferred attributes: variables that are used by operators inside the module. Attribute names will have prefix "inferred::". This is to differentiate from predefined attributes retrieved from python module annotations. Inferred attributes are used inside the subgraph of ONNX local function. * ``False`` (default): export ``nn.Module`` forward calls as fine grained nodes. * ``True``: export all ``nn.Module`` forward calls as local function nodes. * Set of type of nn.Module: export ``nn.Module`` forward calls as local function nodes, only if the type of the ``nn.Module`` is found in the set. autograd_inlining: Flag used to control whether to inline autograd functions. Refer to https://github.com/pytorch/pytorch/pull/74765 for more details. Raises: :class:`torch.onnx.errors.CheckerError`: If the ONNX checker detects an invalid ONNX graph. :class:`torch.onnx.errors.UnsupportedOperatorError`: If the ONNX graph cannot be exported because it uses an operator that is not supported by the exporter. :class:`torch.onnx.errors.OnnxExporterError`: Other errors that can occur during export. All errors are subclasses of :class:`errors.OnnxExporterError`. z}Setting `operator_export_type` to something other than default is deprecated. The option will be removed in a future release.categoryzSetting `training` to something other than default is deprecated. The option will be removed in a future release. Please set the training mode before exporting the model.N)rbrcrdrerfrgrhri) r+OperatorExportTypesONNXr4r5 FutureWarningr,r0r*r>Tensor_export)r9r\fr]r_rQr(r`rarbrcrdrerfrgrhris r&rrsj w::???  >" 7''000  *#  !u||4D7$D vi    1#/!$?#$?+!& r%cF|jdk7ry|jj}|jtj j ry|jt j tjjryy)Nzprim::ConstantFT) kindoutputr. isSubtypeOfr ListType ofTensors OptionalTypeofTensor)node output_types r&_is_constant_tensor_listr} ss yy{&&++-$$&Kr{{4467r{{2??+C+C+EFGHr%c|jD]M}|jD]}t||t|s1g}|j j D]b}|j |}|jj||jj||j|d|jd|j|j jtjj!}|jj||j j#|Py)Nzprim::ListConstruct)nodesblocks_split_tensor_list_constantsr}rutoIValueinsertConstantr{ moveBefore copyMetadataappendcreate insertBeforesetTyper rwrxreplaceAllUsesWith)gblockr{subblockinputsvalinputlcs r&rrs  1  6H (H 5 6 #D )F{{}--/ %((- ''- ))$/ e$  %.7d#..01  GGI " "4 ( KKM , ,R 0%1r%c|i}tj|tj|tj|tj rtj |tj||durtj|t||tj|tj|tj|rtj|tj|tj|tj|dtj|tj|tj|dtj|tj ||tj"|tj|tj$|tj&|tj(|t*j,j/tj0||tj2|tj4r#|gn|}|in|}tj6|||tj|tj8||}tj|tj|tj:|dtj<tj|tj>|tj<|tj|tj@|tj|tjB|}tj|tj4r%tjD||tj<|S)NFT)#r _jit_pass_inline_jit_pass_inline_fork_wait_jit_pass_lintrri(_jit_pass_onnx_autograd_function_process_jit_pass_lower_all_tuples_jit_pass_constant_propagationr _jit_pass_dce _jit_pass_cse_jit_pass_onnx_lint&_jit_pass_canonicalize_graph_fuser_ops_jit_pass_peephole_jit_pass_fuse_addmm*_jit_pass_onnx_remove_inplace_ops_for_onnx_jit_pass_onnx_preprocess#_jit_pass_prepare_division_for_onnx_jit_pass_onnx_remove_print _jit_pass_onnx_preprocess_caffe2r_quantized_opsclear'_jit_pass_onnx_unpack_quantized_weights_jit_pass_erase_number_typesonnx_shape_inference&_jit_pass_onnx_set_dynamic_input_shape_jit_pass_onnx#_jit_pass_onnx_scalar_type_analysisr3_jit_pass_onnx_peephole4_jit_pass_dce_allow_deleting_nodes_with_side_effects_jit_pass_canonicalize)_jit_pass_onnx_graph_shape_type_inference)graphrb_disable_torch_constant_propfixed_batch_size params_dictrer`rGs r&_optimize_graphr0s !!%(e   33E:!!%( $u, ))%0 .Ue   u%--e4e%&E"e%&!!%(11%@  'e**51""5)''.""((*..ukB##E*##'/b[ )1r|  11%{S5!   e%9 :E5!e** tW66e w002Be;;EBe  % %e ,Ee## 44 ; A A  Lr%cLt|d|dD]\}}t|trLt|j t|j k7sJd}t j |bt|tss||k7syd}t j |y)aYWarns that changes to input dictionaries and strings won't take effect in the traced ONNX graph. We accept dictionaries and strings as ONNX inputs, but they should be only for configuration use. we detect here if these inputs are modified, and if so we warn the user that the changes won't take effect in the traced ONNX graph. raQWe detected that you are modifying a dictionary that is an input to your model. Note that dictionaries are allowed as inputs in ONNX but they should be handled with care. Usages of dictionaries is not recommended, and should not be used except for configuration use. Also note that the order and values of the keys must remain the same. zvThe model seems to have string inputs/outputs. Note that strings will not appear as inputs/outputs of the ONNX graph. N)zipr*r[listkeysr4r5str) input_statesr traced_inputwarnings r&rrs #<?LOD'| eT "EJJL!T,*;*;*=%>>] g& s # $^ g&''r%c|S)zVResolves the arguments that are ignored when export_type != operator_export_type.ONNX.r$)arg_name arg_valuerbs r&_resolve_args_by_export_typers r%c|dkr|durtjdy|dn|}||tjjurd}|S)aeDecides whether the initializers in the graph should be listed as ONNX graph inputs. This method encapsulates the logic to decide whether the initializers in the graph should be listed as ONNX graph inputs (i.e., whether to choose ONNX IR v3 or v4). If keep_initializers_as_inputs is not specified (None), then we decide whether to keep initializers as graph inputs (val_keep_init_as_ip) based on export type. If export type is ONNX, then do not keep initializers as input (val_keep_init_as_ip=False). For all other export types keep initializers as input (val_keep_init_as_ip=True). If keep_initializers_as_inputs is specified, then respect it. Unless opset version <= 8, in which case it must be ignored because for opset version <= 8, all initializers MUST be part of graph input (only ONNX IR v3 is allowed), i.e. val_keep_init_as_ip=True. Special handling is needed for opset version 8 or lower, because irrespective of user input for keep_initializers_as_inputs, the graph must follow ONNX IR v3 semantics, i.e. all initializers must be listed as ONNX graph input. FaSetting 'keep_initializers_as_inputs=False' for opset version8 or lower would lead to an invalid ONNX graph. Therefore, 'keep_initializers_as_inputs=False' is ignored during export.Exported model will have initializers as graph inputs (compliant to ONNX IR v3).T)r4r5r+rmrn)rfrbrcval_keep_init_as_ips r&_decide_keep_init_as_inputrsb,q &% / MM# +39T $+ G$?$?$D$D D# r%ctd||S)Nadd_node_names)r)rrbs r&_decide_add_node_namesrs '.*> r%ctd||}|r3|1|tjjurt j d|S)NrdaIt is recommended that constant folding be turned off ('do_constant_folding=False') when exporting the model in training-amenable mode, i.e. with 'training=TrainingMode.TRAIN' or 'training=TrainingMode.PRESERVE' (when model is in training mode). Otherwise, some learnable model parameters may not translate correctly in the exported ONNX model because constant folding mutates model parameters. Please consider turning off constant folding or setting the training=TrainingMode.EVAL.)rr+r,r8r4r5)rdrbr(s r&_decide_constant_foldingrsN624H1E1E1J1J!J  V  r%crt|d|}t|rtj|St d)Nforwardz/model has no forward method and is not callable)getattrcallableinspect signature ValueError)r9should_be_callables r& _signaturers8  59"#  !344 F GGr%c\ t|} t |j j }|ddk(r|dd}i}t|tr|}nt|tr t |}n|g}t|dtr |d}|dd}t|}||dD]_}||vr|j|||j |} | j| jk7sE|j| jat|tr|}|St|}|S#t$r$}tj|d|cYd}~Sd}~wwxYw#t$rtjdY|St$r0}tjd|j dYd}~|Sd}~wwxYw)Nz, skipping _decide_input_formatrselfrrZz,No input args, skipping _decide_input_formatzSkipping _decide_input_format )rrr4r5r parametersrr*tupler[lenrdefaultempty IndexError Exceptionr\) r9r\sigeordered_list_keys args_dict args_list n_nonkeyword optional_argparams r&_decide_input_formatr sF !4!4!67 Q 6 ) 1!" 5  dD !I e $T II imT *!" I!#2I9~ -lm< 4Ly(  i8H KA  :;< 8 F DE K F 8 DEE KFsG D"CE$/E E" E+E E EF+3F+;%F&&F+c |y| t}n t|}i}|jD]\}}||vr tdt|trE|jDcic]%\}}|t j j|'c}}||<jt|tr7|Dcic]'}|t j j|d|)c}||<tdt| t|} | jjD] }||vsd||<|Scc}}wcc}w#t$r$} tj| d|cYd} ~ Sd} ~ wwxYw)a dynamic_axes examples: (1) dynamic_axes = {"x": {0: "my_custom_axis_name_1"}, "y": {1: "my_custom_axis_name_2"}} (2) dynamic_axes = {"x": [0], "y": [1]} these will be converted to dynamic_shapes respectively: (1) dynamic_shapes = {"x": {0: Dim("my_custom_axis_name_1")}, "y": {1: Dim("my_custom_axis_name_2")}} (2) dynamic_shapes = {"x": {0: Dim("x_dim_0")}, "y": {1: Dim("y_dim_1")}} # auto-generated dim names NzzAssinging new input names is not supported yet. Please use model forward signature to specify input names in dynamix_axes._dim_zrDimrr-r.rr4r5rr) r9rer`input_names_setdynamic_shapes input_nameaxeskvrrs r&$_from_dynamic_axes_to_dynamic_shapesr0s$%k*,.N(..0 D  (:  dD !37::<*+/1a5<<##A&&*N: &d #FJ*AB5<<##zl%s$;<<*N: &NtTXzl[ (nn))+. ^ +)-N: &. +**  IJKs*&*D.,,D48 D99 E&E!E&!E&ct|tjr|f}tjj ||ddd\}}}t |t ||i}|r||fS|S)NFTstrict_force_outplace_return_inputs_states)r)r*r>rpr?_get_trace_graphrr)funcr\rb return_outs trace_graph torch_out inputs_statess r&_tracerjsu$ %w,1II,F,F  " -G-)KM .!+/CQSTKI%% r%ctjj|j}tj}tj dtjj ||ddd\}}}tj |t||tjj|jk7r td||fS)NFTrzXstate_dict changed after running the tracer; something weird is happening in your model!) r>r?_unique_state_dictris_autocast_cache_enabledset_autocast_cache_enabledrr RuntimeError)r9r\orig_state_dict_keysprev_autocast_cache_enabledrrrs r&_trace_and_get_graph_from_modelr~s!9977>CCE #("A"A"C $$U+,1II,F,F  " -G-)KM $$%@A .uyy;;EBGGII :   !!r%c$g}t|j|D]p\}}dt|jvr=tj j |\}}|jt|^|j|dur|S)N PackedParams) rrrr.r>r?_flattenrr) method_graph args_paramsparam_count_listinput_ arg_params_in_vars_s r&_get_param_count_listrs"<#6#6#8+F= S/ /++K8JGQ  # #CL 1  # #Kt$; < = r%cfdt|}t|t|z }|dk\sJ|rtd|dy)zAtorch.jit._flatten removes None. Check if it did so in this case.c3Kt|ttfr|D]}|Ed{yt|tr&|j D]}|Ed{y|y7B7wrL)r*rrr[values)xinnerflattens r&rz._check_flatten_did_not_remove..flattenso a$ ' *"5>)) * 4  *"5>)) *G **s!'A1A-5A1 A/! A1/A1rzargs contained z None's after flattening. When exporting a ScriptModule or ScriptFunction, no args may be None because that breaks type propagation.N)rrr)original jit_flattenedflattened_with_nonenum_noners @r&_check_flatten_did_not_removersawx01&'#m*<r?r@ ScriptModulerrrrrAttributeErrorrr $_jit_pass_onnx_function_substitution_freeze_moduler_c_jit_onnx_list_model_parameters _get_methodr"_propagate_and_assign_input_shapesrrrrrrrr enumerate setDebugName)r9r\flattened_argsrrrfreezed_modulerGparamsrr r r r state_dict graph_inputsuser_input_num param_namesiinps r&_create_jit_graphr0s%%))22EII4J4JKLuyy11%+>qAB%dN; eUYY33 4 V ++  3 3E :..R__ehh/DN ??ONFF!--i8>>L+f 5K4\;O ++K8JGQ99eGn.>uE&)V3 3  //60=55 >#3UE fi--6udCE95!--e4J *##% &F 'L&Z8Nz()KL)>3     [^);< =>++E2 &)T ))K" V"#MNTUU Vs(K** L3 K??Lc|jDcgc]}|j}}|t|t|z d}tt ||}|Scc}wrL)r debugNamerr[r)rr)rinput_and_param_namesr- _params_dicts r&_get_named_param_dictr5s[8= GS]]_GG',A(BS[(P(RSKK01L HsActj|}i}|rt|dtr |d}|dd}||i|}t|tr|g}|St|t s|f}|S)NrZ)copydeepcopyr*r[rr)r9r\ input_args input_kwargsexample_outputss r&_get_example_outputsr<s|t$JLjB6!"~ _ Z8<8O/4(*+  /*, r%ct|tjr&|jtvr|j }|r3tj |jtjn2tj |jtj}|r3tj |jtjn5tj |jt|j}||z |z}|jt|j}|||fS|fS)N)dtype) r*r>rpr>_qtype_vtype_map dequantizetensorq_scaledoublefloat32 q_zero_pointint64to)valuecast_onnx_acceptedq_value_dequantizerBrEq_values r&rrs%&5;;:J+J"--/" LL =emmoU]]C " LL++-U[[ Ae002:J5;;:WX  %w.=**#3EKK#@*A--xr%c tdt|dtDstd|Dr tjj ||S|S)zReturns `torch.jit.trace(model, args)` if model is quantized. Otherwise do nothing and return original model. This is due to https://github.com/pytorch/pytorch/issues/75761. c34K|]}t|dyw)_packed_paramsN)r/).0ms r& z)_pre_trace_quant_model..,s )*#$ srAc36K|]}t|ddyw is_quantizedFNr)rOargs r&rQz)_pre_trace_quant_model...s ASWS.% 0 A)anyrrr>r?trace)r9r\s r&_pre_trace_quant_modelrZ&sO   .MgeY.M.O  AD A Ayyud++ Lr%c t|tjttt fr|f}t ||}t||\} } } }t| | } t| ||||| ||} t|tjjtjjf}|r|t!||}d}|D]}|t#|z }tjj%|\}}t'j(| ||t*j,|t*j.nt| t0t2fs| g}n| }tjj%t3|\}}t5d|Ds6t'j(| ||t*j,|t*j.t7| ||t| | }|rt*j.t8j:k\ro| | t<j>j@k(rt'jB| |}t'jD| |t*j.}t'jF| t*j,r%t'jH| |t*j.t'jJ| |}t*j.dkrt'jL| t'jN|}t'jP| tS| || || fS#t$r&}tjjd| d}~wwxYw)aConverts model into an ONNX graph. Returns: graph: A TorchScript IR Graph with ONNX nodes. params_dict: Dict from input param name to param value. torch_out: The output tensors resulting from the trace of ``model``. If ``model`` is a :class:`torch.jit.ScriptModule` or :class:`torch.jit.ScriptFunction`, this will be None, since we are not doing any tracing. )rrrrer`rGzTorch IR graph at exception: Nr$c36K|]}t|ddywrSrU)rOouts r&rQz"_model_to_graph..sQ3736QrWr)*r*r>rpintfloatboolrZr0r5rrrMlogr?r@rr<rrr "_jit_pass_onnx_assign_output_shaperrr3rrrX_set_input_and_output_namesr ONNX_CONSTANT_FOLDING_MIN_OPSETr+r,r8_jit_pass_onnx_eval_peephole_jit_pass_onnx_constant_foldrr%_jit_pass_onnx_eliminate_unused_items,_jit_pass_onnx_cast_all_constant_to_floating%_jit_pass_filter_non_tensor_arguments#_jit_decay_packed_param_input_types_apply_friendly_debug_names)r9r\rQr`rarbrdrrr(rerr)rrGrr is_scriptr;example_outputs_finalexample_outputout_varsdescoutput_wrappedoutput_tensorsout_descs r&_model_to_graphrt3sD$sE489w "5$ /E'8'E$E69f'v6K   )E-#%#  5599#;#;UYY=S=S"TUI.ud; "- MN !%<^%L L ! M++,AB$ --     ( (   - -  )dE]3'[N&N#(99#5#5eN6K#L Q.QQ  1 1,,11   {LA'v6K   - -  5 5 6  x7+?+?+D+DD99%MK55 ; A A  ??F## 44 ; A A ::5+NK((1, 77>::;GK**51 {3 +y (([  6> sL L>!L99L>z2.5z the futurez"use onnx.printer.to_text() insteadc d| tj} | i} | t_|t_t |||5t | || }t| |}t|||}t||}t||||||||| \}}}|j|| d|| || |cdddS#1swYyxYw)aSimilar to :func:`export`, but returns a text representation of the ONNX model. Only differences in args listed below. All other args are the same as :func:`export`. Args: add_node_names (bool, default True): Whether or not to set NodeProto.name. This makes no difference unless ``google_printer=True``. google_printer (bool, default False): If False, will return a custom, compact representation of the model. If True will return the protobuf's `Message::DebugString()`, which is more verbose. Returns: A UTF-8 str containing a human-readable representation of the ONNX model. N)r(reF) r ONNX_DEFAULT_OPSETrr3rbrrrrrrt_pretty_print_onnx)r9r\r_rQr(r`rarb export_typegoogle_printerrcrfrgrrdrerval_add_node_namesval_do_constant_foldingrrrs r&rrsH"55  (5G%#7G %7 3  8 ')=} 4 0 #; !5x# $E40(7      #% ) %{I''         /    s A"B&&B/zavoid using this functionc|xstj}|t_ t ||d5t ||}t ||}t||\}}}}tj|tj||tj|tj|dddg}j!D]e} | j#} | j%dr%t&j(j+| j-d|rU|j/| g||fS#1swYxYw#t$r}tjd|d}~wwxYw)aReturns an approximated list of all ops that are yet supported by :mod:`torch.onnx`. The list is approximated because some ops may be removed during the conversion process and don't need to be converted. Some other ops may have partial support that will fail conversion with particular inputs. Please open a Github Issue for op support requests. Args: model: Same as the `model` parameter in :func:`torch.onnx.export`. args: Same as the `args` parameter in :func:`torch.onnx.export`. training: Same as the `training` parameter in :func:`torch.onnx.export`. opset_version: Same as the `opset_version` parameter in :func:`torch.onnx.export`. Returns: The JIT graph and a list of unconvertible ops in the format of "domain::op". F)rQNz_Failed to discover unconvertible ops because of errors during the JIT graph generation process.)zonnx::zprim::r)r rvrr3rrrZr0r rrrrrrOnnxExporterErrorrrt startswithrregistryis_registered_oprstripr) r9r\r(rcrrrGrunsupported_opsr{ domain_ops r&rrsZ0"BZ%B%BM(5G% eXu = K(t4D*5$7E"3E4"@ E1a    &  9 9% H  + +E 2  C CE J K*O .IIK    4 5 $$55   S !=   " "9 -. / !!M K K && "  s/EA?D4.E4D=9E E$ EE$c 6fd}dd}jDcic]H\}}|tjjtjt |||J}}}|tj j_t|tr.|r,|Dchc] }tjt |"}}n5t|tr|rd} |D chc] } | |  }} n t}|r||Scc}}wcc}wcc} w)Ncdfd}fd}jD]$}|j||j|&y)N _onnx_attrsc2t|t|yrL)setattr_get_module_attributes)rGr attr_names r&)_track_module_attributes_forward_pre_hookzm_setup_trace_module_map..__register_attribute_hook.._track_module_attributes_forward_pre_hookQs FI'=f'E Fr%ctj}|sy|j}i}t|rt |}t |tj ||yrL)r _get_tracing_staterr/rdelattr%_jit_pass_onnx_track_scope_attributes)rGrru tracing_stater onnx_attrsrs r&%_track_module_attributes_forward_hookzi_setup_trace_module_map..__register_attribute_hook.._track_module_attributes_forward_hookTsZ113M !'')EJvy)$VY7  *  4 4UJ Gr%)rAregister_forward_hookregister_forward_pre_hook)rrrPrr9s @r&__register_attribute_hookz:_setup_trace_module_map..__register_attribute_hookNsK!  G H SA # #$I J ' '(Q R Sr%c|jd}ttt|D]+\}}|j rdj ||dcS|S)a Parse qualified variable name and return the unqualified version. Pure numeric atoms are considered inadequate, so this function will look past them, and start from the first non-numeric atom. Example: >>> _unqualified_variable_name("__main__.Foo.bar") 'bar' >>> _unqualified_variable_name("__main__.Foo.bar.0") 'bar.0' .N)splitreversedrr% isnumericjoin)qualified_name name_atomsr.atoms r&_unqualified_variable_namez;_setup_trace_module_map.._unqualified_variable_namees]$))#. Yz%: ;< 0GAt>>#xx 12// 0r%ct|trtj|St dt|j d)NzjOnly type of the `nn.Module` should be passed in the set for argument `export_modules_as_functions`. Got `z`.)r*r.r>typenamerrD)rs r&_find_typenamez/_setup_trace_module_map.._find_typenamesD!T"~~a((" G,,-R1r%)rrreturnr) named_modulesr>r _jit_onnx_create_full_scope_namerr.r?r_trace_module_mapr*r`r) r9rhrr_n_mtrace_module_maprGmodule_typenamesrrs ` r&_setup_trace_module_maprJsS..))+  B EHH 5 5 NN48 $&@&D   *:EII&-t49TGWXVENN4<8XX / 5:U 8SS!N1-SS5!# 9YTsA D #%D$Dcjdtjj_t j yrL)r>r?rrr "_jit_pass_onnx_clear_scope_recordsr$r%r&_reset_trace_module_maprs )-EII&))+r%c~tjt|}tjtjj }|Dcgc]}|j |dc}i}|D]} t||||<|Scc}w#t$r&tjjd|dYJwxYw)NzSkipping module attribute '') typingget_type_hintsr.r>nnModulerErrrMra)rGrbase_m_annotationsrattrss r&rrs''V 5K..uxx?'9:!_[__Q: E  vq)E!H L%;  JJNN81= >  sB5B  ,B<;B<c~tjdusJ| tjj} t |t jjr td|t_ | tj} | tjkDr:tjd| dtjdt j"|r| dkr td|st$j&j(}| t_|t_ d t_tj.}|t_t1}t |t jj2t j4j6fr t9||}t;|||5t=| || }t?||}tA| ||}t |tBr|}nd }tE||}| i} tG| |||tI|||||||||| \}}}| tjju}|i}tKjL|i}|r.tKjN||tQ|jS}| d ur"tKjT||tW|d d}tKjX||r"|j[|| | ||| ||||| \}} }!}"n!|j[i| | d|| ||||| \}} }!}"t]j^||}|r t j`jcd |t]jd||| | dddtjsJdt_|t_tgS#1swY=xYw#tjsJdt_t_tgwxYw)NFztorch.nn.DataParallel is not supported by ONNX exporter, please use 'attribute' module to unwrap model from torch.nn.DataParallel. Try torch.onnx.export(model.module, ...)z Exporting to ONNX opset version zT is not supported. by 'torch.onnx.export()'. The highest opset version supported is zP. To use a newer opset version, consider 'torch.onnx.export(..., dynamo=True)'. rkz`export_modules_as_functions` is not supported for `opset_version` < 15.This is because `opset_version` < 15 implies IR version < 8, which means no local function support. T)rr(rer(zExported graph: )4rr#r ExportTypes PROTOBUF_FILEr*r>r DataParallelrrr rv#ONNX_TORCHSCRIPT_EXPORTER_MAX_OPSETr4r5rOnnxExporterWarningr+rmrnr3rbrirrr?rrrrrrrr_validate_dynamic_axesrtr r"_jit_pass_onnx_function_extractionrr'_jit_pass_onnx_deduplicate_initializersr5_jit_pass_onnx_assign_scoped_names_for_node_and_value _export_onnxr_add_onnxscript_fnrMra _export_filer)#r9r\rrr_rQr(r`rarbrxrcrdrerfrrgrrrhri_autograd_inlining_previous'module_typenames_to_export_as_functionsrrzr{model_file_locationrrrdefer_weight_exportnode_attr_to_nameproto export_mapval_use_external_data_format node_namess# r&rqrqs,  ! !U ** *&22@@ %../ 3  $8G "55 zEEE  .}o>66@6d6d5ef] ^//  #}r'9 *  &::??)6G%#7G y"!%&-&?&?#$5!.set_namess+    y>C N *Ns9~z3y>JK  %(Y )BC (OA|dX%?*$)LL1A$BM!--diik:!**40!((*22499;?%%'44Q 8L8L8NO(//1D##D)~~4'!!$' (r%rru)rroutputs)rr`rars` r&rcrcs8(4d5<<>"K9 d5==?#\8|jDcic]}|tj||}}|| g|i|S|jDcic]1}|dz|j|dztj||3}}| d k(r(| j(| g|i|d|jiSt+j,|||r|j/dcc}wcc}wcc}w#t0$r|t2j4j6k(rYy|t2j4j8k(rs|jDcic]1}|dz|j|dztj||3ncc}w}}| j| g|dt|i|cYSt:$r!}|j<dd | d f|_d}~wwxYw) zRuns a symbolic function. The function is used in C++ to export the node to ONNX. Returns: A single or a tuple of Values. None when the node gets cloned as is into the new graph. rNrZrrrr::rMz (Occurred when translating z).)rr3rtendswithrparse_node_kindrr4rattributeNameskindOfr _node_get outputsSizeaten_oprrrget_function_groupgetoprUnsupportedOperatorErrorget_min_supportedrr+rmONNX_FALLTHROUGHrr-r\)rrr{rrrrrbrc node_kind ns_op_name namespacerrrrrdomainsymbolic_function_namesymbolic_function_grouprrs r&_run_symbolic_functionrs&55M I#s^  "22:>Iw** # MZ8LM((*  Gdkk!nQ' ')B)B4)K K  ""$"i$}$$   5T:    6$*82gY!7"."7"7"J"J "#  # .155mDK&DHCVCVCX>?A00q99#=C6CUCC((*  Gdkk!nQ' ')B)B4)K K    #=## $)373C3C3E -- " & $ 5 5 7     O 0  $  7#>#>#O#O O !W%@%@%S%S S,,.C$++a.++_-F-FtQ-OOE)=((9>    VVAYK=gYbIK sa6H AH/H%. H/<H/6H*.H/3-H/% H//&L/L6J=<)L' L0L  Lctjd|stjd|dt j |\}}|dk(rt d|d|dy)Nz+^[a-zA-Z0-9-_]+::[a-zA-Z-_]+[a-zA-Z0-9-_]*$zFailed to register operator z. The symbolic name must match the format domain::name, and should start with a letter and contain only alphanumerical charactersrMz. z domain cannot be modified.)rematchrr}rr r) symbolic_namensrs r&_verify_custom_op_namer!Wsw 88BM R&&*=/:( (    % %m 4EB V|*=/B4?Z [  r%c~|jdrd|}t|tj|||y)aCRegisters a symbolic function for a custom operator. When the user registers symbolic for custom/contrib ops, it is highly recommended to add shape inference for that operator via setType API, otherwise the exported graph may have incorrect shape inference in some extreme cases. An example of setType is `test_aten_embedding_2` in `test_operators.py`. See "Custom Operators" in the module documentation for an example usage. Args: symbolic_name (str): The name of the custom operator in "::" format. symbolic_fn (Callable): A function that takes in the ONNX graph and the input arguments to the current operator, and returns new operator nodes to add to the graph. opset_version (int): The ONNX opset version in which to register. ratenN)r~r!rcustom_onnx_symbolic)rrrcs r&r r gs=,%}o. =)CL%%m]CKPr%c|jdrd|}t|tjj ||y)a-Unregisters ``symbolic_name``. See "Custom Operators" in the module documentation for an example usage. Args: symbolic_name (str): The name of the custom operator in "::" format. opset_version (int): The ONNX opset version in which to unregister. rr#N)r~r!rr unregister)rrcs r&r!r!s<%}o. =)$$]MBr%c 6t|dk(ryt|dr|t|dk(r5|jjDcgc]}|j }}|t|dk(r5|jj Dcgc]}|j }}t |xsg|xsgz}|jD]\}}||vrtjd|dt|ts4tjd|i} t|D]a\} }t|ts td|| vrtjd|d |d Bt|d zt| d zz| |<c| ||<ycc}wcc}w) z=Ensures dynamic axes argument is follows the expected format.rNrz Provided key z2 for dynamic axes is not a valid input/output namezNo names were found for specified dynamic axes of provided input.Automatically generated names will be applied to each dynamic axes of input z3The type of axis index is expected to be an integerzDuplicate dynamic axis index z was provided for input r_dynamic_axes_r)rr/rrr2rrrCr4r5r*rr%r^rr) rer9r`rary valid_namesrHrH value_dictr.s r&rrs <Aug  C $4$927++2D2D2FGQ1;;=GKG  S%6!%;38;;3F3F3HIaAKKMILI{(b\-?R@AK #((*+ U k ! MMu$VW  eT " MM__b^ce  J!%( M1!!S)$M ?MM7s:RSVRWWXY%(H/?$?#a!e*$LJqM M!+L /+HIs F Fctjt|tjj r|j S|SrL)rrr*r>rrr)r9s r&rrs:   #E588??;  AF r%)rr`)r:_C_onnx.TrainingMode)r9*torch.nn.Module | torch.jit.ScriptFunction)rQr`)r:r-rQr`)r\ztuple[Any, ...]r]dict[str, Any] | Nonerz-tuple[tuple[Any, ...], dict[str, Any] | None])$r9zCtorch.nn.Module | torch.jit.ScriptModule | torch.jit.ScriptFunctionr\ztuple[Any, ...] | torch.Tensorrrrr]r/r_r`rQr`r(r-r`Sequence[str] | Nonerar0rb_C_onnx.OperatorExportTypesrc int | Nonerdr`reDMapping[str, Mapping[int, str]] | Mapping[str, Sequence[int]] | Nonerf bool | NonergzMapping[str, int] | Nonerh(bool | Collection[type[torch.nn.Module]]rir`rNone)FFNNNN)r_C.Graphrbr1rr`rr`)rfr4rbr1rcr^)rinspect.Signature)NN)rer3r`r0rr/)F)r9r.r\z Sequence[Any]rzDtuple[_C.Graph, list[_C.IValue], Any | None, _C.ScriptModule | None])T)rztuple[_C.Graph, dict[str, torch.Tensor], torch.Tensor | tuple[torch.Tensor, ...] | list[torch.Tensor] | dict[str, torch.Tensor] | Any | None])r(r-rcr2rztuple[_C.Graph, list[str]])r9z(torch.nn.Module | torch.jit.ScriptModulerhr5rzset[str])rhr)r{_C.Noder_C.Block)rr:)rr:rHz_C.Valuerr^)rrrcr^rbr1)rr9rr)rr7rr:r{r9rrrzdict[_C.Value, _C.Value]rz set[_C.Value]rz list[_C.Node]rz+_C.Value | Sequence[_C.Value | None] | None)rr)rrrrrcr^)rrrcr^)r9ztorch.nn.Module | Callablerr8)d__doc__ __future__r contextlibr7rrrr4rrrrrr r>torch._C._onnxr _onnxr+torch.jit._tracetorch.serialization torch.onnxr r r rrtorch.onnx._globalsrtorch.onnx._internalrrrr__all__rr4contextmanagerrrrrr^r,r8rmrnrr}rrrrrrrrrrrrrrr0r5r<quint8uint8qint8int8qint32int32quint4x2r?rrZrt_disable_dynamo deprecatedrrrrrrqrkrcrrrrrrrr!r r!rrr$r%r&rPs #  EE (WW ""  ,-,-^ < %% <<  !3 %)%,%9%9%>%>(,)-8?8S8S8X8X $ $/3.2LQ")Z NZ (Z Z " Z  ZZ#Z&Z'Z6ZZZ Z""-#Z$,%Z&"J'Z()Z* +Zz 12*/" k k5k#'k k\': (!,(5((V $H#T(, 7 7 & 7  7t("<  00* 50*=J0*I0*f " LL%++ KK LL%++ NNEJJ (   4499!&  ! ! & &A) A)H .RS   ! ! & & 4499 $!I TI X .IJ&-%9%9%>%> $ A"#A" A"  A"KA"HJ 3J!IJJZ, 8   ! ! & & 4499 $',)A&"%'AH 8=>2#' !9T*1 !4499o o o o  o " o ! oo1od  QQQQ<C$)+Xr%