Mise en service de vLLM pour les modèles de langage textuels et multimodaux sur des GPU Cloud

Résumé

Ce tutoriel vous explique comment déployer et mettre en service des modèles Llama 3.1 et 3.2 à l'aide de vLLM dans Gemini Enterprise Agent Platform. Il est conçu pour être utilisé avec deux notebooks distincts : Serve Llama 3.1 avec vLLM pour déployer des modèles Llama 3.1 uniquement textuels, et Serve Multimodal Llama 3.2 avec vLLM pour déployer des modèles Llama 3.2 multimodaux qui gèrent à la fois les entrées de texte et d'image. Les étapes décrites sur cette page vous montrent comment gérer efficacement l'inférence de modèle sur des GPU et personnaliser des modèles pour diverses applications. Vous disposez ainsi des outils nécessaires pour intégrer des modèles de langage avancés à vos projets.

À la fin de ce guide, vous saurez comment :

  • Télécharger des modèles Llama prédéfinis de Hugging Face avec un conteneur vLLM
  • Utiliser vLLM pour déployer ces modèles sur des instances GPU dans Google Cloud Gemini Enterprise Agent Platform Model Garden
  • Mettre en service des modèles de manière efficace pour traiter les requêtes d'inférence à grande échelle
  • Exécuter l'inférence sur les requêtes uniquement basées sur du texte et les requêtes basées sur du texte et des images
  • Supprimer les fichiers de l"atelier
  • Déboguer le déploiement

Principales fonctionnalités de vLLM

Fonctionnalité Description
PagedAttention Un mécanisme d'attention optimisé qui gère efficacement la mémoire pendant l'inférence. Permet de générer du texte à haut débit en allouant dynamiquement des ressources de mémoire, ce qui permet d'évoluer pour répondre à plusieurs requêtes simultanées.
Traitement par lot continu Regroupe plusieurs requêtes d'entrée dans un seul lot pour un traitement en parallèle, ce qui optimise l'utilisation et le débit du GPU.
Distribution de jetons Active la sortie jeton par jeton en temps réel pendant la génération de texte. Idéal pour les applications qui nécessitent une faible latence, comme les chatbots ou les systèmes d'IA interactifs.
Compatibilité des modèles Il est compatible avec un large éventail de modèles pré-entraînés sur des frameworks populaires tels que Hugging Face Transformers. Il facilite l'intégration et l'expérimentation de différents LLM.
Multi-GPU et multi-hôte Permet une mise en service efficace des modèles en répartissant la charge de travail sur plusieurs GPU au sein d'une même machine et sur plusieurs machines d'un cluster, ce qui augmente considérablement le débit et l'évolutivité.
Déploiement efficace Il s'intègre parfaitement aux API, telles que les complétions de chat OpenAI, ce qui facilite le déploiement pour les cas d'utilisation en production.
Intégration parfaite aux modèles Hugging Face vLLM est compatible avec le format d'artefact de modèle Hugging Face et accepte le chargement depuis HF. Il est donc facile de déployer des modèles Llama aux côtés d'autres modèles populaires comme Gemma, Phi et Qwen dans un environnement optimisé.
Projet Open Source géré par la communauté vLLM est Open Source et encourage les contributions de la communauté, ce qui favorise l'amélioration continue de l'efficacité de la diffusion des LLM.

Tableau 1 : Résumé des fonctionnalités de vLLM

Personnalisations de vLLM sur Google Gemini Enterprise Agent Platform : améliorez les performances et l'intégration

L'implémentation de vLLM dans Model Garden de Google Gemini Enterprise Agent Platform n'est pas une intégration directe de la bibliothèque Open Source. Gemini Enterprise Agent Platform gère une version personnalisée et optimisée de vLLM, spécialement conçue pour améliorer les performances, la fiabilité et l'intégration parfaite dans Google Cloud.

  • Optimisations des performances :
    • Téléchargement parallèle depuis Cloud Storage : accélère considérablement le chargement et le déploiement des modèles en permettant la récupération parallèle des données depuis Cloud Storage, ce qui réduit la latence et améliore la vitesse de démarrage.
  • Améliorations des fonctionnalités :
    • LoRA dynamique avec mise en cache améliorée et compatibilité avec Cloud Storage : étend les fonctionnalités LoRA dynamiques avec des mécanismes de mise en cache sur disque local et une gestion robuste des erreurs, ainsi que la compatibilité avec le chargement des pondérations LoRA directement à partir des chemins d'accès Cloud Storage et des URL signées. Cela simplifie la gestion et le déploiement des modèles personnalisés.
    • Analyse des appels de fonction Llama 3.1/3.2 : implémente une analyse spécialisée pour les appels de fonction Llama 3.1/3.2, ce qui améliore la robustesse de l'analyse.
    • Mise en cache des préfixes de mémoire hôte : vLLM externe n'est compatible qu'avec la mise en cache des préfixes de mémoire GPU.
    • Décodage spéculatif : il s'agit d'une fonctionnalité vLLM existante, mais Gemini Enterprise Agent Platform a effectué des tests pour trouver des configurations de modèle performantes.

