Empezar

Exportación a Google LiteRT

LiteRT es el entorno de ejecución de Google para la IA en el dispositivo y el nuevo nombre de TensorFlow Lite (TFLite). Al exportar un modelo Ultralytics YOLO26 con format="litert", se crea un único archivo .tflite para móviles Android e iOS, placas Linux integradas y navegadores web, en FP32 o con uno de los tres esquemas de cuantización INT8.

Resumen#

PropiedadDetalles
Argumento formatlitert. Los valores anteriores tflite y tfjs siguen funcionando: registran un aviso de obsolescencia y exportan el mismo archivo LiteRT.
Salidayolo26n.tflite, un archivo con los nombres de las clases, la tarea y el tamaño de imagen almacenados en su interior como metadatos; las exportaciones cuantizadas se denominan yolo26n_w8a32.tflite, yolo26n_int8.tflite y yolo26n_w8a16.tflite.
Se ejecuta enDispositivos Android e iOS, placas Linux integradas, CPU de sobremesa, navegadores web mediante LiteRT.js y GPU y NPU Intel.
Entorno de ejecuciónLiteRT: el paquete Python ai-edge-litert (versión 2.1.4 o posterior), las bibliotecas LiteRT para Android e iOS, o LiteRT.js.
PrecisiónFP32, w8a32, INT8, w8a16. YOLO26n ocupa 10,0 MB en FP32, 2,9 MB con w8a32, 3,1 MB en INT8 y 3,0 MB con w8a16.
Equipo de exportaciónLinux x86-64 o macOS en Apple silicon, con Python 3.10 o posterior. La exportación se ejecuta en la CPU y no necesita GPU.
Exportar en la nube

Ultralytics Platform puede exportar por ti un modelo entrenado a LiteRT, así que no necesitas un entorno de exportación local.

Inicio rápido#

Instala el paquete Ultralytics con las dependencias de exportación de LiteRT:

pip install "ultralytics[export-litert]"

Esto instala litert-torch, ai-edge-litert y ai-edge-quantizer. Con un pip install ultralytics sin opciones adicionales, la primera exportación instala los paquetes que faltan y puede detenerse con un error si eso sustituye PyTorch. La exportación tiene estos requisitos de versión:

PaqueteVersión requerida
Python3.10 o posterior
litert-torch0.10.0 o posterior
torchEl intervalo aceptado por litert-torch instalado: 2.4.0 o posterior e inferior a 2.15.0 para 0.10.0.
ai-edge-litert2.3.0 o posterior para exportar; 2.1.4 o posterior, también con Python 3.10 o posterior, para ejecutar un modelo exportado.
ai-edge-quantizer0.10.0 o posterior, para quantize="w8a32", quantize=8 y "w8a16".

Para otros métodos de instalación, consulta la guía de instalación. Después, exporta tu modelo y carga el archivo exportado para ejecutar inferencias o validar su precisión.

Exportar
from ultralytics import YOLO

# Carga un modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporta el modelo al formato LiteRT
model.export(format="litert")  # crea 'yolo26n.tflite'

# Exporta con pesos INT8 y activaciones FP32; no hacen falta datos de calibración.
model.export(format="litert", quantize="w8a32")  # crea 'yolo26n_w8a32.tflite'
Predecir
from ultralytics import YOLO

# Carga el modelo LiteRT exportado
model = YOLO("yolo26n.tflite")

# Ejecutar inferencia
results = model("https://ultralytics.com/images/bus.jpg")
Validar
from ultralytics import YOLO

# Carga el modelo LiteRT exportado
model = YOLO("yolo26n.tflite")

# Valida la precisión con el conjunto de datos COCO8
metrics = model.val(data="coco8.yaml")

Tareas compatibles#

La exportación LiteRT es compatible con las siete tareas de Ultralytics con modelos YOLOv8, YOLO11 y YOLO26: detección, segmentación, segmentación semántica, estimación de profundidad, clasificación, estimación de pose y OBB. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esos cabezales.

Argumentos de exportación#

