Offene Gemma-Modelle mithilfe von TPUs in GKE mit Saxml bereitstellen

In dieser Anleitung wird gezeigt, wie Sie ein Gemma 2-LLM (Large Language Model) mit TPUs in GKE mit dem Saxml-Serving-Framework bereitstellen und verfügbar machen. Dieses Tutorial bietet eine Grundlage für das Verständnis und die praktische Bereitstellung von LLMs für die Inferenz in einer verwalteten Kubernetes-Umgebung. Sie stellen einen vorgefertigten Container mit Saxml in GKE bereit. Außerdem konfigurieren Sie GKE so, dass die Gemma 2B- und 7B-Gewichte zur Laufzeit aus Cloud Storage geladen werden.

Diese Anleitung richtet sich an ML-Entwickler (Machine Learning), Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen zum Bereitstellen von LLMs zu nutzen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir inGoogle Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.

Machen Sie sich vor dem Lesen dieser Seite mit den folgenden Themen vertraut:

Wenn Sie eine einheitliche verwaltete KI-Plattform benötigen, um ML-Modelle schnell und kostengünstig zu erstellen und bereitzustellen, empfehlen wir Ihnen, unsere Bereitstellungslösung Vertex AI zu testen.

Hintergrund

In diesem Abschnitt werden die in dieser Anleitung verwendeten Schlüsseltechnologien beschrieben.

Gemma

Gemma ist eine Reihe offen verfügbarer, einfacher und auf generativer KI basierender Modelle, die unter einer offenen Lizenz veröffentlicht wurden. Diese KI-Modelle können in Ihren Anwendungen, Geräten, Mobilgeräten oder gehosteten Diensten ausgeführt werden. Sie können die Gemma-Modelle für die Textgenerierung verwenden. Außerdem können Sie diese Modelle für spezielle Aufgaben optimieren.

Weitere Informationen finden Sie in der Gemma-Dokumentation.

TPUs

TPUs sind von Google speziell entwickelte anwendungsspezifische integrierte Schaltkreise (ASICs), die verwendet werden, um Datenverarbeitungs-Frameworks wie TensorFlow, PyTorch und JAX zu beschleunigen.

In dieser Anleitung werden die Modelle Gemma 2B und Gemma 7B bereitgestellt. GKE hostet diese Modelle auf den folgenden TPU v5e-Knotenpools mit nur einem Host:

  • Gemma 2B: Abgestimmtes Anleitungsmodell, das in einem TPU v5e-Knotenpool mit 1x1-Topologie gehostet wird, die einen TPU-Chip darstellt. Der Maschinentyp für die Knoten ist ct5lp-hightpu-1t.
  • Gemma 7B: Abgestimmtes Anleitungsmodell, das in einem TPU v5e-Knotenpool mit 2x2-Topologie gehostet wird, die vier TPU-Chips darstellt. Der Maschinentyp für die Knoten ist ct5lp-hightpu-4t.

Saxml

Saxml ist ein experimentelles System, das Paxml-, JAX- und PyTorch-Modelle zur Inferenz bereitstellt. Das Saxml-System umfasst die folgenden Komponenten:

  • Saxml-Zelle oder Sax-Cluster: Je ein Administratorserver und eine Gruppe Modellserver. Der Administratorserver verfolgt Modellserver, weist veröffentlichte Modelle Modellservern zur Bereitstellung zu und hilft Clients, Modellserver zu finden, die bestimmte veröffentlichte Modelle bereitstellen.
  • Saxml-Client: Die für Nutzer sichtbare Programmierschnittstelle für das Saxml-System. Der Saxml-Client enthält ein Befehlszeilentool (saxutil) und eine Reihe von Clientbibliotheken in Python, C++ und Go.

In dieser Anleitung verwenden Sie auch den Saxml-HTTP-Server. Der Saxml-HTTP-Server ist ein benutzerdefinierter HTTP-Server, der die Saxml-Python-Clientbibliothek kapselt und REST APIs zur Interaktion mit dem Saxml-System bereitstellt. Die REST APIs umfassen Endpunkte zum Veröffentlichen, Auflisten, Aufheben der Veröffentlichung von Modellen und Generieren von Vorhersagen.

