Maintenance Prédictive IA pour PME : YOLO et Capteurs IoT

Une panne machine imprévue coûte en moyenne 8 000 à 15 000 € par heure dans l’industrie manufacturière, selon une étude du cabinet Aberdeen Group. Pourtant, 70 % des défaillances présentent des signes précurseurs détectables plusieurs heures, voire plusieurs jours à l’avance. L’IA et l’IoT transforment aujourd’hui la maintenance réactive en maintenance prédictive — et cette révolution est désormais accessible aux PME.

Des Trois Types de Maintenance, Lequel Choisit Votre PME ?

Avant d’aborder les solutions techniques, posons le cadre :

La maintenance prédictive réduit les coûts de maintenance de 25 à 40 % et les pannes imprévues de 70 à 75 % (McKinsey, 2023). Pour une PME industrielle avec 5 à 10 machines critiques, le ROI s’atteint généralement en 12 à 18 mois.

Axe 1 : Inspection Visuelle avec YOLO

Pourquoi la Vision par Ordinateur pour la Maintenance ?

L’œil humain est fatigable, subjectif et limité à une fréquence d’inspection raisonnable. Une caméra couplée à un modèle YOLO inspecte en continu, 24h/24, avec une précision constante.

Détecter l’Usure et les Fissures sur Courroies et Roulements

YOLOv8, la version actuelle de référence, permet de détecter des défauts visuels avec une précision supérieure à 95 % sur des jeux de données bien construits.

from ultralytics import YOLO
import cv2

# Charger le modèle pré-entraîné et fine-tuné sur vos données
model = YOLO("yolov8s_defauts_courroie.pt")

# Capture depuis une caméra IP industrielle
cap = cv2.VideoCapture("rtsp://192.168.1.50/stream1")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame, conf=0.7)  # Seuil de confiance 70%

    for r in results:
        for box in r.boxes:
            cls = int(box.cls[0])
            conf = float(box.conf[0])
            label = model.names[cls]

            if label in ["fissure", "usure_avancee", "deformation"]:
                # Alerte critique
                envoyer_alerte(label, conf, timestamp=r.timestamp)
                print(f"ALERTE : {label} détecté avec {conf:.1%} de confiance")

Construire votre Dataset d’Anomalies

Le défi principal n’est pas le modèle, c’est les données. Voici une approche pragmatique pour une PME :

1. Phase de collecte (4-6 semaines) : installer des caméras sur les équipements et collecter des images normales (environ 1 000 images)
2. Images d’anomalies : récupérer des photos d’archives des pannes passées, demander aux techniciens de photographier les défauts lors des interventions
3. Annotation : utiliser LabelImg ou Roboflow (version gratuite suffisante pour débuter) pour annoter les boîtes de détection
4. Augmentation : rotations, variations de luminosité, flou — Albumentations permet de multiplier par 5 un dataset limité

import albumentations as A

transform = A.Compose([
    A.RandomRotate90(p=0.5),
    A.RandomBrightnessContrast(brightness_limit=0.3, p=0.7),
    A.GaussianBlur(blur_limit=(3, 7), p=0.3),
    A.HorizontalFlip(p=0.5),
    A.CLAHE(p=0.4),  # Améliore le contraste local
], bbox_params=A.BboxParams(format="yolo", label_fields=["category_ids"]))

Applications Concrètes

• Courroies de transmission : détection de fissures, effilochages, désalignement
• Roulements : pitting (micro-écaillage), usure de cage
• Soudures : porosités, manques de fusion sur pièces critiques
• Joints d’étanchéité : fuites, déformation

Axe 2 : Analyse de Capteurs IoT

Les Capteurs Clés pour la Maintenance Industrielle

L’analyse vibratoire est le signal le plus riche pour détecter les défauts mécaniques naissants :

Architecture IoT Typique

Capteurs → ESP32/Arduino → MQTT Broker → InfluxDB → Modèle IA → Alertes

# Acquisition vibratoire sur ESP32 (MicroPython)
import machine, time
import network, umqtt.simple as mqtt
import ujson

# Capteur ADXL345 sur I2C
i2c = machine.I2C(0, sda=machine.Pin(21), scl=machine.Pin(22))
ADXL345_ADDR = 0x53

def lire_acceleration():
    data = i2c.readfrom_mem(ADXL345_ADDR, 0x32, 6)
    x = (data[1] << 8 | data[0]) / 256.0  # g
    y = (data[3] << 8 | data[2]) / 256.0
    z = (data[5] << 8 | data[4]) / 256.0
    return x, y, z

# Collecte 512 échantillons à 1600 Hz
echantillons = []
for _ in range(512):
    echantillons.append(lire_acceleration())
    time.sleep_us(625)  # 1 600 Hz