Ces personnalisations spécifiques à Gemini Enterprise Agent Platform, bien que souvent transparentes pour l'utilisateur final, vous permettent de maximiser les performances et l'efficacité de vos déploiements Llama 3.1 sur Model Garden sur Gemini Enterprise Agent Platform.

  • Intégration de l'écosystème Gemini Enterprise Agent Platform :
    • Compatibilité avec les formats d'entrée/sortie de prédiction de Gemini Enterprise Agent Platform : assure une compatibilité parfaite avec les formats d'entrée et de sortie de prédiction de Gemini Enterprise Agent Platform, ce qui simplifie la gestion des données et l'intégration avec d'autres services Gemini Enterprise Agent Platform.
    • Prise en compte des variables d'environnement Vertex : respecte et exploite les variables d'environnement Gemini Enterprise Agent Platform (AIP_*) pour la configuration et la gestion des ressources, ce qui simplifie le déploiement et garantit un comportement cohérent dans l'environnement Gemini Enterprise Agent Platform.
    • Gestion des exceptions et robustesse améliorées : implémente des mécanismes complets de gestion des exceptions, de validation des entrées/sorties et d'arrêt du serveur pour garantir la stabilité, la fiabilité et un fonctionnement fluide dans l'environnement géré de Gemini Enterprise Agent Platform.
    • Serveur Nginx pour la capacité : intègre un serveur Nginx au-dessus du serveur vLLM, ce qui facilite le déploiement de plusieurs instances répliquées et améliore l'évolutivité et la haute disponibilité de l'infrastructure de diffusion.

Avantages supplémentaires de vLLM

  • Performances de l'analyse comparative : vLLM offre des performances compétitives par rapport à d'autres systèmes de diffusion tels que l'inférence de génération de texte Hugging Face et FasterTransformer de NVIDIA en termes de débit et de latence.
  • Facilité d'utilisation : la bibliothèque fournit une API simple pour l'intégration aux workflows existants, ce qui vous permet de déployer les modèles Llama 3.1 et 3.2 avec une configuration minimale.
  • Fonctionnalités avancées : vLLM est compatible avec les sorties en streaming (génération de réponses jeton par jeton) et gère efficacement les requêtes de longueur variable, ce qui améliore l'interactivité et la réactivité des applications.

Pour une présentation du système vLLM, consultez cet article.

Modèles compatibles

vLLM est compatible avec une large sélection de modèles de pointe, ce qui vous permet de choisir celui qui correspond le mieux à vos besoins. Le tableau suivant présente une sélection de ces modèles. Toutefois, pour accéder à une liste complète des modèles compatibles, y compris ceux pour l'inférence textuelle et multimodale, vous pouvez consulter le site Web officiel de vLLM.

Catégorie Modèles
Meta AI Llama 3.3, Llama 3.2, Llama 3.1, Llama 3, Llama 2, Code Llama
Mistral AI Mistral 7B, Mixtral 8x7B, Mixtral 8x22B et leurs variantes (Instruct, Chat), Mistral-tiny, Mistral-small, Mistral-medium
DeepSeek AI DeepSeek-V3, DeepSeek-R1, DeepSeek-R1-Distill-Qwen-1.5B, DeepSeek-R1-Distill-Qwen-7B, DeepSeek-R1-Distill-Llama-8B, DeepSeek-R1-Distill-Qwen-14B, DeepSeek-R1-Distill-Qwen-32B, DeepSeek-R1-Distill-Llama-70B, Deepseek-vl2-tiny, Deepseek-vl2-small, Deepseek-vl2
MosaicML MPT (7B, 30B) et variantes (Instruct, Chat), MPT-7B-StoryWriter-65k
OpenAI GPT-2, GPT-3, GPT-4, GPT-NeoX
Together AI RedPajama, Pythia
Stability AI StableLM (3B, 7B), StableLM-Alpha-3B, StableLM-Base-Alpha-7B, StableLM-Instruct-Alpha-7B
TII (Technology Innovation Institute) Falcon 7B, Falcon 40B et variantes (Instruct, Chat), Falcon-RW-1B, Falcon-RW-7B
BigScience BLOOM, BLOOMZ
Google FLAN-T5, UL2, Gemma (2B, 7B), PaLM 2,
Salesforce CodeT5, CodeT5+
LightOn Persimmon-8B-base, Persimmon-8B-chat
EleutherAI GPT-Neo, Pythia
AI21 Labs Jamba
Cerebras Cerebras-GPT
Intel Intel-NeuralChat-7B
Autres modèles importants StarCoder, OPT, Baichuan, Aquila, Qwen, InternLM, XGen, OpenLLaMA, Phi-2, Yi, OpenCodeInterpreter, Nous-Hermes, Gemma-it, Mistral-Instruct-v0.2-7B-Zeus,

