Les modèles d’apprentissage profond (CNN/GNN) atteignent une précision F1>0,97 dans le diagnostic des défauts de ponts roulants, mais la plupart des utilisateurs industriels n’acceptent pas une décision en « boîte noire » du type « le modèle signale un défaut, c’est tout ». Sur le plan de la conformité, la norme ISO 23894 (équivalente à la GB/T 41867-2022 sur l’IA explicable) exige que les systèmes d’IA à haut risque fournissent une explication de leurs décisions. Sur le plan pratique, les opérateurs ont besoin de savoir pourquoi l’IA diagnostique un défaut de roulement — est-ce la fréquence de vibration ou la forme du courant qui a changé ? — pour faire confiance au système et exécuter les instructions de maintenance.

Cet article s’appuie sur le système de diagnostic IA déployé par Kelude sur 12 ponts roulants. Il présente de manière complète les principes, l’implémentation en Python et l’intégration dans un environnement de pont roulant de deux méthodes d’explicabilité majeures : Grad-CAM (Gradient-weighted Class Activation Mapping) et SHAP (SHapley Additive exPlanations). Les deux méthodes ont des rôles distincts : Grad-CAM répond à la question « où le modèle a-t-il regardé ? » (localisation spatiale), tandis que SHAP répond à « quelles caractéristiques sont les plus importantes ? » (attribution des caractéristiques). Ensemble, elles couvrent les deux exigences clés de l’explicabilité : la compréhensibilité fonctionnelle et la traçabilité des caractéristiques.

Principe de Grad-CAM : de la rétropropagation du gradient à la visualisation par carte de chaleur

Principe mathématique : Grad-CAM (Selvaraju et al., 2017) utilise les gradients de la dernière couche convolutive d’un CNN pour calculer un poids d’importance pour chaque canal de caractéristiques, puis génère une carte d’activation de classe par somme pondérée. Pour le diagnostic de défauts de pont roulant, supposons que la dernière couche convolutive produise une carte de caractéristiques A⁽ˡ⁾∈ℝ^C×H×W (C=512 canaux, résolution spatiale H=8, W=8). Pour une classe cible c (par exemple, le défaut de roulement F1), on calcule d’abord la moyenne des gradients du score yᶜ de la classe c par rapport à toutes les positions spatiales de la k-ième carte de caractéristiques : αₖᶜ = (1/Z)·∑ᵢ∑ⱼ ∂yᶜ/∂Aⁱʲₖ. Ensuite, on effectue une somme pondérée linéaire des cartes de caractéristiques en utilisant αₖᶜ comme poids : L_Grad-CAM = ReLU(∑ₖ αₖᶜ·Aₖ). La fonction ReLU finale garantit que seules les régions positivement corrélées sont conservées (« le modèle a regardé ici pour établir son diagnostic »), tandis que les régions négativement corrélées sont supprimées.

Interprétation dans le diagnostic vibratoire d’un pont roulant : Considérons une entrée composée de 12 capteurs × 256 points de FFT (concaténés en une entrée 2D de 12×128). Après 3 couches de convolution et de pooling, la dernière carte de caractéristiques a une taille de 8×8 (chaque position spatiale correspondant à une plage de fréquences). Les zones rouges sur la carte de chaleur Grad-CAM correspondent aux plages de fréquences et aux positions de capteurs jugées les plus importantes par le modèle de diagnostic. Lors des tests, pour le diagnostic du défaut de roulement F1, le pic de la carte de chaleur Grad-CAM se concentre sur la bande de fréquence 1,2~2,4 kHz du capteur de vibrations V3 du logement de roulement de tambour — précisément la plage de fréquences correspondant à la fréquence fondamentale de défaut de la bague extérieure du roulement, soit 2 180 Hz, ce qui est en parfait accord avec la théorie du contact élastique de Hertz.

