Visão geral do LiteRT

O LiteRT é o framework no dispositivo do Google para implantação de ML e IA generativa 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 (antiga TensorFlow Lite) ainda esteja disponível para compatibilidade com versões anteriores, a API CompiledModel é a opção recomendada para desenvolvedores que buscam performance de ponta em aplicativos de IA no dispositivo.

Principais recursos do LiteRT

Simplifique o desenvolvimento com o LiteRT

Seleção automatizada de aceleradores em vez de criação de delegados explícita. Gerenciamento eficiente de buffers de E/S e execução assíncrona para performance superior. Consulte a documentação de inferência no dispositivo.

Melhor performance de GPU da categoria

Desenvolvido pelo ML Drift, agora com suporte a modelos de ML e IA generativa nas APIs de GPUs. Consulte a documentação de aceleração de GPU.

Aceleração unificada de NPU

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

Suporte superior a LLM

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

Amplo suporte a 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 de 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 totalmente no dispositivo em Android, iOS, Web, IoT e em computadores. Independentemente do dispositivo, este é o fluxo de trabalho mais comum, 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 para resolver problemas de machine learning, o que o torna adequado para usuários que exigem um modelo específico ou uma implementação especializada. Os usuários que procuram soluções plug-and-play podem preferir Tarefas do MediaPipe, que oferecem soluções prontas para tarefas comuns de machine learning, como detecção de objetos, classificação de texto e inferência de LLM.

Como receber e preparar o modelo

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

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

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

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

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

• Converta o modelo PyTorch, TensorFlow ou JAX escolhido em um modelo do LiteRT se você optar por não usar um modelo pré-treinado. [USUÁRIO PROFISSIONAL]

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

• Crie seu LLM para otimização adicional usando a API Generativa [USUÁRIO PROFISSIONAL]

  Nossa biblioteca de APIs Generativas oferece elementos básicos integrados do PyTorch para compor modelos de transformadores, como Gemma, TinyLlama e outros, usando abstrações compatíveis com dispositivos móveis, por meio das quais podemos garantir a conversão e a execução de desempenho no nosso ambiente de execução para dispositivos móveis, o LiteRT. Consulte a documentação da API Generativa.

Otimizar [USUÁRIO PROFISSIONAL]

O AI Edge Quantizer para desenvolvedores avançados é uma ferramenta para quantizar modelos convertidos do LiteRT. Ele tem como objetivo facilitar que usuários avançados busquem a performance ideal em modelos exigentes de recursos (por exemplo, modelos de IA generativa).

Consulte mais detalhes na documentação do AI Edge Quantizer.

Integrar o modelo ao app em plataformas de borda

O LiteRT permite executar modelos de ML totalmente no dispositivo com alta performance em plataformas Android, iOS, Web, desktop e IoT.

Use os guias a seguir para integrar um modelo do LiteRT na plataforma de sua preferência:

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 é confiar na inteligência integrada do ambiente de execução. Com a API CompiledModel, o LiteRT simplifica a configuração significativamente 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.

Documentação e suporte adicionais

• Repositório do GitHub de exemplos do LiteRT 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 performance, criação de perfis, relatórios de erros etc.