Questa pagina è stata tradotta dall'API Cloud Translation.

Interruzione vLLM su TPU v6e

Questo tutorial mostra come eseguire l'inferenza vLLM sulle TPU v6e. Inoltre, mostra come eseguire lo script di benchmark per il modello Meta Llama-3.1 8B.

Per iniziare a utilizzare vLLM sulle TPU v6e, consulta la guida rapida a vLLM.

Se utilizzi GKE, consulta anche il tutorial su GKE.

Prima di iniziare

Devi firmare il contratto di consenso per utilizzare la famiglia di modelli Llama3 nel repo HuggingFace. Vai alla pagina https://huggingface.co/meta-llama/Llama-3.1-8B, compila il contratto di consenso e attendi l'approvazione.

Preparati a eseguire il provisioning di una TPU v6e con 4 chip:

Accedi al tuo Account Google. Se non l'hai ancora fatto, registrati per creare un nuovo account.
Nella console Google Cloud, seleziona o crea un Google Cloud progetto dalla pagina del selettore di progetti.
Attiva la fatturazione per il tuo Google Cloud progetto. La fatturazione è obbligatoria per tutto l' Google Cloud utilizzo.
Installa i componenti gcloud alpha.
Esegui il seguente comando per installare la versione più recente dei componenti gcloud.
```
gcloud components update
```
Abilita l'API TPU tramite il seguente comando gcloud utilizzando Cloud Shell. Puoi anche attivarlo dalla console Google Cloud.
```
gcloud services enable tpu.googleapis.com
```

Crea un'identità di servizio per la VM TPU.

gcloud alpha compute tpus tpu-vm service-identity create --zone=ZONE

Crea un account di servizio TPU e concedi l'accesso ai Google Cloud servizi.

Gli account di servizio consentono al Google Cloud servizio TPU di accedere ad altri Google Cloud servizi. È consigliato un account di servizio gestito dall'utente. Segui queste guide per creare e concedere i ruoli. Sono necessari i seguenti ruoli:
- Amministratore TPU: necessario per creare una TPU
- Amministratore dello spazio di archiviazione: necessario per accedere a Cloud Storage
- Scrittore di log: necessario per scrivere i log con l'API Logging
- Monitoring Metric Writer: necessario per scrivere le metriche in Cloud Monitoring
Esegui l'autenticazione con Google Cloud e configura il progetto e la zona predefiniti per Google Cloud CLI.
```
gcloud auth login
gcloud config set project PROJECT_ID
gcloud config set compute/zone ZONE
```

Capacità sicura

Contatta il team di vendita o dedicato all'account Cloud TPU per richiedere una quota TPU e per eventuali domande sulla capacità.

Esegui il provisioning dell'ambiente Cloud TPU

Puoi eseguire il provisioning delle TPU v6e con GKE, con GKE e XPK, o come risorse in coda.

Prerequisiti

Verifica che il tuo progetto disponga di una quota TPUS_PER_TPU_FAMILY sufficiente, che specifica il numero massimo di chip a cui puoi accedere all'interno del progettoGoogle Cloud .
Questo tutorial è stato testato con la seguente configurazione:
- Python 3.10 or later
- Versioni software Nightly:
  - a notte JAX 0.4.32.dev20240912
  - nightly LibTPU 0.1.dev20240912+nightly
- Versioni software stabili:
  - JAX + libreria JAX di v0.4.35
Verifica che il tuo progetto disponga di una quota TPU sufficiente per:
- Quota VM TPU
- Quota di indirizzi IP
- Quota Hyperdisk bilanciata
Autorizzazioni del progetto per gli utenti
- Se utilizzi GKE con XPK, consulta Autorizzazioni di Cloud Console per l'account utente o di servizio per conoscere le autorizzazioni necessarie per eseguire XPK.

Provisiona una TPU v6e

   gcloud alpha compute tpus queued-resources create QUEUED_RESOURCE_ID \
      --node-id TPU_NAME \
       --project PROJECT_ID \
       --zone ZONE \
       --accelerator-type v6e-4 \
       --runtime-version v2-alpha-tpuv6e \
       --service-account SERVICE_ACCOUNT

Descrizioni dei flag dei comandi

