Skalierbare LLMs in GKE mit TorchServe bereitstellen

In dieser Anleitung wird gezeigt, wie Sie ein vortrainiertes PyTorch-Modell für maschinelles Lernen (ML) in einem GKE-Cluster mit dem TorchServe-Framework für skalierbare Bereitstellung bereitstellen. Das in dieser Anleitung verwendete ML-Modell generiert Vorhersagen auf Basis von Nutzeranfragen. Sie können die Informationen in dieser Anleitung verwenden, um Ihre eigenen Modelle in großem Maßstab in GKE bereitzustellen.

Über die Anwendung in diesem Tutorial

Die Anwendung ist eine kleine Python-Webanwendung, die mit dem Fast Dash-Framework erstellt wurde. Sie verwenden die Anwendung, um Vorhersageanfragen an das T5-Modell zu senden. Diese Anwendung erfasst Texteingaben und Sprachpaare von Nutzern und sendet die Informationen an das Modell. Das Modell übersetzt den Text und gibt das Ergebnis an die Anwendung zurück, das das Ergebnis dem Nutzer anzeigt. Weitere Informationen zu Fast Dash finden Sie in der Fast Dash-Dokumentation.

Funktionsweise

In dieser Anleitung werden die Arbeitslasten in einem GKE Autopilot-Cluster bereitgestellt. GKE verwaltet Autopilot-Knoten vollständig, wodurch der Verwaltungsaufwand für Knotenkonfiguration, Skalierung und Upgrades reduziert wird. Wenn Sie die ML-Arbeitslast und -Anwendung auf Autopilot bereitstellen, wählt GKE den richtigen zugrunde liegenden Maschinentyp und die richtige Größe für die Ausführung der Arbeitslasten aus. Weitere Informationen finden Sie in der Autopilot-Übersicht.

Nachdem Sie das Modell bereitgestellt haben, erhalten Sie eine Vorhersage-URL, mit der Ihre Anwendung Vorhersageanfragen an das Modell senden kann. Diese Methode entkoppelt das Modell von der Anwendung, sodass das Modell unabhängig von der Webanwendung skaliert werden kann.

Ziele

  • Bereiten Sie ein vortrainiertes T5-Modell aus dem Hugging Face-Repository zur Bereitstellung vor. Dazu verpacken Sie es als Container-Image und übertragen es per Push in Artifact Registry.
  • Modell in einem Autopilot-Cluster bereitstellen
  • Die Fast Dash-Anwendung bereitstellen, die mit dem Modell kommuniziert
  • Modell anhand von Prometheus-Messwerten automatisch skalieren

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Vorbereitung

  1. 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.
  2. Install the Google Cloud CLI.

  3. To initialize the gcloud CLI, run the following command: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs: 

    gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
  7. Install the Google Cloud CLI.

  8. To initialize the gcloud CLI, run the following command: 

    gcloud init

  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Make sure that billing is enabled for your Google Cloud project.

  11. Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs: 

    gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com

Umgebung vorbereiten

Klonen Sie das Beispiel-Repository und öffnen Sie das Anleitungsverzeichnis:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving

Cluster erstellen

Führen Sie dazu diesen Befehl aus:

gcloud container clusters create-auto ml-cluster \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=CLUSTER_VERSION \
    --location=us-central1

Ersetzen Sie Folgendes:

  • RELEASE_CHANNEL: die Release-Version für Ihren Cluster. Muss rapid, regular oder stable sein. Wählen Sie einen Kanal mit der GKE-Version 1.28.3-gke.1203000 oder höher aus, um L4-GPUs zu verwenden. Informationen zu den in einem bestimmten Kanal verfügbaren Versionen finden Sie unter Standard- und verfügbare Versionen für Release-Versionen ansehen.
  • CLUSTER_VERSION ist die zu verwendende GKE-Version. Es muss 1.28.3-gke.1203000 oder höher sein.

Dieser Vorgang kann mehrere Minuten dauern.

Artifact Registry-Repository erstellen

  1. Erstellen Sie ein neues Artifact Registry-Standard-Repository im Docker-Format in derselben Region wie Ihr Cluster:

    gcloud artifacts repositories create models \
    --repository-format=docker \
    --location=us-central1 \
    --description="Repo for T5 serving image"

  2. Prüfen Sie den Repository-Namen:

    gcloud artifacts repositories describe models \
    --location=us-central1

    Die Ausgabe sieht in etwa so aus:

    Encryption: Google-managed key
