Guía de inferencia de LLM para Android

La API de LLM Inference te permite ejecutar modelos de lenguaje grandes (LLM) completamente en el dispositivo para aplicaciones para Android, que puedes usar para realizar una amplia variedad de tareas, como generar texto, recuperar información en forma de lenguaje natural y resumir documentos. La tarea proporciona compatibilidad integrada con varios modelos grandes de lenguaje de texto a texto, de modo que puedas aplicar los modelos de IA generativa más recientes en el dispositivo a tus apps para Android.

Para agregar rápidamente la API de LLM Inference a tu aplicación para Android, sigue la Guía de inicio rápido. Para ver un ejemplo básico de una aplicación para Android que ejecuta la API de LLM Inference, consulta la aplicación de ejemplo. Para obtener una explicación más detallada del funcionamiento de la API de LLM Inference, consulta las secciones opciones de configuración, conversión de modelos y ajuste de LoRA.

Puedes ver esta tarea en acción con la demo de MediaPipe Studio. Para obtener más información sobre las funciones, los modelos y las opciones de configuración de esta tarea, consulta la descripción general.

Guía de inicio rápido

Sigue los pasos que se indican a continuación para agregar la API de LLM Inference a tu aplicación para Android. La API de LLM Inference está optimizada para dispositivos Android de alta gama, como Pixel 8 y Samsung S23 o versiones posteriores, y no es compatible de forma confiable con emuladores de dispositivos.

Cómo agregar dependencias

La API de LLM Inference usa la biblioteca com.google.mediapipe:tasks-genai. Agrega esta dependencia al archivo build.gradle de tu app para Android:

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

En el caso de los dispositivos con Android 12 (nivel de API 31) o versiones posteriores, agrega la dependencia de la biblioteca nativa de OpenCL. Para obtener más información, consulta la documentación sobre la etiqueta uses-native-library.

Agrega las siguientes etiquetas uses-native-library al archivo 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"/>

Descarga un modelo

Descarga Gemma-3 1B en un formato cuantificado de 4 bits desde Hugging Face. Para obtener más información sobre los modelos disponibles, consulta la documentación de los modelos.

Envía el contenido de la carpeta output_path al 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

Inicializa la tarea

Inicializa la tarea con opciones de configuración 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)

Ejecuta la tarea

Usa el método generateResponse() para generar una respuesta de texto. Esto produce una respuesta generada única.

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

Para transmitir la respuesta, usa el método generateResponseAsync().

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

llmInference.generateResponseAsync(inputPrompt)

Aplicación de ejemplo

La aplicación de ejemplo es un ejemplo de una app de generación de texto básica para Android que usa la API de inferencia de LLM. Puedes usar la app como punto de partida para tu propia app para Android o consultarla cuando modifiques una app existente. El código de ejemplo se aloja en GitHub.

Clona el repositorio de git con el siguiente comando:

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

Después de crear una versión local del código de ejemplo, puedes importar el proyecto a Android Studio y ejecutar la app. Para obtener más información, consulta la Guía de configuración para Android.

Opciones de configuración

Usa las siguientes opciones de configuración para configurar una app para Android:

Conversión de modelos

La API de inferencia de LLM es compatible con los siguientes tipos de modelos, algunos de los cuales requieren conversión de modelos. Usa la tabla para identificar el método de pasos necesarios para tu modelo.

Para obtener información sobre cómo convertir otros modelos, consulta la sección Conversión de modelos.

Personalización de LoRA

La API de Inference de LLM admite el ajuste de LoRA (adaptación de clasificación baja) con la biblioteca PEFT (ajuste fino eficiente en parámetros). El ajuste de LoRA personaliza el comportamiento de los LLM a través de un proceso de entrenamiento rentable, lo que crea un pequeño conjunto de pesos entrenables basados en datos de entrenamiento nuevos en lugar de volver a entrenar todo el modelo.

La API de inferencia de LLM admite la adición de ponderaciones de LoRA a las capas de atención de los modelos Gemma-2 2B, Gemma 2B y Phi-2. Descarga el modelo en formato safetensors.

El modelo de base debe estar en formato safetensors para crear pesos de LoRA. Después del entrenamiento de LoRA, puedes convertir los modelos al formato FlatBuffers para ejecutarlos en MediaPipe.

Prepara los pesos de LoRA

Usa la guía de métodos LoRA de PEFT para entrenar un modelo LoRA ajustado en tu propio conjunto de datos.

La API de LLM Inference solo admite LoRA en las capas de atención, por lo que solo debes especificar las capas de atención en 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"],
)

Después de entrenar el conjunto de datos preparado y guardar el modelo, los pesos del modelo LoRA ajustados están disponibles en adapter_model.safetensors. El archivo safetensors es el punto de control de LoRA que se usa durante la conversión de modelos.

Conversión de modelos

Usa el paquete de Python de MediaPipe para convertir las ponderaciones del modelo en el formato Flatbuffer. ConversionConfig especifica las opciones del modelo base junto con las opciones adicionales 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)

El convertidor producirá dos archivos Flatbuffer, uno para el modelo base y otro para el modelo LoRA.

Inferencia de modelos de LoRA

Android admite LoRA estático durante la inicialización. Para cargar un modelo de LoRA, especifica la ruta de acceso del modelo de LoRA y el 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 ejecutar la inferencia de LLM con LoRA, usa los mismos métodos generateResponse() o generateResponseAsync() que el modelo base.