Ultralytics YOLO27: Inscreve-te na lista de espera.
Começar

Exportar modelos YOLO para LiteRT para implementação em dispositivos de periferia e na Web

LiteRT edge deployment framework

LiteRT (abreviatura de ambiente de execução leve) é o ambiente de execução de elevado desempenho da Google para IA no dispositivo. É a nova geração e a nova designação do TensorFlow Lite (TFLite), e utiliza o mesmo formato de modelo .tflite. Com o LiteRT, um único modelo Ultralytics YOLO exportado pode ser implementado em dispositivos móveis, sistemas incorporados, dispositivos de periferia e navegadores — abrangendo tudo o que os formatos de exportação mais antigos tflite e tfjs tratavam separadamente, agora numa única solução.



Assista: Como exportar Ultralytics YOLO26 para Google LiteRT | Implante IA de visão em Android e iOS | IA móvel 📱🚀

O formato de exportação LiteRT otimiza os teus modelos para tarefas como deteção de objetos, segmentação, estimativa de pose e classificação, para que funcionem rapidamente e sem ligação à Internet numa ampla variedade de dispositivos.

Executa hoje YOLO no Android com LiteRT através do plugin oficial para Flutter

O plugin oficial Ultralytics YOLO para Flutter executa exportações LiteRT .tflite no Android sem configuração adicional — inferência de câmara em tempo real, previsão de imagem única, aceleração por GPU e transferência automática de modelos para todas as sete tarefas do YOLO26, incluindo Depth. Consulta o guia MediaTek Dimensity para a implementação no Android, a integração Qualcomm QNN para NPUs Snapdragon e a exportação CoreML para dispositivos Apple.

Tamanhos de entrada oficiais para dispositivos móveis

Exporta modelos de classificação em imgsz=224. Exporta modelos de deteção, segmentação, semântica, profundidade, pose e OBB em imgsz=640. Este padrão 224/640 é partilhado pelos recursos móveis oficiais LiteRT, CoreML e QNN.

Executa hoje YOLO na Web com LiteRT.js através do pacote npm oficial @ultralytics/yolo

O pacote oficial Ultralytics YOLO para NPM executa exportações LiteRT .tflite diretamente no navegador usando LiteRT.js, sem precisar de servidor nem Python, e oferece inferência de webcam em tempo real, previsão de imagem única e aceleração WebGPU (com fallback automático para CPU/WASM) em seis tarefas do YOLO26 (detecção, segmentação, semântica, classificação, pose e OBB). No WebGPU, costuma ser cerca de ~2× mais rápido que o ONNX Runtime Web.

npm i @ultralytics/yolo @litertjs/core

Por que exportar para LiteRT?#

O LiteRT é um framework de código aberto desenvolvido para inferência no dispositivo, também conhecida como computação de borda. Ele oferece aos desenvolvedores ferramentas para executar modelos treinados em dispositivos móveis, embarcados e IoT, computadores tradicionais e, por meio do LiteRT.js, diretamente em navegadores da Web e no Node.js.

Um formato de modelo, todos os destinos:

  • Dispositivos móveis e sistemas incorporados: Android, iOS, Linux incorporado e microcontroladores (MCUs).
  • Aceleradores de periferia: compatível com o Coral Edge TPU para obter aceleração adicional.
  • Navegador e Node.js: O LiteRT.js executa o mesmo modelo .tflite na Web com aceleração WebGPU/WASM, eliminando a necessidade de uma exportação separada para TensorFlow.js.

Principais funcionalidades dos modelos LiteRT#

  • Otimização no dispositivo: Reduz a latência da inferência ao processar dados localmente, aumenta a privacidade ao não transmitir dados pessoais e minimiza o tamanho do modelo para economizar espaço.
  • Suporte a várias plataformas: funciona em Android, iOS, Linux embarcado, microcontroladores e navegadores modernos.
  • Aceleração de hardware: Usa XNNPACK na CPU e aceleração de GPU via OpenCL, Metal e WebGPU. O delegado de GPU é executado em FP16 por padrão para oferecer velocidade adicional.
  • Quantização: Suporta FP32, INT8 estático (quantize=8, pesos int8 + ativações int8), ativação INT16 estática (quantize="w8a16", pesos int8 + ativações int16 para maior precisão) e INT8 dinâmico (quantize="w8a32", pesos int8 + ativações FP32, sem necessidade de dados de calibração) para comprimir modelos e acelerar a inferência com perda mínima de precisão.
  • Suporte a diversas linguagens: compatível com Java/Kotlin, Swift, Objective-C, C++, Python e JavaScript.

