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. Damit lassen sich viele Aufgaben erledigen, 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 Text-zu-Text-Anwendungen, sodass Sie die neuesten generativen KI-Modelle auf dem Gerät in Ihren Apps und Produkten einsetzen können.

Jetzt ausprobieren

Die Aufgabe bietet integrierte Unterstützung für eine Vielzahl von LLMs. Modelle, die auf der Seite LiteRT Community gehostet werden, sind in einem MediaPipe-freundlichen Format verfügbar und erfordern keine zusätzlichen Konvertierungs- oder Kompilierungsschritte.

Mit AI Edge Torch können Sie PyTorch-Modelle in LiteRT-Modelle (tflite) mit mehreren Signaturen exportieren, die mit Tokenizer-Parametern gebündelt werden, um Task-Bundles zu erstellen. Mit AI Edge Torch konvertierte Modelle sind mit der LLM Inference API kompatibel und können im CPU-Backend ausgeführt werden. Daher eignen sie sich für Android- und iOS-Anwendungen.

Jetzt starten

Folgen Sie einer der Implementierungsanleitungen für Ihre Zielplattform, um diese Aufgabe zu verwenden. In diesen plattformspezifischen Anleitungen wird die grundlegende Implementierung dieser Aufgabe beschrieben. Die Codebeispiele verwenden ein verfügbares Modell und die empfohlenen Konfigurationsoptionen:

Taskdetails

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

Funktionen

Die LLM Inference API enthält die folgenden Hauptfunktionen:

  1. Text-zu-Text-Generierung: Generieren Sie Text basierend auf einem Text-Prompt.
  2. LLM-Auswahl: Sie können mehrere Modelle anwenden, um die App an Ihre spezifischen Anwendungsfälle anzupassen. Sie können das Modell auch neu trainieren und benutzerdefinierte Gewichte anwenden.
  3. LoRA-Unterstützung: Erweitern und passen Sie die LLM-Funktionen mit einem LoRA-Modell an, indem Sie es entweder mit Ihrem gesamten Dataset trainieren oder vorbereitete, vorgefertigte LoRA-Modelle aus der Open-Source-Community verwenden (nicht kompatibel mit Modellen, die mit der AI Edge Torch Generative API konvertiert wurden).
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 dem Eingabe-Prompt (z.B. eine Antwort auf die Frage, ein E‑Mail-Entwurf, eine Zusammenfassung des Dokuments)

Konfigurationsoptionen

Für diese Aufgabe sind die folgenden Konfigurationsoptionen verfügbar:

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 wahrscheinlichsten Tokens. Ganzzahl 40
temperature Der Grad der Zufälligkeit, der während 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 während der Textgenerierung verwendete Zufalls-Seed. Ganzzahl 0
loraPath Der absolute Pfad zum LoRA-Modell lokal auf dem Gerät. Hinweis: Dies ist nur mit GPU-Modellen kompatibel. PFAD –
resultListener Legt den Ergebnis-Listener fest, der die Ergebnisse asynchron empfangen soll. Gilt nur, wenn die asynchrone Generierungsmethode verwendet wird. – –
errorListener Legt einen optionalen Fehler-Listener fest. – –

Modelle

Die LLM Inference API unterstützt viele Large Language Models für Text-zu-Text-Anwendungen, darunter mehrere Modelle, die für die Ausführung in Browsern und auf Mobilgeräten optimiert sind. Diese einfachen Modelle können verwendet werden, um Inferenzvorgänge vollständig auf dem Gerät auszuführen.

Bevor Sie die LLM Inference API initialisieren, laden Sie ein Modell herunter und speichern Sie die Datei in Ihrem Projektverzeichnis. Sie können ein vorkonvertiertes Modell aus dem LiteRT Community-Repository von Hugging Face verwenden oder ein Modell mit dem AI Edge Torch Generative Converter in ein MediaPipe-kompatibles Format konvertieren.

Wenn Sie noch kein LLM haben, das Sie mit der LLM Inference API verwenden können, beginnen Sie mit einem der folgenden Modelle.

Gemma-3n

