Skalierbare LLMs mit TorchServe in GKE bereitstellen

In dieser Anleitung wird gezeigt, wie Sie ein skalierbares ML-Modell (Machine Learning) in einem Google Kubernetes Engine-Cluster (GKE) mit dem TorchServe-Framework bereitstellen und bereitstellen. Sie stellen ein vortrainiertes PyTorch-Modell bereit, das Vorhersagen auf Grundlage von Nutzeranfragen generiert. Nachdem Sie das Modell bereitgestellt haben, erhalten Sie eine Vorhersage-URL, die von Ihrer Anwendung zum Senden von Vorhersageanfragen verwendet wird. Mit dieser Methode können Sie das Modell und die Webanwendung unabhängig voneinander skalieren. Wenn Sie die ML-Arbeitslast und -Anwendung in Autopilot bereitstellen, wählt GKE den effizientesten zugrunde liegenden Maschinentyp und die effizienteste Größe für die Ausführung der Arbeitslasten aus.

Diese Anleitung richtet sich an ML-Entwickler (Machine Learning), Plattformadministratoren und ‑betreiber sowie an Daten- und KI-Spezialisten, die GKE Autopilot verwenden möchten, um den Verwaltungsaufwand für die Knotenkonfiguration, ‑skalierung und ‑upgrades zu reduzieren. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in Google Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE Enterprise-Nutzerrollen und -Aufgaben.

Machen Sie sich vor dem Lesen dieser Seite mit dem GKE Autopilot-Modus vertraut.

Ü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, die es dem Nutzer anzeigt. Weitere Informationen zu Fast Dash finden Sie in der Fast Dash-Dokumentation.

Lernziele

  • Bereiten Sie ein vortrainiertes T5-Modell aus dem Hugging Face-Repository für die Bereitstellung vor, indem Sie es als Container-Image verpacken und per Push an Artifact Registry übertragen.
  • Modell in einem Autopilot-Cluster bereitstellen
  • 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.

Hinweise

  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. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

    gcloud init

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

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

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

  8. Install the Google Cloud CLI.

  9. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

    gcloud init

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

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

  13. 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 Channel mit der GKE-Version 1.28.3-gke.1203000 oder höher aus, um L4-GPUs zu verwenden. Informationen dazu, welche Versionen in einem bestimmten Kanal verfügbar sind, finden Sie unter Standardversion 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 mit dem 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 mit Cloud Build in einem einzelnen Container-Image und übertragen das resultierende Image per Push in das Artifact Registry-Repository.

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

    # 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.12.0-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 Modelldatei im Archivformat (.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 mit Cloud Build und übertragen Sie es per Push:

    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 eine größere Modellgröße als t5-small verwenden, kann der Build-Prozess erheblich 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 Ihre Projekt-ID. Google Cloud

    Die Ausgabe sieht 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

Verpacktes Modell in GKE bereitstellen

In dieser Anleitung werden Kubernetes-Deployments verwendet, um das Image bereitzustellen. 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.

Ändern Sie das Kubernetes-Manifest im Beispielrepository, damit es Ihrer Umgebung entspricht.

  1. Überprü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"

    So 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 des Deployments und des Dienstes ab:

    kubectl get -f kubernetes/serving-gpu.yaml

    Warten Sie, bis in der Ausgabe bereite Pods angezeigt werden, wie im Folgenden. Je nach Größe des Images kann der erste Image-Pull 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, konnten einige Modellabhängigkeiten nicht installiert werden:

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

    So beheben Sie das Problem:

    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.

Über die Webanwendung auf das bereitgestellte Modell zugreifen

