开始使用

Google LiteRT 导出

LiteRT 是 Google 的端侧 AI 运行时,也是 TensorFlow Lite (TFLite) 的新名称。使用 format="litert" 导出 Ultralytics YOLO26 模型,会生成一个 .tflite 文件,可用于 Android 和 iOS 手机、嵌入式 Linux 开发板以及 Web 浏览器,支持 FP32 或三种 INT8 量化方案之一。

概览#

属性详情
format 参数litert。较早的 tflite 和 tfjs 值仍然可用:它们会记录弃用警告,并导出相同的 LiteRT 文件
输出yolo26n.tflite,单个文件,类别名称、任务和图像尺寸作为元数据存储在文件中;量化导出的文件名为 yolo26n_w8a32.tflite、yolo26n_int8.tflite 和 yolo26n_w8a16.tflite
运行平台Android 和 iOS 设备、嵌入式 Linux 开发板、桌面 CPU、通过 LiteRT.js运行的 Web 浏览器,以及 Intel GPU 和 NPU
运行时LiteRT:ai-edge-litert Python 包(2.1.4 或更高版本)、Android 和 iOS 的 LiteRT 库,或 LiteRT.js
精确率FP32、w8a32、INT8、w8a16。YOLO26n 的 FP32 模型为 10.0 MB,使用 w8a32 时为 2.9 MB,INT8 模型为 3.1 MB,使用 w8a16 时为 3.0 MB
导出主机Linux x86-64 或搭载 Apple 芯片的 macOS,且 Python 版本为 3.10 或更高。导出在 CPU 上运行,不需要 GPU
在云端导出

Ultralytics Platform 可以帮你将训练好的模型导出为 LiteRT,因此你不需要本地导出环境。

快速入门#

安装包含 LiteRT 导出依赖项的 Ultralytics 包:

pip install "ultralytics[export-litert]"

这会安装 litert-torch、ai-edge-litert 和 ai-edge-quantizer。在纯净的 pip install ultralytics 环境中,首次导出会安装缺失的包;如果这会替换 PyTorch,导出可能会报错并中止。导出有以下版本要求:

软件包所需版本
Python3.10 或更高
litert-torch0.10.0 或更高
torch已安装的 litert-torch 所接受的版本范围:2.4.0 或更高,且低于 2.15.0(适用于 0.10.0)
ai-edge-litert导出需要 2.3.0 或更高版本;运行导出的模型需要 2.1.4 或更高版本,且 Python 也需为 3.10 或更高版本
ai-edge-quantizer0.10.0 或更高,适用于 quantize="w8a32"、quantize=8 和 "w8a16"

其他安装方式请参阅安装指南。然后导出模型,并加载导出的文件以运行推理或验证模型精度。

导出
from ultralytics import YOLO

# 加载 YOLO26 模型
model = YOLO("yolo26n.pt")

# 将模型导出为 LiteRT 格式
model.export(format="litert")  # 创建 'yolo26n.tflite'

# 使用 INT8 权重和 FP32 激活值导出,无需校准数据
model.export(format="litert", quantize="w8a32")  # 会生成 'yolo26n_w8a32.tflite'
预测
from ultralytics import YOLO

# 加载导出的 LiteRT 模型
model = YOLO("yolo26n.tflite")

# 运行推理
results = model("https://ultralytics.com/images/bus.jpg")
验证
from ultralytics import YOLO

# 加载导出的 LiteRT 模型
model = YOLO("yolo26n.tflite")

# 在 COCO8 数据集上验证准确率
metrics = model.val(data="coco8.yaml")

支持的任务#

LiteRT 导出支持所有七种 Ultralytics 任务,适用于 YOLOv8、YOLO11 和 YOLO26 模型:检测、实例分割、语义分割、深度估计、分类、姿态估计和 OBB。语义分割和深度估计仅适用于 YOLO26;只有 YOLO26 系列提供这两种检测头。

导出参数#

