Questa pagina è stata tradotta dall'API Cloud Translation.

Pubblicare modelli aperti Gemma utilizzando TPU su GKE con Saxml

Standard

Questa guida mostra come gestire un modello linguistico di grandi dimensioni (LLM) di Gemma open models utilizzando le unità di elaborazione tensoriale (TPU) su Google Kubernetes Engine (GKE) con Saxml. In questa guida, scarichi i modelli Gemma ottimizzati per le istruzioni sui parametri 2B e 7B su Cloud Storage ed esegui il loro deployment su un cluster GKE Standard utilizzando i contenitori che eseguono Saxml.

Questa guida è un buon punto di partenza se hai bisogno della scalabilità, della resilienza e del rapporto costi/benefici offerti dalle funzionalità di Kubernetes durante il deployment del modello su Saxml.

Se hai bisogno di una piattaforma di IA gestita unificata per creare e pubblicare rapidamente modelli ML in modo economico, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.

Sfondo

Se utilizzi Gemma con TPU su GKE e Saxml, puoi implementare una soluzione di generazione di inferenze affidabile e pronta per la produzione con tutti i vantaggi di Kubernetes gestito, inclusa una scalabilità efficiente e una maggiore disponibilità. Questa sezione descrive le tecnologie chiave utilizzate in questo tutorial.

Gemma

Gemma è un insieme di modelli di 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 in hosting. Puoi utilizzare i modelli Gemini per la generazione di testo e ottimizzarli per attività specializzate.

Per saperne di più, consulta la documentazione di Gemma.

TPU

Le TPU sono circuiti integrati per applicazioni specifiche (ASIC) sviluppati da Google e utilizzati per accelerare framework di elaborazione dei dati come TensorFlow, PyTorch e JAX.

Prima di utilizzare le TPU in GKE, ti consigliamo di completare il seguente percorso di apprendimento:

Scopri la disponibilità attuale delle versioni TPU con l'architettura di sistema Cloud TPU.
Scopri di più sulle TPU in GKE.

Questo tutorial è rivolto ai modelli Gemma 2B e Gemma 7B. GKE ospita questi modelli sui seguenti pool di nodi TPU v5e a host singolo:

Gemma 2B: modello ottimizzato per le istruzioni ospitato in un pool di nodi TPU v5e con topologia 1x1 che rappresenta un chip TPU. Il tipo di macchina per i nodi è ct5lp-hightpu-1t.
Gemma 7B: modello ottimizzato per le istruzioni ospitato in un pool di nodi TPU v5e con topologia 2x2 che rappresenta quattro chip TPU. Il tipo di macchina per i nodi è ct5lp-hightpu-4t.

Saxml

Saxml è un sistema sperimentale che serve modelli Paxml, JAX e PyTorch per l'inferenza. Il sistema Saxml include i seguenti componenti:

Cella saxml o cluster Sax: un server di amministrazione e un gruppo di server di modelli. Il server di amministrazione tiene traccia dei server dei modelli, assegna i modelli pubblicati ai server dei modelli da pubblicare e aiuta i client a individuare i server dei modelli che pubblicano modelli pubblicati specifici.
Client Saxml: l'interfaccia di programmazione rivolta all'utente per il sistema Saxml. Il client Saxml include uno strumento a riga di comando (saxutil) e una suite di librerie client in Python, C++ e Go.

In questo tutorial utilizzerai anche il server HTTP Saxml. Il server HTTP Saxml è un server HTTP personalizzato che incapsula la libreria client Python di Saxml ed espone API REST per interagire con il sistema Saxml. Le API REST includono endpoint per pubblicare, elencare, annullare la pubblicazione di modelli e generare previsioni.

Obiettivi

Questo tutorial è rivolto ai clienti di IA generativa che utilizzano JAX, nonché agli utenti nuovi o esistenti di GKE che vogliono utilizzare le funzionalità di orchestrazione dei container Kubernetes per pubblicare Gemma, ad esempio ingegneri ML, ingegneri MLOps (DevOps) e amministratori della piattaforma.