Desempenho medido#

Hardware: Xiaomi 17 com 12 GB de memória LPDDR5X e Android 17 / API 37. O Snapdragon 8 Elite Gen 5 de 3 nm (SM8850) tem uma CPU Qualcomm Oryon de 8 núcleos (2 núcleos Prime de até 4.6 GHz e 6 núcleos de desempenho de até 3.62 GHz), GPU Adreno e NPU Hexagon.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetecção64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-segSegmentação64050.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-depthProfundidade64066.8
2.2 / 55.0 / 9.7
21.9
2.1 / 10.1 / 9.8
24.8
4.3 / 6.0 / 14.5
YOLO26n-clsClassificação2243.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
  • Os valores de velocidade são latências de rajada de imagem única — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas com o 0.7.1 do plugin Flutter da Ultralytics e os recursos oficiais v0.7.0 (exportações Ultralytics 8.4.188). A ordem entre CPU/GPU alternou entre tarefas em uma única varredura sequencial. Os registros nativos confirmaram que cada linha da CPU usou LiteRT CPU/XNNPACK e cada linha da GPU delegou o grafo completo ao LiteRT OpenCL (LITERT_CL).
  • A exportação para LiteRT rastreia diretamente o modelo PyTorch, gerando um .tflite NCHW com entrada float — o delegado da GPU compila o grafo inteiro (aqui, todas as sete tarefas são executadas na GPU Adreno) e w8a32 não precisa de dados de calibração. Os consumidores devem consultar os formatos dos tensores e os nomes das assinaturas, em vez de presumir o layout legado NHWC do onnx2tf ou os nomes de saída Identity; empacote os dados RGB diretamente no formato CHW planar ou faça a transposição antes da inferência. As exportações semânticas retornam logits NCHW e exigem argmax de classes no host. Os recursos oficiais para Android estão hospedados na versão v0.7.0 do yolo-flutter-app, e o registro detalhado do benchmark está no documento de desempenho do Flutter.
  • A coluna NPU corresponde ao caminho NPU próprio do LiteRT: uma exportação FP32 (yolo export format=litert, sem quantize), compilada no dispositivo pelos tempos de execução litert-npu-runtime-qualcomm e -mediatek 2.3.0, medida com uma versão de protótipo do plugin Flutter com suporte a NPU (ainda não lançada). O primeiro carregamento inclui essa compilação (cerca de 0.3 s para n, até 6 s para x). Os recursos w8a32 não são totalmente compilados nessas NPUs. O LiteRT informa uma compilação para NPU mesmo quando executa silenciosamente o grafo na GPU; por isso, cada linha da NPU foi comparada com o tempo da GPU; as linhas que usaram o fallback são indicadas por —.
  • Os números correspondentes da NPU Hexagon Snapdragon para os recursos oficiais QNN estão na integração Qualcomm QNN.
  • Compare os resultados da CPU/acelerador da Apple na integração do CoreML.

As varreduras dos dispositivos a seguir usam os mesmos recursos oficiais v0.7.0.

Google Pixel 10#