参数类型默认值说明
formatstr'litert'导出模型的目标格式,用于定义与各种部署环境的兼容性。
imgszint 或 tuple640模型输入图像尺寸:正方形图像可使用整数,也可以使用元组 (height, width)。未指定时,导出会使用检查点训练时的尺寸。官方 YOLO26 检查点中,检测、分割和姿态模型以及在 ADE20K 上预训练的语义分割模型使用 640;OBB 模型以及在 Cityscapes 上预训练的语义分割模型使用 1024;深度模型使用 768;分类模型使用 224。
quantizeint 或 strNone量化方案:'w8a32'(INT8 权重、FP32 激活值,无需校准)、8(INT8 权重和激活值,使用 data 校准),或 'w8a16'(INT8 权重、INT16 激活值,使用 data 校准);32/未设置时使用 FP32。16 会报错,使用 quantize=8 训练的检查点无法导出为 LiteRT,详见限制和故障排除。这些方案取代已弃用的 half/int8 标志。
datastrNone用于 quantize=8 和 'w8a16' 校准的数据集 YAML;分类任务则使用数据集目录或内置数据集名称。除非设置了 split,否则校准使用 val 分割。若未指定,Ultralytics 会使用适用于模型任务的小型默认数据集,例如检测任务使用 coco8.yaml。
fractionfloat、int 或 list1.0校准子集:可以指定比例、图像数量(大于 1 的整数),或 [train, val, test] 列表;导出会使用列表中的校准集条目。
nmsbool,可选None选择原始输出(None,默认值)或无 NMS 检测头(False,仅适用于 FP32 和 'w8a32' 导出)。LiteRT 不支持嵌入式 NMS(True)。请参阅输出格式。
batchint1导出模型的批次大小,固定在输入形状中。也用作校准时的批次大小。
devicestrNone无论传入什么值,导出始终在 CPU 上运行。

所有格式共有的参数请参阅导出模式文档。

官方移动端和 Web 模型的图像尺寸

官方 LiteRT、Core ML 和 QNN 移动端模型以 imgsz=640 导出,分类模型则以 imgsz=224 导出。Cityscapes 语义分割、深度估计和 OBB 检查点默认以更大的尺寸导出,因此请传入 imgsz=640 以匹配这些检查点。

量化#

quantize 用于选择三种 INT8 方案之一。它们都会将权重存储为 8 位整数,区别在于激活值(即在层与层之间传递的值)的存储方式:

quantize权重激活值校准数据YOLO26n 文件大小
未设置或 32FP32FP32否yolo26n.tflite10.0 MB
'w8a32'INT8FP32否yolo26n_w8a32.tflite2.9 MB
8INT8INT8是yolo26n_int8.tflite3.1 MB
'w8a16'INT8INT16是yolo26n_w8a16.tflite3.0 MB
  • 输入和输出:在四种精度下,输入和输出都保持为 float32,因此,为 FP32 模型编写的推理代码无需更改即可运行使用相同 nms 布局导出的量化模型。
  • 'w8a32':动态范围量化。无需校准数据;搭配 nms=False 时支持无 NMS 检测头,也是实测性能中 CPU 和 GPU 栏目所列官方移动端模型采用的精度。
  • 8 和 'w8a16':静态量化。导出时会使用 data 的 val 分割中的每个完整批次进行校准;若设置了 split,则使用指定的分割进行校准。图像少于 300 张时会发出警告。使用 fraction 可限制图像数量。
  • 检测头输出(quantize=8):对于检测、分割、分类、姿态和 OBB 模型,检测头的输出层及其解码操作会保留为浮点数,因为 INT8 会截断类别分数并降低边界框坐标的精度。'w8a16' 也会量化这些层,但使用 16 位激活值。
  • 无 NMS 检测头:YOLO26 或 YOLOv10 模型使用 quantize=8 和 'w8a16' 导出时,会采用一对多检测头并返回需要进行 NMS 的原始预测;搭配 nms=False 时也如此。
  • FP16:不支持 FP16 导出。LiteRT GPU 委托默认以半精度运行 FP32 模型,因此不需要 quantize=16,传入该参数会报错。
示例
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# 使用 COCO 验证图像的 10%(500 张图像)进行校准;将 coco.yaml 替换为你自己的数据集
model.export(format="litert", quantize=8, data="coco.yaml", fraction=0.1)  # 会生成 'yolo26n_int8.tflite'

# 加载导出的 INT8 模型并运行推理
model = YOLO("yolo26n_int8.tflite")
results = model("https://ultralytics.com/images/bus.jpg")

