vLLM-Bereitstellung für Nur-Text- und multimodale Sprachmodelle auf Cloud-GPUs

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Zusammenfassung

In dieser Anleitung erfahren Sie, wie Sie Llama 3.1- und 3.2-Modelle mit vLLM in Vertex AI bereitstellen und ausführen. Es ist für die Verwendung in Verbindung mit zwei separaten Notebooks konzipiert: Llama 3.1 mit vLLM bereitstellen zum Bereitstellen von Llama 3.1-Modellen mit reinem Text und Multimodales Llama 3.2 mit vLLM bereitstellen zum Bereitstellen von Llama 3.2-Multimodel-Modellen, die sowohl Text- als auch Bildeingaben verarbeiten. Die auf dieser Seite beschriebenen Schritte zeigen Ihnen, wie Sie Modellinferenzen auf GPUs effizient verarbeiten und Modelle für verschiedene Anwendungen anpassen. So erhalten Sie die Tools, mit denen Sie erweiterte Sprachmodelle in Ihre Projekte einbinden können.

Am Ende dieses Leitfadens wissen Sie, wie Sie:

• Laden Sie vordefinierte Llama-Modelle von Hugging Face mit vLLM-Container herunter.
• Mit vLLM können Sie diese Modelle auf GPU-Instanzen in Google Cloud Vertex AI Model Garden bereitstellen.
• Modelle effizient bereitstellen, um Inferenzanfragen im großen Maßstab zu verarbeiten.
• Führen Sie die Inferenz für Anfragen mit nur Text und Anfragen mit Text und Bild aus.
• Sie setzen alles wieder zurück.
• Bereitstellung debuggen

Wichtige Features von vLLM

Google Vertex AI vLLM-Anpassungen: Leistung und Einbindung verbessern

Die vLLM-Implementierung in Google Vertex AI Model Garden ist keine direkte Einbindung der Open-Source-Bibliothek. Vertex AI verwaltet eine benutzerdefinierte und optimierte Version von vLLM, die speziell auf die Leistungssteigerung, Zuverlässigkeit und nahtlose Integration in die Google Cloudausgerichtet ist.

• Leistungsoptimierungen:
  • Paralleles Herunterladen aus Cloud Storage:Durch parallelen Datenabruf aus Cloud Storage werden die Modelllade- und Bereitstellungszeiten erheblich beschleunigt, die Latenz verringert und die Startgeschwindigkeit verbessert.
• Funktionsverbesserungen:
  • Dynamische LoRA-Funktionen mit erweitertem Caching und Cloud Storage-Unterstützung:Die dynamischen LoRA-Funktionen werden durch lokales Laufwerk-Caching und eine robuste Fehlerbehandlung erweitert. Außerdem wird das Laden von LoRA-Gewichten direkt aus Cloud Storage-Pfaden und signierten URLs unterstützt. Das vereinfacht die Verwaltung und Bereitstellung benutzerdefinierter Modelle.
  • Llama 3.1/3.2-Funktionsaufruf-Parsing:Es wird ein spezielles Parsing für Llama 3.1/3.2-Funktionsaufrufe implementiert, um die Robustheit beim Parsen zu verbessern.
  • Hostspeicher-Präfix-Caching:Der externe vLLM unterstützt nur das Präfix-Caching des GPU-Speichers.
  • Spekulative Dekodierung:Diese Funktion ist bereits in vLLM verfügbar. In Vertex AI wurden jedoch Tests durchgeführt, um leistungsstarke Modellkonfigurationen zu finden.

Diese Vertex AI-spezifischen Anpassungen sind für den Endnutzer oft transparent und ermöglichen es Ihnen, die Leistung und Effizienz Ihrer Llama 3.1-Bereitstellungen in Vertex AI Model Garden zu maximieren.

• Einbindung in das Vertex AI-System:
  • Unterstützung von Vertex AI-Vorhersage-Eingabe-/Ausgabeformaten:Sorgt für eine nahtlose Kompatibilität mit den Eingabe- und Ausgabeformaten von Vertex AI-Vorhersagen, was die Datenverarbeitung und Einbindung in andere Vertex AI-Dienste vereinfacht.
  • Vertex-Umgebungsvariablen: Vertex AI-Umgebungsvariablen (AIP_*) werden für die Konfiguration und Ressourcenverwaltung berücksichtigt und genutzt, um die Bereitstellung zu optimieren und ein einheitliches Verhalten in der Vertex AI-Umgebung zu gewährleisten.
  • Verbesserte Fehlerbehandlung und Robustheit: Umfassende Fehlerbehandlung, Eingabe-/Ausgabevalidierung und Serverbeendigungsmechanismen sorgen für Stabilität, Zuverlässigkeit und reibungslosen Betrieb in der verwalteten Vertex AI-Umgebung.
  • Nginx-Server für Funktionen:Ein Nginx-Server wird über dem vLLM-Server eingebunden, was die Bereitstellung mehrerer Replikate erleichtert und die Skalierbarkeit und Hochverfügbarkeit der Bereitstellungsinfrastruktur verbessert.

Weitere Vorteile von vLLM

• Benchmark-Leistung: vLLM bietet im Vergleich zu anderen Bereitstellungssystemen wie der Textgenerierungsinferenz von Hugging Face und dem FasterTransformer von NVIDIA eine wettbewerbsfähige Leistung in Bezug auf Durchsatz und Latenz.
• Einfache Bedienung: Die Bibliothek bietet eine einfache API für die Einbindung in vorhandene Workflows. So können Sie sowohl Llama 3.1- als auch Llama 3.2-Modelle mit minimaler Einrichtung bereitstellen.
• Erweiterte Funktionen: vLLM unterstützt Streamingausgaben (generiert Antworten Token für Token) und verarbeitet Prompts mit variabler Länge effizient, wodurch die Interaktivität und Reaktionsfähigkeit in Anwendungen verbessert wird.

Eine Übersicht über das vLLM-System finden Sie in diesem Artikel.

Unterstützte Modelle

vLLM unterstützt eine breite Auswahl an modernen Modellen, sodass Sie das Modell auswählen können, das Ihren Anforderungen am besten entspricht. In der folgenden Tabelle finden Sie eine Auswahl dieser Modelle. Eine umfassende Liste der unterstützten Modelle, einschließlich derer für reine Text- und multimodale Inferenz, finden Sie jedoch auf der offiziellen vLLM-Website.

Erste Schritte mit Model Garden

