Guia de inferência de LLM para Android

A API LLM Inference permite executar modelos de linguagem grandes (LLMs) completamente no dispositivo para aplicativos Android, que podem ser usados para realizar uma ampla variedade 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 guia de início rápido. Para um exemplo básico de um aplicativo Android que executa a API LLM Inference, consulte o aplicativo de exemplo. Para entender melhor como a API LLM Inference funciona, consulte as seções opções de configuração, conversão de modelo 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 estas etapas para adicionar a API LLM Inference ao seu aplicativo Android. A API LLM Inference é otimizada para dispositivos Android de última geração, como Pixel 8 e Samsung S23 ou versões 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 esta dependência ao arquivo build.gradle do seu app Android:

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

Fazer o download de um modelo

Faça o download do Gemma-3 1B em um formato quantizado de 4 bits da 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 básicas de configuração:

// 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 única resposta gerada.

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 variedade de recursos de IA generativa no dispositivo, confira o app Google AI Edge Gallery.

A Google AI Edge Gallery é um aplicativo Android de código aberto que funciona como um playground interativo para desenvolvedores. Ele mostra:

• Exemplos práticos de uso da API LLM Inference para várias tarefas, incluindo:
  • Perguntar à 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 de formato livre para analisar casos de uso de LLM de uma única interação.
  • Chat de IA: participe de conversas multiturno.
• A capacidade de descobrir, baixar e testar vários modelos otimizados para LiteRT da comunidade LiteRT do Hugging Face e lançamentos oficiais do Google (por exemplo, Gemma 3N).
• Comparativos de mercado de desempenho em tempo real no dispositivo para diferentes modelos (tempo até o primeiro token, velocidade de decodificação etc.).
• Como importar e testar seus próprios modelos personalizados de .litertlm ou .task.

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 baixe o app no repositório do GitHub da Google AI Edge Gallery.

Opções de configuração

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

Comandos multimodais

As APIs Android de inferência de LLM oferecem suporte a comandos multimodais com modelos que aceitam entradas de texto, imagem e áudio. Com a multimodalidade ativada, os usuários podem incluir uma combinação de imagens e texto ou áudio e texto nos comandos.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 eficaz da família Gemma-3n.
• Gemma-3n E4B: um modelo 4B eficaz da família Gemma-3n.

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

Siga as etapas abaixo para ativar a entrada de imagem ou áudio na API LLM Inference.

Entrada de imagem

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 à API LLM Inference:

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 de visão na API LLM Inference, defina a opção de configuração EnableVisionModality como true nas opções de gráfico:

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

Defina o máximo de 10 imagens por sessão.

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

Este é 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();
}

Entrada de áudio

Ativar o suporte de áudio em LlmInferenceOptions

val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()

Ativar o suporte de áudio em sessionOptions

    val sessionOptions =  LlmInferenceSessionOptions.builder()
      ...
      .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
      .build()

Enviar dados de áudio durante a inferência. Observação: o áudio precisa ser mono e estar no formato .wav.

val audioData: ByteArray = ...
inferenceEngine.llmInferenceSession.addAudio(audioData)

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

val audioData: ByteArray = ...
val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()
val sessionOptions =  LlmInferenceSessionOptions.builder()
  ...
  .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
  .build()

LlmInference.createFromOptions(context, inferenceOptions).use { llmInference ->
  LlmInferenceSession.createFromOptions(llmInference, sessionOptions).use { session ->
    session.addQueryChunk("Transcribe the following speech segment:")
    session.addAudio(audioData)
    val result = session.generateResponse()
  }
}

Personalização da LoRA

A API LLM Inference oferece suporte ao ajuste de LoRA (Low-Rank Adaptation) usando a biblioteca PEFT (Parameter-Efficient Fine-Tuning). O ajuste do LoRA personaliza o comportamento dos LLMs com 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 todo o modelo novamente.

A API LLM Inference permite adicionar 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 de base precisa estar no formato safetensors para criar ponderações de LoRA. Depois do treinamento LoRA, é possível converter os modelos para o formato FlatBuffers para execução no MediaPipe.

Preparar ponderações da LoRA

Use o guia LoRA Methods da PEFT para treinar um modelo LoRA refinado no seu próprio conjunto de dados.

A API LLM Inference 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 refinado estarão disponíveis em adapter_model.safetensors. O arquivo safetensors é o checkpoint do LoRA usado durante a conversão do modelo.

Conversão de modelos

Use o pacote Python do MediaPipe para converter os pesos do modelo no formato Flatbuffer. O ConversionConfig especifica as opções de modelo de base e as opções adicionais de 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 de base e outro para o modelo LoRA.

Inferência de modelo LoRA

O Android é compatível com LoRA estático durante a inicialização. Para carregar um modelo LoRA, especifique o caminho do modelo LoRA e o LLM de 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 LoRA, use os mesmos métodos generateResponse() ou generateResponseAsync() do modelo de base.