使用 Ultralytics Inference for Rust 进行 YOLO ONNX 推理：库与 CLI 全面实战指南

Ultralytics Inference for Rust 是基于 ONNX Runtime 的高性能 YOLO 推理库与命令行工具，面向推理阶段不依赖任何 Python 运行时的部署场景。本文完整讲解它的安装、CLI 与 Rust 库两种使用方式、七类任务的输出解析、硬件执行提供方（CUDA/TensorRT/CoreML/OpenVINO 等）、GPU 端零拷贝预处理与 Cargo feature 编译选项，并结合当前仓库的导出流程与示例代码，帮你把训练好的 Ultralytics 模型无缝迁移到 Rust 生态中做实时推理。

阅读前提提示：本文介绍的是独立的 Rust crate（ultralytics-inference）。Python 侧的训练、验证与导出工作流请参见仓库的 快速上手 与 Predict 模式；将任何 Ultralytics 模型先导出为 ONNX，再用本工具运行，是完整的落地链路。

一、为什么选择 Rust 做 YOLO 推理？

Ultralytics Inference 是一个用 Rust 编写的 YOLO 推理库与命令行工具，通过 ONNX Runtime 执行已导出的 ONNX 模型，在图像、视频、摄像头与网络流上提供快速且内存安全的预测能力，推理阶段无需 Python 运行时。

整个项目以单一 crate——ultralytics-inference——的形式分发，有两种使用形态：

• CLI 形态：适合快速跑通预测与批量任务；
• 库形态：直接嵌入你的 Rust 应用。

它同时覆盖 Ultralytics 的全部 任务类型，并通过统一的设备接口支持广泛的硬件后端。其核心卖点集中在以下几个方面：

• 原生速度与小体积：编译为原生二进制，无解释器，非常适合服务器、容器与边缘设备场景。
• 内存安全：Rust 的所有权模型在没有垃圾回收器的情况下消除了整类运行时错误。
• 覆盖全部 YOLO 任务：检测、实例分割、语义分割、深度估计、分类、姿态与 OBB（旋转框）均由同一套 API 提供。
• 广泛的硬件支持：在编译期按需开启 CPU 之外的 CUDA、TensorRT、CoreML、OpenVINO、DirectML、ROCm、XNNPACK 等执行提供方（Execution Provider）。
• GPU 端预处理：可选的融合 CUDA 内核将 letterbox 缩放、归一化与 HWC→CHW 布局转换全部留在设备端，形成零拷贝输入路径。
• 自动下载：已知的 YOLO 模型名与示例资源在首次使用时自动下载。

二、环境要求与安装

2.1 前提条件

• Rust：需要 1.89 或更新版本。
• FFmpeg：若需要使用视频相关能力，需额外在系统上安装 FFmpeg 7+，并通过 video 这个 Cargo feature 开启（见下文安装说明）。
• Python（可选）：仅在需要先用 Ultralytics Python 包训练或导出模型时才需要，推理本身不依赖 Python。

2.2 CLI 方式安装

# 从 crates.io 安装命令行工具
cargo install ultralytics-inference

# 或者编译进 GPU 支持
cargo install ultralytics-inference --features cuda,tensorrt

安装完成后，可执行文件位于 ~/.cargo/bin/ultralytics-inference（Linux 与 macOS）或 Windows 的 %USERPROFILE%\.cargo\bin\ 目录下。

2.3 库方式引入

# 将 crate 添加到你的项目
cargo add ultralytics-inference

也可以在 Cargo.toml 中手动声明（本文成文时文档中记录的版本号为 0.0.35）：

[dependencies]
ultralytics-inference = "0.0.35"

三、CLI 快速上手：一条命令开始推理

CLI 暴露了 predict 子命令。不带任何参数执行时，它会自动下载一个 nano 检测模型与示例图片，执行推理并把标注结果保存到 runs/detect/predict 目录：

# 对内置示例做检测（自动下载模型与图片）
ultralytics-inference predict

# 对自己的图片做检测
ultralytics-inference predict --model yolo26n.onnx --source image.jpg

# 实例分割（自动下载 yolo26n-seg.onnx）
ultralytics-inference predict --task segment --source image.jpg

