Edge AI : Faire Tourner des Modèles IA sur Appareils Embarqués

Edge AI : Faire Tourner des Modèles IA sur Appareils Embarqués

Votre caméra de contrôle qualité envoie 30 images par seconde vers le cloud — combien coûte cette bande passante sur un an ? Selon une étude IDC de 2024, 68 % des entreprises industrielles constatent que la latence et le coût du cloud freinent leurs projets d’IA temps réel. L’Edge AI apporte une réponse concrète : exécuter les modèles directement sur l’appareil, là où les données sont produites.

Ce guide vous explique comment déployer des modèles d’intelligence artificielle sur des appareils embarqués, avec des exemples pratiques adaptés aux contraintes des PME françaises.

Pourquoi Exécuter l’IA en Local plutôt que dans le Cloud ?

Latence quasi nulle

Un appel vers une API cloud prend entre 50 et 500 ms selon la connexion. Pour détecter un défaut sur une ligne de production cadencée à 1 200 pièces/heure, c’est rédhibitoire. Un modèle embarqué répond en 10 à 30 ms — assez pour déclencher une alarme ou stopper un convoyeur en temps réel.

Confidentialité des données

Les images de votre atelier, les plans de production, les données biométriques de vos employés — tout cela peut rester sur site. La réglementation RGPD s’en trouve considérablement simplifiée : pas de transfert vers des serveurs tiers, pas de sous-traitance à déclarer pour ce traitement.

Coût à long terme

Un Raspberry Pi 5 (80 €) tourne pendant 5 ans sur 20 W. Un modèle léger exécutant 10 000 inférences par jour sur ce matériel coûte moins de 20 € d’électricité annuellement. La même charge de travail sur une API cloud de vision facture plusieurs milliers d’euros par an selon les prestataires.

Fonctionnement hors ligne

Dans une usine avec Wi-Fi instable, un entrepôt frigorifique, ou un tracteur en plein champ, la connexion n’est pas garantie. L’Edge AI fonctionne sans réseau.

Le Matériel : Choisir la Bonne Plateforme

Raspberry Pi 5 — L’entrée de gamme polyvalente

Le Raspberry Pi 5 (8 Go RAM) est idéal pour les projets pilotes. Avec son processeur ARM Cortex-A76 à 2,4 GHz, il exécute des modèles TFLite ou ONNX de taille raisonnable (MobileNetV3, YOLOv8n) à 15-25 FPS sur images 640×480.

Cas d’usage : comptage de personnes, lecture de QR codes, détection de présence, classification simple.

Limites : pas d’accélérateur neural intégré. Pour des performances supérieures, ajouter un Google Coral USB (35 €) qui multiplie les performances par 5 à 10 sur les modèles quantifiés INT8.

NVIDIA Jetson Nano / Orin — La puissance GPU embarquée

La famille Jetson embarque un GPU NVIDIA capable d’exécuter des modèles bien plus lourds :

  • Jetson Nano (4 Go) : 472 GFLOPS, convient pour YOLOv5s à 30 FPS
  • Jetson Orin Nano : 40 TOPS, exécute des modèles de segmentation ou de pose estimation en temps réel
  • Jetson AGX Orin : 275 TOPS, capable de traiter plusieurs flux vidéo simultanément
# Installer TensorRT sur Jetson (optimisation GPU)
sudo apt-get install tensorrt
# Convertir un modèle ONNX en TensorRT
trtexec --onnx=model.onnx --saveEngine=model.trt --fp16

Cas d’usage PME : inspection visuelle sur ligne de production, analyse vidéo multi-caméras, robotique autonome.

ESP32-S3 — L’ultra-embarqué pour capteurs

Le microcontrôleur ESP32-S3 (moins de 5 €) dispose de 512 Ko de RAM et d’instructions vectorielles pour l’inférence. Avec TensorFlow Lite Micro, il peut exécuter des modèles de classification audio (détection d’anomalie sonore) ou des réseaux convolutifs minuscules (32×32 pixels).

Cas d’usage : détection de mot-clé vocal, classification de vibrations pour maintenance prédictive, analyse de sons anormaux sur machine.

Optimiser les Modèles pour l’Embarqué

Un modèle entraîné pour le cloud n’est pas directement utilisable sur un Raspberry Pi. L’optimisation est l’étape clé.

Quantification INT8 : Diviser par 4 la Taille du Modèle

La quantification convertit les poids float32 (32 bits) en int8 (8 bits), réduisant la taille du modèle par 4 et accélérant l’inférence de 2 à 4× avec une perte de précision généralement inférieure à 1-2 %.

import tensorflow as tf

# Charger un modèle Keras entraîné
converter = tf.lite.TFLiteConverter.from_saved_model("mon_modele/")

# Activer la quantification entière
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# Fournir des données de calibration (100-500 images représentatives)
def representative_dataset():
    for image in calibration_images:
        yield [image.reshape(1, 224, 224, 3).astype("float32")]

converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8

tflite_model = converter.convert()
with open("modele_int8.tflite", "wb") as f:
    f.write(tflite_model)

print(f"Taille du modèle quantifié : {len(tflite_model) / 1024:.1f} Ko")

Élagage (Pruning) : Supprimer les Connexions Inutiles

L’élagage identifie les neurones dont les poids sont proches de zéro et les supprime. Combiné à la quantification, on obtient des modèles 10 à 20× plus petits que l’original.

