Diffuser des LLM évolutifs sur GKE à l'aide de TorchServe

Ce tutoriel explique comment diffuser un modèle de machine learning (ML) PyTorch pré-entraîné sur un cluster GKE à l'aide du framework TorchServe pour une mise en service évolutive. Le modèle de ML utilisé dans ce tutoriel génère des prédictions basées sur les requêtes des utilisateurs. Vous pouvez utiliser les informations de ce tutoriel pour déployer et diffuser vos propres modèles à grande échelle sur GKE.

À propos de l'application du tutoriel

L'application est une petite application Web Python créée à l'aide du framework Fast Dash. Vous utilisez l'application pour envoyer des requêtes de prédiction au modèle T5. Cette application capture les entrées de texte et les paires linguistiques des utilisateurs, puis envoie les informations au modèle. Le modèle traduit le texte et renvoie le résultat à l'application, qui le présente à l'utilisateur. Pour en savoir plus sur Fast Dash, consultez la documentation de Fast Dash.

Fonctionnement

Ce tutoriel déploie les charges de travail sur un cluster GKE Autopilot. GKE gère entièrement les nœuds Autopilot, ce qui réduit les frais d'administration pour la configuration, le scaling et les mises à niveau des nœuds. Lorsque vous déployez la charge de travail et l'application de ML sur Autopilot, GKE choisit le type de machine et la taille sous-jacents appropriés pour exécuter les charges de travail. Pour en savoir plus, consultez la page Présentation d'Autopilot.

Après avoir déployé le modèle, vous obtenez une URL de prédiction que votre application peut utiliser pour envoyer des requêtes de prédiction au modèle. Cette méthode dissocie le modèle de l'application, ce qui lui permet d'évoluer indépendamment de l'application Web.

Objectifs

  • Préparer un modèle T5 pré-entraîné à partir du dépôt Hugging Face pour le diffuser en l'empaquetant en tant qu'image de conteneur et en le transférant dans Artifact Registry
  • Déployer le modèle sur un cluster Autopilot
  • Déployer l'application Fast Dash qui communique avec le modèle
  • Autoscaling du modèle en fonction des métriques Prometheus

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  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

Préparer l'environnement

Clonez l'exemple de dépôt et ouvrez le répertoire du tutoriel :

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

Créer le cluster

Exécutez la commande ci-dessous.

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

Remplacez les éléments suivants :

  • RELEASE_CHANNEL : version disponible pour votre cluster. Doit être défini sur rapid, regular ou stable. Choisissez un canal disposant de la version 1.28.3-gke.1203000 ou ultérieure de GKE pour utiliser des GPU L4. Pour afficher les versions disponibles dans un canal spécifique, consultez la section Afficher les versions par défaut et disponibles pour les canaux de publication.
  • CLUSTER_VERSION : version de GKE à utiliser. Doit être 1.28.3-gke.1203000 ou une version ultérieure.

Cette opération prend plusieurs minutes.

Créer un dépôt Artifact Registry

  1. Créez un dépôt standard Artifact Registry au format Docker dans la même région que votre cluster :

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

  2. Vérifiez le nom du dépôt :

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

    Le résultat ressemble à ce qui suit :

    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'

Empaqueter le modèle

Dans cette section, vous allez empaqueter le modèle et le framework de diffusion dans une seule image de conteneur à l'aide de Cloud Build, puis transférer l'image obtenue dans le dépôt Artifact Registry.

  1. Examinez le fichier Dockerfile de l'image du conteneur :

    # 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/

    Ce fichier Dockerfile définit le processus de compilation en plusieurs étapes suivant :

    1. Téléchargez les artefacts de modèle à partir du dépôt Hugging Face.
    2. Empaquetez le modèle à l'aide de l'outil PyTorch Serving Archive. Cela crée un fichier d'archive de modèle (.mar) que le serveur d'inférence utilise pour charger le modèle.
    3. Créez l'image finale avec PyTorch Serve.

  2. Créez et transférez l'image à l'aide de 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

    Le processus de compilation prend plusieurs minutes. Si le modèle est de taille supérieure à t5-small, le processus de compilation risque de prendre considérablement plus de temps.

  3. Vérifiez que l'image se trouve dans le dépôt :

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

    Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

    Le résultat ressemble à ce qui suit :

    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

Déployer le modèle empaqueté sur GKE

Pour déployer l'image, modifiez le fichier manifeste Kubernetes dans l'exemple de dépôt afin qu'il corresponde à votre environnement.

  1. Examinez le fichier manifeste pour la charge de travail d'inférence :

    # 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. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud :

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

    Cela garantit que le chemin d'accès de l'image de conteneur dans la spécification du déploiement correspond au chemin d'accès à votre image de modèle T5 dans Artifact Registry.

  3. Créez les ressources Kubernetes :

    kubectl create -f kubernetes/serving-gpu.yaml

