Guide des jeux de données de détection de drones : entraîner Ultralytics YOLO sur de petits UAV

Le benchmark de détection et de suivi des UAV indique une taille moyenne de drone de 34 x 23 pixels dans les données Drone-vs-Bird. Imagine un drone de cette taille dans une image hypothétique de 3840 x 2160 : redimensionné aux 640 pixels utilisés par défaut par un détecteur, il ne mesurerait plus qu’environ 5,7 x 3,8 pixels.

Les équipes de lutte anti-drones doivent veiller à ce que l’objet reste visible, du jeu de données choisi jusqu’au modèle déployé. Ce guide aborde les quatre décisions à prendre avec Ultralytics YOLO26 : le jeu de données de détection de drones sur lequel entraîner le modèle, la taille d’image à utiliser, le moment où ajouter l’inférence par tuiles SAHI et la façon d’évaluer le modèle selon la taille des objets, afin qu’un bon mAP global ne masque pas les drones lointains manqués.

La plupart des « jeux de données de détection de drones » ne répondent pas à la bonne question#

Les personnes qui recherchent un jeu de données de détection de drones ont généralement l’un de ces deux objectifs :

• Détecter des drones (anti-UAV ou lutte anti-UAV) : une caméra au sol ou aérienne cherche un petit aéronef dans le ciel, parmi les arbres ou les bâtiments. Il te faut des images de drones, idéalement avec des oiseaux et d’autres objets qui leur ressemblent.
• Détecter à partir de drones : une caméra embarquée sur le drone observe les personnes, les voitures et les bâtiments au sol. VisDrone est le benchmark de référence pour cette tâche. Il contient 8 629 images aériennes réparties en 10 classes, du piéton au bus, et aucune classe « drone ».

VisDrone reste utile aux équipes de lutte anti-UAV, car ses objets sont petits et nombreux. C’est donc un bon jeu de données public pour tester les paramètres de détection des petits objets, comme la taille d’image et le découpage en tuiles, avant que tes propres données soient prêtes. Pour les applications aériennes elles-mêmes, consulte notre aperçu de la vision par ordinateur dans les opérations de drones. Le reste de cet article porte sur le premier objectif : détecter des drones.

Choisis un jeu de données adapté à ta caméra et à son point de vue#

Le bon jeu de données public dépend de l’emplacement de ta caméra, au sol ou dans les airs, du type d’images qu’elle enregistre, en lumière visible ou en infrarouge thermique, et de la distance à laquelle vole ton objet :

Le nombre de Drone-vs-Bird correspond au jeu d’entraînement de 77 séquences distribué pour les éditions 2021 et ICASSP 2023 du défi, dont les résolutions sont indiquées par l’étude SynDroneVision. Cette étude couvre également Det-Fly et Anti-UAV, et l’article sur LRDDv3 décrit son propre jeu de données. Les licences et les conditions d’accès varient d’un jeu de données à l’autre : vérifie-les avant tout usage commercial.

Entraîne le modèle sur plusieurs jeux de données et réserve-en un pour les tests#

Un modèle qui fonctionne bien sur le jeu de données utilisé pour son entraînement peut tout de même avoir des difficultés sur un autre jeu. Les auteurs de LRDDv3 ont entraîné des modèles Ultralytics YOLO11m sur différents jeux de données et les ont tous testés sur Det-Fly. Le modèle entraîné sur Drone-vs-Bird y a obtenu un mAP₅₀ de 0,484, et celui entraîné sur DUT Anti-UAV, un mAP₅₀ de 0,431.

Combine donc deux ou trois sources adaptées à ta caméra et à la distance de prise de vue, puis convertis-les toutes au format de détection YOLO. Réattribue ensuite les identifiants de classe de manière cohérente, complète les annotations d’oiseaux manquantes et sépare les données par vol ou par vidéo avant d’extraire les images ou les tuiles. Une séparation par image peut placer des images presque identiques d’un même vol à la fois dans les ensembles d’entraînement et de test, ce qui gonfle les scores. Réserve un jeu de données complet, ou des séquences filmées sur ton propre site, pour les tests et inclus des images avec uniquement des oiseaux et des images de ciel vide afin de mesurer les fausses alertes.

Annote les oiseaux autant que les drones#

