Edge AI : faire tourner des modèles d’IA sur vos appareils — guide pratique

📑 Sommaire

• 1. Introduction : pourquoi l’Edge AI change la donne
• 2. Edge AI vs Cloud AI : comprendre les différences fondamentales
• 3. La quantization : réduire la taille des modèles sans sacrifier la qualité
• 4. Ollama : le Docker de l’IA locale
• 5. llama.cpp : l’inférence bare-metal ultra-optimisée
• 6. ONNX Runtime : l’interopérabilité au service de la performance
• 7. CoreML et l’écosystème Apple Silicon
• 8. TensorRT : la puissance NVIDIA à portée de main
• 9. Benchmarks détaillés : Raspberry Pi, Mac, smartphones
• 10. Use cases IoT et applications industrielles
• 11. Guide pratique : votre premier déploiement Edge AI
• 12. Conclusion et perspectives
• Sources et références

1. Introduction : pourquoi l’Edge AI change la donne

L’intelligence artificielle a longtemps été synonyme de datacenters massifs, de clusters GPU coûteux et de connexions cloud permanentes. Mais un changement de paradigme majeur est en cours : l’Edge AI, c’est-à-dire la capacité de faire tourner des modèles d’IA directement sur vos appareils — smartphones, ordinateurs portables, Raspberry Pi, capteurs IoT — sans dépendre d’une connexion internet ou d’un serveur distant.

Cette révolution n’est pas anecdotique. Selon les dernières estimations de Gartner, plus de 55 % des analyses de données par deep learning se feront sur des appareils edge d’ici fin 2026, contre à peine 10 % en 2022. Les raisons de cette migration sont multiples et profondes : latence réduite, protection de la vie privée, réduction des coûts cloud, fonctionnement hors-ligne, et souveraineté des données.

Ce guide pratique vous accompagnera pas à pas dans la compréhension et la mise en œuvre de l’Edge AI. Que vous soyez développeur souhaitant intégrer l’IA dans une application mobile, ingénieur IoT cherchant à ajouter de l’intelligence à vos capteurs, ou simplement un passionné voulant faire tourner un LLM sur son propre matériel, vous trouverez ici toutes les clés pour démarrer et réussir vos projets d’IA embarquée.

Nous couvrirons l’ensemble de la chaîne : de la théorie de la quantization aux outils concrets comme Ollama, llama.cpp, ONNX Runtime, CoreML et TensorRT, en passant par des benchmarks détaillés sur différentes plateformes matérielles. Chaque section inclut des exemples de code fonctionnels et des recommandations pratiques issues de notre expérience terrain.

2. Edge AI vs Cloud AI : comprendre les différences fondamentales

Avant de plonger dans les aspects techniques, il est essentiel de comprendre pourquoi l’Edge AI représente une alternative crédible — et parfois supérieure — au Cloud AI traditionnel. Les deux approches ne s’opposent pas nécessairement, mais répondent à des contraintes et des cas d’usage différents.

2.1 La latence : le facteur décisif

Dans une architecture cloud classique, chaque requête d’inférence effectue un aller-retour réseau : les données sont envoyées au serveur, traitées, puis le résultat est renvoyé. Même avec une connexion fibre, ce processus ajoute typiquement 100 à 500 ms de latence. Pour des applications temps réel comme la conduite autonome, la robotique industrielle ou les assistants vocaux embarqués, cette latence est inacceptable.

En Edge AI, l’inférence se fait localement. La latence se réduit aux seuls temps de calcul du modèle, soit généralement 10 à 50 ms pour des modèles optimisés. C’est un gain d’un ordre de grandeur qui ouvre des possibilités impossibles avec le cloud.

2.2 La confidentialité et la souveraineté des données

Avec l’entrée en vigueur de réglementations de plus en plus strictes (RGPD, AI Act européen, HIPAA pour le médical), la question de la localisation et du traitement des données est devenue critique. L’Edge AI offre une solution élégante : les données ne quittent jamais l’appareil. Pas de transfert réseau, pas de stockage cloud, pas de risque de fuite. C’est particulièrement crucial dans les secteurs de la santé, de la finance et de la défense.

2.3 Les coûts à long terme