Pour vérifier que le modèle a bien été déployé, procédez comme suit :

  1. Obtenez l'état du déploiement et du service :

    kubectl get -f kubernetes/serving-gpu.yaml

    Attendez que le résultat affiche des pods prêts, comme ci-dessous. Selon la taille de l'image, la première extraction d'image peut prendre plusieurs minutes.

    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. Ouvrez un port local pour le service t5-inference :

    kubectl port-forward svc/t5-inference 8080

  3. Ouvrez une nouvelle fenêtre de terminal et envoyez une requête de test au service :

    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"

    Si la requête de test échoue et que la connexion du pod se ferme, consultez les journaux :

    kubectl logs deployments/t5-inference

    Si le résultat ressemble à ce qui suit, TorchServe n'a pas réussi à installer certaines dépendances de modèle :

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

    Pour résoudre ce problème, redémarrez le déploiement :

    kubectl rollout restart deployment t5-inference

    Le contrôleur de déploiement crée un pod. Répétez les étapes précédentes pour ouvrir un port sur le nouveau pod.

Accéder au modèle déployé à l'aide de l'application Web

  1. Créez et transférez l'application Web Fast Dash en tant qu'image de conteneur dans Artifact Registry :

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

  2. Ouvrez kubernetes/application.yaml dans un éditeur de texte et remplacez PROJECT_ID dans le champ image: par votre ID de projet. Vous pouvez également exécuter la commande suivante :

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

  3. Créez les ressources Kubernetes :

    kubectl create -f kubernetes/application.yaml

    Le provisionnement complet des services de déploiement et de service peut prendre un certain temps.

  4. Pour vérifier l'état, exécutez la commande suivante :

    kubectl get -f kubernetes/application.yaml

    Attendez que le résultat affiche des pods prêts, semblable à ceci :

    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. L'application Web est désormais en cours d'exécution, bien qu'elle ne soit pas exposée sur une adresse IP externe. Pour accéder à l'application Web, ouvrez un port local :

    kubectl port-forward service/fastdash 8050

  6. Dans un navigateur, ouvrez l'interface Web :

    • Si vous utilisez un shell local, ouvrez un navigateur et accédez à l'adresse http://127.0.0.1:8050.
    • Si vous utilisez Cloud Shell, cliquez sur Aperçu Web, puis sur Modifier le port. Définissez le port 8050.

  7. Pour envoyer une requête au modèle T5, spécifiez des valeurs dans les champs TEXT, FROM LANG et TO LANG de l'interface Web et cliquez sur Envoyer. Pour obtenir la liste des langues disponibles, consultez la documentation T5.

Activer l'autoscaling pour le modèle

Cette section explique comment activer l'autoscaling pour le modèle en fonction des métriques de Google Cloud Managed Service pour Prometheus en procédant comme suit :

  1. Installer l'adaptateur de métriques personnalisées Stackdriver
  2. Appliquer les configurations PodMonitoring et HorizontalPodAutoscaling

Google Cloud Managed Service pour Prometheus est activé par défaut dans les clusters Autopilot exécutant les versions 1.25 et ultérieures.

Installer l'adaptateur de métriques personnalisées Stackdriver

Cet adaptateur permet à votre cluster d'utiliser les métriques de Prometheus pour prendre des décisions d'autoscaling Kubernetes.

  1. Déployez l'adaptateur :

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

  2. Créez un compte de service IAM que l'adaptateur utilisera :

    gcloud iam service-accounts create monitoring-viewer

  3. Attribuez au compte de service IAM le rôle monitoring.viewer sur le projet et le rôle iam.workloadIdentityUser :

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

    Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

  4. Annotez le compte de service Kubernetes de l'adaptateur pour lui permettre d'emprunter l'identité du compte de service IAM :

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

  5. Redémarrez l'adaptateur pour propager les modifications :

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

Appliquer les configurations PodMonitoring et HorizontalPodAutoscaling

PodMonitoring est une ressource personnalisée Google Cloud Managed Service pour Prometheus qui permet l'ingestion de métriques et le scraping cible dans un espace de noms spécifique.

  1. Déployez la ressource PodMonitoring dans le même espace de noms que le déploiement TorchServe :

    kubectl apply -f kubernetes/pod-monitoring.yaml

  2. Examinez le fichier manifeste HorizontalPodAutoscaler :

    # 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"

    L'objet HorizontalPodAutoscaler adapte la quantité de pods du modèle T5 en fonction de la durée cumulée de la file d'attente de requêtes. L'autoscaling est basé sur la métrique ts_queue_latency_microseconds, qui affiche la durée cumulée de la file d'attente en microsecondes.

  3. Créez l'objet HorizontalPodAutoscaler :

    kubectl apply -f kubernetes/hpa.yaml

Vérifier l'autoscaling à l'aide d'un générateur de charge