Gemma-3n E2B und E4B sind die neuesten Modelle der Gemma-Familie, die aus leichten, hochmodernen offenen Modellen besteht, die auf derselben Forschung und Technologie basieren, die auch zum Erstellen der Gemini-Modelle verwendet werden. Gemma 3n-Modelle sind für die effiziente Ausführung auf Geräten mit geringen Ressourcen konzipiert. Sie können multimodale Eingaben verarbeiten, also Text-, Bild- und Audioeingaben, und Textausgaben generieren.

Gemma 3n-Modelle verwenden die Technologie der selektiven Parameteraktivierung, um den Ressourcenbedarf zu senken. Mit dieser Technik können die Modelle mit einer effektiven Größe von 2 Mrd. und 4 Mrd. Parametern arbeiten, was weniger ist als die Gesamtzahl der Parameter, die sie enthalten.

Gemma-3n E2B herunterladen

Gemma-3n E4B herunterladen

Die Modelle Gemma-3n E2B und E4B von HuggingFace sind im .litertlm-Format verfügbar und können mit der LLM Inference API für Android verwendet werden.

Gemma-3 1B

Gemma-3 1B ist das leichteste Modell der Gemma-Familie, die aus leichten, hochmodernen offenen Modellen besteht, die auf derselben Forschung und Technologie basieren, die auch zum Erstellen der Gemini-Modelle verwendet werden. Das Modell enthält 1 Milliarde Parameter und offene Gewichte.

Gemma-3 1B herunterladen

Das Modell Gemma-3 1B von HuggingFace ist im Format .task/.litertlm verfügbar und kann mit der LLM Inference API für Android- und Webanwendungen verwendet werden.

Wenn Sie Gemma-3 1B mit der LLM Inference API ausführen, konfigurieren Sie die folgenden Optionen entsprechend:

  • preferredBackend: Mit dieser Option können Sie zwischen einem CPU- oder GPU-Backend wählen. Diese Option ist nur für Android verfügbar.
  • supportedLoraRanks: Die LLM Inference API kann nicht für die Unterstützung von Low-Rank Adaptation (LoRA) mit dem Modell Gemma-3 1B konfiguriert werden. Verwenden Sie nicht die Optionen supportedLoraRanks oder loraRanks.
  • maxTokens: Der Wert für maxTokens muss mit der im Modell integrierten Kontextgröße übereinstimmen. Dies wird auch als Key-Value-Cache (KV-Cache) oder Kontextlänge bezeichnet.
  • numResponses: Muss immer 1 sein. Diese Option ist nur für das Web verfügbar.

Wenn Gemma-3 1B in Webanwendungen ausgeführt wird, kann die Initialisierung zu einer längeren Blockierung des aktuellen Threads führen. Führen Sie das Modell nach Möglichkeit immer in einem Worker-Thread aus.

Gemma-2 2B

Gemma-2 2B ist eine 2B-Variante von Gemma-2 und funktioniert auf allen Plattformen.

Gemma-2 2B herunterladen

Das Modell enthält 2 Milliarden Parameter und offene Gewichte. Gemma-2 2B ist für seine hochmodernen Schlussfolgerungsfähigkeiten für Modelle seiner Klasse bekannt.

PyTorch-Modellkonvertierung

Generative PyTorch-Modelle können mit der AI Edge Torch Generative API in ein MediaPipe-kompatibles Format konvertiert werden. Mit der API können Sie PyTorch-Modelle in LiteRT-Modelle (TensorFlow Lite) mit mehreren Signaturen konvertieren. Weitere Informationen zum Zuordnen und Exportieren von Modellen finden Sie auf der GitHub-Seite von AI Edge Torch.

Die Konvertierung eines PyTorch-Modells mit der AI Edge Torch Generative API umfasst die folgenden Schritte:

  1. Laden Sie die PyTorch-Modellprüfpunkte herunter.
  2. Mit der AI Edge Torch Generative API können Sie das Modell in ein MediaPipe-kompatibles Dateiformat (.tflite) schreiben, konvertieren und quantisieren.
  3. Erstellen Sie ein Task-Bundle (.task/.litertlm) aus der tflite-Datei und dem Modell-Tokenizer.