Der Bereitstellungscontainer für vLLM-Cloud-GPUs ist in Model Garden, im Playground, in der Ein-Klick-Bereitstellung und in den Colab Enterprise-Notebook-Beispielen eingebunden. In dieser Anleitung wird die Llama-Modellfamilie von Meta AI als Beispiel verwendet.

Colab Enterprise-Notebook verwenden

Playgrounds und Bereitstellungen mit einem Klick sind ebenfalls verfügbar, werden aber in dieser Anleitung nicht beschrieben.

1. Rufen Sie die Seite „Modellkarte“ auf und klicken Sie auf Notebook öffnen.
2. Wählen Sie das Vertex Serving-Notebook aus. Das Notebook wird in Colab Enterprise geöffnet.
3. Führen Sie das Notebook aus, um ein Modell mit vLLM bereitzustellen und Vorhersageanfragen an den Endpunkt zu senden.

Einrichtung und Anforderungen

In diesem Abschnitt werden die erforderlichen Schritte zum Einrichten Ihres Google Cloud Projekts und zum Sicherstellen der erforderlichen Ressourcen für die Bereitstellung und Bereitstellung von vLLM-Modellen beschrieben.

1. Abrechnung

• Abrechnung aktivieren: Die Abrechnung muss für Ihr Projekt aktiviert sein. Weitere Informationen finden Sie unter Abrechnung für ein Projekt aktivieren, deaktivieren oder ändern.

2. GPU-Verfügbarkeit und -Kontingente

• Wenn Sie Vorhersagen mit Hochleistungs-GPUs (NVIDIA A100 80 GB oder H100 80 GB) ausführen möchten, prüfen Sie die Kontingente für diese GPUs in der ausgewählten Region:
  • Kontingent für NVIDIA A100 80 GB
  • Kontingent für NVIDIA H100 80 GB

3. Google Cloud -Projekt einrichten

Führen Sie das folgende Codebeispiel aus, um zu prüfen, ob Ihre Google Cloud Umgebung richtig eingerichtet ist. In diesem Schritt werden die erforderlichen Python-Bibliotheken installiert und der Zugriff auf Google Cloud -Ressourcen eingerichtet. Zu den Aktionen gehören:

• Installation: Aktualisieren Sie die google-cloud-aiplatform-Bibliothek und klonen Sie das Repository mit den Dienstprogrammfunktionen.
• Umgebungseinrichtung: Definieren von Variablen für die Projekt-ID, die Region und einen eindeutigen Cloud Storage-Bucket zum Speichern von Modellartefakten. Google Cloud
• API-Aktivierung: Aktivieren Sie die Vertex AI- und Compute Engine APIs, die für die Bereitstellung und Verwaltung von KI-Modellen erforderlich sind.
• Bucket-Konfiguration: Erstellen Sie einen neuen Cloud Storage-Bucket oder prüfen Sie einen vorhandenen Bucket, um sicherzustellen, dass er sich in der richtigen Region befindet.
• Vertex AI-Initialisierung: Die Vertex AI-Clientbibliothek wird mit den Einstellungen für das Projekt, den Speicherort und den Staging-Bucket initialisiert.
• Dienstkonto einrichten: Geben Sie das Standarddienstkonto für die Ausführung von Vertex AI-Jobs an und gewähren Sie ihm die erforderlichen Berechtigungen.

BUCKET_URI = "gs://"

REGION = ""

! pip3 install --upgrade --quiet 'google-cloud-aiplatform>=1.64.0'
! git clone https://github.com/GoogleCloudPlatform/vertex-ai-samples.git

import datetime
import importlib
import os
import uuid
from typing import Tuple

import requests
from google.cloud import aiplatform

common_util = importlib.import_module(
    "vertex-ai-samples.community-content.vertex_model_garden.model_oss.notebook_util.common_util"
)

models, endpoints = {}, {}

PROJECT_ID = os.environ["GOOGLE_CLOUD_PROJECT"]

if not REGION:
    REGION = os.environ["GOOGLE_CLOUD_REGION"]

print("Enabling Vertex AI API and Compute Engine API.")
! gcloud services enable aiplatform.googleapis.com compute.googleapis.com

now = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
BUCKET_NAME = "/".join(BUCKET_URI.split("/")[:3])

if BUCKET_URI is None or BUCKET_URI.strip() == "" or BUCKET_URI == "gs://":
    BUCKET_URI = f"gs://{PROJECT_ID}-tmp-{now}-{str(uuid.uuid4())[:4]}"
    BUCKET_NAME = "/".join(BUCKET_URI.split("/")[:3])
    ! gsutil mb -l {REGION} {BUCKET_URI}
else:
    assert BUCKET_URI.startswith("gs://"), "BUCKET_URI must start with `gs://`."
    shell_output = ! gsutil ls -Lb {BUCKET_NAME} | grep "Location constraint:" | sed "s/Location constraint://"
    bucket_region = shell_output[0].strip().lower()
    if bucket_region != REGION:
        raise ValueError(
            "Bucket region %s is different from notebook region %s"
            % (bucket_region, REGION)
        )
print(f"Using this Bucket: {BUCKET_URI}")

STAGING_BUCKET = os.path.join(BUCKET_URI, "temporal")
MODEL_BUCKET = os.path.join(BUCKET_URI, "llama3_1")

print("Initializing Vertex AI API.")
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=STAGING_BUCKET)

shell_output = ! gcloud projects describe $PROJECT_ID
project_number = shell_output[-1].split(":")[1].strip().replace("'", "")
SERVICE_ACCOUNT = "your service account email"
print("Using this default Service Account:", SERVICE_ACCOUNT)

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.admin $BUCKET_NAME

! gcloud config set project $PROJECT_ID
! gcloud projects add-iam-policy-binding --no-user-output-enabled {PROJECT_ID} --member=serviceAccount:{SERVICE_ACCOUNT} --role="roles/storage.admin"
! gcloud projects add-iam-policy-binding --no-user-output-enabled {PROJECT_ID} --member=serviceAccount:{SERVICE_ACCOUNT} --role="roles/aiplatform.user"

Hugging Face mit Meta Llama 3.1, 3.2 und vLLM verwenden

Die Llama 3.1- und 3.2-Sammlungen von Meta bieten eine Reihe mehrsprachiger Large Language Models (LLMs), die für die qualitativ hochwertige Textgenerierung in verschiedenen Anwendungsfällen entwickelt wurden. Diese Modelle sind vortrainiert und anhand von Anleitungen abgestimmt. Sie eignen sich hervorragend für Aufgaben wie mehrsprachige Unterhaltungen, Zusammenfassungen und die Suche nach Informationen. Bevor Sie die Modelle Llama 3.1 und 3.2 verwenden können, müssen Sie den Nutzungsbedingungen zustimmen, wie im Screenshot zu sehen. Die vLLM-Bibliothek bietet eine optimierte Open-Source-Bereitstellungsumgebung mit Optimierungen für Latenz, Arbeitsspeichereffizienz und Skalierbarkeit.

