Exécuter et profiler des charges de travail vLLM avec ML Diagnostics

vLLM est une bibliothèque Open Source pour l'inférence et la mise en service de grands modèles de langage (LLM). L'intégration de ML Diagnostics à vLLM vous permet de suivre les configurations de diffusion, de surveiller la télémétrie des charges de travail et de capturer des profils XProf sur Google Cloud. Ce document décrit la commande du wrapper ML Diagnostics pour vLLM et vous explique comment conteneuriser, exécuter et profiler une charge de travail vLLM.

Arguments de ligne de commande du wrapper

ML Diagnostics fournit une commande wrapper intégrée, google_cloud_mldiagnostics.commands.run_vllm, pour lancer les charges de travail de diffusion et d'inférence vLLM, et configurer automatiquement la télémétrie et le profilage. Vous pouvez définir le wrapper run_vllm comme point d'entrée dans votre conteneur Docker vLLM ou l'exécuter directement à partir de la ligne de commande sur Google Kubernetes Engine (GKE) ou Compute Engine.

Lorsque vous démarrez une charge de travail avec la commande run_vllm, le wrapper effectue les actions suivantes :

  • Enregistrer l'exécution : crée et enregistre une ressource MLRun gérée configurée pour les charges de travail de diffusion vLLM.
  • Configurer le profilage : définit les variables d'environnement du profileur et met à jour les chemins de sortie du profileur dans Cloud Storage pour organiser les traces dans un répertoire pour votre exécution de ML.
  • Arguments de transfert : transmet tous les arguments de ligne de commande restants directement à la commande vllm.

Le tableau suivant décrit les arguments de ligne de commande acceptés par le wrapper run_vllm :

Argument Description
--mlrun_name Obligatoire. Identifiant unique de la ressource d'exécution de ML (MLRun).
--mlrun_gcs_path Obligatoire. Chemin d'accès au bucket Cloud Storage qui stocke les traces et les artefacts du profileur. Par exemple : gs://my-bucket/vllm-profiles
--project Facultatif. ID de votre projet Google Cloud .
--region Facultatif. Région qui stocke les métadonnées MLRun. Valeur par défaut : us-central1.
--run_group Facultatif. Identifiant qui regroupe plusieurs exécutions associées.
--configs Facultatif. Configurations définies par l'utilisateur que vous transmettez sous forme de chaîne d'objet JSON. Par exemple : '{"user":"my-team", "running_on":"TPU"}'
--framework Facultatif. Framework de ML sous-jacent pour la charge de travail (pytorch ou jax). Valeur par défaut : pytorch.
--jax_profiler_port Facultatif. Port du serveur du profileur JAX. Valeur par défaut : 9999.
--phased_profiling_dir Facultatif. Répertoire Cloud Storage de base pour les traces de profilage par phases JAX. Le wrapper ajoute le chemin d'accès RUN_NAME/plugins/profile/ et exporte le résultat en tant que variable d'environnement PHASED_PROFILING_DIR vers le processus vLLM. Utilisez cet argument pour activer le profilage par phases.

Profilage par phases dans les configurations multihôtes

Pour activer le profilage par phases JAX dans les configurations multi-hôtes, telles qu'un backend Ray sur un LeaderWorkerSet GKE, transmettez l'argument --phased_profiling_dir et omettez la variable d'environnement PHASED_PROFILING_DIR dans l'environnement de votre système d'exploitation.

Si vous définissez la variable d'environnement PHASED_PROFILING_DIR sans transmettre l'argument --phased_profiling_dir, les profils par phases peuvent ne pas apparaître dans XProf dans la console Google Cloud pour les raisons suivantes :

  • Le wrapper run_vllm détecte la variable PHASED_PROFILING_DIR dans l'environnement du système d'exploitation, ajoute le suffixe de champ d'application, transmet le chemin d'accès à la commande vllm serve et consigne un avertissement.
  • L'exécuteur Ray de vLLM applique les variables d'environnement du pilote aux télétravailleurs à l'aide de la méthode os.environ.setdefault.
  • Les télétravailleurs qui disposent déjà de la variable PHASED_PROFILING_DIR dans leur environnement conservent leur chemin d'accès existant au lieu d'adopter le chemin d'accès limité à l'exécution, qui écrit leurs traces en dehors du répertoire MLRun.