Repository Size: 0.000MB
createTime: '2023-06-14T15:48:35.267196Z'
description: Repo for T5 serving image
format: DOCKER
mode: STANDARD_REPOSITORY
name: projects/PROJECT_ID/locations/us-central1/repositories/models
updateTime: '2023-06-14T15:48:35.267196Z'

Modell verpacken

In diesem Abschnitt verpacken Sie das Modell und das Bereitstellungs-Framework mithilfe von Cloud Build in einem einzigen Container-Image und übertragen das resultierende Image per Push in das Artifact Registry-Repository.

  1. Prüfen Sie das Dockerfile für das Container-Image:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

ARG BASE_IMAGE=pytorch/torchserve:0.7.1-cpu

FROM alpine/git

ARG MODEL_NAME=t5-small
ARG MODEL_REPO=https://huggingface.co/${MODEL_NAME}
ENV MODEL_NAME=${MODEL_NAME}
ENV MODEL_VERSION=${MODEL_VERSION}

RUN git clone "${MODEL_REPO}" /model

FROM ${BASE_IMAGE}

ARG MODEL_NAME=t5-small
ARG MODEL_VERSION=1.0
ENV MODEL_NAME=${MODEL_NAME}
ENV MODEL_VERSION=${MODEL_VERSION}

COPY --from=0 /model/. /home/model-server/
COPY handler.py \
     model.py \
     requirements.txt \
     setup_config.json /home/model-server/

RUN  torch-model-archiver \
     --model-name="${MODEL_NAME}" \
     --version="${MODEL_VERSION}" \
     --model-file="model.py" \
     --serialized-file="pytorch_model.bin" \
     --handler="handler.py" \
     --extra-files="config.json,spiece.model,tokenizer.json,setup_config.json" \
     --runtime="python" \
     --export-path="model-store" \
     --requirements-file="requirements.txt"

FROM ${BASE_IMAGE}

ENV PATH /home/model-server/.local/bin:$PATH
ENV TS_CONFIG_FILE /home/model-server/config.properties
# CPU inference will throw a warning cuda warning (not error)
# Could not load dynamic library 'libnvinfer_plugin.so.7'
# This is expected behaviour. see: https://stackoverflow.com/a/61137388
ENV TF_CPP_MIN_LOG_LEVEL 2

COPY --from=1 /home/model-server/model-store/ /home/model-server/model-store
COPY config.properties /home/model-server/

    Dieses Dockerfile definiert den folgenden mehrstufigen Build-Prozess:

    1. Laden Sie die Modellartefakte aus dem Hugging Face-Repository herunter.
    2. Verpacken Sie das Modell mit dem Tool PyTorch Serving Archive. Dadurch wird eine Modellarchivdatei (.mar) erstellt, die der Inferenzserver zum Laden des Modells verwendet.
    3. Erstellen Sie das endgültige Image mit PyTorch Serve.

  2. Erstellen Sie das Image und übertragen Sie es mit Cloud Build:

    gcloud builds submit model/ \
    --region=us-central1 \
    --config=model/cloudbuild.yaml \
    --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0

    Der Build-Prozess dauert einige Minuten. Wenn Sie ein größeres Modell als t5-small verwenden, kann der Build-Prozess deutlich länger dauern.

  3. Prüfen Sie, ob sich das Image im Repository befindet:

    gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models

    Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.

    Die Ausgabe sieht in etwa so aus:

    IMAGE                                                     DIGEST         CREATE_TIME          UPDATE_TIME
us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small     sha256:0cd...  2023-06-14T12:06:38  2023-06-14T12:06:38

Gepacktes Modell in GKE bereitstellen

Ändern Sie zum Bereitstellen des Images das Kubernetes-Manifest im Beispiel-Repository an Ihre Umgebung.

  1. Prüfen Sie das Manifest für die Inferenzarbeitslast:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: t5-inference
  labels:
    model: t5
    version: v1.0
    machine: gpu
spec:
  replicas: 1
  selector:
    matchLabels:
      model: t5
      version: v1.0
      machine: gpu
  template:
    metadata:
      labels:
        model: t5
        version: v1.0
        machine: gpu
    spec:
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      securityContext:
        fsGroup: 1000
        runAsUser: 1000
        runAsGroup: 1000
      containers:
        - name: inference
          image: us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small:1.0-gpu
          imagePullPolicy: IfNotPresent
          args: ["torchserve", "--start", "--foreground"]
          resources:
            limits:
              nvidia.com/gpu: "1"
              cpu: "3000m"
              memory: 16Gi
              ephemeral-storage: 10Gi
            requests:
              nvidia.com/gpu: "1"
              cpu: "3000m"
              memory: 16Gi
              ephemeral-storage: 10Gi
          ports:
            - containerPort: 8080
              name: http
            - containerPort: 8081
              name: management
            - containerPort: 8082
              name: metrics
          readinessProbe:
            httpGet:
              path: /ping
              port: http
            initialDelaySeconds: 120
            failureThreshold: 10
          livenessProbe:
            httpGet:
              path: /models/t5-small
              port: management
            initialDelaySeconds: 150
            periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: t5-inference
  labels:
    model: t5
    version: v1.0
    machine: gpu
