Executar e criar perfis de cargas de trabalho do vLLM com o ML Diagnostics

O vLLM é uma biblioteca de código aberto para inferência e disponibilização de modelos de linguagem grandes (LLMs). A integração do diagnóstico de ML com o vLLM permite acompanhar as configurações de exibição, monitorar a telemetria da carga de trabalho e capturar perfis do XProf no Google Cloud. Neste documento, descrevemos o comando wrapper do ML Diagnostics para vLLM e mostramos como conteinerizar, executar e criar o perfil de uma carga de trabalho do vLLM.

Argumentos de linha de comando do wrapper

O ML Diagnostics oferece um comando wrapper integrado, google_cloud_mldiagnostics.commands.run_vllm, para iniciar cargas de trabalho de disponibilização e inferência do vLLM e configurar automaticamente a telemetria e a criação de perfil. É possível definir o wrapper run_vllm como o ponto de entrada no contêiner do Docker do vLLM ou executá-lo diretamente na linha de comando no Google Kubernetes Engine (GKE) ou no Compute Engine.

Quando você inicia uma carga de trabalho com o comando run_vllm, o wrapper executa as seguintes ações:

  • Registrar a execução: cria e registra um recurso gerenciado MLRun configurado para cargas de trabalho de veiculação do vLLM.
  • Configurar a criação de perfil: define as variáveis de ambiente do criador de perfil e atualiza os caminhos de saída do criador de perfil no Cloud Storage para organizar os traces em um diretório para sua execução de ML.
  • Encaminhar argumentos: transmite todos os argumentos de linha de comando restantes diretamente para o comando vllm.

A tabela a seguir descreve os argumentos de linha de comando aceitos pelo wrapper run_vllm:

Argumento Descrição
--mlrun_name Obrigatório. Identificador exclusivo do recurso de execução de ML (MLRun).
--mlrun_gcs_path Obrigatório. Caminho do bucket do Cloud Storage que armazena traces e artefatos do profiler. Exemplo: gs://my-bucket/vllm-profiles
--project Opcional. O ID do projeto do Google Cloud .
--region Opcional. Região que armazena os metadados do MLRun. Padrão: us-central1.
--run_group Opcional. Identificador que agrupa várias execuções relacionadas.
--configs Opcional. Configurações definidas pelo usuário que você transmite como uma string de objeto JSON. Exemplo: '{"user":"my-team", "running_on":"TPU"}'
--framework Opcional. Framework de ML subjacente para a carga de trabalho (pytorch ou jax). Padrão: pytorch.
--jax_profiler_port Opcional. Porta do servidor do criador de perfil do JAX. Padrão: 9999.
--phased_profiling_dir Opcional. Diretório base do Cloud Storage para traces de criação de perfil em fases do JAX. O wrapper anexa o caminho RUN_NAME/plugins/profile/ e exporta o resultado como a variável de ambiente PHASED_PROFILING_DIR para o processo vLLM. Use esse argumento para ativar a criação de perfil em fases.

Criação de perfil em fases em configurações de vários hosts

Para ativar a criação de perfil em fases do JAX em configurações de vários hosts, como um back-end do Ray em um LeaderWorkerSet do GKE, transmita o argumento --phased_profiling_dir e omita a variável de ambiente PHASED_PROFILING_DIR no ambiente do sistema operacional.

Se você definir a variável de ambiente PHASED_PROFILING_DIR sem transmitir o argumento --phased_profiling_dir, os perfis em fases podem não aparecer no XProf no console do Google Cloud pelos seguintes motivos:

  • O wrapper run_vllm detecta a variável PHASED_PROFILING_DIR no ambiente do sistema operacional, anexa o sufixo com escopo de execução, encaminha o caminho para o comando vllm serve e registra um aviso.
  • O executor do Ray do vLLM aplica variáveis de ambiente do driver em funcionários remotos usando o método os.environ.setdefault.
  • Os funcionários remotos que já têm a variável PHASED_PROFILING_DIR no ambiente mantêm o caminho atual em vez de adotar o caminho com escopo de execução, que grava os traces fora do diretório MLRun.

Executar e criar perfis de cargas de trabalho do vLLM

Para disponibilizar um modelo com vLLM e ML Diagnostics, siga estas etapas:

  1. Crie uma imagem de contêiner do Docker que empacote o vLLM com o SDK de diagnóstico de ML e configure o wrapper run_vllm como o ponto de entrada.
  2. Execute o contêiner no GKE ou no Compute Engine transmitindo os argumentos MLRun com os argumentos vllm serve.
  3. Capture traces de desempenho enquanto o servidor processa solicitações de inferência usando a criação de perfil em fases, manual ou sob demanda e confira os resultados no console doGoogle Cloud .

Preparar uma imagem Docker para vLLM

