Esegui e profila i workload vLLM con ML Diagnostics

vLLM è una libreria open source per l'inferenza e la distribuzione di modelli linguistici di grandi dimensioni (LLM). L'integrazione di ML Diagnostics con vLLM ti consente di monitorare le configurazioni di gestione, monitorare la telemetria dei workload e acquisire profili XProf su Google Cloud. Questo documento descrive il comando wrapper di ML Diagnostics per vLLM e mostra come containerizzare, eseguire e profilare un workload vLLM.

Argomenti della riga di comando del wrapper

ML Diagnostics fornisce un comando wrapper integrato, google_cloud_mldiagnostics.commands.run_vllm, per avviare i workload di inferenza e di gestione vLLM e configurare automaticamente la telemetria e la profilazione. Puoi impostare il wrapper run_vllm come entrypoint nel container Docker vLLM o eseguirlo direttamente dalla riga di comando su Google Kubernetes Engine (GKE) o Compute Engine.

Quando avvii un workload con il comando run_vllm, il wrapper esegue le seguenti azioni:

  • Registra l'esecuzione: crea e registra una risorsa MLRun gestita configurata per i workload di distribuzione vLLM.
  • Configura la profilazione: imposta le variabili di ambiente del profiler e aggiorna i percorsi di output del profiler in Cloud Storage per organizzare le tracce in una directory per l'esecuzione del ML.
  • Inoltra argomenti: passa tutti gli argomenti della riga di comando rimanenti direttamente al comando vllm.

La tabella seguente descrive gli argomenti della riga di comando accettati dal wrapper run_vllm:

Argomento Descrizione
--mlrun_name Obbligatorio. Identificatore univoco della risorsa di esecuzione ML (MLRun).
--mlrun_gcs_path Obbligatorio. Percorso del bucket Cloud Storage in cui sono archiviati gli artefatti e le tracce di Profiler. Ad esempio, gs://my-bucket/vllm-profiles.
--project Facoltativo. L'ID progetto Google Cloud .
--region Facoltativo. Regione in cui vengono archiviati i metadati di MLRun. Valore predefinito: us-central1.
--run_group Facoltativo. Identificatore che raggruppa più esecuzioni correlate.
--configs Facoltativo. Configurazioni definite dall'utente che passi come stringa di oggetto JSON. Ad esempio, '{"user":"my-team", "running_on":"TPU"}'.
--framework Facoltativo. Framework ML sottostante per il workload (pytorch o jax). Valore predefinito: pytorch.
--jax_profiler_port Facoltativo. Porta del server del profiler JAX. Predefinito: 9999.
--phased_profiling_dir Facoltativo. Directory Cloud Storage di base per le tracce di profilazione in fasi di JAX. Il wrapper aggiunge il percorso RUN_NAME/plugins/profile/ ed esporta il risultato come variabile di ambiente PHASED_PROFILING_DIR nel processo vLLM. Utilizza questo argomento per attivare la profilazione in fasi.

Profilazione in fasi in configurazioni multi-host

Per abilitare la profilazione in fasi di JAX in configurazioni multi-host, come un backend Ray su un GKE LeaderWorkerSet, passa l'argomento --phased_profiling_dir e ometti la variabile di ambiente PHASED_PROFILING_DIR nell'ambiente del sistema operativo.

Se imposti la variabile di ambiente PHASED_PROFILING_DIR senza passare l'argomento --phased_profiling_dir, i profili a fasi potrebbero non essere visualizzati in XProf nella console Google Cloud per i seguenti motivi:

  • Il wrapper run_vllm rileva la variabile PHASED_PROFILING_DIR nell'ambiente del sistema operativo, aggiunge il suffisso con ambito di esecuzione, inoltra il percorso al comando vllm serve e registra un avviso.
  • L'esecutore Ray di vLLM applica le variabili di ambiente del driver ai lavoratori da remoto utilizzando il metodo os.environ.setdefault.
  • I lavoratori da remoto che hanno già la variabile PHASED_PROFILING_DIR nel loro ambiente mantengono il percorso esistente anziché adottare il percorso con ambito di esecuzione, che scrive le tracce all'esterno della directory MLRun.

Esegui e profila i workload vLLM

Per pubblicare un modello con vLLM e ML Diagnostics, completa i seguenti passaggi:

  1. Crea un'immagine container Docker che pacchettizza vLLM con l'SDK ML Diagnostics e configura il wrapper run_vllm come entrypoint.
  2. Esegui il container su GKE o Compute Engine passando gli argomenti MLRun insieme agli argomenti vllm serve.
  3. Acquisisci le tracce delle prestazioni mentre il server elabora le richieste di inferenza utilizzando la profilazione a fasi, manuale o on demand e visualizza i risultati nella consoleGoogle Cloud .

