Questo tutorial mostra come pubblicare un Gemma un modello linguistico di grandi dimensioni (LLM) che utilizza le GPU Google Kubernetes Engine (GKE), utilizzando NVIDIA Triton e TensorRT-LLM stack di servizio per un'inferenza efficiente basata su GPU con Kubernetes e l'orchestrazione dei comandi. In questo tutorial, scarichi i parametri 2B e 7B Gemma ottimizzato per le istruzioni di base ed eseguirne il deployment su una Pilota automatico o Standard utilizzando un container che esegue Triton e TensorRT-LLM.
Questa guida è un buon punto di partenza se hai bisogno di controlli granulari, scalabilità, resilienza, portabilità e convenienza di Kubernetes gestito il deployment e la gestione dei carichi di lavoro di AI/ML. Se hai bisogno di AI gestita unificata per creare e distribuire rapidamente modelli ML in modo economico, consigliamo di provare la nostra soluzione di deployment Vertex AI.
Sfondo
Gestisci Gemma utilizzando GPU su GKE con Triton TensorRT-LLM, è possibile implementare una soluzione di inferenza robusta e pronta per la produzione con tutte le vantaggi di Kubernetes gestito, tra cui una scalabilità efficiente e una la disponibilità del servizio. Questa sezione descrive le tecnologie chiave utilizzate in questa guida.
Gemma
Gemma è un insieme di intelligenza artificiale (AI) generativa aperta e leggera rilasciati con licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione in applicazioni, hardware, dispositivi mobili o servizi in hosting. Puoi utilizzare i modelli Gemma per la generazione del testo, ma puoi anche e ottimizzare questi modelli per attività specializzate.
Per saperne di più, consulta la documentazione di Gemma.
GPU
Le GPU consentono di accelerare carichi di lavoro specifici in esecuzione sui nodi, come l'apprendimento e l'elaborazione dei dati. GKE offre una gamma tipi di macchine per la configurazione dei nodi, inclusi i tipi di macchina con NVIDIA H100, GPU L4 e A100.
Prima di utilizzare le GPU in GKE, ti consigliamo di completare nel seguente percorso di apprendimento:
- Scopri di più sulla disponibilità attuale della versione di GPU
- Scopri di più sulle GPU in GKE
TensorRT-LLM
NVIDIA TensorRT-LLM (TRT-LLM) è un toolkit con un'API Python per l'assemblaggio soluzioni ottimizzate per definire gli LLM e creare motori TensorRT in grado di eseguire l'inferenza in modo efficiente sulle GPU NVIDIA. TensorRT-LLM include funzionalità come:
- Implementazione del trasformatore ottimizzata con fusioni di livelli, memorizzazione nella cache di attivazione riutilizzo del buffer di memoria e PagedAttention
- Elaborazione in batch continua o in corso per migliorare la velocità effettiva di distribuzione complessiva
- Parallelismo tensore e parallelismo delle pipeline per la pubblicazione distribuita su più GPU
- Quantizzazione (FP16, FP8, INT8)
Per saperne di più, consulta la documentazione relativa a TensorFlow-LLM.
Triton
NVIDIA Triton Inference Server è un server di inferenza open source per AI/ML diverse applicazioni. Triton supporta l'inferenza ad alte prestazioni sia su GPU NVIDIA che CPU con backend ottimizzati, tra cui TensorRT e TensorRT-LLM. Triton include funzionalità come:
- Inferenza multi-nodo, multi-GPU
- Esecuzione contemporanea di più modelli
- Assemblaggio o concatenamento dei modelli
- Batch di richieste di previsione statico, dinamico e continuo o in corso
Per saperne di più, consulta la documentazione di Triton.
Obiettivi
Questa guida è rivolta ai clienti di IA generativa che utilizzano PyTorch, utenti nuovi o esistenti di GKE, ML ingegneri, MLOps (DevOps) o amministratori di piattaforma che sono ti interessa utilizzare le funzionalità di orchestrazione dei container Kubernetes per LLM su hardware GPU H100, A100 e L4.
Alla fine di questa guida, sarai in grado di:
- Prepara l'ambiente con un cluster GKE in Autopilot.
- Esegui il deployment di un container con Triton e TritonRT-LLM nel tuo cluster.
- Utilizza Triton e TensorRT-LLM per gestire il modello Gemma 2B o 7B tramite curl.
Prima di iniziare
- Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Enable the required API.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
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 colunn 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 l'accesso.
-
Nel campo Nuove entità, inserisci l'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 aggiungiamo ogni altro ruolo.
- Fai clic su Salva.
-
- Crea un account Kaggle, se non ne hai già uno.
- Assicurati che il tuo progetto disponga di una quota sufficiente per le GPU. Per saperne di più, consulta Informazioni sulle GPU e Quote di allocazione.
prepara l'ambiente
In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate
in Google Cloud. Cloud Shell è preinstallato con il software necessario
per questo tutorial, inclusi
kubectl
e
con gcloud CLI.
Per configurare l'ambiente con Cloud Shell, segui questi passaggi:
Nella console Google Cloud, avvia una sessione di Cloud Shell facendo clic su Attiva Cloud Shell nella console Google Cloud. Viene avviata una sessione nella 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 REGION=REGION export CLUSTER_NAME=triton
Sostituisci i seguenti valori:
- PROJECT_ID: il tuo account Google Cloud ID progetto.
- REGION: una regione che supporta l'acceleratore
che vuoi utilizzare, ad esempio
us-central1
per GPU L4.
Ottieni l'accesso al modello
Per accedere ai modelli Gemma, devi accedere alla piattaforma Kaggle. ottenere un token API Kaggle.
Firma il contratto di consenso di licenza
Devi firmare il contratto di consenso per utilizzare Gemma. Segui queste istruzioni:
- Accedere alla pagina di consenso del modello. su Kaggle.com.
- Accedi a Kaggle se non l'hai ancora fatto.
- Fai clic su Richiedi accesso.
- Nella sezione Scegli l'account per il consenso, seleziona Verifica tramite l'account Kaggle a utilizzare il tuo account Kaggle per il consenso.
- Accetta i Termini e condizioni del modello.
Genera un token di accesso
Per accedere al modello tramite Kaggle, ti serve un token API Kaggle. Segui questi passaggi per generare un nuovo token, se non ne hai già uno:
- Nel browser, vai alle impostazioni di Kaggle.
- Nella sezione API, fai clic su Create New Token (Crea nuovo token).
È stato scaricato un file denominato kaggle.json
.
Carica il token di accesso su Cloud Shell
In Cloud Shell, carica il token dell'API Kaggle nel tuo account Google Cloud progetto:
- In Cloud Shell, fai clic su > Carica. Altro
- Seleziona File e fai clic su Scegli file.
- Apri il file
kaggle.json
. - Fai clic su Carica.
Creazione e configurazione delle risorse Google Cloud
Segui queste istruzioni per creare le risorse richieste.
Crea un cluster GKE e un pool di nodi
Puoi gestire Gemma su GPU in un ambiente GKE Autopilot o Standard. Ti consigliamo di usare una modalità Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi carichi di lavoro, vedi Scegliere una modalità operativa di 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.28
GKE crea un cluster Autopilot con CPU e GPU come richiesto dai carichi di lavoro di cui è stato eseguito il deployment.
Standard
In Cloud Shell, esegui questo comando per creare un'istanza cluster:
gcloud container clusters create ${CLUSTER_NAME} \ --project=${PROJECT_ID} \ --location=${REGION}-a \ --workload-pool=${PROJECT_ID}.svc.id.goog \ --release-channel=rapid \ --machine-type=e2-standard-4 \ --num-nodes=1
La creazione del cluster potrebbe richiedere diversi minuti.
Esegui questo comando per creare pool di nodi per il tuo cluster:
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \ --project=${PROJECT_ID} \ --location=${REGION}-a \ --cluster=${CLUSTER_NAME} \ --machine-type=g2-standard-12 \ --num-nodes=1
GKE crea un singolo pool di nodi contenente un nodo GPU L4.
crea un secret Kubernetes per le credenziali di Kaggle
In questo tutorial utilizzerai un secret di Kubernetes per le credenziali di Kaggle.
In Cloud Shell, segui questi passaggi:
Configura
kubectl
per comunicare con il tuo cluster:gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}
Crea un secret per archiviare le credenziali di Kaggle:
kubectl create secret generic kaggle-secret \ --from-file=kaggle.json \ --dry-run=client -o yaml | kubectl apply -f -
crea una risorsa PersistentVolume per archiviare i checkpoint
In questa sezione creerai un PersistentVolume supportato da un disco permanente per archiviare i checkpoint del modello.
Crea il seguente manifest
trtllm_checkpoint_pv.yaml
:Applica il manifest:
kubectl apply -f trtllm_checkpoint_pv.yaml
Scarica i file del motore TensorRT-LLM per Gemma
In questa sezione, eseguirai un Job per scaricare i file del motore TensorRT-LLM e archiviarli nella il PersistentVolume che hai creato in precedenza. Il job prepara anche i file di configurazione per il deployment del modello sul server Triton nel prossimo passaggio. Questo processo può richiede qualche minuto.
Gemma 2B-it
Il motore TensorRT-LLM è basato su Gemma 2B-it (istruzioni ottimizzate)
Checkpoint PyTorch di Gemma utilizzando l'attivazione di bfloat16
, lunghezza della sequenza di input=2048,
e lunghezza della sequenza di output=1024 GPU L4 scelte come target. Puoi eseguire il deployment del modello
con una singola GPU L4.
Crea il seguente manifest
job-download-gemma-2b.yaml
:Applica il manifest:
kubectl apply -f job-download-gemma-2b.yaml
Visualizza i log per il job:
kubectl logs -f job/data-loader-gemma-2b
L'output dei log è simile al seguente:
... Creating configuration files + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/2b/bfloat16/1-gpu/' + echo -e '\nCreating configuration files' ...
Attendi il completamento del job:
kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-2b
L'output è simile al seguente:
job.batch/data-loader-gemma-2b condition met
Verifica che il job sia stato completato correttamente (l'operazione potrebbe richiedere alcuni minuti):
kubectl get job/data-loader-gemma-2b
L'output è simile al seguente:
NAME COMPLETIONS DURATION AGE data-loader-gemma-2b 1/1 ##s #m##s
Gemma 7B-it
Il motore TensorRT-LLM è basato su Gemma 7B-it (istruzioni ottimizzate)
Checkpoint PyTorch di Gemma utilizzando l'attivazione di bfloat16
, lunghezza sequenza di input=1024,
e lunghezza della sequenza di output=512 GPU L4 scelte come target. Puoi eseguire il deployment del modello
con una singola GPU L4.
Crea il seguente manifest
job-download-gemma-7b.yaml
:Applica il manifest:
kubectl apply -f job-download-gemma-7b.yaml
Visualizza i log per il job:
kubectl logs -f job/data-loader-gemma-7b
L'output dei log è simile al seguente:
... Creating configuration files + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/7b/bfloat16/1-gpu/' + echo -e '\nCreating configuration files' ...
Attendi il completamento del job:
kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-7b
L'output è simile al seguente:
job.batch/data-loader-gemma-7b condition met
Verifica che il job sia stato completato correttamente (l'operazione potrebbe richiedere alcuni minuti):
kubectl get job/data-loader-gemma-7b
L'output è simile al seguente:
NAME COMPLETIONS DURATION AGE data-loader-gemma-7b 1/1 ##s #m##s
Assicurati che il job sia stato completato correttamente prima di passare alla sezione successiva.
Esegui il deployment di Triton
In questa sezione eseguirai il deployment di un container che utilizza Triton con il modello TensorRT-LLM per gestire il modello Gemma che vuoi utilizzare.
Crea il seguente manifest
deploy-triton-server.yaml
:Applica il manifest:
kubectl apply -f deploy-triton-server.yaml
Attendi che il deployment sia disponibile:
kubectl wait --for=condition=Available --timeout=900s deployment/triton-gemma-deployment
Visualizza i log del file manifest:
kubectl logs -f -l app=gemma-server
La risorsa di deployment avvia il server Triton e carica i dati del modello. Questo processo può richiedere alcuni minuti (fino a 20 minuti o più). L'output è simile al seguente:
I0216 03:24:57.387420 29 server.cc:676] +------------------+---------+--------+ | Model | Version | Status | +------------------+---------+--------+ | ensemble | 1 | READY | | postprocessing | 1 | READY | | preprocessing | 1 | READY | | tensorrt_llm | 1 | READY | | tensorrt_llm_bls | 1 | READY | +------------------+---------+--------+ .... .... .... I0216 03:24:57.425104 29 grpc_server.cc:2519] Started GRPCInferenceService at 0.0.0.0:8001 I0216 03:24:57.425418 29 http_server.cc:4623] Started HTTPService at 0.0.0.0:8000 I0216 03:24:57.466646 29 http_server.cc:315] Started Metrics Service at 0.0.0.0:8002
Pubblica il modello
In questa sezione devi interagire con il modello.
Configura il port forwarding
Esegui questo comando per configurare il port forwarding al modello:
kubectl port-forward service/triton-server 8000:8000
L'output è simile al seguente:
Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
Handling connection for 8000
Interagire con il modello utilizzando curl
Questa sezione mostra come eseguire un test di fumo di base per verificare l'avvenuta implementazione modello ottimizzato per le istruzioni. Per semplicità, questa sezione descrive l'approccio di test utilizzando solo il modello ottimizzato per l'istruzione 2-B.
In una nuova sessione del terminale, utilizza curl
per chattare con il tuo modello:
USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"
curl -X POST localhost:8000/v2/models/ensemble/generate \
-H "Content-Type: application/json" \
-d @- <<EOF
{
"text_input": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
"temperature": 0.9,
"max_tokens": 128
}
EOF
L'output seguente mostra un esempio della risposta del modello:
{
"context_logits": 0,
"cum_log_probs": 0,
"generation_logits": 0,
"model_name": "ensemble",
"model_version": "1",
"output_log_probs": [0.0,0.0,...],
"sequence_end": false,
"sequence_id": 0,
"sequence_start": false,
"text_output":"Python.\n\nPython is an excellent choice for beginners due to its simplicity, readability, and extensive documentation. Its syntax is close to natural language, making it easier for beginners to understand and write code. Python also has a vast collection of libraries and tools that make it versatile for various projects. Additionally, Python's dynamic nature allows for easier learning and experimentation, making it a perfect choice for newcomers to get started.Here are some specific reasons why Python is a good choice for beginners:\n\n- Simple and Easy to Read: Python's syntax is designed to be close to natural language, making it easier for"
}
Risoluzione dei problemi
- Se viene visualizzato il messaggio
Empty reply from server
, è possibile che il contenitore non abbia terminato il download dei dati del modello. Controlla di nuovo nei log del pod il messaggioConnected
che indica che il modello è pronto per la pubblicazione. - Se vedi
Connection refused
, verifica che il port forwarding sia attivo.
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 le risorse di cui è stato eseguito il deployment
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse creato in questa guida, esegui questo comando:
gcloud container clusters delete ${CLUSTER_NAME} \
--region=${REGION}
Passaggi successivi
- Scopri di più sulle GPU in GKE.
- Scopri come eseguire il deployment dei carichi di lavoro GPU in Autopilot.
- Scopri come eseguire il deployment dei carichi di lavoro GPU in Standard.
- Esplora il repository GitHub TensorRT-LLM e la documentazione.
- Esplora Vertex AI Model Garden.
- Scopri come eseguire carichi di lavoro ottimizzati di AI/ML con GKE orchestrazione delle piattaforme di archiviazione.