Tableau 2 : Quelques modèles compatibles avec vLLM

Premiers pas dans Model Garden

Le conteneur de diffusion Cloud GPU vLLM est intégré à Model Garden, au Playground, au déploiement en un clic et aux exemples de notebooks Colab Enterprise. Ce tutoriel utilise la famille de modèles Llama de Meta AI comme exemple.

Utiliser le notebook Colab Enterprise

Les déploiements Playground et en un clic sont également disponibles, mais ne sont pas décrits dans ce tutoriel.

  1. Accédez à la page de la fiche de modèle, puis cliquez sur Ouvrir le notebook.
  2. Sélectionnez le notebook Vertex Serving. Le notebook s'ouvre dans Colab Enterprise.
  3. Parcourez le notebook pour déployer un modèle à l'aide de vLLM et envoyez des requêtes de prédiction au point de terminaison.

Préparation

Cette section décrit les étapes nécessaires pour configurer votre projet Google Cloudet vous assurer que vous disposez des ressources requises pour déployer et diffuser des modèles vLLM.

1. Facturation

2. Disponibilité et quotas des GPU

Type de machine Type d'accélérateur Régions recommandées
a2-ultragpu-1g 1 NVIDIA_A100_80GB us-central1, us-east4, europe-west4, asia-southeast1
a3-highgpu-8g 8 NVIDIA_H100_80GB us-central1, us-west1, europe-west4, asia-southeast1

3. Configurer un projet Google Cloud

Exécutez l'exemple de code suivant pour vous assurer que votre environnement Google Cloud est correctement configuré. Cette étape installe les bibliothèques Python nécessaires et configure l'accès aux ressources Google Cloud . Ceci inclut les actions suivantes :

  • Installation : mettez à niveau la bibliothèque google-cloud-aiplatform et clonez le dépôt contenant les fonctions utilitaires.
  • Configuration de l'environnement : définition des variables pour l'ID du projet Google Cloud , la région et un bucket Cloud Storage unique pour stocker les artefacts du modèle.
  • Activation des API : activez les API Gemini Enterprise Agent Platform et Compute Engine, qui sont essentielles pour déployer et gérer des modèles d'IA.
  • Configuration du bucket : créez un bucket Cloud Storage ou vérifiez un bucket existant pour vous assurer qu'il se trouve dans la bonne région.
  • Initialisation de Gemini Enterprise Agent Platform : initialisez la bibliothèque cliente Gemini Enterprise Agent Platform avec les paramètres de projet, d'emplacement et de bucket de préproduction.
  • Configuration du compte de service : identifiez le compte de service par défaut pour l'exécution des jobs Gemini Enterprise Agent Platform et accordez-lui les autorisations nécessaires.
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"

Utiliser Hugging Face avec Meta Llama 3.1, 3.2 et vLLM

Les collections Llama 3.1 et 3.2 de Meta fournissent une gamme de grands modèles de langage (LLM) multilingues conçus pour générer du texte de haute qualité dans divers cas d'utilisation. Ces modèles sont pré-entraînés et adaptés aux instructions. Ils excellent dans des tâches telles que le dialogue multilingue, la synthèse et la récupération agentique. Avant d'utiliser les modèles Llama 3.1 et 3.2, vous devez accepter leurs conditions d'utilisation, comme indiqué dans la capture d'écran. La bibliothèque vLLM offre un environnement de diffusion Open Source simplifié avec des optimisations pour la latence, l'efficacité de la mémoire et l'évolutivité.

Contrat de licence Communauté Meta Llama 3 Figure 1 : Contrat de licence de la communauté Meta Llama 3

Présentation des collections Meta Llama 3.1 et 3.2

Les collections Llama 3.1 et 3.2 répondent chacune à des échelles de déploiement et des tailles de modèle différentes, ce qui vous offre des options flexibles pour les tâches de dialogue multilingue et plus encore. Pour en savoir plus, consultez la page de présentation de Llama.

  • Texte uniquement : la collection Llama 3.2 de grands modèles de langage (LLM) multilingues est une collection de modèles génératifs pré-entraînés et adaptés aux instructions, offrant 1 ou 3 milliards de paramètres (texte entrant/texte sortant).
  • Vision et Vision Instruct : la collection Llama 3.2-Vision de grands modèles de langage (LLM) multimodaux est une collection de modèles génératifs de raisonnement par image pré-entraînés et adaptés aux instructions, proposés en 11 milliards et 90 milliards de paramètres (texte + images entrants, texte sortant). Optimisation : comme Llama 3.1, les modèles 3.2 sont adaptés aux dialogues multilingues et sont performants pour les tâches de récupération et de synthèse, ce qui leur permet d'obtenir d'excellents résultats sur les benchmarks standards.
  • Architecture du modèle : Llama 3.2 dispose également d'un framework de transformateur autorégressif, avec SFT et RLHF appliqués pour aligner les modèles sur l'utilité et la sécurité.

