Leitfaden für LLM-Inferenzen

Mit der LLM Inference API können Sie Large Language Models (LLMs) vollständig ausführen mit denen eine Vielzahl von Aufgaben ausgeführt werden kann, z. B. das Generieren von Text, das Abrufen von Informationen in natürlicher Sprache das Zusammenfassen von Dokumenten. Die Aufgabe unterstützt mehrere Large Language Models (Text-zu-Text), damit Sie die neuesten On-Device- auf generativer KI basierende Modelle für Ihre Apps und Produkte.

<ph type="x-smartling-placeholder"></ph> Jetzt testen!arrow_forward

Die Aufgabe unterstützt Gemma 2B und 7B, ein Teil von eine Familie leichter, hochmoderner offener Modelle, die aus derselben Forschung und Technologie zur Entwicklung von Gemini Modelle. Außerdem werden die folgenden externen Modelle unterstützt: Phi-2 Falcon-RW-1B und StableLM-3B.

Neben den nativ unterstützten Modellen können Nutzer auch andere Modelle mit AI Edge von Google Angebote (einschließlich PyTorch-Modelle zuordnen). Dadurch können Nutzer ein zugeordnetes Modell in die Mehrfachsignatur exportieren TensorFlow Lite-Modelle, die mit Tokenizer-Parametern gebündelt sind, ein Aufgaben-Bundle zu erstellen.

Jetzt starten

Beginnen Sie mit dieser Aufgabe, indem Sie einen dieser Implementierungsleitfäden für Ihr Zielplattform. Diese plattformspezifischen Anleitungen führen Sie durch Implementierung dieser Aufgabe mit Codebeispielen, die ein verfügbares Modell und empfohlenen Konfigurationsoptionen:

• Web:

  • Leitfaden
  • Google Code Beispiel

• Android:

  • Leitfaden
  • Google Code Beispiel

• iOS

  • Leitfaden
  • Google Code Beispiel

Taskdetails

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

Funktionen

Die LLM Inference API enthält die folgenden Hauptfunktionen:

1. Text-zu-Text-Generierung: Hiermit wird Text basierend auf einem eingegebenen Text-Prompt generiert.
2. LLM-Auswahl – mehrere Modelle anwenden, um die App an Ihre Bedürfnisse anzupassen für bestimmte Anwendungsfälle. Sie können das Modell auch neu trainieren und modellieren.
3. LoRA-Unterstützung – Die LLM-Funktion mit dem LoRA-Modell erweitern und anpassen entweder durch Training mit Ihrem gesamten Dataset oder durch eine vorbereitete vordefinierte LoRA aus der Open-Source-Community (nur native Modelle).

Konfigurationsoptionen

Diese Aufgabe hat die folgenden Konfigurationsoptionen:

Modelle

Die LLM Inference API unterstützt die trennbare Text-zu-Text- Language Models, die für die Ausführung in Browsern und auf Mobilgeräten optimiert sind. Diese schlanke Modelle können heruntergeladen werden, um Inferenzen vollständig auf dem Gerät auszuführen.

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

Gemma 2B

Gemma 2B ist Teil einer Familie von leichten, hochmodernen offenen Modellen, die auf derselben Forschung Technologie, mit der die Gemini-Modelle erstellt werden. Die Modell 2 Mrd. Parameter und offene Gewichtungen enthält. Dieses Modell eignet sich gut für wie Fragen beantworten, Zusammenfassungen erstellen, und logischen Schlussfolgerungen.

<ph type="x-smartling-placeholder"></ph> Gemma 2B herunterladen

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

• gemma-2b-it-cpu-int4: Gemma 2B 4-Bit-Modell mit CPU-Kompatibilität.
• gemma-2b-it-cpu-int8: Gemma 2B 8-Bit-Modell mit CPU-Kompatibilität.
• gemma-2b-it-gpu-int4: Gemma 2B-4-Bit-Modell mit GPU-Kompatibilität.
• gemma-2b-it-gpu-int8: Gemma 2B-8-Bit-Modell mit GPU-Kompatibilität.

Sie können das Modell auch abstimmen und neue Gewichtungen hinzufügen, bevor Sie es der App hinzufügen. Für Weitere Informationen zum Abstimmen und Anpassen von Gemma finden Sie unter Gemma abstimmen. Nachdem Sie Gemma von Kaggle Models heruntergeladen haben, Das Modell liegt bereits im geeigneten Format für MediaPipe vor.

Wenn Sie Gemma 2B von Hugging herunterladen Gesicht, müssen Sie konvertieren in ein MediaPipe-freundliches Format konvertieren. Die LLM Inference API erfordert, dass 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 Parameter und offene Gewichtungen. Das Modell ist leistungsfähiger für eine Vielzahl von Texten, Generierungsaufgaben, einschließlich Fragenbeantwortung, Zusammenfassung und Schlussfolgerung. Gemma 7B wird nur im Web unterstützt.

<ph type="x-smartling-placeholder"></ph> Gemma 7B herunterladen

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

• gemma-1.1-7b-it-gpu-int8: Gemma 7B 8-Bit-Modell mit GPU-Kompatibilität.

Wenn Sie Gemma 7B von Hugging Face herunterladen, müssen Sie das Modell in ein MediaPipe-freundliches Format konvertieren. Die Für die LLM 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 Kausal-Decoder-Modell mit 1 Milliarde Parametern, das mit 350B trainiert wurde Tokens von RefinedWeb gefunden.

<ph type="x-smartling-placeholder"></ph> Falcon 1B herunterladen

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

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

Nach dem Herunterladen der Falcon-Modelldateien kann das Modell konvertiert werden in das MediaPipe-Format. Führen Sie die Schritte unter Modell in MediaPipe umwandeln Format.

StableLM 3B

StableLM-3B ist ein Sprachmodell, das nur 3 Milliarden Parameter umfasst, 1 Billion Tokens an vielfältigen englischen und Code-Datasets über 4 Epochen

<ph type="x-smartling-placeholder"></ph> StableLM 3B herunterladen

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

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

Nachdem Sie die StableLM-Modelldateien heruntergeladen haben, kann das Modell konvertiert werden in das MediaPipe-Format. Führen Sie die Schritte unter Modell in MediaPipe umwandeln Format.

Phi-2

Phi-2 ist ein Transformer-Modell mit 2,7 Milliarden Parametern. Sie wurde mit verschiedenen Synthetische NLP-Texte und gefilterte Websites Das Modell eignet sich am besten für Prompts mit dem Format „Frage-Antwort“, „Chat“ und „Code“.

<ph type="x-smartling-placeholder"></ph> Phi-2 herunterladen

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

• 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 konvertiert werden in das MediaPipe-Format. Führen Sie die Schritte unter Modell in MediaPipe umwandeln Format.

Exportierte AI Edge-Modelle

AI Edge ist ein Angebot von Google, mit dem Sie vom Nutzer zugeordnete Modelle konvertieren können in TensorFlow Lite-Modelle mit mehreren Signaturen umwandeln. Weitere Informationen zur Zuordnung und dem Export von Modellen, besuchen Sie die Seite „AI Edge Torch“ GitHub-Seite

Nach dem Exportieren des Modells in das TFLite-Format ist es einsatzbereit. in das MediaPipe-Format konvertiert. Weitere Informationen finden Sie unter Konvertieren Sie das Modell in das MediaPipe-Format.

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.

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)

LoRA-Anpassung

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.

// 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 zum Ausführen von LLM-Inferenzen mit LoRA dieselben generateResponse()- oder generateResponseAsync()-Methoden wie das Basismodell.