Code d’implémentation PyTorch :

 import torch import torch.nn.functional as F import matplotlib.pyplot as plt import numpy as np class GradCAM: """Grad-CAMGénérateur de carte de chaleur——Adaptation au pont roulantCNNModule de diagnostic type""" def __init__(self, model, target_layer): self.model = model self.target_layer = target_layer self.gradients = None self.activations = None # Enregistrement des hooks forward et backward target_layer.register_forward_hook(self._forward_hook) target_layer.register_full_backward_hook(self._backward_hook) def _forward_hook(self, module, input, output): self.activations = output.detach() # [B, C, H, W] def _backward_hook(self, module, grad_input, grad_output): self.gradients = grad_output[0].detach() # [B, C, H, W] def generate(self, x, class_idx=None): """Génération de carte de chaleur""" # propagation avant logits = self.model(x.unsqueeze(0)) if class_idx is None: class_idx = logits.argmax(dim=1).item() # rétropropagation（Score de la classe cible） self.model.zero_grad() logits[0, class_idx].backward() # Calcul des poids de gradient αₖᶜ = global_average_pooling(∂y/∂Aₖ) weights = self.gradients.mean(dim=(2, 3), keepdim=True) # [1, C, 1, 1] # Somme pondérée: Σ αₖ·Aₖ cam = (weights * self.activations).sum(dim=1, keepdim=True) # [1, 1, H, W] cam = F.relu(cam) # Conservation des corrélations positives uniquement # Suréchantillonnage à la taille d cam = F.interpolate(cam, size=(128, 128), mode='bilinear', align_corners=False) cam = cam.squeeze().cpu().numpy() # Normalisation à[0,1] cam = (cam - cam.min()) / (cam.max() - cam.min() + 1e-8) return cam, class_idx # Exemple d # model = torch.load('crane_cnn_fault.pt') # Pont roulant pré-entraînéCNNModule de diagnostic type # target_conv = model.features[-1] # Dernière couche convolutive # grad_cam = GradCAM(model, target_conv) # heatmap, pred_class = grad_cam.generate(sample_spectrogram, class_idx=1) # plt.imshow(heatmap, cmap='jet', alpha=0.5) # Superposition sur le spectrogramme # plt.title(f'Grad-CAM: Classe prédite={pred_class} (défaut de roulementF1)') 

Explication du code : la classe GradCAM utilise register_forward_hook et register_full_backward_hook de PyTorch pour capturer automatiquement les activations et les gradients de la couche convolutive cible. Le calcul principal est effectué dans la méthode generate : ① propagation avant pour obtenir les logits ; ② rétropropagation de la classe cible pour obtenir les gradients ; ③ pooling global moyen des gradients pour obtenir les poids de canal αₖᶜ ; ④ somme pondérée + ReLU + suréchantillonnage. La carte de chaleur finale est superposée au spectrogramme d’entrée ; les zones rouges indiquent les bandes de fréquences sur lesquelles le modèle s’est basé pour son diagnostic.

Principe de SHAP : comment les valeurs de Shapley répartissent quantitativement la contribution des caractéristiques

Principe mathématique : SHAP (Lundberg & Lee, 2017) est basé sur la valeur de Shapley issue de la théorie des jeux. Chaque caractéristique est considérée comme un « joueur » dans un jeu coopératif, et la prédiction du modèle comme le « gain total ». La valeur de Shapley φᵢ pour la i-ième caractéristique est définie comme la moyenne pondérée des contributions marginales de l’ajout de la caractéristique i à toutes les sous-ensembles de caractéristiques S⊆F{i} : φᵢ = Σ_{S⊆F{i}} (|S|!(|F|-|S|-1)!/|F|!) · [fₓ(S∪{i}) – fₓ(S)]. Ici, fₓ(S) est la sortie du modèle utilisant uniquement le sous-ensemble de caractéristiques S (les caractéristiques manquantes sont remplacées par des valeurs de référence), et le poids combinatoire reflète la probabilité d’apparition du sous-ensemble S. L’avantage clé de SHAP est de satisfaire trois axiomes idéaux : la précision locale (la somme des explications est égale à la prédiction totale), la nullité (une caractéristique absente a une contribution de 0) et la cohérence (si le modèle change pour rendre une caractéristique plus importante, sa valeur SHAP ne diminue pas).

Application au contexte du pont roulant : Pour une entrée de 120 dimensions (12 capteurs × 10 caractéristiques), calculer les contributions marginales pour les 2¹²⁰ sous-ensembles de caractéristiques est irréaliste. En pratique, on utilise TreeSHAP (spécifique aux modèles à base d’arbres, complexité O(TLD²)) ou KernelSHAP (indépendant du modèle, approximation par échantillonnage). Kelude utilise KernelSHAP avec une stratégie de regroupement des caractéristiques : les 10 caractéristiques sont d’abord regroupées en 12 groupes par capteur (la valeur SHAP de chaque groupe étant la somme des 10 dimensions internes), puis une analyse fine est effectuée en calculant les valeurs SHAP de chaque dimension au sein du groupe. Cela réduit l’espace des caractéristiques de 120 dimensions à 12 groupes, diminuant ainsi la complexité d’échantillonnage d’un facteur 12. Avec 128 échantillons de référence et 256 échantillonnages, le temps de calcul SHAP pour un échantillon est d’environ 1,8 seconde (CPU, Intel i7-12700), ce qui répond aux besoins de génération de rapports de diagnostic hors ligne.

