Pubblicare modelli aperti Gemma utilizzando TPU su GKE con Saxml

Questa guida mostra come pubblicare 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, scaricherai il 2B e il 7B l'istruzione dei parametri ha ottimizzato i modelli Gemma in Cloud Storage ed esegue il deployment su un cluster GKE Standard utilizzando container eseguire Saxml.

Questa guida è un buon punto di partenza se hai bisogno di scalabilità, resilienza e e costi contenuti offerti dalle funzionalità di Kubernetes durante il deployment Saxml.

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

Sfondo

Se gestisci Gemma utilizzando le TPU su GKE con Saxml, puoi implementare una soluzione di inferenza solida e pronta per la produzione con tutte vantaggi di Kubernetes gestito, tra cui una scalabilità efficiente e una la disponibilità del servizio. Questa sezione descrive le tecnologie chiave utilizzate in questo tutorial.

Gemma

Gemma è un insieme di strumenti generativi leggeri e disponibili pubblicamente Modelli di AI rilasciati con licenza aperta. Queste IA disponibili per l'esecuzione su applicazioni, hardware, dispositivi mobili e i servizi in hosting. Puoi utilizzare lo Modelli Gemma per la generazione di testo, inoltre puoi 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 nel seguente percorso di apprendimento:

  1. Scopri la disponibilità attuale delle versioni TPU con l'architettura di sistema Cloud TPU.
  2. 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 una 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 del modello, assegna i dati ai server dei modelli da gestire e aiuta i clienti a individuare i server dei modelli per pubblicare specifici modelli pubblicati.
  • 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 utilizzi anche il server HTTP Saxml. Saxml HTTP Server è un server HTTP personalizzato che incapsula il file Python Saxml libreria client ed espone le API REST per interagire con il sistema Saxml. La Le API REST includono endpoint per pubblicare, elencare, annullare la pubblicazione di modelli e generare per le 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:

  1. Prepara un cluster GKE Standard con Topologia TPU basata sulle caratteristiche del modello.
  2. Eseguire il deployment dei componenti Saxml su GKE.
  3. Ottieni e pubblica il modello di 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 esegue il provisioning delle TPU e ospita i componenti Saxml per il deployment e la distribuzione di 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 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 nodi.
    • Gemma 7B: configurata con una TPU v5e con un 2x2 una topologia. Un'istanza del server Saxml Model è 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 archivia i checkpoint del modello Gemma.

Questa architettura ha le seguenti caratteristiche:

  • Un Artifact Registry pubblico gestisce le immagini dei container per i componenti Saxml.
  • Il cluster GKE utilizza Workload Identity Federation for GKE. Tutto Saxml usano una federazione delle identità per i carichi di lavoro che integra un 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 l'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 altro ruolo.
    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.

  1. Nella console Google Cloud, avvia un'istanza di 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:

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

  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}

    Devi pubblicare il modello Gemma 2B in questo pool di nodi.

Gemma 7B-it

Utilizza Cloud Shell per:

  1. Crea un cluster Standard che utilizza Federazione delle identità dei 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 Saxml Admin e i checkpoint del modello.

In Cloud Shell, esegui questo comando:

  1. Creare un bucket Cloud Storage in cui archiviare le configurazioni del server di amministrazione Saxml.

    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.

  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 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 Kubernetes ServiceAccount per agire come account di servizio IAM.

  1. Configura kubectl per comunicare con il tuo 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 dei criteri IAM per il tuo account di servizio IAM a lettura e scrittura 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

  4. Consenti all'account di servizio Kubernetes di impersonare l'account di servizio IAM aggiungendo un account IAM l'associazione di criteri 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]"

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

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

Ottieni l'accesso al modello

Per ottenere l'accesso ai modelli Gemma per il deployment in a GKE, devi accedere Kaggle, firma il contratto di consenso e ottieni Un Kaggle il token dell'API. In questo tutorial, utilizzerai un secret di Kubernetes per Kaggle e credenziali.

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

  1. Accedere alla pagina relativa al consenso del modello su Kaggle.com.
  2. Accedi a Kaggle, se non l'hai ancora fatto.
  3. Fai clic su Richiedi 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.

Genera un token di accesso

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

Segui questa procedura 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 Create New Token (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:

  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.

Creare un secret Kubernetes per le credenziali di Kaggle

In Cloud Shell, segui questi passaggi:

  1. Configura kubectl per comunicare con il tuo cluster:

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

  2. Crea un secret per archiviare le credenziali di Kaggle:

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

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

  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 il bucket che hai creato nella sezione Creare 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 del modello 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 il bucket che hai creato nella sezione Creare 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 di 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 il bucket che hai creato nella sezione Creare 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 di 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

Deployment del server HTTP Saxml

In questa sezione eseguirai il deployment del server HTTP Saxml e creerai un IP cluster Servizio 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 di amministrazione Saxml.

  2. Applica il manifest:

    kubectl apply -f saxml-http.yaml

  3. Verifica lo stato di distribuzione 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, eseguirai un job Kubernetes che recupera, scarica e archivia il checkpoint del modello. 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 il bucket che hai creato nella sezione Creare 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 il bucket che hai creato nella sezione Creare 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 per il 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 nel 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 questo comando:

    curl -s localhost:8888

    L'output è simile al seguente:

    {
    "Message": "HTTP Server for SAX Client"
}

Il server HTTP Saxml incapsula l'interfaccia client nel sistema Saxml e e lo espone tramite un set di API REST. Utilizzi 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 Gemma 2B o 7 miliardi di parametri.

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

Gemma 2B-it

  1. Assicurati che la sessione di inoltro delle porte 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
}

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

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

  4. Verifica di poter accedere al modello visualizzando le relative 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

  1. Assicurati che la sessione di inoltro delle porte 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 del deployment.

  3. Monitora l'avanzamento osservando i log in un pod del server modello Deployment di 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 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 il protocollo HTTP Saxml l'API generate del server 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 della risposta del modello. L'output effettivo varia in base al prompt pubblicato:

[
    [
        "\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 ulteriori informazioni sull'API del server HTTP Saxml, vedi API HTTP Saxml.

Gemma 7B-it

Elabora 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 può variare per ogni prompt che gestisci:

[
    [
        "\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 diversi parametri query. Puoi inoltre modificare parametri aggiuntivi come temperature, top_k, topc_p utilizzando API generate. Per scoprire 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 diversi prompt che vengono 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 diversi prompt che vengono 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 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