Le cloud computing fonctionne sur un modèle de paiement à l’usage qui peut devenir prohibitif à grande échelle. L’Edge AI implique un investissement matériel initial mais des coûts marginaux quasi nuls par requête. Pour les applications à fort volume, le retour sur investissement est souvent atteint en quelques semaines seulement.

2.4 La résilience et le fonctionnement hors-ligne

Les systèmes cloud sont dépendants de la connectivité réseau. Une panne internet, un datacenter indisponible, ou simplement un environnement sans couverture réseau (zones rurales, sites industriels isolés, véhicules en mouvement) rend ces systèmes inopérants. L’Edge AI fonctionne de manière autonome, quelles que soient les conditions réseau. Cette résilience est un atout majeur pour les applications critiques où l’interruption de service n’est pas une option.

3. La quantization : réduire la taille des modèles sans sacrifier la qualité

La quantization est la technique fondamentale qui rend l’Edge AI possible. Elle consiste à réduire la précision numérique des poids du modèle — typiquement de float32 (32 bits) à int8 (8 bits) ou int4 (4 bits) — ce qui divise proportionnellement la taille du modèle et les besoins en mémoire, tout en maintenant une qualité d’inférence remarquablement proche de l’original.

3.1 GGUF : le format universel de l’IA locale

GGUF (GPT-Generated Unified Format) est devenu le standard de facto pour les modèles quantifiés destinés à l’inférence CPU. Successeur du format GGML, il a été conçu par Georgi Gerganov pour le projet llama.cpp et offre plusieurs avantages décisifs :

• Fichier unique : tout le modèle (poids, tokenizer, métadonnées) dans un seul fichier, facile à distribuer et à gérer
• Quantization flexible : support de multiples niveaux (Q2_K, Q3_K_S, Q4_K_M, Q5_K_M, Q6_K, Q8_0) permettant de choisir le compromis taille/qualité optimal
• Optimisation CPU : exploite les instructions SIMD (AVX2, AVX-512, ARM NEON) pour une inférence rapide sans GPU
• Compatibilité étendue : supporté par Ollama, llama.cpp, LM Studio, GPT4All, et de nombreux autres outils

# Exemple : télécharger un modèle GGUF depuis Hugging Face
# Llama 3.1 8B en quantization Q4_K_M (environ 4.9 Go)
wget https://huggingface.co/bartowski/Meta-Llama-3.1-8B-Instruct-GGUF/resolve/main/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf

# Vérifier la taille et les métadonnées
ls -lh Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
# -rw-r--r-- 1 user user 4.9G  Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf

3.2 GPTQ : la quantization orientée GPU

GPTQ (GPT Quantization) est une méthode de quantization post-entraînement développée par des chercheurs de l’IST Austria. Contrairement à GGUF qui cible principalement le CPU, GPTQ est optimisé pour l’inférence GPU via CUDA. La méthode utilise une approximation de second ordre (basée sur la matrice Hessienne) pour minimiser l’erreur de quantization couche par couche.

Les modèles GPTQ offrent typiquement de meilleures performances que GGUF sur GPU, avec des vitesses d’inférence 2 à 3 fois supérieures. Cependant, ils nécessitent un GPU NVIDIA avec suffisamment de VRAM pour charger le modèle entier. Le format est largement supporté par des frameworks comme AutoGPTQ, ExLlama, et vLLM.

# Installation d'AutoGPTQ
pip install auto-gptq

# Chargement d'un modèle GPTQ en Python
from auto_gptq import AutoGPTQForCausalLM
from transformers import AutoTokenizer

model_name = "TheBloke/Llama-3.1-8B-Instruct-GPTQ"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    device="cuda:0",
    use_triton=False,
    quantize_config=None
)

# Inférence
input_text = "Expliquez le concept d'Edge AI en trois phrases."
inputs = tokenizer(input_text, return_tensors="pt").to("cuda:0")
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

3.3 AWQ : le meilleur des deux mondes

AWQ (Activation-aware Weight Quantization) est la technique de quantization la plus récente et, selon de nombreux benchmarks, la plus performante. Développée par le MIT, elle part d’une observation clé : tous les poids d’un modèle ne sont pas également importants. Certains canaux de poids ont un impact disproportionné sur la qualité de sortie, et les protéger de la quantization permet de maintenir une qualité supérieure à GPTQ tout en conservant une taille comparable.

