Guide d'inférence LLM pour iOS

L'API Inference LLM vous permet d'exécuter des grands modèles de langage (LLM) entièrement sur l'appareil pour les applications iOS. 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 iOS.

Pour ajouter rapidement l'API d'inférence LLM à votre application iOS, suivez le guide de démarrage rapide. Pour obtenir un exemple de base d'application iOS exécutant l'API d'inférence LLM, consultez l'application exemple. 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 iOS, procédez comme suit : L'API d'inférence LLM utilise la bibliothèque MediaPipeTasksGenai, qui doit être installée à l'aide de CocoaPods. La bibliothèque est compatible avec les applications Swift et Objective-C, et ne nécessite aucune configuration supplémentaire spécifique à la langue.

Pour savoir comment installer CocoaPods sur macOS, consultez le guide d'installation de CocoaPods. Pour savoir comment créer un Podfile avec les pods nécessaires à votre application, consultez la section Utiliser CocoaPods.

Ajouter des dépendances

Ajoutez le pod MediaPipeTasksGenai dans le Podfile à l'aide du code suivant:

target 'MyLlmInferenceApp' do
  use_frameworks!
  pod 'MediaPipeTasksGenAI'
  pod 'MediaPipeTasksGenAIC'
end

Si votre application inclut des cibles de test unitaire, consultez le guide de configuration pour iOS pour en savoir plus sur la configuration de votre Podfile.

Télécharger un modèle

Téléchargez Gemma-2 2B au format quantifié 8 bits à partir de Kaggle Models. Pour en savoir plus sur les modèles disponibles, consultez la documentation sur les modèles.

Ajoutez le modèle au répertoire de votre projet à l'aide de Xcode. Pour savoir comment ajouter des fichiers à votre projet Xcode, consultez Gérer les fichiers et les dossiers dans votre projet Xcode.

Initialiser la tâche

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

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")

let options = LlmInferenceOptions()
options.baseOptions.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101

let llmInference = try LlmInference(options: options)

Exécuter la tâche

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

let result = try LlmInference.generateResponse(inputText: inputPrompt)

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

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

do {
  for try await partialResult in resultStream {
    print("\(partialResult)")
  }
  print("Done")
}
catch {
  print("Response error: '\(error)")
}

Exemple d'application

L'application exemple est un exemple d'application de génération de texte de base pour iOS, qui utilise l'API d'inférence LLM. Vous pouvez utiliser l'application comme point de départ pour votre propre application iOS 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 iOS Studio et exécuter l'application. Pour en savoir plus, consultez le guide de configuration pour iOS.

Options de configuration

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

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

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

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")
let loraPath= Bundle.main.path(forResource: "lora_model",
                                      ofType: "bin")
let options = LlmInferenceOptions()
options.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101
options.loraPath = loraPath

let llmInference = try LlmInference(options: 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.