Ultralytics YOLO27:

Экспорт моделей YOLO в LiteRT для развёртывания на периферийных устройствах и в вебе#

LiteRT edge deployment framework

LiteRT (сокращение от Lite Runtime) — высокопроизводительная среда выполнения Google для ИИ непосредственно на устройстве. Это новое поколение TensorFlow Lite (TFLite), использующее новый вариант названия, и оно работает с тем же форматом модели .tflite. С LiteRT одну экспортированную модель Ultralytics YOLO можно развернуть на мобильных и встраиваемых устройствах, периферийных устройствах и в браузере — возможности, для которых раньше требовались отдельные форматы экспорта tflite и tfjs, теперь объединены в одном решении.



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

Формат экспорта LiteRT оптимизирует модели для таких задач, как обнаружение объектов, сегментация, оценка позы и классификация, обеспечивая быструю автономную работу на широком спектре устройств.

Запусти YOLO на Android с LiteRT уже сегодня с помощью официального плагина Flutter

Официальный плагин Ultralytics YOLO для Flutter сразу запускает экспорты LiteRT .tflite на Android. Он поддерживает инференс с камеры в реальном времени, предсказания для одного изображения, ускорение на GPU и автоматическое скачивание моделей для всех семи задач YOLO26, включая глубину. Для устройств Apple используй экспорт CoreML, а для NPU Qualcomm Snapdragon — интеграцию Qualcomm QNN.

Официальные размеры входных данных для мобильных устройств

Экспортируй модели классификации с размером imgsz=224. Экспортируй модели detect, segment, semantic, depth, pose и OBB с размером imgsz=640. Этот стандарт 224/640 используется в официальных мобильных ресурсах LiteRT, CoreML и QNN.

Запусти YOLO в вебе с LiteRT.js уже сегодня с помощью официального npm-пакета @ultralytics/yolo

Официальный npm-пакет Ultralytics YOLO запускает экспорты LiteRT .tflite прямо в браузере с помощью LiteRT.js — сервер и Python не нужны. Поддерживаются инференс с веб-камеры в реальном времени, предсказания для одного изображения и ускорение WebGPU (с автоматическим переходом на CPU/WASM) для шести задач YOLO26 (detect, segment, semantic, classify, pose, OBB). На WebGPU скорость часто примерно в ~2 раза выше, чем у ONNX Runtime Web.

npm i @ultralytics/yolo @litertjs/core

Зачем экспортировать в LiteRT?#

LiteRT — это среда с открытым исходным кодом, предназначенная для инференса непосредственно на устройстве, также известного как периферийные вычисления. Она предоставляет разработчикам инструменты для запуска обученных моделей на мобильных и встраиваемых устройствах, устройствах IoT и обычных компьютерах, а с помощью LiteRT.js — непосредственно в веб-браузерах и Node.js.

Один формат модели — для всех целевых платформ:

  • Мобильные и встраиваемые устройства: Android, iOS, встроенный Linux и микроконтроллеры (MCU).
  • Периферийные ускорители: Совместимо с Coral Edge TPU для дополнительного ускорения.
  • Браузер и Node.js: LiteRT.js запускает ту же модель .tflite в вебе с ускорением WebGPU/WASM, поэтому отдельный экспорт TensorFlow.js не нужен.

Основные возможности моделей LiteRT#

  • Оптимизация на устройстве: снижает задержку за счёт локальной обработки данных, повышает конфиденциальность, не передавая персональные данные, и уменьшает размер модели, экономя место.
  • Поддержка нескольких платформ: работает на Android, iOS, встроенном Linux, микроконтроллерах и современных веб-браузерах.
  • Аппаратное ускорение: использует XNNPACK на CPU и ускорение на GPU через OpenCL, Metal и WebGPU. По умолчанию делегат GPU работает в FP16 для дополнительного ускорения.
  • Квантование: поддерживаются FP32, статический INT8 (quantize=8, веса int8 + активации int8), статический INT16-activation (quantize="w8a16", веса int8 + активации int16 для большей точности) и динамический INT8 (quantize="w8a32", веса int8 + активации FP32, калибровочные данные не нужны), чтобы сжимать модели и ускорять инференс с минимальной потерей точности.
  • Поддержка разных языков: совместим с Java/Kotlin, Swift, Objective-C, C++, Python и JavaScript.

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

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