Les oiseaux sont une source fréquente de fausses alertes dans la détection de drones par vision. Drone-vs-Bird contient des oiseaux comme distracteurs, mais ne les annote pas comme une classe : il faut donc ajouter ces boîtes dans un jeu de données à deux classes. Une étude de 2025 sur les petits drones a entraîné YOLO11m sur des classes « drone » et « oiseau », puis ignoré les prédictions d’oiseaux lors de l’inférence. Dans cette expérience, le modèle à deux classes détectait les drones légèrement mieux qu’un modèle entraîné uniquement sur les drones.

Les données publiques te donnent une référence, et tes propres séquences te permettent de passer en production. L’annotation dans Ultralytics Platform te permet d’annoter les boîtes des drones et des oiseaux sur les images de tes propres caméras, et les données synthétiques peuvent ajouter des arrière-plans et des angles rares. La solution classée première au défi Drone-vs-Bird d’AVSS 2021 utilisait un détecteur Ultralytics YOLOv5 affiné sur des images réelles et synthétiques, ainsi qu’un tracker à filtre de Kalman qui renforçait la confiance dans les détections de drones peu visibles et lointains.

La taille d’image détermine si le drone survit au redimensionnement#

YOLO26 redimensionne chaque image pour que son côté le plus long corresponde à imgsz, soit 640 par défaut. Un drone qui ne conserve presque aucun pixel après redimensionnement laisse peu de matière à exploiter au détecteur. Augmenter imgsz est la première mesure à prendre, et la documentation sur l’entraînement comme le guide d’affinage recommandent tous deux imgsz=1280 pour les jeux de données contenant de petits objets.

Le coût augmente à peu près proportionnellement au nombre de pixels : 1280 demande donc environ quatre fois plus de calcul que 640. À titre indicatif, la documentation YOLO26 indique 1,7 ms pour YOLO26n et 2,5 ms pour YOLO26s sur une NVIDIA T4, avec TensorRT 10, une taille de lot de 1 et nms=False, à une résolution de 640 pixels sur COCO val2017. Ces mesures ne concernent ni les drones ni les images de 1280 pixels : chronomètre ta propre configuration.

Une règle de départ utile vient de la leçon sur la latence d’Ultralytics Academy : une résolution mérite d’être testée si le plus petit objet important y couvre encore environ 10 pixels. Si le budget est limité, compare un modèle plus petit à résolution élevée avec un modèle plus grand à résolution plus faible sur le même jeu de validation de drones, puis garde celui qui détecte le plus de petits drones dans la limite de latence visée.

YOLO26 maintient les petits objets dans la sélection des candidats#

Même avec une taille d’image suffisante, le modèle doit encore apprendre à partir de petites boîtes. La fonction Small-Target-Aware Label Assignment (STAL) de YOLO26 est utile à cet égard. Dans les modèles YOLO26 standard P3 à P5 de la version v8.4.199, STAL agrandit à 16 pixels les côtés des boîtes de sélection des candidats qui mesurent moins de 16 pixels, tout en préservant les cibles de régression d’origine. Ainsi, les petits drones ont moins de risques de se retrouver sans ancres candidates.

Pour les plus petits objets, tu peux également modifier l’architecture. YOLO26 propose une variante yolo26-p2.yaml qui ajoute un niveau de sortie de stride 4 à la pyramide de caractéristiques, en plus de P3 à P5. Avec une entrée de 640 x 640, elle fait passer le calcul non fusionné de YOLO26n de 6,1 à 9,5 GFLOPs. P2 est fourni sous forme d’architecture YAML, sans poids P2 préentraînés : tu dois donc le construire avec YOLO("yolo26n-p2.yaml") et l’entraîner sur tes données.

L’inférence par tuiles SAHI préserve tous les détails des images 4K#

Même à 1280 pixels, une image 4K perd les deux tiers de sa largeur avant d’être traitée par le modèle. SAHI (inférence hyper précise assistée par découpage) s’intègre à Ultralytics YOLO26 pour éviter cette perte. La méthode découpe l’image en tuiles qui se chevauchent, exécute le modèle sur chaque tuile, puis reporte les boîtes sur l’image entière : un drone réparti sur deux tuiles voisines n’est donc compté qu’une fois. L’article sur SAHI décrit la méthode et sa variante d’affinage assisté par découpage.

