为推理构建 ONNX Runtime

请按照以下说明构建 ONNX Runtime 以执行推理。

目录

• CPU
• 支持的架构和构建环境
• 通用构建说明
• 其他构建选项

CPU

基本 CPU 构建

先决条件

• 检出源代码树

   git clone --recursive https://github.com/Microsoft/onnxruntime.git
   cd onnxruntime
  

• 安装 Python 3.10+。

• 安装 cmake-3.28 或更高版本。

  在 Windows 上，我们建议从 WinGet 获取最新版本。请运行

    winget install -e --id Kitware.CMake
  

  在 Linux 上，您可以从 PyPI 获取。请运行

    python3 -m pip install cmake
    which cmake
  

  如果上述命令失败，请手动从 https://cmake.com.cn/download/ 获取 cmake。

  安装后，您可以运行

    cmake --version
  

  以验证安装是否成功。

构建说明

Windows

打开您将使用的 Visual Studio 版本的开发人员命令提示符。这将正确设置环境，包括编译器、链接器、实用程序和头文件的路径。

.\build.bat --config RelWithDebInfo --build_shared_lib --parallel --compile_no_warning_as_error --skip_submodule_sync

默认的 Windows CMake 生成器是 Visual Studio 2022。其他 Visual Studio 版本不受支持。

如果您想在 Windows ARM64 机器上构建 ARM64 二进制文件，可以使用上述相同的命令。请确保您的 Visual Studio、CMake 和 Python 都是 ARM64 版本。

如果您想在 Windows x86 机器上交叉编译 ARM64 或 ARM64EC 二进制文件，您需要在上述构建命令中添加“–arm64”或“–arm64ec”。

请确保您的 Python 解释器是 64 位 Windows 应用程序。我们不再支持 32 位构建。

Linux

./build.sh --config RelWithDebInfo --build_shared_lib --parallel --compile_no_warning_as_error --skip_submodule_sync

macOS

默认情况下，ONNX Runtime 配置为针对最低目标 macOS 版本 13.3 进行构建。发布 Nuget 包中的共享库和 Python wheel 文件可以在 macOS 13.3+ 版本上安装。

如果您想使用 Xcode 为 x86_64 macOS 构建 onnxruntime，请在命令行中添加 --use_xcode 参数。

如果没有此标志，cmake 构建生成器将默认为 Unix makefile。

如今，Mac 电脑要么是基于 Intel 的，要么是基于 Apple 芯片的。默认情况下，ONNX Runtime 的构建脚本只为构建机器所具有的 CPU 架构生成二进制文件。如果您想进行交叉编译：在基于 Intel 的 Mac 电脑上生成 arm64 二进制文件，或在带有 Apple 芯片的 Mac 系统上生成 x86 二进制文件，您可以设置“CMAKE_OSX_ARCHITECTURES” cmake 变量。例如

为 Intel CPU 构建

./build.sh --config RelWithDebInfo --build_shared_lib --parallel --compile_no_warning_as_error --skip_submodule_sync --cmake_extra_defines CMAKE_OSX_ARCHITECTURES=x86_64

为 Apple 芯片 CPU 构建

./build.sh --config RelWithDebInfo --build_shared_lib --parallel --compile_no_warning_as_error --skip_submodule_sync --cmake_extra_defines CMAKE_OSX_ARCHITECTURES=arm64

为两者构建

./build.sh --config RelWithDebInfo --build_shared_lib --parallel --compile_no_warning_as_error --skip_submodule_sync --cmake_extra_defines CMAKE_OSX_ARCHITECTURES="x86_64;arm64"

最后一个命令将为两种 CPU 架构生成一个通用二进制文件（fat-binary）。

注意：在交叉编译时，由于 CPU 指令集不兼容，单元测试将被跳过。

AIX

在 AIX 中，您可以使用以下方式构建 64 位 ONNX Runtime：

