Détection d’avions militaires sur des images et vidéos à l’aide de YOLOv8

Introduction

Dans ce projet, j’ai utilisé un modèle YOLOv8 pour détecter et classifier les avions militaires sur des images et des vidéos. L’objectif est de montrer la puissance de l’Object Detection dans le domaine de la Computer Vision, en particulier pour la reconnaissance d’objets complexes et en mouvement, et notament pour des objets ayant des caractéristiques similaires comme les avions militaires.

Le notebook associé à ce projet est disponible sur ce lien Kaggle.

YOLOv8

YOLOv8 est un modèle d’Object Detection basé sur le réseau de neurones YOLO (You Only Look Once). Il s’agit de la huitième version de ce modèle, qui a été amélioré pour être plus rapide et plus précis que ses prédécesseurs. Développé par Ultralytics, YOLOv8 offre des améliorations significatives en termes de précision et de vitesse par rapport à ses prédécesseurs.

En utilisant YOLOv8, ce projet vise à démontrer comment les technologies modernes de vision par ordinateur peuvent être appliquées efficacement pour la détection d’objets spécifiques dans des images et des vidéos, contribuant ainsi à des domaines tels que la sécurité et la surveillance aérienne.

Dataset

Nous disposons d’un riche ensemble de données comprenant 14 500 images, chacune contenant un ou plusieurs avions. Pour chaque image, un fichier CSV associé fournit des annotations détaillées des avions présents, incluant les coordonnées de leurs positions (xmin, ymin, xmax, ymax) ainsi que leur classification.

Exemple d’Images du Dataset

Voici quelques exemples d’images du dataset utilisé pour entraîner et tester le modèle YOLOv8, avec leurs annotations correspondantes :

Cette image montre un avion C5 Galaxy, un avion de transport militaire lourd utilisé par l’US Air Force. Les avions militaires peuvent avoir des formes et des tailles variées, ce qui rend leur détection et classification difficiles pour les modèles d’Object Detection.

Cette image montre un avion Mirage 2000 qui est un avion de chasse conçu par la société française Dassault Aviation, à la fin des années 1970. Le Mirage 2000 est principalement utilisé par l’Armée de l’Air française qui en a reçu 315 exemplaires, tandis que 286 autres ont été exportés vers huit pays différents.

Dans le set de données, il y a tous types d’images, des images plus ou moins claires, des images avec un ou plusieurs avions, d’autres avec des avions de différentes classes, etc. Cela permet de tester la capacité du modèle à détecter et classifier les avions dans des contextes variés.

Entrainement du modèle

Pour entrainer un modèle YOLOv8, il est essentiel de disposer d’un ensemble de données étiquetées, qui servira de base pour l’apprentissage du modèle. Dans ce projet, nous avons utilisé un ensemble de données comprenant 14 500 images d’avions militaires, chacune étant annotée avec les coordonnées des avions présents et leur classification.

Train Validation Test Split

Avant de commencer l’entraînement, nous avons divisé notre ensemble de données en trois parties distinctes : un ensemble d’entraînement (70%), un ensemble de validation (15%) et un ensemble de test (15%). Cette division nous permet de vérifier la performance du modèle sur des données inédites et de s’assurer qu’il généralise bien aux images qu’il n’a pas encore vues.