Code d’implémentation Python :

 import shap import numpy as np import torch class SHAPExplainer: """SHAPInterpréteur d——Spécialisé pour le diagnostic de pannes de pont roulant""" def __init__(self, model, background_size=128, n_samples=256): self.model = model self.background_size = background_size self.n_samples = n_samples self.feature_names = [ # 12capteurs × 10caractéristiques dimensionnelles f'{sensor}_{feat}' for sensor in ['V1','V2','V3','V4','T1','T2','T3','C1','C2','C3','Q1','Q2'] for feat in ['RMS','Valeur de crête','Kurtosis','Asymétrie (Skewness)','Facteur de forme','Facteur d', 'Facteur de marge','Centre de gravité fréquentiel','Rapport d_0_500','Rapport d_500_2k'] ] def _predict_proba(self, X): """PyTorchModule de diagnostic typeConditionné enshapFormat appelable""" self.model.eval() with torch.no_grad(): X_tensor = torch.from_numpy(X).float() outputs = torch.softmax(self.model(X_tensor), dim=1).numpy() return outputs def explain(self, sample, background_data, class_names=None): """Génération pour un échantillon uniqueSHAPExplication""" # Sélection aléatoire d bg_idx = np.random.choice(len(background_data), self.background_size, replace=False) background = background_data[bg_idx] # KernelSHAPInterpréteur d explainer = shap.KernelExplainer(self._predict_proba, background) # CalculSHAPValeur de crête（Index de classe de panne spécifié） shap_values = explainer.shap_values( sample.reshape(1, -1), nsamples=self.n_samples ) return shap_values # list of [n_classes, n_features] arrays # Exemple d # model = torch.load('crane_cnn_fault.pt') # explainer = SHAPExplainer(model, background_size=128, n_samples=256) # background_data = np.load('crane_background_samples.npy') # [5000, 120] # sample = background_data[0] # Échantillon à expliquer # shap_vals = explainer.explain(sample, background_data) # Agrégation groupée par capteurSHAPValeur de crête # sensor_groups = {s: sum(shap_vals[c][:, i*10:(i+1)*10]) for i, s in # enumerate(['V1','V2','V3','V4','T1','T2','T3','C1','C2','C3','Q1','Q2'])} # shap.summary_plot(shap_vals[1], sample.reshape(1,-1), # feature_names=explainer.feature_names) 

Explication du code : la classe SHAPExplainer encapsule la logique d’appel de shap.KernelExplainer. Le paramètre clé background_size contrôle la taille de l’ensemble de données de référence (affectant la précision de l’estimation de base), et n_samples contrôle le nombre d’échantillonnages (affectant le temps de calcul et la stabilité). Il est recommandé de collecter au moins 5 000 échantillons dans des conditions de fonctionnement normales pour l’ensemble de référence. Lors de l’agrégation par groupe, le capteur V1 (RMS d’accélération et crête) présente la valeur SHAP moyenne la plus élevée dans le diagnostic des défauts de roulement, tandis que T2 (température de surface du frein) a la contribution la plus faible dans des conditions normales, ce qui indique que le modèle a correctement appris les corrélations physiques.

La norme GB/T 41867-2022 définit quatre niveaux d'interprétabilité, de L1 à L4. Grad-CAM satisfait au niveau L1 (niveau fonctionnel, expliquant les régions d'intérêt du modèle), tandis que SHAP atteint le niveau L3 (niveau des caractéristiques, expliquant la contribution des variables). Leur combinaison couvre les niveaux L1+L3, ne laissant manquer que le niveau L2 (niveau structurel, explication de l'activation neuronale) et le niveau L4 (niveau conceptuel, explication sémantique des concepts).

Architecture système hybride Grad-CAM + SHAP pour le diagnostic industriel

Stratégie d'intégration : La conception centrale du système hybride repose sur un processus en deux étapes : « localisation par Grad-CAM, puis attribution par SHAP ». Première étape : lors de l'inférence du modèle de diagnostic CNN, celui-ci émet la catégorie de défaut tandis que Grad-CAM génère automatiquement une carte de chaleur superposée au spectrogramme d'entrée, surlignant en rouge les bandes de fréquence surveillées par le modèle sur l'interface de diagnostic. Deuxième étape : si l'utilisateur souhaite une explication plus fine au niveau des caractéristiques, une analyse SHAP (en ligne ou asynchrone) peut être déclenchée en un clic, produisant un diagramme à barres du classement des contributions des caractéristiques. Cette séparation en deux phases évite que les calculs SHAP fréquents (environ 1,8 s par exécution) n'impactent le flux de diagnostic en temps réel (qui exige moins de 50 ms).

Architecture système : Les données capteur en temps réel transitent par la boîte d'informatique en périphérie (Jetson Orin NX) → inférence CNN (6,2 ms) → génération de la carte de chaleur Grad-CAM (+0,3 ms, sans coût supplémentaire) → affichage en temps réel sur l'interface IHM. Lorsque l'utilisateur clique sur « Explication approfondie », une requête MQTT est envoyée au serveur d'usine → calcul KernelSHAP (1,8 s) → le graphique d'attribution SHAP est renvoyé à l'IHM. Grad-CAM reste actif en permanence, tandis que SHAP est déclenché à la demande. Le coût de calcul extrêmement faible de Grad-CAM (une seule rétropropagation, latence négligeable) lui permet de s'intégrer naturellement dans le pipeline d'inférence en temps réel, alors que le coût de calcul de SHAP le destine davantage à une analyse asynchrone.

Indicateurs de performance clés :

Résultats intégrés : sur 12 ponts roulants suivis pendant 16 mois, le taux d'adoption des diagnostics IA par les opérateurs est passé de 62 % (affichage initial des seules étiquettes de classe et du niveau de confiance) à 81 % (après ajout des cartes de chaleur Grad-CAM), puis à 94 % (après ajout de l'attribution SHAP). Ces données démontrent que le positionnement spatial et l'attribution des caractéristiques ont un effet cumulatif sur l'établissement de la confiance des utilisateurs.