AWQ fonctionne à la fois sur CPU et GPU, offre une excellente compatibilité avec vLLM pour le serving à grande échelle, et est supporté nativement par le framework TensorRT-LLM de NVIDIA. C’est actuellement notre recommandation par défaut pour les déploiements GPU en production.

4. Ollama : le Docker de l’IA locale

Ollama s’est imposé comme l’outil le plus accessible pour faire tourner des LLM en local. Son approche « à la Docker » — avec un système de pull/run de modèles, un registre centralisé et une API REST — a considérablement démocratisé l’accès à l’IA locale. En janvier 2026, Ollama revendique plus de 15 millions de téléchargements et une communauté de développeurs en croissance exponentielle.

4.1 Installation et configuration

# Installation sur Linux (une seule commande)
curl -fsSL https://ollama.ai/install.sh | sh

# Installation sur macOS via Homebrew
brew install ollama

# Vérifier l'installation
ollama --version
# ollama version 0.5.x

# Démarrer le service
ollama serve &

# Télécharger et lancer un modèle
ollama pull llama3.1:8b
ollama run llama3.1:8b "Bonjour, comment fonctionne l'Edge AI ?"

4.2 Configuration avancée et Modelfile

La véritable puissance d’Ollama réside dans ses Modelfiles, qui permettent de personnaliser finement le comportement des modèles, à la manière d’un Dockerfile pour les conteneurs. Vous pouvez définir des paramètres de génération, un prompt système, des templates de conversation, et même créer des modèles dérivés avec des personnalités spécifiques.

# Créer un fichier nommé "Modelfile"
FROM llama3.1:8b

# Paramètres d'inférence optimisés pour l'edge
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 4096
PARAMETER repeat_penalty 1.1
PARAMETER num_gpu 0  # Force CPU uniquement (utile pour RPi)

# Prompt système personnalisé
SYSTEM """
Tu es un assistant IA spécialisé en IoT et systèmes embarqués.
Tu réponds en français, de manière concise et technique.
Tu donnes des exemples de code quand c'est pertinent.
"""

# Créer le modèle personnalisé
# ollama create mon-assistant-iot -f Modelfile
# ollama run mon-assistant-iot

4.3 L’API REST d’Ollama pour l’intégration

Ollama expose une API REST compatible OpenAI sur le port 11434, ce qui permet une intégration transparente avec l’ensemble de l’écosystème existant. Voici comment l’utiliser depuis Python pour construire des applications Edge AI robustes :

import requests
import json

# Appel simple à l'API Ollama
def query_ollama(prompt, model="llama3.1:8b", stream=False):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": stream,
            "options": {
                "temperature": 0.7,
                "num_ctx": 4096,
                "num_predict": 512
            }
        }
    )
    return response.json()["response"]

# Appel avec l'API compatible OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # clé factice, Ollama n'en a pas besoin
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[
        {"role": "system", "content": "Tu es un expert en IoT."},
        {"role": "user", "content": "Comment déployer un modèle sur Raspberry Pi ?"}
    ],
    temperature=0.7,
    max_tokens=500
)
print(response.choices[0].message.content)

5. llama.cpp : l’inférence bare-metal ultra-optimisée

Si Ollama est le « Docker » de l’IA locale, llama.cpp en est le « moteur bare-metal ». Créé par Georgi Gerganov en mars 2023, ce projet C/C++ est devenu la référence absolue pour l’inférence LLM sur CPU. Son code est optimisé à la main pour exploiter chaque instruction SIMD disponible (AVX, AVX2, AVX-512, ARM NEON, Metal), et ses performances sur CPU sont inégalées.

5.1 Compilation et optimisation

# Cloner le dépôt
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# Compilation optimisée pour CPU avec support AVX2
cmake -B build -DLLAMA_AVX2=ON -DLLAMA_FMA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j$(nproc)

# Compilation avec support Metal (macOS Apple Silicon)
cmake -B build -DLLAMA_METAL=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j$(sysctl -n hw.ncpu)

# Compilation avec support CUDA (GPU NVIDIA)
cmake -B build -DLLAMA_CUDA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j$(nproc)

# Compilation pour Raspberry Pi (ARM NEON)
cmake -B build -DLLAMA_NEON=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j4

5.2 Inférence en ligne de commande

