N° d‟ordre : 01/ M2/ IRC /TCO Année Universitaire : 2017 / 2018

UNIVERSITE D’ANTANANARIVO
----------------------
ECOLE SUPERIEURE POLYTECHNIQUE
-----------------------
MENTION TELECOMMUNICATION

MEMOIRE

en vue de l‟obtention

du DIPLOME de MASTER
Titre : Ingénieur
Domaine : Sciences de l‟Ingénieur
Mention : Télécommunication
Parcours : Ingénierie des Radiocommunications (IRC)

par : ANDRIAMIANDRASOA Ianjafitia

SYSTEME DE DETECTION D'OBJET BASE SUR LE

DEEP LEARNING DANS UN MAGASIN
INTELLIGENT
Soutenu le Lundi 12 Août 2019 devant la Commission d‟Examen composée de :

Président :
M. RAKOTONDRAINA Tahina Ezéchiel
Examinateurs :
M. RANDRIAMITANTSOA Andry Auguste
M. ANDRIAMIASY Zidora
M. RAJAONARISON Tianandrasana Roméo
Directeur de mémoire :

M. RATSIMBAZAFY Andriamanga
 REMERCIEMENTS

Avant toute chose, je rends grâce à l‟Eternel Dieu pour l‟amour inconditionnel qu‟Il m‟a témoigné.
Mais aussi pour le temps, le courage, la force et la santé nécessaire à l‟aboutissement de ce travail.

Je tiens aussi à exprimer mes plus vifs remerciements aux quelques personnes suivantes sans qui ce
mémoire n‟aurait pas pu être réalisé :

Monsieur RAVELOMANANA Mamy Raoul, Professeur Titulaire, Président de l‟Université

d‟Antananarivo.

Monsieur RAKOTOSAONA Rijalalaina, Professeur d‟Enseignement Supérieur et Responsable du

Domaine Sciences de l‟Ingénieur de l‟Ecole Supérieure Polytechnique d‟Antananarivo,

Monsieur RAKOTONDRAINA Tahina Ezéchiel, Maître de Conférences, Résponsable de la

Mention Télécommunication qui me fait également l‟honneur de présider le jury de ce mémoire.

Monsieur RATSIMBAZAFY Andriamanga, Maître de Conférences, en tant que Directeur de ce

mémoire, il s'est toujours montré à l'écoute et très disponible tout au long de sa réalisation et auquel
je tiens à témoigner ma reconnaissance et ma gratitude les plus sincères.

Les membres du jury qui ont bien voulu accepter de procéder à l'évaluation de ce modeste travail
malgré leurs occupations, à savoir :

Monsieur RANDRIAMITANTSOA Andry Auguste, Maître de Conférences HDR, Docteur.

Monsieur ANDRIAMIASY Zidora, Maître de Conférences.

Monsieur RAJAONARISON Tianandrasana Roméo, Maître de Conférences.

Tous les enseignants et tout le personnel de l‟Ecole Supérieure Polytechnique d‟Antananarivo, en

particulier ceux de la Mention Télécommunication.

Toute ma famille, mes collègues, mes amis et tous ceux qui ont contribué de près ou de loin à la
réalisation de ce travail.

i
 TABLE DES MATIERES

REMERCIEMENTS .......................................................................................................................... i

NOTATIONS ................................................................................................................................... vii

INTRODUCTION GENERALE ......................................................................................................1

CHAPITRE 1 DU MACHINE LEARNING AU DEEP LEARNING ...........................................2

1.1 Introduction ...............................................................................................................................2

1.2 Types de système d’apprentissage automatique .......................................................................3

1.2.1 Apprentissage supervisé ...................................................................................................3

1.2.2 Apprentissage non supervisé ............................................................................................4

1.2.3 Apprentissage semi-supervisé ..........................................................................................5

1.2.4 Apprentissage avec renforcement ....................................................................................6

1.3 Différence entre classification et régression ............................................................................6

1.3.1 Approximation de fonction ...............................................................................................7

1.3.2 Classification ......................................................................................................................7

1.3.3 Régression ..........................................................................................................................7

1.4 Algorithmes utilisés en machine learning ................................................................................7

1.4.1 Régression Linéaire ...........................................................................................................7

1.4.2 Naive Bayes ......................................................................................................................10

1.4.3 K plus proches voisins (K-NN) .......................................................................................12

1.4.4 K moyenne (K-means) ....................................................................................................14

1.5 Réseaux de neurones artificiels ..............................................................................................15

1.5.1 Neurone biologique .........................................................................................................15

1.5.2 Neurone formel ................................................................................................................16

1.5.3 Perceptron ........................................................................................................................18

1.5.3 Réseau de neurones à propagation avant (feed-forward)............................................19

ii
 1.5.4 Apprentissage des réseaux de neurones ........................................................................20

1.6 L’apprentissage profond (Deep learning) ..............................................................................22

1.6.1 Intérêts du deep learning ................................................................................................23

1.6.2 Architectures des modèles de deep learning .................................................................23

1.6.3 Applications du deep learning ........................................................................................24

1.7 Conclusion ...............................................................................................................................25

CHAPITRE 2 FONDEMENTS DE LA VISION PAR ORDINATEUR .....................................26

2.1 Introduction .............................................................................................................................26

2.2 Notions de base sur les images................................................................................................26

2.2.1 Numérisation....................................................................................................................27

2.2.2 Pixel ..................................................................................................................................28

2.2.3 Dimension .........................................................................................................................28

2.2.4 Résolution .........................................................................................................................28

2.2.5 Niveau de gris ..................................................................................................................29

2.2.6 Images couleurs ...............................................................................................................29

2.2.7 Contraste ..........................................................................................................................29

2.2.8 Luminance........................................................................................................................30

2.2.9 Parasite ou bruit ..............................................................................................................30

2.2.10 Contour ..........................................................................................................................30

2.2.11 Histogramme..................................................................................................................31

2.3 Étapes d’un système de vision .................................................................................................31

2.3.1 Acquisition .......................................................................................................................31

2.3.2 Traitement........................................................................................................................32

2.3.3 Analyse .............................................................................................................................33

2.3.4 Interprétation ..................................................................................................................36

2.4 Filtrage d’image ......................................................................................................................36

iii
 2.4.1 Filtrage par produit de convolution ..............................................................................36

2.4.2 Filtrage par utilisation de la transformée de Fourier ..................................................38

2.5 Détection d’objet ......................................................................................................................38

2.5.1 Méthode de Viola et Jones ..............................................................................................38

2.5.2 Histogramme de gradient orienté (HOG) .....................................................................41

2.6 Conclusion ...............................................................................................................................44

CHAPITRE 3 RESEAUX DE NEURONES CONVOLUTIONNELS ........................................45

3.1 Introduction .............................................................................................................................45

3.2 Généralités sur les CNN ..........................................................................................................45

3.3 Différentes couches d’un CNN ...............................................................................................46

3.3.1 Couche de convolution ....................................................................................................46

3.3.2 Couche de pooling ...........................................................................................................48

3.3.3 Couche Rectified Linear Units .......................................................................................49

3.3.4 Couche entièrement connectée .......................................................................................49

3.4 Divers architectures d’un CNN ..............................................................................................50

3.4.1 LeNet ................................................................................................................................50

3.4.2 AlexNet .............................................................................................................................51

3.4.3 VGGNet ............................................................................................................................51

3.4.4 GoogLeNet/Inception ......................................................................................................52

3.5 Rétropropagation dans un CNN .............................................................................................56

3.5.1 Corrélation croisée et convolution .................................................................................56

3.5.2 Notations utilisées ............................................................................................................56

3.5.3 Forward propagation ......................................................................................................57

3.5.4 Erreur ...............................................................................................................................57

3.5.5 Backpropagation (rétropropagation) ............................................................................57

3.6 Apprentissage par transfert .....................................................................................................61

iv
 3.6.1 Fine tuning total ..............................................................................................................61

3.6.2 Extraction des caractéristiques ......................................................................................62

3.6.3 Fine tuning partiel ...........................................................................................................62

3.7 Détection d’objet utilisant les CNN ........................................................................................62

3.7.1 R-CNN ..............................................................................................................................62

3.7.2 Fast R-CNN ......................................................................................................................64

3.7.3 Faster R-CNN ..................................................................................................................65

3.8 Conclusion ...............................................................................................................................67

CHAPITRE 4 APPLICATION A LA CONCEPTION D’UN SMART STORE .......................68

4.1 Introduction .............................................................................................................................68

4.2 Présentation des environnements de développement utilisés ................................................68

4.2.1 Environnement matériel .................................................................................................68

4.2.2 Environnement logiciel ...................................................................................................69

4.3 Principaux outils utilisés .........................................................................................................69

4.3.1 Tensorflow........................................................................................................................69

4.3.2 OpenCV ............................................................................................................................71

4.3.3 Flask..................................................................................................................................71

4.4 Développement de l’application ..............................................................................................72

4.4.1 Développement de l’application de détection d’objet ..................................................72

4.4.2 Développement de l’application web .............................................................................79

4.5 Test de l’application ................................................................................................................81

4.5.1 Mode de fonctionnement ................................................................................................81

4.5.2 Présentation sous forme d’image ...................................................................................82

Conclusion .....................................................................................................................................85

CONCLUSION GENERALE .........................................................................................................86

ANNEXE 1 NOTIONS SUPPLEMENTAIRES ............................................................................87

v
ANNEXE 2 EXTRAITS DE CODES SOURCES .........................................................................93

BIBLIOGRAPHIE ...........................................................................................................................95

FICHE DE RENSEIGNEMENTS ................................................................................................101

RESUME

ABSTRACT

vi
 NOTATIONS

1. Minuscules latines

fonction d‟activation

unité de biais de la couche

contraste

⃗( ) vecteur de sortie désirée

( ) sortie désirée

( ) erreur observée

fonction

( ) image de sortie

h fonction

i variable

image intégrale

j variable

k variable

dimension du filtre w

dimension du filtre w

couche

m variable

n variable

vecteur de sortie à la couche

p variable

r nombre de neurones de la couche précédente

vii
s amplitude du pas

valeurs cibles

( ) somme pondérée de l‟entrée du neurone j

matrice de poids

( ) poids de connexion

représentation des entrées

variable

vecteur d‟entrée convolué au niveau de la couche plus le biais

entrée de l‟observation

plus petite valeur observée pour la feature X

plus grandes valeur observée pour la feature X

⃗( ) vecteur d‟entrée

représentation des sorties

variable

sortie du réseau

⃗( ) vecteur de sortie observée

( ): sortie du neurone i

( ) sortie observée du neurone j

vecteur d‟entrée softmax

2. Majuscules latines

A variable

zone d‟une image

viii
 zone d‟une image

B variable

C variable

C++ langage de programmation

( ) classifieur fort

D variable

distance euclidienne

E variable

entrée des neurones

( ) somme des erreurs quadratiques

F variable

composante horizontale du gradient

composante verticale du gradient

variable

I variable

transformée de Fourier de l‟image

( ) image après filtrage

( ) représentation d‟un pixel

J fonction coût

K variable

L variable

degrés de luminosité de la zones

degrés de luminosité de la zones

ix
M nombre de ligne dans une image

masque de dérivation

masque de dérivation

N variable

O dimension de la sortie

P variable

épaisseur de la marge à zéro

épaisseur de la marge à zéro

surface apparente

T tâche

vecteur non normalisé

histogrammes normalisés en contrastes

‖ ‖ L2-Norme du vecteur V

dimension de l‟entrée

poids des neurones

X variable

Y variable

3. Minuscules grecques

( ) gradient local

gradient

constante de faible valeur

taux d‟apprentissage

θ variable

x
 variable

variable

fonction softmax

: fonction d‟activation

4. Majuscules grecques

( ) expression de la règle du delta

univers des possibles

5. Abréviations

API Application Programming Interface

CCD Charged Coupled Device

CMOS Complementary Metal Oxide Semiconductor

CNN Convolutional Neural Network

CPU Central Processing Unit

CUDA Compute Unified Device Architecture

cuDNN CUDA® Deep Neural Network library

DPI Dots Per Inch

GPU Graphical Processing Units

HOG Histograms of Oriented Gradients

IA Intelligence artificielle

IBM International Business Machines

IIM Institut de l‟Internet et du multimédia

ILSVRC ImageNet Large-Scale Visual Recognition challenge

IOU Intersection Over Union

ISO International Organization for Standardization

K-NN K Nearst Neighbors

xi
ML Machine Learning

MLP Multiple Layers Perceptron

MSCOCO Microsoft Common Objects in COntext

NMS Non Maximum Suppression

OpenCV Open Source Computer Vision

Pixel Picture élément

R-CNN Region-basedCNN

ReLU Rectified linear unit

REST REpresentational State Transfer

RNN Recurrent Neural Network

RoI Region of Intrest

RPN Region Proposal Network

R.V.B Rouge Verte Bleu

SVM Support Vector Machine

TPU TensorFlow Processing Unit

WSGI Web Server Gateway Interface

xii
 INTRODUCTION GENERALE

L‟intelligence artificielle n‟est pas une science nouvelle, les premières traces de l‟IA (Intelligence
artificielle) remontent en 1950. A cette époque, Alan Turing a publié un article intitulé «Computing
Machinery and Intelligence », dans lequel il propose de définir si une machine est consciente ou
non. Le machine learning ou ML, une branche de l‟IA, quant à lui apparait pour la première fois en
1959 : Arthur Samuel y présente alors un programme de jeu de dames capable de s‟améliorer à
chaque partie. Si le machine learning est considéré comme une branche de l‟IA, alors le deep
learning pourrait être vu comme une branche du machine learning. Les idées de base du deep
learning remontent à la fin des années 80, avec la naissance des premiers réseaux de neurones.
Cependant, si la théorie était déjà en place, les moyens, eux, ne sont apparus que récemment.

De nos jours, les avancées en IA sont colossales et couvrent de nombreux domaines comme le
traitement du langage naturel, la reconnaissance d‟écriture ou encore la vision par ordinateur.
Récemment, grâce aux réseaux de neurones convolutifs qui allient le deep learning et la vision
artificielle ; le secteur du « retail » ou vente au détail se trouve complètement bouleversé. Bien que
le commerce en ligne soit de mise aujourd‟hui, nombreux sont les consommateurs à encore se
rendre dans un point de vente physique. Les magasins physiques présentent néanmoins quelques
faiblesses comme : l‟impossibilité de gérer les stocks en temps réel qui fait perdre des profits aux
magasins, les attentes trop longues en caisse qui donne aux clients peu de satisfaction, la difficulté
d‟avoir plus d‟information sur le produit contrairement à une expérience en ligne. Tous ces
problèmes sont à l‟origine d‟une qualité de services moindres. Aujourd‟hui, le « phygital », poussé
par l‟utilisation du deep learning, notamment de la détéction d‟objet, vise à intégrer de façon
efficace les atouts du monde digital dans les lieux physiques. Le phygital est en train de s‟émerger :
à l‟image des magasins sans caisses, des systèmes de recommandation de produit, ou de
l‟évaluation de la disponibilité des stocks en magasin. C‟est dans ce cadre qu‟est née l‟idée de ce
mémoire, la conception d‟un SYSTEME DE DETECTION D'OBJET BASE SUR LE DEEP
LEARNING DANS UN MAGASIN INTELLIGENT pour une meilleure qualité de service afin de
permettre aux magasins d‟entrer dans l‟ère du phygital.

Cet ouvrage se divise en quatre chapitres : le premier traite du machine learning et conduit au deep
learning, le deuxième est dédié à ce qui concerne la vision par ordinateur, le troisième décrit les
réseaux de neurones convolutifs et le dernier est consacré à l‟application créée.

1
 CHAPITRE 1
DU MACHINE LEARNING AU DEEP LEARNING

1.1 Introduction
Le machine learning, que l‟on traduit en français par « apprentissage automatique », ou plus
généralement l‟intelligence artificielle dont le machine learning est un sous domaine, évoque de la
science-fiction pour la plupart des gens. Pourtant le machine learning n‟est pas un rêve futuriste
mais fait déjà partie de la vie quotidienne. A vrai dire, il s‟est déjà imposé depuis des décennies
comme dans les filtres anti-spam vers les années quatre-vingts dix ou encore dans les jeux vidéo
depuis le début des années 2000. Aujourd‟hui le machine learning est partout, il existe que ce soit à
travers la voiture autonome de Google, la reconnaissance de parole de Siri, la detection de visage de
Facebook ou encore le magasin autonome d‟Amazon. Le machine learning est en train de
révolutionner le monde.

Définition 1.01:

L‟intelligence artificielle est définie par Marvin Minsky, qui fut un pionnier de l‟IA, comme : « la
construction de programmes informatiques qui s'adonnent à des tâches qui sont pour l'instant,
accomplies de façon plus satisfaisante par des êtres humains car elles demandent des processus
mentaux de haut niveau tels que : l'apprentissage perceptuel, l'organisation de la mémoire et le
raisonnement critique». [1]

Définition 1.02:

Le machine learning est quant à lui défini en 1959 par Arthur Samuel comme suit:
« L‟apprentissage automatique est la discipline donnant aux ordinateurs la capacité d‟apprendre
sans qu‟ils soient explicitement programmés.» [2]

Dans ce chapitre les types de système d‟apprentissage automatique seront approchés. Ensuite, il
faudra parler de la différence entre la régression et la classification. S‟ensuivra des différents
algorithmes utilisés dans le cadre du machine learning ainsi qu‟une présentation des réseaux de
neurones artificiel et enfin, la dernière partie se concentrera sur le deep learning et clôturera ce
chapitre.

2
1.2 Types de système d’apprentissage automatique
Il existe plusieurs types de système d‟apprentissage et cela varie en fonction du type de problème
que l‟on se pose. Il est alors utile de les classer en différentes catégories. Les systèmes de machine
learning peuvent-être classés en fonction de l‟importance et de la nature de la supervision qu‟ils
requièrent durant la phase d‟entraînement. On distingue alors quatre grandes catégories:
l‟apprentissage supervisé, l‟apprentissage non supervisé, l‟apprentissage semi-supervisé et
l‟apprentissage avec renforcement.

1.2.1 Apprentissage supervisé

L‟apprentissage supervisé consiste en la conception d‟un modèle reliant des données
d‟apprentissage à un ensemble de valeurs de sortie. C‟est-à-dire que les données d‟entraînement
qu‟on fournit à l‟algorithme comportent les solutions désirées, appelées étiquettes (en anglais,
labels). Cette méthode permet donc à l‟algorithme d‟apprendre en comparant sa sortie réelle avec
les sorties enseignées, afin de trouver les erreurs et modifier le modèle en conséquent.
L‟apprentissage supervisé confère au modèle la possibilité de prédire des valeurs d‟étiquette sur des
données non étiquetées supplémentaires.

Soit D un ensemble de données, décrit par un ensemble de caractéristiques X, un algorithme

d‟apprentissage supervisé va trouver une fonction de mapping entre les variables prédictives en
entrée X et la variable à prédire Y. La fonction de mapping décrivant la relation entre X et Y
s‟appelle un modèle de prédiction. Les caractéristiques X peuvent être des valeurs numériques,
alphanumériques ou des images.

Un exemple d‟utilisation de l‟apprentissage supervisé est le filtre anti-spam, l‟apprentissage

s‟effectue à l‟aide de nombreux exemples d‟e-mails qu‟on a étiqueté spam ou normal. A partir de
cela, le filtre doit alors être capable de classer de nouveaux e-mails.

Un autre exemple consiste à prédire le prix d‟une voiture à partir des valeurs d‟un certain nombre
d‟attributs ou variables qu‟on appelle caractéristiques d‟une observation ou features en anglais. Ces
variables peuvent être le kilométrage, l‟âge, la marque, etc. Ils sont également appelés variables
explicatives ou prédictives. L‟entrainement se fait alors à partir de ces variables et des étiquettes. La
catégorie de la variable prédite Y fait décliner l‟apprentissage supervisé en deux sous catégories : la
classification et la régression, ces deux concepts seront abordés plus tard. [2] [3] [4]

3
 Figure 1.01 : Un jeu d‟entraînement étiqueté pour un apprentissage supervisé

1.2.2 Apprentissage non supervisé

L‟apprentissage non supervisé consiste en la conception d‟un modèle structurant l‟information,
c‟est-à-dire les données d‟apprentissage ne sont pas étiquetées. Cette méthode permet donc à
l‟algorithme de trouver tout seul des points communs parmi les données d‟entrée, le système
apprend alors sans professeur. Comme l‟étiquetage de données requiert beaucoup de temps, les
méthodes d‟apprentissage utilisant l‟apprentissage non supervisé sont particulièrement utiles.
L‟apprentissage non supervisé peut être utilisé pour la réduction de dimension ou l‟extraction de
variable. Cette tâche consiste à simplifier les données sans perdre trop d‟informations, il pourra
ensuite être fourni à un autre algorithme d‟apprentissage automatique (tel qu‟un algorithme
d‟apprentissage supervisé). Le kilométrage d‟une voiture, par exemple, peut être fortement corrélé à
son âge, de sorte que l‟algorithme de réduction de dimension les combinera en une seule variable
représentant la vétusté de la voiture.

