Edge AI en production : déployer des modèles IA sur Raspberry Pi et IoT
Votre modèle de détection d'objets tourne parfaitement sur votre laptop avec GPU. Maintenant vous devez le déployer sur un Raspberry Pi 4 qui coûte 60€ et consomme 5W. C'est le défi de l'Edge AI en 2026 : faire tourner de l'IA là où il n'y a ni cloud, ni GPU, ni même connexion internet stable. Ce guide vous montre comment y arriver.
$2
Les limites du cloud centralisé
Envoyer vos données vers le cloud pour l'inférence IA pose trois problèmes critiques :
Latence inacceptable : une caméra de sécurité qui détecte une intrusion doit réagir en <100ms. Envoyer la vidéo au cloud, faire l'inférence, recevoir la réponse prend 300-800ms même avec une bonne connexion. Trop lent pour la sécurité, les véhicules autonomes, la robotique.
Coûts de bande passante : une usine avec 50 caméras 1080p génère 50 GB/heure de vidéo. À $0.09/GB (AWS data transfer), ça fait $100,000/mois juste pour uploader les données. L'inférence locale évite ce coût.
Vie privée et souveraineté : les données médicales, les flux vidéo de domiciles privés, les secrets industriels ne peuvent pas sortir du site. RGPD, HIPAA, contraintes réglementaires imposent le traitement local.
Fiabilité : une plateforme offshore pétrolière, un tracteur agricole en plein champ, un drone en vol n'ont pas de connexion internet garantie. L'IA edge continue de fonctionner hors ligne.
Selon Gartner, 75% des données générées par les entreprises seront traitées à la périphérie (edge) d'ici 2027, contre 10% en 2021. C'est une transformation majeure de l'infrastructure IA.
Le hardware edge en 2026
Les devices edge se sont massivement améliorés :
DeviceCPURAMNPU/GPUPrixCas d'usage ---------------------------------------------- Raspberry Pi 54x ARM A76 2.4GHz8 GBVideoCore VII$80Prototypage, edge simple Jetson Nano4x ARM A574 GB128 CUDA cores$99Vision par ordinateur Jetson Orin Nano6x ARM A788 GB1024 CUDA cores$299IA embarquée avancée Coral Dev Board4x ARM A534 GBGoogle Edge TPU$150Inférence optimisée ESP32-S32x Xtensa LX78 MB-$5IoT ultra-low-cost
Le Jetson Orin Nano 2026 est 40x plus puissant que le Jetson Nano de 2019 au même prix. Les NPUs (Neural Processing Units) dédiés permettent de faire tourner des modèles complexes à 30 FPS sur batterie.
$2
Les trois niveaux de déploiement
Niveau 1 : Microcontrôleurs (ESP32, Arduino) - Budget <$10, consommation <1W. Pour des modèles ultra-légers : classification audio (keyword spotting), détection de mouvement simple, prédiction de séries temporelles. Frameworks : TensorFlow Lite Micro, uTensor.
Niveau 2 : SBC/Edge Devices (Raspberry Pi, Coral) - Budget $50-200, consommation 5-15W. Pour des modèles moyens : détection d'objets temps réel (YOLO), classification d'images (MobileNet), NLP léger. Frameworks : TensorFlow Lite, ONNX Runtime, PyTorch Mobile.
Niveau 3 : Edge Servers (Jetson, Intel NUC) - Budget $300-1000, consommation 20-50W. Pour des modèles lourds : segmentation vidéo, transformers optimisés, multi-modèles parallèles. Frameworks : TensorRT, OpenVINO, complet PyTorch.
Choisissez le niveau selon vos contraintes de coût, consommation et performance requise.
Pipeline de déploiement
Le workflow complet du cloud vers l'edge :
1. Entraînement dans le cloud : GPUs haute performance (A100, H100) pour entraîner le modèle complet 2. Optimisation du modèle : quantization, pruning, distillation pour réduire taille et calculs 3. Conversion au format edge : TFLite, ONNX, TensorRT selon le hardware cible 4. Validation hardware : benchmarks sur le device réel (latence, précision, consommation) 5. Déploiement OTA : mise à jour over-the-air des modèles en production 6. Monitoring edge : métriques de performance, drift detection, health checks
Chaque étape est critique. Un modèle qui marche en Python sur votre laptop peut totalement échouer sur un Raspberry Pi si vous sautez l'optimisation.
$2
Quantization : de float32 à int8
La quantization réduit la précision des poids du modèle de 32 bits (float32) à 8 bits (int8). Gains typiques : -75% de taille, -4x inférence plus rapide, précision -1 à -3%.
Exemple avec TensorFlow Lite :
import tensorflow as tf
# Charger le modèle entraîné
model = tf.keras.models.load_model('my_model.h5')
# Convertir en TFLite avec quantization int8
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.int8]
# Dataset représentatif pour calibration
def representative_dataset():
for _ in range(100):
yield [np.random.rand(1, 224, 224, 3).astype(np.float32)]
converter.representative_dataset = representative_dataset
tflite_model = converter.convert()
Le dataset représentatif calibre les plages de quantization. Utilisez 100-1000 vrais exemples de votre dataset de validation, pas des données aléatoires.
Pruning : éliminer les poids inutiles
Le pruning met à zéro les poids qui contribuent peu. Un modèle peut perdre 50-80% de ses poids avec <2% de dégradation de précision.
import tensorflow_model_optimization as tfmot
# Définir la politique de pruning
pruning_params = {
'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
initial_sparsity=0.0,
final_sparsity=0.5, # 50% des poids à zéro
begin_step=0,
end_step=1000
)
}
# Appliquer le pruning
model_for_pruning = tfmot.sparsity.keras.prune_low_magnitude(
model,
**pruning_params
)
# Ré-entraîner brièvement
model_for_pruning.compile(optimizer='adam', loss='categorical_crossentropy')
model_for_pruning.fit(train_data, epochs=5)
Combinez pruning + quantization pour des gains maximaux : un MobileNetV2 passe de 14 MB à 2.5 MB avec <3% de perte de précision.
Knowledge Distillation : modèle étudiant
Un gros modèle "teacher" entraîne un petit modèle "student" à imiter ses prédictions. Le student est 10-100x plus petit mais garde 90-95% des performances.
import tensorflow as tf
# Gros modèle teacher (déjà entraîné)
teacher = tf.keras.models.load_model('resnet50_teacher.h5')
# Petit modèle student (à entraîner)
student = create_mobilenet_v3_small()
# Loss de distillation
class DistillationLoss(tf.keras.losses.Loss):
def __init__(self, temperature=3.0):
super().__init__()
self.temperature = temperature
def call(self, y_true, y_pred, teacher_pred):
# Soft targets du teacher
teacher_soft = tf.nn.softmax(teacher_pred / self.temperature)
student_soft = tf.nn.softmax(y_pred / self.temperature)
# KL divergence
distillation_loss = tf.keras.losses.KLDivergence()(
teacher_soft, student_soft
) * (self.temperature ** 2)
# Hard targets (vraies labels)
student_loss = tf.keras.losses.sparse_categorical_crossentropy(
y_true, y_pred
)
return 0.7 * distillation_loss + 0.3 * student_loss
Le teacher est typiquement un ResNet50 ou EfficientNet-B7, le student un MobileNetV3 ou EfficientNet-B0.
$2
Installation TensorFlow Lite
TensorFlow Lite est le runtime optimisé pour ARM. Installation sur Raspberry Pi OS :
# Mise à jour système
sudo apt update && sudo apt upgrade -y
# Installer Python 3.11 et pip
sudo apt install python3.11 python3-pip -y
# Installer TensorFlow Lite runtime (pas le full TensorFlow)
pip3 install tflite-runtime
Le runtime TFLite pèse 3 MB contre 500 MB pour TensorFlow complet. Utilisez toujours le runtime en production.
Script d'inférence optimisé
import numpy as np
import tflite_runtime.interpreter as tflite
from PIL import Image
import time
# Charger le modèle
interpreter = tflite.Interpreter(model_path='model_int8.tflite')
interpreter.allocate_tensors()
# Récupérer les détails des tensors
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# Fonction de preprocessing
def preprocess(image_path):
img = Image.open(image_path).resize((224, 224))
img_array = np.array(img, dtype=np.uint8)
img_array = np.expand_dims(img_array, axis=0)
return img_array
# Inférence
def predict(image_path):
start = time.time()
# Prétraitement
input_data = preprocess(image_path)
# Inférence
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output_data = interpreter.get_tensor(output_details[0]['index'])
latency = (time.time() - start) * 1000 # en ms
return output_data, latency
Sur Raspberry Pi 5 avec modèle MobileNetV2 quantizé int8, la latence est de 15-25ms. Suffisant pour du temps réel à 30 FPS.
Optimisation multithreading
TFLite supporte le multithreading pour exploiter les 4 cores du Raspberry Pi :
interpreter = tflite.Interpreter(
model_path='model_int8.tflite',
num_threads=4 # Utiliser les 4 cores
)
Gain mesuré : -40% de latence en passant de 1 à 4 threads sur Raspberry Pi 5.
$2
Pourquoi TensorRT
TensorRT (NVIDIA) optimise agressivement les modèles pour les GPUs embarqués. Gains vs TensorFlow Lite : -60% latence, -50% consommation.
Installation sur Jetson Nano :
# TensorRT est pré-installé sur JetPack
# Installer PyTorch pour la conversion
pip3 install torch torchvision
Conversion PyTorch → TensorRT
import torch
from torch2trt import torch2trt
from torchvision.models import mobilenet_v2
# Charger le modèle PyTorch
model = mobilenet_v2(pretrained=True).eval().cuda()
# Créer un input exemple
x = torch.ones((1, 3, 224, 224)).cuda()
# Convertir en TensorRT avec optimisations
model_trt = torch2trt(
model,
[x],
fp16_mode=True, # Half precision
max_batch_size=1,
max_workspace_size=1 << 30 # 1 GB
)
Le mode fp16 (half precision) divise par 2 la taille et double la vitesse avec <1% de perte de précision sur Jetson.
Inférence optimisée
from torch2trt import TRTModule
import torch
import time
# Charger le modèle TensorRT
model_trt = TRTModule()
model_trt.load_state_dict(torch.load('model_trt.pth'))
# Préparation input (sur GPU)
x = torch.ones((1, 3, 224, 224)).cuda()
# Warm-up (la première inférence est lente)
for _ in range(10):
_ = model_trt(x)
# Benchmark
start = time.time()
for _ in range(100):
y = model_trt(x)
torch.cuda.synchronize()
latency = (time.time() - start) / 100 * 1000
Résultats mesurés sur Jetson Nano (MobileNetV2) :
- PyTorch : 45 ms
- TFLite : 28 ms
- TensorRT fp16 : 12 ms ⚡
TensorRT est 3.7x plus rapide que PyTorch vanilla.
$2
TensorFlow Lite Micro
TFLite Micro est conçu pour les microcontrôleurs avec <256 KB RAM. Parfait pour ESP32.
Configuration Arduino IDE :
#include
#include "model.h" // Modèle converti en C array
// Namespace TFLite
namespace {
const tflite::Model* model = nullptr;
tflite::MicroInterpreter* interpreter = nullptr;
TfLiteTensor* input = nullptr;
TfLiteTensor* output = nullptr;
constexpr int kTensorArenaSize = 60 * 1024; // 60 KB
uint8_t tensor_arena[kTensorArenaSize];
}
void setup() {
Serial.begin(115200);
// Charger le modèle
model = tflite::GetModel(g_model);
if (model->version() != TFLITE_SCHEMA_VERSION) {
Serial.println("Model version mismatch!");
return;
}
// Créer l'interpréteur
static tflite::MicroMutableOpResolver<5> resolver;
resolver.AddFullyConnected();
resolver.AddSoftmax();
// Ajouter les ops nécessaires
static tflite::MicroInterpreter static_interpreter(
model, resolver, tensor_arena, kTensorArenaSize);
interpreter = &static_interpreter;
// Allouer les tensors
interpreter->AllocateTensors();
// Récupérer les pointeurs input/output
input = interpreter->input(0);
output = interpreter->output(0);
}
void loop() {
// Remplir l'input (exemple : audio buffer)
for (int i = 0; i < input->bytes; i++) {
input->data.int8[i] = /* vos données */;
}
// Inférence
unsigned long start = micros();
TfLiteStatus invoke_status = interpreter->Invoke();
unsigned long latency = micros() - start;
if (invoke_status != kTfLiteOk) {
Serial.println("Invoke failed!");
return;
}
// Lire l'output
int8_t result = output->data.int8[0];
Serial.print("Résultat : ");
Serial.print(result);
Serial.print(" | Latence : ");
Serial.print(latency / 1000.0);
Serial.println(" ms");
Cas d'usage typique ESP32 : keyword spotting (détection de mots clés audio type "OK Google"). Modèle de 20 KB, latence <10ms, consommation <200 mW.
$2
Smart camera de sécurité
Hardware : Raspberry Pi 5 + Caméra HQ (12MP) + Coral USB Accelerator Modèle : YOLOv8n (nano) optimisé pour détection personnes/véhicules Performance : 30 FPS en 1080p, latence totale <50ms, consommation 8W Stack : Python + OpenCV + TFLite + Coral TPU
Architecture :
from pycoral.utils import edgetpu
from pycoral.adapters import detect
import cv2
# Charger le modèle sur Coral TPU
interpreter = edgetpu.make_interpreter('yolov8n_edgetpu.tflite')
interpreter.allocate_tensors()
# Boucle vidéo
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
while True:
ret, frame = cap.read()
if not ret:
break
# Inférence sur TPU (beaucoup plus rapide que CPU)
detections = detect_objects(frame, interpreter)
# Si personne détectée, déclencher alarme
for obj in detections:
if obj.id == PERSON_CLASS and obj.score > 0.7:
trigger_alarm()
Le Coral USB Accelerator (TPU Google) fait tourner YOLOv8n à 90 FPS sur Raspberry Pi, vs 8 FPS sur CPU seul. Investissement de $60 qui transforme totalement les performances.
Prédictive maintenance industrielle
Hardware : Jetson Nano + Capteurs vibrations + Microphone industriel Modèle : 1D-CNN pour classification de patterns vibratoires Performance : Analyse temps réel 24/7, prédiction pannes 48h à l'avance Stack : PyTorch + TensorRT + MQTT
Détection d'anomalies sur moteur électrique :
import torch
import numpy as np
from scipy import signal
class VibrationClassifier:
def __init__(self, model_path):
self.model = TRTModule()
self.model.load_state_dict(torch.load(model_path))
self.model.eval()
def preprocess(self, vibration_signal):
# FFT pour extraire features fréquentielles
freqs, psd = signal.welch(vibration_signal, fs=1000)
features = np.log10(psd + 1e-10)
return torch.tensor(features).float().unsqueeze(0).cuda()
def predict(self, vibration_signal):
features = self.preprocess(vibration_signal)
with torch.no_grad():
output = self.model(features)
anomaly_score = torch.sigmoid(output).item()
return anomaly_score
# En production
classifier = VibrationClassifier('vibration_model_trt.pth')
while True:
# Lire 1 seconde de signal vibration
signal_data = read_vibration_sensor(duration=1.0)
# Prédire
score = classifier.predict(signal_data)
if score > 0.85:
# Anomalie détectée
send_alert(f"Anomalie moteur : {score:.2%}")
log_to_database(signal_data, score)
Ce système tourne 24/7 sur batterie, détecte les anomalies 48h avant la panne critique. Coût hardware : $150 (Jetson Nano), économies : éviter 1 arrêt production = $50,000.
Agriculture de précision
Hardware : Raspberry Pi 4 + Caméra NoIR + GPS + Batterie solaire Modèle : Segmentation sémantique pour détection maladies plantes Performance : Analyse 1000 plants/heure, précision 92% Stack : TFLite + OpenCV + 4G LTE
Détection de mildiou sur vignoble :
import tflite_runtime.interpreter as tflite
import cv2
import numpy as np
interpreter = tflite.Interpreter('plant_segmentation.tflite')
interpreter.allocate_tensors()
def analyze_plant(image_path, gps_coords):
# Charger et preprocesser
img = cv2.imread(image_path)
img_resized = cv2.resize(img, (512, 512))
input_data = np.expand_dims(img_resized, axis=0).astype(np.uint8)
# Inférence
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
segmentation_map = interpreter.get_tensor(output_details[0]['index'])
# Analyser le masque de segmentation
disease_pixels = np.sum(segmentation_map == DISEASE_CLASS)
total_pixels = segmentation_map.size
disease_ratio = disease_pixels / total_pixels
if disease_ratio > 0.15: # >15% de la plante malade
return {
'status': 'diseased',
'severity': disease_ratio,
'gps': gps_coords,
'action': 'treat_immediately'
}
return {'status': 'healthy'}
Le système identifie les plants malades en temps réel, génère une carte de traitement précis. Économie de 60% de pesticides vs traitement uniforme du champ entier.
Pour plus d'exemples d'architectures IA en production, consultez notre article RAG multimodal.
$2
Architecture de mise à jour
Les modèles edge évoluent. Vous devez pouvoir mettre à jour 1000 devices sans intervention manuelle.
# Serveur de modèles (FastAPI)
from fastapi import FastAPI
import hashlib
app = FastAPI()
models_registry = {
'yolov8n': {
'version': '2.1.3',
'url': 'https://cdn.example.com/yolov8n_v2.1.3.tflite',
'checksum': 'a3f4b...',
'compatible_devices': ['rpi5', 'jetson-nano']
}
}
@app.get('/model/{model_name}/latest')
def get_latest_model(model_name: str, device_type: str):
model = models_registry.get(model_name)
if not model or device_type not in model['compatible_devices']:
return {'error': 'Model not found or incompatible'}
return model
# Client edge (sur Raspberry Pi)
import requests
import os
def check_model_update():
current_version = load_local_version()
response = requests.get(
'https://api.example.com/model/yolov8n/latest',
params={'device_type': 'rpi5'}
)
latest = response.json()
if latest['version'] != current_version:
download_model(latest['url'], latest['checksum'])
reload_model()
save_local_version(latest['version'])
Avec validation checksum pour garantir l'intégrité du téléchargement. Si le modèle est corrompu, rollback automatique vers la version précédente.
$2
Métriques edge critiques
Sur chaque device, collectez :
import psutil
import time
class EdgeMetrics:
def __init__(self):
self.latencies = []
self.predictions = []
def log_inference(self, latency_ms, prediction, confidence):
self.latencies.append(latency_ms)
self.predictions.append({
'class': prediction,
'confidence': confidence,
'timestamp': time.time()
})
def get_stats(self):
return {
'latency_p50': np.percentile(self.latencies, 50),
'latency_p95': np.percentile(self.latencies, 95),
'latency_p99': np.percentile(self.latencies, 99),
'cpu_percent': psutil.cpu_percent(),
'memory_mb': psutil.virtual_memory().used / 1024 / 1024,
'temperature_c': read_cpu_temperature(),
'predictions_per_hour': len(self.predictions),
'avg_confidence': np.mean([p['confidence'] for p in self.predictions])
}
Envoyez les métriques agrégées toutes les 5 minutes. Ne saturez pas la bande passante avec du logging continu.
Model drift detection
La distribution des données réelles peut dériver du dataset d'entraînement. Détectez ce drift :
from scipy.stats import wasserstein_distance
class DriftDetector:
def __init__(self, reference_distribution):
self.reference = reference_distribution # Confiances du training set
def check_drift(self, recent_confidences):
# Calculer la distance Wasserstein
distance = wasserstein_distance(self.reference, recent_confidences)
if distance > 0.15: # Seuil à tuner
alert_model_drift(distance)
trigger_retraining()
# En production
drift_detector = DriftDetector(training_confidences)
Le drift signale que votre modèle devient obsolète. Déclenchez un réentraînement avec les nouvelles données.
$2
FrameworkHardwareLangageTaillePerformanceFacilité ------------------------------------------------------------- TensorFlow LiteTousPython, C++, Java3 MB⭐⭐⭐⭐⭐⭐⭐⭐ ONNX RuntimeTousPython, C++, C#10 MB⭐⭐⭐⭐⭐⭐⭐⭐ PyTorch MobileARM, x86Python, C++8 MB⭐⭐⭐⭐⭐⭐⭐ TensorRTNVIDIA uniquementPython, C++50 MB⭐⭐⭐⭐⭐⭐⭐⭐ OpenVINOIntel uniquementPython, C++30 MB⭐⭐⭐⭐⭐⭐⭐ TFLite MicroMCU (ESP32)C++<100 KB⭐⭐⭐⭐
Recommandation générale : TensorFlow Lite pour la majorité des cas (bon compromis performance/facilité). TensorRT pour Jetson si vous voulez la performance maximale. TFLite Micro pour microcontrôleurs ultra low-cost.
$2
Model encryption
Les modèles déployés sur edge peuvent être volés (reverse engineering). Chiffrez-les :
from cryptography.fernet import Fernet
# Générer une clé (stockée de manière sécurisée)
key = Fernet.generate_key()
cipher = Fernet(key)
# Chiffrer le modèle
with open('model.tflite', 'rb') as f:
model_data = f.read()
encrypted_model = cipher.encrypt(model_data)
with open('model_encrypted.tflite', 'wb') as f:
f.write(encrypted_model)
# Déchiffrer au runtime
with open('model_encrypted.tflite', 'rb') as f:
encrypted = f.read()
model_data = cipher.decrypt(encrypted)
La clé de chiffrement peut être stockée dans un TPM (Trusted Platform Module) sur le device pour plus de sécurité.
Signature des modèles
Validez que le modèle n'a pas été altéré :
import hmac
import hashlib
SECRET_KEY = b'your-secret-key' # Partagée device + serveur
def sign_model(model_path):
with open(model_path, 'rb') as f:
model_data = f.read()
signature = hmac.new(SECRET_KEY, model_data, hashlib.sha256).hexdigest()
return signature
def verify_model(model_path, expected_signature):
actual_signature = sign_model(model_path)
return hmac.compare_digest(actual_signature, expected_signature)
Combine chiffrement + signature pour une sécurité robuste.
$2
Optimiser la batterie
Pour des devices sur batterie (drones, capteurs autonomes), chaque milliwatt compte :
Inférence par batch : accumulez 10 images, faites 1 inférence batch au lieu de 10 inférences individuelles. Gain : -30% consommation.
Dynamic voltage scaling : réduisez la fréquence CPU pendant les périodes de faible activité.
Sleep modes : entre les inférences, mettez le CPU en deep sleep. Le Raspberry Pi peut descendre à 0.4W au lieu de 5W.
import subprocess
import time
def run_inference_batch():
# Réveil complet
subprocess.run(['sudo', 'cpufreq-set', '-g', 'performance'])
# Accumuler 10 images
images = capture_batch(n=10)
# Inférence batch
predictions = model_batch_predict(images)
# Passer en mode économie
subprocess.run(['sudo', 'cpufreq-set', '-g', 'powersave'])
Avec ce pattern, un Raspberry Pi 4 sur batterie 10,000 mAh tient 18 heures vs 6 heures en mode continu.
$2
Mémoire limitée : impossible de charger des modèles >500 MB sur Raspberry Pi. Solution : distillation pour réduire la taille ou model sharding (découper le modèle).
Pas de GPU : le CPU ARM est lent. Solution : Coral TPU USB ($60) ou Jetson (GPU embarqué).
Latence variable : selon la charge CPU, la latence fluctue. Solution : prioriser le process inférence (nice -20), désactiver services inutiles.
Drift non détecté : le modèle se dégrade silencieusement. Solution : monitoring continu des confidences, A/B testing périodique.
Coût de déploiement : updater 1000 devices manuellement est impossible. Solution : système OTA automatisé, rollback automatique si échec.
$2
- TensorFlow Lite Guide : documentation officielle
- NVIDIA Jetson Projects : exemples de projets edge
- Edge Impulse : plateforme de développement edge AI
- OpenVINO Toolkit : optimisation Intel
- Coral AI : hardware et modèles Google
Pour comprendre l'architecture IA complète, lisez notre article sur l'optimisation des coûts LLM qui couvre aussi les stratégies edge vs cloud.
$2
L'Edge AI transforme des use cases impossibles en 2020 en déploiements viables en 2026. Un Raspberry Pi 5 à $80 fait tourner de la détection d'objets temps réel. Un ESP32 à $5 fait du keyword spotting. Un Jetson Orin Nano à $300 rivalise avec des serveurs cloud à $500/mois.
Les clés du succès : optimisation agressive (quantization int8, pruning, distillation), choix du bon hardware selon les contraintes (coût, consommation, performance), pipeline de déploiement OTA robuste, monitoring continu du drift.
L'edge AI n'est plus un buzzword. C'est une architecture de production mature qui alimente des millions de devices en 2026 : smart cameras, véhicules autonomes, robots industriels, agriculture de précision, santé connectée.
Les développeurs qui maîtrisent cette stack (TensorFlow Lite, TensorRT, ONNX Runtime, hardware edge) sont très demandés. C'est une compétence stratégique pour les 5 prochaines années.
Commencez par un Raspberry Pi 5 et un modèle MobileNet simple. Mesurez, optimisez, itérez. L'edge AI s'apprend par la pratique.