Der Torch Generative-Konverter ist nur für CPUs geeignet und erfordert einen Linux-Computer mit mindestens 64 GB RAM.

Verwenden Sie zum Erstellen eines Task-Bundles das Bundling-Script, um ein Task-Bundle zu erstellen. Beim Bündeln wird das zugeordnete Modell mit zusätzlichen Metadaten verpackt (z.B. Tokenizer-Parameter) erforderlich, um die End-to-End-Inferenz auszuführen.

Für das Bündeln von Modellen ist das MediaPipe-PyPI-Paket erforderlich. Das Conversion-Script ist nach 0.10.14 in allen MediaPipe-Paketen verfügbar.

Installieren und importieren Sie die Abhängigkeiten mit dem folgenden Befehl:

$ python3 -m pip install mediapipe

Verwenden Sie 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 TFLite-Modell von AI Edge. PFAD
tokenizer_model Der Pfad zum SentencePiece-Tokenizer-Modell. PFAD
start_token Modellspezifisches Starttoken. Das Starttoken muss im bereitgestellten Tokenizierungsmodell vorhanden sein. STRING
stop_tokens Modellspezifische Stopp-Tokens. Die Stopp-Tokens müssen im bereitgestellten Tokenizer-Modell vorhanden sein. LIST[STRING]
output_filename Der Name der Ausgabedatei des Aufgaben-Bundles. PFAD

LoRA-Anpassung

Die MediaPipe LLM Inference API kann so konfiguriert werden, dass sie LoRA (Low-Rank Adaptation) für Large Language Models unterstützt. Mit feinabgestimmten 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 alle Gemma-Varianten und Phi-2-Modelle für das GPU-Backend. LoRA-Gewichte sind nur für Attention-Ebenen anwendbar. Diese erste Implementierung dient als experimentelle API für zukünftige Entwicklungen. In den kommenden Updates sollen weitere Modelle und verschiedene Arten von Layern unterstützt werden.

LoRA-Modelle vorbereiten

Folgen Sie der Anleitung auf HuggingFace, um ein feinabgestimmtes LoRA-Modell mit Ihrem eigenen Dataset mit unterstützten Modelltypen (Gemma oder Phi-2) zu trainieren. Die Modelle Gemma-2 2B, Gemma 2B und Phi-2 sind beide auf Hugging Face im safetensors-Format verfügbar. Da die LLM Inference API nur LoRA auf Attention-Layern unterstützt, geben Sie beim Erstellen von LoraConfig nur Attention-Layer 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 sind öffentlich zugängliche, optimierte LoRA-Modelle verfügbar, die zur LLM Inference API auf HuggingFace passen. Beispiele: monsterapi/gemma-2b-lora-maths-orca-200k für Gemma-2B und lole25/phi-2-sft-ultrachat-lora für Phi-2.

Nach dem Training mit dem vorbereiteten Dataset und dem Speichern des Modells erhalten Sie eine adapter_model.safetensors-Datei mit den feinabgestimmten LoRA-Modellgewichten. Die Safetensors-Datei ist der LoRA-Checkpoint, der bei der Modellkonvertierung verwendet wird.

Als Nächstes müssen Sie die Modellgewichte mit dem MediaPipe Python-Paket in einen TensorFlow Lite-Flatbuffer konvertieren. Im ConversionConfig sollten sowohl die Optionen für das Basismodell als auch zusätzliche LoRA-Optionen angegeben werden. Da die API nur LoRA-Inferenz mit GPU unterstützt, muss das Backend 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 Konverter gibt zwei TFLite-Flatbuffer-Dateien aus, eine für das Basismodell und eine für das LoRA-Modell.

LoRA-Modellinferenz

Die LLM Inference API für Web, Android und iOS wurde aktualisiert, um die Inferenz von LoRA-Modellen zu unterstützen.

Android unterstützt statische LoRA während der Initialisierung. Um ein LoRA-Modell zu laden, 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)

Wenn Sie LLM-Inferenz mit LoRA ausführen möchten, verwenden Sie dieselben generateResponse()- oder generateResponseAsync()-Methoden wie für das Basismodell.