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

Zusammenfassung

In diesem Tutorial wird beschrieben, wie Sie Llama 3.1- und Llama 3.2-Modelle mit vLLM in der Gemini Enterprise Agent Platform bereitstellen und ausführen. Es ist für die Verwendung mit zwei separaten Notebooks vorgesehen: Llama 3.1 mit vLLM zum Bereitstellen von Llama 3.1-Nur-Text-Modellen ausführen und Multimodales Llama 3.2 mit vLLM zum Bereitstellen von multimodalen Llama 3.2-Modellen ausführen, die sowohl Text- als auch Bildeingaben verarbeiten. Die auf dieser Seite beschriebenen Schritte zeigen, wie Sie die Modellinferenz auf GPUs effizient verarbeiten und Modelle für verschiedene Anwendungen anpassen können. So erhalten Sie die Tools, mit denen Sie fortschrittliche Sprachmodelle in Ihre Projekte einbinden können.

Am Ende dieses Leitfadens wissen Sie, wie Sie:

• Vordefinierte Llama-Modelle von Hugging Face mit vLLM-Container herunterladen.
• Diese Modelle auf GPU-Instanzen in Cloud de Confiance by S3NSGemini Enterprise Agent Platform Model Garden mit vLLM bereitstellen.
• Modelle effizient bereitstellen, um eine große Anzahl von Inferenzanfragen zu verarbeiten.
• Inferenz für Nur-Text-Anfragen sowie Text- und Bildanfragen ausführen.
• Sie setzen alles wieder zurück.
• Bereitstellung debuggen.

Wichtige vLLM-Funktionen

Google Gemini Enterprise Agent Platform – Anpassungen von Very Large Language Models (vLLMs): Leistung und Integration verbessern

Die vLLM-Implementierung im Model Garden der Google Gemini Enterprise Agent Platform ist keine direkte Integration der Open-Source-Bibliothek. In der Gemini Enterprise Agent Platform wird eine angepasste und optimierte Version von vLLM verwendet, die speziell auf die Verbesserung von Leistung, Zuverlässigkeit und nahtloser Integration in Cloud de Confiance by S3NSzugeschnitten ist.

• Leistungsoptimierungen:
  • Paralleles Herunterladen aus Cloud Storage:Das Laden und Bereitstellen von Modellen wird erheblich beschleunigt, da Daten parallel aus Cloud Storage abgerufen werden können. Dadurch wird die Latenz reduziert und die Startgeschwindigkeit verbessert.
• Funktionsverbesserungen:
  • Dynamisches LoRA mit erweitertem Caching und Cloud Storage-Unterstützung:Die dynamischen LoRA-Funktionen werden durch lokale Festplatten-Caching-Mechanismen und eine robuste Fehlerbehandlung erweitert. Außerdem wird das Laden von LoRA-Gewichten direkt aus Cloud Storage-Pfaden und signierten URLs unterstützt. Dies vereinfacht die Verwaltung und Bereitstellung benutzerdefinierter Modelle.
  • Parsing von Funktionsaufrufen für Llama 3.1/3.2:Implementiert ein spezielles Parsing für Funktionsaufrufe für Llama 3.1/3.2, wodurch die Robustheit beim Parsen verbessert wird.
  • Prefix-Caching für Hostspeicher:Das externe vLLM unterstützt nur das Prefix-Caching für GPU-Speicher.
  • Spekulatives Decodieren:Dies ist eine vorhandene vLLM-Funktion, aber in der Gemini Enterprise Agent Platform wurden Tests durchgeführt, um leistungsstarke Modelleinrichtungen zu finden.

Diese Anpassungen, die speziell für die Gemini Enterprise Agent Platform entwickelt wurden, sind für den Endnutzer oft transparent. Sie ermöglichen es Ihnen jedoch, die Leistung und Effizienz Ihrer Llama 3.1-Bereitstellungen im Model Garden der Gemini Enterprise Agent Platform zu maximieren.