# 对视频做姿态估计，并弹出窗口实时显示
ultralytics-inference predict --task pose --source video.mp4 --show

# 深度估计（自动下载 yolo26n-depth.onnx）
ultralytics-inference predict --task depth --source image.jpg

# 调整阈值并过滤到指定类别
ultralytics-inference predict --source image.jpg --conf 0.5 --iou 0.45 --classes "0,1,2"

# 用 GPU 半精度推理跑整个文件夹
ultralytics-inference predict --source images/ --device cuda:0 --half

3.1 常用命令行参数

Flag	默认值	说明
--model, -m	yolo26n.onnx	ONNX 模型路径；若传入已知的 YOLO 模型名则自动下载。
--task	detect	任务类型，取 detect、segment、pose、obb、classify、semantic、depth 之一。
--source, -s	sample	图片、目录、glob、视频、摄像头序号或 URL。
--conf	0.25	置信度阈值。
--iou	0.7	NMS（非极大值抑制）的 IoU 阈值。
--imgsz	模型元数据	推理图像尺寸。
--device	cpu	执行设备，例如 cuda:0、coreml、tensorrt:0。
--half	false	FP16 半精度推理。
--save	true	是否将标注结果保存到 runs/<task>/predict。
--show	false	是否在窗口中显示结果。
--classes	all	按类别 ID 过滤检测结果，例如 "0,1,2"。

其中 --imgsz 默认读取模型元数据中的输入尺寸，只有在需要改变推理分辨率时才需要显式指定；--conf 与 --iou 共同控制最终输出框的稀疏程度与召回表现。

四、作为 Rust 库嵌入：加载模型与读取结果

库的使用核心是 YOLOModel。加载模型时，类别名、任务类型与图像尺寸等元数据会自动从 ONNX 文件解析，无需手工指定。

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 元数据（类别、任务、输入尺寸）自动从模型解析
    let mut model = YOLOModel::load("yolo26n.onnx")?;

    let results = model.predict("image.jpg")?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let conf = boxes.conf()[i];
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("{name} {conf:.2}");
            }
        }
    }

    Ok(())
}

从源码结构看，这里的关键设计是：Results 结构体按任务携带不同类型的输出容器，例如检测对应 boxes、分割对应 masks、姿态对应 keypoints；而类别 ID 到名称的映射统一放在 result.names 中。所有字段均为 Option，未命中该任务的容器即为 None，读取前通过 if let 解包即可保证安全。

4.1 通过 InferenceConfig 控制推理参数

如果需要精确控制置信度、IoU、图像尺寸、精度与设备，可以使用带 builder 模式的 InferenceConfig：

use ultralytics_inference::{Device, InferenceConfig, YOLOModel};

let config = InferenceConfig::new()
    .with_confidence(0.5)      // 置信度阈值
    .with_iou(0.45)            // NMS 的 IoU 阈值
    .with_imgsz(640, 640)      // 推理输入尺寸
    .with_device(Device::Cuda(0))  // 指定设备
    .with_half(true);          // FP16 半精度

let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("image.jpg")?;

Device 枚举与 CLI 的 --device 字符串一一对应，例如 Device::Cuda(0) 等价于 cuda:0、Device::TensorRt(0) 等价于 tensorrt:0，两者都可以在运行时灵活切换，无需改动业务代码。

五、逐任务解析：不同任务对应不同输出结构

每个任务会填充 Results 上的不同字段。下面的每个代码片段都是完整可运行的程序——模型与示例输入在首次运行时会自动下载。把 predict_default() 换成 predict("image.jpg") 即可运行你自己的文件。

5.1 Detect：边界框与类别

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            println!("{} detections", boxes.len());
            let xyxy = boxes.xyxy(); // 每行 [x1, y1, x2, y2]
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2} {:?}", boxes.conf()[i], xyxy.row(i).to_vec());
            }
        }
    }

    Ok(())
}

检测框以 [x1, y1, x2, y2] 的坐标形式给出，配合 cls()、conf() 即可获得每个框的类别与置信度。实践中可以把 xyxy 坐标换算成中心点/宽高（xywh）供后续跟踪器或业务逻辑使用。

