Guia de inferência de LLM para Android

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) totalmente no dispositivo para aplicativos Android, que podem ser usados para realizar uma ampla gama de tarefas, como gerar texto, recuperar informações em linguagem natural e resumir documentos. A tarefa oferece suporte integrado a vários modelos de linguagem grandes de texto para texto. Assim, você pode aplicar os modelos de IA generativa mais recentes no dispositivo aos seus apps Android.

Para adicionar rapidamente a API LLM Inference ao seu aplicativo Android, siga o Início rápido. Para conferir um exemplo básico de um app Android que executa a API LLM Inference, consulte o app de exemplo. Para entender melhor como a API LLM Inference funciona, consulte as seções opções de configuração, conversão de modelos e ajuste de LoRA.

Confira essa tarefa em ação com a demonstração do MediaPipe Studio. Para mais informações sobre os recursos, modelos e opções de configuração dessa tarefa, consulte a Visão geral.

Guia de início rápido

Siga as etapas abaixo para adicionar a API LLM Inference ao seu app Android. A API de inferência de LLM é otimizada para dispositivos Android avançados, como Pixel 8 e Samsung S23 ou mais recentes, e não oferece suporte confiável a emuladores de dispositivos.

Adicionar dependências

A API LLM Inference usa a biblioteca com.google.mediapipe:tasks-genai. Adicione essa dependência ao arquivo build.gradle do app Android:

dependencies {
    implementation 'com.google.mediapipe:tasks-genai:0.10.24'
}

Fazer o download de um modelo

Faça o download do Gemma-3 1B em um formato quantizado de 4 bits no Hugging Face. Para mais informações sobre os modelos disponíveis, consulte a documentação de modelos.

Envie o conteúdo da pasta output_path para o dispositivo Android.

$ adb shell rm -r /data/local/tmp/llm/ # Remove any previously loaded models
$ adb shell mkdir -p /data/local/tmp/llm/
$ adb push output_path /data/local/tmp/llm/model_version.task

Inicializar a tarefa

Inicialize a tarefa com opções de configuração básicas:

// Set the configuration options for the LLM Inference task
val taskOptions = LlmInferenceOptions.builder()
        .setModelPath('/data/local/tmp/llm/model_version.task')
        .setMaxTopK(64)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, taskOptions)

Executar a tarefa

Use o método generateResponse() para gerar uma resposta de texto. Isso produz uma resposta gerada única.

val result = llmInference.generateResponse(inputPrompt)
logger.atInfo().log("result: $result")

Para fazer streaming da resposta, use o método generateResponseAsync().

val options = LlmInference.LlmInferenceOptions.builder()
  ...
  .setResultListener { partialResult, done ->
    logger.atInfo().log("partial result: $partialResult")
  }
  .build()

llmInference.generateResponseAsync(inputPrompt)

Exemplo de aplicativo

Para conferir as APIs de inferência de LLM em ação e conhecer uma ampla gama de recursos de IA generativa no dispositivo, confira o app Galeria de IA do Google Edge.

A Galeria de IA do Google é um aplicativo Android de código aberto que serve como um ambiente interativo para desenvolvedores. Ele mostra:

• Exemplos práticos de uso da API LLM Inference para várias tarefas, incluindo:
  • Perguntar sobre uma imagem: faça upload de uma imagem e faça perguntas sobre ela. Receba descrições, resolva problemas ou identifique objetos.
  • Laboratório de comandos: resuma, reescreva, gere código ou use comandos livres para conferir casos de uso de LLM de uma única etapa.
  • Chat de IA: converse com o Google Assistente.
• A capacidade de descobrir, fazer o download e testar vários modelos otimizados para LiteRT da comunidade do Hugging Face LiteRT e lançamentos oficiais do Google (por exemplo, Gemma 3N).
• Comparativos de desempenho no dispositivo em tempo real para diferentes modelos (tempo para o primeiro token, velocidade de decodificação etc.).
• Como importar e testar seus próprios modelos .task personalizados.

Este app é um recurso para entender a implementação prática da API LLM Inference e o potencial da IA generativa no dispositivo. Confira o código-fonte e faça o download do app no repositório do GitHub da Galeria de IA de borda do Google.