МодельЗадачаразмер
(пиксели)
CPU
w8a32 LiteRT
(мс)
GPU
w8a32 LiteRT
(мс)
YOLO26nОбнаружение64052.2
1.8 / 48.1 / 2.4
15.8
2.3 / 8.9 / 4.6
YOLO26n-segСегментация64073.4
1.8 / 65.6 / 6.0
33.2
1.8 / 23.8 / 7.6
YOLO26n-semСемантическая64061.2
1.8 / 51.1 / 8.3
34.2
1.8 / 24.0 / 8.3
YOLO26n-depthГлубина640124.4
1.9 / 115.1 / 7.4
23.0
1.8 / 13.5 / 7.7
YOLO26n-clsКлассификация2244.4
0.4 / 4.0 / 0.0
3.1
0.8 / 2.1 / 0.2
YOLO26n-poseПоза64057.4
1.8 / 53.8 / 1.8
16.6
2.7 / 10.1 / 3.9
YOLO26n-obbOBB64050.3
1.8 / 47.2 / 1.4
11.7
1.8 / 7.8 / 2.0
  • Значения скорости — это задержки при пакетной обработке одного изображения: среднее значение 15 запусков после 3 прогревочных запусков на bus.jpg, измеренное с помощью плагина Ultralytics для Flutter 0.6.10 и стандартизированных ресурсов v0.6.6. Порядок 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.6.6, а подробная запись результатов бенчмарка приведена в документе о производительности Flutter.
  • Результаты для соответствующих Snapdragon Hexagon NPU и CPU/GPU LiteRT приведены в разделе интеграции Qualcomm QNN.
  • Сравни результаты для CPU и ускорителя Apple в разделе интеграции CoreML.

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

Google Pixel 10#

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

МодельЗадачаразмер
(пиксели)
CPU
w8a32 LiteRT
(мс)
GPU
w8a32 LiteRT
(мс)
YOLO26nОбнаружение64053.3
1.5 / 50.2 / 1.6
45.5
3.8 / 37.7 / 4.0
YOLO26n-segСегментация64087.7
1.8 / 78.5 / 7.5
50.9
3.0 / 36.9 / 10.9
YOLO26n-semСемантическая64068.6
1.5 / 59.0 / 8.0
71.6
1.5 / 59.5 / 10.6
YOLO26n-depthГлубина640120.3
1.5 / 112.5 / 6.3
52.5
2.0 / 37.5 / 13.0
YOLO26n-clsКлассификация2244.0
0.3 / 3.4 / 0.2
17.6
0.9 / 16.7 / 0.1
YOLO26n-poseПоза64059.7
1.5 / 57.0 / 1.2
46.6
3.8 / 39.2 / 3.5
YOLO26n-obbOBB64052.0
1.5 / 48.9 / 1.7
45.5
4.0 / 38.5 / 2.9

Бенчмарк: среднее значение 15 вызовов predict() после 3 прогревочных запусков на bus.jpg с использованием ultralytics_yolo, 0.6.10 и официальных ресурсов v0.6.6. Порядок CPU/GPU чередуется между задачами в рамках одного последовательного прогона. Нативные журналы подтвердили, что во всех строках CPU использовались LiteRT CPU/XNNPACK, а во всех строках GPU весь граф вычислений передавался LiteRT OpenCL (LITERT_CL).

Samsung Galaxy S26#

