Visão geral do LiteRT Next

O LiteRT Next é um novo conjunto de APIs que melhora o LiteRT, principalmente em termos de aceleração de hardware e desempenho para aplicativos de ML e IA no dispositivo. As APIs são uma versão Alfa e estão disponíveis em Kotlin e C++.

A API LiteRT Next Compiled Model é baseada na API TensorFlow Lite Interpreter e simplifica o processo de carregamento e execução do modelo para o aprendizado de máquina no dispositivo. As novas APIs oferecem uma maneira simplificada de usar a aceleração de hardware, eliminando a necessidade de lidar com FlatBuffers de modelo, interoperabilidade de buffer de E/S e delegados. As APIs LiteRT Next não são compatíveis com as APIs LiteRT. Para usar os recursos do LiteRT Next, consulte o guia Começar a usar.

Para exemplos de implementações do LiteRT Next, consulte os seguintes aplicativos de demonstração:

Guia de início rápido

A execução de inferência com as APIs LiteRT Next envolve as seguintes etapas principais:

  1. Carregue um modelo compatível.
  2. Aloque os buffers de tensor de entrada e saída.
  3. Invocar o modelo compilado.
  4. Leia as inferências em um buffer de saída.

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

C++

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));

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

// Fill the first input
float input_values[] = { /* your data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_values, /*size*/));

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

// Read the output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

Kotlin

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

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

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

Para saber mais, consulte os guias Primeiros passos com o Kotlin e Primeiros passos com o C++.

Principais recursos

O LiteRT Next contém os seguintes benefícios e recursos principais:

  • Nova API LiteRT: simplifique o desenvolvimento com a seleção de acelerador automatizado, execução assíncrona verdadeira e processamento de buffer de E/S eficiente.
  • Melhor desempenho de GPU da categoria: use a aceleração de GPU de última geração para ML no dispositivo. A nova interoperabilidade de buffer permite a cópia zero e minimiza a latência em vários tipos de buffer de GPU.
  • Supremacia na inferência de IA generativa: ative a integração mais simples com a melhor performance para modelos de IA generativa.
  • Aceleração unificada de NPU: ofereça acesso perfeito às NPUs dos principais fornecedores de chipsets com uma experiência consistente para desenvolvedores. A aceleração do NPU do LiteRT está disponível em um programa de acesso antecipado.

Principais melhorias

O LiteRT Next (API de modelo compilado) contém as seguintes melhorias importantes no LiteRT (API de interpretador do TFLite). Para conferir um guia completo de configuração do aplicativo com o LiteRT Next, consulte o guia Primeiros passos.

  • Uso do acelerador: a execução de modelos na GPU com o LiteRT requer a criação explícita de delegados, chamadas de função e modificações de gráfico. Com o LiteRT Next, basta especificar o acelerador.
  • Interoperabilidade de buffer de hardware nativo: o LiteRT não oferece a opção de buffers e força todos os dados pela memória da CPU. Com o LiteRT Next, é possível transmitir buffers de hardware do Android (AHWBs), buffers do OpenCL, buffers do OpenGL ou outros buffers especializados.
  • Execução assíncrona: o LiteRT Next vem com uma API assíncrona redesenhada, oferecendo um mecanismo assíncrono verdadeiro baseado em cercas de sincronização. Isso permite tempos de execução mais rápidos no geral pelo uso de hardwares diversos, como CPUs, GPUs, CPUs e NPUs, para tarefas diferentes.
  • Carregamento de modelo: o LiteRT Next não exige uma etapa de builder separada ao carregar um modelo.