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 das Web

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig im Browser für Webanwendungen ausführen, um eine Vielzahl von Aufgaben auszufü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 (Text-zu-Text), sodass Sie die neuesten generativen KI-Modelle auf dem Gerät auf Ihre Webanwendungen 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

Die Beispielanwendung für die LLM Inference API bietet eine einfache Implementierung dieser Aufgabe in JavaScript als Referenz. Sie können diese Beispiel-App verwenden, um Ihre eigene Textgenerierungs-App zu erstellen.

Sie können auf die Beispiel-App für die LLM Inference API auf GitHub zugreifen.

Einrichtung

In diesem Abschnitt werden die wichtigsten Schritte zum Einrichten Ihrer Entwicklungsumgebung und Codeprojekte speziell für die Verwendung der LLM Inference API beschrieben. Allgemeine Informationen zum Einrichten der Entwicklungsumgebung für MediaPipe Tasks, einschließlich der 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 im Paket @mediapipe/tasks-genai verfügbar. Sie können diese Bibliotheken über die Links im Einrichtungsleitfaden für die Plattform herunterladen.

Installieren Sie die erforderlichen Pakete für das lokale Staging:

npm install @mediapipe/tasks-genai

Verwenden Sie für die Bereitstellung auf einem Server einen Content Delivery Network-Dienst (CDN) wie jsDelivr, um Code direkt auf Ihrer HTML-Seite einzufügen:

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

Modell

Die MediaPipe LLM Inference API erfordert ein trainiertes Modell, 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 Inference API finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell herunterladen

Laden Sie vor dem Initialisieren der LLM Inference API eines der unterstützten Modelle herunter und speichern Sie die Datei in Ihrem Projektverzeichnis:

Gemma: Teil einer Familie von einfachen, modernen offenen Modellen, die auf derselben Forschung und Technologie basieren, die auch zum Erstellen der Gemini-Modelle verwendet wird. Eignet sich gut für eine Vielzahl von Aufgaben zur Textgenerierung, einschließlich Fragenbeantwortung, Zusammenfassung und Logik. Laden Sie entweder die Modellvariante Gemma 2B oder Gemma 7B herunter.
Phi-2: Transformer-Modell mit 2, 7 Milliarden Parametern, das sich am besten für das Frage-Antwort-, Chat- und Codeformat eignet.
Falcon-RW-1B: 1 Milliarde Parametermodell, das nur mit kausalen Decodern arbeitet und mit 350 Mrd. Tokens von RefinedWeb trainiert wurde.
StableLM-3B: 3 Milliarden Sprachmodell für Decodierer, das mit 1 Billion Tokens verschiedener Englisch- und Code-Datasets vortrainiert wurde.

Wir empfehlen die Verwendung von Gemma 2B oder Gemma 7B, die auf Kaggle-Modellen verfügbar sind und in einem Format vorliegen, das bereits mit der LLM Inference API kompatibel ist. Wenn Sie ein anderes LLM verwenden, müssen Sie das Modell in ein MediaPipe-kompatibles Format konvertieren. Weitere Informationen zu Gemma finden Sie auf der Gemma-Website. Weitere Informationen zu den anderen verfügbaren Modellen finden Sie in der Aufgabenübersicht im Abschnitt „Modelle“.

Modell in das MediaPipe-Format konvertieren

Conversion für natives Modell

Wenn Sie ein externes LLM (Phi-2, Falcon oder StableLM) oder eine Nicht-Kaggle-Version von Gemma verwenden, formatieren Sie das Modell mithilfe unserer Konvertierungsskripts so, dass es mit MediaPipe kompatibel ist.

Für den Modellkonvertierungsprozess ist das MediaPipe-PyPI-Paket erforderlich. Das Konvertierungsskript ist nach dem 0.10.11 in allen MediaPipe-Paketen verfügbar.

Installieren und importieren Sie die Abhängigkeiten mit Folgendem:

$ python3 -m pip install mediapipe

Verwenden Sie die genai.converter-Bibliothek, um das Modell zu konvertieren:

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Zum Konvertieren des LoRA-Modells sollten in ConversionConfig die Basismodelloptionen sowie zusätzliche LoRA-Optionen angegeben werden. Da die API nur LoRA-Inferenz 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.