Wichtiger Hinweis: Für den Zugriff auf diese Modelle müssen Sie Ihre Kontaktdaten angeben und die Nutzungsbedingungen gemäß der Meta-Datenschutzerklärung akzeptieren. Ihre Anfrage wird dann von den Autoren des Repos geprüft.

Abbildung 1: Meta LLama 3 Community-Lizenzvereinbarung

Übersicht über Meta Llama 3.1- und 3.2-Sammlungen

Die Sammlungen „Llama 3.1“ und „Llama 3.2“ sind jeweils für unterschiedliche Bereitstellungsskalen und Modellgrößen geeignet und bieten flexible Optionen für mehrsprachige Dialogaufgaben und darüber hinaus. Weitere Informationen finden Sie auf der Übersichtsseite für Llama.

• Nur Text: Die Llama 3.2-Sammlung mehrsprachiger Large Language Models (LLMs) ist eine Sammlung vortrainierter und anweisungsorientierter generativer Modelle in den Größen 1B und 3B (Text-in, Text-out).
• Vision und Vision Instruct: Die Llama 3.2-Vision-Sammlung multimodaler Large Language Models (LLMs) ist eine Sammlung vortrainierter und anweisungsorientierter generativer Modelle für die Bilderkennung in den Größen 11 Milliarden und 90 Milliarden (Text + Bilder in, Text aus). Optimierung: Wie Llama 3.1 sind auch die 3.2-Modelle auf mehrsprachige Dialoge zugeschnitten und eignen sich gut für Abruf- und Zusammenfassungsaufgaben. Sie erzielen Spitzenergebnisse bei Standard-Benchmarks.
• Modellarchitektur: Llama 3.2 enthält auch ein autoregressives Transformer-Framework, bei dem SFT und RLHF angewendet werden, um die Modelle in Bezug auf Nützlichkeit und Sicherheit anzupassen.

Hugging Face-Nutzerzugriffstokens

Für diese Anleitung ist ein Lesezugriffstoken vom Hugging Face Hub erforderlich, um auf die erforderlichen Ressourcen zuzugreifen. So richten Sie die Authentifizierung ein:

Abbildung 2: Hugging Face-Zugriffstoken-Einstellungen

1. So generieren Sie ein Lesezugriffstoken:

   • Rufe die Hugging Face-Kontoeinstellungen auf.
   • Erstellen Sie ein neues Token, weisen Sie ihm die Rolle „Lesen“ zu und speichern Sie es sicher.

2. So verwenden Sie das Token:

   • Verwenden Sie das generierte Token, um sich zu authentifizieren und bei Bedarf auf öffentliche oder private Repositories zuzugreifen.

Abbildung 3: Hugging Face-Zugriffstoken verwalten

So haben Sie die richtige Zugriffsebene, ohne dass unnötige Berechtigungen erforderlich sind. Diese Praktiken erhöhen die Sicherheit und verhindern eine versehentliche Token-Offenlegung. Weitere Informationen zum Einrichten von Zugriffstokens finden Sie auf der Seite zu Hugging Face-Zugriffstokens.

Geben Sie Ihr Token nicht öffentlich oder online weiter. Wenn Sie Ihr Token während der Bereitstellung als Umgebungsvariable festlegen, bleibt es für Ihr Projekt privat. Vertex AI sorgt für Sicherheit, indem andere Nutzer nicht auf Ihre Modelle und Endpunkte zugreifen können.

Weitere Informationen zum Schutz Ihres Zugriffstokens finden Sie unter Best Practices für Hugging Face-Zugriffstokens.

Llama 3.1-Modelle mit reinem Text mit vLLM bereitstellen

Für die Bereitstellung von Large Language Models auf Produktionsebene bietet vLLM eine effiziente Bereitstellungslösung, die die Arbeitsspeichernutzung optimiert, die Latenz verringert und den Durchsatz erhöht. Das macht es besonders gut geeignet für die Verarbeitung der größeren Llama 3.1-Modelle sowie der multimodalen Llama 3.2-Modelle.

Schritt 1: Modell für die Bereitstellung auswählen

Wählen Sie die zu implementierende Llama 3.1-Modellvariante aus. Es sind verschiedene Größen und Versionen mit unterschiedlichen Anleitungen verfügbar:

base_model_name = "Meta-Llama-3.1-8B"  # @param ["Meta-Llama-3.1-8B", "Meta-Llama-3.1-8B-Instruct", "Meta-Llama-3.1-70B", "Meta-Llama-3.1-70B-Instruct", "Meta-Llama-3.1-405B-FP8", "Meta-Llama-3.1-405B-Instruct-FP8"]
hf_model_id = "meta-Llama/" + base_model_name

Schritt 2: Hardware und Kontingent für die Bereitstellung prüfen

Die Bereitstellungsfunktion legt die entsprechende GPU und den Maschinentyp basierend auf der Modellgröße fest und prüft das Kontingent in dieser Region für ein bestimmtes Projekt:

if "8b" in base_model_name.lower():
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-12"
    accelerator_count = 1
elif "70b" in base_model_name.lower():
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-96"
    accelerator_count = 8
elif "405b" in base_model_name.lower():
    accelerator_type = "NVIDIA_H100_80GB"
    machine_type = "a3-highgpu-8g"
    accelerator_count = 8
else:
    raise ValueError(f"Recommended GPU setting not found for: {accelerator_type} and {base_model_name}.")

Prüfen Sie die Verfügbarkeit von GPU-Kontingenten in der angegebenen Region:

common_util.check_quota(
    project_id=PROJECT_ID,
    region=REGION,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    is_for_training=False,
)

Schritt 3: Modell mit vLLM prüfen

Die folgende Funktion lädt das Modell in Vertex AI hoch, konfiguriert die Bereitstellungseinstellungen und stellt es mit vLLM auf einem Endpunkt bereit.

1. Docker-Image: Für die Bereitstellung wird ein vorkonfiguriertes vLLM-Docker-Image verwendet, um die Bereitstellung effizient zu gestalten.
2. Konfiguration: Hier können Sie die Speichernutzung, die Modelllänge und andere vLLM-Einstellungen konfigurieren. Weitere Informationen zu den vom Server unterstützten Argumenten finden Sie auf der offiziellen vLLM-Dokumentationsseite.
3. Umgebungsvariablen: Legen Sie Umgebungsvariablen für die Authentifizierung und die Bereitstellungsquelle fest.