Umgebung für Gemma vorbereiten

Cloud Shell starten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die in Google Cloudgehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich kubectl und gcloud CLI.

  1. Starten Sie in der Google Cloud Console eine Cloud Shell-Instanz:
    Cloud Shell öffnen

  2. Legen Sie die Standardumgebungsvariablen fest:

    gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=saxml-tpu

    Ersetzen Sie die folgenden Werte:

GKE-Standardcluster erstellen

In diesem Abschnitt erstellen Sie den GKE-Cluster und den Knotenpool.

Gemma 2B-it

Erledigen Sie mit Cloud Shell Folgendes:

  1. Erstellen Sie einen Standard-Cluster, der die Workload Identity Federation for GKE verwendet:

    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}

    Die Erstellung eines Clusters kann einige Minuten dauern.

  2. So erstellen Sie einen TPU v5e-Knotenpool mit einer 1x1-Topologie und einem Knoten:

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

    In diesem Knotenpool stellen Sie das Modell Gemma 2B bereit.

Gemma 7B-it

Erledigen Sie mit Cloud Shell Folgendes:

  1. Erstellen Sie einen Standard-Cluster, der die Workload Identity Federation for GKE verwendet:

    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}

    Die Erstellung eines Clusters kann einige Minuten dauern.

  2. So erstellen Sie einen TPU v5e-Knotenpool mit einer 2x2-Topologie und einem Knoten:

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

    In diesem Knotenpool stellen Sie das Modell Gemma 7B bereit.

Cloud Storage-Buckets erstellen

Erstellen Sie zwei Cloud Storage-Buckets zum Verwalten des Status des Saxml Admin-Servers und der Modellprüfpunkte.

Führen Sie in Cloud Shell folgenden Befehl aus:

  1. Cloud Storage-Bucket zum Speichern der Saxml Admin-Serverkonfigurationen erstellen.

    gcloud storage buckets create gs://ADMIN_BUCKET_NAME

    Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Cloud Storage-Buckets, in dem der Saxml-Admin-Server gespeichert ist.

  2. Erstellen Sie einen Cloud Storage-Bucket zum Speichern von Modell-Checkpoints:

    gcloud storage buckets create gs://CHECKPOINTS_BUCKET_NAME

    Ersetzen Sie CHECKPOINTS_BUCKET_NAME durch den Namen des Cloud Storage-Buckets, in dem die Modellprüfpunkte gespeichert sind.

Arbeitslastzugriff mit Workload Identity Federation for GKE konfigurieren

Weisen Sie der Anwendung ein Kubernetes-Dienstkonto zu und konfigurieren Sie dieses Kubernetes-Dienstkonto als IAM-Dienstkonto.

  1. Konfigurieren Sie kubectl für die Kommunikation mit Ihrem Cluster:

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

  2. Erstellen Sie ein Kubernetes-ServiceAccount für die Anwendung:

    gcloud iam service-accounts create wi-sax

  3. Fügen Sie eine IAM-Richtlinienbindung für Ihr IAM-Dienstkonto zum Lesen und Schreiben in Cloud Storage hinzu:

    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. Erlauben Sie dem Kubernetes-ServiceAccount, die Identität des IAM-Dienstkontos zu übernehmen. Fügen Sie dazu eine IAM-Richtlinienbindung zwischen den beiden Dienstkonten hinzu. Durch diese Bindung kann das Kubernetes-Dienstkonto als IAM-Dienstkonto verwendet werden.

    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. Kennzeichnen Sie das Kubernetes-Dienstkonto mit der E-Mail-Adresse des IAM-Dienstkontos:

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

Zugriff auf das Modell erhalten

Damit Sie auf die Gemma-Modelle für die Bereitstellung in GKE zugreifen können, müssen Sie sich in der Kaggle-Plattform anmelden, die Lizenz-Einwilligungsvereinbarung unterzeichnen und ein Kaggle-API-Token erwerben. In dieser Anleitung verwenden Sie ein Kubernetes Secret für die Kaggle-Anmeldedaten.

