Univérsité Cheikh Anta Diop

École Supérieure Polytechnique

Département Génie Informatique
RAPPORT Projet Deep Learning DIC 3 Info & TR

Etudiant
Modou Fall
Exercice 1

w i + = w i − η⋅ ∂w i
∂E

1. Calcul du Gradient Erreur (GE) :

o GE=−(target−outa)GE = -(target - out_a)GE=−(target−outa)
o Donné : target=valeur cibletarget = \text{valeur cible}target=valeur cible
o outa=sortie actuelleout_a = \text{sortie actuelle}outa=sortie actuelle
o Exemple : GE=−(0,21707153)GE = - (0,21707153)GE=−(0,21707153)
o
2. Calcul de la Fonction de Sortie Dérivée (FoutaF_{out_a}Fouta) :
o Fouta=f′(eneta)F_{out_a} = f'(e_{net_a})Fouta=f′(eneta)
o Fouta=outa(1−outa)F_{out_a} = out_a(1 - out_a)Fouta=outa(1−outa)
o Exemple : Fouta=0,17551005F_{out_a} = 0,17551005Fouta=0,17551005
o
3. Calcul de la Dérivée du Réseau (∂neta∂(wy⋅outhc+wx⋅outhc+ba⋅x)\frac{\partial
net_a}{\partial (w_y \cdot out_hc + w_x \cdot out_hc + b_a \cdot x)}∂(wy⋅outh
c+wx⋅outhc+ba⋅x)∂neta) :
o Donné : outhc=sortie cacheˊeout_hc = \text{sortie cachée}outhc=sortie cacheˊe
o Exemple : outhc=0,593269992out_hc = 0,593269992outhc=0,593269992
o
4. Résultats :
o GEt=−0,0226023405GE_t = -0,0226023405GEt=−0,0226023405
o Wyt=0,5−0,5⋅yW_{yt} = 0,5 - 0,5 \cdot yWyt=0,5−0,5⋅y
o GEt=0,511301273GE_t = 0,511301273GEt=0,511301273

Étape 2 :

1. Calcul du Gradient Erreur (GE) :

o GE=−(target−outa)GE = -(target - out_a)GE=−(target−outa)
o Donné : target=valeur cibletarget = \text{valeur cible}target=valeur cible
o outa=sortie actuelleout_a = \text{sortie actuelle}outa=sortie actuelle
o Exemple : GE=−(0,21707153)GE = - (0,21707153)GE=−(0,21707153)
2. Calcul de la Fonction de Sortie Dérivée (FoutaF_{out_a}Fouta) :
o Fouta=f′(eneta)F_{out_a} = f'(e_{net_a})Fouta=f′(eneta)
o Fouta=outa(1−outa)F_{out_a} = out_a(1 - out_a)Fouta=outa(1−outa)
o Exemple : Fouta=0,17551005F_{out_a} = 0,17551005Fouta=0,17551005

3. Calcul de la Dérivée du Réseau (∂neta∂(wy⋅outhc+wx⋅outhc+ba⋅x)\frac{\partial

net_a}{\partial (w_y \cdot out_hc + w_x \cdot out_hc + b_a \cdot x)}∂(wy⋅outh
c+wx⋅outhc+ba⋅x)∂neta) :
o Donné : outhc=sortie cacheˊeout_hc = \text{sortie cachée}outhc=sortie cacheˊe
o Exemple : outhc=0,596084370out_hc = 0,596084370outhc=0,596084370

GEt=−0,02274024GE_t = -0,02274024GEt=−0,02274024

Wxt= 0,55 − 0,5⋅yW_{xt} = 0,55 - 0,5 \cdot yWxt=0,55−0,5⋅y

GEt=0,561370121GE_t = 0,561370121GEt=0,561370121

4. Résultats :

W2+ = 0.199726765

W 3+= 0,249564366

W4+ = 0,299446231

W6+ = 0,408666049

W7+ = 0,511311289

W8+ = 0,561370121

Exercice 2: Etude de YOLO

INTRODUCTION
YOLO (You Only Look Once) est une méthode de détection d'objets qui divise
une image en une grille et fait des prédictions de boîtes englobantes et des
probabilités de classe pour chaque grille en une seule passe à travers le réseau
 neuronal. Cette approche est connue pour sa rapidité, ce qui la rend idéale pour des
applications en temps réel.

Versions de YOLO