def deploy_model_vllm(
    model_name: str,
    model_id: str,
    service_account: str,
    base_model_id: str = None,
    machine_type: str = "g2-standard-8",
    accelerator_type: str = "NVIDIA_L4",
    accelerator_count: int = 1,
    gpu_memory_utilization: float = 0.9,
    max_model_len: int = 4096,
    dtype: str = "auto",
    enable_trust_remote_code: bool = False,
    enforce_eager: bool = False,
    enable_lora: bool = False,
    max_loras: int = 1,
    max_cpu_loras: int = 8,
    use_dedicated_endpoint: bool = False,
    max_num_seqs: int = 256,
) -> Tuple[aiplatform.Model, aiplatform.Endpoint]:
    """Deploys trained models with vLLM into Vertex AI."""
    endpoint = aiplatform.Endpoint.create(
        display_name=f"{model_name}-endpoint",
        dedicated_endpoint_enabled=use_dedicated_endpoint,
    )

    if "8b" in base_model_name.lower():
        accelerator_type = "NVIDIA_L4"
        machine_type = "g2-standard-12"
        accelerator_count = 1
    elif "70b" in base_model_name.lower():
        accelerator_type = "NVIDIA_L4"
        machine_type = "g2-standard-96"
        accelerator_count = 8
    elif "405b" in base_model_name.lower():
        accelerator_type = "NVIDIA_H100_80GB"
        machine_type = "a3-highgpu-8g"
        accelerator_count = 8
    else:
        raise ValueError(f"Recommended GPU setting not found for: {accelerator_type} and {base_model_name}.")

    common_util.check_quota(
        project_id=PROJECT_ID,
        region=REGION,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        is_for_training=False,
    )

    vllm_args = [
        "python", "-m", "vllm.entrypoints.api_server", 
        "--host=0.0.0.0", 
        "--port=8080",
        f"--model={model_id}", 
        f"--tensor-parallel-size={accelerator_count}",
        "--swap-space=16",
        f"--gpu-memory-utilization={gpu_memory_utilization}",
        f"--max-model-len={max_model_len}", f"--dtype={dtype}",
        f"--max-loras={max_loras}", f"--max-cpu-loras={max_cpu_loras}",
        f"--max-num-seqs={max_num_seqs}", "--disable-log-stats"
    ]

    if enable_trust_remote_code:
        vllm_args.append("--trust-remote-code")
    if enforce_eager:
        vllm_args.append("--enforce-eager")
    if enable_lora:
        vllm_args.append("--enable-lora")
    if model_type:
        vllm_args.append(f"--model-type={model_type}")

    env_vars = {
        "MODEL_ID": model_id,
        "DEPLOY_SOURCE": "notebook",
        "HF_TOKEN": HF_TOKEN
    }

    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=VLLM_DOCKER_URI,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/generate",
        serving_container_health_route="/ping",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),
        serving_container_deployment_timeout=7200,
    )
    print(f"Deploying {model_name} on {machine_type} with {accelerator_count} {accelerator_type} GPU(s).")

    model.deploy(
        endpoint=endpoint,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        deploy_request_timeout=1800,
        service_account=service_account,
    )
    print("endpoint_name:", endpoint.name)

    return model, endpoint

Schritt 4: Bereitstellung ausführen

Führen Sie die Bereitstellungsfunktion mit dem ausgewählten Modell und der ausgewählten Konfiguration aus. In diesem Schritt wird das Modell bereitgestellt und die Modell- und Endpunktinstanzen werden zurückgegeben:

HF_TOKEN = ""

VLLM_DOCKER_URI = "us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241001_0916_RC00"

model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
gpu_memory_utilization = 0.9
max_model_len = 4096
max_loras = 1

models["vllm_gpu"], endpoints["vllm_gpu"] = deploy_model_vllm(
    model_name=common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve"),
    model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type=machine_type,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    gpu_memory_utilization=gpu_memory_utilization,
    max_model_len=max_model_len,
    max_loras=max_loras,
    enforce_eager=True,
    enable_lora=True,
    use_dedicated_endpoint=use_dedicated_endpoint,
)

Nachdem Sie dieses Codebeispiel ausgeführt haben, wird Ihr Llama 3.1-Modell in Vertex AI bereitgestellt und ist über den angegebenen Endpunkt zugänglich. Sie können mit ihm für Inferenzaufgaben wie Textgenerierung, Zusammenfassung und Dialog interagieren. Je nach Größe des Modells kann die Bereitstellung des neuen Modells bis zu einer Stunde dauern. Sie können den Fortschritt unter „Vertex-Onlinevorhersagen“ prüfen.

Abbildung 4: Llama 3.1-Bereitstellungsendpunkt im Vertex-Dashboard

Vorhersagen mit Llama 3.1 in Vertex AI treffen

Nachdem Sie das Llama 3.1-Modell in Vertex AI bereitgestellt haben, können Sie Vorhersagen treffen, indem Sie Textprompts an den Endpunkt senden. In diesem Abschnitt finden Sie ein Beispiel für das Generieren von Antworten mit verschiedenen anpassbaren Parametern zur Steuerung der Ausgabe.

Schritt 1: Prompt und Parameter definieren

Richten Sie zuerst den Textprompt und die Stichprobenparameter ein, um die Antwort des Modells zu steuern. Hier sind die wichtigsten Parameter:

• prompt: Der Eingabetext, für den das Modell eine Antwort generieren soll. Beispiel: prompt = „Was ist ein Auto?“
• max_tokens: Die maximale Anzahl von Tokens in der generierten Ausgabe. Wenn Sie diesen Wert verringern, können Zeitüberschreitungsprobleme vermieden werden.
• temperature: Steuert die Zufälligkeit von Vorhersagen. Höhere Werte (z. B. 1, 0) erhöhen die Vielfalt, während niedrigere Werte (z. B. 0, 5) die Ausgabe fokussierter machen.
• top_p: Der Stichprobenpool wird auf die höchste kumulative Wahrscheinlichkeit beschränkt. Wenn Sie beispielsweise „top_p“ auf 0,9 festlegen, werden nur Tokens mit den 90% höchsten Wahrscheinlichkeiten berücksichtigt.
• top_k: Die Stichprobenerhebung wird auf die k wahrscheinlichsten Tokens beschränkt. Wenn Sie beispielsweise „top_k“ auf „50“ festlegen, werden nur die 50 wichtigsten Tokens ausgewählt.
• raw_response: Wenn „wahr“ (true), wird die Rohausgabe des Modells zurückgegeben. Wenn „False“ (falsch), wenden Sie eine zusätzliche Formatierung mit der Struktur „Prompt:\n{prompt}\nOutput:\n{output}“ an.
• lora_id (optional): Pfad zu LoRA-Gewichtsdateien, um LoRA-Gewichte anzuwenden. Dies kann ein Cloud Storage-Bucket oder eine Hugging Face-Repository-URL sein. Hinweis: Dies funktioniert nur, wenn --enable-lora in den Bereitstellungsargumenten festgelegt ist. Dynamisches LoRA wird für multimodale Modelle nicht unterstützt.