Exécuter et profiler des charges de travail vLLM

Pour diffuser un modèle avec vLLM et ML Diagnostics, procédez comme suit :

  1. Créez une image de conteneur Docker qui empaquette vLLM avec le SDK ML Diagnostics et configure le wrapper run_vllm comme point d'entrée.
  2. Exécutez le conteneur sur GKE ou Compute Engine en transmettant vos arguments MLRun avec vos arguments vllm serve.
  3. Capturez les traces de performances pendant que le serveur traite les requêtes d'inférence à l'aide du profilage par phases, manuel ou à la demande, et affichez les résultats dans la consoleGoogle Cloud .

Préparer une image Docker pour vLLM

Pour utiliser le wrapper run_vllm dans un conteneur, créez une image Docker qui installe le SDK ML Diagnostics, le package xprof et les dépendances de journalisation en plus de l'image de base TPU vLLM. Dans Dockerfile, définissez le module google_cloud_mldiagnostics.commands.run_vllm comme point d'entrée du conteneur.

L'exemple Dockerfile suivant empaquette une image TPU vLLM avec le SDK ML Diagnostics :

FROM vllm/vllm-tpu:latest
WORKDIR /app
RUN pip install --no-cache-dir --upgrade pip && \
    pip install --no-cache-dir \
        google-cloud-mldiagnostics \
        xprof \
        google-cloud-logging \
        packaging \
        tensorflow-cpu
EXPOSE 8000 9999
ENTRYPOINT ["python3", "-m", "google_cloud_mldiagnostics.commands.run_vllm"]
CMD ["--help"]

Exécuter vLLM avec ML Diagnostics

Après avoir créé l'image Docker, vous pouvez exécuter le conteneur sur GKE ou Compute Engine. Lorsque vous démarrez le conteneur, configurez les variables d'environnement du profileur et transmettez les arguments MLRun ainsi que vos arguments vllm serve standards.

Exécutez le conteneur vLLM avec les diagnostics de ML activés :

docker run --name vllm_diagnostics -d --privileged --net=host \
  -e HF_HUB_DISABLE_XET=1 \
  -e USE_MOE_EP_KERNEL=1 \
  -e PJRT_DEVICE=TPU \
  -e ENABLE_GOOGLE_DIAGON_ML_DIAGNOSTICS=True \
  -e VLLM_LOGGING_LEVEL=DEBUG \
  -e VLLM_TORCH_PROFILER_DIR="gs://BUCKET_NAME/vllm_profiles" \
  -e PHASED_PROFILING_DIR="gs://BUCKET_NAME/vllm_profiles" \
  -e PYTHONUNBUFFERED=1 \
  -e PHASED_PROFILER_NUM_STEPS_TO_PROFILE_FOR=100 \
  -e HF_TOKEN="HF_TOKEN" \
  -e HUGGING_FACE_HUB_TOKEN="HF_TOKEN" \
  VLLM_IMAGE \
  --mlrun_name="vllm-tpu-run" \
  --run_group="vllm-benchmark" \
  --configs='{"user":"ml-team", "running_on":"TPU"}' \
  --mlrun_gcs_path="gs://BUCKET_NAME/vllm_profiles" \
  --project="PROJECT_ID" \
  --region="us-central1" \
  -- serve Qwen/Qwen2-1.5B \
  --kv-cache-dtype=fp8 \
  --tensor-parallel-size=1 \
  --data-parallel-size=1 \
  --max-model-len=2048 \
  --max-num-batched-tokens=2048 \
  --max-num-seqs=64 \
  --no-enable-prefix-caching \
  --block-size=256 \
  --gpu-memory-utilization=0.95 \
  --port=8000 \
  --profiler-config.profiler=torch \
  --profiler-config.torch_profiler_dir="gs://BUCKET_NAME/vllm_profiles"

