Inizia

Esportazione Google LiteRT

LiteRT è il runtime di Google per l'IA on-device e il nuovo nome di TensorFlow Lite (TFLite). L'esportazione di un modello Ultralytics YOLO26 con format="litert" crea un singolo file .tflite per telefoni Android e iOS, schede Linux integrate e browser web, in FP32 o con uno dei tre schemi di quantizzazione INT8.

In breve#

ProprietàDettagli
argomento formatlitert. I valori precedenti tflite e tfjs funzionano ancora: registrano un avviso di deprecazione ed esportano lo stesso file LiteRT
Outputyolo26n.tflite, un file con i nomi delle classi, l'attività e le dimensioni dell'immagine memorizzati al suo interno come metadati; gli export quantizzati sono denominati yolo26n_w8a32.tflite, yolo26n_int8.tflite e yolo26n_w8a16.tflite
Esecuzione suDispositivi Android e iOS, schede Linux integrate, CPU desktop, browser web tramite LiteRT.js e GPU e NPU Intel
RuntimeLiteRT: il pacchetto Python ai-edge-litert (versione 2.1.4 o successive), le librerie LiteRT per Android e iOS oppure LiteRT.js
PrecisioneFP32, w8a32, INT8, w8a16. YOLO26n pesa 10,0 MB in FP32, 2,9 MB con w8a32, 3,1 MB in INT8 e 3,0 MB con w8a16
Sistema per l'esportazioneLinux x86-64 o macOS su Apple silicon, con Python 3.10 o versioni successive. L'esportazione viene eseguita sulla CPU e non richiede una GPU
Esportazione nel cloud

Ultralytics Platform può esportare per te un modello addestrato in LiteRT, così non hai bisogno di un ambiente di esportazione locale.

Guida rapida#

Installa il pacchetto Ultralytics con le dipendenze per l'esportazione LiteRT:

pip install "ultralytics[export-litert]"

Questo installa litert-torch, ai-edge-litert e ai-edge-quantizer. Con una semplice installazione di pip install ultralytics, la prima esportazione installa i pacchetti mancanti e può interrompersi con un errore se questo sostituisce PyTorch. L'esportazione richiede queste versioni:

PacchettoVersione richiesta
Python3.10 o versioni successive
litert-torch0.10.0 o versioni successive
torchL'intervallo accettato dal pacchetto litert-torch installato: 2.4.0 o versioni successive e precedenti alla 2.15.0 per la versione 0.10.0
ai-edge-litert2.3.0 o versioni successive per l'esportazione; 2.1.4 o versioni successive, anche con Python 3.10 o versioni successive, per eseguire un modello esportato
ai-edge-quantizer0.10.0 o versioni successive, per quantize="w8a32", quantize=8 e "w8a16"

Per altri metodi di installazione, consulta la guida all'installazione. Poi esporta il tuo modello e carica il file esportato per eseguire l'inferenza o convalidarne l'accuratezza.

Esporta
from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato LiteRT
model.export(format="litert")  # crea 'yolo26n.tflite'

# Esporta con pesi INT8 e attivazioni FP32, senza bisogno di dati di calibrazione
model.export(format="litert", quantize="w8a32")  # crea 'yolo26n_w8a32.tflite'
Predici
from ultralytics import YOLO

# Carica il modello LiteRT esportato
model = YOLO("yolo26n.tflite")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")
Convalida
from ultralytics import YOLO

# Carica il modello LiteRT esportato
model = YOLO("yolo26n.tflite")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Attività supportate#

L'esportazione LiteRT supporta tutte e sette le attività Ultralytics con i modelli YOLOv8, YOLO11 e YOLO26: rilevamento, segmentazione, segmentazione semantica, stima della profondità, classificazione, stima della posa e OBB. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste head.

Argomenti di esportazione#