Pour tester votre configuration d'autoscaling, générez une charge pour l'application de diffusion. Ce tutoriel utilise un générateur de charge Locust pour envoyer des requêtes au point de terminaison de prédiction du modèle.

  1. Créez le générateur de charge :

    kubectl apply -f kubernetes/loadgenerator.yaml

    Attendez que les pods du générateur de charge soient prêts.

  2. Exposez l'interface Web du générateur de charge localement :

    kubectl port-forward svc/loadgenerator 8080

    Si un message d'erreur s'affiche, réessayez lorsque le pod est en cours d'exécution.

  3. Dans un navigateur, ouvrez l'interface Web du générateur de charge :

    • Si vous utilisez un shell local, ouvrez un navigateur et accédez à l'adresse http://127.0.0.1:8080.
    • Si vous utilisez Cloud Shell, cliquez sur Aperçu Web, puis sur Modifier le port. Indiquez le port 8080.

  4. Cliquez sur l'onglet Graphiques pour observer les performances au fil du temps.

  5. Ouvrez une nouvelle fenêtre de terminal et surveillez le nombre d'instances dupliquées de vos autoscalers horizontaux de pods :

    kubectl get hpa -w

    Le nombre d'instances répliquées augmente à mesure que la charge augmente. Le scaling à la hausse peut prendre environ dix minutes. À mesure que de nouvelles instances répliquées démarrent, le nombre de requêtes réussies dans le graphique Locust augmente.

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

Recommandations

  • Créez votre modèle avec la même version de l'image Docker de base que celle que vous utiliserez pour la diffusion.
  • Si votre modèle possède des dépendances de package spéciales ou si la taille de vos dépendances est importante, créez une version personnalisée de votre image Docker de base.
  • Observez la version d'arborescence de vos packages de dépendance de modèle. Assurez-vous que vos dépendances de package sont compatibles avec leurs versions respectives. Par exemple, Panda version 2.0.3 est compatible avec NumPy version 1.20.3 et ultérieure.
  • Exécutez des modèles avec une utilisation intensive des GPU sur des nœuds GPU et des modèles avec utilisation intensive du processeur sur le processeur. Cela peut améliorer la stabilité de la diffusion du modèle et vous assurer que vous consommez efficacement les ressources de nœud.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Supprimer des ressources individuelles

  1. Supprimez les ressources Kubernetes :

    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. Supprimez le cluster GKE :

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

  3. Supprimez le compte de service IAM et les liaisons de stratégie IAM :

    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. Supprimez les images dans Artifact Registry. Vous pouvez également supprimer l'intégralité du dépôt. Pour obtenir des instructions, consultez la documentation d'Artifact Registry sur la suppression d'images.

Présentation des composants

Cette section décrit les composants utilisés dans ce tutoriel, tels que le modèle, l'application Web, le framework et le cluster.

À propos du modèle T5

Ce tutoriel utilise un modèle T5 multilingue pré-entraîné. Le type T5 est un transformateur texte-vers-texte qui convertit du texte d'une langue à une autre. Avec le modèle T5, les entrées et les sorties sont toujours des chaînes de texte, contrairement aux modèles de type BERT qui ne peuvent générer qu'une étiquette de classe ou un segment de l'entrée. Le modèle T5 peut également être utilisé pour des tâches telles que la synthèse, les questions/réponses ou la classification de texte. Le modèle est entraîné sur une grande quantité de texte provenant de Colossal Clean Crawled Corpus (C4) et de Wiki-DPR.

Pour en savoir plus, consultez la documentation du modèle T5.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, et Peter J. Liu a présenté le modèle T5 dans l'article Explore the Limits of Transfer Learning with a Unified Text-to-Text Transformer (Explorer les limites de l'apprentissage par transfert avec un transformateur de texte-vers-texte unifié) publié dans le Journal of Machine Learning Research.

Le modèle T5 est compatible avec différentes tailles de modèle, avec différents niveaux de complexité adaptés à des cas d'utilisation spécifiques. Ce tutoriel utilise la taille par défaut, t5-small, mais vous pouvez également en choisir une autre. Les tailles T5 suivantes sont distribuées sous la licence Apache 2.0 :

  • t5-small : 60 millions de paramètres
  • t5-base : 220 millions de paramètres
  • t5-large : 770 millions de paramètres. 3 Go pour le téléchargement.
  • t5-3b : 3 milliards de paramètres. 11 Go pour le téléchargement.
  • t5-11b : 11 milliards de paramètres. 45 Go pour le téléchargement.

Pour les autres modèles T5 disponibles, consultez le dépôt Hugging Face.

À propos de TorchServe

TorchServe est un outil flexible permettant de diffuser des modèles PyTorch. Il est directement compatible avec tous les principaux frameworks de deep learning, y compris PyTorch, TensorFlow et ONNX. TorchServe peut être utilisé pour déployer des modèles en production, ou pour un prototypage et des tests rapides.

Étapes suivantes