Variabile	Descrizione
NODE_ID	L'ID assegnato dall'utente della TPU creata quando viene allocata la richiesta di risorsa in coda.
PROJECT_ID	Google Cloud nome progetto. Utilizza un progetto esistente o creane uno nuovo.>
ZONA	Consulta il documento Regioni e zone TPU per le zone supportate.
ACCELERATOR_TYPE	Consulta la documentazione relativa ai tipi di acceleratore per conoscere i tipi di acceleratore supportati.
RUNTIME_VERSION	`v2-alpha-tpuv6e`
SERVICE_ACCOUNT	Si tratta dell'indirizzo email del tuo account di servizio che puoi trovare in console Google Cloud -> IAM -> Account di servizio Ad esempio: tpu-service-account@<your_project_ID>.iam.gserviceaccount.com.com

Utilizza i comandi list o describe per eseguire query sullo stato della risorsa in coda.

   gcloud alpha compute tpus queued-resources describe ${QUEUED_RESOURCE_ID}  \
      --project ${PROJECT_ID} --zone ${ZONE}

Per un elenco completo degli stati delle richieste di risorse in coda, consulta la documentazione relativa alle risorse in coda.

Connettiti alla TPU tramite SSH

  gcloud compute tpus tpu-vm ssh TPU_NAME

Installa le dipendenze

Crea una directory per Miniconda:
```
mkdir -p ~/miniconda3
```

Scarica lo script di installazione di Miniconda:

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh

Installa Miniconda:

bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3

Rimuovi lo script di installazione di Miniconda:
```
rm -rf ~/miniconda3/miniconda.sh
```

Aggiungi Miniconda alla variabile PATH:

export PATH="$HOME/miniconda3/bin:$PATH"

Ricarica ~/.bashrc per applicare le modifiche alla variabile PATH:
```
source ~/.bashrc
```
Crea un ambiente Conda:

Nota: devi eseguire conda init e ricaricare la shell prima di eseguire conda activate vllm se è la prima volta che esegui conda.
```
conda create -n vllm python=3.10 -y
conda activate vllm
```

Clona il repository vLLM e vai alla directory vLLM:

git clone https://github.com/vllm-project/vllm.git && cd vllm

Ripulisci i pacchetti torch e torch-xla esistenti:
```
pip uninstall torch torch-xla -y
```

Installa altre dipendenze di compilazione:

pip install -r requirements-tpu.txt
VLLM_TARGET_DEVICE="tpu" python setup.py develop
sudo apt-get install libopenblas-base libopenmpi-dev libomp-dev

Ottieni l'accesso al modello

Genera un nuovo token Abbracciamento se non ne hai già uno:

Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
Seleziona Nuovo token.
Specifica un nome a tua scelta e un ruolo con almeno Read autorizzazioni.
Seleziona Genera un token.

Copia il token generato negli appunti, impostalo come variabile di ambiente e autenticati con huggingface-cli:

export TOKEN=YOUR_TOKEN
git config --global credential.helper store
huggingface-cli login --token $TOKEN

Scaricare i dati di benchmarking

Crea una directory /data e scarica il set di dati ShareGPT da Hugging Face.

mkdir ~/data && cd ~/data
wget https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/resolve/main/ShareGPT_V3_unfiltered_cleaned_split.json

Avvia il server vLLM

Il seguente comando scarica i pesi del modello da Hugging Face Model Hub nella directory /tmp della VM TPU, precompila una serie di forme di input e scrive la compilazione del modello in ~/.cache/vllm/xla_cache.

Per maggiori dettagli, consulta la documentazione di vLLM.

   cd ~/vllm
   vllm serve "meta-llama/Meta-Llama-3.1-8B" --download_dir /tmp --num-scheduler-steps 4 --swap-space 16 --disable-log-requests --tensor_parallel_size=4 --max-model-len=2048 &> serve.log &

Eseguire benchmark vLLM

Esegui lo script di benchmarking vLLM:

   python benchmarks/benchmark_serving.py \
       --backend vllm \
       --model "meta-llama/Meta-Llama-3.1-8B"  \
       --dataset-name sharegpt \
       --dataset-path ~/data/ShareGPT_V3_unfiltered_cleaned_split.json  \
       --num-prompts 1000

Esegui la pulizia

Elimina la TPU:

gcloud compute tpus queued-resources delete QUEUED_RESOURCE_ID \
    --project PROJECT_ID \
    --zone ZONE \
    --force \
    --async