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, telles que la génération de texte, la récupération d'informations sous forme de langage naturel et le résumé de 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.22'
}

Pour les appareils équipés d'Android 12 (API 31) ou version ultérieure, ajoutez la dépendance de la bibliothèque OpenCL native. Pour en savoir plus, consultez la documentation sur la balise uses-native-library.

Ajoutez les balises uses-native-library suivantes au fichier 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"/>

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

L'application exemple est un exemple d'application de génération de texte de base pour Android, qui utilise l'API d'inférence LLM. Vous pouvez utiliser l'application comme point de départ pour votre propre application Android ou vous y référer lorsque vous modifiez une application existante. L'exemple de code est hébergé sur GitHub.

Clonez le dépôt Git à l'aide de la commande suivante:

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

Après avoir créé une version locale de l'exemple de code, vous pouvez importer le projet dans Android Studio et exécuter l'application. Pour en savoir plus, consultez le guide de configuration pour Android.

Options de configuration

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

Conversion de modèles

L'API d'inférence LLM est compatible avec les types de modèles suivants, dont certains nécessitent une conversion de modèle. Utilisez le tableau pour identifier la méthode d'étapes requise pour votre modèle.

Pour savoir comment convertir d'autres modèles, consultez la section Conversion de modèles.

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.