# Inférence simple
./build/bin/llama-cli \
  -m models/llama-3.1-8b-instruct-q4_k_m.gguf \
  -p "Explique le concept de quantization en IA" \
  -n 512 \
  --temp 0.7 \
  --top-p 0.9 \
  --repeat-penalty 1.1 \
  -ngl 35  # Nombre de couches sur GPU (0 pour CPU uniquement)

# Serveur HTTP compatible OpenAI
./build/bin/llama-server \
  -m models/llama-3.1-8b-instruct-q4_k_m.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  -ngl 35 \
  --ctx-size 4096 \
  --parallel 4  # 4 requêtes simultanées

5.3 Quantization de vos propres modèles

llama.cpp inclut des outils pour quantifier vos propres modèles Hugging Face au format GGUF. C’est particulièrement utile si vous avez fine-tuné un modèle et souhaitez le déployer en edge. Le processus est automatisé et prend de quelques minutes à une heure selon la taille du modèle :

# Convertir un modèle Hugging Face en GGUF
python convert_hf_to_gguf.py \
  /chemin/vers/mon-modele-finetune \
  --outfile mon-modele-f16.gguf \
  --outtype f16

# Quantifier en Q4_K_M (meilleur rapport qualité/taille)
./build/bin/llama-quantize \
  mon-modele-f16.gguf \
  mon-modele-q4_k_m.gguf \
  Q4_K_M

# Quantifier en Q5_K_M (meilleure qualité, un peu plus gros)
./build/bin/llama-quantize \
  mon-modele-f16.gguf \
  mon-modele-q5_k_m.gguf \
  Q5_K_M

6. ONNX Runtime : l’interopérabilité au service de la performance

ONNX (Open Neural Network Exchange) est un format ouvert développé conjointement par Microsoft, Facebook et AWS pour représenter les modèles de deep learning de manière indépendante du framework. ONNX Runtime, le moteur d’inférence associé, est l’un des runtimes les plus performants et les plus polyvalents pour le déploiement edge, supportant une gamme impressionnante de matériel et d’accélérateurs.

6.1 Pourquoi ONNX Runtime pour l’Edge

ONNX Runtime excelle dans les scénarios edge pour plusieurs raisons. Premièrement, il supporte la quantization dynamique et statique INT8, permettant de réduire la taille des modèles de 75 % avec une perte de précision minimale. Deuxièmement, son système d’Execution Providers (EP) lui permet de s’adapter automatiquement au matériel disponible : CPU (OpenVINO EP pour Intel, ACL EP pour ARM), GPU (CUDA EP, DirectML EP, ROCm EP), ou accélérateurs spécialisés (TensorRT EP, QNN EP pour Qualcomm, CoreML EP pour Apple).

import onnxruntime as ort
import numpy as np

# Vérifier les providers disponibles
print(ort.get_available_providers())
# ['TensorrtExecutionProvider', 'CUDAExecutionProvider', 'CPUExecutionProvider']

# Charger un modèle avec sélection automatique du meilleur provider
session_options = ort.SessionOptions()
session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
session_options.intra_op_num_threads = 4

session = ort.InferenceSession(
    "modele_optimise.onnx",
    sess_options=session_options,
    providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)

# Préparer les entrées et exécuter l'inférence
input_name = session.get_inputs()[0].name
input_data = np.random.randn(1, 3, 224, 224).astype(np.float32)
result = session.run(None, {input_name: input_data})
print(f"Sortie shape: {result[0].shape}")

6.2 Optimisation et quantization ONNX

from onnxruntime.quantization import quantize_dynamic, QuantType
from onnxruntime.transformers import optimizer

# Optimisation du graphe ONNX
optimized_model = optimizer.optimize_model(
    "modele_original.onnx",
    model_type='bert',
    num_heads=12,
    hidden_size=768
)
optimized_model.save_model_to_file("modele_optimise.onnx")

# Quantization dynamique INT8 (la plus simple)
quantize_dynamic(
    model_input="modele_optimise.onnx",
    model_output="modele_quantise_int8.onnx",
    weight_type=QuantType.QInt8,
    optimize_model=True
)

# Le modèle quantisé est ~4x plus petit et ~2-3x plus rapide sur CPU

7. CoreML et l’écosystème Apple Silicon

