Ce document présente un projet de fin d'études sur l'application du deep learning à la reconnaissance d'objets dans les images et vidéos. Il couvre les principes de l'apprentissage automatique, la modélisation des neurones, ainsi que les réseaux de neurones convolutifs et leur mise en œuvre. Le travail inclut également des ateliers pratiques illustrant la classification binaire et multiple par l'utilisation de réseaux de neurones.

1. UNIVERSITE IBN ZOHR
FACULTE DES SCIENCES
Département Informatique
Filière Sciences Mathématiques et Informatique
PFE
Présenté par: EL YOUSSFI Haytam
Email : elyoussfihaytam@gmail.com
Pour l’obtention de la
Licence en Sciences Mathématiques et Informatique
Deep Learning : Application à la
reconnaissance d’objets de classes multiples
sur les images et les vidéos
Soutenu le 23/05/2019
Année universitaire 2018-2019

2. Table des matières
1 Introduction générale 8
2 L’apprentissage automatique et la classification 10
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 L’apprentissage automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.1 Les types d’apprentissage automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2.2 La différence entre l’apprentissage supervisé et l’apprentissage non supervisé . . . . . . . . . . 12
2.2.3 L’apprentissage supervisé et les réseaux de neurones profonds . . . . . . . . . . . . . . . . . . 12
2.2.4 L’apprentissage automatique et la vision par ordinateur . . . . . . . . . . . . . . . . . . . . . 13
2.3 L’apprentissage profond . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Les motivations de la classification des images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5 Notions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5.1 Définition d’une image numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5.2 Caractéristiques de l’image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6 Classification des images et l’apprentissage machine . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.7 Classification des images et les réseaux de neurones profonds . . . . . . . . . . . . . . . . . . . . . . 17
2.8 Révolution d’apprentissage profond . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.8.1 L’évolution des CPU et des GPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.8.2 Les nouvelles architectures de réseaux des neurones utilisés par l’apprentissage profond . . . . 21
2.9 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3 Modélisation des neurones 23
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2 Les neurones biologiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3 Modélisation d’un neurone artificiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.4 Le perceptron simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.4.1 Régles d’apprentissages de HEB et Frank Rosenblatt . . . . . . . . . . . . . . . . . . . . . . 25
3.4.2 La descente du gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.3 Comment représenter les données en Machine Learning ? . . . . . . . . . . . . . . . . . . . . 27
3.4.4 Exemple d’application du percetron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4.5 Les mesures de la performance d’un neurone artificiel : . . . . . . . . . . . . . . . . . . . . . 31
3.4.6 Courbe ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4.7 Les limitations du perceptron : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.5 Les réseaux de neurones multicouches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.5.1 Propagation de l’information, le calcul de la sortie du réseau . . . . . . . . . . . . . . . . . . 35
3.5.2 Le Rétro-propagation de l’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.5.3 classification binaire d’un ensemble de données par réseau de neurones . . . . . . . . . . . . . 39
3.5.4 Le taux d’apprentissage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.5.5 Préparation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4 Les Réseaux de neurones convolutifs 53
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2 Les réseaux de neurones convolutifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.3 Architecture de réseaux de neurones convolutifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.3.1 Couche de convolution(CONV) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.3.2 Couche de pooling (POOL) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.3.3 Couches de correction (RELU) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.3.4 Couche entièrement connectée (FC) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3.5 Couche de perte (LOSS) : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2

3. TABLE DES MATIÈRES
4.4 Exemples des modèles de CNN : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.5 Choix des paramètres : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.5.1 Nombre de filters : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.5.2 Forme du filtre : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.5.3 Forme du Max Pooling : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.6 Méthodes de régularisation : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.6.1 Empirique : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.6.2 Explicite : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5 La détection des classes d’objets dans sur les vidéos 60
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
5.2 La phase de détection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
5.3 La relation entre la détection et la classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.3.1 Les problèmes des fenêtres glissantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.4 R-CNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.5 Fast R-CNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
6 Implémentation et évaluation 65
6.1 Environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
6.2 Logiciels et librairies Utilisés dans l’implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.2.1 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.2.2 TensorFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.2.3 Keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.2.4 Scikit-learn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.3 Configuration utilisé dans l’implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.4 Atelier 1 : Exemple d’un classificateur du sexe d’une personne à partir de sa taille et son poids . . . . 66
6.5 Atelier 2 : Exemple d’une classification binaire et multiple par un réseau de neurone multicouches (MLP) 70
6.5.1 Le réseau de neurone multi-couche dans le cas de classification binaire . . . . . . . . . . . . . 70
6.5.2 Le réseau de neurone multi-couche dans le cas d’une classification multiple . . . . . . . . . . 75
6.6 Atelier 3 : Classification multiple avec réseau de neurones convolutifs . . . . . . . . . . . . . . . . . . 77
6.6.1 Architecture de notre réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.6.2 Résultats obtenus et discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.6.3 Comment développer un modèle amélioré ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
7 Conclusion et prespectives 89
HAYTAM EL YOUSSFI, PFE: Deep Learning 3

4. Liste des tableaux
2.1 Voisinnage à 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Voisinnage à 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.1 La matrice de confusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2 la fonction OU exclusif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4

5. Table des figures
2.1 Diagramme de l’apprentissage supervisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Diagramme de l’apprentissage non supervisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Diagramme de l’apprentissage par renforcement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4 L’apprentissage profond - l’apprentissage automatique - l’intelligence artificielle . . . . . . . . . . . . 14
3.1 Schèma d’un neurone biologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2 Représentation d’un perceptron mono-couche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3 Un déplacement dans le sens opposé au gradient (fléche Rose ) raproche Wj de la valeur minimisant
l’erreur (point orange) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4 Une cross-validation à 5 folds : Chaque point appartient à 1 des 5 jeux de test (en blanc) et aux 4
autres jeux d’entraı̂nements (en orange) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.5 Représentation visuelle de la validation de train / test et de la validation croisée. . . . . . . . . . . . 28
3.6 Train / Test Split . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.7 Graphe de la fonction ET logique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.8 Précision et rappel (recall) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.9 Courbe ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.10 AUC (aire sous la courbe ROC). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.11 Graphe de la fonction Ou exclusif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.12 Un réseau de neurones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.13 Graphe de la fonction d’identité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.14 Graphe de la fonction Heaviside . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.15 Graphe de la fonction sigmoide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.16 Graphe de la fonction Tangente Hyperbolique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.17 Schéma de rétro-propagation du gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.18 Diagramme de la règle de la chaine dérivée partielle avec un seul chemin . . . . . . . . . . . . . . . . 37
3.19 Diagramme de la règle de la chaine dérivée partielle avec deux chemins . . . . . . . . . . . . . . . . 38
3.20 La distribution des deux ensembles de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.21 Structure du réseau de neurones utilisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.22 Les poids qui relient la couche d’entrée avec la couche cachée . . . . . . . . . . . . . . . . . . . . . 42
3.23 Les poids qui relient la couche cachée avec la couche de sortie . . . . . . . . . . . . . . . . . . . . . 43
3.24 Le sortie de chaque neurone du réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.25 Le descente du gradient du neurone de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.26 Le descente du gradient de chaque neurone de la couche cachée . . . . . . . . . . . . . . . . . . . . 46
3.27 Mise à jour des poids relient la couche entrée avec la couche cachée . . . . . . . . . . . . . . . . . . 46
3.28 Mise à jour des poids relient la couche cachée avec la couche sortie . . . . . . . . . . . . . . . . . . 47
3.29 Les résultats obtenus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.30 Taux d’apprentissage trop bas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.31 Taux d’apprentissage trop élevé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.32 Taux d’apprentissage adéquat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.33 Modéle 1 :Illustration inspirée du cours d’Andrew NG . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.34 Modéle 2 :Illustration inspirée du cours d’Andrew NG . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.35 Exemple de données répondant à une loi normal X ∼ N(3.8, 4.3) . . . . . . . . . . . . . . . . . . . 52
4.1 Architecture standard d’un réseau de neurone convolutif . . . . . . . . . . . . . . . . . . . . . . . . 54
4.2 : Une couche du CNN en 3 dimensions. (Vert = volume d’entrée, bleu = volume du champ récepteur,
gris = couche de CNN, cercles = neurones artificiels indépendants) . . . . . . . . . . . . . . . . . . 55
4.3 Pooling avec un filtre 2x2 et un pas de 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.4 Graphe de la fonction ReLU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5 Exemples de modèles de CNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5

6. TABLE DES FIGURES
5.1 Détection des objets en utilisant des cadres de sélection . . . . . . . . . . . . . . . . . . . . . . . . 60
5.2 Le cadre de sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.3 IoU Score . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.4 les sorties possibles de la détection d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.5 La détection d’un object dans deux différents ”frames” d’un vidéo . . . . . . . . . . . . . . . . . . . 62
5.6 Les problèmes des annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.7 Score Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.8 R-CNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.9 Fast R-CNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
6.1 L’architecture de notre réseaux de neurone Multicouches(MLP) . . . . . . . . . . . . . . . . . . . . . 70
6.2 La distribution des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.3 Visualisation des images des nombres manuscrits . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.4 Flux de travail de Tensorflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
6.5 La configuration de modéle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.6 Entrainement du modéle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.7 Evaluation du modéle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
6.8 La prédiction sur l’ensemble de donnée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
6.9 La courbe d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
6.10 La courbe de précision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.11 L’affichage des poids synaptiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.12 La couche sortie d’un réseau de neurone dans le cas de classification Multiple . . . . . . . . . . . . . 76
6.13 Visualisation des images des nombres manuscrits allant de 0 à 9 . . . . . . . . . . . . . . . . . . . . 76
6.14 La structure de notre réseau de neurone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.15 Base des images :CIFAR-10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.16 La base des images :CIFAR-100 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
6.17 Configuration du modèle 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
6.18 Configuration du modèle 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.19 Configuration du modèle 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.20 Précision et Erreur pour le Modèle 01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.21 Matrice de Confusion pour le Modèle 01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.22 Nombre total des images mal et bien classé de modéle 1 . . . . . . . . . . . . . . . . . . . . . . . . 81
6.23 Taux d’erreur et la précision de modéle 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.24 Précision et Erreur pour le Modèle 02 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.25 Matrice de Confusion pour le Modèle 02 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.26 Nombre total des images mal et bien classé de Modéle 2 . . . . . . . . . . . . . . . . . . . . . . . . 83
6.27 Taux d’erreur et la précision de Modéle 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.28 Précision et Erreur pour le modèle 03 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.29 Matrice de Confusion pour le modèle 03 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.30 Nombre total des images mal et bien classé du Modéle 3 . . . . . . . . . . . . . . . . . . . . . . . . 85
6.31 Taux d’erreur et la précision du Modéle 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.32 La courbe de précision du modéle 3 prés l’amélioration . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.33 La courbe d’erreur du modéle 3 prés l’amélioration . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
HAYTAM EL YOUSSFI, PFE: Deep Learning 6

7. TABLE DES FIGURES
Liste des abréviations
DL : L’apprentissage profond ( Deep Learning )
ML :L’apprentissage automatique (Machine learning )
GPU : Un processeur graphique (Graphics Processing Unit)
CPU : unité centrale de traitement (central processing unit)
ROC : La fonction d’efficacité du récepteur (receiver operating characteristic,)
CONV : Couche de convolution
POOL : Couche de pooling
FC : Couche entiérement connectée
CNN : Les réseaux de neurones convolutifs(Convolutional Neural Network )
MLP : Les perceptrons multicouches (Multi Layer Perceptron)
PNL :Système de traitement du langage naturel
RNN : Les réseaux de neurones récurrents
GAFAM : (Google, Apple, Facebook, Amazon, Microsoft).
RVB : (Rouge, Vert, Bleu)
HAYTAM EL YOUSSFI, PFE: Deep Learning 7

8. Chapitre 1
Introduction générale
Nous vivons dans un monde numérique, où les informations sont stockées, traitées, indexées et recherchées par des
systèmes informatiques, ce qui rend leur récupération une tâche rapide et pas cher. Au cours des dernières années,
des progrès considérables ont été réalisés dans le domaine de classification d’images. Ce progrès est dû aux nombreux
travaux dans ce domaine et à la disponibilité des bases d’images internationales qui ont permis aux chercheurs de
signaler de manière crédible l’exécution de leurs approches dans ce domaine, avec la possibilité de les comparer à
d’autres approches qu’ils utilisent les mêmes bases.
Dans la fin des années 80 Yan le Cun 1
a développé un type de réseau particulier qui s’appelle le réseau de neurone
convolutionnel, ces réseaux sont une forme particulière de réseau neuronal multicouche dont l’architecture des
connexions est inspirée de celle du cortex visuel des mammifères. Par exemple, chaque élément n’est connecté qu’à
un petit nombre d’éléments voisins dans la couche précédente. En 1995, Yan le cun et deux autres ingénieurs ont
développé un système automatique de lecture de chèques qui a été déployé largement dans le monde. À la fin des
années 90, ce système lisait entre 10 et 20 % de tous les chèques émis aux États-Unis. Mais ces méthodes étaient
plutôt difficiles à mettre en oeuvre avec les ordinateurs de l’époque, et malgré ce succès, les réseaux convolutionnels
et les réseaux neuronaux plus généralement ont été délaissés par la communauté de la recherche entre 1998 et 2013.
En 2014 et 2015 trois événements ont soudainement changé la situation. Tout d’abord, les GPU (Graphical Pro-
cessing Unit) capables de plus de mille milliards d’opérations par seconde sont devenus disponibles pour un prix moins
cher. Ces puissants processeurs spécialisés, initialement conçus pour le rendu graphique des jeux vidéo, se sont avérés
être très performants pour les calculs des réseaux neuronaux. Deuxièmement, des expériences menées simultanément
à Microsoft, Google et IBM avec l’aide du laboratoire de Geoff Hinton ont montré que les réseaux profonds pou-
vaient diminuer de moitié les taux d’erreurs des systèmes de reconnaissance vocale. Troisièmement plusieurs records
en reconnaissance d’image ont été battus par des réseaux de neurones convolutionnels. L’événement le plus marquant
a été la victoire éclatante de l’équipe de Toronto dans la compétition de reconnaissance d’objets ”ImageNet” 2
. La
diminution des taux d’erreurs était telle qu’une véritable révolution. Du jour au lendemain, la majorité des équipes
de recherche en parole et en vision ont abandonné leurs méthodes préférées et sont passées aux réseaux de neurones
convolutionnels et autres réseaux neuronaux. L’industrie d’Internet a immédiatement saisi l’opportunité et a commencé
à investir massivement dans des équipes de recherche et développements en apprentissage profond.
Dans notre projet on va utiliser les réseaux de neurones convolutionnels pour classifier les images, on va créer
différents modèles avec différents architectures et par la suite on va appliquer ces modèles sur les bases d’images
(Les IRISIRIS est un jeu de données multivariées présenté par Ronald Fisher dans son papier The use of multiple
measurements in taxonomic problems comme un exemple d’application de l’analyse discriminante linéaire , MNIST
,CIFAR10 . . . .. ) .
Pour ce faire, nous avons structuré notre Projet en quatre chapitres :
Dans le premièr chapitre on va parlé de Machine learnigng (l’apprentissage automatique) et les différent types
et nous spécialisons sur Deep Learning (L’apprentisage profond ) et les domaines d’application , on particulier
classification des images et les vidéos donc nous présenterons les notions de base de la classification des images,
les différents types des images et leur caractéristiques, ainsi que l’utilisation des réseaux de neurones artificiel
dans la classification des images et les vidéos .
Dans le deuxième chapitre, nous présenterons la notion de modélisation d’un réseau de neurone, l’utilisation
dans la classification des images et les vidéos et les diffèrents paramétres qui composent de réseau de neurones
.
Dans le troisième chapitre est consacré à la description des réseaux de neurones convolutionnels ainsi que leurs
l’intérêt dans le domaine de la classification des images et les vidéos .
1. Yan le Cun :est un chercheur en intelligence artificielle et vision artificielle (robotique). Il est considéré comme l’un des inventeurs
de l’apprentissage profond
2. ImageNet est une base de données d’images annotées produit par l’organisation du même nom, à destination des travaux de
recherche en vision par ordinateur.
8

9. CHAPITRE 1. INTRODUCTION GÉNÉRALE
Dans le quatrième chapitre, nous montrerons la partie expérimentale de notre travail, nous discuterons des
différents résultats obtenus et nous nous terminerons par une conclusion générale.
Dans le cinquième chapitre, nous discuterons des méthodes de détection des classes d’objets dans les vidéos en
ignorant leurs fonctionnalités temporelles.
HAYTAM EL YOUSSFI, PFE: Deep Learning 9

10. Chapitre 2
L’apprentissage automatique et la
classification
2.1 Introduction
Les statistiques montrent qu’il y a plus de 3,8 milliards d’utilisateurs de courrier électronique et que 205 milliard
de courriers sont envoyés par jour. Imaginez combien de courrier vous recevez sur votre adresse de courriel. Lorsque
vous êtes trop actif sur Internet, vous risquez de recevoir du nombreux courriels qui ne vous intéressent pas, vous
aurez du mal à trouver les Emails intéressants. Si les fournisseurs du service de messagerie ne vous protègent pas de
ce problème, alors comment peuvent-ils déterminer si un Email est un spam ou non ?
Les fournisseurs de services du messagerie tels que Gmail utilisent L’apprentissage automatique pour distinguer les
mais des spams.
L’apprentissage automatique collecte les données de vos courriels et l’objectif de votre courrier électronique afin
de prédire les courriels susceptibles d’être du spam. [6]
Alors, qu’est-ce que l’apprentissage automatique et comment ça marche ?
2.2 L’apprentissage automatique
Les machines peuvent-elles penser ?
”Can machines think ?”... The new form of the
problem can be described in terms of a game
which we call the ’imitation game’.
”Les machines peuvent-elles penser ?” ... La
nouvelle forme du problème peut être décrite en
termes de jeu appelé ”jeu d’imitation”.
Alan Mathison Turing
Le jeu d’imitation est joué par trois personnes, un homme et une femme et un interrogateur ou une interrogatrice.
Ce jeu consiste à demander à l’interrogateur de distinguer qui est l’homme et qui est la femme en posant simplement
des questions aux ces deux personnes. S’il y a deux personnes A et B, l’interrogateur doit déterminer si A est un
homme et B est une femme, ou A est une femme et B est un homme. Pour répondre à la question posé, au lieu
d’utiliser un homme et une femme, on utilise une personne et une machine, si l’interrogateur ne peut pas distinguer
qui est la personne, et qui est la machine, si l’interrogateur ne peut pas distinguer qui est la personne, et qui est la
machine,donc on peut dire que les machines pensent, c’est-à-dire que la machine est devenue intelligente, et c’est la
définition de l’intelligence artificielle donnée par Alan Mathison Turing en 1950.[6]
On peut définir les machines intelligentes comme des des machines auto-programmés, creatives, ont la possiblité
de reconnaitre des modèles d’une manière sophistiqué, simuler le cerveau, et de traiter les données rapidement, qui
sont maintenant utilisée pour automatiser le travail de routine, reconaissance de la parole ou des images, établir un
diagnostic en médecine et soutenir la recherche scientifique fondamentale, et maintenant, chercheurs, ingénieurs et
entrepreneurs s’intéressent aux nouvelles technologies telles que :les systèmes de répondeur téléphonique intelligent et
les algorithmes de recherche, les assistants personnels en forme de robots, ainsi que les méthodes de réparation du
cerveau humain blessé ou défectueux.[14]
L’intelligence artificielle a commencée par des essaies d’inventir des jeux d’ordinateurs qui peuvent gangner contre
les humains, c’était le premier domaine sur lequel les scientifiques ont essayé d’appliquer l’intelligence artificielle.
10

11. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
— En 1952, OXO (ou Morpion, Tic Tac Toe), mis au point par l’informaticien britannique Alexander S. Douglas
pour l’ordinateur EDSAC de l’Université de Cambridge, devint l’un des premiers jeux connus. l’ordinateur
pourrait jouer des jeux parfaits de tic-tac-toe contre un adversaire humain.
— En 1952, Arthur Samuel a inventé un programme appelée ”Samuel Checkers” (jeu de dames) a été l’un des pre-
miers programmes réussis au monde et, une démonstration très précoce du concept fondamental d’intelligence
artificielle (IA), ce programme s’améliorait en jouant, et il parvint à battre le 4e meilleur joueur des États-Unis.
— En 1956, Alex Bernstein un mathématicien américain, joueur d’échecs et employé d’IBM. Avec ses collègues
Michael de V. Roberts, Timothy Arbuckle et Martin Belsky, Alex Bernstein était l’auteur principal du programme
d’échecs Bernstein pour l’IBM 704.
Ces évolutions ont conduit à la naissance d’un nouveau domaine de l’intelligence , qui est l’apprentissage automatique.
L’apprentissage automatique, est l’étude scientifique d’algorithmes et de modèles statistiques que les systèmes
informatiques utilisent pour effectuer efficacement une tâche spécifique sans utiliser d’instructions explicites, en s’ap-
puyant plutôt sur des modèles et sur des inférences.
— Machine Learning is the field of study that
gives computers the ability to learn without being
explicitly programmed.
— L’apprentissage automatique est le domaine
d’étude qui donne aux ordinateurs la possibilité
d’apprendre sans être explicitement programmé.
Arthur Samuel, 1959
Les algorithmes d’apprentissage automatique construisent un modèle mathématique d’échantillons de données,
appelé ”données d’apprentissage”, afin de faire des prédictions ou de prendre des décisions sans être explicitement
programmé pour effectuer la tâche.
Les algorithmes d’apprentissage automatique sont utilisés dans une grande variété d’applications, telles que le filtrage
de courrier électronique et la vision par ordinateur, où il est impossible de développer un algorithme d’instructions
spécifiques pour effectuer la tâche.
L’apprentissage automatique est étroitement lié aux statistiques informatiques, qui se concentrent sur la réalisation
de prédictions à l’aide d’ordinateurs. L’étude de l’optimisation mathématique permet d’appliquer des méthodes, de la
théorie et des domaines d’application au domaine de l’apprentissage automatique.[15]
2.2.1 Les types d’apprentissage automatique
Il existe trois types d’apprentissages dans l’apprentissage automatique ”Machine Learning” :
— L’apprentissage supervisé :L’objectif principal de ce type est de faire apprendre à un modèle en utilisant des
données d’apprentissage étiquetées, ce qui nous permet de faire des prédictions sur des données non vues
ou futures. Terme supervisé ici fait référence à un ensemble d’échantillons où les données de sortie souhaités
libellées sont déjà connues.[3]
Figure 2.1 – Diagramme de l’apprentissage supervisé
— L’apprentissage non supervisé s’agit de trouver des structures sous-jacentes à partir de données non étiquetées.
Puisque les données ne sont pas étiquetées, il n’est pas possible d’affecter au résultat de l’algorithme utilisé un
score d’adéquation. Cette absence d’étiquetage est ce qui distingue les tâches d’apprentissage non-supervisé
des tâches d’apprentissage supervisé.[3]
HAYTAM EL YOUSSFI, PFE: Deep Learning 11

12. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
Figure 2.2 – Diagramme de l’apprentissage non supervisé
— L’apprentissage par renforcement consiste, pour un agent autonome (robot, etc.), à apprendre les actions à
prendre, à partir d’expériences, de façon à optimiser une récompense quantitative au cours du temps. L’agent
est plongé au sein d’un environnement, et prend ses décisions en fonction de son état courant. En retour,
l’environnement procure à l’agent une récompense, qui peut être positive ou négative. L’agent cherche, au
travers d’expériences itérées, un comportement décisionnel (appelé stratégie ou politique, et qui est une fonction
associant à l’état courant l’action à exécuter) optimal, en ce sens qu’il maximise la somme des récompenses
au cours du temps.[3]
Figure 2.3 – Diagramme de l’apprentissage par renforcement
2.2.2 La différence entre l’apprentissage supervisé et l’apprentissage non supervisé
La principale différence entre les deux types réside dans le fait que l’apprentissage supervisé se fait sur la base
d’une vérité fondamentale. En d’autres termes, nous avons une connaissance préalable de ce que devraient être
les valeurs de sortie de nos échantillons. Par conséquent, l’objectif de l’apprentissage supervisé est d’apprendre une
fonction qui, à partir d’un échantillon de données et des résultats souhaités, se rapproche le mieux de la relation
entre entrée et sortie observable dans les données. En revanche, l’apprentissage non supervisé consiste à apprendre
sans superviseur. Il s’agit d’extraire des classes ou groupes d’individus présentant des caractéristiques communes. La
qualité d’une méthode de classification est mesurée par sa capacité à découvrir certains ou tous les motifs cachés.
2.2.3 L’apprentissage supervisé et les réseaux de neurones profonds
Plus nous connaissons bien un domaine, plus il nous est facile de résoudre des problèmes dans ce domaine.
L’expérience facilite la raisonnement dans un domaine, car nous pouvons utiliser des exemples que nous avons rencontrés
pour trouver des solutions intuitives. En physique, par exemple, nous apprenons un domaine comme l’électricité et le
magnétisme en résolvant de nombreux problèmes et non en mémorisant des formules. Si l’intelligence humaine était
basée uniquement sur la logique, elle devrait être du domaine général, ce qui n’est pas le cas.[13]
Donc, pour créer une intelligence artificielle, nous devons créer un système simulant le cerveau humain. Quatre
indices ont aidé l’IA à devenir un domaine basé sur l’apprentissage par l’expérience, non purement sur la logique :
— Le premier indice était que notre cerveau est un système puissant de reconnaissance des modèles (motifs). Nos
systèmes visuels peuvent reconnaı̂tre un objet dans une scène encombrée en un dixième de seconde, même
si nous n’avons peut-être jamais vu cet objet particulier auparavant et même lorsque l’objet se trouve dans
n’importe quel endroit, quelle que soit sa taille et son orientation. . En bref, notre système visuel se comporte
comme un ordinateur dont l’objet reconnaı̂t un objet est une instruction unique.
— Le deuxième indice était que nos cerveaux peuvent apprendre à effectuer de nombreuses tâches difficiles par la
pratique.
— Le troisième indice était que nos cerveaux ne sont pas remplis de logique ou de règles. Oui, nous pouvons
apprendre à penser de manière logique ou à suivre des règles, mais seulement après beaucoup d’entraı̂nement.
— Le quatrième indice était que nos cerveaux sont remplis de milliards de neurones qui communiquent constam-
ment les uns avec les autres.[13]
HAYTAM EL YOUSSFI, PFE: Deep Learning 12

13. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
Ceci suggère que, pour résoudre des problèmes difficiles de l’intelligence artificielle, nous devrions nous intéresser à
des ordinateurs dotés d’architectures parallèles au cerveau humain, ce qui conduit à la création de réseaux de neurones
artificiels.
Un réseau de neurones artificiels, ou réseau neuronal artificiel, est un système dont la conception est à l’origine
schématiquement inspirée du fonctionnement des neurones biologiques, et qui par la suite s’est rapproché des méthodes
statistiques.
Définition : Les réseaux de neurones sont une métaphore des structures cérébrales : des assemblages de constituants
élémentaires, qui réalisent chacun un traitement simple voire simpliste, mais dont l’ensemble fait émerger des propriétés
globales dignes d’intérêt. Chaque constituant fonctionne indépendamment des autres, de telle sorte que l’ensemble est
un système parallèle, fortement interconnecté. L’information détenue par le réseau de neurones est distribuée à travers
l’ensemble des constituants, et non localisée dans une partie de mémoire sous la forme d’un symbole. Enfin, un réseau
de neurones ne se programme pas pour réaliser telle ou telle tâche. Il est entraı̂né sur des données acquises, grâce à
un mécanisme d’apprentissage qui agit sur les constituants du réseau afin de réaliser au mieux la tâche souhaitée.[7]
Historique des réseaux de neurones artificiels
— En 1943, le neurophysiologiste Warren McCulloch et le mathématicien Walter Pitts publient un article décrivant
le fonctionnement de neurones en les représentant à l’aide de circuits électriques. Cette représentation sera la
base théorique des réseaux neuronaux.
— En 1957, Frank Rosenblatt invente le perceptron alors qu’il travaillait au laboratoire aéronautique Cornell.
L’invention du perceptron a suscité beaucoup d’enthousiasmes.
— En 1970, Seppo Linnainmaa publie la méthode générale de différenciation automatique (AD) de réseaux
connectés discrets de fonctions différentiables imbriquées. Ceci correspond à la version moderne de back-
propagation, mais n’est pas encore nommé comme tel.
— En 1980, Kunihiko Fukushima publie pour la première fois ses travaux sur le néocognitron, un type de réseau de
neurones artificiels (ANN). La néocognition inspire plus tard les réseaux de neurones convolutionnels (CNN). (la
néocognition a été utilisé pour la reconnaissance de caractères manuscrite et d’autres tâches de reconnaissance
de formes)
L’apprentissage automatique a utilisé des approches algorithmiques pendant plusieurs années, notamment l’ap-
prentissage par arbre de décision, la programmation de la logique inductive, l’apprentissage par renforcement et les
réseaux bayésiens 1
. Mais, aucun n’a atteint l’objectif ultime de l’intelligence artificielle générale.
2.2.4 L’apprentissage automatique et la vision par ordinateur
La vision par ordinateur était l’un des meilleurs domaines d’application pour l’apprentissage automatique depuis
de nombreuses années, bien qu’il requiert encore beaucoup de codage manuel pour faire le travail. Les informaticiens
écrivaient des classificateurs codés à la main tels que des filtres de détection des contours afin que le programme
puisse identifier où un objet commençait et s’arrêtait ; détection de forme pour déterminer si elle avait huit côtés ;
un classificateur pour reconnaı̂tre les lettres S-T-O-P. À partir de tous ces classificateurs codés à la main, ils
développeraient des algorithmes pour donner un sens à l’image et apprendraient pour déterminer s’il s’agissait d’un
signe d’arrêt.
Il ya une raison pour laquelle la vision par ordinateur et la détection d’image n’ont rivalisé avec l’être humain que
très récemment : c’était trop fragile et trop sujet aux erreurs. Le temps et les bons algorithmes d’apprentissage ont
fait toute la différence.
2.3 L’apprentissage profond
1. Un réseau bayésien est en informatique et en statistique un modèle graphique probabiliste représentant des variables aléatoires sous
la forme d’un graphe orienté acyclique.
HAYTAM EL YOUSSFI, PFE: Deep Learning 13

14. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
Figure 2.4 – L’apprentissage profond - l’apprentissage automatique - l’intelligence artificielle
L’apprentissage profond est un ensemble de méthodes d’apprentissage automatique tentant de modéliser avec un
haut niveau d’abstraction des données grâce à des architectures articulées de différentes transformations non linéaires.
Ces techniques ont permis des progrès importants et rapides dans les domaines de l’analyse du signal sonore ou visuel
et notamment de la reconnaissance faciale, de la reconnaissance vocale, de la vision par ordinateur, du traitement
automatisé du langage. Dans les années 2000, ces progrès ont suscité des investissements privés, universitaires et
publics importants, notamment de la part des GAFAM (Google, Apple, Facebook, Amazon, Microsoft). Les techniques
d’apprentissage profond constituent une classe d’algorithmes d’apprentissage automatique qui :
— utilisent différentes couches d’unité de traitement non linéaire pour l’extraction et la transformation des ca-
ractéristiques ; chaque couche prend en entrée la sortie de la précédente ; les algorithmes peuvent être supervisés
ou non supervisés, et leurs applications comprennent la reconnaissance de modèles et la classification statistique ;
— fonctionnent avec un apprentissage à plusieurs niveaux de détail ou de représentation des données ; à travers
les différentes couches, on passe de paramètres de bas niveau à des paramètres de plus haut niveau, où les
différents niveaux correspondent à différents niveaux d’abstraction des données.
Les advantages de l’apprentissage profond :
— Plus de neurones que les réseaux utilisées par l’apprentissage automatique.
— Moyens plus complexes de connecter des couches / neurones dans les réseaux des neurones.
— Plus grand capacité de calcul disponible pour entrainer un réseau.
— Extraction automatique des caractéristiques. [11]
2.4 Les motivations de la classification des images
La classification des images consiste à répartir systématiquement des images selon des classes établies au préalable,
classer une image lui fait correspondre une classe, marquant ainsi sa parenté avec d’autres images.
En général reconnaı̂tre une image est une taché aisée pour un humain au fil de son existence, il a acquis des
connaissances qui lui permettent de s’adapter aux variations qui résultent de conditions différents d’acquisition.il lui
est par exemple relativement simple de reconnaı̂tre un objet dans plusieurs orientations partiellement caché par un
autre de près ou de loin et selon diverses illuminations.
Toutefois les progrès technologiques en terme d’acquisition d’images (microscopes, caméras, capteurs) et de sto-
ckage engendrent des bases de données riche en information et multiplient les domaines d’applications, il devient
alors difficile pour l’humain d’analyser le nombre important d’images, le temps requis le caractère répétitif de la tâche
et la concentration nécessaire sont problématiques. Toutefois celle-ci n’est pas forcément aisée pour un programme
informatique pour lequel une image est un ensemble de valeur numérique .
L’objectif de la classification d’images est d’élaborer un système capable d’affecter une classe automatiquement à
une image. Ainsi, ce système permet d’effectuer une tâche d’expertise qui peut s’avérer coûteuse à acquérir pour un
être humain en raison notamment de contraintes physiques comme la concentration, la fatigue ou le temps nécessité
par un volume important de données images .
Les applications de la classification automatique d’images sont nombreuses et vont de l’analyse de documents à la
médecine en passant par le domaine militaire. Ainsi on retrouve des applications dans le domaine médical comme la
reconnaissance de cellules et de tumeurs, la reconnaissance d’écriture manuscrite pour les chèques les codes postaux.
Dans le domaine urbain comme la reconnaissance de panneaux de signalisation la reconnaissance de piétons la détection
HAYTAM EL YOUSSFI, PFE: Deep Learning 14

15. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
de véhicules la reconnaissance de bâtiments pour aider à la localisation. Dans le domaine de la biométrie comme la
reconnaissance de visage, d’empreintes, d’iris.
Le point commun à toutes ces applications est qu’elles nécessitent la mise en place d’une chaı̂ne de traitement à
partir des images disponibles composée de plusieurs étapes afin de fournir en sortie une décision. Chaque étape de la
mise en place d’un tel système de classification nécessite la recherche de méthodes appropriées pour une performance
globale optimale à savoir la phase d’extraction de caractéristiques et la phase d’apprentissage. Typiquement, nous
disposons de données images desquelles il nous faut extraire des informations pertinentes traduites sous formes de
vecteurs numériques. Cette phase d’extraction nous permet de travailler dans un espace numérique. Il s’agit ensuite
d’élaborer dans la phase d’apprentissage, à partir de ces données initiales, une fonction de décision pour décider de
l’appartenance d’une donnée nouvelle à l’une des classes en présence.
2.5 Notions de base
2.5.1 Définition d’une image numérique
Une image est une représentation planaire d’une scène ou d’un objet situé en général dans un espace tridimensionnel,
elle est issue du contact des rayons lumineux provenant des objets formants la scène avec un capteur (caméra, scanner,
rayons X, ...). Il ne s’agit en réalité que d’une représentation spatiale de la lumière.
L’image est considérée comme un ensemble de points auquel est affectée une grandeur physique (luminance, cou-
leur). Ces grandeurs peuvent être continues (image analogique) ou bien discrètes (images digitales). Mathématiquement,
l’image représente une fonction continue IF, appelée fonction image , de deux variables spatiales représentée par
IF(x, y) mesurant la nuance du niveau de gris de l’image aux coordonnées (x, y).
La fonction Image peut se représenter sous la forme suivante :
F : R2
→ R avec R l’ensemble de réels.
(x, y) → F(x, y) avec x,y : deux variables réelles.
— Image couleur RVB :L’oeil humain analyse la couleur à l’aide de trois types de cellules photo ”les cônes”
. Ces cellules sont sensibles aux basses, moyennes, ou hautes fréquences (rouge,vert,bleu). Pour représenter la
couleur d’un pixel, il faut donc donner trois nombres, qui correspondent au dosage de trois couleurs de base :
Rouge, Vert, Bleu. On peut ainsi représenter une image couleur par trois matrices chacune correspondant à
une couleur de base.
— Image d’intensité :C’est une matrice dans laquelle chaque élément est un réel compris entre 0 (noir) et 1
(blanc). On parle aussi d’image en niveaux de gris, car les valeurs comprises entre 0 et 1 représentent les
différents niveaux de gris.
— Image binaire :Une image binaire est une matrice rectangulaire dans l’élément valent 0 ou 1. Lorsque l’on
visualise une telle image, les 0 sont représentés par du noir et les 1 par du blanc.
2.5.2 Caractéristiques de l’image
L’image est un ensemble structuré d’information caractérisé par les paramètres suivants :
— Pixel : Le pixel est l’abréviation du mot Picture élément est une unité de surface permettant de définir la
base d’une image numérique. Il matérialise un point donné (x, y) du plan de l’image. L’information présentée
par le pixel est le niveau de gris (ou la couleur) prélevée à l’emplacement correspondant dans l’image réelle.
La différence entre image monochrome et image couleur réside dans la quantité d’informations contenue dans
chaque pixel, par exemple dans une image couleur (RVB : Rouge, Vert, Bleu) la valeur d’un pixel est représentée
sur trois octets pour chaque couleur.
— Dimension et Résolution :La dimension est la taille de l’image. Elle se présente sous forme d’une matrice
dont les éléments sont des valeurs numériques représentatives des intensités lumineuses (pixels). Le nombre
de lignes de cette matrice multiplié par le nombre de colonnes nous donne le nombre total de pixels dans une
image.
Par contre, la résolution est la clarté ou la finesse de détails atteinte par un moniteur ou une imprimante dans
la production d’images. Sur les moniteurs d’ordinateur, la résolution est exprimée en nombre de pixels par unité
de mesure (pouce ou centimètre). On utilise aussi le mot résolution pour désigner le nombre total de pixels
horizontaux et verticaux sur un moniteur. Plus ce nombre est grand, plus la résolution est meilleure.
— Voisinage : Le plan de l’image est divisé en termes de formes rectangulaires ou hexagonales permettant ainsi
l’exploitation de la notion de voisinage (voir figure). Le voisinage d’un pixel est formé par l’ensemble des pixels
qui se situent autour de ce même pixel. On définit aussi l’assiette comme étant l’ensemble de pixels définissant
le voisinage pris en compte autour d’un pixel.
On distingue deux types de voisinage :
HAYTAM EL YOUSSFI, PFE: Deep Learning 15

16. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
— Voisinage à 4 : On ne prend en considération que les pixels qui ont un coté commun avec le pixel considéré.
P(i,j-1)
P(i-1,j) P(i,j) P(i+1,j)
P(i,j+1)
Table 2.1 – Voisinnage à 4
— Voisinage à 8 : On prend en compte tous les pixels qui ont au moins un point en liaison avec le pixel
considéré.
P(i-1,j-1) P(i,j-1) P(i+1,j-1)
P(i-1,j) P(i,j) P(i+1,j)
P(i-1,j+1) P(i,j+1) P(i+1,j+1)
Table 2.2 – Voisinnage à 8
— Niveau de gris : C’est la valeur d’intensité lumineuse d’un pixel. Cette valeur peut aller du noir (0) jusqu’au
blanc (255) en passant par les nuances qui sont contenues dans l’intervalle [0, 255]. Elle correspond en fait à
la quantité de la lumière réfléchie.
Pour 8 bits, on dispose de 256 niveaux de gris dont 40 sont reconnus à l’oeil nue. Plus le nombre de bit est
grand plus les niveaux sont nombreux et plus la représentation est fidèle.
— Contraste : C’est l’opposition marquée entre deux régions d’une image. Une image contrastée présente une
bonne dynamique de la distribution des valeurs de gris sur tout l’intervalle des valeurs possibles, avec des blancs
bien clairs et des noirs profonds. Au contraire une image peu contrastée a une faible dynamique, la plupart des
pixels ayant des valeurs de gris très proches. Si L1 et L2 sont les degrés de luminosité respectivement de deux
zones voisines A1 et A2 d’une image, le contraste est défini par le rapport :
C = L1−L2
L1+L2
— Luminance : C’est le degré de luminosité des points de l’image. Elle est définie aussi comme étant le quotient
de l’intensité lumineuse d’une surface par l’aire apparente de cette surface, pour un observateur lointain, le mot
luminance est substitué au mot brillance, qui correspond à l’éclat d’un objet.
Une bonne luminance se caractérise par :
— Des images lumineuses (brillantes)
— Un bon contraste : il faut éviter les images où la gamme de contraste tend vers le blanc ou le noir ; ces
images entraı̂nent des pertes de détails dans les zones sombres ou lumineuses.
— L’absence de parasites.
— Bruit : Un bruit (parasite) dans une image est considéré comme un phénomène de brusque variation de
l’intensité d’un pixel par rapport à ses voisins, il provient de l’éclairage des dispositifs optiques et électroniques
du capteur. C’est un parasite qui représente certains défauts (poussière, petits nuages, baisse momentanée
de l’intensité électrique sur les capteurs, ...etc.). Il se traduit par des taches de faible dimension et dont la
distribution sur l’image est aléatoire.
— Contour : Les contours représentent la frontière entre les objets de l’image, ou la limite entre deux pixels dont
les niveaux de gris représentant une différence significative. Dans une image numérique, les contours se situent
entre les pixels appartenant à des régions ayant des intensités moyennes différentes ; il s’agit de contours de type
” saut d’amplitude ”. Un contour peut également correspondre à une variation locale d’intensité présentant un
maximum ou un minimum ; il s’agit alors de contour ”en toit ”.
2.6 Classification des images et l’apprentissage machine
Les méthodes manuelles se sont avérées très difficiles à appliquer pour des tâches en apparence très simples comme
la classification des images, la reconnaissance d’objets dans les images ou la reconnaissance vocale. Les données venant
du monde réel les échantillons d’un son ou les pixels d’une image sont complexes, variables et entachées de bruit.
Pour une machine, une image est un tableau de nombres indiquant la luminosité (ou la couleur) de chaque pixel, et
un signal sonore une suite de nombres indiquant la pression de l’air à chaque instant.Comment une machine peut-
elle transcrire la suite de nombres d’un signal sonore en série de mots tout en ignorant le bruit ambiant,
l’accent du locuteur et les particularités de sa voix ? Comment une machine peut-elle identifier un chien ou
une chaise dans le tableau de nombres d’une image quand l’apparence d’un chien ou d’une chaise et des
objets qui les entourent peut varier infiniment ?
HAYTAM EL YOUSSFI, PFE: Deep Learning 16

17. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
Il est virtuellement impossible d’écrire un programme qui fonctionnera de manière robuste dans toutes les situations.
C’est là qu’intervient l’apprentissage machine (que l’on appelle aussi apprentissage automatique). C’est l’apprentissage
qui anime les systèmes de toutes les grandes entreprises d’Internet.
Elles l’utilisent depuis longtemps pour filtrer les contenus indésirables, ordonner des réponses à une recherche, faire
des recommandations, ou sélectionner les informations intéressantes pour chaque utilisateur.
Un système entraı̂nable peut être vu comme une boite noire avec une entrée, par exemple une image, un son, ou
un texte, et une sortie qui peut représenter la catégorie de l’objet dans l’image, le mot prononcé, ou le sujet dont parle
le texte. On parle alors de systèmes de classification ou de reconnaissance des formes.
Dans sa forme la plus utilisée, l’apprentissage machine est supervisé : on montre en entrée de la machine une photo
d’un objet, par exemple une voiture, et on lui donne la sortie désirée pour une voiture. Puis on lui montre la photo d’un
chien avec la sortie désirée pour un chien. Après chaque exemple, la machine ajuste ses paramètres internes de manière
à rapprocher sa sortie de la sortie désirée. Après avoir montré à la machine des milliers ou des millions d’exemples
étiquetés avec leur catégorie, la machine devient capable de classifier correctement la plupart d’entre eux. Mais ce qui
est plus intéressant, c’est qu’elle peut aussi classifier correctement des images de voiture ou de chien qu’elle n’a jamais
vues durant la phase l’apprentissage. C’est ce qu’on appelle la capacité de généralisation.
Jusqu’à récemment, les systèmes de reconnaissance des images classiques étaient composés de deux blocs : un
extracteur de caractéristiques (feature extractor en anglais), suivi d’un classifieur entraı̂nable simple. L’extracteur de
caractéristiques est programmé à la main, et transforme le tableau de nombres représentant l’image en une série de
nombres, un vecteur de caractéristiques, dont chacun indique la présence ou l’absence d’un motif simple dans l’image.
Ce vecteur est envoyé au classifieur, dont un type commun est le classifieur linéaire. Ce dernier calcule une somme
pondérée des caractéristiques : chaque nombre est multiplié par un poids (positif ou négatif) avant d’être sommé. Si
la somme est supérieure à un seuil, la classe est reconnue. Les poids forment une sorte de ’prototype’ pour la classe à
laquelle le vecteur de caractéristiques est comparé. Les poids sont différents pour les classifieurs de chaque catégorie,
et ce sont eux qui sont modifiés lors de l’apprentissage. Les premières méthodes de classification linéaire entraı̂nable
datent de la fin des années cinquante et sont toujours largement utilisées aujourd’hui. Elles prennent les doux noms
de perceptron ou régression logistique .
2.7 Classification des images et les réseaux de neurones profonds
Le problème de l’approche classique de la reconnaissance des images est qu’un bon extracteur de caractéristiques
est très difficile à construire, et qu’il doit être repensé pour chaque nouvelle application.
C’est là qu’intervient l’apprentissage profond ou deep learning en anglais. C’est une classe de méthodes dont les
principes sont connus depuis la fin des années 1980, mais dont l’utilisation ne s’est vraiment généralisée que depuis
2012, environ.
L’idée est très simple : le système entraı̂nable est constitué d’une série de modules, chacun représentant une étape de
traitement. Chaque module est entraı̂nable, comportant des paramètres ajustables similaires aux poids des classifieurs
linéaires. Le système est entraı̂né de bout en bout : à chaque exemple, tous les paramètres de tous les modules sont
ajustés de manière à rapprocher la sortie produite par le système de la sortie désirée. Le qualificatif profond vient de
l’arrangement de ces modules en couches successives.
Pour pouvoir entraı̂ner le système de cette manière, il faut savoir dans quelle direction et de combien ajuster chaque
paramètre de chaque module. Pour cela il faut calculer un gradient, c’est-à-dire pour chaque paramètre ajustable, la
quantité par laquelle l’erreur en sortie augmentera ou diminuera lorsqu’on modifiera le paramètre d’une quantité
donnée. Le calcul de ce gradient se fait par la méthode de rétropropagation, pratiquée depuis le milieu des années
1980.
Dans sa réalisation la plus commune, une architecture profonde peut être vue comme un réseau multicouche
d’éléments simples, similaires aux classifieurs linéaires, interconnectés par des poids entraı̂nables. C’est ce qu’on appelle
un réseau neuronal multicouche .
Pourquoi neuronal ? Un modèle extrêmement simplifié des neurones du cerveau les voit comme calculant une
somme pondérée et activant leur sortie lorsque celle-ci dépasse un seuil. L’apprentissage modifie les efficacités des
synapses, les poids des connexions entre neurones. Un réseau neuronal n’est pas un modèle précis des circuits du
cerveau, mais est plutôt vu comme un modèle conceptuel ou fonctionnel. Le réseau neuronal est inspiré du cerveau un
peu comme l’avion est inspiré de l’oiseau.
Ce qui fait l’avantage des architectures profondes, c’est leur capacité d’apprendre à représenter le monde de manière
hiérarchique. Comme toutes les couches sont entraı̂nables, nul besoin de construire un extracteur de caractéristiques à
la main. L’entraı̂nement s’en chargera. De plus, les premières couches extrairont des caractéristiques simples (présence
de contours) que les couches suivantes combineront pour former des concepts de plus en plus complexes et abstraits :
assemblages de contours en motifs, de motifs en parties d’objets, de parties d’objets en objets, etc
2.8 Révolution d’apprentissage profond
HAYTAM EL YOUSSFI, PFE: Deep Learning 17

18. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
2.8.1 L’évolution des CPU et des GPU
2.8.1.1 L’unité centrale de traitement
L’unité centrale de traitement est le cerveau des ordinateurs et plusieurs dispositifs électroniques, c’est un composant
éléctrique (une collection de millions de transistors) qui exécute les instructions d’un programme d’ordinateur en
effectuant des opérations arithmétiques, logiques, de contrôle etles opérations d’entrée et de sortie spécifiées par les
instructions.
2.8.1.2 L’unité graphique de traitement
Un processeur graphique, ou GPU , est un circuit intégré présent la plupart du temps sur une carte graphique
(mais pouvant aussi être intégré sur une carte-mère ou dans un CPU) et assurant les fonctions de calcul de l’affichage.
Un processeur graphique a généralement une structure hautement parallèle (voir accélération matérielle) qui le rend
efficace pour une large palette de tâches graphiques comme le rendu 3D, en Direct3D ou en OpenGL, la gestion
de la mémoire vidéo, le traitement du signal vidéo, la décompression Mpeg, etc. Leur parallélisme massif les rend
aussi intéressants comme processeurs de calcul matriciel, ou pour des cassages de code en force brute d’archives
chiffrées.
2.8.1.3 L’unité graphique de traitement et l’apprentissage profond
La différence entre une unité centrale de traitementet une unité graphique de traitement est la manière de gestion
des capacités, l’unité centrale de traitement est un processeur à usage général, qui est bonne lorsqu’on l’utilise pour
traiter des sons, visuals, fichiers textuelles ... etc, mais pour le domaine de traitement des images, on a besoin d’un
processeur dédié à traiter une seule tâche, traiter et visualiser les images, un processeur qui a la capacité de traiter
une immense quantité de données, qui représentent des images à deux dimensions ou 3 dimensions, c’est-à-dire qu’il
peut appliquer les différentes operations de la géometrie et les transformations sur ces images comme :
— la translation
— la rotaion
— la réfléxion
— l’homothétie
. L’unité centrale de traitement n’est pas le meilleure choix, parce qu’il est composé de seulement quelques cœurs avec
beaucoup de mémoire cache pouvant gérer plusieurs threads logiciels à la fois, même que chaque coeur de ce processeur
est forte, chaque coeur du processeur est adapté à traister une seule instruction par cycle d’horloge, c’est-à-dire qu’il
traite l’ensemble des instructions d’une manière linéaire, une instruction aprés l’autre (processeur scalaire).
HAYTAM EL YOUSSFI, PFE: Deep Learning 18

19. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
En revanche, l’unité graphique de traitement est composé de centaines de cœurs pouvant gérer des milliers de
threads simultanément. La capacité d’un processeur graphique doté de plus de 100 cœurs à traiter des milliers de
threads peut accélérer certains logiciels 100 fois par rapport à une unité centrale de traitement uniquement. De plus,
le GPU réalise cette accélération tout en étant plus économique au niveau dénergie et aussi au niveau de coût qu’un
unité centrale de traitement.
En plus, les unités graphiques de traitement utilisent le modèle pipeline graphique sa principale fonction est de
générer ou de restituer une image en deux dimensions, à partir d’une caméra virtuelle, d’objets en trois dimensions,
de sources de lumière, etc. Le pipeline de rendu est donc l’outil sous-jacent du rendu en temps réel.Les emplacements
et les formes des objets dans l’image sont déterminés par leur géométrie, les caractéristiques de l’environnement et
l’emplacement de la caméra dans cet environnement. est affecté par les propriétés des matériaux, les sources de lumière,
les textures (images appliquées aux surfaces) et les équations d’ombrage.[2]
Principe de pipeline graphique
Un pipeline graphique peut être divisé en trois parties principales : Application, Géométrie et Rastérisation.
Application : Le fichier contenant le graphique que l’on veut traiter est chargé du disque vers la RAM, l’unité
centrale de traitement envoie des informations et des commandes au l’unité graphique de traitement en passant par
le tampon de commandes, ces informations seront stockées dans la VRAM, pour que le traitement soit vite, puisque
de l’unité graphique de traitement avec la VRAM et plus vite que avec la RAM.
Géométrie Dans cette partie, les graphiques sont représentés par des vertices (sommets), qui sont des structures des
données qui décrivent certains attributs, comme la position d’un point dans un espace 2D ou 3D, ou plusieurs points
sur une surface.
L’unité graphique de traitement les traite en deux étapes :
— L’étape de filtrage de vertices : les vertices sont transformés en ”espace de vue” tel que chaque vertex est
transformé indépendament.
HAYTAM EL YOUSSFI, PFE: Deep Learning 19

20. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
— L’étape de traitement primitif : les vertives organisés en primitives (triangulaires) :
Rastérisation
— Premièrement, les primitives sont pixellisées en fragments de pixels tel que chaque primitive est pixellisée
indépendament.
— Deuxièmement, on calcule chaque le couleur de chaque pixel.
HAYTAM EL YOUSSFI, PFE: Deep Learning 20

21. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
— Troisièmement, Les fragments sont mélangés dans le framebuffer à leur emplacement de pixel (le z-buffer
détermine la visibilité).[2]
Les entitées du pipeline :
En conclusion, la bonne qualité de la performance de l’unité graphique de traitement aide les scientifiques de réaliser
des évolutions dans le domaine de traitement des images, ce qui aide a appliquer les algorithmes de l’apprentissage
profond pour la recaonnaissance des images d’une manière developpé et efficace.
2.8.2 Les nouvelles architectures de réseaux des neurones utilisés par l’apprentissage
profond
2.8.2.1 Les réseaux de neurones convolutifs
HAYTAM EL YOUSSFI, PFE: Deep Learning 21

22. CHAPITRE 2. L’APPRENTISSAGE AUTOMATIQUE ET LA CLASSIFICATION
Les réseaux de neurones convolutifs (CNN) ont émergé de l’étude du cortex visuel du cerveau et sont utilisés dans la
reconnaissance d’image depuis les années 1980. Au cours des dernières années, grâce à l’augmentation de la
puissance de calcul, à la quantité de données d’apprentissage disponibles, les CNN ont réussi à atteindre des
performances surhumaines dans certaines tâches visuelles complexes. Ils alimentent les services de recherche
d’images, les voitures autonomes, les systèmes de classification automatique des vidéos, etc. De plus, les CNN ne se
limitent pas à la perception visuelle : ils réussissent également à d’autres tâches, telles que la reconnaissance vocale
ou le traitement du langage naturel.[8]
2.8.2.2 Les réseaux de neurones récurrents
Les réseaux de neurones récurrents (RNN) constituent une classe de réseaux pouvant prédire l’avenir (jusqu’à un
certain point, bien sûr). Ils peuvent analyser des données de séries chronologiques telles que les cours des actions et
vous indiquer quand acheter ou vendre. Dans les systèmes de conduite autonome, ils peuvent anticiper les
trajectoires des voitures et éviter les accidents. Plus généralement, ils peuvent travailler sur des séquences de
longueurs arbitraires, plutôt que sur des entrées de taille fixe comme tous les réseaux décrits précédemment. Par
exemple, ils peuvent prendre des phrases, des documents ou des échantillons audio en entrée, ce qui les rend
extrêmement utiles pour les systèmes de traitement du langage naturel (PNL) tels que la traduction automatique, la
synthèse vocale ou l’analyse des sentiments (par exemple, la lecture de critiques de films et l’extraction du sentiment
de l’évaluateur à propos du film).
De plus, la capacité d’anticipation des RNN les rend également capables d’une créativité surprenante. Vous pouvez
leur demander de prédire quelles sont les prochaines notes les plus probables d’une mélodie, puis choisissez-en une au
hasard et jouez-la. Ensuite, demandez au réseau les notes les plus probables, jouez-le et répétez le processus encore
et encore. Avant que vous ne le sachiez, votre réseau composera une mélodie telle que celle produite par le projet
Google de Magenta. De même, les RNN peuvent générer des phrases, des légendes d’images et bien plus encore.[8]
2.9 Conclusion
Nous avons consacré ce chapitre à la présentation l’apprentissage automatique et en particulier l’apprentissage
profond en des notions de la classification ainsi que leurs intérêts dans le domaine d’imagerie et on a parlé aussi de
l’utilisation des réseaux de neurones dans ce domaine. Dans le deuxième chapitre nous allons détailler les réseaux de
neurones et plus précisément l’utilisation des réseaux de neurones convolutionnels dans la classification des images.
HAYTAM EL YOUSSFI, PFE: Deep Learning 22

23. Chapitre 3
Modélisation des neurones
3.1 Introduction
Les réseaux des neurones artificiels sont des structures la plupart du temps simulées par des algorithmes exécutés
sur les ordinateurs d’usage général, parfois sur des machines ou même des circuits spécialisés, qui prennent leurs ins-
pirations à partir du fonctionnement élémentaire des systèmes nerveux. Ils sont utilisés essentiellement pour résoudre
des problèmes de classification, de reconnaissance de formes, d’association, d’extraction de caractéristique, et d’iden-
tification .
Dans ce chapitre nous allons parler sur un neurone artificiel et la signification un réseau de neurone mul-
ticouches (perceptron multicouche) et des différents hyperparamétres qui influencent sur notre modèle
neuronal ?
3.2 Les neurones biologiques
Un neurone, ou cellule nerveuse, est une cellule excitable constituant l’unité fonctionnelle de base du système
nerveux. Les neurones assurent la transmission d’un signal bioélectrique appelé influx nerveux. Ils ont deux propriétés
physiologiques : l’excitabilité :la capacité de répondre aux stimulations et de convertir celles-ci en impulsions nerveuses,
et la conductivité, c’est-à-dire la capacité de transmettre les impulsions.
Structure :On pense que le système nerveux compte plus de 1000 milliards de neurones interconnectés. Bien que les
neurones ne soient pas tous identiques, leur forme et certaines caractéristiques permettent de les répartir en quelques
grandes classes. En effet, il est aussi important de savoir, que les neurones n’ont pas tous un comportement similaire
en fonction de leur position dans le cerveau. Avant de rentrer plus en avant dans les détails, examinons un neurone.
Figure 3.1 – Schèma d’un neurone biologie
les principales parties d’un nourone :
— Les synapses sont la jonction de connexion entre axone et dendrites. La majorité des synapses envoient des
signaux de l’axone d’un neurone à la dendrite d’un autre neurone. Les exceptions pour ce cas sont lorsqu’un
neurone peut manquer de dendrites, ou d’un neurone, d’un axone, ou d’une synapse, qui connecte un axone à
un autre axone.
23

24. CHAPITRE 3. MODÉLISATION DES NEURONES
— Les dendrites ont des fibres qui sortent du corps cellulaire dans un réseau broussailleux autour de la cellule
nerveuse. Les dendrites permettent à la cellule de recevoir des signaux de neurones voisins connectés et chaque
dendrite peut effectuer une multiplication par la valeur de poids de ce dendrite. Par multiplication, on entend
une augmentation ou une diminution du rapport neurotransmetteur synaptique aux signaux chimiques introduits
dans la dendrite.
— Les axones sont les fibres simples et longues qui s’étendent du corps cellulaire principal. Ils s’étendent sur des
distances plus longues que les dendrites et mesurent généralement 1 centimètre de long (100 fois le diamètre
du soma). Finalement, l’axone se ramifiera et se connectera à d’autres dendrites. Les neurones sont capables
d’envoyer des impulsions électrochimiques par le biais de changements de tension transmembranaires générant
un potentiel d’action. Ce signal se déplace le long de l’axone de la cellule et active les connexions synaptiques
avec d’autres neurones.
Il existe deux propriétés principales des réseaux de neurones artificiels qui suivent l’idée générale du fonctionnement du
cerveau. Premièrement, l’unité la plus fondamentale du réseau neuronal est le neurone artificiel. Les neurones artificiels
sont modelés sur les neurones biologiques du cerveau et, comme les neurones biologiques, ils sont stimulés par des
entrées. Ces neurones artificiels transmettent certaines informations qu’ils reçoivent à d’autres neurones artificiels,
souvent avec des transformations.
Deuxièmement, comme les neurones du cerveau peuvent être entraı̂nés à ne transmettre que les signaux utiles pour
atteindre les objectifs plus vastes du cerveau, nous pouvons former les neurones d’un réseau neuronal pour qu’ils ne
transmettent que des signaux utiles.
3.3 Modélisation d’un neurone artificiel
Un neurone artificiel est une fonction mathématique conçue comme un modèle de neurones biologiques. Le neurone
artificiel reçoit une ou plusieurs entrées et les additionne pour produire une sortie (ou une activation représentant le
potentiel d’action d’un neurone qui est transmis le long de son axone). Généralement, chaque entrée est pondérée
séparément : Pn
i=1 pixi
cette la somme est transmise à une fonction non linéaire appelée fonction d’activation ou fonction de transfert afin
que les résultats soient précis. Les fonctions de transfert ont généralement une forme sigmoı̈de, mais elles peuvent
également prendre la forme d’autres fonctions non linéaires, de fonctions linéaires par morceaux ou de fonctions de
pas. Ils sont aussi souvent en augmentation monotone, continue, différenciable et bornée.
Dans de nombreux contextes, il existe une partie invariante de la prédiction, appelée biais, ajoutée au somme du com-
binaison linéaire du poids et entrées. Par exemple, considérons un paramètre dans lequel les variables de caractéristique
sont centrées sur la moyenne, mais la moyenne de la prédiction de classe binaire à partir de
−1, +1
n’est pas égale
à 0. Cela aura tendance à se produire dans les cas où la distribution de classe binaire est fortement déséquilibré.[10]
Nous devons incorporer une variable de biais supplémentaire b qui capture cette partie invariante de la prédiction :
Pn
i=1 pixi + θ
3.4 Le perceptron simple
Figure 3.2 – Représentation d’un perceptron mono-couche
HAYTAM EL YOUSSFI, PFE: Deep Learning 24

25. CHAPITRE 3. MODÉLISATION DES NEURONES
Le premier neuro-ordinateur a été créé en 1957, par Frank Rosenblatt au laboratoire aérospatial de l’Université
Cornell. C’est un modèle inspiré des théories cognitives de Friedrich Hayek et de Donald Hebb. Il s’agit d’un neurone
formel muni d’une règle d’apprentissage qui permet de déterminer automatiquement les poids synaptiques de manière
à séparer un problème d’apprentissage supervisé. Si le problème est linéairement séparable, un théorème assure que la
règle du perceptron permet de trouver une séparatrice entre les deux classes.
Le perceptron peut être vu comme le type de réseau de neurones le plus simple. c’est un classifieur linéaire. Ce type
de réseau neuronal ne contient aucun cycle (il s’agit d’un réseau de neurones à propagation avant). Dans sa version
simplifiée, le perceptron est mono-couche et n’a qu’une seule sortie à laquelle toutes les entrées sont connectées et les
entrées et la sortie sont booléennes. Plus généralement, les entrées peuvent être des nombres réels.[12]
On peut décrire l’apprentissage du perceptron en trois étapes :
Première étape : La combinaison linéaire des entrées : chaque valeur de la liste en entrée est associée à sa valeur
de poids. De plus, la somme prend souvent une valeur d’entrée supplémentaire θ avec une valeur de poids de 1 pour
représenter le biais d’un neurone.
Deuxième étape : Pour produire une sortie du neurone, nous allons ensuite appliquer la fonction d’activation (la
fonction de Heaviside) sur le somme
Pn
i=1 pixi + θ , comme le montre l’équation suivante :
Avec :
Troisième étape : La mise à jour des poids synaptiques (Correction) : utilisé pour trouve les meilleurs valeurs des
poids synaptiques qui peuvent assurer la bonne prédiction des résultats du neurone.
Il existe deux règles populaires de mise à jour du poids :
3.4.1 Régles d’apprentissages de HEB et Frank Rosenblatt
La règle de Hebb, établie par Donald Hebb, est une règle d’apprentissage des réseaux de neurones artificiels dans
le contexte de l’étude d’assemblées de neurones.
• Cette règle suggère que lorsque deux neurones sont excités conjointement, il se crée ou renforce un lien les unissant.
p0
i = pi + α(Y.Xi)
où p0
i représente le poids i corrigé et α représente le pas d’apprentissage(Taux d’apprentissage).
Le perceptron de Frank Rosenblatt est très proche de la règle de Hebb, la grande différence étant qu’il tient compte
de l’erreur observée en sortie.
Cette fonction est recommandée lorsque la tangente hyperbolique (tanh) est utilisée comme fonction d’activation.
En conclusion, on peut donner la règle d’apprentissage de perceptron comme suit :
HAYTAM EL YOUSSFI, PFE: Deep Learning 25

26. CHAPITRE 3. MODÉLISATION DES NEURONES
Result : Minimum local d’erreur
1 Initialiser les poids au hasard;
2 TantQue divergence Faire
3 Pour chaque paire / motif d’entraı̂nement (x,ycible) Faire
4 Applique la fonction Heaviside :y = f(
Pn
i=1 pixi);
5 Calculer l’erreure E : E = ycible − y;
6 Mettre à jour les poids : pi = pi + η × E × x;
7 avec η est le pas d’apprentissage;
8 FinPour
9 FinTantQue
Algorithme 1 : La règle d’apprentissage de perceptron
3.4.2 La descente du gradient
L’entraı̂nement d’un perceptron est donc un processus itératif. Après chaque observation, nous allons ajuster les
poids de connexion de sorte à réduire l’erreur de prédiction faite par le perceptron dans son état actuel. Pour cela,
nous allons utiliser l’algorithme du gradient : le gradient nous donnant la direction de plus grande variation d’une
fonction (dans notre cas, la fonction d’erreur), pour trouver le minimum local de cette fonction il faut se déplacer dans
la direction opposée au gradient.Lorsque la fonction est minimisée localement, son gradient est égal à 0.
Figure 3.3 – Un déplacement dans le sens opposé au gradient (fléche Rose ) raproche Wj de la valeur minimisant
l’erreur (point orange)
C’est-à-dire , on doit minimiser l’erreur suivante, avec c : sortie cible et r :sortie réelle : E = 1
2
P
(c − r)2
Mathématiquement, cela signifie que nous examinons la dérivée de l’erreur par rapport au poids, qui représente le
changement de l’erreur dépendant du changement du poids.
Pour un nouvel exemple d’entraı̂nement X = (x1, x2,. . . , xn),on met à jour chaque poid en utilisant la règle
suivante :
pj = pj + ∆pj
avec : ∆pj = −η ∂E
∂pj
Premièrement, on doit calculer la dirivée de l’erreure :
HAYTAM EL YOUSSFI, PFE: Deep Learning 26

27. CHAPITRE 3. MODÉLISATION DES NEURONES
∂E
∂pj
=
∂( 1
2
P
(c−r)2
)
∂pj
∂E
∂pj
= 1
2
P
2(cs − rs)∂(−r)
∂pj
∂E
∂pj
=
P
(c − r)∂(−r)
∂pj
Ensuite, on calcule ∂(−r)
∂pj
:
∂(−r)
∂pj
= ∂(−f(somme))
∂pj
avec :f : fonction d’activation et somme =
Pn
i=1 pixi
∂(−f(somme))
∂pj
= ∂(−f(somme))
∂somme × ∂somme
∂pj
On a :
∂somme
∂pj
=
∂
Pn
i=1 pixi
∂pj
= ∂(p1x1+p2x2+.....+pnxn)
∂pj
= ∂(p1x1)
∂pj
+ .... +
∂(pj xj )
∂pj
+ ..... + ∂(pnxn)
∂pj
= xj
à cette étape, il nous reste que calculer ∂(−f(somme))
∂somme ; ça depend de la fonction d’activation choisi.
pj = pj − η ∂(−f(somme))
∂somme
P
(c − r)xj
[1]
3.4.3 Comment représenter les données en Machine Learning ?
En machine Learning, les données sont le nerf de la guerre. Et vu leur importance alors dans notre article on va
traiter comment représenter les données en machine learning et les types de données les plus souvent rencontrés.
Les types de données majeurs :
1. Données quantitatives : Les données quantitatives représentent une mesure de quelque chose. Elles peuvent
être de deux types :
Continue :Les valeurs que peut prendre une donnée numérique continue sont infinies. elles représentent une
mesure d’une quantité. Par exemple le poids en Kg d’une personne, la distance entre deux ville en Km. . .
Discrète : Il s’agit généralement d’un comptage d’un événement. Par exemple : Le nombre d’enfants dans
un foyer. Il ne peut pas avoir 2,5 enfants dans un foyer.
2. Données qualitatives : Les données qualitatives sont aussi nommées des modalités.Une donnée qualitative
n’a pas une sémantique mathématique. Elles apporte une information sur une caractéristique d’un individu
observé.
Exemple de modalité :
— Sexe d’une personne (Homme / Femme)
— Pays de naissance d’une personne
— Race d’un chien
3. Données ordinales : Les données ordinales sont un “mix” entre les données quantitatives et qualitatives. Ils
s’agit de catégories/modalités ordonnées et qui ont une signification mathématique.
Prenons l’exemple des notes données par un client pour un produit sur un site e-commerce. Une étoile signifie
qualité médiocre, et 5 étoiles signifie un produit excellent. Le nombre d’étoiles représentent une modalité (5
modalités si le nombre d’étoiles qu’on peut assigner à un produit est égale à 5). On peut, par exemple, ordonner
les produits par qualité en fonction du nombre d’étoiles.
Représentation des données : Cross Validation : La validation croisée va nous permettre d’utiliser
l’intégralité de notre jeu de données pour l’entraı̂nement et pour la validation .Voilà comment ça marche :
On découpe le jeu de données en k parties (folds en anglais) à peu près égales. Tour à tour, chacune des k parties
est utilisée comme jeu de test. Le reste (autrement dit, l’union des k-1 autres parties) est utilisé pour l’entraı̂nement.
HAYTAM EL YOUSSFI, PFE: Deep Learning 27

28. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.4 – Une cross-validation à 5 folds : Chaque point appartient à 1 des 5 jeux de test (en blanc) et aux 4
autres jeux d’entraı̂nements (en orange)
À la fin, chaque point (ou observation) a servi 1 fois dans un jeu de test, (k-1) fois dans un jeu d’entraı̂nement. J’ai
donc 1 prédiction par point de mon jeu initial, et aucune de ces prédictions n’a été faite avec un jeu d’entraı̂nement
qui contienne ce point. Je n’ai pas violé le principe de ne pas valider sur le jeu d’entraı̂nement !
Je peux finalement rapporter la performance de mon modèle :
— Soit en évaluant les prédictions faites sur l’ensemble des données (puisque j’ai fait une prédiction par point du
jeu de données complet)
— Soit en moyennant les performances obtenues sur les k folds, auquel cas je peux aussi rapporter l’erreur type,
pour quantifier la variation de ces performances sur les k folds.
Figure 3.5 – Représentation visuelle de la validation de train / test et de la validation croisée.
1 importer numpy en tant que np
2 depuis s k l e a r n . c r o s s v a l i d a t i o n importer t r a i n t e s t s p l i t
3 a , b = np . arange ( 10 ) . remodeler (( 5 , 2 ) ) , plage ( 5 )
4 un
5 t a b l e a u ( [ [ 0 , 1 ] , [ 2 , 3 ] , [ 4 , 5 ] , [ 6 , 7 ] , [ 8 , 9 ] ] )
6 l i s t e ( b )
7 [ 0 , 1 , 2 , 3 , 4]
8
9 a t r a i n , a t e s t , b t r a i n , b t e s t = t r a i n t e s t s p l i t (
10 . . . a , b , t e s t s i z e = 0.33 , random state = 42 )
11 . . .
12 a t r a i n
13 a r r a y ( [ [ 4 , 5 ] , [ 0 , 1 ] , [ 6 , 7 ] ] )
14 b t r a i n
15 [ 2 , 0 , 3]
16 un t a b l e a u
17 a t e s t ( [ [ 2 , 3 ] , [ 8 , 9 ] ] )
18 b t e s t
19 [ 1 , 4]
Algorithme de la méthode K-fold cross-validation :
HAYTAM EL YOUSSFI, PFE: Deep Learning 28

29. CHAPITRE 3. MODÉLISATION DES NEURONES
1. Divisez le jeu de données en K partitions égales (ou”K-fold”)
— Donc si K=5 et que le dataset compte 150 observations
— Chacun des 5 fold aurait 30 observations
2. Utilisez le fold 1 comme donnée de test et l’union des autres fold comme jeu d’entrainement
— Ensemble de tests =30 observation
— Ensemble d’entrainement =120 observation (fold 2 à 5)
3. Calculer la précision des tests
4. Répétez les étapes 2 à 3 K fois , en utilisant un fold différent comme set de test et à chaque fois
— Nous allons répéter le processus 5 ( K=5) fois
— 2éme itération
— Le deuxiéme fold serait le jeu de test
— L’union des plis 1,3 et 5 constituerait l’entrainement
— 3éme itération
— Le Fold 3 serait le set de test
— L’union des plis 1,2,4 et 5 constituerait l’entrainement
5. La précision moyenne des tests est l’estimation de la précision sur des données non vues
Train / Test Split : Comme je l’ai dit précédemment, les données que nous utilisons sont généralement divisées en
données d’apprentissage et en données de test. L’ensemble d’apprentissage contient une sortie connue et le modèle
apprend sur ces données pour être généralisé ultérieurement à d’autres données. Nous avons le jeu de données de test
(ou sous-ensemble) afin de tester la prédiction de notre modèle sur ce sous-ensemble.
Figure 3.6 – Train / Test Split
1 import numpy as np
2 from s k l e a r n . m o d e l s e l e c t i o n import t r a i n t e s t s p l i t
3 X, y = np . arange (10) . reshape ((5 , 2) ) , range (5)
4 X
5 a r r a y ( [ [ 0 , 1 ] , [ 2 , 3 ] , [ 4 , 5 ] , [ 6 , 7 ] , [ 8 , 9 ] ] )
6 l i s t ( y )
7 [ 0 , 1 , 2 , 3 , 4]
8 X train , X test , y t r a i n , y t e s t = t r a i n t e s t s p l i t (
9 . . . X, y , t e s t s i z e =0.33 , random state =42)
10 . . .
11 X t r a i n
12 a r r a y ( [ [ 4 , 5 ] , [ 0 , 1 ] , [ 6 , 7 ] ] )
13 y t r a i n
14 [ 2 , 0 , 3]
15 X t e s t
16 a r r a y ( [ [ 2 , 3 ] ,
17 [ 8 , 9 ] ] )
18 y t e s t
19 [ 1 , 4]
20 t r a i n t e s t s p l i t ( y , s h u f f l e=F a l s e )
21 [ [ 0 , 1 , 2 ] , [ 3 , 4 ] ]
Comparer de la méthode Cross-validation et la méthode de Train/Test split :
Avantages de la méthode de Cross-validation :
— Estimation plus précise de la précision des données non vues
— Utilisation plus ”efficace” des données ( de taille petite) :C’est parce que chaque observation est utilisée à la
fois pour l’entrainement et pour le test.
Avantages de la méthode train / test split :
— Exécute K fois plus rapidement que la validation croisée des K-fold :Cela est dû au fait que la validation croisée
du K-fold répète K fois la méthode train / test split.
HAYTAM EL YOUSSFI, PFE: Deep Learning 29

30. CHAPITRE 3. MODÉLISATION DES NEURONES
— Plus simple pour suivre et examiner les résultats détaillés du processus de test .
3.4.4 Exemple d’application du percetron
Nous savons que la fonction et logique est représentée comme suit :
Entrée x1 Entrée x2 Sortie
0 0 0
0 1 0
1 0 0
1 1 1
On a que la sortie cible = 1 si les entrées sont tous égales à 1, et 0 sinon, prenant par exemple, deux entrées x1
et x2 on a quatre cas :
— cas 1 : x1=1 et x2=1 ⇒ y=1
— cas 2 : x1=0 et x2=1 ⇒ y=0
— cas 3 : x1=1 et x2=0 ⇒ y=0
— cas 4 : x1=0 et x2=0 ⇒ y=0
Sachant que la somme généré par le perceptron est : somme = p1x1 + p2x2 + p0 ;
A partir de la fonction d’activation, la somme obtenu doit être plus ou égale à 0 pour la première cas, et moins
que 0 pour les autres cas ; On prend p1 et p2 égales à 1, il nous reste de déterminer p0 :
— cas 1 : 1 * 1 + 1 * 1 + p0=2+p0
— cas 2 : 1 * 0 + 1 * 1 + p0=1+p0
— cas 3 : 1 * 1 + 1 * 0 + p0=1+p0
— cas 4 : 1 * 0 + 1 * 0 + p0=p0
On obtient les conditions suivants :
— 2+p0 ≥ 0
— 1+p0 0
— p0 0
ce qui donne :
— p0 ≥ -2
— p0 -1
— p0 0
Il suffit de prendre une valeur qui vérifie : -2 ≤ p0 -1 ; on prend p0 = −1.5
On obtient : somme = 1 ∗ x1 + 1 ∗ x2 − 1.5
Et en appliquant la fonction d’activation nous donnera les résultats souhaités ;
— Pour x1 = 1 et x2 = 1, f(1*1+1*1-1.5)=0.5 ≥ 0
— Pour x1 = 1 et x2 = 0, f(1*1+1*0-1.5)=-0.5 0
— Pour x1 = 0 et x2 = 1, f(1*0+1*1-1.5)=-0.5 0
— Pour x1 = 0 et x2 = 0, f(1*0+1*0-1.5)=-1.5 0
avec :
La figure ci-dessous montre les résultats obtenus par le perceptron. le perceptron est capable de tracer une ligne
séparant les deux catégories, on peut remarquer que le point (1,1) qui a une sortie égale à 1 est en haut, tandis que
les autres sont en bas de la ligne (la sortie est 0 dans ce cas), on peut dire que le perceptron a réussi à trouver les
poids précisés pour prédire les sorties.
HAYTAM EL YOUSSFI, PFE: Deep Learning 30

31. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.7 – Graphe de la fonction ET logique
3.4.5 Les mesures de la performance d’un neurone artificiel :
Évaluation du modèle Notre principale objectif lorsqu’on construit un neurone artificiel est de produire des résultats
précis, c’est pourquoi on doit mesurer la performance et la qualité de notre modèle de prédiction utilisé par le neurone,
il y’a des mesures qui peut nous aider à atteindre nous but :
— Taux de réussite
— La précision
— La sensitivité (rappel)
— F-mesure
Ces mesures dépendent sur quatre valeurs : vrais positifs, faux positifs, vrais négatifs et faux négatifs, qui sont
représentés dans la matrice de confusion comme suit :
Véritable condition
Condition positive Condition négative
Condition prévue positive Vrai positif Faux positif
Condition
prévue Condition prévue négative Faux négatif Vrai négatif
Table 3.1 – La matrice de confusion
La matrice de confusion est connue sous le nom de matrice d’erreurs, est un tableau spécifique qui permet de
visualiser les performances d’un algorithme, généralement un algorithme d’apprentissage supervisé. Chaque ligne de la
matrice représente les instances dans une classe prédite, tandis que chaque colonne représente les instances dans une
classe réelle. Le nom découle du fait qu’il est facile de voir si le système confond deux classes.
Le taux de réussite : compte le nombre de points de données dans l’ensemble de test qui ont été prédits correctement
et renvoie ce nombre sous forme de fraction de la taille de l’ensemble de test. S’en tenant à l’exemple de la classification
d’images en tant que chats ou chiens, l’exactitude indique la fraction d’images correctement classées comme contenant
soit un chat, soit un chien. C’est la mesure la plus élémentaire pour les classificateurs. [3]
Le taux de réussite = le nombre de points de données dans l’ensemble de test qui ont été prédits correctement
la taille de l’ensemble de test
L’utilisation de cette mesure est limitée au cas où il n’y a pas une grande différence entre les tailles des deux ensembles
de classes de test ; Prenons par exemple une ensemble de test de 500 points de données représentent deux classes,
classe1 et classe2, 480 points de données représentent une classe1, et 20 points de données représentent l’autre classe,
si tous les points de données de classe1 sont prédit correctement, pendent que les points de données de classe2 ne
sont pas prédit correctement, la résultat du taux de réussite donne :
Le taux de réussite = 480
500 =0.96, cela signifie que la qualité de notre modèle utilisé est trés bonne, tant qu’il prédit
tous les points de données de classe2 incorrectement.
Ce qui veut dire que la mesure taux de réussite n’a aucun validité lorsqu’on a une taille d’une ensemble de points de
données d’une classe plus grande que la taille de l’ensemble de points de données de l’autre classe.
HAYTAM EL YOUSSFI, PFE: Deep Learning 31

32. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.8 – Précision et rappel (recall)
La précision : La précision décrit la capacité d’un classificateur à ne pas étiqueter comme chat une image contenant
un chien. En d’autres termes, sur toutes les images de l’ensemble de tests que le classificateur pense contenir un chat,
la précision est la fraction des images qui contiennent en réalité un chat.[3]
Le précision = le nombre de points de données bien classifiés
la taille de l’ensemble de points bien classifiés plus l’ensemble de points mal classifiés
La sensitivité (rappel) : décrit la capacité d’un classificateur à récupérer toutes les images contenant un chat. En
d’autres termes, sur toutes les images de chats de l’ensemble de tests, le rappel est la fraction d’images qui ont été
correctement identifiées en tant qu’images de chats.[3]
Le précision = le nombre de points de données correctement attribuées à une classei
la taille de l’ensemble de points attribuées à la classei
F-mesure : Une mesure populaire qui combine la précision et le rappel est leur moyenne harmonique, nommée
F-mesure (soit F-measure en anglais) ou F-score :
F-mesure = 2 × précision × rappel
précision + rappel
F1-mesure atteignant sa meilleure valeur à 1 (précision parfaite et rappel) et le pire à 0.
HAYTAM EL YOUSSFI, PFE: Deep Learning 32

33. CHAPITRE 3. MODÉLISATION DES NEURONES
3.4.6 Courbe ROC
Dans le cas d’un classifieur binaire, il est possible de visualiser les performances du classifieur sur ce que l’on appelle
une courbe ROC . La courbe ROC est une représentation du taux de vrais positifs en fonction du taux de faux positifs.
Son intérêt est de s’affranchir de la taille des données de test dans le cas où les données sont déséquilibrées.
Cette représentation met en avant un nouvel indicateur qui est l’aire sous la courbe. Plus elle se rapproche de 1,
plus le classifieur est performant.
Figure 3.9 – Courbe ROC
AUC : aire sous la courbe ROC AUC signifie ”aire sous la courbe ROC” : Cette valeur mesure l’intégralité
de l’aire à deux dimensions située sous l’ensemble de la courbe ROC (par calculs d’intégrales) de (0,0) à (1,1).
Figure 3.10 – AUC (aire sous la courbe ROC).
Les valeurs d’AUC sont comprises dans une plage de 0 à 1. Un modèle dont 100 des prédictions sont erronées a un
AUC de (0,0). Si toutes ses prédictions sont correctes, son AUC est de (1,0). L’AUC présente les avantages suivants :
— L’AUC est invariante d’échelle . Elle mesure la qualité du classement des prédictions, plutôt que leurs valeurs
absolues.
— L’AUC est indépendante des seuils de classification . Elle mesure la qualité des précisions du modèle quel
que soit le seuil de classification sélectionné.
3.4.7 Les limitations du perceptron :
Essayons d’entrainer un perceptron pour faire le même rôle de la fonction OU exclusif : Prenons deux entrées x1,
x2, la somme généré par le perceptron est : somme = p1x1 + p2x2 + p0 ; Nous savons que la fonction ou exclusif est
représentée comme suit :
HAYTAM EL YOUSSFI, PFE: Deep Learning 33

34. CHAPITRE 3. MODÉLISATION DES NEURONES
Entrée x1 Entrée x2 Sortie
0 0 0
0 1 1
1 0 1
1 1 0
Table 3.2 – la fonction OU exclusif
à partir du tableau ci-dessus, on doit obtenir des valeurs des poids qui vérifier ces quatre conditions :
— cas 1 : p1 * 1 + p2 * 1 + p0 0
— cas 2 : p1 * 0 + p2 * 1 + p0 ≥ 0
— cas 3 : p1 * 1 + p2 * 0 + p0 ≥ 0
— cas 4 : p1 * 0 + p2 * 0 + p0 0
c-à-d :
— p1 + p2 + p0 0
— p2 + p0 ≥ 0
— p1 + p0 ≥ 0
— p0 0
c-à-d :
— p1 + p2 b
— p2 ≥ b
— p1 ≥ b
— b 0
Avec b=- p0 ; on trouve que :
— p1 + p2 b
— p1 + p2 ≥ 2b
— b 0
ce qui est absurde car b 0 ;
C’est là que apparaissent les limites du perceptron, car l’entraı̂nement du perceptron converge toujours si les données
d’apprentissage des deux classes sont des ensembles séparables linéairement.ce qui apparaı̂t clairement sur cette figure
qui représente les résultats d’une fonction ou exclusif :
Figure 3.11 – Graphe de la fonction Ou exclusif
la solution de cette limitation n’apparaı̂t qu’au milieu des années 1980, par l’utilisation des réseaux de neurones,
même que les recherches sur ces réseaux existent depuis les années 1940.
HAYTAM EL YOUSSFI, PFE: Deep Learning 34

35. CHAPITRE 3. MODÉLISATION DES NEURONES
3.5 Les réseaux de neurones multicouches
Les réseaux de neurones sont des systèmes neuronaux artificiels contient plusieurs neurones artificiels, structurés
en trois couches :
— Une couche d’entrée (Input Layer) : cette couche est la façon dont nous allons introduire les données dans
notre réseau.
— Une couche cachée (Hidden Layer) : appelée cachée car les calculs effectués par cette couche ne sont pas
visibles pour l’utilisateur, pendant qu’ils sont visible par l’utilisateur dans le cas d’un perceptron mono-couche,
cette couche est la méthode qui nous permet de modeler les fonctions non lineaires, ce qui était la limitation
du perceptron mono-couche.
— Une couche en sortie (Output Layer) : cette couche représente l’estimation final des données qui sont sortié de
notre réseau c-à-d la prédiction final.
Figure 3.12 – Un réseau de neurones
Les neurones appartenant à un réseau de neurones peuvent utiliser différentes fonctions d’activation, dependant du
type de transformation à appliquer.
3.5.1 Propagation de l’information, le calcul de la sortie du réseau
Un réseau de neurones multicouche est un réseau à action directe ”feedforward”, car les couches successives se
transmettent les donnés des unes aux autres dans le sens directe de couche d’entrée au couche de sortie.
Les sorties de la première couche sont utilisées par la couche suivante pour calculer ses sorties, et la couche suivante
fait la même chose jusqu’à ce qu’elles atteignent la couche de sortie du réseau.
On a plusieurs fonctions d’activation que nous pouvons utiliser pour ’propager’ l’information dans notre réseau :
[1] Remarque : les neurones du réseau peuvent utiliser des fonctions d’activation différents !
Les fonctions d’activation :
— La fonction d’identité :
Equation Dérivée Etendue Ordre de continuité Monotone Douce Identité en 0
f(x)=x f ’(x)=1 (−∞, +∞) C∞
Oui Oui Oui
HAYTAM EL YOUSSFI, PFE: Deep Learning 35

36. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.13 – Graphe de la fonction d’identité
— La fonction Heaviside :
Equation Dérivée Etendue Ordre de continuité Monotone Douce Identité en 0
f(x)=1 si x ≥ 0 , f(x)=0 si x 0 f’(x)=0 si x 6= 0 , f’(x)= ? si x=0 {0,1} C−1
Oui Non Non
Figure 3.14 – Graphe de la fonction Heaviside
— La fonction sigmoide :
Equation Dérivée Etendue Ordre de continuité Monotone Douce Identité en 0
∀xR, f(x) = 1
1+e−x f’(x)=f(x)(f(x)-1) (0,1) C∞
Oui Non Non
Figure 3.15 – Graphe de la fonction sigmoide
— La fonction Tangente Hyperbolique :
Equation Dérivée Etendue Ordre de continuité Monotone Douce Identité en 0
∀xR, f(x) = tanh(x) = 2
1+e−2x−1 f’(x)=1-f2
(x) (-1,1) C∞
Oui Non Oui
Figure 3.16 – Graphe de la fonction Tangente Hyperbolique
HAYTAM EL YOUSSFI, PFE: Deep Learning 36

37. CHAPITRE 3. MODÉLISATION DES NEURONES
3.5.2 Le Rétro-propagation de l’erreur
3.5.2.1 Principe :
Le but principal de cette étape est de réduire l’erreur dans un réseau de neurones, en utilisant la méthode de
la descente de gradient. C’est une méthode simple que nous avons utilisée pour la mise à jour des poids dans un
perceptron, mais pour un réseau de neurones, c’est un peu plus compliqué, car chaque neurone de la réseau a son
effet sur l’erreur globale, c’est-à-dire que pour mettre à jour les poids de chaque neurone, nous devons calculer le
gradient de la fonction d’erreur en fonction de différents poids pour chaque neurone du réseau, on applique la règle
de la chaine dérivée partielle, et puisque on calcule le gradient des neurones de sortie premièrement, la direction de
la rétropropagation est de la couche de sortie à la couche d’entrée, la direction opposée de l’étape de propagation de
l’information.
Figure 3.17 – Schéma de rétro-propagation du gradient
3.5.2.2 La règle de la chaine dérivée partielle :
Cas d’un seul chemin du premier noeud au dernier noeud :
La règle de la chaine dérivée partielle permet de connaı̂tre la j-ème dérivée partielle de la i-ème application partielle
de la composée de deux fonctions de plusieurs variables chacune. Schématiquement, si une variable y dépend d’une
seconde variable u, qui dépend à son tour d’une variable x, le taux de variation de y selon x est calculable comme le
produit de taux de variation de y selon u et du taux de variation de u selon x : ∂y
∂x = ∂y
∂u
∂u
∂x
Figure 3.18 – Diagramme de la règle de la chaine dérivée partielle avec un seul chemin
∂S
∂x = ∂S
∂z
∂z
∂y
∂y
∂x = ∂h(z)
∂z
∂g(y)
∂y
∂f(x)
∂x
Cas de deux chemin du premier noeud au dernier noeud :
HAYTAM EL YOUSSFI, PFE: Deep Learning 37

38. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.19 – Diagramme de la règle de la chaine dérivée partielle avec deux chemins
Dans cette cas, on a deux chemins vers le dernièr noeud, donc la dérivée partielle de la sortie S par rapport au x
est la somme des dérivées partielles par rapport au x pour chaque chemin :
∂S
∂x = ∂S
∂z
∂z
∂y
∂y
∂x + ∂S
∂u
∂u
∂w
∂w
∂x = ∂h(z,u)
∂z
∂g(y)
∂y
∂f(x)
∂x + ∂h(z,u)
∂u
∂k(w)
∂w
∂f(x)
∂x
En général :
On prend les combinaisons linéaires des entrées et des poids des neurones d’un réseau a1, a2, ....., ak , et pj−1,j le
poid qui relie aj−1 avec aj, et E la fonction d’erreure.
Si on a un seul chemin qui relie a1 avec S la sortie du réseau, on applique la règle de la chaine dérivée partielle par la
relation suivante :
∂E
∂pj−1,j
= ∂E
∂S
h
∂S
∂as
Qk−1
i=j
∂ai+1
∂ai
i
∂aj
∂pj−1,j
= ∂E
∂s
h
∂g(as)
∂as
Qk−1
i=j
∂ai+1
∂ai
i
∂aj
∂pj−1,j
= ∂E
∂S
h
g0
(as)
Qk−1
i=j
∂ai+1
∂ai
i
∂aj
∂pj−1,j ∀jd,....,s
Si on a plusieurs chemins des neurones de la couche d’entrée vers la sortie on calcule le somme du gradient de
chaque chemin relie un neurone d’entrée avec la sortie du réseau.
∂E
∂pj−1,j
= ∂E
∂S g0
(as)
hP
[ad,.....,as]C
Qk−1
i=j
∂ai+1
∂ai
i
∂aj
∂pj−1,j
Avec C : l’ensemble des chemins lient un neurone de la couche d’entrée avec la sortie du réseau
L’algorithm de la retropropagation sert a calculer le terme :
δs = ∂E
∂S g0
(as)
hP
[ad,.....,as]C
Qk−1
i=j
∂ai+1
∂ai
i
(s Couche de sortie) pour les noeuds les plus proches de la sortie S du
réseau, et aprés on calcule recursivement les δi pour les noeuds suivates, en même direction de la retropropagation.
On a :
δs = ∂E
∂S g0
(as)
hP
[ad.....,as]C
Qk−1
i=j
∂ai+1
∂ai
i
c’est-à-dire : δi = ∂E
∂ai
Et δs = ∂E
∂as
= ∂E
∂s
∂s
∂as
= ∂E
∂s × g0
(as) (s Couche de sortie)
Si on prend ai est la combinaison lineaire des entrées et des poids d’un neurone qui précéde la sortie du réseau, on a :
δi = ∂E
∂ai
=
P ∂E
∂as
∂as
∂ai
=
P ∂as
∂ai
δs
avec a est la combinaison lineaire des entrées et des poids de la neurone de la sortie du réseau.
HAYTAM EL YOUSSFI, PFE: Deep Learning 38

39. CHAPITRE 3. MODÉLISATION DES NEURONES
∂as
∂ai
= g0
(ai)pi,s
puisque : as =
P
pk,sg(ak)
Ce qui donne :
δi = g0
(ai)
P
pi,sδs avec : δs = ∂E
∂as
Et finalement on trouve que :
∂E
∂pi−1,i
= δi.g(as−1)
La première étape pour appliquer la retropropagation est de calculer le gradient de la couche de sortie δs, ce dernier
depend de la fonction d’activation choisi, est la methode de calculer l’erreur du réseau. [1]
1 /* sk : les sorties des neurones, */
2 /* pi,j : les poids : l’indice i c’est l’indice du neurone de la couche précédente, et j
l’indice du neurone de la couche courant, */
3 /* C : le nombre des couches du réseau, */
4 /* f : la fonction d’activation */
5 Pour chaque poid pi,j du réseau Faire
6 pi,j ← nombre aléatoire
7 Fin
8 Répéter
9 Pour chaque point de données (x,y) de l’ensemble de données Faire
10 /* calculer la sortie pour cet exemple d’entrée */
11 Pour chaque entrée i de la couche d’entrée Faire
12 si ← xi
13 Fin
14 Pour c=2 à C Faire
15 Pour chaque indice de neurone j de la couche c Faire
16 sommej ←
P
i pi,jsi
17 sj ← f(sommej)
18 Fin
19 FinPour
20 /* calculer l’erreure et le gradient ∆ pour tous les neurones de la couche de
sortie */
21 Pour chaque indice de neurone j de la couche de sortie Faire
22 ∆[j] ← ∂E
∂sommej
23 Fin
24 Pour c=C-1 à 1 Faire
25 Pour chaque indice de neurone i de la couche c Faire
26 ∆[i] ← f0
(sommej)
P
j pi,j∆[j]
27 Fin
28 FinPour
29 /* la mise à jour de tous les poids du réseau */
30 Pour chaque poid pi,j de réseau Faire
31 pi,j ← pi,j + η × si × ∆[j]
32 Fin
33 Fin
34 jusqu’à Le minimum de la fonction d’erreure est trouvé;
35
Algorithme 2 : Algorithme du rétropropagation du gradient
3.5.3 classification binaire d’un ensemble de données par réseau de neurones
L’ensemble de données utilisées contient 800 point de données, 400 pour une classe 1, et 400 pour une classe 0.
Nombre de données Classe
400 1
400 0
HAYTAM EL YOUSSFI, PFE: Deep Learning 39

40. CHAPITRE 3. MODÉLISATION DES NEURONES
Les deux classes sont distribuées comme le graphe suivant le montre :
Figure 3.20 – La distribution des deux ensembles de données
3.5.3.1 La language de programmation et les bibliothèques utilisées :
Nous choisissons la language Python pour implementer notre réseau de neurones, en utilisant une classe pour
atteindre notre objectif.
— NumPy est une extension du langage de programmation Python, destinée à manipuler des matrices ou tableaux
multidimensionnels ainsi que des fonctions mathématiques opérant sur ces tableaux.
— Matplotlib est une bibliothèque du langage de programmation Python destinée à tracer et visualiser des données
sous formes de graphiques4. Elle peut être combinée avec les bibliothèques python de calcul scientifique NumPy
et SciPy5.
— Pandas est une bibliothèque écrite pour le langage de programmation Python permettant la manipulation et
l’analyse des données. Elle propose en particulier des structures de données et des opérations de manipulation
de tableaux numériques et de séries temporelles.
1 import numpy as np
2 import pandas as pd
3 import m a t p l o t l i b . p y p l o t as p l t
3.5.3.2 La structure du neurone :
Pour cet exemple, nous avons choisi un réseau de neurones d’une structure comme suit : [3,4,1], l’entrée du réseau
a deux variables x, y et une valeur ’biais’, la couche cachée a quatre neurones, y compris le biais, et la couche de sortie
a un seul neurone puisque nous voulons prédire une classe binaire.
HAYTAM EL YOUSSFI, PFE: Deep Learning 40

41. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.21 – Structure du réseau de neurones utilisé
3.5.3.3 La fonction d’activation choisi :
Puisque nous souhaitons prédire une probabilité d’une classe binaire, il est clair d’utiliser une fonction sigmoı̈de
pour activer le nœud de sortie, de sorte que la prédiction indique la probabilité que la valeur observée, y, de la variable
dépendante soit égale à 1.
1 def sigmoid ( x ) :
2 r e t u r n 1 . 0 / ( 1 . 0 + np . exp(−x ) )
3
4 def d sigmoid ( x ) :
5 r e t u r n x ∗( 1.0 − x )
3.5.3.4 L’initialisation de notre classe Reseau Neurones :
Pour notre classe, nous avons assignés trois attributs :
— Structure : définie la structure de notre réseau de neurones, cette attribut est présenté par une liste comme
suit : [CE, CC1, ..., CCn, CS], le nombre des éléments de cette liste est le nombre de couches que nous avons
choisi, avec :
CE : est le nombre de neurones de la couche d’entrée,
CCi :est le nombre de neurones de la iieme
couche cachée,
CS :est le nombre de neurones de la couche de sortie
— N couche : définie la nombre de couches de notre réseau.
— Poids : les poids de notre réseau que nous devons les générer.
1 c l a s s Reseau Neurone :
2 # i n i t i a l i s a t i o n du rese au
3 def i n i t ( s e l f , s t r u c t u r e ) :
4 s e l f . n couches = l e n ( s t r u c t u r e )
5 s e l f . s t r u c t u r e = s t r u c t u r e
6 s e l f . poids = [ ]
7
3.5.3.5 Comment générer les poids ?
HAYTAM EL YOUSSFI, PFE: Deep Learning 41

42. CHAPITRE 3. MODÉLISATION DES NEURONES
Nous devons générer un tableau qui contient des matrices des poids, tel que :
— le nombre de matrice est égal au nombre des couches - 1
— la iieme
matrice du tableau représente les poids qui relient la iieme
couche avec la couche suivante.
— le nombre de lignes d’une matrice des poids d’une couche est égale à le nombre de neurones de cette couche y
compris le neurone bias.
— le nombre de colonnes d’une matrice des poids d’une couche est égale à le nombre de neurones de la couche
suivant excluant le neurone bias. Pour notre exemple, nous avons choisi un réseau de structure : [3,4,1]
La matrice de poids qui relie la première couche avec la suivante est représentée comme suit :
P1
=


P1
11 P1
12 P1
13
P1
21 P1
22 P1
23
P1
31 P1
32 P1
33


Figure 3.22 – Les poids qui relient la couche d’entrée avec la couche cachée
La matrice de poids qui relie la deuxième couche avec la couche de sortie est représentée comme suit :
P2
=




P2
11
P2
21
P2
31
P2
41




HAYTAM EL YOUSSFI, PFE: Deep Learning 42

43. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.23 – Les poids qui relient la couche cachée avec la couche de sortie
Et finalement, nous avons trouvés notre tableau des poids :
Poids = [P1
,P2
]
Remarque : Chaque élément de chaque matrice du tableau des poids est généré aléatoirement.
1 def Genere Poids ( s e l f ) :
2 f o r couche i n range ( s e l f . n couches −1) :
3 poid = 2∗np . random . rand ( s e l f . s t r u c t u r e [ couche ]+1 , s e l f . s t r u c t u r e [ couche +1])−1
4 s e l f . poids . append ( poid )
5
3.5.3.6 Propagation d’informations :
On fait la combinaison lineaire des entrees de chaque neurone et ces poids générées, et on la stocke dans un
tableau. Remarque : On doit ajouter un bias pour chaque couche caché.
1 def P r o p a g a t i o n d i n f o r m a t i o n ( s e l f , e n t r e e ) :
2 s o r t i e s=e n t r e e
3 f o r i i n range ( l e n ( s e l f . poids ) ) :
4 c o m b i n a i s o n l i n e a i r e = np . dot ( s o r t i e s [ i ] , s e l f . poids [ i ] )
5 s o r t i e = sigmoid ( c o m b i n a i s o n l i n e a i r e )
6 # a j o u t e r b i a s pour l a prochaine couche s i c e t t e couche n ’ e s t pas une couche de s o r t i e
7 i f i != l e n ( s e l f . poids ) −1:
8 s o r t i e = np . concatenate (( np . ones (1) , np . a r r a y ( s o r t i e ) ) )
9 s o r t i e s . append ( s o r t i e )
10 r e t u r n s o r t i e s
11
HAYTAM EL YOUSSFI, PFE: Deep Learning 43

44. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.24 – Le sortie de chaque neurone du réseau
On introduit les entrées à notre réseau avec une entree 1 pour le bais :
S1
= [Sb11, S12, S13]
avec Sb11 = 1, S12 = x1 et S13 = x2
On ajoute le bias de la couche cachée :
Sb21 = 1
On calcule le somme et la sortie de chaque neurone de la couche cachée :
[E22, E23, E24] = S1
× P1
[E22, E23, E24] = [Sb11, S12, S13] ×


P1
11 P1
12 P1
13
P1
21 P1
22 P1
23
P1
31 P1
32 P1
33


[S22, S23, S24] = sigmoid([E22, E23, E24])
S2
= [Sb21, S22, S23, S24]
On calcule le somme et la sortie du neurone de la couche sortie :
E3
= [Ef ] = S2
× P2
E3
= [Ef ] = [Sb21, S22, S23, S24] ×




P2
11
P2
21
P2
31
P2
41




S3
= [Sf ] = sigmoid(Ef )
Avec Sf est la sortie du réseau :
S = [S1
, S2
, S3
] = [Sb11, S12, S13, Sb21, S22, S23, S23, Sf ]
Et E sont les entrées de tous les neurones du réseau :
E = [1, x1, x2, 1, E22, E23, E24, Ef ]
HAYTAM EL YOUSSFI, PFE: Deep Learning 44

45. CHAPITRE 3. MODÉLISATION DES NEURONES
3.5.3.7 La Retropropagation de l’erreur
1 /* calculer l’erreure et le gradient ∆ pour tous les neurones de la couche de sortie
*/
2 Pour chaque indice de neurone j de la couche de sortie Faire
3 ∆[j] ← ∂E
∂sommej
4 Fin
5 Pour c=C-1 à 1 Faire
6 Pour chaque indice de neurone i de la couche c Faire
7 ∆[i] ← f0
(sommei)
P
j pi,j∆[j]
8 Fin
9 FinPour
10 /* la mise à jour de tous les poids du réseau */
11 Pour chaque poid pi,j de réseau Faire
12 pi,j ← pi,j + η × si × ∆[j]
13 Fin
La première chose à faire, et de caulculer le gradient descent de la neurone de sortie :
δf =
∂Erreur
∂sommef
avec : Erreur = 1
2 (sortiecible − sortiereel)2
δf = (sortiecible − sf )
∂(sortiecible − sf )
∂sommef
δf = (sortiecible − sf )
∂(−f(sommef ))
∂sommef
δf = −(sortiecible − sf )f0
(sommef )
c-à-d :
δf = −(sortiecible − S[8])f0
(E[8])
ou : (δf = −(sortiecible − Sf )f0
(Ef ))
Figure 3.25 – Le descente du gradient du neurone de sortie
Maintenant, on doit calculer l’erreur de chaque neurone, à partir les neurones de la couche précéde la couche sortie :
δ2
= δf ×
P2
21 P2
31 P2
41
Avec :
δ2
=
δ1 δ2 δ3
HAYTAM EL YOUSSFI, PFE: Deep Learning 45

46. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.26 – Le descente du gradient de chaque neurone de la couche cachée
On peut maintenant mettre à jour nos poids :
P1
=


P1
11 P1
12 P1
13
P1
21 P1
22 P1
23
P1
31 P1
32 P1
33

 + η ×


[Sb1]
[S11]
[S12]


δ1 δ2 δ3
P2
=
P2
11 P2
21 P2
31 P2
41
+ η ×




[Sb2]
[S21]
[S22]
[S23]




δf
Figure 3.27 – Mise à jour des poids relient la couche entrée avec la couche cachée
HAYTAM EL YOUSSFI, PFE: Deep Learning 46

47. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.28 – Mise à jour des poids relient la couche cachée avec la couche sortie
1 def Retropropagation ( s e l f , s o r t i e s , s o r t i e c i b l e , p a s d a p r e n t i s s a g e ) :
2 E r r e u r = s o r t i e c i b l e − s o r t i e s [ −1]
3 Delta = [ E r r e u r ∗ d sigmoid ( s o r t i e s [ −1]) ]
4
5 f o r i i n range ( s e l f . n couches − 2 , 0 , −1) :
6 E r r e u r = Delta [ −1]. dot ( s e l f . poids [ i ] [ 1 : ] . T)
7 Delta =[ E r r e u r ∗ d sigmoid ( s o r t i e s [ i ] [ 1 : ] ) ]+ Delta
8
9 f o r i i n range ( l e n ( s e l f . poids ) ) :
10 c o u c h e s o r t i e = s o r t i e s [ i ] . reshape ( s e l f . s t r u c t u r e [ i ] + 1 ,1)
11 temp = Delta [ i ] . reshape (1 , s e l f . s t r u c t u r e [ i + 1 ] )
12 s e l f . poids [ i ] += p a s d a p r e n t i s s a g e ∗ c o u c h e s o r t i e . dot ( temp )
13
3.5.3.8 L’apprentissage du réseau des neurones
en utilisant une fonction définie au niveau de la class ReseauNeurone pour entrainer notre réseau, en suivant les
étapes de l’algorithme de rétropropagation.
Nous avons utilisée la précision comme un condition d’arrêt, c-à-d en arrête si la précision de notre réseau est plus
qu’une valeure choisi.
1 def a p p r e n t i s s a g e ( s e l f , entree , s o r t i e , s t o p p r e c i s i o n , p a s d a p r e n t i s s a g e ) :
2 b i a s = np . ones ((1 , e n t r e e . shape [ 0 ] ) )
3 donnees = np . concatenate (( b i a s .T, e n t r e e ) , a x i s =1)
4 p r e c i s i o n = 0
5 w h i l e p r e c i s i o n s t o p p r e c i s i o n :
6 k=0
7 f o r i i n range ( donnees . shape [ 0 ] ) :
8 p=s e l f . P r o p a g a t i o n d i n f o r m a t i o n ( [ donnees [ i ] ] )
9 i f p[ −1] 0.5 :
10 pred = 1
11 e l s e :
12 pred = 0
13 s e l f . Retropropagation (p , s o r t i e [ i ] , p a s d a p r e n t i s s a g e )
14 i f pred == s o r t i e [ i ] :
15 k = k+1
16 p r e c i s i o n=k/ donnees . shape [ 0 ]
17
HAYTAM EL YOUSSFI, PFE: Deep Learning 47

48. CHAPITRE 3. MODÉLISATION DES NEURONES
3.5.3.9 Prédire la sortie des nouveaux données :
Il suffit d’appliquer notre réseau sur ces nouveaux données en utilisant les poids obtenus par l’apprentissage du
réseau :
1 def p r e d i c t e r ( s e l f , x ) :
2 temp = np . concatenate (( np . ones (1) , np . a r r a y ( x ) ) )
3 f o r i i n range ( l e n ( s e l f . poids ) ) :
4 temp = sigmoid ( np . dot ( temp , s e l f . poids [ i ] ) )
5 temp = np . concatenate (( np . ones (1) .T, np . a r r a y ( temp ) ) )
6 i f temp [ 1 ] 0 . 5 :
7 r e t u r n 1
8 e l s e :
9 r e t u r n 0
3.5.3.10 Préparation des données d’entrée
En utilisant les fonctions de la bibliothèque Pandas, on importe nos données à partir d’un fichier Excel.
Et on doit diviser nos données en deux ensembles, une pour l’apprentissage, et l’autre pour le teste.
1 d a t a s e t=pd . r e a d e x c e l ( ’ data . x l s x ’ , i n d e x c o l=None , header=None )
2 x = d a t a s e t . i l o c [ : , 0 : 2 ] . v a l u e s
3 y = d a t a s e t . i l o c [ : , 2 : 3 ] . v a l u e s
4 x a p p r e n t i s s a g e , x t e s t e , y a p p r e n t i s s a g e , y t e s t e = DiviserDonnees ( x , y , 0 . 3 )
3.5.3.11 L’apprentissage de notre réseau
1 NotreReseau = Reseau Neurone ( [ 2 , 3 , 1 ] )
2 NotreReseau . Genere Poids ()
3 #p r e c i s i o n s o u h a i t e 0.98
4 NotreReseau . a p p r e n t i s s a g e ( x a p p r e n t i s s a g e , y a p p r e n t i s s a g e , 0.98 , 0.01)
3.5.3.12 L’évaluation de notre réseau
1 temp =[]
2 f o r i i n range ( x t e s t e . shape [ 0 ] ) :
3 temp . append ( NotreReseau . p r e d i r ( x t e s t e [ i ] ) )
4 y pred = np . a s a r r a y ( temp )
Figure 3.29 – Les résultats obtenus
HAYTAM EL YOUSSFI, PFE: Deep Learning 48

49. CHAPITRE 3. MODÉLISATION DES NEURONES
3.5.4 Le taux d’apprentissage
Comme nous l’avons vu, un vecteur de gradient comporte à la fois une direction et une magnitude. Les algorithmes
de descente de gradient multiplient généralement le gradient par une valeur scalaire appelée taux d’apprentissage (ou
parfois pas d’apprentissage) pour déterminer le point suivant. Par exemple, si la magnitude du gradient est de 2,5 et
que le taux d’apprentissage est de 0,01, alors l’algorithme de descente de gradient sélectionnera le point suivant situé
à une distance de 0,025 du point précédent.
Les hyperparamètres 1
sont les variables pouvant être ajustées par les programmeurs dans les algorithmes de
Machine Learning. La plupart des programmeurs spécialisés dans le Machine Learning consacrent une bonne partie de
leur temps à ajuster le taux d’apprentissage. Si vous sélectionnez un taux d’apprentissage trop bas, le temps requis
pour l’apprentissage sera trop long.
Figure 3.30 – Taux d’apprentissage trop bas
Dans le cas contraire, si vous fixez un taux d’apprentissage trop élevé, le point suivant rebondira frénétiquement
de part et d’autre du minimum recherché, à la manière d’une expérience de mécanique quantique hors de contrôle :
Figure 3.31 – Taux d’apprentissage trop élevé
Il existe un taux d’apprentissage idéal pour chaque problème de régression. Cette valeur dépend de la courbure
de la fonction de perte. Si vous savez que le gradient de la fonction de perte est faible, vous pouvez en toute sécurité
1. Les paramètres que vous réglez pendant les exécutions successives de l’entraı̂nement du modèle. Le taux d’apprentissage, par exemple,
est un hyperparamètre.
HAYTAM EL YOUSSFI, PFE: Deep Learning 49

50. CHAPITRE 3. MODÉLISATION DES NEURONES
essayer un taux d’apprentissage plus élevé, ce qui compense le gradient faible et entraı̂ne un pas d’apprentissage plus
grand.
Figure 3.32 – Taux d’apprentissage adéquat
3.5.5 Préparation des données
Les données sont au centre des algorithmes de Machine Learning. Par conséquent, préparer au mieux ces données
permettra d’avoir de meilleures performances.
La plupart du temps, en machine Learning, les dataset proviennent avec des ordres de grandeurs différents. Cette
différence d’échelle peut conduire à des performances moindres. Pour palier à cela, des traitements préparatoires sur
les données existent. Notamment le Feature Scaling qui comprend la Standardisation et la Normalisation .
Nécessité de faire du traitement de données : Quand les données d’un dataset sont dans des ordres de grandeurs
différents, certains algorithmes de Machine Learning mettent plus de temps à trouver un modèle prédictif optimal.
Trouver un modèle prédictif optimal, revient souvent à minimiser une fonction de coût (en utilisant gradient descent
par exemple). Ce dernier va itérativement, trouver un vecteur de poids (weights) Θi, qui minimise la fonction de coût.
Supposons qu’on ait à prédire le prix d’une maison en fonction de sa superficie et le nombre de chambres qu’elle
contient. La feature nombre de chambres sera largement inférieure à la superficie de l’appartement (ex : 40 metre carré
pour 2 pièces).
Pour une régression multivariée, vu qu’on a pour cet exemple deux features ( X1 : la superficie et X2 : le nombre de
chambres), on aura à trouver trois constantes θ0, θ1, et θ2.
Tel que :
h(X) = θ0x0 + θ1x1 + θ2x2
Note : x0 vaut toujours 1(Biais). Il s’agit d’une astuce mathématique pour simplifier le calcul matriciel de h(X). Lors
des itérations du gradient Descent pour calculer les meilleurs θ pour h(X), certaines d’entre elles se mettront plus rapi-
dement à jour par rapport à d’autres. Cela en fonction de l’ordre de grandeur des différentes features. Cette différence
de ”rapidité” de mise à jour des θ, conduira à ce que Gradient Descent mette plus de temps pour converger et par
conséquent trouver le modèle optimal.
HAYTAM EL YOUSSFI, PFE: Deep Learning 50

51. CHAPITRE 3. MODÉLISATION DES NEURONES
Figure 3.33 – Modéle 1 :Illustration inspirée du cours d’Andrew NG
Le contour plot ci-dessus est typique de deux features ayant une grandeur d’échelle différentes. On remarque
que les contours (lignes bleues) sont assez entassées. Les flèches rouges illustrent comment Gradient Descent peine
(avec des “zig-zag”) à trouver le “centre” du contour plot qui est le vecteur Θi optimal.
On remarque également, avec les flêches rouges, que le Gradient Descent, met plus d’itérations pour trouver le
centre du “contour plot” qui est le meilleur couple de θ0 et θ1.
Figure 3.34 – Modéle 2 :Illustration inspirée du cours d’Andrew NG
En appliquant la normalisation, on souhaite obtenir une valeur de features ayant le même ordre de grandeur . La
première conséquence à cela est d’avoir un contour plot plus régulier (et moins entassé). Généralement, dans cette
situation, Gradient Descent trouve plus rapidement le minimum de la fonction de coût. Et par conséquent la fonction
de prédiction optimale.
Les algorithmes concernés par le Data processing :
Le Feature Scaling est une bonne pratique, pour ne pas dire obligatoire, lors de la modélisation avec du Machine
Learning.Les algorithmes pour lesquels le feature scaling s’avère nécessaire, sont ceux pour les quels il faudra :
— Calculer un vecteur de poids (weights) theta
— Calculer des distances pour déduire le degrée de similarité de deux items
— Certains algorithmes de Clustering
Les différentes techniques de Feature Scaling :
La Normalisation : Min-Max Scaling peut- être appliqué quand les données varient dans des échelles différentes. A
l’issue de cette transformation, les features seront comprises dans un intervalle fixe [0,1]. Le but d’avoir un tel intervalle
restreint est de réduire l’espace de variation des valeurs d’une feature et par conséquent réduire l’effet des outliers.
La normalisation peut- être effectuée par la technique du Min-Max Scaling. La transformation se fait grâce à la
formule suivante :
Xnormalise = X−Xmin
Xmax−Xmin
Avec :
— Xmin : la plus petite valeur observée pour la feature X
— Xmin : la plus grande valeur observée pour la feature X
— X : La valeur de la feature qu’on cherche à normaliser
La Standardisation : (aussi appelée Z-Score normalisation à ne pas confondre avec la normalisation du para-
graphe précendent) peut- être appliquée quand les input features répondent à des distributions normales (Distributions
HAYTAM EL YOUSSFI, PFE: Deep Learning 51

52. CHAPITRE 3. MODÉLISATION DES NEURONES
Gaussiennes) avec des moyennes et des écart-types différents. Par conséquent, cette transformation aura pour impact
d’avoir toutes nos features répondant à la même loi normale X ∼ N(0, 1) .
La standardisation peut également être appliquée quand les features ont des unités différentes.
La Standardisation est le processus de transformer une feature en une autre qui répondra à la loi normale (Gaussian
Distribution) X ∼ N(µ, σ).
avec :
+ µ = 0 La moyenne de la loi de distribution
+ σ = 1 est l’Écart-type (Standard Deviation)
La formule de standardisation d’une feature est la suivante :
z = x−µ
σ
avec :
— x la valeur qu’on veut standardiser (input variable)
— µ la moyenne (mean) des observations pour cette feature
— σ est l’ecart-type (Standard Deviation) des observations pour cette feature
Pour s’assurer que nos données non transformées répondent à une loi normale, on peut toujours faire un plot pour
voir leur répartition.
Figure 3.35 – Exemple de données répondant à une loi normal X ∼ N(3.8, 4.3)
Python et sa librairie Sickit Learn permettent d’appliquer le feature scaling sans avoir à coder les formules par nous
même. Les fonctions de feature scaling sont regroupées dans le package preprocessing de Sickit Learn.
3.6 Conclusion
Dans ce chapitre, nous avons présentés les réseaux de neurones artificiels, en spécifiant leurs définition, les concepts
de base de cette technique, l’apprentissage des réseaux de neurones, et ses différents domaines d’utilisation.Nous avons
procédé à étude détaillée sur l’algorithme du rétro-propagation qui a prouvé son efficacité dans la pratique avec ses
capacités d’apprentissage et d’identification.Pour ces raisons, cet algorithme est la base du travail qui sera présenté
dans les prochains chapitres qui traitent des types de réseaux de neurons profonds.
HAYTAM EL YOUSSFI, PFE: Deep Learning 52

53. Chapitre 4
Les Réseaux de neurones convolutifs
4.1 Introduction
Les perceptrons multicouches ou MLP pour ”Multi Layer Perceptron” ont montré leur efficacité comme technique
d’apprentissage pour la classification de données. Ils sont en effet capables d’approximer des fonctions non– linéaires et
complexes afin de traiter des données de grande dimension. Dans le cadre de la classification d’images, deux approches
sont possibles :
— Extraire des caractéristiques directement des données. Classiquement, ces caractéristiques sont extraites par
un algorithme choisi par l’utilisateur. Les vecteurs de caractéristiques obtenus sont ensuite présentés en entrée
d’un réseau de neurones.
— Présenter l’image en entrée d’un réseau de neurones. L’image nécessite cependant d’être vectorisée, c’est à dire
mise sous forme d’un vecteur dont la dimension est égale au nombre de pixels de l’image.
Dans le premier cas, le réseau se contente d’effectuer une classification des vecteurs de caractéristiques. Le point
sensible (l’extraction des caractéristiques) est laissé à la discrétion de l’utilisateur, et le choix de l’algorithme permettant
l’extraction des caractéristiques est crucial.
Dans le deuxième cas, plusieurs problèmes se posent :
Classiquement, les couches d’un réseau de neurones sont complètement connectées, c’est à dire que la valeur
d’un neurone d’une couche n va dépendre des valeurs de tous les neurones de la couche n − 1. Ainsi le nombre
de connexions (et donc de poids, de paramètres) peut être très grand. Par exemple pour une image de taille
15*15, la dimension de l’entrée d’un MLP est de 225. Si la couche cachée comporte 100 neurones, alors le
nombre de paramètres de cette couche est de 100*225 = 22500. Le nombre de paramètres va ainsi augmenter
exponentiellement avec la dimension de l’entrée (des images). Cette grande complexité du réseau impose d’avoir
de nombreux échantillons d’apprentissage, ce qui n’est souvent pas le cas. Le réseau va donc avoir tendance à
faire un sur apprentissage, et proposera donc une mauvaise capacité de généralisation.
Un autre défaut des MLP pour une application à des images est qu’ils sont peu ou pas invariants à des
transformations de l’entrée, ce qui arrive très souvent avec des images (légères translations, rotations ou
distorsions).
Enfin, les MLP ne prennent pas en compte la corrélation entre pixels d’une image, ce qui est un élément très
important pour la reconnaissance de formes.
Les réseaux de neurones convolutionnels ou CNN pour ”Convolutional Neural Network” sont une extension des MLP
permettant de répondre efficacement aux principaux défauts des MLP. Ils sont conçus pour extraire automatiquement
les caractéristiques des images d’entrée, sont invariants à de légères distorsions de l’image, et implémentent la notion
de partage des poids permettant de réduire considérablement le nombre de paramètres du réseau. Ce partage des poids
permet en outre de prendre en compte de manière forte les corrélations locales contenues dans une image. Les réseaux
de neurones convolutionnels ont initialement été inspirés par la découverte faite par Hubel et Wiesel de neurones
sensibles aux aspects locaux et sélectifs en orientation dans le système visuel du chat.
La première utilisation des réseaux de neurones convolutifs a été réalisée par Fukushima avec son Neocognitron.
Les poids sont forcés à être égaux pour détecter des lignes, des points ou des coins à tous les endroits possibles de
l’image, implémentant de fait l’idée du partage des poids.Dans ce chapitre nous présenterons l’architecture de réseaux
de neurones convolutifs et Exemples des modèles de CNN en plus différents paramètres .
4.2 Les réseaux de neurones convolutifs
53

54. CHAPITRE 4. LES RÉSEAUX DE NEURONES CONVOLUTIFS
Les réseaux de neurones convolutionnels sont à ce jour les modèles les plus performants pour classer des images.
Désignés par l’acronyme CNN, de l’anglais Convolutional Neural Network, ils comportent deux parties bien distinctes.
En entrée, une image est fournie sous la forme d’une matrice de pixels. Elle a 2 dimensions pour une image en
niveaux de gris. La couleur est représentée par une troisième dimension, de profondeur 3 pour représenter les couleurs
fondamentales [Rouge, Vert, Bleu].
La première partie d’un CNN est la partie convolutive à proprement parler. Elle fonctionne comme un extracteur
de caractéristiques des images. Une image est passée à travers une succession de filtres, ou noyaux de convolution,
créant de nouvelles images appelées cartes de convolutions. Certains filtres intermédiaires réduisent la résolution de
l’image par une opération de maximum local. Au final, les cartes de convolutions sont mises à plat et concaténées en
un vecteur de caractéristiques, appelé code CNN.
Figure 4.1 – Architecture standard d’un réseau de neurone convolutif
Ce code CNN en sortie de la partie convolutive est ensuite branché en entrée d’une deuxième partie, constituée de
couches entièrement connectées (perceptron multicouche). Le rôle de cette partie est de combiner les caractéristiques
du code CNN pour classer l’image.
La sortie est une dernière couche comportant un neurone par catégorie. Les valeurs numériques obtenues sont
généralement normalisées entre 0 et 1, de somme 1, pour produire une distribution de probabilité sur les catégories.
4.3 Architecture de réseaux de neurones convolutifs
Les réseaux de neurones convolutionnels sont basés sur le perceptron multicouche(MLP), et inspirés du compor-
tement du cortex visuel des vertébrés. Bien qu’efficaces pour le traitement d’images, les MLP ont beaucoup de mal à
gérer des images de grande taille, ce qui est dû à la croissance exponentielle du nombre de connexions avec la taille
de l’image.
Par exemple, si on prend une image de taille 32x32x3 (32 de large, 32 de haut, 3 canaux de couleur), un seul
neurone entièrement connecté dans la première couche cachée du MLP aurait 3072 entrées (32*32*3). Une image
200x200 conduirait ainsi à traiter 120 000 entrées par neurone ce qui, multiplié par le nombre de neurones, devient
énorme.
Les CNN visent à limiter le nombre d’entrées tout en conservant la forte corrélationspatialement locale des
images naturelles. Par opposition aux MLP, les CNN ont les traits distinctifs suivants :
— ’Volumes 3D de neurones’ :La couche de neurones n’est plus simplement une surface(perceptron), mais
devient un volume avec une profondeur. Si on considère un seul champ récepteur du CNN, les n neurones
associés (sur la profondeur) forment l’équivalent de la première couche d’un MLP.
— ’Connectivité locale’ :Grâce au champ récepteur qui limite le nombre d’entrées du neurone, tout en conservant
l’architecture MLP, les CNN assurent ainsi que les filtres produisent la réponse la plus forte à un motif d’entrée
spatialement localisé, ce qui conduit à une représentation parcimonieuse de l’entrée. Une telle représentation
occupe moins d’espace en mémoire. De plus, le nombre de paramètres à estimer étant réduit, leur estimation
(statistique) est plus robuste pour un volume de données fixé (comparé à un MLP).
— ’Poids partagés’ :Dans les CNNs, les paramètres de filtrage d’un neurone (pour un champ récepteur donné)
sont identiques pour tous les autres neurones d’un même noyau (traitant tous les autres champs récepteurs de
l’image). Ce paramétrage (vecteur de poids et biais) est défini dans une carte de fonction . Cela signifie que
tous les neurones dans une couche de convolution donnée détectent exactement la même caractéristique. En
HAYTAM EL YOUSSFI, PFE: Deep Learning 54

55. CHAPITRE 4. LES RÉSEAUX DE NEURONES CONVOLUTIFS
multipliant les champs récepteurs,il devient possible de détecter des éléments indépendamment de leur position
dans le champ visuel,ce qui induit une propriété d’invariance par translation.
Ensemble, ces propriétés permettent aux réseaux de neurones convolutionnels d’obtenir une meilleure généralisation
(en termes d’apprentissage) sur des problèmes de vision. Le partage de poids permet aussi de réduire considérablement
le nombre de paramètres libres à apprendre, et ainsi les besoins en mémoire pour le fonctionnement du réseau. La
diminution de l’empreinte mémoire permet l’apprentissage de réseaux plus grands donc souvent plus puissants.
Figure 4.2 – : Une couche du CNN en 3 dimensions. (Vert = volume d’entrée, bleu = volume du champ récepteur,
gris = couche de CNN, cercles = neurones artificiels indépendants)
Une architecture CNN est formée par un empilement de couches de traitement indépendantes :
— La couche de convolution (CONV) qui traite les données d’un champ récepteur.
— La couche de pooling (POOL), qui permet de compresser l’information en réduisant la taille de l’image in-
termédiaire (souvent par sous-échantillonnage).
— La couche de correction (ReLU), souvent appelée par abus ’ReLU’ en référence à la fonction d’activation (Unité
de rectification linéaire).
— La couche ”entièrement connectée” (FC), qui est une couche de type perceptron.
— La couche de perte (LOSS).
4.3.1 Couche de convolution(CONV) :
Couche de convolution : le bloc de construction de base d’un CNN. Trois paramètres permettent de dimensionner
le volume de la couche de convolution la profondeur, le pas et la marge.
1. Profondeur de la couche :nombre de noyaux de convolution (ou nombre de neurones associés à un même
champ récepteur).
2. Le pas :contrôle le chevauchement des champs récepteurs. Plus le pas est petit, plus les champs récepteurs se
chevauchent et plus le volume de sortie sera grand.
3. La marge (à 0) ou zero padding : parfois, il est commode de mettre des zéros à la frontière du volume
d’entrée. La taille de ce ’zero-padding’ est le troisième hyper paramètre. Cette marge permet de contrôler la
dimension spatiale du volume de sortie. En particulier, il est de conserver la même surface que celle du volume
d’entrée.
Si le pas et la marge appliquée à l’image d’entrée permettent de contrôler le nombre de champs récepteurs à gérer
(surface de traitement), la profondeur permet d’avoir une notion de volume de sortie, et de la même manière qu’une
image peut avoir un volume, si on prend une profondeur de 3 pour les trois canaux RGB d’une image couleur, la couche
de convolution va également présenter en sortie une profondeur.C’est pour cela que l’on parle plutôt de ”volume de
sortie” et de ”volume d’entrée”, car l’entréed’une couche de convolution peut être soit une image soit la sortie d’une
autre couche de convolution.
La taille spatiale du volume de sortie peut être calculée en fonction de la taille du volume d’entrée Wi la surface
de traitement K (nombre de champs récepteurs), le pas S avec lequel ils sont appliqués, et la taille de la marge P La
formule pour calculer le nombre de neurones du volume de sortie est W0 = Wi−K+2P
S + 1 Si Wi n’est pas entier,
les neurones périphériques n’auront pas autant d’entrée que les autres. Il faudra donc augmenter la taille de la marge
(pour recréer des entrées virtuelles).
Souvent, on considère un pas S=1, on calcule donc la marge de la manière suivante : P = K−1
2 si on souhaite un volume
de sortie de même taille que le volume d’entrée. Dans ce cas particulier la couche est dite ”connectée localement”.
HAYTAM EL YOUSSFI, PFE: Deep Learning 55