graph TD
    B1 -->|70%| B[Ensemble d'entraînement]
    C1 -->|15%| C[Ensemble de validation]
    D1 -->|15%| D[Ensemble de test]

    subgraph Ensemble de données
        direction LR
        B1[████████████████████████████████████████████████████████████████████████████████████████████████████████]
        C1[██████████████████]
        D1[██████████████████]
    end

Etapes de l’Entrainement

1. Configuration du Modèle

Un fichier de configuration YAML est créé pour spécifier :

• Les chemins vers les ensembles d’entraînement, de validation et de test.
• Le nombre de classes à détecter.
• Les noms des classes.

1
2
3
4
5
train: ../data/train.txt
val: ../data/val.txt
test: ../data/test.txt
nc: 3
names: ['F35', 'JAS39', 'B52']

2. Architecture du Modèle

YOLOv8 utilise une architecture de réseau de neurones convolutifs (CNN) avec plusieurs couches :

• Convolutionnelles : Pour extraire les caractéristiques des images.
• Couches d’activation : Pour introduire la non-linéarité.
• Couches de mise en commun (pooling) : Pour réduire la dimensionnalité.
• Couches de prédiction : Pour générer les prédictions des boîtes englobantes et des classes.

Chaque couche est conçue pour capturer des informations spécifiques des images et les combiner pour produire des prédictions précises.

3. Processus d’Entraînement

Pendant l’entraînement, le modèle passe par les étapes suivantes :

• Propagation avant : L’image passe à travers les couches du modèle, produisant des prédictions.
• Calcul de la perte : La différence entre les prédictions et les annotations réelles est calculée. La fonction de perte de YOLO combine les erreurs de classification, de localisation des boîtes et des objets manquants.
• Propagation arrière : Les gradients de la perte sont calculés et utilisés pour mettre à jour les poids du modèle via l’algorithme de descente de gradient.
• Validation : Après chaque epoch, le modèle est évalué sur l’ensemble de validation pour ajuster les hyperparamètres et éviter le surapprentissage.

Validation du Modèle

Après l’entraînement, le modèle est évalué sur l’ensemble de test pour mesurer sa performance. Les métriques suivantes sont utilisées pour évaluer la qualité des prédictions :

• Box(P): Précision des détections des boîtes englobantes.
• R: Rappel, mesure de la capacité du modèle à retrouver toutes les instances pertinentes.
• mAP50: Mean Average Precision à 50% IoU (Intersection over Union), mesure la précision moyenne à un seuil de 50% d’IoU.
• mAP50-95: Mean Average Precision à différents seuils d’IoU, de 50% à 95%.

Ces métriques permettent d’évaluer la capacité du modèle à détecter et classifier les avions militaires avec précision et rappel, tout en minimisant les fausses détections et les faux négatifs.

1
2
3
4
5
6
!yolo val \
model='/kaggle/input/yolov7-military-plane/yolov8-m-best.pt' \
data='/kaggle/working/ultralytics/data/mad.yaml'\
augment \
batch=12 \
imgsz=1280

Ce code est utilisé pour évaluer le modèle sur l’ensemble de validation, en utilisant le modèle entraîné et les paramètres spécifiés dans le fichier de configuration YAML.

Voici les résultats de l’évaluation du modèle sur l’ensemble de validation :

Test du modèle sur des images

Test sur dataset test

Après l’entraînement et la validation du modèle, nous pouvons le tester sur des images réelles pour évaluer sa performance en conditions réelles. Voici un exemple de code pour tester le modèle sur quelques images du dataset test :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
from ultralytics import YOLO
import cv2
import matplotlib.pyplot as plt
import glob
import random
import pandas as pd

# Charger le modèle YOLO
model = YOLO('/kaggle/input/yolov7-military-plane/yolov8-m-best.pt')

# Chemins vers les images et annotations de test
test_image_paths = sorted(glob.glob('/kaggle/working/ultralytics/data/test/images/*.jpg'))
test_annotation_paths = sorted(glob.glob('/kaggle/working/ultralytics/data/test/labels/*.txt'))

# Sélectionner quelques images aléatoires
sampled_indices = random.sample(range(len(test_image_paths)), 5)
sampled_image_paths = [test_image_paths[i] for i in sampled_indices]
sampled_annotation_paths = [test_annotation_paths[i] for i in sampled_indices]

# Faire des prédictions sur les images sélectionnées
results = model(sampled_image_paths)

for img_path, ann_path, result in zip(sampled_image_paths, sampled_annotation_paths, results):
    image = cv2.imread(img_path)[:, :, ::-1]
    plt.figure(figsize=(10, 10))
    plt.imshow(image)
    ax = plt.gca()

    # Lire et afficher les annotations réelles
    with open(ann_path, 'r') as f:
        annotations = f.readlines()
    
    print(f"Annotations réelles pour {img_path}:")
    for annotation in annotations:
        class_num, x_center, y_center, b_width, b_height = map(float, annotation.split())
        class_name = model.names[int(class_num)]
        print(f"Classe: {class_name}")

    # Afficher les prédictions du modèle
    for box in result.boxes:
        x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()  # Déplacer les tenseurs vers la CPU et les convertir en numpy
        rect = plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, color='red')
        ax.add_patch(rect)
        plt.text(x1, y1, model.names[int(box.cls[0])], color='white', fontsize=12, bbox=dict(facecolor='red', alpha=0.5))

    plt.axis('off')
    plt.show()