Parameter	Beschreibung	Zulässige Werte
`input_ckpt`	Der Pfad zur Datei `model.safetensors` oder `pytorch.bin`. Beachten Sie, dass das Safetensors-Format für das Modell manchmal in mehrere Dateien fragmentiert wird, z.B. `model-00001-of-00003.safetensors`, `model-00001-of-00003.safetensors`. Sie können ein Dateimuster wie `model*.safetensors` angeben.	PATH
`ckpt_format`	Das Modelldateiformat.	{"safetensors", "pytorch"}
`model_type`	Das LLM, das konvertiert wird.	{"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
`backend`	Der Prozessor (Bevollmächtigte), der zum Ausführen des Modells verwendet wird.	{"cpu", "gpu"}
`output_dir`	Der Pfad zum Ausgabeverzeichnis, in dem die Gewichtungsdateien pro Ebene gehostet werden.	PATH
`output_tflite_file`	Der Pfad zur Ausgabedatei. Zum Beispiel: "model_cpu.bin" oder "model_gpu.bin". Diese Datei ist nur mit der LLM Inference API kompatibel und kann nicht als allgemeine TFlite-Datei verwendet werden.	PATH
`vocab_model_file`	Der Pfad zu dem Verzeichnis, in dem die Dateien `tokenizer.json` und `tokenizer_config.json` gespeichert sind. Verweisen Sie bei Gemma auf die einzelne Datei `tokenizer.model`.	PATH
`lora_ckpt`	Der Pfad zur LoRA-ckpt der Safetensors-Datei, in der die Gewichtung des LoRA-Adapters gespeichert ist.	PATH
`lora_rank`	Eine Ganzzahl, die den Rang von LoRA ckpt darstellt. Erforderlich für die Umrechnung der Lora-Gewichtungen. Wenn nicht angegeben, geht der Conversion-Wert davon aus, dass keine LoRA-Gewichtungen vorhanden sind. Hinweis: Nur das GPU-Backend unterstützt LoRA.	Integer
`lora_output_tflite_file`	Ausgabe des TFlite-Dateinamens für die LoRA-Gewichtungen.	PATH

AI Edge-Modellkonvertierung

Wenn Sie ein LLM verwenden, das einem TFLite-Modell über AI Edge zugeordnet ist, verwenden Sie unser Bündelungsskript, um ein Task Bundle zu erstellen. Bei der Bündelung wird das zugeordnete Modell mit zusätzlichen Metadaten verpackt (z.B. Tokenizer-Parameter) erforderlich sind, um End-to-End-Inferenzen auszuführen.

Für den Modellbündelungsprozess ist das MediaPipe-PyPI-Paket erforderlich. Das Konvertierungsskript ist nach dem 0.10.14 in allen MediaPipe-Paketen verfügbar.

Installieren und importieren Sie die Abhängigkeiten mit Folgendem:

$ python3 -m pip install mediapipe

Verwende die genai.bundler-Bibliothek, um das Modell zu bündeln:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Parameter	Beschreibung	Zulässige Werte
`tflite_model`	Der Pfad zum exportierten AI Edge-TFLite-Modell.	PATH
`tokenizer_model`	Der Pfad zum SentencePiece-Tokenizer-Modell.	PATH
`start_token`	Modellspezifisches Starttoken. Das Starttoken muss im angegebenen Tokenizer-Modell vorhanden sein.	STRING
`stop_tokens`	Modellspezifische Stopptokens. Die Stopptokens müssen im angegebenen Tokenizer-Modell vorhanden sein.	LISTE[STRING]
`output_filename`	Der Name der Ausgabe-Task-Bundle-Datei.	PATH

Modell zum Projektverzeichnis hinzufügen

Speichern Sie das Modell in Ihrem Projektverzeichnis:

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

Geben Sie den Pfad des Modells mit dem Parameter baseOptions des modelAssetPath-Objekts 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 das Ausführen von Inferenzen vorzubereiten. Sie können die Funktion createFromModelPath() mit einem relativen oder absoluten Pfad zur Datei des trainierten Modells verwenden. In diesem Codebeispiel wird die Funktion createFromOptions() verwendet. Weitere Informationen zu den verfügbaren Konfigurationsoptionen finden Sie unter Konfigurationsoptionen.

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

Diese Aufgabe bietet die folgenden Konfigurationsoptionen für Web- und JavaScript-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
`loraRanks`	Das LoRA-Rang, das von den LoRA-Modellen während der Laufzeit verwendet werden soll. Hinweis: Dies 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 Tensor-Vorverarbeitung.

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

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

Task ausführen

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

Der folgende Code zeigt, wie die Verarbeitung mit dem Aufgabenmodell ausgeführt wird.

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

Verwenden Sie folgenden Code, um die Antwort zu streamen:

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

Ergebnisse verarbeiten und anzeigen

Die LLM Inference 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 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.

Das Web unterstützt während der Laufzeit dynamische LoRA. Das heißt, Nutzer deklarieren die LoRA-Ränge, die während der Initialisierung verwendet werden, 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 die zu verwendenden LoRA-Modelle, nachdem das Basismodell initialisiert wurde. Lösen Sie außerdem das LoRA-Modell aus, indem Sie beim Generieren der LLM-Antwort die LoRA-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;
});