构建 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 Generator 是 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 版本 10.12 进行构建。发布 Nuget 包和 Python wheel 中的共享库可以安装在 macOS 10.12+ 版本上。

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

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

如今，Mac 计算机是基于 Intel 或基于 Apple silicon 的。默认情况下，ONNX Runtime 的构建脚本仅生成构建机器 CPU ARCH 对应的二进制文件。如果您想进行交叉编译：在基于 Intel 的 Mac 计算机上生成 arm64 二进制文件，或在搭载 Apple silicon 的 Mac 系统上生成 x86 二进制文件，您可以设置 cmake 变量 “CMAKE_OSX_ARCHITECTURES”。例如：

构建 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 silicon 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 中，您可以使用以下工具构建 ONNX Runtime 的 64 位版本：

• IBM Open XL 编译器工具链。所需的最低 AIX OS 版本为 7.2。您需要拥有 17.1.2 编译器 PTF5 (17.1.2.5) 版本。
• GNU GCC 编译器工具链。所需的最低 AIX OS 版本为 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。要解决此问题，您可以安装相关的 file-sets。
• 构建选项中的 –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=full path to protoc"，以便 ONNX 构建能够找到它。同时运行 ldconfig <protobuf lib folder path>，以便链接器能够找到 protobuf 库。
• 如果您想从源代码安装 onnx，请先安装 protobuf，然后：

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

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

支持的架构和构建环境

架构

	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)
Release 构建	--config Release	Release 构建。其他有效的 config 值包括 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。

前提条件

• 构建 csharp 绑定和创建托管 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 中包含更多相关信息。

精简算子内核构建

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

DebugNodeInputsOutputs

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。

示例

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

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 容器）的 x86_64 设备上使用 docker 容器进行构建。然后，构建说明基本上与 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，target 是 aarch64 Linux。

   您可以自己从源代码构建 GCC，或者从 Ubuntu、linaro 等供应商获取预构建版本。选择与您的目标操作系统相同的编译器版本是最好的。如果无法做到，请选择最新的稳定版本并静态链接到 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。通常每个硬件供应商都会提供工具链；检查它是如何构建的。

   目标环境由以下因素标识：

   • 架构 (Arch)：x86_32, x86_64, armv6,armv7,arvm7l,aarch64,…
   • 操作系统 (OS)：裸机 (bare-metal) 或 linux。
   • Libc：gnu libc/ulibc/musl/…
   • ABI：Arm 有多种 ABI，如 eabi, eabihf…

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

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

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

   以下是一些示例：

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

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

   Disk 2020-02-13-raspbian-buster.img: 3.54 GiB, 3787456512 bytes, 7397376 sectors Units: sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disklabel type: dos Disk identifier: 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 和 mount 之前进行转换。

    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

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

   -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 作为构建选项来开始构建。最好使用 适用于 VS 的开发者命令提示符，或确保使用 PATH 环境变量可从用于构建的命令提示符找到所有已安装的交叉编译器。

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

---

移动端

请参阅 构建 Android 和 构建 iOS

Web

请参阅 构建 Web