• IBM Open XL 编译器工具链。最低要求的 AIX 操作系统版本为 7.2。您需要安装 17.1.2 编译器 PTF5 (17.1.2.5) 版本。
• GNU GCC 编译器工具链。最低要求的 AIX 操作系统版本为 7.3。需要 GCC 10.3+ 版本。

对于 IBM Open XL，请导出以下环境变量设置。

ulimit -m unlimited
ulimit -d unlimited
ulimit -n 2000
ulimit -f unlimited
export OBJECT_MODE=64
export BUILD_TYPE="Release"
export CC="/opt/IBM/openxlC/17.1.2/bin/ibm-clang" 
export CXX="/opt/IBM/openxlC/17.1.2/bin/ibm-clang++_r"
export CFLAGS="-pthread -m64 -D_ALL_SOURCE -mcmodel=large -Wno-deprecate-lax-vec-conv-all  -Wno-unused-but-set-variable -Wno-unused-command-line-argument -maltivec -mvsx  -Wno-unused-variable -Wno-unused-parameter -Wno-sign-compare"
export CXXFLAGS="-pthread -m64 -D_ALL_SOURCE -mcmodel=large -Wno-deprecate-lax-vec-conv-all -Wno-unused-but-set-variable -Wno-unused-command-line-argument -maltivec -mvsx  -Wno-unused-variable -Wno-unused-parameter -Wno-sign-compare"
export LDFLAGS="-L$PWD/build/Linux/$BUILD_TYPE/ -lpthread"
export LIBPATH="$PWD/build/Linux/$BUILD_TYPE/"

对于 GCC，请导出以下环境变量设置。

ulimit -m unlimited
ulimit -d unlimited
ulimit -n 2000
ulimit -f unlimited
export OBJECT_MODE=64
export BUILD_TYPE="Release"
export CC="gcc" 
export CXX="g++"
export CFLAGS="-maix64 -pthread -DFLATBUFFERS_LOCALE_INDEPENDENT=0 -maltivec -mvsx   -Wno-unused-function -Wno-unused-variable -Wno-unused-parameter -Wno-sign-compare -fno-extern-tls-init -Wl,-berok "
export CXXFLAGS="-maix64 -pthread -DFLATBUFFERS_LOCALE_INDEPENDENT=0 -maltivec -mvsx  -Wno-unused-function -Wno-unused-variable -Wno-unused-parameter -Wno-sign-compare -fno-extern-tls-init -Wl,-berok "
export LDFLAGS="-L$PWD/build/Linux/$BUILD_TYPE/ -Wl,-bbigtoc -lpython3.9"
export LIBPATH="$PWD/build/Linux/$BUILD_TYPE"

要启动构建，请运行以下命令：

./build.sh \
--config $BUILD_TYPE\
  --build_shared_lib \
  --skip_submodule_sync \
  --cmake_extra_defines CMAKE_INSTALL_PREFIX=$PWD/install \
  --parallel  

• 如果您想将包安装到自定义目录中，请将该目录位置指定为 CMAKE_INSTALL_PREFIX 的值。
• 对于 IBM Open XL 编译器工具链，AIX 7.2 中可能缺少 onnxruntime 所需的一些运行时库，例如 libunwind.a。要解决此问题，您可以安装相关的文件集。
• 构建选项中的 –parallel 选项。顾名思义，此选项用于并行构建，并且是资源密集型选项。因此，如果您的系统每个 CPU 核心没有足够的内存，则可以跳过此选项。
• 如果 root 用户触发构建，则需要 –allow_running_as_root。

备注