• Integration in das Ökosystem der Gemini Enterprise Agent Platform:
  • Unterstützung von Eingabe-/Ausgabeformaten für Vorhersagen der Gemini Enterprise Agent Platform:Sorgt für nahtlose Kompatibilität mit Eingabe- und Ausgabeformaten für Vorhersagen der Gemini Enterprise Agent Platform und vereinfacht die Datenverarbeitung und Integration mit anderen Diensten der Gemini Enterprise Agent Platform.
  • Vertex-Umgebungsvariablen: Die Umgebungsvariablen (AIP_*) der Gemini Enterprise Agent Platform werden für die Konfiguration und Ressourcenverwaltung berücksichtigt und genutzt. So wird die Bereitstellung optimiert und ein einheitliches Verhalten in der Umgebung der Gemini Enterprise Agent Platform gewährleistet.
  • Verbesserte Fehlerbehandlung und Robustheit:Umfassende Fehlerbehandlung, Ein-/Ausgabevalidierung und Serverbeendigungsmechanismen sorgen für Stabilität, Zuverlässigkeit und reibungslosen Betrieb in der verwalteten Gemini Enterprise Agent Platform-Umgebung.
  • Nginx-Server für Funktion: Integriert einen Nginx-Server über dem vLLM-Server, was die Bereitstellung mehrerer Replikate ermöglicht und die Skalierbarkeit und Hochverfügbarkeit der Bereitstellungsinfrastruktur verbessert.

Zusätzliche Vorteile von vLLM

• Benchmark-Leistung: vLLM bietet im Vergleich zu anderen Bereitstellungssystemen wie Hugging Face „text-generation-inference“ und FasterTransformer von NVIDIA eine wettbewerbsfähige Leistung in Bezug auf Durchsatz und Latenz.
• Einfache Bedienung: Die Bibliothek bietet eine unkomplizierte API für die Integration in bestehende Arbeitsabläufe. So können Sie sowohl Llama 3.1- als auch Llama 3.2-Modelle mit minimalem Aufwand bereitstellen.
• Erweiterte Funktionen: vLLM unterstützt Streaming-Ausgaben (Generieren von Antworten Token für Token) und verarbeitet Prompts mit variabler Länge effizient, wodurch die Interaktivität und Reaktionsfähigkeit in Anwendungen verbessert werden.

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

Unterstützte Modelle

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

Erste Schritte mit Model Garden

Der vLLM Cloud GPUs-Bereitstellungscontainer ist in Model Garden, Playground, Ein-Klick-Bereitstellung und Colab Enterprise-Notebook-Beispiele integriert. In dieser Anleitung wird die Llama-Modellfamilie von Meta AI als Beispiel verwendet.

Colab Enterprise-Notebook verwenden

Playground- und One-Click-Bereitstellungen sind ebenfalls verfügbar, werden in dieser Anleitung jedoch 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 geladen.
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 Cloud de Confiance by S3NS-Projekts und zum Bereitstellen der erforderlichen Ressourcen für die Bereitstellung und Bereitstellung von vLLM-Modellen beschrieben.

1. Abrechnung

• Abrechnung aktivieren: Achten Sie darauf, dass die Abrechnung für Ihr Projekt aktiviert ist. Weitere Informationen finden Sie unter Abrechnung für ein Projekt aktivieren, deaktivieren oder ändern.

2. GPU-Verfügbarkeit und ‑Kontingente

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

3. Cloud de Confiance by S3NS -Projekt einrichten

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