prompt = "What is a car?"
max_tokens = 50
temperature = 1.0
top_p = 1.0
top_k = 1
raw_response = False
lora_id = ""

Schritt 2: Vorhersageanfrage senden

Nachdem die Instanz konfiguriert wurde, können Sie die Vorhersageanfrage an den bereitgestellten Vertex AI-Endpunkt senden. In diesem Beispiel wird gezeigt, wie eine Vorhersage erstellt und das Ergebnis ausgegeben wird:

response = endpoints["vllm_gpu"].predict(
    instances=instances, use_dedicated_endpoint=use_dedicated_endpoint
)

for prediction in response.predictions:
    print(prediction)

Beispielausgabe

Hier ein Beispiel dafür, wie das Modell auf den Prompt „Was ist ein Auto?“ reagieren könnte:

Human: What is a car?
Assistant: A car, or a motor car, is a road-connected human-transportation system
used to move people or goods from one place to another.

Zusätzliche Hinweise

• Moderation: Um für sichere Inhalte zu sorgen, können Sie den generierten Text mit den Textmoderationsmöglichkeiten von Vertex AI moderieren.
• Zeitüberschreitungen behandeln: Wenn Probleme wie ServiceUnavailable: 503 auftreten, versuchen Sie, den Parameter max_tokens zu verringern.

Dieser Ansatz bietet eine flexible Möglichkeit, mit dem Llama 3.1-Modell mithilfe verschiedener Stichprobentechniken und LoRA-Adapter zu interagieren. Dadurch eignet es sich für eine Vielzahl von Anwendungsfällen, von der allgemeinen Textgenerierung bis hin zu aufgabenspezifischen Antworten.

Multimodale Llama 3.2-Modelle mit vLLM bereitstellen

In diesem Abschnitt erfahren Sie, wie Sie vorkonfigurierte Llama 3.2-Modelle in die Model Registry hochladen und auf einem Vertex AI-Endpunkt bereitstellen. Je nach Größe des Modells kann die Bereitstellung bis zu einer Stunde dauern. Llama 3.2-Modelle sind in multimodalen Versionen verfügbar, die sowohl Text- als auch Bildeingaben unterstützen. vLLM unterstützt:

• Nur-Text-Format
• Einzelbild + Textformat

Diese Formate machen Llama 3.2 für Anwendungen geeignet, die sowohl visuelle als auch Textverarbeitung erfordern.

Schritt 1: Modell für die Bereitstellung auswählen

Geben Sie die Modellvariante von Llama 3.2 an, die Sie bereitstellen möchten. Im folgenden Beispiel wird Llama-3.2-11B-Vision als ausgewähltes Modell verwendet. Je nach Anforderungen können Sie jedoch eine andere verfügbare Option auswählen.

base_model_name = "Llama-3.2-11B-Vision"  # @param ["Llama-3.2-1B", "Llama-3.2-1B-Instruct", "Llama-3.2-3B", "Llama-3.2-3B-Instruct", "Llama-3.2-11B-Vision", "Llama-3.2-11B-Vision-Instruct", "Llama-3.2-90B-Vision", "Llama-3.2-90B-Vision-Instruct"]
hf_model_id = "meta-Llama/" + base_model_name

Schritt 2: Hardware und Ressourcen konfigurieren

Wählen Sie die für die Modellgröße geeignete Hardware aus. Je nach Rechenanforderungen des Modells können für vLLM verschiedene GPUs verwendet werden:

• Modelle 1B und 3B: Verwenden Sie NVIDIA L4-GPUs.
• 11B-Modelle: Verwenden Sie NVIDIA A100-GPUs.
• 90B-Modelle: Verwenden Sie NVIDIA H100-GPUs.

In diesem Beispiel wird die Bereitstellung basierend auf der Modellauswahl konfiguriert:

if "3.2-1B" in base_model_name or "3.2-3B" in base_model_name:
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-8"
    accelerator_count = 1
elif "3.2-11B" in base_model_name:
    accelerator_type = "NVIDIA_TESLA_A100"
    machine_type = "a2-highgpu-1g"
    accelerator_count = 1
elif "3.2-90B" in base_model_name:
    accelerator_type = "NVIDIA_H100_80GB"
    machine_type = "a3-highgpu-8g"
    accelerator_count = 8
else:
    raise ValueError(f"Recommended GPU setting not found for: {base_model_name}.")

Sie benötigen das erforderliche GPU-Kontingent:

common_util.check_quota(
    project_id=PROJECT_ID,
    region=REGION,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    is_for_training=False,
)

Schritt 3: Modell mit vLLM bereitstellen

Die folgende Funktion übernimmt die Bereitstellung des Llama 3.2-Modells in Vertex AI. Dabei werden die Umgebung, die Arbeitsspeichernutzung und die vLLM-Einstellungen des Modells für eine effiziente Bereitstellung konfiguriert.