Jetons d'accès utilisateur Hugging Face

Ce tutoriel nécessite un jeton d'accès en lecture du hub Hugging Face pour accéder aux ressources nécessaires. Pour configurer l'authentification, procédez comme suit :

Paramètres du jeton d'accès Hugging Face Figure 2 : Paramètres du jeton d'accès Hugging Face

  1. Générez un jeton d'accès en lecture :

  2. Utilisez le jeton :

    • Utilisez le jeton généré pour vous authentifier et accéder aux dépôts publics ou privés, selon les besoins du tutoriel.
Gérer le jeton d'accès Hugging Face Figure 3 : Gérer le jeton d'accès Hugging Face

Cette configuration vous permet de disposer du niveau d'accès approprié sans autorisations inutiles. Ces pratiques renforcent la sécurité et empêchent l'exposition accidentelle des jetons. Pour en savoir plus sur la configuration des jetons d'accès, consultez la page sur les jetons d'accès Hugging Face.

Évitez de partager ou d'exposer votre jeton publiquement ou en ligne. Lorsque vous définissez votre jeton en tant que variable d'environnement lors du déploiement, il reste privé pour votre projet. Gemini Enterprise Agent Platform assure sa sécurité en empêchant les autres utilisateurs d'accéder à vos modèles et points de terminaison.

Pour en savoir plus sur la protection de votre jeton d'accès, consultez Hugging Face Access Tokens - Best Practices (Jetons d'accès Hugging Face : bonnes pratiques).

Déployer des modèles Llama 3.1 textuels avec vLLM

Pour le déploiement en production de grands modèles de langage, vLLM fournit une solution de diffusion efficace qui optimise l'utilisation de la mémoire, réduit la latence et augmente le débit. Il est donc particulièrement adapté à la gestion des modèles Llama 3.1 plus volumineux, ainsi que des modèles Llama 3.2 multimodaux.

Étape 1 : Choisissez un modèle à déployer

Choisissez la variante du modèle Llama 3.1 à déployer. Les options disponibles incluent différentes tailles et versions optimisées pour les instructions :

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

Étape 2 : Vérifiez le matériel et le quota de déploiement

La fonction de déploiement définit le GPU et le type de machine appropriés en fonction de la taille du modèle, et vérifie le quota dans cette région pour un projet particulier :

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}.")

Vérifiez la disponibilité des quotas de GPU dans la région spécifiée :

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

Étape 3 : Inspecter le modèle à l'aide de vLLM

La fonction suivante importe le modèle dans Gemini Enterprise Agent Platform, configure les paramètres de déploiement et le déploie sur un point de terminaison à l'aide de vLLM.

  1. Image Docker : le déploiement utilise une image Docker vLLM prédéfinie pour une diffusion efficace.
  2. Configuration : configurez l'utilisation de la mémoire, la longueur du modèle et d'autres paramètres vLLM. Pour en savoir plus sur les arguments compatibles avec le serveur, consultez la page de documentation officielle de vLLM.
  3. Variables d'environnement : définissez des variables d'environnement pour l'authentification et la source de déploiement.
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

Étape 4 : Exécuter le déploiement

Exécutez la fonction de déploiement avec le modèle et la configuration sélectionnés. Cette étape déploie le modèle et renvoie les instances de modèle et de point de terminaison :

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,
)

Après avoir exécuté cet exemple de code, votre modèle Llama 3.1 sera déployé sur Gemini Enterprise Agent Platform et accessible via le point de terminaison spécifié. Vous pouvez interagir avec lui pour des tâches d'inférence telles que la génération de texte, la synthèse et le dialogue. Selon la taille du modèle, le déploiement d'un nouveau modèle peut prendre jusqu'à une heure. Vous pouvez vérifier la progression de la prédiction en ligne.

Point de terminaison de déploiement Llama 3.1 dans le tableau de bord Vertex Figure 4 : Point de terminaison de déploiement Llama 3.1 dans le tableau de bord Vertex

Faire des prédictions avec Llama 3.1 sur Gemini Enterprise Agent Platform

Une fois le modèle Llama 3.1 déployé sur Gemini Enterprise Agent Platform, vous pouvez commencer à effectuer des prédictions en envoyant des prompts textuels au point de terminaison. Cette section fournit un exemple de génération de réponses avec différents paramètres personnalisables pour contrôler la sortie.

Éthought Étape 1 : Définissez votre prompt et vos paramètres