• Installation: Aktualisieren Sie die google-cloud-aiplatform-Bibliothek und klonen Sie das Repository mit Hilfsfunktionen.
• Umgebung einrichten: Variablen für die Cloud de Confiance by S3NS Projekt-ID, die Region und einen eindeutigen Cloud Storage-Bucket zum Speichern von Modellartefakten definieren.
• API-Aktivierung: Aktivieren Sie die Gemini Enterprise Agent Platform und die Compute Engine APIs, die für die Bereitstellung und Verwaltung von KI-Modellen unerlässlich 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.
• Initialisierung der Gemini Enterprise Agent Platform: Initialisieren Sie die Clientbibliothek der Gemini Enterprise Agent Platform mit den Einstellungen für Projekt, Standort und Staging-Bucket.
• Dienstkonto einrichten: Identifizieren Sie das Standarddienstkonto zum Ausführen von Gemini Enterprise Agent Platform-Jobs und weisen Sie ihm die erforderlichen Berechtigungen zu.

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 Agent Platform 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 Agent Platform 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 Sammlungen Llama 3.1 und 3.2 von Meta bieten eine Reihe von mehrsprachigen Large Language Models (LLMs), die für die hochwertige Textgenerierung in verschiedenen Anwendungsfällen entwickelt wurden. Diese Modelle sind vortrainiert und anweisungsorientiert und eignen sich hervorragend für Aufgaben wie mehrsprachige Dialoge, Zusammenfassungen und die Suche nach Agenten. Bevor Sie Llama 3.1- und Llama 3.2-Modelle verwenden, müssen Sie den Nutzungsbedingungen zustimmen, wie im Screenshot gezeigt. Die vLLM-Bibliothek bietet eine optimierte Open-Source-Bereitstellungsumgebung mit Optimierungen für Latenz, Speichereffizienz und Skalierbarkeit.

Abbildung 1: Meta LLama 3 Community-Lizenzvereinbarung

Übersicht über die Sammlungen für Meta Llama 3.1 und 3.2

Die Sammlungen für Llama 3.1 und 3.2 sind jeweils für unterschiedliche Bereitstellungsgrößen und Modellgrößen konzipiert und bieten Ihnen flexible Optionen für mehrsprachige Dialogaufgaben und mehr. Weitere Informationen finden Sie auf der Übersichtsseite zu 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-Ausgang).
• 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 Bildanalyse in den Größen 11 B und 90 B (Text + Bilder ein, Text aus). Optimierung: Wie Llama 3.1 sind die 3.2-Modelle für mehrsprachige Dialoge optimiert und erzielen bei Aufgaben zum Abrufen und Zusammenfassen gute Ergebnisse. Bei Standard-Benchmarks werden Spitzenwerte erreicht.
• Modellarchitektur: Llama 3.2 basiert ebenfalls auf einem autoregressiven Transformer-Framework, wobei SFT und RLHF angewendet werden, um die Modelle auf Nützlichkeit und Sicherheit auszurichten.

Hugging Face-Nutzerzugriffstokens

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

Abbildung 2: Einstellungen für das Hugging Face-Zugriffstoken

1. So generieren Sie ein Lesezugriffstoken:

   • Rufen Sie die Einstellungen Ihres Hugging Face-Kontos auf.
   • Erstellen Sie ein neues Token, weisen Sie ihm die Rolle „Lesen“ zu und speichern Sie das Token sicher.

2. Token verwenden:

   • Verwenden Sie das generierte Token, um sich zu authentifizieren und auf öffentliche oder private Repositories zuzugreifen, die für das Tutorial erforderlich sind.

Abbildung 3: Hugging Face-Zugriffstoken verwalten

So haben Sie die richtige Zugriffsebene ohne unnötige Berechtigungen. Diese Praktiken erhöhen die Sicherheit und verhindern, dass Tokens versehentlich offengelegt werden. Weitere Informationen zum Einrichten von Zugriffstokens finden Sie auf der Seite „Access Tokens“ von Hugging Face.

Geben Sie Ihr Token nicht öffentlich oder online weiter. Wenn Sie Ihr Token während der Bereitstellung als Umgebungsvariable festlegen, bleibt es privat für Ihr Projekt. Die Gemini Enterprise Agent Platform sorgt für Sicherheit, indem sie verhindert, dass andere Nutzer auf Ihre Modelle und Endpunkte zugreifen.

