AI Training - Tutoriel - Premiers pas avec Triton Inference Server de NVIDIA et AI Training

Comment utiliser de manière optimale les modèles d'IA avec le serveur d'inférence Triton de NVIDIA et AI Training

Objectif

Triton Inference Server de NVIDIA vous permet de simplifier et de standardiser l'inférence IA.

Triton permet aux utilisateurs de déployer, exécuter et scaler des modèles d'IA entraînés, quel que soit le framework et quel que soit le type de ressources : GPU ou CPU. Il permet également aux développeurs de fournir de l'inférence haute performance dans le Cloud.

L'objectif de ce tutoriel est de voir comment déployer facilement Triton Inference Server grâce à l'outil OVHcloud AI Training.

Prérequis

Accès à l'
La CLI ovhai installée
Un projet AI Training créé au sein d'un projet Public Cloud sur votre compte OVHcloud
Un utilisateur pour AI Training
Docker installé sur votre ordinateur local ou sur une machine virtuelle
Quelques connaissances sur les images Docker et le Dockerfile
Quelques bases sur NVIDIA Triton Inference Server

En pratique

Créer le repository de modèles

Le repository de modèles est le répertoire dans lequel vous placez les modèles d'IA que vous souhaitez faire servir par Triton Inference Server.

Modèles personnalisés

Triton Inference Sever vous permet de déployer plusieurs modèles provenant de multiples frameworks de Deep Learning et de Machine Learning. Par exemple, Triton Inference Server peut servir les formats de modèles suivants : TensorRT, TensorFlow, PyTorch, ONNX, ...

Suivez le guide utilisateur de NVIDIA Triton Inference Server pour en savoir plus sur ses capacités.

Pour utiliser des modèles d'IA personnalisés, les répertoires et fichiers qui composent un repository de modèles doivent suivre une structure requise.

├── <model-repository-path>/
    └── <model-name>/
        └── [config.pbtxt]
        └── [<output-labels-file> ...]
        └── <version>/
            └── <model-definition-file>
        └── <version>/
            └── <model-definition-file>
        ...
    └── <model-name>/
        └── [config.pbtxt]
        └── [<output-labels-file> ...]
        └── <version>/
            └── <model-definition-file>
        └── <version>/
            └── <model-definition-file>
        ...
    ...

Retrouvez plus d'informations sur l'utilisation de modèles personnalisés avec Triton dans cette documentation.

Un exemple de repository de modèles est inclus dans docs/examples/model_repository.

Info

Nous utiliserons ces modèles déjà entraînés dans ce tutoriel.

Modèles d'exemple

Tout d'abord, vous devez cloner localement le dépôt GitHub de Triton Inference Server.

Info

Dans cette commande, spécifiez également la version de Triton qui vous intéresse. Pour cet exemple, nous utiliserons la r23.03.

Clonez le dépôt GitHub :

git clone -b r23.03 https://github.com/triton-inference-server/server.git

Avant d'utiliser le dépôt, vous devez récupérer tous les fichiers de définition de modèles manquants depuis leurs model zoos publics via le script fourni : fetch_models.sh.

Les modèles suivants seront téléchargés :

densenet_onnx
inception_graphdef
simple
simple_dyna_sequence
simple_identity
simple_int8
simple_sequence
simple_string

cd server/docs/examples
./fetch_models.sh

Vérifiez le contenu et l'architecture de votre repository de modèles avec la commande tree :

tree model_repository/

Vous devriez obtenir :

model_repository/
├── densenet_onnx
│   ├── 1
│   │   └── model.onnx
│   ├── config.pbtxt
│   └── densenet_labels.txt
├── inception_graphdef
│   ├── 1
│   │   └── model.graphdef
│   ├── config.pbtxt
│   └── inception_labels.txt
├── simple
│   ├── 1
│   │   └── model.graphdef
│   └── config.pbtxt
├── simple_dyna_sequence
│   ├── 1
│   │   └── model.graphdef
│   └── config.pbtxt
├── simple_identity
│   ├── 1
│   │   └── model.savedmodel
│   │       └── saved_model.pb
│   └── config.pbtxt
├── simple_int8
│   ├── 1
│   │   └── model.graphdef
│   └── config.pbtxt
├── simple_sequence
│   ├── 1
│   │   └── model.graphdef
│   └── config.pbtxt
└── simple_string
    ├── 1
    │   └── model.graphdef
    └── config.pbtxt

