Pubblicare modelli aperti Gemma utilizzando TPU su GKE con Saxml

Questo tutorial mostra come eseguire il deployment e gestire un modello linguistico di grandi dimensioni (LLM) Gemma 2 utilizzando le TPU su GKE con il framework di gestione Saxml. Questo tutorial fornisce le basi per comprendere ed esplorare l'implementazione pratica di LLM per l'inferenza in un ambiente Kubernetes gestito. Esegui il deployment di un container predefinito con Saxml in GKE. Configuri anche GKE per caricare i pesi di Gemma 2B e 7B da Cloud Storage in fase di runtime.

Questo tutorial è rivolto a ingegneri di machine learning (ML), amministratori e operatori di piattaforme e specialisti di dati e AI interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la pubblicazione di LLM. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti di Trusted Cloud by S3NS , consulta Ruoli utente e attività comuni di GKE Enterprise.

Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:

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

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questo tutorial.

Gemma

Gemma è un insieme di modelli di AI generativa leggeri e disponibili apertamente rilasciati con una licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione nelle tue applicazioni, hardware, dispositivi mobili o servizi ospitati. Puoi utilizzare i modelli Gemma per la generazione di testo e puoi ottimizzarli per attività specializzate.

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

TPU

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

Questo tutorial mostra i modelli Gemma 2B e Gemma 7B. GKE ospita questi modelli nei seguenti pool di nodi TPU v5e a singolo host:

  • 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 gestisce i 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 specifici.
  • Client Saxml: l'interfaccia di programmazione rivolta agli utenti 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 utilizzi anche il server HTTP Saxml. Il server HTTP Saxml è un server HTTP personalizzato che incapsula la libreria client Python 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

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

Architettura

Questa sezione descrive l'architettura GKE utilizzata in questo tutorial. L'architettura comprende un cluster GKE Standard che esegue il provisioning delle TPU e ospita i componenti Saxml per eseguire il deployment e gestire 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 a livello di zona.
  • Un pool di nodi di sezioni TPU single-host che dipende dal modello Gemma che vuoi pubblicare:
    • Gemma 2B: configurato con una TPU v5e con una topologia 1x1. Un'istanza del server Saxml Model è configurata per utilizzare questo pool di nodil.
    • Gemma 7B: configurato con una TPU v5e con una topologia 2x2. Un'istanza del server Saxml Model è configurata per utilizzare questo pool di nodil.
  • Un pool di nodi CPU predefinito in cui vengono implementati il server Saxml Admin e il server HTTP Saxml.
  • Due bucket Cloud Storage:
    • Un bucket Cloud Storage memorizza lo stato gestito da un server di amministrazione.
    • Un bucket Cloud Storage archivia i checkpoint del modello Gemma.

Questa architettura ha 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 Saxml utilizzano una federazione delle identità per i carichi di lavoro 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 di rendimento dei pool di nodi GKE, come quelle create in questo tutorial.

Prima di iniziare

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

    Go to project selector

  • Make sure that billing is enabled for your Trusted 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, roles/iam.policyAdmin, roles/iam.securityAdmin, roles/iam.roleAdmin

    Check for the roles

    1. In the Trusted 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 column to see whether the list of roles includes the required roles.

    Grant the roles

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

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

    4. Nel campo Nuove entità, inserisci il tuo identificatore utente. In genere si tratta dell'identificatore di un utente in un pool di identità della forza lavoro. Per maggiori dettagli, vedi Rappresentare gli utenti del pool di forza lavoro nelle norme IAM o contatta l'amministratore.

    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 avere quote sufficienti per 5 chip TPU v5e. In questo tutorial utilizzi le istanze on demand.
  • Crea un account Kaggle, se non ne hai già uno.

Preparare l'ambiente per Gemma

Avvia Cloud Shell

In questo tutorial utilizzi Cloud Shell per gestire le risorse ospitate su Trusted Cloud. Cloud Shell include il software necessario per questo tutorial, tra cui kubectl e gcloud CLI.

  1. Nella console Trusted Cloud , avvia un'istanza Cloud Shell:
    Apri Cloud Shell

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

Crea un cluster GKE Standard

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

Gemma 2B-it

Utilizza Cloud Shell per svolgere le seguenti operazioni:

  1. Crea un cluster Standard che utilizza la federazione delle identità per i carichi di lavoro per 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.

  2. 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 gestito il modello Gemma 2B.

Gemma 7B-it

Utilizza Cloud Shell per svolgere le seguenti operazioni:

  1. Crea un cluster Standard che utilizza la federazione delle identità per i carichi di lavoro per 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.

  2. 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 di amministrazione Saxml e i checkpoint del modello.

In Cloud Shell, esegui questo comando:

  1. 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 in cui è archiviato il server Saxml Admin.

  2. 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 in cui sono archiviati i checkpoint del modello.

Configura l'accesso ai tuoi workload utilizzando Workload Identity Federation for GKE

