Начать

Экспорт Google LiteRT

LiteRT — среда выполнения Google для ИИ на устройстве и новое название TensorFlow Lite (TFLite). При экспорте модели Ultralytics YOLO26 с помощью format="litert" создаётся один файл .tflite для телефонов Android и iOS, встраиваемых плат Linux и веб-браузеров — с точностью FP32 или с одной из трёх схем квантования INT8.

Краткий обзор#

СвойствоОписание
Аргумент formatlitert. Старые значения tflite и tfjs по-прежнему работают: они выводят предупреждение об устаревании и экспортируют тот же файл LiteRT
Результатyolo26n.tflite — один файл, в котором имена классов, задача и размер изображения хранятся как метаданные; квантованные экспорты получают имена yolo26n_w8a32.tflite, yolo26n_int8.tflite и yolo26n_w8a16.tflite
Поддерживаемые устройстваУстройства Android и iOS, встраиваемые платы Linux, настольные CPU, веб-браузеры через LiteRT.js, а также GPU и NPU Intel
Среда выполненияLiteRT: пакет Python ai-edge-litert (версии 2.1.4 или новее), библиотеки LiteRT для Android и iOS или LiteRT.js
ТочностьFP32, w8a32, INT8, w8a16. Размер YOLO26n составляет 10,0 МБ в FP32, 2,9 МБ с w8a32, 3,1 МБ в INT8 и 3,0 МБ с w8a16
Среда для экспортаLinux x86-64 или macOS на Apple silicon, Python 3.10 или новее. Экспорт выполняется на CPU и не требует GPU
Экспорт в облаке

Платформа Ultralytics может экспортировать для тебя обученную модель в LiteRT, поэтому локальная среда для экспорта не понадобится.

Быстрый старт#

Установи пакет Ultralytics с зависимостями для экспорта в LiteRT:

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-litert2.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 — единственного семейства, в котором есть такие головы.

Аргументы экспорта#

АргументТипПо умолчаниюОписание
formatstr'litert'Целевой формат экспортируемой модели, определяющий совместимость с различными средами развертывания.
imgszint или tuple640Размер входного изображения модели: целое число для квадратных изображений или кортеж (height, width). Если значение не задано, при экспорте используется размер, на котором обучалась контрольная точка. В официальных контрольных точках YOLO26 используется 640 для моделей обнаружения, сегментации и позы, а также для семантических моделей, предобученных на ADE20K; 1024 — для моделей OBB и семантических моделей, предобученных на Cityscapes; 768 — для оценки глубины; 224 — для классификации.
quantizeint или strNoneСхема квантования: 'w8a32' (веса INT8, активации FP32, без калибровки), 8 (веса и активации INT8, калибровка на data) или 'w8a16' (веса INT8, активации INT16, калибровка на data); 32/не задано означает FP32. 16 вызывает ошибку, а контрольную точку, обученную с quantize=8, нельзя экспортировать в LiteRT; см. раздел «Ограничения и устранение неполадок». Заменяет устаревшие флаги half/int8.
datastrNoneYAML-файл датасета для калибровки с quantize=8 и 'w8a16'; для классификации вместо этого укажи каталог датасета или имя встроенного датасета. Для калибровки используется сплит val, если не задан split. Если параметр не указан, Ultralytics использует небольшой датасет по умолчанию для задачи модели, например coco8.yaml для детекции.
fractionfloat, int или list1.0Подмножество для калибровки: доля, количество изображений (целые числа больше 1) или список [train, val, test]; в последнем случае используется запись для разбиения калибровки.
nmsbool, необязательноNoneВыбери необработанный выход (None, по умолчанию) или голову без NMS (False, только экспорты FP32 и 'w8a32'). Встроенная NMS (True) в LiteRT недоступна. См. формат выхода.
batchint1Размер батча экспортированной модели, зафиксированный во входной форме. Также размер батча, используемый для калибровки.
devicestrNoneЭкспорт всегда выполняется на CPU независимо от переданного значения.

