Ottimizzare i modelli aperti di Gemma utilizzando più GPU su GKE

Questo tutorial mostra come ottimizzare la famiglia di modelli aperti (LLM), modello linguistico di grandi dimensioni (LLM) di Gemma utilizzando le unità di elaborazione grafiche (GPU) su Google Kubernetes Engine (GKE) con la libreria Transformers di Hugging Face. L'ottimizzazione fine è un processo di apprendimento supervisionato che migliora la capacità di un modello preaddestrato di eseguire attività specifiche aggiornandone i parametri con un nuovo set di dati. In questo tutorial, scarichi i modelli della famiglia Gemma preaddestrati con 2 miliardi di parametri da Hugging Face e li perfezioni 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 per perfezionare un modello LLM.

Best practice:

Prova la nostra soluzione Vertex AI se hai bisogno di una piattaforma di IA gestita unificata per creare e pubblicare rapidamente modelli ML in modo economico.

Sfondo

Se utilizzi Gemma con GPU su GKE con la libreria Transformers, puoi implementare una soluzione di servizio di inferenza affidabile 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 IA possono essere eseguiti nelle tue applicazioni, nel tuo hardware, sui tuoi dispositivi mobili o nei tuoi servizi ospitati.

In questa guida presentiamo Gemma per la generazione di testo. Puoi anche ottimizzare questi modelli in modo che si specializzino 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 il machine learning e l'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 GPU attuali
  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 di Hugging Face per scaricare e perfezionare questi modelli preaddestrati.

Obiettivi

Questa guida è rivolta a utenti nuovi o esistenti di GKE, ML Engineers, MLOps (DevOps) Engineers o amministratori della piattaforma che sono interessato a utilizzare le funzionalità di orchestrazione dei container Kubernetes per ottimizzare i modelli LLM su hardware GPU H100, A100 e L4.

Al termine di questa guida, dovresti essere in grado di eseguire i seguenti passaggi:

  1. Prepara l'ambiente con un cluster GKE in modalità Autopilot.
  2. Crea un contenitore di ottimizzazione.
  3. Utilizza la GPU per perfezionare il modello Gemma 2B e caricarlo su Hugging Face.

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.

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

    •

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

    •

  • Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

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

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

    1. In the Google Cloud console, go to the IAM page.

      Vai a IAM
    2. Seleziona il progetto.
    3. Fai clic su Concedi accesso.

    4. Nel campo Nuove entità, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.

    5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
    6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
    7. Fai clic su Salva.

Ottieni l'accesso al modello

Per accedere ai modelli Gemma per il deployment in GKE, devi prima firmare il contratto di consenso per la licenza e poi generare un token di accesso a Hugging Face.

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

  1. Accedi alla pagina del consenso per i modelli su Kaggle.com.
  2. Verifica il consenso utilizzando il tuo account Hugging Face.
  3. Accetta i termini del modello.

Genera un token di accesso

Per accedere al modello tramite Hugging Face, devi disporre di un token Hugging Face.

Se non ne hai già uno, segui questi passaggi per generare un nuovo token:

  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 di cui avrai bisogno per questo tutorial, tra cui kubectl e gcloud CLI.

Per configurare l'ambiente con Cloud Shell:

  1. Nella console Google Cloud, avvia una sessione Cloud Shell facendo clic su Icona di attivazione di Cloud Shell Attiva Cloud Shell nella console Google 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 REGION=REGION
export CLUSTER_NAME=finetuning
export HF_TOKEN=HF_TOKEN
export HF_PROFILE=HF_PROFILE

    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 Hugging Face che hai generato in precedenza.
    • HF_PROFILE: l'ID profilo Hugging Face che hai creato in precedenza.

  3. Clona il repository di 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 eseguire Gemma su GPU in un cluster GKE Autopilot o Standard. Per scegliere la modalità operativa di GKE più adatta ai tuoi carichi di lavoro, 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} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.29

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 il comando seguente 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.

  2. Esegui il comando seguente per creare un pool di nodi per il cluster:

    gcloud container node-pools create gpupool \
  --accelerator type=nvidia-l4,count=8,gpu-driver-version=latest \
  --project=${PROJECT_ID} \
  --location=${REGION} \
  --node-locations=${REGION}-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 di 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=${REGION}

  2. Crea un secret di Kubernetes contenente il token di Hugging Face:

    kubectl create secret generic hf-secret \
  --from-literal=hf_api_token=${HF_TOKEN} \
  --dry-run=client -o yaml | kubectl apply -f -

Creare un container di ottimizzazione fine con Docker e Cloud Build

Questo contenitore utilizza il codice di 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"

  2. Crea ed esegui il push dell'immagine

    gcloud builds submit .

  3. Esporta il file 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 ottimizzazione su GKE

Esegui il deployment del job di ottimizzazione fine di Gemma

  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 ottimizzazione fine:

    envsubst < finetune.yaml | kubectl apply -f -

    Questa istruzione sostituisce IMAGE_URL con la variabile nel manifest.

  3. Monitora il job eseguendo il seguente comando:

    watch kubectl get pods

  4. Controlla i log del job eseguendo il seguente comando:

    kubectl logs job.batch/finetune-job -f

    La risorsa Job scarica i dati del modello e poi perfeziona il modello su tutte le 8 GPU. L'operazione potrebbe 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.

Pubblica il modello ottimizzato su GKE

In questa sezione, esegui il deployment del contenitore vLLM per pubblicare il modello Gemma.

  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: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20240220_0936_RC01
        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.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        env:
        - 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. Creare una variabile di ambiente per il nuovo MODEL_ID 

    export MODEL_ID=$HF_PROFILE/gemma-2b-sql-finetuned

  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. Questa operazione 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 il seguente 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

Interagire 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

Il seguente output 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 basato su istruzioni per un'esperienza di chat migliore.

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 che hai creato in questa guida, esegui il seguente comando:

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

Passaggi successivi