5.2 Segment：框 + 逐实例掩码

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-seg.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(masks) = &result.masks {
            let (n, h, w) = masks.data.dim(); // 掩码数据形状 (N, H, W)
            println!("{n} instance masks ({h}x{w})");
        }
        if let Some(boxes) = &result.boxes {
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2}", boxes.conf()[i]);
            }
        }
    }

    Ok(())
}

实例分割的掩码形状为 (N, H, W)，N 为实例数量，H × W 为掩码分辨率；每个实例同时伴随一个检测框，便于裁剪与后续区域级分析。

5.3 Pose：框 + 关键点

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-pose.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(kpts) = &result.keypoints {
            let (n, k, _) = kpts.xy().dim(); // 关键点坐标形状 (N, K, 2)
            println!("{n} pose(s), {k} keypoints each");

            // 可选：逐关键点置信度，形状 (N, K)
            if let Some(conf) = kpts.conf() {
                println!("  keypoint confidence values: {}", conf.len());
            }
        }
    }

    Ok(())
}

姿态输出的关键点坐标为 (N, K, 2)，N 为人体实例数、K 为每实例关键点数；kpts.conf() 可选返回逐关键点置信度，可用于过滤低可信度的关节。

5.4 Classify：类别概率

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-cls.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(probs) = &result.probs {
            let top1 = probs.top1();
            let name = result.names.get(&top1).map_or("unknown", |s| s.as_str());
            println!("top-1: {name} ({:.2})", probs.top1conf());

            for (id, conf) in probs.top5().into_iter().zip(probs.top5conf()) {
                let name = result.names.get(&id).map_or("unknown", |s| s.as_str());
                println!("  {name} {conf:.2}");
            }
        }
    }

    Ok(())
}

分类任务返回完整概率向量，API 直接提供 top1() / top1conf() 与 top5() / top5conf() 两组便捷访问器，无需自己排序全量概率。

5.5 OBB：旋转框

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-obb.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(obb) = &result.obb {
            println!("{} oriented boxes", obb.len());
            let xywhr = obb.xywhr(); // 每行 [cx, cy, w, h, angle]
            for i in 0..obb.len() {
                let class_id = obb.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2} {:?}", obb.conf()[i], xywhr.row(i).to_vec());
            }
        }
    }

    Ok(())
}

OBB（定向边界框）输出以 [cx, cy, w, h, angle] 表示带旋转角的框，适用于航拍影像、文档图像等旋转目标检测场景。

5.6 Semantic：逐像素类别图

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-sem.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(sem) = &result.semantic_mask {
            let (h, w) = sem.data.dim(); // 逐像素类别图，形状 (H, W)
            println!("class map {h}x{w}");

            for class_id in sem.class_ids() {
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  present: {name}");
            }
        }
    }

    Ok(())
}

语义分割输出的是形状为 (H, W) 的逐像素类别图，class_ids() 可直接枚举画面中出现的类别集合，适合快速统计场景构成。

5.7 Depth：逐像素深度图

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-depth.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(depth) = &result.depth {
            let (h, w) = depth.data.dim(); // 逐像素深度图，形状 (H, W)，单位为米
            println!("depth map {h}x{w}");

            // 仅统计有效像素（depth > 0）；若整张图无有效像素则返回 None
            if let (Some(min), Some(max)) = (depth.min_depth(), depth.max_depth()) {
                println!("  range {min:.2}-{max:.2} m");
            }

            // 直接读取任意像素的深度值（单位：米）
            println!("  center {:.2} m", depth.data[[h / 2, w / 2]]);
        }
    }

    Ok(())
}

深度估计返回单位为米的逐像素深度图，形状为 (H, W)。注意有效像素的定义为 depth > 0，min_depth() 与 max_depth() 只统计有效像素；也可通过 ndarray 的索引直接读取任意位置的深度值，便于测距类应用。

六、支持的任务与模型兼容性

6.1 任务与默认模型

Ultralytics 的全部任务均已支持。省略 --model 时，会自动下载所选任务对应的 nano 模型。