# Envoi via MQTT
client = mqtt.MQTTClient("machine_A3", "192.168.1.100")
client.connect()
payload = ujson.dumps({
    "machine_id": "A3",
    "timestamp": time.time(),
    "samples": echantillons
})
client.publish(b"vibrations/brutes", payload)

Modèle de Détection d’Anomalies Vibratoires

L’approche la plus efficace pour les PME sans données de pannes étiquetées : l’autoencoder non supervisé. Il apprend le comportement normal de la machine et signale tout écart significatif.

import numpy as np
from sklearn.preprocessing import StandardScaler
from tensorflow import keras

# Extraire les features fréquentielles (FFT)
def extraire_features(signal, fe=1600):
    fft = np.abs(np.fft.rfft(signal))
    freqs = np.fft.rfftfreq(len(signal), 1/fe)

    # Features clés : amplitude RMS, fréquences dominantes, crête
    rms = np.sqrt(np.mean(signal**2))
    crete = np.max(np.abs(signal))
    facteur_crete = crete / rms
    energie_basses = np.sum(fft[freqs < 100])
    energie_hautes = np.sum(fft[freqs > 500])

    return [rms, crete, facteur_crete, energie_basses, energie_hautes]

# Entraîner l'autoencoder sur les données normales (2-4 semaines de collecte)
scaler = StandardScaler()
X_normal = scaler.fit_transform([extraire_features(s) for s in signaux_normaux])

autoencoder = keras.Sequential([
    keras.layers.Dense(16, activation="relu", input_shape=(5,)),
    keras.layers.Dense(4, activation="relu"),  # Bottleneck
    keras.layers.Dense(16, activation="relu"),
    keras.layers.Dense(5, activation="linear")
])
autoencoder.compile(optimizer="adam", loss="mse")
autoencoder.fit(X_normal, X_normal, epochs=100, validation_split=0.2)

# Seuil d'anomalie = moyenne + 3 écarts-types des erreurs de reconstruction
erreurs = np.mean((autoencoder.predict(X_normal) - X_normal)**2, axis=1)
seuil = np.mean(erreurs) + 3 * np.std(erreurs)

def est_anomalie(nouveau_signal):
    features = scaler.transform([extraire_features(nouveau_signal)])
    erreur = np.mean((autoencoder.predict(features) - features)**2)
    return erreur > seuil, erreur

Intégration : Combiner Vision et Capteurs

La puissance maximale vient de la fusion multi-capteurs : un roulement dégradé se manifeste simultanément par des vibrations anormales (capteur) ET une légère décoloration thermique (caméra thermique).

class SystemeMaintenancePredictive:
    def __init__(self):
        self.modele_vision = YOLO("yolov8s_defauts.pt")
        self.detecteur_vibration = AutoencoderVibration()
        self.seuil_alerte = 0.7  # Score de risque (0-1)

    def evaluer_machine(self, frame_camera, signal_vibration):
        # Score vision
        resultats_vision = self.modele_vision(frame_camera)
        score_vision = max([box.conf for r in resultats_vision for box in r.boxes], default=0)

        # Score vibration
        est_anomalie, erreur_reconstruction = self.detecteur_vibration.predire(signal_vibration)
        score_vibration = min(erreur_reconstruction / self.seuil_vibration, 1.0)

        # Fusion des scores
        score_global = 0.6 * score_vision + 0.4 * score_vibration

        if score_global > self.seuil_alerte:
            return {
                "statut": "INTERVENTION_REQUISE",
                "score": score_global,
                "details": {
                    "vision": score_vision,
                    "vibration": score_vibration
                }
            }
        return {"statut": "NORMAL", "score": score_global}

Comparaison des Coûts : Préventive vs Prédictive

Prenons l’exemple d’une PME avec 8 machines critiques :

Déployer en 3 Phases

Phase 1 — Pilote (3 mois) : instrumenter 1 ou 2 machines les plus critiques, collecter les données, valider les alertes avec les techniciens.

Phase 2 — Modèles (2-3 mois) : entraîner les modèles de détection d’anomalies sur les données collectées, ajuster les seuils d’alerte.

Phase 3 — Généralisation (6 mois) : déployer sur l’ensemble du parc machine, connecter au GMAO (Gestion de Maintenance Assistée par Ordinateur), former les équipes.

Conclusion

La maintenance prédictive par IA n’est plus un luxe réservé aux grandes entreprises. Avec des capteurs à moins de 100 € et des modèles open-source comme YOLOv8, une PME peut anticiper ses pannes et réduire drastiquement ses coûts d’exploitation en 12 à 18 mois.

La clé : commencer petit sur les équipements les plus critiques, mesurer le ROI, puis étendre progressivement.

Votre PME fait face à des pannes récurrentes sur des équipements clés ? Contactez-nous à contact@brio-novia.eu pour une étude de faisabilité gratuite — nous identifions avec vous les signaux précurseurs exploitables sur votre parc machine.