Opções de configuração

Use as opções de configuração a seguir para configurar um app Android:

Comandos multimodais

As APIs Android da API de inferência de LLM oferecem suporte a comandos multimodais com modelos que aceitam entradas de texto e imagem. Com a multimodalidade ativada, os usuários podem incluir uma combinação de imagens e texto nos comandos, e o LLM fornece uma resposta de texto.

Para começar, use uma variante compatível com o MediaPipe do Gemma 3n:

• Gemma-3n E2B: um modelo 2B da família Gemma-3n.
• Gemma-3n E4B: um modelo 4B da família Gemma-3n.

Para mais informações, consulte a documentação do Gemma-3n.

Para fornecer imagens em um comando, converta as imagens ou frames de entrada em um objeto com.google.mediapipe.framework.image.MPImage antes de transmiti-lo para a API de inferência LLM:

import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage

// Convert the input Bitmap object to an MPImage object to run inference
val mpImage = BitmapImageBuilder(image).build()

Para ativar o suporte à visão para a API LLM Inference, defina a opção de configuração EnableVisionModality como true nas opções do gráfico:

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    ...
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

O Gemma-3n aceita no máximo uma imagem por sessão. Portanto, defina MaxNumImages como 1.

LlmInferenceOptions options = LlmInferenceOptions.builder()
  ...
  .setMaxNumImages(1)
  .build();

Confira a seguir um exemplo de implementação da API LLM Inference configurada para processar entradas de visão e texto:

MPImage image = getImageFromAsset(BURGER_IMAGE);

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    .setTopK(10)
    .setTemperature(0.4f)
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

try (LlmInference llmInference =
    LlmInference.createFromOptions(ApplicationProvider.getApplicationContext(), options);
  LlmInferenceSession session =
    LlmInferenceSession.createFromOptions(llmInference, sessionOptions)) {
  session.addQueryChunk("Describe the objects in the image.");
  session.addImage(image);
  String result = session.generateResponse();
}

Personalização da LoRA

A API Inference LLM oferece suporte ao ajuste da LoRA (adaptação de classificação baixa) usando a biblioteca PEFT (ajuste fino de eficiência de parâmetros). O ajuste de LoRA personaliza o comportamento dos LLMs por meio de um processo de treinamento econômico, criando um pequeno conjunto de pesos treináveis com base em novos dados de treinamento em vez de treinar o modelo inteiro novamente.

A API de inferência LLM oferece suporte à adição de pesos de LoRA às camadas de atenção dos modelos Gemma-2 2B, Gemma 2B e Phi-2. Faça o download do modelo no formato safetensors.

O modelo base precisa estar no formato safetensors para criar pesos de LoRA. Após o treinamento do LoRA, você pode converter os modelos no formato FlatBuffers para execução no MediaPipe.

Preparar pesos da LoRA

Use o guia Métodos LoRA do PEFT para treinar um modelo LoRA ajustado no seu conjunto de dados.

A API de inferência de LLM só oferece suporte a LoRA em camadas de atenção. Portanto, especifique apenas as camadas de atenção em LoraConfig:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Depois de treinar no conjunto de dados preparado e salvar o modelo, os pesos do modelo LoRA ajustados estarão disponíveis em adapter_model.safetensors. O arquivo safetensors é o ponto de verificação do LoRA usado durante a conversão do modelo.

Conversão de modelos

Use o pacote MediaPipe Python para converter os pesos do modelo no formato Flatbuffer. O ConversionConfig especifica as opções de modelo básico e as opções adicionais do LoRA.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_FILE,
)

converter.convert_checkpoint(config)

O conversor vai produzir dois arquivos Flatbuffer, um para o modelo base e outro para o modelo LoRA.

Inferência de modelo LoRA

O Android oferece suporte a LoRA estático durante a inicialização. Para carregar um modelo LoRA, especifique o caminho do modelo LoRA e o LLM base.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath(BASE_MODEL_PATH)
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath(LORA_MODEL_PATH)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Para executar a inferência de LLM com o LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo base.