Оборудование: Samsung Galaxy S26 (SM-S942B) с 12 ГБ памяти и Android 16 / API 36. В его 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
(мс)
YOLO26nОбнаружение64036.7
1.3 / 33.8 / 1.7
16.4
1.4 / 12.3 / 2.6
YOLO26n-segСегментация64054.6
1.2 / 48.0 / 5.3
32.8
1.3 / 24.5 / 7.0
YOLO26n-semСемантическая64047.8
1.2 / 38.4 / 8.1
34.2
1.3 / 24.9 / 8.0
YOLO26n-depthГлубина64092.9
1.2 / 84.8 / 6.9
33.5
1.3 / 22.4 / 9.8
YOLO26n-clsКлассификация2242.7
0.2 / 2.3 / 0.2
2.6
0.2 / 2.4 / 0.0
YOLO26n-poseПоза64042.8
1.3 / 40.5 / 1.0
18.4
1.4 / 14.1 / 2.9
YOLO26n-obbOBB64037.5
1.3 / 35.1 / 1.2
18.8
2.5 / 14.6 / 1.8

Бенчмарк: среднее значение 15 вызовов predict() после 3 прогревочных запусков на bus.jpg с использованием ultralytics_yolo, 0.6.10 и официальных ресурсов v0.6.6. Порядок CPU/GPU чередуется между задачами в рамках одного последовательного прогона. Нативные журналы подтвердили, что во всех строках CPU использовались LiteRT CPU/XNNPACK, а во всех строках GPU весь граф вычислений передавался LiteRT OpenCL (LITERT_CL).

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
(мс)
YOLO26nОбнаружение64045.4
1.3 / 42.1 / 2.0
26.6
1.9 / 22.0 / 2.7
YOLO26n-segСегментация640126.2
2.6 / 113.9 / 9.7
46.7
2.6 / 33.3 / 10.8
YOLO26n-semСемантическая640117.9
2.6 / 98.8 / 16.5
74.3
2.6 / 54.7 / 17.0
YOLO26n-depthГлубина640182.4
2.5 / 167.6 / 12.3
47.8
2.5 / 32.3 / 12.9
YOLO26n-clsКлассификация2246.2
0.4 / 5.3 / 0.4
7.4
0.4 / 6.9 / 0.1
YOLO26n-poseПоза64097.6
2.5 / 93.3 / 1.8
28.6
2.5 / 23.3 / 2.8
YOLO26n-obbOBB64091.5
2.6 / 85.8 / 3.2
27.5
2.7 / 21.8 / 2.9

Бенчмарк: среднее значение 15 вызовов predict() после 3 прогревочных запусков на bus.jpg с использованием ultralytics_yolo, 0.6.10 и официальных ресурсов v0.6.6. Порядок CPU/GPU чередуется между задачами в рамках одного последовательного прогона. Нативные журналы подтвердили, что во всех строках CPU использовались LiteRT CPU/XNNPACK, а во всех строках GPU весь граф вычислений передавался LiteRT OpenCL (LITERT_CL).

Поддерживаемые задачи#

Экспорт LiteRT поддерживает все семь задач Ultralytics. Семантическая сегментация и оценка глубины доступны только для YOLO26 — единственного семейства, в котором предусмотрены такие выходные слои.

Экспорт в LiteRT: преобразование модели YOLO#

Преобразуй модели в формат LiteRT, чтобы повысить эффективность выполнения на устройстве и расширить возможности развёртывания.

Установка#

Чтобы установить необходимый пакет, выполни команду:

Установка
# Install the required package for YOLO
pip install ultralytics

Подробные инструкции и рекомендации смотри в нашем руководстве по установке Ultralytics. Если возникнут трудности, обратись к нашему руководству по распространённым проблемам.

Поддержка платформ

Экспорт LiteRT сейчас поддерживается в Linux x86_64 и macOS. Сама экспортированная модель .tflite работает на всех платформах, поддерживаемых LiteRT (мобильных, встраиваемых, периферийных и в браузере).