A première vue, on pourrait penser que l‟apprentissage non supervisé a peu d‟utilité dans les
applications de la vraie vie, mais les applications de cette technique sont nombreuses. Les sites
comme Amazon, Netflix ou encore Youtube utilisent les algorithmes de partitionnement ou
Clustering en anglais pour faire des recommandations de produits ou de films. Il peut être
également utilisé pour explorer de larges ensembles de données et de découvrir d‟intéressantes
relations entre les variables : pour un supermarché par exemple, exécuter une règle d‟association sur
les journaux de vente permettrait peut-être de découvrir que les personnes achetant de la sauce
barbecue et des chips ont aussi tendance à acheter des grillades. Cela permettrait de réorganiser les
rayons afin de présenter ces articles à proximité les uns des autres. [2] [4] [5]

4
 Figure 1.02 : Un jeu d‟entraînement non étiqueté pour un apprentissage non supervisé

1.2.3 Apprentissage semi-supervisé

L‟apprentissage semi-supervisé vise à résoudre les problèmes avec relativement peu de données
étiquetées et une grande quantité de données non étiquetées. L‟apprentissage semi-supervisé réduit
également le temps d‟étiquetage de grande quantité de données par rapport à un apprentissage
supervisé. Il a été démontré que l'utilisation de données non-étiquetées, en combinaison avec des
données étiquetées, permet d'améliorer significativement la qualité de l'apprentissage. Ce type
d‟apprentissage a pour objectif de classer certaines des données non étiquetées à l'aide de
l'ensemble d'informations étiquetées.

Un exemple illustrant l‟utilisation d‟un apprentissage semi-supervisé est le service d‟hébergement

d‟image : Google Photos. Une fois avoir téléchargé des photos de famille sur ce service, le système
arrive à reconnaitre qu‟une personne A apparaît sur telle ou telle photos et qu‟une personne B sur
telle autres. Cela est dû à la partie non supervisé de l‟algorithme. Une fois que vous aviez identifié
ces personnes, juste une étiquette par personne, le système sera capable de nommer les personnes
figurant sur chaque photo, ce qui est utile pour des recherches ultérieures. [2]

Figure 1.03 : Apprentissage semi-supervisé

5
1.2.4 Apprentissage avec renforcement
L‟apprentissage par renforcement est très différent des types d‟apprentissage vus jusqu‟ici. Il
consiste à apprendre, à partir d‟expériences successives, ce qu‟il convient de faire de façon à
trouver la meilleure solution. Le système d‟apprentissage, que l‟on appelle ici « agent », interagit
avec l‟environnement, en sélectionnant et accomplissant des actions afin de trouver la solution
optimale et obtenir en retour des récompenses. L‟agent essaie plusieurs solutions, on parle d‟«
exploration », observe la réaction de l‟environnement et adapte son comportement, c‟est-à-dire les
variables pour trouver la meilleure stratégie. Pour ce type d‟apprentissage, les données
d‟entrainement proviennent directement de l‟environnement.

L‟apprentissage par renforcement peut être utilisé pour apprendre à un robot à marcher, ou à un
programme à jouer, comme AlphaGo de DeepMind qui a vaincu l‟un des meilleurs joueurs de go au
niveau mondial. En 2018, une startup issue des travaux de l‟université de Cambridge a formé une
intelligence artificielle à la conduite automobile. Au bout de seulement vingt minutes, l'IA est
parvenue à savoir comment maintenir la voiture sur sa voie de circulation. Durant cette expérience
un chauffeur été présent à bord de la voiture pour corriger les écarts de trajectoire causés par le
logiciel, en arrêtant la voiture. Le programme a rapidement progressé en suivant une logique
pénalité-récompense, en l'occurrence, respectivement, une intervention humaine et la distance
maximale parcourue sans correction par le conducteur. [2] [6] [7]

Figure 1.04 : Apprentissage par renforcement

1.3 Différence entre classification et régression

Il y a une grande différence entre les problèmes de classification et de régression. La classification
consiste à prédire une étiquette et la régression, à prédire une quantité. Avant de présenter ces deux
concepts, il sera utile de comprendre la notion d‟approximation de fonction.

6
1.3.1 Approximation de fonction
Le terme « modélisation prédictive » (en anglais : Predictive Modelling) désigne un ensemble de
méthodes qui permettent d‟analyser et d‟interpréter des données définies afin d‟effectuer une
prédiction sur de futurs données. La modélisation prédictive peut être décrite comme un problème
mathématique consistant à approximer une fonction de mappage f entre les variables prédictives en
entrée X et la variable à prédire Y. C'est ce qu'on appelle un problème d'approximation de fonction.
En règle générale, toutes les tâches d'approximation de fonctions peuvent être divisées en tâches de
classification et en tâches de régression. [8]

1.3.2 Classification
Les algorithmes de classification sont utilisés lorsque la variable à prédire Y est discrète. Exemple :
la classification d‟email à l‟aide de filtre anti spam présenté précédemment. Une classification peut
avoir des variables d'entrée à valeurs réelles ou discrètes. Il est courant que les modèles de
classification prédisent des valeurs continues comme les probabilités d‟appartenance à chaque
classe de sortie. Une probabilité prédite peut être convertie en une valeur de classe en sélectionnant
l'étiquette de la classe qui présente la probabilité la plus élevée. [8]

1.3.3 Régression
Les algorithmes de régression sont quant à eux utilisés lorsque la variable à prédire Y est continue.
Comme le cas de la prédiction du prix d‟une voiture. Un problème de régression nécessite la
prédiction d'une quantité. Il peut avoir des variables d'entrée à valeurs réelles ou discrètes.

Remarquons que certains algorithmes ont le mot «régression» dans leur nom, tels que régression
linéaire et régression logistique, ce qui peut prêter à confusion, car la régression linéaire est un
algorithme de régression alors que la régression logistique est un algorithme de classification.
Certains algorithmes peuvent être utilisés à la fois pour la classification et la régression avec de
petites modifications, telles que les arbres de décision et les réseaux de neurones artificiels. [8]

1.4 Algorithmes utilisés en machine learning

Le domaine du Machine Learning regorge d‟algorithmes qui répondent à différents besoins. Les
principaux algorithmes en machine learning seront présentés dans les sous paragraphes suivants.

1.4.1 Régression Linéaire

La régression linéaire est un algorithme qui va trouver une droite qui se rapproche le plus possible
d‟un ensemble de points. Les points représentent les données d‟entrainement. C‟est un algorithme

7
d‟apprentissage supervisé de types régression. Dans un problème de régression, les caractères ne
sont pas considérés de la même façon, il y a les caractères explicatifs et le caractère à expliquer.

1.4.1.1 Régression linéaire simple

Pour le cas de la régression linéaire simple, les caractères sont au nombre de deux : pour la
variable explicative et pour la variable à expliquer. Le but est alors de trouver la meilleure
fonction hypothèse, qu‟on nommera h et qui aura pour rôle d‟approximer les valeurs de sortie Y.
Pour la régression linéaire simple, h sera de la forme :

( ) (1.01)

Le problème revient à trouver le couple ( ) qui rapproche le plus ( ) de Y pour les couples
( ) de notre base de données. Pour chaque point , la fonction hypothèse prend une valeur ( )
qui est plus ou moins proche de . La proximité se mesure en général comme une erreur
quadratique moyenne. L‟erreur unitaire pour est alors définie par :

( ( ) ) (1.02)

L‟erreur unitaire pour étant définie, on peut ensuite sommer les erreurs pour l‟ensemble des
points :

(1.03)
∑( ( ) )

La fonction de coût est alors obtenue en effectuant une normalisation par le nombre m de points
dans la base d‟apprentissage et en remplaçant ( ) :

(1.04)
( ) ∑( )

Trouver le couple ( ) qui rapproche le plus h(x) de Y revient à minimiser la fonction coût
( ). Une façon de minimiser ( ) est d‟utiliser l‟algorithme de descente de gradient qui se
présente comme suit:

 Itération 0 : initialisation d‟un couple ( )

 Itération jusqu‟à convergence :

8
 ( ) pour et 0 (1.05)

L‟algorithme calcule le gradient de la fonction de coût au point θ. Pour trouver le minimum de cette
fonction, il faut se déplacer dans la direction opposée au gradient. Lorsque le gradient est nul, le
minimum est atteint. Ici α représente le taux d‟apprentissage ou learning rate en anglais.
Physiquement, c‟est la vitesse à laquelle on souhaite terminer les itérations. Comme la fonction
( ) est une fonction convexe, alors tout minimum local est aussi le minimum global, cela nous
permet d‟éviter d‟être induit en erreur.

1.4.1.2 Régression linéaire multiple

La régression linéaire multiple est une généralisation, à plusieurs variables explicatives, de la
régression linéaire simple.

Pour n variables d‟entrée, la fonction h prend une forme plus générale :

( ) (1.06)

Nos données d‟entrée se représentent sous forme d‟une matrice de dimension ( ):

(1.07)
( )

correspond à la valeur prise par la variable j de l‟observation i.

La fonction coût est quant à elle donnée par une généralisation de celle vue précédemment:

(1.08)
( ) ∑( ( ) )

Pour minimiser ( ) on va également utiliser la méthode de descente du gradient.

 Itération 0 : initialisation d‟un vecteur ( )

 Itération jusqu‟à convergence :

( ) pour (1.09)

J étant toujours convexe, nous n‟aurons pas de problème de minima. [9] [10] [2]

9
 Figure 1.05 : Descente du gradient

1.4.2 Naive Bayes

L‟apprentissage Bayésien permet de faire des prédictions en se basant sur des probabilités.
L‟algorithme Naive Bayes se base sur le théorème de Bayes et suppose l‟indépendance totale des
variables. C‟est un algorithme d‟apprentissage supervisé de types classification. Il est
principalement utilisé pour les problèmes de classement de texte.

1.4.2.1 Théorème de Bayes et notion d‟indépendance

La formule de Bayes est issue des travaux du révérend Tomas Bayes. Elle se base sur la notion de
probabilité conditionnelle qui peut se traduire par la probabilité qu‟un événement se produise
sachant qu‟un autre événement s‟est déjà produit. Cette formule est définie par la relation suivante :

( | ) ( ) (1.10)
( | )
( )

Ici ( | ) désigne la probabilité a posteriori de A sachant B,

P(B│A) désigne la probabilité a posteriori de B sachant A,

( ) est la probabilité a priori de A ou probabilité marginale de A,

( ) est la probabilité a priori de B ou probabilité marginale de B.

Pour la notion d‟indépendance, on dit que deux évènements A et B sont indépendants si la

probabilité de A ne dépend pas de celle de B. Autrement dit :

( | ) ( ) (1.11)

Dans le cas où deux événements d'un espace probabilisé sont indépendants, on voit bien que la
connaissance de l'un n'affectera pas la prévision de l'autre. Cette notion peut également être

10
quantifiée de la façon suivante : deux évènements A et B sont dits indépendants par rapport à la
mesure de probabilité P si et seulement si :

( ) ( ) ( ) (1.12)

Cette notion d‟indépendance est une hypothèse forte et qui est violée dans la majorité des cas réels.

1.4.2.2 Modèle Naives Bayes

Pour mieux comprendre le principe du modèle Naive Bayes, illustrons son fonctionnement par un
exemple. Soit un algorithme de classement de fruits en trois types : banane, orange, autre et selon
trois caractéristiques :

 Si le fruit est long ou non

 S‟il est sucré ou non
 Si sa couleur est jaune ou non

Types Long Non long Sucré Non sucré Jaune Pas Jaune Total

Banane 400 100 350 150 450 50 500

Orange 0 300 150 150 300 0 300

Autre 100 100 150 50 50 150 200

Total 500 500 650 350 800 200 1000

Tableau 1.01 : Jeu de données sur 1000 fruits

Le but est de prédire le type d‟un fruit (orange, banane ou autre) qu‟on n‟a pas encore vu. Ceci en se
basant sur ses caractéristiques. Soit un fruit ayant les caractéristiques suivantes : long, jaune, sucré
qu‟on va noter respectivement L, J, S. Pour savoir s‟il s‟agit d‟une banane, d‟une orange ou d‟un
autre fruit, il faut qu‟on calcule les trois probabilités suivantes: ( | ),
( | ), ( | )

En se basant sur la formule de Bayes on a :

( | ) ( | ) (| ) ( ) (1.13)
( | )
( ) ( ) ()

Ces probabilités sont calculées facilement en utilisant notre jeu de données.

11
 ( ) (1.14)
( )
( )

D‟où

( )
( )
( )

Ici ( ) représente le nombre de total de fruits.

En utilisant le même procédé, on a : ( ) , ( ) , ( ) .

On a également :

( ) (1.15)
( | )
( )

( )
( | )
( )

Avec la même logique on a : ( | ) et ( | )

Ainsi :

( | )

Finalement, avec le même calcul on a : ( | ) , ( | )

La probabilité que le fruit en question soit une banane est largement plus grande que les autres. Le
fruit inconnu est donc classifié comme Banane.

En se basant sur cet exemple, on peut constater que le Naive Bayes est rapide en termes de calcul et
que la classification est possible même avec un petit jeu de données. [10] [4]

1.4.3 K plus proches voisins (K-NN)

L‟algorithme des k plus proches voisins ou K-NN, de son nom anglais K Nearst Neighbors, consiste
à supposer qu'une observation est similaire à celle de ses voisins. Son fonctionnement peut être
assimilé à l‟analogie suivante : « dis-moi qui sont tes voisins, je te dirais qui tu es ». C‟est un
algorithme d‟apprentissage supervisé de types classification ou régression. L‟algorithme ne
nécessite qu‟une notion de distance et l‟hypothèse que les points proches les uns des autres sont
similaires.

12
1.4.3.1 Méthode de prédiction
La spécificité de l‟algorithme K-NN est le fait qu‟il ne nécessite pas d‟apprentissage mais
simplement le stockage des données. En effet, pour une observation qui ne fait pas parti du jeu de
données qu‟on souhaite prédire, l‟algorithme va chercher les K instances du jeu de données les plus
proches de notre observation. Ensuite, en utilisant les variables de sortie de ses voisins, l‟algorithme
calcul la valeur de la variable de sortie de l‟observation qu‟on souhaite prédire. Si K-NN est utilisé
pour la régression, alors on calcule la moyenne ou la médiane des variables de sortie des K plus
proches observations. Par ailleurs, si K-NN est utilisé pour une classification, alors c‟est le mode
des variables de sortie des K plus proches observations qui servira pour la prédiction.

Notons que la médiane désigne une valeur réelle m telle qu‟il y ait autant d‟observations
inférieures ou égales à m que supérieure ou égales à m. Le mode, quant à lui, est la valeur la plus
représentée d'une variable quelconque dans une population donnée.

1.4.3.2 Notion de distance

L‟algorithme K-NN a également besoin d‟une fonction de calcul de distance entre deux
observations. Plus deux points sont proches l‟un de l‟autre, plus ils sont similaires et vice versa. Il
existe plusieurs fonctions de calcule de distance qui sont choisie en fonction des types de données
qu‟on manipule. Pour les données quantitatives (exemple : poids, salaires, taille, montant de panier
électronique), on a tendance à utiliser la distance euclidienne. Alors que pour des données qui ne
sont pas de mêmes types, quantitatives et qualitatives (exemple : âge, sexe, longueur), la distance de
Manhattan est plus appropriée.

Dans un hyperespace, espace à n dimensions, la distance euclidienne entre les points

( ) et ( ) est donnée par :

(1.16)
( ) √∑( )

La distance de Manhattan entre les points ( ) et ( ) est quant à elle

donnée par :

(1.17)
( ) ∑| |

13
La figure 1.06 montre une classification avec l'algorithme des k plus proches voisins, ici en prend
deux cas : k = 5 ou k = 18. Le nouvel individu sera affecté à la classe « cercle bleu » dans ces deux
cas. [4] [11] [12] [13]

Figure 1.06 : Sélection de k plus proches voisins d'une observation

1.4.4 K moyenne (K-means)

L‟algorithme k-moyennes est un algorithme non supervisé. Il permet de regrouper en K clusters ou
familles distincts les observations du data set. Il tente alors de trouver des regroupements discrets au
sein des données, au sein desquels les membres d'un groupe sont aussi semblables que possible les
uns des autres et aussi différents que possible des membres des autres groupes. Une même
observation ne pourra pas appartenir à deux clusters différents. L‟algorithme K-moyenne utilise la
notion de distance pour comparer le degré de similarité entre les différentes observations. Les
distances les plus utilisées sont la distance euclidienne et la distance de Manhattan. Ces distances
ont déjà été abordées dans l‟algorithme des K-nn. L‟approche de K-moyenne consiste à affecter
aléatoirement des centres de clusters (appelés centroides) et ensuite assigner chaque point de nos
données au centroide qui lui est le plus proche. Cela s‟effectue jusqu‟à assigner toutes les données à
un cluster. [4] [14] [15]

L‟algorithme k-moyenne se présente comme suit :

Entrée :

 k le nombre de cluster à former,

 x un ensemble de données.

Début :

14
  Etape 1 : choisir k individus au hasard (comme centre des classes initiales)
 Etape 2 : affecter chaque individu au centre le plus proche
 Etape 3 : recalculer le centre de chaque cluster
 Etape 4 : recommencer les étapes 2 et 3 jusqu‟à stabilité des centres

Fin

Figure 1.07 : Fonctionnement de l‟algorithme K-means

1.5 Réseaux de neurones artificiels

Les réseaux de neurones sont au cœur des progrès récents de l‟apprentissage automatique. On ne
peut donc parler de machine learning sans parlé des réseaux de neurones, un ensemble
d‟algorithmes dont le fonctionnement est inspiré des neurones biologiques.

1.5.1 Neurone biologique

Le cerveau est un organe fascinant, depuis longtemps, on a compris que notre capacité à réfléchir se
faisait grâce au cerveau. Les cellules les plus importantes du cortex cérébral sont les neurones, dont
le nombre atteint la centaine de milliards chez l'être humain. Elles sont constituées de trois parties
essentielles : le corps cellulaire, les dendrites et l‟axone.

Le corps cellulaire contient le noyau du neurone, son rôle est d‟effectuer les transformations
biochimiques nécessaires à la synthèse des enzymes qui assurent la vie du neurone. Chaque neurone
possède des dendrites, qui sont les récepteurs principaux du neurone et servent à capter les signaux
qui lui parviennent. L‟axone quant à lui, sert de moyen de transport pour les signaux émis par le
neurone. Les neurones sont connectés les uns aux autres suivant des répartitions spatiales
complexes. Le lien physique entre deux neurones se fait grâce aux synapses. [16] [17]

15
 Figure 1.08 : Neurone biologique

1.5.2 Neurone formel

Le neurone formel ou artificiel vise à reprendre le fonctionnement du neurone biologique. Le
neurone reçoit des entrées et fournit une sortie, grâce à différentes caractéristiques. Dans un neurone
formel, les poids permettent de modifier l‟importance de certaines entrées par rapport à d‟autres. La
fonction d‟agrégation permet quant à lui d‟obtenir une unique valeur à partir des entrées et des
poids correspondants. Le seuil permet au neurone de savoir quand il doit agir ou non. Enfin, une
fonction d'activation, qui associe à chaque valeur agrégée une unique valeur de sortie dépendant du
seuil.

Figure 1.09 : Neurone formel

1.5.2.1 Fonction d‟agrégation

Il existe plusieurs types de fonctions d‟agrégation, mais les plus courantes sont : la somme pondérée
et le calcul de distance. Le but étant d'associer une seule valeur à l'ensemble des entrées et des
poids.

16
La somme pondérée consiste à calculer la somme de toutes les entrées multipliées par leur poids
c‟est-à-dire :

(1.18)
∑

Le calcul des distances consiste plutôt à comparer les entrées aux poids (qui sont les entrées
attendues par le neurone), et calculer la distance entre les deux. Dans ce cas la distance est données
par :

(1.19)
∑( )

1.5.2.2 Fonctions d'activation

Il existe plusieurs fonctions d‟activation, après avoir obtenu la valeur donnée par la fonction
d‟agrégation, le neurone compare cette dernière avec le seuil et décide de la sortie en utilisant la
fonction d‟activation.

Ci-après les fonctions d‟activation les plus utilisées :

La fonction de Heaviside : c‟est une fonction qui permet l'obtention de sorties binaires, 1 si la
valeur agrégée calculée est plus grande que le seuil, 0 sinon.

( ) 2 (1.20)

Elle est principalement utilisée pour les problèmes de classifications en indiquant qu'un objet
appartient ou non à une classe donnée. L‟inconvénient, c‟est qu‟elle n‟indique pas à quel point une
valeur est forte.

La fonction sigmoïde est définie par la relation mathématique suivante:

(1.21)
( )

Elle est dérivable et donc contrairement à la fonction de Heaviside, permet de savoir vers quelle
direction aller pour améliorer les résultats.

17
La fonction softmax : elle est utilisée pour de la classification multi-classe. Elle prend en entrée un
vecteur ( ) de K nombres réels et en sort un vecteur ( ) de K nombres réels
strictement positifs de somme 1. Elle est définie par la relation mathématique suivante : pour
tout * +. [17] [18]

(1.22)
( )
∑

Figure 1.10 : fonctions d‟activation

1.5.2.3 Poids et seuils