17 directories, 18 files

Envoyer les modèles vers un conteneur Object Storage

Pour envoyer les modèles vers un conteneur Object Storage OVHcloud, vous pouvez utiliser la CLI ovhai.

Warning

Attention ! Pour utiliser Triton Inference Server, vous devez vous assurer que votre repository de modèles est correctement architecturé. Par exemple, conservez les répertoires vides, ils sont nécessaires au bon fonctionnement.

ovhai bucket object upload my-models@GRA model_repository/ --remove-prefix model_repository/

Une fois vos modèles envoyés, vérifiez qu'ils sont tous disponibles :

ovhai bucket object list my-models@GRA

Vous devriez obtenir :

DATE                       BYTES    NAME                                              DESCRIPTION ETAG
2023-05-04T12:45:41.643960 31.2 MiB densenet_onnx/1/model.onnx                        Object      c037b5c86fdfc940900b309299657f92
2023-05-04T12:45:41.663860 387 B    densenet_onnx/config.pbtxt                        Object      d0479dc66442434320897957068e5d51
2023-05-04T12:45:41.668330 10.1 KiB densenet_onnx/densenet_labels.txt                 Object      8ea0e7b022e01f34c5cccecbdf90b14f
2023-05-04T12:45:41.664780 91.3 MiB inception_graphdef/1/model.graphdef               Object      4b0459bcf60c61cf2ec759ff89ebbbb7
2023-05-04T12:45:41.672190 340 B    inception_graphdef/config.pbtxt                   Object      7c62d703609e2db1145cbb709ed0bf35
2023-05-04T12:45:41.659140 10.1 KiB inception_graphdef/inception_labels.txt           Object      aafe29c3854eda34886973b95036e66d
2023-05-04T12:45:41.668390 310 B    simple/1/model.graphdef                           Object      de0bafd39f604ea09ca677fc79c70bb5
2023-05-04T12:45:41.663640 370 B    simple/config.pbtxt                               Object      c805202e04542e47a8473181f9dcd0b9
2023-05-04T12:45:41.778020 879 B    simple_dyna_sequence/1/model.graphdef             Object      bce7d0674c80275ccb865a14eaa0c29a
2023-05-04T12:45:41.786770 2.6 KiB  simple_dyna_sequence/config.pbtxt                 Object      ffe0ca21fb2fd3352f976d139869a87e
2023-05-04T12:45:41.783670 531 B    simple_identity/1/model.savedmodel/saved_model.pb Object      eb2ce10be33de0013d98b26348cc8818
2023-05-04T12:45:41.789540 242 B    simple_identity/config.pbtxt                      Object      5994e38fdf5f2789a0dc942dfdeff422
2023-05-04T12:45:41.822000 281 B    simple_int8/1/model.graphdef                      Object      ff193cfa1d711e1e0d647e7f0d09965d
2023-05-04T12:45:41.888750 371 B    simple_int8/config.pbtxt                          Object      fa24596d26d5d03b6c78c02dacabe039
2023-05-04T12:45:41.949530 621 B    simple_sequence/1/model.graphdef                  Object      9c3c5501f283e1a1c955b299b027811c
2023-05-04T12:45:41.971580 2.1 KiB  simple_sequence/config.pbtxt                      Object      fd5b8ae1375aef54998845c4690b7af9
2023-05-04T12:45:42.042580 696 B    simple_string/1/model.graphdef                    Object      4b8239460b9c647e71e0d79e3f42d1c1
2023-05-04T12:45:42.056610 382 B    simple_string/config.pbtxt                        Object      840206b87fb3259eabdc3bb6478ab687

