Rapport sur le Traitement

d’Images
Détection d’Objets avec YOLO

Réalisé par :
LAKHAL HALA
MALEK SAMI

Encadré par :
Pr. HAMMOUCH

Année Universitaire : 2024/2025

ENSAM RABAT
INDIA-2
 Table des Matières
1 Les filtres en traitement d’images 3

2 Filtres dans les CNN (Convolutional Neural Networks) 3

2.1 Types de filtres utilisés dans les CNN . . . . . . . . . . . . . . 4
2.2 Contexte d’utilisation . . . . . . . . . . . . . . . . . . . . . . . 4

3 Filtres dans YOLO (You Only Look Once) 5

3.1 Types de filtres utilisés dans YOLO . . . . . . . . . . . . . . . 5
3.2 Contexte d’utilisation . . . . . . . . . . . . . . . . . . . . . . . 5

4 Les CNN et l’utilisation des filtres 6

5 Introduction aux algorithmes avancés 6

5.1 RCNN (Region-based Convolutional Neural Networks) . . . . 6
5.2 Fast RCNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5.3 Faster RCNN . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
5.4 YOLO (You Only Look Once) . . . . . . . . . . . . . . . . . . 7

6 YOLO et son utilisation dans le projet 7

6.1 YOLO v8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
6.2 Application dans le projet . . . . . . . . . . . . . . . . . . . . 7
6.3 Pourquoi YOLO pour ce projet ? . . . . . . . . . . . . . . . . 8

7 Explication de l’Architecture et des Fichiers du Projet Object-

Detection-Yolo 8
7.1 Structure des fichiers et des dossiers . . . . . . . . . . . . . . . 8
7.2 Explication des scripts . . . . . . . . . . . . . . . . . . . . . . 9
7.2.1 [Link] . . . . . . . . . . . . . . . . . . . . . . . . . . 9
7.2.2 predict_images.py . . . . . . . . . . . . . . . . . . . . 11
7.2.3 predict_videos.py . . . . . . . . . . . . . . . . . . . . . 12
7.2.4 predict_gifs.py . . . . . . . . . . . . . . . . . . . . . . 14
7.2.5 assemble_results.py . . . . . . . . . . . . . . . . . . . . 14
7.2.6 affichage_results.py . . . . . . . . . . . . . . . . . . . . 15
7.3 Fichier de configuration [Link] . . . . . . . . . . . . . . . 15
7.4 Analyse d’Entraînements (Après 32 epochs) . . . . . . . . . . 16

1
 7.4.1 Courbe de Précision . . . . . . . . . . . . . . . . . . . 16
7.4.2 Courbe de Rappel . . . . . . . . . . . . . . . . . . . . . 17
7.4.3 Courbe de Perte pour la Localisation des Boîtes (Box_Loss) 18
7.4.4 Courbe de Perte pour la Classification (Cls_Loss) . . . 19
7.4.5 Matrice de Confusion . . . . . . . . . . . . . . . . . . . 20
7.4.6 Courbe Precision-Recall . . . . . . . . . . . . . . . . . 22
7.5 Analyse des Prédictions : val_batch1_labels et val_batch1_pred 23
7.5.1 Tester des Nouvelles images: . . . . . . . . . . . . . . . 25
7.6 Flux de travail . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2
Introduction
Le traitement d’images est une branche fondamentale de l’intelligence ar-
tificielle, largement utilisée dans divers domaines comme la surveillance, la
reconnaissance faciale, et l’agriculture intelligente. Dans ce projet, nous nous
intéressons à la détection d’objets appliquée à trois classes spécifiques : les
oranges, les pommes, et les fraises. Pour cela, nous avons choisi l’algorithme
YOLO (You Only Look Once), connu pour sa rapidité et sa précision.

1 Les filtres en traitement d’images

Les filtres sont des matrices appliquées sur les images pour extraire des car-
actéristiques spécifiques telles que les contours, les textures ou les couleurs.
Voici les types de filtres couramment utilisés :

• Filtres passe-haut : Utilisés pour détecter les contours et les détails

fins.

