LLM-Inferenzleitfaden für das Web

<ph type="x-smartling-placeholder">

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig auf der Browser für Webanwendungen, mit dem eine breite Palette von Aufgaben wie das Generieren von Text, das Abrufen von Informationen in natürlicher Sprache, und Zusammenfassen von Dokumenten. Die Aufgabe unterstützt mehrere Large Language Models (Text-zu-Text), damit Sie die neuesten On-Device- generative KI-Modelle in Ihre Webanwendungen einbinden.

Sie können diese Aufgabe in Aktion mit dem MediaPipe Studio Weitere Informationen zu Funktionen, Modellen und Konfigurationsoptionen Sehen Sie sich die Übersicht an.

Codebeispiel

Die Beispielanwendung für die LLM Inference API bietet eine einfache Implementierung als Referenz in JavaScript schreiben. Mit dieser Beispiel-App können Sie mit der Entwicklung einer eigenen App zur Textgenerierung begonnen.

Sie können über die Beispiel-App der LLM Inference API GitHub

Einrichtung

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

Browserkompatibilität

Für die LLM Inference API ist ein Webbrowser mit WebGPU-Kompatibilität erforderlich. Für eine vollständige Liste der kompatiblen Browser siehe GPU-Browser Kompatibilität.

JavaScript-Pakete

Der LLM Inference API-Code ist über die @mediapipe/tasks-genai Paket. Sie können diese Bibliotheken über die Links in der Einrichtungsleitfaden für die Plattform

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

npm install @mediapipe/tasks-genai

Für die Bereitstellung auf einem Server verwenden Sie 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

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

Weitere Informationen zu verfügbaren trainierten Modellen für die LLM Inference API finden Sie in der Aufgabe Übersicht über Modelle.

Modell herunterladen

Bevor Sie die LLM Inference API initialisieren, laden Sie eines der unterstützten Modelle herunter und und speichern Sie die Datei in Ihrem Projektverzeichnis:

  • Gemma: Teil einer Familie von leichten, hochmodernen offenen Modellen, die aus dem der gleichen Forschung und Technologie, die zur Erstellung Gemini-Modelle. Gut geeignet für eine Vielzahl von Aufgaben zur Textgenerierung, einschließlich Fragenbeantwortung, Zusammenfassung und Logik. Laden Sie die Modellvariante Gemma 2B oder Gemma 7B herunter.
  • Phi-2: 2,7 Milliarden Parameter Transformer-Modell, am besten für Frage-Antwort, Chat und Code geeignet Format.
  • Falcon-RW-1B: 1 Milliarde kausaler Decoder-Parameter, das mit 350 Mrd. Tokens von RefinedWeb
  • StableLM-3B: 3 Sprachmodell nur mit Parameterdecoder mit 1 Billion vortrainiert Tokens verschiedener englischer und Code-Datasets.

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

Modell in das MediaPipe-Format konvertieren

Konvertierung des nativen Modells

Wenn Sie ein externes LLM (Phi-2, Falcon oder StableLM) oder ein anderes LLM ohne Kaggle verwenden Version von Gemma, verwenden Sie unsere Conversion-Skripts, um das Modell kompatibel mit MediaPipe.

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

Installieren und importieren Sie die Abhängigkeiten so:

$ python3 -m pip install mediapipe

Verwenden Sie die Bibliothek genai.converter, 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 sollte in ConversionConfig das Basismodell angegeben werden sowie zusätzliche LoRA-Optionen. Da die API nur unterstützt LoRA-Inferenz mit GPU, muss das Back-End auf 'gpu' eingestellt 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 Converter gibt zwei TFLite-Flatbuffer-Dateien aus, eine für das Basismodell und das andere 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 des Modells manchmal in mehrere Dateien aufgeteilt ist, z.B. model-00001-of-00003.safetensors, model-00001-of-00003.safetensors. Sie können ein Dateimuster wie model*.safetensors angeben. PFAD
ckpt_format Das Dateiformat des Modells. {"Safetensors", "pytorch"}
model_type Das LLM, das konvertiert wird. {&quot;PHI_2&quot;, &quot;FALCON_RW_1B&quot;, &quot;STABLELM_4E1T_3B&quot;, &quot;GEMMA_2B&quot;}
backend Der Prozessor (delegieren), der zum Ausführen des Modells verwendet wird. {&quot;cpu&quot;, &quot;gpu&quot;}
output_dir Der Pfad zum Ausgabeverzeichnis, in dem die Dateien für die Gewichtung pro Ebene gehostet werden. PFAD
output_tflite_file Der Pfad zur Ausgabedatei. 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. PFAD
vocab_model_file Der Pfad zum Verzeichnis, in dem tokenizer.json und tokenizer_config.json Dateien. Bewegen Sie bei Gemma den Mauszeiger auf die einzelne tokenizer.model-Datei. PFAD
lora_ckpt Der Pfad zur LoRA-ckpt der Safetensors-Datei, in der die LoRA-Adaptergewichtung gespeichert ist. PFAD
lora_rank Eine Ganzzahl, die den Rang von LoRA-ckpt darstellt. Erforderlich zum Umrechnen der Lora-Gewichtungen. Wenn nicht angegeben, geht der Konverter davon aus, dass keine LoRA-Gewichtungen vorhanden sind. Hinweis: LoRA wird nur vom GPU-Back-End unterstützt. Ganzzahl
lora_output_tflite_file Name der tflite-Ausgabedatei für die LoRA-Gewichtungen. PFAD