Lancer Triton Inference Server avec AI Training

Triton est optimisé pour offrir les meilleures performances d'inférence en utilisant des GPUs. Dans ce tutoriel, il fonctionnera avec un GPU grâce à l'outil OVHcloud AI Training.

Tout d'abord, récupérez l'image Docker de Triton Inference Server depuis le dépôt NGC. Dans ce tutoriel, nous utiliserons la version de container 23.03-py3.

docker pull nvcr.io/nvidia/tritonserver:23.03-py3

Personnaliser l'image Docker de Triton Inference Server pour OVHcloud AI Tools

Pour rendre l'image de Triton Inference Server compatible avec AI Training, vous devez reconstruire l'image en donnant les droits à l'utilisateur OVHcloud sur le contenu de /workspace.

Info

Pour plus d'informations sur la construction d'images Docker compatibles avec les solutions AI d'OVHcloud, reportez-vous à cette documentation.

Créer le Dockerfile

Votre Dockerfile doit commencer par l'instruction FROM indiquant l'image parente à utiliser. Dans notre cas, nous choisissons de partir de l'image récupérée FROM nvcr.io/nvidia/tritonserver:23.03-py3 :

FROM nvcr.io/nvidia/tritonserver:23.03-py3

Créez le répertoire personnel et copiez-y vos fichiers :

WORKDIR /workspace
COPY . /workspace

Donnez les droits d'accès corrects à l'utilisateur OVHcloud (42420:42420) :

Warning

N'oubliez pas l'argument --user=42420:42420 si vous souhaitez simuler exactement le même comportement que celui qui se produira sur les jobs AI Training. Il exécute le container Docker en tant qu'utilisateur OVHcloud spécifique (utilisateur 42420:42420).

RUN chown -R 42420:42420 /workspace
ENV HOME=/workspace

Retrouvez le Dockerfile complet ci-dessous :

FROM nvcr.io/nvidia/tritonserver:23.03-py3

WORKDIR /workspace
COPY . /workspace

RUN chown -R 42420:42420 /workspace
ENV HOME=/workspace

Construire l'image Docker depuis le Dockerfile

Depuis le répertoire contenant votre Dockerfile, exécutez l'une des commandes suivantes pour construire l'image de votre application :

# Build the image using your machine's default architecture
docker build . -t triton-inference-server:23.03-py3

# Build image targeting the linux/amd64 architecture
docker buildx build --platform linux/amd64 -t triton-inference-server:23.03-py3 .

La première commande construit l'image en utilisant l'architecture par défaut de votre système. Cela peut fonctionner si votre machine utilise déjà l'architecture linux/amd64, qui est requise pour exécuter des containers avec nos produits AI. Cependant, sur des systèmes avec une architecture différente (par exemple ARM64 sur Apple Silicon), l'image résultante ne sera pas compatible et ne pourra pas être déployée.
La seconde commande cible explicitement l'architecture linux/amd64 afin de garantir la compatibilité avec nos services AI. Elle nécessite buildx, qui n'est pas installé par défaut. Si vous n'avez jamais utilisé buildx, vous pouvez l'installer en exécutant : docker buildx install

Info

L'argument point . indique que votre contexte de build (emplacement du Dockerfile et des autres fichiers nécessaires) est le répertoire courant.

L'argument -t vous permet de choisir l'identifiant à donner à votre image. En général, les identifiants d'image sont composés d'un nom et d'un tag de version <name>:<version>. Pour cet exemple, nous avons choisi triton-inference-server:23.03-py3.

Envoyer l'image du serveur vers le registre partagé

Warning

Le registre partagé d'AI Training ne doit être utilisé qu'à des fins de test. Pensez à attacher votre propre registre. Plus d'informations à ce sujet sont disponibles ici. Les images envoyées vers ce registre sont uniquement destinées aux workloads AI Tools, et ne seront pas accessibles pour des usages externes.