ArgumentoTipoPredeterminadoDescripción
formatstr'litert'Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación.
imgszint o tuple640Tamaño de imagen de la entrada del modelo: un entero para imágenes cuadradas o una tupla (height, width). Si no se especifica, la exportación utiliza el tamaño con el que se entrenó el punto de control. Los puntos de control oficiales de YOLO26 utilizan 640 para modelos de detección, segmentación y pose, y para modelos semánticos preentrenados en ADE20K; 1024 para modelos OBB y modelos semánticos preentrenados en Cityscapes; 768 para profundidad; y 224 para clasificación.
quantizeint o strNoneEsquema de cuantización: 'w8a32' (pesos INT8, activaciones FP32, sin calibración), 8 (pesos y activaciones INT8, calibrados con data) o 'w8a16' (pesos INT8, activaciones INT16, calibrados con data); 32/sin definir corresponde a FP32. 16 produce un error, y un punto de control entrenado con quantize=8 no se puede exportar a LiteRT; consulta Limitaciones y solución de problemas. Sustituye los indicadores obsoletos half/int8.
datastrNoneArchivo YAML del conjunto de datos usado para la calibración con quantize=8 y 'w8a16'; en clasificación, en cambio, se indica un directorio de conjunto de datos o el nombre de uno integrado. La calibración usa la partición val, salvo que se establezca split. Si se omite, Ultralytics usa el conjunto de datos predeterminado pequeño para la tarea del modelo, como coco8.yaml para detección.
fractionfloat, int o list1.0Subconjunto de calibración: una proporción, un número de imágenes (enteros superiores a 1) o una lista [train, val, test], de la que se utiliza la entrada de la partición de calibración.
nmsbool, opcionalNoneSelecciona la salida sin procesar (None, opción predeterminada) o el cabezal sin NMS (False, solo exportaciones FP32 y 'w8a32'). NMS integrado (True) no está disponible en LiteRT. Consulta el formato de salida.
batchint1Tamaño del lote del modelo exportado, fijado en la forma de entrada. También es el tamaño del lote usado para la calibración.
devicestrNoneLa exportación siempre se ejecuta en la CPU, independientemente del valor indicado.

Para consultar los argumentos comunes a todos los formatos, visita la documentación del modo de exportación.

Tamaño de imagen de los modelos oficiales para móviles y web

Los modelos LiteRT, Core ML y QNN oficiales para móviles se exportan con imgsz=640 y con imgsz=224 para clasificación. Los puntos de control de Cityscapes para segmentación semántica, profundidad y OBB se exportan de forma predeterminada con un tamaño mayor, así que indica imgsz=640 para que coincida con ellos.

Cuantización#

quantize selecciona uno de los tres esquemas INT8. Todos almacenan los pesos como enteros de 8 bits y se diferencian por la forma de almacenar las activaciones, es decir, los valores que pasan entre capas:

quantizePesosActivacionesDatos de calibraciónArchivo YOLO26nTamaño
sin especificar o 32FP32FP32Noyolo26n.tflite10.0 MB
'w8a32'INT8FP32Noyolo26n_w8a32.tflite2.9 MB
8INT8INT8Síyolo26n_int8.tflite3.1 MB
'w8a16'INT8INT16Síyolo26n_w8a16.tflite3.0 MB
  • Entradas y salidas: la entrada y las salidas siguen siendo float32 con las cuatro precisiones, por lo que el código de inferencia escrito para el modelo FP32 ejecuta sin cambios un modelo cuantizado exportado con la misma disposición nms.
  • 'w8a32': cuantización de rango dinámico. No necesita datos de calibración y admite el cabezal sin NMS con nms=False; además, es la precisión de los modelos oficiales para móviles que aparecen en las columnas de CPU y GPU de Rendimiento medido.
  • 8 y 'w8a16': cuantización estática. La exportación calibra con cada lote completo de la partición val de data, o de la partición que establezcas con split, y muestra un aviso si hay menos de 300 imágenes. Usa fraction para limitar el número de imágenes.
  • Salidas de la cabeza con quantize=8: en los modelos de detección, segmentación, clasificación, pose y OBB, las capas de salida de la cabeza y las operaciones que las decodifican se mantienen en coma flotante, porque INT8 recorta las puntuaciones de clase y reduce la precisión de las coordenadas de las cajas. 'w8a16' también cuantiza estas capas, con activaciones de 16 bits.
  • Cabezal sin NMS: las exportaciones quantize=8 y 'w8a16' de un modelo YOLO26 o YOLOv10 usan el cabezal uno a muchos y devuelven predicciones sin procesar que necesitan NMS, también con nms=False.
  • FP16: no hay exportación FP16. Los delegados de GPU de LiteRT ejecutan de forma predeterminada un modelo FP32 en precisión media, así que quantize=16 no es necesario y produce un error.