Использование#

Все модели Ultralytics YOLO поддерживают экспорт без дополнительной настройки. Формат LiteRT поддерживает режимы Экспорт, Предсказание и Валидация, поэтому ты можешь экспортировать модель, а затем загрузить её для запуска инференса или локальной проверки точности.

Экспорт
from ultralytics import YOLO

# Загрузи модель YOLO26
model = YOLO("yolo26n.pt")

# Экспортировать модель в формат LiteRT
model.export(format="litert", imgsz=640)  # создаёт 'yolo26n.tflite'; для классификации используй imgsz=224
Экспорт с квантованием
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Динамический INT8: веса int8, активации FP32 — калибровочные данные не нужны
model.export(format="litert", quantize="w8a32", imgsz=640)  # создаёт 'yolo26n_w8a32.tflite'

# Статический INT8: веса int8 + активации int8 — нужны калибровочные данные
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # создаёт 'yolo26n_int8.tflite'

# Статический w8a16: веса int8 + активации int16 (более высокая точность) — нужны калибровочные данные
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # создаёт 'yolo26n_w8a16.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")

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

АргументТипПо умолчаниюОписание
formatstr'litert'Целевой формат экспортируемой модели, определяющий совместимость с различными средами развертывания.
imgszint или tuple640Заданный размер изображения на входе модели. Можно указать целое число для квадратных изображений или кортеж (height, width) для конкретных размеров.
quantizeint или strNoneТочность квантования: 8 (статический INT8, веса int8 + активации int8; требуются калибровочные data/fraction), 'w8a16' (статический режим, веса int8 + активации int16; требуются калибровочные data/fraction), 'w8a32' (динамический INT8, веса int8 + активации FP32; калибровка не нужна) или 32/не задано (FP32). FP16 не экспортируется отдельно (см. примечание ниже). Заменяет устаревшие флаги half/int8.
batchint1Задаёт размер пакета изображений для инференса экспортированной модели или максимальное количество изображений, которые экспортированная модель будет обрабатывать одновременно в режиме predict.
datastrNoneYAML-файл датасета, используемый для калибровки INT8; для классификации вместо него укажи каталог датасета или название встроенного датасета. Если параметр не задан вместе с quantize=8 или 'w8a16', Ultralytics выбирает датасет калибровки по умолчанию для этой задачи модели.
fractionfloat, int или list1.0Подмножество для калибровки, заданное как доля, количество изображений или [train, val, test] отношения/количества. Если список содержит два элемента, test остаётся без изменений, а 0 пропускает его.
devicestrNoneЗадаёт устройство для экспорта. Экспорт LiteRT выполняется на CPU (device=cpu).
Точность FP16

В отличие от прежнего экспорта tflite, LiteRT не требует отдельного экспорта FP16. Модель .tflite с FP32 работает в режиме половинной точности во время выполнения, если используется делегат GPU (WebGPU, OpenCL, Metal) — это официальный подход LiteRT к инференсу FP16.

Подробнее о процессе экспорта смотри на странице документации Ultralytics об экспорте.

Развёртывание экспортированных моделей YOLO LiteRT#

После экспорта модели Ultralytics YOLO в LiteRT ты можешь развёртывать её на разных платформах. Быстрее всего проверить её локально с помощью метода YOLO("yolo26n.tflite"), описанного выше. Чтобы развернуть модель в других средах, смотри следующие материалы:

Мобильные и встраиваемые устройства#

  • Android: краткое руководство по интеграции LiteRT в приложения Android.
  • iOS: руководство по интеграции и развёртыванию моделей LiteRT в приложениях iOS.
  • Встраиваемый Linux и Raspberry Pi: запускай модели LiteRT на одноплатных компьютерах, при желании ускоряя их с помощью Coral Edge TPU.
  • Микроконтроллеры: развёртывай модели на MCU с объёмом памяти всего в несколько килобайт — основная среда выполнения занимает около 16 КБ на Arm Cortex-M3.