ArgomentoTipoPredefinitoDescrizione
formatstr'litert'Formato di destinazione del modello esportato, che definisce la compatibilità con i vari ambienti di distribuzione.
imgszint o tuple640Dimensione dell'immagine di input del modello: un numero intero per immagini quadrate o una tupla (height, width). Se non viene specificata, l'esportazione usa la dimensione con cui è stato addestrato il checkpoint. I checkpoint ufficiali YOLO26 usano 640 per i modelli detect, segment e pose e per i modelli semantici preaddestrati su ADE20K, 1024 per i modelli OBB e per quelli semantici preaddestrati su Cityscapes, 768 per depth e 224 per classify.
quantizeint o strNoneSchema di quantizzazione: 'w8a32' (pesi INT8, attivazioni FP32, senza calibrazione), 8 (pesi e attivazioni INT8, calibrati su data) oppure 'w8a16' (pesi INT8, attivazioni INT16, calibrati su data); 32/non specificato corrisponde a FP32. 16 genera un errore e un checkpoint addestrato con quantize=8 non può essere esportato in LiteRT; consulta Limitazioni e risoluzione dei problemi. Sostituisce i flag deprecati half/int8.
datastrNoneFile YAML del dataset usato per la calibrazione con quantize=8 e 'w8a16'; per la classificazione si specifica invece una directory del dataset o il nome di un dataset integrato. La calibrazione usa lo split val, a meno che non sia impostato split. Se omesso, Ultralytics usa il piccolo dataset predefinito per l'attività del modello, ad esempio coco8.yaml per il rilevamento.
fractionfloat, int o list1.0Sottoinsieme di calibrazione: un rapporto, un numero di immagini (interi maggiori di 1) o un elenco [train, val, test], dal quale viene usata la voce della suddivisione di calibrazione.
nmsbool, facoltativoNoneSeleziona l'output grezzo (None, predefinito) o la head senza NMS (False, solo per gli export FP32 e 'w8a32'). La NMS integrata (True) non è disponibile per LiteRT. Consulta il formato di output.
batchint1Dimensione del batch del modello esportato, fissata nella forma dell'input. È anche la dimensione del batch usata per la calibrazione.
devicestrNoneL'esportazione viene sempre eseguita sulla CPU, indipendentemente dal valore passato.

Per gli argomenti condivisi da tutti i formati, consulta la documentazione della modalità di esportazione.

Dimensione dell'immagine dei modelli ufficiali per dispositivi mobili e web

I modelli LiteRT, Core ML e QNN ufficiali per dispositivi mobili vengono esportati a imgsz=640 e a imgsz=224 per la classificazione. I checkpoint Cityscapes per la segmentazione semantica, la profondità e OBB vengono esportati per impostazione predefinita a una dimensione maggiore: passa imgsz=640 per uniformarti a questi.

Quantizzazione#

quantize seleziona uno dei tre schemi INT8. In tutti i casi i pesi vengono memorizzati come interi a 8 bit; gli schemi differiscono per il modo in cui vengono memorizzate le attivazioni, cioè i valori che passano da un livello all'altro:

quantizePesiAttivazioniDati di calibrazioneFile YOLO26nDimensione
non impostato o 32FP32FP32Noyolo26n.tflite10.0 MB
'w8a32'INT8FP32Noyolo26n_w8a32.tflite2.9 MB
8INT8INT8Sìyolo26n_int8.tflite3.1 MB
'w8a16'INT8INT16Sìyolo26n_w8a16.tflite3.0 MB
  • Input e output: l'input e gli output restano float32 in tutte e quattro le precisioni, quindi il codice di inferenza scritto per il modello FP32 esegue senza modifiche un modello quantizzato esportato con lo stesso layout nms.
  • 'w8a32': quantizzazione a intervallo dinamico. Non richiede dati di calibrazione e supporta la head senza NMS con nms=False; è inoltre la precisione dei modelli ufficiali per dispositivi mobili nelle colonne CPU e GPU di Prestazioni misurate.
  • 8 e 'w8a16': quantizzazione statica. L'esportazione esegue la calibrazione su ogni batch completo dello split val di data o dello split impostato con split, e mostra un avviso se ci sono meno di 300 immagini. Usa fraction per limitare il numero di immagini.
  • Output della testa con quantize=8: nei modelli di rilevamento, segmentazione, classificazione, stima della posa e OBB, i livelli di output della testa e le operazioni che li decodificano restano in virgola mobile, perché INT8 limita i punteggi delle classi e riduce la precisione delle coordinate dei riquadri. 'w8a16' quantizza anche questi livelli, usando attivazioni a 16 bit.
  • Head senza NMS: gli export quantize=8 e 'w8a16' di un modello YOLO26 o YOLOv10 usano la head one-to-many e restituiscono predizioni grezze che richiedono NMS, anche con nms=False.
  • FP16: non è disponibile l'esportazione FP16. I delegate GPU di LiteRT eseguono per impostazione predefinita un modello FP32 in precisione dimezzata, quindi quantize=16 non è necessario e genera un errore.