Commencez par configurer votre prompt textuel et vos paramètres d'échantillonnage pour guider la réponse du modèle. Voici les paramètres clés :

  • prompt : texte d'entrée pour lequel vous souhaitez que le modèle génère une réponse. Par exemple, prompt = "What is a car?".
  • max_tokens : nombre maximal de jetons dans la sortie générée. Réduire cette valeur peut aider à éviter les problèmes de délai avant expiration.
  • temperature : contrôle le caractère aléatoire des prédictions. Les valeurs les plus élevées (par exemple, 1,0) augmentent la diversité, tandis que les valeurs les plus basses (par exemple, 0,5) rendent le résultat plus ciblé.
  • top_p : limite le pool d'échantillonnage à la probabilité cumulée la plus élevée. Par exemple, si vous définissez top_p = 0,9, seuls les jetons compris dans les 90 % de la masse de probabilité seront pris en compte.
  • top_k : limite l'échantillonnage aux k jetons les plus probables. Par exemple, si vous définissez top_k = 50, l'échantillonnage ne portera que sur les 50 premiers jetons.
  • raw_response : si la valeur est "True", renvoie la sortie brute du modèle. Si la valeur est "False", appliquez une mise en forme supplémentaire avec la structure "Prompt:\n{prompt}\nOutput:\n{output}".
  • lora_id (facultatif) : chemin d'accès aux fichiers de pondération LoRA pour appliquer les pondérations d'adaptation à faible rang (LoRA). Il peut s'agir d'un bucket Cloud Storage ou d'une URL de dépôt Hugging Face. Notez que cela ne fonctionne que si --enable-lora est défini dans les arguments de déploiement. LoRA dynamique n'est pas compatible avec les modèles multimodaux.
prompt = "What is a car?"
max_tokens = 50
temperature = 1.0
top_p = 1.0
top_k = 1
raw_response = False
lora_id = ""

Étape 2 : Envoyer la requête de prédiction

Maintenant que l'instance est configurée, vous pouvez envoyer la requête de prédiction au point de terminaison Gemini Enterprise Agent Platform déployé. Cet exemple montre comment effectuer une prédiction et afficher le résultat :

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

for prediction in response.predictions:
    print(prediction)

Exemple de résultat

Voici un exemple de réponse du modèle à la requête "Qu'est-ce qu'une voiture ?" :

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.

Remarques supplémentaires

  • Modération : pour garantir la sécurité du contenu, vous pouvez modérer le texte généré à l'aide des fonctionnalités de modération de texte d'Agent Platform.
  • Gérer les délais d'expiration : si vous rencontrez des problèmes tels que ServiceUnavailable: 503, essayez de réduire le paramètre max_tokens.

Cette approche offre un moyen flexible d'interagir avec le modèle Llama 3.1 à l'aide de différentes techniques d'échantillonnage et d'adaptateurs LoRA, ce qui le rend adapté à une variété de cas d'utilisation, de la génération de texte à usage général aux réponses spécifiques à une tâche.

Déployer des modèles Llama 3.2 multimodaux avec vLLM

Cette section vous explique comment importer des modèles Llama 3.2 prédéfinis dans Model Registry et les déployer sur un point de terminaison Gemini Enterprise Agent Platform. Le déploiement peut prendre jusqu'à une heure, selon la taille du modèle. Les modèles Llama 3.2 sont disponibles dans des versions multimodales qui acceptent les entrées de texte et d'image. vLLM est compatible avec :

  • Format texte uniquement
  • Format image unique + texte

Ces formats rendent Llama 3.2 adapté aux applications nécessitant un traitement visuel et textuel.

Étape 1 : Choisissez un modèle à déployer

Spécifiez la variante du modèle Llama 3.2 que vous souhaitez déployer. L'exemple suivant utilise Llama-3.2-11B-Vision comme modèle sélectionné, mais vous pouvez choisir parmi d'autres options disponibles en fonction de vos besoins.

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

Étape 2 : Configurer le matériel et les ressources

Sélectionnez le matériel approprié pour la taille du modèle. vLLM peut utiliser différents GPU en fonction des besoins de calcul du modèle :

  • Modèles 1B et 3B : utilisez des GPU NVIDIA L4.
  • Modèles 11B : utilisez des GPU NVIDIA A100.
  • Modèles 90B : utilisez des GPU NVIDIA H100.

Cet exemple configure le déploiement en fonction de la sélection du modèle :

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}.")

Assurez-vous de disposer du quota de GPU requis :

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

Étape 3 : Déployer le modèle à l'aide de vLLM

La fonction suivante gère le déploiement du modèle Llama 3.2 sur Gemini Enterprise Agent Platform. Il configure l'environnement du modèle, l'utilisation de la mémoire et les paramètres vLLM pour une diffusion efficace.

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

Étape 4 : Exécuter le déploiement

Exécutez la fonction de déploiement avec le modèle et les paramètres configurés. La fonction renvoie les instances de modèle et de point de terminaison, que vous pouvez utiliser pour l'inférence.

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,
)
Point de terminaison de déploiement Llama 3.2 dans le tableau de bord Vertex Figure 5 : Point de terminaison de déploiement Llama 3.2 dans le tableau de bord Vertex