• Filtres passe-bas : Lissent les images en réduisant le bruit.

• Filtres de Sobel : Détectent les gradients dans les images.

En appliquant ces filtres, nous pouvons préparer les images pour des
analyses plus avancées, telles que leur passage à travers un réseau neuronal
convolutif (CNN).

2 Filtres dans les CNN (Convolutional Neural

Networks)
Les CNN sont utilisés principalement pour le traitement d’images et de
données structurées spatialement, comme les vidéos. Les filtres dans un
CNN effectuent des opérations de convolution, où chaque filtre “passe” sur
une région locale de l’entrée pour produire une carte de caractéristiques.

3
2.1 Types de filtres utilisés dans les CNN
• Filtres de détection de caractéristiques (Feature detectors) :
Ces filtres sont conçus pour détecter des caractéristiques spécifiques
dans les images, comme les bords, les textures, et les motifs.

– Exemple de filtres classiques :

∗ Sobel filter : utilisé pour détecter les bords verticaux et hori-
zontaux dans une image.
∗ Prewitt filter : également utilisé pour détecter les bords, mais
de manière légèrement différente de Sobel.
∗ Gabor filter : souvent utilisé pour la détection de textures et
de motifs.
• Filtres convolutifs pour l’extraction de caractéristiques : Ces
filtres apprennent directement à extraire des caractéristiques perti-
nentes lors de l’entraînement du réseau. Ils sont initialisés avec des
valeurs aléatoires et sont ajustés au fil de l’entraînement.

– Exemples :
∗ Filtres 3x3 ou 5x5 : les tailles de filtres les plus courantes dans
les CNN modernes. Ils permettent de capturer des relations
locales à différentes échelles.
• Filtres de réduction de dimensions (Pooling) : Utilisés dans les
couches de pooling (max pooling, average pooling), ces filtres sont re-
sponsables de la réduction de la taille des cartes de caractéristiques
pour diminuer le nombre de paramètres et augmenter l’invariance aux
petites translations.

– Max Pooling : sélectionne le maximum d’une région locale.

– Average Pooling : prend la moyenne d’une région locale.

2.2 Contexte d’utilisation

Les CNN sont principalement utilisés pour des tâches de classification d’images,
détection d’objets, segmentation, etc. Les filtres dans un CNN permettent
de capturer des relations spatiales entre les pixels, ce qui est essentiel pour
l’extraction de caractéristiques locales et globales d’une image.

4
3 Filtres dans YOLO (You Only Look Once)
YOLO est un algorithme avancé de détection d’objets en temps réel. Il
divise une image en une grille et prédit les objets présents ainsi que leurs
emplacements en une seule passe (d’où le nom “You Only Look Once”).

3.1 Types de filtres utilisés dans YOLO

• Filtres convolutifs (Convolutional filters) : YOLO utilise un
réseau de type CNN pour extraire les caractéristiques d’une image. Ces
filtres convolutifs sont responsables de l’extraction des caractéristiques
locales et de la détection des objets à différentes échelles.

• Filtres de détection multi-échelle : Les modèles modernes de YOLO,

comme YOLOv3, utilisent des filtres multi-échelles pour détecter des
objets de différentes tailles. Cela permet de mieux gérer la détection
des objets petits et grands.

– Par exemple, les objets plus petits peuvent être détectés avec des
filtres sur des cartes de caractéristiques de plus petite taille (plus
proches de l’entrée), tandis que des objets plus grands sont détec-
tés sur des cartes de caractéristiques plus grandes (plus profondes
dans le réseau).

• Filtres d’ancrage (Anchor boxes) : Bien que les anchor boxes ne

soient pas techniquement des filtres dans le sens classique, elles jouent
un rôle similaire dans la détection d’objets. Elles permettent à YOLO
de prédire plusieurs boîtes englobantes pour chaque grille.

– Chaque ancrage est associé à un ensemble de prédictions de

filtres qui dépendent de l’échelle et de la forme des objets attendus
dans cette région.

3.2 Contexte d’utilisation