任务	--task	输出	默认模型
检测	detect	边界框与类别	yolo26n.onnx
实例分割	segment	框 + 逐实例掩码	yolo26n-seg.onnx
语义分割	semantic	逐像素类别图	yolo26n-sem.onnx
深度估计	depth	单位为米的逐像素深度图	yolo26n-depth.onnx
分类	classify	类别概率	yolo26n-cls.onnx
姿态	pose	框 + 关键点	yolo26n-pose.onnx
定向框	obb	旋转边界框	yolo26n-obb.onnx

上表与仓库中 任务总览 所列能力一一对应；其中语义分割与深度估计为 YOLO26 系列独有能力（当前仓库的模型配置目录 ultralytics/cfg/models/26 下可看到 yolo26-sem.yaml 与 yolo26-depth.yaml 对应的独立模型配置）。

6.2 模型兼容范围

任何已导出为 ONNX 的 Ultralytics 模型都可以从本地文件加载。自动下载仅对标准的 YOLO26、YOLO11 与 YOLOv8 模型名可用，尺寸覆盖 n、s、m、l、x：

模型系列	可自动下载的变体
YOLO26	yolo26{n,s,m,l,x}.onnx，以及 -seg、-pose、-obb、-cls、-sem、-depth
YOLO11	yolo11{n,s,m,l,x}.onnx，以及 -seg、-pose、-obb、-cls
YOLOv8	yolov8{n,s,m,l,x}.onnx，以及 -seg、-pose、-obb、-cls

需要特别留意：语义分割（-sem）与深度估计（-depth）是 YOLO26 独占的模型变体，YOLO11 与 YOLOv8 没有这两个任务头。

6.3 模型文件从哪来？

两种途径：一是用 Ultralytics Python 包导出（见本文最后一章，也可参考 ONNX 集成 与 Export 模式）；二是首次运行让 CLI 为所选任务自动下载一个标准 nano 模型。若要使用自定义尺寸或自定义结构，直接把 --model 指向本地 .onnx 文件即可。

七、输入源：图像、目录、视频、摄像头与流

--source 参数（以及库中的 Source 类型）接受多种输入形态，并会从字符串自动识别类型：

