Questo tutorial mostra come pubblicare un modello linguistico di grandi dimensioni (LLM) utilizzando le unità di elaborazione tensoriale (TPU) su Google Kubernetes Engine (GKE) con il componente aggiuntivo Ray Operator e il framework di pubblicazione vLLM.
In questo tutorial puoi pubblicare modelli LLM su TPU v5e o TPU Trillium (v6e) come segue:
- Istruzioni Llama 3 8B su una TPU v5e a un solo host.
- Mistral 7B instruct v0.3 su una TPU v5e con un solo host.
- Llava 1.5 13b hf su una TPU v5e a un solo host.
- Llama 3.1 70B su una TPU Trillium (v6e) a un solo host.
Questa guida è rivolta ai clienti di AI generativa, agli utenti GKE nuovi ed esistenti, agli ingegneri ML, agli ingegneri MLOps (DevOps) o agli amministratori della piattaforma interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per pubblicare modelli utilizzando Ray su TPU con vLLM.
Sfondo
Questa sezione descrive le tecnologie chiave utilizzate in questa guida.
Servizio Kubernetes gestito GKE
Google Cloud offre una vasta gamma di servizi, tra cui GKE, che è adatto per il deployment e la gestione dei carichi di lavoro di AI/ML. GKE è un servizio Kubernetes gestito che semplifica il deployment, la scalabilità e la gestione delle applicazioni containerizzate. GKE fornisce l'infrastruttura necessaria, tra cui risorse scalabili, calcolo distribuito e reti efficienti, per gestire le richieste di calcolo degli LLM.
Per saperne di più sui concetti chiave di Kubernetes, consulta Inizia a conoscere Kubernetes. Per scoprire di più su GKE e su come ti aiuta a scalare, automatizzare e gestire Kubernetes, consulta la panoramica di GKE.
Operatore Ray
Il componente aggiuntivo Ray Operator su GKE fornisce una piattaforma AI/ML end-to-end per l'erogazione, l'addestramento e la messa a punto dei carichi di lavoro di machine learning. In questo tutorial, utilizzerai Ray Serve, un framework in Ray, per pubblicare i modelli LLM più diffusi di Hugging Face.
TPU
Le TPU sono circuiti integrati per applicazioni specifiche (ASIC), sviluppati da Google, utilizzati per accelerare i modelli di machine learning e IA creati utilizzando framework come TensorFlow, PyTorch e JAX.
Questo tutorial illustra la pubblicazione di modelli LLM su nodi TPU v5e o TPU Trillium (v6e) con topologie TPU configurate in base ai requisiti di ciascun modello per la pubblicazione di prompt con bassa latenza.
vLLM
vLLM è un framework di pubblicazione di modelli LLM open source altamente ottimizzato che può aumentare il throughput di pubblicazione sulle TPU, con funzionalità come:
- Implementazione ottimizzata del transformer con PagedAttention
- Raggruppamento continuo per migliorare il throughput complessivo della pubblicazione
- Parallelismo di tensori e pubblicazione distribuita su più GPU
Per saperne di più, consulta la documentazione di vLLM.
Obiettivi
Questo tutorial illustra i seguenti passaggi:
- Crea un cluster GKE con un pool di nodi TPU.
- Esegui il deployment di una risorsa personalizzata RayCluster con uno slice TPU a un solo host. GKE esegue il deployment della risorsa personalizzata RayCluster come pod Kubernetes.
- Gestisci un LLM.
- Interagire con i modelli.
Facoltativamente, puoi configurare le seguenti risorse e tecniche di pubblicazione dei modelli supportate dal framework Ray Serve:
- Esegui il deployment di una risorsa personalizzata RayService.
- Componi più modelli con la composizione dei modelli.
Prima di iniziare
Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:
- Attiva l'API Google Kubernetes Engine. Attiva l'API Google Kubernetes Engine
- Se vuoi utilizzare Google Cloud CLI per questa attività,
installa e poi
inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo
gcloud components update.
- Crea un account AbbracciAmore, se non ne hai già uno.
- Assicurati di avere un token Hugging Face.
- Assicurati di avere accesso al modello Hugging Face che vuoi utilizzare. In genere, ottieni questo accesso firmando un contratto e richiedendo l'accesso al proprietario del modello nella pagina del modello Hugging Face.
prepara l'ambiente
Assicurati di disporre di una quota sufficiente nel tuo Google Cloud progetto per una TPU v5e a host singolo o una TPU Trillium (v6e) a host singolo. Per gestire la tua quota, consulta la pagina relativa alle quote TPU.
Nella console Google Cloud, avvia un'istanza Cloud Shell:
Apri Cloud ShellClona il repository di esempio:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git cd kubernetes-engine-samplesVai alla directory di lavoro:
cd ai-ml/gke-ray/rayserve/llmImposta le variabili di ambiente predefinite per la creazione del cluster GKE:
Llama-3-8B-Instruct
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="meta-llama/Meta-Llama-3-8B-Instruct" export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcSostituisci quanto segue:
HUGGING_FACE_TOKEN: il tuo token di accesso a Hugging Face.REGION: la regione in cui hai la quota TPU. Assicurati che la versione TPU che vuoi utilizzare sia disponibile in questa regione. Per saperne di più, consulta la sezione Disponibilità delle TPU in GKE.ZONE: la zona con la quota TPU disponibile.VLLM_IMAGE: l'immagine TPU vLLM. Puoi utilizzare l'immagine pubblicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o creare la tua immagine TPU.
Mistral-7B
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="mistralai/Mistral-7B-Instruct-v0.3" export TOKENIZER_MODE=mistral export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcSostituisci quanto segue:
HUGGING_FACE_TOKEN: il tuo token di accesso a Hugging Face.REGION: la regione in cui hai la quota TPU. Assicurati che la versione TPU che vuoi utilizzare sia disponibile in questa regione. Per saperne di più, consulta la sezione Disponibilità delle TPU in GKE.ZONE: la zona con la quota TPU disponibile.VLLM_IMAGE: l'immagine TPU vLLM. Puoi utilizzare l'immagine pubblicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o creare la tua immagine TPU.
Llava-1.5-13b-hf
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="llava-hf/llava-1.5-13b-hf" export DTYPE=bfloat16 export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcSostituisci quanto segue:
HUGGING_FACE_TOKEN: il tuo token di accesso a Hugging Face.REGION: la regione in cui hai la quota TPU. Assicurati che la versione TPU che vuoi utilizzare sia disponibile in questa regione. Per saperne di più, consulta la sezione Disponibilità delle TPU in GKE.ZONE: la zona con la quota TPU disponibile.VLLM_IMAGE: l'immagine TPU vLLM. Puoi utilizzare l'immagine pubblicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o creare la tua immagine TPU.
Llama 3.1 70B
export PROJECT_ID=$(gcloud config get project) export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") export CLUSTER_NAME=vllm-tpu export COMPUTE_REGION=REGION export COMPUTE_ZONE=ZONE export HF_TOKEN=HUGGING_FACE_TOKEN export GSBUCKET=vllm-tpu-bucket export KSA_NAME=vllm-sa export NAMESPACE=default export MODEL_ID="meta-llama/Llama-3.1-70B" export MAX_MODEL_LEN=8192 export VLLM_IMAGE=docker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1 export SERVICE_NAME=vllm-tpu-head-svcSostituisci quanto segue:
HUGGING_FACE_TOKEN: il tuo token di accesso a Hugging Face.REGION: la regione in cui hai la quota TPU. Assicurati che la versione TPU che vuoi utilizzare sia disponibile in questa regione. Per saperne di più, consulta la sezione Disponibilità delle TPU in GKE.ZONE: la zona con la quota TPU disponibile.VLLM_IMAGE: l'immagine TPU vLLM. Puoi utilizzare l'immagine pubblicadocker.io/vllm/vllm-tpu:866fa4550d572f4ff3521ccf503e0df2e76591a1o creare la tua immagine TPU.
Estrai l'immagine del container vLLM:
docker pull ${VLLM_IMAGE}
Crea un cluster
Puoi pubblicare un LLM su TPU con Ray in un cluster GKE Autopilot o Standard utilizzando il componente aggiuntivo Ray Operator.
Utilizza un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi carichi di lavoro, consulta Scegliere una modalità operativa GKE.
Utilizza Cloud Shell per creare un cluster Autopilot o standard:
Autopilot
Crea un cluster GKE Autopilot con il componente aggiuntivo Ray Operator abilitato:
gcloud container clusters create-auto ${CLUSTER_NAME} \ --enable-ray-operator \ --release-channel=rapid \ --location=${COMPUTE_REGION}
Standard
Crea un cluster standard con il componente aggiuntivo Ray Operator abilitato:
gcloud container clusters create ${CLUSTER_NAME} \ --release-channel=rapid \ --location=${COMPUTE_ZONE} \ --workload-pool=${PROJECT_ID}.svc.id.goog \ --machine-type="n1-standard-4" \ --addons=RayOperator,GcsFuseCsiDriverCrea un pool di nodi di sezioni TPU a un solo host:
Llama-3-8B-Instruct
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-8t \ --num-nodes=1GKE crea un pool di nodi TPU v5e con un tipo di macchina
ct5lp-hightpu-8t.Mistral-7B
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-8t \ --num-nodes=1GKE crea un pool di nodi TPU v5e con un tipo di macchina
ct5lp-hightpu-8t.Llava-1.5-13b-hf
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-8t \ --num-nodes=1GKE crea un pool di nodi TPU v5e con un tipo di macchina
ct5lp-hightpu-8t.Llama 3.1 70B
gcloud container node-pools create tpu-1 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=ct6e-standard-8t \ --num-nodes=1GKE crea un pool di nodi TPU v6e con un tipo di macchina
ct6e-standard-8t.
Configura kubectl per comunicare con il cluster
Per configurare kubectl in modo che comunichi con il cluster, esegui il seguente comando:
Autopilot
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_REGION}
Standard
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${COMPUTE_ZONE}
Crea un secret di Kubernetes per le credenziali di Hugging Face
Per creare un secret di Kubernetes contenente il token di Hugging Face, esegui il seguente comando:
kubectl create secret generic hf-secret \
--from-literal=hf_api_token=${HF_TOKEN} \
--dry-run=client -o yaml | kubectl --namespace ${NAMESPACE} apply -f -
Crea un bucket Cloud Storage
Per accelerare il tempo di avvio del deployment di vLLM e ridurre al minimo lo spazio su disco richiesto per nodo, utilizza il driver CSI di Cloud Storage FUSE per montare il modello scaricato e la cache di compilazione sui nodi Ray.
In Cloud Shell, esegui questo comando:
gcloud storage buckets create gs://${GSBUCKET} \
--uniform-bucket-level-access
Questo comando crea un bucket Cloud Storage per archiviare i file del modello che hai scaricato da Hugging Face.
Configura un account di servizio Kubernetes per accedere al bucket
Crea l'account di servizio Kubernetes:
kubectl create serviceaccount ${KSA_NAME} \ --namespace ${NAMESPACE}Concedi a Kubernetes ServiceAccount l'accesso in lettura e scrittura al bucket Cloud Storage:
gcloud storage buckets add-iam-policy-binding gs://${GSBUCKET} \ --member "principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/${NAMESPACE}/sa/${KSA_NAME}" \ --role "roles/storage.objectUser"GKE crea le seguenti risorse per l'LLM:
- Un bucket Cloud Storage per archiviare il modello scaricato e la cache di compilazione. Un driver CSI di Cloud Storage FUSE legge i contenuti del bucket.
- Volumi con la memorizzazione nella cache dei file abilitata e la funzionalità di download parallelo di Cloud Storage FUSE.
Best practice: Utilizza una cache di file basata su
tmpfsoHyperdisk / Persistent Diska seconda delle dimensioni previste dei contenuti del modello, ad esempio i file di peso. In questo tutorial utilizzi la cache dei file Cloud Storage FUSE basata su RAM.
Esegui il deployment di una risorsa personalizzata RayCluster
Esegui il deployment di una risorsa personalizzata RayCluster, che in genere è costituita da un pod di sistema e da più pod worker.
Llama-3-8B-Instruct
Crea la risorsa personalizzata RayCluster per eseguire il deployment del modello ottimizzato per le istruzioni Llama 3 8B completando i seguenti passaggi:
Controlla il file manifest
ray-cluster.tpu-v5e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.
GKE crea una risorsa personalizzata RayCluster con un workergroup contenente un singolo host TPU v5e in una topologia 2x4.
Mistral-7B
Crea la risorsa personalizzata RayCluster per eseguire il deployment del modello Mistral-7B completando i seguenti passaggi:
Controlla il file manifest
ray-cluster.tpu-v5e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.
GKE crea una risorsa personalizzata RayCluster con un workergroup contenente un singolo host TPU v5e in una topologia 2x4.
Llava-1.5-13b-hf
Crea la risorsa personalizzata RayCluster per eseguire il deployment del modello Llava-1.5-13b-hf completando i seguenti passaggi:
Controlla il file manifest
ray-cluster.tpu-v5e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-cluster.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.
GKE crea una risorsa personalizzata RayCluster con un workergroup
che contiene un singolo host TPU v5e in una topologia 2x4.
Llama 3.1 70B
Crea la risorsa personalizzata RayCluster per eseguire il deployment del modello Llama 3.1 70B completando i seguenti passaggi:
Controlla il file manifest
ray-cluster.tpu-v6e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-cluster.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.
GKE crea una risorsa personalizzata RayCluster con un workergroup
che contiene un singolo host TPU v6e in una topologia 2x4.
Connettiti alla risorsa personalizzata RayCluster
Dopo aver creato la risorsa personalizzata RayCluster, puoi connetterti alla risorsa RayCluster e iniziare a pubblicare il modello.
Verifica che GKE abbia creato il servizio RayCluster:
kubectl --namespace ${NAMESPACE} get raycluster/vllm-tpu \ --output wideL'output è simile al seguente:
NAME DESIRED WORKERS AVAILABLE WORKERS CPUS MEMORY GPUS TPUS STATUS AGE HEAD POD IP HEAD SERVICE IP vllm-tpu 1 1 ### ###G 0 8 ready ### ###.###.###.### ###.###.###.###Attendi finché
STATUSnon èreadye le colonneHEAD POD IPeHEAD SERVICE IPnon contengono un indirizzo IP.Stabilisci sessioni
port-forwardingcon la testa Ray:pkill -f "kubectl .* port-forward .* 8265:8265" pkill -f "kubectl .* port-forward .* 10001:10001" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8265:8265 2>&1 >/dev/null & kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 10001:10001 2>&1 >/dev/null &Verifica che il client Ray possa connettersi alla risorsa personalizzata RayCluster remota:
docker run --net=host -it ${VLLM_IMAGE} \ ray list nodes --address http://localhost:8265L'output è simile al seguente:
======== List: YYYY-MM-DD HH:MM:SS.NNNNNN ======== Stats: ------------------------------ Total: 2 Table: ------------------------------ NODE_ID NODE_IP IS_HEAD_NODE STATE STATE_MESSAGE NODE_NAME RESOURCES_TOTAL LABELS 0 XXXXXXXXXX ###.###.###.### True ALIVE ###.###.###.### CPU: 2.0 ray.io/node_id: XXXXXXXXXX memory: #.### GiB node:###.###.###.###: 1.0 node:__internal_head__: 1.0 object_store_memory: #.### GiB 1 XXXXXXXXXX ###.###.###.### False ALIVE ###.###.###.### CPU: 100.0 ray.io/node_id: XXXXXXXXXX TPU: 8.0 TPU-v#e-8-head: 1.0 accelerator_type:TPU-V#E: 1.0 memory: ###.### GiB node:###.###.###.###: 1.0 object_store_memory: ##.### GiB tpu-group-0: 1.0
Esegui il deployment del modello con vLLM
Esegui il deployment del modello con vLLM:
Llama-3-8B-Instruct
docker run \
--env MODEL_ID=${MODEL_ID} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"MODEL_ID": "meta-llama/Meta-Llama-3-8B-Instruct"}}'
Mistral-7B
docker run \
--env MODEL_ID=${MODEL_ID} \
--env TOKENIZER_MODE=${TOKENIZER_MODE} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"MODEL_ID": "mistralai/Mistral-7B-Instruct-v0.3", "TOKENIZER_MODE": "mistral"}}'
Llava-1.5-13b-hf
docker run \
--env DTYPE=${DTYPE} \
--env MODEL_ID=${MODEL_ID} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"DTYPE": "bfloat16", "MODEL_ID": "llava-hf/llava-1.5-13b-hf"}}'
Llama 3.1 70B
docker run \
--env MAX_MODEL_LEN=${MAX_MODEL_LEN} \
--env MODEL_ID=${MODEL_ID} \
--net=host \
--volume=./tpu:/workspace/vllm/tpu \
-it \
${VLLM_IMAGE} \
serve run serve_tpu:model \
--address=ray://localhost:10001 \
--app-dir=./tpu \
--runtime-env-json='{"env_vars": {"MAX_MODEL_LEN": "8192", "MODEL_ID": "meta-llama/Meta-Llama-3.1-70B"}}'
Visualizzare la dashboard di Ray
Puoi visualizzare il deployment di Ray Serve e i log pertinenti dalla dashboard di Ray.
- Fai clic sul pulsante
Anteprima web, che si trova in alto a destra nella barra delle app di Cloud Shell. - Fai clic su Cambia porta e imposta il numero di porta su
8265. - Fai clic su Modifica e anteprima.
- Nella dashboard di Ray, fai clic sulla scheda Pubblica.
Una volta che il deployment di Serve ha uno stato HEALTHY, il modello è pronto per iniziare a elaborare gli input.
Pubblica il modello
Questa guida mette in evidenza i modelli che supportano la generazione di testo, una tecnica che consente di creare contenuti di testo da un prompt.
Llama-3-8B-Instruct
Configura il port forwarding sul server:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Invia un prompt all'endpoint Serve:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Mistral-7B
Configura il port forwarding sul server:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Invia un prompt all'endpoint Serve:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Llava-1.5-13b-hf
Configura il port forwarding sul server:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Invia un prompt all'endpoint Serve:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Llama 3.1 70B
Configura il port forwarding sul server:
pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8000:8000 2>&1 >/dev/null &Invia un prompt all'endpoint Serve:
curl -X POST http://localhost:8000/v1/generate -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'
Configurazione aggiuntiva
Facoltativamente, puoi configurare le seguenti risorse e tecniche di pubblicazione dei modelli supportate dal framework Ray Serve:
- Esegui il deployment di una risorsa personalizzata RayService. Nei passaggi precedenti di questo tutorial, utilizzi RayCluster anziché RayService. Consigliamo RayService per gli ambienti di produzione.
- Combina più modelli con la composizione dei modelli. Configura il multiplexing e la composizione dei modelli supportati dal framework Ray Serve. La composizione del modello ti consente di collegare input e output su più LLM e di scalare i modelli come singola applicazione.
- Crea ed esegui il deployment della tua immagine TPU. Ti consigliamo questa opzione se hai bisogno di un controllo più granulare sui contenuti dell'immagine Docker.
Esegui il deployment di un RayService
Puoi eseguire il deployment degli stessi modelli di questo tutorial utilizzando una risorsa personalizzata RayService.
Elimina la risorsa personalizzata RayCluster che hai creato in questo tutorial:
kubectl --namespace ${NAMESPACE} delete raycluster/vllm-tpuCrea la risorsa personalizzata RayService per eseguire il deployment di un modello:
Llama-3-8B-Instruct
Controlla il file manifest
ray-service.tpu-v5e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.GKE crea un RayService con un
workergroupcontenente un singolo host TPU v5e in una topologia2x4.
Mistral-7B
Controlla il file manifest
ray-service.tpu-v5e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.GKE crea un RayService con un
workergroupcontenente un singolo host TPU v5e in una topologia2x4.
Llava-1.5-13b-hf
Controlla il file manifest
ray-service.tpu-v5e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.GKE crea un RayService con un
workergroupcontenente un singolo host TPU v5e in una topologia2x4.
Llama 3.1 70B
Controlla il file manifest
ray-service.tpu-v6e-singlehost.yaml:Applica il manifest:
envsubst < tpu/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -Il comando
envsubstsostituisce le variabili di ambiente nel manifest.
GKE crea una risorsa personalizzata RayCluster in cui viene eseguita il deployment dell'applicazione Ray Serve e viene creata la risorsa personalizzata RayService.
Verifica lo stato della risorsa RayService:
kubectl --namespace ${NAMESPACE} get rayservices/vllm-tpuAttendi che lo stato del servizio diventi
Running:NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 1Recupera il nome del servizio principale RayCluster:
SERVICE_NAME=$(kubectl --namespace=${NAMESPACE} get rayservices/vllm-tpu \ --template={{.status.activeServiceStatus.rayClusterStatus.head.serviceName}})Stabilisci sessioni
port-forwardingcon il Ray Head per visualizzare la dashboard di Ray:pkill -f "kubectl .* port-forward .* 8265:8265" kubectl --namespace ${NAMESPACE} port-forward service/${SERVICE_NAME} 8265:8265 2>&1 >/dev/null &Ripulisci la risorsa RayService:
kubectl --namespace ${NAMESPACE} delete rayservice/vllm-tpu
Componi più modelli con la composizione del modello
La composizione di modelli è una tecnica per comporre più modelli in un'unica applicazione.
In questa sezione utilizzi un cluster GKE per comporre due modelli, Llama 3 8B IT e Gemma 7B IT, in un'unica applicazione:
- Il primo modello è il modello di assistente che risponde alle domande poste nel prompt.
- Il secondo modello è il modello di riassunto. L'output del modello di assistente viene collegato all'input del modello di riassunto. Il risultato finale è la versione riassunta della risposta del modello dell'assistente.
Configura l'ambiente:
export ASSIST_MODEL_ID=meta-llama/Meta-Llama-3-8B-Instruct export SUMMARIZER_MODEL_ID=google/gemma-7b-itPer i cluster standard, crea un altro pool di nodi con sezione TPU a un solo host:
gcloud container node-pools create tpu-2 \ --location=${COMPUTE_ZONE} \ --cluster=${CLUSTER_NAME} \ --machine-type=MACHINE_TYPE \ --num-nodes=1Sostituisci
MACHINE_TYPEcon uno dei seguenti tipi di macchine:ct5lp-hightpu-8tper eseguire il provisioning di TPU v5e.ct6e-standard-8tper eseguire il provisioning di TPU v6e.
I cluster Autopilot eseguono automaticamente il provisioning dei nodi richiesti.
Esegui il deployment della risorsa RayService in base alla versione della TPU che vuoi utilizzare:
TPU v5e
Controlla il file manifest
ray-service.tpu-v5e-singlehost.yaml:Applica il manifest:
envsubst < model-composition/ray-service.tpu-v5e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
TPU v6e
Controlla il file manifest
ray-service.tpu-v6e-singlehost.yaml:Applica il manifest:
envsubst < model-composition/ray-service.tpu-v6e-singlehost.yaml | kubectl --namespace ${NAMESPACE} apply -f -
Attendi che lo stato della risorsa RayService cambi in
Running:kubectl --namespace ${NAMESPACE} get rayservice/vllm-tpuL'output è simile al seguente:
NAME SERVICE STATUS NUM SERVE ENDPOINTS vllm-tpu Running 2In questo output, lo stato
RUNNINGindica che la risorsa RayService è pronta.Verifica che GKE abbia creato il servizio per l'applicazione Ray Serve:
kubectl --namespace ${NAMESPACE} get service/vllm-tpu-serve-svcL'output è simile al seguente:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE vllm-tpu-serve-svc ClusterIP ###.###.###.### <none> 8000/TCP ###Stabilisci sessioni
port-forwardingcon il Ray head:pkill -f "kubectl .* port-forward .* 8000:8000" kubectl --namespace ${NAMESPACE} port-forward service/vllm-tpu-serve-svc 8000:8000 2>&1 >/dev/null &Invia una richiesta al modello:
curl -X POST http://localhost:8000/ -H "Content-Type: application/json" -d '{"prompt": "What is the most popular programming language for machine learning and why?", "max_tokens": 1000}'L'output è simile al seguente:
{"text": [" used in various data science projects, including building machine learning models, preprocessing data, and visualizing results.\n\nSure, here is a single sentence summarizing the text:\n\nPython is the most popular programming language for machine learning and is widely used in data science projects, encompassing model building, data preprocessing, and visualization."]}
Crea ed esegui il deployment dell'immagine TPU
Questo tutorial utilizza immagini TPU ospitate di
vLLM. vLLM fornisce un'immagineDockerfile.tpu che crea vLLM sulla base dell'immagine PyTorch XLA obbligatoria
che include le dipendenze TPU. Tuttavia, puoi anche creare ed eseguire il deployment della tua immagine TPU per un controllo più granulare sui contenuti dell'immagine Docker.
Crea un repository Docker per archiviare le immagini del contenitore per questa guida:
gcloud artifacts repositories create vllm-tpu --repository-format=docker --location=${COMPUTE_REGION} && \ gcloud auth configure-docker ${COMPUTE_REGION}-docker.pkg.devClona il repository vLLM:
git clone https://github.com/vllm-project/vllm.git cd vllmCrea l'immagine:
docker build -f Dockerfile.tpu . -t vllm-tpuTagga l'immagine TPU con il nome del tuo Artifact Registry:
export VLLM_IMAGE=${COMPUTE_REGION}-docker.pkg.dev/${PROJECT_ID}/vllm-tpu/vllm-tpu:TAG docker tag vllm-tpu ${VLLM_IMAGE}Sostituisci
TAGcon il nome del tag da definire. Se non specifichi un tag, Docker applica il tag predefinito latest.Esegui il push dell'immagine ad Artifact Registry:
docker push ${VLLM_IMAGE}
Elimina le singole risorse
Se hai utilizzato un progetto esistente e non vuoi eliminarlo, puoi eliminare le singole risorse.
Elimina la risorsa personalizzata RayCluster:
kubectl --namespace ${NAMESPACE} delete rayclusters vllm-tpuElimina il bucket Cloud Storage:
gcloud storage rm -r gs://${GSBUCKET}Elimina il repository Artifact Registry:
gcloud artifacts repositories delete vllm-tpu \ --location=${COMPUTE_REGION}Elimina il cluster:
gcloud container clusters delete ${CLUSTER_NAME} \ --location=LOCATIONSostituisci
LOCATIONcon una delle seguenti variabili di ambiente:- Per i cluster Autopilot, utilizza
COMPUTE_REGION. - Per i cluster standard, utilizza
COMPUTE_ZONE.
- Per i cluster Autopilot, utilizza
Elimina il progetto
Se hai eseguito il deployment del tutorial in un nuovo Google Cloud progetto e non ne hai più bisogno, eliminalo completando i seguenti passaggi:
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
Passaggi successivi
- Scopri come eseguire carichi di lavoro di AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.
- Scopri come utilizzare Ray Serve su GKE visualizzando il codice di esempio su GitHub.
- Scopri come raccogliere e visualizzare le metriche per i cluster Ray in esecuzione su GKE completando i passaggi descritti in Raccogliere e visualizzare log e metriche per i cluster Ray su GKE.