torch.onnx 的源代码

# mypy: 允许未类型化定义
from 未来 导入 注释


全部 = [
    # 模块
    "符号辅助器",
    "工具",
    错误,
    所有 opsets
    symbolic_caffe2,
    symbolic_opset7,
    "符号算子集 8",
    "符号算子集 9",
    "符号算子集 10",
    "符号算子集 11",
    "符号算子集 12",
    "符号算子集 13",
    "符号算子集 14",
    "符号算子集 15",
    "符号算子集 16",
    "符号算子集 17",
    "符号算子集 18",
    "符号算子集 19",
    "symbolic_opset20",
    枚举
    "操作符导出类型",
    "训练模式",
    "TensorProto 数据类型",
    "Jit 标量类型",
    # 公共函数
    "导出",
    "is_in_onnx_export",
    "选择导出模型模式",
    "注册自定义算子符号",
    "注销自定义算子符号",
    # 基础错误
    "Onnx 导出器错误",
    # 动态导出器
    "诊断选项",
    "导出选项",
    ONNX 程序,
    ONNX 运行时选项,
    ONNX 注册表,
    dynamo 导出,
    启用模拟模式,
    # DORT / torch.compile
    支持 ONNXRT 后端,
]

from 打字 导入 任何, 可调用, 类型检查
from typing_extensions 导入 已弃用

导入 火炬
from 火炬 导入 _C
from torch._C 导入 onnx as C_onnx
from torch._C._onnx 导入 运算符导出类型, TensorProtoDataType, 训练模式

from ._internal.exporter._onnx_program 导入 ONNX 程序
from ._internal.onnxruntime 导入 (
    支持 ONNXRT 后端,
    Ort 后端 as _Ort 后端,
    Ort 后端选项 as Ort 后端选项,
    Ort 执行提供者 as Ort 执行提供者,
)
from .类型工具 导入 JitScalarType
from .错误 导入 Onnx 导出器错误
from .工具 导入 (
    _运行符号函数,
    运行符号方法,
    是否在 ONNX 导出中,
    注册自定义算子符号,
    选择导出模型模式,
    注销自定义操作符号,
)


from . 导入 (  # usort: 跳过。保持顺序，而不是按字典顺序排序
    错误,
    符号化 Caffe2,
    符号化助手,
    符号算子集 7,
    符号算子集 8,
    符号算子集 9,
    符号算子集 10,
    符号算子集 11,
    符号算子集 12,
    符号算子集 13,
    符号算子集 14,
    符号算子集 15,
    符号算子集 16,
    符号算子集 17,
    符号算子集 18,
    symbolic_opset19,
    symbolic_opset20,
    工具,
)


from ._internal._exporter_legacy 导入 (  # usort: 跳过。必须放在最后以避免循环导入
    诊断选项,
    导出选项,
    ONNX 运行时选项,
    ONNX 注册表,
    启用模拟模式,
)


如果 类型检查:
    导入 操作系统
    from collections.abc 导入 收藏, 映射, 序列

# 设置公开的私有名称命名空间
诊断选项.__module__ = torch.onnx
导出选项.__module__ = torch.onnx
JitScalarType.__module__ = torch.onnx
ONNX 程序.__module__ = torch.onnx
ONNX 运行时选项.__module__ = torch.onnx
ONNX 导出器错误.__module__ = torch.onnx
Onnx 注册表.__module__ = torch.onnx
_Ort 后端.__module__ = torch.onnx
_OrtBackendOptions.__module__ = torch.onnx
_OrtExecutionProvider.__module__ = torch.onnx
启用模拟模式.__module__ = torch.onnx
支持 onnxrt 后端.__module__ = torch.onnx

生产者名称 = pytorch
生产者版本 = _C_onnx.生产者版本


