LLM-Inferenzleitfaden für iOS

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig auf dem Gerät für iOS-Anwendungen ausführen. Sie können damit eine Vielzahl von Aufgaben ausführen, z. B. Text generieren, Informationen in natürlicher Sprache abrufen und Dokumente zusammenfassen. Die Aufgabe bietet integrierte Unterstützung für mehrere Large Language Models für die Text-zu-Text-Transformation, sodass Sie die neuesten On-Device-Modelle für generative KI auf Ihre iOS-Apps anwenden können.

Die Aufgabe unterstützt die folgenden Varianten von Gemma: Gemma-2 2B, Gemma 2B und Gemma 7B. Gemma ist eine Familie leichter, hochmoderner offener Modelle, die auf derselben Forschung und Technologie basieren wie die Gemini-Modelle. Außerdem werden die folgenden externen Modelle unterstützt: Phi-2, Falcon-RW-1B und StableLM-3B.

Neben den unterstützten Modellen können Nutzer mit AI Edge Torch von Google PyTorch-Modelle in LiteRT-Modelle mit mehreren Signaturen (tflite) exportieren. Diese werden mit Tokenizer-Parametern gebündelt, um Aufgabenpakete zu erstellen, die mit der LLM Inference API kompatibel sind.

In der MediaPipe Studio-Demo können Sie sich diese Aufgabe in Aktion ansehen. Weitere Informationen zu den Funktionen, Modellen und Konfigurationsoptionen dieser Aufgabe finden Sie in der Übersicht.

Codebeispiel

Der Beispielcode für MediaPipe Tasks ist eine grundlegende Implementierung einer LLM Inference API-App für iOS. Sie können die App als Ausgangspunkt für Ihre eigene iOS-App verwenden oder sich bei der Änderung einer vorhandenen App daran orientieren. Der Beispielcode für die LLM Inference API wird auf GitHub gehostet.

Code herunterladen

In der folgenden Anleitung wird beschrieben, wie Sie mit dem Befehlszeilentool git eine lokale Kopie des Beispielcodes erstellen.

So laden Sie den Beispielcode herunter:

1. Klonen Sie das Git-Repository mit dem folgenden Befehl:

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

2. Optional können Sie Ihre Git-Instanz so konfigurieren, dass eine spärliche Überprüfung verwendet wird, sodass nur die Dateien für die Beispielanwendung der LLM-Inferenz-API vorhanden sind:

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

Nachdem Sie eine lokale Version des Beispielcodes erstellt haben, können Sie die MediaPipe-Aufgabenbibliothek installieren, das Projekt mit Xcode öffnen und die App ausführen. Eine Anleitung finden Sie im Einrichtungsleitfaden für iOS.

Einrichtung

In diesem Abschnitt werden die wichtigsten Schritte zum Einrichten Ihrer Entwicklungsumgebung und Codeprojekte für die Verwendung der LLM Inference API beschrieben. Allgemeine Informationen zum Einrichten Ihrer Entwicklungsumgebung für die Verwendung von MediaPipe-Aufgaben, einschließlich Anforderungen an die Plattformversion, finden Sie im Einrichtungsleitfaden für iOS.

Abhängigkeiten

Die LLM Inference API verwendet die MediaPipeTasksGenai-Bibliothek, die mit CocoaPods installiert werden muss. Die Bibliothek ist sowohl mit Swift- als auch mit Objective-C-Apps kompatibel und erfordert keine zusätzliche sprachspezifische Einrichtung.

Eine Anleitung zum Installieren von CocoaPods unter macOS findest du in der Installationsanleitung für CocoaPods. Eine Anleitung zum Erstellen einer Podfile mit den erforderlichen Pods für Ihre App finden Sie unter CocoaPods verwenden.

Fügen Sie den MediaPipeTasksGenai-Pod mit dem folgenden Code in den Podfile ein:

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

