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

Qwen2-7B-Instruct mit vLLM auf TPUs bereitstellen

In dieser Anleitung wird das Modell Qwen/Qwen2-7B-Instruct mit dem vLLM TPU-Bereitstellungsframework auf einer v6e TPU-VM bereitgestellt.

Ziele

die Umgebung einrichten
vLLM mit Qwen2-7B-Instruct ausführen
eine Inferenzanfrage senden
eine Benchmark-Arbeitslast ausführen
bereinigen.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Hinweis

Bevor Sie diese Anleitung durcharbeiten, folgen Sie der Anleitung auf der Seite Cloud TPU-Umgebung einrichten. Dort werden die Schritte beschrieben, die zum Erstellen eines Google Cloud Projekts und zum Konfigurieren der Verwendung von Cloud TPU erforderlich sind. Sie können auch ein vorhandenes Google Cloud Projekt verwenden. In diesem Fall können Sie den Schritt zum Erstellen eines Google Cloud Projekts überspringen und mit Umgebung für die Verwendung von Cloud TPU einrichten beginnen.

Für diese Anleitung benötigen Sie ein Hugging Face-Zugriffstoken. Sie können sich bei Hugging Face für ein kostenloses Konto registrieren. Nachdem Sie ein Konto erstellt haben, generieren Sie ein Zugriffstoken:

Klicken Sie auf der Seite Welcome to Hugging Face (Willkommen bei Hugging Face) auf Ihren Kontoavatar und wählen Sie Access tokens (Zugriffstokens) aus.
Klicken Sie auf der Seite Access Tokens (Zugriffstokens) auf Create new token (Neues Token erstellen).
Wählen Sie den Tokentyp Read (Lesen) aus und geben Sie einen Namen für Ihr Token ein.
Ihr Zugriffstoken wird angezeigt. Speichern Sie das Token an einem sicheren Ort.

Umgebung einrichten

Erstellen Sie eine Cloud TPU v6e-VM mit der API für in die Warteschlange gestellte Ressourcen. Für qwen2-7b-instruct empfehlen wir die Verwendung einer v6e-1 TPU.

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

Prüfen Sie, ob Ihre TPU-VM bereit ist.

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

Beispiel: Wenn der Status ACTIVE lautet:

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

Stellen Sie eine Verbindung zur TPU-VM her.

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

vLLM mit Qwen2-7B-Instruct ausführen

Legen Sie Ihr Hugging Face-Token fest.
```
  export HF_TOKEN="YOUR_HF_TOKEN"
```

Führen Sie in der TPU-VM den vLLM-Docker-Container im getrennten Modus aus und starten Sie den vLLM-Server. Dieser Befehl verwendet eine Größe des gemeinsamen Arbeitsspeichers von 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

Prüfen Sie in den Serverlogs, ob er ausgeführt wird.

sudo docker logs -f "${CONTAINER_NAME}"

Wenn der vLLM-Server ausgeführt wird, sehen Sie eine Ausgabe, die der folgenden ähnelt. Drücken Sie nach der Ausgabe CTRL+C, um zum Terminal zurückzukehren.

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

Inferenzanfrage senden

Sobald der vLLM-Server ausgeführt wird, können Sie Anfragen an die API senden. Weitere Informationen finden Sie in der vLLM-API-Referenzdokumentation.

Senden Sie mit curl eine Testanfrage an den Server.

  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
        }'

Die Antwort wird im JSON-Format zurückgegeben.

Benchmark-Arbeitslast ausführen

Sie können Benchmarks für den ausgeführten Server über Ihr zweites Terminal ausführen.

Installieren Sie im Container die Bibliothek datasets.

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

Führen Sie im Container den Befehl vllm bench serve aus.

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

Die Benchmark-Ergebnisse sehen so aus:

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

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Geben Sie im Terminal exit ein, um die Verbindung zur TPU-VM zu trennen.

Ressourcen löschen

Sie können das Projekt löschen, wodurch alle Ressourcen gelöscht werden, oder Sie können das Projekt beibehalten und die Ressourcen löschen.

Projekt löschen

Führen Sie Folgendes aus, um Ihr Google Cloud Projekt und alle zugehörigen Ressourcen zu löschen:

    gcloud projects delete $PROJECT_ID

TPU-Ressourcen löschen

Löschen Sie Ihre Cloud TPU-Ressourcen. Mit dem folgenden Befehl werden sowohl die Anfrage für in die Warteschlange gestellte Ressourcen als auch die TPU-VM mit dem Parameter --force gelöscht.

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

Nächste Schritte

Weitere Informationen zu vLLM auf Cloud TPU
Weitere Informationen zu Cloud TPU.