Hardware: Google Pixel 10 com 12 GB de memória e Android 17 / API 37. O Google Tensor G5 de 3 nm tem uma CPU de 8 núcleos (1 núcleo Prime de até 3.78 GHz, 5 núcleos de desempenho de até 3.05 GHz e 2 núcleos de eficiência de até 2.25 GHz), GPU PowerVR D-Series e TPU Google. As frequências dos núcleos da CPU e o nome do driver da GPU foram lidos no dispositivo de benchmark, pois o Google não os publica nas especificações vinculadas.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
YOLO26nDetecção64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-segSegmentação64053.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-depthProfundidade64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-clsClassificação2246.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

Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.7.1 e os recursos oficiais v0.7.0. A ordem entre CPU/GPU alterna entre tarefas em uma única varredura sequencial. Os registros nativos confirmaram que cada linha da CPU usou LiteRT CPU/XNNPACK e cada linha da GPU delegou o grafo completo ao LiteRT OpenCL (LITERT_CL). O Tensor NPU não tem uma linha LiteRT: o serviço EdgeTPU do Google rejeita aplicativos que não estão na lista de permissões, e o LiteRT passa então a executar o modelo na GPU.

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) com 12 GB de memória e Android 17 / API 37. O Exynos 2600 de 2 nm tem uma CPU Armv9.3 de 10 núcleos (1 núcleo C1-Ultra de até 3.8 GHz, 3 núcleos C1-Pro de desempenho de até 3.26 GHz e 6 núcleos C1-Pro de eficiência de até 2.76 GHz), GPU Xclipse 960 e NPU Samsung.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT w8a32 AOT
(ms)
YOLO26nDetecção64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-segSegmentação64045.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-depthProfundidade64063.5
1.4 / 53.6 / 8.4
37.3
1.4 / 24.6 / 11.3
28.4
2.1 / 12.9 / 13.4
YOLO26n-clsClassificação2243.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

Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.7.1 e os recursos oficiais v0.7.0. A ordem entre CPU/GPU alterna entre tarefas em uma única varredura sequencial. Os registros nativos confirmaram que cada linha da CPU usou LiteRT CPU/XNNPACK e cada linha da GPU delegou o grafo completo ao LiteRT OpenCL (LITERT_CL). A coluna NPU usa os recursos w8a32 compilados antecipadamente para o Exynos 2600 (E9965) com o plugin compilador Samsung do LiteRT. A Samsung não tem um compilador no dispositivo no LiteRT 2.3, e o Google ainda não disponibiliza um tempo de execução para NPU Samsung, por isso essas linhas usaram uma biblioteca de despacho compilada a partir do código-fonte do LiteRT 2.3.

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) com 12 GB de memória LPDDR5X e Android 16 / API 36. O MediaTek Dimensity 9500 de 3 nm (MT6993) tem uma CPU Armv9.3 de 8 núcleos (1 núcleo C1-Ultra de até 4.21 GHz, 3 núcleos C1-Premium de até 3.5 GHz e 4 núcleos C1-Pro de até 2.7 GHz), GPU Mali-G1 Ultra MC12 e NPU MediaTek 990.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetecção64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-segSegmentação64077.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-depthProfundidade640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-clsClassificação2246.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
—

Referência de desempenho: média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.7.1 e os recursos oficiais v0.7.0. A ordem CPU/GPU alterna entre tarefas em uma única execução sequencial. Os registos nativos confirmaram que todas as linhas de CPU usaram LiteRT CPU/XNNPACK e todas as linhas de GPU delegaram o grafo completo ao LiteRT OpenCL (LITERT_CL). Depth e OBB não têm resultados de NPU: o compilador de NPU da MediaTek rejeita as operações exponenciais e trigonométricas, e o LiteRT executa esses grafos na GPU.

Para saberes mais sobre o fluxo de trabalho de implementação no Android e as limitações da NPU, consulta o guia MediaTek Dimensity.

Tarefas suportadas#

A exportação LiteRT oferece suporte às sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com YOLO26, a única família que inclui esses cabeçalhos.

TarefaYOLOv8YOLO11YOLO26
Detetar✅✅✅
Segmentar✅✅✅
Semântica❌❌✅
Profundidade❌❌✅
Classificar✅✅✅
Pose✅✅✅
OBB✅✅✅

Exportar para LiteRT: convertendo seu modelo YOLO#

Você pode melhorar a eficiência da execução no dispositivo e ampliar as opções de implantação convertendo seus modelos para o formato LiteRT.

Instalação#

Para instalar o pacote necessário, executa:

Instalação
# Install the required package for YOLO
pip install ultralytics

Para ver instruções detalhadas e práticas recomendadas, consulte nosso guia de instalação da Ultralytics. Se encontrar dificuldades, consulte nosso guia de problemas comuns.

Suporte à plataforma

A exportação para LiteRT é compatível atualmente com Linux x86_64 e macOS. O próprio modelo .tflite exportado funciona em todas as plataformas compatíveis com LiteRT (dispositivos móveis, embarcados, de borda e navegadores).

Uso#

Todos os modelos YOLO da Ultralytics oferecem suporte à exportação desde o início. O formato LiteRT é compatível com os modos Exportar, Prever e Validar, para que você possa exportar um modelo e, em seguida, carregá-lo para executar inferências ou validar sua precisão localmente.