Ejemplo
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Calibra con el 10 % de las imágenes de validación de COCO (500 imágenes); sustituye coco.yaml por tu propio conjunto de datos
model.export(format="litert", quantize=8, data="coco.yaml", fraction=0.1)  # crea 'yolo26n_int8.tflite'

# Carga el modelo INT8 exportado y ejecuta inferencias
model = YOLO("yolo26n_int8.tflite")
results = model("https://ultralytics.com/images/bus.jpg")

La cuantización modifica la precisión, y el efecto depende del modelo, la tarea y las imágenes de calibración. Valida un modelo cuantizado con tus propios datos antes de implementarlo.

Formato de salida#

La exportación escribe un único archivo .tflite. El modelo recibe una entrada con la forma (batch, 3, height, width): RGB, canales primero (NCHW), float32, escalado de 0 a 1. Esto difiere de los archivos TFLite de la exportación anterior format="tflite", que recibían imágenes con los canales al final (NHWC). El argumento nms y la tarea determinan las salidas. Las formas siguientes corresponden a los puntos de control oficiales YOLO26n con el tamaño de exportación predeterminado, con el punto de control Cityscapes yolo26n-sem.pt para segmentación semántica:

TareaValor predeterminado imgszSalida con nms=NoneSalida con nms=False
Detección640(1, 84, 8400)(1, 300, 6)
Segmentación640(1, 116, 8400) y (1, 32, 160, 160)(1, 300, 38) y (1, 32, 160, 160)
Semántica1024(1, 19, 1024, 1024), una puntuación para cada clase y píxelIgual que nms=None
Profundidad768(1, 1, 768, 768), mapa de profundidadIgual que nms=None
Clasificar224(1, 1000), probabilidades de claseIgual que nms=None
Pose640(1, 56, 8400)(1, 300, 57): 6 valores de caja y, después, 17 puntos clave x 3
OBB1024(1, 20, 21504)(1, 300, 7): 4 valores de caja, puntuación, clase y ángulo
  • Salida sin procesar (nms=None): forma (batch, values, anchors). Para cada ancla: centro x y centro y de la caja, anchura y altura, después las puntuaciones de clase y, a continuación, los valores de la tarea (32 coeficientes de máscara, 17 x 3 valores de puntos clave o el ángulo OBB en radianes). Los valores de la caja y las coordenadas x e y de los puntos clave están normalizados entre 0 y 1, así que multiplícalos por la anchura y la altura de entrada. Aplica NMS por tu cuenta.
  • Salida sin NMS (nms=False): max_det (300 de forma predeterminada) filas de x1, y1, x2, y2, score, class en píxeles de entrada, sin paso NMS. Las filas OBB tienen el formato center x, center y, width, height, score, class, angle, con el ángulo en radianes. Filtra las filas por puntuación. Disponible en exportaciones FP32 y 'w8a32' de modelos con cabezal sin NMS.
  • Segmentación: los 32 coeficientes de máscara son los últimos 32 valores de cada ancla o fila, y la segunda salida contiene los prototipos de máscara.
  • Segmentación semántica: la salida contiene puntuaciones de clase, no el mapa de clases de la exportación ONNX, así que calcula el argmax sobre el eje de clases en tu propio código.