AI Edge-Modellkonvertierung

Wenn Sie ein LLM verwenden, das über AI Edge einem TFLite-Modell zugeordnet ist, nutzen Sie unser Bündelskript, um ein Task Bundle zu erstellen. Der Bündelungsprozess mit zusätzlichen Metadaten (z.B. Tokenizer-Parameter) erforderlich um eine End-to-End-Inferenz auszuführen.

Für die Modellbündelung ist das MediaPipe-PyPI-Paket erforderlich. Die Conversion Skript ist in allen MediaPipe-Paketen nach dem 0.10.14 verfügbar.

Installieren und importieren Sie die Abhängigkeiten so:

$ python3 -m pip install mediapipe

Verwenden Sie die Bibliothek genai.bundler, 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 TFLite-Modell von AI Edge. PFAD
tokenizer_model Der Pfad zum SentencePiece-Tokenizer-Modell. PFAD
start_token Modellspezifisches Starttoken. Das Starttoken muss im Feld bereitgestelltes Tokenizer-Modell. STRING
stop_tokens Modellieren Sie spezifische Haltestellentokens. Die Haltestellentokens müssen im bereitgestelltes Tokenizer-Modell. Liste [STRING]
output_filename Der Name der Bundle-Datei der Ausgabeaufgabe. PFAD

Modell zu 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 baseOptions-Objekt modelAssetPath an Parameter:

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

Aufgabe erstellen

Verwenden Sie eine der createFrom...()-Funktionen der LLM Inference API, um die Aufgabe auf ausgeführte Inferenzen. Sie können die createFromModelPath()-Funktion mit einem relativen oder absoluten Pfads zur Datei des trainierten Modells angegeben. Im Codebeispiel wird die Methode createFromOptions(). Weitere Informationen zu den verfügbaren 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. PFAD –
maxTokens Die maximale Anzahl von Tokens (Eingabetokens + Ausgabetokens), die das Modell verarbeitet. Ganzzahl 512
topK Die Anzahl der Tokens, die das Modell bei jedem Generierungsschritt berücksichtigt. Beschränkt Vorhersagen auf die k höchstwahrscheinlichen Tokens. Ganzzahl 40
temperature Der Grad der Zufälligkeit, der bei der Erstellung eingeführt wird. Eine höhere führt die Temperatur zu mehr Kreativität im generierten Text, während ein sorgt bei niedrigeren Temperaturen zu einer vorhersehbaren Erzeugung. Gleitkommazahl 0,8
randomSeed Der bei der Textgenerierung zufällige Startwert. Ganzzahl 0
loraRanks LoRA-Einstufungen, die von den LoRA-Modellen während der Laufzeit verwendet werden. Hinweis: Dies ist nur mit GPU-Modellen kompatibel. Ganzzahl-Array –

Daten vorbereiten

Die LLM Inference API akzeptiert Textdaten (string). Die Aufgabe verarbeitet die Dateneingabe Vorverarbeitung, einschließlich Tokenisierung und Tensor-Vorverarbeitung.

Die gesamte Vorverarbeitung erfolgt über die Funktion generateResponse(). Es gibt keine zusätzliche Vorverarbeitung des Eingabetexts erforderlich ist.

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 dies, dass die möglichen Kategorien für die Text ein.

Der folgende Code zeigt, wie die Verarbeitung mit der Aufgabe ausgeführt wird. modellieren.

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]

Anpassung des LoRA-Modells

Die Mediapipe LLM Inference API kann so konfiguriert werden, dass sie Low-Rank Adaptation (LoRA) unterstützt für Large Language Models. Mit optimierten LoRA-Modellen können Entwickelnde 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 im GPU-Back-End, wobei LoRA-Gewichtungen nur für Aufmerksamkeitsebenen gelten. Dieses Die erste Implementierung dient als experimentelles API für zukünftige Entwicklungen. mit Plänen, in Zukunft weitere Modelle und verschiedene Arten von Ebenen zu unterstützen. Aktualisierungen.

LoRA-Modelle vorbereiten

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

Zu Testzwecken gibt es öffentlich zugängliche, abgestimmte LoRA-Modelle, die zur LLM Inference 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 vorbereitete Dataset trainiert und das Modell gespeichert haben, erhalten Sie eine adapter_model.safetensors-Datei mit den abgestimmten LoRA-Modellgewichtungen. Die Safetensors-Datei ist der bei der Modellkonvertierung verwendete LoRA-Prüfpunkt.

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

Inferenz des LoRA-Modells

Die Web-, Android- und iOS LLM Inference API wurde aktualisiert, um die Inferenz von LoRA-Modellen zu unterstützen. Das Web unterstützt dynamische LoRA, mit denen verschiedene LoRA-Modelle während der Laufzeit gewechselt werden können. Android und iOS unterstützen statische LoRA-Werte, bei denen während der Lebensdauer der Aufgabe dieselben LoRA-Gewichtungen verwendet werden.

Das Web unterstützt dynamische LoRA während der Laufzeit. Das heißt, Nutzer deklarieren die LoRA-Rangs, die während der Initialisierung verwendet werden, und können verschiedene LoRA-Modelle während der Laufzeit 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 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;
});