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 VariablePHASED_PROFILING_DIRin der Betriebssystemumgebung, hängt das Suffix mit dem Ausführungsbereich an, leitet den Pfad an den Befehlvllm serveweiter und protokolliert eine Warnung. - Der Ray-Executor von vLLM wendet Treiberumgebungsvariablen auf Remote-Worker an, indem er die Methode
os.environ.setdefaultverwendet. - Remote-Worker, die die Variable
PHASED_PROFILING_DIRbereits in ihrer Umgebung haben, behalten ihren vorhandenen Pfad bei, anstatt den Pfad mit Ausführungsbereich zu übernehmen, der ihre Traces außerhalb des VerzeichnissesMLRunschreibt.
vLLM-Arbeitslasten ausführen und profilieren
Führen Sie die folgenden Schritte aus, um ein Modell mit vLLM und ML-Diagnose bereitzustellen:
- Erstellen Sie ein Docker-Container-Image, das vLLM mit dem ML Diagnostics SDK verpackt und den
run_vllm-Wrapper als Einstiegspunkt konfiguriert. - Führen Sie den Container in GKE oder Compute Engine aus, indem Sie die
MLRun-Argumente zusammen mit denvllm serve-Argumenten übergeben. - 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 -ArtefaktenHF_TOKEN: Ihr Hugging Face-ZugriffstokenVLLM_IMAGE: der Name oder URI Ihres vLLM-Docker-ImagesPROJECT_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_pathangebenRUN_NAME: die eindeutige Kennung für IhreMLRun-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=Truefest. - Legen Sie die Umgebungsvariable
PHASED_PROFILER_NUM_STEPS_TO_PROFILE_FORauf die Anzahl der zu profilierenden Schritte fest. - Übergeben Sie den Cloud Storage-Basispfad mit dem Wrapper-Argument
--phased_profiling_diroder legen Sie die UmgebungsvariablePHASED_PROFILING_DIRin 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:
- Legen Sie beim Starten des Containers die Umgebungsvariable
VLLM_TORCH_PROFILER_DIRfest und übergeben Sie die Argumente--profiler-config.profiler=torchund--profiler-config.torch_profiler_diran den Befehlvllm serve. - Senden Sie während der Lastgenerierung auf dem Server HTTP-Anfragen an die vLLM-API-Endpunkte
/start_profileund/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:
- 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.
- Wählen Sie den Tab Profile aus.
- Starten Sie eine Aufnahmesitzung.