Diffuser des LLM évolutifs sur GKE avec TorchServe

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 avec la version GKE 1.28.3-gke.1203000 ou ultérieure pour utiliser les 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 empaquetez le modèle et le framework de diffusion dans une seule image de conteneur à l'aide de Cloud Build, puis transférez l'image obtenue vers 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.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/
   

   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. Emballez le modèle à l'aide de l'outil PyTorch Serving Archive. Un fichier d'archive de modèle (.mar) est alors créé et utilisé par le serveur d'inférence 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 Google Cloudprojet.

   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, ce tutoriel utilise des déploiements Kubernetes. Un déploiement est un objet d'API Kubernetes qui vous permet d'exécuter plusieurs réplicas de pods répartis entre les nœuds d'un cluster.

Modifiez le fichier manifeste Kubernetes dans l'exemple de dépôt pour 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 votre Google CloudID de projet:

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

   Cela garantit que le chemin d'accès à l'image du conteneur dans la spécification de déploiement correspond au chemin d'accès à l'image de votre 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 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            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

Pour accéder au modèle déployé avec l'application Web Fast Dash, procédez comme suit:

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 déploiement et le service peuvent prendre un certain temps à être entièrement provisionnés.

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            8050/TCP         1m
   

5. L'application Web s'exécute désormais, 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 Web preview (Aperçu Web), puis sur Change port (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 la version 1.25 ou ultérieure.

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

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 d'ingérer des métriques et d'extraire des cibles 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'autoscaler horizontal de pods ajuste la quantité de pods du modèle T5 en fonction de la durée cumulée de la file d'attente des requêtes. L'autoscaling est basé sur la métrique ts_queue_latency_microseconds, qui indique 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 de la 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 Web preview (Aperçu Web), puis sur Change port (Modifier le port). Saisissez 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. L'ajustement 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 vous utiliserez pour le traitement.
• Si votre modèle comporte des dépendances de paquets spéciales ou si la taille de vos dépendances est importante, créez une version personnalisée de votre image Docker de base.
• Surveillez la version de l'arborescence des packages de dépendance de votre modèle. Assurez-vous que les dépendances de vos packages sont compatibles avec les versions des autres. Par exemple, la version 2.0.3 de Panda est compatible avec la version 1.20.3 de NumPy et les versions ultérieures.
• Exécutez des modèles gourmands en GPU sur des nœuds GPU et des modèles gourmands en CPU sur un CPU. Cela peut améliorer la stabilité de la diffusion du modèle et vous assurer que vous consommez efficacement les ressources de nœud.

Observer les performances du modèle

Pour observer les performances du modèle, vous pouvez utiliser l'intégration du tableau de bord TorchServe dans Cloud Monitoring. Ce tableau de bord vous permet d'afficher des métriques de performances critiques telles que le débit des jetons, la latence des requêtes et les taux d'erreur.

Pour utiliser le tableau de bord TorchServe, vous devez activer Google Cloud Managed Service pour Prometheus, qui collecte les métriques de TorchServe, dans votre cluster GKE. TorchServe expose les métriques au format Prometheus par défaut. Vous n'avez pas besoin d'installer un exportateur supplémentaire.