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 aplicativo 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 de última geração, como Pixel 8 e Samsung S23 ou mais recente, 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.22'
}

Para dispositivos com o Android 12 (API 31) ou mais recente, adicione a dependência de biblioteca OpenCL nativa. Para mais informações, consulte a documentação da tag uses-native-library.

Adicione as seguintes tags uses-native-library ao arquivo AndroidManifest.xml:

<uses-native-library android:name="libOpenCL.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false"/>

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

O aplicativo de exemplo é um exemplo de app básico de geração de texto para Android, usando a API de inferência de LLM. Você pode usar o app como ponto de partida para seu próprio app Android ou se referir a ele ao modificar um app existente. O código de exemplo está hospedado no GitHub.

Clone o repositório do Git usando o seguinte comando:

git clone https://github.com/google-ai-edge/mediapipe-samples

Depois de criar uma versão local do código de exemplo, você pode importar o projeto para o Android Studio e executar o app. Para mais informações, consulte o Guia de configuração para Android.

Opções de configuração

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

Conversão de modelos

A API LLM Inference é compatível com os seguintes tipos de modelos, alguns dos quais exigem conversão de modelo. Use a tabela para identificar o método de etapas necessário para seu modelo.

Para saber como converter outros modelos, consulte a seção Conversão de modelos.

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 do 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.