import tensorflow_model_optimization as tfmot

# Appliquer l'élagage progressif pendant le fine-tuning
pruning_schedule = tfmot.sparsity.keras.PolynomialDecay(
    initial_sparsity=0.0,
    final_sparsity=0.80,  # Supprimer 80% des connexions
    begin_step=0,
    end_step=1000
)

model_pruned = tfmot.sparsity.keras.prune_low_magnitude(
    model_original, pruning_schedule=pruning_schedule
)

ONNX Runtime : Portabilité entre Frameworks

ONNX (Open Neural Network Exchange) permet d’exporter un modèle PyTorch ou TensorFlow et de l’exécuter sur n’importe quelle plateforme avec ONNX Runtime — y compris Raspberry Pi et Jetson.

import onnxruntime as ort
import numpy as np

# Charger le modèle ONNX
session = ort.InferenceSession(
    "yolov8n.onnx",
    providers=["CPUExecutionProvider"]  # ou CUDAExecutionProvider sur Jetson
)

# Inférence
input_name = session.get_inputs()[0].name
image = preprocess(frame)  # Votre prétraitement
outputs = session.run(None, {input_name: image})

Cas d’Usage Concrets pour PME

Contrôle Qualité Visuel sur Ligne de Production

Contexte : un fabricant de pièces plastiques souhaitait détecter les éraflures et déformations en sortie de moule, sans arrêter la cadence (1 pièce/seconde).

Solution déployée :

  • Matériel : Jetson Orin Nano + caméra industrielle GigE
  • Modèle : YOLOv8s quantifié INT8, entraîné sur 2 000 images d’exemples
  • Performances : 45 FPS, précision 97 %, latence < 22 ms
  • Coût matériel : 850 € (vs 15 000 € pour un système de vision industrielle classique)

Comptage de Personnes et Analyse de Flux

Dans un point de vente ou un musée, compter les visiteurs et analyser les zones fréquentées permet d’optimiser l’accueil et le placement des produits.

  • Matériel : Raspberry Pi 5 + caméra grand angle
  • Modèle : MobileNetV3 + tracker ByteTrack, traitement TFLite
  • Performances : 20 FPS, précision comptage ±3 %
  • Aucune donnée ne quitte les locaux — conformité RGPD native

Détection d’Anomalies sur Équipements

Sur un compresseur ou une pompe, un modèle audio léger (LEAF sur ESP32-S3) détecte les sons anormaux (roulement défectueux, cavitation) et déclenche une alerte via MQTT avant la panne.

# Envoi d'alerte MQTT depuis ESP32 (MicroPython)
import network, umqtt.simple as mqtt

client = mqtt.MQTTClient("capteur_01", "192.168.1.100")
client.connect()
if anomalie_detectee:
    client.publish(b"usine/alertes", b"anomalie_compresseur_A3")

Architecture de Déploiement Typique

Un déploiement Edge AI en production suit généralement ce schéma :

  1. Entraînement cloud : utiliser les ressources GPU du cloud (AWS SageMaker, Google Colab) pour entraîner le modèle sur vos données
  2. Optimisation : quantification + test de performance sur le matériel cible
  3. Déploiement : envoi du modèle sur les appareils via un outil de gestion de flotte (Balena, AWS Greengrass)
  4. Monitoring : remontée des métriques (précision, latence, températures) vers un dashboard centralisé
  5. Mise à jour : déploiement OTA (Over The Air) des nouvelles versions du modèle
# docker-compose.yml sur Raspberry Pi (via Balena)
version: "2"
services:
  inference:
    image: monregistre/edge-inference:v2.1
    privileged: true
    volumes:
      - /dev/video0:/dev/video0  # Caméra USB
    environment:
      - MODEL_PATH=/models/defect_detection_int8.tflite
      - MQTT_BROKER=192.168.1.100
      - CONFIDENCE_THRESHOLD=0.85

Checklist Avant de Lancer Votre Projet Edge AI

Avant de commander du matériel, posez-vous ces questions :

  • Quelle est la latence acceptable ? En dessous de 100 ms, l’Edge devient nécessaire
  • Quelle est la bande passante disponible ? Si limitée ou coûteuse, Edge est incontournable
  • Les données sont-elles sensibles ? Données de santé, biométriques, industrielles confidentielles → Edge
  • Combien d’appareils déployer ? Au-delà de 10 appareils, la gestion de flotte devient critique
  • Disposez-vous de données d’entraînement ? Comptez 500 à 2 000 images annotées pour un modèle de vision performant

Conclusion

L’Edge AI n’est plus réservé aux grands groupes avec des équipes de recherche dédiées. Les outils de quantification, les frameworks légers (TFLite, ONNX Runtime) et le matériel abordable (Raspberry Pi 5, Jetson Orin Nano) rendent ces déploiements accessibles à toute PME désireuse d’automatiser ses processus.

La clé du succès reste la même qu’en machine learning classique : partir d’un problème métier précis, collecter des données représentatives, et itérer rapidement sur un prototype avant de passer à l’échelle.

Vous avez un projet de déploiement IA embarqué ? Nos équipes accompagnent les PME de l’étude de faisabilité jusqu’au déploiement en production. Contactez-nous à contact@brio-novia.eu pour une première analyse gratuite de votre cas d’usage.