量化会影响精度,影响程度取决于模型、任务和校准图像。部署前,请使用你自己的数据验证量化模型。

输出格式#

导出会写入一个 .tflite 文件。模型接收一个形状为 (batch, 3, height, width) 的输入:RGB、通道优先(NCHW)、float32,并缩放到 0-1。与早期 format="tflite" 导出的 TFLite 文件不同,早期文件接收的是通道后置(NHWC)图像。nms 参数和任务决定输出。以下形状适用于默认导出尺寸的官方 YOLO26n 检查点;语义分割使用 Cityscapes 检查点 yolo26n-sem.pt:

任务默认 imgsz使用 nms=None 时的输出使用 nms=False 时的输出
检测640(1, 84, 8400)(1, 300, 6)
分割640(1, 116, 8400) 和 (1, 32, 160, 160)(1, 300, 38) 和 (1, 32, 160, 160)
语义1024(1, 19, 1024, 1024),每个类别和像素对应一个分数与 nms=None 相同
深度768(1, 1, 768, 768),深度图与 nms=None 相同
分类224(1, 1000),类别概率与 nms=None 相同
姿态640(1, 56, 8400)(1, 300, 57):6 个边界框值,随后是 17 个关键点,每个关键点 3 个值
OBB1024(1, 20, 21504)(1, 300, 7):4 个边界框值、分数、类别、角度
  • 原始输出(nms=None):形状为 (batch, values, anchors)。每个锚点依次包含边界框中心 x、中心 y、宽度和高度,然后是类别分数,最后是任务值(32 个掩码系数、17 × 3 个关键点值,或以弧度表示的 OBB 角度)。边界框值以及关键点的 x 和 y 都归一化到 0-1,因此请将它们分别乘以输入宽度和高度。你需要自行应用 NMS。
  • 无 NMS 输出(nms=False):max_det 行(默认 300),每行包含以输入像素为单位的 x1, y1, x2, y2, score, class,无需执行 NMS。OBB 行的格式为 center x, center y, width, height, score, class, angle,角度以弧度表示。根据分数筛选行。适用于带有无 NMS 检测头的模型的 FP32 和 'w8a32' 导出。
  • 实例分割:每个锚点或行的最后 32 个值是 32 个掩码系数,第二个输出包含掩码原型。
  • 语义分割:输出包含类别分数,而不是 ONNX 导出中的类别图,因此请在自己的代码中沿类别轴取 argmax。

YOLO("yolo26n.tflite") 会从文件元数据读取布局并缩放坐标,因此只有在自己的代码中运行模型时才需要了解这些细节。元数据是一个 metadata.json 条目,导出时会将它作为 ZIP 归档追加到文件中,可使用任意 ZIP 库读取。其键包括 names、task、imgsz、stride、batch、end2end、args,以及姿态模型中的 kpt_shape。

使用 LiteRT Interpreter 运行#

若要在 Ultralytics 包之外运行模型,请使用 ai-edge-litert 包的 Interpreter 加载模型。请从模型中读取输入和输出形状,不要依赖张量名称。分割模型有两个输出:3D 输出包含检测结果,4D 输出包含掩码原型。

# 先导出:yolo export model=yolo26n.pt format=litert nms=False
import json
import zipfile

import numpy as np
from ai_edge_litert.interpreter import Interpreter

interpreter = Interpreter(model_path="yolo26n.tflite")
interpreter.allocate_tensors()

image = np.zeros((1, 3, 640, 640), dtype=np.float32)  # 你预处理后的图像:RGB、NCHW、0-1
interpreter.set_tensor(interpreter.get_input_details()[0]["index"], image)
interpreter.invoke()
detections = interpreter.get_tensor(interpreter.get_output_details()[0]["index"])[0]  # shape (300, 6)
assert detections.shape == (300, 6), "export the model with nms=False"
detections = detections[detections[:, 4] > 0.25]  # 保留置信度高于阈值的行

with zipfile.ZipFile("yolo26n.tflite") as z:
    names = json.loads(z.read("metadata.json"))["names"]  # {'0': 'person', '1': 'bicycle', ...}

部署#