Sie müssen die Einwilligungsvereinbarung unterzeichnen, um Gemma verwenden zu können. Gehen Sie dazu so vor:

  1. Rufen Sie die Seite zur Modelleinwilligung auf Kaggle.com auf.
  2. Melden Sie sich bei Kaggle an, falls Sie dies noch nicht getan haben.
  3. Klicken Sie auf Zugriffsanfrage.
  4. Wählen Sie im Abschnitt Konto zur Einwilligung die Option Über Kaggle-Konto verifizieren aus, um Ihr Kaggle-Konto für das Erteilen der Einwilligung zu verwenden.
  5. Akzeptieren Sie die Nutzungsbedingungen des Modells.

Zugriffstoken erstellen

Für den Zugriff auf das Modell über Kaggle benötigen Sie ein Kaggle API-Token.

Führen Sie die folgenden Schritte aus, um ein neues Token zu generieren, falls Sie noch keines haben:

  1. Rufen Sie in Ihrem Browser die Kaggle-Einstellungen auf.
  2. Klicken Sie im Abschnitt API auf Neues Token erstellen.

Kaggle lädt eine Datei mit dem Namen kaggle.json herunter.

Zugriffstoken in Cloud Shell hochladen

In Cloud Shell können Sie das Kaggle API-Token in Ihr Google Cloud-Projekt hochladen:

  1. Klicken Sie in Cloud Shell auf Mehr > Hochladen.
  2. Wählen Sie "Datei" aus und klicken Sie auf Dateien auswählen.
  3. Öffnen Sie die Datei kaggle.json.
  4. Klicken Sie auf Hochladen.

Kubernetes-Secret für Kaggle-Anmeldedaten erstellen

Gehen Sie in Cloud Shell so vor:

  1. Konfigurieren Sie kubectl für die Kommunikation mit Ihrem Cluster:

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

  2. Erstellen Sie ein Secret zum Speichern der Kaggle-Anmeldedaten:

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

Saxml bereitstellen

In diesem Abschnitt stellen Sie den Saxml-Administratorserver, die Modellserver und den HTTP-Server bereit. In dieser Anleitung werden Kubernetes-Bereitstellungsmanifeste verwendet. Ein Deployment ist ein Kubernetes-API-Objekt, mit dem Sie mehrere Replikate von Pods ausführen können, die auf die Knoten in einem Cluster verteilt sind.

Saxml-Administratorserver bereitstellen

In diesem Abschnitt stellen Sie den Saxml-Administratorserver bereit.

  1. Erstellen Sie das folgende saxml-admin-server.yaml-Manifest:

    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

    Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

  2. Wenden Sie das Manifest an:

    kubectl apply -f saxml-admin-server.yaml

  3. Bereitstellung des Administratorservers prüfen:

    kubectl get deployment

    Die Ausgabe sieht dann ungefähr so aus:

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

Saxml-Modellserver bereitstellen

Folgen Sie dieser Anleitung, um den Modellserver für das Modell Gemma 2B oder für Gemma 7B bereitzustellen.

Gemma 2B-it

  1. Erstellen Sie das folgende saxml-model-server-1x1.yaml-Manifest:

    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

    Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

  2. Wenden Sie das Manifest an:

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

  3. Prüfen Sie den Status der Bereitstellung des Modellservers:

    kubectl get deployment

    Die Ausgabe sieht dann ungefähr so aus:

    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. Erstellen Sie das folgende saxml-model-server-2x2.yaml-Manifest:

    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

    Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

  2. Wenden Sie das Manifest an:

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

  3. Prüfen Sie den Status der Bereitstellung des Modellservers:

    kubectl get deployment

    Die Ausgabe sieht dann ungefähr so aus:

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

Saxml-HTTP-Server bereitstellen

In diesem Abschnitt stellen Sie den Saxml-HTTP-Server bereit und erstellen einen Cluster-IP-Dienst, mit dem Sie auf den Server zugreifen.

  1. Erstellen Sie das folgende saxml-http.yaml-Manifest:

    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

    Ersetzen Sie ADMIN_BUCKET_NAME durch den Namen des Cloud Storage-Buckets, in dem der Saxml-Admin-Server gespeichert ist.

  2. Wenden Sie das Manifest an:

    kubectl apply -f saxml-http.yaml

  3. Prüfen Sie den Status der Bereitstellung des Saxml-HTTP-Servers:

    kubectl get deployment

    Gemma 2B-it

    Die Ausgabe sieht dann ungefähr so aus:

    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

    Die Ausgabe sieht dann ungefähr so aus:

    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