Wenn Ihre App Unit-Testziele enthält, finden Sie im Einrichtungsleitfaden für iOS weitere Informationen zur Einrichtung Ihrer Podfile.

Modell

Für die MediaPipe LLM Inference API-Aufgabe ist ein trainiertes Modell erforderlich, das mit dieser Aufgabe kompatibel ist. Weitere Informationen zu verfügbaren trainierten Modellen für die LLM Inference API finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell herunterladen

Laden Sie ein Modell herunter und fügen Sie es Ihrem Projektverzeichnis mit Xcode hinzu. Eine Anleitung zum Hinzufügen von Dateien zu Ihrem Xcode-Projekt finden Sie unter Dateien und Ordner in Ihrem Xcode-Projekt verwalten.

Bevor Sie die LLM Inference API initialisieren, laden Sie eines der unterstützten Modelle herunter und speichern Sie die Datei in Ihrem Projektverzeichnis:

• Gemma-2 2B: Die neueste Version der Gemma-Modellfamilie. Teil einer Familie leichter, hochmoderner offener Modelle, die auf derselben Forschung und Technologie basieren, die auch für die Erstellung der Gemini-Modelle verwendet werden.
• Gemma 2B: Ist Teil einer Familie leichter, hochmoderner offener Modelle, die auf derselben Forschung und Technologie basieren, die auch für die Erstellung der Gemini-Modelle verwendet werden. Geeignet für eine Vielzahl von Textgenerierungsaufgaben, einschließlich Fragebeantwortung, Zusammenfassung und Argumentation.
• Phi-2: Transformer-Modell mit 2, 7 Milliarden Parametern, das sich am besten für Frage-Antwort-, Chat- und Codeformate eignet.
• Falcon-RW-1B: Modell mit kausalem Decoder und einer Milliarde Parametern, trainiert auf 350 Milliarden Tokens von RefinedWeb.
• StableLM-3B: Ein Decoder-Sprachmodell mit 3 Milliarden Parametern, das mit 1 Billion Token aus verschiedenen englischen und Code-Datasets vortrainiert wurde.

Zusätzlich zu den unterstützten Modellen können Sie mit AI Edge Torch von Google PyTorch-Modelle in LiteRT-Modelle (tflite) mit mehreren Signaturen exportieren. Weitere Informationen finden Sie unter Torch Generative Converter für PyTorch-Modelle.

Wir empfehlen die Verwendung von Gemma-2 2B, das auf Kaggle Models verfügbar ist. Weitere Informationen zu den anderen verfügbaren Modellen finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell in das MediaPipe-Format konvertieren

Die LLM Inference API ist mit zwei Modellkategorien kompatibel, für die teilweise eine Modellkonvertierung erforderlich ist. Anhand der Tabelle können Sie die erforderlichen Schritte für Ihr Modell ermitteln.

Die konvertierten .bin-Dateien für Gemma 2B, Gemma 7B und Gemma-2 2B werden auf Kaggle gehostet. Diese Modelle können direkt mit unserer LLM Inference API bereitgestellt werden. Informationen zum Konvertieren anderer Modelle finden Sie im Abschnitt Modellkonvertierung.

Aufgabe erstellen

Sie können die LLM-Inferenz-API-Aufgabe erstellen, indem Sie einen ihrer Initialisierer aufrufen. Mit dem LlmInference(options:)-Initialisierer werden Werte für die Konfigurationsoptionen festgelegt.

Wenn Sie keine LLM-Inferenz-API benötigen, die mit benutzerdefinierten Konfigurationsoptionen initialisiert wurde, können Sie mit dem LlmInference(modelPath:)-Initialisierer eine LLM-Inferenz-API mit den Standardoptionen erstellen. Weitere Informationen zu den Konfigurationsoptionen finden Sie unter Konfigurationsübersicht.

Im folgenden Code wird gezeigt, wie diese Aufgabe erstellt und konfiguriert wird.

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)

Konfigurationsoptionen