YOLO("yolo26n.tflite") 使用 ai-edge-litert Interpreter 在 CPU 上运行模型,最多使用 8 个线程。其他 device 值(如 0 或 mps)也会在 CPU 上运行;xpu 和 npu 则会选择 Intel 硬件。推理设备表对比了这些名称在不同格式中的含义。

模型始终以导出时的 imgsz 和 batch 运行,Ultralytics 会从文件元数据中读取这两个值。传入 predict 或 val 的 imgsz 参数会被忽略。较大的批次会拆分为多个导出批次大小的块,较小的批次则会填充,因此支持任意数量的图像。

Intel GPU 和 NPU 推理#

导出的 .tflite 模型可通过 LiteRT Intel OpenVINO 插件在 Intel 硬件上运行。GPU 请传入 device=xpu,NPU 请传入 device=npu;首次使用时,Ultralytics 会安装 ai-edge-litert>=2.3.0 和 ai-edge-litert-sdk-intel。该插件会固定使用自己的 openvino 版本,因此,如果你还要使用其他版本的 OpenVINO 运行模型,请将插件放在独立环境中。NPU 需要配备 Intel Core Ultra 处理器并安装 Intel NPU 驱动程序;请参阅 Core Ultra X7 358H 的实测延迟。如果机器没有请求的 Intel 设备,OpenVINO 插件将无法编译模型,LiteRT 会改用自身的 CPU 后端(XNNPACK)运行,而不是通过 OpenVINO 运行:在 AMD 服务器 CPU 上,YOLO26n 搭配 device=xpu 和 device=npu 时,每张图像耗时 29 到 30 毫秒,而搭配 device=cpu 时耗时 18 毫秒。此时 Ultralytics 不会记录警告,因此请将延迟与 device=cpu 对比,以确认设备正在使用。

预测
from ultralytics import YOLO

model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="npu")  # 或 "xpu"

部署指南#

限制和故障排查#

  • 导出主机:在 Windows 和 Linux ARM64(例如 Raspberry Pi)上,导出会因 LiteRT export only supported on Linux x86 and macOS 而失败。请在受支持的主机上导出,并将 .tflite 文件复制到设备。
  • 纯净安装后的首次导出:如果首次导出安装的 litert-torch 不接受已安装的 PyTorch 版本(0.10.0 接受 2.4.0 至低于 2.15.0),pip 会替换 PyTorch,Ultralytics 会记录 Restart runtime or rerun command for updates to take effect,且该次导出可能失败;如果使用 PyTorch 2.15.0,则会出现 RuntimeError: duplicate registrations for aten.miopen_batch_norm.default。请再次运行导出。
  • FP16:quantize=16 会因 quantize=16 (FP16) is not supported; format='litert' supports quantize=8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 'w8a32' (dynamic INT8), 32 or None (FP32). 而失败。请导出 FP32,并让 GPU 委托以半精度运行模型。
  • 使用 quantize=8 训练的检查点:经过量化感知训练微调的检查点会因 format='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends 而导出失败。请改用 quantize=8 导出微调前使用的检查点,或将微调后的检查点导出为 ONNX 或 TensorRT。
  • 使用 quantize=8 或 'w8a16' 的无 NMS 检测头:搭配 nms=False 时,导出会记录 LiteRT INT8 export does not support end2end models, disabling end2end branch. 并写入需要进行 NMS 的原始预测。请使用 FP32 或 'w8a32',以保留无 NMS 检测头。
  • 嵌入式 NMS:nms=True 会记录 format=litert does not support embedded NMS; exporting native outputs for external NMS. 并写入原始输出。
  • 其他模型上的无 NMS 检测头:nms=False 需要带有无 NMS 检测头的模型,例如 YOLO26 或 YOLOv10。对于其他模型(例如 YOLO11),导出会发出 This model has no one-to-one head; using one-to-many outputs. 警告,并写入原始 (1, 84, 8400) 输出。
  • 输入形状固定:dynamic=True 会因 argument 'dynamic' is not supported for format='litert' 失败。重新导出以更改图像尺寸或批次大小。
  • 不使用 data 进行校准:quantize=8 或 'w8a16' 导出会记录 INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'.,并使用该任务的小型默认数据集进行校准。请传入 data,并使用能够代表部署数据的图像。
  • 校准数据量:校准集少于 300 张图像时,导出会记录 >300 images recommended for INT8 calibration, found 4 images.。coco8.yaml 只有 4 张验证图像,足以测试导出,但不足以为部署校准模型。
  • x86 CPU 上的 'w8a16':LiteRT CPU Interpreter 在 AMD EPYC 9655 服务器 CPU 上使用 8 个线程运行 YOLO26n 'w8a16' 模型时,每张图像耗时约 1 秒;FP32 模型则约为 17 毫秒。请在实际部署的设备和委托上测量 'w8a16'。
  • 文件名:同一检查点的每次导出只要 quantize 值相同,就会写入同一个文件。例如,FP32 文件名为 yolo26n.tflite,无论 imgsz、batch 或 nms 的值是什么,因此后一次导出会替换先前的文件。

