Guide d'inférence LLM pour Android

L'API Inference LLM vous permet d'exécuter des grands modèles de langage (LLM) entièrement sur l'appareil pour les applications Android. Vous pouvez les utiliser pour effectuer un large éventail de tâches, comme générer du texte, récupérer des informations au format langage naturel et résumer des documents. La tâche est compatible avec plusieurs grands modèles de langage de texte à texte, ce qui vous permet d'appliquer les derniers modèles d'IA générative sur l'appareil à vos applications Android.

Pour ajouter rapidement l'API d'inférence LLM à votre application Android, suivez le guide de démarrage rapide. Pour obtenir un exemple de base d'application Android exécutant l'API d'inférence LLM, consultez l'exemple d'application. Pour en savoir plus sur le fonctionnement de l'API d'inférence LLM, consultez les sections Options de configuration, Conversion de modèle et Réglage de LORA.

Vous pouvez voir cette tâche en action avec la démo MediaPipe Studio. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la section Présentation.

Guide de démarrage rapide

Pour ajouter l'API d'inférence LLM à votre application Android, procédez comme suit : L'API d'inférence LLM est optimisée pour les appareils Android haut de gamme, tels que le Pixel 8 et le Samsung S23 ou version ultérieure. Elle n'est pas compatible de manière fiable avec les émulateurs d'appareils.

Ajouter des dépendances

L'API Inference LLM utilise la bibliothèque com.google.mediapipe:tasks-genai. Ajoutez cette dépendance au fichier build.gradle de votre application Android:

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

Télécharger un modèle

Téléchargez Gemma-3 1B au format quantifié 4 bits sur Hugging Face. Pour en savoir plus sur les modèles disponibles, consultez la documentation sur les modèles.

Transférez le contenu du dossier output_path sur l'appareil 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

Initialiser la tâche

Initialisez la tâche avec des options de configuration de base:

// 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)

Exécuter la tâche

Utilisez la méthode generateResponse() pour générer une réponse textuelle. Une seule réponse est générée.

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

Pour diffuser la réponse en continu, utilisez la méthode generateResponseAsync().

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

llmInference.generateResponseAsync(inputPrompt)

Exemple d'application

Pour voir les API d'inférence LLM en action et explorer une gamme complète de fonctionnalités d'IA générative sur l'appareil, consultez l'application Google AI Gallery.

La Google AI Edge Gallery est une application Android Open Source qui sert de terrain d'entraînement interactif pour les développeurs. Il présente les éléments suivants:

• Exemples pratiques d'utilisation de l'API d'inférence LLM pour diverses tâches, y compris :
  • Demander à une image: importez une image et posez-lui des questions. Obtenez des descriptions, résolvez des problèmes ou identifiez des objets.
  • Atelier sur les requêtes: résumez, réécrivez, générez du code ou utilisez des requêtes au format libre pour explorer les cas d'utilisation des LLM à un seul tour.
  • Chat avec IA: engagez des conversations multitours.
• Possibilité de découvrir, télécharger et tester différents modèles optimisés pour LiteRT de la communauté Hugging Face LiteRT et des versions officielles de Google (par exemple, Gemma 3N).
• Benchmarks de performances sur l'appareil en temps réel pour différents modèles (temps de premier jeton, vitesse de décodage, etc.).
• Importer et tester vos propres modèles .task personnalisés

Cette application est une ressource permettant de comprendre l'implémentation pratique de l'API d'inférence LLM et le potentiel de l'IA générative sur l'appareil. Explorez le code source et téléchargez l'application depuis le dépôt GitHub de la galerie Google AI Edge.

Options de configuration

Utilisez les options de configuration suivantes pour configurer une application Android:

Requêtes multimodales

Les API Android de l'API d'inférence LLM sont compatibles avec les requêtes multimodales avec des modèles qui acceptent les entrées de texte et d'image. Lorsque la multimodalité est activée, les utilisateurs peuvent inclure une combinaison d'images et de texte dans leurs requêtes, et le LLM fournit une réponse textuelle.

Pour commencer, utilisez une variante de Gemma 3n compatible avec MediaPipe:

• Gemma-3n E2B: modèle 2B de la famille Gemma-3n.
• Gemma-3n E4B: modèle 4 B de la famille Gemma-3n.

Pour en savoir plus, consultez la documentation Gemma-3n.

Pour fournir des images dans une requête, convertissez les images ou les frames d'entrée en objet com.google.mediapipe.framework.image.MPImage avant de les transmettre à l'API d'inférence 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()

Pour activer la prise en charge de la vision pour l'API d'inférence LLM, définissez l'option de configuration EnableVisionModality sur true dans les options de graphique:

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

Gemma-3n n'accepte qu'une seule image par session. Définissez donc MaxNumImages sur 1.

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

Voici un exemple d'implémentation de l'API d'inférence LLM configurée pour gérer les entrées visuelles et textuelles:

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

Personnalisation LoRA

L'API Inference LLM est compatible avec le réglage LoRA (Low-Rank Adaptation) à l'aide de la bibliothèque PEFT (Parameter-Efficient Fine-Tuning). Le réglage LoRA personnalise le comportement des LLM via un processus d'entraînement rentable, en créant un petit ensemble de poids enregistrables en fonction de nouvelles données d'entraînement plutôt que de réentraîner l'ensemble du modèle.

L'API d'inférence LLM permet d'ajouter des poids LoRA aux couches d'attention des modèles Gemma-2 2B, Gemma 2B et Phi-2. Téléchargez le modèle au format safetensors.

Le modèle de base doit être au format safetensors pour créer des poids LoRA. Après l'entraînement LoRA, vous pouvez convertir les modèles au format FlatBuffers pour les exécuter sur MediaPipe.

Préparer les pondérations LoRA

Utilisez le guide Méthodes LoRA de PEFT pour entraîner un modèle LoRA affiné sur votre propre ensemble de données.

L'API LLM Inference n'est compatible qu'avec LoRA sur les couches d'attention. Par conséquent, ne spécifiez que les couches d'attention dans 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"],
)

Après avoir entraîné le modèle sur l'ensemble de données préparé et enregistré le modèle, les poids du modèle LoRA affinés sont disponibles dans adapter_model.safetensors. Le fichier safetensors est le point de contrôle LoRA utilisé lors de la conversion du modèle.

Conversion de modèles

Utilisez le package Python MediaPipe pour convertir les poids du modèle au format Flatbuffer. ConversionConfig spécifie les options de modèle de base ainsi que les options LoRA supplémentaires.

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)

Le convertisseur génère deux fichiers Flatbuffer, l'un pour le modèle de base et l'autre pour le modèle LoRA.

Inférence de modèle LoRA

Android est compatible avec LoRA statique lors de l'initialisation. Pour charger un modèle LoRA, spécifiez le chemin d'accès au modèle LoRA ainsi que le 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)

Pour exécuter l'inférence LLM avec LoRA, utilisez les mêmes méthodes generateResponse() ou generateResponseAsync() que le modèle de base.