Remplacez les éléments suivants :

  • BUCKET_NAME : nom de votre bucket Cloud Storage pour stocker les traces et les artefacts du profileur
  • HF_TOKEN : votre jeton d'accès Hugging Face
  • VLLM_IMAGE : nom ou URI de votre image Docker vLLM
  • PROJECT_ID : ID de votre projet Google Cloud

Profiler les charges de travail vLLM

Lorsque vous démarrez votre conteneur avec la commande run_vllm, le wrapper configure l'environnement du traceur et enregistre toutes les traces du traceur dans Cloud Storage sous le répertoire MLRUN_GCS_PATH/RUN_NAME/plugins/profile/ :

  • MLRUN_GCS_PATH : chemin d'accès au bucket Cloud Storage que vous spécifiez avec l'argument --mlrun_gcs_path.
  • RUN_NAME : identifiant unique de votre ressource MLRun

Pendant que votre conteneur vLLM diffuse des requêtes d'inférence, vous pouvez capturer des traces de profileur à l'aide du profilage par phases, manuel ou à la demande.

Profilage par étapes

Le profilage par phases capture automatiquement les traces de différentes phases de la charge de travail d'inférence, telles que PREFILL_ONLY, PREFILL_HEAVY, BALANCED et DECODE_HEAVY. Lorsque vous fournissez un chemin d'accès Cloud Storage de base, le wrapper run_vllm ajoute le sous-répertoire RUN_NAME/plugins/profile/ et exporte le chemin d'accès obtenu vers la variable d'environnement PHASED_PROFILING_DIR.

Pour activer le profilage par phases lorsque vous démarrez le conteneur, configurez les paramètres suivants :

  • Définissez la variable d'environnement ENABLE_GOOGLE_DIAGON_ML_DIAGNOSTICS=True.
  • Définissez la variable d'environnement PHASED_PROFILER_NUM_STEPS_TO_PROFILE_FOR sur le nombre d'étapes à profiler.
  • Transmettez votre chemin d'accès Cloud Storage de base à l'aide de l'argument de wrapper --phased_profiling_dir (ou définissez la variable d'environnement PHASED_PROFILING_DIR dans les configurations à hôte unique).

Profilage manuel (déclenché par l'API)

Le profilage manuel vous permet de démarrer et d'arrêter des sessions de profilage de manière programmatique pour des fenêtres spécifiques de trafic d'inférence. Lorsque vous démarrez le conteneur, le wrapper run_vllm met à jour la variable d'environnement VLLM_TORCH_PROFILER_DIR et l'argument --profiler-config.torch_profiler_dir pour enregistrer les traces dans le répertoire de profil de votre exécution de ML.

Pour capturer un profil manuel :

  1. Lorsque vous démarrez le conteneur, définissez la variable d'environnement VLLM_TORCH_PROFILER_DIR et transmettez les arguments --profiler-config.profiler=torch et --profiler-config.torch_profiler_dir à la commande vllm serve.
  2. Pendant que vous générez une charge sur le serveur, envoyez des requêtes HTTP aux points de terminaison de l'API /start_profile et /stop_profile de vLLM pour démarrer et arrêter la session de profilage.

Profilage à la demande dans la console Google Cloud

Le profilage à la demande vous permet de déclencher des captures de profils en direct de manière interactive depuis la console Google Cloud sans redémarrer votre charge de travail ni envoyer de requêtes API. Lorsque vous démarrez le conteneur, le wrapper run_vllm démarre automatiquement le serveur du profileur JAX en définissant les variables d'environnement USE_JAX_PROFILER_SERVER=True et JAX_PROFILER_SERVER_PORT.

Pour capturer un profil à la demande pendant que votre charge de travail diffuse des requêtes, procédez comme suit :

  1. Dans la consoleGoogle Cloud , accédez à l'onglet Exécuter les diagnostics et sélectionnez votre ressource MLRun :
    • Cluster Director : accédez à la page Cluster Director, puis cliquez sur l'onglet Exécuter les diagnostics.
    • GKE : accédez à la page Kubernetes, cliquez sur IA/ML dans le menu de navigation, puis sur l'onglet Exécuter les diagnostics.
  2. Sélectionnez l'onglet Profils.
  3. Démarrez une session de capture.