其他错误请参阅常见问题指南。

实测性能#

下表列出 YOLO26n 各任务模型在四款 Android 手机和一款 Intel Core Ultra 处理器上的单张图像延迟。每个单元格显示总耗时(单位为毫秒),下方细分预处理 / 推理 / 后处理耗时;每个模型最快的列以粗体显示。YOLO26 模型页面列出了 PyTorch 检查点的精度。

小米 17#

硬件:配备 12 GB LPDDR5X 内存、运行 Android 17 / API 37 的 Xiaomi 17。其 3 nm Snapdragon 8 Elite Gen 5(SM8850)配备 8 核 Qualcomm Oryon CPU(2 个最高 4.6 GHz 的 Prime 核心和 6 个最高 3.62 GHz 的性能核心)、Adreno GPU 和 Hexagon NPU。

模型任务尺寸
(像素)
CPU
w8a32 LiteRT
(毫秒)
GPU
w8a32 LiteRT
(毫秒)
NPU
LiteRT FP32
(毫秒)
YOLO26n检测64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-seg分割64050.5
1.9 / 42.9 / 5.8
18.0
1.9 / 9.5 / 6.6
19.2
3.6 / 5.9 / 9.7
YOLO26n-sem语义64045.7
1.9 / 35.7 / 8.2
30.6
1.9 / 20.5 / 8.3
25.8
3.6 / 11.0 / 11.3
YOLO26n-depth深度64066.8
2.2 / 55.0 / 9.7
21.9
2.1 / 10.1 / 9.8
24.8
4.3 / 6.0 / 14.5
YOLO26n-cls分类2243.6
0.3 / 3.3 / 0.0
2.0
0.4 / 1.4 / 0.2
1.5
0.6 / 0.7 / 0.3
YOLO26n-pose姿态64039.9
2.0 / 36.5 / 1.4
10.0
1.8 / 6.7 / 1.4
11.5
3.5 / 4.2 / 3.8
YOLO26n-obbOBB64036.3
2.0 / 33.2 / 1.2
10.1
2.6 / 5.9 / 1.6
8.2
3.5 / 3.7 / 0.9
  • 速度数据为单图突发延迟——在 bus.jpg 上预热 3 次后运行 15 次的平均值,使用Ultralytics Flutter 插件 0.7.1 和官方 v0.7.0 资源(Ultralytics 8.4.188 导出)测得。各任务在一次顺序扫描中交替测试 CPU/GPU。原生日志确认,每个 CPU 行都使用 LiteRT CPU/XNNPACK,每个 GPU 行都将完整计算图交由 LiteRT OpenCL(LITERT_CL)执行。
  • LiteRT 导出会直接跟踪 PyTorch 模型,生成浮点输入的 NCHW .tflite——GPU delegate 会编译整个计算图(此处七项任务均在 Adreno GPU 上运行),且 w8a32 无需校准数据。使用者应读取张量形状和签名名称,而不是假设使用传统的 onnx2tf NHWC 布局或 Identity 输出名称;应将 RGB 数据直接打包为平面 CHW 格式,或在推理前进行转置。语义分割导出会返回 NCHW logits,需要在主机端执行类别 argmax。官方 Android 资源托管在 yolo-flutter-app v0.7.0 版本中,详细基准测试记录见Flutter 性能文档。
  • NPU列采用 LiteRT 自身的 NPU 路径:FP32 导出(yolo export format=litert,不含 quantize)由 litert-npu-runtime-qualcomm 和 -mediatek 2.3.0 运行时在设备上编译,并使用 Flutter 插件的原型 NPU 构建版本测量(尚未发布)。首次加载包含编译过程(n 约需 0.3 秒,x 最长需 6 秒)。w8a32 资源无法在这些 NPU 上完成编译。即使 LiteRT 悄然将计算图交由 GPU 执行,也会报告 NPU 编译,因此每个 NPU 行都与 GPU 耗时进行了核对;回退到 GPU 的行显示为 —。
  • 官方 QNN 资源在 Snapdragon Hexagon NPU 上的对应数据见 Qualcomm QNN 集成。
  • 请在 CoreML 集成中对比 Apple CPU/加速器的结果。