定义 导出(
    模型: 火炬.神经网络.模块
    | 火炬.导出.导出程序
    | 火炬.算子.脚本模块
    | 火炬.算子.脚本函数,
    参数: 元组[任何, ...] = (),
    f: 字符串 | os.路径类型 | 无 = 无,
    *,
    关键字参数: 字典[str, 任何] | 无 = 无,
    导出参数: 布尔值 = True,
    详细: 布尔值 | 无 = 无,
    输入名称: 序列[str] | 无 = 无,
    输出名称: 序列[str] | 无 = 无,
    opset 版本: 整型 | 无 = 无,
    动态轴: 映射[str, 映射[int, str]]
    | 映射[str, 序列[int]]
    | 无 = 无,
    将初始化器作为输入保留: 布尔值 = False,
    dynamo: 布尔值 = False,
    # 动态选项
    外部数据: 布尔值 = True,
    动态形状: 字典[str, 任何] | 元组[任何, ...] | 列表[任何] | 无 = 无,
    自定义翻译表: 字典[可调用, 可调用 | 序列[可调用]]
    | 无 = 无,
    报告: 布尔值 = False,
    优化: 布尔值 = True,
    核实: 布尔值 = False,
    个人资料: 布尔值 = False,
    导出程序: 布尔值 = False,
    艺术品目录: 字符串 | os.PathLike = “。”,
    回退: 布尔值 = False,
    已弃用选项
    训练: _C_onnx.训练模式 = _C_onnx.训练模式.评估,
    运算符导出类型: _C_onnx.运算符导出类型 = _C_onnx.运算符导出类型.ONNX,
    做常量折叠: 布尔值 = True,
    自定义算子集: 映射[str, int] | 无 = 无,
    将模块导出为函数: 布尔值 | 集合[类型[火炬.神经网络.模块]] = False,
    自动微分内联: 布尔值 = True,
) -> ONNX 程序 | 无:
    r导出模型为 ONNX 格式。

参数：
模型：要导出的模型。
args: 示例位置参数输入。任何非 Tensor 参数将被硬编码到
导出的模型中；任何 Tensor 参数将成为导出模型的输入，其顺序与元组中出现的顺序相同。
text: text: 在
f: 输出 ONNX 模型文件的路径。例如："model.onnx"。
可选的示例关键字输入。
export_params: 如果为 false，则不会导出参数（权重）。
verbose: 是否启用详细日志记录。
input_names: 按顺序分配给图输入节点的名称。
output_names: 按顺序分配给图输出节点的名称。
opset_version: 版本号
`默认（ai.onnx）opset `_
要针对的目标。必须大于等于 7。
        dynamic_axes:

默认情况下，导出的模型将具有所有输入和输出张量的形状
将设置与在 `args` 中给出的完全匹配。要指定张量的轴
动态（即在运行时才知道），将 `dynamic_axes` 设置为具有以下模式的字典：

* KEY (str): 输入或输出名称。每个名称也必须在 ``input_names`` 或
``输出名称``.
* VALUE (字典或列表)：如果是一个字典，键是轴索引，值是轴名称。如果是列表，每个元素是一个轴索引。
例如：

例如：

                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",
输入名称=["x"],
输出名称=["sum"]
                )

产生::

