Entrega Qwen2-7B-Instruct con vLLM en TPU

En este instructivo, se entrega el modelo Qwen/Qwen2-7B-Instruct con el framework de entrega de vLLM TPU en una VM de TPU v6e.

Objetivos

  1. Configura el entorno.
  2. Ejecuta vLLM con Qwen2-7B-Instruct.
  3. Envía una solicitud de inferencia.
  4. Ejecuta una carga de trabajo de comparativa.
  5. Realizar una limpieza

Costos

En este instructivo, se usan componentes facturables de Google Cloud, que incluyen lo siguiente:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Antes de comenzar

Antes de realizar este instructivo, sigue las instrucciones de la página Configura el entorno de Cloud TPU. Las instrucciones te guían por los pasos necesarios para crear un proyecto de Google Cloudy configurarlo para usar Cloud TPU. También puedes usar un proyectoGoogle Cloud existente. Si decides hacerlo, puedes omitir el paso para crear un proyecto deGoogle Cloud y comenzar con Configura tu entorno para usar Cloud TPU.

Para usar este instructivo, necesitas un token de acceso de Hugging Face. Puedes registrarte para obtener una cuenta gratuita en Hugging Face. Una vez que tengas una cuenta, genera un token de acceso:

  1. En la página Welcome to Hugging Face, haz clic en el avatar de tu cuenta y selecciona Access tokens.
  2. En la página Tokens de acceso, haz clic en Crear token nuevo.
  3. Selecciona el tipo de token Read y, luego, ingresa un nombre para el token.
  4. Se mostrará tu token de acceso. Guarda el token en un lugar seguro.

Configura tu entorno

  1. Crea una VM de Cloud TPU v6e con la API de Queued Resources. Para qwen2-7b-instruct, recomendamos usar una TPU v6e-1.

    export PROJECT_ID=YOUR_PROJECT_ID
export TPU_NAME=qwen2-7b-instruct-tutorial
export ZONE=us-east5-a
export QR_ID=qwen2-7b-instruct-qr

gcloud alpha compute tpus queued-resources create $QR_ID \
 --node-id $TPU_NAME \
 --project $PROJECT_ID \
 --zone $ZONE \
 --accelerator-type v6e-1 \
 --runtime-version v2-alpha-tpuv6e

  2. Verifica que tu VM de TPU esté lista.

    gcloud compute tpus queued-resources describe $QR_ID \
  --project $PROJECT_ID \
  --zone $ZONE

    Por ejemplo, cuando el estado es ACTIVE:

    name: projects/your-project-id/locations/your-zone/queuedResources/your-queued-resource-id
  state:
  state: ACTIVE
  tpu:
  nodeSpec:
  - node:
      acceleratorType: v6e-1
      bootDisk: {}
      networkConfig:
          enableExternalIps: true
      queuedResource: projects/your-project-number/locations/your-zone/queuedResources/your-queued-resource-id
      runtimeVersion: v2-alpha-tpuv6e
      schedulingConfig: {}
      serviceAccount: {}
      shieldedInstanceConfig: {}
      useTpuVm: true
      nodeId: your-node-id
      parent: projects/your-project-number/locations/your-zone

  3. Conéctate a la VM de TPU.

      gcloud compute tpus tpu-vm ssh $TPU_NAME \
    --project $PROJECT_ID \
    --zone $ZONE

Ejecuta vLLM con Qwen2-7B-instruct

  1. Establece tu token de Hugging Face.

      export HF_TOKEN="YOUR_HF_TOKEN"

  2. Dentro de la VM de TPU, ejecuta el contenedor de Docker de vLLM en modo desconectado y, luego, inicia el servidor de vLLM. Este comando usa un tamaño de memoria compartida de 10 GB.

    export DOCKER_URI="vllm/vllm-tpu:v0.18.0"
export CONTAINER_NAME="${USER}-vllm"
export MAX_MODEL_LEN=4096
export TP=1 # number of chips