Questo tutorial illustra i seguenti passaggi:

Prepara un cluster GKE Standard con la topologia TPU consigliata in base alle caratteristiche del modello.
Esegui il deployment dei componenti di Saxml su GKE.
Recupera e pubblica il modello di parametri Gemma 2B o Gemma 7B.
Pubblicare e interagire con i modelli pubblicati.

Architettura

Questa sezione descrive l'architettura GKE utilizzata in questo tutorial. L'architettura comprende un cluster GKE Standard che provisiona le TPU e ospita i componenti Saxml per eseguire il deployment e pubblicare i modelli Gemma 2B o 7B. Il seguente diagramma mostra i componenti di questa architettura:

Un diagramma dell'architettura di cui è stato eseguito il deployment in questo tutorial

Questa architettura include i seguenti componenti:

Un cluster GKE Standard zonale.
Un pool di nodi della sezione TPU a un solo host che dipende dal modello Gemma che vuoi pubblicare:
- Gemma 2B: configurato con una TPU v5e con una topologia 1x1. Un'istanza del server del modello Saxml è configurata per utilizzare questo pool di nodi.
- Gemma 7B: configurato con una TPU v5e con una topologia 2x2. Un'istanza del server del modello Saxml è configurata per utilizzare questo pool di nodi.
Un pool di nodi CPU predefinito in cui sono dipiamente il server Saxml Admin e il server HTTP Saxml.
Due bucket Cloud Storage:
- Un bucket Cloud Storage archivia lo stato gestito da un server di amministrazione.
- Un bucket Cloud Storage memorizza i checkpoint del modello Gemma.

Questa architettura presenta le seguenti caratteristiche:

Un Artifact Registry pubblico gestisce le immagini container per i componenti Saxml.
Il cluster GKE utilizza Workload Identity Federation for GKE. Tutti i componenti di Saxml utilizzano una federazione Workload Identity che integra un account di servizio IAM per accedere a servizi esterni come i bucket Cloud Storage.
I log generati dai componenti Saxml sono integrati in Cloud Logging.
Puoi utilizzare Cloud Monitoring per analizzare le metriche sul rendimento dei pool di nodi GKE, come quelli creati in questo tutorial.

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.

Assicurati di disporre di quote sufficienti per 5 chip TPU v5e. In questo tutorial utilizzerai le istanze on demand.
Crea un account Kaggle, se non ne hai già uno.

Prepara l'ambiente per Gemma

Avvia Cloud Shell

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell è preinstallato con il software necessario per questo tutorial, tra cui kubectl e gcloud CLI.

Nella console Google Cloud, avvia un'istanza Cloud Shell:
Apri Cloud Shell
Imposta le variabili di ambiente predefinite:
```
gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=saxml-tpu
```
Sostituisci i seguenti valori:
- PROJECT_ID: il tuo ID progetto Google Cloud.
- LOCATION: il nome della zona Compute Engine in cui sono disponibili i tipi di macchine TPU v5e.

Crea un cluster GKE Standard

In questa sezione, crei il cluster GKE e il pool di nodi.

Gemma 2B-it

Utilizza Cloud Shell per:

Crea un cluster standard che utilizza Workload Identity Federation for GKE:

gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --release-channel=rapid \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${LOCATION}

La creazione del cluster può richiedere diversi minuti.

Crea un pool di nodi TPU v5e con una topologia 1x1 e un nodo:

gcloud container node-pools create tpu-v5e-1x1 \
    --cluster=${CLUSTER_NAME} \
    --machine-type=ct5lp-hightpu-1t \
    --num-nodes=1 \
    --location=${LOCATION}

In questo pool di nodi viene pubblicato il modello Gemma 2B.

Gemma 7B-it

Utilizza Cloud Shell per:

Crea un cluster standard che utilizza Workload Identity Federation for GKE:

gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --release-channel=rapid \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${LOCATION}

La creazione del cluster può richiedere diversi minuti.

