vLLM-Arbeitslasten mit ML Diagnostics ausführen und profilieren

vLLM ist eine Open-Source-Bibliothek für die Inferenz und Bereitstellung von Large Language Models (LLMs). Durch die Einbindung von ML-Diagnose in vLLM können Sie Bereitstellungskonfigurationen verfolgen, Arbeitslasttelemetrie überwachen und XProf-Profile auf Google Clouderfassen. In diesem Dokument wird der ML-Diagnose-Wrapper-Befehl für vLLM beschrieben und gezeigt, wie Sie eine vLLM-Arbeitslast containerisieren, ausführen und profilieren.

Wrapper-Befehlszeilenargumente

ML Diagnostics bietet einen integrierten Wrapper-Befehl, google_cloud_mldiagnostics.commands.run_vllm, um vLLM-Bereitstellungs- und Inferenzarbeitslasten zu starten und Telemetrie und Profilerstellung automatisch zu konfigurieren. Sie können den run_vllm-Wrapper als Einstiegspunkt in Ihrem vLLM-Docker-Container festlegen oder ihn direkt über die Befehlszeile in der Google Kubernetes Engine (GKE) oder der Compute Engine ausführen.

Wenn Sie eine Arbeitslast mit dem Befehl run_vllm starten, führt der Wrapper die folgenden Aktionen aus:

  • Ausführung registrieren: Erstellt und registriert eine verwaltete MLRun-Ressource, die für vLLM-Bereitstellungsarbeitslasten konfiguriert ist.
  • Profilerstellung konfigurieren: Legt Profiler-Umgebungsvariablen fest und aktualisiert die Profiler-Ausgabepfade in Cloud Storage, um Traces in einem Verzeichnis für Ihren ML-Ausführung zu organisieren.
  • Argumente weiterleiten: Übergibt alle verbleibenden Befehlszeilenargumente direkt an den Befehl vllm.

In der folgenden Tabelle werden die Befehlszeilenargumente beschrieben, die der run_vllm-Wrapper akzeptiert:

Argument Beschreibung
--mlrun_name Erforderlich. Eindeutige Kennung für die ML-Ausführungsressource (MLRun).
--mlrun_gcs_path Erforderlich. Cloud Storage-Bucket-Pfad, in dem Profiler-Traces und -Artefakte gespeichert werden. Beispiel: gs://my-bucket/vllm-profiles.
--project Optional. Ihre Google Cloud -Projekt-ID.
--region Optional. Region, in der die MLRun-Metadaten gespeichert werden. Standardeinstellung: us-central1
--run_group Optional. ID, die mehrere zusammengehörige Ausführungen gruppiert.
--configs Optional. Benutzerdefinierte Konfigurationen, die Sie als JSON-Objektstring übergeben. Beispiel: '{"user":"my-team", "running_on":"TPU"}'.
--framework Optional. Zugrunde liegendes ML-Framework für die Arbeitslast (pytorch oder jax). Standard: pytorch.
--jax_profiler_port Optional. Port des JAX-Profiler-Servers. Standard: 9999.
--phased_profiling_dir Optional. Cloud Storage-Basisverzeichnis für JAX-Phasenprofilierungs-Traces. Der Wrapper hängt den Pfad RUN_NAME/plugins/profile/ an und exportiert das Ergebnis als Umgebungsvariable PHASED_PROFILING_DIR in den vLLM-Prozess. Verwenden Sie dieses Argument, um die phasenweise Profilerstellung zu aktivieren.

Phasenweises Profiling in Setups mit mehreren Hosts

Wenn Sie die phasenweise Profilerstellung für JAX in Umgebungen mit mehreren Hosts aktivieren möchten, z. B. in einem Ray-Backend auf einer GKE-LeaderWorkerSet, übergeben Sie das Argument --phased_profiling_dir und lassen Sie die Umgebungsvariable PHASED_PROFILING_DIR in Ihrer Betriebssystemumgebung weg.

Wenn Sie die Umgebungsvariable PHASED_PROFILING_DIR festlegen, ohne das Argument --phased_profiling_dir zu übergeben, werden phasenbasierte Profile aus den folgenden Gründen möglicherweise nicht in XProf in der Google Cloud Console angezeigt:

  • Der run_vllm-Wrapper erkennt die Variable PHASED_PROFILING_DIR in der Betriebssystemumgebung, hängt das Suffix mit dem Ausführungsbereich an, leitet den Pfad an den Befehl vllm serve weiter und protokolliert eine Warnung.
  • Der Ray-Executor von vLLM wendet Treiberumgebungsvariablen auf Remote-Worker an, indem er die Methode os.environ.setdefault verwendet.
  • Remote-Worker, die die Variable PHASED_PROFILING_DIR bereits in ihrer Umgebung haben, behalten ihren vorhandenen Pfad bei, anstatt den Pfad mit Ausführungsbereich zu übernehmen, der ihre Traces außerhalb des Verzeichnisses MLRun schreibt.

vLLM-Arbeitslasten ausführen und profilieren

Führen Sie die folgenden Schritte aus, um ein Modell mit vLLM und ML-Diagnose bereitzustellen:

  1. Erstellen Sie ein Docker-Container-Image, das vLLM mit dem ML Diagnostics SDK verpackt und den run_vllm-Wrapper als Einstiegspunkt konfiguriert.
  2. Führen Sie den Container in GKE oder Compute Engine aus, indem Sie die MLRun-Argumente zusammen mit den vllm serve-Argumenten übergeben.
  3. Erfassen Sie Leistungs-Traces, während der Server Inferenzanfragen verarbeitet, indem Sie phasenweises, manuelles oder On-Demand-Profiling verwenden, und rufen Sie die Ergebnisse in derGoogle Cloud Console auf.