• 请注意，这些说明构建的是调试版本，这可能会带来性能上的折衷。 “–config”参数有四个有效值：Debug、Release、RelWithDebInfo 和 MinSizeRel。与“Release”相比，“RelWithDebInfo”不仅包含调试信息，还禁用了一些内联，使二进制文件更容易调试。因此，RelWithDebInfo 比 Release 慢。
• 要从每个版本（包括 Windows、Linux 和 Mac 变体）构建版本，请参阅这些 .yml 文件以供参考
• 构建脚本默认对本机构建运行所有单元测试，并默认跳过交叉编译构建的测试。要跳过测试，请使用 --build 或 --update --build 运行。
• 如果您需要从源代码安装 protobuf，请注意
  • 首先，请打开 cmake/deps.txt 查看 ONNX Runtime 官方包使用的 protobuf 版本。
  • 由于我们静态链接到 protobuf，在 Windows 上 protobuf 的 CMake 标志 protobuf_BUILD_SHARED_LIBS 应该设置为 OFF；在 Linux 上，如果该选项为 OFF，您还需要确保 PIC 已启用。安装后，您的 PATH 中应该有 'protoc' 可执行文件。建议运行 ldconfig 以确保能找到 protobuf 库。
  • 如果您将 protobuf 安装在非标准位置，设置以下环境变量会很有帮助：export CMAKE_ARGS="-DONNX_CUSTOM_PROTOC_EXECUTABLE=protoc 的完整路径"，以便 ONNX 构建能够找到它。同时运行 ldconfig <protobuf 库文件夹路径>，以便链接器能够找到 protobuf 库。