Crea un pool di nodi TPU v5e con una topologia 2x2 e un nodo:

gcloud container node-pools create tpu-v5e-2x2 \
    --cluster=${CLUSTER_NAME} \
    --machine-type=ct5lp-hightpu-4t \
    --num-nodes=1 \
    --location=${LOCATION}

In questo pool di nodi viene pubblicato il modello Gemma 7B.

Crea i bucket Cloud Storage

Crea due bucket Cloud Storage per gestire lo stato del server Saxml Admin e i checkpoint del modello.

In Cloud Shell, esegui quanto segue:

Crea un bucket Cloud Storage per archiviare le configurazioni del server Saxml Admin.
```
gcloud storage buckets create gs://ADMIN_BUCKET_NAME
```
Sostituisci ADMIN_BUCKET_NAME con il nome del bucket Cloud Storage che memorizza il server Saxml Admin.
Crea un bucket Cloud Storage per archiviare i checkpoint del modello:
```
gcloud storage buckets create gs://CHECKPOINTS_BUCKET_NAME
```
Sostituisci CHECKPOINTS_BUCKET_NAME con il nome del bucket Cloud Storage che memorizza i checkpoint del modello.

Configurare l'accesso ai carichi di lavoro utilizzando la federazione delle identità per i carichi di lavoro per GKE

Assegna un account di servizio Kubernetes all'applicazione e configuralo in modo che agisca come account di servizio IAM.

Configura kubectl per comunicare con il cluster:

gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${LOCATION}

Crea un account di servizio Kubernetes da utilizzare per la tua applicazione:
```
gcloud iam service-accounts create wi-sax
```

Aggiungi un'associazione del criterio IAM per il tuo account di servizio IAM in modo che possa leggere e scrivere in Cloud Storage:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-sax@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.objectUser

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-sax@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.insightsCollectorService

Consenti all'account di servizio Kubernetes di simulare l'account di servizio IAM aggiungendo un'associazione dei criteri IAM tra i due account di servizio. Questa associazione consente all'account di servizio Kubernetes di agire come account di servizio IAM:
```
gcloud iam service-accounts add-iam-policy-binding wi-sax@${PROJECT_ID}.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
```

Annota l'account di servizio Kubernetes con l'indirizzo email dell'account di servizio IAM:

kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-sax@${PROJECT_ID}.iam.gserviceaccount.com

Ottieni l'accesso al modello

Per accedere ai modelli Gemma per il deployment su GKE, devi accedere alla piattaforma Kaggle, firmare il contratto di consenso alla licenza e ottenere un token API Kaggle. In questo tutorial utilizzi un secret Kubernetes per le credenziali di Kaggle.

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

Accedi alla pagina del consenso per i modelli su Kaggle.com.
Se non l'hai ancora fatto, accedi a Kaggle.
Fai clic su Richiedi accesso.
Nella sezione Scegli account per il consenso, seleziona Verifica tramite account Kaggle per utilizzare il tuo account Kaggle per concedere il consenso.
Accetta i Termini e condizioni del modello.

Genera un token di accesso

Per accedere al modello tramite Kaggle, devi disporre di un token API Kaggle.

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

Nel browser, vai alle impostazioni di Kaggle.
Nella sezione API, fai clic su Crea nuovo token.

Kaggle scarica un file denominato kaggle.json.

Carica il token di accesso in Cloud Shell

In Cloud Shell, puoi caricare il token dell'API Kaggle nel tuo progetto Google Cloud:

In Cloud Shell, fai clic su Altro > Carica.
Seleziona File e fai clic su Scegli file.
Apri il file kaggle.json.
Fai clic su Carica.

Creare un secret Kubernetes per le credenziali di Kaggle

In Cloud Shell:

Configura kubectl per comunicare con il cluster:

gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${LOCATION}

Crea un secret per archiviare le credenziali di Kaggle:

kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json

Esegui il deployment di Saxml

In questa sezione esegui il deployment del server di amministrazione Saxml, dei server di modelli e del server HTTP.