Modellprüfpunkt herunterladen

In diesem Abschnitt führen Sie einen Kubernetes-Job aus, der den Modell-Checkpoint abruft, herunterlädt und speichert. Ein Jobcontroller in Kubernetes erstellt einen oder mehrere Pods und sorgt dafür, dass sie eine bestimmte Aufgabe erfolgreich ausführen.

Folgen Sie der Anleitung für das Gemma-Modell, das Sie verwenden möchten:

Gemma 2B-it

  1. Erstellen Sie das folgende job-2b.yaml-Manifest:

    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

    Ersetzen Sie CHECKPOINTS_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie nicht das Präfix gs:// an.

  2. Wenden Sie das Manifest an:

    kubectl apply -f job-2b.yaml

  3. Warten Sie, bis der Job abgeschlossen ist:

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

    Die Ausgabe sieht dann ungefähr so aus:

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

  4. Prüfen Sie, ob der Job erfolgreich abgeschlossen wurde:

    kubectl get job/data-loader-2b

    Die Ausgabe sieht dann ungefähr so aus:

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

  5. So rufen Sie die Logs für den Job auf:

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

Mit dem Job wird der Prüfpunkt in gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000 hochgeladen.

Gemma 7B-it

  1. Erstellen Sie das folgende job-7b.yaml-Manifest:

    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

    Ersetzen Sie CHECKPOINTS_BUCKET_NAME durch den Namen des Buckets, den Sie unter Cloud Storage-Buckets erstellen erstellt haben. Geben Sie das Präfix gs:// an.

  2. Wenden Sie das Manifest an:

    kubectl apply -f job-7b.yaml

  3. Warten Sie, bis der Job abgeschlossen ist:

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

    Die Ausgabe sieht dann ungefähr so aus:

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

  4. Prüfen Sie, ob der Job erfolgreich abgeschlossen wurde:

    kubectl get job/data-loader-7b

    Die Ausgabe sieht dann ungefähr so aus:

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

  5. So rufen Sie die Logs für den Job auf:

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

Mit dem Job wird der Prüfpunkt in gs://CHECKPOINTS_BUCKET_NAME/gemma_7b_it/checkpoint_00000000 hochgeladen.

Saxml-HTTP-Server freigeben

Sie können über den ClusterIP-Dienst, den Sie beim Bereitstellen des Saxml-HTTP-Servers erstellt haben, auf den Saxml-HTTP-Server zugreifen. Die ClusterIP-Dienste sind nur innerhalb des Clusters erreichbar. Führen Sie daher die folgenden Schritte aus, um von außerhalb des Clusters auf den Dienst zuzugreifen:

  1. Richten Sie eine Portweiterleitungssitzung ein:

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

  2. Prüfen Sie, ob Sie auf den Saxml-HTTP-Server zugreifen können. Öffnen Sie dazu ein neues Terminal und führen Sie den folgenden Befehl aus:

    curl -s localhost:8888

    Die Ausgabe sieht dann ungefähr so aus:

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

Der Saxml-HTTP-Server kapselt die Clientschnittstelle zum Saxml-System und stellt sie über eine Reihe von REST APIs zur Verfügung. Sie verwenden diese APIs für die Veröffentlichung, Verwaltung und Kontrolle von Gemma 2B- und Gemma 7B-Modellen.

Gemma-Modell veröffentlichen

Als Nächstes können Sie das Gemma-Modell auf einem Modellserver veröffentlichen, der in einem TPU-Slice-Knotenpool ausgeführt wird. Sie verwenden die publish API des Saxml-HTTP-Servers, um ein Modell zu veröffentlichen. Folgen Sie dieser Anleitung, um das Modell mit 2 B oder 7 B Parametern von Gemma zu veröffentlichen.

Weitere Informationen zur API des Saxml-HTTP-Servers finden Sie unter Saxml HTTP APIs.