56. CHAPITRE 4. LES RÉSEAUX DE NEURONES CONVOLUTIFS
4.3.2 Couche de pooling (POOL) :
Couche de pooling : Un autre concept important des CNNs est le pooling, ce qui est une forme de sous-
échantillonnage de l’image. L’image d’entrée est découpée en une série de rectangles de n pixels de côté ne se
chevauchant pas (pooling). Chaque rectangle peut être vu comme une tuile. Le signal en sortie de tuile est défini en
fonction des valeurs prises par les différents pixels de la tuile.
Le pooling réduit la taille spatiale d’une image intermédiaire, réduisant ainsi la quantité de paramètres et de calcul
dans le réseau. Il est donc fréquent d’insérer périodiquement une couche de pooling entre deux couches convolutives
successives d’une architecture CNN pour contrôler l’overfitting (sur-apprentissage). L’opération de pooling créait aussi
une forme d’invariance par translation.
La couche de pooling fonctionne indépendamment sur chaque tranche de profondeur de l’entrée et la redimensionne
uniquement au niveau de la surface. La forme la plus courante est une couche de mise en commun avec des tuiles
de taille 2x2 (largeur/hauteur) et comme valeur de sortie la valeur maximale en entrée. On parle dans ce cas de
”Max-Pool 2x2 ”.
Il est possible d’utiliser d’autres fonctions de pooling que le maximum. On peut utiliser un average pooling (la
sortie est la moyenne des valeurs du patch d’entrée), du L2-norm pooling . Dans les faits, même si initialement
l’average pooling était souvent utilisé il s’est avéré que le max-pooling était plus efficace car celui-ci augmente plus
significativement l’importance des activations fortes. En d’autres circonstances, on pourra utiliser un pooling sto-
chastique.
Le pooling permet de gros gains en puissance de calcul. Cependant, en raison de la réduction agressive de la taille de
la représentation (et donc de la perte d’information associée), la tendance actuelle est d’utiliser de petits filtres (type
2x2). Il est aussi possible d’éviter la couche de pooling mais cela implique un risque sur-apprentissage plus important.
Figure 4.3 – Pooling avec un filtre 2x2 et un pas de 2
4.3.3 Couches de correction (RELU) :
Couches de correction : Il est possible d’améliorer l’efficacité du traitement en intercalant entre les couches de
traitement une couche qui va opérer une fonction mathématique (fonction d’activation) sur les signaux de sortie.
La fonction ReLU (abréviation de Unités Rectifié linéaires) : f(x)=max(0,x) Cette fonction force les neurones à
retourner des valeurs positives.
Equation Dérivée Etendue Ordre de continuité Monotone Douce Identité en 0
∀xR, f(x) = Max(0.x) f’(x)=(0,1) [0,+∞[ C0
Oui Oui Oui
Figure 4.4 – Graphe de la fonction ReLU
HAYTAM EL YOUSSFI, PFE: Deep Learning 56

57. CHAPITRE 4. LES RÉSEAUX DE NEURONES CONVOLUTIFS
4.3.4 Couche entièrement connectée (FC) :
Couche entièrement connectée : Après plusieurs couches de convolution et de max-pooling, le raisonnement de
haut niveau dans le réseau neuronal se fait via des couches entièrement connectées. Les neurones dans une couche
entièrement connectée ont des connexions vers toutes les sorties de la couche précédente. Leurs fonctions d’activations
peuvent donc être calculées avec une multiplication matricielle suivie d’un décalage de polarisation.
4.3.5 Couche de perte (LOSS) :
Couche de perte : La couche de perte spécifie comment l’entrainement du réseau pénalise l’écart entre le signal
prévu et réel. Elle est normalement la dernière couche dans le réseau. Diverses fonctions de perte adaptées à différentes
tâches peuvent y être utilisées. La fonction Softmax permet de calculer la distribution de probabilités sur les classes
de sortie.
4.4 Exemples des modèles de CNN :
La forme la plus commune d’une architecture CNN empile quelques couches Conv-ReLU, les suit avec des couches
Pool, et répète ce schéma jusqu’à ce que l’entrée soit réduite dans un espace d’une taille suffisamment petite. À un
moment, il est fréquent de placer des couches entièrement connectées (FC). La dernière couche entièrement connectée
est reliée vers la sortie. Voici quelques architectures communes CNN qui suivent ce modèle :
— INPUT - CONV - RELU - FC
— INPUT - [CONV - RELU - POOL] * 2 - FC - RELU - FC Ici, il y a une couche de CONV unique
entre chaque couche POOL.
— INPUT - [CONV - RELU - CONV - RELU - POOL] * 3 - [FC - RELU] * 2 - FC Ici, il y a deux
couches CONV empilées avant chaque couche POOL.
Figure 4.5 – Exemples de modèles de CNN
4.5 Choix des paramètres :
Les CNNs utilisent plus de paramètres qu’un MLP standard. Même si les règles habituelles pour les taux d’appren-
tissage et des constantes de régularisation s’appliquent toujours, il faut prendre en considération les notions de nombre
de filtres, leur forme et la forme du max pooling.
4.5.1 Nombre de filters :
Comme la taille des images intermédiaires diminue avec la profondeur du traitement, les couches proches de
l’entrée ont tendance à avoir moins de filtres tandis que les couches plus proches de la sortie peuvent en avoir
d’avantage. Pour égaliser le calcul à chaque couche, le produit du nombre de caractéristiques et le nombre de pixels
traités est généralement choisi pour être à peu près constant à travers les couches. Pour préserver l’information en
HAYTAM EL YOUSSFI, PFE: Deep Learning 57

58. CHAPITRE 4. LES RÉSEAUX DE NEURONES CONVOLUTIFS
entrée, il faudrait maintenir le nombre de sorties intermédiaires (nombre d’images intermédiaire multiplié par le nombre
de positions de pixel) pour être croissante (au sens large) d’une couche à l’autre. le nombre d’images intermédiaires
contrôle directement la puissance du système,dépend du nombre d’exemples disponibles et la complexité du traitement.
4.5.2 Forme du filtre :
Les formes de filtre varient grandement dans la littérature. Ils sont généralement choisis en fonction de l’ensemble
de données. Les meilleurs résultats sur les images de MNIST (28x28) sont habituellement dans la gamme de 5x5 sur la
première couche, tandis que les ensembles de données d’images naturelles (souvent avec des centaines de pixels dans
chaque dimension) ont tendance à utiliser de plus grands filtres de première couche de 12x12, voire 15x15. Le défi est
donc de trouver le bon niveau de granularité de manière à créer des abstractions à l’échelle appropriée et adaptée à
chaque cas.
4.5.3 Forme du Max Pooling :
Les valeurs typiques sont 2x2. De très grands volumes d’entrée peuvent justifier un pooling 4x4 dans les premières
couches. Cependant, le choix de formes plus grandes va considérablement réduire la dimension du signal, et peut
entraı̂ner la perte de trop d’information.
4.6 Méthodes de régularisation :
Pour ne pas tomber dans le problème de sur apprentissage il y a des méthodes de régularisation à utiliser.
4.6.1 Empirique :
1. Dropout : Les couches ”FC” (Fully Connected) occupent la majeure partie de la mémoire du CNN. D’ailleurs
le concept de FC crée un problème exponentiel de mémoire appelé ”overfitting” (”sur-connexion” conduisant
au sur-apprentissage) ralentissant le traitement de l’information. Pour prévenir cela, la méthode du dropout
est utilisée pour ”éteindre” les neurones aléatoirement (avec une probabilité prédéfinie, souvent un neurone sur
deux) ainsi que les neurones périphériques. Ainsi, avec moins de neurones, le réseau est plus réactif et peut
donc apprendre plus rapidement. À la fin de la séance d’apprentissage, les neurones ”éteints” sont ”rallumés”
(avec leurs poids originaux). Plus la couche FC est proche de l’image source, moins on éteindra de neurones.
L’objectif est d’éteindre et rallumer les neurones aléatoirement, dans le cadre d’entraı̂nements successifs.Une
fois les séries d’entraı̂nements terminées, on rallume tous les neurones et on utilise le réseau comme d’habitude.
Cette technique a montré non seulement un gain dans la vitesse d’apprentissage, mais en déconnectant les
neurones, on a aussi limité des effets marginaux, rendant le réseau plus robuste et capable de mieux généraliser
les concepts appris.
2. DropConnect :Le DropConnect est une évolution du dropout, où on ne va non plus éteindre un neurone, mais
une connexion (l’équivalent de la synapse), et ce de manière toujours aléatoire. Les résultats sont similaires
(rapidité, capacité de généralisation de l’apprentissage), mais présentent une différence au niveau de l’évolution
des poids des connexions. Une couche FC avec un DropConnect peut s’apparenter à une couche à connexion
”diffuse”.
3. Pooling stochastique Le pooling stochastique reprend le même principe que le Max-pooling, mais la sortie
choisie sera prise au hasard, selon une distribution multinomiale définie en fonction de l’activité de la zone
adressée par le pool. Dans les faits, ce système s’apparente à faire du Max-pooling avec un grand nombre
d’images similaires, qui ne varient que par des déformations localisées. On peut aussi considérer cette méthode
comme une adaptation à des déformations élastiques de l’image. C’est pourquoi cette méthode est très efficace
sur les images MNIST (base de données d’images représentant des chiffres manuscrits). La force du pooling
stochastique est de voir ses performances croı̂tre de manière exponentielle avec le nombre de couches du réseau.
4.6.2 Explicite :
1. Taille du réseau : La manière la plus simple de limiter le sur apprentissage est de limiter le nombre de couches
du réseau et de libérer les paramètres libres (connexions) du réseau. Ceci réduit directement la puissance et le
potentiel prédictif du réseau. C’est équivalent à avoir une ”norme zéro”.
2. Dégradation du poids : Le concept est de considérer le vecteur des poids d’un neurone (liste des poids associés
aux signaux entrants), et de lui rajouter un vecteur d’erreur proportionnel à la somme des poids (norme 1) ou
du carré des poids (norme 2 ou euclidienne). Ce vecteur d’erreur peut ensuite être multiplié par un coefficient
de proportionnalité que l’on va augmenter pour pénaliser davantage les vecteurs de poids forts.
HAYTAM EL YOUSSFI, PFE: Deep Learning 58

59. CHAPITRE 4. LES RÉSEAUX DE NEURONES CONVOLUTIFS
— La régularisation par norme 1 : La spécificité de cette régulation est de diminuer le poids des entrées
aléatoires et faibles et d’augmenter le poids des entrées ”importantes”. Le système devient moins sensible
au bruit.
— La régularisation par norme 2 : : (norme euclidienne) La spécificité de cette régulation est de diminuerle
poids des entrées fortes, et de forcer le neurone à plus prendre en compte les entrées de poids faible.
Les régularisations par norme 1 et norme 2 peuvent être combinées : c’est la ”régularisation de réseau élastique”
(Elastic net regulation).
4.7 Conclusion
Dans cette partie , nous avons présenté les réseaux de neurones convolutifs. Ces réseaux sont capables d’extraire
des caractéristiques d’images présentées en entrée et de classifier ces caractéristiques, Ils sont fondés sur la notion de
”champs récepteurs” (receptive fields), ils implémentent aussi l’idée de partage des poids qui permettant de réduire
le nombre de paramètres libres de l’architecture. Ce partage des poids permet en outre de réduire les temps de calcul,
l’espace mémoire nécessaire, et également d’améliorer les capacités de généralisation du réseau .
Les réseaux de neurones convolutifs présentent cependant un certain nombre de limitations : en premier lieu, les
hyper paramètres du réseau sont difficiles à évaluer a priori. En effet, le nombre de couches, les nombre de neurones
par couche ou encore les différentes connexions entre couches sont des éléments cruciaux et essentiellement déterminés
par une bonne intuition ou par une succession de tests/calcul d’erreurs (ce qui est coûteux en temps). Le nombre
d’échantillons d’apprentissage est également un élément déterminant, et il arrive souvent que celui–ci soit trop faible
en comparaison du nombre de paramètres (poids) du réseau. Des solutions existent comme augmenter artificiellement
leur nombre de connexions ou encore de réduire le nombre de paramètres libres (en réalisant un pré-apprentissage des
premières couches par exemple).
HAYTAM EL YOUSSFI, PFE: Deep Learning 59

60. Chapitre 5
La détection des classes d’objets dans sur
les vidéos
5.1 Introduction
Dans ce chapitre, nous parlerons de la détection des classes d’objets dans les vidéos, la détection d’objets est une
méthode utilisée dans les méthodes de classification, pour classifier chaque objet et detecter sa position exacte dans
la vidéo.
Pour les vidéos, nous allons ignorer les fonctionnalités temporelles de la vidéo et tenter de classer chaque clip en
balayant chaque image. Nous ferons cela en utilisant un CNN.
5.2 La phase de détection
Le but de la détection d’objet est de détecter la présence d’un objet à partir d’un certain ensemble de classes et
de localiser la position exacte dans l’image.
Nous pouvons spécifier où l’objet est situé dans l’image avec un cadre de sélection.
Figure 5.1 – Détection des objets en utilisant des cadres de sélection
Par rapport à la classification des images, la sortie du détecteur est structurée, chaque objet est généralement
marqué avec un cadre de sélection et une étiquette de classe. Le cadre de sélection est décrite par la position de l’un
des coins, ainsi que par la largeur et la taille de la boı̂te(x,y,h,w).
60

61. CHAPITRE 5. LA DÉTECTION DES CLASSES D’OBJETS DANS SUR LES VIDÉOS
Figure 5.2 – Le cadre de sélection
Pour vérifier si la détection est correcte, comparons le cadre de sélection prédite à le cadre de sélection correct,la
métrique est l’intersection de l’union ou de l’IoU, c’est le rapport entre :
— la surface d’intersection des cadres de sélection corrects et les cadres de sélection prédites
— la surface de l’union de ces cadres
Figure 5.3 – IoU Score
Si la valeur IoU est supérieure au seuil, la détection est correcte, plus le seuil est grand, plus le détecteur doit localiser
les objets avec précision, normalement, le seuil est généralement défini à 0,5, la sortie du détecteur est un ensemble
de propositions de détection.
Habituellement, pour chaque proposition, le détecteur attribue également un score comme mesure de performance de
la détection, nous pouvons donc classer toutes les propositions en fonction du score. Chaque proposition est considérée.
— Si l’IoU est supérieur au seuil, il s’agit de la détection positive réelle.
— Si la valeur de l’IoU est inférieure, il s’agit d’une détection faussement positive.
Si un objet n’est pas détecté, il est marqué comme erreur de détection ou faux négatif.
Figure 5.4 – les sorties possibles de la détection d’objets
Pour la détection d’objet, la création des données d’annotations est très importante.
Beaucoup d’objets peuvent être manqués dans l’ensemble des données correctes, cela est particulièrement vrai pour
les petits objets ou les objets ayant une apparence très similaire à la cible.
Par exemple, si nous souhaitons détecter des visages, les détecteurs peuvent détecter non seulement des visages réels,
mais également des impressions sur des vêtements ou des portraits.
HAYTAM EL YOUSSFI, PFE: Deep Learning 61

62. CHAPITRE 5. LA DÉTECTION DES CLASSES D’OBJETS DANS SUR LES VIDÉOS
(a) Frame A (b) Frame B
Figure 5.5 – La détection d’un object dans deux différents ”frames” d’un vidéo
Figure 5.6 – Les problèmes des annotations
Il est bien mieux d’annoter tous ces objets, puis de marquer certains d’entre eux comme des objets à ignorer lors
de l’apprentissage et de l’évaluation. Il peut également utiliser plusieurs annotateurs pour la vérification d’annotation.
Il est très important d’avoir un protocole d’annotation strict avec une définition claire de la manière dont les objets
doivent être marqués dans les cas difficiles.
5.3 La relation entre la détection et la classification
La classification des images nous donne un moyen précis de classer les images, par exemple, vous pouvez former
un classificateur de chien pour indiquer si cette image contient ou non des chiens. Mais comment pouvez-vous dire où
se trouve exactement le chien dans l’image et combien de chiens dans cette image ?
La technique principale pour réduire le problème de la détection à la classification des images est la fenêtre glissante.
Considérons une fenêtre rectangulaire de taille fixe. nous avons choisi correctement, les chiens occuperont la majeure
partie de la fenêtre, nous pouvons parcourir toutes les régions possibles en scannant une image de gauche à droite et de
haut en bas avec cette fenêtre, nous classons chaque fenêtre en utilisant ”est chien ?” classificateur indépendamment.
5.3.1 Les problèmes des fenêtres glissantes
Comment gérer les différentes tailles d’objets ? Comment gérer différents ratios d’aspect ? Beaucoup de fenêtres
recouvriront bien cet objet, donc, pour chaque objet, nous aurons plusieurs réponses positives. que faire si un objet
coı̈ncide partiellement avec d’autres objets ou si sa forme est purement par une fenêtre rectangulaire ?
Dans ce dernier cas, le classificateur devrait être très puissant pour détecter les objets partiellement coı̈ncidés, ou les
objets n’occupant qu’une petite partie de la fenêtre.
Une façon de résoudre le problème de la taille des objets consiste à utiliser plusieurs fenêtres de tailles différentes et à
vérifier l’image plusieurs fois avec différentes fenêtres.
Alternativement, nous pouvons réduire les images plusieurs fois et créer une pyramide à plusieurs échelles, ensuite, nous
pouvons vérifier toutes les échelles dans une fenêtre de même taille, en fonction de la capacité de généralisation du
classifieur, le nombre d’échelles peut être très différent. Si les proportions de l’objet peuvent différer considérablement,
comme pour les vues de profil frontales d’un chien, nous devons utiliser des fenêtres de différentes proportions, ainsi,
le nombre d’images à numériser est égal au produit du nombre d’échelles et du nombre de ratios d’aspect utilisés.
La ’Score Map’ pour une échelle spécifique peut contenir plusieurs réponses de différentes forces, et pour obtenir la
détection finale, nous sélectionnons généralement des points de maximum local.
HAYTAM EL YOUSSFI, PFE: Deep Learning 62

63. CHAPITRE 5. LA DÉTECTION DES CLASSES D’OBJETS DANS SUR LES VIDÉOS
Figure 5.7 – Score Map
5.4 R-CNN
R-CNN est l’une des principales approches de la détection d’objets, considérez le problème de détection d’objet
multi-classe, nous avons un puissant classifieur CNN formé sur l’ensemble de données ImageNet, nous voulons appli-
quer ce classifieur au problème de détection d’objet sur un nouvel ensemble de données.
Le nouvel ensemble de données pourrait contenir moins d’images que nécessaire pour l’apprentissage du classifieur
CNN.
Nous pourrions utiliser le classifieur CNN pré-formé comme extracteur de fonctionnalités, former et supporter un clas-
sificateur de machine externe sur ces fonctionnalités, puis l’utiliser dans un framework de fenêtre glissante.
Mais ce sera trop lent car nous devons appliquer CNN à des centaines de milliers de fenêtres.
Dans le travail fondateur de Girshick, il a été proposé d’utiliser un générateur de proposition d’objet externe pour
obtenir 2 000 propositions d’objet par image, les caractéristiques sont ensuite extraites de ces propositions avec un
réseau de neurones de convolution et classées avec un classificateur SVM.
SVM Les machines à vecteurs de support ou séparateurs à vaste marge ont des modèles d’apprentissage
supervisés avec des algorithmes d’apprentissage associés qui analysent les données utilisées pour la classification et
l’analyse de régression. À partir d’un ensemble d’exemples d’apprentissage, chacun étant identifié comme appartenant
à l’une ou l’autre de deux catégories, un algorithme d’apprentissage SVM construit un modèle attribuant de nouveaux
exemples à une catégorie ou à l’autre, en faisant un classifieur linéaire binaire non probabiliste. Un modèle SVM est une
représentation des exemples sous forme de points dans l’espace, mappés de telle sorte que les exemples de catégories
distinctes soient divisés par un écart clair et aussi large que possible. Les nouveaux exemples sont ensuite mappés
dans ce même espace et devraient appartenir à une catégorie en fonction de quel côté de l’espace ils tombent. En plus
d’effectuer une classification linéaire, les SVM peuvent efficacement effectuer une classification non linéaire en utilisant
ce que l’on appelle le ’astuce du noyau’, en mappant implicitement leurs entrées dans des espaces de fonctions de
grande dimension.[5] [9]
Cette méthode est appelée réseau de convolution basé sur une région ou R-CNN.
Figure 5.8 – R-CNN
Dans R-CNN, un algorithme de recherche sélective a été utilisé, la recherche sélective est l’une des méthodes de
génération de proposition d’objet générique, de telles méthodes peuvent fournir un taux de rappel élevé mais une
précision très faible, ainsi, ils ne peuvent pas être utilisés comme détecteurs d’objets eux-mêmes, mais ils peuvent être
utilisés comme première étape du pipeline de détection.
La procédure de formation pour le R-CNN comprend trois étapes. :
— CNN est pré-formé sur ImageNet pour la classification des images.
— CNN est optimisé pour la détection d’objet sur un ensemble de données de détection d’objet limité.
— les régresseurs linéaires de classifieur et de boı̂te englobante ”bounding box” sont formés sur les caractéristiques
CNN extraites des propositions des objets.
L’évolution expérimentale a démontré que R-CNN surpasse les anciens méthodes de détection d’objet, même si seul
le CNN prétraité est utilisé pour l’extraction de caractéristiques.
HAYTAM EL YOUSSFI, PFE: Deep Learning 63

64. CHAPITRE 5. LA DÉTECTION DES CLASSES D’OBJETS DANS SUR LES VIDÉOS
Un avantage très important de la méthode R-CNN est qu’elle peut utiliser n’importe quel réseau de neurones de
convolution pour l’extraction de caractéristiques, nous pouvons améliorer les performances de R-CNN en utilisant une
architecture convolutifs plus avancée.
Mais la méthode de R-CNN pose plusieurs problèmes :
— les calculs redondants, toutes les fonctionnalités sont calculées indépendamment même pour les régions de
proposition superposées.
— il est nécessaire de redimensionner les propositions d’objet avec une résolution et un ratios d’aspect fixes.
— il s’agit d’une procédure d’entraı̂nement très complexe avec une charge de système de fichiers élevée.
5.5 Fast R-CNN
Dans fast R-CNN, deux autres modifications ont été introduites, tout d’abord, le classificateur softmax est utilisé
à la place du classificateur SVM, deuxièmement, l’apprentissage multitâche est utilisée pour former simultanément le
classifieur et le régresseur de la boı̂te englobante.
L’image d’entrée et l’ensemble de propositions d’objet sont fournis au réseau de neurones, ce dernier produit une
carte de caractéristiques convolutionnelle (Features Map). À partir de la carte de caractéristiques convolutionnelle, les
vecteurs de caractéristiques sont extraits à l’aide de la couche de regroupement de régions d’intérêt ’ROI Pooling’.
Le regroupement de régions d’intérêt (également appelé en Anglais RoI Pooling) est un rectangle spécifié par l’utilisateur
qui peut être utilisé pour limiter certains calculs de composition à l’intérieur de ses limites (généralement de manière
temporaire). L’utilisation du ROI pour limiter les calculs s’effectue principalement comme une étape intermédiaire dans
un composite, c’est-à-dire souhaite se concentrer sur le réglage d’une zone particulière de l’image complète.[4]
Figure 5.9 – Fast R-CNN
Les advantages de Fast R-CNN :
— Implementation simple
— Apprentissage rapide
— pas d’intensive écriture/lecture sur le disque dur
— pas d’apprentissage SVM séparée
— Improvement du précision par l’apprentissage multitâche.
5.6 Conclusion
Les méthodes de R-CNN et Fast R-CNN sont des méthodes qui montrées une bonne efficacité de détection des
objets dans les images, (mAp précision moyen : R-CNN : 66.0 % Fast R-CNN : 66.9 %) ça revient à l’utilisation
de l’extraction des propositions de régions, SVM pour classer ou séparer les différents objets dans les images et ROI
Pooling pour limiter les calculs , sachant que Fast R-CNN est 25 fois plus vite que R-CNN.
HAYTAM EL YOUSSFI, PFE: Deep Learning 64

65. Chapitre 6
Implémentation et évaluation
6.1 Environnement de travail
Anaconda est une distribution libre et open source des langages de programmation Python et R appliqué au
développement d’applications dédiées à la science des données et à l’apprentissage automatique (traitement de données
à grande échelle, analyse prédictive, calcul scientifique), qui vise à simplifier la gestion des paquets et de déploiement.
Les versions de paquetages sont gérées par le système de gestion de paquets conda. La distribution Anaconda est
utilisée par plus de 6 millions d’utilisateurs et comprend plus de 250 paquets populaires en science des données adaptés
pour Windows, Linux et MacOS.
PyCharm est un environnement de développement intégré utilisé pour programmer en Python.
Il permet l’analyse de code et contient un débogueur graphique. Il permet également la gestion des tests unitaires,
l’intégration de logiciel de gestion de versions
Colaboratory est un environnement de notebook Jupyter qui ne nécessite aucune configuration et qui s’exécute
entièrement dans le cloud. Il vous permet d’écrire et d’exécuter du code, de sauvegarder et partager vos analyses, et
d’accéder à de puissantes ressources informatiques. Tout cela gratuitement, depuis votre navigateur.
TeXstudio est un environnement d’écriture intégré pour la création de documents LaTeX
65

66. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
6.2 Logiciels et librairies Utilisés dans l’implémentation
6.2.1 Python
Python :est un langage de programmation de haut niveau interprété (il n’y a pas d’étape de compilation) et
orienté objet avec une sémantique dynamique. Il est très sollicité par une large communauté de développeurs et
de programmeurs. Python est un langage simple, facile à apprendre et permet une bonne réduction du cout de la
maintenance des codes. Les bibliothèques (packages) python encouragent la modularité et la réutilisabilité des codes.
Python et ses bibliothèques sont disponibles (en source ou en binaires) sans charges pour la majorité des plateformes
et peuvent être redistribués gratuitement.
6.2.2 TensorFlow
TensorFlow est un framework de programmation pour le calcul numérique qui a été rendu Open Source par Google
en Novembre 2015. Depuis son release, TensorFlow n’a cessé de gagner en popularité, pour devenir très rapidement l’un
des frameworks les plus utilisés pour le Deep Learning et donc les réseaux de neurones. Son nom est notamment inspiré
du fait que les opérations courantes sur des réseaux de neurones sont principalement faites via des tables de données
multi-dimensionnelles, appelées Tenseurs (Tensor). Un Tensor à deux dimensions est l’équivalent d’une matrice.
Aujourd’hui, les principaux produits de Google sont basés sur TensorFlow : Gmail, Google Photos, Reconnaissance de
voix.
6.2.3 Keras
Keras : est une API de réseaux de neurones de haut niveau, écrite en Python et capable de fonctionner sur
TensorFlow ou Theano. Il a été développé en mettant l’accent sur l’expérimentation rapide. Être capable d’aller de
l’idée à un résultat avec le moins de délai possible est la clé pour faire de bonnes recherches. Il a été développé dans le
cadre de l’effort de recherche du projet ONEIROS (Open-ended Neuro-Electronic Intelligent Robot Operating System),
et son principal auteur et mainteneur est François Chollet, un ingénieur Google.
En 2017, l’équipe TensorFlow de Google a décidé de soutenir Keras dans la bibliothèque principale de TensorFlow.
Chollet a expliqué que Keras a été conçue comme une interface plutôt que comme un cadre d’apprentissage end to
end. Il présente un ensemble d’abstractions de niveau supérieur et plus intuitif qui facilitent la configuration des réseaux
neuronaux indépendamment de la bibliothèque informatique de backend. Microsoft travaille également à ajouter un
backend CNTK à Keras aussi.
6.2.4 Scikit-learn
Scikit-learn :est une bibliothèque libre Python dédiée à l’apprentissage automatique. Elle est développée par de
nombreux contributeurs notamment dans le monde académique par des instituts français d’enseignement supérieur et
de recherche comme Inria et Télécom ParisTech.
Elle comprend notamment des fonctions pour estimer des forêts aléatoires, des régressions logistiques, des algo-
rithmes de classification, et les machines à vecteurs de support. Elle est conçue pour s’harmoniser avec des autres
bibliothèques libre Python, notamment NumPy et SciPy.
6.3 Configuration utilisé dans l’implémentation
La configuration du matériel utilisé dans notre implémentation est :
— Un PC portable ASUS/HP i7 CPU/GPU 3.40 GHZ
— Carte graphique Nvidia GeForce GT920M
— RAM de taille 8 GO
— Disque dur de taille 1000 GO
6.4 Atelier 1 : Exemple d’un classificateur du sexe d’une personne à partir
de sa taille et son poids
Dans cet atelier, on va mettre on oeuvre classificateur du sexe de la personne à partir de sa taille et sa poids en
utilisant un perceptron.
Les bibliothèques utilisées :
HAYTAM EL YOUSSFI, PFE: Deep Learning 66

67. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Numpy pour manipuler des matrices ou tableaux multidimensionnels ainsi que des fonctions mathématiques opérant
sur ces tableaux.
Pandas pour la manipulation et l’analyse des données. Elle propose en particulier des structures de données et des
opérations de manipulation de tableaux numériques et de séries temporelles.
Random : pour générer des nombres aléatoires.
Préparation des données d’entrée du perceptron :
On a 30 données pour l’entrée du perceptron, 15 données représentant les femmes (1), et 15 données peprésentant
les hommes (-1). On import le fichier Excel qui contient tous les données nécessaires pour notre atelier, puis :
— On stock nos données (taille et poid) concernant 30 personnes, 15 femmes et 15 hommes avec une constante
cte=1 dans un tableau de dimension (30,3) :
— On stock les sorties cibles dans un tableau de dimension (30,1) : les sorties cibles sont soit 1 soit -1, 1 : pour
les femmes et -1 : pour les hommes
1 donnees = pandas . r e a d c s v ( ’ S t a t i s t i q u e −T a i l l e V s P o i d s . csv ’ )
2 x e n t r e e = donnes . i l o c [ : , 0 : 3 ] . v a l u e s
3 y s o r t i e= donnes . i l o c [ : , 3 : 4 ] . v a l u e s
Nous avons dans ce cas, deux caractéristiques : taille et poid, les valeurs de poid sont plus grandes que les valeurs
de taille ; par conséquent, les valeurs de poid vont dominer et avoir un effet plus important que les valeurs de taille
sur les sorties. Pour éviter ça, nous devons utiliser la technique de standardisation pour mettre toutes les données à
la même échelle. Le résultat de la standardisation est que les entités seront redimensionnées afin qu’elles aient les
propriétés d’une distribution standard avec µ = 0 et σ = 1. où µ est la moyenne et σ est l’écart type par rapport à la
moyenne ; Les nouvelles valeurs des échantillons sont calculées comme suit : z = (x − µ)σ.
1 # t a b l e a u pour s t o c k e r l a moyenne des t a i l l e [ 0 ] et La moyenne des poids [ 1 ] mean t p =[]
2 s t a n d a r d d e v i a t i o n = [ ]
3 def s t a n d a r d i s a t i o n ( x ) :
4 m= np . mean( x , 0 ) ;
5 mean t p . append (m[ 0 ] )
6 mean t p . append (m[ 1 ] )
7 s t a n d a r d d e v i a t i o n . append (0)
8 f o r i i n range (0 , x . shape [ 0 ] ) :
9 s t a n d a r d d e v i a t i o n [0]+=math . pow (( x [ i ][0] − mean t p [ 0 ] ) ,2) s t a n d a r d d e v i a t i o n [0]= math . s q r t
((1/ x . shape [ 0 ] ) ∗ s t a n d a r d d e v i a t i o n [ 0 ] )
HAYTAM EL YOUSSFI, PFE: Deep Learning 67

68. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
10 f o r i i n range (0 , x . shape [ 0 ] ) :
11 x [ i ] [ 0 ] =(x [ i ][0] − mean t p [ 0 ] ) / s t a n d a r d d e v i a t i o n [ 0 ]
12 s t a n d a r d d e v i a t i o n . append (0)
13 f o r i i n range (0 , x . shape [ 0 ] ) :
14 s t a n d a r d d e v i a t i o n [1]+=math . pow (( x [ i ][1] − mean t p [ 1 ] ) ,2) s t a n d a r d d e v i a t i o n [1]= math .
s q r t ((1/ x . shape [ 0 ] ) ∗ s t a n d a r d d e v i a t i o n [ 1 ] )
15 f o r i i n range (0 , x . shape [ 0 ] ) :
16 x [ i ] [ 1 ] =(x [ i ][1] − mean t p [ 1 ] ) / s t a n d a r d d e v i a t i o n [ 1 ]
17 s t a n d a r d i s a t i o n ( x e n t r e e )
L’étape suivante est de diviser les données en deux parties : une grande partie pour l’apprentissage, et le reste pour
les tests. Pour cela, nous introduisons une fonction qui prend comme paramètres les entrées et les sorties, ainsi que le
pourcentage des données que nous voulons spécifier aux tests, et le reste pour la phase d’apprentissage.
1 def v c o n t i e n t ( tab , num) :
2 f o r i i n range (0 , l e n ( tab ) ) :
3 i f tab [ i ]==num :
4 r e t u r n True
5 r e t u r n F a l s e
6 def DiviserDonnees ( entree , s o r t i e , porcentage ) :
7 a p p i n d i c e =[]
8 t e s t i n d i c e =[]
9 l e n a i=l e n ( e n t r e e ) ∗ porcentage
10 l e n t i=l e n ( e n t r e e )−l e n a i
11 x a p p r e n t i s s a g e = np . empty ( shape =[ i n t ( l e n t i ) , 3 ] )
12 x t e s t e = np . empty ( shape =[ i n t ( l e n a i ) , 3 ] )
13 y a p p r e n t i s s a g e = np . empty ( shape =[ i n t ( l e n t i ) , 1 ] )
14 y t e s t e = np . empty ( shape =[ i n t ( l e n a i ) , 1 ] )
15 w h i l e l e n ( a p p i n d i c e )!= l e n t i or l e n ( t e s t i n d i c e )!= l e n a i :
16 i=random . r a n d i n t (0 , l e n ( e n t r e e ) −1)
17 j=random . r a n d i n t (0 ,1)
18 i f j == 0:
19 i f l e n ( a p p i n d i c e )!= l e n t i and not v c o n t i e n t ( a p p i n d i c e , i ) and not v c o n t i e n t (
t e s t i n d i c e , i ) :
20 a p p i n d i c e . append ( i )
21 e l s e :
22 j=1
23 i f j == 1:
24 i f l e n ( t e s t i n d i c e )!= l e n a i and not v c o n t i e n t ( t e s t i n d i c e , i ) and not v c o n t i e n t (
a p p i n d i c e , i ) :
25 t e s t i n d i c e . append ( i )
26 count=0
27 f o r i i n range (0 , l e n ( a p p i n d i c e ) ) :
28 x a p p r e n t i s s a g e [ count ]=[ e n t r e e [ a p p i n d i c e [ i ] ] [ 0 ] , e n t r e e [ a p p i n d i c e [ i ] ] [ 1 ] , e n t r e e [
a p p i n d i c e [ i ] ] [ 2 ] ]
29 y a p p r e n t i s s a g e [ count ]=[ s o r t i e [ a p p i n d i c e [ i ] ] ]
30 count+=1
31 count=0
32 f o r i i n range (0 , l e n ( t e s t i n d i c e ) ) :
33 x t e s t e [ count ]=[ e n t r e e [ t e s t i n d i c e [ i ] ] [ 0 ] , e n t r e e [ t e s t i n d i c e [ i ] ] [ 1 ] , e n t r e e [ t e s t i n d i c e [
i ] ] [ 2 ] ]
34 y t e s t e [ count ]=[ s o r t i e [ t e s t i n d i c e [ i ] ] ]
35 count+=1
36 r e t u r n x a p p r e n t i s s a g e , x t e s t e , y a p p r e n t i s s a g e , y t e s t e
37 x a p p r e n t i s s a g e , x t e s t , y a p p r e n t i s s a g e , y t e s t=DiviserDonnees ( x e n t r e e , y s o r t i e , 0 . 3 )
Pour la fonction d’activation, on choisie la fonction de heaviside pour determiner si la sortie sera 1 ou bien -1 :
1 def a c t i v a t i o n ( x ) :
2 f o r i i n range (0 , l e n ( x ) ) :
3 i f x [ i ] = 0:
4 x [ i ]=1
5 e l s e :
6 x [ i ]=−1
7 r e t u r n x
L’étape suivante est de générer les poids (Pi) aléatoirement : on choisie des valeurs entre -0.5 et 0.5 :
1 np . random . seed (1)
2 poids = 1∗np . random . random ( ( 3 , 1 ) ) −0.5
HAYTAM EL YOUSSFI, PFE: Deep Learning 68

69. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Aprés avoir déterminer les poids aléatoirement, on fait les traitement pour trouver les poids précis qui donnent
les résultats correctes, par la mise à jour de ces poids, cette mise à jour s’applique aprés l’application du fonction
d’activation sur la somme px, et le calcule d’erreur qui égale à E= sortiecible − sortiereelle , et change la valeur des
poids par la relation :pi = pi + ∆pi= pi + ηExi , et le taux d’apprentissage. On répete ces opérations jusqu’au le
taux de l’erreur égale à 0 pour tous nos échantillons :
1 def v e r i f i e r e r r e u r e ( x ) :
2 p=0
3 f o r i i n range (0 , l e n ( x ) ) :
4 p+=abs ( x [ i ] )
5 i f p==0:
6 r e t u r n F a l s e
7 e l s e :
8 r e t u r n True
9 #Le taux d ’ a p p r e n t i s s a g e
10 n=0.5
11 #i n i t i a l i s a t i o n d ’ un t a b l e a u des 1 , pour l e taux de l ’ e r r e u r e
12 x=np . ones ((21 ,1) )
13 w h i l e v e r i f i e r e r r e u r e ( x ) :
14 x a p p r e n t i s s a g e = x a p p r e n t i s s a g e . astype ( f l o a t )
15 output=a c t i v a t i o n ( np . dot ( x a p p r e n t i s s a g e , poids ) )
16 x=y a p p r e n t i s s a g e −output
17 adjustments = np . dot ( x a p p r e n t i s s a g e .T, n∗x )
18 poids += adjustments
Aprés avoir entraı̂ner notre perceptron, on représente maintenant nos résultats dans un graphe, pour faire ça on
utilise les poids trouvées pour les prédictions de chaque points d’un intervalle spécéfié pour séparer les deux classes
(femme,homme) :
1 a = np . l i n s p a c e ( −15 ,15 ,200)
2 b = np . l i n s p a c e ( −15 ,15 ,200)
3
4 f o r i i n a :
5 f o r j i n b :
6 i f ( np . dot ( np . a r r a y ( [ i , j , 1 ] ) , poids ) ) = 0:
7 p l t . s c a t t e r ( i , j , c=” l i g h t c o r a l ” )
8 e l s e :
9 p l t . s c a t t e r ( i , j , c=” l i g h t s t e e l b l u e ” )
10 f o r i i n range ( x e n t r e e . shape [ 0 ] ) :
11 i f ( y s o r t i e [ i ]==1) :
12 p l t . s c a t t e r ( x e n t r e e [ i , 0 ] , x e n t r e e [ i , 1 ] , alpha =0.5 , c=” red ” )
13 e l s e :
14 p l t . s c a t t e r ( x e n t r e e [ i , 0 ] , x e n t r e e [ i , 1 ] , alpha =0.5 , c=” blue ” )
15 p l t . p l o t ()
16 p l t . show ()
HAYTAM EL YOUSSFI, PFE: Deep Learning 69

70. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
6.5 Atelier 2 : Exemple d’une classification binaire et multiple par un
réseau de neurone multicouches (MLP)
Dans cet atelier nous allons mettre en œuvre un réseau de neurones Multicouche (en anglais Multilayer Per-
ceptron) à keras qui sera adapter par tensorflow 1
. Nous utiliserons la classification binaire des images des chiffres
manuscrite (0 et 1) et d’autre part la classification Multiple des chiffres manuscrite MNIST , comme ces deux exemple
pour illustrer l’efficacité d’un réseau de neurones Multicouche.
Base des images : MNIST :
MNIST est un ensemble des données chiffrées manuscrites couramment utilisé comprenant 60 000 images dans l’en-
semble d’apprentissage et 10 000 images dans l’ensemble de test. Ainsi, chaque chiffre contient 6000 images dans
le jeu d’entraı̂nement. Les chiffres sont normalisés en taille et centrés dans une image de taille fixe (28*28). La tâche
consiste à former un algorithme d’apprentissage automatique pour reconnaı̂tre correctement un nouvel échantillon de
l’ensemble des tests.
6.5.1 Le réseau de neurone multi-couche dans le cas de classification binaire
Nous allons utiliser des valeurs de pixels comme entrées sur le réseau. Les images sont des matrices de taille
(28*28). Nous avons donc reshape la matrice d’images en un tableau de taille 784 (28*28) qui constitue l’entrée de
notre MLP . Nous allons utiliser un réseau avec un couches cachées ayant chacune 120 neurones. La couche en sortie
aura une seul neurone pour la classification binaire des images des chiffres manuscrite 0 et 1 .Voila Un diagramme est
présenté ci-dessous notre cas :
Figure 6.1 – L’architecture de notre réseaux de neurone Multicouches(MLP)
Chargement les données :
La bibliothétique Tensorflow est fourni avec la possibilité de télécharger MNIST dataset . Il a utilise la fonction
tf.keras.datasets.mnist.load.data() qui télécharge les données de ses serveurs si elles ne sont pas présentes sur votre
la machine . Les données chargées à l’aide de cette fonction sont divisées en ensembles de l’apprentissage (TrainSet)
60 000 images et l’ensembles des tests (TestSet) 10 000 images .
1 import m a t p l o t l i b . p y p l o t as p l t
2 import t e n s o r f l o w as t f
3 import numpy as np
4 ( images , l a b e l s ) , ( t e s t i m a g e s , t e s t l a b e l s ) = t f . k e r a s . d a t a s e t s . mnist . l o a d d a t a ()
5 p r i n t ( ” Les donnees d ’ a p p r e n t i s s a g e s : ” , images . shape , l a b e l s . shape )
6 p r i n t ( ” Les donnees de t e s t : ” , t e s t i m a g e s . shape , t e s t l a b e l s . shape )
1. TensorFlow :est un outil open source d’apprentissage automatique développé par Google
HAYTAM EL YOUSSFI, PFE: Deep Learning 70

71. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.2 – La distribution des données
Dans notre cas de classification binaire on va extraire seulement les images des chiffres binaire 0 et 1 :
1 donne = [ ]
2 l a b e l = [ ]
3 d o n n e t e s t = [ ]
4 l a b e l t e s t = [ ]
5
6 f o r i i n range ( images . shape [ 0 ] ) :
7 i f l a b e l s [ i ]==0 or l a b e l s [ i ]==1:
8 donne . append ( images [ i , : , : ] )
9 l a b e l . append ( l a b e l s [ i ] )
10 f o r i i n range ( t e s t i m a g e s . shape [ 0 ] ) :
11 i f t e s t l a b e l s [ i ]==0 or t e s t l a b e l s [ i ]==1:
12 d o n n e t e s t . append ( t e s t i m a g e s [ i , : , : ] )
13 l a b e l t e s t . append ( t e s t l a b e l s [ i ] )
Les données comprennent des nombres manuscrits allant de 0 à 9, ainsi que leur label. Il contient 60 000 échantillons
de l’apprentissage et 10 000 échantillons de test . Chaque échantillon est une image 28*28 en niveaux de gris et les
valeurs de pixels sont comprise entre 0 et 255.
1 l a b e l =[”Nombre e s t 0” , ”Nombre e s t 1” ]
2 f o r i i n range (10) :
3 p l t . s u b p l o t (5 ,2 , i +1)
4 p l t . imshow ( np . reshape ( donne [ i ] , ( 2 8 , 2 8 ) ) , cmap=” gray ” )
5 p l t . t i t l e ( l a b e l [ l a b e l [ i ] ] )
6 p l t . show ()
On vois dans cette l’exécution une séquence des images avec les labels qui indique le numéro de chaque image :
Figure 6.3 – Visualisation des images des nombres manuscrits
Tensorflow fournit un flux de travail très simple pour la formation et l’évaluation des modèles. Il est
décrit avec le schéma suivant :
HAYTAM EL YOUSSFI, PFE: Deep Learning 71

72. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.4 – Flux de travail de Tensorflow
Fondamentalement, nous créons le modèle et le formons en utilisant les données de l’apprentissage . Une fois le
modèle entrainé, nous prenons le modèle pour effectuer une inférence sur les données de test.
Tensorflow fournit une manières de définir le modèle séquentiel utilisé pour empiler des couches de réseau de
neurone .
1 model = t f . k e r a s . models . S e q u e n t i a l ()
— Création de réseau de neurone MLP : Dans notre modéle réseau de neurone est composé d’un seul couches
cachées qui contient 120 neurone et une couche de sortie avec une seul unités L’entrée dans le réseau est
vecteur 784 convertie à partir de l’image 28*28.
1
2 model . add ( t f . k e r a s . l a y e r s . F l a t t e n ( i n p u t s h a p e =[28 , 2 8 ] ) )
3 model . add ( t f . k e r a s . l a y e r s . Dense (120 , a c t i v a t i o n=” sigmoid ” ) )
4 model . add ( t f . k e r a s . l a y e r s . Dense (1 , a c t i v a t i o n=” sigmoid ” ) )
Nous allons utiliser le modèle séquentiel pour construire le réseau. Dans le modèle séquentiel, nous pouvons sim-
plement empiler des couches en ajoutant la couche souhaitée une par une ,L’empilement de couches se fait simplement
avec .add() .Dans notre cas la couche dense, également appelée couche Full connecte, car nous construisons un réseau
MLP dans lequel tous les neurones d’une couche sont connectés aux neurones de la couche précédente. Outre la couche
dense,il y a la fonction d’activation sigmoid. Pour la classification binaire, nous utilisons la fonction d’activation sigmoid
dans dernier couche la couche sortie .
Nous utilisons la fonction model.summary() pour vérifier la configuration du modèle
1 model . summary ()
HAYTAM EL YOUSSFI, PFE: Deep Learning 72

73. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.5 – La configuration de modéle
— La configuration du modéle : Cette étape consiste à spécifier les caractéristiques de l’algorithme d’appren-
tissage ,la fonction de perte à optimiser (loss) est l’entropie croisée binaire, elle correspond d’un échantillon
où la probabilité conditionnelle d’appartenance aux classes est modélisée à l’aide de la loi binomiale . Sgd est
l’algorithme d’optimisation ”optimizer” c’est la descente du gradient stochastique ( optimizer=”sgd” ) .La
métrique (metrics) utilisée pour mesurer la qualité de la modélisation est le taux de reconnaissance ou taux
de succès (metrics=[”accuracy”]).
1 model . compile ( l o s s=” b i n a r y c r o s s e n t r o p y ” , o p t i m i z e r=” sgd ” , m e t r i c s =[” accuracy ” ] )
— Entrainement du modèle :
Le réseau est prêt à être entrainée. Ceci est effectué en utilisant la fonction fit () dans Tensorflow . Nous
spécifions le nombre d’époques à 50. Cela signifie que l’ensemble du jeu de données sera envoyé au réseau 50
fois. Nous utiliserons les données de test pour la validation.
1 model . compile ( l o s s=” b i n a r y c r o s s e n t r o p y ” , o p t i m i z e r=” sgd ” , m e t r i c s =[” accuracy ” ] )
2 h i s t o r y = model . f i t ( donne , l a b e l , epochs =50)
Figure 6.6 – Entrainement du modéle
— Evaluer le modèle entrainé : Nous vérifions les performances de l’ensemble des données de test à l’aide de
la méthode evaluate ().
1 t e s t l o s s , t e s t a c c = model . e v a l u a t e ( donne test , l a b e l t e s t )
2 p r i n t ( ”L ’ e r r e u r de Test e s t ” , t e s t l o s s )
3 p r i n t ( ”La p r e c i s i o n de Test e s t : ” , t e s t a c c )
HAYTAM EL YOUSSFI, PFE: Deep Learning 73

74. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.7 – Evaluation du modéle
Les résultats sont parfait tantque erreur (La fonction de perte ) diminue approche à zero , et la précision tant vers 1 .
— La prédiction du modéle :La génération de prédictions sur de nouvelles données se fait la fonction mo-
del.predict( ) n’oublie pas que nous sommes dans le cas de classification binaire :
1 m o d e l p r e d i c t i o n=model . p r e d i c t ( d o n n e t e s t [ 0 : 1 ] )
2 p r i n t ( m o d e l p r e d i c t i o n , l a b e l t e s t [ 0 : 1 ] )
Figure 6.8 – La prédiction sur l’ensemble de donnée
— La courbe de perte et la précision :
fonction fit() renvoie un objet d’historique contenant un dictionnaire de toutes les métriques devant faire
l’objet d’un suivi pendant l’entraı̂nement. Nous pouvons utiliser les données de l’historique pour tracer les
courbes de perte et de précision et vérifier le déroulement du processus d’entraı̂nement. Vous pouvez utiliser
la fonction history.history([”loss”]) et history.history([”acc”]) pour vérifier les métriques présentes dans
l’historique.
1 p l t . p l o t ( h i s t o r y . h i s t o r y [ ” l o s s ” ] )
2 p l t . x l a b e l ( ’ Epochs ’ , f o n t s i z e =16)
3 p l t . y l a b e l ( ’ Loss ’ , f o n t s i z e =16)
4 p l t . t i t l e ( ”La Courbe d ’ e r r e u r ” , f o n t s i z e =20)
5 p l t . show ()
6
7 p l t . p l o t ( h i s t o r y . h i s t o r y [ ” acc ” ] )
8 p l t . x l a b e l ( ’ Epochs ’ , f o n t s i z e =20)
9 p l t . y l a b e l ( ’ Accuracy ’ , f o n t s i z e =20)
10 p l t . t i t l e ( ”La Courbe de p r e c i s i o n ” , f o n t s i z e =20)
11 p l t . show ()
Figure 6.9 – La courbe d’erreur
HAYTAM EL YOUSSFI, PFE: Deep Learning 74

75. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.10 – La courbe de précision
Pour afficher la dernier mise a jour des poids on utilise la méthode get.weights()
1 p r i n t ( ” Recupere l e s poids du modele : ” )
2 p r i n t ( model . g e t w e i g h t s () )
Figure 6.11 – L’affichage des poids synaptiques
6.5.2 Le réseau de neurone multi-couche dans le cas d’une classification multiple
Dans notre cas La classification Multiple nous allons utiliser des valeurs de pixels brutes d’images comme entrées
sur le réseau , le même chose que on a vu dans la classification binaire seulement il existe quelque différence par
exemple dans la couches sortie on va classifie 10 objets alors on a besoin de 10 neurones à la couche sortie . En plus
on’augmente le nombre de couche cachée en deux couches à cause de la quantité des images et pour amélioré la
performance de notre programme,la première couche contient 280 neurones et la deuxième 170 neurones , avec une
fonction d’activation ”Relu” qui est nécessaire pour introduire la non-linéarité dans le modèle et remplace donc
toutes les valeurs négatives reçues en entrées par des zéros.La dernière couche est une couche softmax 2
puisqu’il
s’agit d’un problème de classification multiclass attribue des probabilités décimales à chaque classe d’un problème à
plusieurs classes. La somme de ces probabilités décimales doit être égale à 1. Cette contrainte supplémentaire permet
de faire converger l’apprentissage plus rapidement qu’il ne le ferait autrement ,Pour la classification binaire, nous
pouvons utiliser sigmoid.Voila Un diagramme est présenté la couche sortie ci-dessous notre cas :
2. Softmax complet est relativement économique lorsque le nombre de classes est petit, mais devient extrêmement coûteux lorsque le
nombre de classes augmente. L’échantillonnage de candidats peut améliorer l’efficacité des problèmes qui comportent un grand nombre de
classes.
HAYTAM EL YOUSSFI, PFE: Deep Learning 75

76. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.12 – La couche sortie d’un réseau de neurone dans le cas de classification Multiple
1 import m a t p l o t l i b . p y p l o t as p l t
2 import t e n s o r f l o w as t f
3 import numpy as np
4 ( t r a i n i m a g e s , t r a i n l a b e l s ) ,( t e s t i m a g e s , t e s t l a b e l s ) = t f . k e r a s . d a t a s e t s . mnist . l o a d d a t a ()
5 p r i n t ( t r a i n i m a g e s . shape )
6 p r i n t ( t r a i n l a b e l s . shape )
7 l a b e l =[”Nombre e s t 0” , ”Nombre e s t 1” , ”Nombre e s t 2” , ”Nombre e s t 3” , ”Nombre e s t 4” , ”Nombre
e s t 5” , ”Nombre e s t 6” , ”Nombre e s t 7 ” , ”Nombre e s t 8” , ”Nombre 9” ]
8 f o r i i n range (10) :
9 p l t . s u b p l o t (5 ,3 , i +1)
10 p l t . imshow ( np . reshape ( t r a i n i m a g e s [ i ] , ( 2 8 , 2 8 ) ) , cmap=” gray ” )
11 p l t . t i t l e ( l a b e l [ t r a i n l a b e l s [ i ] ] )
12 p l t . show ()
Les données d’entrainement comprennent des nombres manuscrits allant de 0 à 9, ainsi que leur labels.
Figure 6.13 – Visualisation des images des nombres manuscrits allant de 0 à 9
La structure de notre réseau :
1 model = t f . k e r a s . models . S e q u e n t i a l ()
2
3 model . add ( t f . k e r a s . l a y e r s . F l a t t e n ( i n p u t s h a p e =[28 , 2 8 ] ) )
4 model . add ( t f . k e r a s . l a y e r s . Dense (280 , a c t i v a t i o n=” r e l u ” ) )
5 model . add ( t f . k e r a s . l a y e r s . Dense (170 , a c t i v a t i o n=” r e l u ” ) )
6 model . add ( t f . k e r a s . l a y e r s . Dense (10 , a c t i v a t i o n=” softmax ” ) )
7 model . summary ()
HAYTAM EL YOUSSFI, PFE: Deep Learning 76

77. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.14 – La structure de notre réseau de neurone
6.6 Atelier 3 : Classification multiple avec réseau de neurones convolutifs
6.6.1 Architecture de notre réseau
Dans cette partie ,on va définir l’architecture des trois modèles qu’on a créé et par la suite on va appliquer ces
modèles sur la base d’images CIFAR 10 et CIFAR 100. Pour cela, on va travailler avec les bibliothèques Tensorflow
et Keras pour l’apprentissage et la classification et afin d’améliorer les performances des modèles on va utiliser quelques
techniques simple et efficaces comme data augmentation et dropout .
La base des d’images : CIFAR-10 et CIFAR-100 sont des sous-ensembles d’images étiquetés parmi 80
millions d’images. Ils ont été collectés par Alex Krizhevsky, Vinod Nair et Geoffrey Hinton dont le but de les utiliser
dans le domaine de la reconnaissance d’objet. Ils sont disponibles sur lien suivant :
http ://www.cs.toronto.edu/ kriz/cifar.html
— CIFAR-10 : La base d’image de CIFAR-10 se compose de 60000 images couleur (RGB), chaque image à une
taille de 32∗32, ces images sont réparties en 10 classes, avec 6000 images par classe. Dans cette base on trouve
50000 images pour l’apprentissage et 10000 images pour le test.
Figure 6.15 – Base des images :CIFAR-10
— CIFAR-100 : La base d’image de CIFAR-100 c’est une base d’image qui contient les mêmes caractéristiques
que CIFAR-10, sauf qu’elle possède 100 classes contenant 600 images pour chaque classe. Il y a 500 images
pour l’apprentissage et 100 images pour le test par classe. Les 100 classes du CIFAR-100 sont regroupées en
20 superclasses. Chaque image est livrée avec une étiquette ”fine” (la classe à laquelle elle appartient) et une
étiquette ”grossière” (la superclasse à laquelle elle appartient).
HAYTAM EL YOUSSFI, PFE: Deep Learning 77

78. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.16 – La base des images :CIFAR-100
Au cours de nos expérimentations, nous avons créé trois modèles (modèle 1, modèle 2 et modèle 3) avec différents
architectures, où on a appliqué trois modèle sur CIFAR10 .
Architecture du modèle 01 :
Le premier modèle que nous présentons dans la figure 4.17 est composé de deux couches de convolution et une
seul couches de maxpooling et deux couches de fully connected.
L’image en entrée est de taille 32*32, l’image passe d’abord à la première couche de convolution. Cette couche est
composée de 32 filtres de taille 3*3, Chacune de nos couches de convolution à une fonction d’activation ReLU cette
fonction force les neurones à retourner des valeurs positives, après cette convolution 32 features maps de taille 32*32
seront créés.
Les 32 feature maps qui sont obtenus auparavant ils sont donnés en entrée de la deuxième couche de convolution
qui est composée aussi de 32 filtres, une fonction d’activation ReLU est appliquée sur la couche de convolution, ensuite
on applique Maxpooling pour réduire la taille de l’image ainsi la quantité de paramètres et de calcul. À la sortie de
cette couche, nous aurons 32 feature maps de taille 16*16.À Le vecteur de caractéristiques issu des convolutions a
une dimension de 8192.
Après ces deux couches de convolution, nous utilisons un réseau de neurones composé de deux couches fully
connected. la premières couche a 128 neurones où la fonction d’activation utilisée est le ReLU, et la deuxiéme couche
est un softmax qui permet de calculer la distribution de probabilité des 10 classes (nombre de classe dans la base
d’image CIFAR10).
Figure 6.17 – Configuration du modèle 1
HAYTAM EL YOUSSFI, PFE: Deep Learning 78

79. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Architecture du modèle 2 :
Le deuxiéme modèle que nous présentons dans la figure 4.18 est composé de quatre couches de convolution et
deux couches de maxpooling et deux couches de fully connected.
L’image en entrée est de taille 32*32, l’image passe d’abord à la première couche de convolution. Cette couche est
composée de 32 filtres de taille 3*3, Chacune de nos couches de convolution à une fonction d’activation ReLU cette
fonction force les neurones à retourner des valeurs positives, après cette convolution 32 features maps de taille 32*32
seront créés.
Les 32 feature maps qui sont obtenus auparavant ils sont donnés en entrée de la deuxième couche de convolution
qui est composée aussi de 32 filtres, une fonction d’activation ReLU est appliquée sur la couche de convolution, ensuite
on applique Maxpooling pour réduire la taille de l’image ainsi la quantité de paramètres et de calcul. À la sortie de
cette couche, nous aurons 32 feature maps de taille 16*16.
On répète la même chose avec les couches de convolutions trois, quatre sont composées de 64 filtres, la fonction
d’activation ReLU est appliquée toujours sur chaque convolution.Une couche de Maxpooling est appliquée après la
couche de convolution quatre. À la sortie de cette couche,nous aurons 64 feature maps de taille 8*8. Le vecteur de
caractéristiques issu des convolutions a une dimension de 4096. Après ces deux couches de convolution, nous utilisons
un réseau de neurones composé de deux couches fully connected. la premières couche a 128 neurones où la fonction
d’activation utilisée est le ReLU, et la deuxiéme couche est un softmax qui permet de calculer la distribution de
probabilité des 10 classes (nombre de classe dans la base d’image CIFAR10).
Figure 6.18 – Configuration du modèle 2
Architecture du modèle 3 :
Le toisiéme modèle que nous présentons dans la figure 4.19 est composé de six couches de convolution et trois
couches de maxpooling et deux couches de fully connected.
L’image en entrée est de taille 32*32, l’image passe d’abord à la première couche de convolution. Cette couche
est composée de 32 filtres de taille 3*3, la fonction d’activation ReLU est utilisé, cette fonction d’activation force les
neurones à retourner des valeurs positives, après cette convolution 32 features maps seront créés de taille 32*32.
Ensuite, les 32 feature maps qui sont obtenus ils sont données en entrée de la deuxième couche de convolution
qui est composée aussi de 32 filtres. La fonction d’activation ReLU est appliquée sur cette couche. Le Maxpooling
est appliqué après pour réduire la taille de l’image. À la sortie de cette couche, nous aurons 32 feature maps de taille
16*16.
On répète la même chose avec les couches de convolutions trois et quatre qui sont composées de 64 filtres, la
fonction d’activation ReLU est appliquée toujours sur chaque convolution. Une couche de Maxpooling est appliqué
après la couche de convolution quatre. À la sortie de cette couche, nous aurons 64 feature maps de taille 8*8.On
répète en troisiéme fois avec les couches de convolutions cinq et six qui compose de 128 filtres avec une fonctions
d’activations ReLU , une couche Maxpooling est aprés la couche de convolution six à la sortie de cette couche , nous
aurons 128 feature maps de taille 4*4 , Le vecteur de caractéristiques issu des convolutions a une dimension de 2048.
Après ces quatre couches de convolution, nous utilisons un réseau de neurones composé de deux couches fully
connected. La première couche est composée de 125 neurones où la fonction d’activation utilisée est le ReLU, la
deuxième couche utilise la fonction softmax qui permet de calculer la distribution de probabilité des 10 classes (nombre
HAYTAM EL YOUSSFI, PFE: Deep Learning 79

80. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
de classe dans la base d’image CIFAR10).
Figure 6.19 – Configuration du modèle 3
6.6.2 Résultats obtenus et discussion
Afin de montrer les résultats obtenus pour les trois modèles, on illustre dans ce qui suit les résultats en termes de
précision et d’erreur ainsi que matrice de confusion pour chacun des trois modèles.
Résultats obtenus pour le modèle 1 :
(a) La courbe de précision
[H]
(b) La courbe d’erreur
[H]
Figure 6.20 – Précision et Erreur pour le Modèle 01
HAYTAM EL YOUSSFI, PFE: Deep Learning 80

81. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.21 – Matrice de Confusion pour le Modèle 01
[0 :Avion , 1 :Voiture , 2 :Oiseau , 3 :Chat , 4 :Cerf ,5 :Chien , 6 :La grenouille ,7 :Cheval ,8 :na-
rive,9 :camion]
Figure 6.22 – Nombre total des images mal et bien classé de modéle 1
HAYTAM EL YOUSSFI, PFE: Deep Learning 81

82. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.23 – Taux d’erreur et la précision de modéle 1
Après l’analyse des résultats obtenus, On constate les remarques suivantes :
D’après la Figure 4.20 La précision de l’apprentissage et de la validation augmente avec le nombre d’époque, ceci
reflète qu’à chaque époque le modèle apprenne plus d’informations. Si la précision est diminuée alors on aura besoin
de plus d’information pour faire apprendre notre modèle et par conséquent on doit augmenter le nombre d’époque et
vice versa. De même, l’erreur d’apprentissage et de la validation diminue avec le nombre d’époque.
D’après la figure 4.22 et la figure 4.23 nous remarquons que la totalité des images mal classées est de 3313
images, un taux d’erreur de 0.3313% et la totalité des images bien classées est de 6687 un taux de précision de 0.6687
% .
La matrice de confusion permet d’évaluer la performance de notre modèle, puisqu’elle reflète les métriques du Vrai
positif, Vrai négatif, Faux positif et Faux négatif. La figure 4.21 illustre de près la position de ces métriques pour
chaque classe. A titre d’exemple le modèle a bien classé les images Avion , voiture ,un camion et narive et il a mal
classé les images oiseau, chat , chien et cerf .
Résultats obtenus pour le modèle 02 :
(a) La courbe de précision
[H]
(b) La courbe d’erreur
[H]
Figure 6.24 – Précision et Erreur pour le Modèle 02
HAYTAM EL YOUSSFI, PFE: Deep Learning 82

83. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Figure 6.25 – Matrice de Confusion pour le Modèle 02
[0 :Avion , 1 :Voiture , 2 :Oiseau , 3 :Chat , 4 :Cerf ,5 :Chien , 6 :La grenouille ,7 :Cheval ,8 :na-
rive,9 :camion]
Figure 6.26 – Nombre total des images mal et bien classé de Modéle 2
Figure 6.27 – Taux d’erreur et la précision de Modéle 2
HAYTAM EL YOUSSFI, PFE: Deep Learning 83

84. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Après l’analyse des résultats obtenus, On constate les remarques suivantes :
D’après la Figure 4.24 La précision de l’apprentissage et de la validation augmente avec le nombre d’époque, ceci
reflète qu’à chaque époque le modèle apprenne plus d’informations. Si la précision est diminuée alors on aura besoin
de plus d’information pour faire apprendre notre modèle et par conséquent on doit augmenter le nombre d’époque
et vice versa.Dans la figure nous regardons que la précision de validation augment jusqu’a 0.7 et stabilise par contre
la précision de l’apprentissage augment jusqu’a la sommet 1 et stabilise alors il existe un sur-apprentissage de notre
modéle 2
De même, l’erreur d’apprentissage et de la validation diminue avec le nombre d’époque mais la courbe l’erreur
de validation arrive jusqu’a 1 et augment c’est a dire augmentation des nombres des images qui sont mal classifier à
cause de sur-apprentissage de notre modéle.
D’après la figure 4.26 et la figure 4.27 nous remarquons que la totalité des images mal classées est de 2873
images, un taux d’erreur de 0.2873% et la totalité des images bien classées est de 7127 un taux de précision de 0.7127
% .
La matrice de confusion permet d’évaluer la performance de notre modèle, puisqu’elle reflète les métriques du
Vrai positif, Vrai négatif, Faux positif et Faux négatif. La figure 4.25 illustre de près la position de ces métriques
pour chaque classe. A titre d’exemple le modèle a bien classé les images Avion , voiture ,un camion ,chien et narive
et il a mal classé les images oiseau, chat et cerf .Alors on regarde que Modèle 2 mieux de modèle 1 même si il y’a
sur-apprentissage
Résultats obtenus pour le modèle 03 :
(a) La courbe de précision du modéle 3
[H]
(b) La courbe d’erreur du modéle 3
[H]
Figure 6.28 – Précision et Erreur pour le modèle 03
Figure 6.29 – Matrice de Confusion pour le modèle 03
HAYTAM EL YOUSSFI, PFE: Deep Learning 84

85. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
[0 :Avion , 1 :Voiture , 2 :Oiseau , 3 :Chat , 4 :Cerf ,5 :Chien , 6 :La grenouille ,7 :Cheval ,8 :na-
rive,9 :camion]
Figure 6.30 – Nombre total des images mal et bien classé du Modéle 3
Figure 6.31 – Taux d’erreur et la précision du Modéle 3
Après l’analyse des résultats obtenus, On constate les remarques suivantes :
D’après la Figure 4.28 La précision de l’apprentissage et de la validation augmente avec le nombre d’époque, ceci
reflète qu’à chaque époque le modèle apprenne plus d’informations. Si la précision est diminuée alors on aura besoin
de plus d’information pour faire apprendre notre modèle et par conséquent on doit augmenter le nombre d’époque et
vice versa.Dans la figure nous regardons que la précision de validation augment jusqu’a 0.6 et stabilise par contre la
précision de l’apprentissage augment jusqu’a la sommet 1 et stabilise
De même, l’erreur d’apprentissage et de la validation diminue avec le nombre d’époque mais la courbe l’erreur
de validation arrive jusqu’a 1 et augment c’est a dire augmentation des nombres des images qui sont mal classifie à
cause de sur-apprentissage de notre modéle alors il faut augmenter la performance de notre modéle par la méthode
de régularisation ( Dropout ou Augmentation Data )
D’après la figure 4.30 et la figure 4.31 nous remarquons que la totalité des images mal classées est de 2628
images, un taux d’erreur de 0.2628% et la totalité des images bien classées est de 7372 un taux de précision de 0.73 % .
HAYTAM EL YOUSSFI, PFE: Deep Learning 85

86. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
La matrice de confusion permet d’évaluer la performance de notre modèle, puisqu’elle reflète les métriques du
Vrai positif, Vrai négatif, Faux positif et Faux négatif. La figure 4.49 illustre de près la position de ces métriques
pour chaque classe. A titre d’exemple le modèle a bien classé les images Avion , voiture ,un camion ,chien , narive,
cerf et oiseau . il a mal classifié les images chat .Alors on regarde que Modèle 3 mieux du modèle 2 même si il y’a
sur-apprentissage donc il faut augmenté la pérformence de ce modéle 3
6.6.3 Comment développer un modèle amélioré ?
DROPOUT :
Le overfitting survient principalement parce que les paramètres du réseau deviennent trop collés par rapport aux
données d’entrainements. Nous pouvons ajouter une couche de suppression de neurones ”DROPOUT” pour surmonter
relativement ce problème. Pour cela nous allons désactiver une fraction de neurones de manière aléatoire pendant le
processus d’entraı̂nement, ce qui réduit légèrement la dépendance vis-à-vis de l’entraı̂nement.
Augmentation de données :
L’augmentation des données implique la copie des exemples de l’ensemble de données d’apprentissage avec de pe-
tites modifications aléatoires. Cela a un effet de régularisation, car il étend à la fois le jeu de données d’apprentissage
et permet au modèle d’apprendre les mêmes caractéristiques générales, bien que de manière plus généralisée.
Les deux techniques qui nous avons veut on va appliquer sur notre modéle 3 pour amélioré son perfor-
mence par conséquence on obtient 88.620 % dans la précision.D’aprés la figure 4.32 et la figure 4.33 La
précision de l’apprentissage et de la validation augmente avec le nombre d’époque, ceci reflète qu’à chaque
époque le modèle apprenne plus d’informations. De même, l’erreur d’apprentissage et de la validation dimi-
nue avec le nombre d’époque et converge vers 0
Figure 6.32 – La courbe de précision du modéle 3 prés l’amélioration
Figure 6.33 – La courbe d’erreur du modéle 3 prés l’amélioration
HAYTAM EL YOUSSFI, PFE: Deep Learning 86

87. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
Extrait de code de modéle 3 aprés l’amélioration :
1 model = S e q u e n t i a l ()
2 model . add ( Conv2D (32 , (3 , 3) , a c t i v a t i o n=’ r e l u ’ , i n p u t s h a p e =(32 , 32 , 3) ) )
3 model . add ( BatchNormalization () )
4 model . add ( Conv2D (32 , (3 , 3) , a c t i v a t i o n=’ r e l u ’ ) )
5 model . add ( BatchNormalization () )
6 model . add ( MaxPooling2D ((2 , 2) ) )
7 model . add ( Dropout ( 0 . 2 ) )
8 model . add ( Conv2D (64 , (3 , 3) , a c t i v a t i o n=’ r e l u ’ ) )
9 model . add ( BatchNormalization () )
10 model . add ( Conv2D (64 , (3 , 3) , a c t i v a t i o n=’ r e l u ’ ) )
11 model . add ( BatchNormalization () )
12 model . add ( MaxPooling2D ((2 , 2) ) )
13 model . add ( Dropout ( 0 . 3 ) )
14 model . add ( Conv2D (128 , (3 , 3) , a c t i v a t i o n=’ r e l u ’ ) )
15 model . add ( BatchNormalization () )
16 model . add ( Conv2D (128 , (3 , 3) , a c t i v a t i o n=’ r e l u ’ ) )
17 model . add ( BatchNormalization () )
18 model . add ( MaxPooling2D ((2 , 2) ) )
19 model . add ( Dropout ( 0 . 4 ) )
20 model . add ( F l a t t e n () )
21 model . add ( Dense (128 , a c t i v a t i o n=’ r e l u ’ ) )
22 model . add ( BatchNormalization () )
23 model . add ( Dropout ( 0 . 5 ) )
24 model . add ( Dense (10 , a c t i v a t i o n=’ softmax ’ ) )
model = Sequential()
Les modèles de Keras peuvent prendre deux formes - Sequential et via l’API fonctionnelle. Pour la plupart des
réseaux d’apprentissage en profondeur que vous construisez, le modèle Sequential est probablement ce que vous utili-
serez. Il vous permet d’empiler facilement des couches séquentielles du réseau dans l’ordre de l’entrée à la sortie.
model.add(Conv2D(32, (3,3), activation=’relu’, input shape=(32, 32, 3)))
Nous ajoutons une couche convolutifs 2D pour traiter les images entées avec une forme d’entré (ligne, colonne,
chaine de couleur) et la taille de convolution (kernel size : la taille de la fenêtre mobile qui navigue sur l’image) qui est
(3, 3) pixel et le nombre des filtres qui est égale à 32.Cette commande permet de créer 32 features maps en utilisant
un filtre de taille 3 par 3 pixels et une fonction d’activation de type RELU.
model.add(BatchNormalization())
Normaliser les activations de la couche précédente à chaque lot, c’est-à-dire appliquer une transformation qui
maintient l’activation moyenne proche de 0 et l’écart type d’activation proche de 1.
model.add(MaxPool2D(pool size=(2, 2), activation=’relu’))
Cette ligne de commande permet de réduire la taille de l’image, La méthode Max Pooling est utilisée et la taille
de l’image sera divisée sur 2.
model.add(Dropout(0.2))
Pour ne pas tomber dans le problème de sur apprentissage il faut utiliser dropout elle est très efficace pour les
réseaux de neurones pour le régulariser et elle n’a besoin que d’un paramètre pour être défini, dont : Le paramètre
rate avec pour valeur 0.25 et 0.5.
model.add(Flatten())
Cette commande permet de créer un seul vecteur 1D puis connecter avec la première couche cachée pour com-
mencer la classification.
model.add(Dense())
Cette commande permet de créer une couche cachée avec une taille de 1024 neurones, la fonction RELU est utilisé
comme fonction d’activation.
HAYTAM EL YOUSSFI, PFE: Deep Learning 87

88. CHAPITRE 6. IMPLÉMENTATION ET ÉVALUATION
model.add(Dense(10, activation=’softmax’))
Cette commande permet de créer une couche de sortie composée de 10 neurones (nombre de classes) ,la fonction
softmax est utilisé pour calculer la probabilité de chaque classe.
model.compile(optimizer=sgd, loss=’categorical crossentropy’, metrics=[’accuracy’])
Cette commande permet de définir optimizer à utiliser et de compiler notre modèle, elle prend deux paramètres
la fonction de perte (loss) et d’optimisation (Optimizer). On a choisi la fonction ”binary crossentropy” pour la clas-
sification binaire et pour la classification multiple en utilise categorical crossentropy comme fonction ”loss” et ”sgd”
comme un optimiseur.
6.7 Conclusion
Nous avons présenté dans ce chapitre une approche de classification binaire et multiple basée sur les réseaux de
neurones multicouche et nous avons vous limitations de ce dernière pour cette raison nous avons basé encore sur les
réseaux de neurones convolutifs, pour cela on a utilisé trois modèles avec différents architectures et on a montré les
différents résultats obtenus en termes de précision et d’erreur. La comparaison des résultats trouvés a montré que le
nombre d’époque, la taille de la base et la profondeur de réseaux, sont des facteurs importants pour l’obtention de
meilleurs résultats.
Nous avons parlé aussi sur les méthodes de régularisation (dropout et data augmentation) utilisées pour éviter le
problème de sur-apprentissage.
HAYTAM EL YOUSSFI, PFE: Deep Learning 88

89. Chapitre 7
Conclusion et prespectives
Dans ce projet nous avons discuté des notions fondamentales des réseaux de neurones en générale et des réseaux de
neurones convolutifs en particulier. Nous avons introduit ces réseaux de neurones convolutifs en présentant les différents
types de couches utilisées dans la classification dans les images et les vidéos :la couche convolutif, la couche de recti-
fication, la couche de pooling et la couche fully connected. Nous avons parlé aussi sur les méthodes de régularisation
(dropout et data augmentation) utilisées pour éviter le problème de sur-apprentissage.
Les paramètres du réseau sont difficiles à définir a priori. C’est pour cette raison que nous avons défini différents
modèles avec des architectures différentes afin d’obtenir des meilleurs résultats en terme de précision et d’erreur.
Nous avons rencontré quelques problèmes dans la phase d’implémentation, l’utilisation d’un CPU a fait que le temps
d’exécution était trop couteux. Afin de régler ce problème on doit utiliser des réseaux de neurones convolutifs plus
profonds déployé sur un GPU au lieu d’un CPU sur des bases plus importantes.
89

90. Bibliographie
[1] Charu C Aggarwal. Neural networks and deep learning. Springer, 2018.
[2] Tomas Akenine-Moller, Eric Haines et Naty Hoffman. Real-time rendering. AK Peters/CRC Press, 2018.
[3] Michael Beyeler. Machine Learning for OpenCV. Packt Publishing Ltd, 2017.
[4] Ron Brinkmann. The art and science of digital compositing : Techniques for visual effects, animation and
motion graphics. Morgan Kaufmann, 2008.
[5] Nello Cristianini, John Shawe-Taylor et al. An introduction to support vector machines and other kernel-
based learning methods. Cambridge university press, 2000.
[6] Robert Epstein, Gary Roberts et Grace Beber. Parsing the Turing test. Springer, 2009.
[7] Michel Verleysen François Blayo. Les réseaux de neurones artificiels. 1996.
[8] Aurélien Géron. Hands-on machine learning with Scikit-Learn and TensorFlow : concepts, tools, and techniques
to build intelligent systems. ” O’Reilly Media, Inc.”, 2017.
[9] Vojislav Kecman. Support vector machines, neural networks, and fuzzy logic models. 2001.
[10] Akshay Kumar Maan, Deepthi Anirudhan Jayadevi et Alex Pappachen James. “A survey of memristive
threshold logic circuits”. In : IEEE transactions on neural networks and learning systems 28.8 (2016), p. 1734-
1746.
[11] Josh Patterson et Adam Gibson. Deep learning : A practitioner’s approach. ” O’Reilly Media, Inc.”, 2017.
[12] Frank Rosenblatt. “The perceptron : a probabilistic model for information storage and organization in the
brain.” In : Psychological review 65.6 (1958), p. 386.
[13] Terrence J Sejnowski. The deep learning revolution. MIT Press, 2018.
[14] Alan Turing. “Mind-a quarterly review of psychology and philosophy”. In : Vol. LIX 236 (1950).
[15] Christopher KI Williams et Carl Edward Rasmussen. Gaussian processes for machine learning. T. 2. 3. MIT
Press Cambridge, MA, 2006.
90