Weitere Informationen zum Schutz Ihres Zugriffstokens finden Sie unter Hugging Face-Zugriffstokens – Best Practices.

Nur-Text-Llama 3.1-Modelle mit vLLM bereitstellen

Für die Bereitstellung von Large Language Models in der Produktion bietet vLLM eine effiziente Bereitstellungslösung, die die Arbeitsspeichernutzung optimiert, die Latenz verringert und den Durchsatz erhöht. Dadurch eignet sich vLLM besonders gut für die Verarbeitung der größeren Llama 3.1-Modelle sowie der multimodalen Llama 3.2-Modelle.

Schritt 1: Bereitzustellendes Modell auswählen

Wählen Sie die Llama 3.1-Modellvariante aus, die Sie bereitstellen möchten. Es sind verschiedene Größen und auf Anweisungen abgestimmte Versionen 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 entsprechenden Maschinentyp basierend auf der Modellgröße fest und prüft das Kontingent in der 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, ob in der angegebenen Region ein GPU-Kontingent verfügbar ist:

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

Mit der folgenden Funktion wird das Modell in die Gemini Enterprise Agent Platform hochgeladen, die Bereitstellungseinstellungen werden konfiguriert und das Modell wird mit vLLM für einen Endpunkt bereitgestellt.

1. Docker-Image: Bei der Bereitstellung wird ein vorgefertigtes vLLM-Docker-Image für die effiziente Bereitstellung verwendet.
2. Konfiguration: Konfigurieren Sie die Speichernutzung, die Modelllänge und andere vLLM-Einstellungen. 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 Agent Platform."""
    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: Deployment 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 der Gemini Enterprise Agent Platform bereitgestellt und ist über den angegebenen Endpunkt zugänglich. Sie können mit ihm interagieren, um Inferenzaufgaben wie Textgenerierung, Zusammenfassung und Dialog auszuführen. Je nach Modellgröße kann die Bereitstellung eines neuen Modells bis zu einer Stunde dauern. Sie können den Fortschritt bei der Onlinevorhersage prüfen.

Abbildung 4: Llama 3.1-Bereitstellungsendpunkt im Vertex-Dashboard

Vorhersagen mit Llama 3.1 auf der Gemini Enterprise Agent Platform treffen

Nachdem Sie das Llama 3.1-Modell erfolgreich in der Gemini Enterprise Agent Platform bereitgestellt haben, können Sie Vorhersagen treffen, indem Sie Text-Prompts 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 Ihren Text-Prompt und die Sampling-Parameter 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 Sie Probleme mit Zeitüberschreitungen vermeiden.
• 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: Beschränkt den Stichprobenpool auf die höchste kumulative Wahrscheinlichkeit. Wenn Sie beispielsweise „top_p = 0.9“ festlegen, werden nur Tokens innerhalb der obersten 90 % der Wahrscheinlichkeitsmasse berücksichtigt.
• top_k: Beschränkt die Stichprobenerhebung auf die k wahrscheinlichsten Tokens. Wenn Sie beispielsweise „top_k = 50“ festlegen, werden nur die 50 besten Tokens berücksichtigt.
• raw_response: Wenn „True“, wird die Rohausgabe des Modells zurückgegeben. Bei „False“ wird die zusätzliche Formatierung mit der Struktur „Prompt:\n{prompt}\nOutput:\n{output}“ angewendet.
• lora_id (optional): Pfad zu LoRA-Gewichtungsdateien zum Anwenden von Gewichten für Low-Rank Adaptation (LoRA). Das kann ein Cloud Storage-Bucket oder eine Hugging Face-Repository-URL sein. Das funktioniert nur, wenn --enable-lora in den Bereitstellungsargumenten festgelegt ist. Dynamic 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 Gemini Enterprise Agent Platform-Endpunkt senden. In diesem Beispiel wird gezeigt, wie Sie eine Vorhersage treffen und das Ergebnis ausgeben:

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 Textmoderationsfunktionen der Agent Platform 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 zu interagieren. Dabei können verschiedene Sampling-Techniken und LoRA-Adapter verwendet werden. Das Modell eignet sich daher für eine Vielzahl von Anwendungsfällen, von der Textgenerierung für allgemeine Zwecke bis hin zu aufgabenspezifischen Antworten.

Multimodale Llama 3.2-Modelle mit vLLM bereitstellen

In diesem Abschnitt wird beschrieben, wie Sie vorgefertigte Llama 3.2-Modelle in die Model Registry hochladen und an einem Gemini Enterprise Agent Platform-Endpunkt bereitstellen. Die Bereitstellung kann je nach Größe des Modells 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: Bereitzustellendes Modell auswählen

Geben Sie die Llama 3.2-Modellvariante an, die Sie bereitstellen möchten. Im folgenden Beispiel wird Llama-3.2-11B-Vision als ausgewähltes Modell verwendet. Sie können jedoch je nach Bedarf auch andere verfügbare Optionen 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 geeignete Hardware für die Modellgröße aus. vLLM kann je nach Rechenanforderungen des Modells verschiedene GPUs verwenden:

• 1B- und 3B-Modelle: 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}.")

Prüfen Sie, ob Sie das erforderliche GPU-Kontingent haben:

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 auf der Gemini Enterprise Agent Platform. Damit werden die Umgebung, die Speichernutzung 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 Agent Platform."""
    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: Deployment ausführen