Para usar o wrapper run_vllm em um contêiner, crie uma imagem Docker que instale o SDK de diagnóstico de ML, o pacote xprof e as dependências de geração de registros sobre a imagem base da TPU do vLLM. No Dockerfile, defina o módulo google_cloud_mldiagnostics.commands.run_vllm como o ponto de entrada do contêiner.

O exemplo de Dockerfile a seguir empacota uma imagem de TPU do vLLM com o SDK de diagnóstico de ML:

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

Executar o vLLM com o diagnóstico de ML

Depois de criar a imagem Docker, é possível executar o contêiner no GKE ou no Compute Engine. Ao iniciar o contêiner, configure as variáveis de ambiente do criador de perfil e transmita os argumentos MLRun com os argumentos vllm serve padrão.

Execute o contêiner vLLM com o diagnóstico de ML ativado:

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"

Substitua:

  • BUCKET_NAME: o nome do bucket do Cloud Storage para armazenar traces e artefatos do criador de perfil
  • HF_TOKEN: seu token de acesso do Hugging Face.
  • VLLM_IMAGE: o nome ou URI da imagem Docker do vLLM
  • PROJECT_ID: o ID do projeto do Google Cloud .

Criar perfis de cargas de trabalho do vLLM

Quando você inicia o contêiner com o comando run_vllm, o wrapper configura o ambiente do criador de perfil e salva todos os traces do criador de perfil no Cloud Storage no diretório MLRUN_GCS_PATH/RUN_NAME/plugins/profile/:

  • MLRUN_GCS_PATH: o caminho do bucket do Cloud Storage que você especifica com o argumento --mlrun_gcs_path.
  • RUN_NAME: o identificador exclusivo do recurso MLRun.

Enquanto o contêiner do vLLM atende às solicitações de inferência, é possível capturar traces do criador de perfil usando a criação de perfil em fases, manual ou on demand.

Criação de perfis em fases

A criação de perfil em fases captura automaticamente traces em diferentes fases da carga de trabalho de inferência, como PREFILL_ONLY, PREFILL_HEAVY, BALANCED e DECODE_HEAVY. Quando você fornece um caminho base do Cloud Storage, o wrapper run_vllm anexa o subdiretório RUN_NAME/plugins/profile/ e exporta o caminho resultante para a variável de ambiente PHASED_PROFILING_DIR.

Para ativar a criação de perfil em fases ao iniciar o contêiner, defina as seguintes configurações:

  • Defina a variável de ambiente ENABLE_GOOGLE_DIAGON_ML_DIAGNOSTICS=True.
  • Defina a variável de ambiente PHASED_PROFILER_NUM_STEPS_TO_PROFILE_FOR como o número de etapas para criar o perfil.
  • Transmita o caminho base do Cloud Storage usando o argumento wrapper --phased_profiling_dir (ou defina a variável de ambiente PHASED_PROFILING_DIR em configurações de host único).

Criação de perfil manual (acionada por API)

Com a criação de perfil manual, é possível iniciar e interromper sessões de criação de perfil de maneira programática para janelas específicas de tráfego de inferência. Quando você inicia o contêiner, o wrapper run_vllm atualiza a variável de ambiente VLLM_TORCH_PROFILER_DIR e o argumento --profiler-config.torch_profiler_dir para salvar traces no diretório de perfil da sua execução de ML.

Para capturar um perfil manual:

  1. Ao iniciar o contêiner, defina a variável de ambiente VLLM_TORCH_PROFILER_DIR e transmita os argumentos --profiler-config.profiler=torch e --profiler-config.torch_profiler_dir para o comando vllm serve.
  2. Ao gerar carga no servidor, envie solicitações HTTP para os endpoints de API /start_profile e /stop_profile do vLLM para iniciar e interromper a sessão de criação de perfil.

Criação de perfil sob demanda no console do Google Cloud

Com a criação de perfil sob demanda, é possível acionar capturas de perfil em tempo real de forma interativa no console do Google Cloud sem reiniciar a carga de trabalho ou enviar solicitações de API. Quando você inicia o contêiner, o wrapper run_vllm inicia automaticamente o servidor do criador de perfil do JAX definindo as variáveis de ambiente USE_JAX_PROFILER_SERVER=True e JAX_PROFILER_SERVER_PORT.

Para capturar um perfil sob demanda enquanto sua carga de trabalho está atendendo a solicitações, siga estas etapas:

  1. No console doGoogle Cloud , acesse a guia Executar diagnóstico e selecione o recurso do MLRun:
    • Cluster Director: acesse a página Cluster Director e clique na guia Executar diagnósticos.
    • GKE: acesse a página do Kubernetes, clique em IA/ML no menu de navegação e clique na guia Executar diagnósticos.
  2. Selecione a guia Perfis.
  3. Inicie uma sessão de captura.