Définis séparément la taille des tuiles et celle de l’entrée du modèle, puis vérifie l’échelle des drones obtenue sur des séquences mises de côté. Un modèle entraîné sur des images 4K complètes redimensionnées à 1280 a appris à détecter des drones trois fois plus petits que ceux présents dans des tuiles de 1280 pixels à la résolution native. Si cet écart d’échelle nuit aux résultats, essaie d’affiner le modèle sur des recadrages extraits de tes images d’entraînement en pleine résolution, comme dans l’article sur SAHI, puis compare-le au modèle entraîné sur des images complètes avec le même jeu de test. Commence par un chevauchement de 20 % entre les tuiles voisines et vérifie les détections manquées aux bords des tuiles.

La charge de calcul est prévisible. Avec des tuiles de 1280 x 1280 et un chevauchement de 0,2, une image de 3840 x 2160 nécessite quatre colonnes et deux rangées, soit huit passes avant au lieu d’une, à condition de désactiver la prédiction supplémentaire de SAHI sur l’image complète. Cette approche convient aux séquences enregistrées, à l’examen des alertes et aux GPU périphériques puissants. Pour une caméra qui doit traiter chaque image à la cadence maximale, découpe uniquement la partie du ciel, ou effectue des balayages périodiques par tuiles ou déclenche-les à partir d’un autre capteur, comme un radar.

Évalue ton détecteur par taille et par classe#

La précision moyenne (mAP) globale correspond à la moyenne de l’AP des classes. Dans ce jeu de données à deux classes, les performances sur les oiseaux peuvent masquer une détection médiocre des drones ; et, au sein de la classe des drones, un score global élevé peut masquer un faible rappel pour les plus petites catégories de taille. Analyse les scores par classe et par taille avant de leur faire confiance.

La validation avec save_json=True calcule l’AP des petits, moyens et grands objets pour les jeux de données de détection, à l’aide de faster-coco-eval et des catégories COCO : moins de 32 x 32 pixels de surface de boîte, jusqu’à 96 x 96, puis au-delà. Ces valeurs regroupent les deux classes. L’étude SynDroneVision indique que la plupart des drones annotés dans Drone-vs-Bird mesurent moins de 32 x 32 : surveille donc l’AP_small propre aux drones et le rappel.

Pour les obtenir, évalue predictions.json à partir d’annotations de référence correspondantes, en utilisant la surface des boîtes en pixels dans l’image d’origine. Ultralytics enregistre les boîtes dans les coordonnées de l’image d’origine, utilise le nom de base du fichier image comme identifiant d’image et numérote les classes personnalisées à partir de 1 : ici, le drone correspond donc à la catégorie 1 et l’oiseau à la catégorie 2. Convertis les étiquettes de test en JSON au format COCO avec les mêmes identifiants d’image et de catégorie, puis limite l’évaluation à catIds=[1].

La petite catégorie de COCO est trop large pour les applications à longue portée, puisqu’un drone de 12 pixels et un drone de 30 x 30 y appartiennent tous deux. Définis des plages de surface plus précises de la même manière, par exemple moins de 64 pixels (8 x 8), de 64 à 256 (16 x 16) et de 256 à 1 024 (32 x 32), puis relève l’AP et le rappel des drones pour chacune. Si tes annotations indiquent la distance, comme celles de LRDDv3, indique aussi le rappel par distance. Ajoute la précision, en comptant séparément les prédictions de drones dans les images avec uniquement des oiseaux et dans celles où le ciel est vide.

Deux habitudes permettent de garder des chiffres fiables :

• Valide à la résolution de déploiement. Un modèle entraîné à 1280 et validé à 640 voit les drones à une taille deux fois moindre que pendant l’entraînement : ses scores baissent donc pour des raisons sans rapport avec le modèle.
• Interprète le mAP_50-95 avec prudence. Un décalage de 2 pixels sur une boîte de 10 pixels représente une grande part de l’IoU : les seuils stricts pénalisent donc les petites cibles. Suis le rappel pour les drones manqués et l’AP₅₀ pour les détections correctement classées qui atteignent un IoU de 0,5.

Entraîne, découpe et évalue un détecteur de drones YOLO26#

Ces étapes te permettent de passer d’un jeu de données combinant drones et oiseaux à une comparaison de l’inférence sur images complètes et de l’inférence par tuiles, sur le même jeu de test mis de côté.

1. Installe les paquets avec pip install -U ultralytics sahi.

2. Écris un fichier YAML de jeu de données avec les oiseaux comme deuxième classe et une partition de test mise de côté :

path: datasets/drones
train: images/train
val: images/val
test: images/test
names:
  0: drone
  1: bird

1. Entraîne le modèle à 1280 à partir de poids préentraînés. batch=-1 permet à AutoBatch de choisir une taille de lot utilisant environ 60 % de la mémoire du GPU :