输入源	示例	说明
图像	image.jpg	单个文件。
目录	images/	文件夹内全部图像。
Glob	images/*.jpg	Shell 风格通配符。
视频	video.mp4	需要开启 video feature。
摄像头	0	需要开启 video feature。
流	rtsp://...	需要开启 video feature。
URL	https://example.com/image.jpg	远程图片下载后推理。

这一设计让同一命令在开发（单图）与生产（目录批量、实时流）场景间无缝切换，例如先用 URL 验证模型，再切换到文件夹批量处理。

八、设备与执行提供方：一套 API 覆盖多硬件

推理默认在 CPU 上运行。GPU 与加速器后端以 Cargo feature 的形式在构建期编译进去，运行时通过 --device（CLI）或 Device（库）选择。下表汇总了设备字符串、Device 变体、所需构建 feature 与对应硬件：

设备字符串	Device 变体	构建 feature	硬件
cpu	Device::Cpu	内置	任意 CPU
cuda:0	Device::Cuda(0)	cuda	NVIDIA GPU
tensorrt:0	Device::TensorRt(0)	tensorrt	NVIDIA GPU，已优化
coreml	Device::CoreMl	coreml	Apple Silicon / macOS
intel:cpu	Device::IntelCpu	openvino	Intel CPU
intel:gpu	Device::IntelGpu	openvino	Intel GPU
intel:npu	Device::IntelNpu	openvino	Intel NPU
directml:0	Device::DirectMl(0)	directml	Windows GPU
rocm:0	Device::Rocm(0)	rocm	AMD GPU
xnnpack	Device::Xnnpack	xnnpack	优化后的 CPU

构建时按需编译对应执行提供方即可：

# 编译 CLI 并启用需要的执行提供方
cargo install ultralytics-inference --features cuda,tensorrt

补充说明：CLI 的 --device 字符串与库的 Device 枚举是对同一套能力的两面表述，选择哪种执行提供方本质上取决于构建期编译了哪些 feature；例如未编译 openvino 的二进制就无法通过 intel:cpu 切换后端，这一点与构建配置强相关。

九、GPU 加速与 CUDA 端零拷贝预处理

在 NVIDIA 硬件上，cuda feature 启用 CUDA 执行提供方，tensorrt 则进一步叠加 TensorRT 提供方做图级优化。若想追求最低延迟，cuda-preprocess feature 可以把预处理整体搬到 GPU 上。

其原理是：将 letterbox 缩放、归一化以及 HWC→CHW 布局转换实现为一个融合的单个 CUDA 内核，输出直接作为零拷贝的设备张量喂给模型。这样既省去了逐图的 CPU 预处理开销，也省去了 host→device 的拷贝，对高吞吐批次与实时视频流收益最明显：

# 编译融合 GPU 预处理（隐式包含 cuda + tensorrt）
cargo build --release --features cuda-preprocess

快速路径会在无需改动任何 API的情况下自动启用，前提是同时满足以下条件：

1. 构建期已编译 cuda-preprocess feature；
2. 运行设备为 CUDA 或 TensorRT；
3. 任务属于 detect、segment、pose、OBB、语义分割或深度估计；
4. 模型输入为 FP32。

该路径默认开启，也可以按模型单独关闭：

use ultralytics_inference::{Device, InferenceConfig};

let config = InferenceConfig::new()
    .with_device(Device::TensorRt(0))
    .with_cuda_preprocess(false); // 强制回退到 CPU 预处理

注意：cuda-preprocess 在构建期需要与系统匹配的 CUDA toolkit，并在运行时通过 NVRTC 编译融合预处理内核。若版本不匹配出现编译或运行问题，请核对 CUDA 版本要求并参考官方 troubleshooting 指引（docs.rs 上有完整的 CUDA/TensorRT 加速指南页面）。

十、Cargo features 全解

Cargo feature 在构建期启用，默认值已覆盖标注与实时显示需求：

Feature	默认	用途
annotate	是	绘制框、掩码、关键点与标签；--save 保存标注结果所需。
visualize	是	为 --show 提供实时窗口显示。
video	否	读写视频文件（需要 FFmpeg 7+）。
cuda	否	NVIDIA CUDA 执行提供方。
tensorrt	否	NVIDIA TensorRT 执行提供方。
cuda-preprocess	否	融合 GPU 预处理与零拷贝输入（隐含 cuda、tensorrt）。
coreml	否	Apple CoreML 执行提供方。
openvino	否	Intel OpenVINO 执行提供方。
rocm	否	AMD ROCm 执行提供方。
directml	否	Windows DirectML 执行提供方。

此外还提供若干便捷分组，一次启用一组相关后端：

• nvidia：cuda、tensorrt；
• amd：rocm、migraphx；
• intel：openvino、onednn；
• mobile：nnapi、coreml、qnn；
• all：annotate、visualize、video。

其它后端（如 nnapi、qnn、xnnpack、webgpu 等）也可单独启用。开启方式如下：

# 安装 CLI 时启用视频支持
cargo install ultralytics-inference --features video

# 安装 CLI 时启用 NVIDIA 后端
cargo install ultralytics-inference --features cuda,tensorrt

[dependencies]
ultralytics-inference = { version = "0.0.35", features = ["video"] }

瘦身建议：如果只关心程序化返回结果、不写标注文件也不需要弹窗，可以在构建时用 --no-default-features 关掉默认的 annotate 与 visualize，再按需逐项加回，从而获得更小、无图形依赖的 headless 二进制。

十一、推理结果的输出与保存

默认情况下，预测结果会被标注并保存到自动递增的 run 目录中：

runs/
└── detect/
    └── predict/          # 之后依次为 predict2、predict3……
        └── image.jpg     # 标注结果

• 子目录名与任务对应：runs/segment/、runs/pose/……依此类推。
• 视频输入源输出为标注后的视频文件；若想逐帧保存，改用 --save-frames。
• semantic 任务下，--save-json 会把逐像素类别图写成 PNG，放在 results/ 子目录下。
• depth 任务会把着色后的深度图混合叠加到原始图上输出，与 Ultralytics Python plot() 的输出风格一致。
• 标注图与视频保存需要 annotate feature；语义类别图 PNG 导出不需要它；视频输入与输出则需要 video feature。

这套输出约定与 Ultralytics Python 侧的 runs/detect/predict 目录习惯保持一致，方便跨语言工具链复用同一套后续处理流程。

十二、常见问题（FAQ）

问：我必须要安装 Python 吗？

不需要。该 crate 直接通过 ONNX Runtime 执行导出的 ONNX 模型。Python 只在前置阶段需要——即用 Ultralytics 包训练模型或将其 导出 为 ONNX 时。

问：可以运行哪些模型？

任何已导出为 ONNX 的 Ultralytics YOLO 模型都可以，包括 YOLO26、YOLO11 与 YOLOv8。已知模型名自动下载；也可以把 --model 指向任意本地 .onnx 文件。

问：如何获得模型文件？

两种方式：用 Python 包导出（参考 ONNX 集成），或首次运行时让 CLI 自动下载所选任务对应的标准 nano 模型。

问：支持视频吗？

支持，前提是编译时开启 video feature 且系统装有 FFmpeg 7+。覆盖视频文件、摄像头以及 RTSP/RTMP/HTTP 流。

问：annotate 和 visualize 这两个 feature 做什么用？

两者默认开启。annotate 负责把框、掩码、关键点与类别标签绘制到图像上，是 --save 写出标注结果的前提；visualize 为 --show 打开实时预览窗口。若只需要程序化返回结果，可用 cargo build --no-default-features 得到更精简的无头构建，再按需加回单个 feature。

十三、完整衔接：先把模型导出为 ONNX

本仓库的 Python 侧与上述 Rust 工具共同构成一条完整的落地流水线。在仓库中安装 Ultralytics Python 包后，即可把模型导出成 Rust 工具可直接加载的 ONNX 文件：

pip install ultralytics

# 以 YOLO26n 为例，导出检测模型
yolo export model=yolo26n.pt format=onnx   # 生成 yolo26n.onnx

其它任务模型沿用同一命名与 format=onnx 的导出方式：yolo26n-seg.pt（实例分割）、yolo26n-pose.pt（姿态）、yolo26n-obb.pt（旋转框）、yolo26n-cls.pt（分类），语义分割与深度估计对应 yolo26n-sem.pt、yolo26n-depth.pt（仅 YOLO26 系列可用）。导出的模型再交给 ultralytics-inference 加载，就进入了"零 Python 运行时"的推理阶段。

导出过程还支持一批常用参数用于优化部署，包括 imgsz（输入尺寸）、dynamic（动态输入尺寸）、simplify（图简化，默认开启）、opset（算子集版本）、nms（是否内置后处理）以及 quantize=8 的 INT8 静态量化（配合 data 指定校准集）。这些参数会直接影响 Rust 侧推理时的输入约定与性能表现，例如 dynamic=True 导出的模型才支持在推理侧自由调整 imgsz。更多细节可参考仓库内的 ONNX 集成指南 与 Export 模式。

十四、仓库中的相关示例与延伸阅读

如果你想在动手使用该 crate 之前，先在本仓库内看到完整的"ONNX Runtime + Rust"推理范式，可以参考两份现成的 Rust 示例工程：

• examples/YOLOv8-ONNXRuntime-Rust：覆盖分类、检测、分割、姿态与 OBB 五类任务，支持 FP16/FP32 模型、CPU/CUDA/TensorRT 执行提供方、动态输入尺寸，并提供逐阶段的推理耗时 profiling（预处理、H2D、推理、D2H、后处理）。
• examples/YOLO-Series-ONNXRuntime-Rust：面向 YOLO 系列模型的 Rust ONNX Runtime 工程。

进一步阅读仓库内配套文档，可帮助你把本文介绍的能力接入更完整的项目流程：

• Predict 模式（Python 侧预测对照）
• Export 模式（导出各格式模型）
• ONNX 集成指南（导出与部署详解）
• YOLO26 模型、YOLO11 模型、YOLOv8 模型
• 任务总览

综上，Ultralytics Inference for Rust 把 Ultralytics 全系任务与 ONNX Runtime 的多硬件生态封装进一个内存安全、无 Python 依赖的 Rust crate 中。无论你是想快速用 CLI 做一次批量检测，还是把 YOLO 推理作为模块嵌入 Rust 服务、边缘设备或实时流管线，本文给出的安装、CLI 参数、库 API、设备切换与输出约定都足以支撑你直接落地——只需先按上一章把模型导出成 ONNX，即可开始 Rust 之旅。