Exportar
from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporte o modelo para o formato LiteRT
model.export(format="litert", imgsz=640)  # cria 'yolo26n.tflite'; use imgsz=224 para classificação
Exportação quantizada
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# INT8 dinâmico: pesos int8, ativações FP32 - sem necessidade de dados de calibração
model.export(format="litert", quantize="w8a32", imgsz=640)  # cria 'yolo26n_w8a32.tflite'

# INT8 estático: pesos int8 + ativações int8 - requer dados de calibração
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # cria 'yolo26n_int8.tflite'

# w8a16 estático: pesos int8 + ativações int16 (maior precisão) - requer dados de calibração
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # cria 'yolo26n_w8a16.tflite'
Prever
from ultralytics import YOLO

# Carregue o modelo LiteRT exportado
model = YOLO("yolo26n.tflite")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")
Validar
from ultralytics import YOLO

# Carregue o modelo LiteRT exportado
model = YOLO("yolo26n.tflite")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

ArgumentoTipoPadrãoDescrição
formatstr'litert'Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação.
imgszint ou tuple640Tamanho de imagem desejado para a entrada do modelo. Pode ser um inteiro para imagens quadradas ou uma tupla (height, width) para dimensões específicas.
quantizeint ou strNonePrecisão da quantização: 8 (INT8 estático, pesos int8 + ativações int8; requer calibração data/fraction), 'w8a16' (estático, pesos int8 + ativações int16; requer calibração data/fraction), 'w8a32' (INT8 dinâmico, pesos int8 + ativações FP32; sem necessidade de calibração) ou 32/não definido (FP32). FP16 não é exportado separadamente (consulte a observação abaixo). Substitui as flags obsoletas half/int8.
batchint1Especifica o tamanho do lote de inferência do modelo exportado ou o número máximo de imagens que o modelo exportado processará em simultâneo no modo predict.
datastrNoneArquivo YAML do conjunto de dados usado para a calibração INT8; para classificação, em vez disso, informe um diretório do conjunto de dados ou o nome de um conjunto de dados integrado. Se omitido com quantize=8 ou 'w8a16', a Ultralytics seleciona o conjunto de dados de calibração padrão para a tarefa do modelo.
fractionfloat, int ou list1.0Subconjunto de calibração como proporção, número de imagens ou proporções/contagens [train, val, test]. Listas de dois itens deixam test completo, enquanto 0 o ignora.
devicestrNoneEspecifica o dispositivo para a exportação. A exportação LiteRT é executada na CPU (device=cpu).
Precisão FP16

Ao contrário da exportação legada tflite, o LiteRT não exige uma exportação FP16 separada. Um modelo .tflite FP32 é executado em precisão média em tempo de execução ao usar um delegado de GPU (WebGPU, OpenCL, Metal) — esta é a abordagem oficial do LiteRT para inferência FP16.

Para mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

Inferência em CPU e NPU Intel#

Os modelos .tflite exportados são executados em hardware Intel por meio do plugin LiteRT Intel OpenVINO. Passa device=intel:cpu ou device=intel:npu, e o Ultralytics instala ai-edge-litert>=2.3.0 e ai-edge-litert-sdk-intel na primeira utilização. A NPU requer um processador Intel Core Ultra com o driver NPU da Intel instalado.

Prever
from ultralytics import YOLO

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

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.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26nDetecção64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-segSegmentação64024.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-depthProfundidade64031.7
0.9 / 30.2 / 0.5
76.6
0.9 / 75.2 / 0.5
9.1
1.0 / 7.5 / 0.5
YOLO26n-clsClassificação2244.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

Benchmark: Média de 15 chamadas a predict() após 3 aquecimentos em bus.jpg, usando ultralytics 8.4.174 e ai-edge-litert 2.3.0 com exportações w8a32. Cada célula mostra o tempo total, com a divisão entre pré-processamento / inferência / pós-processamento logo abaixo.

Implantação de modelos YOLO LiteRT exportados#

Depois de exportar seu modelo YOLO da Ultralytics para LiteRT, você pode implantá-lo em várias plataformas. A maneira mais rápida de verificá-lo localmente é o método YOLO("yolo26n.tflite") mostrado acima. Para implantá-lo em outros ambientes, consulte os recursos a seguir:

Dispositivos móveis e sistemas embarcados#

  • Android: Guia de início rápido para integrar LiteRT em aplicações Android.
  • iOS: Guia para integrar e implantar modelos LiteRT em aplicações iOS.
  • Linux embarcado e Raspberry Pi: Executa modelos LiteRT em computadores de placa única, opcionalmente acelerados com um Coral Edge TPU.
  • Microcontroladores: Implanta em MCUs com apenas alguns kilobytes de memória — o ambiente de execução principal ocupa aproximadamente 16 KB em um Arm Cortex-M3.

Navegador e Node.js (LiteRT.js)#

  • Visão geral do LiteRT.js: Executa o mesmo modelo .tflite diretamente no navegador com aceleração WebGPU/WASM, eliminando a computação no servidor e mantendo os dados no dispositivo do usuário.
  • Exemplos de ponta a ponta: Exemplos práticos e tutoriais para implementar LiteRT em dispositivos móveis, na borda e na web.

Resumo#

Neste guia, explicámos como exportar modelos Ultralytics YOLO para o formato LiteRT. Ao consolidar a implementação móvel/de borda (anteriormente TFLite) e no navegador (anteriormente TF.js) num único modelo .tflite, o LiteRT torna os teus modelos YOLO menores, mais rápidos e portáteis entre destinos móveis, embarcados, de borda e de navegador.

Para mais detalhes, consulta a documentação oficial do LiteRT.

Perguntas frequentes#

  • Usa a biblioteca Ultralytics para exportar um modelo YOLO para LiteRT (.tflite). Primeiro, instala o pacote:

    pip install ultralytics

    Em seguida, exporta o modelo:

    from ultralytics import YOLO
    
    # Carrega um modelo YOLO26
    model = YOLO("yolo26n.pt")
    
    # Exporte o modelo para o formato LiteRT
    model.export(format="litert", imgsz=640)  # usar imgsz=224 para classificação

    Para usuários da CLI:

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

    Para mais detalhes, consulta o guia de exportação da Ultralytics.

  • LiteRT é o novo nome do TensorFlow Lite — mesmo formato de modelo .tflite, mesma linhagem de ambiente de execução, renomeado pelo Google. Na Ultralytics, o único formato de exportação litert agora abrange os dois casos de uso que antes exigiam formatos separados:

    • O antigo formato tflite → implantação em dispositivos móveis, embarcados e na borda.
    • O antigo formato tfjs → implementação em navegadores e Node.js, agora gerida pelo LiteRT.js, que executa o mesmo ficheiro .tflite.

    Se você tiver um arquivo .tflite existente, poderá carregá-lo diretamente com YOLO("model.tflite"), que o executará pelo backend LiteRT.

  • Sim. Exporta o teu modelo para o formato LiteRT e, em seguida, executa-o num Raspberry Pi para melhorar a velocidade de inferência. Um Coral Edge TPU pode acelerar ainda mais a inferência.

  • Sim. O LiteRT.js executa o mesmo modelo exportado .tflite diretamente em um navegador ou aplicação Node.js, com aceleração WebGPU/WASM. Isso substitui o fluxo de trabalho anterior do TensorFlow.js — não há uma exportação separada para o navegador; basta implantar o modelo LiteRT com o ambiente de execução LiteRT.js.

  • Sim — em tempo de execução. Um modelo LiteRT FP32 é executado automaticamente em FP16 quando roda em um delegado de GPU (WebGPU, OpenCL ou Metal), que é a abordagem oficial do LiteRT. Portanto, não precisas de uma exportação FP16 dedicada; para compactar ainda mais, usa quantização INT8 com quantize=8.

  • Se encontrar erros ao exportar modelos YOLO para LiteRT, algumas soluções comuns são:

    • Verifica a plataforma: a exportação LiteRT é compatível com Linux x86_64 e macOS. Confirma se o teu ambiente corresponde a esses requisitos.
    • Verifica a compatibilidade do pacote: confirma se estás usando uma versão compatível do Ultralytics. Consulta nosso guia de instalação.
    • Problemas de quantização: ao usar quantização INT8, verifica se o caminho do conjunto de dados está especificado corretamente no parâmetro data.

    Para mais dicas de solução de problemas, consulta nosso guia de problemas comuns.

Comentários

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.