Ce code charge le modèle YOLOv8 entraîné, sélectionne quelques images aléatoires du dataset test, fait des prédictions sur ces images et affiche les résultats. Les annotations réelles sont également affichées dans des prints pour comparer les prédictions du modèle avec les vérités terrain.

Test sur images réelles

En plus des images du dataset test, nous pouvons également tester le modèle sur des images hors échantillon pour évaluer sa capacité à généraliser à de nouvelles données. J’ai choisi une image de Rafale sur google image pour tester le modèle.

Voici l’image de Rafale utilisée pour le test et la prédiction du modèle :

On peut voir que le modèle a correctement détecté et classifié les deux avions Rafale dans l’image, avec des boîtes englobantes précises et des prédictions de classe correctes.

Test du modèle sur des vidéos

En plus des images, le modèle YOLOv8 peut également être utilisé pour détecter des avions dans des vidéos. J’ai testé le modèle sur une vidéo de présentation du Rafale sur YouTube. Voici le lien de la vidéo : Rafale Video

Après avoir téléchargé la vidéo, j’ai extrait des images de la vidéo à intervalles réguliers et utilisé le modèle YOLOv8 pour détecter les avions dans chaque image. Voici un exemple de code pour détecter les avions dans une vidéo :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import cv2
import numpy as np
from ultralytics import YOLO

F22_video_path = "/kaggle/input/videos/F-22 Raptor with Wall of Fire - Dayton Air Show 72323.mp4"

def process_video(video_path, output_path):
    cap = cv2.VideoCapture(video_path)
    
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = int(cap.get(cv2.CAP_PROP_FPS))
    new_width = 640
    new_height = int(new_width * height / width)

    fourcc = cv2.VideoWriter_fourcc(*'VP90')  # mp4v pour un format mp4
    out = cv2.VideoWriter(output_path, fourcc, fps, (new_width, new_height))

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        
        resized_frame = cv2.resize(frame, (new_width, new_height))

        results = model(resized_frame)

        annotated_frame = results[0].plot()

        out.write(annotated_frame)

    cap.release()
    out.release()

output_path = '/kaggle/working/annotated_F22_video.mp4'

process_video(F22_video_path, output_path)

Voici un exemple de la vidéo annotée avec les détections de YOLOv8 :

La vidéo montre les détections de YOLOv8 sur la vidéo de présentation du Rafale, avec des boîtes englobantes et des prédictions de classe pour chaque avion détecté. Le modèle est capable de détecter les avions en mouvement dans la vidéo, démontrant sa capacité à traiter des séquences vidéo en temps réel.

Cependant, nous pouvons observer que le modèle a parfois des difficultés à détecter les avions lorsqu’ils sont partiellement cachés ou vus de dos. Par exemple, dans la vidéo, le modèle a du mal à détecter les avions Rafale lorsqu’ils sont vus de dos, il a tendance à les confondre avec d’autres avions, notamment avec l’EF2000 et le Tornado.

Cela souligne l’importance de la qualité des données d’entraînement et de la diversité des exemples pour améliorer la performance du modèle dans des conditions variées.

Nous pouvons essayer le modèle sur une autre vidéo où la visibilité des avions est moins bonne pour voir si le modèle arrive à les détecter.

Ceci est un exemple de vidéo annotée avec les détections de YOLOv8 sur une vidéo de présentation du F22. Le modèle a plutôt bien réussi à détecter l’avion dans la vidéo, mais il a rencontré des difficultés à classifier l’avion correctement. Il semble que le modèle ait confondu le F22 avec d’autres avions, notamment le F35. Cela peut être dû à des similitudes dans les caractéristiques visuelles des avions ou à des variations dans les données d’entraînement.

Conclusion

Dans ce projet, j’ai utilisé un modèle YOLOv8 pour détecter et classifier les avions militaires sur des images et des vidéos. Le modèle a été entraîné sur un ensemble de données comprenant 14 500 images d’avions militaires, avec des annotations détaillées pour chaque image.

Après l’entraînement et la validation, le modèle a montré de solides performances en termes de précision et de rappel, avec des scores élevés pour la plupart des classes d’avions. Les tests sur des images et des vidéos réelles ont également démontré que le modèle est capable de détecter les avions dans des conditions variées, bien qu’il puisse parfois rencontrer des difficultés avec des avions partiellement cachés ou lorsqu’ils sont capturés sous des angles inhabituels.