Esempio
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Esegui la calibrazione sul 10% delle immagini di convalida COCO (500 immagini); sostituisci coco.yaml con il tuo dataset
model.export(format="litert", quantize=8, data="coco.yaml", fraction=0.1)  # crea 'yolo26n_int8.tflite'

# Carica il modello INT8 esportato ed esegui l'inferenza
model = YOLO("yolo26n_int8.tflite")
results = model("https://ultralytics.com/images/bus.jpg")

La quantizzazione modifica l'accuratezza e l'effetto dipende dal modello, dall'attività e dalle immagini di calibrazione. Convalida un modello quantizzato sui tuoi dati prima di distribuirlo.

Formato di output#

L'esportazione scrive un unico file .tflite. Il modello accetta un input con forma (batch, 3, height, width): RGB, canali per primi (NCHW), float32, scalato da 0 a 1. Questo differisce dai file TFLite creati dalla precedente esportazione format="tflite", che accettava immagini con i canali per ultimi (NHWC). L'argomento nms e l'attività determinano gli output. Le forme riportate sotto si riferiscono ai checkpoint YOLO26n ufficiali alla dimensione di esportazione predefinita, con il checkpoint Cityscapes yolo26n-sem.pt per la segmentazione semantica:

Attivitàimgsz predefinitoOutput con nms=NoneOutput con nms=False
Rilevamento640(1, 84, 8400)(1, 300, 6)
Segmentazione640(1, 116, 8400) e (1, 32, 160, 160)(1, 300, 38) e (1, 32, 160, 160)
Semantica1024(1, 19, 1024, 1024), un punteggio per ogni classe e pixelCome nms=None
Profondità768(1, 1, 768, 768), mappa di profonditàCome nms=None
Classificazione224(1, 1000), probabilità delle classiCome nms=None
Posa640(1, 56, 8400)(1, 300, 57): 6 valori del riquadro, poi 17 keypoint x 3
OBB1024(1, 20, 21504)(1, 300, 7): 4 valori del riquadro, punteggio, classe, angolo
  • Output grezzo (nms=None): forma (batch, values, anchors). Per ogni anchor: il centro x e il centro y del riquadro, la larghezza e l'altezza, poi i punteggi delle classi e infine i valori dell'attività (32 coefficienti della maschera, 17 x 3 valori dei keypoint oppure l'angolo OBB in radianti). I valori del riquadro e le coordinate x e y dei keypoint sono normalizzati tra 0 e 1, quindi moltiplicali per la larghezza e l'altezza dell'input. Applica la NMS autonomamente.
  • Output senza NMS (nms=False): max_det (300 per impostazione predefinita) righe di x1, y1, x2, y2, score, class in pixel dell'input, senza passaggio NMS. Le righe OBB sono center x, center y, width, height, score, class, angle, con l'angolo in radianti. Filtra le righe in base al punteggio. Disponibile per gli export FP32 e 'w8a32' dei modelli con una head senza NMS.
  • Segmentazione: i 32 coefficienti della maschera sono gli ultimi 32 valori di ogni anchor o riga, mentre il secondo output contiene i prototipi della maschera.
  • Segmentazione semantica: l'output contiene i punteggi delle classi, non la mappa delle classi dell'export ONNX; calcola quindi l'argmax sull'asse delle classi nel tuo codice.

YOLO("yolo26n.tflite") legge il layout dai metadati del file e scala le coordinate, quindi questi dettagli ti servono solo se esegui il modello nel tuo codice. I metadati sono una voce metadata.json che l'esportazione aggiunge al file come archivio ZIP, leggibile con qualsiasi libreria ZIP. Le chiavi includono names, task, imgsz, stride, batch, end2end, args e, per i modelli pose, kpt_shape.

Esegui con l'interprete LiteRT#

Per eseguire il modello al di fuori del pacchetto Ultralytics, caricalo con l'interprete del pacchetto ai-edge-litert. Leggi dal modello le forme di input e output invece di basarti sui nomi dei tensori. Un modello di segmentazione ha due output: quello tridimensionale contiene i rilevamenti e quello quadridimensionale i prototipi della maschera.

# Export first: 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)  # la tua immagine preelaborata: 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]  # mantieni le righe sopra la soglia di confidenza

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

Distribuisci#

YOLO("yolo26n.tflite") esegue il modello sulla CPU con l'interprete ai-edge-litert, usando fino a 8 thread. Anche altri valori device, come 0 o mps, vengono eseguiti sulla CPU; xpu e npu selezionano hardware Intel. La tabella dei dispositivi di inferenza confronta questi nomi tra i diversi formati.

Il modello viene sempre eseguito con imgsz e batch definiti durante l'esportazione, che Ultralytics legge dai metadati del file. Un imgsz passato a predict o val viene ignorato. I batch più grandi vengono suddivisi in blocchi della dimensione del batch di esportazione, mentre quelli più piccoli vengono riempiti: è quindi possibile usare qualsiasi numero di immagini.

Inferenza su GPU e NPU Intel#

I modelli .tflite esportati vengono eseguiti su hardware Intel tramite il plugin LiteRT Intel OpenVINO. Passa device=xpu per la GPU o device=npu per la NPU; al primo utilizzo Ultralytics installa ai-edge-litert>=2.3.0 e ai-edge-litert-sdk-intel. Il plugin vincola la propria versione di openvino, quindi tienilo in un ambiente separato se esegui anche modelli OpenVINO con una versione diversa. La NPU richiede un processore Intel Core Ultra con il driver Intel NPU installato; consulta la latenza misurata su un Core Ultra X7 358H. Su una macchina priva del dispositivo Intel richiesto, il plugin OpenVINO non riesce a compilare il modello e LiteRT lo esegue sul proprio backend CPU (XNNPACK), non tramite OpenVINO: su una CPU server AMD, YOLO26n ha impiegato da 29 a 30 ms per immagine con device=xpu e device=npu, contro 18 ms con device=cpu. In questo caso Ultralytics non registra alcun avviso, quindi confronta la latenza con device=cpu per verificare che il dispositivo sia in uso.

Predici
from ultralytics import YOLO

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

Guide alla distribuzione#

Limitazioni e risoluzione dei problemi#

  • Host di esportazione: su Windows e su Linux ARM64, ad esempio su un Raspberry Pi, l'esportazione non riesce con LiteRT export only supported on Linux x86 and macOS. Esporta su un host supportato e copia il file .tflite sul dispositivo.
  • Prima esportazione dopo una semplice installazione: se la prima esportazione installa un litert-torch che non accetta la versione di PyTorch installata (la versione 0.10.0 accetta dalla 2.4.0 fino alle versioni precedenti alla 2.15.0), pip sostituisce PyTorch, Ultralytics registra Restart runtime or rerun command for updates to take effect e l'esportazione può non riuscire, con RuntimeError: duplicate registrations for aten.miopen_batch_norm.default su PyTorch 2.15.0. Esegui di nuovo l'esportazione.
  • FP16: quantize=16 non riesce 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).. Esporta in FP32 e lascia che il delegate GPU lo esegua a precisione dimezzata.
  • Checkpoint addestrati con quantize=8: un checkpoint ottimizzato con l'addestramento consapevole della quantizzazione non può essere esportato con format='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Esporta invece il checkpoint da cui hai avviato l'ottimizzazione con quantize=8, oppure esporta il checkpoint ottimizzato in ONNX o TensorRT.
  • Head senza NMS con quantize=8 o 'w8a16': con nms=False, l'esportazione registra LiteRT INT8 export does not support end2end models, disabling end2end branch. e scrive predizioni grezze che richiedono NMS. Usa FP32 o 'w8a32' per mantenere la head senza NMS.
  • NMS incorporata: nms=True registra format=litert does not support embedded NMS; exporting native outputs for external NMS. e scrive l'output grezzo.
  • Head senza NMS su altri modelli: nms=False richiede un modello con una head senza NMS, come YOLO26 o YOLOv10. Per altri modelli, ad esempio YOLO11, l'esportazione mostra l'avviso This model has no one-to-one head; using one-to-many outputs. e scrive l'output grezzo (1, 84, 8400).
  • Forma di input fissa: dynamic=True non riesce con argument 'dynamic' is not supported for format='litert'. Esporta di nuovo per modificare la dimensione dell'immagine o del batch.
  • Calibrazione senza data: un'esportazione quantize=8 o 'w8a16' registra INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. ed esegue la calibrazione sul piccolo dataset predefinito per l'attività. Passa data con immagini rappresentative dei dati di distribuzione.
  • Dimensione della calibrazione: l'esportazione registra >300 images recommended for INT8 calibration, found 4 images. se la suddivisione di calibrazione contiene meno di 300 immagini. coco8.yaml ha solo 4 immagini di convalida, sufficienti per testare l'esportazione ma non per calibrare un modello da distribuire.
  • 'w8a16' su CPU x86: l'interprete LiteRT per CPU ha eseguito un modello YOLO26n 'w8a16' a circa 1 s per immagine su una CPU server AMD EPYC 9655 con 8 thread, contro circa 17 ms per il modello FP32. Misura 'w8a16' sul dispositivo e sul delegate che userai in produzione.
  • Nome del file: ogni esportazione dello stesso checkpoint con lo stesso valore quantize scrive lo stesso file, ad esempio yolo26n.tflite per FP32, indipendentemente da imgsz, batch o nms; l'esportazione successiva quindi sovrascrive quella precedente.

