Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Diffuser Qwen2-7B-Instruct avec vLLM sur des TPU

Ce tutoriel met en service le modèle Qwen/Qwen2-7B-Instruct à l'aide du framework de mise en service vLLM TPU sur une VM TPU v6e.

Objectifs

Configurer votre environnement
Exécuter vLLM avec Qwen2-7B-Instruct
Envoyer une requête d'inférence
Exécuter une charge de travail de benchmark
Effectuer un nettoyage

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

Avant de suivre ce tutoriel, suivez les instructions de la page Configurer l'environnement Cloud TPU. Ces instructions vous guident tout au long des étapes nécessaires pour créer un Google Cloud projet et le configurer afin d'utiliser Cloud TPU. Vous pouvez également utiliser un projet existant Google Cloud projet. Si vous le souhaitez, vous pouvez ignorer l'étape de création d'un Google Cloud projet et commencer par Configurer votre environnement pour utiliser Cloud TPU.

Vous avez besoin d'un jeton d'accès Hugging Face pour suivre ce tutoriel. Vous pouvez créer un compte sans frais sur Hugging Face. Une fois que vous avez un compte, générez un jeton d'accès :

Sur la page "Welcome to Hugging Face" (Bienvenue sur Hugging Face), cliquez sur l'avatar de votre compte, puis sélectionnez Access tokens (Jetons d'accès).
Sur la page Access Tokens (Jetons d'accès), cliquez sur Create new token (Créer un jeton).
Sélectionnez le type de jeton Read (Lecture), puis saisissez un nom pour votre jeton.
Votre jeton d'accès s'affiche. Enregistrez-le dans un endroit sûr.

Configurer votre environnement

Créez une VM Cloud TPU v6e à l'aide de l'API de ressources en file d'attente. Pour qwen2-7b-instruct, nous vous recommandons d'utiliser un 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

Vérifiez que votre VM TPU est prête.

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

Par exemple, lorsque l'état est 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

Connectez-vous à la VM TPU.

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

Exécuter vLLM avec Qwen2-7B-instruct

Définissez votre jeton Hugging Face.
```
  export HF_TOKEN="YOUR_HF_TOKEN"
```

Dans la VM TPU, exécutez le conteneur Docker vLLM en mode détaché et démarrez le serveur vLLM. Cette commande utilise une taille de mémoire partagée de 10 Go.

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

Consultez les journaux du serveur pour vérifier qu'il est en cours d'exécution.
```
sudo docker logs -f "${CONTAINER_NAME}"
```
Lorsque le serveur vLLM est en cours d'exécution, une sortie semblable à la suivante s'affiche. Une fois la sortie affichée, appuyez sur CTRL+C pour revenir au terminal.
```
(APIServer pid=7) INFO:     Started server process [7]
(APIServer pid=7) INFO:     Waiting for application startup.
(APIServer pid=7) INFO:     Application startup complete.
```

Envoyer une requête d'inférence

Une fois le serveur vLLM en cours d'exécution, vous pouvez envoyer des requêtes à l'API. Pour en savoir plus, consultez la documentation de référence de l'API vLLM.

Envoyez une requête de test au serveur à l'aide de 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 réponse est renvoyée au format JSON.

Exécuter une charge de travail de benchmark

Vous pouvez exécuter des benchmarks sur le serveur en cours d'exécution à partir de votre deuxième terminal.

Dans le conteneur, installez la bibliothèque datasets.

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

Dans le conteneur, exécutez la commande 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

Les résultats du benchmark se présentent comme suit :

============ 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
==================================================

Libérer de l'espace

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Dans votre terminal, saisissez exit pour vous déconnecter de la VM TPU.

Supprimer vos ressources

Vous pouvez supprimer le projet, ce qui supprimera toutes les ressources, ou conserver le projet et supprimer les ressources.

Supprimer votre projet

Pour supprimer votre Google Cloud projet et toutes les ressources associées, exécutez la commande suivante :

    gcloud projects delete $PROJECT_ID

Supprimer les ressources TPU

Supprimez vos ressources Cloud TPU. La commande suivante supprime à la fois la requête de ressource en file d'attente et la VM TPU à l'aide du paramètre --force.

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

Étape suivante

En savoir plus sur vLLM sur Cloud TPU.
En savoir plus sur Cloud TPU.