Аргументы, общие для всех форматов, описаны в документации по режиму экспорта.

Размер изображения для официальных мобильных и веб-моделей

Официальные мобильные модели 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 с nms=False. Именно такая точность используется в официальных мобильных моделях, для которых приведены значения CPU и GPU в разделе «Измеренная производительность».
  • 8 и 'w8a16': статическое квантование. При экспорте калибровка выполняется на каждом полном батче сплита val датасета data либо на сплите, заданном через split; если изображений меньше 300, выводится предупреждение. Используй fraction, чтобы ограничить их количество.
  • Выходы головы с quantize=8: у моделей обнаружения, сегментации, классификации, оценки позы и OBB выходные слои головы и операции их декодирования остаются в формате с плавающей запятой, поскольку INT8 обрезает оценки классов и снижает точность координат рамок. 'w8a16' также квантует эти слои, используя 16-битные активации.
  • Голова без NMS: при экспорте модели YOLO26 или YOLOv10 с quantize=8 и 'w8a16' используется голова one-to-many и возвращаются необработанные предсказания, для которых нужна NMS; то же относится к nms=False.
  • FP16: экспорт в FP16 недоступен. Делегаты GPU LiteRT по умолчанию запускают модель FP32 в режиме половинной точности, поэтому quantize=16 не нужен и вызывает ошибку.