Per altri errori, consulta la guida ai problemi comuni.

Prestazioni misurate#

Le tabelle seguenti riportano la latenza per una singola immagine del modello YOLO26n per ciascuna attività su quattro telefoni Android e su un processore Intel Core Ultra. Ogni cella mostra il tempo totale in millisecondi e, sotto, la suddivisione tra preelaborazione, inferenza e postelaborazione; la colonna più veloce per ciascun modello è in grassetto. La pagina del modello YOLO26 riporta l'accuratezza dei checkpoint PyTorch.

Xiaomi 17#

Hardware: Xiaomi 17 con 12 GB di memoria LPDDR5X e Android 17 / API 37. Il suo Snapdragon 8 Elite Gen 5 a 3 nm (SM8850) integra una CPU Qualcomm Oryon a 8 core (2 core Prime fino a 4.6 GHz e 6 core Performance fino a 3.62 GHz), una GPU Adreno e una NPU Hexagon.

ModelloAttivitàdimensione
(pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nRilevamento64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-segSegmentazione64050.5
1.9 / 42.9 / 5.8
18.0
1.9 / 9.5 / 6.6
19.2
3.6 / 5.9 / 9.7
YOLO26n-semSemantica64045.7
1.9 / 35.7 / 8.2
30.6
1.9 / 20.5 / 8.3
25.8
3.6 / 11.0 / 11.3
YOLO26n-depthProfondità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-clsClassificazione2243.6
0.3 / 3.3 / 0.0
2.0
0.4 / 1.4 / 0.2
1.5
0.6 / 0.7 / 0.3
YOLO26n-posePosa64039.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
  • I valori di velocità sono latenze a raffica su singola immagine: la media di 15 esecuzioni dopo 3 esecuzioni di riscaldamento su bus.jpg, misurata con il plugin Flutter di Ultralytics 0.7.1 e gli asset ufficiali v0.7.0 (esportazioni di Ultralytics 8.4.188). L'ordine CPU/GPU è stato alternato tra le attività in un'unica sequenza di test. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL).
  • L'esportazione LiteRT traccia direttamente il modello PyTorch, generando un .tflite NCHW con input float: il delegate GPU compila l'intero grafo (qui tutte e sette le attività vengono eseguite sulla GPU Adreno) e w8a32 non richiede dati di calibrazione. Chi utilizza il modello dovrebbe leggere le forme dei tensori e i nomi delle signature anziché dare per scontato il layout NHWC legacy di onnx2tf o i nomi di output Identity; i dati RGB vanno organizzati direttamente in CHW planare o trasposti prima dell'inferenza. Le esportazioni semantiche restituiscono logits NCHW e richiedono un argmax delle classi sul lato host. Gli asset Android ufficiali sono disponibili nella release v0.7.0 di yolo-flutter-app; il documento sulle prestazioni di Flutter contiene i dettagli completi del benchmark.
  • La colonna NPU indica il percorso NPU di LiteRT: un'esportazione FP32 (yolo export format=litert, senza quantize) compilata sul dispositivo dai runtime litert-npu-runtime-qualcomm e -mediatek 2.3.0, misurata con una build prototipo del plugin Flutter per NPU (non ancora rilasciata). Il primo caricamento include la compilazione (circa 0.3 s per n, fino a 6 s per x). Gli asset w8a32 non vengono compilati completamente su queste NPU. LiteRT segnala una compilazione NPU anche quando esegue silenziosamente il grafo sulla GPU, quindi ogni riga NPU è stata confrontata con il tempo GPU; le righe che sono passate alla GPU sono indicate con —.
  • I valori corrispondenti per la NPU Hexagon Snapdragon con gli asset QNN ufficiali sono disponibili nell'integrazione Qualcomm QNN.
  • Confronta i risultati di CPU/acceleratore Apple nell'integrazione CoreML.