Führen Sie die Bereitstellungsfunktion mit dem konfigurierten Modell und den konfigurierten 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 Modellgröße kann die Bereitstellung eines neuen Modells bis zu einer Stunde dauern. Sie können den Fortschritt bei der Onlinevorhersage verfolgen.

Inferenz mit vLLM auf der Gemini Enterprise Agent Platform über den Standardvorhersagepfad

In diesem Abschnitt erfahren Sie, wie Sie die Inferenz für das Modell „Llama 3.2 Vision“ auf der Gemini Enterprise Agent Platform mit dem Standardvorhersagepfad einrichten. Sie verwenden die vLLM-Bibliothek für die effiziente Bereitstellung und interagieren mit dem Modell, indem Sie einen visuellen Prompt in Kombination mit Text senden.

Prüfen Sie zuerst, ob Ihr 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 das Modell verarbeitet, um eine Antwort zu generieren.

Abbildung 6: Beispiel für die Bildeingabe für Prompts 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 Gemini Enterprise Agent Platform-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 Sie auf ein Zeitlimitproblem stoßen (z. B. ServiceUnavailable: 503 Took too long to respond when processing), versuchen Sie, den Wert von max_tokens auf eine niedrigere Zahl wie 20 zu reduzieren, um die Reaktionszeit zu verkürzen.

Inferenz mit vLLM auf der Gemini Enterprise Agent Platform mit OpenAI Chat Completion

In diesem Abschnitt wird beschrieben, wie Sie mit der OpenAI Chat Completions API auf der Gemini Enterprise Agent Platform Inferenz für Llama 3.2 Vision-Modelle ausführen. Mit diesem Ansatz können Sie multimodale Funktionen nutzen, indem Sie sowohl Bilder als auch Textprompts an das Modell senden, um interaktivere Antworten zu erhalten.

Schritt 1: Llama 3.2 Vision Instruct-Modell bereitstellen

Führen Sie die Bereitstellungsfunktion mit dem konfigurierten Modell und den konfigurierten 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 Endpunktressourcennamen für Ihre Gemini Enterprise Agent Platform-Bereitstellung ein.

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

Schritt 3: OpenAI SDK und Authentifizierungsbibliotheken installieren

Wenn Sie Anfragen mit dem SDK von OpenAI senden möchten, müssen Sie die erforderlichen Bibliotheken installieren:

!pip install -qU openai google-auth requests

Schritt 4: Eingabeparameter für die Chat-Vervollständigung definieren

Richten Sie die Bild-URL und den Text-Prompt ein, 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: Chat-Vervollständigungsanfrage senden

