Questo tutorial mostra come ottimizzare Gemma, una famiglia di modelli linguistici di grandi dimensioni (LLM) aperti, utilizzando unità di elaborazione grafica (GPU) su Google Kubernetes Engine (GKE) con la libreria Transformers di Hugging Face. L'ottimizzazione è un processo di apprendimento supervisionato che migliora la capacità di un modello preaddestrato di svolgere attività specifiche aggiornando i suoi parametri con un nuovo set di dati. In questo tutorial, scaricherai i modelli preaddestrati della famiglia Gemma con 2 miliardi di parametri da Hugging Face e li perfezionerai su un cluster GKE Autopilot o Standard.
Questa guida è un buon punto di partenza se hai bisogno del controllo granulare, della scalabilità, della resilienza, della portabilità e dell'economicità di Kubernetes gestito durante l'ottimizzazione di un LLM.
Prova la nostra soluzione Vertex AI se hai bisogno di una piattaforma di AI gestita unificata per creare e pubblicare rapidamente modelli ML in modo conveniente.
Sfondo
Se utilizzi Gemma con le GPU su GKE con la libreria Transformers, puoi implementare una soluzione di gestione dell'inferenza solida e pronta per la produzione con tutti i vantaggi di Kubernetes gestito, tra cui scalabilità efficiente e maggiore disponibilità. Questa sezione descrive le tecnologie chiave utilizzate in questa guida.
Gemma
Gemma è un insieme di modelli di intelligenza artificiale (AI) generativa leggeri e disponibili pubblicamente rilasciati con una licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione nelle tue applicazioni, hardware, dispositivi mobili o servizi ospitati.
In questa guida presentiamo Gemma per la generazione di testo. Puoi anche ottimizzare questi modelli per specializzarli nell'esecuzione di attività specifiche.
Il set di dati utilizzato in questo documento è b-mc2/sql-create-context.
Per saperne di più, consulta la documentazione di Gemma.
GPU
Le GPU ti consentono di accelerare carichi di lavoro specifici in esecuzione sui tuoi nodi, come machine learning ed elaborazione di dati. GKE offre una gamma di opzioni di tipo 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à delle versioni attuali delle GPU
- Scopri di più sulle GPU in GKE
Hugging Face Transformers
Con la libreria Transformers di Hugging Face, puoi accedere a modelli preaddestrati all'avanguardia. La libreria Transformers ti consente di ridurre i tempi, le risorse e i costi di calcolo associati all'addestramento completo del modello.
In questo tutorial, utilizzerai le API e gli strumenti Hugging Face per scaricare e ottimizzare questi modelli preaddestrati.
Ottenere l'accesso al modello
Per accedere ai modelli Gemma per il deployment su GKE, devi prima firmare il contratto di consenso alla licenza, quindi generare un token di accesso Hugging Face.
Firmare il contratto di consenso alla licenza
Per utilizzare Gemma devi firmare il contratto di consenso. Segui queste istruzioni:
- Accedi alla pagina del consenso del modello su Kaggle.com.
- Verifica il consenso utilizzando il tuo account Hugging Face.
- Accetta i termini del modello.
Generare un token di accesso
Per accedere al modello tramite Hugging Face, è necessario un token Hugging Face.
Segui questi passaggi per generare un nuovo token se non ne hai già uno:
- Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
- Seleziona Nuovo token.
- Specifica un nome a tua scelta e un ruolo di almeno
Write
. - 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. Cloud Shell include il software preinstallato necessario
per questo tutorial, tra cui
kubectl
e
gcloud CLI.
Per configurare l'ambiente con Cloud Shell:
Nella console Google Cloud , avvia una sessione di Cloud Shell facendo clic su
Attiva Cloud Shell nella consoleGoogle 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 CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION export CLUSTER_NAME=CLUSTER_NAME export HF_TOKEN=HF_TOKEN export HF_PROFILE=HF_PROFILE
Sostituisci i seguenti valori:
PROJECT_ID
: il tuo Google Cloud ID progetto.CONTROL_PLANE_LOCATION
: la regione di Compute Engine del control plane del tuo cluster. Fornisci una regione che supporti il tipo di acceleratore che vuoi utilizzare, ad esempious-central1
per le GPU L4.CLUSTER_NAME
: il nome del tuo cluster.HF_TOKEN
: il token Hugging Face che hai generato in precedenza.HF_PROFILE
: l'ID profilo Hugging Face che hai creato in precedenza.
Clona il repository del codice campione da GitHub:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/ai-ml/llm-finetuning-gemma
Creare e configurare 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. Per scegliere la modalità operativa GKE più adatta ai tuoi workload, consulta Scegliere una modalità operativa GKE.
Utilizza Autopilot per un'esperienza Kubernetes completamente gestita.
Autopilot
In Cloud Shell, esegui questo comando:
gcloud container clusters create-auto CLUSTER_NAME \
--project=PROJECT_ID \
--location=CONTROL_PLANE_LOCATION \
--release-channel=rapid \
--cluster-version=1.29
Sostituisci i seguenti valori:
PROJECT_ID
: il tuo Google Cloud ID progetto.CONTROL_PLANE_LOCATION
: la regione di Compute Engine del control plane del tuo cluster. Fornisci una regione che supporti il tipo di acceleratore che vuoi utilizzare, ad esempious-central1
per le GPU L4.CLUSTER_NAME
: il nome del tuo cluster.
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 \ --location=CONTROL_PLANE_LOCATION \ --workload-pool=PROJECT_ID.svc.id.goog \ --release-channel=rapid \ --num-nodes=1
Sostituisci i seguenti valori:
PROJECT_ID
: il tuo Google Cloud ID progetto.CONTROL_PLANE_LOCATION
: la regione di Compute Engine del control plane del tuo cluster. Fornisci una regione che supporti il tipo di acceleratore che vuoi utilizzare, ad esempious-central1
per le GPU L4.CLUSTER_NAME
: il nome del tuo cluster.
La creazione del cluster potrebbe richiedere diversi minuti.
Esegui questo comando per creare un node pool per il tuo cluster:
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=8,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --node-locations=CONTROL_PLANE_LOCATION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-96 \ --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:
Configura
kubectl
per comunicare con il cluster:gcloud container clusters get-credentials CLUSTER_NAME \ --location=CONTROL_PLANE_LOCATION
Sostituisci i seguenti valori:
CONTROL_PLANE_LOCATION
: la regione di Compute Engine del piano di controllo del cluster.CLUSTER_NAME
: il nome del tuo cluster.
Crea un secret di Kubernetes che contenga 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 -
Sostituisci
$HF_TOKEN
con il token Hugging Face che hai generato in precedenza o utilizza la variabile di ambiente se l'hai impostata.
Crea un container di perfezionamento con Docker e Cloud Build
Questo container utilizza il codice PyTorch e Hugging Face Transformers per ottimizzare il modello Gemma preaddestrato esistente.
Crea un repository Docker di Artifact Registry:
gcloud artifacts repositories create gemma \ --project=PROJECT_ID \ --repository-format=docker \ --location=us \ --description="Gemma Repo"
Sostituisci
PROJECT_ID
con l'ID progetto Google Cloud.Crea ed esegui il push dell'immagine:
gcloud builds submit .
Esporta
IMAGE_URL
per utilizzarlo in un secondo momento in questo tutorial.export IMAGE_URL=us-docker.pkg.dev/PROJECT_ID/gemma/finetune-gemma-gpu:1.0.0
Esegui un job di perfezionamento su GKE
In questa sezione, esegui il deployment del job di ottimizzazione di Gemma. Un controller Job in Kubernetes crea uno o più pod e assicura che eseguano correttamente un'attività specifica.
Apri il file
finetune.yaml
.Applica il manifest per creare il job di perfezionamento:
envsubst < finetune.yaml | kubectl apply -f -
Questa istruzione sostituisce
IMAGE_URL
con la variabile nel manifest.Monitora il job eseguendo questo comando:
watch kubectl get pods
Controlla i log del job eseguendo questo comando:
kubectl logs job.batch/finetune-job -f
La risorsa Job scarica i dati del modello e poi lo perfeziona su tutte le otto GPU. Questa operazione può richiedere fino a 20 minuti.
Al termine del job, vai al tuo account Hugging Face. Nel tuo profilo Hugging Face viene visualizzato un nuovo modello denominato
HF_PROFILE/gemma-2b-sql-finetuned
.
Gestisci il modello ottimizzato su GKE
In questa sezione, esegui il deployment del container vLLM
per pubblicare il modello Gemma. Questo tutorial utilizza un deployment Kubernetes per eseguire il deployment del container vLLM
. Un deployment è un oggetto API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.
Crea il seguente manifest
serve-gemma.yaml
:Crea la variabile di ambiente per il nuovo
MODEL_ID
:export MODEL_ID=HF_PROFILE/gemma-2b-sql-finetuned
Sostituisci
HF_PROFILE
con l'ID del profilo Hugging Face che hai creato in precedenza.Sostituisci
MODEL_ID
nel manifest:sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml
Applica il manifest:
kubectl apply -f serve-gemma.yaml
Un pod nel cluster scarica i pesi del modello da Hugging Face e avvia il motore di pubblicazione.
Attendi che il deployment sia disponibile:
kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment
Visualizza i log del deployment in esecuzione:
kubectl logs -f -l app=gemma-server
La risorsa Deployment scarica i dati del modello. Questo processo può richiedere alcuni minuti. L'output è simile al seguente:
INFO 01-26 19:02:54 model_runner.py:689] Graph capturing finished in 4 secs.
INFO: Started server process [1]
INFO: Waiting for application startup.
INFO: Application startup complete.
INFO: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
Assicurati che il modello sia stato scaricato completamente prima di procedere alla sezione successiva.
Pubblica il modello
In questa sezione, interagisci con il modello.
Configurare il port forwarding
Una volta eseguito il deployment del modello, 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
In una nuova sessione del terminale, utilizza curl
per chattare con il tuo modello:
Il seguente comando di esempio è per TGI:
USER_PROMPT="Question: What is the total number of attendees with age over 30 at kubecon eu? Context: CREATE TABLE attendees (name VARCHAR, age INTEGER, kubecon VARCHAR)"
curl -X POST http://localhost:8000/generate \
-H "Content-Type: application/json" \
-d @- <<EOF
{
"prompt": "${USER_PROMPT}",
"temperature": 0.1,
"top_p": 1.0,
"max_tokens": 24
}
EOF
L'output seguente mostra un esempio di risposta del modello:
{"generated_text":" Answer: SELECT COUNT(age) FROM attendees WHERE age > 30 AND kubecon = 'eu'\n"}
A seconda della query, potrebbe essere necessario modificare max_token
per ottenere un risultato migliore. Puoi anche utilizzare il modello ottimizzato per le istruzioni per una migliore esperienza di chat.