Esegui il deployment del server di amministrazione Saxml

Crea il seguente manifest saxml-admin-server.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-admin-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sax-admin-server
  template:
    metadata:
      labels:
        app: sax-admin-server
    spec:
      hostNetwork: false
      containers:
      - name: sax-admin-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-admin-server:v1.2.0
        securityContext:
          privileged: true
        ports:
        - containerPort: 10000
        env:
        - name: GSBUCKET
          value: ADMIN_BUCKET_NAME

Sostituisci ADMIN_BUCKET_NAME con il nome del bucket che hai creato nella sezione Crea bucket Cloud Storage. Non includere il prefisso gs://.

Applica il manifest:

kubectl apply -f saxml-admin-server.yaml

Verifica il deployment del server di amministrazione:

kubectl get deployment

L'output è simile al seguente:

NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
sax-admin-server                  1/1     1            1           ##s

Esegui il deployment del server di modelli Saxml

Segui queste istruzioni per eseguire il deployment del server del modello per il modello Gemma 2B o Gemma 7B.

Gemma 2B-it

Crea il seguente manifest saxml-model-server-1x1.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-model-server-v5e-1x1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b-it
        ai.gke.io/inference-server: saxml
        examples.ai.gke.io/source: user-guide
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 1x1
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      hostNetwork: false
      restartPolicy: Always
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
        args:
        - "--jax_platforms=tpu"
        - "--platform_chip=tpuv5e"
        - "--platform_topology=1x1"
        - "--port=10001"
        - "--sax_cell=/sax/test"
        ports:
        - containerPort: 10001
        securityContext:
          privileged: true
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
        resources:
          requests:
            google.com/tpu: 1
          limits:
            google.com/tpu: 1

Sostituisci ADMIN_BUCKET_NAME con il nome del bucket che hai creato nella sezione Crea bucket Cloud Storage. Non includere il prefisso gs://.

Applica il manifest:

kubectl apply -f saxml-model-server-1x1.yaml

Verifica lo stato del deployment del server del modello:

kubectl get deployment

L'output è simile al seguente:

NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-1x1                          1/1     Running   0          ##s

Gemma 7B-it

Crea il seguente manifest saxml-model-server-2x2.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-model-server-v5e-2x2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b-it
        ai.gke.io/inference-server: saxml
        examples.ai.gke.io/source: user-guide
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x2
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      hostNetwork: false
      restartPolicy: Always
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
        args:
        - "--jax_platforms=tpu"
        - "--platform_chip=tpuv5e"
        - "--platform_topology=2x2"
        - "--port=10001"
        - "--sax_cell=/sax/test"
        ports:
        - containerPort: 10001
        securityContext:
          privileged: true
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4

Sostituisci ADMIN_BUCKET_NAME con il nome del bucket che hai creato nella sezione Crea bucket Cloud Storage. Non includere il prefisso gs://.

Applica il manifest:

kubectl apply -f saxml-model-server-2x2.yaml

Verifica lo stato del deployment del server del modello:

kubectl get deployment

L'output è simile al seguente:

NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-2x2                          1/1     Running   0          ##s

Esegui il deployment del server HTTP Saxml

In questa sezione esegui il deployment del server HTTP Saxml e crei un servizio Cluster IP che utilizzi per accedere al server.

Crea il seguente manifest saxml-http.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-http
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sax-http
  template:
    metadata:
      labels:
        app: sax-http
    spec:
      hostNetwork: false
      containers:
      - name: sax-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-http:v1.2.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8888
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
---
apiVersion: v1
kind: Service
metadata:
  name: sax-http-svc
spec:
  selector:
    app: sax-http
  ports:
  - protocol: TCP
    port: 8888
    targetPort: 8888
  type: ClusterIP

Sostituisci ADMIN_BUCKET_NAME con il nome del bucket Cloud Storage che memorizza il server Saxml Admin.

Applica il manifest:
```
kubectl apply -f saxml-http.yaml
```