以下设备测试使用相同的官方 v0.7.0 资源。

Google Pixel 10#

硬件:配备 12 GB 内存、运行 Android 17 / API 37 的 Google Pixel 10。其 3 nm Google Tensor G5 配备 8 核 CPU(1 个最高 3.78 GHz 的 Prime 核心、5 个最高 3.05 GHz 的性能核心,以及 2 个最高 2.25 GHz 的能效核心)、PowerVR D 系列 GPU 和 Google TPU。由于 Google 未在链接的规格中公布核心频率和 GPU 驱动名称,这些数据是从基准测试设备上读取的。

模型任务尺寸
(像素)
CPU
w8a32 LiteRT
(毫秒)
GPU
w8a32 LiteRT
(毫秒)
YOLO26n检测64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-seg分割64053.1
1.5 / 45.8 / 5.7
51.5
1.6 / 40.1 / 9.9
YOLO26n-sem语义64057.2
1.5 / 47.7 / 8.0
75.9
1.8 / 63.4 / 10.8
YOLO26n-depth深度64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-cls分类2246.1
0.3 / 5.5 / 0.3
12.1
0.9 / 11.0 / 0.1
YOLO26n-pose姿态64035.2
1.5 / 31.9 / 1.8
38.2
3.5 / 29.3 / 5.4
YOLO26n-obbOBB64032.7
1.5 / 29.3 / 1.9
38.8
3.8 / 29.6 / 5.4

基准测试:在 bus.jpg 上预热 3 次后,使用 ultralytics_yolo 0.7.1 和官方 v0.7.0 资源,计算 15 次 predict() 调用的平均值。各任务在一次顺序扫描中交替测试 CPU/GPU。原生日志确认,每个 CPU 行都使用 LiteRT CPU/XNNPACK,每个 GPU 行都将完整计算图交由 LiteRT OpenCL(LITERT_CL)执行。Tensor NPU 没有 LiteRT 数据:Google 的 EdgeTPU 服务会拒绝不在许可名单中的应用,随后 LiteRT 会在 GPU 上运行模型。

Samsung Galaxy S26#

硬件:配备 12 GB 内存、运行 Android 17 / API 37 的 Samsung Galaxy S26(SM-S942B)。其 2 nm Exynos 2600 配备 10 核 Armv9.3 CPU(1 个最高 3.8 GHz 的 C1-Ultra 核心、3 个最高 3.26 GHz 的性能型 C1-Pro 核心,以及 6 个最高 2.76 GHz 的能效型 C1-Pro 核心)、Xclipse 960 GPU 和 Samsung NPU。

模型任务尺寸
(像素)
CPU
w8a32 LiteRT
(毫秒)
GPU
w8a32 LiteRT
(毫秒)
NPU
LiteRT w8a32 AOT
(毫秒)
YOLO26n检测64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-seg分割64045.6
1.3 / 39.1 / 5.2
30.5
1.3 / 23.6 / 5.6
17.0
1.4 / 9.7 / 5.8
YOLO26n-sem语义64038.1
1.3 / 28.6 / 8.2
26.1
1.3 / 16.8 / 7.9
28.3
1.7 / 15.1 / 11.5
YOLO26n-depth深度64063.5
1.4 / 53.6 / 8.4
37.3
1.4 / 24.6 / 11.3
28.4
2.1 / 12.9 / 13.4
YOLO26n-cls分类2243.8
0.2 / 3.4 / 0.2
2.8
0.2 / 2.6 / 0.0
6.1
0.5 / 5.2 / 0.4
YOLO26n-pose姿态64031.1
1.3 / 28.4 / 1.4
18.4
1.6 / 13.0 / 3.8
13.5
1.8 / 9.5 / 2.2
YOLO26n-obbOBB64027.9
1.3 / 25.7 / 0.9
15.3
1.9 / 11.4 / 2.1
11.4
1.7 / 8.3 / 1.4

