Leitfaden für LLM-Inferenzen

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig auf dem Gerät ausführen und 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 (Text-zu-Text), sodass Sie die neuesten generativen KI-Modelle auf dem Gerät auf Ihre Anwendungen und Produkte anwenden können.

Jetzt ausprobieren

Die Aufgabe unterstützt Gemma 2B und 7B, einen Teil einer Familie von einfachen, modernen offenen Modellen, die auf derselben Forschung und Technologie basieren, die auch für die Erstellung der Gemini-Modelle verwendet wurden. Außerdem werden die folgenden externen Modelle unterstützt: Phi-2, Falcon-RW-1B und StableLM-3B.

Zusätzlich zu den nativ unterstützten Modellen können Nutzer mithilfe der AI Edge-Angebote von Google andere Modelle zuordnen, einschließlich der Zuordnung von PyTorch-Modellen. Dadurch können Nutzer ein zugeordnetes Modell in TensorFlow Lite-Modelle mit mehreren Signaturen exportieren, die mit Tokenizer-Parametern gebündelt sind, um ein Aufgaben-Bundle zu erstellen.

Jetzt starten

Beginnen Sie mit dieser Aufgabe, indem Sie einem dieser Implementierungsleitfäden für Ihre Zielplattform folgen. Diese plattformspezifischen Leitfäden führen Sie durch eine grundlegende Implementierung dieser Aufgabe. Sie enthalten Codebeispiele, die ein verfügbares Modell und die empfohlenen Konfigurationsoptionen verwenden:

Taskdetails

In diesem Abschnitt werden die Funktionen, Eingaben, Ausgaben und Konfigurationsoptionen dieser Aufgabe beschrieben.

Funktionen

Die LLM Inference API umfasst die folgenden Hauptfunktionen:

  1. Text-zu-Text-Generierung: Hiermit wird Text anhand eines eingegebenen Texts generiert.
  2. LLM-Auswahl: Wenden Sie mehrere Modelle an, um die App an Ihre spezifischen Anwendungsfälle anzupassen. Sie können das Modell auch neu trainieren und benutzerdefinierte Gewichtungen darauf anwenden.
  3. LoRA-Unterstützung: Erweitern und passen Sie die LLM-Funktion mit dem LoRA-Modell an. Dazu trainieren Sie entweder mit Ihrem gesamten Dataset oder verwenden vorbereitete LoRA-Modelle aus der Open-Source-Community (nur native Modelle).
Aufgabeneingaben Aufgabenausgaben
Die LLM Inference API akzeptiert die folgenden Eingaben:
  • Text-Prompt (z.B. eine Frage, ein E-Mail-Betreff, ein Dokument, das zusammengefasst werden soll)
 Die LLM Inference API gibt die folgenden Ergebnisse aus:
  • Generierter Text basierend auf der Eingabeaufforderung (z.B. eine Antwort auf die Frage, ein E-Mail-Entwurf, eine Zusammenfassung des Dokuments)

Konfigurationsoptionen

Diese Aufgabe hat die folgenden Konfigurationsoptionen:

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
loraPath Der absolute Pfad zum LoRA-Modell lokal auf dem Gerät. Hinweis: Dies ist nur mit GPU-Modellen kompatibel. PATH –
resultListener Legt den Ergebnis-Listener fest, um die Ergebnisse asynchron zu empfangen. Gilt nur bei Verwendung der asynchronen Generierungsmethode. – –
errorListener Legt einen optionalen Fehler-Listener fest. – –

Modelle

Die LLM Inference API bietet integrierte Unterstützung für durchgängige Text-zu-Text-Large Language Models, die für die Ausführung in Browsern und auf Mobilgeräten optimiert sind. Diese schlanken Modelle können heruntergeladen werden, um Inferenzen vollständig auf dem Gerät auszuführen.

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

Gemma 2B

Gemma 2B ist Teil einer Familie von leichten, hochmodernen offenen Modellen, die auf derselben Forschung und Technologie basieren, die auch für die Erstellung der Gemini-Modelle verwendet wurde. Das Modell enthält 2 Milliarden Parameter und offene Gewichtungen. Dieses Modell eignet sich gut für eine Vielzahl von Aufgaben zur Textgenerierung, einschließlich Fragenbeantwortung, Zusammenfassung und Logik.

Gemma 2B herunterladen

Die Gemma 2B-Modelle gibt es in vier Varianten:

Sie können das Modell auch abstimmen und neue Gewichtungen hinzufügen, bevor Sie es der App hinzufügen. Weitere Informationen zum Abstimmen und Anpassen von Gemma finden Sie unter Gemma abstimmen. Nachdem Sie Gemma von Kaggle Models heruntergeladen haben, ist das Modell bereits im richtigen Format für die Verwendung mit MediaPipe vorhanden.