sudo docker run -d --name "${CONTAINER_NAME}" \
    --privileged --net=host \
    -v /dev/shm:/dev/shm \
    --shm-size 10gb \
    -e "HF_HOME=/dev/shm" \
    -e "HF_TOKEN=${HF_TOKEN}" \
    -p 8000:8000 "${DOCKER_URI}" \
        vllm serve Qwen/Qwen2-7B-Instruct \
            --seed 42 \
            --gpu-memory-utilization 0.98 \
            --max-num-batched-tokens 1024 \
            --max-num-seqs 128 \
            --tensor-parallel-size $TP \
            --max-model-len $MAX_MODEL_LEN

  3. Verifica los registros del servidor para confirmar que se esté ejecutando.

    sudo docker logs -f "${CONTAINER_NAME}"

    Cuando el servidor de vLLM esté en ejecución, verás un resultado similar al siguiente. Después de que se muestre el resultado, presiona CTRL+C para volver a la terminal.

    (APIServer pid=7) INFO:     Started server process [7]
(APIServer pid=7) INFO:     Waiting for application startup.
(APIServer pid=7) INFO:     Application startup complete.

Envía una solicitud de inferencia

Una vez que el servidor de vLLM esté en ejecución, puedes enviar solicitudes a la API. Para obtener más información, consulta la documentación de referencia de la API de vLLM.

  1. Envía una solicitud de prueba al servidor con curl.

      sudo docker exec -ti "${CONTAINER_NAME}" \
    curl http://localhost:8000/v1/completions \
      -H "Content-Type: application/json" \
      -d '{
          "model": "Qwen/Qwen2-7B-Instruct",
          "prompt": "The future of AI is",
          "max_tokens": 200,
          "temperature": 0
        }'

La respuesta se devuelve en formato JSON.

Ejecuta una carga de trabajo de comparativa

Puedes ejecutar comparativas del servidor en ejecución desde tu segunda terminal.

  1. Dentro del contenedor, instala la biblioteca datasets.

    sudo docker exec -it "${CONTAINER_NAME}" pip install datasets

  2. Dentro del contenedor, ejecuta el comando vllm bench serve.

    sudo docker exec -it "${CONTAINER_NAME}" \
    vllm bench serve \
        --backend vllm \
        --model "Qwen/Qwen2-7B-Instruct"  \
        --dataset-name random \
        --num-prompts 1000 \
        --seed 100

Los resultados de la comparativa se ven de la siguiente manera:

============ Serving Benchmark Result ============
Successful requests:                     1000
Benchmark duration (s):                  45.35
Total input tokens:                      1024000
Total generated tokens:                  126848
Request throughput (req/s):              22.05
Output token throughput (tok/s):         2797.15
Peak output token throughput (tok/s):    4258.00
Peak concurrent requests:                1000.00
Total Token throughput (tok/s):          25377.57
---------------Time to First Token----------------
Mean TTFT (ms):                          21332.46
Median TTFT (ms):                        21330.37
P99 TTFT (ms):                           42436.47
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          37.36
Median TPOT (ms):                        38.56
P99 TPOT (ms):                           38.69
---------------Inter-token Latency----------------
Mean ITL (ms):                           37.35
Median ITL (ms):                         38.55
P99 ITL (ms):                            39.43
==================================================

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  1. En la terminal, escribe exit para desconectarte de la VM de TPU.

Borra tus recursos

Puedes borrar el proyecto, lo que borrará todos los recursos, o bien puedes conservar el proyecto y borrar los recursos.

Borra tu proyecto

Para borrar tu proyecto Google Cloud y todos los recursos asociados, ejecuta el siguiente comando:

    gcloud projects delete $PROJECT_ID

Borra recursos de TPU

Borra tus recursos de Cloud TPU. El siguiente comando borra la solicitud del recurso en cola y la VM de TPU con el parámetro --force.

  gcloud alpha compute tpus queued-resources delete $QR_ID \
    --project=$PROJECT_ID \
    --zone=$ZONE \
    --force

¿Qué sigue?