基准测试:在 bus.jpg 上预热 3 次后,使用 ultralytics_yolo 0.7.1 和官方 v0.7.0 资源,计算 15 次 predict() 调用的平均值。各任务在一次顺序扫描中交替测试 CPU/GPU。原生日志确认,每个 CPU 行都使用 LiteRT CPU/XNNPACK,每个 GPU 行都将完整计算图交由 LiteRT OpenCL(LITERT_CL)执行。NPU 列使用 w8a32 资源,这些资源通过 LiteRT 的 Samsung 编译器插件为 Exynos 2600(E9965)预先编译。LiteRT 2.3 没有 Samsung 设备端编译器,Google 也尚未发布 Samsung NPU 运行时,因此这些测试行使用了基于 LiteRT 2.3 源码构建的调度库。

Xiaomi 17T Pro#

硬件:Xiaomi 17T Pro (2602EPTC0G),配备 12 GB LPDDR5X 内存,运行 Android 16 / API 36。其 3 nm MediaTek Dimensity 9500 (MT6993) 配备 8 核 Armv9.3 CPU(1 个 C1-Ultra 核心,最高 4.21 GHz;3 个 C1-Premium 核心,最高 3.5 GHz;4 个 C1-Pro 核心,最高 2.7 GHz)、Mali-G1 Ultra MC12 GPU 和 MediaTek NPU 990。

模型任务尺寸
(像素)
CPU
w8a32 LiteRT
(毫秒)
GPU
w8a32 LiteRT
(毫秒)
NPU
LiteRT FP32
(毫秒)
YOLO26n检测64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-seg分割64077.8
2.6 / 65.3 / 9.9
47.4
2.6 / 33.6 / 11.3
36.5
2.6 / 23.4 / 10.4
YOLO26n-sem语义64081.3
2.6 / 62.2 / 16.5
79.3
2.6 / 59.5 / 17.1
87.6
2.6 / 68.3 / 16.7
YOLO26n-depth深度640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-cls分类2246.3
0.5 / 5.4 / 0.4
8.1
0.5 / 7.5 / 0.1
3.2
0.5 / 2.2 / 0.5
YOLO26n-pose姿态64053.9
2.6 / 49.5 / 1.8
32.8
2.7 / 26.7 / 3.4
16.2
2.9 / 11.1 / 2.3
YOLO26n-obbOBB64049.5
2.7 / 44.4 / 2.4
29.4
2.8 / 22.7 / 3.9
—

基准测试:在 bus.jpg 上预热 3 次后,对 predict() 调用进行 15 次测量并取平均值,使用 ultralytics_yolo 0.7.1 和官方 v0.7.0 资源。CPU/GPU 顺序在一次连续测试中交替排列。原生日志确认,每个 CPU 行都使用 LiteRT CPU/XNNPACK,每个 GPU 行都将完整计算图交给 LiteRT OpenCL(LITERT_CL)。 深度和 OBB 没有 NPU 结果:MediaTek NPU 编译器不支持它们的指数和三角函数运算,而 LiteRT 会在 GPU 上运行这些计算图。

如需了解 Android 部署流程和 NPU 的限制,请参阅 MediaTek Dimensity 指南。

Intel Core Ultra X7 358H#

硬件: Intel Core Ultra X7 358H (Panther Lake) 和 Intel AI Boost NPU 5010、Fedora Linux、NPU 驱动 1.38.0、ai-edge-litert 2.3.0。

