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. Damit lassen sich 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-LLMs, sodass Sie die neuesten On-Device-Modelle für generative KI in Ihren iOS-Apps verwenden können.

Wenn Sie die LLM Inference API schnell in Ihre iOS-Anwendung einfügen möchten, folgen Sie dem Schnellstart. Ein einfaches Beispiel für eine iOS-Anwendung, in der die LLM Inference API ausgeführt wird, finden Sie in der Beispielanwendung. Weitere Informationen zur Funktionsweise der LLM Inference API finden Sie in den Abschnitten Konfigurationsoptionen, Modellkonvertierung und LoRA-Abstimmung.

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

Kurzanleitung

So fügen Sie die LLM Inference API Ihrer iOS-Anwendung hinzu: 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 finden Sie im CocoaPods-Installationsleitfaden. Eine Anleitung zum Erstellen eines Podfile mit den erforderlichen Pods für Ihre App finden Sie unter CocoaPods verwenden.

Abhängigkeiten hinzufügen

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

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

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

Modell herunterladen

Laden Sie Gemma-2 2B im 8‑Bit-quantisierten Format von Kaggle Models herunter. Weitere Informationen zu den verfügbaren Modellen finden Sie in der Dokumentation zu Modellen.

Fügen Sie das Modell mit Xcode Ihrem Projektverzeichnis hinzu. Eine Anleitung zum Hinzufügen von Dateien zu Ihrem Xcode-Projekt finden Sie unter Dateien und Ordner in Ihrem Xcode-Projekt verwalten.

Aufgabe initialisieren

Initialisieren Sie die Aufgabe mit grundlegenden Konfigurationsoptionen:

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)

Aufgabe ausführen

Verwenden Sie die Methode generateResponse(inputText:), um eine Textantwort zu generieren. Dadurch wird eine einzelne Antwort generiert.

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)")
}

Beispielanwendung

Die Beispielanwendung ist ein Beispiel für eine einfache Textgenerierungs-App für iOS, die die LLM Inference API verwendet. Sie können die App als Ausgangspunkt für Ihre eigene iOS-App verwenden oder sich daran orientieren, wenn Sie eine vorhandene App ändern. Der Beispielcode wird auf GitHub gehostet.

Klonen Sie das Git-Repository mit dem folgenden Befehl:

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

Nachdem Sie eine lokale Version des Beispielcodes erstellt haben, können Sie das Projekt in iOS Studio importieren und die App ausführen. Weitere Informationen finden Sie im Einrichtungsleitfaden für iOS.

Konfigurationsoptionen

Verwenden Sie die folgenden Konfigurationsoptionen, um eine iOS-App einzurichten:

Modellkonvertierung

Die LLM Inference API ist mit den folgenden Modelltypen kompatibel. Für einige ist eine Modellkonvertierung erforderlich. In der Tabelle finden Sie die erforderlichen Schritte für Ihr Modell.

Informationen zum Konvertieren anderer Modelle finden Sie im Abschnitt Modellkonvertierung.

LoRA-Anpassung

Die LLM Inference API unterstützt die LoRA-Abstimmung (Low-Rank Adaptation) mit der PEFT-Bibliothek (Parameter-efficient Fine-tuning). Durch die LoRA-Abstimmung wird das Verhalten von LLMs durch einen kostengünstigen Trainingsprozess angepasst. Dabei wird eine kleine Gruppe von trainierbaren Gewichten auf der Grundlage neuer Trainingsdaten erstellt, anstatt das gesamte Modell neu zu trainieren.

Die LLM Inference API unterstützt das Hinzufügen von LoRA-Gewichten zu Attention-Layern der Modelle Gemma-2 2B, Gemma 2B und Phi-2. Laden Sie das Modell im safetensors-Format herunter.

Das Basismodell muss das Format safetensors haben, damit LoRA-Gewichte erstellt werden können. Nach dem LoRA-Training können Sie die Modelle in das FlatBuffers-Format konvertieren, um sie in MediaPipe auszuführen.

LoRA-Gewichte vorbereiten

Verwenden Sie die LoRA-Methoden aus PEFT, um ein feinabgestimmtes LoRA-Modell mit Ihrem eigenen Dataset zu trainieren.

Die LLM Inference API unterstützt LoRA nur auf Attention-Layern. Geben Sie daher nur die Attention-Layer in LoraConfig 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"],
)

Nach dem Training mit dem vorbereiteten Dataset und dem Speichern des Modells sind die feinabgestimmten LoRA-Modellgewichte in adapter_model.safetensors verfügbar. Die Datei safetensors ist der LoRA-Prüfpunkt, der bei der Modellkonvertierung verwendet wird.

Modellkonvertierung

Verwenden Sie das MediaPipe Python-Paket, um die Modellgewichte in das Flatbuffer-Format zu konvertieren. Mit ConversionConfig werden die Optionen für das Basismodell sowie die zusätzlichen LoRA-Optionen angegeben.

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

converter.convert_checkpoint(config)

Bei der Konvertierung werden zwei Flatbuffer-Dateien erzeugt, eine für das Basismodell und eine für das LoRA-Modell.

LoRA-Modellinferenz

iOS unterstützt statische LoRA während der Initialisierung. Wenn Sie ein LoRA-Modell laden möchten, geben Sie sowohl den LoRA-Modellpfad als auch 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)

Wenn Sie LLM-Inferenz mit LoRA ausführen möchten, verwenden Sie dieselben Methoden vom Typ generateResponse() oder generateResponseAsync() wie für das Basismodell.