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.

La tâche est compatible avec les variantes suivantes de Gemma: Gemma-2 2B, Gemma 2B et Gemma 7B. Gemma est une famille de modèles ouverts, légers et à la pointe de la technologie, basés sur les mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. Il est également compatible avec les modèles externes suivants: Phi-2, Falcon-RW-1B et StableLM-3B.

En plus des modèles compatibles, les utilisateurs peuvent utiliser AI Edge Torch de Google pour exporter des modèles PyTorch vers des modèles LiteRT (tflite) multisignatures, qui sont regroupés avec des paramètres de tokenizer pour créer des bundles de tâches compatibles avec l'API d'inférence LLM.

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.

Exemple de code

L'exemple de code MediaPipe Tasks est une implémentation de base d'une application d'API d'inférence LLM pour iOS. 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 de l'API d'inférence LLM est hébergé sur GitHub.

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple de code à l'aide de l'outil de ligne de commande git.

Pour télécharger l'exemple de code:

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

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

2. Vous pouvez également configurer votre instance git pour qu'elle utilise un "checkout" clairsemé afin de n'avoir que les fichiers de l'application exemple de l'API d'inférence LLM:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/ios/
   

Après avoir créé une version locale de l'exemple de code, vous pouvez installer la bibliothèque de tâches MediaPipe, ouvrir le projet à l'aide de Xcode et exécuter l'application. Pour obtenir des instructions, consultez le guide de configuration pour iOS.

Configuration

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement et vos projets de code afin d'utiliser l'API d'inférence LLM. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour utiliser les tâches MediaPipe, y compris les exigences concernant les versions de la plate-forme, consultez le guide de configuration pour iOS.

Dépendances

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.

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.

Modèle

La tâche de l'API d'inférence LLM MediaPipe nécessite un modèle entraîné compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour l'API d'inférence LLM, consultez la section Modèles de la présentation de la tâche.

Télécharger un modèle

Téléchargez un modèle et ajoutez-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.

Avant d'initialiser l'API d'inférence LLM, téléchargez l'un des modèles compatibles et stockez le fichier dans le répertoire de votre projet:

• Gemma-2B : dernière version de la famille de modèles Gemma. Fait partie d'une famille de modèles ouverts, légers et à la pointe de la technologie, basés sur la recherche et la technologie utilisées pour créer les modèles Gemini.
• Gemma 2B : fait partie d'une famille de modèles ouverts, légers et de pointe conçus à partir des mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. Convient à diverses tâches de génération de texte, y compris la réponse à des questions, la synthèse et le raisonnement.
• Phi-2: modèle Transformer à 2, 7 milliards de paramètres, le plus adapté aux formats question-réponse, chat et code.
• Falcon-RW-1B: modèle de décodeur causal à un milliard de paramètres entraîné sur 350 milliards de jetons de RefinedWeb.
• StableLM-3B: modèle de langage avec 3 milliards de paramètres, uniquement pour le décodeur, pré-entraîné sur 1 billion de jetons provenant de divers ensembles de données en anglais et en code.

En plus des modèles compatibles, vous pouvez utiliser AI Edge Torch de Google pour exporter des modèles PyTorch vers des modèles LiteRT (tflite) à signature multiple. Pour en savoir plus, consultez Convertisseur génératif Torch pour les modèles PyTorch.

Nous vous recommandons d'utiliser Gemma-2 2B, qui est disponible sur Kaggle Models. Pour en savoir plus sur les autres modèles disponibles, consultez la section Modèles de la présentation des tâches.

Convertir le modèle au format MediaPipe

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

Nous hébergeons les fichiers .bin convertis pour Gemma 2B, Gemma 7B et Gemma-2 2B sur Kaggle. Ces modèles peuvent être déployés directement à l'aide de notre API d'inférence LLM. Pour savoir comment convertir d'autres modèles, consultez la section Convertir des modèles.

Créer la tâche

Vous pouvez créer la tâche de l'API Inference LLM en appelant l'un de ses initialiseurs. L'initialiseur LlmInference(options:) définit les valeurs des options de configuration.

Si vous n'avez pas besoin d'une API d'inférence LLM initialisée avec des options de configuration personnalisées, vous pouvez utiliser l'initialiseur LlmInference(modelPath:) pour créer une API d'inférence LLM avec les options par défaut. Pour en savoir plus sur les options de configuration, consultez la section Présentation de la configuration.

Le code suivant montre comment créer et configurer cette tâche.

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)

Options de configuration

Cette tâche propose les options de configuration suivantes pour les applications iOS:

Préparer les données

L'API d'inférence LLM fonctionne avec les données textuelles. La tâche gère le prétraitement de l'entrée de données, y compris la tokenisation et le prétraitement des tenseurs.

Tout le prétraitement est géré dans la fonction generateResponse(inputText:). Aucun prétraitement supplémentaire du texte saisi n'est nécessaire.

let inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

Exécuter la tâche

Pour exécuter l'API d'inférence LLM, utilisez la méthode generateResponse(inputText:). L'API d'inférence LLM renvoie les catégories possibles pour le texte d'entré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)")
}

Gérer et afficher les résultats

L'API d'inférence LLM renvoie le texte de réponse généré.

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

Personnalisation du modèle LoRA

L'API d'inférence LLM Mediapipe peut être configurée pour prendre en charge l'adaptation faible (LoRA) pour les grands modèles de langage. Grâce à des modèles LoRA optimisés, les développeurs peuvent personnaliser le comportement des LLM via un processus d'entraînement rentable.

La prise en charge de LoRA par l'API d'inférence LLM fonctionne pour toutes les variantes Gemma et les modèles Phi-2 pour le backend GPU, avec des poids LoRA applicables uniquement aux couches d'attention. Cette implémentation initiale sert d'API expérimentale pour les futurs développements. Nous prévoyons de prendre en charge davantage de modèles et différents types de calques dans les prochaines mises à jour.

Préparer des modèles LoRA

Suivez les instructions sur HuggingFace pour entraîner un modèle LoRA affiné sur votre propre ensemble de données avec les types de modèles compatibles, Gemma ou Phi-2. Les modèles Gemma-2 2B, Gemma 2B et Phi-2 sont tous disponibles sur HuggingFace au format safetensors. Étant donné que l'API d'inférence LLM n'est compatible qu'avec LORA sur les couches d'attention, ne spécifiez que les couches d'attention lors de la création de LoraConfig comme suit:

# 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"],
)

Pour les tests, des modèles LoRA affinés accessibles au public qui correspondent à l'API d'inférence LLM sont disponibles sur HuggingFace. Par exemple, monsterapi/gemma-2b-lora-maths-orca-200k pour Gemma-2B et lole25/phi-2-sft-ultrachat-lora pour Phi-2.

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

L'étape suivante consiste à convertir les poids du modèle en Flatbuffer TensorFlow Lite à l'aide du package Python MediaPipe. ConversionConfig doit spécifier les options de modèle de base ainsi que les options LoRA supplémentaires. Notez que, comme l'API n'est compatible qu'avec l'inférence LoRA avec GPU, le backend doit être défini sur 'gpu'.

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_TFLITE_FILE,
)

converter.convert_checkpoint(config)

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

Inférence de modèle LoRA

L'API d'inférence LLM pour le Web, Android et iOS est mise à jour pour prendre en charge l'inférence de modèle LoRA.

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.