Qu'est-ce que l'edge AI ? Des modèles près des capteurs

Qu'est-ce que l'edge AI ? C'est la pratique qui consiste à exécuter l'inférence de machine learning sur l'appareil qui collecte les données, ou sur une passerelle juste à côté, au lieu d'envoyer chaque mesure vers un data center. À la fin de cet article, vous saurez comment fonctionne l'inférence en périphérie, quel matériel convient à quelle tâche et comment concevoir les messages qu'un appareil edge envoie, pour que le reste de votre système reçoive des réponses plutôt que des données brutes.

L'edge AI en un paragraphe

Un modèle entraîné est une fonction : des données entrent, une prédiction sort. Entraîner cette fonction exige de grands jeux de données et beaucoup de puissance de calcul ; cela se fait donc généralement dans le cloud ou sur une station de travail. L'exécuter, ce qu'on appelle l'inférence, coûte bien moins cher. L'edge AI prend le modèle entraîné, le réduit et l'optimise, puis exécute l'inférence là où naissent les données : une caméra, un capteur de vibrations, un microphone, une passerelle d'automate. L'appareil communique ensuite sa conclusion, par exemple « personne au portail », « défaut de roulement probable » ou « pièce défectueuse », via un protocole léger comme MQTT.

Comment fonctionne l'inférence en périphérie

Le cycle de vie est le même, que la cible soit un microcontrôleur ou un module GPU :

Collecter et étiqueter des données issues des vrais capteurs dans l'environnement réel.
Entraîner un modèle avec un framework comme TensorFlow, PyTorch ou un outil comme Edge Impulse.
L'optimiser pour la cible. Les étapes typiques sont la quantification (stocker les poids en entiers 8 bits au lieu de flottants 32 bits), l'élagage et la compilation pour un accélérateur spécifique.
Le déployer sur l'appareil sous forme de fichier ou d'image firmware.
Exécuter l'inférence en boucle : lire le capteur, prétraiter (redimensionner une image, calculer une FFT), exécuter le modèle, post-traiter (appliquer des seuils, lisser dans le temps).
Publier le résultat et envoyer de temps en temps des échantillons pour le réentraînement.
Mettre à jour le modèle lorsque la précision dérive, via un déploiement contrôlé.

L'étape 6 est celle où l'edge AI rencontre l'IoT. Au lieu de diffuser un flux vidéo ou des milliers d'échantillons d'accéléromètre par seconde, l'appareil publie quelques centaines d'octets décrivant ce qui s'est passé.

Pourquoi exécuter l'IA en périphérie

Raison	Ce que cela signifie en pratique
Latence	Une décision est prise en quelques millisecondes sans aller-retour réseau ; indispensable pour les éjections, les arrêts de sécurité et la robotique
Bande passante	La vidéo et les données de vibration à haute fréquence restent locales ; seuls les résultats transitent sur le réseau
Confidentialité	Les images et l'audio ne quittent jamais les locaux ; seuls les labels et les comptages en sortent
Résilience	La détection continue de fonctionner quand la liaison Internet tombe
Coût	Moins de transfert de données et de calcul cloud pour les charges continues

Il y a des compromis. Les appareils edge disposent de peu de mémoire et de puissance de calcul : les modèles doivent donc être petits. Mettre à jour des centaines d'appareils est plus difficile que de mettre à jour un seul service cloud. Et un modèle qui tourne sur le terrain est plus difficile à superviser qu'un modèle exécuté dans un data center. La comparaison edge AI vs IA cloud explique plus en détail quand chaque approche l'emporte et comment les architectures hybrides les combinent.

Les niveaux de matériel edge AI

L'edge AI couvre une large gamme d'appareils. Un modèle mental utile distingue quatre niveaux :