Senden Sie das Bild und den Text-Prompt mithilfe der Chat Completions API von OpenAI an Ihren Gemini Enterprise Agent Platform-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): Verbindung zu einem vorhandenen Endpunkt wiederherstellen

Wenn Sie die Verbindung zu einem zuvor erstellten Endpunkt wiederherstellen möchten, verwenden Sie die Endpunkt-ID. 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 Einrichtung bietet die Flexibilität, bei Bedarf zwischen neu erstellten und vorhandenen Endpunkten zu wechseln, was Tests und die Bereitstellung vereinfacht.

Bereinigen

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

Schritt 1: Endpunkte und Modelle löschen

Mit dem folgenden Code wird die Bereitstellung jedes Modells aufgehoben und die zugehörigen Endpunkte werden 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 dieses Experiment 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

Wenn Sie diese Schritte ausführen, werden alle in dieser Anleitung verwendeten Ressourcen bereinigt, wodurch unnötige Kosten für das Experiment reduziert werden.

Häufige Probleme beheben

In diesem Abschnitt finden Sie Informationen zum Identifizieren und Beheben häufiger Probleme, die bei der Bereitstellung und Inferenz von vLLM-Modellen auf der Gemini Enterprise Agent Platform auftreten.

Log prüfen

Prüfen Sie die Logs, um die Ursache von Bereitstellungsfehlern oder unerwartetem Verhalten zu ermitteln:

1. Zur Gemini Enterprise Agent Platform Prediction Console wechseln:Rufen Sie in der Cloud de Confiance Console die Gemini Enterprise Agent Platform 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. Logs ansehen:Klicken Sie auf den Endpunkt und rufen Sie dann den Tab Logs auf oder klicken Sie auf Logs ansehen. Sie werden zu Cloud Logging weitergeleitet, wo die Logs für diesen Endpunkt und die Modellbereitstellung gefiltert angezeigt werden. Sie können auch direkt über den Cloud Logging-Dienst auf Logs zugreifen.
4. Logs analysieren:Prüfen Sie die Logeinträge auf Fehlermeldungen, Warnungen und andere relevante Informationen. Zeitstempel ansehen, um Logeinträge mit bestimmten Aktionen in Beziehung zu setzen. Suchen Sie nach Problemen im Zusammenhang mit Ressourcenbeschränkungen (Arbeitsspeicher und CPU), Authentifizierungsproblemen oder Konfigurationsfehlern.

Häufiges Problem 1: CUDA-Fehler „Out of Memory“ (OOM) während der Bereitstellung

CUDA-OOM-Fehler (Out-of-Memory) treten auf, wenn die Arbeitsspeichernutzung des Modells die verfügbare GPU-Kapazität überschreitet.

Für das Modell, das nur Text enthält, 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 haben wir 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 beim reinen Textmodell, 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 „Out of Memory“ (OOM)

max_num_seqs und GPU-Arbeitsspeicher:

• 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 Gesamtarbeitsspeichernutzung ist proportional zu max_num_seqs multipliziert mit dem Arbeitsspeicher pro Sequenz.
• Nur-Text-Modelle (wie Meta-Llama-3.1-8B) benötigen in der Regel weniger Speicher pro Sequenz als multimodale Modelle (wie Llama-3.2-11B-Vision-Instruct), die sowohl Text als auch Bilder verarbeiten.

Sehen Sie sich das Fehlerprotokoll an (Abbildung 8):

• Das Protokoll zeigt ein torch.OutOfMemoryError beim Versuch, Arbeitsspeicher auf der GPU zuzuweisen.
• Der Fehler tritt auf, weil die Arbeitsspeichernutzung des Modells die verfügbare GPU-Kapazität überschreitet. Die NVIDIA L4-GPU hat 24 GB. Wenn Sie den Parameter max_num_seqs für das multimodale Modell zu hoch festlegen, kommt es zu einem Überlauf.
• Das Log empfiehlt, PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True festzulegen, um die Speicherverwaltung zu verbessern. Das primäre Problem ist jedoch die hohe Speicherauslastung.