spec:
  type: ClusterIP
  selector:
    model: t5
    version: v1.0
    machine: gpu
  ports:
    - port: 8080
      name: http
      targetPort: http
    - port: 8081
      name: management
      targetPort: management
    - port: 8082
      name: metrics
      targetPort: metrics

  2. Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-Projekt-ID.

    sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"

    Dadurch wird sichergestellt, dass der Container-Image-Pfad in der Deployment-Spezifikation mit dem Pfad zu Ihrem T5-Modell-Image in Artifact Registry übereinstimmt.

  3. Erstellen Sie die Kubernetes-Ressourcen:

    kubectl create -f kubernetes/serving-gpu.yaml

So prüfen Sie, ob das Modell erfolgreich bereitgestellt wurde:

  1. Rufen Sie den Status der Bereitstellung und des Dienstes ab:

    kubectl get -f kubernetes/serving-gpu.yaml

    Warten Sie ähnlich dem folgenden Beispiel, bis in der Ausgabe einsatzbereite Pods angezeigt werden. Je nach Größe des Images kann der erste Abruf des Images einige Minuten dauern.

    NAME                            READY   UP-TO-DATE    AVAILABLE   AGE
deployment.apps/t5-inference    1/1     1             0           66s

NAME                    TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)                       AGE
service/t5-inference    ClusterIP   10.48.131.86    <none>        8080/TCP,8081/TCP,8082/TCP    66s

  2. Öffnen Sie einen lokalen Port für den t5-inference-Dienst:

    kubectl port-forward svc/t5-inference 8080

  3. Öffnen Sie ein neues Terminalfenster und senden Sie eine Testanfrage an den Dienst:

    curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"

    Wenn die Testanfrage fehlschlägt und die Pod-Verbindung geschlossen wird, prüfen Sie die Logs:

    kubectl logs deployments/t5-inference

    Wenn die Ausgabe in etwa so aussieht, konnte TorchServe einige Modellabhängigkeiten nicht installieren:

    org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small

    Starten Sie das Deployment neu, um dieses Problem zu beheben:

    kubectl rollout restart deployment t5-inference

    Der Deployment-Controller erstellt einen neuen Pod. Wiederholen Sie die vorherigen Schritte, um einen Port auf dem neuen Pod zu öffnen.

Mit der Webanwendung auf das bereitgestellte Modell zugreifen

  1. Erstellen Sie die Fast Dash-Webanwendung als Container-Image und übertragen Sie sie per Push in Artifact Registry:

    gcloud builds submit client-app/ \
    --region=us-central1 \
    --config=client-app/cloudbuild.yaml

  2. Öffnen Sie kubernetes/application.yaml in einem Texteditor und ersetzen Sie PROJECT_ID im Feld image: durch Ihre Projekt-ID. Alternativ können Sie den folgenden Befehl ausführen:

    sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"

  3. Erstellen Sie die Kubernetes-Ressourcen:

    kubectl create -f kubernetes/application.yaml

    Es kann einige Zeit dauern, bis das Deployment und der Dienst vollständig bereitgestellt wurden.

  4. Führen Sie zum Prüfen des Status den folgenden Befehl aus:

    kubectl get -f kubernetes/application.yaml

    Warten Sie, bis in der Ausgabe einsatzbereite Pods angezeigt werden, ähnlich dem Folgenden:

    NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/fastdash   1/1     1            0           1m

NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/fastdash   NodePort   203.0.113.12    <none>        8050/TCP         1m

  5. Die Webanwendung wird jetzt ausgeführt, obwohl sie nicht über eine externe IP-Adresse verfügbar gemacht wird. Öffnen Sie einen lokalen Port, um auf die Webanwendung zuzugreifen:

    kubectl port-forward service/fastdash 8050

  6. Öffnen Sie in einem Browser die Weboberfläche:

    • Wenn Sie eine lokale Shell verwenden, öffnen Sie einen Browser und rufen Sie http://127.0.0.1:8050 auf.
    • Wenn Sie Cloud Shell verwenden, klicken Sie auf Webvorschau und dann auf Port ändern. Gib Port 8050 an.

  7. Um eine Anfrage an das T5-Modell zu senden, geben Sie in der Weboberfläche Werte in den Feldern TEXT, FROM LANG und TO LANG an. und klicken Sie auf Senden. Eine Liste der verfügbaren Sprachen finden Sie in der T5-Dokumentation.