Trouvez l'adresse de votre registre partagé en lançant cette commande :

ovhai registry list

Connectez-vous au registre partagé avec vos identifiants habituels d'utilisateur de la plateforme AI :

docker login -u <user> -p <password> <shared-registry-address>

Envoyez l'image compilée vers le registre partagé :

docker tag triton-inference-server:23.03-py3 <shared-registry-address>/triton-inference-server:23.03-py3
docker push <shared-registry-address>/triton-inference-server:23.03-py3

Lancer Triton Inference Server dans un job dédié

Triton Inference Server expose des endpoints à la fois HTTP/REST et gRPC. Les clients peuvent donc communiquer avec Triton en utilisant soit le protocole HTTP/REST, soit le protocole gRPC.

Lancez Triton Inference Server avec l'outil OVHcloud AI Training pour bénéficier de la puissance du GPU :

ovhai job run --default-http-port 8000 \
              --gpu 1 \
              --volume my-models@GRA:/workspace/models:RO \
              <shared-registry-address>/triton-inference-server:23.03-py3 \
              -- bash -c 'tritonserver --model-repository=/workspace/models'

Pour que le client puisse communiquer avec Triton Inference Server, vous devez récupérer l'IP et l'URL du job serveur.

Si nécessaire, installez jq comme suit :

sudo apt-get install jq

Pour obtenir l'URL du job serveur, exécutez la commande suivante :

ovhai job get <job_id> -o json | jq '.status.url' -r

Vous pouvez vérifier que Triton Inference Server fonctionne correctement.

curl -v <job_url>/v2/health/ready

Ensuite, vous pouvez obtenir l'IP du job serveur :

ovhai job get <job_id> -o json | jq '.status.ip' -r

Envoyer des requêtes d'inférence

Utilisez d'abord un docker pull pour récupérer l'image contenant les bibliothèques et exemples clients depuis NGC.

docker pull nvcr.io/nvidia/tritonserver:23.03-py3-sdk

Info

Dans l'exemple suivant, nous utiliserons densenet, un modèle de classification d'images. Nous verrons les résultats obtenus sur l'image suivante :

Tester en local (optionnel)

docker run -it --rm --net=host nvcr.io/nvidia/tritonserver:23.03-py3-sdk

Ensuite, testez le modèle densenet_onnx sur l'image d'exemple.

Warning

Pour tester en local, vous devez spécifier le server_job_url pour pouvoir envoyer des requêtes http. Vous pouvez l'obtenir en utilisant la commande suivante :

ovhai job get <job_id> -o json | jq '.status.url' -r

/workspace/install/bin/image_client -u <server_job_url> -m densenet_onnx -c 3 -s INCEPTION /workspace/images/mug.jpg

Vous devriez obtenir le résultat suivant :

Image '/workspace/images/dog.jpg':
12.465825 (264) = CARDIGAN
11.567661 (263) = PEMBROKE
9.468060 (151) = CHIHUAHUA

Personnaliser l'image Docker du client Triton pour OVHcloud AI Tools

Ici, la méthode est exactement la même que celle utilisée précédemment pour le serveur Triton. Reportez-vous à la partie concernant l'image Docker du serveur Triton pour plus de détails.

Créer le Dockerfile

FROM nvcr.io/nvidia/tritonserver:23.03-py3-sdk

WORKDIR /workspace
COPY . /workspace

RUN chown -R 42420:42420 /workspace
ENV HOME=/workspace

Construire l'image Docker depuis le Dockerfile

Lancez la commande suivante depuis le répertoire du Dockerfile pour construire l'image de votre application :

docker build . -t triton-inference-server:23.03-py3-sdk

Envoyer l'image du client vers le registre partagé

Envoyez l'image compilée vers le registre partagé :

docker tag triton-inference-server:23.03-py3-sdk <shared-registry-address>/triton-inference-server:23.03-py3-sdk
docker push <shared-registry-address>/triton-inference-server:23.03-py3-sdk