Apple Silicon a transformé le paysage de l’Edge AI. Les puces M1 à M4 intègrent un Neural Engine dédié capable de 38 TOPS (trillions d’opérations par seconde) pour le M4 Pro, rivalisent avec des GPU discrets pour l’inférence IA, tout en maintenant une consommation électrique remarquablement basse. CoreML est le framework d’Apple pour exploiter cette puissance, et il est devenu un pilier incontournable de l’Edge AI sur l’écosystème Apple.

7.1 MLX : le framework ML natif Apple Silicon

MLX, développé par Apple Research, est un framework de machine learning spécifiquement conçu pour Apple Silicon. Il exploite l’architecture mémoire unifiée des puces M-series, où CPU et GPU partagent le même pool de mémoire, éliminant les transferts de données coûteux qui pénalisent les architectures traditionnelles. MLX supporte nativement les modèles de langage et offre des performances comparables à CUDA sur GPU NVIDIA, tout en consommant une fraction de l’énergie.

# Installation de MLX
pip install mlx mlx-lm

# Télécharger et exécuter un modèle
mlx_lm.generate \
  --model mlx-community/Llama-3.1-8B-Instruct-4bit \
  --prompt "Quels sont les avantages de l'Edge AI ?" \
  --max-tokens 500

# Utilisation en Python
from mlx_lm import load, generate

model, tokenizer = load("mlx-community/Llama-3.1-8B-Instruct-4bit")
response = generate(
    model, tokenizer,
    prompt="Expliquez la quantization AWQ",
    max_tokens=500,
    temp=0.7
)
print(response)

7.2 Conversion CoreML pour les apps iOS/macOS

Pour intégrer un modèle dans une application native iOS ou macOS, CoreML est le chemin le plus direct. Le package coremltools permet de convertir des modèles PyTorch ou TensorFlow en format .mlpackage optimisé pour le Neural Engine :

import coremltools as ct
import torch

# Charger un modèle PyTorch
model = torch.load("mon_modele.pt")
model.eval()

# Convertir en CoreML avec quantization INT8
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

mlmodel = ct.convert(
    traced_model,
    inputs=[ct.TensorType(shape=example_input.shape)],
    compute_precision=ct.precision.FLOAT16,
    compute_units=ct.ComputeUnit.ALL  # CPU + GPU + Neural Engine
)

# Quantization post-conversion
from coremltools.optimize.coreml import OpLinearQuantizerConfig, linear_quantize_weights

config = OpLinearQuantizerConfig(mode="linear_symmetric", weight_threshold=512)
mlmodel_quantized = linear_quantize_weights(mlmodel, config)
mlmodel_quantized.save("mon_modele_quantise.mlpackage")

8. TensorRT : la puissance NVIDIA à portée de main

TensorRT est le SDK d’optimisation d’inférence de NVIDIA, conçu pour maximiser les performances sur les GPU de la famille GeForce, Quadro et Jetson. Il applique automatiquement des optimisations comme la fusion de couches, la calibration de précision (FP16, INT8), le kernel auto-tuning et l’allocation mémoire optimale. Pour les déploiements Edge AI sur matériel NVIDIA (Jetson Nano, Jetson Orin, GeForce), TensorRT offre les meilleures performances absolues.

8.1 TensorRT-LLM pour les modèles de langage

TensorRT-LLM est l’extension spécialisée de TensorRT pour les grands modèles de langage. Il implémente des optimisations spécifiques comme l’attention flash, le KV-cache paginé, l’inflight batching et la parallélisation tensorielle. Les gains de performance par rapport à une inférence PyTorch naïve sont spectaculaires : souvent 3 à 5 fois plus rapide, avec une consommation VRAM réduite de 30 à 50 %.

# Installation de TensorRT-LLM
pip install tensorrt-llm

# Conversion d'un modèle Llama pour TensorRT-LLM
python convert_checkpoint.py \
  --model_dir /chemin/vers/llama-3.1-8b \
  --output_dir ./trt_checkpoint \
  --dtype float16 \
  --tp_size 1

# Construction du moteur TensorRT
trtllm-build \
  --checkpoint_dir ./trt_checkpoint \
  --output_dir ./trt_engine \
  --gemm_plugin float16 \
  --max_batch_size 8 \
  --max_input_len 2048 \
  --max_output_len 512

# Exécution de l'inférence
python run.py \
  --engine_dir ./trt_engine \
  --tokenizer_dir /chemin/vers/llama-3.1-8b \
  --max_output_len 200 \
  --input_text "Avantages de l'Edge AI pour l'industrie"

