Diffusion de vLLM pour les modèles de langage textuels et multimodals sur les GPU Cloud
Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Ce guide vous explique comment déployer et mettre en service des modèles Llama 3.1 (texte uniquement) et Llama 3.2 (multimodaux) à l'aide de vLLM dans Vertex AI.
Dans ce document, vous allez apprendre à effectuer les opérations suivantes :
Déployer un modèle Llama 3.2 multimodal : utilisez un conteneur vLLM prédéfini pour déployer un modèle Llama 3.2 qui traite à la fois les entrées de texte et d'image.
Nettoyer les ressources : supprimez les modèles déployés, les points de terminaison et le bucket de stockage pour éviter des frais continus.
Déboguer les problèmes courants : trouvez des solutions aux problèmes courants, comme les erreurs de mémoire insuffisante et les problèmes d'authentification.
Le schéma suivant résume le workflow global :
Principales fonctionnalités de vLLM
Fonctionnalité
Description
PagedAttention
Mécanisme d'attention qui gère efficacement la mémoire pour prendre en charge la génération de texte à haut débit et plusieurs requêtes simultanées.
Traitement par lots continu
Traite plusieurs requêtes dans un même lot pour maximiser l'utilisation et le débit du GPU.
Streaming de jetons
Les jetons sont diffusés au fur et à mesure de leur génération, ce qui est idéal pour les applications à faible latence comme les chatbots.
Compatibilité des modèles
Il est compatible avec un large éventail de modèles issus de frameworks tels que Hugging Face Transformers, ce qui simplifie l'intégration et l'expérimentation.
Multi-GPU et multi-hôte
Distribue les charges de travail sur plusieurs GPU et hôtes pour augmenter le débit et l'évolutivité.
Déploiement efficace
S'intègre aux API telles que l'API OpenAI Chat Completions pour un déploiement simple.
Intégration parfaite aux modèles Hugging Face
Compatible avec les artefacts de modèle Hugging Face, ce qui vous permet de déployer des modèles Llama et d'autres modèles populaires tels que Gemma, Phi et Qwen dans un environnement optimisé.
Projet Open Source axé sur la communauté
Projet Open Source qui encourage les contributions de la communauté pour améliorer en continu l'efficacité du service LLM.
Tableau 1. Récapitulatif des fonctionnalités de vLLM
Personnalisations vLLM Google Vertex AI
L'implémentation vLLM dans Vertex AI Model Garden est une version personnalisée de la bibliothèque Open Source, optimisée pour les performances, la fiabilité et l'intégration à Google Cloud.
Optimisation des performances :
Téléchargement parallèle depuis Cloud Storage : accélère le chargement et le déploiement des modèles en récupérant les données depuis Cloud Storage en parallèle.
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 la mise en cache sur disque local, une gestion robuste des erreurs et la possibilité de charger les pondérations LoRA à partir de chemins Cloud Storage et d'URL signées.
Analyse des appels de fonction Llama 3.1/3.2 : inclut une analyse spécialisée pour les appels de fonction Llama 3.1 et 3.2 afin d'améliorer la robustesse.
Mise en cache des préfixes de mémoire hôte : ajoute la compatibilité avec la mise en cache des préfixes de mémoire hôte, qui n'est pas disponible dans la bibliothèque vLLM Open Source standard.
Décodage spéculatif : Vertex AI fournit des configurations optimisées pour cette fonctionnalité vLLM existante, basées sur des tests internes.
Intégration de l'écosystème Vertex AI :
Prise en charge des formats d'entrée/sortie de prédiction Vertex AI : assure la compatibilité avec les formats de prédiction Vertex AI pour simplifier le traitement et l'intégration des données.
Connaissance des variables d'environnement Vertex : utilise les variables d'environnement Vertex AI (par exemple, AIP_*) pour la configuration et la gestion des ressources.
Gestion des gestion des exceptions et robustesse améliorées : inclut une gestion complète des erreurs, une validation des entrées/sorties et des mécanismes d'arrêt du serveur pour améliorer la stabilité.
Serveur Nginx pour la capacité : intègre un serveur Nginx pour prendre en charge le déploiement de plusieurs répliques, ce qui améliore l'évolutivité et la haute disponibilité.
Avantages supplémentaires de vLLM
Performances de référence : vLLM offre un débit et une latence compétitifs par rapport à d'autres systèmes de diffusion tels que Hugging Face text-generation-inference et FasterTransformer de NVIDIA.
Facilité d'utilisation : la bibliothèque dispose d'une API simple qui vous permet d'intégrer et de déployer les modèles Llama 3.1 et 3.2 avec une configuration minimale.
Fonctionnalités avancées : vLLM est compatible avec le streaming des sorties et gère les requêtes de longueur variable, ce qui améliore l'interactivité et la réactivité des applications.
Pour obtenir une présentation du système vLLM, consultez l'article.
Modèles compatibles
vLLM est compatible avec un large éventail de modèles. Le tableau suivant présente une sélection de ces modèles. Pour obtenir la liste complète, consultez la page officielle des modèles compatibles de vLLM.
Tableau 2. Modèles sélectionnés compatibles avec vLLM
Premiers pas dans Model Garden
Vous pouvez utiliser le conteneur de diffusion vLLM Cloud GPUs dans Model Garden via Playground, le déploiement en un clic ou les exemples de notebooks Colab Enterprise. Ce document explique comment utiliser un notebook pour déployer des modèles de la famille Llama.
Ouvrir le notebook Colab Enterprise
Les Playgrounds et les déploiements en un clic sont également disponibles, mais ne sont pas abordés dans ce document.
Le code suivant configure votre environnement Google Cloud . Le script effectue les actions suivantes :
Installation : met à niveau la bibliothèque google-cloud-aiplatform et clone un dépôt avec des fonctions utilitaires.
Configuration de l'environnement : définit les variables pour l'ID de votre projet Google Cloud , la région et un bucket Cloud Storage pour stocker les artefacts du modèle.
Activation des API : active les API Vertex AI et Compute Engine.
Configuration du bucket : crée un bucket Cloud Storage ou vérifie qu'un bucket existant se trouve dans la bonne région.
Initialisation de Vertex AI : initialise la bibliothèque cliente Vertex AI avec votre projet, votre emplacement et votre bucket de préproduction.
Configuration du compte de service : identifie le compte de service par défaut pour les jobs Vertex AI et lui accorde les autorisations nécessaires.
BUCKET_URI="gs://"REGION=""!pip3install--upgrade--quiet'google-cloud-aiplatform>=1.64.0'!gitclonehttps://github.com/GoogleCloudPlatform/vertex-ai-samples.gitimportdatetimeimportimportlibimportosimportuuidfromtypingimportTupleimportrequestsfromgoogle.cloudimportaiplatformcommon_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"]ifnotREGION:REGION=os.environ["GOOGLE_CLOUD_REGION"]print("Enabling Vertex AI API and Compute Engine API.")!gcloudservicesenableaiplatform.googleapis.comcompute.googleapis.comnow=datetime.datetime.now().strftime("%Y%m%d%H%M%S")BUCKET_NAME="/".join(BUCKET_URI.split("/")[:3])ifBUCKET_URIisNoneorBUCKET_URI.strip()==""orBUCKET_URI=="gs://":BUCKET_URI=f"gs://{PROJECT_ID}-tmp-{now}-{str(uuid.uuid4())[:4]}"BUCKET_NAME="/".join(BUCKET_URI.split("/")[:3])!gsutilmb-l{REGION}{BUCKET_URI}else:assertBUCKET_URI.startswith("gs://"),"BUCKET_URI must start with `gs://`."shell_output=!gsutills-Lb{BUCKET_NAME}|grep"Location constraint:"|sed"s/Location constraint://"bucket_region=shell_output[0].strip().lower()ifbucket_region!=REGION:raiseValueError("Bucket region %s is different from notebook region %s"%(bucket_region,REGION))print(f"Using this Bucket: {BUCKET_URI}")STAGING_BUCKET=os.path.join(BUCKET_URI,"temporal")MODEL_BUCKET=os.path.join(BUCKET_URI,"llama3_1")print("Initializing Vertex AI API.")aiplatform.init(project=PROJECT_ID,location=REGION,staging_bucket=STAGING_BUCKET)shell_output=!gcloudprojectsdescribe$PROJECT_IDproject_number=shell_output[-1].split(":")[1].strip().replace("'","")SERVICE_ACCOUNT="your service account email"print("Using this default Service Account:",SERVICE_ACCOUNT)!gsutiliamchserviceAccount:{SERVICE_ACCOUNT}:roles/storage.admin$BUCKET_NAME!gcloudconfigsetproject$PROJECT_ID!gcloudprojectsadd-iam-policy-binding--no-user-output-enabled{PROJECT_ID}--member=serviceAccount:{SERVICE_ACCOUNT}--role="roles/storage.admin"!gcloudprojectsadd-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 et 3.2
Pour accéder aux modèles Llama de Meta, vous devez accepter leurs conditions d'utilisation.
Figure 1. Contrat de licence Communauté Meta Llama 3
Présentation des collections Meta Llama 3.1 et 3.2
Les collections Llama 3.1 et 3.2 offrent des options flexibles pour diverses tâches, y compris le dialogue multilingue. Pour en savoir plus, consultez la page de présentation de Llama.
Llama 3.1 : cette collection inclut des modèles uniquement textuels allant de 8 à 405 milliards de paramètres. Ils sont pré-entraînés et ajustés aux instructions pour générer du texte de haute qualité.
Llama 3.2 : cette collection inclut des modèles textuels plus petits (1B, 3B) et des modèles multimodaux plus grands (11B, 90B) qui peuvent traiter à la fois du texte et des images.
Architecture du modèle : Llama 3.1 et 3.2 utilisent un framework Transformer autorégressif. Ils sont affinés avec SFT et RLHF pour aligner les modèles sur l'utilité et la sécurité.
Jetons d'accès utilisateur Hugging Face
Ce guide nécessite un jeton d'accès en lecture depuis le Hugging Face Hub.
Figure 2. Paramètres du jeton d'accès Hugging Face
Créez un jeton, attribuez-lui le rôle Lecture, puis copiez-le.
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 de ce guide.
Figure 3. Gérer le jeton d'accès Hugging Face
Lorsque vous définissez votre jeton en tant que variable d'environnement lors du déploiement, il reste privé pour votre projet. Pour en savoir plus, consultez Hugging Face Access Tokens – Best Practices (Jetons d'accès Hugging Face – Bonnes pratiques).
Déployer un modèle Llama 3.1 uniquement textuel
Cette section vous explique comment déployer un modèle Llama 3.1 uniquement textuel avec vLLM.
Étape 2 : Configurez le matériel de déploiement et vérifiez le quota
Définissez le GPU et le type de machine appropriés en fonction de la taille du modèle.
if"8b"inbase_model_name.lower():accelerator_type="NVIDIA_L4"machine_type="g2-standard-12"accelerator_count=1elif"70b"inbase_model_name.lower():accelerator_type="NVIDIA_L4"machine_type="g2-standard-96"accelerator_count=8elif"405b"inbase_model_name.lower():accelerator_type="NVIDIA_H100_80GB"machine_type="a3-highgpu-8g"accelerator_count=8else:raiseValueError(f"Recommended GPU setting not found for: {accelerator_type} and {base_model_name}.")
Vérifiez que vous disposez d'un quota de GPU suffisant dans votre région.
La fonction suivante importe un modèle dans Vertex AI et le déploie sur un point de terminaison à l'aide d'une image Docker vLLM prédéfinie.
defdeploy_model_vllm(model_name:str,model_id:str,service_account:str,base_model_id:str=None,machine_type:str="g2-standard-8",accelerator_type:str="NVIDIA_L4",accelerator_count:int=1,gpu_memory_utilization:float=0.9,max_model_len:int=4096,dtype:str="auto",enable_trust_remote_code:bool=False,enforce_eager:bool=False,enable_lora:bool=False,max_loras:int=1,max_cpu_loras:int=8,use_dedicated_endpoint:bool=False,max_num_seqs:int=256,)-> Tuple[aiplatform.Model,aiplatform.Endpoint]:"""Deploys trained models with vLLM into Vertex AI."""endpoint=aiplatform.Endpoint.create(display_name=f"{model_name}-endpoint",dedicated_endpoint_enabled=use_dedicated_endpoint,)if"8b"inbase_model_name.lower():accelerator_type="NVIDIA_L4"machine_type="g2-standard-12"accelerator_count=1elif"70b"inbase_model_name.lower():accelerator_type="NVIDIA_L4"machine_type="g2-standard-96"accelerator_count=8elif"405b"inbase_model_name.lower():accelerator_type="NVIDIA_H100_80GB"machine_type="a3-highgpu-8g"accelerator_count=8else:raiseValueError(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"]ifenable_trust_remote_code:vllm_args.append("--trust-remote-code")ifenforce_eager:vllm_args.append("--enforce-eager")ifenable_lora:vllm_args.append("--enable-lora")ifmodel_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)returnmodel,endpoint
Étape 4 : Déployer le modèle
Appelez la fonction de déploiement avec le modèle et la configuration de votre choix. Selon la taille du modèle, cette étape peut prendre jusqu'à une heure. Pour suivre la progression, consultez la section sur la prédiction en ligne.
Figure 4. Point de terminaison de déploiement Llama 3.1 dans le tableau de bord Vertex
Effectuer des prédictions avec un modèle Llama 3.1
Une fois le modèle Llama 3.1 déployé, vous pouvez envoyer des requêtes textuelles au point de terminaison pour générer des réponses.
Étape 1 : Définissez votre requête et vos paramètres
Configurez votre requête textuelle et vos paramètres d'échantillonnage pour guider la réponse du modèle.
prompt : texte d'entrée pour le modèle.
max_tokens : nombre maximal de jetons dans le résultat généré.
temperature : contrôle le caractère aléatoire des prédictions. Des valeurs plus élevées (1,0, par exemple) augmentent la diversité, tandis que des valeurs plus faibles (0,2, par exemple) rendent le résultat plus ciblé.
top_p : limite le pool d'échantillonnage à la probabilité cumulative la plus élevée.
top_k : limite l'échantillonnage aux k jetons les plus probables.
raw_response : si la valeur est True, renvoie la sortie brute du modèle. Si la valeur est False, met en forme le résultat.
lora_id (facultatif) : chemin d'accès aux fichiers de poids LoRA (URL d'un bucket Cloud Storage ou d'un dépôt Hugging Face). Pour ce faire, --enable-lora doit être défini lors du déploiement.
prompt="What is a car?"max_tokens=50temperature=1.0top_p=1.0top_k=1raw_response=Falselora_id=""
Étape 2 : Envoyer la requête de prédiction
Envoyez la requête de prédiction au point de terminaison Vertex AI déployé.
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.
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 de Vertex AI.
Gérer les délais d'attente : si vous rencontrez des problèmes tels que ServiceUnavailable:
503, essayez de réduire le paramètre max_tokens.
Déployer un modèle multimodal Llama 3.2
Cette section vous explique comment déployer un modèle multimodal Llama 3.2 préentraîné sur un point de terminaison Vertex AI. Le déploiement peut prendre jusqu'à une heure. Les modèles Llama 3.2 sont compatibles avec les formats texte uniquement et image unique plus texte.
Étape 1 : Choisir un modèle à déployer
Spécifiez la variante du modèle Llama 3.2. Cet exemple utilise Llama-3.2-11B-Vision.
Étape 2 : Configurez le matériel et les ressources
Sélectionnez le matériel approprié à la taille de votre modèle.
Modèles 1B et 3B : GPU NVIDIA L4
Modèles 11B : GPU NVIDIA A100
Modèles 90B : GPU NVIDIA H100
if"3.2-1B"inbase_model_nameor"3.2-3B"inbase_model_name:accelerator_type="NVIDIA_L4"machine_type="g2-standard-8"accelerator_count=1elif"3.2-11B"inbase_model_name:accelerator_type="NVIDIA_TESLA_A100"machine_type="a2-highgpu-1g"accelerator_count=1elif"3.2-90B"inbase_model_name:accelerator_type="NVIDIA_H100_80GB"machine_type="a3-highgpu-8g"accelerator_count=8else:raiseValueError(f"Recommended GPU setting not found for: {base_model_name}.")
La fonction suivante gère le déploiement du modèle Llama 3.2 sur Vertex AI. Il configure l'environnement du modèle, l'utilisation de la mémoire et les paramètres vLLM pour une diffusion efficace.
defdeploy_model_vllm(model_name:str,model_id:str,service_account:str,base_model_id:str=None,machine_type:str="g2-standard-8",accelerator_type:str="NVIDIA_L4",accelerator_count:int=1,gpu_memory_utilization:float=0.9,max_model_len:int=4096,dtype:str="auto",enable_trust_remote_code:bool=False,enforce_eager:bool=False,enable_lora:bool=False,max_loras:int=1,max_cpu_loras:int=8,use_dedicated_endpoint:bool=False,max_num_seqs:int=12,model_type:str=None,)-> Tuple[aiplatform.Model,aiplatform.Endpoint]:"""Deploys trained models with vLLM into Vertex AI."""endpoint=aiplatform.Endpoint.create(display_name=f"{model_name}-endpoint",dedicated_endpoint_enabled=use_dedicated_endpoint,)ifnotbase_model_id:base_model_id=model_idvllm_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",]ifenable_trust_remote_code:vllm_args.append("--trust-remote-code")ifenforce_eager:vllm_args.append("--enforce-eager")ifenable_lora:vllm_args.append("--enable-lora")ifmodel_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:ifHF_TOKEN:env_vars["HF_TOKEN"]=HF_TOKENexceptNameError:passmodel=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)returnmodel,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 renverra les instances de modèle et de point de terminaison, que vous pourrez utiliser pour l'inférence.
Figure 5. Point de terminaison de déploiement Llama 3.2 dans le tableau de bord Vertex
Effectuer des prédictions avec un modèle multimodal
Vous pouvez utiliser deux formats d'API différents pour faire des prédictions avec votre modèle multimodal déployé.
Méthode d'inférence
Description
Cas d'utilisation
Route de prédiction par défaut
Utilise le point de terminaison de prédiction Vertex AI standard (/generate). La charge utile de la requête est un objet JSON personnalisé qui contient la requête, les données d'image et les paramètres d'échantillonnage.
Idéal pour l'inférence directe et simple, et pour l'intégration aux workflows Vertex AI existants qui utilisent le format de prédiction standard.
API OpenAI Chat Completion
Émule le format de l'API Chat Completions d'OpenAI, ce qui vous permet d'utiliser la bibliothèque cliente OpenAI. La requête utilise une structure de messages familière (par exemple, role et content).
Idéal pour les développeurs qui connaissent déjà l'API OpenAI, ce qui permet de migrer facilement les applications existantes. Il est idéal pour créer des applications multimodales conversationnelles ou basées sur le chat.
Effectuer des prédictions avec la route de prédiction par défaut
Cette section vous explique comment effectuer des prédictions avec le modèle Llama 3.2 Vision à l'aide de la route de prédiction par défaut.
Étape 1 : Définissez votre requête et vos paramètres
Fournissez une URL d'image et une requête textuelle que le modèle pourra traiter.
Figure 6. Exemple d'image d'entrée pour solliciter 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-promptprompt=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=64temperature=0.5top_p=0.95
Étape 3 : Préparez la requête de prédiction
Configurez la requête de prédiction avec l'URL de l'image, l'invite et d'autres paramètres.
Si vous rencontrez un problème de délai d'attente, essayez de réduire la valeur max_tokens.
Faire des prédictions avec l'API OpenAI Chat Completion
Cette section vous explique comment effectuer des prédictions sur les modèles Llama 3.2 Vision Instruct à l'aide du format de l'API OpenAI Chat Completions. Cette approche est idéale pour les applications conversationnelles.
Étape 1 : Déployer un modèle Llama 3.2 Vision Instruct
Cette méthode nécessite un modèle ajusté aux instructions. Pour déployer le modèle Llama-3.2-11B-Vision-Instruct, appelez la fonction deploy_model_vllm définie précédemment.
Étape 2 : Configurez la ressource de point de terminaison
Configurez le nom de ressource du point de terminaison pour votre déploiement. Pour vous reconnecter à un point de terminaison créé précédemment, remplacez la variable endpoint.name par l'ID de votre point de terminaison existant.
Étape 3 : Installez le SDK OpenAI et les bibliothèques d'authentification
Pour envoyer des requêtes à l'aide du SDK OpenAI, installez les bibliothèques nécessaires.
!pipinstall-qUopenaigoogle-authrequests
Étape 4 : Définir les paramètres d'entrée pour la finalisation du chat
Configurez l'URL de votre image et votre requête textuelle. Ajustez max_tokens et temperature pour contrôler 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=50temperature=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.
Cliquez sur l'onglet Journaux ou sur Afficher les journaux pour ouvrir Cloud Logging, filtré pour votre point de terminaison.
Analysez les journaux pour identifier les messages d'erreur liés aux contraintes de ressources, à l'authentification ou à la configuration.
Problème courant 1 : CUDA Out of Memory (OOM) lors du déploiement
Les erreurs CUDA de mémoire insuffisante (OOM, Out Of Memory) se produisent lorsque l'utilisation de la mémoire par le modèle dépasse la capacité du GPU disponible. Cette erreur se produit souvent si le paramètre max_num_seqs, qui définit le nombre maximal de requêtes simultanées, est défini sur une valeur trop élevée pour le modèle et le GPU.
Par exemple, le déploiement d'un modèle multimodal tel que Llama-3.2-11B-Vision-Instruct avec max_num_seqs = 256 sur un GPU NVIDIA L4 peut entraîner une erreur OOM, car les modèles multimodaux consomment plus de mémoire par séquence que les modèles textuels.
Dans le cas du modèle de texte uniquement, nous avons utilisé les arguments de moteur suivants :
[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)
Figure 7. Journal des erreurs GPU pour cause de mémoire insuffisante (OOM)
Solution : Pour résoudre cette erreur, réduisez la valeur max_num_seqs. Par exemple, pour le modèle Llama-3.2-11B-Vision-Instruct sur un GPU L4, une valeur de 12 est plus appropriée. Redéployez le modèle avec le paramètre ajusté.
Figure 8. Échec du déploiement de Llama 3.2
Problème courant 2 : Jeton Hugging Face requis
Cette erreur se produit lorsque vous déployez un modèle restreint depuis Hugging Face sans fournir de jeton d'accès valide.
Exemple de journal d'erreurs : le journal contient un message tel que Cannot access gated repository for URL, qui indique qu'une authentification est requise.
Figure 9. Erreur de jeton Hugging Face
Solution : Assurez-vous d'avoir généré un jeton d'accès Hugging Face avec au moins les autorisations Read (Lecture) et d'avoir accepté les conditions de licence du modèle. Fournissez ce jeton dans la variable d'environnement HF_TOKEN lors du déploiement.
Problème courant 3 : Modèle de chat requis
Cette erreur peut se produire avec les versions plus récentes de la bibliothèque transformers si le tokenizer du modèle ne comporte pas de modèle de chat par défaut.
Exemple de journal des erreurs : le journal affiche un ValueError qui indique qu'un modèle de chat est manquant et doit être fourni.
Figure 10. Erreur "Modèle de chat requis"
Résolution : pour résoudre cette erreur, fournissez un modèle de chat lors du déploiement à l'aide de l'argument --chat-template. Vous trouverez des exemples de modèles dans le dépôt d'exemples vLLM.
Problème courant 4 : Erreur de longueur maximale de séquence du modèle
Cette erreur se produit lorsque la longueur de séquence maximale du modèle (max_model_len) est supérieure au nombre de jetons pouvant être stockés dans le cache KV du GPU.
Exemple de journal des erreurs :
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.
Figure 11. Erreur "Max Seq Length too Large" (Longueur de séquence max. trop élevée)
Résolution : Pour résoudre cette erreur, diminuez la valeur de max_model_len à une valeur inférieure à la taille du cache KV disponible (par exemple, 2048) ou augmentez le paramètre gpu_memory_utilization. Vous pouvez également utiliser un GPU plus grand ou plusieurs GPU avec le paramètre tensor-parallel-size approprié.
Pour obtenir la liste complète des versions standards de conteneurs vLLM de VMG, consultez la page Artifact Registry.
Les versions de vLLM-TPU en état expérimental sont taguées avec <yyyymmdd_hhmm_tpu_experimental_RC00>.
Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/08/19 (UTC).
[[["Facile à comprendre","easyToUnderstand","thumb-up"],["J'ai pu résoudre mon problème","solvedMyProblem","thumb-up"],["Autre","otherUp","thumb-up"]],[["Difficile à comprendre","hardToUnderstand","thumb-down"],["Informations ou exemple de code incorrects","incorrectInformationOrSampleCode","thumb-down"],["Il n'y a pas l'information/les exemples dont j'ai besoin","missingTheInformationSamplesINeed","thumb-down"],["Problème de traduction","translationIssue","thumb-down"],["Autre","otherDown","thumb-down"]],["Dernière mise à jour le 2025/08/19 (UTC)."],[],[]]
Figure 1. Contrat de licence Communauté Meta Llama 3
Figure 2. Paramètres du jeton d'accès Hugging Face
Figure 3. Gérer le jeton d'accès Hugging Face
Figure 4. Point de terminaison de déploiement Llama 3.1 dans le tableau de bord Vertex
Figure 5. Point de terminaison de déploiement Llama 3.2 dans le tableau de bord Vertex
Figure 6. Exemple d'image d'entrée pour solliciter Llama 3.2
Figure 7. Journal des erreurs GPU pour cause de mémoire insuffisante (OOM)
Figure 8. Échec du déploiement de Llama 3.2
Figure 9. Erreur de jeton Hugging Face
Figure 10. Erreur "Modèle de chat requis"
Figure 11. Erreur "Max Seq Length too Large" (Longueur de séquence max. trop élevée)
