Guide d'inférence LLM pour iOS

L'API LLM Inference vous permet d'exécuter de grands modèles de langage (LLM) entièrement sur l'appareil pour les applications iOS, que vous pouvez utiliser pour effectuer un large éventail de tâches, telles que comme la génération de texte, l'extraction d'informations en langage naturel résumer des documents. Cette tâche intègre la prise en charge de plusieurs de grands modèles de langage texte-vers-texte, ce qui vous permet d'appliquer des modèles d'IA générative à vos applications iOS.

Vous pouvez voir concrètement cette tâche à l'aide de MediaPipe Studio une démonstration. 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 API d'inférence LLM pour iOS. Vous pouvez utiliser l'application comme point de départ pour votre propre application iOS. s'y référer lors de la modification d'une application existante. L'exemple de code de l'API LLM Inference hébergé sur GitHub

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple à 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. Si vous le souhaitez, vous pouvez configurer votre instance Git pour utiliser le paiement creuse. Seuls 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 bibliothèque de tâches MediaPipe, ouvrez le projet avec Xcode et exécutez l'application. Pour 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 pour utiliser l'API d'inférence LLM. Pour obtenir des informations générales sur la configuration environnement de développement permettant d'utiliser des tâches MediaPipe, y compris la version 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 de langue supplémentaire.

Pour obtenir des instructions sur l'installation de CocoaPods sous macOS, reportez-vous au document CocoaPods guide d'installation. Pour savoir comment créer un Podfile avec les pods nécessaires pour votre consultez la section Utilisation CocoaPods

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

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

Si votre application inclut des cibles de tests unitaires, reportez-vous au Guide de configuration iOS. votre Podfile.

Modèle

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

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 pour savoir comment ajouter des fichiers à votre projet Xcode, reportez-vous à la section Gérer les fichiers et dossiers dans votre Xcode projet.

<ph type="x-smartling-placeholder"></ph> Télécharger Gemma 2B

Lorsque vous créez des applications iOS, utilisez l'une des variantes suivantes:

• gemma-2b-it-cpu-int4: Modèle Gemma 4 bits avec compatibilité CPU.
• gemma-2b-it-gpu-int4: Modèle Gemma 4 bits compatible avec les GPU.
• Edge Torch par IA mappé des modèles conformes aux exigences de mémoire iOS.

Pour en savoir plus sur d'autres modèles, consultez la présentation des tâches Modèles .

Créer la tâche

Vous pouvez créer la tâche de l'API LLM Inference en appelant l'un de ses initialiseurs. La 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 une configuration personnalisée vous pouvez utiliser l'initialiseur LlmInference(modelPath:) pour créer API d'inférence LLM avec les options par défaut. Pour en savoir plus sur la configuration consultez la page Présentation de la configuration.

Le code suivant montre comment compiler 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 comporte les options de configuration suivantes pour les applications iOS:

Préparer les données

L'API d'inférence LLM fonctionne avec des données textuelles. La tâche gère la saisie des données le prétraitement, y compris la tokenisation et le prétraitement des Tensors.

L'ensemble du prétraitement est géré dans la fonction generateResponse(inputText:). Il n'est pas nécessaire d'effectuer un prétraitement supplémentaire du texte d'entrée au préalable.

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:). La L'API LLM Inference renvoie les catégories possibles pour le texte d'entrée.

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

Pour diffuser la réponse, 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 LLM Inference renvoie un code LlmInferenceResult, qui inclut l'élément généré le texte de la réponse.

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 LoRA (Low-Rank Adaptation) pour les grands modèles de langage. À l'aide de modèles LoRA affinés, les développeurs peuvent personnaliser le comportement des LLM grâce à un processus d'entraînement économique.

La compatibilité LoRA de l'API d'inférence LLM fonctionne avec les modèles Gemma-2B et Phi-2 pour le backend du GPU, avec les pondérations LoRA applicables uniquement aux couches d'attention. Ce l'implémentation initiale sert d'API expérimentale pour les développements futurs Nous prévoyons de prendre en charge d'autres modèles et différents types de couches mises à jour.

Préparer les modèles LoRA

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

# For Gemma-2B
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, il existe des modèles LoRA affinés accessibles au public et adaptés à l'API d'inférence LLM 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é sur l'ensemble de données préparé et enregistré le modèle, vous obtenez un fichier adapter_model.safetensors contenant les pondérations affinées du modèle LoRA. Le fichier Safetensors est le point de contrôle LoRA utilisé lors de la conversion du modèle.

L'étape suivante consiste à convertir les pondérations du modèle en un Flatbuffer TensorFlow Lite à l'aide du package Python MediaPipe. Le ConversionConfig doit spécifier les options du modèle de base ainsi que les options LoRA supplémentaires. Comme l'API n'accepte que 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 TFLite Flatbuffer, 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 Web, Android et iOS a été mise à jour pour prendre en charge l'inférence de modèles LoRA. Le Web est compatible avec la technologie LoRA dynamique, qui peut changer de modèle LoRA pendant l'exécution. Android et iOS sont compatibles avec la fonctionnalité LoRA statique, qui utilise les mêmes pondérations LoRA pendant toute la durée de vie de la tâche.

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 une inférence LLM avec LoRA, utilisez les mêmes méthodes generateResponse() ou generateResponseAsync() que le modèle de base.