Assegna un service account Kubernetes all'applicazione e configura questo service account Kubernetes in modo che funga da account di servizio IAM.

  1. Configura kubectl per comunicare con il cluster:

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

  2. Crea un ServiceAccount Kubernetes da utilizzare per la tua applicazione:

    gcloud iam service-accounts create wi-sax

  3. Aggiungi un'associazione della policy IAM per il tuo account di servizio IAM per leggere e scrivere in Cloud Storage:

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

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

  4. Consenti al service account Kubernetes di rappresentare l'account di servizio IAM aggiungendo un'associazione dei criteri IAM tra i due service account. Questa associazione consente al service account Kubernetes di agire come account di servizio IAM:

    gcloud iam service-accounts add-iam-policy-binding wi-sax@${PROJECT_ID}.s3ns-system.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"

  5. Annota il account di servizio Kubernetes con l'indirizzo email del account di servizio IAM:

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

Ottenere 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 Kaggle.

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

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

Generare un token di accesso

Per accedere al modello tramite Kaggle, è necessario un token API di Kaggle.

Segui questi passaggi per generare un nuovo token, se non ne hai già uno:

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

Kaggle scarica un file denominato kaggle.json.

Carica il token di accesso su Cloud Shell

In Cloud Shell, puoi caricare il token API Kaggle nel tuo Trusted Cloud by S3NS progetto:

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

Crea un secret Kubernetes per le credenziali Kaggle

In Cloud Shell, segui questi passaggi:

  1. Configura kubectl per comunicare con il cluster:

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

  2. Crea un secret per archiviare le credenziali 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. Questo tutorial utilizza i manifest di deployment di Kubernetes. Un deployment è un oggetto API Kubernetes che consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.

Esegui il deployment del server di amministrazione Saxml

In questa sezione, esegui il deployment del server di amministrazione Saxml.

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

  2. Applica il manifest:

    kubectl apply -f saxml-admin-server.yaml

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

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

  2. Applica il manifest:

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

  3. Verifica lo stato del deployment del server dei modelli:

    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

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

  2. Applica il manifest:

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

  3. Verifica lo stato del deployment del server dei modelli:

    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 crea un servizio Cluster IP che utilizzi per accedere al server.

  1. 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 in cui è archiviato il server Saxml Admin.

  2. Applica il manifest:

    kubectl apply -f saxml-http.yaml

  3. 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 archivia il checkpoint del modello. Un controller Job in Kubernetes crea uno o più pod e garantisce che eseguano correttamente un'attività specifica.

Segui i passaggi per il modello Gemma che vuoi utilizzare:

Gemma 2B-it

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

  2. Applica il manifest:

    kubectl apply -f job-2b.yaml

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

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

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

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

  2. Applica il manifest:

    kubectl apply -f job-7b.yaml

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

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

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

Esporre il server HTTP Saxml

Puoi accedere al server HTTP Saxml tramite il servizio ClusterIP che hai creato durante la 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:

  1. Stabilisci una sessione di port forwarding:

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

  2. 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. Utilizzi queste API per pubblicare, gestire e interagire con i modelli Gemma 2B e Gemma 7B.

Pubblicare il modello Gemma

Dopodiché, puoi pubblicare il modello Gemma su un server di modelli che viene eseguito in unpool di nodil di slice TPU. Utilizzi l'API publish del server HTTP Saxml per pubblicare un modello. Segui questi passaggi per pubblicare il modello con parametri Gemma 2B o 7B.

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

Gemma 2B-it

  1. Assicurati che la sessione di port forwarding sia ancora attiva:

    curl -s localhost:8888

  2. 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 dell'implementazione.

  3. Monitora l'avanzamento osservando i log in un pod del server modello del deployment sax-model-server-v5e-1x1.

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

    Il completamento del 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

  4. Verifica di poter accedere al modello visualizzando le informazioni del modello:

    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

  1. Assicurati che la sessione di port forwarding sia ancora attiva:

    curl -s localhost:8888

  2. 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 dell'implementazione.

  3. Monitora l'avanzamento osservando i log in un pod del server modello del deployment sax-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

  4. Verifica che il modello sia stato pubblicato visualizzando le informazioni del modello:

    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

Servi 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 fornisci:

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

Puoi eseguire il comando con parametri query diversi. 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

Servi 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
    ]
]

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

Annullare la pubblicazione del modello

Per annullare la pubblicazione del modello:

Gemma 2B-it

Per annullare la pubblicazione del modello Gemma 2B-it, esegui questo 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 prompt diversi passati nel parametro query.

Gemma 7B-it

Per annullare la pubblicazione del modello Gemma 7B-it, esegui questo 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 prompt diversi passati nel parametro query.

Risoluzione dei problemi

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 Trusted Cloud vengano addebitati costi relativi alle risorse che hai creato in questa guida, esegui questo comando:

gcloud container clusters delete ${CLUSTER_NAME} --location=${LOCATION}
gcloud iam service-accounts delete --quiet wi-sax@${PROJECT_ID}.s3ns-system.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 archivia il server Saxml Admin.
  • CHECKPOINTS_BUCKET_NAME: il nome del bucket Cloud Storage in cui sono archiviati i checkpoint del modello.

Passaggi successivi