YOLO est utilisé pour la détection d’objets en temps réel. Les filtres con-
volutifs extraits par YOLO permettent d’analyser l’image, de localiser des
objets et de prédire leur catégorie en une seule passe, ce qui est plus rapide
que les méthodes traditionnelles de détection d’objets comme R-CNN.

5
4 Les CNN et l’utilisation des filtres
Un réseau neuronal convolutif (CNN) est conçu pour analyser les données
visuelles. Voici comment les filtres sont utilisés dans ce contexte :

1. Convolution : Un filtre glisse sur l’image et calcule un produit scalaire

entre les poids du filtre et les pixels correspondants. Cela génère une
carte d’activations qui met en évidence les caractéristiques importantes.

• Exemple : Un filtre de Sobel appliqué sur une image de pomme

permet de détecter les contours de l’objet.

2. ReLU (Rectified Linear Unit) : Une fonction d’activation qui sup-

prime les valeurs négatives, augmentant ainsi la non-linéarité.

3. Pooling : Réduit la dimensionnalité des cartes d’activations en ré-

sumant les informations importantes (max-pooling ou average-pooling).

Dans notre contexte, les CNN sont également utilisés pour apprendre les
caractéristiques distinctives des oranges, des pommes et des fraises à partir
d’images annotées.

5 Introduction aux algorithmes avancés

5.1 RCNN (Region-based Convolutional Neural Net-
works)
Principe : RCNN propose des régions d’intérêt (ROI) et applique un CNN
à chaque région pour classifier les objets.
Inconvénients : Lent, car il traite chaque région séparément.

5.2 Fast RCNN

Améliorations : Partage les calculs des convolutions entre les régions, ré-
duisant ainsi le temps de calcul.

6
5.3 Faster RCNN
Améliorations : Introduit un Réseau de Propositions de Régions (RPN)
pour générer les ROI de manière efficace.

5.4 YOLO (You Only Look Once)

Principe : YOLO traite une image complète en un seul passage, prédisant
à la fois les classes et les positions des objets.
Avantages : Rapidité et adaptabilité à des applications en temps réel.

6 YOLO et son utilisation dans le projet

6.1 YOLO v8
YOLO v8 est la dernière version de la famille YOLO, améliorée pour offrir
des performances supérieures en termes de vitesse et de précision. Voici ses
éléments clés :

• Architecture : Inclut des modules comme les CSP (Cross Stage

Partial Networks) et PANet (Path Aggregation Network) pour une
meilleure représentation des caractéristiques.

• Métriques : Offre des scores élevés en mAP (mean Average Precision)

sur des benchmarks standard.

6.2 Application dans le projet

1. Annotation des données : Les images d’oranges, de pommes et de
fraises sont annotées avec leurs bounding boxes.

2. Entraînement du modèle : Le modèle YOLO v8 est entraîné sur

ces images pour apprendre les caractéristiques des trois classes.

3. Inférence : Une fois entraîné, le modèle peut détecter et classifier les

fruits en temps réel avec une précision élevée.

7
6.3 Pourquoi YOLO pour ce projet ?
• Rapide : Convient à une utilisation en temps réel, comme dans les
chaînes de production agroalimentaires.
• Efficace : Détecte plusieurs classes dans une seule image avec un com-
promis optimal entre précision et vitesse.

7 Explication de l’Architecture et des Fichiers

du Projet Object-Detection-Yolo
7.1 Structure des fichiers et des dossiers
Votre projet semble être une application d’Object Detection utilisant le
modèle YOLO (You Only Look Once) pour détecter des objets dans dif-
férentes formes de médias (images, vidéos, GIFs). Voici une vue d’ensemble
de l’architecture de votre projet :

Object-Detection-Yolo/
|
+-- [Link] # Script principal pour
l’entraînement du modèle YOLO
+-- [Link] # Fichier de configuration
|
+-- videos/ # Dossier contenant les vidéos
| +-- vid6.mp4 # Exemple de vidéo à traiter
|
+-- Test/
| +-- test/ # Dossier pour les images à traiter

| +-- gifs/ # Sous-dossier pour les GIFs à traiter

| +-- results of test/ # Sous-dossier contenant les résultats

| +-- gifs/ et GIFs