YOLO("yolo26n.tflite") lee la disposición de los metadatos del archivo y escala las coordenadas, así que solo necesitas estos detalles si ejecutas el modelo con tu propio código. Los metadatos son una entrada metadata.json que la exportación añade al archivo como un archivo ZIP, legible con cualquier biblioteca ZIP. Entre sus claves están names, task, imgsz, stride, batch, end2end, args y, para los modelos de pose, kpt_shape.

Ejecutar con el intérprete LiteRT#

Para ejecutar el modelo fuera del paquete Ultralytics, cárgalo con el intérprete del paquete ai-edge-litert. Lee las formas de entrada y salida del modelo en lugar de depender de los nombres de los tensores. Un modelo de segmentación tiene dos salidas: la de 3 dimensiones contiene las detecciones y la de 4 dimensiones, los prototipos de máscara.

# Primero exporta: 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)  # tu imagen preprocesada: 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]  # conserva las filas que superen el umbral de confianza

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

Despliega#

YOLO("yolo26n.tflite") ejecuta el modelo en la CPU con el intérprete ai-edge-litert, con hasta 8 hilos. Otros valores de device, como 0 o mps, también se ejecutan en la CPU; xpu y npu seleccionan hardware Intel. La tabla de dispositivos de inferencia compara estos nombres entre formatos.

El modelo siempre se ejecuta con imgsz y batch de la exportación, que Ultralytics lee de los metadatos del archivo. Se ignora un imgsz indicado en predict o val. Los lotes más grandes se dividen en bloques del tamaño de lote de exportación y los más pequeños se rellenan, así que funciona cualquier número de imágenes.

Inferencia en GPU y NPU Intel#

Los modelos .tflite exportados se ejecutan en hardware Intel mediante el complemento LiteRT Intel OpenVINO. Indica device=xpu para la GPU o device=npu para la NPU; Ultralytics instala ai-edge-litert>=2.3.0 y ai-edge-litert-sdk-intel la primera vez que se usan. El complemento fija su propia versión de openvino, así que mantenlo en un entorno independiente si también ejecutas modelos OpenVINO con otra versión. La NPU necesita un procesador Intel Core Ultra con el controlador Intel NPU instalado; consulta la latencia medida en un Core Ultra X7 358H. En una máquina sin el dispositivo Intel solicitado, el complemento OpenVINO no consigue compilar el modelo y LiteRT lo ejecuta en su propio backend de CPU (XNNPACK), no mediante OpenVINO: en una CPU de servidor AMD, YOLO26n tardó entre 29 y 30 ms por imagen con device=xpu y device=npu, frente a 18 ms con device=cpu. Ultralytics no registra ningún aviso en este caso, así que compara la latencia con device=cpu para confirmar que se está usando el dispositivo.

Predecir
from ultralytics import YOLO

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

Guías de despliegue#