Браузер и Node.js (LiteRT.js)#

  • Обзор LiteRT.js: запускай ту же модель .tflite прямо в браузере с ускорением WebGPU/WASM, избавляясь от вычислений на сервере и оставляя данные на устройстве пользователя.
  • Примеры полного цикла: практические примеры и руководства по внедрению LiteRT на мобильных устройствах, периферийных устройствах и в веб-приложениях.

Итоги#

В этом руководстве мы рассмотрели экспорт моделей Ultralytics YOLO в формат LiteRT. Объединив развёртывание на мобильных и периферийных устройствах (ранее TFLite) и в браузере (ранее TF.js) в одну модель .tflite, LiteRT делает модели YOLO быстрее, компактнее и совместимыми практически со всеми целевыми устройствами.

Подробнее смотри в официальной документации LiteRT.

Если тебе интересны и другие интеграции Ultralytics YOLO, загляни на нашу страницу руководств по интеграции — там много полезных материалов.

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

  • Используй библиотеку Ultralytics, чтобы экспортировать модель YOLO в LiteRT (.tflite). Сначала установи пакет:

    pip install ultralytics

    Затем экспортируй модель:

    from ultralytics import YOLO
    
    # Загрузи модель YOLO26
    model = YOLO("yolo26n.pt")
    
    # Экспортировать модель в формат LiteRT
    model.export(format="litert", imgsz=640)  # используй imgsz=224 для классификации

    Для пользователей CLI:

    yolo export model=yolo26n.pt format=litert imgsz=640 # use imgsz=224 for classification

    Подробнее смотри в руководстве Ultralytics по экспорту.

  • LiteRT — это новое название TensorFlow Lite: тот же формат модели .tflite, та же линейка сред выполнения, новое название от Google. В Ultralytics единый формат экспорта litert теперь охватывает оба сценария, для которых раньше требовались два отдельных формата:

    • Старый формат tflite → развёртывание на мобильных и встраиваемых устройствах и на периферии.
    • Старый формат tfjs → развёртывание в браузере и Node.js, теперь поддерживаемое LiteRT.js, который использует тот же файл .tflite.

    Если у тебя уже есть файл .tflite, ты можешь загрузить его напрямую с помощью YOLO("model.tflite"); он будет выполняться через бэкенд LiteRT.

  • Да. Экспортируй модель в формат LiteRT, а затем запусти её на Raspberry Pi, чтобы ускорить инференс. Для дополнительной оптимизации попробуй Coral Edge TPU. Подробные инструкции смотри в нашем руководстве по развёртыванию на Raspberry Pi.

  • Да. LiteRT.js запускает ту же экспортированную модель .tflite прямо в веб-браузере или приложении Node.js с ускорением WebGPU/WASM. Это заменяет прежний процесс работы с TensorFlow.js: отдельный экспорт для браузера не нужен — просто разверни модель LiteRT с помощью среды выполнения LiteRT.js.

  • Да — во время выполнения. Модель LiteRT в формате FP32 автоматически работает в FP16 при запуске на GPU delegate (WebGPU, OpenCL или Metal) — это официальный подход LiteRT. Поэтому отдельный экспорт FP16 не нужен; для дополнительного сжатия используй квантование INT8 с quantize=8.

  • Если при экспорте моделей YOLO в LiteRT возникают ошибки, попробуй следующие распространённые решения:

    • Проверь платформу: экспорт в LiteRT поддерживается в Linux x86_64 и macOS. Убедись, что твоя среда соответствует этим требованиям.
    • Проверь совместимость пакетов: убедись, что используешь совместимую версию Ultralytics. Инструкции смотри в нашем руководстве по установке.
    • Проблемы с квантованием: при квантовании INT8 убедись, что путь к набору данных правильно указан в параметре data.

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

Комментарии