I seguenti test comparativi sui dispositivi utilizzano gli stessi asset ufficiali v0.7.0.

Google Pixel 10#

Hardware: Google Pixel 10 con 12 GB di memoria e Android 17 / API 37. Il suo Google Tensor G5 a 3 nm integra una CPU a 8 core (1 core Prime fino a 3.78 GHz, 5 core Performance fino a 3.05 GHz e 2 core Efficiency fino a 2.25 GHz), una GPU PowerVR D-Series e una TPU Google. Le frequenze dei core e il nome del driver GPU sono stati rilevati dal dispositivo usato per i test comparativi, perché Google non li pubblica nelle specifiche collegate.

ModelloAttivitàdimensione
(pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
YOLO26nRilevamento64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-segSegmentazione64053.1
1.5 / 45.8 / 5.7
51.5
1.6 / 40.1 / 9.9
YOLO26n-semSemantica64057.2
1.5 / 47.7 / 8.0
75.9
1.8 / 63.4 / 10.8
YOLO26n-depthProfondità64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-clsClassificazione2246.1
0.3 / 5.5 / 0.3
12.1
0.9 / 11.0 / 0.1
YOLO26n-posePosa64035.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

Test comparativo: media di 15 chiamate predict() dopo 3 esecuzioni di riscaldamento su bus.jpg, usando ultralytics_yolo 0.7.1 e gli asset ufficiali v0.7.0. L'ordine CPU/GPU si alterna tra le attività in un'unica sequenza di test. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL). La TPU Tensor non ha una riga LiteRT: il servizio EdgeTPU di Google rifiuta le app che non sono nella relativa lista di autorizzazione e LiteRT esegue quindi il modello sulla GPU.

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) con 12 GB di memoria e Android 17 / API 37. Il suo Exynos 2600 a 2 nm integra una CPU Armv9.3 a 10 core (1 core C1-Ultra fino a 3.8 GHz, 3 core C1-Pro ad alte prestazioni fino a 3.26 GHz e 6 core C1-Pro a basso consumo fino a 2.76 GHz), una GPU Xclipse 960 e una NPU Samsung.