Autoscaling für das Modell aktivieren

In diesem Abschnitt erfahren Sie, wie Sie das Autoscaling für das Modell anhand von Messwerten aus Google Cloud Managed Service for Prometheus aktivieren. Gehen Sie dazu so vor:

  1. Stackdriver-Adapter für benutzerdefinierte Messwerte installieren
  2. PodMonitoring- und HorizontalPodAutoscaling-Konfigurationen anwenden.

Google Cloud Managed Service for Prometheus ist in Autopilot-Clustern mit Version 1.25 und höher standardmäßig aktiviert.

Stackdriver-Adapter für benutzerdefinierte Messwerte installieren

Mit diesem Adapter kann Ihr Cluster Messwerte von Prometheus verwenden, um Autoscaling-Entscheidungen in Kubernetes zu treffen.

  1. Stellen Sie den Adapter bereit:

    kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

  2. Erstellen Sie ein IAM-Dienstkonto für den Adapter:

    gcloud iam service-accounts create monitoring-viewer

  3. Weisen Sie dem IAM-Dienstkonto die Rolle monitoring.viewer für das Projekt und die Rolle iam.workloadIdentityUser zu:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"

    Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.

  4. Annotieren Sie das Kubernetes-Dienstkonto des Adapters, damit es die Identität des IAM-Dienstkontos übernehmen kann:

    kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
    --namespace custom-metrics \
    iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com

  5. Starten Sie den Adapter neu, um die Änderungen zu übernehmen:

    kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
    --namespace=custom-metrics

PodMonitoring- und HorizontalPodAutoscaling-Konfigurationen anwenden.

PodMonitoring ist eine benutzerdefinierte Google Cloud Managed Service for Prometheus-Ressource, die die Aufnahme von Messwerten und das Ziel-Scraping in einem bestimmten Namespace ermöglicht.

  1. Stellen Sie die PodMonitoring-Ressource im selben Namespace wie das TorchServe-Deployment bereit:

    kubectl apply -f kubernetes/pod-monitoring.yaml

  2. Prüfen Sie das HorizontalPodAutoscaler-Manifest:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: t5-inference
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: t5-inference
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|ts_queue_latency_microseconds|counter
      target:
        type: AverageValue
        averageValue: "30000"

    Der HorizontalPodAutoscaler skaliert die T5-Modell-Pod-Menge anhand der kumulativen Dauer der Anfragewarteschlange. Die automatische Skalierung basiert auf dem Messwert ts_queue_latency_microseconds, der die kumulative Warteschlangendauer in Mikrosekunden anzeigt.

  3. Erstellen Sie den HorizontalPodAutoscaler:

    kubectl apply -f kubernetes/hpa.yaml

Autoscaling mit einem Load Generator prüfen

Generieren Sie zum Testen der Autoscaling-Konfiguration eine Last für die Bereitstellungsanwendung. In dieser Anleitung wird ein Locust-Lastgenerator verwendet, um Anfragen an den Vorhersageendpunkt für das Modell zu senden.

  1. Erstellen Sie den Lastgenerator:

    kubectl apply -f kubernetes/loadgenerator.yaml

    Warten Sie, bis die Lastgenerator-Pods bereit sind.

  2. Machen Sie die Weboberfläche des Lastgenerators lokal verfügbar:

    kubectl port-forward svc/loadgenerator 8080

    Wenn eine Fehlermeldung angezeigt wird, versuchen Sie es noch einmal, wenn der Pod ausgeführt wird.

  3. Öffnen Sie in einem Browser die Weboberfläche des Lastgenerators:

    • Wenn Sie eine lokale Shell verwenden, öffnen Sie einen Browser und rufen Sie http://127.0.0.1:8080 auf.
    • Wenn Sie Cloud Shell verwenden, klicken Sie auf Webvorschau und dann auf Port ändern. Geben Sie Port 8080 ein.

  4. Klicken Sie auf den Tab Diagramme, um die Leistung im Zeitverlauf zu beobachten.

  5. Öffnen Sie ein neues Terminalfenster und beobachten Sie die Anzahl der Replikate Ihrer horizontalen Pod-Autoscalings:

    kubectl get hpa -w

    Die Anzahl der Replikate erhöht sich, wenn die Last zunimmt. Das Hochskalieren kann etwa zehn Minuten dauern. Wenn neue Replikate gestartet werden, erhöht sich die Anzahl der erfolgreichen Anfragen im Locust-Diagramm.

    NAME           REFERENCE                 TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