8.2 NVIDIA Jetson : la plateforme Edge AI de référence

La gamme Jetson de NVIDIA (Nano, Xavier NX, Orin Nano, Orin NX, AGX Orin) est spécifiquement conçue pour les applications Edge AI exigeantes. Le Jetson Orin Nano, à moins de 250 €, offre 40 TOPS de performance IA dans un format compact et basse consommation (7-15W). Couplé à TensorRT et JetPack SDK, il permet de faire tourner des modèles de vision, de NLP et même des LLM compacts avec des performances industrielles.

9. Benchmarks détaillés : Raspberry Pi, Mac, smartphones

Les performances Edge AI varient considérablement selon le matériel utilisé. Voici nos benchmarks détaillés réalisés avec Llama 3.1 8B quantifié en Q4_K_M (GGUF), mesurant la vitesse de génération en tokens par seconde (t/s) — un token correspondant approximativement à un mot ou sous-mot :

Ces chiffres montrent que l’Edge AI est déjà viable sur une large gamme de matériel. Un Mac avec puce M-series offre une expérience fluide et confortable, tandis que même un Raspberry Pi 5 peut servir de base pour des applications IA simples comme la classification d’images, la détection d’objets ou un chatbot à réponse différée.

9.1 Impact de la taille du contexte

La taille du contexte (context window) a un impact significatif sur les performances et la consommation mémoire. Un contexte de 2048 tokens consomme environ 1.2 Go de RAM supplémentaire pour Llama 3.1 8B, tandis qu’un contexte de 8192 tokens en consomme environ 4.8 Go. Sur les appareils edge avec mémoire limitée, il est crucial de calibrer la taille du contexte en fonction de la mémoire disponible. Notre recommandation : 2048 tokens pour les Raspberry Pi et smartphones, 4096 pour les mini PC et Jetson, 8192 et plus pour les Mac et desktops.

10. Use cases IoT et applications industrielles

L’Edge AI trouve des applications concrètes et à forte valeur ajoutée dans de nombreux secteurs industriels. Voici les cas d’usage les plus matures et les plus prometteurs en 2026 :

10.1 Maintenance prédictive

Des modèles de machine learning légers (Random Forest, XGBoost, réseaux de neurones compacts) déployés sur des capteurs industriels analysent en temps réel les vibrations, températures et courants électriques des machines. L’inférence locale permet de détecter les anomalies en quelques millisecondes et de déclencher des alertes avant qu’une panne ne survienne. General Electric rapporte une réduction de 20 % des temps d’arrêt non planifiés grâce à cette approche.

10.2 Vision par ordinateur embarquée

La détection d’objets, le comptage de personnes, le contrôle qualité visuel et la surveillance de sécurité sont parmi les applications Edge AI les plus déployées. Des modèles comme YOLOv8-nano ou EfficientDet-Lite tournent confortablement sur des caméras intelligentes ou des Jetson Nano, analysant les flux vidéo en temps réel sans envoyer un seul pixel dans le cloud.

10.3 Agriculture de précision

Des drones et capteurs équipés de modèles de classification d’images détectent les maladies des plantes, évaluent la maturité des fruits et optimisent l’irrigation. L’inférence locale est essentielle car les champs agricoles ont souvent une connectivité réseau limitée ou inexistante. Le projet OpenAg du MIT a démontré une augmentation de 15 % des rendements grâce à l’Edge AI.

10.4 Assistants vocaux embarqués

Les assistants vocaux edge, utilisant des modèles ASR (Automatic Speech Recognition) comme Whisper.cpp et des LLM compacts pour la compréhension et la génération, fonctionnent entièrement hors-ligne. C’est crucial pour les applications automobiles, les équipements médicaux et les contextes où la confidentialité des conversations est primordiale. La latence réduite (réponse en moins de 500 ms) offre une expérience utilisateur supérieure aux assistants cloud.

« L’Edge AI n’est pas une mode technologique, c’est une nécessité architecturale. À mesure que nous connectons des milliards d’appareils, il devient physiquement impossible de tout envoyer dans le cloud. L’intelligence doit migrer vers la périphérie du réseau. »
— Dr. Andrew Ng, fondateur de DeepLearning.AI et Landing AI

11. Guide pratique : votre premier déploiement Edge AI