Les neurones se différencient par leurs seuils ainsi que les poids les liant à leurs entrées. Les poids
sont accordés à chacune des entrées, permettent de modifier l'importance de certaines par rapport
aux autres. Les seuils ou biais quant à eux, permettent d'indiquer quand le neurone doit agir. Il est
très difficile de déterminer la valeur des seuils et des poids pour des fonctions complexes.
L‟apprentissage consiste alors à trouver leurs valeurs optimales afin d‟obtenir la sortie voulue. [17]

1.5.3 Perceptron
Le perceptron a été inventé par Frank Rosenblatt en 1955, il est constitué d‟une première couche
d‟unité permettant de lire les données. On peut rajouter une unité de biais qui est toujours activée.
Ces unités sont reliées à une seule unité de sortie. Mais pour une classification multi-classe, il peut
avoir plusieurs sorties.

18
 Figure 1.11 : Perceptron à une unité de sortie

Ici représente le biais, ( ) ( ) représentent respectivement les entrées

et les poids correspondants à chaque entrée, (∑ ) la fonction d‟activation.

Pour les problèmes de classification multi-classe, le réseau va avoir autant de neurones de sortie que
de classes. Ainsi, chacune de ces unités sera connectée à toutes les unités d'entrée. Dans ce cas, c'est
la sortie ayant la plus forte valeur qui est prise en compte.

Figure 1.12 : Perceptron à plusieurs unités de sortie

Dans cet exemple K représente le nombre de classe.

Le perceptron est simple à mettre en œuvre, son plus grand défaut est qu‟il ne permet de résoudre
que les problèmes linéairement séparables. La fonction d‟activation utilisée (sigmoïde ou
Heaviside) présente un seuil, séparant deux zones de l'espace. [17] [18]

1.5.3 Réseau de neurones à propagation avant (feed-forward)

Les réseaux de neurones à propagation avant permettent de dépasser les limites du perceptron. Ils
aident à faire face à des problèmes autres que ceux linéairement séparables. Ces réseaux sont munis

19
d‟une ou plusieurs couches cachées de neurones, entre la couche d'entrée et celle de sortie. Dans
cette architecture, chaque neurone d'une couche est connecté à tous les neurones de la couche au-
dessus de lui. La structure feed-forward ou non bouclée signifie que les neurones ne sont connectés
que dans un sens : les signaux provenant des entrées traversent les unités cachées pour
éventuellement atteindre les unités de sortie.

L‟exemple le plus connu de réseau de neurones feed-forward est le réseau MPL ou Multi-layer
Perceptron. [17] [18]

Figure 1.13 : Perceptron multicouche à deux couches intermédiaires

1.5.4 Apprentissage des réseaux de neurones

L‟apprentissage est très important dans l‟utilisation d‟un réseau de neurone. Il consiste à calculer les
valeurs des poids et des seuils du réseau.

1.5.4.1 Apprentissage du perceptron

L‟apprentissage d‟un perceptron consiste à minimiser l'erreur de prédiction sur le jeu de données.
Cet entrainement est un processus itératif. Afin de réduire l‟erreur de prédiction faite par le
perceptron dans son état actuel, il faut ajuster les poids de connections après chaque observation.

L‟algorithme du gradient permet l‟apprentissage des réseaux monocouches de type perceptron.

Soit les n Observations qui sont observées séquentiellement, l'une après l'autre.
Comme dans la régression linéaire, on commence par choisir aléatoirement des valeurs initiales
( ) ( ) ( ) () ()
pour les poids de connections. Après chaque observation ( ) nous allons
appliquer à chacun des poids la règle de mise à jour suivante :

20
 ( ( ) ) (1.23)

Ici représente l‟entrée de l‟observation, sa sortie attendue et le taux d‟apprentissage ou

vitesse d'apprentissage (ou learning rate en anglais).

L‟itération peut se faire sur l‟intégralité du jeu d‟entrainement et s‟arrête quand l'algorithme
converge ou quand le nombre d‟itération fixé est atteint.

1.5.4.2 Apprentissage d‟un Perceptron multicouche

L‟apprentissage d‟un MLP (Multiple Layers Perceptron) se fait grâce à l‟utilisation d‟un algorithme
basé sur la descente de gradient qui est la méthode dite de rétropropagation ou Backpropagation en
anglais. On va chercher à minimiser la fonction d‟erreur du réseau de neurones.

L‟algorithme se présente comme suit :

Etape 1 : Initialisation de tous les poids à des valeurs aléatoires

Etape 2 : Normalisation des données d‟entrainement

Etape 3 : Permuter aléatoirement les données d‟entrainement

Etape 4 : Pour chaque donnée d‟entrainement n :

 Calculer les sorties observées en propageant les entrées vers l‟avant ;

 Ajuster les poids en rétropropageant l‟erreur observée :

( ) ( ) ( ) ( ) ( ) ( ) (1.25)

Où ( ) est le gradient local défini par :

( ) ( ) ( )[ ( )] (1.26)
( ) {
( )[ ( )] [∑ ( ) ( )]

représente le taux d‟apprentissage, ( ) la sortie du neurone i sur la couche précédente ou

l‟entrée i quand celle-ci n‟existe pas.

Etape 5 : répéter les étapes 3 et 4 jusqu‟à un nombre maximum d‟itérations ou jusqu‟à ce que la
racine de l‟erreur quadratique moyenne soit inférieure à un certain seuil.

21
Remarques:

La plupart du temps, en machine Learning, les Data Set proviennent avec des ordres de grandeurs
différents. La normalisation des données restreint les valeurs numériques à une plage spécifiée. La
normalisation peut être effectuée par la technique du Min-Max Scaling. La transformation se fait
grâce à la formule suivante :

(1.27)

Avec

et : la plus petite et la plus grandes valeur observée pour la feature X,

: la valeur de la feature qu‟on cherche à normaliser.

Permuter aléatoirement les données permet d‟augmenter vitesse de convergence, en effet si on a

beaucoup d‟exemples consécutifs de la même classe, la convergence sera très lente.

Les équations 1.25 et 1.26 présentes dans l‟étape 4 seront détaillées dans l‟annexe A1. [4] [18] [19]

1.6 L’apprentissage profond (Deep learning)

Le terme deep learning, qui se traduit en français par apprentissage profond, est très en vogue ces
derniers temps. Pourtant, les principes de cette méthode datent de la fin des années quatre-vingts.
L‟intérêt soudain pour le deep learning ces dernières années a été favorisé par plusieurs critères.
Tout d‟abord, les GPU (Graphical Processing Units) capables de plus de mille milliards
d‟opérations par seconde à moindre couts. Deuxièmement, des expériences menées simultanément à
Microsoft, Google et IBM (International Business Machines), ont montré que les réseaux profonds
pouvaient diminuer de moitié les taux d‟erreur des systèmes de reconnaissance vocale.
Troisièmement, plusieurs records en reconnaissance d‟image ont été battus par des réseaux
convolutifs dont un durant la compétition de reconnaissance d‟objets “ImageNet”. [20]

Définition 1.03 :

Le Deep Learning est basé sur l‟idée des réseaux de neurones artificiels et il est taillé pour gérer de
larges quantités de données en ajoutant des couches au réseau. Pour Yann LeCun, un des pionniers
du deep learning et lauréat du prix Turing 2019, « la technologie du deep learning apprend à

22
représenter le monde. C'est-à-dire comment la machine va représenter la parole ou l'image par
exemple ». [21]

1.6.1 Intérêts du deep learning

Les algorithmes de machine learning classiques fonctionnent très bien dans certains cas. Cependant,
ils semblent être inefficaces pour les problèmes majeurs du deep learning telles que la
reconnaissance vocale et la reconnaissance d‟objets.

La principale différence entre les algorithmes de machine learning traditionnel et le deep learning
est l‟étape de l‟extraction de caractéristiques. Pour le machine learning traditionnel les
caractéristiques à identifier dépendent de l‟expertise humaine. Cette pratique est très difficile et
requiert un spécialiste en la matière, parfois les caractéristiques distinctives ne sont même pas
identifiables par l‟homme. Le deep learning permet de pallier à ce problème en utilisant plusieurs
couches de réseau de neurones. 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.

Un autre avantage du deep learning c‟est qu‟il s‟adapte bien, plus la quantité de données fournie est
grande plus les performances sont meilleurs. Les algorithmes de ML classiques quant à eux
possèdent une borne supérieure à la quantité de données qu‟ils peuvent recevoir appelée "plateau de
performance". [20] [22]

1.6.2 Architectures des modèles de deep learning

Il existe plusieurs types de réseaux de neurones profonds. Parmi les modèles les plus utilisés, on
peut citer : les réseaux de neurones à convolution et les réseaux de neurone récurent.

1.6.2.1 Réseaux de neurones à convolution

Une architecture profonde particulièrement répandue est le réseau à convolution. Désignés par
l‟acronyme CNN, de l‟anglais Convolutional Neural Network. Les premières versions ont été
développées par Yann LeCun aux Bell Laboratories vers 1989. Les réseaux convolutifs sont une
forme particulière de réseau neuronal multicouche dont l‟architecture des connexions est inspirée du
cortex visuel des animaux. Par exemple, chaque élément n‟est connecté qu‟à un petit nombre
d‟éléments voisins dans la couche précédente. Les CNN sont tout particulièrement utiles pour les
applications basées sur la reconnaissance d‟objets et la vision par ordinateur.

23
Les couches présentes dans un CNN sont de l‟ordre de plusieurs dizaines, voire plusieurs centaines
de couches. Toutes ces couches effectuent des opérations qui modifient les données dans l‟objectif
d‟apprendre les caractéristiques spécifiques à ces données. On distingue trois principaux types de
couches :

 la couche convolution qui fait passer les images d‟entrée par un ensemble de filtres
convolutifs, chacun de ces filtres activant certaines caractéristiques des images ;
 la couche ReLU (Rectified linear unit) permet d‟accélérer et d‟optimiser l‟apprentissage en
remplaçant toutes les valeurs négatives reçues en entrées par des zéros. Elle joue le rôle de
fonction d'activation ;
 la couche de pooling qui consiste à réduire la taille des images, tout en préservant leurs
caractéristiques importantes.

Après l‟apprentissage des caractéristiques, la dernière couche du CNN est un réseau complètement
connectée (perceptron ou bien un MLP).

Les différentes couches d‟un CNN seront expliquées plus en détails dans un autre chapitre.

1.6.2.2 Réseaux de neurones récurrents

Une autre classe d‟architecture autre que les CNN est également revenue au goût du jour, les
réseaux de neurones récurrents ou recurrent neural network (RNN) en anglais. Ils ont également été
créés dans les années 1980. Contrairement aux réseaux de neurones à propagation avant, dans un
RNN, il existe non seulement des liens d'une couche vers les suivantes, mais aussi vers les couches
précédentes. Ces architectures sont particulièrement adaptées au traitement de signaux séquentiels,
tels que le texte. Une autre façon de penser les RNN est qu‟ils ont une « mémoire » qui capture
l‟information sur ce qui a été calculé jusqu‟ici. En théorie, les RNN peuvent utiliser des
informations dans des séquences arbitrairement longues, mais dans la pratique, on les limite à
regarder seulement quelques étapes en arrière. [22] [23] [24]

1.6.3 Applications du deep learning

Les applications du deep learning sont très nombreuses et ne sont plus considérées comme de la
science-fiction. Les géants du Net comme Google, Facebook et Amazon ne cessent d‟investir
fortement dans ce domaine.

En 2014, Google a acheté la société anglaise DeepMind, dont l‟objectif est actuellement de «
comprendre ce qu‟est l‟intelligence ». DeepMind est célèbre pour son programme AlphaGo, qui a

24
battu le champion du monde de go. Un des grands projets de Google, la Google Car renommé en
2016 par le projet Waymo, fonctionne à base de reconnaissance et de détection d‟objet utilisant du
deep learning pour la reconnaissance des panneaux pour savoir à quelle vitesse rouler, quelles voies
ne pas prendre, quand s‟arrêter, reconnaissance des lignes blanches etc. Aujourd‟hui, ces voitures
sont déjà utilisées en tant que robot taxi, c‟est ainsi que WALMART (le leader mondial des
supermarchés) et AVIS l‟utilisent pour transporter des clients jusqu‟à leur magasins.

Facebook, quant à lui, est un très grand acteur de l‟intelligence artificielle, plus précisément le deep
learning. Il choisit les messages qu‟il affiche en utilisant un moteur de recommandation.
Récemment, Facebook a mis en place un moteur d‟intelligence artificielle pour détecter les
tendances suicidaires. Facebook utilise également le deep learning pour l‟analyse de scène dans les
images pour masquer les images à caractère violent ou inapproprié.

Amazon utilise l‟intelligence artificielle dans son moteur de recommandation, nommé Echo, et dans
ses assistants basés sur son système de reconnaissance vocale Alexa. Mais une des grandes
révolutions apportée par Amazon, est le fameux Amazon Go. Amazon Go est un magasin sans
caisse, munie de centaine de caméras et des capteurs sur des étagères. Le magasin permet de se
saisir les produits et de les ajouter au panier virtuel d‟une l‟application sur le smartphone du client
qui, en retraversant les portiques, sera facturé et débité.

Le deep learning est aujourd‟hui présent dans tous les domaines, et continuera sans doute à avoir
une place importante dans les décennies à venir. [25] [26] [27]

1.7 Conclusion
Le machine learning ne date pas d‟aujourd‟hui, les différents algorithmes utilisé dans le ML ont vu
le jour durant le XXe siècle. Durant des années, les réseaux de neurones ont été mis aux oubliettes.
L‟émergence récent du deep learning, qui est une branche du machine learning, est due à
l‟évolution des GPU ainsi qu‟à la disponibilité des données en grande quantité. On peut dire que
cette technologie a été en avance sur son temps. Les applications du deep learning sont nombreuses
et touche tous les domaines, que ce soit pour le traitement de la voix ou la vision par ordinateur. Le
chapitre suivant se focalisera sur la vision par ordinateur car elle est essentielle à ce projet.

25
 CHAPITRE 2
FONDEMENTS DE LA VISION PAR ORDINATEUR

2.1 Introduction
La vision a suscité l‟intérêt de nombreux philosophes et scientifiques depuis longtemps. Avec
l‟avènement des machines modernes, un certains nombres de scientifiques se sont attaqués au
problème de la vision d‟un point de vue quantitatif, c‟est-à-dire créer un modèle qui vu de
l‟extérieur, possède des propriétés semblables à la vision humaine.

La vision par ordinateur a vu le jour aux Etats Unis au début des années soixante. Elle s‟est vite
imposée comme étant très utile dans divers domaines : militaire, aérospatiale, médicale et
industrielle. Aujourd‟hui avec l‟énorme quantité d‟image disponible sur internet et l‟arrivé du deep
learning, ses performances se sont considérablement améliorées. Cela a permis l‟utilisation de la
vision par ordinateur par tous dans nos vies quotidiennes.

La vision par ordinateur traite de l‟extraction d‟informations à partir d‟images numériques ou de

vidéos, elle diffère du simple traitement d‟image. Les applications de la vision par ordinateur
incluent la classification d‟ images, la reconstruction de scènes 3D à partir d'images 2D, la réalité
augmentée, la détection d‟objet etc. [28]

Définition 2.01:

La vision par ordinateur est une discipline informatique qui consiste à mettre en œuvre des outils et
techniques pour permettre à un ordinateur d‟interpréter un élément visuel c‟est-à-dire, de créer des
descriptions intelligentes et utiles de séquences et de scènes visuelles, ainsi que des objets au moyen
d'opérations menées sur des images ou des vidéos. [29]

Dans ce chapitre, les points suivants seront évoqués : premièrement, quelques notions de base
concernant les images, deuxièmement, les étapes d‟un processus de vision par ordinateur,
troisièmement, la notion de filtrage et finalement, la détection d‟objet dans le cadre du machine
learning.

2.2 Notions de base sur les images

L‟image du latin imago, a été défini par Platon comme suit : « J‟appelle image d‟abord les ombres
ensuite les reflets qu‟on voit dans les eaux ou à la surface des corps opaques, polis et brillants et

26
toutes les représentations de ce genre ». Dans ce paragraphe, on parlera d‟image en étant plus un
ensemble structuré d‟information défini par plusieurs caractéristiques.

Définition 2.02:

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, etc.). L‟image est constituée de plusieurs points
qui sont représentatifs d‟une grandeur physique comme la luminance et la couleur. [30]

Définition 2.03:

Le terme image numérique désigne généralement toute image qui a été acquise ou créée, traitée et
sauvegardée sous une forme codée, représentable par des valeurs numériques. La surface d‟une
image numérique est divisée en éléments de tailles fixes appelés pixels. Chaque pixel possède
comme caractéristique un niveau de gris ou de couleurs prélevé à l‟emplacement correspondant
dans l‟image réelle ou calculé à partir d‟une description interne de la scène à représenter. [31] [32]

2.2.1 Numérisation
La numérisation est le processus qui permet de passer de l‟état d‟image physique (image optique
par exemple) qui est caractérisée par l‟aspect continu du signal qu‟elle représente c‟est-à-dire une
image dans un état analogique (une infinité de valeur dans l‟intensité lumineuse), à l‟état d‟image
numérique qui est caractérisée par l‟aspect discret (l‟intensité lumineuse ne peut prendre que des
valeurs quantifiées en un nombre fini). L‟image peut être représentée par une matrice
bidimensionnelle de valeurs numériques ( ), où sont les coordonnées cartésiennes d‟un
point de l‟image et ( ) donne le niveau de gris en ce point. En général, la représentation pour
l‟affichage et l‟adressage des données se fait sous formes de tableau, ici nous le nommons I, de n
lignes et p colonnes. Chaque élément ( ) de ce tableau est représentatif d‟un pixel de l‟image.
La valeur de ce pixel sera associée à un niveau de gris codée sur bits ( niveaux de gris ; 0 =
noir ; blanc). La valeur en chaque point exprime la mesure d‟intensité lumineuse perçue
par le capteur. [31] [32]

27
 Figure 2.01 : Image numérique

2.2.2 Pixel
Le pixel est l‟abréviation du mot « Picture élément », c‟est le plus petit élément permettant de
définir la base d‟une image numérique. Il matérialise un point donné ( ) 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.

Pour une image monochrome, chaque pixel est codé sur un octet. Dans une image couleur (R.V.B.),
un pixel peut être représenté sur trois octets c‟est à dire un octet pour chacune des couleurs
primaires: rouge (R), vert (V) et bleu (B). [30] [32]

2.2.3 Dimension
La dimension représente la taille de l‟image en pixel, c‟est-à-dire le nombre total de pixel dans
l‟image. La dimension D de l‟image est donc donnée par le nombre de colonnes N de l'image que
multiplie son nombre de lignes M. [32]

(2.01)

2.2.4 Résolution
La résolution, c'est le nombre de points contenu dans une longueur donnée (en pouce). Elle est
exprimée en points par pouce (en anglais: DPI pour Dots Per Inch). Un pouce mesure 2.54 cm, c'est
une unité de mesure britannique. La résolution représente la clarté ou la finesse de détails atteinte
par un moniteur ou une imprimante dans la production d‟images. Le mot résolution désigne le
nombre total de pixel affichables horizontalement ou verticalement sur un moniteur; plus ce nombre
est grand, meilleure est la résolution. Pour une même image, plus la valeur de la résolution est
élevée moins l‟image imprimée sera grande et plus les détails seront fins. [32] [33]

28
2.2.5 Niveau de gris
Le niveau de gris représente 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]. Chaque pixel est donc représenté par un octet. Les images qui sont communément appelées
images en "noir et blanc" sont appelées images en niveaux de gris dans le domaine de l'image
numérique. [32]

Figure 2.02 : Représentation du niveau de gris de 0 à 255

2.2.6 Images couleurs

La représentation des images couleurs se fait en utilisant trois valeurs qui sont les composantes
rouge, verte, bleu. De la même façon que pour les niveaux de gris, les trois valeurs sont quantifiées.
Une couleur est donc représentée par 3 entiers. Les systèmes émettant de la lumière sont basés sur
le principe de la synthèse additive, c‟est-à-dire les couleurs se forment par le mélange des trois
couleurs primaires. [32]

2.2.7 Contraste
Le contraste d‟une image correspond à l‟écart de densité entre ses teintes les plus claires et ses
teintes les plus sombres. C‟est l‟opposition marquée entre deux régions d‟une image, plus
précisément entre les régions sombres et les régions claires. Si une image possède à la fois des
éléments très clairs et des zones très sombres, c‟est qu‟elle est contrastée.

Soit et les degrés de luminosité respectivement de deux zones voisines et d‟une image,
on définit par contraste le rapport :

(2.02)

[32] [34]

29
 Figure 2.03 : Représentation des contrastes d‟une image

2.2.8 Luminance
La luminance est le degré de luminosité des points d‟une image. La luminance est également
l'intensité lumineuse divisée par la surface apparente, exprimée en candela par mètre carré ou nit.
Pour un observateur lointain, on parle plutôt de brillance qui correspond à l‟éclat d‟un objet.

(2.03)

Une image a une bonne luminance si : elle est lumineuse, possède un bon contraste, et n‟est pas
parasitée. [30]

2.2.9 Parasite ou bruit

