为推理构建 ONNX Runtime

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

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 版本的“Developer Command Prompt for 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 版本 10.12 构建。发布 Nuget 和 Python wheel 中的共享库可以安装在 macOS 10.12+ 版本上。

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

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

如今，Mac 电脑要么是基于 Intel 的，要么是基于 Apple 芯片的。默认情况下，ONNX Runtime 的构建脚本仅为构建机器所拥有的 CPU ARCH 生成位。如果您想进行交叉编译：在基于 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 架构生成一个胖二进制文件。

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

AIX

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

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。要解决此问题，您可以安装相关的文件集。
–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 上受支持。

先决条件

构建 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 上交叉编译

下载并安装 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 ()

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

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

使用 --rv64 标志执行 ./build.sh，使用 --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 设备上、或在带有模拟器的 docker 容器的 x86_64 设备上执行此操作（您可以在 x86_64 PC 上运行基于 Arm 的容器）。然后，构建说明与 Linux x86_64 的说明基本相同。但是，如果您的目标 CPU 不是 64 位，则这将不起作用，因为构建过程需要超过 2GB 的内存。

使用模拟交叉编译基于 Arm 的设备（Linux/Windows） - 推荐；简单、缓慢、仅限 ARM64（不支持 ARM32）
在 Linux 上交叉编译 - 困难、快速
在 Windows 上交叉编译

使用模拟交叉编译基于 Arm 的设备（Linux/Windows）

简单、缓慢、推荐

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

在 Linux 上交叉编译

困难、快速

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

获取相应的工具链。

TLDR；转到 https://www.linaro.org/downloads/，获取“64-bit Armv8 Cortex-A, little-endian”和“Linux Targeted”，而不是“Bare-Metal Targeted”。将其解压缩到您的构建机器，并将 bin 文件夹添加到您的 $PATH env。然后跳过这部分。

您可以使用 GCC 或 Clang。两者都可以工作，但此处的说明基于 GCC。

在 GCC 术语中
- “build”描述了配置和编译 GCC 的系统类型。
- “host”描述了 GCC 运行的系统类型。
- “target”描述了 GCC 生成代码的系统类型。
不进行交叉编译时，通常“build”=“host”=“target”。当您进行交叉编译时，通常“build”=“host”!=“target”。例如，您可以在 x86_64 上构建 GCC，然后在 x86_64 上运行 GCC，然后生成以 aarch64 为目标的二进制文件。在这种情况下，“build”=“host”= x86_64 Linux，target 是 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、arvm7l、aarch64、...
- 操作系统：裸机或 linux。
- Libc：gnu libc/ulibc/musl/…
- ABI：Arm 有多个 ABI，如 eabi、eabihf…
您可以从之前的输出中获得所有这些信息，请确保它们都是正确的。

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

将目标操作系统的根文件系统转储到您的构建机器。我们将该文件夹称为“sysroot”，并将其用于构建 onnxruntime python 扩展。在执行此操作之前，您应该首先在目标机器上安装 python3 dev 包（其中包含 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

生成 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 的依赖项可能会使用。

运行 CMake 和 make

将 -Donnxruntime_ENABLE_CPUINFO=OFF -DCMAKE_TOOLCHAIN_FILE=path/to/tool.cmake 附加到您的 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

（可选）构建 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++ 编译器

下载并安装用于 Arm(64) 的 Visual C++ 编译器和库。如果您已安装 Visual Studio，请使用 Visual Studio Installer（在选择 修改 Visual Studio 后，在 Individual components 部分下查找）下载并安装相应的 Arm(64) 编译器和库。
使用 .\build.bat 并指定 --arm 或 --arm64 作为构建选项以开始构建。最好使用 Developer Command Prompt for VS，或确保所有已安装的交叉编译器都可以从用于构建的命令提示符中使用 PATH 环境变量找到。
将 --use_vcpkg 添加到您的构建命令中，这可以避免手动处理 protoc.exe。

移动端

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

Web

请参阅为 Web 构建

为推理构建 ONNX Runtime

目录

CPU

先决条件

构建说明

Windows

Linux

macOS

AIX

注意事项

支持的架构和构建环境

架构

构建环境（主机）

目标环境

通用构建说明

API 和语言绑定

构建 Nuget 包

先决条件

构建说明

Windows

Linux

其他构建选项

缩减运算符内核构建

DebugNodeInputsOutputs

构建说明

Linux

Windows

配置

示例

RISC-V

在 Linux 上交叉编译

Arm

使用模拟交叉编译基于 Arm 的设备（Linux/Windows）

在 Linux 上交叉编译

在 Windows 上交叉编译

移动端

Web