Verifica lo stato del deployment del server HTTP Saxml:

kubectl get deployment

Gemma 2B-it

L'output è simile al seguente:

  NAME                                              READY   STATUS    RESTARTS   AGE
  sax-admin-server                                  1/1     Running   0          ##m
  sax-model-server-v5e-1x1                          1/1     Running   0          ##m
  sax-http                                          1/1     Running   0          ##s

Gemma 7B-it

L'output è simile al seguente:

  NAME                                              READY   STATUS    RESTARTS   AGE
  sax-admin-server                                  1/1     Running   0          ##m
  sax-model-server-v5e-2x2                          1/1     Running   0          ##m
  sax-http                                          1/1     Running   0          ##s

Scarica il checkpoint del modello

In questa sezione esegui un job Kubernetes che recupera, scarica e memorizza il checkpoint del modello. Segui i passaggi per il modello Gemma che vuoi utilizzare:

Gemma 2B-it

Crea il seguente manifest job-2b.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \

    gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-2b
  labels:
    app: data-loader-2b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-2b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
        command:
        - /scripts/fetch_model.sh
        env:
        - name: BUCKET_NAME
          value: CHECKPOINTS_BUCKET_NAME
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/pax/2b-it/2"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts

Sostituisci CHECKPOINTS_BUCKET_NAME con il nome del bucket che hai creato nella sezione Crea bucket Cloud Storage. Non includere il prefisso gs://.

Applica il manifest:
```
kubectl apply -f job-2b.yaml
```

Attendi il completamento del job:

kubectl wait --for=condition=complete --timeout=180s job/data-loader-2b

L'output è simile al seguente:

job.batch/data-loader-2b condition met

Verifica che il job sia stato completato correttamente:

kubectl get job/data-loader-2b

L'output è simile al seguente:

NAME             COMPLETIONS   DURATION   AGE
data-loader-2b   1/1           ##s        #m##s

Visualizza i log del job:

kubectl logs --follow job/data-loader-2b

Il job carica il checkpoint su gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000.

Gemma 7B-it

Crea il seguente manifest job-7b.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \

    gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-7b
  labels:
    app: data-loader-7b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-7b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
        command:
        - /scripts/fetch_model.sh
        env:
        - name: BUCKET_NAME
          value: CHECKPOINTS_BUCKET_NAME
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/pax/7b-it/2"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts

Sostituisci CHECKPOINTS_BUCKET_NAME con il nome del bucket che hai creato nella sezione Crea bucket Cloud Storage. Includi il prefisso gs://.

Applica il manifest:
```
kubectl apply -f job-7b.yaml
```

Attendi il completamento del job:

kubectl wait --for=condition=complete --timeout=360s job/data-loader-7b

L'output è simile al seguente:

job.batch/data-loader-7b condition met

Verifica che il job sia stato completato correttamente:

kubectl get job/data-loader-7b

L'output è simile al seguente:

NAME             COMPLETIONS   DURATION   AGE
data-loader-7b   1/1           ##s        #m##s

Visualizza i log del job:

kubectl logs --follow job/data-loader-7b

Il job carica il checkpoint su gs://CHECKPOINTS_BUCKET_NAME/gemma_7b_it/checkpoint_00000000.

Esponi il server HTTP Saxml

Puoi accedere al server HTTP Saxml tramite il servizio ClusterIP che hai creato durante il deployment del server HTTP Saxml. I servizi ClusterIP sono raggiungibili solo dall'interno del cluster. Pertanto, per accedere al servizio dall'esterno del cluster, completa i seguenti passaggi:

Stabilisci una sessione di port forwarding:

kubectl port-forward service/sax-http-svc 8888:8888

Verifica di poter accedere al server HTTP Saxml aprendo un nuovo terminale ed eseguendo il seguente comando:
```
curl -s localhost:8888
```
L'output è simile al seguente:
```
{
    "Message": "HTTP Server for SAX Client"
}
```