Microcontrôleurs (ESP32-S3, cartes Arm Cortex-M). Quelques kilo-octets de RAM, quelques milliwatts, des modèles pour la détection de mots-clés, la reconnaissance de gestes et la classification de vibrations. C'est le monde du TinyML ; voir ce qu'est le TinyML.
Ordinateurs monocartes (catégorie Raspberry Pi). Ils exécutent de petits modèles de vision et d'audio sur le CPU à des fréquences d'images modestes, et se programment facilement en Python.
Ordinateurs monocartes avec accélérateurs (Coral Edge TPU, modules Hailo). Un processeur neuronal dédié prend en charge le modèle, ce qui rend la détection d'objets en temps réel possible à faible consommation.
Modules GPU edge et PC industriels (NVIDIA Jetson, PC avec GPU). Plusieurs flux caméra, des modèles plus grands, la segmentation et l'estimation de pose.

Choisissez le niveau le plus bas qui satisfait vos exigences de précision et de latence : il est moins cher, consomme moins et comporte moins de pièces mobiles. La comparaison du matériel edge AI passe en revue des cartes précises.

Cas d'usage courants de l'edge AI

Vision : détection de personnes et de véhicules, surveillance de zones de sécurité, inspection de défauts, comptage et occupation.
Audio : détection de mots-clés, bruits anormaux de machines, détection de bris de vitre.
Vibrations et courant : usure des roulements, balourd et désalignement sur les moteurs et les pompes.
Environnement : occupation déduite des profils de CO2 et de température, détection de fuites.
Contrôle industriel : capteurs virtuels qui estiment une valeur coûteuse à mesurer directement.

Dans chaque cas, l'appareil transforme un signal dense en un événement rare et porteur de sens.

Publier des résultats d'inférence, pas des données brutes

La décision de conception la plus importante de l'edge AI pour l'IoT concerne ce qui circule sur le réseau. Un bon message d'inférence est petit, horodaté et autodescriptif :

{
  "ts": "2026-10-16T08:15:02Z",
  "device": "pump-07",
  "model": "vib-anomaly-v3",
  "label": "bearing_wear",
  "score": 0.87,
  "window_s": 2.0
}

Utilisez une hiérarchie de topics qui situe l'appareil dans son contexte, comme site/area/line/device/inference, et gardez les données brutes en local sauf si un abonné en a réellement besoin. ConnectMQ, par exemple, reconnaît les hiérarchies de topics de style ISA-95 et regroupe les appareils par site, zone et ligne dans sa vue des appareils, ce qui devient rentable dès que vous avez plus de quelques nœuds edge. Un broker MQTT cloud diffuse ensuite le résultat vers les tableaux de bord, les alertes, les historians et les modèles cloud, sans que l'appareil edge ait besoin de savoir qui écoute.

Exemple : un publieur d'inférence edge en Python

Le script ci-dessous illustre le principe sur n'importe quel appareil edge sous Linux. La fonction infer() est un espace réservé à remplacer par TensorFlow Lite, ONNX Runtime ou un runtime fournisseur. Il ne publie que lorsque le label change, ou toutes les 60 secondes en guise de heartbeat, ce qui limite le trafic.

pip install "paho-mqtt>=2.0" numpy

import json
import time
import uuid
from datetime import datetime, timezone

import numpy as np
import paho.mqtt.client as mqtt

RUN = uuid.uuid4().hex[:8]
TOPIC = f"connectmq/demo/{RUN}/site1/pumps/pump-07/inference"
MODEL = "vib-anomaly-v3"


def read_window():
    """Placeholder sensor read: 2 s of vibration at 1 kHz."""
    t = np.arange(2000) / 1000
    signal = np.sin(2 * np.pi * 50 * t) + 0.3 * np.random.randn(t.size)
    if np.random.rand() < 0.1:
        signal += 0.8 * np.sin(2 * np.pi * 180 * t)   # simulated fault harmonic
    return signal


def infer(window):
    """Placeholder model: energy in a fault band. Replace with a real runtime."""
    spectrum = np.abs(np.fft.rfft(window))
    band = spectrum[170 * 2:190 * 2].sum() / spectrum.sum()
    score = float(min(1.0, band * 8))
    return ("bearing_wear" if score > 0.5 else "normal"), score


