Jetzt neu: LiteRT: Die leistungsstarke Laufzeit von Google für On-Device-KI, ehemals TensorFlow Lite.

Diese Seite wurde von der Cloud Translation API übersetzt.

LLM-Inferenzleitfaden für das Web

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig im Browser 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.

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.

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

Die Beispielanwendung für die LLM Inference API bietet eine grundlegende Implementierung dieser Aufgabe in JavaScript. Sie können diese Beispiel-App als Ausgangspunkt für die Erstellung Ihrer eigenen App zur Textgenerierung verwenden.

Die Beispiel-App für die LLM-Inferenz-API finden Sie auf GitHub.

Einrichtung

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

Browserkompatibilität

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.

JavaScript-Pakete

Der Code der LLM Inference API ist über das Paket @mediapipe/tasks-genai verfügbar. Diese Bibliotheken finden Sie im Einrichtungsleitfaden der Plattform.

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

Für die MediaPipe LLM Inference API ist ein trainiertes Modell erforderlich, das mit dieser Aufgabe kompatibel ist. Bei Webanwendungen muss das Modell GPU-kompatibel sein.

Weitere Informationen zu verfügbaren trainierten Modellen für die LLM-Inferenz-API finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell herunterladen

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.

	Modelle	Conversion-Methode	Kompatible Plattformen	Dateityp
Unterstützte Modelle	Gemma 2B, Gemma 7B, Gemma-2 2B, Phi-2, StableLM, Falcon	MediaPipe	Android, iOS, Web	.bin
Andere PyTorch-Modelle	Alle PyTorch-LLM-Modelle	AI Edge Torch Generative Library	Android, iOS	.task

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.

Modell zum Projektverzeichnis hinzufügen

Speichern Sie das Modell im Projektverzeichnis:

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

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

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

Aufgabe erstellen

Verwenden Sie eine der createFrom...()-Funktionen der LLM Inference API, um die Aufgabe für die Ausführung von Inferenzen vorzubereiten. Sie können die Funktion createFromModelPath() mit einem relativen oder absoluten Pfad zur trainierten Modelldatei verwenden. Im Codebeispiel wird die Funktion createFromOptions() verwendet. Weitere Informationen zu den verfügbaren Konfigurationsoptionen finden Sie unter Konfigurationsoptionen.

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

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-int4.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

Konfigurationsoptionen

Für diese Aufgabe sind die folgenden Konfigurationsoptionen für Web- und JavaScript-Apps verfügbar:

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 „Top-K“-Tokens mit der höchsten Wahrscheinlichkeit.	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 Zufallsstartwert, 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	–

Daten vorbereiten

Die LLM Inference API akzeptiert Textdaten (string). Die Aufgabe übernimmt die Vorverarbeitung der Dateneingabe, einschließlich Tokenisierung und Tensorvorverarbeitung.

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

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

Aufgabe ausführen

Die LLM Inference API verwendet die Funktion generateResponse(), um Inferenzen auszulösen. Bei der Textklassifizierung bedeutet das, dass die möglichen Kategorien für den Eingabetext zurückgegeben werden.

Im folgenden Code wird gezeigt, wie die Verarbeitung mit dem Aufgabenmodell ausgeführt wird.

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

Ergebnisse verarbeiten und anzeigen

Die LLM-Inferenz-API gibt einen String 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-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.

Das Web unterstützt dynamisches LoRA zur Laufzeit. Das heißt, Nutzer deklarieren die LoRA-Ränge, die während der Initialisierung verwendet werden sollen, und können während der Laufzeit verschiedene LoRA-Modelle austauschen.

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 während der Laufzeit, nachdem das Basismodell initialisiert wurde, die zu verwendenden LoRA-Modelle. Außerdem müssen Sie das LoRA-Modell auslösen, indem Sie die LoRA-Modellreferenz beim Generieren der LLM-Antwort ü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;
});