📍 Guide principal : Détection d’objets en 2026 : pipeline YOLO v11 + Ultralytics + Roboflow. Prérequis : avoir exporté un modèle en ONNX.

La gamme Jetson Orin de NVIDIA est devenue le standard de fait pour l’inférence en temps réel sur capteur embarqué. Le Jetson Orin Nano Super Developer Kit, présenté par NVIDIA en décembre 2024 à 249 USD, monte à 67 TOPS en mode performance — assez pour faire tourner YOLO v11s à plus de 30 images par seconde sur un flux vidéo 1080p. À l’autre bout de la gamme, le Jetson AGX Orin 64 Go culmine à 275 TOPS et tient plusieurs flux simultanés. Mais sortir ces chiffres en pratique demande une chaîne logicielle correctement installée : JetPack à la bonne version, drivers natifs, TensorRT compilé sur la cible, et un mode d’alimentation adapté. Ce tutoriel détaille la procédure complète, du flash de la carte SD à un benchmark d’inférence reproductible.

Prérequis

Une carte Jetson Orin (Nano, NX, AGX) avec son bloc d’alimentation officiel.
Une carte microSD de 64 Go minimum (classe U3 / V30 conseillée) ou un SSD NVMe pour les modèles supérieurs.
Un PC sous Linux ou Windows pour flasher l’image.
Un écran HDMI, un clavier, une souris pour la première configuration (ou un câble de console série pour le mode headless).
Un modèle YOLO v11 exporté en ONNX (cf. tutoriel d’export).
Niveau attendu : Linux à l’aise en ligne de commande.
Temps estimé : 2 à 3 heures pour la première installation, 30 minutes pour les déploiements suivants.

Étape 1 — Flasher JetPack 6 sur la Jetson

JetPack est la distribution Linux officielle de NVIDIA pour Jetson. La version 6 (sortie en 2024 et stabilisée fin 2024) est basée sur Ubuntu 22.04 et embarque CUDA 12.6, cuDNN 9.x et TensorRT 10.3 à partir de la mise à jour JetPack 6.2. C’est la version qui supporte officiellement YOLO v11 et son export TensorRT. Téléchargez l’image SD officielle depuis developer.nvidia.com/embedded/jetpack, en sélectionnant le modèle exact de votre Jetson (l’image n’est pas la même pour Orin Nano, NX ou AGX).

Sur le PC, utiliser Balena Etcher ou dd pour flasher l’image .img.xz sur la carte SD. La procédure complète est documentée dans le Getting Started Guide de chaque modèle. Pour le Jetson Orin Nano Developer Kit, la procédure officielle est sur jetson-ai-lab.com/initial_setup_jon.html.

Une fois la SD flashée, l’insérer dans le slot Jetson, brancher écran/clavier, alimenter. Le premier boot vous fait passer la configuration Ubuntu (langue, clavier, utilisateur, mot de passe). Comptez 10-15 minutes. Après login, vérifier la version active :

sudo apt update
cat /etc/nv_tegra_release

La sortie doit afficher quelque chose du type « # R36 (release), REVISION: 3.0 », qui correspond à JetPack 6.0 / L4T 36.3. Si la version est antérieure à R36, votre image est trop ancienne — re-télécharger la dernière depuis le site NVIDIA.

Étape 2 — Activer le mode performance maximum

Par défaut, la Jetson démarre dans un mode d’alimentation conservateur qui plafonne les performances pour préserver la consommation. Pour utiliser les 67 TOPS du Orin Nano Super (ou les 275 TOPS de l’AGX), il faut basculer manuellement vers le profil maximal. NVIDIA expose deux outils : nvpmodel pour choisir le profil de puissance, et jetson_clocks pour verrouiller les fréquences au maximum :

# Lister les profils disponibles
sudo nvpmodel -q --verbose

# Sur Orin Nano : le profil "MAXN_SUPER" est l'ID 2
sudo nvpmodel -m 2

# Verrouiller les fréquences au maximum
sudo jetson_clocks

# Vérifier l'état actuel
sudo nvpmodel -q
sudo jetson_clocks --show

Après cette bascule, la carte consomme plus (jusqu’à 25 W sur Orin Nano Super, 60 W sur AGX Orin) et chauffe davantage. Pour des cycles d’inférence longs, prévoir un dissipateur actif si l’enveloppe ne suffit pas. La sortie de jetson_clocks --show affiche les fréquences CPU, GPU et mémoire ; toutes doivent être à leur valeur maximale.

Pour rendre la configuration persistante au reboot, ajoutez les commandes dans /etc/rc.local ou créez un service systemd dédié.

Étape 3 — Installer Python 3.10 + PyTorch arm64

JetPack 6 livre Python 3.10. PyTorch officiel pour aarch64 (l’architecture des Tegra) n’est pas distribué via PyPI — il faut passer par les wheels NVIDIA dédiées au Jetson. Le repository officiel est listé dans la doc NVIDIA Install PyTorch on Jetson. La commande, à adapter à la version exacte de PyTorch correspondant à votre JetPack, ressemble à :

sudo apt install -y python3-pip libopenblas-dev
# Choisir l'URL de la wheel dans la doc NVIDIA selon JetPack 6.x
# Exemple JetPack 6.1 — voir la doc NVIDIA pour la version exacte
pip install --no-cache https://developer.download.nvidia.com/compute/redist/jp/v61/pytorch/torch-2.5.0a0+872d972e41.nv24.08.17622132-cp310-cp310-linux_aarch64.whl
pip install torchvision==0.19.0