Selon la taille du modèle, le déploiement d'un nouveau modèle peut prendre jusqu'à une heure. Vous pouvez vérifier sa progression dans la prédiction en ligne.

Inférence avec vLLM sur Gemini Enterprise Agent Platform à l'aide de la route de prédiction par défaut

Cette section vous explique comment configurer l'inférence pour le modèle Llama 3.2 Vision sur Gemini Enterprise Agent Platform à l'aide de la route de prédiction par défaut. Vous utiliserez la bibliothèque vLLM pour une diffusion efficace et interagirez avec le modèle en envoyant un prompt visuel combiné à du texte.

Pour commencer, assurez-vous que le point de terminaison de votre modèle est déployé et prêt pour les prédictions.

Éthought Étape 1 : Définissez votre prompt et vos paramètres

Cet exemple fournit une URL d'image et un prompt textuel, que le modèle traitera pour générer une réponse.

Exemple d'image d'entrée pour le prompting Llama 3.2 Figure 6 : Exemple d'image d'entrée pour un prompt 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}"

Étape 2 : Configurez les paramètres de prédiction

Ajustez les paramètres suivants pour contrôler la réponse du modèle :

max_tokens = 64

temperature = 0.5

top_p = 0.95

Étape 3 : Préparer la requête de prédiction

Configurez la requête de prédiction avec l'URL de l'image, la requête et d'autres paramètres.

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

Étape 4 : Effectuer la prédiction

Envoyez la requête à votre point de terminaison Gemini Enterprise Agent Platform et traitez la réponse :

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

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

Si vous rencontrez un problème de délai avant expiration (par exemple, ServiceUnavailable: 503 Took too long to respond when processing), essayez de réduire la valeur max_tokens à un nombre inférieur, tel que 20, pour réduire le temps de réponse.

Inférence avec vLLM sur Gemini Enterprise Agent Platform à l'aide d'OpenAI Chat Completion

Cette section explique comment effectuer une inférence sur les modèles Llama 3.2 Vision à l'aide de l'API OpenAI Chat Completions sur Gemini Enterprise Agent Platform. Cette approche vous permet d'utiliser des fonctionnalités multimodales en envoyant à la fois des images et des prompts textuels au modèle pour obtenir des réponses plus interactives.

Étape 1 : Déployez le modèle Llama 3.2 Vision Instruct

Exécutez la fonction de déploiement avec le modèle et les paramètres configurés. La fonction renvoie les instances de modèle et de point de terminaison, que vous pouvez utiliser pour l'inférence.

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,
)

Étape 2 : Configurer la ressource de point de terminaison

Commencez par configurer le nom de la ressource de point de terminaison pour votre déploiement Gemini Enterprise Agent Platform.

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

Étape 3 : Installer le SDK OpenAI et les bibliothèques d'authentification

Pour envoyer des requêtes à l'aide du SDK OpenAI, assurez-vous que les bibliothèques nécessaires sont installées :

!pip install -qU openai google-auth requests

Étape 4 : Définir les paramètres d'entrée pour la complétion de chat

Configurez l'URL de l'image et le prompt textuel qui seront envoyés au modèle. Ajustez max_tokens et temperature pour contrôler respectivement la longueur et le caractère aléatoire de la réponse.

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

Étape 5 : Configurez l'authentification et l'URL de base

Récupérez vos identifiants et définissez l'URL de base pour les requêtes API.

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

Étape 6 : Envoyer une requête de complétion de chat

À l'aide de l'API Chat Completions d'OpenAI, envoyez l'image et le prompt textuel à votre point de terminaison Gemini Enterprise Agent Platform :

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)

(Facultatif) Étape 7 : Se reconnecter à un point de terminaison existant

Pour vous reconnecter à un point de terminaison créé précédemment, utilisez l'ID du point de terminaison. Cette étape est utile si vous souhaitez réutiliser un point de terminaison au lieu d'en créer un.

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

Cette configuration offre la flexibilité nécessaire pour basculer entre les points de terminaison nouvellement créés et existants, ce qui permet de simplifier les tests et le déploiement.

Nettoyage

Pour éviter des frais récurrents et libérer des ressources, veillez à supprimer les modèles déployés, les points de terminaison et, éventuellement, le bucket de stockage utilisé pour ce test.

Étape 1 : Supprimer les points de terminaison et les modèles

Le code suivant annule le déploiement de chaque modèle et supprime les points de terminaison associés :

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

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

Étape 2 : (Facultatif) Supprimer le bucket Cloud Storage

Si vous avez créé un bucket Cloud Storage spécifiquement pour ce test, vous pouvez le supprimer en définissant delete_bucket sur True. Cette étape est facultative, mais recommandée si le bucket n'est plus nécessaire.

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

En suivant ces étapes, vous vous assurez que toutes les ressources utilisées dans ce tutoriel sont nettoyées, ce qui réduit les coûts inutiles associés au test.

