Questo tutorial mostra come pubblicare un modello di generazione di immagini SDXL utilizzando le Tensor Processing Unit (TPU) su Google Kubernetes Engine (GKE) con MaxDiffusion. In questo tutorial, scarica il modello da Hugging Face ed esegui il deployment in un cluster Autopilot o Standard utilizzando un contenitore che esegue MaxDiffusion.
Questa guida è un buon punto di partenza se hai bisogno del controllo granulare, della personalizzazione, della scalabilità, della resilienza, della portabilità e dell'economicità di Kubernetes gestito per il deployment e l'erogazione dei tuoi carichi di lavoro di AI/ML. Se hai bisogno di una piattaforma di IA gestita unificata per creare e pubblicare rapidamente modelli ML in modo economicamente vantaggioso, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.
Contesto
Pubblicando SDXL utilizzando TPU su GKE con MaxDiffusion, puoi creare una soluzione di pubblicazione affidabile e pronta per la produzione con tutti i vantaggi di Kubernetes gestito, tra cui economicità, scalabilità e maggiore disponibilità. Questa sezione descrive le tecnologie chiave utilizzate in questo tutorial.
Stable Diffusion XL (SDXL)
Stable Diffusion XL (SDXL) è un tipo di modello di diffusione latente (LDM) supportato da MaxDiffusion per l'inferenza. Per lAI generativa, puoi utilizzare gli LDM per generare immagini di alta qualità dalle descrizioni di testo. Gli LDM sono utili per applicazioni come la ricerca di immagini e la creazione di didascalie.
SDXL supporta l'inferenza su un singolo host o su più host con annotazioni di sharding. In questo modo, SDXL può essere addestrato ed eseguito su più macchine, il che può migliorare l'efficienza.
Per saperne di più, consulta il repository Generative Models by Stability AI e il SDXL.
TPU
Le TPU sono circuiti integrati per applicazioni specifiche (ASIC), sviluppati da Google, utilizzati per accelerare i modelli di machine learning e AI creati utilizzando framework come TensorFlow, PyTorch e JAX.
Prima di utilizzare le TPU in GKE, ti consigliamo di completare il seguente percorso di apprendimento:
- Scopri la disponibilità attuale delle versioni TPU con l'architettura di sistema Cloud TPU.
- Scopri di più sulle TPU in GKE.
Questo tutorial illustra la pubblicazione del modello SDXL. GKE
implementa il modello su nodi TPU v5e a host singolo con topologie TPU configurate
in base ai requisiti del modello per la pubblicazione di prompt con bassa latenza. In questa
guida, il modello utilizza un chip TPU v5e con una topologia 1x1
.
MaxDiffusion
MaxDiffusion è una raccolta di implementazioni di riferimento, scritte in Python e Jax, di vari modelli di diffusione latente che vengono eseguiti su dispositivi XLA, tra cui TPU e GPU. MaxDiffusion è un punto di partenza per i progetti di Diffusion sia per la ricerca che per la produzione.
Per saperne di più, consulta il repository MaxDiffusion.
Obiettivi
Questo tutorial è rivolto ai clienti di IA generativa che utilizzano JAX, agli utenti nuovi o esistenti di SDXL e a qualsiasi esperto di ML, MLOps (DevOps) o amministratore della piattaforma interessato a utilizzare le funzionalità di orchestrazione dei contenitori Kubernetes per l'erogazione di LLM.
Questo tutorial illustra i seguenti passaggi:
- Crea un cluster GKE Autopilot o Standard con la topologia TPU consigliata in base alle caratteristiche del modello.
- Crea un'immagine container di inferenza SDXL.
- Esegui il deployment del server di inferenza SDXL su GKE.
- Pubblica un'interazione con il modello tramite un'app web.
Architettura
Questa sezione descrive l'architettura GKE utilizzata in questo tutorial. L'architettura è costituita da un cluster GKE Autopilot o Standard che esegue il provisioning delle TPU e ospita i componenti MaxDiffusion. GKE utilizza questi componenti per eseguire il deployment e il servizio dei modelli.
Il seguente diagramma mostra i componenti di questa architettura:
Questa architettura include i seguenti componenti:
- Un cluster GKE Autopilot o Standard a livello di regione.
- Un pool di nodi con sezione TPU a host singolo che ospita il modello SDXL nel deployment di MaxDiffusion.
- Il componente Service con un bilanciatore del carico di tipo
ClusterIP
. Questo servizio distribuisce il traffico in entrata a tutte le replicheMaxDiffusion HTTP
. - Il server
WebApp HTTP
con un servizioLoadBalancer
esterno che distribuisce il traffico in entrata e reindirizza il traffico di pubblicazione del modello al servizioClusterIP
.
Prima di iniziare
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the required API.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the required API.
-
Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin
Check for the roles
-
In the Google Cloud console, go to the IAM page.
Go to IAM - Select the project.
-
In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
- For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.
Grant the roles
-
In the Google Cloud console, go to the IAM page.
Vai a IAM - Seleziona il progetto.
- Fai clic su Concedi accesso.
-
Nel campo Nuovi principali, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.
- Nell'elenco Seleziona un ruolo, seleziona un ruolo.
- Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
- Fai clic su Salva.
-
- Assicurati di disporre di una quota sufficiente per i chip
TPU v5e PodSlice Lite
. In questo tutorial utilizzi le istanze on demand.
Prepara l'ambiente
In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su
Google Cloud. Cloud Shell include il software di cui avrai bisogno per questo tutorial, tra cui kubectl
e
gcloud CLI.
Per configurare l'ambiente con Cloud Shell:
Nella console Google Cloud, avvia una sessione Cloud Shell facendo clic su
Attiva Cloud Shell nella console Google Cloud. Viene avviata una sessione nel riquadro inferiore della console Google Cloud.
Imposta le variabili di ambiente predefinite:
gcloud config set project PROJECT_ID export PROJECT_ID=$(gcloud config get project) export CLUSTER_NAME=CLUSTER_NAME export REGION=REGION_NAME export ZONE=ZONE
Sostituisci i seguenti valori:
- PROJECT_ID: il tuo Google Cloud ID progetto.
- CLUSTER_NAME: il nome del tuo cluster GKE.
- REGION_NAME: la regione in cui si trovano il cluster GKE, il bucket Cloud Storage e i nodi TPU. La regione contiene zone in cui sono disponibili tipi di macchine TPU v5e (ad esempio
us-west1
,us-west4
,us-central1
,us-east1
,us-east5
oeurope-west4
). - (Solo cluster standard) ZONE: la zona in cui sono disponibili le risorse TPU (ad esempio
us-west4-a
). Per i cluster Autopilot, non è necessario specificare la zona, ma solo la regione.
Clona il repository di esempio e apri la directory del tutorial:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/ai-ml/maxdiffusion-tpu WORK_DIR=$(pwd) gcloud artifacts repositories create gke-llm --repository-format=docker --location=$REGION gcloud auth configure-docker $REGION-docker.pkg.dev
Crea e configura le risorse Google Cloud
Segui queste istruzioni per creare le risorse richieste.
Crea un cluster GKE
Puoi pubblicare SDXL su TPU in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa di GKE più adatta ai tuoi carichi di lavoro, consulta Scegliere una modalità operativa GKE.
Autopilot
In Cloud Shell, esegui questo comando:
gcloud container clusters create-auto ${CLUSTER_NAME} \ --project=${PROJECT_ID} \ --region=${REGION} \ --release-channel=rapid \ --cluster-version=1.29
GKE crea un cluster Autopilot con nodi CPU e TPU come richiesto dai workload di cui è stato eseguito il deployment.
Configura
kubectl
per comunicare con il cluster:gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}
Standard
Crea un cluster GKE Standard regionale che utilizza Workload Identity Federation for GKE.
gcloud container clusters create ${CLUSTER_NAME} \ --enable-ip-alias \ --machine-type=n2-standard-4 \ --num-nodes=2 \ --workload-pool=${PROJECT_ID}.svc.id.goog \ --location=${REGION}
La creazione del cluster potrebbe richiedere diversi minuti.
Esegui il comando seguente per creare un pool di nodi per il cluster:
gcloud container node-pools create maxdiffusion-tpu-nodepool \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-1t \ --num-nodes=1 \ --region=${REGION} \ --node-locations=${ZONE} \ --spot
GKE crea un pool di nodi TPU v5e con una topologia
1x1
e un nodo.Per creare node pool con topologie diverse, scopri come pianificare la configurazione TPU. Assicurati di aggiornare i valori di esempio in questo tutorial, ad esempio
cloud.google.com/gke-tpu-topology
egoogle.com/tpu
.Configura
kubectl
per comunicare con il cluster:gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}
Crea il contenitore di inferenza SDXL
Segui queste istruzioni per creare un'immagine del contenitore per il server di inferenza SDXL.
Apri il file manifest
server/cloudbuild.yaml
:Esegui la compilazione e crea l'immagine container di inferenza.
cd $WORK_DIR/build/server gcloud builds submit . --region=$REGION
L'output contiene il percorso dell'immagine container.
Esegui il deployment del server di inferenza SDXL
In questa sezione, esegui il deployment del server di inferenza SDXL. Per eseguire il deployment del server, questo tutorial utilizza un deployment Kubernetes. Un deployment è un oggetto dell'API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.
Esplora il file manifest
serve_sdxl_v5e.yaml
.Aggiorna l'ID progetto nel file manifest.
cd $WORK_DIR sed -i "s|PROJECT_ID|$PROJECT_ID|g" serve_sdxl_v5e.yaml sed -i "s|REGION|$REGION|g" serve_sdxl_v5e.yaml
Applica il manifest:
kubectl apply -f serve_sdxl_v5e.yaml
L'output è simile al seguente:
deployment.apps/max-diffusion-server created
Verifica lo stato del modello:
watch kubectl get deploy
L'output è simile al seguente:
NAME READY UP-TO-DATE AVAILABLE AGE stable-diffusion-deployment 1/1 1 1 8m21s
Recupera l'indirizzo
ClusterIP
:kubectl get service max-diffusion-server
L'output contiene un campo
ClusterIP
. Prendi nota del valore CLUSTER-IP.Convalida il deployment:
export ClusterIP=CLUSTER_IP kubectl run curl --image=curlimages/curl \ -it --rm --restart=Never \ -- "$ClusterIP:8000"
Sostituisci CLUSTER_IP con il valore CLUSTER-IP che hai annotato in precedenza. L'output è simile al seguente:
{"message":"Hello world! From FastAPI running on Uvicorn with Gunicorn."} pod "curl" deleted
Visualizza i log del deployment:
kubectl logs -l app=max-diffusion-server
Al termine del deployment, l'output è simile al seguente:
2024-06-12 15:45:45,459 [INFO] __main__: replicate params: 2024-06-12 15:45:46,175 [INFO] __main__: start initialized compiling 2024-06-12 15:45:46,175 [INFO] __main__: Compiling ... 2024-06-12 15:45:46,175 [INFO] __main__: aot compiling: 2024-06-12 15:45:46,176 [INFO] __main__: tokenize prompts:2024-06-12 15:48:49,093 [INFO] __main__: Compiled in 182.91802048683167 INFO: Started server process [1] INFO: Waiting for application startup. INFO: Application startup complete.
Esegui il deployment del client dell'app web
In questa sezione esegui il deployment del client della web app per pubblicare il modello SDXL.
Esplora il file manifest
build/webapp/cloudbuild.yaml
.Esegui la compilazione e crea l'immagine del container del client nella directory
build/webapp
.cd $WORK_DIR/build/webapp gcloud builds submit . --region=$REGION
L'output contiene il percorso dell'immagine container.
Apri il file manifest
serve_sdxl_client.yaml
:Modifica l'ID progetto nel manifest:
cd $WORK_DIR sed -i "s|PROJECT_ID|$PROJECT_ID|g" serve_sdxl_client.yaml sed -i "s|ClusterIP|$ClusterIP|g" serve_sdxl_client.yaml sed -i "s|REGION|$REGION|g" serve_sdxl_client.yaml
Applica il manifest:
kubectl apply -f serve_sdxl_client.yaml
Recupera l'indirizzo IP
LoadBalancer
:kubectl get service max-diffusion-client-service
L'output contiene un campo
LoadBalancer
. Prendi nota del valore EXTERNAL-IP.
Interagire con il modello utilizzando la pagina web
Accedi al seguente URL da un browser web:
http://EXTERNAL_IP:8080
Sostituisci EXTERNAL_IP con il valore
EXTERNAL_IP
che hai annotato in precedenza.Interagisci con SDXL utilizzando l'interfaccia della chat. Aggiungi un prompt e fai clic su Invia. Ad esempio:
Create a detailed image of a fictional historical site, capturing its unique architecture and cultural significance
L'output è un'immagine generata dal modello simile all'esempio seguente:
Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.
Elimina il progetto
- 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.
Elimina le singole risorse
Mantieni il progetto ed elimina le singole risorse, come descritto nella sezione seguente. Esegui i seguenti comandi e segui le istruzioni:
gcloud container clusters delete ${CLUSTER_NAME} --region=${REGION}
Passaggi successivi
- Configura il tutorial con altre topologie TPU. Per scoprire di più su altre topologie TPU, consulta Pianificare la configurazione TPU.
- Esplora il codice di esempio del server di inferenza MaxDiffusion nel repository di esempio che hai clonato in questo tutorial.
- Scopri di più sulle TPU in GKE.
- Esplora il repository GitHub di JetStream.
- Esplora Vertex AI Model Garden.