Le bruit est un phénomène de changement brusque d‟intensité d‟un pixel par rapport à ses voisins.
Ces bruits proviennent principalement de l‟énergie qui circule dans les circuits électroniques. Pour
une valeur basse de l'échelle de la sensibilité ISO (International Organization for Standardization),
le courant électrique est faible et ne gêne en rien la captation de l‟image. Mais dès que la lumière se
fait rare, l‟intensité du signal reçu par le capteur est faible, il est donc difficile pour ce dernier de
percevoir l'image. L‟appareil photo doit amplifier le signal reçu par le capteur en augmentant la
sensibilité ISO. Cette augmentation se traduit par l‟augmentation de l'intensité électrique envoyée
au capteur. C‟est cette intensité qui finit par causer des interférences avec l‟information électrique.
[32][35]

2.2.10 Contour
Les contours sont la représentation des frontières entre les objets de l‟image, c‟est la limite entre
deux pixels dont les niveaux de gris sont largement différents. La structure des contours peuvent

30
être décrite par les textures. L‟extraction de contour consiste donc à reconnaitre dans l‟image les
points qui séparent deux textures différentes. [32]

2.2.11 Histogramme
L‟histogramme des niveaux de gris ou de couleur d‟une image est une fonction représentant la
fréquence d‟apparition de chaque niveau de gris ou de couleur dans l‟image. L‟histogramme est un
moyen efficace pour connaitre la distribution des niveaux de gris ou de couleur et de voir entre
quelles bornes sont reparties la majorité des niveaux dans les cas d‟une image trop claire ou trop
foncée. [32]

2.3 Étapes d’un système de vision

Le schéma classique d‟un processus de vision par ordinateur peut être représenté par la figure
suivante:
Acquisition Traitement Analyse Interprétation

Figure 2.04 : Les étapes de la vision par ordinateur

Examinons en détails chacune de ces phases.

2.3.1 Acquisition
La phase d‟acquisition est essentielle au processus de vision par ordinateur car elle permet de
simplifier les étapes de traitement et d‟analyse. La manipulation d‟image sur un système
informatique nécessite son extraction sous une forme numérique, c‟est-à-dire une numérisation.
Cette étape nécessite plusieurs outils dont l‟éclairage, les cartes d‟acquisition (carte ajoutée à un
ordinateur pour la numérisation de sons et d'images en provenance de sources externes), les caméras
et les scanners.

Le principe d‟acquisition d‟image se présente comme suit : des sources lumineuses éclairent une
scène composée d‟objets, chaque objet absorbe et renvoie cette énergie lumineuse, le capteur
d‟images transforme l‟énergie lumineuse renvoyée dans sa direction en un signal électrique. Cette
transformation est basée sur l‟effet photoélectrique, il permet à un photon incident d‟arracher des
électrons à des éléments sensibles ou photosites d'une matrice de petits capteurs élémentaires. Les
deux principaux types de capteurs sont : les capteurs CCD et les capteurs CMOS. [32] [36]

31
2.3.1.1 Capteur CCD
Inventés dans les laboratoires Bell en 1970 par Willard S. Boyle et George Smith, les capteurs CCD
(Charged Coupled Device) sont les premiers à faire leur apparition. Ces capteurs sont des systèmes
à base de charge.

Figure 2.05 : Photosite d‟un capteur CCD

Les photons sont reçus sur l‟électrode semi-transparente et sont transformés en électron par effet
photoélectrique. Les électrons sont ensuite collectés dans la zone désertée. À la fin de l'exposition,
grâce à un jeu de variation de potentiel cyclique résultant d'une horloge externe, les charges sont
transportées de photosite en photosite et envoyées dans un registre de sortie. Finalement, les
charges sont transformées en tension. Ce signal sera, à l'extérieur du CCD, amplifié et numérisé.
[37]

2.3.1.2 CMOS
Les capteurs CMOS (Complementary Metal Oxide Semiconductor) sont apparus au début des
années 80, son fonctionnement est différent de celle des capteurs CCD. Mais néanmoins, le principe
de base reste le même. Les photosites sont également sensibles à la lumière et obtiennent une
certaine charge électrique qui est en fonction de la quantité de lumière reçue. La différence est que
pour un capteur CMOS ; à l'intérieur de chaque photosite, la charge générée est directement
convertie en tension utilisable. [37]

2.3.2 Traitement
Le traitement est souvent appelé prétraitement, cette phase regroupe un ensemble de techniques
pour l‟amélioration de l‟image. En effet, des bruits accompagnent toujours la phase d‟acquisition
dus essentiellement aux phénomènes physiques tels que : la diffraction (déviation) du système
optique ou le flou causé par le mouvement de l‟image durant son acquisition.

32
Les techniques de prétraitement les plus courants sont : la modification d‟histogramme et la
réduction de bruit par filtrage. [32] [38]

2.3.2.1 Modification d‟histogramme

Cette méthode consiste à améliorer l‟image en appliquant une transformation ponctuelle d‟intensité.
Pour chaque pixel on associe une intensité par une transformation croissante telle que les contrastes
entre régions seront conservés. Ici une région représente un ensemble connexe de pixels ayant le
même niveau, délimité par un contour de pixels de niveaux différents. Ce procédé permet d‟obtenir
un meilleur contraste. L‟expansion de dynamique et l‟égalisation d‟histogramme sont deux
exemples de modification d‟histogramme.

L‟expansion de dynamique : c‟est une opération consistant à répartir les fréquences d'apparition des
pixels sur la largeur de l'histogramme. Ceci revient à étendre l'histogramme afin que la valeur
d'intensité la plus faible soit à zéro et que la plus haute soit à la valeur maximale.

L‟égalisation d‟histogramme : ce procédé a pour but d'harmoniser la répartition des niveaux de

luminosité de l'image, de telle manière à tendre vers un même nombre de pixel pour chacun des
niveaux de l'histogramme. Cette opération vise à augmenter les nuances dans l'image. Cette
transformation permettra d‟avoir un histogramme de niveaux de gris le plus plat possible. [38] [39]
[40]

2.3.2.2 Filtrage
Un des objectifs du filtrage est d‟éliminer les perturbations qui accompagnent les procédés
d‟acquisitions. Le filtrage d‟une image consiste à lui appliquer une transformation mathématique,
modifiant les valeurs de gris d‟une partie ou de tous ces pixels. Durant ce procédé les éléments
significatifs de l‟image doivent être préservés au mieux. Les filtres les plus utilisés sont basées sur
le filtrage linéaire, mais il existe également d‟autres filtres basés sur le filtrage non linéaire.

La notion de filtre sera plus approfondie dans un autre paragraphe qui lui sera voué
particulièrement. [32] [41]

2.3.3 Analyse
Le principal but de la phase d‟analyse est l‟extraction d‟information caractéristique contenue dans
l‟image. Pour cela elle a recours à divers techniques telles que :

 la classification d‟objet qui consiste à catégoriser l‟image entière dans une classe ;

33
  la détection d‟objet qui consiste à localiser des instances dans une image, en dessinant un
rectangle autour de chacune d‟elle ;
 la segmentation d‟objet qui consiste à identifier les parties de l‟image. Elle constitue la base
de la classification et la détection d‟objet.

Figure 2.06 : Différence entre classification, détection et segmentation d‟objet

La segmentation étant la base des autres techniques, elle sera approfondie dans ce qui suit. [42]

2.3.3.1 Anciennes techniques de segmentation

Définition 2.04:

Une segmentation d‟image est un partitionnement de l'image en ensembles de pixels homogènes,

afin de simplifier son analyse. Les partitions obtenues représentent des objets ou des parties d‟objet.
[42]

La segmentation permet de prendre en compte des composants plus grands et élimine la nécessité
de considérer les pixels comme unité d‟observation.

Ci-après les principales techniques de segmentation non basée sur le deep learning :

 seuillage : le seuillage est un procédé de segmentation très simple, il consiste à dire que tout
objet se différencie de son arrière-plan. Une valeur seuil spécifiée sépare les pixels en deux
niveaux (exemple 255 si le niveau est supérieur au seuil et 0 si il est inférieur). Le seuillage
convertit les images en niveaux de gris en images binaires ou distingue les pixels clairs et
foncés d‟une image couleur.
 K-means : l‟algorithme K-means identifie des groupes dans les données, K représentant le
nombre de groupe. L'algorithme assigne chaque pixel à l'un des groupes en fonction de la

34
 similarité des caractéristiques. Cet algorithme étant présenté dans le chapitre 1, le lecteur est
invité à revoir le sous paragraphe 1.4.4 de ce chapitre pour plus de précision.
 segmentation basée sur l‟analyse d‟histogramme : cette technique utilise l‟histogramme pour
regrouper les pixels en fonction du niveau de gris. Les images simples étant constituées d‟un
objet et d‟un arrière-plan. L‟arrière-plan est généralement sur un niveau de gris et est la plus
grande entité. Ainsi, un pic élevé de niveau de gris dans l‟histogramme représente le fond de
l‟image et une valeur plus petite correspondant à un autre niveau de gris représentant l‟objet.
 détection de contour : La segmentation par détection de contour consiste à identifier les
changements brusques ou les discontinuités de luminosité dans l‟image.

2.3.3.2 Techniques de segmentation et deep learning

Les techniques de segmentation d‟image présentées précédemment sont largement moins efficaces
que celles utilisant le deep learning. En effet, la plupart de ces anciennes techniques utilisent des
algorithmes rigides et nécessitent une intervention et une expertise humaines.

Ci-après les principales techniques de segmentation utilisant le deep learning :

 segmentation sémantique: la segmentation sémantique est un algorithme de deep learning

permettant d‟associer une étiquette ou une classe à chaque pixel d'une image. Ces classes
sont interprétable sémantiquement. Contrairement à la détection d‟objet, cette technique
détecte proprement les objets de forme irrégulière.
 Segmentation d‟instance : la segmentation d‟instance est un algorithme permettant
d‟identifier chaque instance de chaque classe d‟objet dans une image. Elle se distingue de la
segmentation sémantique par le fait qu‟elle ne classe pas chaque pixel. S'il y a trois chaises
dans une image, la segmentation sémantique classe toutes les chaises en une instance, tandis
que la segmentation d‟instance identifie chaque chaise. [42] [43] [44]

Figure 2.07 : Différence segmentation sémantique et segmentation d‟instance

35
2.3.4 Interprétation
La phase d‟interprétation consiste à interpréter les informations et à décider des actions à engager :
la visualisation, le stockage et la transmission des images. L‟image est alors décrite de manière
sémantique.

2.4 Filtrage d’image

Une image peut être améliorée par une opération dite de filtrage. Si certain signaux (électriques,
sonores, images, etc.) présentent des fréquences très différentes, il peut être avantageux d'en
éliminer certaines. L‟amélioration des images est essentiellement obtenue par filtrage, qui consiste
soit à atténuer certains attributs, soit à accentuer d‟autres. On rappelle que le principal objectif du
filtrage est d‟éliminer les perturbations liées aux procédés d‟acquisitions et aux problèmes de
transmission pour réduire les variations d‟intensité au sein de chaque région de l‟image. Dans la
suite, on parlera essentiellement de filtrage linéaire. Le filtrage linéaire s‟obtient soit par produit de
convolution pour le domaine spatial soit en multipliant la transformée de Fourier de l‟image par la
fonction de Transfert du filtre pour le domaine fréquentiel. L‟image filtrée est alors obtenue par
transformée de Fourier inverse. [32] [41]

2.4.1 Filtrage par produit de convolution

Le filtrage d‟une image ( ) peut s‟effectuer par son produit de convolution avec une fonction
( ) qui représente la réponse impulsionnelle du filtre.

L‟image de sortie ( ) s‟obtient donc par :

( ) ( ) ( ) (2.04)

Le filtrage par produit de convolution met en jeu les pixels voisins, ce qui n‟est pas le cas pour les
manipulations d‟histogramme qui sont des opérations ponctuelles.

Le produit de convolution est défini dans le cas continu et à une dimension par:

(2.05)
( ) ( ) ( ) ∫ ( ) ( )

Pour deux dimensions, on a :

(2.06)
( ) ( ) ( ) ∫ ∫ ( ) ( )

36
Pour le cas d‟une image numérique, la convolution numérique est donnée par sa forme discrète:

(2.07)
( ) ( )( ) ∑∑ ( ) ( )

Soit deux matrices I et K, où I représente la matrice image et K la réponse impulsionnelle du filtre

que l‟on nommera noyau. Le noyau va agir sur chaque pixel de la matrice image.

La figure 2.08 représente les pixels voisins du pixel ( ) et un noyau K de éléments.

Figure 2.08 : Pixels voisins du pixel ( )et le noyau K

L‟image de ( )après filtrage ( ) est donnée par :

( ) ( ) ( ) ( ) ( ) ( ) ( ) (2.08)
( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )
( ) ( ) ( ) ( )

Illustrons cela par un exemple plus concret donné par la figure 2.09 :

Figure 2.09 : Exemple d‟opération de convolution

37
Sur la figure 2.09 l‟image de 150 après filtrage est 350, pour la convolution des bords, on peut
utiliser l‟ajout de zéro ou l‟ajout de valeurs par défaut. [32]

2.4.2 Filtrage par utilisation de la transformée de Fourier

Le filtrage d‟une image peut être également réalisé dans le domaine fréquentiel. Cette opération
consiste à multiplier la transformée de Fourier de l‟image par la réponse fréquentielle du filtre et de
calculer la transformée de Fourier inverse du résultat.

( ) , - (2.09)

La transformé de Fourier permet de décomposer un signal en une somme de sinusoïdes, permettant

ainsi de mettre en évidence les fréquences contenues dans un signal. La transformé de Fourier d‟une
image de taille est une image de taille à valeur complexe : [32] [45]

(2.10)
( )
( ) ∑∑ ( )

2.5 Détection d’objet

La détection d‟objet comme on l‟a déjà évoqué dans le paragraphe 2.3.3 est un processus de
recherche d‟instance d‟objets dans une image ou vidéo. Les algorithmes de détection d‟objet
utilisent généralement les caractéristiques d‟une observation (features), et des algorithmes
d‟apprentissage pour reconnaitre les instances d‟une catégorie d‟objet. Il existe plusieurs méthodes
de détection d‟objet, celles basées sur le machine learning et celles basées sur le deep learning.
Seules les méthodes basées sur le machine learning seront abordées dans ce chapitre, celles basées
sur le deep learning feront objet d‟un autre chapitre.

2.5.1 Méthode de Viola et Jones

La méthode de Viola et Jones a été réalisée par les chercheurs Paul Viola et Michael Jones en 2001.
Cette méthode est une avancée majeure dans le domaine de la détection d‟objet et fait partie des
toutes premières méthodes capables de détecter efficacement et en temps réel des objets dans une
image. Initialement créée pour la détection de visage, elle peut également servir pour la détection
d‟autres objets. [46]

38
2.5.1.1 Principe
Dans l‟algorithme original une fenêtre de détection de taille initiale 24px par 24px est utilisée pour
balayer l‟image et déterminer si un visage y est présent. Une fois l‟image parcourue entièrement, la
taille de la fenêtre est augmentée d‟un facteur multiplicatif de 1,25 et le balayage recommence, en
décalant d‟un pixel, jusqu‟à ce que la fenêtre fasse la taille de l‟image. Ce décalage peut être changé
afin d‟accélérer le processus, mais un décalage d‟un pixel assure une précision maximale.

Cette méthode a comme particularités : l‟utilisation d‟image intégrale, la sélection par boosting des
caractéristiques, la combinaison en cascade de classifieurs boostés. [46]

2.5.1.2 Apprentissage du classifieur

La méthode de Viola et Jones est un procédé d‟apprentissage supervisé, elle utilise quelques
centaines à plusieurs milliers d‟exemples de l‟objet que l‟on souhaite détecter, pour entraîner un
classifieur. Pour cette étape, le classifieur est mis dans deux situations, d‟abord une énorme quantité
de cas positifs lui sont présentés et ensuite, à l‟inverse, une énorme quantité de cas négatifs lui sont
présentés. [46]

2.5.1.3 Caractéristiques
Une caractéristique est une représentation synthétique et informative, calculée à partir des valeurs
des pixels, ici on utilise les caractéristiques pseudo-Haar. Les caractéristiques sont calculées par la
différence des sommes de pixels de deux ou plusieurs zones rectangulaires adjacentes. Une
caractéristique est donc donnée par un nombre réel codant les variations des pixels à une position
donnée dans la fenêtre de détection. Pour calculer ces caractéristiques rapidement, on utilise les
images intégrales. [46]

2.5.1.4 Images intégrales

L‟image intégrale est une nouvelle représentation qui va permettre de calculer plus rapidement les
attributs du descripteur de Haar. L'idée est de calculer seulement une fois la somme de tous les
pixels de l'image. C‟est une représentation sous la forme d‟une image de même taille que l‟image
d‟origine. Elle contient en chacun de ses points la somme des pixels situés au-dessus et à gauche du
pixel courant.

L‟image intégrale au point ( )est définie par :

39
 ( ) ∑ ( ) (2.11)

En utilisant l‟image intégrale, à partir de ( ) n‟importe quel rectangle de l‟image peut être
calculé avec 4 points:





 ( ) (2.12)

Ainsi pour calculer tous les pixels dans la région D (figure 2.10), on n‟a pas à additionner tous les
pixels qui le composent. [47]

Figure 2.10 : Calcul de la somme du rectangle D avec l'image intégrale

2.5.1.5 Sélection de caractéristiques par boosting

Le boosting est un principe dont le but est de construire un classifieur fort à l‟aide d‟une
combinaison pondérée de classifieurs faibles. On forme les classifieurs faibles avec les descripteurs
de Haar. Un classifieur h(x), composé d'un descripteur f, d'un seuil θ et d'une parité p, permet de
donner une prédiction sur la classe d‟appartenance de x.

( ) (2.13)
( ) 2

Etant donné les exemples négatifs et positifs, on initialise les poids de chaque exemple et on
applique un processus de boosting : T itérations sélectionnant T classifieurs faibles ( ) avec
chacun un poids pour obtenir finalement un classifieur fort ( ). Pour chaque itération, un
classifieur est choisi en minimisant le taux d‟erreur calculé avec les poids courants des exemples.

40
On augmente ensuite les poids des exemples mal classifiés pour la sélection suivante. L‟itération se
termine quand le taux de bonnes détections et le taux de faux positifs atteignent le compromis
choisi au départ. Le classifieur fort final est composé de la somme pondérée des classifieurs
sélectionnés. [47]

2.5.1.6 Combinaison en cascade de classifieurs boostés

La réalisation d‟un traitement efficace nécessite l'avis de plusieurs classifieurs forts. Une cascade de
classifieurs est un arbre de décision dégénéré dans lequel chaque étape est entraînée pour détecter
un maximum d‟objets intéressants tout en rejetant une certaine fraction des objets non-intéressants.

Une décision « fausse » interrompe le calcul et impose au détecteur de retourner faux, une décision
vraie passe l‟image d‟entrée au prochain classifieur. Cela nécessite que pour qu‟une entrée soit
classifier vraie tous les classifieurs doivent voter « vraie ».

En pratique, la cascade est constituée d'une succession d'étages, chacune étant formée d'un
classifieur fort. L'apprentissage du classifieur de l'étage (n) est réalisé avec les exemples qui ont
passé l'étage (n – 1). Ce classifieur doit donc faire face à un problème plus difficile : plus on monte
dans les étages, plus les classifieurs sont complexes.

Figure 2.11 : L‟architecture de la cascade

La principale limitation de la méthode de Viola et Jones est sa non adaptation à la rotation. Il est
donc difficile d‟apprendre plusieurs vues d‟un même objet. Plusieurs améliorations ont été
proposées pour remédier à ce problème. [46] [48]

2.5.2 Histogramme de gradient orienté (HOG)

Les HOG pour « Histograms of Oriented Gradients » ont été proposés par les chercheurs Navneet
Dalal et Bill Triggs en 2005. La base des histogrammes de gradients est justement le calcul de
gradient, qui se traduit pour une image par le calcul de la variation de l‟intensité des pixels dans
différentes directions. Cela est équivaut à un calcul de gradient à une dimension. Le calcul d‟un

41
descripteur HOG se fait en trois étapes : le calcul du gradient, le calcul de l‟orientation, la
construction de l‟histogramme.

2.5.2.1 Calcul du gradient

La première étape consiste à calculer le gradient de chaque point de l‟image. Pour cela deux
masques de dérivation sont appliquées à l‟image, un horizontal et un vertical : , - et
, - .

Pour tous les points de l‟image, une approximation de la composante horizontale du gradient notée
et de la composante verticale notée est ainsi obtenue. Ici ce qui importe le plus c‟est le
contraste entre deux régions, cela implique que dans la plupart des cas la valeur absolue du gradient
est prise. Cela signifie qu‟un objet noir sur un fond blanc aura le même résultat qu‟un objet blanc
sur un fond noir.

2.5.2.2 Calcul de l‟orientation

Une fois que le calcul du gradient a été effectué pour tous les pixels de l‟image, il faut en calculer
l‟orientation, celle-ci peut être définie comme :

(2.14)
( )

2.5.2.3 Construction de l‟histogramme

L‟image est divisée en plusieurs cellules et pour chaque cellule un histogramme est construit.
L‟histogramme est construit en comptabilisant les occurrences du gradient dans une barre
correspondant à un intervalle d‟orientation spécifique. Pour cela différentes méthodes ont été
développées.

D‟abord, les occurrences peuvent être pondérées par la magnitude du gradient. Les régions
uniformes se représentent par un gradient de faible amplitude. L‟information est donc plus
significative quand le gradient atteint de grande valeur. Cela correspond par exemple à des coins ou
à des contours d‟un objet.

Ensuite, le nombre de barres d‟histogramme désirées influe directement sur la précision des
informations. Une barre d‟histogramme correspond au nombre d‟occurrence de l‟orientation du
gradient pour un intervalle donné. En effet, un petit nombre de barres réduit l‟information
disponible et trop de barres risquent de ne pas faire ressortir une information globale intéressante.

42
Enfin, l‟étape suivante est la normalisation, les histogrammes locaux sont normalisés en contrastes
afin d‟avoir une meilleure résistance aux changements d'illuminations et aux ombres. Pour cela les
cellules sont regroupées en blocs (concaténation des histogrammes des cellules d‟un bloc). Après sa
combinaison, les histogrammes sont normalisés en utilisant l'équation :

(2.15)
√‖ ‖

: est le vecteur non normalisé contenant tous les histogrammes d'un bloc donné,

‖ ‖ : est la L2-Norme du vecteur V,

: est une constante de valeur très faible.

Le processus de détection d‟objet nécessite l‟utilisation des descripteurs HOG pour entraîner un
classifieur supervisé. Différents types de classifieurs peuvent-être utilisés, initialement un
classifieur SVM ou Support Vector Machine a été utilisé. [49] [50]

2.5.2.4 Machine à Vecteur de support

Le classificateur Support Vector Machines est une technique de classification binaire. Ils sont
particulièrement bien adaptés à la classification de jeux de données complexes. Cette méthode
cherche alors l‟hyperplan qui sépare les exemples positifs des exemples négatifs en garantissant que
la marge entre le plus proche des positifs et des négatifs soit maximale. La généralisation et la
robustesse aux éventuelles variations des exemples de chaque classe est alors garantie. L‟intérêt de
cette méthode est la sélection de vecteurs supports qui représentent les vecteurs discriminant grâce
auxquels est déterminé l‟hyperplan. [51]

Figure 2.12 : Classification SVM

43
2.6 Conclusion
Les scientifiques se sont toujours intéressés à la vision et ont essayé de le reproduire. Grâce à la
vision par ordinateur, on arrive à permettre à une machine d‟interpréter des éléments visuels et de
créer des descriptions intelligentes et utiles de séquences, de scènes visuelles, ainsi que d‟objets.
L‟exploitation de la vision par ordinateur nécessite plusieurs bases de connaissances sur les images
et sur leurs manipulations. Son utilisation dans le domaine de la détection d‟objet a connue
plusieurs bouleversements et dernièrement les connaissances acquises grâce au deep learning ont
permis un changement majeur. Les méthodes de détection d‟objet présentées dans ce chapitre sont
basées sur le machine learning, dans le chapitre 3, l‟intérêt des méthodes utilisant le deep learning
sera mis en avant.

44
 CHAPITRE 3
RESEAUX DE NEURONES CONVOLUTIONNELS

3.1 Introduction
Les méthodes de détection d‟objet vues dans le chapitre précédent se basent sur des méthodes
traditionnelles qui consistent à extraire les caractéristiques « features » de chaque image du jeu de
données, puis à entraîner un classifieur sur ces features. Ces techniques peuvent fournir de bons
résultats, dépendant de la qualité des features préalablement trouvées.

En 2012, commence une révolution, lors de la compétition imagenet, un nouvel algorithme basé sur
le deep learning va se démarquer de tous les autres en explosant les records. C‟est un réseau de
neurone convolutif appelé « AlexNet ». La méthode utilisée par les CNN est similaire à celle des
méthodes traditionnelles, c‟est-à-dire ils reçoivent des images en entrée, détectent les features de
chacune d'entre elles, puis entraînent un classifieur dessus. Les grandes différences sont l'extraction
et la hiérarchisation automatique des features. Le CNN est l‟un des algorithmes les plus répandus
pour le Deep Learning. Selon l‟utilisation, on peut soit créer un CNN à partir de zéro, soit utiliser
un modèle pré-entrainé.

Ce chapitre a pour but de présenter les CNN et leur application à la détection d‟objet. Pour ce faire,
une présentation générale des CNN s‟impose, ensuite, on verra en détail les différentes couches et
les différents architectures des CNN, s‟en suivra la présentation de la rétropropagation dans un
CNN, enfin, l‟apprentissage par transfert et la détection d‟objet utilisant les CNN seront abordés
pour conclure ce chapitre. [24]

3.2 Généralités sur les CNN

Les réseaux de neurones convolutionnels sont spécialement conçus pour traiter des images en
entrée. Ils sont les plus performants en terme classifications d‟images. Ces réseaux comportent deux
parties bien distinctes.

La première partie est la partie convolutive, elle fait la particularité de ce type de réseau. Cette
partie fonctionne comme un extracteur de caractéristiques. Une image passe à travers une
succession de filtres de convolution. Habituellement, une couche de convolution est suivie d'une
fonction d'activation. Certains filtres intermédiaires sont là pour réduire la résolution de l‟image par
une opération de maximum local. Ce procédé peut être réitéré plusieurs fois. Finalement, les cartes

45
de convolutions sont concaténées dans un vecteur, appelé code CNN. Ce vecteur représente la sortie
du premier bloc, et l‟entrée du second.

La deuxième partie n‟est pas caractéristique d‟un CNN, elle est constituée d‟une couche
entièrement connectée. Cette partie a pour rôle de combiner les caractéristiques du code CNN pour
classer l‟image. La sortie est une dernière couche qui contient autant d'éléments qu'il y a de classes.
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. Comme pour les réseaux de neurones
ordinaires, les paramètres des couches sont déterminés par rétropropagation du gradient. Mais dans
le cas des CNN, ces paramètres désignent en particulier les features des images. [34]

Figure 3.01 : Architecture standard d'un réseau de neurones convolutionnels

3.3 Différentes couches d’un CNN

Les différentes couches constituant un CNN présentées dans le chapitre 1 serons détaillées dans ce
paragraphe.

3.3.1 Couche de convolution

3.3.1.1 Principe de fonctionnement

La couche de convolution est la composante clé des CNN, elle est présente au moins dans la
première couche. Le but de cette couche est de trouver un ensemble de features dans les images
reçues en entrée. C‟est là qu‟intervient l‟opération de convolution : le principe est de faire "glisser"
une fenêtre représentant la feature sur l'image. Le produit de convolution entre la feature et chaque
portion de l'image balayée est alors calculé. Dans ce cas, la feature est considérée comme un filtre.
Les filtres correspondent exactement aux features que l'on souhaite retrouver dans les images. En
sortie, on obtient une carte d‟activation ou feature map, indiquant l‟emplacement des features dans

46
l‟image. Dans un CNN, les features ne sont pas prédéfinies selon un formalisme particulier comme
pour les méthodes traditionnelles (Viola Jones ou HOG par exemple), elles sont apprises lors de la
phase d‟entrainement du réseau. Les CNN sont donc capables de déterminer tout seul les éléments
discriminants d'une image.

3.3.1.2 Calcul des dimensions de la sortie

Le calcul de la dimension de la sortie associée à une couche de convolution nécessite la
connaissance de trois hyperparamètres.

 Le pas : dans le contexte d‟une opération de convolution, le pas ou « stride » désigne le pas
de déplacement du noyau après chaque opération à travers l'image.
 La profondeur : c‟est le nombre de noyaux de convolution ou filtre.
 La marge à zéro ou zéro padding : il est commun d‟utiliser une épaisseur de marge de zéros
autour de l‟entrée, le zero-padding est une technique consistant à ajouter P zeros à chaque
côté des frontières de l‟entrée.

Soit I le côté associé à l'entrant, F la dimension du noyau, P l‟épaisseur de la marge à zéro et s

l‟amplitude du pas utilisée ; la dimension O de la sortie est alors donnée par :

(3.01)

Figure 3.02 : Illustration de la taille d‟une sortie de couche de convolution

Remarques : si est différent de alors

(3.02)

[24] [52] [53]

47
3.3.2 Couche de pooling

3.3.2.1 Principe de fonctionnement

La couche de pooling est souvent placée entre deux couches de convolution. Elle applique une
opération de pooling qui est une opération de sous-échantillonnage. Elle consiste à réduire la taille
des images, tout en préservant leurs caractéristiques importantes. Pour se faire, l‟image est
découpée en cellules régulières de tailles 2 × 2 pixels qui ne se chevauchent pas, ou de taille 3 × 3
pixels, distantes les unes des autres d'un pas de 2 pixels (qui se chevauchent donc). Ensuite, on
applique l‟opération de pooling. Les sorties obtenues sont de même nombre que les entrées mais de
taille plus petite. La couche de pooling permet de réduire le nombre de paramètres et de calculs
dans le réseau. On améliore ainsi l'efficacité du réseau et on évite le sur apprentissage. [24]

3.3.2.2 L‟opération pooling

L'idée derrière l'opération pooling est de retirer une certaine information dans un même voisinage
pour l'entrant. L‟opération est effectuée sur chacune des épaisseurs liées à la profondeur de l'entrant.
Généralement, on utilise le max ou l‟average pooling, où les valeurs maximales et moyennes sont
prises respectivement.

Figure 3.03 : Exemple de calcul du Max pooling et Average pooling

Dans la figure 3.03, on est en présence de cellules de taille 2x2.

Pour l‟average pooling : chaque case correspond à la moyenne du carré d‟entrée de la même
couleur, exemple pour le cas de la case jaune, on a :

48
Pour le max pooling : chaque case correspond à la valeur maximum du carré d‟entrée de la même
couleur, exemple pour la case bleu :

( )

[22] [52]

3.3.3 Couche Rectified Linear Units

La fonction ReLU ou Rectified Linear Units est appliquée après la fonction de convolution et laisse
les dimensions inchangées. Elle désigne une fonction réelle non linéaire définie par :

( ) ( ) (3.03)

La couche de correction ReLU remplace donc toutes les valeurs négatives reçues en entrées par des
zéros. Elle joue le rôle de fonction d'activation et a pour but d‟introduire des complexités non-
linéaires au réseau. [52] [53]

Figure 3.04 : fonction Rectified Linear Units

3.3.4 Couche entièrement connectée

La couche entièrement connectée ou fully-connected layer en anglais constitue toujours la dernière
couche d‟un réseau de neurones. Cette couche n‟est donc pas caractéristique d‟un CNN. Elle
s'applique sur une entrée préalablement aplatie où chaque entrée est connectée à tous les neurones et
produit un nouveau vecteur en sortie. La dernière couche classifie l‟image d‟entrée en plusieurs
classes et renvoie un vecteur dont la taille est égale au nombre de classe du problème. Chaque
élément du vecteur indique la probabilité pour l'image en entrée d'appartenir à une certaine classe.

49
Pour calculer les probabilités, la couche entièrement connectée multiplie donc chaque élément en
entrée par un poids, fait la somme, puis applique une fonction d'activation (ici on utilise la fonction
softmax si le nombre de classe ou sigmoïde logistique si ). L‟apprentissage des
valeurs des poids se fait lors de phase d'entraînement, par rétropropagation du gradient.