ModelloAttivitàdimensione
(pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT w8a32 AOT
(ms)
YOLO26nRilevamento64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-segSegmentazione64045.6
1.3 / 39.1 / 5.2
30.5
1.3 / 23.6 / 5.6
17.0
1.4 / 9.7 / 5.8
YOLO26n-semSemantica64038.1
1.3 / 28.6 / 8.2
26.1
1.3 / 16.8 / 7.9
28.3
1.7 / 15.1 / 11.5
YOLO26n-depthProfondità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-clsClassificazione2243.8
0.2 / 3.4 / 0.2
2.8
0.2 / 2.6 / 0.0
6.1
0.5 / 5.2 / 0.4
YOLO26n-posePosa64031.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

Test comparativo: media di 15 chiamate predict() dopo 3 esecuzioni di riscaldamento su bus.jpg, usando ultralytics_yolo 0.7.1 e gli asset ufficiali v0.7.0. L'ordine CPU/GPU si alterna tra le attività in un'unica sequenza di test. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e ogni riga GPU delegava il grafo completo a LiteRT OpenCL (LITERT_CL). La colonna NPU usa gli asset w8a32 compilati in anticipo per Exynos 2600 (E9965) con il plugin del compilatore Samsung di LiteRT. Samsung non dispone di un compilatore sul dispositivo in LiteRT 2.3 e Google non pubblica ancora un runtime per NPU Samsung, quindi per queste righe è stata usata una libreria di dispatch creata dai sorgenti di LiteRT 2.3.

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) con 12 GB di memoria LPDDR5X e Android 16 / API 36. Il suo MediaTek Dimensity 9500 a 3 nm (MT6993) integra una CPU Armv9.3 a 8 core (1 core C1-Ultra fino a 4.21 GHz, 3 core C1-Premium fino a 3.5 GHz e 4 core C1-Pro fino a 2.7 GHz), una GPU Mali-G1 Ultra MC12 e una NPU MediaTek 990.