Limitaciones y solución de problemas#

  • Equipo de exportación: en Windows y Linux ARM64, como Raspberry Pi, la exportación falla con LiteRT export only supported on Linux x86 and macOS. Exporta en un equipo compatible y copia el archivo .tflite al dispositivo.
  • Primera exportación tras una instalación normal: si la primera exportación instala un litert-torch que no admite la versión de PyTorch instalada (0.10.0 admite desde 2.4.0 hasta versiones anteriores a 2.15.0), pip sustituye PyTorch, Ultralytics registra Restart runtime or rerun command for updates to take effect y la exportación puede fallar con RuntimeError: duplicate registrations for aten.miopen_batch_norm.default en PyTorch 2.15.0. Vuelve a ejecutar la exportación.
  • FP16: quantize=16 falla con quantize=16 (FP16) is not supported; format='litert' supports quantize=8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 'w8a32' (dynamic INT8), 32 or None (FP32).. Exporta en FP32 y deja que el delegado de GPU lo ejecute en precisión media.
  • Checkpoints entrenados con quantize=8: un checkpoint ajustado con entrenamiento consciente de la cuantización falla con format='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. En su lugar, exporta con quantize=8 el checkpoint desde el que empezaste el ajuste, o exporta el checkpoint ajustado a ONNX o TensorRT.
  • Cabezal sin NMS con quantize=8 o 'w8a16': con nms=False, la exportación registra LiteRT INT8 export does not support end2end models, disabling end2end branch. y escribe predicciones sin procesar que necesitan NMS. Usa FP32 o 'w8a32' para mantener el cabezal sin NMS.
  • NMS integrada: nms=True registra format=litert does not support embedded NMS; exporting native outputs for external NMS. y escribe la salida sin procesar.
  • Cabezal sin NMS en otros modelos: nms=False necesita un modelo con cabezal sin NMS, como YOLO26 o YOLOv10. En otros modelos, como YOLO11, la exportación muestra el aviso This model has no one-to-one head; using one-to-many outputs. y escribe la salida sin procesar (1, 84, 8400).
  • Forma de entrada fija: dynamic=True falla con argument 'dynamic' is not supported for format='litert'. Vuelve a exportar para cambiar el tamaño de imagen o el tamaño de lote.
  • Calibración sin data: una exportación quantize=8 o 'w8a16' registra INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. y calibra con el conjunto de datos predeterminado pequeño para la tarea. Indica data con imágenes representativas de tus datos de implementación.
  • Tamaño de calibración: la exportación registra >300 images recommended for INT8 calibration, found 4 images. cuando la partición de calibración contiene menos de 300 imágenes. coco8.yaml solo tiene 4 imágenes de validación, suficientes para probar la exportación, pero no para calibrar un modelo para su despliegue.
  • 'w8a16' en CPU x86: el intérprete de CPU LiteRT ejecutó un modelo YOLO26n 'w8a16' a aproximadamente 1 s por imagen en una CPU de servidor AMD EPYC 9655 con 8 hilos, frente a unos 17 ms para el modelo FP32. Mide 'w8a16' en el dispositivo y con el delegado que vayas a implementar.
  • Nombre de archivo: cada exportación de un mismo punto de control con el mismo valor quantize escribe el mismo archivo, como yolo26n.tflite para FP32, independientemente de sus valores imgsz, batch o nms; por tanto, la exportación posterior sustituye a la anterior.

Para otros errores, consulta la guía de problemas habituales.

Rendimiento medido#

Las tablas siguientes muestran la latencia de una imagen para el modelo YOLO26n de cada tarea en cuatro móviles Android y en un procesador Intel Core Ultra. Cada celda indica el tiempo total en milisegundos y, debajo, el desglose de preprocesamiento / inferencia / posprocesamiento; la columna más rápida de cada modelo aparece en negrita. La página del modelo YOLO26 muestra la precisión de los puntos de control PyTorch.

Xiaomi 17#

Hardware: Xiaomi 17 con 12 GB de memoria LPDDR5X y Android 17 / API 37. Su Snapdragon 8 Elite Gen 5 de 3 nm (SM8850) tiene una CPU Qualcomm Oryon de 8 núcleos (2 núcleos Prime de hasta 4,6 GHz y 6 núcleos de rendimiento de hasta 3,62 GHz), una GPU Adreno y una NPU Hexagon.