Gemma 2B-it

  1. Prüfen Sie, ob Ihre Portweiterleitungssitzung noch aktiv ist:

    curl -s localhost:8888

  2. Veröffentlichen Sie den Gemma 2B-Parameter:

    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"
}'

    Die Ausgabe sieht dann ungefähr so aus:

    {
    "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
}

    Im nächsten Schritt erfahren Sie, wie Sie den Fortschritt der Bereitstellung überwachen können.

  3. Überwachen Sie den Fortschritt, wozu Sie Logs in einem Modellserver-Pod des Deployments sax-model-server-v5e-1x1 beobachten.

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

    Die Bereitstellung kann bis zu fünf Minuten dauern. Warten Sie, bis eine Meldung ähnlich der folgenden angezeigt wird:

    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. Prüfen Sie, ob Sie auf das Modell zugreifen können. Lassen Sie dazu die Modellinformationen anzeigen:

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

    Die Ausgabe sieht dann ungefähr so aus:

    {
    "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. Prüfen Sie, ob Ihre Portweiterleitungssitzung noch aktiv ist:

    curl -s localhost:8888

  2. Veröffentlichen Sie den Gemma 7B-Parameter:

    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"
}'

    Die Ausgabe sieht dann ungefähr so aus:

    {
    "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
}

    Im nächsten Schritt erfahren Sie, wie Sie den Fortschritt der Bereitstellung überwachen können.

  3. Überwachen Sie den Fortschritt, wozu Sie Logs in einem Modellserver-Pod des Deployments sax-model-server-v5e-2x2 beobachten.

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

    Warten Sie, bis eine Meldung ähnlich der folgenden angezeigt wird:

    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. Prüfen Sie, ob das Modell veröffentlicht wurde. Lassen Sie dazu die Modellinformationen anzeigen:

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

    Die Ausgabe sieht in etwa so aus:

    {
    "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
}

Modell verwenden

Sie können mit den Modellen Gemma 2B oder 7B interagieren. Verwenden Sie die generate API des Saxml-HTTP-Datei-Servers, um einen Prompt an das Modell zu senden.

Gemma 2B-it

Stellen Sie eine Prompt-Anfrage mithilfe des generate-Endpunkts des Saxml-HTTP-Servers bereit:

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?"
}'

Das folgende Beispiel zeigt eine Modellantwort. Die tatsächliche Ausgabe variiert je nach dem von Ihnen gesendeten Prompt:

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

Sie können den Befehl mit verschiedenen query-Parametern ausführen. Sie können auch zusätzliche Parameter wie temperature, top_k und topc_p mit der generate API ändern. Weitere Informationen zur API des Saxml-HTTP-Servers finden Sie unter Saxml HTTP APIs.

Gemma 7B-it

Stellen Sie eine Prompt-Anfrage mithilfe des generate-Endpunkts des Saxml-HTTP-Servers bereit:

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?"
}'

Das folgende Beispiel zeigt eine Modellantwort. Die Ausgabe kann sich bei jedem Prompt, den Sie senden, ändern:

[
    [
        "\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
    ]
]

Sie können den Befehl mit verschiedenen query-Parametern ausführen. Sie können auch zusätzliche Parameter wie temperature, top_k und topc_p mit der generate API ändern. Weitere Informationen zur API des Saxml-HTTP-Servers finden Sie unter Saxml HTTP APIs.

Veröffentlichung des Modells aufheben

So heben Sie die Veröffentlichung Ihres Modells auf:

Gemma 2B-it

Führen Sie den folgenden Befehl aus, um die Veröffentlichung des Gemma 2B-it-Modells aufzuheben:

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

Die Ausgabe sieht dann ungefähr so aus:

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

Sie können den Befehl mit verschiedenen Eingabeaufforderungen ausführen, die im query-Parameter übergeben werden.

Gemma 7B-it

Führen Sie den folgenden Befehl aus, um die Veröffentlichung des Gemma 7B-it-Modells aufzuheben:

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

Die Ausgabe sieht dann ungefähr so aus:

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

Sie können den Befehl mit verschiedenen Eingabeaufforderungen ausführen, die im query-Parameter übergeben werden.

Probleme beheben