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 de Android, que puedes usar para realizar una amplia variedad de tareas, como generar texto, recuperar información en formato de lenguaje natural y resumir documentos. La tarea proporciona compatibilidad integrada con varios modelos de lenguaje grandes de texto a texto, por lo que puedes aplicar los modelos de IA generativa en el dispositivo más recientes 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 comprender mejor cómo funciona la API de LLM Inference, consulta las secciones sobre opciones de configuración, conversión de modelos y ajuste de LoRA.

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

Guía de inicio rápido

Sigue estos pasos 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 el Pixel 8 y el Samsung S23 o modelos posteriores, y no admite de forma confiable los 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.27'
}

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

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 sola respuesta generada.

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

Para ver las APIs de LLM Inference en acción y explorar una amplia gama de capacidades de IA generativa integradas en el dispositivo, consulta la app de Google AI Edge Gallery.

Google AI Edge Gallery es una aplicación de Android de código abierto que funciona como un espacio de pruebas interactivo para desarrolladores. En ella, se muestran los siguientes elementos:

• Ejemplos prácticos del uso de la API de LLM Inference para diversas tareas, incluidas las siguientes:
  • Pregúntale a la imagen: Sube una imagen y haz preguntas sobre ella. Obtener descripciones, resolver problemas o identificar objetos
  • Prompt Lab: Resume, reescribe, genera código o usa instrucciones de formato libre para explorar casos de uso de LLM de un solo turno.
  • Chat con IA: Participa en conversaciones de varios turnos.
• La capacidad de descubrir, descargar y experimentar con una variedad de modelos optimizados para LiteRT de la comunidad de LiteRT de Hugging Face y los lanzamientos oficiales de Google (p. ej., Gemma 3N)
• Comparativas de rendimiento en tiempo real en el dispositivo para diferentes modelos (tiempo hasta el primer token, velocidad de decodificación, etcétera).
• Cómo importar y probar tus propios modelos personalizados de .litertlm o .task

Esta app es un recurso para comprender la implementación práctica de la API de LLM Inference y el potencial de la IA generativa integrada en el dispositivo. Explora el código fuente y descarga la app desde el repositorio de GitHub de Google AI Edge Gallery.

Opciones de configuración

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

Instrucciones multimodales

Las APIs de Android de la API de LLM Inference admiten instrucciones multimodales con modelos que aceptan entradas de texto, imagen y audio. Con la multimodalidad habilitada, los usuarios pueden incluir una combinación de imágenes y texto, o audio y texto en sus instrucciones.Luego, el LLM proporciona una respuesta de texto.

Para comenzar, usa una variante de Gemma 3n compatible con MediaPipe:

• Gemma-3n E2B: Un modelo eficaz de 2B de la familia Gemma-3n.
• Gemma-3n E4B: Un modelo eficaz de 4B de la familia Gemma-3n.

Para obtener más información, consulta la documentación de Gemma-3n.

Sigue los pasos que se indican a continuación para habilitar la entrada de imágenes o audio para la API de LLM Inference.

entrada de imagen

Para proporcionar imágenes dentro de una instrucción, convierte las imágenes o los fotogramas de entrada en un objeto com.google.mediapipe.framework.image.MPImage antes de pasarlo a la API de 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 habilitar la compatibilidad con la visión en la API de LLM Inference, establece la opción de configuración EnableVisionModality en true dentro de las opciones de Graph:

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

Establece un máximo de 10 imágenes por sesión.

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

A continuación, se muestra un ejemplo de implementación de la API de LLM Inference configurada para controlar entradas de texto y visión:

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 audio

Habilita la compatibilidad con audio en LlmInferenceOptions

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

Habilita la compatibilidad con audio en sessionOptions

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

Envía datos de audio durante la inferencia. Nota: El audio debe tener formato de canal mono como .wav

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

A continuación, se muestra un ejemplo de implementación de la API de LLM Inference configurada para controlar entradas de audio y 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()
  }
}

Personalización de LoRA

La API de LLM Inference admite el ajuste de LoRA (adaptación de bajo rango) con la biblioteca PEFT (ajuste eficiente de 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 LLM Inference admite la adición de pesos 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 base debe tener el 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 LoRA Methods de PEFT para entrenar un modelo de 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 modelo con el conjunto de datos preparado y guardarlo, los pesos del modelo LoRA ajustado están disponibles en adapter_model.safetensors. El archivo safetensors es el punto de control de LoRA que se usa durante la conversión del modelo.

Conversión de modelos

Usa el paquete de Python de MediaPipe para convertir los pesos del modelo al formato Flatbuffer. El parámetro 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 conversor producirá dos archivos FlatBuffer, uno para el modelo base y otro para el modelo LoRA.

Inferencia de modelos LoRA

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