Questo tutorial mostra come eseguire il deployment e il servizio di un modello di machine learning (ML) scalabile in un cluster Google Kubernetes Engine (GKE) utilizzando il framework TorchServe. Pubblichi un modello PyTorch preaddestrato che genera previsioni in base alle richieste degli utenti. Dopo aver eseguito il deployment del modello, ricevi un URL di previsione utilizzato dalla tua applicazione per inviare richieste di previsione. Questo metodo ti consente di scalare il modello e l'applicazione web in modo indipendente. Quando esegui il deployment del carico di lavoro e dell'applicazione ML su Autopilot, GKE sceglie il tipo di macchina e le dimensioni di base più efficienti per eseguire i carichi di lavoro.
Questo tutorial è rivolto a tecnici del machine learning (ML), amministratori e operatori della piattaforma e a specialisti di dati e AI interessati a utilizzare GKE Autopilot per ridurre il sovraccarico amministrativo per la configurazione, il ridimensionamento e gli upgrade dei nodi. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei Google Cloud contenuti, consulta Ruoli e attività utente comuni di GKE Enterprise.
Prima di leggere questa pagina, assicurati di conoscere la modalità GKE Autopilot.
Informazioni sulla richiesta di tutorial
L'applicazione è una piccola applicazione web Python creata utilizzando il framework Fast Dash. L'applicazione viene utilizzata per inviare richieste di previsione al modello T5. Questa applicazione acquisisce gli input di testo dell'utente e le coppie di lingue e invia le informazioni al modello. Il modello traduce il testo e restituisce il risultato all'applicazione, che lo mostra all'utente. Per ulteriori informazioni su Fast Dash, consulta la documentazione di Fast Dash.
Obiettivi
- Prepara un modello T5 preaddestrato dal repository Hugging Face per la pubblicazione, impacchettandolo come immagine container e spingendolo in Artifact Registry
- Esegui il deployment del modello in un cluster Autopilot
- Esegui il deployment dell'applicazione Fast Dash che comunica con il modello
- Scalabilità automatica del modello in base alle metriche di Prometheus
Costi
In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi in base all'utilizzo previsto,
utilizza il Calcolatore prezzi.
Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.
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.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
-
Create or select a Google Cloud project.
-
Create a Google Cloud project:
gcloud projects create PROJECT_ID
Replace
PROJECT_ID
with a name for the Google Cloud project you are creating. -
Select the Google Cloud project that you created:
gcloud config set project PROJECT_ID
Replace
PROJECT_ID
with your Google Cloud project name.
-
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs:
gcloud services enable container.googleapis.com
storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com - Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
-
Create or select a Google Cloud project.
-
Create a Google Cloud project:
gcloud projects create PROJECT_ID
Replace
PROJECT_ID
with a name for the Google Cloud project you are creating. -
Select the Google Cloud project that you created:
gcloud config set project PROJECT_ID
Replace
PROJECT_ID
with your Google Cloud project name.
-
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs:
gcloud services enable container.googleapis.com
storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
Prepara l'ambiente
Clona il repository di esempio e apri la directory del tutorial:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving
Crea il cluster
Esegui questo comando:
gcloud container clusters create-auto ml-cluster \
--release-channel=RELEASE_CHANNEL \
--cluster-version=CLUSTER_VERSION \
--location=us-central1
Sostituisci quanto segue:
RELEASE_CHANNEL
: il canale di rilascio del cluster. Deve essererapid
,regular
ostable
. Scegli un canale con GKE 1.28.3-gke.1203000 o versioni successive per utilizzare le GPU L4. Per visualizzare le versioni disponibili in un canale specifico, consulta Visualizzare le versioni predefinite e disponibili per i canali di rilascio.CLUSTER_VERSION
: la versione di GKE da utilizzare. Deve essere1.28.3-gke.1203000
o successiva.
Il completamento dell'operazione richiede diversi minuti.
Crea un repository Artifact Registry
Crea un nuovo repository standard di Artifact Registry con il formato Docker nella stessa regione del tuo cluster:
gcloud artifacts repositories create models \ --repository-format=docker \ --location=us-central1 \ --description="Repo for T5 serving image"
Verifica il nome del repository:
gcloud artifacts repositories describe models \ --location=us-central1
L'output è simile al seguente:
Encryption: Google-managed key Repository Size: 0.000MB createTime: '2023-06-14T15:48:35.267196Z' description: Repo for T5 serving image format: DOCKER mode: STANDARD_REPOSITORY name: projects/PROJECT_ID/locations/us-central1/repositories/models updateTime: '2023-06-14T15:48:35.267196Z'
Impacchetta il modello
In questa sezione, pacchettizzi il modello e il framework di pubblicazione in un'unica immagine container utilizzando Cloud Build ed esegui il push dell'immagine risultante nel repository Artifact Registry.
Esamina il Dockerfile dell'immagine container:
Questo Dockerfile definisce la seguente procedura di compilazione in più fasi:
- Scarica gli artefatti del modello dal repository Hugging Face.
- Impacchetta il modello utilizzando lo strumento PyTorch Serving Archive. Viene creato un file dell'archivio del modello (.mar) che il server di inferenza utilizza per caricare il modello.
- Crea l'immagine finale con PyTorch Serve.
Crea ed esegui il push dell'immagine utilizzando Cloud Build:
gcloud builds submit model/ \ --region=us-central1 \ --config=model/cloudbuild.yaml \ --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0
Il processo di compilazione richiede diversi minuti. Se utilizzi un modello di dimensioni superiori a
t5-small
, la procedura di compilazione potrebbe richiedere molto più tempo.Verifica che l'immagine sia nel repository:
gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models
Sostituisci
PROJECT_ID
con il tuo Google Cloud ID progetto.L'output è simile al seguente:
IMAGE DIGEST CREATE_TIME UPDATE_TIME us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small sha256:0cd... 2023-06-14T12:06:38 2023-06-14T12:06:38
Esegui il deployment del modello pacchettizzato in GKE
Per eseguire il deployment dell'immagine, questo tutorial utilizza i 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.
Modifica il manifest di Kubernetes nel repository di esempio in modo che corrisponda al tuo ambiente.
Esamina il manifest per il carico di lavoro di inferenza:
Sostituisci
PROJECT_ID
con il tuo Google Cloud ID progetto:sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"
In questo modo, il percorso dell'immagine container nella specifica di deployment corrisponde al percorso dell'immagine del modello T5 in Artifact Registry.
Crea le risorse Kubernetes:
kubectl create -f kubernetes/serving-gpu.yaml
Per verificare che il deployment del modello sia andato a buon fine:
Visualizza lo stato del deployment e del servizio:
kubectl get -f kubernetes/serving-gpu.yaml
Attendi che l'output mostri i pod pronti, come nel seguente esempio. A seconda delle dimensioni dell'immagine, il primo recupero dell'immagine potrebbe richiedere diversi minuti.
NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/t5-inference 1/1 1 0 66s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/t5-inference ClusterIP 10.48.131.86 <none> 8080/TCP,8081/TCP,8082/TCP 66s
Apri una porta locale per il servizio
t5-inference
:kubectl port-forward svc/t5-inference 8080
Apri una nuova finestra del terminale e invia una richiesta di test al servizio:
curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"
Se la richiesta di test non va a buon fine e la connessione del pod si chiude, controlla i log:
kubectl logs deployments/t5-inference
Se l'output è simile al seguente, TorchServe non è riuscito a installare alcune dipendenze del modello:
org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small
Per risolvere il problema, riavvia il deployment:
kubectl rollout restart deployment t5-inference
Il controller Deployment crea un nuovo pod. Ripeti i passaggi precedenti per aprire una porta sul nuovo pod.
Accedi al modello di cui è stato eseguito il deployment utilizzando l'applicazione web
Per accedere al modello di cui è stato eseguito il deployment con l'applicazione web Fast Dash, completa i seguenti passaggi:
Crea ed esegui il push dell'applicazione web Fast Dash come immagine container in Artifact Registry:
gcloud builds submit client-app/ \ --region=us-central1 \ --config=client-app/cloudbuild.yaml
Apri
kubernetes/application.yaml
in un editor di testo e sostituisciPROJECT_ID
nel campoimage:
con il tuo ID progetto. In alternativa, esegui il seguente comando:sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"
Crea le risorse Kubernetes:
kubectl create -f kubernetes/application.yaml
Il provisioning completo del deployment e del servizio potrebbe richiedere del tempo.
Per controllare lo stato, esegui il seguente comando:
kubectl get -f kubernetes/application.yaml
Attendi che l'output mostri i pod pronti, come nel seguente esempio:
NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/fastdash 1/1 1 0 1m NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/fastdash NodePort 203.0.113.12 <none> 8050/TCP 1m
L'applicazione web è ora in esecuzione, anche se non è esposta su un indirizzo IP esterno. Per accedere all'applicazione web, apri una porta locale:
kubectl port-forward service/fastdash 8050
In un browser, apri l'interfaccia web:
- Se utilizzi una shell locale, apri un browser e vai all'indirizzo http://127.0.0.1:8050.
- Se utilizzi Cloud Shell, fai clic su Anteprima web, quindi su
Cambia porta. Specifica la porta
8050
.
Per inviare una richiesta al modello T5, specifica i valori nei campi TESTO, LINGUA DA e LINGUA A nell'interfaccia web e fai clic su Invia. Per un elenco delle lingue disponibili, consulta la documentazione di T5.
Abilita la scalabilità automatica per il modello
Questa sezione mostra come attivare la scalabilità automatica per il modello in base alle metriche di Google Cloud Managed Service per Prometheus procedendo nel seguente modo:
- Installa l'adattatore Stackdriver delle metriche personalizzate
- Applica le configurazioni di PodMonitoring e HorizontalPodAutoscaling
Google Cloud Managed Service per Prometheus è abilitato per impostazione predefinita nei cluster Autopilot che eseguono la versione 1.25 e successive.
Installa l'adattatore Stackdriver delle metriche personalizzate
Questo adattatore consente al cluster di utilizzare le metriche di Prometheus per prendere decisioni di scalabilità automatica di Kubernetes.
Esegui il deployment dell'adattatore:
kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
Crea un account di servizio IAM da utilizzare per l'adattatore:
gcloud iam service-accounts create monitoring-viewer
Concedi all'account di servizio IAM il ruolo
monitoring.viewer
sul progetto e il ruoloiam.workloadIdentityUser
:gcloud projects add-iam-policy-binding PROJECT_ID \ --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \ --role roles/monitoring.viewer gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
Sostituisci
PROJECT_ID
con il tuo Google Cloud ID progetto.Aggiungi un'annotazione all'account di servizio Kubernetes dell'adattatore per consentirgli di rubare l'identità dell'account di servizio IAM:
kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \ --namespace custom-metrics \ iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com
Riavvia l'adattatore per propagare le modifiche:
kubectl rollout restart deployment custom-metrics-stackdriver-adapter \ --namespace=custom-metrics
Applica le configurazioni di PodMonitoring e HorizontalPodAutoscaling
PodMonitoring è una risorsa personalizzata di Google Cloud Managed Service per Prometheus che consente l'importazione delle metriche e lo scraping dei target in uno spazio dei nomi specifico.
Esegui il deployment della risorsa PodMonitoring nello stesso spazio dei nomi del deployment di TorchServe:
kubectl apply -f kubernetes/pod-monitoring.yaml
Esamina il manifest di HorizontalPodAutoscaler:
HorizontalPodAutoscaler scala la quantità di pod del modello T5 in base alla durata cumulativa della coda delle richieste. La scalabilità automatica si basa sulla metrica
ts_queue_latency_microseconds
, che mostra la durata cumulativa della coda in microsecondi.Crea HorizontalPodAutoscaler:
kubectl apply -f kubernetes/hpa.yaml
Verificare la scalabilità automatica utilizzando un generatore di carico
Per testare la configurazione della scalabilità automatica, genera un carico per l'applicazione di pubblicazione. Questo tutorial utilizza un generatore di carico Locust per inviare richieste all'endpoint di previsione del modello.
Crea il generatore di carico:
kubectl apply -f kubernetes/loadgenerator.yaml
Attendi che i pod del generatore di carico siano pronti.
Esponi l'interfaccia web del generatore di carico in locale:
kubectl port-forward svc/loadgenerator 8080
Se viene visualizzato un messaggio di errore, riprova quando il pod è in esecuzione.
In un browser, apri l'interfaccia web del generatore di carico:
- Se utilizzi una shell locale, apri un browser e vai all'indirizzo http://127.0.0.1:8080.
- Se utilizzi Cloud Shell, fai clic su Anteprima web, quindi su Cambia porta. Inserisci la porta
8080
.
Fai clic sulla scheda Grafici per osservare il rendimento nel tempo.
Apri una nuova finestra del terminale e controlla il numero di repliche degli agenti di scalabilità automatica dei pod orizzontali:
kubectl get hpa -w
Il numero di repliche aumenta con l'aumento del carico. L'operazione di scalabilità potrebbe richiedere circa dieci minuti. Man mano che vengono avviate nuove repliche, il numero di richieste andate a buon fine nel grafico Locust aumenta.
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE t5-inference Deployment/t5-inference 71352001470m/7M 1 5 1 2m11s
Suggerimenti
- Crea il modello con la stessa versione dell'immagine Docker di base che utilizzerai per il servizio.
- Se il tuo modello ha dipendenze di pacchetti speciali o se le dimensioni delle dipendenze sono elevate, crea una versione personalizzata dell'immagine Docker di base.
- Controlla la versione dell'albero dei pacchetti delle dipendenze del modello. Assicurati che le dipendenze dei pacchetti supportino le versioni l'una dell'altra. Ad esempio, la versione 2.0.3 di Panda supporta la versione 1.20.3 e successive di NumPy.
- Esegui modelli che richiedono l'uso intensivo di GPU su nodi GPU e modelli che richiedono l'uso intensivo di CPU su CPU. Ciò potrebbe migliorare la stabilità del servizio del modello e assicurarti di utilizzare in modo efficiente le risorse del nodo.
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
Delete a Google Cloud project:
gcloud projects delete PROJECT_ID
Elimina singole risorse
Elimina le risorse Kubernetes:
kubectl delete -f kubernetes/loadgenerator.yaml kubectl delete -f kubernetes/hpa.yaml kubectl delete -f kubernetes/pod-monitoring.yaml kubectl delete -f kubernetes/application.yaml kubectl delete -f kubernetes/serving-gpu.yaml kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
Elimina il cluster GKE:
gcloud container clusters delete "ml-cluster" \ --location="us-central1" --quiet
Elimina l'account di servizio IAM e le associazioni di criteri IAM:
gcloud projects remove-iam-policy-binding PROJECT_ID \ --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \ --role roles/monitoring.viewer gcloud iam service-accounts remove-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]" gcloud iam service-accounts delete monitoring-viewer
Elimina le immagini in Artifact Registry. (Facoltativo) Elimina l'intero repository. Per le istruzioni, consulta la documentazione di Artifact Registry sull'eliminazione delle immagini.
Panoramica dei componenti
Questa sezione descrive i componenti utilizzati in questo tutorial, ad esempio il modello, l'applicazione web, il framework e il cluster.
Informazioni sul modello T5
Questo tutorial utilizza un modello T5 multilingue preaddestrato. T5 è un trasformatore text-to-text che converte il testo da una lingua all'altra. In T5, gli input e gli output sono sempre stringhe di testo, a differenza dei modelli in stile BERT che possono produrre solo un'etichetta di classe o un intervallo dell'input. Il modello T5 può essere utilizzato anche per attività come il riassunto, le domande e risposte o la classificazione del testo. Il modello viene addestrato su una grande quantità di testo proveniente da Colossal Clean Crawled Corpus (C4) e Wiki-DPR.
Per ulteriori informazioni, consulta la documentazione del modello T5.
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li e Peter J. Liu ha presentato il modello T5 in Esplorazione dei limiti dell'apprendimento tramite trasferimento con un Transformer testo-testo unificato, pubblicato nel Journal of Machine Learning Research.
Il modello T5 supporta vari modelli, con diversi livelli di complessità, adatti a casi d'uso specifici. Questo tutorial utilizza la dimensione predefinita t5-small
, ma puoi anche scegliere una dimensione diversa. I seguenti formati T5 sono distribuiti
in base alla licenza Apache 2.0:
t5-small
: 60 milioni di parametrit5-base
: 220 milioni di parametrit5-large
: 770 milioni di parametri. Download di 3 GB.t5-3b
: 3 miliardi di parametri. Download di 11 GB.t5-11b
: 11 miliardi di parametri. Download di 45 GB.
Per altri modelli T5 disponibili, consulta il repository Hugging Face.
Informazioni su TorchServe
TorchServe è uno strumento flessibile per la pubblicazione di modelli PyTorch. Fornisce il supporto out of the box per tutti i principali framework di deep learning, tra cui PyTorch, TensorFlow e ONNX. TorchServe può essere utilizzato per eseguire il deployment dei modelli in produzione o per la prototipazione e la sperimentazione rapide.
Passaggi successivi
- Pubblica un LLM con più GPU.
- Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.