Diffuser des LLM évolutifs sur GKE à l'aide de 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 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, TEXT et TEXT de l'interface Web et cliquez sur TEXT. 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.