LLM-Inferenzleitfaden für das Web

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig auf dem Gerät für Webanwendungen 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 Webanwendungen anwenden können.

Wenn Sie Ihrer Webanwendung schnell die LLM Inference API hinzufügen möchten, folgen Sie der Kurzanleitung. Ein einfaches Beispiel für eine Webanwendung, 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 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.

Kurzanleitung

So fügen Sie Ihrer Webanwendung die LLM Inference API hinzu: Für die LLM Inference API ist ein Webbrowser mit WebGPU-Kompatibilität erforderlich. Eine vollständige Liste der kompatiblen Browser finden Sie unter GPU-Browserkompatibilität.

Abhängigkeiten hinzufügen

Die LLM-Inferenz-API verwendet das Paket @mediapipe/tasks-genai.

Installieren Sie die erforderlichen Pakete für die lokale Bereitstellung:

npm install @mediapipe/tasks-genai

Wenn Sie den Code auf einem Server bereitstellen möchten, verwenden Sie einen CDN-Dienst (Content Delivery Network) wie jsDelivr, um Code direkt in Ihre HTML-Seite einzufügen:

<head>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
    crossorigin="anonymous"></script>
</head>

Modell herunterladen

Laden Sie Gemma-2 2B in einem 8‑Bit-Quantisierungsformat von Kaggle-Modellen herunter. Weitere Informationen zu den verfügbaren Modellen finden Sie in der Modelldokumentation.

Speichern Sie das Modell im Projektverzeichnis:

<dev-project-root>/assets/gemma-2b-it-gpu-int8.bin

Geben Sie den Pfad des Modells mit dem Parameter baseOptions des Objekts modelAssetPath an:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int8.bin`}

Aufgabe initialisieren

Initialisieren Sie die Aufgabe mit den grundlegenden Konfigurationsoptionen:

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
    baseOptions: {
        modelAssetPath: '/assets/gemma-2b-it-gpu-int8.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

Task ausführen

Verwenden Sie die Funktion generateResponse(), um Inferenzen auszulösen.

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

So streamst du die Antwort:

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

Beispielanwendung

Die Beispielanwendung ist ein Beispiel für eine einfache App zur Textgenerierung im Web, die die LLM Inference API verwendet. Sie können die App als Ausgangspunkt für Ihre eigene Webanwendung verwenden oder sie als Referenz verwenden, 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

Weitere Informationen finden Sie im Einrichtungsleitfaden für das Web.

Konfigurationsoptionen

Verwenden Sie die folgenden Konfigurationsoptionen, um eine Webanwendung einzurichten:

Option Beschreibung Wertebereich Standardwert
modelPath Der Pfad zum Speicherort des Modells im Projektverzeichnis. PFAD –
maxTokens Die maximale Anzahl von Tokens (Eingabe- und Ausgabetokens), die vom Modell verarbeitet werden. Ganzzahl 512
topK Die Anzahl der Tokens, die das Modell bei jedem Schritt der Generierung berücksichtigt. Begrenzt die Vorhersagen auf die k wahrscheinlichsten Tokens. Ganzzahl 40
temperature Der Grad der Zufälligkeit, der bei der Generierung eingeführt wird. Eine höhere Temperatur führt zu mehr Kreativität im generierten Text, während eine niedrigere Temperatur zu einer vorhersehbareren Generierung führt. Gleitkommazahl 0,8
randomSeed Der Zufallszahlengenerator, der bei der Textgenerierung verwendet wird. Ganzzahl 0
loraRanks LoRA-Ränge, die von den LoRA-Modellen während der Laufzeit verwendet werden sollen. Hinweis: Diese Funktion ist nur mit GPU-Modellen kompatibel. Ganzzahl-Array –

Modellkonvertierung

Die LLM Inference API ist mit den folgenden Modelltypen kompatibel. Für einige davon ist eine Modellkonvertierung erforderlich. Anhand der Tabelle können Sie die erforderlichen Schritte für Ihr Modell ermitteln.

Modelle Conversion-Methode Kompatible Plattformen Dateityp
Gemma-3 1B Keine Conversion erforderlich Android, Web .task
Gemma 2B, Gemma 7B, Gemma-2 2B Keine Conversion erforderlich Android, iOS, Web .bin
Phi-2, StableLM, Falcon MediaPipe-Konvertierungsskript Android, iOS, Web .bin
Alle PyTorch-LLM-Modelle AI Edge Torch Generative Library Android, iOS .task

Informationen zum Konvertieren anderer Modelle finden Sie im Abschnitt Modellkonvertierung.

LoRA-Anpassung

Die LLM Inference API unterstützt die LoRA-Abstimmung (Low-Rank Adaptation) mithilfe der Bibliothek PEFT (Parameter-Efficient Fine-Tuning). Bei der LoRA-Optimierung wird das Verhalten von LLMs durch einen kosteneffizienten Trainingsablauf angepasst. Dabei werden anhand neuer Trainingsdaten eine kleine Anzahl trainierbarer Gewichte erstellt, anstatt das gesamte Modell neu zu trainieren.

Die LLM Inference API unterstützt das Hinzufügen von LoRA-Gewichten zu den Aufmerksamkeitsschichten 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 den Leitfaden LoRA-Methoden von PEFT, um ein optimiertes LoRA-Modell mit Ihrem eigenen Datensatz zu trainieren.

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

Nachdem Sie das Modell mit dem vorbereiteten Dataset trainiert und gespeichert haben, sind die optimierten 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 des Basismodells 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)

Der Konverter erstellt zwei MediaPipe-kompatible Dateien, eine für das Basismodell und eine für das LoRA-Modell.

LoRA-Modellinferenz

Das Web unterstützt dynamische LoRA-Ränge während der Laufzeit. Das bedeutet, dass Nutzer die LoRA-Ränge während der Initialisierung angeben. Das bedeutet, dass Sie während der Laufzeit verschiedene LoRA-Modelle austauschen können.

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
    // options for the base model
    ...
    // LoRA ranks to be used by the LoRA models during runtime
    loraRanks: [4, 8, 16]
});

Laden Sie die LoRA-Modelle während der Laufzeit, nachdem Sie das Basismodell initialisiert haben. Triggern Sie das LoRA-Modell, indem Sie beim Generieren der LLM-Antwort die Modellreferenz übergeben.

// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);

// Specify LoRA model to be used during inference
llmInference.generateResponse(
  inputPrompt,
  loraModelRank4,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});