+-- runs/ # Dossier contenant les résultats de l’entraînement

| +-- detect/

8
| +-- train13/
| +-- weights/ # Poids du modèle YOLO pour
| +-- [Link]
| +-- [Link]
| +-- [Link]
|
| +-- [Link] # Fichier CSV contenant les résultats (d’entraînemen
| +-- train_batch0.log # Logs des lots d’entraînement
(batch0, batch1, etc.)
| +-- train_batch1.log
| +-- train_batch2.log
| +-- val/ # Résultats de test(confusion_matrix)
| +-- combined_resluts.csv/ # rassemble tous les résultats
+-- outputs
| +-- metrics # l’affichage (plots) des metrics de test
| +-- train # l’affichage (plots) des erreurs loss de test
| +-- val # l’affichage (plots) des erreurs loss de validation

+-- predict_images.py # Script pour prédire des objets dans des images
+-- predict_videos.py # Script pour prédire des objets dans des vidéos
+-- predict_gifs.py # Script pour prédire des objets dans des GIFs
+-- assemble_results.py # Scipt pour rassembler tous les résultats de train
+-- affichage_results.py # Scipt pour afficher tous les résultats de train

7.2 Explication des scripts

7.2.1 [Link]
Le fichier [Link] charge et entraîne un modèle YOLO. Le modèle est chargé
à partir des poids enregistrés dans le fichier [Link] dans le dossier
runs/detect/train13/weights/. Ensuite, il utilise les données définies
dans [Link] pour entraîner le modèle pendant 21 époques, avec un
enregistrement des poids tous les 3 époques.

9
Rôle dans l’architecture du projet :
Le script [Link] est responsable de l’entraînement du modèle YOLOv8 sur
un jeu de données personnalisé. Il utilise la bibliothèque Ultralytics YOLO
pour entraîner un modèle de détection d’objets en spécifiant un fichier de
configuration et des hyperparamètres tels que le nombre d’époques.

Bibliothèques importantes :
• ultralytics: Fournit des outils pour le modèle YOLOv8 (entraînement,
prédiction, validation).

Exemple de code :
from ultralytics import YOLO

# Charger un m o d l e p r c o n f i g u r YOLOv8 ou des poids

existants
model = YOLO ( " yolov8n . yaml " ) # C r e r un m o d l e
partir de z r o
# model = YOLO (" runs / detect / train13 / weights / epoch15 . pt ")
# Charger des poids e n t r a n s

# E n t r a n e r le m o d l e
results = model . train (
data = " config . yaml " , # Fichier de configuration avec
chemins des images et labels
epochs =21 , # Nombre d ’ poques
save_period =3 # Sauvegarder les poids tous les
3 epochs
)

Explication :
• YOLO : La classe permet de créer un modèle YOLO ou de charger des
poids entraînés.

• train() : Cette méthode lance l’entraînement. Les paramètres impor-

tants sont :

10
 – data : Chemin vers le fichier YAML qui spécifie les chemins des
images (train/validation).
– epochs : Nombre total de cycles d’entraînement.
– save_period : Fréquence de sauvegarde des poids.

7.2.2 predict_images.py
Le fichier predict_images.py prend des images dans un répertoire et ap-
plique le modèle YOLO préalablement entraîné pour détecter des objets dans
chaque image.
Fonctionnalités :

• Charger une image à partir du chemin spécifié.

• Appliquer le modèle YOLO pour détecter des objets avec une confiance
minimale de 30%.

• Dessiner des rectangles autour des objets détectés et ajouter des éti-
quettes avec des scores de confiance.

• Sauvegarder les images annotées dans un répertoire de sortie spécifié.

Ce script utilise cv2 pour manipuler les images et ajouter les annotations.

Bibliothèques importantes :
• ultralytics : Pour la prédiction avec YOLO.

• cv2 (OpenCV) : Pour lire, modifier et sauvegarder des images.

• os : Gestion des fichiers et répertoires.

Exemple de code :
from ultralytics import YOLO
import cv2
import os

# Charger le m o d l e YOLO
model = YOLO ( " runs / detect / train13 / weights / epoch15 . pt " )