La couche entièrement connectée cherche les liens entre la position des features dans l'image et une
classe. En effet, le tableau en entrée correspond à une carte d'activation pour une feature donnée :
les valeurs élevées indiquent la localisation de cette feature dans l'image. Si la localisation d'une
feature à un certain endroit de l'image est caractéristique d'une certaine classe, alors on accorde un
poids important à la valeur correspondante dans le tableau. [24] [53]

Figure 3.05 : Mis en évidence d‟une couche entièrement connectée

3.4 Divers architectures d’un CNN

Ce paragraphe abordera quelques-uns des architectures de CNN les plus célèbres.

3.4.1 LeNet
Les premières applications réussies des réseaux convolutifs ont été développées par Yann LeCun
dans les années 1990. Parmi ceux-ci, le plus connu est l‟architecture LeNet. LeNet est un réseau de
convolution à 7 niveaux, il permet de classifier des chiffres. Il a été utilisé par plusieurs banques
pour reconnaitre les nombres manuscrits sur les chèques numérisés en image d‟entrée de taille
. Cette technique est limitée par la disponibilité des ressources informatiques de l‟époque. [54]

50
 Figure 3.06 : Architecture de LeNet

3.4.2 AlexNet
AlexNet a été proposé par Alex Krizhevsky durant le défi ImageNet Large-Scale Visual
Recognition Challenge (ILSVRC) de 2012 et remporte le premier prix. Ce réseau a permis
d‟accroitre considérablement la précision de la classification par rapport aux méthodes
traditionnelles. Il avait une architecture très similaire à celle de LeNet, mais été plus profond avec
plus de filtre par couche et des couches de convolution empilées. AlexNet est constitué de 5
couches convolutives, suivies de 3 couches entièrement connectées et utilise Relu pour la partie non
linéaire. AlexNet a été formé pendant 6 jours simultanément sur deux GPU Nvidia Geforce GTX
580. [54]

Figure 3.07 : Architecture d‟ALexNet

3.4.3 VGGNet
Le finaliste du concours ILSVRC 2014 est baptisé VGGNet et a été développé par Simonyan et
Zisserman. VGGNet est composé de 16 couches convolutives très attrayant en raison de son
architecture très uniforme. VGGNet est similaire à ALexNet mais apporte une amélioration en

51
remplaçant les filtres de noyau volumineux par des filtres de taille . Il a nécessité quatre GPU
et un temps de deux à trois semaines pour la formation. Bien que VGG atteigne une grande
précision sur le jeu de données ImageNet, son déploiement est un problème. Les exigences en
calcul sont énormes, à la fois en terme de mémoire et de temps. [54]

Figure 3.08 : Architecture de VGGNet

3.4.4 GoogLeNet/Inception

3.4.4.1 InceptionV1
Le gagnant du concours ILSVRC 2014 était GoogLeNet ou InceptionV1. Il contient une pile de 22
convolutions et un nouveau module appelé le « module Inception ». Ce modèle est composé de
calculs parallèles de convolutions de formes différentes et de max-pooling. La sortie de tous ces
modules est concaténée à la fin de chaque module Inception.

Le principe de l‟architecture Inception consiste à augmenter la profondeur et la largeur du réseau

dans son ensemble, tout en maintenant les couts de calcul constant. Cela a été accompli grâce à une
conception modulaire, impliquant l‟empilement de blocs de couches convolutives. Chaque bloc
contient un certain nombre de couches convolutives.

Figure 3.09 : Module Inception

52
En empilant ces blocs les uns sur les autres et en insérant occasionnellement des couches de max-
pooling, l‟architecture Inception atteint des vitesses 2 à 3 fois plus rapide comparé à des
architectures n‟utilisant pas Inception. Cela est due au fait que l‟architecture Inception est plus
centrée sur la disposition spécifique du réseau plutôt que d‟ajouter simplement plus de couches dans
la séquence. En augmentant efficacement la largeur du réseau en plus de sa profondeur, le réseau
résultant contient plus de couches au total, mais comme les couches ne sont pas simplement
connectées directement les unes aux autres, le nombre total de connexions dans le réseau est réduit.
Ainsi, il y a moins de connexions qui doivent être ajustées durant l‟entrainement du réseau ce qui
fait gagner beaucoup plus de temps.

Le réseau débute comme n'importe quel autre réseau convolutionnel, les couches convolutionnelles
et de max-pooling étant empilées de manière séquentielle. Cependant, après les quatre premières
couches, les modules Inception sont utilisés, les deux premiers d'une rangée, puis cinq autres après
une couche de max-pooling. De cette manière, le réseau initial contient un grand nombre de
couches, tout en limitant la profondeur totale du réseau, ce qui a permis d'améliorer
considérablement les performances. [54] [55]

Figure 3.10 : Architecture de GoogLeNet

3.4.4.2 InceptionV2
Il existe plusieurs améliorations d‟Inception, Inception v2 et Inception v3 ont été présentés dans le
même document. Les auteurs ont proposé un certain nombre de mises à niveau qui augmentent la

53
précision et réduisent la complexité des calculs. Les améliorations apportées pour l‟obtention
d‟InceptionV2 sont :

On a factorisé la convolution en deux opérations de convolution pour améliorer la

vitesse de calcul. Une convolution 5x5 coûte plus cher qu'une convolution 3x3. Donc, empiler deux
convolutions 3x3 améliore les performances.

Figure 3.11 : Changement de convolution en

De plus on a factorisé les convolutions en une combinaison de convolution et .

Par exemple, une convolution équivaut à exécuter d‟abord une convolution suivit d‟une
convolution sur sa sortie. Cette méthode est 33% moins chère en calcul qu‟une seule
convolution de .

Figure 3.12 : Changement de convolution en et

54
Les banques de filtre du module ont été développées (élargies). Car si le module était approfondi, il
y aurait une réduction excessive des dimensions et donc une perte d'informations appelée
«representational bottleneck »

Figure 3.13 : Elargissement des filtres

Les trois principes vus précédemment seront utilisés pour construire trois différents types de
modules Inception.

Figure 3.14 : Architecture d‟InceptionV2

Dans la figure 3.14, 5 représente le module Inception de la figure 3.11 ; 6 le module de la figure
3.12 et 7 le module de la figure 3.13. [56]

55
3.5 Rétropropagation dans un CNN

3.5.1 Corrélation croisée et convolution

Soit I une image et F un filtre de dimension une opération de corrélation croisée est définie
par :

(3.04)
∑∑ ( ) ( )

Le produit de convolution de la matrice image I et du filtre K est obtenu en appliquant une rotation
de 180° sur le filtre et en faisant le calcul de la corrélation croisée du résultat par I. [57]

Figure 3.15 : Relation entre produit de convolution et corrélation croisée

3.5.2 Notations utilisées

Les notations suivantes seront utilisées dans les sous paragraphes suivants:

 représente la couche où est la première et la dernière couche ;

 L‟entrée est de dimension et ( ) sont utilisés comme itérateurs ;
 Le filtre ou noyau de dimension et a comme itérateurs ( );
 est la matrice de poids reliant les neurones de la couche aux neurones de la
couche ;
 est l‟unité de biais de la couche ;
 est le vecteur d‟entrée convolué au niveau de la couche plus le biais :

56
 ∑∑ (3.05)

 est le vecteur de sortie à la couche :

( ) (3.06)

 est la fonction d‟activation .

[57]

3.5.3 Forward propagation

Pour effectuer une opération de convolution, on effectue une rotation du filtre à 180°.

L‟équation de convolution à l‟entrée de la couche est donnée par :

{ }

(3.07)
∑∑

[57]

3.5.4 Erreur
Pour un total de P prédictions, les sorties du réseau et les valeurs cibles correspondantes ,
l‟erreur quadratique moyenne est donnée par :

(3.08)
∑( )

L‟apprentissage se fera en ajustant les poids de manière à ce que soit aussi proche de que
possible. [57]

3.5.5 Backpropagation (rétropropagation)

On cherche à calculer , qui peut se traduire par la mesure de la manière dont la modification

d‟un seul pixel dans le noyau de poids affecte la fonction d‟erreur. Le pixel affecte tous
les éléments de la sortie.

57
La convolution entre l‟entrée de dimension et le filtre de dimension produit une
sortie de dimension ( ) ( ). En appliquant la règle de la dérivation en
chaine :

∑ ∑

∑ ∑
(3.09)

On a est équivalent à ∑ ∑ donc :

(3.10)
(∑ ∑ )

Développons encore la somme de l‟équation si dessus et en prenant la dérivée partielle de tous les
composantes, on obtient les valeurs nulles sauf les composantes où et :

. /

(3.11)

En substituant l‟équation (3.11) dans (3.9) on a :

∑ ∑

(3.12)
{ }

La double somme résulte du partage de poids dans le réseau (le même filtre est appliqué à l‟entrée
durant la phase de convolution).

L‟opération de convolution pour obtenir le nouvel ensemble de poids est représentée sur la figure
3.16:

58
 Figure 3.16 : Obtention d‟un nouvel ensemble de poids

Les deltas sont fournis par équation suivante:

(3.13)

Ici on cherche à calculer qui peut être interprété par la mesure de la manière dont la

modification d‟un seul pixel dans la carte de caractéristiques en entrée affecte la fonction
d‟erreur.

Figure 3.17 : Région de la sortie affectée par la modification d‟un pixel

La figure 3.17 montre que la région de sortie affectée par le pixel de l‟entrée est la région
délimitée par les pointillés.

En appliquant la règle de la dérivation en chaine et en faisant la somme, on a :

59
 (3.14)
∑

Q représente la région délimitée par les pointillées dans la figure 3.17. Plus formellement l‟équation
3.14 peut s‟écrire :

∑ ∑

(3.15)
∑ ∑

Dans la région Q, la hauteur varie de à ( ) et la largeur de à ( ).

Ils peuvent être représentés par et car et existent dans des intervalles similaires :

et .

est équivalent à ∑ ∑ donc :

(∑ ∑ )

(3.16)
(∑ ∑ . / )

Développons encore la somme de l‟équation si dessus et en prenant la dérivée partielle de tous les
composantes, on obtient les valeurs nulles sauf les composantes où et :

. ( )/

(3.17)
( )