Il server HTTP Saxml incapsula l'interfaccia client del sistema Saxml e la espone tramite un insieme di API REST. Utilizza queste API per pubblicare, gestire e interfacciarti con i modelli Gemma 2B e Gemma 7B.

Pubblicare il modello Gemma

Successivamente, puoi pubblicare il modello Gemma su un server di modelli in esecuzione in un pool di nodi di slice TPU. Per pubblicare un modello, utilizzi l'APIpublish del server HTTP Saxml. Segui questi passaggi per pubblicare il modello di parametri Gemma 2B o 7B.

Per scoprire di più sull'API del server HTTP Saxml, consulta API HTTP Saxml.

Gemma 2B-it

Assicurati che la sessione di inoltro delle porte sia ancora attiva:
```
curl -s localhost:8888
```

Pubblica il parametro Gemma 2B:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/publish \
--data \
'{
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "replicas": "1"
}'

L'output è simile al seguente:

{
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "replicas": 1
}

Consulta il passaggio successivo per monitorare l'avanzamento del deployment.

Monitora l'avanzamento osservando i log in un pod del server di modelli del deploymentsax-model-server-v5e-1x1.

kubectl logs --follow deployment/sax-model-server-v5e-1x1

Il completamento di questo deployment può richiedere fino a cinque minuti. Attendi finché non viene visualizzato un messaggio simile al seguente:

I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma2bfp16

Verifica di poter accedere al modello visualizzandone le informazioni:

curl --request GET \
--header "Content-type: application/json" \
-s \
localhost:8888/listcell \
--data \
'{
    "model": "/sax/test/gemma2bfp16"
}'

L'output è simile al seguente:

{
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "max_replicas": 1,
    "active_replicas": 1
}

Gemma 7B-it

Assicurati che la sessione di inoltro delle porte sia ancora attiva:
```
curl -s localhost:8888
```

Pubblica il parametro Gemma 7B:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/publish \
--data \
'{
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "replicas": "1"
}'

L'output è simile al seguente:

{
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "replicas": 1
}

Consulta il passaggio successivo per monitorare l'avanzamento del deployment.

Monitora l'avanzamento osservando i log in un pod del server di modelli del deploymentsax-model-server-v5e-2x2.

kubectl logs --follow deployment/sax-model-server-v5e-2x2

Attendi finché non viene visualizzato un messaggio simile al seguente:

I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma7bfp16

Verifica che il modello sia stato pubblicato visualizzando le relative informazioni:

curl --request GET \
--header "Content-type: application/json" \
-s \
localhost:8888/listcell \
--data \
'{
    "model": "/sax/test/gemma7bfp16"
}'

L'output è simile al seguente:

{
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "max_replicas": 1,
    "active_replicas": 1
}

usa il modello

Puoi interagire con i modelli Gemma 2B o 7B. Utilizza l'API generate del server HTTP Saxml per inviare un prompt al modello.

Gemma 2B-it

Invia una richiesta di prompt utilizzando l'endpoint generate del server HTTP Saxml:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma2bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

Di seguito è riportato un esempio di risposta del modello. L'output effettivo varia in base al prompt che presenti:

[
    [
        "\n\n1. **Python**\n2. **JavaScript**\n3. **Java**\n4. **C++**\n5. **Go**",
        -3.0704939365386963
    ]
]

Puoi eseguire il comando con diversi parametri query. Puoi anche modificare parametri aggiuntivi come temperature, top_k, topc_p utilizzando l'API generate. Per scoprire di più sull'API del server HTTP Saxml, consulta API HTTP Saxml.

Gemma 7B-it

Invia una richiesta di prompt utilizzando l'endpoint generate del server HTTP Saxml:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma7bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

Di seguito è riportato un esempio di risposta del modello. L'output potrebbe variare in ogni prompt che pubblichi:

[
    [
        "\n\n**1. JavaScript**\n\n* Most widely used language on the web.\n* Used for front-end development, such as websites and mobile apps.\n* Extensive libraries and frameworks available.\n\n**2. Python**\n\n* Known for its simplicity and readability.\n* Versatile, used for various tasks, including data science, machine learning, and web development.\n* Large and active community.\n\n**3. Java**\n\n* Object-oriented language widely used in enterprise applications.\n* Used for web applications, mobile apps, and enterprise software.\n* Strong ecosystem and support.\n\n**4. Go**\n\n",
        -16.806324005126953
    ]
]

Annullare la pubblicazione del modello

Per annullare la pubblicazione del modello:

Gemma 2B-it

Per annullare la pubblicazione del modello Gemma 2B-it, esegui il seguente comando:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma2bfp16"
}'

L'output è simile al seguente:

{
    "model": "/sax/test/gemma2bfp16"
}

Puoi eseguire il comando con diversi prompt che vengono passati nel parametro query.

Gemma 7B-it

Per annullare la pubblicazione del modello Gemma 7B-it, esegui il seguente comando:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma7bfp16"
}'

L'output è simile al seguente:

{
    "model": "/sax/test/gemma7bfp16"
}

Puoi eseguire il comando con diversi prompt che vengono passati nel parametro query.

Risoluzione dei problemi

Se ricevi il messaggio Empty reply from server, è possibile che il contenitore non abbia completato il download dei dati del modello. Controlla di nuovo i log del pod per verificare se è presente il messaggio Connected che indica che il modello è pronto per essere pubblicato.
Se vedi Connection refused, verifica che l'inoltro di porta 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 che hai creato in questa guida, esegui il seguente comando:

gcloud container clusters delete ${CLUSTER_NAME} --location=${LOCATION}
gcloud iam service-accounts delete --quiet wi-sax@${PROJECT_ID}.iam.gserviceaccount.com
gcloud storage rm --recursive gs://ADMIN_BUCKET_NAME
gcloud storage rm --recursive gs://CHECKPOINTS_BUCKET_NAME

Sostituisci quanto segue:

ADMIN_BUCKET_NAME: il nome del bucket Cloud Storage che memorizza il server Saxml Admin.
CHECKPOINTS_BUCKET_NAME: il nome del bucket Cloud Storage che memorizza i checkpoint del modello.

Passaggi successivi

Scopri di più sulle TPU in GKE.
Esplora il repository GitHub di Saxml, incluse le API HTTP Saxml.
Esplora Model Garden di Vertex AI.
Scopri come eseguire carichi di lavoro di AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.
Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.

Pubblicare modelli aperti Gemma utilizzando TPU su GKE con Saxml

Sfondo

Gemma

TPU

Saxml

Obiettivi

Architettura

Prima di iniziare

Check for the roles

Grant the roles

Prepara l'ambiente per Gemma

Avvia Cloud Shell

Crea un cluster GKE Standard

Gemma 2B-it

Gemma 7B-it

Crea i bucket Cloud Storage

Configurare l'accesso ai carichi di lavoro utilizzando la federazione delle identità per i carichi di lavoro per GKE

Ottieni l'accesso al modello

Firmare il contratto di consenso per la licenza

Genera un token di accesso

Carica il token di accesso in Cloud Shell

Creare un secret Kubernetes per le credenziali di Kaggle

Esegui il deployment di Saxml

Esegui il deployment del server di amministrazione Saxml

Esegui il deployment del server di modelli Saxml

Gemma 2B-it

Gemma 7B-it

Esegui il deployment del server HTTP Saxml

Gemma 2B-it

Gemma 7B-it

Scarica il checkpoint del modello

Gemma 2B-it

Gemma 7B-it

Esponi il server HTTP Saxml

Pubblicare il modello Gemma

Gemma 2B-it

Gemma 7B-it

usa il modello

Gemma 2B-it

Gemma 7B-it

Annullare la pubblicazione del modello

Gemma 2B-it

Gemma 7B-it

Risoluzione dei problemi

Esegui la pulizia

Elimina le risorse di cui è stato eseguito il deployment

Passaggi successivi