Étude de cas concrets en diagnostic de pannes de pont roulant

Cas 1 : Écaillage par fatigue de la bague extérieure d'un roulement (pont roulant QD32/5t d'une aciérie, août 2025)

Sortie du modèle CNN : classe de défaut F1 (défaut de roulement), niveau de confiance 0,963. Carte de chaleur Grad-CAM : les zones rouges à forte contribution sont concentrées sur les lignes 3 à 5 du spectrogramme d'entrée (correspondant aux signaux des capteurs de vibrations V2 et V3) et les colonnes 32 à 64 (correspondant à la bande de fréquence 1,2 à 2,4 kHz). Attribution SHAP : V2_kurtosis = +0,21 (le plus élevé), V1_RMS = +0,19, V3_ratio_énergie_500_2k = +0,15, T1_moyenne = +0,08. Interprétation combinée : « L'augmentation anormale du kurtosis du capteur de vibrations V2 du palier (+0,21) et l'élévation de la valeur RMS de V1 (+0,19), associées à l'accroissement de l'énergie dans la bande 1,2 à 2,4 kHz du capteur V3 du logement de roulement de tambour (+0,15), conduisent au diagnostic d'écaillage par fatigue de la bague extérieure du roulement. Arrêt et remplacement recommandés sous 48 heures. » L'inspection par ouverture a confirmé : surface d'écaillage par fatigue de contact sur la piste de roulement de la bague extérieure d'environ 15 mm², en parfaite conformité avec le diagnostic.

Cas 2 : Usure d'engrenage (pont roulant LD16/3,2t d'une aciérie, janvier 2026)