L’installation prend 5 à 10 minutes (téléchargement plus long sur Jetson). Vérifiez que PyTorch voit le GPU :

python3 -c "import torch; print(torch.__version__, 'CUDA:', torch.cuda.is_available(), torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU')"

La sortie attendue affiche la version PyTorch, CUDA: True, et Orin (nvgpu) ou similaire. Si CUDA: False, la wheel installée est la version CPU générique au lieu de la wheel Jetson — désinstaller et reprendre l’URL exacte de la doc NVIDIA.

Étape 4 — Installer Ultralytics et compiler l’engine TensorRT sur la cible

Ultralytics s’installe normalement via pip une fois PyTorch en place :

pip install -U ultralytics

Copier ensuite le fichier ONNX précédemment exporté sur la Jetson (via scp, clé USB ou rsync). La compilation TensorRT doit obligatoirement se faire sur la Jetson elle-même, parce qu’un engine TensorRT est verrouillé au modèle de GPU exact :

from ultralytics import YOLO

# Charger l'ONNX qu'on a copié
model = YOLO("./best.onnx")

# Compiler l'engine pour ce GPU Jetson Orin précisément
model.export(format="engine", imgsz=640, half=True, workspace=2)

La compilation prend 10 à 20 minutes sur Orin Nano (plus rapide sur AGX). À la fin, un fichier best.engine apparaît, optimisé pour cette carte précise. Ne pas tenter de transférer ce .engine à une autre Jetson de modèle différent — il échouerait au chargement avec « Engine cannot be deserialized ».

Étape 5 — Lancer un benchmark d’inférence

Le moment de vérité : mesurer la latence et le throughput réels du modèle sur la carte. Ultralytics expose une commande de benchmark intégrée :

yolo benchmark model=./best.engine imgsz=640 half=True device=0

La sortie liste la latence par image (en ms) et le throughput (en FPS). Sur Orin Nano Super en mode MAXN_SUPER avec YOLO11s.engine FP16, l’ordre de grandeur attendu est 25-35 ms par image, soit 30-40 FPS sur flux 640×640. Avec YOLO11n, on monte à 80-100 FPS. Sur AGX Orin 64 Go, ces chiffres sont multipliés par 4 à 6.

Pour un test plus représentatif d’un cas d’usage réel (vidéo en temps réel), pointer la commande YOLO sur un fichier .mp4 ou un flux RTSP :

yolo predict model=./best.engine source='rtsp://camera-ip/stream1' show=True device=0

Si l’affichage tourne à 30 FPS sans saccade, vous tenez votre baseline de production.

Étape 6 — Surveiller la carte et la température

Le passage en mode MAXN_SUPER fait chauffer la Jetson. Pour une exécution 24/7, surveiller la température et l’utilisation GPU est indispensable. L’outil jtop (équivalent htop pour Jetson) affiche tout sur un seul écran :

sudo pip install jetson-stats
sudo systemctl restart jtop.service
jtop

L’interface affiche la consommation CPU, l’utilisation GPU, la VRAM, la température (CPU, GPU, board) et la consommation électrique. Pour un Orin Nano Super sous YOLO11s en boucle continue, la température GPU stable doit rester entre 50 et 70 °C selon la ventilation. Au-delà de 80 °C, la carte commence à throttler (ralentir pour préserver la silicium) et la latence remonte. Solution : ajouter un ventilateur ou passer en MAXN standard (mode 1) qui plafonne à 15 W au lieu de 25 W avec une perte de 20-30 % sur le throughput.

Cas qui posent problème

Symptôme	Diagnostic	Action
Carte qui ne boot pas après flash	Image SD corrompue ou inadaptée au modèle	Re-télécharger l’image .img.xz officielle correspondant exactement au modèle.
« Engine cannot be deserialized »	Engine compilé sur un GPU différent	Recompiler l’engine sur la Jetson cible.
PyTorch installé mais CUDA: False	Wheel CPU générique au lieu de la wheel Jetson	Désinstaller, suivre la doc NVIDIA pour la bonne URL.
Latence x2 par rapport au benchmark attendu	Mode d’alimentation pas en MAXN	`sudo nvpmodel -m 2 && sudo jetson_clocks`.
Throttling thermique au bout de 5 minutes	Dissipation insuffisante	Ajouter un ventilateur, ou repasser en MAXN standard.
Inférence vidéo qui saute des frames	Pré-traitement OpenCV non vectorisé qui sature le CPU	Utiliser `v4l2` ou GStreamer plutôt que `cv2.VideoCapture` brut.

Sur des sujets adjacents

Exporter YOLO v11 en ONNX et TensorRT — l’amont indispensable.
Servir YOLO v11 derrière une API FastAPI — variante serveur du même problème.
Surveiller la dérive d’un modèle en production — utile dès qu’une Jetson tourne 24/7.

Documentation et ressources

🔝 Vue d’ensemble : Pipeline YOLO v11
JetPack downloads : developer.nvidia.com/embedded/jetpack
NVIDIA Jetson Orin homepage : developer.nvidia.com/embedded/jetson-orin
Install PyTorch on Jetson : docs.nvidia.com/deeplearning/frameworks/install-pytorch-jetson-platform
jetson-stats / jtop : github.com/rbonghi/jetson_stats
Ultralytics on Jetson guide : docs.ultralytics.com/guides/nvidia-jetson

Avec une Jetson correctement configurée et un engine TensorRT validé, le déploiement edge est prêt. Reste à industrialiser la collecte de métriques d’inférence pour détecter à temps une éventuelle dégradation des performances.

Inférence YOLO v11 sur Jetson Orin : tutoriel pas-à-pas