from ultralytics import YOLO

model = YOLO("yolo26s.pt")
model.train(data="drones.yaml", epochs=100, imgsz=1280, batch=-1, name="drone_1280")

1. Évalue la référence sur images complètes avec la partition de test à la même résolution. Cette opération écrit predictions.json dans le dossier d’exécution :

best = YOLO("runs/detect/drone_1280/weights/best.pt")
metrics = best.val(data="drones.yaml", split="test", imgsz=1280, save_json=True)

1. Exporte les prédictions par tuiles pour les mêmes images de test, dans les coordonnées des images d’origine, en désactivant la passe supplémentaire de SAHI sur l’image complète :

import json
from pathlib import Path

from sahi import AutoDetectionModel
from sahi.predict import get_sliced_prediction

detector = AutoDetectionModel.from_pretrained(
    model_type="ultralytics",
    model_path="runs/detect/drone_1280/weights/best.pt",
    confidence_threshold=0.001,
    image_size=1280,
    device="cuda:0",
)
preds = []
for img in sorted(Path("datasets/drones/images/test").glob("*.jpg")):
    result = get_sliced_prediction(
        str(img),
        detector,
        slice_height=1280,
        slice_width=1280,
        overlap_height_ratio=0.2,
        overlap_width_ratio=0.2,
        perform_standard_pred=False,
    )
    image_id = int(img.stem) if img.stem.isnumeric() else img.stem
    for p in result.to_coco_predictions(image_id=image_id):
        p["category_id"] += 1  # correspond aux identifiants à partir de 1 dans predictions.json
        preds.append(p)
Path("sahi_predictions.json").write_text(json.dumps(preds))

1. Évalue les deux fichiers de prédictions par rapport aux mêmes annotations de référence, pour la classe des drones uniquement :

from faster_coco_eval import COCO, COCOeval_faster

gt = COCO("test_coco.json")  # tes étiquettes de test au format COCO
for name in ["runs/detect/val/predictions.json", "sahi_predictions.json"]:
    ev = COCOeval_faster(gt, gt.loadRes(name), "bbox")
    ev.params.catIds = [1]  # drone
    ev.evaluate()
    ev.accumulate()
    ev.summarize()

Compare l’AP des drones par taille, les prédictions de drones dans les images avec uniquement des oiseaux ou un ciel vide, ainsi que la latence de bout en bout par image sur le matériel de déploiement. Ne conserve le découpage en tuiles que si le gain sur les petits drones justifie les passes supplémentaires.

1. Effectue le suivi entre les images avec cet exemple séparé sur image complète : best.track(source="perimeter.mp4", imgsz=1280, tracker="bytetrack.yaml") utilise le mode de suivi et ne consomme pas les prédictions SAHI ci-dessus. ByteTrack peut réactiver une piste perdue si une détection ultérieure lui correspond avant son expiration.

2. Exporte pour l’edge. Pour une NVIDIA Jetson installée au niveau de la caméra, exporte vers TensorRT avec best.export(format="engine", imgsz=1280, half=True) et suis le guide Jetson. Mesure la latence sur l’appareil à la résolution de déploiement.

Si ton GPU ne peut pas gérer l’entraînement à 1280 pixels, tu peux exécuter le même jeu de données et les mêmes arguments en entraînement dans le cloud sur Ultralytics Platform.

À qui s’adresse cette méthode de création d’un détecteur de drones#

Ce flux de travail convient aux équipes qui protègent un site fixe, comme le périmètre d’un aéroport, une prison, un stade ou une infrastructure critique, à l’aide de caméras RGB ou thermiques qui surveillent le ciel. Il convient aussi aux intégrateurs qui ajoutent la vision à des capteurs radar ou RF dans des déploiements de sécurité. Dans les deux cas, la caméra doit reconnaître un drone à des distances où celui-ci ne couvre que quelques dizaines de pixels.

Commence avec DUT Anti-UAV et Drone-vs-Bird pour établir une référence, ajoute des annotations d’oiseaux et tes propres séquences, entraîne YOLO26 à 1280, puis évalue chaque changement selon l’AP_small propre aux drones, le rappel et les fausses alertes causées par les oiseaux. Ajoute SAHI pour les images 4K ou plus grandes si ton évaluation par tuiles montre un gain sur les petits drones. Pour aborder le problème dans son ensemble, consulte notre guide sur la détection des petits objets et la liste de vérification du mAP des petits objets.