Ottimizzare i modelli open Gemma utilizzando più GPU su GKE

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.

Best practice:

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:

  1. Scopri di più sulla disponibilità delle versioni attuali delle GPU
  2. 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.

Per utilizzare Gemma devi firmare il contratto di consenso. Segui queste istruzioni:

  1. Accedi alla pagina del consenso del modello su Kaggle.com.
  2. Verifica il consenso utilizzando il tuo account Hugging Face.
  3. 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:

  1. Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
  2. Seleziona Nuovo token.
  3. Specifica un nome a tua scelta e un ruolo di almeno Write.
  4. Seleziona Genera un token.
  5. 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:

  1. Nella console Google Cloud , avvia una sessione di Cloud Shell facendo clic su Icona di attivazione di Cloud Shell Attiva Cloud Shell nella consoleGoogle Cloud . Viene avviata una sessione nel riquadro inferiore della console Google Cloud .

  2. 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 esempio us-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.

  3. 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.

Best practice:

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 esempio us-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

  1. 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 esempio us-central1 per le GPU L4.
    • CLUSTER_NAME: il nome del tuo cluster.

    La creazione del cluster potrebbe richiedere diversi minuti.

  2. 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:

  1. 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.

  2. 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.

  1. 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.

  2. Crea ed esegui il push dell'immagine:

    gcloud builds submit .

  3. 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.

  1. Apri il file finetune.yaml.

    apiVersion: batch/v1
kind: Job
metadata:
  name: finetune-job
  namespace: default
spec:
  backoffLimit: 2
  template:
    metadata:
      annotations:
        kubectl.kubernetes.io/default-container: finetuner
    spec:
      terminationGracePeriodSeconds: 600
      containers:
      - name: finetuner
        image: $IMAGE_URL
        resources:
          limits:
            nvidia.com/gpu: "8"
        env:
        - name: MODEL_NAME
          value: "google/gemma-2b"
        - name: NEW_MODEL
          value: "gemma-2b-sql-finetuned"
        - name: LORA_R
          value: "8"
        - name: LORA_ALPHA
          value: "16"
        - name: TRAIN_BATCH_SIZE
          value: "1"
        - name: EVAL_BATCH_SIZE
          value: "2"
        - name: GRADIENT_ACCUMULATION_STEPS
          value: "2"
        - name: DATASET_LIMIT
          value: "1000"
        - name: MAX_SEQ_LENGTH
          value: "512"
        - name: LOGGING_STEPS
          value: "5"
        - name: HF_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      restartPolicy: OnFailure

  2. 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.

  3. Monitora il job eseguendo questo comando:

    watch kubectl get pods

  4. 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.

  5. 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.

  1. Crea il seguente manifest serve-gemma.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-2b
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

  2. 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.

  3. Sostituisci MODEL_ID nel manifest:

    sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml

  4. 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.

  5. Attendi che il deployment sia disponibile:

    kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment

  6. 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.