En substituant l‟équation 3.17 dans l‟équation 3.15 :

60
 (3.18)
∑ ∑ ( )

On a une convolution exprimée sous forme de corrélation croisée avec un filtre retourné, d‟où :

{∑ ∑ } ( )

(3.19)
{ } ( )

[57]

3.6 Apprentissage par transfert

L‟entrainement d‟un réseau de neurones convolutif implique une puissance de calcul souvent
massive pour fonctionner. Plus il y a de couches, plus le nombre de paramètres à optimiser est
élevé. Néanmoins, une solution existe pour améliorer cette phase et ainsi réduire le temps
d‟apprentissage. C‟est là qu‟intervient l‟apprentissage par transfert ou Transfer Learning en anglais.
Cette méthode permet de faire du deep learning sans avoir besoins d‟y passer un mois de calcul. Le
principe est de transférer les connaissances acquises par un réseau de neurones lors de la résolution
d‟un problème afin de traiter un problème similaire. L‟apprentissage par transfert permet également
d‟éviter le surapprentissage. Lorsqu‟on a peu de données, il est déconseillé d'entraîner le réseau de
neurones en partant de zéro. Il existe un grand nombre d‟approches de Transfer Learning. Pour cela,
on peut généralement exploiter un réseau de neurone pré-entrainé de différentes manières. Dans les
sous paragraphe suivants, les manières d‟exploiter un réseau pré-entrainé seront abordées. [24]

3.6.1 Fine tuning total

La dernière couche entièrement connectée du réseau pré-entrainé est remplacée par un classifieur
adapté au nouveau problème et initialisé de manière aléatoire. On entraine ensuite toutes les
couches sur de nouvelles images.

Le fine tuning total doit être utilisé avec une très grande collection de nouvelles images, sinon on
risque le surapprentissage. L‟utilisation de cette méthode permet à l‟apprentissage d‟être plus
rapide. En effet, les paramètres utilisés étant ceux du réseau pré-entrainé et non aléatoirement
choisi. [24]

61
3.6.2 Extraction des caractéristiques
Cette méthode consiste à utiliser les features apprises par le réseau pré-entrainé pour représenter les
images du nouveau problème. La dernière couche entièrement connectée est également retirée et
tous les autres paramètres sont fixés. Ce réseau tronqué va ainsi calculer la représentation de chaque
image en entrée à partir des features déjà apprises lors du pré-entraînement. On entraîne alors un
classifieur initialisé aléatoirement sur ces représentations pour résoudre le nouveau problème.

L‟utilisation de cette méthode est conseillée lorsque les nouvelles images sont peu nombreuses et
similaires aux images de pré-entraînement. Cela permettra d‟éviter le surapprentissage et de plus, si
les nouvelles images ressemblent aux anciennes, la représentation par les même features sera
possible. [24]

3.6.3 Fine tuning partiel

Le fine tuning partiel consiste à utiliser un mélange des deux méthodes précédemment évoquées. La
dernière couche entièrement connectée est encore retirée pour être remplacée par un classifieur
initialisée aléatoirement. On fixe certains paramètres de certaines couches du réseau pré-entraîné.
L‟entrainement se fait donc sur le classifieur et les couches non fixées qui sont généralement les
couches hautes du réseau.

L‟utilisation de cette méthode se fait lorsque la nouvelle collection d'images est petite mais très
différente des images du pré-entraînement. Comme les couches basses sont simples et génériques,
les fixer ne pose donc pas de problème. [24]

3.7 Détection d’objet utilisant les CNN

Les méthodes de détection d‟objet basées sur le deep learning sont nombreuses, les Region-
basedCNN ou R-CNN font parties des approches permettant d‟appliquer les modèles de deep
learning au problème de détection d‟objet. Dans ce paragraphe, on va présenter les R-CNN et les
améliorations qui leurs ont été apportées c‟est-à-dire le Fast R-CNN et le Faster R-CNN.

3.7.1 R-CNN
La détection d‟objet nécessite la connaissance de la classe d‟objet ainsi que l‟emplacement et la
taille du cadre de sélection. La méthode classique utilise une fenêtre coulissante pour chercher dans
chaque portion de l„image. Toutefois, différents objets, voire un même type d‟objet, peuvent avoir
différentes tailles et format d‟image, cela dépend de la distance qui le sépare de la camera. Le
nombre d‟emplacement à considérer devient alors trop nombreux pour être classifié par un CNN.

62
Figure 3.18 : Illustration d‟une fenêtre coulissante (gauche) avec formats, tailles différents (droite)

Afin de contourner ce problème, R-CNN propose la recherche sélective ou selective search en

anglais pour extraire seulement 2000 régions. La recherche sélective utilise des indices locaux tels
que la texture, la couleur, la taille de la région, la compatibilité des formes pour faire de la
segmentation non basé sur des objets. On obtient ainsi de nombreuses petites zones segmentées.
Ensuite, on ajoute les cadres de détection correspondants aux parties segmentées à la liste des
propositions de région. Les régions voisines sont regroupées en considérant le degré de similarité,
afin de former des zones segmentées plus grandes. Ainsi, environ 2000 propositions de région sont
générées.

La classification par un CNN est ensuite effectuée pour chaque cadre de sélection, les propositions
de région sont alors tronquées et redimensionnées. Les 2000 propositions de région sont
transformées en carrés de taille fixe pour être ensuite introduites dans un CNN dont la sortie est un
vecteur de caractéristiques de 4096 dimensions. Le CNN agit comme un extracteur de
caractéristiques (features). Ces caractéristiques sont introduites dans un SVM formé pour chaque
classe afin de classifier la présence d‟un objet. L‟ensemble des propositions de région classées est
réduit à l‟aide d‟une suppression non maximale ou Non Maximum Suppression (NMS). NMS trie
les détections en fonction du score de confiance des objets, prend la détection de score le plus élevé
et supprime celles qui ont un Intersection Over Union ou IOU inférieur à un seuil.

En plus de prédire la présence d‟un objet, l‟algorithme prédit également quatre valeurs qui sont des
valeurs de décalage pour augmenter la précision du cadre de sélection. En effet, l‟algorithme aurait
pu prédire la présence d‟une personne, alors que le visage de cette personne est réduit de moitié.
Dans ces cas, les valeurs de décalages aident à ajuster le cadre de sélection de la proposition de
région.

63
 Figure 3.19 : Illustration du système de détection d‟objet utilisant un R-CNN

Le R-CNN n‟est pas parfait et présente encore quelques défauts : l‟entrainement du réseau prend
beaucoup de temps (il faut classifier 2000 propositions de région), l‟implémentation pour une
application en temps réels n‟est pas possible (47s pour chaque image test), l‟algorithme de
recherche sélective est un algorithme fixe (génération de mauvaise propositions de région
candidates). [58] [59]

3.7.2 Fast R-CNN

Les créateurs de R-CNN ont résolu certains de ses inconvénients, pour créer une version plus rapide
baptisée Fast R-CNN. L‟approche utilisée est similaire à celle vue dans R-CNN, sauf qu‟au lieu de
transmettre des propositions de région, l‟image d‟entrée est directement transmit au CNN pour
générer une carte de caractéristiques. Les régions de propositions sont extraites à l‟aide de ces
cartes. On utilise ensuite une couche RoI (Region of Intrest) pooling pour redimensionner toutes les
régions proposées en une taille fixe de sorte qu‟elle puisse être insérée dans un réseau entièrement
connecté. Une couche softmax est alors utilisée sur le réseau entièrement connecté pour prédire la
classe de la région proposée. En plus de la couche softmax, une couche de régression linéaire est
également utilisée parallèlement, afin de générer les coordonnées du cadre de sélection pour les
classes prédites.

La couche RoI pooling procède comme suit : pour chaque proposition de région sur la liste d‟entrée,
il prend une section de la carte de caractéristique qui lui correspond et la redimensionne à une taille
prédéfinie. La mise à l‟échelle se fait en divisant la région en section et en procédant à une
opération de max pooling sur chaque section. Le nombre de section correspond à la taille de la
sortie.

64
 Figure 3.20 : Illustration du système de détection d‟objet utilisant un fast R-CNN

La raison pour laquelle Fast R-CNN est plus rapide que R-CNN est que l‟opération de convolution
n‟est effectuée qu‟une seule fois. [58] [60]

3.7.3 Faster R-CNN

Les deux méthodes R-CNN et fast R-CNN utilisent tous les deux la recherche sélective pour
rechercher les propositions de région qui est un processus lent et couteux en ressources. Faster R-
CNN remplace la recherche sélective par un réseau appelé Région Proposal Network (RPN) pour
générer des régions d‟intérêt.

Figure 3.21 : Illustration du système de détection d‟objet utilisant un faster R-CNN

3.7.3.1 Anchor
Faster RCNN introduit l‟idée d‟anchors, afin de gérer les variations de format d‟image et d‟échelle
des objets. Un anchors est une boite, dans la configuration d‟origine, Faster R-CNN utilise neuf
anchors pour chaque emplacement.

65
 Figure 3.22 : Illustration des anchors dans l‟emplacement (320,320)

La figure 3.22 montre neuf anchors dans la position (320,320) sur une image de taille (600,800).
Les trois couleurs représentent trois différentes tailles : , , .
Chaque couleur ont des rapports hauteur/ largeur de : 1:1, 1:2, 2:1.

3.7.3.2 Région Proposal Network

Le RPN doit donc vérifier quelles emplacements contiennent un objet, il prend en entrée la carte de
caractéristique et donne en sortie les emplacements du cadre de sélection et le score de confiance
des objets pour chaque emplacement. Dans un RPN, une fenêtre glissante est utilisée pour chaque
emplacement situé sur la carte de caractéristique et pour chacun de ces emplacements les 9 anchors
vus précédemment sont utilisés pour générer des propositions de régions. Chaque fenêtre glissante
est mappée sur un vecteur de dimension inférieure, 256-d pour la configuration d‟origine. Une
couche de classification génère 2k scores, qu‟il y ait un objet ou non et une couche de régression
produit 4k pour les coordonnées, k ici représente le nombre de boîtes.

Figure 3.23 : Illustration d‟un RPN

66
Pour une carte de caractéristique, de taille , le nombre total de anchors est de .

Les régions pouvant se chevaucher fortement, afin de réduire les redondances, la suppression non
maximale est utilisée sur des propositions de régions en fonction de leurs scores de classification, le
seuil de IOU est fixé à 0,7. [60] [61]

3.8 Conclusion
Les méthodes de détection d‟objet utilisant les CNN sont aujourd‟hui très populaires. Ces
techniques se démarquent par l'extraction et la hiérarchisation automatiques des features. Ils sont
également les plus performants et se sont toujours démarqués lors des compétitions comme
ILSVRC. Les CNN sont composés de plusieurs couches qui peuvent être disposées de façons
différentes afin de former différentes architectures. Cependant, concevoir un CNN en partant de
zéro n‟est pas envisageable pour tout un chacun car cela nécessite une puissance de calcul
phénoménale. Il faut alors se tourner vers une autre alternative qui est l‟apprentissage par transfert.
L‟apprentissage par transfert permet de modifier des modèles pré-entrainés comme celles de
détection d‟objet, pour la détection de nouveaux objets. Le chapitre suivant sera consacré à la
conception d‟une application basée sur l‟utilisation du transfert de connaissance sur un modèle de
détection d‟objet utilisant le Faster-RCNN.

67
 CHAPITRE 4
APPLICATION A LA CONCEPTION D’UN SMART STORE

4.1 Introduction
Face aux récentes avancées en termes de détection d‟objet et leurs applications dans le domaine du
commerce, notamment l‟évaluation de la disponibilité des stocks en magasin, l‟ajout d‟information
digitale sur les produits, les caisses intelligentes, on a choisi de dédier ce chapitre à la conception de
tels systèmes. Le système créé aura pour but d‟améliorer les qualités de services dans les magasins
et d‟offrir une nouvelle expérience d‟achat pour le client.

La partie théorique destinée à expliquer les concepts nécessaires à la compréhension d‟un système
de détection d‟objet utilisant les CNN ont été abordés dans les chapitres précédents. Ce dernier
chapitre a pour but d‟expliquer la conception d‟une étagère intelligente et d‟un système de caisse
intelligent basée sur les CNN afin de concrétiser les études menées préalablement.

Ce chapitre commencera par une présentation des environnements de développement, suivit des
outils utilisés, ensuite, des méthodes de développement et finalement, des tests de l‟application.

4.2 Présentation des environnements de développement utilisés

4.2.1 Environnement matériel

La conception et le déploiement de l‟application web servant d‟interface utilisateur a été effectuée
sur un ordinateur portable Hewlett-Packard avec les caractéristiques suivantes :

Processeur : Intel® Core ™ i5-3230M CPU @ 2,60 GHz.

RAM : 4,00 Go

Système d‟exploitation : Windows 8.

L‟entrainement et le déploiement du modèle de détection d‟objet ont été effectués sur un ordinateur
de bureau TAROX ayant les caractéristiques suivantes :

Processeur : Intel® Core ™ i3 CPU 540 @ 3,07 GHz.

RAM : 6,00 Go

GPU : NVIDIA GeForce GTX 950, compute capability 5.2

Mémoire video dédiée 2048 Mo

68
Mémoire système partagée 3035 Mo

Système d‟exploitation : Windows 10.

4.2.2 Environnement logiciel

L‟application a été développée sous Python 3 et en utilisant Sublime Text 3 comme éditeur de texte.
L‟installation de deux outils qui sont : CUDA (Compute Unified Device Architecture) et cuDNN
(CUDA® Deep Neural Network library) sont également nécessaires.

CUDA a été développé par NVIDIA en réponse aux demandes sans cesse croissantes de puissance
de calcul. Cette librairie, dévoilée en 2007, permet d'exploiter la puissance de calcul des GPU. Pour
fonctionner CUDA nécessite une carte graphique compatible. En effet, elle n'est que la partie
logicielle du tout.

cuDNN est une librairie accélérée par GPU pour les réseaux de neurones profonds. Elle fournit des
implémentations très optimisées pour les routines standards comme : les convolutions, pooling et
activation. [62] [63]

4.3 Principaux outils utilisés

4.3.1 Tensorflow
Tensorflow est un outil open source lancé en 2015 par Google pour aider les développeurs à
concevoir, créer et entrainer des modèles de deep learning. Une version stable 1.0 a été annoncée en
février 2017. Tensorflow est multiplateforme, il fonctionne sur les GPU, les CPU (central
processing unit) et même les TPU (TensorFlow Processing Unit) qui sont des matériels spécialisés
pour effectuer des calculs sur des tenseurs et permettant ainsi de faire profiter d‟une importante
accélération.

La particularité de Tensorflow est qu‟il permet de représenter les calculs sous la forme d‟un graphe
d‟exécution: chaque nœud représente une opération à réaliser et chaque lien représente un tenseur.
Les opérations peuvent aller des plus simples aux plus complexes. Les données dans Tensorflow
sont représentées par des tenseurs qui sont des tableaux multidimensionnels. Un exemple typique de
tenseur est un batch d‟images. Un batch d‟images est représenté par un tenseur à 4 dimensions:
taille du batch qui représente le nombre d‟images dans le batch, la hauteur, la largeur et le nombre
de canaux de représentation. De plus, Tensorflow possède un support très vaste d‟opérations
spécifiques au deep learning, ce qui donne la faculté de construire un réseau de neurones et

69
d‟utiliser les opérations mathématiques couramment associées pour l‟entraîner avec les bons
optimiseurs. L‟exécution du graphe doit être faite dans une session. Une session place les
opérations du graphe dans le CPU ou le GPU et donne également les méthodes permettant de les
exécuter. Pour lancer les opérations du graphe on utilise la méthode run() de la session.

Figure 4.01 : Représentation d’un graphe de calcul

Le plus important est qu‟il est possible de fractionner le graphe en morceaux et de les exécuter en
parallèle sur plusieurs CPU ou GPU. Il est également possible d‟entrainer des réseaux de neurones
gigantesques en un temps raisonnable en répartissant le calcul sur des centaines de serveurs.

Figure 4.02 : Illustration de calcul en parallèle sur plusieurs GPU

La représentation des calculs sous la forme d‟un graphe a plusieurs avantages :

70
  le graphe est portable, car il peut être exécuté tout de suite ou sauvegardé pour une
utilisation ultérieure. En outre, il peut être déployé en production sans avoir à dépendre du
code qui l‟a construit, mais uniquement du temps nécessaire à son exécution.
 le graphe peut être transformé pour produire une version plus optimale pour une plate-
forme donnée. En outre, des optimisations de mémoire ou de calcul peuvent être
effectuées. Ceci est utile, par exemple, pour l‟exécution sur des appareils mobiles.

Tensorflow propose également plusieurs modèles comme Tensorflow object detection API
(Application Programming Interface) qui est un framework open source construit sur Tensorflow.
La réalisation du projet est basée sur ce dernier. Il permet d'utiliser des modèles de détection
d'objets pré-entraînés ou d‟entrainer des modèles en utilisant l'apprentissage par transfert. [64] [65]
[66]

4.3.2 OpenCV
OpenCV ou Open Source Computer Vision est une bibliothèque contenant plus de 2500
algorithmes de vision par ordinateur. Il est accessible au travers d‟API pour plusieurs langages dont
Python qui est le principal langage de programmation utilisé dans ce projet. Initialement écrite en C
par des chercheurs de la société Intel, OpenCV est aujourd‟hui la bibliothèque de référence pour la
vision par ordinateur, aussi bien dans le monde de la recherche que celui de l'industrie.

En comparaison avec d‟autre langage comme C ou C++, Python est plus lent. Mais Python peut être
étendu avec C ou C++. Cette fonctionnalité aide à écrire des codes gourmands en termes de calculs
en C ou C++ et à créer un wrapper (une fonction qui est destinée à appeler une ou plusieurs autres
fonctions) Python pour pouvoir les utiliser en tant que modules. Le code est alors aussi rapide que
l‟original, puisqu‟il s‟agit d‟un code C++ travaillant en arrière-plan. Python-OpenCV fonctionne
ainsi, c‟est un warper Python sur une implémentation C++ originale. [67] [68]

4.3.3 Flask
Flask est un micro Framework de développement web écrit en Python. Il est livré avec : un moteur
de template qui est Jinja 2, un serveur web de développement werkzeug WSGI (Web Server
Gateway Interface), un système de distribution de requête compatible REST ou Representational
State Transfer, un support de débogage intégrer au serveur web, un micro Framework doté d‟une
très grande flexibilité, une très bonne documentation. Par défaut Flask n‟inclut pas : une solution
d‟authentification, le support de base de données etc. Cependant la grande flexibilité du micro

71
Framework permet l‟utilisation d‟extensions Flask couvrant ces manques apparents. Avec Flask il
est donc possible de choisir les extensions qui conviennent le mieux à un projet. [69]

4.4 Développement de l’application

Le développement de l‟application se divisera en deux grandes étapes : le développement de
l‟application de détection d‟objet et le développement d‟une application web.

4.4.1 Développement de l’application de détection d’objet

L‟application de détection d‟objet utilisera l‟apprentissage par transfert et permettra de détecter
quatre produits. Le développement de l‟application nécessitera plusieurs étapes.

4.4.1.1 Rassembler les données

Cette étape est vraiment cruciale pour le projet, la qualité et la quantité de données collectées
détermineront directement combien l‟application sera efficace ou non. Pour avoir de bon résultat,
on utilise de nombreuses images avec divers conditions d‟éclairages, la présence d‟objets autres que
ceux à détecter, ainsi que des arrières plans différents. Il doit également avoir des images
partiellement visibles donc masquer par quelque chose d‟autre. Idéalement chaque classe d‟objet
nécessite plus d‟une centaine d‟images.

On a utilisé 154 images par produits et environs 100 images montrant plusieurs produits ensembles.

Figure 4.03 : Extrait d’images utilisées

Les dimensions des images doivent être réduites pour plus de rapidité durant le processus
d‟entrainement. Les images dont on a besoin sont maintenant à disposition, 80% d‟entre eux seront

72
utilisées pour apprentissage et 20% pour l‟évaluation. La séparation des données permet d‟éviter le
surapprentissage.

4.4.1.2 Etiquetage des données

L‟étiquetage des données se fait à partir de LabelImg qui est un outil d‟annotation d‟image écrit en
python et utilise Qt pour son interface graphique. Les étiquettes sont alors sauvegardées sous format
xml pour chaque image.

Figure 4.04 : Etiquetage des données

Pour créer le cadre de sélection on utilise le bouton « Create RectBox », après la sélection,
l‟annotation correspondante est ajoutée.

4.4.1.3 Générer les données d‟apprentissage

Après l‟étiquetage de toutes les images d‟apprentissage et d‟évaluation, les annotations seront
converties au format TFrecords pour servir d‟entrée au modèle d‟apprentissage. Le format TFrecord
est un format simple permettant de stocker une séquence d‟enregistrement binaire, il est propre à
Tensorflow. L‟avantage de ce format est que les données binaires occupent moins de place sur le
disque, elles prennent également moins de temps à copier.

La conversion au format TFrecord nécessite la conversion des fichiers individuels au format xml en
un fichier unique au format csv. C‟est ce fichier qui sera converti au format TFrecord pour chaque
jeu de données. Pour ce faire on doit lire dans le fichier csv un exemple à la fois, le formater en
utilisant tf.train.Exemple() puis imprimer cet exemple dans un fichier sur le disque. Chaque
« tf.train.Exemple » stocke des informations sur l‟exemple en particulier via des fonctions. Chaque

