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.

O LiteRT 2.x contém a API de ambiente de execução mais recente, a API CompiledModel, que melhora a API Interpreter (também conhecida como APIs do TensorFlow Lite), principalmente por meio da aceleração de hardware e da performance geral para aplicativos de ML e IA no dispositivo. A API CompiledModel está em versão Beta e disponível em Kotlin e C++.

Principais recursos do LiteRT

Modelos compatíveis

O LiteRT oferece suporte à conversão simplificada de frameworks Pytorch, TensorFlow e JAX para o formato .tflite ou .litertlm.

Simplifique o desenvolvimento com o LiteRT

Seleção automática de acelerador em vez de criação explícita de delegado. Tempo de execução simples da NPU e distribuição de modelos. Gerenciamento eficiente de buffers de E/S e execução assíncrona para um desempenho superior.

Melhor desempenho de GPU da categoria

Com tecnologia ML Drift, agora compatível com modelos de ML e IA generativa nas APIs de GPUs.

Aceleração unificada da NPU

Acelere seu modelo usando o acesso simplificado à NPU dos principais provedores de chipset.

Suporte simplificado para LLM com LiteRT

Você pode usar o LiteRT-LM, que é alimentado pelo LiteRT. O LiteRT-LM oferece suporte aos LLMs mais recentes e recursos úteis, como multimodalidade, decodificação restrita etc.

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, o que o torna 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 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 otimizar ainda mais 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 ambiente de execução para dispositivos móveis, o LiteRT. Consulte a documentação da API generativa.

Quantização [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).

Para modelos de machine learning e de IA generativa, consulte a documentação de quantização de IA na borda.

Pré-requisitos para começar

• Python 3.10 a 3.12
• Arquivo de modelo .tflite
• Mais detalhes disponíveis na seção da plataforma correspondente

Integrar o modelo ao app em plataformas de borda

É possível implementar seus modelos LiteRT para executar inferências completamente no dispositivo em dispositivos Android, iOS, Web, IoT e desktop. O LiteRT contém APIs para Python, Java e Kotlin para Android, Swift para iOS e C++ para microdispositivos.

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

*Em breve

Exemplo de código Kotlin

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

// Prepare I/O buffers and fill in the data
val inputBuffers = compiledModel.createInputBuffers()
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

val outputBuffers = compiledModel.createOutputBuffers()

// Execute model
compiledModel.run(inputBuffers, outputBuffers)

// Access model output
val output = outputBuffers.get(0).readFloat()

inputBuffers.forEach { it.close() }
outputBuffers.forEach { it.close() }
compiledModel.close()

Exemplo de código em C++

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));
LITERT_ASSIGN_OR_RETURN(auto input_buffers,compiled_model.CreateInputBuffers(signature_index));
LITERT_ASSIGN_OR_RETURN(auto output_buffers,compiled_model.CreateOutputBuffers(signature_index));
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

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

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 tempo de execução. Com as mudanças mais recentes, o LiteRT simplifica bastante a configuração com a capacidade de especificar o backend de destino como uma opção.

O núcleo do LiteRT v2.x é o objeto CompiledModel. Ao carregar um modelo, o LiteRT usa o hardware disponível do sistema e a lógica de prioridade interna para selecionar o back-end ideal sem configuração manual. Consulte o back-end para mais detalhes.

Mais documentação e suporte

App de exemplo do LiteRT v2.x Consulte o app de exemplo de segmentação de imagens do LiteRT

Para usuários atuais do TensorFlow Lite Consulte o guia de migração

Cobertura de operações Operadores compatíveis

Modelos de LLM compatíveis LiteRT Hugging face e API Gen: exemplos

Ferramentas Página de ferramentas do LiteRT: performance, criação de perfis, relatórios de erros etc.