Déboguer les problèmes courants

Cette section explique comment identifier et résoudre les problèmes courants rencontrés lors du déploiement et de l'inférence de modèles vLLM sur Gemini Enterprise Agent Platform.

Vérifier les journaux

Consultez les journaux pour identifier la cause première des échecs de déploiement ou des comportements inattendus :

  1. Accédez à la console de prédiction Gemini Enterprise Agent Platform : accédez à la console de prédiction Gemini Enterprise Agent Platform dans la console Google Cloud .
  2. Sélectionnez le point de terminaison : cliquez sur le point de terminaison qui rencontre des problèmes. L'état doit indiquer si le déploiement a échoué.
  3. Afficher les journaux : cliquez sur le point de terminaison, puis accédez à l'onglet Journaux ou cliquez sur Afficher les journaux. Vous êtes alors redirigé vers Cloud Logging, filtré pour afficher les journaux spécifiques à ce point de terminaison et à ce déploiement de modèle. Vous pouvez également accéder aux journaux directement via le service Cloud Logging.
  4. Analyser les journaux : examinez les entrées de journal pour détecter les messages d'erreur, les avertissements et d'autres informations pertinentes. Affichez les codes temporels pour mettre en corrélation les entrées de journal avec des actions spécifiques. Recherchez les problèmes liés aux contraintes de ressources (mémoire et processeur), les problèmes d'authentification ou les erreurs de configuration.

Problème courant 1 : Mémoire insuffisante (OOM) de CUDA pendant le déploiement

Les erreurs de mémoire insuffisante (OOM) CUDA se produisent lorsque l'utilisation de la mémoire du modèle dépasse la capacité du GPU disponible.

Dans le cas du modèle textuel, nous avons utilisé les arguments de moteur suivants :

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

Dans le cas du modèle multimodal, nous avons utilisé les arguments de moteur suivants :

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

Le déploiement du modèle multimodal avec max_num_seqs = 256, comme nous l'avons fait pour le modèle textuel, peut entraîner l'erreur suivante :

[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)
Journal des erreurs de mémoire insuffisante (OOM) du GPU Figure 7 : Journal des erreurs de mémoire insuffisante (OOM) du GPU

Comprendre max_num_seqs et la mémoire GPU :

  • Le paramètre max_num_seqs définit le nombre maximal de requêtes simultanées que le modèle peut gérer.
  • Chaque séquence traitée par le modèle consomme de la mémoire GPU. L'utilisation totale de la mémoire est proportionnelle à max_num_seqs fois la mémoire par séquence.
  • Les modèles de texte uniquement (comme Meta-Llama-3.1-8B) consomment généralement moins de mémoire par séquence que les modèles multimodaux (comme Llama-3.2-11B-Vision-Instruct), qui traitent à la fois du texte et des images.

Examinez le journal d'erreurs (figure 8) :

  • Le journal affiche un torch.OutOfMemoryError lors de la tentative d'allocation de mémoire sur le GPU.
  • L'erreur se produit, car l'utilisation de la mémoire du modèle dépasse la capacité du GPU disponible. Le GPU NVIDIA L4 dispose de 24 Go. Si vous définissez le paramètre max_num_seqs sur une valeur trop élevée pour le modèle multimodal, un dépassement de capacité se produit.
  • Le journal suggère de définir PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True pour améliorer la gestion de la mémoire, bien que le problème principal soit l'utilisation élevée de la mémoire.
Message d'erreur indiquant que le déploiement de Llama 3.2 a échoué Figure 8 : Échec du déploiement de Llama 3.2
Panneau &quot;Détails de la version du modèle&quot; Figure 9 : Panneau "Détails de la version du modèle"

Pour résoudre ce problème, accédez à la console de prédiction Gemini Enterprise Agent Platform, puis cliquez sur le point de terminaison. L'état doit indiquer que le déploiement a échoué. Cliquez pour afficher les journaux. Vérifiez que max-num-seqs = 256. Cette valeur est trop élevée pour Llama-3.2-11B-Vision-Instruct. Une valeur plus appropriée serait 12.

Problème courant 2 : Jeton Hugging Face requis

Des erreurs de jeton Hugging Face se produisent lorsque le modèle est restreint et nécessite des identifiants d'authentification appropriés pour être accessible.

La capture d'écran suivante montre une entrée de journal dans l'explorateur de journaux de Google Cloud, qui affiche un message d'erreur lié à l'accès au modèle Meta LLaMA-3.2-11B-Vision hébergé sur Hugging Face. L'erreur indique que l'accès au modèle est restreint et qu'une authentification est requise pour continuer. Le message indique spécifiquement "Impossible d'accéder au dépôt contrôlé pour l'URL", ce qui indique que le modèle est contrôlé et nécessite des identifiants d'authentification appropriés pour être accessible. Cette entrée de journal peut vous aider à résoudre les problèmes d'authentification lorsque vous travaillez avec des ressources restreintes dans des dépôts externes.