模型任务尺寸
(像素)
CPU
w8a32 LiteRT
(毫秒)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26n检测64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-seg分割64024.2
0.9 / 22.1 / 1.3
32.6
1.0 / 30.1 / 1.5
6.2
0.8 / 4.2 / 1.2
YOLO26n-sem语义64025.2
1.0 / 14.2 / 10.0
33.1
1.1 / 21.9 / 10.2
16.5
1.0 / 5.5 / 10.0
YOLO26n-depth深度64031.7
0.9 / 30.2 / 0.5
76.6
0.9 / 75.2 / 0.5
9.1
1.0 / 7.5 / 0.5
YOLO26n-cls分类2244.6
2.8 / 1.7 / 0.0
7.3
3.3 / 3.9 / 0.0
4.1
3.2 / 0.9 / 0.0
YOLO26n-pose姿态64020.3
0.8 / 19.0 / 0.5
28.6
1.1 / 26.8 / 0.8
6.3
0.8 / 4.9 / 0.5
YOLO26n-obbOBB64017.2
0.8 / 16.1 / 0.3
22.1
1.2 / 20.5 / 0.4
4.6
0.9 / 3.4 / 0.3

基准测试:在 bus.jpg 上预热 3 次后,对 predict() 调用 15 次并取平均值;使用 ultralytics 8.4.174 和 ai-edge-litert 2.3.0,并通过 w8a32 导出。每个单元格显示总耗时,其下方列出预处理 / 推理 / 后处理的耗时拆分。

关于 LiteRT#

LiteRT 是 Lite Runtime 的简称,它以新名称延续了 TensorFlow Lite,并继续使用相同的 .tflite 模型格式。它通过 XNNPACK 在 CPU 上运行模型,也可通过硬件委托在 GPU 和 NPU 上运行;LiteRT.js 则可在浏览器和 Node.js中运行相同的文件。完整参考信息请参阅 LiteRT 文档。

LiteRT edge deployment framework



观看: 如何将 Ultralytics YOLO26 导出为 Google LiteRT | 在 Android 和 iOS 上部署视觉 AI | 移动端 AI 📱🚀

常见问题#

  • LiteRT 是 TensorFlow Lite 的新名称,使用相同的 .tflite 模型格式。在 Ultralytics 中,format="litert" 取代了两种较早的导出格式:一种是适用于移动端、嵌入式和边缘设备的 tflite,另一种是适用于浏览器和 Node.js 的 tfjs;LiteRT.js 现在可以运行相同的 .tflite 文件。两种较早的值仍可导出 LiteRT 文件,但会显示弃用警告。TFLite 和 TF.js 页面介绍了较早的格式。

  • 建议先使用 quantize="w8a32"。它无需校准数据,生成的文件小于 FP32 文件的三分之一;搭配 nms=False 时支持 YOLO26 的无 NMS 检测头,也是 Ultralytics 官方移动端 CPU 和 GPU 模型采用的精度。目标设备需要整数激活值时,请使用 quantize=8:例如,NXP i.MX95 导出会编译经校准的 INT8 LiteRT 模型。与 8 相比,'w8a16' 能保留更高的激活值精度。两者都需要有代表性的校准数据,并会返回需要进行 NMS 的原始预测。由于 CPU、GPU 和 NPU 委托对各方案的支持不同,请在目标设备上测量延迟和精度后再做选择。

  • 不可以。导出只能在 Linux x86-64 和搭载 Apple 芯片的 macOS 上运行。请在其中一种主机上导出模型,或使用 Ultralytics Platform 导出,然后将 .tflite 文件复制到设备。关于如何在开发板上运行模型,请参阅 Raspberry Pi 指南;你也可以使用 Coral Edge TPU加速推理。

  • 是的。LiteRT.js 可通过 WebGPU 或 WASM 在浏览器或 Node.js 中运行导出的 .tflite 文件,因此无需单独导出浏览器版本。 @ultralytics/yolo npm 包 对其进行了封装,支持检测、分割、语义分割、分类、姿态和 OBB 任务的摄像头及单张图像推理。

  • 使用 Ultralytics YOLO Flutter 插件,它可以在 Android 上加载 LiteRT .tflite 导出模型,并支持 YOLO26 的全部七种任务。请以 imgsz=640 导出;分类模型则使用 imgsz=224,以匹配官方模型。对于原生应用,请遵循 LiteRT Android 指南,并按照输出格式中的说明输入模型。在 iPhone 上,原生格式为 Core ML。

评论

提出问题、分享结果,或帮助其他人。