Weitere Informationen zu den Ankündigungen der Google AI Edge auf der Google I/O

Diese Seite wurde von der Cloud Translation API übersetzt.

LLM-Inferenzleitfaden für iOS

Mit der LLM Inference API können Sie Large Language Models (LLMs) für iOS-Anwendungen vollständig auf dem Gerät ausführen und 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 Text-zu-Text-Large Language Models, sodass Sie die neuesten generativen KI-Modelle auf dem Gerät auf Ihre iOS-Apps anwenden können.

An der MediaPipe Studio-Demo können Sie sich diese Aufgabe 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 einfache Implementierung einer LLM Inference API-App für iOS. Sie können die App als Ausgangspunkt für Ihre eigene iOS-App verwenden oder darauf zurückgreifen, wenn Sie eine vorhandene App ändern. Der Beispielcode der LLM Inference API wird auf GitHub gehostet.

Code herunterladen

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

So laden Sie den Beispielcode herunter:

Klonen Sie das Git-Repository mit dem folgenden Befehl:

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

Konfigurieren Sie optional die Git-Instanz für die Verwendung von Sparse Checkout, sodass Sie nur die Dateien für die Beispielanwendung der LLM Inference API haben:
```
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 der Entwicklungsumgebung für die Verwendung von MediaPipe-Aufgaben, einschließlich der 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-Anwendungen kompatibel und erfordert keine zusätzliche sprachspezifische Einrichtung.

Eine Anleitung zur Installation von CocoaPods unter macOS finden Sie in der CocoaPods-Installationsanleitung. Eine Anleitung zum Erstellen eines Podfile mit den erforderlichen Pods für Ihre Anwendung finden Sie unter CocoaPods verwenden.

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

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

Falls Ihre App Ziele für Einheitentests enthält, finden Sie im Einrichtungsleitfaden für iOS weitere Informationen zum Einrichten von Podfile.

Modell

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

Modell herunterladen

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

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
AI Edge Torch hat Modelle zugeordnet, die den iOS-Arbeitsspeicheranforderungen entsprechen.

Weitere Informationen zu anderen Modellen finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Aufgabe erstellen

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

Wenn Sie keine LLM Inference API benötigen, die mit benutzerdefinierten Konfigurationsoptionen initialisiert ist, können Sie den LlmInference(modelPath:)-Initialisierer verwenden, um eine LLM Inference API mit den Standardoptionen zu erstellen. Weitere Informationen zu Konfigurationsoptionen finden Sie in der Konfigurationsübersicht.

Im folgenden Codebeispiel 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

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

Option	Beschreibung	Wertebereich	Standardwert
`modelPath`	Der Pfad zum Speicherort des Modells im Projektverzeichnis.	PATH	–
`maxTokens`	Die maximale Anzahl von Tokens (Eingabe- und Ausgabetokens), die das Modell verarbeitet.	Integer	512
`topk`	Die Anzahl der Tokens, die das Modell bei jedem Generierungsschritt berücksichtigt. Beschränkt die Vorhersagen auf die k wahrscheinlichsten Tokens. Beim Festlegen von `topk` müssen Sie auch einen Wert für `randomSeed` festlegen.	Integer	40
`temperature`	Das Ausmaß der Zufälligkeit, die während der Generierung eingeführt wird. Eine höhere Temperatur ermöglicht mehr Kreativität im generierten Text, während eine niedrigere Temperatur eine vorhersehbarere Generierung des Textes ermöglicht. Beim Festlegen von `temperature` müssen Sie auch einen Wert für `randomSeed` festlegen.	Gleitkommazahl	0,8
`randomSeed`	Der zufällige Startwert, der bei der Textgenerierung verwendet wird.	Integer	0
`loraPath`	Der absolute Pfad zum LoRA-Modell lokal auf dem Gerät. Hinweis: Dies ist nur mit GPU-Modellen kompatibel.	PATH	–

Daten vorbereiten

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

Die gesamte Vorverarbeitung erfolgt in der generateResponse(inputText:)-Funktion. Eine zusätzliche Vorverarbeitung des Eingabetexts ist im Voraus nicht erforderlich.

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

Task ausführen

Verwenden Sie zum Ausführen der LLM Inference API die Methode generateResponse(inputText:). Die LLCM 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 einen LlmInferenceResult zurück, der den generierten Antworttext enthält.

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 Inference API kann so konfiguriert werden, dass sie Low-Rank Adaptation (LoRA) für Large Language Models unterstützt. Mit fein abgestimmten LoRA-Modellen können Entwickler 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 das GPU-Back-End, wobei die LoRA-Gewichtungen nur für Aufmerksamkeitsebenen gelten. Diese anfängliche Implementierung dient als experimentelle API für zukünftige Entwicklungen mit Plänen zur Unterstützung weiterer Modelle und verschiedener Ebenentypen in den kommenden Updates.

LoRA-Modelle vorbereiten

Folgen Sie der Anleitung für HuggingFace, um ein abgestimmtes LoRA-Modell in Ihrem eigenen Dataset mit den unterstützten Modelltypen Gemma-2B oder Phi-2 zu trainieren. Die Modelle Gemma-2B und Phi-2 sind in HuggingFace im Safetensors-Format verfügbar. Da die LLM Inference API LoRA nur auf Aufmerksamkeitsebenen unterstützt, geben Sie beim Erstellen des LoraConfig nur Aufmerksamkeitsebenen 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"],
)

Für Tests gibt es öffentlich zugängliche, abgestimmte LoRA-Modelle, die auf die LLM Inference API abgestimmt sind, die auf HuggingFace verfügbar sind. 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 mit dem vorbereiteten Dataset trainiert und das Modell gespeichert haben, erhalten Sie eine adapter_model.safetensors-Datei mit den abgestimmten LoRA-Modellgewichtungen. Die Safetensors-Datei ist der LoRA-Prüfpunkt, der bei der Modellkonvertierung verwendet wird.

Im nächsten Schritt müssen Sie die Modellgewichtungen mithilfe des Python-Pakets „MediaPipe“ in einen TensorFlow Lite-Flatbuffer konvertieren. 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 eine für das LoRA-Modell.

Inferenz des LoRA-Modells

Die Web, Android und iOS LLM Inference API wurde aktualisiert, um die Inferenz des LoRA-Modells zu unterstützen. Das Web unterstützt dynamische LoRA-Modelle, die während der Laufzeit zwischen verschiedenen LoRA-Modellen wechseln können. Android und iOS unterstützen die statische LORA, die während der Lebensdauer der Aufgabe dieselben LoRA-Gewichtungen verwendet.

iOS unterstützt die statische LoRA während der Initialisierung. Zum Laden eines LORA-Modells geben Nutzer den LoRA-Modellpfad sowie das Basis-LLM an.

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 dieselben Methoden generateResponse() oder generateResponseAsync() wie für das Basismodell, um LLM-Inferenzen mit LoRA auszuführen.