ModelloAttivitàdimensione
(pixel)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nRilevamento64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-segSegmentazione64077.8
2.6 / 65.3 / 9.9
47.4
2.6 / 33.6 / 11.3
36.5
2.6 / 23.4 / 10.4
YOLO26n-semSemantica64081.3
2.6 / 62.2 / 16.5
79.3
2.6 / 59.5 / 17.1
87.6
2.6 / 68.3 / 16.7
YOLO26n-depthProfondità640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-clsClassificazione2246.3
0.5 / 5.4 / 0.4
8.1
0.5 / 7.5 / 0.1
3.2
0.5 / 2.2 / 0.5
YOLO26n-posePosa64053.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
—

Benchmark: media di 15 chiamate a predict() dopo 3 fasi di riscaldamento su bus.jpg, usando ultralytics_yolo 0.7.1 e gli asset ufficiali v0.7.0. L'ordine CPU/GPU si alterna tra le attività durante un'unica esecuzione sequenziale. I log nativi hanno confermato che ogni riga CPU usava LiteRT CPU/XNNPACK e che ogni riga GPU delegava l'intero grafo a LiteRT OpenCL (LITERT_CL). Profondità e OBB non hanno risultati NPU: il compilatore NPU di MediaTek rifiuta le operazioni esponenziali e trigonometriche e LiteRT esegue questi grafi sulla GPU.

Per il flusso di lavoro di distribuzione su Android e i limiti delle NPU, consulta la guida MediaTek Dimensity.

Intel Core Ultra X7 358H#

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