def deploy_model_vllm(
    model_name: str,
    model_id: str,
    service_account: str,
    base_model_id: str = None,
    machine_type: str = "g2-standard-8",
    accelerator_type: str = "NVIDIA_L4",
    accelerator_count: int = 1,
    gpu_memory_utilization: float = 0.9,
    max_model_len: int = 4096,
    dtype: str = "auto",
    enable_trust_remote_code: bool = False,
    enforce_eager: bool = False,
    enable_lora: bool = False,
    max_loras: int = 1,
    max_cpu_loras: int = 8,
    use_dedicated_endpoint: bool = False,
    max_num_seqs: int = 12,
    model_type: str = None,
) -> Tuple[aiplatform.Model, aiplatform.Endpoint]:
    """Deploys trained models with vLLM into Vertex AI."""
    endpoint = aiplatform.Endpoint.create(
        display_name=f"{model_name}-endpoint",
        dedicated_endpoint_enabled=use_dedicated_endpoint,
    )

    if not base_model_id:
        base_model_id = model_id

    vllm_args = [
        "python",
        "-m",
        "vllm.entrypoints.api_server",
        "--host=0.0.0.0",
        "--port=8080",
        f"--model={model_id}",
        f"--tensor-parallel-size={accelerator_count}",
        "--swap-space=16",
        f"--gpu-memory-utilization={gpu_memory_utilization}",
        f"--max-model-len={max_model_len}",
        f"--dtype={dtype}",
        f"--max-loras={max_loras}",
        f"--max-cpu-loras={max_cpu_loras}",
        f"--max-num-seqs={max_num_seqs}",
        "--disable-log-stats",
    ]

    if enable_trust_remote_code:
        vllm_args.append("--trust-remote-code")
    if enforce_eager:
        vllm_args.append("--enforce-eager")
    if enable_lora:
        vllm_args.append("--enable-lora")
    if model_type:
        vllm_args.append(f"--model-type={model_type}")

    env_vars = {
        "MODEL_ID": base_model_id,
        "DEPLOY_SOURCE": "notebook",
    }

    # HF_TOKEN is not a compulsory field and may not be defined.
    try:
        if HF_TOKEN:
            env_vars["HF_TOKEN"] = HF_TOKEN
    except NameError:
        pass

    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=VLLM_DOCKER_URI,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/generate",
        serving_container_health_route="/ping",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),
        serving_container_deployment_timeout=7200,
    )
    print(f"Deploying {model_name} on {machine_type} with {accelerator_count} {accelerator_type} GPU(s).")

    model.deploy(
        endpoint=endpoint,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        deploy_request_timeout=1800,
        service_account=service_account,
    )
    print("endpoint_name:", endpoint.name)

    return model, endpoint

Schritt 4: Bereitstellung ausführen

Führen Sie die Bereitstellungsfunktion mit dem konfigurierten Modell und den Einstellungen aus. Die Funktion gibt sowohl die Modell- als auch die Endpunktinstanzen zurück, die Sie für die Inferenz verwenden können.

model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
models["vllm_gpu"], endpoints["vllm_gpu"] = deploy_model_vllm(
    model_name=model_name
    model_id=hf_model_id,
    base_model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type=machine_type,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    gpu_memory_utilization=gpu_memory_utilization,
    max_model_len=max_model_len,
    enforce_eager=True,
    use_dedicated_endpoint=use_dedicated_endpoint,
    max_num_seqs=max_num_seqs,
)

Abbildung 5: Llama 3.2-Bereitstellungsendpunkt im Vertex-Dashboard

Je nach Größe des Modells kann die Bereitstellung des neuen Modells bis zu einer Stunde dauern. Sie können den Fortschritt unter „Vertex-Onlinevorhersagen“ prüfen.

Inferenz mit vLLM in Vertex AI mit Standardvorhersagepfad

In diesem Abschnitt erfahren Sie, wie Sie die Inferenz für das Llama 3.2 Vision-Modell in Vertex AI mit der Standardvorhersageroute einrichten. Sie verwenden die vLLM-Bibliothek für eine effiziente Bereitstellung und interagieren mit dem Modell, indem Sie einen visuellen Prompt in Kombination mit Text senden.

Prüfen Sie zuerst, ob der Modellendpunkt bereitgestellt und für Vorhersagen bereit ist.

Schritt 1: Prompt und Parameter definieren

In diesem Beispiel werden eine Bild-URL und ein Text-Prompt angegeben, die vom Modell verarbeitet werden, um eine Antwort zu generieren.

Abbildung 6: Beispiel für eine Bildeingabe für Llama 3.2

image_url = "https://images.pexels.com/photos/1254140/pexels-photo-1254140.jpeg"

raw_prompt = "This is a picture of"

# Reference prompt formatting guidelines here: https://www.Llama.com/docs/model-cards-and-prompt-formats/Llama3_2/#-base-model-prompt
prompt = f"<|begin_of_text|><|image|>{raw_prompt}"

Schritt 2: Prognoseparameter konfigurieren

Passen Sie die folgenden Parameter an, um die Antwort des Modells zu steuern:

max_tokens = 64

temperature = 0.5

top_p = 0.95

Schritt 3: Vorhersageanfrage vorbereiten

Richten Sie die Vorhersageanfrage mit der Bild-URL, dem Prompt und anderen Parametern ein.

instances = [
    {
        "prompt": prompt,
        "multi_modal_data": {"image": image_url},
        "max_tokens": max_tokens,
        "temperature": temperature,
        "top_p": top_p,
    },
]

Schritt 4: Vorhersage treffen

Senden Sie die Anfrage an Ihren Vertex AI-Endpunkt und verarbeiten Sie die Antwort:

response = endpoints["vllm_gpu"].predict(instances=instances)

for raw_prediction in response.predictions:
    prediction = raw_prediction.split("Output:")
    print(prediction[1])

Wenn ein Zeitüberschreitungsproblem auftritt (z. B. ServiceUnavailable: 503 Took too long to respond when processing), versuchen Sie, den Wert für max_tokens auf eine niedrigere Zahl wie 20 zu reduzieren, um die Antwortzeit zu verkürzen.

Inferenzen mit vLLM in Vertex AI mit OpenAI Chat Completion

In diesem Abschnitt erfahren Sie, wie Sie mit der OpenAI Chat Completions API in Vertex AI Inferenzen für Llama 3.2 Vision-Modelle ausführen. Mit diesem Ansatz können Sie multimodale Funktionen nutzen, indem Sie dem Modell sowohl Bilder als auch Textprompts senden, um interaktivere Antworten zu erhalten.

Schritt 1: Bereitstellung des Llama 3.2 Vision Instruct-Modells ausführen

Führen Sie die Bereitstellungsfunktion mit dem konfigurierten Modell und den Einstellungen aus. Die Funktion gibt sowohl die Modell- als auch die Endpunktinstanzen zurück, die Sie für die Inferenz verwenden können.

base_model_name = "Llama-3.2-11B-Vision-Instruct"
hf_model_id = f"meta-llama/{base_model_name}"
model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
model, endpoint = deploy_model_vllm(
    model_name=model_name
    model_id=hf_model_id,
    base_model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type="a2-highgpu-1g",
    accelerator_type="NVIDIA_TESLA_A100",
    accelerator_count=1,
    gpu_memory_utilization=0.9,
    max_model_len=4096,
    enforce_eager=True,
    max_num_seqs=12,
)

Schritt 2: Endpunktressource konfigurieren