73
caractéristique sera alors stocker entant qu‟élément d‟un dictionnaire, la clé devant être descriptive.
L‟écriture des exemples dans un fichier TFrecord se fait par la classe tf.io.TFRecordWriter via
la méthode write().

Figure 4.05 : Extrait du fichier csv pour les données de test

4.4.1.4 Construction du Label Map

Tensorflow nécessite un Label Map, qui mappe chacune des étiquettes utilisées à une valeur entière.
Ce Label Map est à la fois utilisé durant le processus d‟apprentissage et de détection. C‟est un
fichier dont l‟extension est au format pbtxt. Voici un extrait du Label Map qu‟on a utilisé :

item {
id: 1
name: 'EauVive'
}

item {
id: 2
name: 'Mira'
}(…)

4.4.1.5 Configuration d‟un pipeline d‟apprentissage

Le pipeline d‟apprentissage définit quel modèle et quels paramètres seront utilisés. Les chercheurs
et les Data Scientist ont créés divers modèles au fil des années dont plusieurs sont répertoriés dans
le modèle de détection zoo de Tensorflow. On a utilisé le modèle Faster_rcnn_inception_v2 _coco
2018_01_28, car il fournit un compromis relativement intéressant entre performance et vitesse. Ce
modèle a été entrainé sur le Microsoft Common Objects in COntext Dataset ou MSCOCO dataset.

74
Le MSCOCO dataset contient 91 catégories d‟objets communs avec 82 d'entre eux ayant plus de 5
000 instances étiquetées. Au total, le jeu de données contient 2500000 instances étiquetées dans
328000 images. [70]

Le projet ne consiste pas à détecter des objets dans ce dataset mais à utiliser l‟apprentissage par
transfert pour la détection de nouveaux objets. Il est donc nécessaire de modifier l‟exemple de
fichiers de configuration procuré par Tensorflow object detection api. Tensorflow object detection
api donne accès à plusieurs fichiers de configuration de pipeline, celui qui est spécifique au modèle
Faster_rcnn_inception_v2 _coco sera utilisé. Dans ce fichier les différentes sections suivantes
doivent être modifiées :

faster_rcnn {
num_classes: 90
image_resizer {
keep_aspect_ratio_resizer {
min_dimension: 600
max_dimension: 1024
}
}

Le num_classes d‟origine est de 90 et doit être remplacé par le nombre de classe utilisé. Dans
notre cas, cela est au chiffre 4 et qui correspond au nombre de catégorie d‟objet.

La variable fine_tune_checkpoint doit être également modifiée. Elle indique le chemin d‟accès
au modèle qui servira pour l‟apprentissage par transfert. Initialement, elle se présente comme suit :

fine_tune_checkpoint: "PATH_TO_BE_CONFIGURED/model.ckpt"

Le chemin d‟accès au fichier train.record, qui contient les données d‟entrée utilisées pour
l‟entrainement et le chemin d‟accès au Label Map doivent être également spécifiés. Ainsi que le
chemin d‟accès au fichier test.record, qui lui contient l‟ensemble des données d‟évaluation.

On doit donner le nombre d‟exemple pour l‟évaluation, ici on a utilisé 169 exemples :

eval_config: {
num_examples: 169
…
}

4.4.1.6 L‟entrainement du modèle

L‟entrainement du modèle utilise un script fourni par Tensorflow object detection api. L‟exécution
de ce script nécessite l‟accès au fichier de configuration du pipeline d‟apprentissage ainsi que du
dossier où les enregistrements durant l‟apprentissage seront placés.

75
Une fois le script lancé, il est possible de suivre la progression de l‟apprentissage :

Figure 4.06 : Progression de l‟apprentissage

Le global step représente l‟itération, cela correspond donc à une mise à jour du gradient de la
fonction de coût, loss ici représente l‟erreur correspondant à chaque itération. L‟application de la
mise à jour se fait par la méthode suivante :

grad_updates = training_optimizer.apply_gradients()

Au début le loss aura une valeur élevée est baissera au fur et à mesure que l‟entrainement avance.
Tensorflow inclus une suite d‟outil de visualisation nommée Tensorboard qui permet le suivi du
travail d‟apprentissage avec plus de détails. La figure 4.07 montre le loss en fonction du global
step vue dans tensorboard :

Figure 4.07 : Progression de l‟apprentissage dans tensorboard

Des points de contrôle sont sauvegardés toutes les 5 minutes, pour éviter de remplir le disque, on ne
conserve que les fichiers les plus récents. La méthode suivante permet la sauvegarde des fichiers :

keep_checkpoint_every_n_hours = train_config.keep_checkpoint_every_n_hours
saver = tf.train.Saver(keep_checkpoint_every_n_hours =
keep_checkpoint_every_n_hours)

76
4.4.1.7 Exporter le graphe d‟inférence
Une fois l‟apprentissage fini, on doit extraire le graphe d‟inférence nouvellement formé. Il sera
utilisé pour effectuer la détection d‟objet. Tensorflow stocke la structure du graphe séparément des
valeurs des variables. Après la sauvegarde du modèle, on aura 4 fichiers :

 Model.cpkt.meta : contient le graphe complet.

 Model-ckpt.data-0000-of-00001 : contient toutes les valeurs des variables.
 Model-ckpt.index : C‟est une table immuable dont chaque clé représente le nom d‟un
tenseur et sa valeur un BundleEntryProto séréalisé.
 Checkpoint : toutes les informations de point de contrôle, telles que le nom et le chemin du
fichier model ckpt.

Un BundleEntryProto séréalisé contient les métadonnées des tenseurs : lequel des fichiers « data »
contient le contenu d‟un tenseur, le décalage dans ce fichier, la somme de contrôle ect.

Pour conserver toutes les valeurs des variables et du graphe dans un seul fichier, on fait un freezing.
Le freezing est une opération permettant d‟identifier et de sauvegarder toutes les choses requises
lors du déploiement du modèle dans un seul fichier facilement utilisable.

Le script d‟exportation du graphe d‟inférence est également fourni par Tensorflow object detection
api. En interne, le script commence une session et y restaure les poids du graphe à l‟aide de la
fonction :

saver.restore(sess, input_checkpoint).

Ensuite, toutes les variables du graphe sont remplacées par des constantes de mêmes valeurs en
utilisant :

graph_util.convert_variables_to_ constants ().

Enfin, le graphique est exporté dans le système de fichier :

with gfile.GFile(frozen_graph_path, 'wb') as f:

f.write(frozen_graph_def.SerializeToString())

On obtient ainsi un nouveau fichier, d‟extension .pb.

4.4.1.8 Lancement de la détection

Le modèle étant maintenant près à l‟emploi, on l‟utilisera pour détecter les produits directement via
le flux vidéo d‟une webcam.

77
Pour commencer on charge le frozen graphe en mémoire :

detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')

On charge également le Label Map, le label map fait correspondre les indices à des noms. Par
exemple dans le cas du projet: si le réseau prédit «1 » cela indique EauVive.

label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)

Les tenseurs d‟entrées et de sorties sont ensuite définis, la méthode get_tensor_by_name retourne
un tenseur du même nom ; le nom des tenseurs sont déjà défini par défaut lors de l‟opération de
freezing.

#Tenseur d'entrée
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')

#Tenseur de sortie
#chaque "boxes" représente une partie de l'image ou un objet a été détecté.
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
#Chaque score représente le niveau de confiance pour chacun des objets.
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
num_detections = detection_graph.get_tensor_by_name('num_detections:0')

On initialise une boucle infinie et on capture la vidéo, frame par frame :

while True:
#Capture frame par frame
ret, frame = cap.read()

#pas de frame (ret = false)

if not ret:
print("fin de la video...")
break

La détection sera effectuée en exécutant le modèle avec les frames en entrée :

(boxes, scores, classes,num) = sess.run([detection_boxes, detection_scores,

detection_classes,num_detections],
feed_dict = {image_tensor: image_np_expanded})

Pour la visualisation des résultats sur l‟image (cadre, scores, classe…), on va utiliser la méthode :

vis_util.visualize_boxes_and_labels_on_image_array()

78
Cette méthode retourne également une variable « counting_mode » contenant la liste des objets
détectés et leurs nombres. La méthode suivante permet de mettre le texte contenu dans
counting_mode sur l‟image :

cv2.putText(input_frame, counting_mode, (10, 35), font, 0.8, (0,255,255),2,cv2

.LINE_AA)

Finalement, la vidéo est affichée et les données contenues sont envoyées pour la mise à jour de la
base de données contenant le nombre de produits.

4.4.2 Développement de l’application web

L‟application web présentera l‟interface utilisateur et utilisera les données calculées lors de la phase
de détection. Dans ce projet, Mysql sera utilisé comme système de gestion de base de données, à
cause de sa popularité et de son accessibilité en écriture par le langage de programmation python.
L‟application sera composée de trois pages principales : une pour la modification manuelle de la
base de données, une autre liée directement à l‟étagère, c‟est-à-dire l‟affichage des produits et de
leurs caractéristiques et une dernière pour l‟utilisation du système comme une smart caisse.

4.4.2.1 Opérations sur la base de données

La première chose à faire est de créer la base de données « smartstore » et la table « produits » dans
phpmyadmin. La table « produits » a comme attributs : nom, nombre, prix, rayon, et image.
L‟application créée doit autoriser l‟ajout, la mise à jour et la suppression des données dans la base
de données.

Pour commencer on doit configurer les paramètres suivants :

app.config['MYSQL_HOST']='localhost'
app.config['MYSQL_USER']='root'
app.config['MYSQL_PASSWORD']=''
app.config['MYSQL_DB']='Smartstore'

On instancie un objet de la classe MySQLCursor pouvant exécuter des opérations telles que des
instructions SQL :

cur = mysql.connection.cursor()

L‟ajout d‟un enregistrement se fait à l‟aide de la méthode suivante :

cur.execute("INSERT INTO Produits(Nom, Nombre, Prix, Rayon, Image) VALUES(%s,

%s, %s, %s, %s)", (Nom, Nombre, Prix, Rayon, image))

La mise à jour d‟une la table se fait par :

79
 cur.execute("""
UPDATE produits
SET nom=%s, nombre=%s, Prix=%s, rayon=%s, image=%s
WHERE id=%s
""", (Nom, Nombre, Prix, Rayon, image, id_data))

La suppression des données se fait en exécutant la méthode:

cur.execute("DELETE FROM produits WHERE id=%s", (id_data,))

A chaque changement effectué sur la base de données, on utilise la méthode :

mysql.connection.commit()

Cette méthode permet de confirmer les modifications apportées.

On ferme la connexion en utilisant :

Cur.close

4.4.2.2 Le système créé

Dans ce sous paragraphe, on va voir l‟élaboration d‟un système d‟inventaire automatique
permettant de donner la description de chaque produit sur une étagère, ainsi que d‟un système de
calcul automatique de prix.

Pour commencer, on a élaboré une fonction permettant de mettre automatiquement à jour la base de
données. Les données reçues par l‟application web contiennent la liste des noms et des nombres des
produits sur l‟étagère, ce qui permet de mettre à jour la base de données. La méthode suivante est
utilisée pour l‟acquisition des données :

updata = json.loads(request.data)

Ici, il est mieux de préciser que les données ne sont envoyées que s‟il y a un changement perçu.

Dans la page qui gère l‟étagère, on prend alors les données dans la base de données et on les places
dans une variable :

cur = mysql.connection.cursor()
cur.execute("SELECT * FROM produits")
data = cur.fetchall()
cur.close()

80
Ces données seront affichées dans un tableau qui sera rafraîchi automatiquement et rendra possible
la visualisation en temps réel des produits présents sur l‟étagère. L‟application donne également des
informations sur le produit sélectionné par le client du magasin, cela se fait à l‟aide d‟image.

La page qui gère la caisse intelligente est légèrement différente :

cur = mysql.connection.cursor()
cur.execute("SELECT * FROM produits where nombre != 0")

Ici, seuls les produits présents sont comptabilisés, la somme est alors calculée.

4.5 Test de l’application

Dans ce paragraphe, le fonctionnement et les différents tests de l‟application seront présentés.

4.5.1 Mode de fonctionnement

L‟application créée sera utilisée pour l‟inventaire des produits, l‟ajout d‟information digitale et en
tant que caisse automatique.

Le système est constitué d‟une application de détection d‟objet et d‟une application web servant
d‟interface utilisateur. L‟application de détection d‟objet sert à identifier et compter les différents
produits. Une caméra permet l‟acquisition de la vidéo qui sera traitée afin de distinguer les
différents éléments à détecter. Une fois les informations sur les différents objets collectées (le
nombre et le nom de chaque produit) et à chaque changement perçu sur l‟étagère, les données seront
transmises sous un format json à l‟application web.

L‟exploitation des informations contenues dans les données transmises permet alors de concevoir le
système. Le système est capable d‟effectuer l‟inventaire en temps réel des produits, de l‟afficher
sous forme d‟un tableau et de donner un surplus d‟information sur chaque produit. Il peut être
également utilisé comme une caisse automatique, les produits sont présentés à la caméra et le total
des prix sont comptabilisés.

Le mode de fonctionnement de l‟application est illustré par la figure 4.08.

81
 Figure 4.08 : Mode de fonctionnement globale du système

4.5.2 Présentation sous forme d’image

La figure 4.09 illustre les produits que l‟on va soumettre au système, on a utilisé les quatre produits
pouvant être détectés par le système.

Figure 4.09 : l‟image captée par la caméra

Une webcam est utilisée pour l‟acquisition des images. Une fois les images captées par la caméra,
elles seront traitées par le système de détection.

82
 Figure 4.10 : Illustration de la détection effectuée par le système

La figure 4.10 indique le nom, le nombre ainsi que le score de confiance de chaque objet. Les
données sont envoyées à l‟application web et sont ensuite traitées. La figure 4.11 affiche le nom et
le nombre de chaque produit sous forme de tableau, ainsi que de l‟information digitale concernant
chaque produit. Le produit dont on veut obtenir plus d‟information doit être soumis à la caméra.

Figure 4.11 : Interface permettant la visualisation des produits

La figure 4.12 illustre la page de modification de la base de données, elle permet l‟ajout, la
suppression ainsi que la modification de la base de données.

83
 Figure 4.12 : Interface permettant la modification de la base de données

La figure 4.13 montre l‟utilisation du système en tant que smart caisse, les produits soumis à la
caméra sont comptabilisés, le coût total est alors affiché.

Figure 4.13 : Interface permettant l‟utilisation comme une smart caisse

84
Conclusion
La détection d‟objet trouve son utilité dans de nombreux domaines notamment dans le secteur du
commerce, les magasins subissent aujourd‟hui de grands bouleversements. Le deep learning est un
outil essentiel pour l‟entrer des magasins dans l‟ère du Phygital. C‟est dans ce cadre qu‟on a choisi
de s‟orienter dans ce domaine pour la conception d‟une application de détection d‟objet basée sur
les CNN, donnant une alternative pour améliorer la qualité de service. L‟application conçue
comprend un système d‟évaluation de la disponibilité des stocks en magasin, de l‟ajout
d‟information digitale sur les produits, ainsi que d‟un système de caisse intelligent. Le
développement de cette application a nécessité plusieurs outils et étapes. Les applications
présentées ici sont très restreintes, cependant, les méthodes vues dans ce chapitre sont applicable à
la conception de n‟importe quels systèmes de détection d‟objet.

85
 CONCLUSION GENERALE

L‟augmentation permanant de la puissance des ordinateurs actuels ainsi que la grande disponibilité
des données ont permis l‟émergence du deep learning. Le deep learning est aujourd‟hui très
sollicité, ce mémoire a permis une démystification totale du terme et en a donné une meilleure
compréhension. Il a également mis en avant la possibilité de son utilité dans le secteur du commerce
afin de résoudre les problèmes rencontrés dans les magasins physiques et apporter une meilleure
qualité de service. Le deep learning pousse le commerce vers une nouvelle ère : la mutation des
magasins physiques sous l‟ère digitale ou « le phygital ». Pour permettre la fusion du monde
physique avec le digital, la vision par ordinateur constitue un atout essentiel.

Une des principales applications de la vision par ordinateur est la détection d‟objet. Depuis de
nombreuses années, les scientifiques ont cherché des moyens efficaces pour obtenir de bons
résultats dans ce domaine. Les méthodes comme celle de Viola et Jones ou les HOG ont été la
référence pendant plusieurs années. Elles ont permis un tournant majeur dans le problème de
détection d‟objet. Mais en 2012, le mariage du deep learning avec cette discipline, les détrône et
met en avant les CNN.

Aujourd‟hui, les méthodes de détection d‟objet basées sur les CNN sont les plus performants. Ce
sont des réseaux de neurones spécialement conçus pour le traitement d‟image. Ils sont composés de
plusieurs couches qui peuvent être agencées de différentes manières afin de donner divers
architectures. La conception d‟un CNN en partant de zéro n‟est cependant pas envisageable car cela
serait trop gourmand en ressource, l‟apprentissage par transfert permet de résoudre ce problème.
Dans ce mémoire, on a utilisé l‟apprentissage par transfert sur un réseau de détection d‟objet de la
famille des R-CNN qui est le Faster RCNN.

L‟application conçue pour la mise en pratique des connaissances acquises dans la partie théorique
permet l‟évaluation de la disponibilité des stocks dans un magasin, l‟ajout d‟information digitale sur
les produits ainsi que l‟utilisation d‟une caisse intelligente. Ce système présente un grand nombre
d‟intérêt car il peut être utilisé comme base d‟un autre système plus spécifique.

Il faut dire que des améliorations peuvent encore être apportées à ce système, notamment l‟ajout
d‟un système de notification instantané ou encore un système de recommandation de produit basée
sur une connaissance du client. Ces améliorations peuvent faire l‟objet d‟une autre étude.

86
 ANNEXE 1
NOTIONS SUPPLEMENTAIRES

A1.1 Rétropropagation du gradient

Soit le couple ( ⃗( ) ⃗( )) désignant la n-ième donnée d‟entrainement du réseau où:

⃗( ) ( ) ( ) ( ) (A1.01)

⃗( ) ( ) ( ) ( ) (A1.02)

correspondent respectivement aux p entrées et aux q sorties désirées du système et ⃗( ) la sortie

observée :

⃗( ) ( ) ( ) ( ) (A1.03)

L‟algorithme de rétropropagation permet de calculer l‟erreur entre les sorties désirées et observées
résultant de la propagation vers l‟avant des entrées ⃗( ) et de rétropropager cette erreur à travers les
couches du réseau en allant des sorties vers les entrées.

Cas de la couche de sortie :

L‟algorithme de rétropropagation procède à l‟adaptation des poids neurone par neurone en

commençant par la couche de sortie. Soit l‟erreur observée ( ) pour le neurone de sortie j
correspondant à la donnée d‟observation n :

( ) ( ) ( ) (A1.04)

Ici ( ) est la sortie désirée du neurone j et ( ) la sortie observée, l‟indice j représentera

toujours le neurone pour lequel on veut adapter les poids. L‟objectif est de minimiser la somme des
erreurs sur tous les neurones de sortie en adaptant les poids de connections.

Considérons la somme des erreurs quadratiques observé sur l‟ensemble C des neurones de sortie :

(A1.05)
( ) ∑ ( )

La sortie ( ) est définie par :

( ) [ ( )] (A1.06)

87
Avec

( ) ∑ ( ) ( ) : la somme pondérée de l‟entrée du neurone j,

: la fonction d‟activation du neurone,

( ) : le poids de connexion entre le neurone i de la couche précédente et le neurone j de la

couche courante,

( ) : la sortie du neurone i.

On suppose que la couche précédente contient r neurones numérotés de 1 à r, que le neurone ( )

correspond au biais du neurone j et que l‟entrée ( )

Figure A1.01 : Représentation du neurone j

( )
Pour minimiser l‟erreur, on va modifier les poids ( ) dans le sens opposé du gradient
( )

de l‟erreur. Cette dérivée représente un facteur de sensibilité : si on change un peu ( ), comment

cela va affecter ( ) ? On agira donc en conséquence.

On va décomposer l'erreur grâce au théorème de dérivation des fonctions composées énoncé comme
suit :

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, autrement dit :

(A1.07)

D‟où l‟erreur devient :

88
 ( ) ( ) ( ) ( ) ( ) (A1.08)
( ) ( ) ( ) ( ) ( )

La variation du poids est exprimée sous la forme :

( ) (A1.09)
( )
( )

représente le taux d‟apprentissage.

Calculons chacun des termes de l‟équation A1.08 :

 Premier terme :

( ) 0 ∑ 1
( ) ( )

( ) ( ) (A1.10)
( )
( ) ( )

 Le deuxième terme :

( ) [ ( ) ( )] (A1.11)
( ) ( )

 Le troisième terme :

( ) , ( )-

( ) ( )

( )
( )
( ) [ ( )
]

( )
( )
( )
( ) ( )
[ ]

89
 ( )
( )
( )[ ]
( ) ( ) ( )
[ ] [ ]

( ) (A1.12)
( ), ( )-
( )

