Visão geral do LiteRT

O LiteRT é o framework no dispositivo do Google para implantação de ML e GenAI de alta performance em plataformas de borda, usando conversão, ambiente de execução e otimização eficientes.

A versão mais recente do LiteRT 2.x apresenta a API CompiledModel, uma interface de ambiente de execução moderna projetada para maximizar a aceleração de hardware. Embora a API Interpreter (antes TensorFlow Lite) ainda esteja disponível para compatibilidade com versões anteriores, a API CompiledModel é a opção recomendada para desenvolvedores que buscam desempenho de ponta em aplicativos de IA no dispositivo.

Principais recursos do LiteRT

Simplifique o desenvolvimento com o LiteRT

Seleção automática de acelerador x criação explícita de delegado. Tratamento eficiente de buffers de E/S e execução assíncrona para um desempenho superior. Consulte a documentação de inferência no dispositivo.

Melhor desempenho de GPU da categoria

Com tecnologia ML Drift, agora compatível com modelos de ML e IA generativa nas APIs de GPUs. Consulte a documentação sobre aceleração de GPU.

Aceleração unificada da NPU

Acelere seu modelo usando o acesso simplificado à NPU dos principais provedores de chipset. Consulte a documentação sobre aceleração de NPU.

Suporte superior para LLM

O LiteRT oferece implantação de alto desempenho para modelos de IA generativa em plataformas móveis, de computador e da Web. Consulte a documentação de implantação da IA generativa.

Ampla compatibilidade com frameworks de ML

O LiteRT oferece suporte à conversão simplificada de frameworks PyTorch, TensorFlow e JAX para o formato .tflite ou .litertlm. Consulte a documentação sobre conversão de modelos.

Começar a usar a API CompiledModel

• Para modelos de ML clássicos, consulte os seguintes apps de demonstração.

  • App Kotlin de segmentação de imagens: inferência de CPU/GPU/NPU.
  • App C++ de segmentação de imagens: inferência de CPU/GPU/NPU com execução assíncrona.

• Para modelos de IA generativa, consulte os seguintes apps de demonstração:

  • App C++ de similaridade semântica EmbeddingGemma: inferência de CPU/GPU/NPU.

Fluxo de trabalho de desenvolvimento

O LiteRT executa inferências completamente no dispositivo em Android, iOS, Web, IoT e em computadores desktop/notebooks. Independente do dispositivo, o fluxo de trabalho mais comum é o seguinte, com links para mais instruções.

Identificar a solução mais adequada para o desafio de ML

O LiteRT oferece aos usuários um alto nível de flexibilidade e personalização ao resolver problemas de machine learning, sendo uma boa opção para quem precisa de um modelo específico ou de uma implementação especializada. Os usuários que procuram soluções plug-and-play podem preferir o MediaPipe Tasks, que oferece soluções prontas para tarefas comuns de machine learning, como detecção de objetos, classificação de texto e inferência de LLM.

Obter e preparar o modelo

Um modelo do LiteRT é representado em um formato portátil eficiente conhecido como FlatBuffers, que usa a extensão de arquivo .tflite.

É possível conseguir um modelo do LiteRT das seguintes maneiras:

• Receba um modelo pré-treinado para cargas de trabalho de ML conhecidas, como segmentação de imagens, detecção de objetos etc.

  A abordagem mais simples é usar um modelo LiteRT já no formato .tflite. Esses modelos não exigem etapas de conversão adicionais.

  Tipo de modelo	Origem do modelo pré-treinado
  ML clássico (formato .tflite)	Acesse Kaggle ou HuggingFace .Por exemplo, modelos de segmentação de imagem e app de exemplo.
  IA generativa (formato .litertlm)	Página do Hugging Face do LiteRT Por exemplo, Família Gemma

• Converta o modelo escolhido do PyTorch, TensorFlow ou JAX em um modelo do LiteRT se você não quiser usar um modelo pré-treinado. [PRO USER]

  Framework do modelo	Modelos de amostra	Ferramenta de conversão
  Pytorch	Hugging Face Torchvision	Link
  TensorFlow	Modelos do Kaggle Hugging Face	Link
  Jax	Hugging Face	Link

• Crie seu LLM para mais otimizações usando a API Generativa [USUÁRIO PRO]

  Nossa biblioteca de API Generativa oferece blocos de construção integrados do PyTorch para criar modelos Transformer, como Gemma, TinyLlama e outros usando abstrações compatíveis com dispositivos móveis. Assim, podemos garantir a conversão e a execução eficiente no nosso tempo de execução para dispositivos móveis, o LiteRT. Consulte a documentação da API generativa.

Otimizar [USUÁRIO PRO]

O AI Edge Quantizer para desenvolvedores avançados é uma ferramenta para quantizar modelos LiteRT convertidos. O objetivo é facilitar que usuários avançados busquem o desempenho ideal em modelos que exigem muitos recursos (por exemplo, modelos de IA generativa).

Confira mais detalhes na documentação do quantizador de borda de IA.

Integrar o modelo ao app em plataformas de borda

Com o LiteRT, é possível executar modelos de ML totalmente no dispositivo com alto desempenho em plataformas Android, iOS, Web, desktop e IoT.

Use os guias a seguir para integrar um modelo LiteRT na sua plataforma preferida:

Os snippets de código a seguir mostram uma implementação básica em Kotlin e C++.

// Load model and initialize runtime
val compiledModel = CompiledModel.create(
    "/path/to/mymodel.tflite",
    CompiledModel.Options(Accelerator.CPU))

// Preallocate input/output buffers
val inputBuffers = compiledModel.createInputBuffers()
val outputBuffers = compiledModel.createOutputBuffers()

// Fill the input buffer
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

// Invoke
compiledModel.run(inputBuffers, outputBuffers)

// Read the output
val output = outputBuffers.get(0).readFloat()

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto env, GetEnvironment());
LITERT_ASSIGN_OR_RETURN(auto options, GetOptions());
LITERT_ASSIGN_OR_RETURN(
    auto compiled_model,
    CompiledModel::Create(env, "/path/to/mymodel.tflite", options));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers,compiled_model.CreateInputBuffers(signature_index));
LITERT_ASSIGN_OR_RETURN(auto output_buffers,compiled_model.CreateOutputBuffers(signature_index));

// Fill the input buffer
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

// Invoke
LITERT_ABORT_IF_ERROR(compiled_model.Run(signature_index, input_buffers, output_buffers));

// Read the output
LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

Escolher um back-end

A maneira mais simples de incorporar back-ends no LiteRT é usar a inteligência integrada do tempo de execução. Com a API CompiledModel, o LiteRT simplifica bastante a configuração com a capacidade de especificar o back-end de destino como uma opção. Consulte o guia de inferência no dispositivo para mais detalhes.

Mais documentação e suporte

• Repositório do GitHub LiteRT-Samples para mais apps de exemplo do LiteRT.

• Para usuários atuais do TensorFlow Lite, consulte o guia de migração.

• Página de ferramentas do LiteRT para desempenho, criação de perfis, relatórios de erros etc.