Sortie du modèle CNN : classe de défaut F2 (usure d'engrenage), niveau de confiance 0,941. Carte de chaleur Grad-CAM : les zones rouges se concentrent sur le capteur V2 (palier d'entrée du réducteur) sur toute la bande de fréquence, avec un pic dans la bande 0,5 à 1,0 kHz (fréquence d'engrènement et ses bandes latérales). Attribution SHAP : V2_ratio_énergie_0_500 = +0,24, V2_crête = +0,18, C2_fondamental = +0,11, Q1_moyenne = +0,07. Le schéma de combinaison des caractéristiques diffère nettement du cas 1 — dans le cas 1, la caractéristique à forte contribution était V2_kurtosis +0,21 (indicateur typique de défaut de roulement : le kurtosis est sensible aux chocs), tandis que dans le cas 2, la caractéristique dominante est V2_ratio_énergie_0_500 +0,24 (indicateur typique d'usure d'engrenage : élévation de l'énergie des bandes latérales de la fréquence d'engrènement). Ce schéma d'attribution différencié entre les deux types de défauts dans l'espace des caractéristiques valide la capacité de discrimination de l'explication au niveau des caractéristiques par SHAP.

Données de fiabilité : sur 12 ponts roulants suivis pendant 16 mois, la double méthode Grad-CAM + SHAP a généré 784 rapports de diagnostic. Après vérification manuelle (ouverture, démontage, inspection par endoscope), 752 diagnostics ont été confirmés corrects, soit un taux de précision de 95,9 %. Le taux de concordance entre l'attribution SHAP et le jugement d'experts atteint 92,3 % (155 avis favorables sur 168 évaluations indépendantes concernant le classement d'importance des caractéristiques fourni par SHAP).

Conformité et valeur de confiance de l'IA explicable en environnement industriel

Exigences de conformité : la norme ISO/IEC 22989 (exigences d'explicabilité pour les systèmes d'IA) définit quatre niveaux d'explicabilité (du niveau L1 fonctionnel au niveau L4 conceptuel), et la norme ISO/IEC 23053 (cadre d'évaluation des algorithmes d'apprentissage profond) impose une évaluation de l'explicabilité pour les systèmes d'IA à haut risque. Le diagnostic de pannes de pont roulant affecte directement la sécurité des équipements et du personnel ; il s'agit donc d'un système d'IA à haut risque devant satisfaire au minimum aux exigences d'explicabilité des niveaux L1 et L3. Grad-CAM satisfait au niveau L1 (la carte de chaleur décrit l'attention fonctionnelle du modèle), SHAP satisfait au niveau L3 (attribution quantitative des contributions des caractéristiques). L'intégration des deux méthodes a passé avec succès l'examen de conformité interne de Kelude.

Établissement de la confiance : la confiance des opérateurs dans les diagnostics IA ne s'établit pas en une seule fois, mais se construit progressivement à travers chaque rapport de diagnostic. En passant de « vous indiquer uniquement la classe de défaut » à « vous montrer ce qui a été examiné », puis à « vous expliquer pourquoi cette analyse a été faite », la transparence de l'information s'accroît par paliers et la confiance se développe naturellement. Les données de suivi sur 12 ponts roulants pendant 16 mois montrent que : les cartes de chaleur Grad-CAM ont fait passer la tolérance aux fausses alarmes de 1 fois/semaine à 3 fois/semaine (les opérateurs acceptent davantage de « fausses alertes » car ils peuvent visualiser le raisonnement du modèle), et l'attribution SHAP a réduit de 38 % à 9 % la proportion de « refus des conclusions IA et remontée forcée pour inspection ».

Valeur économique : chaque inspection par ouverture inutile évitée représente une économie d'environ 12 000 ¥ (main-d'œuvre + arrêt + pièce de rechange). Sur 16 mois, 47 inspections par ouverture non nécessaires ont été évitées grâce à la confiance des opérateurs dans les diagnostics IA, soit une économie totale d'environ 560 000 ¥. Par ailleurs, l'attribution SHAP ayant révélé des caractéristiques de défaut à un stade précoce (comme dans le cas 1 avec une alerte de défaut de roulement 72 heures à l'avance), un incident de grippage de l'arbre principal a été évité (perte directe estimée à 180 000 ¥ + perte de production de 450 000 ¥/jour × 3 jours = 1 530 000 ¥).

Pour d'autres combinaisons d'explicabilité des modèles et de déploiement en périphérie, consultez les ressources de Kelude sur le diagnostic de pannes multi-capteurs par GNN et les pratiques de déploiement en périphérie avec PyTorch et ONNX TensorRT.

Questions fréquentes sur l'IA explicable pour le diagnostic de ponts roulants

Grad-CAM et SHAP résolvent le problème de la « boîte noire » du diagnostic de panne par IA des ponts roulants sous deux angles : le positionnement spatial et l'attribution des caractéristiques. L'opérateur ne se contente plus d'un simple verdict binaire « panne / normal », mais visualise la chaîne de preuves complète du raisonnement du modèle. Sur 12 ponts roulants suivis pendant 16 mois, 784 rapports de diagnostic, un taux de précision de 95,9 % et un taux d'adoption de 94 % par les opérateurs démontrent que l'explicabilité n'est pas seulement une exigence de conformité, mais bien la clé de l'acceptation et de la valeur réelle des systèmes d'IA dans les environnements industriels. Kelude poursuit le développement de la double approche Grad-CAM + SHAP vers une explication structurelle de niveau L2 (actuellement en recherche : suivi des chemins d'activation neuronale) et une explication conceptuelle de niveau L4 (vecteurs d'activation conceptuels, CAV).