11
def predict_and_save ( image_path , output_dir ) :
img = cv2 . imread ( image_path )
results = model . predict ( source = image_path , conf =0.3)
# Seuil de confiance 30%

for box in results [0]. boxes :

x1 , y1 , x2 , y2 = map ( int , box . xyxy [0]. tolist () )
label = model . names [ int ( box . cls [0]) ]
confidence = box . conf [0]
cv2 . rectangle ( img , ( x1 , y1 ) , ( x2 , y2 ) , (0 , 255 ,
0) , 2)
text = f " { label } ␣ { confidence :.2 f } "
cv2 . putText ( img , text , ( x1 , y1 - 10) , cv2 .
FONT_HERSHEY_SIMPLEX , 0.5 , (0 , 0 , 0) , 1)

os . makedirs ( output_dir , exist_ok = True )

cv2 . imwrite ( os . path . join ( output_dir , f " pred_ { os . path .
basename ( image_path ) } " ) , img )

Explication :
• [Link]() : Génère des prédictions pour l’image spécifiée.
• [Link]() : Dessine une boîte autour de l’objet détecté.
• [Link]() : Ajoute le nom de la classe et la confiance sur l’image.

7.2.3 predict_videos.py
Le fichier predict_videos.py traite des vidéos. Il ouvre une vidéo à partir
du dossier videos/, puis pour chaque frame de la vidéo, il applique le modèle
YOLO pour détecter des objets. Les objets détectés sont marqués par des
rectangles et des étiquettes, puis la vidéo annotée est sauvegardée.
Fonctionnalité : Traitement vidéo par vidéo frame par frame.
Sortie : Une nouvelle vidéo avec les annotations des objets détectés.

Bibliothèques importantes :
• ultralytics : Détection d’objets.

12
 • cv2 : Gestion des flux vidéo.

Exemple de code :
cap = cv2 . VideoCapture ( " videos / vid6 . mp4 " )
model = YOLO ( " runs / detect / train13 / weights / epoch15 . pt " )
out = cv2 . VideoWriter ( " output . mp4 " , cv2 .
VideoWriter_fourcc (* ’ MP4V ’) , 30 , (1920 , 1080) )

while True :
ret , frame = cap . read ()
if not ret :
break
results = model ( frame ) [0]

for x1 , y1 , x2 , y2 , score , class_id in results . boxes .

data . tolist () :
if score > 0.5:
cv2 . rectangle ( frame , ( int ( x1 ) , int ( y1 ) ) , ( int
( x2 ) , int ( y2 ) ) , (0 , 255 , 0) , 4)
cv2 . putText ( frame , results . names [ int ( class_id
) ] , ( int ( x1 ) , int ( y1 - 10) ) ,
cv2 . FONT_HERSHEY_SIMPLEX , 1 , (0 ,
255 , 0) , 2)

out . write ( frame )

cap . release ()
out . release ()

Explication :
• Flux vidéo : Le script lit les images image par image à partir de la
vidéo.

• model() : Applique la détection sur chaque image.

• [Link] : Crée un fichier vidéo pour sauvegarder les résul-

tats.

13
7.2.4 predict_gifs.py
Le fichier predict_gifs.py fonctionne de manière similaire à predict_videos.py,
mais il traite des GIFs. Il ouvre chaque GIF, puis pour chaque image dans
le GIF, il applique le modèle YOLO pour détecter des objets et ajoute les
annotations.
Fonctionnalité : Traitement des GIFs frame par frame.
Sortie : Un GIF annoté avec les objets détectés.

7.2.5 assemble_results.py

Rôle dans l’architecture :

Ce script compile les métriques de plusieurs sessions d’entraînement en un
seul fichier CSV.

Bibliothèques importantes :
• pandas : Manipulation de données.

• os : Gestion des fichiers.

Exemple de code :
import pandas as pd
import os

train_dirs = [ f " runs / detect / train { i } " for i in range (7 ,

14) ]
dfs = [ pd . read_csv ( os . path . join (d , " results . csv " ) ) for d
in train_dirs if os . path . exists ( d ) ]

combined_df = pd . concat ( dfs , ignore_index = True )

combined_df . to_csv ( " runs / detect / combined_results . csv " ,
index = False )

14
7.2.6 affichage_results.py

Rôle dans l’architecture :

Ce script génère des graphiques pour analyser les performances du modèle.

Exemple de code :
import matplotlib . pyplot as plt

class AffichageResults :
def __init__ ( self , results_df ) :
self . results_df = results_df

def plot_metrics ( self ) :

for metric in [ " train / box_loss " , " metrics / mAP50 "
]:
plt . plot ( self . results_df [ " epoch " ] , self .
results_df [ metric ])
plt . title ( f " { metric } ␣ over ␣ epochs " )
plt . savefig ( f " outputs /{ metric }. png " )

Explication :
• Courbes de perte et mAP : Pour suivre les progrès du modèle.

• Matrice de confusion : Évaluation des erreurs de classification.

7.3 Fichier de configuration [Link]

Ce fichier définit la structure contient la configuration des données en spé-
cifiant les chemins vers les répertoires d’entraînement et de validation ainsi
que les noms des [Link] entraîner le modèle YOLO. Il définit :

• path : Le répertoire racine des données d’entraînement et de validation.

• train : Le sous-dossier contenant les images d’entraînement.

• val : Le sous-dossier contenant les images de validation.

15
 • names : Les classes d’objets que le modèle va apprendre à détecter (par
exemple, Apple, Orange, Strawberry).

Exemple de code :
path : C :\ Users \ HP \ Downloads \ Object - Detection - Yolo \
datasets

train : images / train # Chemin relatif pour les

images d ’ e n t r a n e m e n t
val : images / validation # Chemin relatif pour les
images de validation

names :
0: Apple
1: Orange
2: Strawberry

7.4 Analyse d’Entraînements (Après 32 epochs)

Lors de l’entraînement, le modèle apprend à détecter les objets spécifiés dans
[Link]. Les images d’entraînement et de validation sont utilisées pour
optimiser le modèle.
Après l’entraînement, le modèle peut être utilisé pour prédire des objets
dans des images, des vidéos ou des GIFs.

7.4.1 Courbe de Précision

Description :
La courbe de précision représente l’évolution de la précision au cours des
époques d’entraînement. On observe une chute brusque initiale, suivie d’une
tendance générale à la hausse avec stabilisation autour de 0.35. Cela indique
que le modèle a eu des difficultés initiales mais s’est progressivement amélioré
dans la réduction des faux positifs.

16
 Figure 1: Évolution de la précision au fil des époques.

7.4.2 Courbe de Rappel

Description :
La courbe de rappel montre la capacité du modèle à identifier correctement
les exemples faits . Une augmentation rapide au début conduit à une stabil-
isation autour de 0.50, ce qui indique que le modèle privilégie la détection
des vrais positifs, parfois au détriment de la précision.

17
 Figure 2: Évolution du rappel au fil des époques.

7.4.3 Courbe de Perte pour la Localisation des Boîtes (Box_Loss)

Description :
La courbe Box_Loss représente la perte liée à la localisation des boîtes
d’objets prédits. Une diminution rapide est observée dans les premières épo-
ques, suivie d’une stabilisation autour de 1.5. Cela montre que le modèle
converge efficacement dans la réduction des erreurs de localisation.

18
 Figure 3: Évolution de la perte de localisation des boîtes (Box_Loss).

7.4.4 Courbe de Perte pour la Classification (Cls_Loss)

Description :
La courbe Cls_Loss illustre la diminution de l’erreur liée à la classification
des objets détectés. La perte commence élevée et descend progressivement
jusqu’à environ 1.6 après 32 époques, indiquant une amélioration notable des
prédictions de classe.

19
 Figure 4: Évolution de la perte de classification (Cls_Loss).

Remarques
Les courbes analysées montrent une convergence progressive du modèle :
• La précision pour la classe B s’améliore mais reste modérée.
• Le rappel est plus élevé, indiquant une bonne capacité de détection
des vrais positifs.
• La perte Box_Loss diminue, attestant d’une amélioration des locali-
sations.
• La perte Cls_Loss suit une tendance décroissante, montrant une meilleure
classification.
Des optimisations supplémentaires, telles que l’ajustement des hyper-
paramètres ou l’ajout de données, pourraient améliorer davantage les per-
formances.

7.4.5 Matrice de Confusion

Description de la Matrice de Confusion

La matrice de confusion suivante permet d’évaluer les performances du mod-
èle en montrant les prédictions comparées aux étiquettes réelles. Voici les

20
principaux points à noter :
• La diagonale représente les prédictions correctes.
• Les éléments en dehors de la diagonale montrent les erreurs (faux posi-
tifs et faux négatifs).
• Une erreur notable apparaît lorsque l’objet Apple est prédit comme
Orange.

Figure 5: Matrice de confusion des prédictions du modèle.

Analyse des Erreurs

Une observation importante :
• Une confusion notable a été identifiée : certaines images de Apple sont
classées comme Orange, probablement en raison de la similarité de
couleur.
• Cela indique que le modèle s’appuie principalement sur des caractéris-
tiques visuelles simples comme la couleur.
—

21
7.4.6 Courbe Precision-Recall

Description de la Courbe Precision-Recall

La courbe Precision-Recall suivante montre la relation entre la précision et
le rappel pour chaque classe.

Figure 6: Courbe Precision-Recall pour chaque classe et [email protected].

Analyse des Performances

• La classe Strawberry présente la meilleure performance avec une pré-
cision et un rappel supérieurs à ceux des autres classes (AP = 0.481).

• Les classes Apple et Orange montrent des performances moins bonnes

avec des AP respectifs de 0.285 et 0.227.

• Le mAP global du modèle est de 0.331, ce qui indique une performance

moyenne pour toutes les classes.

• Une amélioration pourrait être apportée en équilibrant les données et

en ajoutant des exemples visuellement ambiguës.

22
7.5 Analyse des Prédictions : val_batch1_labels et val_batch1_pred

Figure 7: Exemple d’un Batch de validation étiqueté.

Figure 8: Prédictions pour le Batch de validation.

23
Description des Résultats
Le modèle a correctement prédit la majorité des images de val_batch1, à
l’exception d’une image :
• L’objet Apple a été prédit comme Orange.
• Cette erreur est due à la couleur orangeâtre de l’objet, ce qui a trompé
le modèle.

Analyse de l’Erreur
• Cause principale : Le modèle s’est basé principalement sur la couleur
comme caractéristique discriminante.
• Impact : Cette confusion montre que le modèle n’a pas appris à cap-
turer des caractéristiques plus complexes comme la forme ou la texture.
• Solution proposée :
– Ajouter des images de Apple avec des teintes variées dans l’ensemble
d’entraînement.
– Appliquer des augmentations de données pour améliorer la ro-
bustesse.
– Utiliser des techniques d’explication comme Grad-CAM pour vi-
sualiser où le modèle porte son attention.

Remarques
• La matrice de confusion et la courbe Precision-Recall montrent des per-
formances globales acceptables, avec des points faibles pour certaines
classes.
• L’erreur entre Apple et Orange est attribuée à la dépendance du modèle
sur la couleur.
• Des solutions telles que l’augmentation des données et la prise en compte
de caractéristiques complexes doivent être envisagées.

24
7.5.1 Tester des Nouvelles images:

Première Image : Oranges Simples

Figure 9: Image contenant deux oranges (entière et coupée).

Prédictions :

• Orange 0.82 : L’orange entière a été détectée avec une confiance

élevée.

• Orange 0.76 : L’orange coupée en deux est également identifiée avec

précision.

Analyse :

• Le modèle montre de bonnes performances sur cette image simple.

• Les objets sont correctement détectés avec des scores de confiance sat-
isfaisants.

25
Deuxième Image : Assortiment de Fruits

Figure 10: Assortiment de fruits contenant oranges, pommes et citrons.

Prédictions :
• Oranges :

– Orange 0.56, 0.67, 0.76, 0.55 : Détection correcte des oranges avec
des scores de confiance modérés.

• Pommes :

– Apple 0.53, 0.35 : Les pommes sont détectées, mais avec une faible
confiance.

Analyse :
• Le modèle arrive à distinguer les fruits dans un environnement encom-
bré.

26
 • Les scores pour les pommes sont plus faibles, indiquant un manque de
confiance.

• Amélioration possible : Augmenter la représentation des pommes dans

les données d’entraînement.

Troisième Image : Fruits Variés et Complexes

Figure 11: Image complexe contenant divers fruits : fraises, oranges,

pommes, etc.

Prédictions :

• Fraises (Strawberry) :

– Strawberry 0.38, 0.39, 0.30, 0.30, 0.55 : Détection correcte mais

scores faibles.

• Orange :

– Orange 0.34 : Faible confiance pour l’orange détectée.

• Pomme (Apple) :

27
 – Apple 0.32 : Détection avec faible confiance.

Analyse :
• Le modèle montre des difficultés face à la complexité de l’image et à la
variété des fruits.

• Les scores de confiance sont faibles pour presque toutes les classes.

• Certains fruits (pastèque, raisin, banane) n’ont pas été détectés.

Discussion et Solutions Proposées

• Amélioration des données d’entraînement :

– Ajouter des images plus variées avec des fruits dans des environ-
nements complexes.
– Assurer une meilleure représentation des classes (ex. : pastèque,
kiwi, raisin).

• Augmentation des données :

– Appliquer des transformations telles que la rotation, le zoom, et

l’augmentation de luminosité.

• Optimisation du modèle :

– Utiliser des modèles plus robustes comme YOLOv5 ou Faster

R-CNN.
– Ajuster le seuil de confiance pour filtrer les prédictions peu fiables.

Remarque
Le modèle, après 32 epochs, montre de bonnes performances pour des im-
ages simples contenant peu d’objets. Toutefois, dans des environnements
complexes, il présente des limites, notamment des scores de confiance faibles
et des objets non détectés. Les solutions proposées, telles que l’amélioration
des données et l’optimisation de l’architecture du modèle, permettront de
renforcer sa robustesse et sa précision.

28
7.6 Flux de travail
Voici un résumé du flux de travail global du projet :

1. Entraînement du modèle : Utiliser [Link] pour entraîner le mod-

èle sur les images d’entraînement spécifiées dans [Link].

2. Prédictions :

• Utiliser predict_images.py pour appliquer le modèle sur des im-

ages individuelles.
• Utiliser predict_videos.py pour traiter des vidéos.
• Utiliser predict_gifs.py pour traiter des GIFs.

3. Sortie :

• Utiliser assemble_results.py pour combiner et organiser les ré-

sultats des prédictions.
• Utiliser affichage_results.py pour visualiser directement les
prédictions sur les différentes sorties.

Les résultats des prédictions sont sauvegardés dans un dossier de sortie

spécifié, avec les annotations (rectangles et étiquettes) dessinées sur les
objets détectés.

4. Échantillons de test :

• Des échantillons de test comprenant des images, vidéos et GIFs

sont utilisés pour valider les prédictions du modèle et illustrer ses
performances.

En résumé, ce projet est une solution complète de détection d’objets util-

isant YOLO pour traiter des images, des vidéos et des GIFs, avec un flux
d’entraînement, de prédiction et de sauvegarde des résultats.

29
Conclusion
L’algorithme YOLO v8 se distingue par sa capacité à traiter les images en
temps réel, ce qui en fait un choix idéal pour notre projet de détection de
fruits. En s’appuyant sur des concepts avancés comme les CNN et les filtres,
il offre une solution robuste et efficace pour des applications pratiques dans
le domaine de l’agriculture intelligente.

Ressources
Documentation
• Ultralytics Open Images V7 - Modèles Pré-entraînés

• Documentation de YOLOv8

Livres
• Research of YOLO Architecture Models in Book Detection

• You Only Live Once

Ressources d’Apprentissage
• YOLO Object Detection Explained - DataCamp

• Object Detection Course - Computer Vision Zone

• CNN Explainer - Polo Club

30