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

In dieser Anleitung wird gezeigt, wie Sie ein Gemma 2-Large Language Model (LLM) mit TPUs in GKE mit dem Saxml-Bereitstellungs-Framework bereitstellen. Diese Anleitung 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 vorkonfigurierten 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 Entwickler für maschinelles Lernen (ML), Plattformadministratoren und ‑betreiber sowie an Daten- und KI-Spezialisten, die Kubernetes-Container-Orchestrierungsfunktionen zum Bereitstellen von LLMs nutzen möchten. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir inGoogle Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE Enterprise-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 Schaltungen (Application-Specific Integrated Circuits, 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 verwendet. 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 überwacht Modellserver, weist Modellservern veröffentlichte Modelle zu, die sie bereitstellen sollen, und hilft Kunden, 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 für die 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.

Lernziele

  1. Bereiten Sie einen GKE-Standardcluster mit der empfohlenen TPU-Topologie anhand der Modelleigenschaften vor.
  2. Stellen Sie die Saxml-Komponenten in GKE bereit.
  3. Anleitung zum Abrufen und Veröffentlichen des Parametermodells Gemma 2B oder Gemma 7B.
  4. Stellen Sie die veröffentlichten Modelle bereit und interagieren Sie mit diesen.

Architektur

In diesem Abschnitt wird die in dieser Anleitung verwendete GKE-Architektur beschrieben. Die Architektur umfasst einen GKE-Standardcluster, der TPUs bereitstellt und Saxml-Komponenten zum Bereitstellen und Bereitstellen von Gemma 2B- oder 7B-Modellen hostet. Das folgende Diagramm zeigt die Komponenten dieser Architektur:

Ein Diagramm der in dieser Anleitung bereitgestellten Architektur

Diese Architektur umfasst die folgenden Komponenten:

  • Einen zonalen GKE-Standardcluster.
  • Ein TPU-Slice-Knotenpool mit einem einzelnen Host, der von dem bereitzustellenden Gemma-Modell abhängt:
    • Gemma 2B: Konfiguriert mit einer TPU v5e mit einer 1x1-Topologie. Eine Instanz des Saxml-Modellservers ist für die Verwendung dieses Knotenpools konfiguriert.
    • Gemma 7B: Konfiguriert mit einer TPU v5e mit einer 2x2-Topologie. Eine Instanz des Saxml-Modellservers ist für die Verwendung dieses Knotenpools konfiguriert.
  • Ein standardmäßiger CPU-Knotenpool, in dem der Saxml Admin-Server und der Saxml HTTP-Server bereitgestellt werden.
  • Zwei Cloud Storage-Buckets:
    • Ein Cloud Storage-Bucket speichert den von einem Admin-Server verwalteten Status.
    • Ein Cloud Storage-Bucket speichert die Prüfpunkte des Gemma-Modells.

Diese Architektur hat folgende Merkmale:

  • Eine öffentliche Artifact Registry verwaltet die Container-Images für die Saxml-Komponenten.
  • Der GKE-Cluster verwendet Workload Identity Federation for GKE. Alle Saxml-Komponenten verwenden eine Identitätsföderation von Arbeitslasten, die ein IAM-Dienstkonto einbindet, um auf externe Dienste wie Cloud Storage-Buckets zuzugreifen.
  • Die von Saxml-Komponenten generierten Logs sind in Cloud Logging eingebunden.
  • Mit Cloud Monitoring können Sie die Leistungsmesswerte von GKE-Knotenpools analysieren, wie sie in diesem Tutorial erstellt werden.

Hinweise

  • 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, roles/iam.policyAdmin, roles/iam.securityAdmin, roles/iam.roleAdmin

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

      Zu IAM
    2. Wählen Sie das Projekt aus.
    3. Klicken Sie auf Zugriff erlauben.

    4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Dies ist in der Regel die E-Mail-Adresse eines Google-Kontos.

    5. Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
    6. Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
    7. Klicken Sie auf Speichern.
  • Achten Sie darauf, dass Sie genügend Kontingente für 5 TPU v5e-Chips haben. In dieser Anleitung verwenden Sie On-Demand-Instanzen.
  • Erstellen Sie ein Kaggle-Konto, falls Sie noch keines haben.

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 Standard-Cluster 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}

    Sie stellen das Modell Gemma 2B in diesem Knotenpool 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}

    Sie stellen das Gemma 7B-Modell in diesem Knotenpool 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-Administratorserverkonfigurationen 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-Checkpunkten:

    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. Admin-Server-Bereitstellung 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 Modellserverbereitstellung:

    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 Modellserverbereitstellung:

    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 Saxml-HTTP-Serverbereitstellung:

    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

Der Job lädt den Prüfpunkt auf gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000 hoch.

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

Der Job lädt den Prüfpunkt auf gs://CHECKPOINTS_BUCKET_NAME/gemma_7b_it/checkpoint_00000000 hoch.

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 ein und stellt sie über eine Reihe von REST APIs bereit. 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 Parametermodell Gemma 2B oder Gemma 7B 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 die Portweiterleitungssitzung noch aktiv ist:

    curl -s localhost:8888

  2. Gemma 2B-Parameter veröffentlichen:

    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 im Blick behalten.

  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

    Diese 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 die Portweiterleitungssitzung noch aktiv ist:

    curl -s localhost:8888

  2. Gemma 7B-Parameter veröffentlichen:

    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 im Blick behalten.

  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 Gemma 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 mithilfe 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 bei jedem Prompt variieren:

[
    [
        "\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 widerrufen Sie die Veröffentlichung Ihres Modells:

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

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Bereitgestellte Ressourcen löschen

Führen Sie den folgenden Befehl aus, damit Ihrem Google Cloud -Konto die in dieser Anleitung erstellten Ressourcen nicht in Rechnung gestellt werden:

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

Ersetzen Sie Folgendes:

  • ADMIN_BUCKET_NAME: Der Name des Cloud Storage-Bucket, in dem der Saxml-Admin-Server gespeichert ist.
  • CHECKPOINTS_BUCKET_NAME: Der Name des Cloud Storage-Bucket, in dem die Modellprüfpunkte gespeichert sind.

Nächste Schritte