t5-inference   Deployment/t5-inference   71352001470m/7M   1         5        1           2m11s

Empfehlungen

  • Erstellen Sie Ihr Modell mit derselben Version des Basis-Docker-Images, die Sie für die Bereitstellung verwenden.
  • Wenn Ihr Modell spezielle Paketabhängigkeiten hat oder die Abhängigkeiten groß sind, erstellen Sie eine benutzerdefinierte Version Ihres Basis-Docker-Images.
  • Beobachten Sie die Baumversion Ihrer Modellabhängigkeitspakete. Achten Sie darauf, dass Ihre Paketabhängigkeiten die Versionen der jeweils anderen unterstützen. Die Panda-Version 2.0.3 unterstützt beispielsweise die NumPy-Version 1.20.3 und höher.
  • Führen Sie GPU-intensive Modelle auf GPU-Knoten und CPU-intensiven Modellen auf CPU aus. Dies kann die Stabilität der Modellbereitstellung verbessern und dafür sorgen, dass Sie Knotenressourcen effizient nutzen.

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.

Projekt löschen

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Einzelne Ressourcen löschen

  1. Löschen Sie die Kubernetes-Ressourcen:

    kubectl delete -f kubernetes/loadgenerator.yaml
kubectl delete -f kubernetes/hpa.yaml
kubectl delete -f kubernetes/pod-monitoring.yaml
kubectl delete -f kubernetes/application.yaml
kubectl delete -f kubernetes/serving-gpu.yaml
kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

  2. Löschen Sie den GKE-Cluster:

    gcloud container clusters delete "ml-cluster" \
    --location="us-central1" --quiet

  3. Löschen Sie das IAM-Dienstkonto und die IAM-Richtlinienbindungen:

    gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts remove-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
gcloud iam service-accounts delete monitoring-viewer

  4. Löschen Sie die Images in Artifact Registry. Löschen Sie optional das gesamte Repository. Eine Anleitung dazu finden Sie in der Artifact Registry-Dokumentation unter Images löschen.

Komponentenübersicht

In diesem Abschnitt werden die in dieser Anleitung verwendeten Komponenten beschrieben, z. B. das Modell, die Webanwendung, das Framework und der Cluster.

T5-Modell

In dieser Anleitung wird ein vortrainiertes mehrsprachiges T5-Modell verwendet. T5 ist ein Text-zu-Text-Transformer, der Text von einer Sprache in eine andere umwandelt. Bei T5 sind Ein- und Ausgaben immer Textstrings, im Gegensatz zu BERT-ähnlichen Modellen, die nur entweder ein Klassenlabel oder einen Span der Eingabe ausgeben können. Das T5-Modell kann auch für Aufgaben wie Zusammenfassungen, Fragen und Antworten oder Textklassifizierung verwendet werden. Das Modell wird mit einer großen Textmenge aus Colossal Clean Crawled Corpus (C4) und Wiki-DPR trainiert.

Weitere Informationen finden Sie in der Dokumentation zum T5-Modell.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li und Peter J. Liu stellte das T5-Modell in Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer vor, veröffentlicht im Journal of Machine Learning Research.

Das T5-Modell unterstützt verschiedene Modellgrößen mit unterschiedlichen Komplexitätsgraden, die bestimmten Anwendungsfällen entsprechen. In dieser Anleitung wird die Standardgröße t5-small verwendet. Sie können jedoch auch eine andere Größe auswählen. Die folgenden T5-Größen werden unter der Apache 2.0-Lizenz verteilt:

  • t5-small: 60 Millionen Parameter
  • t5-base: 220 Millionen Parameter
  • t5-large: 770 Millionen Parameter. 3 GB Download.
  • t5-3b: 3 Milliarden Parameter. 11 GB Download.
  • t5-11b: 11 Milliarden Parameter. 45 GB Download.

Weitere verfügbare T5-Modelle finden Sie im Hugging Face-Repository.

TorchServe

TorchServe ist ein flexibles Tool zum Bereitstellen von PyTorch-Modellen. Sie bietet sofort Unterstützung für alle wichtigen Deep-Learning-Frameworks, einschließlich PyTorch, TensorFlow und ONNX. TorchServe kann für die Bereitstellung von Modellen in der Produktion oder für ein schnelles Prototyping und Experimentieren verwendet werden.

Nächste Schritte