Führen Sie die folgenden Schritte aus, um mit der Fast Dash-Webanwendung auf das bereitgestellte Modell zuzugreifen:

  1. Erstellen Sie die Fast Dash-Webanwendung und übertragen Sie sie per Push als Container-Image 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 die Bereitstellung der Bereitstellung und des Dienstes abgeschlossen ist.

  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 bereite Pods angezeigt werden, die in etwa so aussehen:

    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, ist aber nicht über eine externe IP-Adresse zugänglich. So greifen Sie auf die Webanwendung zu:

    kubectl port-forward service/fastdash 8050

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

    • 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 wird beschrieben, wie Sie das Autoscaling für das Modell basierend auf Messwerten aus Google Cloud Managed Service for Prometheus aktivieren. Dazu gehen Sie 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 Kubernetes-Autoscaling-Entscheidungen 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 Ihre Projekt-ID. Google Cloud

  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 Ressource für Google Cloud Managed Service for Prometheus, die die Aufnahme von Messwerten und das Extrahieren von Zielen in einem bestimmten Namespace ermöglicht.

  1. Stellen Sie die PodMonitoring-Ressource im selben Namespace wie die TorchServe-Bereitstellung 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 Anzahl der T5-Modell-Pods basierend auf der kumulativen Dauer der Anfragewarteschlange. Das Autoscaling basiert auf dem Messwert ts_queue_latency_microseconds, der die kumulative Warteschlangendauer in Mikrosekunden angibt.

  3. Erstellen Sie den HorizontalPodAutoscaler:

    kubectl apply -f kubernetes/hpa.yaml

Autoscaling mit einem Load Generator prüfen

Um die Autoscaling-Konfiguration zu testen, generieren Sie Last für die Serving-Anwendung. In dieser Anleitung wird ein Locust-Load-Generator verwendet, um Anfragen an den Vorhersageendpunkt für das Modell zu senden.

  1. Load Generator erstellen:

    kubectl apply -f kubernetes/loadgenerator.yaml

    Warten Sie, bis die Pods des Lastgenerators 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, steigt 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, das Sie für die Bereitstellung verwenden.
  • Wenn Ihr Modell spezielle Paketabhängigkeiten hat oder die Größe Ihrer Abhängigkeiten groß ist, erstellen Sie eine benutzerdefinierte Version Ihres Basis-Docker-Images.
  • Beobachten Sie die Baumversion Ihrer Modellabhängigkeitspakete. Achten Sie darauf, dass die Paketabhängigkeiten die Versionen der anderen unterstützen. Panda-Version 2.0.3 unterstützt beispielsweise NumPy-Version 1.20.3 und höher.
  • GPU-intensive Modelle auf GPU-Knoten und CPU-intensive Modelle auf CPUs ausführen. Das kann die Stabilität der Bereitstellung von Modellen verbessern und dafür sorgen, dass Sie Knotenressourcen effizient nutzen.

Modellleistung beobachten

Um die Modellleistung zu beobachten, können Sie die TorchServe-Dashboard-Integration in Cloud Monitoring verwenden. In diesem Dashboard können Sie wichtige Leistungsmesswerte wie den Token-Durchsatz, die Anfrage-Latenz und die Fehlerraten einsehen.

Damit Sie das TorchServe-Dashboard verwenden können, müssen Sie Google Cloud Managed Service for Prometheus in Ihrem GKE-Cluster aktivieren. Damit werden die Messwerte von TorchServe erfasst. TorchServe stellt Messwerte standardmäßig im Prometheus-Format bereit. Sie müssen keinen zusätzlichen Exporter installieren.

Anschließend können Sie die Messwerte über das TorchServe-Dashboard aufrufen. Informationen zum Erfassen von Messwerten aus Ihrem Modell mit Google Cloud Managed Service for Prometheus finden Sie in der TorchServe-Anleitung zur Beobachtbarkeit in der Cloud Monitoring-Dokumentation.

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

Das 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 dazu können BERT-Modelle nur ein Klassenlabel oder einen Teil der Eingabe ausgeben. Das T5-Modell kann auch für Aufgaben wie Zusammenfassung, Fragen und Antworten oder Textklassifizierung verwendet werden. Das Modell wird mit einer großen Menge an Text aus dem 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 für bestimmte Anwendungsfälle geeignet sind. In dieser Anleitung wird die Standardgröße t5-small verwendet. Sie können aber auch eine andere Größe auswählen. Die folgenden T5-Größen werden unter der Apache 2.0-Lizenz vertrieben:

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

Informationen zu TorchServe

TorchServe ist ein flexibles Tool zum Bereitstellen von PyTorch-Modellen. Sie bietet sofortige Unterstützung für alle wichtigen Deep-Learning-Frameworks, darunter PyTorch, TensorFlow und ONNX. TorchServe kann verwendet werden, um Modelle in der Produktion bereitzustellen oder um schnell Prototypen zu erstellen und zu experimentieren.

Nächste Schritte