1. YOLOv1
o Publié en 2016 par Joseph Redmon et al.
o Divise l'image en une grille SxS et pour chaque cellule de la grille, prédit
des boîtes englobantes et des probabilités de classe.
o Avantages : Rapidité et simplicité.
o Inconvénients : Précision inférieure pour les petits objets et objets
proches les uns des autres.
2. YOLOv2 (YOLO9000)
o Améliore la précision tout en maintenant la vitesse.
o Introduit des ancres (anchors) pour mieux gérer les objets de différentes
tailles.
o Utilise l'apprentissage multi-échelle pour améliorer la robustesse.
3. YOLOv3
o Utilise une architecture Darknet-53.
o Prédictions faites à trois échelles différentes pour capturer des objets de
différentes tailles.
o Améliore la précision et la détection des petits objets.
4. YOLOv4 et YOLOv5
o Continuent d'améliorer la précision et la vitesse.
o Utilisent des techniques avancées comme la mosaïque, les augmentations
de données, et des optimisations plus sophistiquées.

5. YOLO V6 à V8

- Les versions les plus récentes de YOLO, à partir de la version 6,

introduisent des améliorations continues axées sur les applications concrètes
de YOLO, telles que les véhicules autonomes ou la surveillance vidéo. Plus
on avance dans le temps, et plus YOLO s'éloigne de la communauté des
chercheurs pour atteindre le grand public et les cas d'usage appliqués à la vie
réelle.

- Ces versions ont affiné l'utilisation des techniques de Deep Learning, y

compris diverses formes d'augmentation des données et d'algorithmes
d'optimisation qui ont aidé à améliorer la précision moyenne et la capacité à
détecter une gamme diversifiée de classes d'objets.

6. YOLO V9
 Le 21 février 2024, Chien-Yao Wang, I-Hau Yeh et Hong-Yuan Mark Liao
ont publié l'article "YOLOv9

YOLOv9 représente une avancée majeure dans la série des modèles YOLO,
offrant des améliorations significatives en termes de précision et d'efficacité
pour la détection d'objets en temps réel. Il se distingue de ses prédécesseurs,
notamment YOLOv8, par une réduction de 49% du nombre de paramètres et
de 43% de la complexité computationnelle, tout en augmentant la précision
moyenne sur le jeu de données MS COCO de 0,6%.

La série YOLOv9 comprend quatre modèles : YOLOv9-s (petit), YOLOv9-

m (moyen), YOLOv9-c (compact) et YOLOv9-e (étendu), chacun variant en
termes de nombre de paramètres et de performances. Ces modèles sont
conçus pour répondre à divers besoins, allant d'applications légères à des
applications plus exigeantes en performances.

YOLOv9 introduit deux innovations majeures :

- 1. Le Programmable Gradient Information (PGI)

- 2. Le Generalized Efficient Layer Aggregation Network (GELAN)

Le PGI est un mécanisme de supervision auxiliaire comprenant trois

composants principaux :

- 1. Une branche principale

- 2. Une branche auxiliaire réversible

- 3. Une information auxiliaire multi-niveaux

En somme, YOLOv9 représente un jalon important dans la recherche en

intelligence artificielle, reflétant la dynamique actuelle de quête incessante pour
atteindre et conserver le statut de pointe dans le domaine. Les développeurs de
YOLOv9 ont publié le code source sur GitHub, facilitant ainsi son adaptation à
diverses tâches de Computer Vision.

Comment fonctionne YOLO ?

Voici comment l'algorithme de détection d'objets YOLO fonctionne,

expliqué en étapes simples :
1. Prendre une photo

Tout d'abord, l'algorithme YOLO commence par une image, tout comme
lorsque vous prenez une photo avec un appareil photo. C'est ce que nous
appelons la détection d'objets basée sur la classification d'images !

2. Diviser l'image

Ensuite, il divise l'image donnée en petits carrés, comme un damier. Chaque

carré sera vérifié pour voir s'il contient un objet (un chat, un chien ou encore
une boîte de conserve, par exemple).

3. Chercher des indices

Pour chaque carré, YOLO recherche des indices ou des caractéristiques

