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 format | litert. I valori precedenti tflite e tfjs funzionano ancora: registrano un avviso di deprecazione ed esportano lo stesso file LiteRT |
| Output | yolo26n.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 su | Dispositivi Android e iOS, schede Linux integrate, CPU desktop, browser web tramite LiteRT.js e GPU e NPU Intel |
| Runtime | LiteRT: il pacchetto Python ai-edge-litert (versione 2.1.4 o successive), le librerie LiteRT per Android e iOS oppure LiteRT.js |
| Precisione | FP32, 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'esportazione | Linux 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 |
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:
| Pacchetto | Versione richiesta |
|---|---|
| Python | 3.10 o versioni successive |
litert-torch | 0.10.0 o versioni successive |
torch | L'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-litert | 2.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-quantizer | 0.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.
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'from ultralytics import YOLO
# Carica il modello LiteRT esportato
model = YOLO("yolo26n.tflite")
# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")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#
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
format | str | 'litert' | Formato di destinazione del modello esportato, che definisce la compatibilità con i vari ambienti di distribuzione. |
imgsz | int o tuple | 640 | Dimensione 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. |
quantize | int o str | None | Schema 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. |
data | str | None | File 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. |
fraction | float, int o list | 1.0 | Sottoinsieme 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. |
nms | bool, facoltativo | None | Seleziona 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. |
batch | int | 1 | Dimensione del batch del modello esportato, fissata nella forma dell'input. È anche la dimensione del batch usata per la calibrazione. |
device | str | None | L'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.
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:
quantize | Pesi | Attivazioni | Dati di calibrazione | File YOLO26n | Dimensione |
|---|---|---|---|---|---|
non impostato o 32 | FP32 | FP32 | No | yolo26n.tflite | 10.0 MB |
'w8a32' | INT8 | FP32 | No | yolo26n_w8a32.tflite | 2.9 MB |
8 | INT8 | INT8 | Sì | yolo26n_int8.tflite | 3.1 MB |
'w8a16' | INT8 | INT16 | Sì | yolo26n_w8a16.tflite | 3.0 MB |
- Input e output: l'input e gli output restano
float32in 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 layoutnms. 'w8a32': quantizzazione a intervallo dinamico. Non richiede dati di calibrazione e supporta la head senza NMS connms=False; è inoltre la precisione dei modelli ufficiali per dispositivi mobili nelle colonne CPU e GPU di Prestazioni misurate.8e'w8a16': quantizzazione statica. L'esportazione esegue la calibrazione su ogni batch completo dello splitvaldidatao dello split impostato consplit, e mostra un avviso se ci sono meno di 300 immagini. Usafractionper 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=8e'w8a16'di un modello YOLO26 o YOLOv10 usano la head one-to-many e restituiscono predizioni grezze che richiedono NMS, anche connms=False. - FP16: non è disponibile l'esportazione FP16. I delegate GPU di LiteRT eseguono per impostazione predefinita un modello FP32 in precisione dimezzata, quindi
quantize=16non è necessario e genera un errore.
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 predefinito | Output con nms=None | Output con nms=False |
|---|---|---|---|
| Rilevamento | 640 | (1, 84, 8400) | (1, 300, 6) |
| Segmentazione | 640 | (1, 116, 8400) e (1, 32, 160, 160) | (1, 300, 38) e (1, 32, 160, 160) |
| Semantica | 1024 | (1, 19, 1024, 1024), un punteggio per ogni classe e pixel | Come nms=None |
| Profondità | 768 | (1, 1, 768, 768), mappa di profondità | Come nms=None |
| Classificazione | 224 | (1, 1000), probabilità delle classi | Come nms=None |
| Posa | 640 | (1, 56, 8400) | (1, 300, 57): 6 valori del riquadro, poi 17 keypoint x 3 |
| OBB | 1024 | (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 dix1, y1, x2, y2, score, classin pixel dell'input, senza passaggio NMS. Le righe OBB sonocenter 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.
from ultralytics import YOLO
model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="npu") # oppure "xpu"Guide alla distribuzione#
- Plugin Ultralytics YOLO per Flutter: esegue su Android gli export LiteRT
.tflitecon inferenza della fotocamera in tempo reale, predizione su singola immagine e accelerazione GPU. - Pacchetto npm @ultralytics/yolo: esegue nel browser gli export LiteRT
.tflitetramite LiteRT.js, con accelerazione WebGPU e un fallback CPU (WASM). Installalo connpm i @ultralytics/yolo @litertjs/core. - MediaTek Dimensity: distribuzione su dispositivi Android con processori MediaTek, inclusa la NPU.
- Qualcomm QNN e Core ML: i formati per le NPU Snapdragon e per i dispositivi Apple.
- NXP i.MX95 e Coral Edge TPU: formati per questi acceleratori.
- Raspberry Pi: configura Ultralytics sulle schede Raspberry Pi.
- Documentazione LiteRT: integra il runtime nelle applicazioni Android e iOS, oppure nel browser.
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.tflitesul dispositivo. - Prima esportazione dopo una semplice installazione: se la prima esportazione installa un
litert-torchche 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 registraRestart runtime or rerun command for updates to take effecte l'esportazione può non riuscire, conRuntimeError: duplicate registrations for aten.miopen_batch_norm.defaultsu PyTorch 2.15.0. Esegui di nuovo l'esportazione. - FP16:
quantize=16non riesce conquantize=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 conformat='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 conquantize=8, oppure esporta il checkpoint ottimizzato in ONNX o TensorRT. - Head senza NMS con
quantize=8o'w8a16': connms=False, l'esportazione registraLiteRT 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=Trueregistraformat=litert does not support embedded NMS; exporting native outputs for external NMS.e scrive l'output grezzo. - Head senza NMS su altri modelli:
nms=Falserichiede un modello con una head senza NMS, come YOLO26 o YOLOv10. Per altri modelli, ad esempio YOLO11, l'esportazione mostra l'avvisoThis 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=Truenon riesce conargument 'dynamic' is not supported for format='litert'. Esporta di nuovo per modificare la dimensione dell'immagine o del batch. - Calibrazione senza
data: un'esportazionequantize=8o'w8a16'registraINT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'.ed esegue la calibrazione sul piccolo dataset predefinito per l'attività. Passadatacon 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.yamlha 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
quantizescrive lo stesso file, ad esempioyolo26n.tfliteper FP32, indipendentemente daimgsz,batchonms; 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.
| Modello | Attività | dimensione (pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT FP32 (ms) |
|---|---|---|---|---|---|
| YOLO26n | Rilevamento | 640 | 36.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 | Segmentazione | 640 | 50.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 | Semantica | 640 | 45.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 | Profondità | 640 | 66.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 | Classificazione | 224 | 3.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 | Posa | 640 | 39.9 2.0 / 36.5 / 1.4 | 10.0 1.8 / 6.7 / 1.4 | 11.5 3.5 / 4.2 / 3.8 |
| YOLO26n-obb | OBB | 640 | 36.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 Ultralytics0.7.1e gli asset ufficialiv0.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
.tfliteNCHW con input float: il delegate GPU compila l'intero grafo (qui tutte e sette le attività vengono eseguite sulla GPU Adreno) ew8a32non 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 outputIdentity; 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 releasev0.7.0di 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, senzaquantize) compilata sul dispositivo dai runtimelitert-npu-runtime-qualcomme-mediatek2.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 pern, fino a 6 s perx). Gli assetw8a32non 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.
| Modello | Attività | dimensione (pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) |
|---|---|---|---|---|
| YOLO26n | Rilevamento | 640 | 36.6 1.5 / 33.5 / 1.6 | 36.5 3.5 / 28.4 / 4.6 |
| YOLO26n-seg | Segmentazione | 640 | 53.1 1.5 / 45.8 / 5.7 | 51.5 1.6 / 40.1 / 9.9 |
| YOLO26n-sem | Semantica | 640 | 57.2 1.5 / 47.7 / 8.0 | 75.9 1.8 / 63.4 / 10.8 |
| YOLO26n-depth | Profondità | 640 | 75.0 1.6 / 65.1 / 8.3 | 50.1 1.7 / 33.5 / 14.9 |
| YOLO26n-cls | Classificazione | 224 | 6.1 0.3 / 5.5 / 0.3 | 12.1 0.9 / 11.0 / 0.1 |
| YOLO26n-pose | Posa | 640 | 35.2 1.5 / 31.9 / 1.8 | 38.2 3.5 / 29.3 / 5.4 |
| YOLO26n-obb | OBB | 640 | 32.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.
| Modello | Attività | dimensione (pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT w8a32 AOT (ms) |
|---|---|---|---|---|---|
| YOLO26n | Rilevamento | 640 | 30.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 | Segmentazione | 640 | 45.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 | Semantica | 640 | 38.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 | Profondità | 640 | 63.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 | Classificazione | 224 | 3.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 | Posa | 640 | 31.1 1.3 / 28.4 / 1.4 | 18.4 1.6 / 13.0 / 3.8 | 13.5 1.8 / 9.5 / 2.2 |
| YOLO26n-obb | OBB | 640 | 27.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.
| Modello | Attività | dimensione (pixel) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT FP32 (ms) |
|---|---|---|---|---|---|
| YOLO26n | Rilevamento | 640 | 31.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 | Segmentazione | 640 | 77.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 | Semantica | 640 | 81.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 | Profondità | 640 | 111.3 3.4 / 91.1 / 16.8 | 55.3 2.8 / 36.3 / 16.1 | — |
| YOLO26n-cls | Classificazione | 224 | 6.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 | Posa | 640 | 53.9 2.6 / 49.5 / 1.8 | 32.8 2.7 / 26.7 / 3.4 | 16.2 2.9 / 11.1 / 2.3 |
| YOLO26n-obb | OBB | 640 | 49.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.
| Modello | Attività | dimensione (pixel) | CPU w8a32 LiteRT (ms) | CPU w8a32 Intel (ms) | NPU w8a32 Intel (ms) |
|---|---|---|---|---|---|
| YOLO26n | Rilevamento | 640 | 17.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 | Segmentazione | 640 | 24.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 | Semantica | 640 | 25.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 | Profondità | 640 | 31.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 | Classificazione | 224 | 4.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 | Posa | 640 | 20.3 0.8 / 19.0 / 0.5 | 28.6 1.1 / 26.8 / 0.8 | 6.3 0.8 / 4.9 / 0.5 |
| YOLO26n-obb | OBB | 640 | 17.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.
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:tfliteper dispositivi mobili, integrati ed edge etfjsper 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 connms=Falseed è la precisione dei modelli ufficiali Ultralytics per dispositivi mobili su CPU e GPU. Usaquantize=8quando 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 a8. 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
.tflitesul 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
.tflitein 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
.tflitee supporta tutte e sette le attività YOLO26. Esporta conimgsz=640o, per la classificazione, conimgsz=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.