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. 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 Apps und Produkte anwenden können.

Jetzt testen!arrow_forward

Die Aufgabe bietet integrierte Unterstützung für eine Vielzahl von LLMs. Auf der Seite LiteRT Community gehostete Modelle sind in einem MediaPipe-kompatiblen 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 zu Task-Bundles kombiniert werden. Mit AI Edge Torch konvertierte Modelle sind mit der LLM Inference API kompatibel und können auf dem CPU-Backend ausgeführt werden. Sie eignen sich daher für Android- und iOS-Anwendungen.

Jetzt starten

Folgen Sie einer dieser Implementierungsanleitungen für Ihre Zielplattform, um diese Aufgabe zu verwenden. In diesen plattformspezifischen Anleitungen erfahren Sie, wie Sie diese Aufgabe mithilfe von Codebeispielen, die ein verfügbares Modell und die empfohlenen Konfigurationsoptionen verwenden, implementieren:

• Web:

  • Leitfaden
  • Codebeispiel

• Android:

  • Leitfaden
  • Codebeispiel

• iOS

  • Leitfaden
  • Codebeispiel

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: Text wird anhand eines Eingabetext-Prompts generiert.
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 darauf anwenden.
3. LoRA-Unterstützung: Sie können die LLM-Funktionen mit einem LoRA-Modell erweitern und anpassen. Dazu können Sie entweder Ihren gesamten Datensatz verwenden oder vorgefertigte LoRA-Modelle aus der Open-Source-Community verwenden. Diese sind nicht mit Modellen kompatibel, die mit der AI Edge Torch Generative API konvertiert wurden.

Konfigurationsoptionen

Für diese Aufgabe stehen die folgenden Konfigurationsoptionen zur Verfügung:

Modelle

Die LLM Inference API unterstützt viele Large Language Models für die Text-zu-Text-Transformation, einschließlich der integrierten Unterstützung für mehrere Modelle, die für die Ausführung in Browsern und auf Mobilgeräten optimiert sind. Mit diesen schlanken Modellen können Inferenzen vollständig auf dem Gerät ausgeführt werden.

Bevor Sie die LLM Inference API initialisieren, laden Sie ein Modell herunter und speichern Sie die Datei im Projektverzeichnis. Sie können ein vorab konvertiertes Modell aus dem HuggingFace-Repository der LiteRT Community verwenden oder ein Modell mit dem AI Edge Torch Generative Converter in ein MediaPipe-kompatibles Format konvertieren.

Wenn Sie noch kein LLM für die LLM Inference API haben, können Sie mit einem der folgenden Modelle beginnen.

Gemma-3 1B

Gemma-3 1B ist das neueste Modell der Gemma-Familie leichter, hochmoderner offener Modelle, die auf derselben Forschung und Technologie basieren, die auch für die Erstellung der Gemini-Modelle verwendet werden. Das Modell enthält 1 Milliarden Parameter und offene Gewichtungen. Die 1B-Variante ist das leichteste Modell der Gemma-Familie und eignet sich daher ideal für viele On-Device-Anwendungsfälle.

Gemma-3 1B herunterladen

Das Gemma-3 1B-Modell von HuggingFace ist im .task-Format 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-Back-End wählen. Diese Option ist nur für Android verfügbar.
• supportedLoraRanks: Die LLM Inference API kann nicht so konfiguriert werden, dass sie die Low-Rank Adaptation (LoRA) mit dem Gemma-3 1B-Modell unterstützt. Verwenden Sie nicht die Optionen supportedLoraRanks oder loraRanks.
• maxTokens: Der Wert für maxTokens muss mit der im Modell integrierten Kontextgröße übereinstimmen. Dieser Wert wird auch als Schlüssel/Wert-Cache (KV-Cache) oder Kontextlänge bezeichnet.
• numResponses: Muss immer „1“ sein. Diese Option ist nur im Web verfügbar.

Wenn Sie Gemma-3 1B in Webanwendungen ausführen, kann die Initialisierung zu einem langen Blockieren des aktuellen Threads führen. Führen Sie das Modell nach Möglichkeit immer über einen 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 Gewichtungen. Gemma-2 2B ist für seine fortschrittlichen Fähigkeiten zur Argumentation bekannt.

PyTorch-Modellkonvertierung

Mit der AI Edge Torch Generative API können generative PyTorch-Modelle 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.

So wandeln Sie ein PyTorch-Modell mit der AI Edge Torch Generative API um:

1. Laden Sie die PyTorch-Modellprüfpunkte herunter.
2. Verwende die AI Edge Torch Generative API, um das Modell zu erstellen, zu konvertieren und in ein MediaPipe-kompatibles Dateiformat (.tflite) zu quantisieren.
3. Erstellen Sie ein Task-Bundle (.task) aus der TFLite-Datei und dem Modell-Tokenisierer.

Der Torch Generative-Konverter kann nur auf der CPU ausgeführt werden und erfordert einen Linux-Rechner mit mindestens 64 GB RAM.

Verwenden Sie das Bündelungsscript, um ein Task-Bundle zu erstellen. Beim Bündelungsprozess wird das zugeordnete Modell mit zusätzlichen Metadaten (z.B. Tokenizer-Parameter), die für die End-to-End-Inferenz erforderlich sind.

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

Installieren und importieren Sie die Abhängigkeiten mit folgendem 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)

LoRA-Anpassung

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 bei Hugging Face 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 das Web, Android und iOS wurde aktualisiert, um die Inferenz von LoRA-Modellen zu unterstützen.

// 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 für die LLM-Inferenz mit LoRA dieselben generateResponse()- oder generateResponseAsync()-Methoden wie für das Basismodell.