Message d'erreur indiquant qu'un jeton HuggingFace est nécessaire pour accéder au modèle Figure 10 : Erreur de jeton Hugging Face

Pour résoudre ce problème, vérifiez les autorisations de votre jeton d'accès Hugging Face. Copiez le dernier jeton et déployez un nouveau point de terminaison.

Problème courant 3 : Modèle de chat requis

Des erreurs de modèle de chat se produisent lorsque le modèle de chat par défaut n'est plus autorisé. Un modèle de chat personnalisé doit être fourni si le tokeniseur n'en définit pas un.

Cette capture d'écran montre une entrée de journal dans l'explorateur de journaux de Google Cloud, où une ValueError se produit en raison d'un modèle de chat manquant dans la version 4.44 de la bibliothèque transformers. Le message d'erreur indique que le modèle de chat par défaut n'est plus autorisé et qu'un modèle de chat personnalisé doit être fourni si le tokeniseur n'en définit pas un. Cette erreur met en évidence une modification récente de la bibliothèque qui nécessite la définition explicite d'un modèle de chat, ce qui est utile pour déboguer les problèmes lors du déploiement d'applications basées sur le chat.

Figure 11 : Modèle de chat requisMessage d'erreur indiquant qu'un modèle de chat est nécessaire pour accéder au modèle

Pour contourner ce problème, veillez à fournir un modèle de chat lors du déploiement à l'aide de l'argument d'entrée --chat-template. Vous trouverez des exemples de modèles dans le dépôt d'exemples vLLM.

Problème courant 4 : longueur de séquence maximale du modèle

Des erreurs de longueur de séquence maximale du modèle se produisent lorsque la longueur de séquence maximale du modèle (4 096) est supérieure au nombre maximal de jetons pouvant être stockés dans le cache KV (2 256).

Longueur de séquence maximale du modèle Figure 12 : Longueur de séquence maximale trop élevée

ValueError: The model's max seq len (4096) is larger than the maximum number of tokens that can be stored in KV cache (2256). Essayez d'augmenter gpu_memory_utilization ou de diminuer max_model_len lors de l'initialisation du moteur.

Pour résoudre ce problème, définissez max_model_len sur 2048, ce qui est inférieur à 2256. Une autre solution à ce problème consiste à utiliser des GPU plus nombreux ou plus grands. Si vous optez pour l'utilisation de plus de GPU, vous devrez définir tensor-parallel-size de manière appropriée.

Notes de version du conteneur vLLM Model Garden

Principales versions

vLLM standard


Date de sortie
Architecture		 Version de vLLM
URI du conteneur
17 juillet 2025
ARM
v0.9.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250717_0916_arm_RC01
10 juillet 2025
x86
v0.9.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250710_0916_RC01
20 juin 2025
x86
Après la version 0.9.1, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250620_0916_RC01
11 juin 2025
x86
v0.9.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250611_0916_RC01
2 juin 2025
x86
v0.9.0
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250601_0916_RC01
6 mai 2025
x86
v0.8.5.post1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250506_0916_RC01
29 avril 2025
x86
v0.8.4
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250429_0916_RC01, 20250430_0916_RC00_maas
17 avr. 2025
x86
v0.8.4
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250417_0916_RC01
10 avril 2025
x86
Après la version 0.8.3, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250410_0917_RC01
7 avril 2025
x86
v0.8.3
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250407_0917_RC01, 20250407_0917_RC0120250429_0916_RC00_maas
7 avril 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250404_0916_RC01
5 avril 2025
x86
Après la version 0.8.2, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
31 mars 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250401_0916_RC01
26 mars 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250327_0916_RC01
23 mars 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250324_0916_RC01
21 mars 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250321_0916_RC01
11 mars 2025
x86
Après la version 0.7.3, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01
3 mars 2025
x86
v0.7.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250304_0916_RC01
14 janvier 2025
x86
v0.6.4.post1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250114_0916_RC00_maas
2 décembre 2024
x86
v0.6.4.post1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241202_0916_RC00_maas
12 nov. 2024
x86
v0.6.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241112_0916_RC00_maas
16 oct. 2024
x86
v0.6.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas

vLLM optimisé


Date de sortie
Architecture
URI du conteneur
21 janvier 2025
x86
us-docker.pkg.dev/vertex-ai-restricted/vertex-vision-model-garden-dockers/pytorch-vllm-optimized-serve:20250121_0835_RC00
29 oct. 2024
x86
us-docker.pkg.dev/vertex-ai-restricted/vertex-vision-model-garden-dockers/pytorch-vllm-optimized-serve:20241029_0835_RC00

Autres versions

La liste complète des versions de conteneurs vLLM standards de VMG est disponible sur la page Artifact Registry.

Les versions de vLLM-TPU à l'état expérimental sont taguées avec <yyyymmdd_hhmm_tpu_experimental_RC00>.