Docker-Image für vLLM vorbereiten

Wenn Sie den run_vllm-Wrapper in einem Container verwenden möchten, erstellen Sie ein Docker-Image, das das ML Diagnostics SDK, das xprof-Paket und Logging-Abhängigkeiten zusätzlich zum vLLM-TPU-Basis-Image installiert. Legen Sie im Dockerfile das Modul google_cloud_mldiagnostics.commands.run_vllm als Container-Einstiegspunkt fest.

Im folgenden Dockerfile-Beispiel wird ein vLLM-TPU-Image mit dem ML Diagnostics SDK verpackt:

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"]

vLLM mit ML-Diagnose ausführen

Nachdem Sie das Docker-Image erstellt haben, können Sie den Container in der GKE oder der Compute Engine ausführen. Konfigurieren Sie beim Starten des Containers die Profiler-Umgebungsvariablen und übergeben Sie die MLRun-Argumente zusammen mit den Standardargumenten vllm serve.

Führen Sie den vLLM-Container mit aktivierter ML-Diagnose aus:

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"

Ersetzen Sie Folgendes:

  • BUCKET_NAME: der Name Ihres Cloud Storage-Bucket zum Speichern von Profiler-Traces und -Artefakten
  • HF_TOKEN: Ihr Hugging Face-Zugriffstoken
  • VLLM_IMAGE: der Name oder URI Ihres vLLM-Docker-Images
  • PROJECT_ID: Ihre Projekt-ID in Google Cloud

Profil für vLLM-Arbeitslasten erstellen

Wenn Sie Ihren Container mit dem Befehl run_vllm starten, konfiguriert der Wrapper die Profiler-Umgebung und speichert alle Profiler-Traces in Cloud Storage im Verzeichnis MLRUN_GCS_PATH/RUN_NAME/plugins/profile/:

  • MLRUN_GCS_PATH: der Cloud Storage-Bucket-Pfad, den Sie mit dem Argument --mlrun_gcs_path angeben
  • RUN_NAME: die eindeutige Kennung für Ihre MLRun-Ressource

Während Ihr vLLM-Container Inferenzanfragen verarbeitet, können Sie Profiler-Traces mithilfe von phasenweisem, manuellem oder On-Demand-Profiling erfassen.

Phasenweise Profilerstellung

Beim phasenweisen Profiling werden automatisch Traces in verschiedenen Phasen der Inferenzarbeitslast erfasst, z. B. PREFILL_ONLY, PREFILL_HEAVY, BALANCED und DECODE_HEAVY. Wenn Sie einen Cloud Storage-Basispfad angeben, hängt der run_vllm-Wrapper das Unterverzeichnis RUN_NAME/plugins/profile/ an und exportiert den resultierenden Pfad in die Umgebungsvariable PHASED_PROFILING_DIR.

Konfigurieren Sie die folgenden Einstellungen, um die phasenweise Profilerstellung beim Starten des Containers zu aktivieren:

  • Legen Sie die Umgebungsvariable ENABLE_GOOGLE_DIAGON_ML_DIAGNOSTICS=True fest.
  • Legen Sie die Umgebungsvariable PHASED_PROFILER_NUM_STEPS_TO_PROFILE_FOR auf die Anzahl der zu profilierenden Schritte fest.
  • Übergeben Sie den Cloud Storage-Basispfad mit dem Wrapper-Argument --phased_profiling_dir oder legen Sie die Umgebungsvariable PHASED_PROFILING_DIR in Setups mit einem einzelnen Host fest.

Manuelle (API-getriggerte) Profilerstellung

Mit der manuellen Profilerstellung können Sie Profilerstellungssitzungen für bestimmte Zeiträume des Inferenz-Traffics programmatisch starten und beenden. Wenn Sie den Container starten, aktualisiert der run_vllm-Wrapper die Umgebungsvariable VLLM_TORCH_PROFILER_DIR und das Argument --profiler-config.torch_profiler_dir, um Traces im Profilverzeichnis für Ihren ML-Ausführung zu speichern.

So erfassen Sie ein Profil manuell:

  1. Legen Sie beim Starten des Containers die Umgebungsvariable VLLM_TORCH_PROFILER_DIR fest und übergeben Sie die Argumente --profiler-config.profiler=torch und --profiler-config.torch_profiler_dir an den Befehl vllm serve.
  2. Senden Sie während der Lastgenerierung auf dem Server HTTP-Anfragen an die vLLM-API-Endpunkte /start_profile und /stop_profile, um die Profilerstellungssitzung zu starten und zu beenden.

On-Demand-Profiling in der Google Cloud Console

Mit On-Demand-Profiling können Sie Live-Profilerfassungen interaktiv über die Google Cloud Console auslösen, ohne Ihre Arbeitslast neu starten oder API-Anfragen senden zu müssen. Wenn Sie den Container starten, startet der run_vllm-Wrapper automatisch den JAX-Profiler-Server, indem er die Umgebungsvariablen USE_JAX_PROFILER_SERVER=True und JAX_PROFILER_SERVER_PORT festlegt.

Führen Sie die folgenden Schritte aus, um ein On-Demand-Profil zu erfassen, während Ihre Arbeitslast Anfragen verarbeitet:

  1. Rufen Sie in der Google Cloud Console den Tab Diagnose ausführen auf und wählen Sie Ihre MLRun-Ressource aus:
    • Cluster Director: Rufen Sie die Seite Cluster Director auf und klicken Sie auf den Tab Diagnose ausführen.
    • GKE: Rufen Sie die Seite Kubernetes auf, klicken Sie im Navigationsmenü auf KI/ML und dann auf den Tab Diagnose ausführen.
  2. Wählen Sie den Tab Profile aus.
  3. Starten Sie eine Aufnahmesitzung.