Пример
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Выполнить калибровку на 10% валидационных изображений COCO (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. Это отличается от файлов TFLite, полученных при прежнем экспорте format="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, угол указан в радианах. Отфильтруй строки по оценке. Доступно для экспортов FP32 и 'w8a32' моделей с головой без NMS.
  • Сегментация: 32 коэффициента маски — это последние 32 значения каждого якоря или строки, а второй выход содержит прототипы масок.
  • Семантическая сегментация: выход содержит оценки классов, а не карту классов, как в экспорте ONNX, поэтому в своём коде вычисли argmax по оси классов.

YOLO("yolo26n.tflite") считывает структуру из метаданных файла и масштабирует координаты, поэтому эта информация нужна только при запуске модели в собственном коде. Метаданные представлены записью metadata.json, которую экспорт добавляет в файл как ZIP-архив; её можно прочитать любой ZIP-библиотекой. Среди ключей есть names, task, imgsz, stride, batch, end2end, args и, для моделей оценки позы, kpt_shape.

Запуск с помощью интерпретатора LiteRT#

Чтобы запускать модель вне пакета Ultralytics, загрузи её с помощью интерпретатора пакета ai-edge-litert. Получай формы входов и выходов из модели, а не ориентируйся на имена тензоров. У модели сегментации два выхода: 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") запускает модель на CPU с помощью интерпретатора ai-edge-litert, используя до 8 потоков. Другие значения device, например 0 или mps, также запускают модель на CPU; xpu и npu выбирают оборудование Intel. В таблице устройств для инференса сравниваются эти названия для разных форматов.

Модель всегда запускается с imgsz и batch, заданными при экспорте; Ultralytics считывает эти значения из метаданных файла. Значение imgsz, переданное в predict или val, игнорируется. Большие батчи разбиваются на части размером с экспортный батч, а меньшие дополняются, поэтому можно обрабатывать любое число изображений.

Инференс на GPU и NPU Intel#

Экспортированные модели .tflite работают на оборудовании Intel через плагин LiteRT Intel OpenVINO. Укажи device=xpu для GPU или device=npu для 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: на серверном CPU AMD YOLO26n обрабатывала одно изображение за 29–30 мс с device=xpu и device=npu против 18 мс с device=cpu. В этом случае Ultralytics не выводит предупреждение, поэтому сравни задержку с device=cpu, чтобы убедиться, что устройство используется.

Предсказание
from ultralytics import YOLO

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

Руководства по развертыванию#

  • Плагин Ultralytics YOLO для Flutter: запускает экспорты LiteRT .tflite на Android, поддерживая инференс с камеры в реальном времени, предсказания для одного изображения и ускорение на GPU.
  • Пакет npm @ultralytics/yolo: запускает экспорты LiteRT .tflite в браузере через LiteRT.js с ускорением WebGPU и резервным выполнением на CPU (WASM). Установи его командой npm i @ultralytics/yolo @litertjs/core.
  • MediaTek Dimensity: развёртывание на Android-телефонах MediaTek, включая использование NPU.
  • Qualcomm QNN и Core ML: форматы для NPU Snapdragon и устройств Apple.
  • NXP i.MX95 и Coral Edge TPU: форматы для этих ускорителей.
  • Raspberry Pi: настрой Ultralytics на платах Raspberry Pi.
  • Документация LiteRT: интегрируй среду выполнения в приложения для Android и iOS или в браузере.

Ограничения и устранение неполадок#

  • Хост экспорта: в 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.
  • Голова без NMS с quantize=8 или 'w8a16': при использовании nms=False экспорт выводит LiteRT INT8 export does not support end2end models, disabling end2end branch. и записывает необработанные предсказания, для которых нужна NMS. Чтобы сохранить голову без NMS, используй FP32 или 'w8a32'.
  • Встроенный 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 проверочных изображения: их достаточно, чтобы проверить экспорт, но недостаточно для калибровки модели перед развертыванием.
  • 'w8a16' на CPU x86: интерпретатор CPU LiteRT запускал модель YOLO26n 'w8a16' примерно за 1 с на изображение на серверном CPU AMD EPYC 9655 с 8 потоками, тогда как модель FP32 выполнялась примерно за 17 мс. Измерь 'w8a16' на устройстве и с делегатом, которые собираешься использовать.
  • Имя файла: каждый экспорт одной контрольной точки с одинаковым значением quantize записывает один и тот же файл — например, yolo26n.tflite для FP32 — независимо от значения imgsz, batch или nms, поэтому более поздний экспорт заменяет предыдущий.

Другие ошибки описаны в руководстве по распространённым проблемам.

Измеренная производительность#

В таблицах ниже приведена задержка обработки одного изображения моделью YOLO26n для каждой задачи на четырёх Android-телефонах и процессоре Intel Core Ultra. В каждой ячейке указано общее время в миллисекундах, а ниже — время предобработки / инференса / постобработки; самый быстрый столбец для каждой модели выделен жирным. Точность контрольных точек PyTorch приведена на странице модели YOLO26.

Xiaomi 17#

Оборудование: Xiaomi 17 с 12 ГБ памяти LPDDR5X и Android 17 / API 37. В его 3-нм Snapdragon 8 Elite Gen 5 (SM8850) установлены 8-ядерный CPU Qualcomm Oryon (2 Prime-ядра с частотой до 4.6 ГГц и 6 производительных ядер с частотой до 3.62 ГГц), GPU Adreno и NPU Hexagon.

МодельЗадачаразмер
(пиксели)
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
  • Значения скорости — это задержки при пакетном инференсе одного изображения: среднее значение по 15 запускам после 3 прогревочных запусков на bus.jpg, измеренное с помощью плагина 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 с входом типа float — делегат GPU компилирует весь граф (здесь все семь задач выполняются на GPU Adreno), а w8a32 не требует калибровочных данных. Сверяй формы тензоров и имена сигнатур, а не полагайся на устаревшую раскладку NHWC из onnx2tf или на имена выходов Identity; упаковывай данные RGB непосредственно в планарный формат CHW или транспонируй их перед инференсом. Экспорт для семантической сегментации возвращает логиты NCHW и требует вычисления argmax по классам на стороне хоста. Официальные Android-ресурсы размещены в релизе yolo-flutter-app v0.7.0, а подробная запись результатов бенчмарка приведена в документе о производительности Flutter.
  • Столбец NPU показывает результаты собственного пути NPU в LiteRT: экспорт FP32 (yolo export format=litert, без quantize), скомпилированный на устройстве средами выполнения litert-npu-runtime-qualcomm и -mediatek версии 2.3.0; измерения проведены с прототипной сборкой плагина Flutter для NPU (пока не выпущена). При первой загрузке выполняется компиляция (около 0.3 с для n, до 6 с для x). Ресурсы w8a32 не компилируются полностью на этих NPU. LiteRT сообщает о компиляции для NPU, даже если незаметно выполняет граф на GPU, поэтому каждую строку NPU сверяли со временем GPU; строки с переходом на другой процессор обозначены символом —.
  • Соответствующие результаты для NPU Hexagon Snapdragon с официальными ресурсами QNN приведены в разделе интеграция Qualcomm QNN.
  • Сравни результаты для CPU и ускорителя Apple в разделе интеграции CoreML.

В следующих сериях тестов на устройствах используются те же официальные ресурсы v0.7.0.

Google Pixel 10#

Оборудование: Google Pixel 10 с 12 ГБ памяти и Android 17 / API 37. В его 3-нм Google Tensor G5 установлены 8-ядерный CPU (1 Prime-ядро с частотой до 3.78 ГГц, 5 производительных ядер с частотой до 3.05 ГГц и 2 энергоэффективных ядра с частотой до 2.25 ГГц), GPU PowerVR D-Series и TPU Google. Тактовые частоты ядер и название драйвера GPU считаны с устройства для тестирования, поскольку Google не публикует их в спецификациях по ссылкам.

МодельЗадачаразмер
(пиксели)
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

Тестирование: среднее значение по 15 вызовам predict() после 3 прогревочных запусков на bus.jpg с использованием ultralytics_yolo 0.7.1 и официальных ресурсов v0.7.0. Порядок CPU/GPU чередуется для разных задач в одном последовательном прогоне. В нативных логах подтверждено, что для каждой строки CPU использовались LiteRT CPU/XNNPACK, а для каждой строки GPU весь граф выполнялся через LiteRT OpenCL (LITERT_CL). Для Tensor NPU нет строки LiteRT: сервис EdgeTPU от Google отклоняет приложения, которых нет в списке разрешённых, после чего LiteRT запускает модель на GPU.

Samsung Galaxy S26#

Оборудование: Samsung Galaxy S26 (SM-S942B) с 12 ГБ памяти и Android 17 / API 37. В его 2-нм Exynos 2600 установлены 10-ядерный CPU Armv9.3 (1 ядро C1-Ultra с частотой до 3.8 ГГц, 3 производительных ядра C1-Pro с частотой до 3.26 ГГц и 6 энергоэффективных ядер C1-Pro с частотой до 2.76 ГГц), GPU Xclipse 960 и NPU Samsung.

МодельЗадачаразмер
(пиксели)
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

Тестирование: среднее значение по 15 вызовам predict() после 3 прогревочных запусков на bus.jpg с использованием ultralytics_yolo 0.7.1 и официальных ресурсов v0.7.0. Порядок CPU/GPU чередуется для разных задач в одном последовательном прогоне. В нативных логах подтверждено, что для каждой строки CPU использовались LiteRT CPU/XNNPACK, а для каждой строки GPU весь граф выполнялся через LiteRT OpenCL (LITERT_CL). В столбце NPU указаны результаты для ресурсов w8a32, заранее скомпилированных для Exynos 2600 (E9965) с помощью плагина компилятора Samsung для LiteRT. В LiteRT 2.3 нет встроенного компилятора Samsung для устройств, а Google пока не выпускает среду выполнения для NPU Samsung, поэтому в этих строках использовалась библиотека диспетчеризации, собранная из исходного кода LiteRT 2.3.

Xiaomi 17T Pro#

Оборудование: Xiaomi 17T Pro (2602EPTC0G) с 12 ГБ памяти LPDDR5X и Android 16 / API 36. В его 3-нм MediaTek Dimensity 9500 (MT6993) установлены 8-ядерный CPU Armv9.3 (1 ядро C1-Ultra с частотой до 4,21 ГГц, 3 ядра C1-Premium с частотой до 3,5 ГГц и 4 ядра C1-Pro с частотой до 2,7 ГГц), GPU Mali-G1 Ultra MC12 и NPU MediaTek 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
—

Бенчмарк: среднее значение по 15 вызовам predict() после 3 прогревочных запусков на bus.jpg с использованием ultralytics_yolo 0.7.1 и официальных ресурсов v0.7.0. Порядок CPU/GPU чередуется между задачами в одном последовательном цикле. В нативных логах подтверждено, что для всех строк CPU использовались LiteRT CPU/XNNPACK, а для всех строк GPU полный вычислительный граф обрабатывался LiteRT OpenCL (LITERT_CL). Для Depth и 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
(мс)
NPU
w8a32 Intel
(мс)
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

Бенчмарк: среднее значение для 15 вызовов predict() после 3 прогревочных вызовов на bus.jpg с использованием ultralytics 8.4.174 и ai-edge-litert 2.3.0 для экспорта w8a32. В каждой ячейке указано общее время, а ниже — разбивка на предобработку / инференс / постобработку.

О LiteRT#

LiteRT — сокращение от Lite Runtime — продолжает TensorFlow Lite под новым названием и использует тот же формат модели .tflite. Модели выполняются на CPU с помощью XNNPACK, а на GPU и NPU — через аппаратные делегаты; LiteRT.js позволяет использовать тот же файл в браузерах и Node.js. Полную справочную информацию см. в документации LiteRT.

LiteRT edge deployment framework



Смотри: Как экспортировать Ultralytics YOLO26 в Google LiteRT | Развертывание ИИ для компьютерного зрения на Android и iOS | Мобильный ИИ 📱🚀

Часто задаваемые вопросы#

  • LiteRT — новое название TensorFlow Lite с тем же форматом модели .tflite. В Ultralytics format="litert" заменяет два прежних формата экспорта: tflite для мобильных, встраиваемых и периферийных устройств и tfjs для браузеров и Node.js, где LiteRT.js теперь запускает тот же файл .tflite. Оба прежних значения по-прежнему экспортируют файл LiteRT с предупреждением об устаревании. На страницах TFLite и TF.js описаны прежние форматы.

  • Начни с quantize="w8a32". Калибровочные данные не нужны, размер файла составляет менее трети от размера FP32, поддерживается голова YOLO26 без NMS с nms=False; именно эта точность используется в официальных мобильных моделях Ultralytics для CPU и GPU. Используй quantize=8, если целевому устройству нужны целочисленные активации: например, экспорт NXP i.MX95 компилирует откалиброванную модель LiteRT INT8. В 'w8a16' сохраняется более высокая точность активаций, чем в 8. Для обоих вариантов нужны репрезентативные калибровочные данные, и они возвращают необработанные предсказания, для которых нужна NMS. Перед выбором измерь задержку и точность на целевом устройстве: поддержка каждой схемы различается у делегатов CPU, GPU и NPU.

  • Нет. Экспорт выполняется только в Linux x86-64 и macOS на Apple silicon. Экспортируй модель на одной из этих платформ или с помощью платформы Ultralytics, а затем скопируй файл .tflite на устройство. Инструкции по запуску моделей на плате см. в руководстве по Raspberry Pi; ускорить инференс может Coral Edge TPU.

  • Да. LiteRT.js запускает экспортированный файл .tflite в браузере или Node.js с помощью WebGPU или WASM, поэтому отдельный экспорт для браузера не нужен. Пакет @ultralytics/yolo npm добавляет инференс с веб-камеры и для одного изображения для задач детекции, сегментации, семантической сегментации, классификации, оценки позы и OBB.

  • Используй плагин Ultralytics YOLO для Flutter: он загружает экспорты LiteRT .tflite на Android и поддерживает все семь задач YOLO26. Чтобы соответствовать официальным моделям, экспортируй с imgsz=640, а для классификации — с imgsz=224. Для нативного приложения следуй руководству LiteRT для Android и передавай данные модели, как описано в разделе «Формат выхода». На iPhone используется нативный формат Core ML.

Комментарии

Задай вопрос, поделись результатами или помоги кому-нибудь.