• 如果您想从源代码安装 onnx，请先安装 protobuf，然后

    export ONNX_ML=1
    python3 setup.py bdist_wheel
    pip3 install --upgrade dist/*.whl
  

  然后，在开始构建 ONNX Runtime 之前，最好卸载 protobuf，特别是如果您安装了与 ONNX Runtime 不同的 protobuf 版本。—

支持的架构和构建环境

架构

	x86_32	x86_64	ARM32v7	ARM64	PPC64LE	RISCV64	PPC64BE	S390X
Windows	是	是	是	是	否	否	否	否
Linux	是	是	是	是	是	是	否	是
macOS	否	是	否	否	否	否	否	否
Android	否	否	是	是	否	否	否	否
iOS	否	否	否	是	否	否	否	否
AIX	否	否	否	否	否	否	是	否

构建环境(宿主机)

操作系统	支持 CPU	支持 GPU	备注
Windows 10	是	是	支持 VS2019 至最新的 VS2022
Windows 10 适用于 Linux 的子系统	是	否
Ubuntu 20.x/22.x	是	是	也支持 ARM32v7 (实验性)
CentOS 7/8/9	是	是	也支持 ARM32v7 (实验性)
macOS	是	否

不支持 GCC 8.x 及以下版本。
如果您想为 32 位架构构建二进制文件，您可能需要进行交叉编译，因为 32 位编译器可能没有足够的内存来运行构建。
不支持在 Android/iOS 上构建代码。您需要使用 Windows、Linux 或 macOS 设备来完成。

操作系统/编译器	支持 VC	支持 GCC	支持 Clang
Windows 10	是	未测试	未测试
Linux	否	是(gcc>=8)	未测试
macOS	否	未测试	是 (最低版本未确定)

目标环境

您可以为以下平台构建代码：

• Windows
• Linux
• macOS
• Android
• iOS
• WebAssembly

运行时

• 支持的最低 Windows 版本是 Windows 10。
• 支持的最低 CentOS 版本是 7。
• 支持的最低 Ubuntu 版本是 16.04。

---

通用构建说明

描述	命令	附加详情
基本构建	build.bat (Windows) ./build.sh (Linux)
发布构建	--config Release	发布构建。其他有效的配置值是 RelWithDebInfo 和 Debug。
使用并行处理构建	--parallel	强烈建议使用此选项以加速构建。
构建共享库	--build_shared_lib
启用训练支持	--enable_training

API 和语言绑定

API	命令	附加详情
Python	--build_wheel
C# 和 C Nuget 包	--build_nuget	构建 C# 绑定并创建 nuget 包。暗示 --build_shared_lib 详细说明请见下文。
WindowsML	--use_winml --use_dml --build_shared_lib	WindowsML 依赖于 DirectML 和 OnnxRuntime 共享库
Java	--build_java	在构建目录中创建 onnxruntime4j.jar，暗示 --build_shared_lib 编译 Java API 除了通常的要求外，还需要安装 gradle v6.1+。
Node.js	--build_nodejs	构建 Node.js 绑定。暗示 --build_shared_lib

构建 Nuget 包

目前仅支持 Windows 和 Linux。

先决条件

• 构建 C# 绑定和创建托管 nuget 包需要 dotnet。请按照此处说明下载 dotnet。已使用 2.1 和 3.1 版本进行测试。
• nuget.exe。请按照此处说明下载 nuget
  • 在 Windows 上，下载 nuget 非常简单，只需按照上述说明操作即可。
  • 在 Linux 上，nuget 依赖于 Mono 运行时，因此也需要进行设置。上述链接包含设置 Mono 和 nuget 的所有信息。说明可直接在此处找到。在某些情况下，安装 Mono 后需要运行 sudo apt-get install mono-complete。

构建说明

Windows

.\build.bat --build_nuget

Linux

./build.sh --build_nuget

Nuget 包创建在\nuget-artifacts

---

其他构建选项

• 您可以使用 VCPKG 构建 onnxruntime。文档 /docs/build/dependencies.md 包含更多信息。

精简运算符内核构建

精简运算符内核构建允许您自定义构建中的内核，以提供更小的二进制文件大小。

调试节点输入输出

OnnxRuntime 支持用于启用中间张量形状和数据调试的构建选项。

构建说明

设置 onnxruntime_DEBUG_NODE_INPUTS_OUTPUT 以启用此功能进行构建。

Linux

./build.sh --cmake_extra_defines onnxruntime_DEBUG_NODE_INPUTS_OUTPUTS=1

Windows

.\build.bat --cmake_extra_defines onnxruntime_DEBUG_NODE_INPUTS_OUTPUTS=1

配置

调试转储行为可以通过多个环境变量控制。详情请参阅 onnxruntime/core/framework/debug_node_inputs_outputs_utils.h。

示例

要指定节点输出数据应被转储（默认为标准输出），请设置此环境变量

ORT_DEBUG_NODE_IO_DUMP_OUTPUT_DATA=1

要指定节点输出数据应转储到名为“Foo”或“Bar”的节点的对应文件中，请设置这些环境变量

ORT_DEBUG_NODE_IO_DUMP_OUTPUT_DATA=1
ORT_DEBUG_NODE_IO_NAME_FILTER="Foo;Bar"
ORT_DEBUG_NODE_IO_DUMP_DATA_TO_FILES=1

---

RISC-V

在 RISC-V 等平台上运行涉及从主机平台（例如 Linux）交叉编译到目标平台（特定的 RISC-V CPU 架构和操作系统）。请按照以下说明构建用于 RISC-V 64 位的 ONNX Runtime。

在 Linux 上交叉编译

1. 下载并安装 GNU RISC-V 交叉编译工具链和模拟器。

   如果您使用 Ubuntu，可以通过访问 https://github.com/riscv-collab/riscv-gnu-toolchain/releases 获取预构建的 RISC-V GNU 工具链。查找合适的版本，例如 riscv64-glibc-ubuntu-22.04-llvm-nightly-XXXX-nightly.tar.gz。下载后，将存档解压到您的构建机器，并将“bin”文件夹添加到您的 $PATH 环境变量中。QEMU 模拟器也位于工具链文件夹中。如果您已经按照这些说明操作，请跳过此步骤。

   对于其他 Linux 发行版的用户，可以选择从源代码编译 GCC。建议选择与您的目标操作系统相对应的编译器版本，并推荐选择最新的稳定版本。

   获取编译器后，运行 riscv64-unknown-linux-gnu-gcc -v，这将产生如下输出：

       Using built-in specs.
       COLLECT_GCC=/path/to/riscv64-unknown-linux-gnu-gcc
       COLLECT_LTO_WRAPPER=/path/to/libexec/gcc/riscv64-unknown-linux-gnu/13.2.0/lto-wrapper
       Target: riscv64-unknown-linux-gnu
       Configured with: /path/to/riscv-gnu-toolchain/gcc/configure --target=riscv64-unknown-linux-gnu --prefix=/opt/riscv --with-sysroot=/opt/riscv/sysroot --with-pkgversion= --with-system-zlib --enable-shared --enable-tls --enable-languages=c,c++,fortran --disable-libmudflap --disable-libssp --disable-libquadmath --disable-libsanitizer --disable-nls --disable-bootstrap --src=.././gcc --disable-multilib --with-abi=lp64d --with-arch=rv64gc --with-tune=rocket --with-isa-spec=20191213 'CFLAGS_FOR_TARGET=-O2    -mcmodel=medlow' 'CXXFLAGS_FOR_TARGET=-O2    -mcmodel=medlow'
       Thread model: posix
       Supported LTO compression algorithms: zlib zstd
       gcc version 13.2.0 ()
   

2. 配置 RISC-V 64 位 CMake 工具链文件

   CMake 工具链文件位于 ${ORT_ROOT}/cmake/riscv64.toolchain.cmake。如果变量有需要配置的替代值，请在该文件中包含相应的设置。

3. 在 Linux 上交叉编译

   执行 ./build.sh 并带上 --rv64 标志，使用 --riscv_toolchain_root 指定 RISC-V 工具链根目录，并使用 --riscv_qemu_path 提供 QEMU 路径作为构建选项来启动构建过程。确保所有已安装的交叉编译器都可以从用于构建的命令提示符访问，方法是配置 PATH 环境变量。

   （可选）如果您打算使用 xnnpack 作为执行提供程序，请务必在构建配置中包含 --use_xnnpack 选项。

   示例构建命令

    ./build.sh --parallel --config Debug --rv64 --riscv_toolchain_root=/path/to/toolchain/root --riscv_qemu_path=/path/to/qemu-riscv64 --skip_tests
   

Arm

有几种为基于 Arm® 的设备构建 ONNX Runtime 的选项。

首先，您可以在真实的 Arm 设备上进行，或者在带有模拟器（如 qemu）的 x86_64 设备上进行，或者在带有模拟器（您可以在 x86_64 PC 上运行基于 Arm 的容器）的 docker 容器中的 x86_64 设备上进行。那么构建说明本质上与 Linux x86_64 的说明相同。但是，如果您的目标 CPU 不是 64 位，则无法工作，因为构建过程需要超过 2GB 内存。

• 通过模拟进行基于 Arm 设备的交叉编译 (Linux/Windows) - 推荐；简单，慢，仅限 ARM64（不支持 ARM32）
• 在 Linux 上交叉编译 - 困难，快
• 在 Windows 上交叉编译

通过模拟进行基于 Arm 设备的交叉编译 (Linux/Windows)

简单、慢、推荐

此方法依赖于 qemu 用户模式仿真。它允许您通过指令级仿真使用桌面或云虚拟机进行编译。您将在 x86 CPU 上运行构建，并将每个 Arm 架构指令转换为 x86。这可能比在低端设备上本地编译快得多。生成的 ONNX Runtime Python wheel (.whl) 文件随后部署到基于 Arm 的设备上，在那里可以在 Python 3 脚本中调用。构建过程可能需要数小时，如果目标 CPU 是 32 位，可能会内存不足。

在 Linux 上交叉编译

困难，快

此选项非常快，可以在几分钟内构建软件包，但设置起来很困难。如果您有大型代码库（例如，您正在向 onnxruntime 添加新的执行提供程序），这可能是唯一可行的方法。

1. 获取相应的工具链。

   简而言之；前往 https://www.linaro.org/downloads/，获取“64-bit Armv8 Cortex-A, little-endian”和“Linux Targeted”，而不是“Bare-Metal Targeted”。将其解压到您的构建机器并将 bin 文件夹添加到您的 $PATH 环境变量中。然后跳过此部分。

   您可以使用 GCC 或 Clang。两者都可行，但这里的说明基于 GCC。

   在 GCC 术语中

   • “build”描述了配置和编译 GCC 的系统类型。
   • “host”描述了 GCC 运行的系统类型。
   • “target”描述了 GCC 生成代码的系统类型。

   当不进行交叉编译时，通常“build”=“host”=“target”。当您进行交叉编译时，通常“build”=“host”≠“target”。例如，您可以在 x86_64 上构建 GCC，然后运行在 x86_64 上，再生成目标为 aarch64 的二进制文件。在这种情况下，“build”=“host”= x86_64 Linux，目标是 aarch64 Linux。

   您可以自行从源代码构建 GCC，或者从 Ubuntu、linaro 等供应商获取预构建的 GCC。选择与目标操作系统相同的编译器版本是最好的。如果不可能，请选择最新的稳定版本并静态链接到 GCC 库。

   获取编译器后，运行 aarch64-linux-gnu-gcc -v，这将产生如下输出：

    Using built-in specs.
    COLLECT_GCC=/usr/bin/aarch64-linux-gnu-gcc
    COLLECT_LTO_WRAPPER=/usr/libexec/gcc/aarch64-linux-gnu/9/lto-wrapper
    Target: aarch64-linux-gnu
    Configured with: ../gcc-9.2.1-20190827/configure --bindir=/usr/bin --build=x86_64-redhat-linux-gnu --datadir=/usr/share --disable-decimal-float --disable-dependency-tracking --disable-gold --disable-libgcj --disable-libgomp --disable-libmpx --disable-libquadmath --disable-libssp --disable-libunwind-exceptions --disable-shared --disable-silent-rules --disable-sjlj-exceptions --disable-threads --with-ld=/usr/bin/aarch64-linux-gnu-ld --enable-__cxa_atexit --enable-checking=release --enable-gnu-unique-object --enable-initfini-array --enable-languages=c,c++ --enable-linker-build-id --enable-lto --enable-nls --enable-obsolete --enable-plugin --enable-targets=all --exec-prefix=/usr --host=x86_64-redhat-linux-gnu --includedir=/usr/include --infodir=/usr/share/info --libexecdir=/usr/libexec --localstatedir=/var --mandir=/usr/share/man --prefix=/usr --program-prefix=aarch64-linux-gnu- --sbindir=/usr/sbin --sharedstatedir=/var/lib --sysconfdir=/etc --target=aarch64-linux-gnu --with-bugurl=https://bugzilla.redhat.com/bugzilla/ --with-gcc-major-version-only --with-isl --with-newlib --with-plugin-ld=/usr/bin/aarch64-linux-gnu-ld --with-sysroot=/usr/aarch64-linux-gnu/sys-root --with-system-libunwind --with-system-zlib --without-headers --enable-gnu-indirect-function --with-linker-hash-style=gnu
    Thread model: single
    gcc version 9.2.1 20190827 (Red Hat Cross 9.2.1-3) (GCC)
   

   检查 --build、--host、--target 的值，以及它是否包含特殊参数，例如 --with-arch=armv8-a、--with-arch=armv6、--with-tune=arm1176jz-s、--with-fpu=vfp、--with-float=hard。

   您还必须了解您的目标硬件需要哪种标志，这可能大相径庭。例如，如果您直接获取普通的 ARMv7 编译器并将其用于 Raspberry Pi V1，它将不起作用，因为 Raspberry Pi 只有 ARMv6。通常，每个硬件供应商都会提供一个工具链；检查它是如何构建的。

   目标环境通过以下方式识别：

   • 架构：x86_32, x86_64, armv6, armv7, armv7l, aarch64,...
   • 操作系统：裸机或 Linux。
   • Libc：gnu libc/ulibc/musl/...
   • ABI：Arm 有多种 ABI，如 eabi, eabihf...

   您可以从之前的输出中获取所有这些信息，请确保它们都正确无误。

2. （可选）设置 sysroot 以启用 Python 扩展。如果不使用 Python，请跳过。

   将目标操作系统的根文件系统转储到您的构建机器上。我们将该文件夹称为“sysroot”，并将其用于构建 onnxruntime Python 扩展。在此之前，您应该首先在目标机器上安装 python3 开发包（包含 C 头文件）和 numpy Python 包。

   以下是一些示例。

   如果目标操作系统是 raspbian-buster，请从其网站下载 RAW 镜像，然后运行

    $ fdisk -l 2020-02-13-raspbian-buster.img
   

   磁盘 2020-02-13-raspbian-buster.img：3.54 GiB, 3787456512 字节, 7397376 扇区 单位：扇区大小为 1 * 512 = 512 字节 扇区大小（逻辑/物理）：512 字节 / 512 字节 I/O 大小（最小/最佳）：512 字节 / 512 字节 磁盘标签类型：dos 磁盘标识符：0xea7d04d6

   设备	启动	开始	结束	扇区	大小	ID	类型
   2020-02-13-raspbian-buster.img1		8192	532479	524288	256M	c	W95 FAT32 (LBA)
   2020-02-13-raspbian-buster.img2		532480	7397375	6864896	3.3G	83	Linux

   您会发现根分区从第 532480 个扇区开始，即从开头算起 532480 * 512 = 272629760 字节。

   然后运行

    $ mkdir /mnt/pi
    $ mount -r -o loop,offset=272629760 2020-02-13-raspbian-buster.img /mnt/pi
   

   您将在 /mnt/pi 看到所有 raspbian 文件。但是您还不能使用它。因为一些符号链接已损坏，您必须先修复它们。

   在 /mnt/pi 中，运行

    $ find . -type l -exec realpath  {} \; |grep 'No such file'
   

   它会显示哪些已损坏。然后您可以通过运行以下命令修复它们：

    $ mkdir /mnt/pi2
    $ cd /mnt/pi2
    $ sudo tar -C /mnt/pi -cf - . | sudo tar --transform 'flags=s;s,^/,/mnt/pi2/,' -xf -
   

   然后 /mnt/pi2 就是您下一步将使用的 sysroot 文件夹。

   如果目标操作系统是 Ubuntu，您可以从 https://cloud-images.ubuntu.com/ 获取镜像。但该镜像为 qcow2 格式。请在运行 fdisk 和挂载之前进行转换。

    qemu-img convert -p -O raw ubuntu-18.04-server-cloudimg-arm64.img ubuntu.raw
   

   剩余部分与 raspbian 类似。

   如果目标操作系统是 manylinux2014，您可以通过以下方式获取：从 apt 或 dnf 安装 qemu-user-static。然后运行 docker

   Ubuntu

    docker run -v /usr/bin/qemu-aarch64-static:/usr/bin/qemu-aarch64-static -it --rm quay.io/pypa/manylinux2014_aarch64 /bin/bash
   

   在 Fedora 上不需要 “-v /usr/bin/qemu-aarch64-static:/usr/bin/qemu-aarch64-static” 参数。

   然后，在 docker 内部，运行

    cd /opt/python
    ./cp35-cp35m/bin/python -m pip install numpy==1.16.6
    ./cp36-cp36m/bin/python -m pip install numpy==1.16.6
    ./cp37-cp37m/bin/python -m pip install numpy==1.16.6
    ./cp38-cp38/bin/python -m pip install numpy==1.16.6
   

   这些命令将花费数小时，因为 numpy 还没有预构建的包。完成后，打开第二个窗口并运行

    docker ps
   

   从输出中

    CONTAINER ID        IMAGE                                COMMAND             CREATED             STATUS              PORTS               NAMES
    5a796e98db05        quay.io/pypa/manylinux2014_aarch64   "/bin/bash"         3 minutes ago       Up 3 minutes                            affectionate_cannon
   

   您会看到 docker 实例 ID 是：5a796e98db05。使用以下命令将根文件系统导出为 sysroot 以备将来使用。

    docker export 5a796e98db05 -o manylinux2014_aarch64.tar
   

3. 生成 CMake 工具链文件 将以下内容保存为 tool.cmake

    SET(CMAKE_SYSTEM_NAME Linux)
    SET(CMAKE_SYSTEM_VERSION 1)
    SET(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
    SET(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
    SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
    SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
    SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
    SET(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
    SET(CMAKE_FIND_ROOT_PATH /mnt/pi)
   

   如果您没有 sysroot，可以删除最后一行。

   此外，您还可以设置 CMAKE_SYSTEM_PROCESSOR。CMake 的官方文档建议，在进行交叉编译时，CMAKE_TOOLCHAIN_FILE 应设置 CMAKE_SYSTEM_PROCESSOR 变量以匹配其指定的目标架构。但文档未提供有效值列表，我们发现此设置并非必需。无论如何，如果您知道该变量应设置为哪个值，请在此处添加设置。ONNX Runtime 的构建脚本不使用此变量，但 ONNX Runtime 的依赖项可能会使用。

4. 运行 CMake 和 make

   在您的 cmake 参数中添加 -Donnxruntime_ENABLE_CPUINFO=OFF -DCMAKE_TOOLCHAIN_FILE=path/to/tool.cmake，然后运行 cmake 和 make 来构建它。如果您还想构建 Python 包，可以使用类似以下的 cmake 参数：

   -Donnxruntime_GCC_STATIC_CPP_RUNTIME=ON -DCMAKE_BUILD_TYPE=Release -Dprotobuf_WITH_ZLIB=OFF -DCMAKE_TOOLCHAIN_FILE=path/to/tool.cmake -Donnxruntime_ENABLE_PYTHON=ON -DPYTHON_EXECUTABLE=/mnt/pi/usr/bin/python3 -Donnxruntime_BUILD_SHARED_LIB=OFF -Donnxruntime_DEV_MODE=OFF "-DPYTHON_INCLUDE_DIR=/mnt/pi/usr/include;/mnt/pi/usr/include/python3.7m" -DNUMPY_INCLUDE_DIR=/mnt/pi/folder/to/numpy/headers
   

   运行 cmake 后，运行

   $ make
   

5. （可选）构建 Python 包

   将 setup.py 文件从源文件夹复制到构建文件夹并运行

   python3 setup.py bdist_wheel -p linux_aarch64
   

   如果目标是 manylinux，不幸的是其工具在交叉编译场景下不起作用。请在 docker 中运行，例如

   docker run  -v /usr/bin/qemu-aarch64-static:/usr/bin/qemu-aarch64-static -v `pwd`:/tmp/a -w /tmp/a --rm quay.io/pypa/manylinux2014_aarch64 /opt/python/cp37-cp37m/bin/python3 setup.py bdist_wheel
   

   如果您只想针对特定的 Linux 发行版（即 Ubuntu），则无需此操作。

在 Windows 上交叉编译

使用 Visual C++ 编译器

1. 下载并安装适用于 Arm(64) 的 Visual C++ 编译器和库。如果您已安装 Visual Studio，请使用 Visual Studio 安装程序（在选择修改 Visual Studio 后，查看“各个组件”部分）下载并安装相应的 Arm(64) 编译器和库。

2. 使用 .\build.bat 并指定 --arm 或 --arm64 作为构建选项来开始构建。最好使用 Visual Studio 的开发人员命令提示符，或者确保所有已安装的交叉编译器都可以从用于构建的命令提示符通过 PATH 环境变量找到。

3. 在构建命令中添加 --use_vcpkg，这可以避免手动处理 protoc.exe。

---

移动设备

请参阅 为 Android 构建 和 为 iOS 构建

Web

请参阅 为 Web 构建