Abbildung 8: Fehler bei der Bereitstellung von Llama 3.2

Abbildung 9: Feld „Model Version Details“ (Details zur Modellversion)

Um dieses Problem zu beheben, rufen Sie die Gemini Enterprise Agent Platform Prediction Console auf und klicken Sie auf den Endpunkt. Der Status sollte angeben, dass die Bereitstellung fehlgeschlagen ist. Klicken Sie hier, um die Logs aufzurufen. Prüfen Sie, ob „max-num-seqs“ = 256 ist. Dieser Wert ist für Llama-3.2-11B-Vision-Instruct zu hoch. Ein angemessenerer Wert wäre 12.

Häufiges Problem 2: Hugging Face-Token erforderlich

Hugging Face-Tokenfehler treten auf, wenn für das Modell ein eingeschränkter Zugriff gilt und für den Zugriff auf das Modell gültige Anmeldedaten erforderlich sind.

Der folgende Screenshot zeigt einen Logeintrag im Log-Explorer von Google Cloud mit einer Fehlermeldung zum Zugriff auf das auf Hugging Face gehostete Modell Meta LLaMA-3.2-11B-Vision. Der Fehler weist darauf hin, dass der Zugriff auf das Modell eingeschränkt ist und eine Authentifizierung erforderlich ist, um fortzufahren. In der Meldung heißt es: „Cannot access gated repository for URL“ (Auf das Repository mit Zugriffsbeschränkung für die URL kann nicht zugegriffen werden). Das weist darauf hin, dass für das Modell eine Zugriffsbeschränkung gilt und für den Zugriff entsprechende Authentifizierungsanmeldedaten erforderlich sind. Dieser Logeintrag kann bei der Behebung von Authentifizierungsproblemen bei der Arbeit mit eingeschränkten Ressourcen in externen Repositories hilfreich sein.

Abbildung 10: Hugging Face-Token-Fehler

Prüfen Sie zur Behebung dieses Problems die Berechtigungen Ihres Hugging Face-Zugriffstokens. Kopieren Sie das aktuelle Token und stellen Sie einen neuen Endpunkt bereit.

Häufiges Problem 3: Chatvorlage erforderlich

Fehler bei Chatvorlagen treten auf, wenn die Standard-Chatvorlage nicht mehr zulässig ist und eine benutzerdefinierte Chatvorlage angegeben werden muss, wenn der Tokenizer keine definiert.

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

Abbildung 11: Chatvorlage erforderlich

Um dies zu umgehen, müssen Sie bei der Bereitstellung mit dem Eingabeargument --chat-template eine Chatvorlage angeben. Beispielvorlagen finden Sie im vLLM-Beispielrepository.

Häufiges Problem 4: Model Max Seq Len

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

Abbildung 12: Max. Sequenzlänge zu groß

ValueError: The model's max seq len (4096) is larger than the maximum number of tokens that can be stored in KV cache (2256). Try increasing gpu_memory_utilization or decreasing max_model_len when initializing the engine. (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.)

Um dieses Problem zu beheben, legen Sie „max_model_len“ auf 2.048 fest. Das ist weniger als 2.256. Eine weitere Lösung für dieses Problem besteht darin, mehr oder größere GPUs zu verwenden. Wenn Sie sich für die Verwendung von mehr GPUs entscheiden, muss „tensor-parallel-size“ entsprechend festgelegt werden.

Model Garden-Versionshinweise für vLLM-Container

Haupt-Releases

Standard-vLLM

Optimiertes vLLM

Zusätzliche Releases

Die vollständige Liste der VMG-Standard-vLLM-Container-Releases finden Sie auf der Artifact Registry-Seite.

Releases für vLLM-TPU im experimentellen Status sind mit <yyyymmdd_hhmm_tpu_experimental_RC00> gekennzeichnet.