Richten Sie zuerst den Namen der Endpunktressource für Ihre Vertex AI-Bereitstellung ein.

ENDPOINT_RESOURCE_NAME = "projects/{}/locations/{}/endpoints/{}".format(
    PROJECT_ID, REGION, endpoint.name
)

Schritt 3: OpenAI SDK und Authentifizierungsbibliotheken installieren

Damit Sie Anfragen über das SDK von OpenAI senden können, müssen die erforderlichen Bibliotheken installiert sein:

!pip install -qU openai google-auth requests

Schritt 4: Eingabeparameter für den Abschluss des Chats definieren

Legen Sie die Bild-URL und den Text-Prompt fest, die an das Modell gesendet werden. Passen Sie max_tokens und temperature an, um die Länge und Zufälligkeit der Antwort zu steuern.

user_image = "https://images.freeimages.com/images/large-previews/ab3/puppy-2-1404644.jpg"
user_message = "Describe this image?"
max_tokens = 50
temperature = 1.0

Schritt 5: Authentifizierung und Basis-URL einrichten

Rufen Sie Ihre Anmeldedaten ab und legen Sie die Basis-URL für API-Anfragen fest.

import google.auth
import openai

creds, project = google.auth.default()
auth_req = google.auth.transport.requests.Request()
creds.refresh(auth_req)

BASE_URL = (
    f"https://{REGION}-aiplatform.googleapis.com/v1beta1/{ENDPOINT_RESOURCE_NAME}"
)
try:
    if use_dedicated_endpoint:
        BASE_URL = f"https://{DEDICATED_ENDPOINT_DNS}/v1beta1/{ENDPOINT_RESOURCE_NAME}"
except NameError:
    pass

Schritt 6: Anfrage zum Abschluss des Chats senden

Senden Sie das Bild und den Textprompt mit der Chat Completions API von OpenAI an Ihren Vertex AI-Endpunkt:

client = openai.OpenAI(base_url=BASE_URL, api_key=creds.token)

model_response = client.chat.completions.create(
    model="",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": user_image}},
                {"type": "text", "text": user_message},
            ],
        }
    ],
    temperature=temperature,
    max_tokens=max_tokens,
)

print(model_response)

Schritt 7 (optional): Wieder mit einem vorhandenen Endpunkt verbinden

Verwenden Sie die Endpunkt-ID, um eine Verbindung zu einem zuvor erstellten Endpunkt herzustellen. Dieser Schritt ist nützlich, wenn Sie einen Endpunkt wiederverwenden möchten, anstatt einen neuen zu erstellen.

endpoint_name = ""
aip_endpoint_name = (
     f"projects/{PROJECT_ID}/locations/{REGION}/endpoints/{endpoint_name}"
)
endpoint = aiplatform.Endpoint(aip_endpoint_name)

Diese Konfiguration bietet die Flexibilität, nach Bedarf zwischen neu erstellten und vorhandenen Endpunkten zu wechseln, was eine optimierte Test- und Bereitstellung ermöglicht.

Bereinigen

Um laufende Kosten zu vermeiden und Ressourcen freizugeben, löschen Sie die bereitgestellten Modelle, Endpunkte und optional den für diesen Test verwendeten Speicher-Bucket.

Schritt 1: Endpunkte und Modelle löschen

Mit dem folgenden Code wird die Bereitstellung jedes Modells aufgehoben und die zugehörigen Endpunkte gelöscht:

# Undeploy model and delete endpoint
for endpoint in endpoints.values():
    endpoint.delete(force=True)

# Delete models
for model in models.values():
    model.delete()

Schritt 2: Optional: Cloud Storage-Bucket löschen

Wenn Sie einen Cloud Storage-Bucket speziell für diesen Test erstellt haben, können Sie ihn löschen, indem Sie „delete_bucket“ auf „True“ setzen. Dieser Schritt ist optional, wird aber empfohlen, wenn der Bucket nicht mehr benötigt wird.

delete_bucket = False
if delete_bucket:
    ! gsutil -m rm -r $BUCKET_NAME

So sorgen Sie dafür, dass alle in dieser Anleitung verwendeten Ressourcen beseitigt werden, und vermeiden unnötige Kosten im Zusammenhang mit dem Test.

Häufige Probleme beheben

In diesem Abschnitt erfahren Sie, wie Sie häufige Probleme bei der Bereitstellung und Inferenz von vLLM-Modellen in Vertex AI erkennen und beheben.

Log prüfen

Prüfen Sie die Protokolle, um die Ursache für Bereitstellungsfehler oder unerwartetes Verhalten zu ermitteln:

1. Vertex AI Prediction Console aufrufen:Rufen Sie in der Google Cloud Console die Vertex AI Prediction Console auf.
2. Endpunkt auswählen:Klicken Sie auf den Endpunkt, bei dem Probleme auftreten. Der Status sollte angeben, ob die Bereitstellung fehlgeschlagen ist.
3. Protokolle ansehen:Klicken Sie auf den Endpunkt und dann auf den Tab Protokolle oder auf Protokolle ansehen. Sie werden zu Cloud Logging weitergeleitet, wobei die Logs so gefiltert werden, dass nur Logs für diesen Endpunkt und die Modellbereitstellung angezeigt werden. Sie können auch direkt über den Cloud Logging-Dienst auf Logs zugreifen.
4. Protokolle analysieren:Prüfen Sie die Protokolleinträge auf Fehlermeldungen, Warnungen und andere relevante Informationen. Zeitstempel ansehen, um Logeinträge mit bestimmten Aktionen zu verknüpfen Suchen Sie nach Problemen mit Ressourceneinschränkungen (Arbeitsspeicher und CPU), Authentifizierungsproblemen oder Konfigurationsfehlern.

Häufiges Problem 1: CUDA-Fehler „Out of Memory“ (nicht genügend Arbeitsspeicher) während der Bereitstellung

CUDA-Fehler vom Typ „Out of Memory“ (kein Speicher verfügbar) treten auf, wenn die Arbeitsspeichernutzung des Modells die verfügbare GPU-Kapazität überschreitet.

Für das reine Textmodell haben wir die folgenden Engine-Argumente verwendet:

base_model_name = "Meta-Llama-3.1-8B"
hf_model_id = f"meta-llama/{base_model_name}"
accelerator_type = "NVIDIA_L4"
accelerator_count = 1
machine_type = "g2-standard-12"
accelerator_count: int = 1
gpu_memory_utilization = 0.9
max_model_len = 4096
dtype = "auto"
max_num_seqs = 256

Für das multimodale Modell wurden die folgenden Engine-Argumente verwendet:

base_model_name = "Llama-3.2-11B-Vision-Instruct"
hf_model_id = f"meta-llama/{base_model_name}"
accelerator_type = "NVIDIA_L4"
accelerator_count = 1
machine_type = "g2-standard-12"
accelerator_count: int = 1
gpu_memory_utilization = 0.9
max_model_len = 4096
dtype = "auto"
max_num_seqs = 12

Wenn Sie das multimodale Modell mit max_num_seqs = 256 bereitstellen, wie wir es beim reinen Textmodell getan haben, kann der folgende Fehler auftreten:

[rank0]: torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 3.91 GiB. GPU 0 has a total capacity of 39.38 GiB of which 3.76 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 34.94 GiB is allocated by PyTorch, and 175.15 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)

Abbildung 7: GPU-Fehlerprotokoll für „Out of Memory“ (OOM)

max_num_seqs und GPU-Speicher:

• Der Parameter max_num_seqs definiert die maximale Anzahl gleichzeitiger Anfragen, die das Modell verarbeiten kann.
• Jede vom Modell verarbeitete Sequenz belegt GPU-Arbeitsspeicher. Die Gesamtspeichernutzung ist proportional zu max_num_seqs mal dem Arbeitsspeicher pro Sequenz.
• Modelle, die nur Text verarbeiten (z. B. Meta-Llama-3.1-8B), verbrauchen in der Regel weniger Arbeitsspeicher pro Sequenz als multimodale Modelle (z. B. Llama-3.2-11B-Vision-Instruct), die sowohl Text als auch Bilder verarbeiten.

Prüfen Sie das Fehlerprotokoll (Abbildung 8):

• Im Protokoll wird beim Versuch, Arbeitsspeicher auf der GPU zuzuweisen, ein torch.OutOfMemoryError angezeigt.
• Der Fehler tritt auf, weil die Arbeitsspeichernutzung des Modells die verfügbare GPU-Kapazität überschreitet. Die NVIDIA L4-GPU hat 24 GB. Wenn der Parameter max_num_seqs für das multimodale Modell zu hoch festgelegt wird, kommt es zu einem Überlauf.
• Im Protokoll wird empfohlen, PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True festzulegen, um die Arbeitsspeicherverwaltung zu verbessern. Das Hauptproblem ist jedoch die hohe Arbeitsspeichernutzung.

Abbildung 8: Fehlgeschlagene Llama 3.2-Bereitstellung

Abbildung 9: Bereich „Details zur Modellversion“

Rufen Sie dazu die Vertex AI Prediction Console auf und klicken Sie auf den Endpunkt. Der Status sollte angeben, dass die Bereitstellung fehlgeschlagen ist. Klicken Sie, um die Protokolle aufzurufen. Prüfen Sie, ob „max-num-seqs“ den Wert „256“ hat. Dieser Wert ist zu hoch für Llama-3.2-11B-Vision-Instruct. Ein angemessenerer Wert wäre 12.

Häufiges Problem 2: Hugging Face-Token erforderlich

Hugging Face-Tokenfehler treten auf, wenn das Modell gesperrt ist und für den Zugriff gültige Anmeldedaten erforderlich sind.

Der folgende Screenshot zeigt einen Logeintrag im Log-Explorer von Google Cloud mit einer Fehlermeldung zum Zugriff auf das Meta LLaMA-3.2-11B-Vision-Modell, das auf Hugging Face gehostet wird. Der Fehler weist darauf hin, dass der Zugriff auf das Modell eingeschränkt ist und eine Authentifizierung erforderlich ist, um fortzufahren. Die Meldung enthält die folgende Angabe: „Cannot access gated repository for URL“ (Zugriff auf eingeschränktes Repository für URL nicht möglich). Das bedeutet, dass das Modell eingeschränkt ist und für den Zugriff gültige Anmeldedaten erforderlich sind. Dieser Logeintrag kann bei der Behebung von Authentifizierungsproblemen bei der Arbeit mit eingeschränkten Ressourcen in externen Repositories helfen.

Abbildung 10: Hugging Face-Tokenfehler

Prüfen Sie die Berechtigungen Ihres Hugging Face-Zugriffstokens, um dieses Problem zu beheben. Kopieren Sie das neueste Token und stellen Sie einen neuen Endpunkt bereit.

Häufiges Problem 3: Chatvorlage erforderlich

Chatvorlagenfehler treten auf, wenn die Standard-Chatvorlage nicht mehr zulässig ist. In diesem Fall muss eine benutzerdefinierte Chatvorlage angegeben werden, sofern der Tokenizer keine definiert.

Auf diesem Screenshot ist ein Logeintrag im Log-Explorer von Google Cloud zu sehen, bei dem aufgrund einer fehlenden Chatvorlage in der Transformers-Bibliothek Version 4.44 ein ValueError auftritt. Die Fehlermeldung weist darauf hin, dass die Standard-Chatvorlage nicht mehr zulässig ist und eine benutzerdefinierte Chatvorlage angegeben werden muss, wenn der Tokenisierer keine definiert. Dieser Fehler weist auf eine kürzliche Änderung in der Bibliothek hin, die eine explizite Definition einer Chatvorlage erfordert. Dies ist nützlich, um Probleme beim Bereitstellen chatbasierter Anwendungen zu beheben.

Abbildung 11: Chatvorlage erforderlich

Um dies zu vermeiden, müssen Sie während der Bereitstellung eine Chatvorlage mit dem Eingabeargument --chat-template angeben. Mustervorlagen finden Sie im Repository mit vLLM-Beispielen.

Häufiges Problem 4: Max. Sequenzlänge des Modells

Fehler bei der maximalen Sequenzlänge des Modells treten auf, wenn die maximale Sequenzlänge des Modells (4096) größer ist als die maximale Anzahl von Tokens, die im KV-Cache gespeichert werden können (2256).

Abbildung 12: Max. Sequenzlänge zu lang

ValueError: Die maximale Sequenzlänge des Modells (4096) ist größer als die maximale Anzahl von Tokens, die im KV-Cache gespeichert werden können (2256). Versuchen Sie, gpu_memory_utilization zu erhöhen oder max_model_len zu verringern, wenn Sie die Engine initialisieren.

Legen Sie zum Beheben dieses Problems „max_model_len“ auf 2048 fest, was unter 2256 liegt. Eine weitere Lösung für dieses Problem besteht darin, mehr oder größere GPUs zu verwenden. Wenn Sie mehr GPUs verwenden, muss „tensor-parallel-size“ entsprechend festgelegt werden.