Wenn Sie Gemma 2B von „Hugging Face“ herunterladen, müssen Sie das Modell in ein MediaPipe-kompatibles Format konvertieren. Für die LLM Inference API müssen die folgenden Dateien heruntergeladen und konvertiert werden:

  • model-00001-of-00002.safetensors
  • model-00002-of-00002.safetensors
  • tokenizer.json
  • tokenizer_config.json

Gemma 7B

Gemma 7B ist ein größeres Gemma-Modell mit 7B-Parametern und offenen Gewichten. Das Modell ist leistungsfähiger für eine Vielzahl von Textgenerierungsaufgaben, einschließlich Fragenbeantwortung, Zusammenfassung und Begründung. Gemma 7B wird nur im Web unterstützt.

Gemma 7B herunterladen

Das Gemma 7B-Modell gibt es in einer Variante:

Wenn Sie Gemma 7B von Hugging Face herunterladen, müssen Sie das Modell in ein MediaPipe-kompatibles Format konvertieren. Für die LLCM Inference API müssen die folgenden Dateien heruntergeladen und konvertiert werden:

  • model-00001-of-00004.safetensors
  • model-00002-of-00004.safetensors
  • model-00003-of-00004.safetensors
  • model-00004-of-00004.safetensors
  • tokenizer.json
  • tokenizer_config.json

Falcon 1B

Falcon-1B ist ein 1-Milliarde Parameter-Modell, das ausschließlich kausalen Decoder dient und mit 350 Milliarden Tokens von RefinedWeb trainiert wurde.

Falcon 1B herunterladen

Für die LLM Inference API müssen die folgenden Dateien heruntergeladen und lokal gespeichert werden:

  • tokenizer.json
  • tokenizer_config.json
  • pytorch_model.bin

Nachdem Sie die Falcon-Modelldateien heruntergeladen haben, kann das Modell in das MediaPipe-Format konvertiert werden. Folgen Sie der Anleitung unter Modell in das MediaPipe-Format konvertieren.

StabileLM 3B

StableLM-3B ist ein 3-Milliarden-Parameter-Decoder-Sprachmodell, das über vier Epochen mit 1 Billion Tokens verschiedener Englisch- und Code-Datasets vortrainiert wurde.

StableLM 3B herunterladen

Für die LLM Inference API müssen die folgenden Dateien heruntergeladen und lokal gespeichert werden:

  • tokenizer.json
  • tokenizer_config.json
  • model.safetensors

Nachdem die StableLM-Modelldateien heruntergeladen wurden, kann das Modell in das MediaPipe-Format konvertiert werden. Folgen Sie der Anleitung unter Modell in das MediaPipe-Format konvertieren.

Phi-2

Phi-2 ist ein Transformer-Modell mit 2,7 Milliarden Parametern. Es wurde mit verschiedenen synthetischen NLP-Texten und gefilterten Websites trainiert. Dieses Modell eignet sich am besten für Prompts mit dem Frage-Antwort-, Chat- und Codeformat.

Phi-2 herunterladen

Für die LLM Inference API müssen die folgenden Dateien heruntergeladen und lokal gespeichert werden:

  • tokenizer.json
  • tokenizer_config.json
  • model-00001-of-00002.safetensors
  • model-00002-of-00002.safetensors

Nach dem Herunterladen der Phi-2-Modelldateien kann das Modell in das MediaPipe-Format konvertiert werden. Folgen Sie der Anleitung unter Modell in das MediaPipe-Format konvertieren.

Exportierte AI Edge-Modelle

AI Edge ist ein Google-Angebot, mit dem Sie von Nutzern zugeordnete Modelle in TensorFlow Lite-Modelle mit mehreren Signaturen umwandeln können. Weitere Informationen zum Zuordnen und Exportieren von Modellen finden Sie auf der GitHub-Seite zu AI Edge Torch.

Nachdem Sie das Modell in das TFLite-Format exportiert haben, kann es in das MediaPipe-Format konvertiert werden. Weitere Informationen finden Sie unter Modell in das MediaPipe-Format konvertieren.

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

LoRA-Anpassung

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.

Android unterstützt die statische LoRA während der Initialisierung. Zum Laden eines LORA-Modells geben Nutzer den LoRA-Modellpfad sowie das Basis-LLM an.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Verwenden Sie dieselben Methoden generateResponse() oder generateResponseAsync() wie für das Basismodell, um LLM-Inferenzen mit LoRA auszuführen.