Für diese Aufgabe stehen die folgenden Konfigurationsoptionen für iOS-Apps zur Verfügung:

Daten vorbereiten

Die LLM Inference API funktioniert mit Textdaten. Die Aufgabe übernimmt die Vorverarbeitung der Dateneingabe, einschließlich Tokenisierung und Tensorvorverarbeitung.

Die gesamte Vorverarbeitung wird in der Funktion generateResponse(inputText:) ausgeführt. Eine zusätzliche Vorverarbeitung des Eingabetexts ist nicht erforderlich.

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

Aufgabe ausführen

Verwenden Sie die Methode generateResponse(inputText:), um die LLM Inference API auszuführen. Die LLM Inference API gibt die möglichen Kategorien für den Eingabetext zurück.

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

Verwenden Sie die Methode generateResponseAsync(inputText:), um die Antwort zu streamen.

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

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

Ergebnisse verarbeiten und anzeigen

Die LLM-Inferenz-API gibt den generierten Antworttext zurück.

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]

LoRA-Modellanpassung

Die Mediapipe LLM-Inferenz-API kann so konfiguriert werden, dass sie Low-Rank Adaptation (LoRA) für Large Language Models unterstützt. Mithilfe von optimierten LoRA-Modellen können Entwickler das Verhalten von LLMs durch einen kostengünstigen Trainingsablauf anpassen.

Die LoRA-Unterstützung der LLM Inference API funktioniert für alle Gemma-Varianten und Phi-2-Modelle für das GPU-Back-End. LoRA-Gewichte gelten nur für Aufmerksamkeitsschichten. Diese erste Implementierung dient als experimentelle API für zukünftige Entwicklungen. In den kommenden Updates sollen weitere Modelle und verschiedene Arten von Ebenen unterstützt werden.

LoRA-Modelle vorbereiten

Folgen Sie der Anleitung auf HuggingFace, um ein optimiertes LoRA-Modell mit den unterstützten Modelltypen Gemma oder Phi-2 auf Ihrem eigenen Dataset zu trainieren. Die Modelle Gemma-2 2B, Gemma 2B und Phi-2 sind auf HuggingFace im SafeTensors-Format verfügbar. Da die LLM Inference API nur LoRA auf Aufmerksamkeitsschichten unterstützt, geben Sie beim Erstellen der LoraConfig nur Aufmerksamkeitsschichten an:

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

Für Tests gibt es öffentlich zugängliche, optimierte LoRA-Modelle, die zur LLM-Inferenz-API auf HuggingFace passen. Beispiel: monsterapi/gemma-2b-lora-maths-orca-200k für Gemma-2B und lole25/phi-2-sft-ultrachat-lora für Phi-2.

Nachdem Sie das Modell mit dem vorbereiteten Dataset trainiert und gespeichert haben, erhalten Sie eine adapter_model.safetensors-Datei mit den optimierten LoRA-Modellgewichten. Die safetensors-Datei ist der LoRA-Prüfpunkt, der bei der Modellkonvertierung verwendet wird.

Im nächsten Schritt müssen Sie die Modellgewichte mit dem MediaPipe-Python-Paket in einen TensorFlow Lite-Flatbuffer konvertieren. Die ConversionConfig sollte die Optionen für das Basismodell sowie zusätzliche LoRA-Optionen angeben. Da die API nur LoRA-Inferenzen mit GPU unterstützt, muss das Backend auf 'gpu' festgelegt sein.

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)

Der Konverter gibt zwei TFLite-Flatbuffer-Dateien aus, eine für das Basismodell und eine für das LoRA-Modell.

LoRA-Modellinferenz

Die LLM-Inferenz-API für Web, Android und iOS wurde aktualisiert, um die Inferenz von LoRA-Modellen zu unterstützen.

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)

Verwenden Sie für die LLM-Inferenz mit LoRA dieselben generateResponse()- oder generateResponseAsync()-Methoden wie für das Basismodell.