client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=f"pump-07-{RUN}")
client.connect("broker.connectmq.com", 1883, keepalive=60)
client.loop_start()
print("publishing to", TOPIC)

last_label, last_sent = None, 0.0
while True:
    label, score = infer(read_window())
    now = time.time()
    if label != last_label or now - last_sent > 60:
        msg = {
            "ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
            "device": "pump-07",
            "model": MODEL,
            "label": label,
            "score": round(score, 3),
            "window_s": 2.0,
        }
        client.publish(TOPIC, json.dumps(msg), qos=1)
        print(msg)
        last_label, last_sent = label, now
    time.sleep(1)

Abonnez-vous depuis un autre terminal avec le topic affiché pour voir les événements :

mosquitto_sub -h broker.connectmq.com -p 1883 -i edge-viewer-5d1e -t 'connectmq/demo/<run-id>/#' -v

Le serveur MQTT public gratuit est idéal pour ce type de test, mais tout ce qui y est publié est visible par quiconque s'abonne au topic. Pour de vrais appareils, utilisez les identifiants de votre propre broker et TLS sur le port 8883.

Les pièges de l'edge AI à anticiper

Des données d'entraînement qui ne correspondent pas au terrain. Les données de laboratoire reflètent rarement l'éclairage, le bruit ou le montage réels. Collectez tôt depuis des capteurs déployés.
Aucune version de modèle dans les messages. Sans elle, impossible de savoir quel modèle a produit une mauvaise alerte.
Une dérive silencieuse. Publiez les scores de confiance et des statistiques périodiques pour voir quand le modèle devient incertain.
Une publication excessive. Envoyer chaque inférence à pleine cadence annule l'avantage en bande passante. Publiez sur changement, sur seuil ou avec un heartbeat lent.
Aucun chemin de mise à jour. Prévoyez comment un nouveau modèle atteindra les appareils avant le premier déploiement ; le déploiement de modèles ML sur des appareils edge présente les options.

Pour une vue plus large de la place des modèles edge aux côtés de l'analytique cloud et des agents LLM, lisez le guide IA et IoT.

Démarrer avec ConnectMQ

Les appareils edge AI ont besoin d'un endroit fiable où envoyer leurs résultats. ConnectMQ est un broker MQTT managé prenant en charge MQTT 3.1.1 et 5.0 sur TCP, TLS et WebSockets, avec un explorateur de topics en direct pour voir arriver les événements d'inférence. Créez un broker avec l'offre gratuite Serverless sur app.connectmq.com, sans carte bancaire, et dirigez-y vos appareils edge.

Questions fréquentes

Qu'est-ce que l'edge AI en termes simples ?

L'edge AI signifie qu'un appareil exécute lui-même un modèle de machine learning entraîné, près de ses capteurs, au lieu d'envoyer les données à un serveur distant pour analyse. Il communique ensuite le résultat.

L'edge AI, est-ce la même chose que le TinyML ?

Le TinyML est un sous-ensemble de l'edge AI centré sur les microcontrôleurs disposant de très peu de mémoire et d'énergie. L'edge AI inclut aussi des appareils plus grands comme les cartes Raspberry Pi, les accélérateurs et les modules GPU.

L'edge AI a-t-elle encore besoin du cloud ?

En général oui, mais pour d'autres tâches : l'entraînement, la supervision du parc, le stockage à long terme et la combinaison des résultats de nombreux sites. La périphérie gère l'inférence en temps réel et le cloud tout ce qui bénéficie d'une vue globale.

Pourquoi utiliser MQTT pour les résultats edge AI ?

Les résultats d'inférence sont de petits messages événementiels que de nombreux systèmes veulent consommer. Le modèle publish/subscribe de MQTT, ses niveaux de QoS et sa faible surcharge correspondent bien à ce schéma.

Qu'est-ce que l'edge AI ? Exécuter les modèles au plus près des capteurs