comme des bords, des formes ou des textures qui pourraient indiquer quel
objet s'y trouve. Il les entoure avec des boîtes englobantes. Comme YOLO a
besoin d'apprendre pour bien comprendre un nouveau jeu de données et
interpréter, on lui a parfois donné un jeu de donneés de référence (ou "vérité
terrain") dans lequel il peut puiser pour avoir des points de comparaison.

4. Faire des prédictions

L'algorithme fait une supposition pour chaque carré d'une image : quel objet
cela pourrait-il être et où exactement se trouve-t-il dans le carré ? Il attribue
à chaque supposition un score pour montrer son niveau de certitude.

5. Éliminer les excédents

Certains carrés ont des suppositions de différents objets qui se chevauchent,

comme deux carrés devinant une partie de la même voiture. YOLO choisit
la meilleure supposition pour chaque objet, en se débarrassant des
suppositions superflues.

6. Montrer ce qu'il a trouvé

À la fin, YOLO vous montre où il pense que chaque objet se trouve en

dessinant des boîtes autour d'eux et en les étiquetant, comme "voiture" ou
"arbre". Si vous lui donnez 1'000 images contenant des chiens et des chats,
et lui dites d'identifier les chats, il vous montrera des images enrichies de
métadonnées pointant vers les chats.

Le point fort de YOLO est qu'il examine tous les éléments d'une images
(décomposés en "carrés") en même temps. C'est pourquoi il est rapide et
peut même fonctionner en temps réel, ce qui est extrêmement utile pour
 des applications nécessitant des réactions rapides, comme les voitures
autonomes ou la vidéosurveillance !

Avantages et limites

• Avantages :
o Très rapide, adapté aux applications en temps réel.
o Bonne performance pour une large gamme de tailles d'objets.
• Limites :
o Moins précis pour les petits objets dans une image.
o Peut être moins précis pour des objets qui sont très proches les uns des
autres.

CONCLUSION
YOLO, l’un des moteurs de la nouvelle vague d’IA

En permettant pour la première fois la détection d’objets instantanée, You Only

Look Once a ouvert une myriade de nouvelles possibilités pour la vision par
ordinateur. C’est l’une des innovations qui ont permis à l’IA d’entrer dans
une ère nouvelle.

IMPLEMENTATION :

Nous Avons Choisi YOLOv3

Architecture de YOLOv3

YOLOv3 utilise Darknet-53, un réseau de neurones convolutifs avec 53 couches de

convolution, comme base. Il effectue des prédictions à trois échelles différentes, ce qui
améliore la capacité de détecter des objets de différentes tailles.

• Entrée : Une image de taille 416x416.

• Sortie : Une grille avec des boîtes englobantes et des scores de confiance pour
chaque classe.

Fonctionnement de YOLOv3

1. Prétraitement : Redimensionnement de l'image d'entrée à 416x416 pixels.

2. Passage dans le réseau : L'image passe à travers les couches de Darknet-53
pour extraire des caractéristiques.
3. Détection multi-échelle : Prédictions faites à trois niveaux différents de
granularité.
4. Post-traitement : Utilisation de la Non-Maximum Suppression (NMS) pour
supprimer les prédictions redondantes.
 Lien de téléchargement du dataset utilisé :

http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar

Fichier de Configuration et de poids de YOLOv3 :

https://github.com/pjreddie/darknet/blob/master/cfg/yolov3.cfg -O yolov3.cfg

https://pjreddie.com/media/files/yolov3.weights -O yolov3.weights

https://github.com/pjreddie/darknet/blob/master/data/coco.names -O coco.names

CODE
import cv2
import numpy as np
import os

# Chemin vers les fichiers de configuration et de poids

config_path = 'yolov3.cfg'
weights_path = 'yolov3.weights'
classes_path = 'coco.names'

# Charger les noms des classes

with open(classes_path, 'r') as f:
classes = f.read().strip().split('\n')

# Charger le réseau YOLOv3

net = cv2.dnn.readNetFromDarknet(config_path, weights_path)

def detect_objects(image):
# Obtenir les dimensions de l'image
(H, W) = image.shape[:2]

# Créer un blob à partir de l'image et effectuer une passe en avant

blob = cv2.dnn.blobFromImage(image, 1/255.0, (416, 416),
swapRB=True, crop=False)
net.setInput(blob)
layer_outputs = net.forward(net.getUnconnectedOutLayersNames())

boxes = []
confidences = []
class_ids = []

for output in layer_outputs:

for detection in output:
scores = detection[5:]
 class_id = np.argmax(scores)
confidence = scores[class_id]
if confidence > 0.5:
box = detection[0:4] * np.array([W, H, W, H])
(centerX, centerY, width, height) = box.astype('int')
x = int(centerX - (width / 2))
y = int(centerY - (height / 2))
boxes.append([x, y, int(width), int(height)])
confidences.append(float(confidence))
class_ids.append(class_id)

indices = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)

if len(indices) > 0:
for i in indices.flatten():
(x, y) = (boxes[i][0], boxes[i][1])
(w, h) = (boxes[i][2], boxes[i][3])
color = [int(c) for c in np.random.randint(0, 255,
size=(3,))]
cv2.rectangle(image, (x, y), (x + w, y + h), color, 2)
text = f"{classes[class_ids[i]]}: {confidences[i]:.4f}"
cv2.putText(image, text, (x, y - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

return image

# Parcourir les images du dataset Pascal VOC et effectuer la détection

images_path = 'VOCdevkit/VOC2012/JPEGImages' # Dossier contenant les
images

for image_name in os.listdir(images_path):

image_path = os.path.join(images_path, image_name)
image = cv2.imread(image_path)

if image is not None:

output_image = detect_objects(image)
output_image_path = os.path.join('output_images', image_name)
cv2.imwrite(output_image_path, output_image)