ModeloTareatamaño
(píxeles)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetección64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-segSegmentación64050.5
1.9 / 42.9 / 5.8
18.0
1.9 / 9.5 / 6.6
19.2
3.6 / 5.9 / 9.7
YOLO26n-semSemántica64045.7
1.9 / 35.7 / 8.2
30.6
1.9 / 20.5 / 8.3
25.8
3.6 / 11.0 / 11.3
YOLO26n-depthProfundidad64066.8
2.2 / 55.0 / 9.7
21.9
2.1 / 10.1 / 9.8
24.8
4.3 / 6.0 / 14.5
YOLO26n-clsClasificar2243.6
0.3 / 3.3 / 0.0
2.0
0.4 / 1.4 / 0.2
1.5
0.6 / 0.7 / 0.3
YOLO26n-posePose64039.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
  • Los valores de velocidad son latencias de ráfaga para una sola imagen: la media de 15 ejecuciones tras 3 ejecuciones de calentamiento en bus.jpg, medidas con el complemento Flutter de Ultralytics 0.7.1 y los recursos oficiales v0.7.0 (exportaciones de Ultralytics 8.4.188). El orden de CPU/GPU se alternó entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL).
  • La exportación de LiteRT traza directamente el modelo PyTorch y genera un .tflite NCHW con una entrada de tipo float: el delegado de GPU compila todo el grafo (las siete tareas se ejecutan aquí en la GPU Adreno) y w8a32 no necesita datos de calibración. En lugar de dar por hecho que se usa el diseño NHWC heredado de onnx2tf o los nombres de salida Identity, quienes consuman el modelo deben consultar las formas de los tensores y los nombres de las firmas; deben empaquetar los datos RGB directamente como CHW planar o transponerlos antes de la inferencia. Las exportaciones semánticas devuelven logits NCHW y requieren un argmax de clases en el host. Los recursos oficiales para Android están alojados en la versión v0.7.0 de yolo-flutter-app; encontrarás el registro detallado de la evaluación comparativa en el documento de rendimiento de Flutter.
  • La columna NPU corresponde a la ruta NPU propia de LiteRT: una exportación FP32 (yolo export format=litert, sin quantize) compilada en el dispositivo por los tiempos de ejecución litert-npu-runtime-qualcomm y -mediatek 2.3.0, medida con una compilación prototipo para NPU del complemento Flutter (aún no publicada). La primera carga incluye esa compilación (unos 0,3 s para n y hasta 6 s para x). Los recursos w8a32 no se compilan por completo en estas NPU. LiteRT indica que se ha compilado para NPU incluso cuando ejecuta el grafo silenciosamente en la GPU, por lo que se comprobó cada fila de NPU frente al tiempo de GPU; las filas que recurrieron a la GPU se muestran como —.
  • Las cifras correspondientes de la NPU Hexagon de Snapdragon para los recursos oficiales QNN están en la integración de Qualcomm QNN.
  • Compara los resultados de CPU/acelerador de Apple en la integración de CoreML.

Las siguientes pruebas en distintos dispositivos utilizan los mismos recursos oficiales v0.7.0.

Google Pixel 10#

Hardware: Google Pixel 10 con 12 GB de memoria y Android 17 / API 37. Su Google Tensor G5 de 3 nm tiene una CPU de 8 núcleos (1 núcleo Prime de hasta 3,78 GHz, 5 núcleos de rendimiento de hasta 3,05 GHz y 2 núcleos de eficiencia de hasta 2,25 GHz), una GPU PowerVR D-Series y una TPU de Google. Las frecuencias de los núcleos y el nombre del controlador de la GPU se consultaron en el dispositivo de pruebas, ya que Google no los publica en las especificaciones enlazadas.

ModeloTareatamaño
(píxeles)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
YOLO26nDetección64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-segSegmentación64053.1
1.5 / 45.8 / 5.7
51.5
1.6 / 40.1 / 9.9
YOLO26n-semSemántica64057.2
1.5 / 47.7 / 8.0
75.9
1.8 / 63.4 / 10.8
YOLO26n-depthProfundidad64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-clsClasificar2246.1
0.3 / 5.5 / 0.3
12.1
0.9 / 11.0 / 0.1
YOLO26n-posePose64035.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

Prueba de rendimiento: media de 15 llamadas predict() tras 3 ejecuciones de calentamiento en bus.jpg, con ultralytics_yolo 0.7.1 y los recursos oficiales v0.7.0. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL). La TPU Tensor no tiene una fila de LiteRT: el servicio EdgeTPU de Google rechaza las aplicaciones que no están en su lista de permitidas, y LiteRT ejecuta entonces el modelo en la GPU.

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) con 12 GB de memoria y Android 17 / API 37. Su Exynos 2600 de 2 nm tiene una CPU Armv9.3 de 10 núcleos (1 núcleo C1-Ultra de hasta 3,8 GHz, 3 núcleos C1-Pro de rendimiento de hasta 3,26 GHz y 6 núcleos C1-Pro de eficiencia de hasta 2,76 GHz), una GPU Xclipse 960 y una NPU de Samsung.