Prepara un'immagine Docker per vLLM

Per utilizzare il wrapper run_vllm in un container, crea un'immagine Docker che installi l'SDK ML Diagnostics, il pacchetto xprof e le dipendenze di logging sopra l'immagine di base della TPU vLLM. Nel Dockerfile, imposta il modulo google_cloud_mldiagnostics.commands.run_vllm come entrypoint del container.

Il seguente esempio di Dockerfile pacchettizza un'immagine vLLM TPU con l'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"]

Esegui vLLM con ML Diagnostics

Dopo aver creato l'immagine Docker, puoi eseguire il container su GKE o Compute Engine. Quando avvii il container, configura le variabili di ambiente del profiler e passa gli argomenti MLRun insieme agli argomenti vllm serve standard.

Esegui il container vLLM con ML Diagnostics abilitato:

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"

Sostituisci quanto segue:

  • BUCKET_NAME: il nome del bucket Cloud Storage per l'archiviazione di tracce e artefatti di Profiler
  • HF_TOKEN: il tuo token di accesso a Hugging Face
  • VLLM_IMAGE: il nome o l'URI dell'immagine Docker vLLM
  • PROJECT_ID: il tuo ID progetto Google Cloud

Profila i workload vLLM

Quando avvii il container con il comando run_vllm, il wrapper configura l'ambiente del profiler e salva tutte le tracce del profiler in Cloud Storage nella directory MLRUN_GCS_PATH/RUN_NAME/plugins/profile/:

  • MLRUN_GCS_PATH: il percorso del bucket Cloud Storage specificato con l'argomento --mlrun_gcs_path
  • RUN_NAME: l'identificatore univoco della risorsa MLRun

Mentre il container vLLM gestisce le richieste di inferenza, puoi acquisire le tracce del profiler utilizzando la profilazione a fasi, manuale o on demand.

Profilazione in fasi

La profilazione a fasi acquisisce automaticamente le tracce in diverse fasi del workload di inferenza, come PREFILL_ONLY, PREFILL_HEAVY, BALANCED e DECODE_HEAVY. Quando fornisci un percorso Cloud Storage di base, il wrapper run_vllm aggiunge la sottodirectory RUN_NAME/plugins/profile/ ed esporta il percorso risultante nella variabile di ambiente PHASED_PROFILING_DIR.

Per attivare la profilazione in fasi all'avvio del container, configura le seguenti impostazioni:

  • Imposta la variabile di ambiente ENABLE_GOOGLE_DIAGON_ML_DIAGNOSTICS=True.
  • Imposta la variabile di ambiente PHASED_PROFILER_NUM_STEPS_TO_PROFILE_FOR sul numero di passaggi da profilare.
  • Passa il percorso di base di Cloud Storage utilizzando l'argomento wrapper --phased_profiling_dir (o imposta la variabile di ambiente PHASED_PROFILING_DIR nelle configurazioni single-host).

Profilazione manuale (attivata tramite API)

La profilazione manuale ti consente di avviare e interrompere le sessioni di profilazione in modo programmatico per finestre specifiche di traffico di inferenza. Quando avvii il container, il wrapper run_vllm aggiorna la variabile di ambiente VLLM_TORCH_PROFILER_DIR e l'argomento --profiler-config.torch_profiler_dir per salvare le tracce nella directory del profilo per l'esecuzione del ML.

Per acquisire un profilo manuale:

  1. Quando avvii il container, imposta la variabile di ambiente VLLM_TORCH_PROFILER_DIR e passa gli argomenti --profiler-config.profiler=torch e --profiler-config.torch_profiler_dir al comando vllm serve.
  2. Durante la generazione del carico sul server, invia richieste HTTP agli endpoint API /start_profile e /stop_profile di vLLM per avviare e arrestare la sessione di profilazione.

Profilazione on demand nella console Google Cloud

La profilazione on demand ti consente di attivare l'acquisizione di profili in tempo reale in modo interattivo dalla console Google Cloud senza riavviare il workload o inviare richieste API. Quando avvii il container, il wrapper run_vllm avvia automaticamente il server del profiler JAX impostando le variabili di ambiente USE_JAX_PROFILER_SERVER=True e JAX_PROFILER_SERVER_PORT.

Per acquisire un profilo on demand mentre il workload gestisce le richieste, completa i seguenti passaggi:

  1. Nella consoleGoogle Cloud , vai alla scheda Esegui diagnostica e seleziona la risorsa MLRun:
    • Cluster Director: vai alla pagina Cluster Director e fai clic sulla scheda Esegui diagnostica.
    • GKE: vai alla pagina Kubernetes, fai clic su AI/ML nel menu di navigazione e poi sulla scheda Esegui diagnostica.
  2. Seleziona la scheda Profili.
  3. Avvia una sessione di acquisizione.