Lancer un job client Triton pour l'inférence

Exécutez le client image d'exemple dans un job AI Training pour effectuer une classification d'images en utilisant le modèle d'exemple densenet_onnx.

Pour pouvoir classifier vos propres images, vous pouvez créer un conteneur d'objets dans l'Object Storage OVHcloud et y ajouter vos images :

Warning

Dans cet exemple, nous ajoutons l'image dog.jpg dans le bucket.

ovhai bucket object upload my-images@GRA image_repository/ --remove-prefix image_repository/dog.jpg

Pour envoyer une requête pour le modèle densenet_onnx, utilisez une image du répertoire /workspace/images. Dans ce cas, nous demandons les 3 meilleures classifications.

Protocole HTTP/REST

Il vous suffit d'utiliser le flag -u pour pointer vers l'endpoint gRPC sur Triton. L'URL du serveur d'inférence sera votre URL du job serveur.

Warning

Vous devriez avoir obtenu cette IP du job serveur lors du lancement de Triton Inference Server avec AI Training à l'étape Lancer Triton Server dans un job dédié.

Vous devez spécifier le port 8000 si vous souhaitez utiliser le protocole HTTP/REST.

Lancez le job d'inférence pour le protocole HTTP :

ovhai job run \
     --cpu 1 \
     --volume my-images@GRA:/workspace/images:RO \
     <shared-registry-address>/triton-inference-server:23.03-py3-sdk \
     -- bash -c '/workspace/install/bin/image_client -u <server_job_ip>:8000 -m densenet_onnx -c 3 -s INCEPTION /workspace/images/'

Une fois votre job en statut RUNNING, consultez les logs pour obtenir les résultats de la classification.

ovhai job logs <job_id> --from job

Vous devriez obtenir quelque chose comme ceci :

2023-08-21T14:47:03Z [job] Image '/workspace/images//dog.jpg':
2023-08-21T14:47:03Z [job] 12.465825 (264) = CARDIGAN
2023-08-21T14:47:03Z [job] 11.567661 (263) = PEMBROKE
2023-08-21T14:47:03Z [job] 9.468060 (151) = CHIHUAHUA

Protocole gRPC

Si vous souhaitez utiliser le protocole gRPC en fournissant le flag -i, vous devez également utiliser le flag -u pour pointer vers l'endpoint gRPC sur Triton. L'URL du serveur d'inférence sera votre IP du job serveur.

Warning

Vous devriez avoir obtenu cette IP du job serveur lors du lancement de Triton Inference Server avec AI Training à l'étape Lancer Triton Server dans un job dédié.

Vous devez spécifier le port 8001 si vous souhaitez utiliser le protocole gRPC.

Lancez le job d'inférence pour le protocole gRPC :

ovhai job run \
     --cpu 1 \
     --volume my-images@GRA:/workspace/images:RO \
     <shared-registry-address>/triton-inference-server:23.03-py3-sdk \
     -- bash -c '/workspace/install/bin/image_client -i grpc -u <server_job_ip>:8001 -m densenet_onnx -c 3 -s INCEPTION /workspace/images/'

Une fois votre job en statut RUNNING, consultez les logs pour obtenir les résultats de la classification.

ovhai job logs <job_id> --from job

Vous devriez obtenir le résultat suivant :

2023-08-21T14:47:03Z [job] Image '/workspace/images/dog.jpg':
2023-08-21T14:47:03Z [job] 12.465825 (264) = CARDIGAN
2023-08-21T14:47:03Z [job] 11.567661 (263) = PEMBROKE
2023-08-21T14:47:03Z [job] 9.468060 (151) = CHIHUAHUA

Aller plus loin

Pour aller plus loin avec Triton Inference Server et OVHcloud AI Tools, vous pouvez suivre ces tutoriels.

Votre avis nous intéresse !

N’hésitez pas à nous faire part de vos questions, retours et suggestions pour améliorer le service :

Sur le serveur Discord OVHcloud

Cette page vous a-t-elle aidé ?