ModeloTareatamaño
(píxeles)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT w8a32 AOT
(ms)
YOLO26nDetección64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-segSegmentación64045.6
1.3 / 39.1 / 5.2
30.5
1.3 / 23.6 / 5.6
17.0
1.4 / 9.7 / 5.8
YOLO26n-semSemántica64038.1
1.3 / 28.6 / 8.2
26.1
1.3 / 16.8 / 7.9
28.3
1.7 / 15.1 / 11.5
YOLO26n-depthProfundidad64063.5
1.4 / 53.6 / 8.4
37.3
1.4 / 24.6 / 11.3
28.4
2.1 / 12.9 / 13.4
YOLO26n-clsClasificar2243.8
0.2 / 3.4 / 0.2
2.8
0.2 / 2.6 / 0.0
6.1
0.5 / 5.2 / 0.4
YOLO26n-posePose64031.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

Prueba de rendimiento: media de 15 llamadas predict() tras 3 ejecuciones de calentamiento en bus.jpg, con ultralytics_yolo 0.7.1 y los recursos oficiales v0.7.0. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL). La columna NPU utiliza los recursos w8a32 compilados de antemano para Exynos 2600 (E9965) con el complemento del compilador de Samsung para LiteRT. Samsung no tiene un compilador en el dispositivo en LiteRT 2.3 y Google aún no publica un entorno de ejecución para la NPU de Samsung, así que estas filas utilizaron una biblioteca de envío creada a partir del código fuente de LiteRT 2.3.

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) con 12 GB de memoria LPDDR5X y Android 16 / API 36. Su MediaTek Dimensity 9500 de 3 nm (MT6993) tiene una CPU Armv9.3 de 8 núcleos (1 núcleo C1-Ultra de hasta 4,21 GHz, 3 núcleos C1-Premium de hasta 3,5 GHz y 4 núcleos C1-Pro de hasta 2,7 GHz), GPU Mali-G1 Ultra MC12 y NPU MediaTek 990.

ModeloTareatamaño
(píxeles)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetección64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-segSegmentación64077.8
2.6 / 65.3 / 9.9
47.4
2.6 / 33.6 / 11.3
36.5
2.6 / 23.4 / 10.4
YOLO26n-semSemántica64081.3
2.6 / 62.2 / 16.5
79.3
2.6 / 59.5 / 17.1
87.6
2.6 / 68.3 / 16.7
YOLO26n-depthProfundidad640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-clsClasificar2246.3
0.5 / 5.4 / 0.4
8.1
0.5 / 7.5 / 0.1
3.2
0.5 / 2.2 / 0.5
YOLO26n-posePose64053.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
—

Evaluación comparativa: media de 15 llamadas a predict() tras 3 ejecuciones de calentamiento en bus.jpg, usando ultralytics_yolo 0.7.1 y los recursos oficiales de v0.7.0. El orden de CPU/GPU se alterna entre tareas en una única pasada secuencial. Los registros nativos confirmaron que todas las filas de CPU usaron LiteRT CPU/XNNPACK y que todas las filas de GPU delegaron el grafo completo en LiteRT OpenCL (LITERT_CL). Depth y OBB no tienen resultados de NPU: el compilador de NPU de MediaTek rechaza sus operaciones exponenciales y trigonométricas, y LiteRT ejecuta esos grafos en la GPU.

Consulta la guía de MediaTek Dimensity para conocer el flujo de trabajo de despliegue en Android y las limitaciones de las NPU.

Intel Core Ultra X7 358H#

Hardware: Intel Core Ultra X7 358H (Panther Lake) e Intel AI Boost NPU 5010, Fedora Linux, controlador de NPU 1.38.0, ai-edge-litert 2.3.0.