Ici la fonction d‟activation utilisée est la fonction sigmoïde.

Finalement, le quatrième terme :

( ) [∑ ( ) ( )]
( ) ( )

( ) , ( ) ( )-
( ) (A1.13)
( ) ( )

L‟équation A1.08 devient donc :

( ) (A1.14)
( ) ( )[ ( )] ( )
( )

La règle dite du delta de la couche de sortie s‟exprime par :

( ) ( ) ( ) (A1.15)

Avec ( ) ( ) ( )[ ( )] (A1.16)

( ) exprime le gradient local.

Cas des couches cachées :

L‟objectif sera toujours d‟adapter les poids de la couche courante en minimisant la somme des
erreurs sur les neurones de la couche de sortie. L‟indice k désigne un neurone sur la couche
suivante. Comme ( ) est inconnue pour les couches cachées l‟expression de la dérivée partielle
de l‟erreur totale devient :

( ) ( ) ( ) ( ) (A1.17)
( ) ( ) ( ) ( )

Seul le premier terme diffère des calculs précédents.

90
 0 ∑ ( )1 (A1.18)
( )
( ) ( )

Le problème vient du fait que tous les ( ) dépendent de ( ):

0 ∑ ( )1 ( )
∑[ ( ) ]
( ) ( )

( ) ( ) ( )
∑[ ( ) ] ∑[ ( ) ]
( ) ( ) ( )

( ) ( ) [ ( ) ( ( ))] ,∑ ( ) ( )- (A1.19)
∑[ ( ) ] ∑[ ( ) ]
( ) ( ) ( ) ( )

D‟où l‟équation A1.19 devient :

∑[ ( )( ( ), ( )-) ( )] (A1.20)

Et en utilisant l‟équation A1.16 :

∑[ ( )( ( ), ( )-) ( )] ∑ ( ) ( ) (A1.21)

Finalement, en substituant A1.21 dans A1.17 :

( ) (A1.22)
( ), ( )- [∑ ( ) ( )] ( )
( )

Et on a :

( ) (A1.23)
( ) ( ) ( )
( )

Avec : ( ), ( )-[∑ ( ) ( )]
(A1.24)

Notons que dans le cas de la première couche cachée du réseau, puisqu‟il n‟y a pas de couche
précédente de neurones, il faut substituer la variable ( ) par l‟entrée ( ). [19]

91
A1.2 Intersection Over Union
Soit un algorithme qui produit un cadre de sélection (noté A) pour un objet. L‟Intersection Over
Union montre combien la prédiction est proche de la vérité (noté B). Pour ce faire, on divise
l‟intersection de A et B par l‟union de A et B. Si IOU est supérieure à un certain seuil, la prédiction
est considérée comme correcte, sinon on doit travailler d‟avantage sur l‟algorithme. [71]

Figure A1.02 : Calcul de l’IOU

L‟illustration de cette idée est donnée par la figure A1.03 :

Figure A1.03 : Illustration de l’idée de IOU

92
 ANNEXE 2
EXTRAITS DE CODES SOURCES

A2.1 Redimensionnement des images

def resize():
for item in dirs:
if os.path.isfile(path+item):
im = Image.open(path+item)
f, e = os.path.splitext(path2+item+'.jpeg')
imResize = im.resize((900,506), Image.ANTIALIAS)
imResize.save(f, 'jpeg', quality=80)
print('resize '+ path2+item )

A2.2 Envoi des données Json

def send_data(Jsondata):
url = "http://192.168.119.1:5000/autoupdate"
#indique le format de la demande et de la réponse autorisée
headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
r = requests.post(url, data=Jsondata, headers=headers)

A2.3 Mise à jour automatique de la Base de données

def autoupdate():
cur = mysql.connection.cursor()
cur.execute("SELECT nom FROM produits")
myresult = cur.fetchall()
#prend les données dans request en python dictionnary
updata = json.loads(request.data)
#noms dans bdd (tupple to list)
Bdd_list=[]
for i in myresult:
x = ''.join(i)
Bdd_list.append(x)
#noms dans updata
updata_list=[]
for key in updata.keys():
updata_list.append(key)
cur.execute("""
UPDATE produits
SET nombre=%s
WHERE nom=%s
""", (updata[key], key))
#listes des non Mise à jour
zero_list = list(set(Bdd_list) - set(updata_list))
for j in zero_list:
cur.execute("""
UPDATE produits
SET nombre=%s
WHERE nom=%s
""", (0, j))
mysql.connection.commit()
cur.close()
return redirect(url_for('Index'))

93
A2.4 Calcul des prix pour la caisse
def caisse():
cur = mysql.connection.cursor()
cur.execute("SELECT * FROM produits where nombre != 0")
data = cur.fetchall()
cur.close()
a = []
#calcul total prix
for i in data:
multi = i[2]*i[3]
a.append(multi)
total=sum(a)
return render_template('caisse.html', nom=data, total=total)

A2.5 Code html de la page pour l’affichage du tableau

<table id= "table1" class="table">
<tr>
<th>Nom</th>
<th>Nombre</th>
<th>Prix</th>
</tr>

{%for row in nom%}

<tr>
<td>{{row.1}}</td>
<td>{{row.2}}</td>
<td>{{row.3}}</td>
</tr>
{%endfor%}
</table>

A2.6 Code permettant de charger les informations sur les produits

<div id="refresh_imag" style="text-align: center">
<div id="imag" class="row">
<a><img src={{path}} img alt="" class="img-thumbnail" ></a>
</div>
</div>

94
 BIBLIOGRAPHIE

[1] A. Mercier, « L’information face à l’intelligence artificielle : promesses et dangers »

https://larevuedesmedias.ina.fr/linformation-face-lintelligence-artificielle-promesses-et-dangers, 05
février 2018.

[2] A. Géron, « Machine Learning avec Scikit-Learn », Dunod : Paris, 2017.

[3] M. Taffar, « Initiation à l’apprentissage automatique », Cours Master, Ment Informatique-

Faculté des Sciences Exactes et de l‟Informatique.

[4] Y. Benzaki, « Machine Learning made easy », https://mrmint.fr/, 2019.

[5] J. B. Metomo, « Machine Learning : Introduction à l'apprentissage automatique »

https://www.supinfo.com/articles/single/6041-machine-learning-introduction-apprentissage-
automatique, 10 octobre 2017.

[6] I. Bellin, N. Vayatis, J. Audiffren, S. Peignier A. Nicolai « Apprentissage par renforcement »,

https://dataanalyticspost.com/Lexique/apprentissage-par-renforcement, Fevrier 2019.

[7] M. Zaffagni, « Cette IA a appris à conduire une voiture autonome en 20 minutes »,

https://www.futura-sciences.com/tech/actualites/intelligence-artificielle-cette-ia-appris-conduire-
voiture-autonome-20-minutes-71942/, 09 Juillet 2018.

[8] J. Brownlee, « Difference Between Classification and Regression in Machine Learning »,

https://machinelearningmastery.com/classification-versus-regression-in-machine-learning/,
décembre 2017.

[9] G. Idiou, « Régression et modélisation par les réseaux de neurones », Mémoire de Magistère,
Université Mentouri-Constantine, Faculté des sciences exactes, Département mathématique, juin
2009.

[10] E. Biernat, M. Lutz, Y. LeCun, « Data science fondamentaux et études de cas », Eyrolles :
Paris, 2015.

[11] J. Y Baudot, « Les distances », http://www.jybaudot.fr/Analdonnees/distances.html, Mars

2019.

[12] J. Grus, « Data science par la pratique Eyrolles », Eyrolles : Paris, 2017.

95
[13] B. Sarra, K. Ikram, « Algorithmes de classification pour la prévision des maladies agricoles »,
Mémoire de Master, Ecole Nationale Supérieure d‟informatique, Option Système informatique,
2017.

[14] M. J. Vieille, « k-means, comment ça marche? », https://lovelyanalytics.com/2016/09/06/k-

means-comment-ca-marche/, 6 septembre 2016.

[15] O. Horiya, M. Asma,« Classification non supervisée : Application de k-means », Mémoire de

Licence, Université Abou Bakr Belkaid– Tlemcen, Faculté de Technologie, Département
d‟Informatique, Juin 2014.

[16] « Les réseaux de Neurones Artificiels », Cours, Université de M‟SILA, Faculté des Sciences et
Sciences de l'Ingénieur, Département d'électrotechnique, 2006.

[17] V. Mathivet, « L'Intelligence Artificielle pour les développeurs », Eni : France, Décembre
2014.

[18] A. Azencott, « Utilisez des modèles supervisés non linéaires », https://openclassrooms.com/

fr/courses/4470406-utilisez-des-modeles-supervises-non-lineaires/, 31 Mai 2019.

[19] M. Parizeau, « Le perceptron multicouche et son algorithme de rétropropagation des

erreurs », Université Laval, Département de génie électrique et de génie informatique, Septembre
2004.

[20] Y. LeCun, « Les Enjeux de la Recherche en Intelligence Artificielle », Chaire Informatique et

Sciences Numériques Collège de France, AU : 2015-2016.

[21] M. Tual, « Comment le deep learning révolutionne l'intelligence artificielle »,

https://www.lemonde.fr/pixels/article/2015/07/24/comment-le-deep-learning-revolutionne-l-
intelligence-artificielle_4695929_4408996.html, 24 juillet 2015.

[22] M. D. Youcef, « Deep Learning pour la classification des images », Mémoire de Master,
Université Abou Bakr Belkaid Tlemcen, Faculté des sciences, Département informatique, 2017.

[23] « Neurones à Convolution 3 choses à savoir », https://fr.mathworks.com/solutions/deep-

learning/convolutional-neural-network.html, 2019.

96
[24] P. Monasse, K. Nadjahi, « Classez et segmentez des données visuelles»,
https://openclassrooms.com/fr/courses/4470531-classez-et-segmentez-des-donnees-visuelles, Mai
2019.

[25] S. Soudoplatoff, « L’intelligence artificielle : l’expertise par tout accessible à tous »,

fondapol : Paris, Février 2018.

[26] « Google cars self-drive to Walmart supermarket in trial », https://www.bbc.com/news/

technology-44957251, 25 Juillet 2018.

[27] F. Fauconnier, « Le magasin sans caisse Amazon Go s’ouvre au public », https://www.lsa-

conso.fr/le-magasin-sans-caisse-amazon-go-s-ouvre-au-public,278202, 22 Janvier 2018.

[28] R. Horaud, O. Monga, « Vision par ordinateur : outils fondamentaux », Hermès, 1995.

[29] Pierre-Julien Grizel, « La vision par ordinateur », https://www.numericube.com/la-vision-par-

ordinateur, 22 Novembre 2017.

[30] M. M. Zakaria, « Classification des images avec les réseaux de neurones convolutionnels »,
Mémoire de Master, Université Abou Bakr Belkaid Tlemcen, Faculté des sciences, Département
informatique, 03 Juillet 2017.

[31] J. Damerji, « Image numérique », https://padlet.com/jihen_damerji/l5ssy7n90oj8, 2018.

[32] M. A. Rakotomalala, « Traitement Numérique des Images », Cours M1- TCO, Ment. TCO.-
E.S.P.A., A.U. : 2016-2017.

[33] R. Isdant, « Traitement numérique de l'image », cours, 2009.

[34] A. L. Jacquart, « Le contraste en photographie : prise de vue, traitement, expressivité »

http://www.questionsphoto.com/le-contraste-en-photographie-prise-de-vue-traitement-expressivite,
31 Janvier 2011.

[35] A. Branco, « Photo : qu'est-ce que le bruit numérique? », https://www.01net.com/astuces/

quest-ce-que-le-bruit-numerique-632881.html, 19 Novembre 2014.

[36] H. Mathieu, « La chaîne de l’acquisition d’image », Cours IRIA, Janvier 2009.

[37] J. Six, L. Meignan, « Les capteurs ccd/cmos », https://pdfslide.fr/documents/jerome-six-leo-

meignan-licence-professionnelle-2009-pour-cette-invention.html, 2009.

97
[38] B. Djemaa, « Résolution de problèmes par écosystèmes : Application au traitement
d’images », Mémoire de Magistère, Universite Mohamed Khider Biskra, Faculté des Sciences et
des Sciences de l‟Ingénieur, Département Informatique, 2005.

[39] F. Legrand, « Extraction de régions », http://www.f-legrand.fr/scidoc/docmml/image

/extraction/regions/regions.html, 2019.

[40] J. F. Pillou, « Introduction au traitement d’image », https://www.commentcamarche.net/

contents/1216-traitement-d-images, 16 décembre 2016.

[41] H. Faigner, « Traitement d'image : Pré-traitements », https://docplayer.fr/amp/7695164-

Chapitre-iii-traitement-d-image-pre-traitements.html, 2019.

[42] M. Kruger, « Image Segmentation in Deep Learning: Methods and Applications »,

https://missinglink.ai/guides/neural-network-concepts/image-segmentation-deep-learning-methods-
applications/, 2019.

[43] « Segmentation sémantique », https://fr.mathworks.com/solutions/image-video-processing/

semantic-segmentation.html, 2019.

[44] S. H. Tsang, « Review: DeepMask Instance Segmentation », https://towardsdatascience.com/

review-deepmask-instance-segmentation-30327a072339, 19 Décembre 2018.

[45] « Outils fondamentaux en traitements d’images», cours M2- INSA, Ment. Mention optique,
image, vision, multimédia- INSA. AU : 2018-2019.

[46] K. Bouchra, « Mise au point d’une application de reconnaissance faciale », Mémoire de

Master, Université Abou Bakr Belkaid – Tlemcen, Faculté des Sciences, Département Informatique,
28 novembre 2013.

[47] S. Zhao, « Apprentissage et Recherche par le Contenu Visuel de Catégories Sémantiques

d'Objets Vidéo », Mémoire de Master, Université Paris Descartes, Informatique - parcours Images,
Juillet 2007.

[48] B. Chahrazed, B. Afef, « La détection des visages », Mémoire de Master, Université Larbi Ben
M‟hidi Oum El Bouaghi, Faculté des sciences, Département de mathématiques et Informatique,
Option : Vision Artificielle, 09 Juin 2014.

98
[49] L. Leyrit, « Reconnaissance d’objets en vision artificielle : Application à la reconnaissance de
piétons », Mémoire de Docteur, Université Blaise Pascal, Sciences Pour L‟Ingénieur De Clermont-
Ferrand, Spécialité : Vision pour la robotique, 22 novembre 2010.

[50] J. Guyomard, « Vectorisations automatique de symboles », Agence Nationale de Recherche,

Rapport de projet GéoPeuple, Octobre 2013.

[51] C. Imane, K. Ahlam, « La Classification Des Feuilles de Vigne à Base de Descripteur

Histogramme de Gradient Orienté », Mémoire de Master, Université Kasdimerbah Ouargla, Faculté
des Nouvelles Technologies de l‟Information et de la Communication, Département d'Informatique
et Technologie de l'information, Spécialité: Informatique Industrielle, 02 Juin 2016.

[52] S. Bédard-Venne, « Réseau de neurones artificiels et application à la classification d'images »,

Mémoire de Master, Université du Québec à Montréal, Département Mathématiques, Mai 2018.

[53] A. Amidi, S. Amidi, « Pense-bête VIP : Réseaux de neurones convolutionnels »,

https://stanford.edu/~shervine/l/fr/teaching/cs-230/pense-bete-reseaux-neurones-convolutionnels, 6
Janvier 2019.

[54] S. Das, « CNN Architectures: LeNet, AlexNet, VGG, GoogLeNet, ResNet and more… »,
https://medium.com/@sidereal/cnns-architectures-lenet-alexnet-vgg-googlenet-resnet-and-more-
666091488df5, 16 Novembre 2017.

[55] R. Ek, « Automatic Image Annotation Using Transfer Learning on Convolutional Neural
Networks », Mémoire de Master, Université Åbo Akademi, Faculté des Sciences et Sciences de
l'Ingénieur, May 2018.

[56] B. Raj, «A Simple Guide to the Versions of the Inception Network »,

https://towardsdatascience.com/a-simple-guide-to-the-versions-of-the-inception-network-
7fc52b863202, 29 Mai 2018.

[57] J. Kafunah, « Backpropagation In Convolutional Neural Networks », https://www.jefkine.com/

general/2016/09/05/backpropagation-in-convolutional-neural-networks/, 5 September 2016.

[58] R. Gandhi, « R-CNN, Fast R-CNN, Faster R-CNN, YOLO — Object Detection Algorithms »,
https://towardsdatascience.com/r-cnn-fast-r-cnn-faster-r-cnn-yolo-object-detection-algorithms-
36d53571365e, 9 Juillet 2018.

99
[59] S. H Tsang, « Review: R-CNN Object Detection », https://medium.com/coinmonks/review-r-
cnn-object-detection-b476aba290d1, 31 Aout 2018.

[60] H. Gao, « Faster R-CNN Explained », https://medium.com/@smallfishbigsea/faster-r-cnn-

explained-864d4fb7e3f8, 27 Septembre 2017.

[61] S. H. Tsang, « Review: Faster R-CNN Object Detection », https://towardsdatascience.com/

review-faster-r-cnn-object-detection-f5685cb30202, Sep 14, 2018.

[62] T. Cuvelier, « Une introduction à CUDA », https://tcuvelier.developpez.com/tutoriels/

gpgpu/cuda/introduction/?page=theorie#LII, 2009.

[63] « NVIDIA cuDNN », https://developer.nvidia.com/cudnn, 2019.

[64] Y. Benoit, « TensorFlow & Deep Learning – Épisode 1 – Introduction »,

https://blog.xebia.fr/2017/03/01/tensorflow-deep-learning-episode-1-introduction/, 2017.

[65] A. Unruh, « What is the TensorFlow machine intelligence platform? »,

https://opensource.com/article/17/11/intro-tensorflow, 09 Novembre 2017.

[66] A. Géron, «Hands-On Machine Learning with Scikit-Learn & TensorFlow», O'Reilly Media :
United States of America, March 2017.

[67] A. Calmettes, « Introduction à la vision par ordinateur », https://openclassrooms.com/fr/

courses/1490316-introduction-a-la-vision-par-ordinateur/1490412-avant-de-commencer, Mai 2018.

[68] A. Mordvintsev, A. Rahman, « Introduction to OpenCV-Python Tutorials », https://opencv-

python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_intro/py_intro.html 2013.

[69] D. Meurisse, « Python, Raspberry Pi et Flask », Eyrolles : Paris, Novembre 2018.

[70] T. Lin, M. Maire, S. Belongie, L. Bourdev, R. Girshick, J. Hays, P. Perona, D. Ramanan L.

Zitnick, P. Dollar, « Microsoft COCO: Common Objects in Context », Publication, Février 2015.

[71] A. Rosebrock , « Intersection over Union (IoU) for object detection »

«https://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/,
novembre 2016

100
 FICHE DE RENSEIGNEMENTS

Nom : ANDRIAMIANDRASOA

Prénom(s) : Ianjafitia

Adresse : Lot II E 81 G M Bis Tsarahonenana Antananarivo 101 – Madagascar

ianjafitia@gmail.com
+261 34 68 943 81

Titre du mémoire :

SYSTEME DE DETECTION D'OBJET BASE SUR LE DEEP

LEARNING DANS UN MAGASIN INTELLIGENT

Nombres de pages : 102

Nombres de tableaux : 01

Nombre de figures : 64

Directeur de mémoire : Nom et prénom : RATSIMBAZAFY Andriamanga

Adresse e-mail : ndriamanga@gmail.com

Téléphone : +261 34 48 426 82

101
 RESUME

Le deep learning est une branche du machine learning qui est lui-même une branche de
l‟intelligence artificielle. Les idées fondatrices du deep learning remontent à la fin des années 80,
avec l‟apparition des premiers réseaux de neurones. Aujourd‟hui, grâce au développement
grandissant de la puissance des ordinateurs et la grande disponibilité des données, le deep learning
est utilisé dans plusieurs domaines surtout dans la vision industrielle. La détection d‟objet qui est
une des applications de la vision par ordinateur se voit alors être complètement révolutionnée. Les
CNN dépassent largement les compétences les méthodes de détection d‟objet traditionnelles comme
celle de Viola et Jones ou les HOG lors des grandes compétitions comme celles de ILSVRC. Le
secteur du commerce est un des secteurs les plus touchés par le deep learning, les méthodes de
détection d‟objet par CNN permettent alors d‟améliorer la qualité de service vue dans les magasins
et aident à leurs entrer dans l‟ère du phygital.

Mots clés: Apprentissage profond, apprentissage par transfert, Vison par ordinateur, CNN,
Détection d‟objet.

ABSTRACT

Deep learning is a subset of machine learning that is itself a subset of artificial intelligence. Deep
learning was founded in the late 80s, when the first neural networks appeared. Nowaday, with the
development of computing power and the wide high availability of data, deep learning is used in
several fields, especially in computer vision. Object detection, which is one of the applications of
computer vision, is then revolutionized. Cnns far exceed the capabilities of traditional object
detection methods such as Viola and Jones or HOG in major competitions like ILSVRC. The
commercial sector is one of the sectors most affected by deep learning, the methods of object
detection by CNN allow to improve the quality of service seen in the stores and help them to enter
the phygital era.

Key-words: Deep learning, Transfer learning, Computer Vision, CNN, Object detection.