ModelloAttivitàdimensione
(pixel)
CPU
w8a32 LiteRT
(ms)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26nRilevamento64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-segSegmentazione64024.2
0.9 / 22.1 / 1.3
32.6
1.0 / 30.1 / 1.5
6.2
0.8 / 4.2 / 1.2
YOLO26n-semSemantica64025.2
1.0 / 14.2 / 10.0
33.1
1.1 / 21.9 / 10.2
16.5
1.0 / 5.5 / 10.0
YOLO26n-depthProfondità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-clsClassificazione2244.6
2.8 / 1.7 / 0.0
7.3
3.3 / 3.9 / 0.0
4.1
3.2 / 0.9 / 0.0
YOLO26n-posePosa64020.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

Benchmark: Media di 15 chiamate predict() dopo 3 cicli di riscaldamento su bus.jpg, usando ultralytics 8.4.174 e ai-edge-litert 2.3.0 con esportazioni w8a32. Ogni cella mostra il tempo totale, con la suddivisione tra pre-elaborazione, inferenza e post-elaborazione riportata sotto.

Informazioni su LiteRT#

LiteRT, abbreviazione di Lite Runtime, prosegue TensorFlow Lite con un nuovo nome ed esegue lo stesso formato di modello .tflite. Esegue i modelli sulla CPU con XNNPACK e su GPU e NPU tramite delegate hardware; LiteRT.js consente di usare lo stesso file anche nei browser e in Node.js. Per la documentazione completa, consulta la documentazione LiteRT.

LiteRT edge deployment framework



Guarda: Come esportare Ultralytics YOLO26 in Google LiteRT | Distribuisci l'IA per la visione su Android e iOS | IA mobile 📱🚀

Domande frequenti#

  • LiteRT è il nuovo nome di TensorFlow Lite e usa lo stesso formato di modello .tflite. In Ultralytics, format="litert" sostituisce due formati di esportazione precedenti: tflite per dispositivi mobili, integrati ed edge e tfjs per browser e Node.js, dove LiteRT.js esegue ora lo stesso file .tflite. Entrambi i valori precedenti esportano ancora un file LiteRT con un avviso di deprecazione. Le pagine TFLite e TF.js descrivono i formati precedenti.

  • Inizia con quantize="w8a32". Non richiede dati di calibrazione, riduce le dimensioni del file a meno di un terzo rispetto a FP32, supporta la head senza NMS di YOLO26 con nms=False ed è la precisione dei modelli ufficiali Ultralytics per dispositivi mobili su CPU e GPU. Usa quantize=8 quando il dispositivo di destinazione richiede attivazioni intere: ad esempio, l'export NXP i.MX95 compila un modello LiteRT INT8 calibrato. 'w8a16' mantiene una precisione delle attivazioni superiore rispetto a 8. Entrambi richiedono dati di calibrazione rappresentativi e restituiscono predizioni grezze che richiedono NMS. Misura la latenza e l'accuratezza sul dispositivo di destinazione prima di scegliere, perché il supporto di ciascuno schema varia tra i delegate CPU, GPU e NPU.

  • No. L'esportazione viene eseguita solo su Linux x86-64 e su macOS con Apple silicon. Esporta il modello su uno di questi host o con Ultralytics Platform, poi copia il file .tflite sul dispositivo. Consulta la guida per Raspberry Pi per eseguire i modelli sulla scheda; una Coral Edge TPU può accelerare l'inferenza.

  • Sì. LiteRT.js esegue il file esportato .tflite in un browser o in Node.js con WebGPU o WASM, quindi non serve un'esportazione separata per il browser. Il pacchetto npm @ultralytics/yolo lo integra con l'inferenza tramite webcam e su singola immagine per le attività detect, segment, semantic, classify, pose e OBB.

  • Usa il plugin Ultralytics YOLO per Flutter, che carica su Android gli export LiteRT .tflite e supporta tutte e sette le attività YOLO26. Esporta con imgsz=640 o, per la classificazione, con imgsz=224, così da uniformarti ai modelli ufficiali. Per un'app nativa, segui la guida LiteRT per Android e passa il modello come descritto nel formato di output. Su iPhone, Core ML è il formato nativo.

Commenti

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.