Optimisation IA pont roulant avec PyTorch vers ONNX sur Jetson

Un modèle IA pour pont roulant qui fonctionne parfaitement sur un GPU en laboratoire ne vaut rien s'il ne peut pas être déployé sur le terrain. Les conditions environnementales industrielles (vibrations, températures élevées, espace restreint, absence de climatisation) ne permettent pas d'installer un serveur GPU à forte puissance (350W+ nécessite une salle climatisée). Le déploiement en périphérie (Edge Deployment) convertit le modèle PyTorch entraîné au format intermédiaire ONNX, puis l'optimise par quantification INT8 TensorRT pour le déployer sur un dispositif périphérique Jetson à faible consommation. Cet article prend l'exemple du modèle ResNet-18 de détection de fils cassés du câble du pont roulant et fournit la chaîne d'ingénierie complète, de l'export au déploiement, chaque étape étant reproductible. Environnement d'expérimentation : entraînement NVIDIA A10 (48GB) / périphérie Jetson Orin NX 16GB (15W) / PyTorch 2.1.0 / TensorRT 8.6 / JetPack 6.0.

Étape 1 : Export du modèle PyTorch vers ONNX

ONNX (Open Neural Network Exchange) est le « langage universel » du déploiement de modèles. torch.onnx.export() convertit le graphe de calcul dynamique de PyTorch en graphe statique ONNX. Paramètres clés : input_names=[« input »], output_names=[« output »], dynamic_axes={« input »:{0:« batch_size »,2:« height »,3:« width »}} (prise en charge d'entrées à dimensions variables). Après l'export, on utilise onnxruntime pour vérifier la cohérence de la précision : la différence de précision d'inférence FP32 par rapport à PyTorch est inférieure à 0,1 % (moyenne sur 20 images de validation).

import torch, torch.onnx model = torch.load("resnet18_crane.pth") # FP32Modèle pré-entraîné type dummy = torch.randn(1, 3, 224, 224) torch.onnx.export(model, dummy, "resnet18_crane.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch", 2: "h", 3: "w"}}, opset_version=17) # Précision de validation/export import onnxruntime as ort sess = ort.InferenceSession("resnet18_crane.onnx") out_ort = sess.run(None, {"input": dummy.numpy()})[0] out_pt = model(dummy).detach().numpy() print(f"Max diff: {abs(out_ort - out_pt).max():.6f}") # Réponse＜1e-5

Étape 2 : Quantification INT8 avec TensorRT

TensorRT est le moteur d'optimisation d'inférence de NVIDIA. Grâce à la fusion de couches (Layer Fusion), à l'étalonnage de précision (INT8 Calibration) et à l'optimisation mémoire (Pool Allocation), il convertit le modèle ONNX en moteur TensorRT (.trt). Processus de quantification INT8 : les poids et valeurs d'activation du modèle FP32 sont mappés de nombres flottants 32 bits vers des entiers 8 bits (256 niveaux de précision). Ce mappage nécessite 100 à 500 images d'étalonnage (Calibration Dataset), en utilisant la méthode d'étalonnage par entropie (Entropy Calibration) pour trouver le seuil de quantification à divergence KL minimale.

Commande spécifique : trtexec –onnx=resnet18_crane.onnx –saveEngine=resnet18_int8.trt –int8 –calib=calibration_data –fp16 –workspace=4096. Explication des paramètres clés : –int8 active la quantification INT8 ; –calib spécifie le répertoire des images d'étalonnage (500 images) ; –fp16 active le calcul intermédiaire FP16 (précision mixte avec les poids INT8) ; –workspace=4096 autorise 4 Go d'espace de travail (Jetson Orin NX 16GB peut allouer 8 Go). Temps de conversion : environ 11 minutes (GPU A10), taille du moteur INT8 : 6,2 MB (14 % de l'ONNX FP32).

Étape 3 : Validation de la précision

Après quantification INT8, il est impératif de vérifier que la perte de précision reste dans des limites acceptables. Le protocole de validation consiste à exécuter successivement PyTorch FP32 (référence) et TensorRT INT8 (modèle à valider) sur un jeu de 1 000 images de test, puis à comparer la précision Top-1, le score F1 et la matrice de confusion pour chaque classe. Dans cette expérience, les résultats INT8 vs FP32 sont les suivants : Top-1 passe de 94,0 % à 93,6 % (soit −0,4 %), et le score F1 de 0,93 à 0,92 (soit −0,01). La perte de précision au niveau des classes se concentre sur la catégorie « rupture de câble métallique » (le taux de faux négatifs passe de 2,3 % à 3,1 %, soit +0,8 %) ; pour les 4 autres classes, la perte reste inférieure à 0,3 %. Si la perte de précision INT8 dépasse 1 %, il est recommandé de basculer vers une quantification FP16 (volume de 12 Mo, perte de précision inférieure à 0,1 %) comme solution de compromis.

Étape 4 : Déploiement Jetson et chaîne de production

Le fichier Engine TensorRT est directement flashé sur la Jetson Orin NX (JetPack 6.0 avec TensorRT 8.6 préinstallé). Le code d'inférence utilise l'API TensorRT liée à Python (ou l'API C++ pour une latence encore plus faible). Pour une chaîne de production multi-modèles (par exemple, détection YOLO + classification ResNet) : utilisez CudaStream pour une inférence asynchrone, en chevauchant le post-traitement CPU (NMS) avec l'inférence GPU du modèle suivant. La latence de bout en bout de la chaîne représente environ 60 % de la somme des latences individuelles (dans cette expérience : YOLOv8s 3,8 ms + ResNet18 1,2 ms ≈ 5 ms de bout en bout).

import tensorrt as trt, pycuda.driver as cuda # ChargementINT8 engine with open("resnet18_int8.trt", "rb") as f, trt.Runtime(trt.Logger()) as r: engine = r.deserialize_cuda_engine(f.read()) ctx = engine.create_execution_context() # AllocationGPUMémoire d_input = cuda.mem_alloc(1*3*224*224*4) # FP32Entrée(Utilisation réelleINT8Prétraitement) d_output = cuda.mem_alloc(1*6*4) stream = cuda.Stream() # Boucle d for img in camera_stream(): cuda.memcpy_htod_async(d_input, preprocess(img), stream) ctx.execute_async_v2([int(d_input), int(d_output)], stream.handle) cuda.memcpy_dtoh_async(output, d_output, stream) stream.synchronize() result = postprocess(output) # Catégorie+Confiance push_to_hmi(result) # Envoi au pont roulantHMIAffichage

Cas de déploiement réel

Dans le cadre d'un projet de détection visuelle par IA des câbles métalliques sur 17 ponts roulants d'une aciérie (référence projet KL-EDGE-2024-003), chaque pont roulant est équipé d'une Jetson Orin NX (environ 448 €/unité). Chaque pont roulant est doté de 2 caméras industrielles (Basler acA2440-75um, capturant des images sur toute la longueur du câble métallique). La Jetson exécute la chaîne YOLOv8s+ResNet18 (détection de la position des ruptures + classification du niveau de gravité). La latence d'inférence de bout en bout est de 5,0 ms (chaîne à deux modèles), avec un traitement quotidien d'environ 14 400 images (2 caméras × 1 image toutes les 5 secondes × 10 heures). Après 14 mois de fonctionnement continu (janvier 2025 à février 2026) : le système a détecté 328 événements de rupture de câble, dont 307 confirmés par vérification manuelle (taux de précision de 93,6 %), et 8 cas de non-détection (taux de rappel de 97,5 %). Par rapport à l'inspection visuelle manuelle quotidienne (1 inspection visuelle par pont roulant et par jour, avec un taux de détection des ruptures d'environ 40 %), le taux de détection de l'inspection automatique par IA est multiplié par 2,3.

Comparatif des solutions de déploiement : serveur GPU vs inférence en périphérie

Le choix de la solution de déploiement dépend des contraintes du site d'exploitation. Voici un comparatif des avantages et inconvénients de quatre approches :

Questions fréquentes sur l'optimisation TensorRT et le déploiement Jetson