Questo tutorial mostra come gestire la famiglia di modelli linguistici di grandi dimensioni (LLM) di Gemma, utilizzando GPU (Graphic Processing Unit) su Google Kubernetes Engine (GKE) con il framework di gestione Text Generation Inference (TGI) di Hugging Face. In questo tutorial, scaricherai i modelli della famiglia Gemma preaddestrati e ottimizzati per le istruzioni da Hugging Face e ne eseguirai il deployment su un cluster GKE Autopilot o Standard utilizzando un container che esegue TGI.
Questa guida è un buon punto di partenza se hai bisogno del controllo granulare, della scalabilità, della resilienza, della portabilità e della convenienza di Kubernetes gestito quando esegui il deployment e la gestione dei tuoi carichi di lavoro AI/ML. Se hai bisogno di una piattaforma IA gestita e unificata per creare e pubblicare rapidamente modelli ML a costi contenuti, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.
Contesto
Utilizzando Gemma tramite GPU su GKE con TGI, puoi implementare una solida soluzione di servizio di inferenza pronta per la produzione con tutti i vantaggi di Kubernetes gestito, tra cui scalabilità efficiente e disponibilità superiore. In questa sezione vengono descritte le tecnologie principali utilizzate in questa guida.
Gemma
Gemma è un insieme di modelli di intelligenza artificiale generativa (AI) leggeri e a disponibilità aperta, rilasciati con licenza aperta. Questi modelli di IA possono essere eseguiti in applicazioni, hardware, dispositivi mobili o servizi in hosting.
In questa guida vengono presentati i seguenti modelli:
- Gemma per la generazione di testo, puoi anche ottimizzare questi modelli per specializzarli nell'esecuzione di attività specifiche.
- CodeGemma è una raccolta di modelli potenti e leggeri in grado di eseguire una varietà di attività di programmazione come il completamento del codice in modalità di compilazione del codice, la generazione di codice, la comprensione del linguaggio naturale, il ragionamento matematico e le istruzioni per seguire.
Per saperne di più, consulta la documentazione di Gemma.
GPU
Le GPU consentono di accelerare carichi di lavoro specifici in esecuzione sui nodi, come il machine learning e l'elaborazione di dati. GKE offre una gamma di opzioni per i tipi di macchina per la configurazione dei nodi, inclusi i tipi di macchina con GPU NVIDIA H100, L4 e A100.
Prima di utilizzare le GPU in GKE, ti consigliamo di completare il seguente percorso di apprendimento:
- Scopri di più sulla disponibilità attuale delle versioni GPU
- Scopri di più sulle GPU in GKE
Inferenza generazione di testo (TGI)
TGI è il toolkit di Hugging Face per il deployment e la gestione degli LLM. TGI consente la generazione di testo ad alte prestazioni per i più diffusi LLM open source, tra cui Gemma. La TGI include funzionalità quali:
- Implementazione del trasformatore ottimizzata con Flash Attention e PagedAttention
- Batch continuo per migliorare la velocità effettiva di pubblicazione complessiva
- Parallelismo Tensor per un'inferenza più rapida su più GPU
Per saperne di più, consulta la documentazione relativa al TGI.
Obiettivi
Questa guida è rivolta ai clienti di IA generativa che utilizzano PyTorch, agli utenti nuovi o esistenti di GKE, ML Engineer, MLOps (DevOps) ingegneri o amministratori di piattaforma interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la gestione di LLM su hardware GPU H100, A100 ed L4.
Al termine di questa guida, dovresti essere in grado di eseguire le seguenti operazioni:
- Prepara l'ambiente con un cluster GKE in modalità Autopilot.
- Esegui il deployment di TGI nel tuo cluster.
- Usate il TGI per fornire il modello Gemma 2B o 7B tramite curl e un'interfaccia di chat web.
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.
-
Attiva l'API richiesta.
-
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.
-
Attiva l'API richiesta.
-
Assicurati di disporre dei seguenti ruoli nel progetto: roles/container.admin, roles/iam.serviceAccountAdmin
Verifica i ruoli
-
Nella console Google Cloud, vai alla pagina IAM.
Vai a IAM - Seleziona il progetto.
-
Nella colonna Entità, individua la riga contenente il tuo indirizzo email.
Se il tuo indirizzo email non è in questa colonna, significa che non disponi di alcun ruolo.
- Nella colonna Ruolo per la riga contenente il tuo indirizzo email, controlla se l'elenco dei ruoli include quelli richiesti.
Concedi i ruoli
-
Nella console Google Cloud, vai alla pagina IAM.
Vai a IAM - Seleziona il progetto.
- Fai clic su Concedi l'accesso.
- Nel campo Nuove entità, inserisci il tuo indirizzo email.
- Nell'elenco Seleziona un ruolo, scegli un ruolo.
- Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ciascun ruolo aggiuntivo.
- Fai clic su Salva.
-
- Crea un account Hugging Face, se non ne hai ancora uno.
- Assicurati che il tuo progetto abbia una quota sufficiente per le GPU. Per saperne di più, consulta Informazioni sulle GPU e Quote di allocazione.
Accedi al modello
Per ottenere l'accesso ai modelli Gemma per il deployment in GKE, devi prima firmare il contratto di consenso di licenza, quindi generare un token di accesso Huugging Face.
Firma il contratto di consenso per la licenza
Devi firmare il contratto di consenso per utilizzare Gemma. Segui queste istruzioni:
- Accedi alla pagina relativa al consenso del modello su Kaggle.com.
- Verifica il consenso usando il tuo account Hugging Face.
- Accetta i termini del modello.
Generare un token di accesso
Per accedere al modello tramite la funzionalità Faccina che abbraccia, devi avere un token.
Se non ne hai già uno, segui questi passaggi per generare un nuovo token:
- Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
- Seleziona Nuovo token.
- Specifica un nome a tua scelta e un ruolo di almeno
Read
. - Seleziona Genera un token.
- Copia il token generato negli appunti.
prepara l'ambiente
In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Il software necessario per questo tutorial è preinstallato in Cloud Shell, tra cui kubectl
e
gcloud CLI.
Per configurare il tuo 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 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 REGION=REGION export CLUSTER_NAME=tgi export HF_TOKEN=HF_TOKEN
Sostituisci i seguenti valori:
- PROJECT_ID: il tuo ID progetto Google Cloud.
- REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio
us-central1
per la GPU L4. - HF_TOKEN: il token Sorpresa che hai generato in precedenza.
crea e configura 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 cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare 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.
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 nodi 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 cluster standard:
gcloud container clusters create ${CLUSTER_NAME} \ --project=${PROJECT_ID} \ --region=${REGION} \ --workload-pool=${PROJECT_ID}.svc.id.goog \ --release-channel=rapid \ --num-nodes=1
La creazione del cluster potrebbe richiedere diversi minuti.
Esegui questo comando per creare un pool di nodi per il tuo cluster:
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \ --project=${PROJECT_ID} \ --location=${REGION} \ --node-locations=${REGION}-a \ --cluster=${CLUSTER_NAME} \ --machine-type=g2-standard-24 \ --num-nodes=1
GKE crea un singolo pool di nodi contenente due GPU L4 per ogni nodo.
Crea un secret Kubernetes per le credenziali di Hugging Face
In Cloud Shell, segui questi passaggi:
Configura
kubectl
per comunicare con il cluster:gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}
Crea un secret di Kubernetes contenente il token Hugging Face:
kubectl create secret generic hf-secret \ --from-literal=hf_api_token=${HF_TOKEN} \ --dry-run=client -o yaml | kubectl apply -f -
Esegui il deployment di TGI
In questa sezione, eseguirai il deployment del container TGI per gestire il modello Gemma che vuoi utilizzare. Per informazioni sui modelli ottimizzati e preaddestrati per le istruzioni e su quale scegliere per il tuo caso d'uso, consulta Modelli ottimizzati.
Esegui il deployment di un modello Gemma ottimizzato per le istruzioni
Segui queste istruzioni se vuoi eseguire il deployment di una variante o di un modello Gemma ottimizzato per le istruzioni.
Gemma 2Bit
Segui queste istruzioni per eseguire il deployment del modello ottimizzato per le istruzioni Gemma 2B.
Crea il seguente manifest
tgi-2b-it.yaml
:Applica il manifest:
kubectl apply -f tgi-2b-it.yaml
Gemma 7B-it
Segui queste istruzioni per eseguire il deployment del modello ottimizzato per le istruzioni Gemma 7B.
Crea il seguente manifest
tgi-7b-it.yaml
:Applica il manifest:
kubectl apply -f tgi-7b-it.yaml
CodeGemma 7B-it
Segui queste istruzioni per eseguire il deployment del modello ottimizzato per le istruzioni CodeGemma 7B.
Crea il seguente manifest
tgi-codegemma-1.1-7b-it.yaml
:Applica il manifest:
kubectl apply -f tgi-codegemma-1.1-7b-it.yaml
Deployment di un modello Gemma preaddestrato
Segui queste istruzioni se vuoi eseguire il deployment di una variante o un modello Gemma preaddestrato.
Gemma 2B
Segui queste istruzioni per eseguire il deployment del modello preaddestrato di Gemma 2B.
Crea il seguente manifest
tgi-2b.yaml
:Applica il manifest:
kubectl apply -f tgi-2b.yaml
Gemma 7B
Segui queste istruzioni per eseguire il deployment del modello preaddestrato di Gemma 2B.
Crea il seguente manifest
tgi-7b.yaml
:Applica il manifest:
kubectl apply -f tgi-7b.yaml
CodeGemma 2B
Segui queste istruzioni per eseguire il deployment del modello preaddestrato di CodeGemma 2B.
Crea il seguente manifest
tgi-codegemma-1.1-2b.yaml
:Applica il manifest:
kubectl apply -f tgi-codegemma-1.1-2b.yaml
Un pod nel cluster scarica i pesi del modello da Faccia abbracciante e avvia il motore di pubblicazione.
Attendi che il deployment sia disponibile:
kubectl wait --for=condition=Available --timeout=700s deployment/tgi-gemma-deployment
Visualizza i log del deployment in esecuzione:
kubectl logs -f -l app=gemma-server
La risorsa Deployment scarica i dati del modello. Questa procedura può richiedere alcuni minuti. L'output è simile al seguente:
2024-05-08T20:27:37.557836Z INFO text_generation_router: router/src/main.rs:317: Warming up model
2024-05-08T20:27:39.206371Z INFO text_generation_launcher: Cuda Graphs are enabled for sizes [1, 2, 4, 8, 16, 32]
2024-05-08T20:27:40.461998Z INFO text_generation_router: router/src/main.rs:354: Setting max batch total tokens to 632992
2024-05-08T20:27:40.462018Z INFO text_generation_router: router/src/main.rs:355: Connected
2024-05-08T20:27:40.462025Z WARN text_generation_router: router/src/main.rs:369: Invalid hostname, defaulting to 0.0.0.0
Assicurati che il modello sia stato scaricato completamente prima di passare alla sezione successiva.
Pubblica il modello
In questa sezione interagisci con il modello.
Configura il port forwarding
Esegui questo comando per configurare il port forwarding al modello:
kubectl port-forward service/llm-service 8000:8000
L'output è simile al seguente:
Forwarding from 127.0.0.1:8000 -> 8000
Interagisci con il modello utilizzando curl
Questa sezione mostra come eseguire un test del fumo di base per verificare i modelli preaddestrati di deployment o ottimizzati per le istruzioni. Per semplicità, questa sezione descrive l'approccio di test utilizzando i modelli preaddestrati di Gemma 2B, ottimizzati per le istruzioni Gemma 2B e ottimizzati per le istruzioni CodeGemma 7B.
Gemma 2B
In una nuova sessione del terminale, utilizza curl
per chattare con il modello:
USER_PROMPT="Java is a"
curl -X POST http://localhost:8000/generate \
-H "Content-Type: application/json" \
-d @- <<EOF
{
"inputs": "${USER_PROMPT}",
"parameters": {
"temperature": 0.90,
"top_p": 0.95,
"max_new_tokens": 128
}
}
EOF
L'output seguente mostra un esempio di risposta del modello:
{"generated_text":" general-purpose, high-level, class-based, object-oriented programming language. <strong>Is Java a statically typed language?</strong> Yes, Java is a statically typed language. Java also supports dynamic typing. Static typing means that the type of every variable is explicitly specified at the time of declaration. The type can be either implicit or explicit. Static typing means that if no types are assigned then it will be assumed as a primitive type.\n\n<h3>What is Java?</h3>\n\nJava is a general-purpose, class-based, object-oriented programming language. Java is one of the oldest programming languages that has gained a"}
Gemma 2Bit
In una nuova sessione del terminale, utilizza curl
per chattare con il 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 http://localhost:8000/generate \
-H "Content-Type: application/json" \
-d @- <<EOF
{
"inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
"parameters": {
"temperature": 0.90,
"top_p": 0.95,
"max_new_tokens": 128
}
}
EOF
L'output seguente mostra un esempio di risposta del modello:
{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}
CodeGemma
In una nuova sessione del terminale, utilizza curl
per chattare con il modello:
USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"
curl -s -X POST http://localhost:8000/generate \
-H "Content-Type: application/json" \
-d @- <<EOF | jq -r .generated_text
{
"inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
"parameters": {
"temperature": 0.90,
"top_p": 0.95,
"max_new_tokens": 2000
}
}
EOF
L'output seguente mostra un esempio di risposta del modello:
def addNumbers(num1, num2):
sum = num1 + num2
return sum
# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
# Call the addNumbers function
sum = addNumbers(num1, num2)
# Print the result
print("The sum of", num1, "and", num2, "is", sum)
(Facoltativo) Interagisci con il modello tramite un'interfaccia della chat di Gradio
In questa sezione creerai un'applicazione di chat web che ti consente di interagire con il tuo modello ottimizzato per le istruzioni. Per semplicità, questa sezione descrive solo l'approccio di test con il modello 2B-it.
Gradio è una libreria Python con un wrapper
ChatInterface
che crea le interfacce utente per i chatbot.
Eseguire il deployment dell'interfaccia della chat
In Cloud Shell, salva il manifest seguente come
gradio.yaml
:Applica il manifest:
kubectl apply -f gradio.yaml
Attendi che il deployment sia disponibile:
kubectl wait --for=condition=Available --timeout=300s deployment/gradio
Utilizzare l'interfaccia della chat
In Cloud Shell, esegui questo comando:
kubectl port-forward service/gradio 8080:8080
Viene creato un port forwarding da Cloud Shell al servizio Gradio.
Fai clic sul pulsante
Anteprima web in alto a destra della barra delle applicazioni di Cloud Shell. Fai clic su Anteprima sulla porta 8080. Nel browser si apre una nuova scheda.
Interagisci con Gemma utilizzando l'interfaccia della chat Gradio. Aggiungi un prompt e fai clic su Invia.
Risoluzione dei problemi
- Se ricevi il messaggio
Empty reply from server
, è possibile che il container non abbia completato il download dei dati del modello. Controlla di nuovo nei log del pod il messaggioConnected
che indica che il modello è pronto per essere pubblicato. - 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 create 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 utilizzare Gemma con TGI su altri acceleratori, incluse le GPU A100 e H100, visualizzando il codice campione in GitHub.
- Scopri come eseguire il deployment dei carichi di lavoro GPU in Autopilot.
- Scopri come eseguire il deployment dei carichi di lavoro delle GPU in Standard.
- Consulta la documentazione del TGI.
- Esplora Vertex AI Model Garden.
- Scopri come eseguire carichi di lavoro AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.