输入{
名称: "x"
                  ...
形状{
                        dim {
dim_value: 2  # 轴 0
                        }
                        dim {
dim_value: 2  # 轴 1
                ...
输出 {
名称: "sum"
                  ...
形状 {
维度 {
dim_value: 2  # 轴 0
                ...

            While::

                torch.onnx.export(
                    SumModule(),
                    (torch.ones(2, 2),),
                    "onnx.pb",
输入名称=["x"],
输出名称=["sum"]
                    dynamic_axes={
# 字典值：手动命名的轴
                        "x": {0: "my_custom_axis_name"},
# 列表值：自动命名
"sum": [0]
                    },
                )

生成::

输入 {
名称: "x"
                  ...
形状 {
维度 {
维度参数: "my_custom_axis_name"  # 轴 0
                        }
维度 {
dim_value: 2  # 轴 1
                ...
                output {
                  name: "sum"
                  ...
                      shape {
                        dim {
dim_param: "sum_dynamic_axes_1"  # 轴 0
                ...

keep_initializers_as_inputs: 如果为 True，则所有
初始化器（通常对应于模型权重）都将
导出的图也将作为图的输入。如果为 False，
则初始化器不会作为图的输入，只有
用户输入被添加为输入。

如果您打算在运行时提供模型权重，请将此设置为 True。
将其设置为 False，如果权重是静态的以允许更好的优化
（例如，常量折叠）由后端/运行时执行。

动力机：是否使用 `torch.export` 导出 ExportedProgram 而不是 TorchScript 模型。
外部数据：是否将模型权重保存为外部数据文件。
这是必需的，因为对于超过 ONNX 文件大小限制（2GB）的大权重模型而言。
当为 False 时，权重将保存到包含模型架构的 ONNX 文件中。
dynamic_shapes：模型输入的动态形状字典或元组。请参阅
func:`torch.export.export` 获取更多详细信息。这仅在 dynamo 为 True 时使用（并推荐使用）。
注意 dynamic_shapes 是在模型导出时使用 dynamo=True 时设计的，而
dynamic_axes 则在 dynamo=False 时使用。
custom_translation_table：模型中操作符的自定义分解字典。
该字典应以 fx Node 中的可调用目标作为键（例如 ``torch.ops.aten.stft.default``），
该值应该是一个使用 ONNX 脚本构建该图的函数。
此选项仅在 dynamo 为 True 时有效。
report：是否为导出过程生成 markdown 报告。此选项
仅在 dynamo 为 True 时有效。
优化：是否优化导出的模型。此选项
仅在 dynamo 为 True 时有效。默认为 True。
验证：是否使用 ONNX Runtime 验证导出的模型。此选项
仅在 dynamo 为 True 时有效。
是否对导出过程进行性能分析。此选项仅在 dynamo 为 True 时有效。
该选项仅在 dynamo 为 True 时有效。
dump_exported_program: 是否将`:class:`torch.export.ExportedProgram`导出到文件。
这对于调试导出器很有用。此选项仅在 dynamo 为 True 时有效。
artifacts_dir: 保存调试文件（如报告和序列化程序）的目录
exported program. 此选项仅在 dynamo 为 True 时有效。
fallback: 当 dynamo 导出器失败时，是否回退到 TorchScript 导出器。
            This option is only valid when dynamo is True. When fallback is enabled, It is
建议即使提供了 dynamic_shapes，也建议设置 dynamic_axes。

training：已弃用选项。请在导出模型之前设置模型的训练模式。
operator_export_type：已弃用选项。仅支持 ONNX。
do_constant_folding：已弃用选项。
custom_opsets: 已废弃。
一个字典：

* KEY (str): opset 域名
* VALUE (int): opset 版本

如果模型中引用了自定义 opset 但未在此字典中提及，
则将 opset 版本设置为 1。仅应指定自定义 opset 的域名和版本。
通过此参数指示。
export_modules_as_functions: 已废弃选项。

启用标志
将所有 `nn.Module` 前向调用导出为 ONNX 中的本地函数。或一个集合，以指示
将特定类型的模块导出为 ONNX 中的本地函数。
此功能需要 `opset_version` >= 15，否则导出将失败。这是因为
`opset_version` < 15 表示 IR 版本 < 8，这意味着没有本地函数支持。
模块变量将被导出为函数属性。函数分为两类
属性。

1. 注解属性：通过类型注解的类变量（
`PEP 526 风格 `_
将作为属性导出。
ONNX 本地函数的子图中不使用标注属性，因为它们不是由 PyTorch JIT 跟踪创建的，
但消费者可能会使用它们来判断是否用特定的融合内核替换函数。
2. 推断属性：模块内操作符使用的变量。属性名称

2. 推断属性：模块内操作符使用的变量。属性名称
将具有前缀 "inferred::"。这是为了区分从
Python 模块注解中检索到的预定义属性。

* ``False``（默认）：将 ``nn.Module`` 前向调用导出为细粒度节点。
* ``True``：将所有 ``nn.Module`` 前向调用导出为局部函数节点。
* nn.Module 类型集合：将 ``nn.Module`` 的 forward 调用导出为本地函数节点，
仅当找到 ``nn.Module`` 类型的集合时。
autograd_inlining: 已弃用。
控制是否内联 autograd 函数的标志。
请参阅 https://github.com/pytorch/pytorch/pull/74765 获取更多详细信息。

返回值：
如果 dynamo 为 True，则为 :class:`torch.onnx.ONNXProgram`，否则为 None。

.. 版本变更:: 2.6
*训练* 现已弃用。相反，在导出模型之前设置模型的训练模式。
*operator_export_type* 已弃用。现在仅支持 ONNX。
*do_constant_folding* 已弃用。它始终启用。
*export_modules_as_functions* 已弃用。
*autograd_inlining* 已弃用。
.. 版本变更：2.7
*优化* 现在默认为 True。
    """
    如果 dynamo 是 真实 或者 isinstance(模型, 火炬.导出.导出程序):
        from torch.onnx._internal.exporter 导入 _compat

        如果 isinstance(参数, 火炬.张量):
            args = (参数,)
        返回 _compat.导出兼容性(
            模型,
            参数,
            f,
            关键字参数=关键字参数,
            导出参数=导出参数,
            详细=详细,
            输入名称=输入名称,
            输出名称=输出名称,
            opset 版本=opset 版本,
            自定义翻译表=自定义翻译表,
            动态轴=动态轴,
            保持初始化器作为输入=保持初始化器作为输入,
            外部数据=外部数据,
            动态形状=动态形状,
            报告=报告,
            优化=优化,
            核实=核实,
            个人资料=个人资料,
            导出程序=导出程序,
            艺术品目录=艺术品目录,
            备用=备用,
        )
    否则:
        from torch.onnx.utils 导入 导出

        如果 动态形状:
            抛出 值错误(
                导出器仅支持动态形状
                当 dynamo=False 时，通过参数 dynamic_axes。
            )

        导出(
            模型,
            参数,
            f,  # type: ignore[arg-type]
            关键字参数=关键字参数,
            导出参数=导出参数,
            详细=详细 是 True,
            输入名称=输入名称,
            输出名称=输出名称,
            opset 版本=opset 版本,
            动态轴=动态轴,
            保持初始化器作为输入=保持初始化器作为输入,
            训练=训练,
            操作符导出类型=操作符导出类型,
            执行常量折叠=执行常量折叠,
            自定义操作集=自定义操作集,
            将模块导出为函数=将模块导出为函数,
            自动微分内联=自动微分内联,
        )
        返回 无



@deprecated(
    "自 2.6.0 版本起已弃用 torch.onnx.dynamo_export。请使用 torch.onnx.export(..., dynamo=True) 代替。"
)
定义 dynamo_export(
    模型: 火炬.神经网络.模块 | 可调用 | 火炬.导出.导出程序,  忽略名称定义
    /,
    *模型参数,
    导出选项: 导出选项 | 无 = 无,
    **模型参数,
) -> ONNX 程序:
    将 torch.nn.Module 导出为 ONNX 图。

已弃用
请使用 ``torch.onnx.export(..., dynamo=True)`` 代替。

参数：
导出至 ONNX 的 PyTorch 模型。
model 参数：传递给`model`的位置参数。
model_kwargs：传递给`model`的关键字参数。
导出选项：影响导出到 ONNX 的选项。

返回值：
导出 ONNX 模型的内存表示。
    """

    导入 警告

    from torch.onnx 导入 _标志
    from torch.onnx._internal.exporter 导入 _兼容
    from torch.utils 导入 _pytree

    如果 isinstance(模型, 火炬.导出.导出程序):
        返回 _compat.export_compat(
            模型,  # type: ignore[arg-type]
            model_args,
            f=无,
            关键字参数=模型参数,
            opset 版本=18,
            外部数据=True,
            导出参数=True,
            回退=True,
        )
    elif _标志.使用实验性逻辑:
        如果 导出选项 是 not 无:
            警告.警告(
                "您正在使用实验性的 ONNX 导出逻辑，该逻辑目前仅支持动态形状。"
                "若需要更全面的导出选项，包括高级功能，请考虑使用 "
                "`torch.onnx.export(..., dynamo=True)`。",
                类别=弃用警告,
            )

        如果 导出选项 是 not 无 以及 导出选项.动态形状:
            如果可能，使所有形状动态化
            定义 _转换为动态形状(x):
                如果 isinstance(x, 火炬.张量):
                    排名 = 长度(x.形状)
                    动态形状 = {}
                    对于 i 进入 范围(排名):
                        动态形状[i] = 火炬.导出.维.自动  # 类型：忽略[已定义]
                    返回 动态形状
                否则:
                    返回 无

            # 模型参数可能嵌套
            动态形状集 = _pytree.tree_map(
                _to_dynamic_shape,
                model_args,
            )
        否则:
            动态形状 = 无

        返回 兼容性.导出兼容性(
            模型,  # type: ignore[arg-type]
            模型参数,
            f=无,
            关键字参数=模型参数,
            动态形状=动态形状,
            opset 版本=18,
            外部数据=True,
            导出参数=True,
            回退=True,
        )
    否则:
        from torch.onnx._internal._exporter_legacy 导入 dynamo 导出

        返回 dynamo 导出(
            模型, *模型参数, 导出选项=导出选项, **模型参数
        )