Pour conclure cette exploration approfondie, voici un guide étape par étape pour réaliser votre premier déploiement Edge AI fonctionnel. Nous allons créer un assistant IA local capable de répondre à des questions, accessible via une API REST, le tout tournant sur un simple ordinateur portable ou un mini PC.

Étape 1 : Choisir et installer votre runtime

# Option A : Ollama (le plus simple)
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
ollama pull llama3.1:8b

# Option B : llama.cpp (le plus performant)
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp && cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j$(nproc)
# Télécharger un modèle GGUF depuis Hugging Face

Étape 2 : Créer l’application FastAPI

# app.py - Application Edge AI complète
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import requests
import time

app = FastAPI(title="Edge AI Assistant", version="1.0")

class Query(BaseModel):
    question: str
    max_tokens: int = 500
    temperature: float = 0.7

class Response(BaseModel):
    answer: str
    tokens_generated: int
    inference_time_ms: float

@app.post("/ask", response_model=Response)
async def ask_question(query: Query):
    start = time.time()
    try:
        result = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "llama3.1:8b",
                "prompt": query.question,
                "stream": False,
                "options": {
                    "temperature": query.temperature,
                    "num_predict": query.max_tokens
                }
            },
            timeout=120
        )
        data = result.json()
        elapsed = (time.time() - start) * 1000
        return Response(
            answer=data["response"],
            tokens_generated=data.get("eval_count", 0),
            inference_time_ms=round(elapsed, 2)
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    return {"status": "ok", "model": "llama3.1:8b", "runtime": "ollama"}

# Lancement : uvicorn app:app --host 0.0.0.0 --port 8000

Étape 3 : Conteneurisation avec Docker

# Dockerfile pour déploiement Edge AI
FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .

EXPOSE 8000
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# docker build -t edge-ai-assistant .
# docker run -p 8000:8000 --network host edge-ai-assistant

12. Conclusion et perspectives

L’Edge AI n’est plus une technologie expérimentale réservée aux laboratoires de recherche. C’est une réalité industrielle mature, accessible à tout développeur disposant d’un ordinateur portable moderne, d’un Raspberry Pi ou même d’un smartphone. Les outils présentés dans ce guide — Ollama, llama.cpp, ONNX Runtime, CoreML, TensorRT — forment un écosystème riche et complémentaire qui couvre l’ensemble des besoins, du prototypage rapide au déploiement en production à grande échelle.

Les progrès en matière de quantization (GGUF, GPTQ, AWQ) ont réduit l’écart de qualité entre les modèles complets et leurs versions compressées à un niveau presque imperceptible pour la plupart des cas d’usage. Cette démocratisation technique, combinée à la montée en puissance des processeurs spécialisés (Neural Engines, NPU) dans les appareils grand public, accélère l’adoption de l’Edge AI dans tous les secteurs.

Les perspectives pour 2026 et au-delà sont enthousiasmantes. L’arrivée de modèles spécifiquement conçus pour l’edge (Phi-3, Gemma 2, les futurs modèles sub-1B optimisés), l’intégration de NPU dédiés dans les processeurs x86 (Intel Meteor Lake, AMD Ryzen AI), et la standardisation des formats d’échange (ONNX, GGUF) vont encore accélérer cette tendance. L’avenir de l’IA est distribué, et il commence sur vos appareils.

Sources et références

1. Gerganov, G. (2024). « llama.cpp: LLM inference in C/C++ ». GitHub Repository. https://github.com/ggerganov/llama.cpp
2. Lin, J., Tang, J., et al. (2024). « AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration ». MIT HAN Lab, MLSys 2024.
3. NVIDIA (2025). « TensorRT-LLM: A TensorRT Toolbox for Large Language Models ». NVIDIA Developer Documentation.
4. Apple (2025). « MLX: An array framework for Apple Silicon ». Apple Machine Learning Research.
5. Gartner (2025). « Predicts 2026: Edge AI Will Process 55% of Deep Neural Network Inferences ». Gartner Research Report.
6. Microsoft (2025). « ONNX Runtime: Cross-platform, high performance ML inferencing and training accelerator ». Microsoft Documentation.
7. Frantar, E., et al. (2023). « GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers ». ICLR 2023.
8. Ollama (2026). « Ollama Documentation and API Reference ». https://ollama.ai/docs