LLM-Inferenzleitfaden für iOS

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig auf dem Gerät ausführen für iOS-Apps, mit denen eine Vielzahl von Aufgaben ausgeführt werden kann, z. B. wie das Generieren von Text, das Abrufen von Informationen in natürlicher Sprache das Zusammenfassen von Dokumenten. Die Aufgabe unterstützt mehrere Large Language Models (Text-zu-Text), damit Sie die neuesten On-Device- auf generativer KI basierende Modelle für Ihre iOS-Apps.

Sie können diese Aufgabe in Aktion mit dem MediaPipe Studio Weitere Informationen zu Funktionen, Modellen und Konfigurationsoptionen Sehen Sie sich die Übersicht an.

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 beim Ändern einer vorhandenen App darauf verweisen. Der Beispielcode der LLM Inference API ist gehostet auf GitHub

Code herunterladen

In der folgenden Anleitung erfahren Sie, wie Sie eine lokale Kopie des Beispiels erstellen. mit dem Befehlszeilentool git 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. Konfigurieren Sie optional Ihre Git-Instanz für den Sparse-Checkout, damit Sie nur die Dateien für die Beispielanwendung der LLM Inference API:

   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 den MediaPipe-Aufgabenbibliothek, öffnen Sie das Projekt mit Xcode und führen Sie die App aus. Für finden Sie im Einrichtungsleitfaden für iOS.

Einrichtung

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

Abhängigkeiten

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

Eine Anleitung zur Installation von CocoaPods unter macOS findest du im Artikel zu CocoaPods Installationsanleitung. Eine Anleitung zum Erstellen eines Podfile mit den für Ihr Projekt erforderlichen Pods erhalten Sie unter Verwendung CocoaPods

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

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

Falls Ihre App Einheitentestziele enthält, lesen Sie den Einrichtungsleitfaden für iOS: Weitere Informationen zur Einrichtung Dein Podfile.

Modell

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

Modell herunterladen

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

<ph type="x-smartling-placeholder"></ph> Gemma 2B herunterladen

Verwenden Sie beim Erstellen von iOS-Apps eine der folgenden Varianten:

• gemma-2b-it-cpu-int4: Gemma-4-Bit-Modell mit CPU-Kompatibilität.
• gemma-2b-it-gpu-int4: Gemma-4-Bit-Modell mit GPU-Kompatibilität.
• KI-Modelle von Edge Torch, die den iOS-Speicheranforderungen entsprechen.

Weitere Informationen zu anderen Modellen finden Sie in der Aufgabenübersicht Modelle .

Aufgabe erstellen

Sie können die LLM Inference API-Aufgabe erstellen, indem Sie einen ihrer Initialisierer aufrufen. Die Der LlmInference(options:)-Initialisierer legt Werte für die Konfigurationsoptionen fest.

Wenn Sie keine LLM Inference API benötigen, die mit benutzerdefinierter Konfiguration initialisiert wurde können Sie mit dem LlmInference(modelPath:)-Initialisierer ein LLM Inference API mit den Standardoptionen Weitere Informationen zur Konfiguration finden Sie unter Konfigurationsübersicht.

Der folgende Code zeigt, 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

Diese Aufgabe bietet die folgenden Konfigurationsoptionen für iOS-Apps:

Daten vorbereiten

Die LLM Inference API arbeitet mit Textdaten. Die Aufgabe verarbeitet die Dateneingabe Vorverarbeitung, einschließlich Tokenisierung und Tensor-Vorverarbeitung.

Die gesamte Vorverarbeitung erfolgt über die Funktion generateResponse(inputText:). Es ist keine zusätzliche Vorverarbeitung des Eingabetexts im Vorfeld 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 Die LLM Inference API gibt die möglichen Kategorien für den Eingabetext zurück.

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

Verwenden Sie zum Streamen der Antwort die Methode generateResponseAsync(inputText:).

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 Inference API gibt eine LlmInferenceResult zurück, die die generierten Antworttext.

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]

Anpassung des LoRA-Modells

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

Die LoRA-Unterstützung der LLM Inference API funktioniert für Gemma-2B- und Phi-2-Modelle für im GPU-Back-End, wobei LoRA-Gewichtungen nur für Aufmerksamkeitsebenen gelten. Dieses Die erste Implementierung dient als experimentelles API für zukünftige Entwicklungen. mit Plänen, in Zukunft weitere Modelle und verschiedene Arten von Ebenen zu unterstützen. Aktualisierungen.

LoRA-Modelle vorbereiten

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

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

Zu Testzwecken gibt es öffentlich zugängliche, abgestimmte LoRA-Modelle, die zur LLM Inference 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 vorbereitete Dataset trainiert und das Modell gespeichert haben, erhalten Sie eine adapter_model.safetensors-Datei mit den abgestimmten LoRA-Modellgewichtungen. Die Safetensors-Datei ist der bei der Modellkonvertierung verwendete LoRA-Prüfpunkt.

Im nächsten Schritt müssen Sie die Modellgewichtungen mithilfe des MediaPipe Python-Pakets in einen TensorFlow Lite-Flatbuffer umwandeln. In ConversionConfig sollten die Basismodelloptionen sowie zusätzliche LoRA-Optionen angegeben werden. Da die API nur LoRA-Inferenzen mit GPU unterstützt, muss das Back-End auf 'gpu' festgelegt werden.

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 Converter gibt zwei TFLite-Flatbuffer-Dateien aus, eine für das Basismodell und das andere für das LoRA-Modell.

Inferenz des LoRA-Modells

Die Web-, Android- und iOS LLM Inference API wurde aktualisiert, um die Inferenz von LoRA-Modellen zu unterstützen. Das Web unterstützt dynamische LoRA, mit denen verschiedene LoRA-Modelle während der Laufzeit gewechselt werden können. Android und iOS unterstützen statische LoRA-Werte, bei denen während der Lebensdauer der Aufgabe dieselben LoRA-Gewichtungen verwendet werden.

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 zum Ausführen von LLM-Inferenzen mit LoRA dieselben generateResponse()- oder generateResponseAsync()-Methoden wie das Basismodell.