ModeloTareatamaño
(píxeles)
CPU
w8a32 LiteRT
(ms)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26nDetección64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-segSegmentación64024.2
0.9 / 22.1 / 1.3
32.6
1.0 / 30.1 / 1.5
6.2
0.8 / 4.2 / 1.2
YOLO26n-semSemántica64025.2
1.0 / 14.2 / 10.0
33.1
1.1 / 21.9 / 10.2
16.5
1.0 / 5.5 / 10.0
YOLO26n-depthProfundidad64031.7
0.9 / 30.2 / 0.5
76.6
0.9 / 75.2 / 0.5
9.1
1.0 / 7.5 / 0.5
YOLO26n-clsClasificar2244.6
2.8 / 1.7 / 0.0
7.3
3.3 / 3.9 / 0.0
4.1
3.2 / 0.9 / 0.0
YOLO26n-posePose64020.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

Prueba de rendimiento: Media de 15 llamadas a predict() tras 3 calentamientos en bus.jpg, con ultralytics 8.4.174 y ai-edge-litert 2.3.0 mediante exportaciones de w8a32. Cada celda muestra el tiempo total y, debajo, el desglose entre preprocesamiento, inferencia y posprocesamiento.

Acerca de LiteRT#

LiteRT, abreviatura de Lite Runtime, continúa TensorFlow Lite con un nuevo nombre y ejecuta el mismo formato de modelo .tflite. Ejecuta modelos en la CPU con XNNPACK y en GPU y NPU mediante delegados de hardware; LiteRT.js permite usar el mismo archivo en navegadores y Node.js. Consulta la documentación de LiteRT para ver la referencia completa.

LiteRT edge deployment framework



Ver: Cómo exportar Ultralytics YOLO26 a Google LiteRT | Implementa IA para visión en Android e iOS | IA móvil 📱🚀

Preguntas frecuentes#

  • LiteRT es el nuevo nombre de TensorFlow Lite y mantiene el mismo formato de modelo .tflite. En Ultralytics, format="litert" sustituye dos formatos de exportación anteriores: tflite para dispositivos móviles, integrados y periféricos, y tfjs para navegadores y Node.js, donde LiteRT.js ahora ejecuta el mismo archivo .tflite. Ambos valores anteriores siguen exportando un archivo LiteRT y muestran un aviso de obsolescencia. Las páginas de TFLite y TF.js describen los formatos anteriores.

  • Empieza con quantize="w8a32". No necesita datos de calibración, reduce el archivo a menos de un tercio del tamaño FP32, admite el cabezal sin NMS de YOLO26 con nms=False y es la precisión de los modelos oficiales de Ultralytics para móviles en CPU y GPU. Usa quantize=8 cuando el dispositivo de destino necesite activaciones enteras: por ejemplo, la exportación NXP i.MX95 compila un modelo LiteRT INT8 calibrado. 'w8a16' conserva más precisión de activación que 8. Ambos necesitan datos de calibración representativos y devuelven predicciones sin procesar que necesitan NMS. Mide la latencia y la precisión en el dispositivo de destino antes de elegir, porque la compatibilidad con cada esquema varía entre los delegados de CPU, GPU y NPU.

  • No. La exportación solo se ejecuta en Linux x86-64 y macOS con Apple silicon. Exporta el modelo en uno de estos equipos o con Ultralytics Platform, y copia el archivo .tflite al dispositivo. Consulta la guía de Raspberry Pi para ejecutar modelos en la placa, donde una Coral Edge TPU puede acelerar la inferencia.

  • Sí. LiteRT.js ejecuta el archivo .tflite exportado en un navegador o en Node.js mediante WebGPU o WASM, así que no hace falta una exportación específica para el navegador. El paquete npm @ultralytics/yolo lo integra con inferencia desde la cámara web y de imágenes individuales para las tareas de detección, segmentación, segmentación semántica, clasificación, pose y OBB.

  • Usa el complemento Ultralytics YOLO para Flutter, que carga exportaciones LiteRT .tflite en Android y admite las siete tareas YOLO26. Exporta con imgsz=640, o con imgsz=224 para clasificación, para que coincida con los modelos oficiales. Para una aplicación nativa, sigue la guía de LiteRT para Android y proporciona la entrada al modelo como se describe en Formato de salida. En iPhone, Core ML es el formato nativo.

Comentarios

Haz una pregunta, comparte tus resultados o ayuda a otra persona.