UniversiaPolis Laayoune

Filière : Génie Informatique

Rapport

Elaboré par : Rachid Aymane.

Encadrant : Mr. Dahan Yassine.

1
 REMERCIEMENT

Ce rapport est le résultat d'un effort constant. Cet effort n'aurait pu aboutir sans la
contribution de M.Dahan Yassine. Ainsi se présente l'occasion de le remercier.

Nous ne pouvons passer sous silence les efforts fournis par Notre Proffesseur ausein
de UniversiaPolis Laayoune pour ses contribution, de ses encadrement et de ses
précieuses informations et conseils.

En outre, nous remercions l’UniversiaPolis, direction et professeurs, de l’effort

précieux qu’ils fournissent afin de nous offrir une formationcomplète et bonne.

3
 DEDICACE

A NOtre professeur Dehan Yassine et corps

administratif,
A notre famille,
En témoignant une affection et un sacrifice que vous
avez déployés, à notre égard, notre
Amour ne saurait être exprime par des dédicaces.
Que Dieu seul, puissant, vous accorde santé,
bonheur, prospérité et longue vie.

4
 SOMMAIRE

Remerciement..............................................................................................................2

Dédicace........................................................................................................................3

Sommaire......................................................................................................................4

Introduction..................................................................................................................7

Liste des figures............................................................................................................9

PARTIE 1: LE PRINCIPE DE LA RECONNAISSANCE DES OBJETS...........17

1. Introduction....................................................................................................18

2. Etapes de catégorisation ou classification d’images....................................18

3. Conclusion.......................................................................................................28

PARTIE 2 : CONCEPTION DE SYSTEME DE DETECTION DE FUMEE......29

1. Introduction...................................................................................................30

2. Spécification des besoins..............................................................................30

5
 3. Le langage UML...........................................................................................31

PARTIE 4 : REALISATION DE SYSTEME DE DETECTION DE FUMEE....37

1. Introduction...................................................................................................38

2. Spécification des besoins...............................................................................38

3. Choix technologiques....................................................................................38

4. Environnement logiciel................................................................................42

5. Modèle de détection utilisé............................................................................44

6. Les étapes de réalisation de notre système de détection de fumée............50

Références bibliographiques.....................................................................................59

Conclusion...................................................................................................................60

6
 INTRODUCTION :

Ce rapport présente le travail que j’ai effectué à savoir l’étude d’une description
globale du site et le développement d’une application de détection des objets à partir
d’une séquence vidéo ou une image.

Comme il est connu les ordinateurs effectuent à longueur de journée des tâches
répétitives. Ils aident ainsi l’homme à manipuler d’énormes quantités de données,
souvent même plus rapidement et plus précisément que lui.

Malgré cela, la capacité des ordinateurs demeure limitée lorsqu’il s’agit d’extraire
automatiquement des informations d’images ou de vidéos, qui représentent pourtant
des volumes de données extrêmement importants. Le traitement automatisé de ces
données ouvrirait la voie à beaucoup d’opportunités.

7
La discipline qui vise à automatiser la compréhension des images, la vision par
ordinateur, est une branche de l’intelligence artificielle dont l’objectif est précisément
de permettre à une machine de comprendre de ce qu’elle «voit» lorsqu’on la connecte
à une ou plusieurs caméras. Nos travaux se situent au cœur de cette discipline.

Dans ce vaste domaine qu’est la vision par ordinateur, nous nous intéressons ici à la
sous-discipline qu’est la reconnaissance d’objets, et plus particulièrement à la
localisation de la fumée dans une image ou à partir d’une séquence vidéo. Ce type de
technique combine des approches de traitement d’images et d’apprentissage
automatique dans le but de mener à bien cette tâche de reconnaissance de fumée.

Cette recherche vise à mettre au point un système automatisé de détection de fumée

moins intrusif, plus économique et plus efficace.

8
 Liste des figures
Figure 2 : Système de détection des objets.................................................................17

Figure 3 : Exemples des formes de l’objet au sein du catégorie ≪avion≫...............19

Figure 4 : Architecture d’un système de reconnaissance d’objets..............................19

Figure 5 : Les étapes pour construire la représentation de sac-de mots visuels.........29

Figure 6 : Exemple de détection de fumée..................................................................25

Figure 7 : modèle de détection R-CNN......................................................................45

Figure 8 : modèle de détection fast R-CNN...............................................................46

Figure 9 : fonctionnement du modèle de détection R-CNN.......................................48

Figure 10 : La classififcation du modèle de détection R-CNN..................................49

Figure 11 : Le résultat de l’invite de commande après le lancement de training.......57

9
 PARTIE 1 : LE PRINCIPE DE LA RECONNAISSANCE
DES OBJETS :

Figure 1 : Système de détection des objets.

Dans cette partie :

 Introduction.

 Etapes de catégorisation ou classification d’images.

17
1. Introduction :

La reconnaissance d’objets est l’un des challenges les plus difficiles dans le domaine
de la vision par ordinateur. Cependant, elle est considérée comme une étape
primordiale dans de nombreuses applications : médicales, industrielles, multimédia …

Par conséquent, ce domaine est depuis longtemps un objet d’intérêt pour la

communauté scientifique. Différents objectifs et méthodes ont été proposés, depuis
plus de 50 ans. En général, on peut les catégoriser en trois taches en fonction de leur
objectif :

 La catégorisation ou classification d’images qui consiste à donner un label a une

image en fonction de la présence ou non d’un objet appartenant à une catégorie
donnée.
 La détection d’objets qui désigne la tâche de localisation des objets d’une
catégorie donnée.
 La segmentation de classes d’objets qui consiste à déterminer quels sont les
pixels de l’image qui appartiennent à un objet d’une des classes d’intérêt.

A vrai dire, ces trois tâches sont étroitement liées. Toutes les trois suivent un
paradigme assez ancien proposé par David Marr. Ce paradigme suggère une analyse
uniquement ascendante, centrée sur les données. De ce fait, les mêmes outils peuvent
être mis en œuvre pour les résoudre. Ce paradigme constitue le cœur de la plupart des
méthodes de reconnaissance d’objets et surtout des systèmes de catégorisation
d’images. L’objectif de ces systèmes est de prédire la nature de l’objet dans une image
au sein d’une liste exhaustive de possibilités.

2. Etapes de catégorisation ou classification d’images :

Dans ce rapport, nous allons nous concentrer sur la tache de ≪catégorisation

d’images≫ puisqu’elle peut être considérée comme une généralisation des autres
tâches citées ci-dessus. La classification d’images selon la catégorie d’objet reste un
vrai challenge, étant donné que l’apparence des objets au sein d’une catégorie

18
 Figure 2 : Exemples des formes de l’objet au sein du catégorie ≪avion≫.

Varie grandement, suite aux modifications de position, orientation et échelle, aux

modifications d’illumination, occultations et aux grandes variabilités de formes au
sein de cette classe (cf. figure 1). Ces grandes variations intra-classes rendent difficile
voire impossible l’utilisation de méthodes globales ou l’image tout entière est
représentée par une signature même si elles forment les premières approches
initialement utilisées …

Figure 3: Architecture simple d’un système de reconnaissance d’objets.

Pour ces raisons, les méthodes ont eu recours à des approches plus locales. Le schéma
classique est représenté dans la figure 2. Dans ces approches, l’image est considérée
comme une collection de régions d’intérêts, généralement de taille faible par rapport à
la taille de l’image. Ces régions sont détectées dans l’étape ≪Extraction des
primitives≫, et ensuite transformées en vecteurs représentant les caractéristiques de
l’image, comme par exemple des contours et/ou orientations (Description des

19
primitives). A partir de ces vecteurs, chaque image est représentée par un
histogramme (Représentation d’images) servant comme base pour catégoriser l’image
selon l’objet qu’elle contient (Classification). Ces approches seront abordées en détail
dans la suite de ce chapitre. Nous allons présenter les principales étapes et outils
nécessaires pour développer un système de reconnaissance d’objets ainsi que les
différentes améliorations qui ont été proposées jusqu’à présent pour traiter les
différentes limitations citées ci-dessus.

Extraction des primitives visuelles :

La première étape (cf. figure 3) d’un système de reconnaissance d’objets consiste

généralement à extraire les régions les plus pertinentes d’une image. En général, on
peut catégoriser les différentes méthodes proposées en se basant sur deux concepts :

 Le premier concept considère l’image entière. L’approche la plus utilisée dans

ce cadre est l’extraction dense. La sélection dense des régions locales consiste
à traiter tous les pixels dans l’image. Cette approche a l’avantage d’être la
plus informative que les autres méthodes de l’état de l’art, cependant, elle
nécessite des ressources en temps et en mémoire très importantes : la plupart
du temps de calcul étant passée à traiter les régions peu informatives (voir
tableau 1).
 Le second concept : la détection des régions d’intérêts. Ce dernier consiste

À extraire les régions considérées comme les plus pertinentes pour la

reconnaissance de l’image (voir tableau 1). L’approche la plus utilisée dans ce cas
est le détecteur de points d’intérêts. Dans la section suivante, nous allons aborder
les différentes méthodes proposées pour la détection des points d’intérêts durant
ces dernières années.

20
 Détecteurs de points d’intérêts :

La plupart des algorithmes de reconnaissance d’objets se basent sur les détecteurs de

points d’intérêts pour sélectionner les régions d’intérêts dans laquelle on peut prédire
l’existence d’un objet. Ces détecteurs présentent l’avantage d’être robustes et
invariants aux modifications d’échelles, de translation, de rotation et même dans une
certaine mesure aux déformations affines. Selon Tuytelaars, on peut les catégoriser
selon leurs critères de sélection des régions locales en quatre familles

21
4 - Description des primitives :

En général, on peut poser le problème de reconnaissance comme une classification

des représentations d’images calculées en se basant sur l’ensemble des descripteurs
déjà extraits. Cette simple définition est capable d’expliquer la multitude des
approches qui se différencient par le choix des descripteurs qui représentent l’objet, le
type et la complexité du modèle, les méthodes utilisées pour l’apprentissage de
chaque classe d’objets. Dans cette section, nous allons aborder les travaux concernant
la construction des descripteurs locaux et les défis auxquels les chercheurs font face.
En général, on peut définir un descripteur par un ensemble de nombres scalaires
générés pour décrire un objet. En d’autres termes, il s’agit ici de construire une
signature représentant le contenu d’une région de l’image. Pratiquement, tous les
systèmes de reconnaissance d’objet s’appuient sur des descripteurs pour décrire les
régions d’intérêt. En effet, le choix de caractéristiques est délicat et dépend de
plusieurs facteurs comme la classe de l’objet considéré, les caractéristiques du
capteur, le contexte et la tâche à accomplir. Ce choix se base souvent sur un
compromis entre la précision et la généralité des caractéristiques. Dans le domaine de
la reconnaissance d’objets, on cherche une méthode de caractérisation qui extrait les
descripteurs locaux les plus efficaces pour une reconnaissance générique.

Selon Mikolajcyk et Schmid, on peut distinguer quatre grandes familles de

descripteurs locaux: bases sur les distributions, bases sur la texture, différentiels,
autres.

22
5 - Représentation d’images :

Dans cette section, nous allons aborder les différentes étapes nécessaires pour
construire une représentation d’images à partir de descripteurs générés par une des
méthodes évoquées dans la section précédente. Cette représentation sera la base des
méthodes de classification afin de catégoriser les images selon l’objet qu’elle contient,
et construire un modèle dans lequel on peut l’utiliser pour déterminer la nature d’un

23
objet dans une image quelconque. On peut distinguer trois types de représentation
d’images : compacte globale, statistique, systématique.

Représentation compacte par un histogramme global :

Dans cette catégorie, l’image est représentée par un seul vecteur global. Les méthodes
dans cette famille ont été parmi les premières propositions pour représenter une
image. Une des méthodes les plus utilisées dans cette catégorie est l’≪histogramme
global≫. Cette méthode consiste à calculer une signature de l’image dans sa globalité,
à l’aide de différents descripteurs globaux, ex : les histogrammes de couleurs utilisés
par Niblack, ou les histogrammes de textures proposées par Schiele. Ces histogrammes
sont très simples, et ils sont robustes à certaines variations comme l’illumination et le
contraste. Cependant, pour les autres transformations d’images comme les
changements de point de vue et d’échelle, ces méthodes nécessitent une quantité
gigantesque d’images d’apprentissage pour qu’ils soient invariants. En outre, ils ne
sont pas du tout invariants aux occultations et à la présence de fonds encombres. Pour
ces raisons, la plupart des méthodes de reconnaissance d’objets ont utilisé d’autres
approches pour représenter les images, en particulier, des approches locales. Dans la
suite, nous allons aborder les différentes propositions de représentation locale
d’images.

Représentation statistique :

L’image est représentée dans cette catégorie par un histogramme de valeurs

statistiques calculées à partir des descripteurs locaux extraits de l’image. Dans la suite,
nous abordons la méthode de représentation la plus populaire dans le domaine de la
reconnaissance d’objets.

Sac de mots visuels :

Cette approche proposée par Sivic est une des plus utilisées par les systèmes de
reconnaissance d’objets. Elle consiste à décrire une image en se basant sur des valeurs
quantifiées et à la classifier en utilisant une méthode de classification comme SVM.
Elle était inspirée d’une méthode d’indexation de documents textuels utilisant les

24
vecteurs de fréquence des mots. Comme la figure 5 le montre, le sac-des-mots visuels
peut être divisé en deux modules :

 Construction du vocabulaire visuel : ils sont définis à partir des

descripteurs locaux d’images. Pour cela, les descripteurs sont extraits
d’une base d’images et sont ensuite clustérises par une des méthodes de
classification non supervisée comme les k-moyennes, ou le GMM. Les
centres de clusters représentent le vocabulaire visuel.
 Construction des histogrammes ou codage : après avoir transformé les
descripteurs en une représentation locale compacte, creuse ou
statistiquement

Figure 5 : Les étapes pour construire la représentation de sac-de mots visuels.

Indépendante. Les histogrammes ou les codes ne sont que des vecteurs binaires (VQ)
ou continu (sparse coding), obtenu par une quantification des descripteurs d’images
dans un dictionnaire.

Représentation systématique par Grille dense :

Une autre approche de représentation d’image est la représentation dense. Cette

représentation repose sur l’extraction de toutes les caractéristiques de l’image en

25
divisant cette dernière en de petites régions uniformément espacées, appelées
≪blocs≫. L’ensemble de ces blocs forme ce qu’on appelle la grille dense. L’idée de
cette approche est de représenter l’image entière de sorte qu’il n’y ait pas de perte au
niveau de l’information. Cette représentation a été proposée pour traiter les limitations
des précédentes représentations qui consiste à sélectionner les informations à
représenter, ce qui peut générer de grandes pertes d’informations, ou/et extraire des
informations peu pertinentes ou aberrantes. De ce fait, récemment, plusieurs
chercheurs ont commencé à utiliser cette approche dans leurs systèmes de
reconnaissance d’objets : Dalal a proposé d’extraire des caractéristiques denses de
l’image en se basant sur la grille dense et en les transformant en un vecteur de grande
dimensionnalité, utilisé ensuite par des méthodes de classification discriminatives, ex :
SVM. Jurie a proposé une nouvelle méthode de classification non supervisée pour
construire un sac-des motsdense, plus informatif et plus saillant. Cette dernière
méthode a montré de meilleurs résultats par rapport aux approches sparse de sac-des
mots.

6. Classification :

Après avoir calculé une ≪bonne≫ représentation des images, la présence ou non
d’objets dans les images test est prédite en utilisant une des méthodes de classification
supervisée. Ces méthodes cherchent, en utilisant un ensemble de données
d’apprentissage, à estimer les paramètres optimaux d’une fonction de décision. Cette
fonction sera utilisée pour classifier les images selon leur label. Deux approches ont
été proposées pour calculer cette fonction : générative et discriminative.

26
6.1 - Approche générative : Le classifieur de Bayes :

Les méthodes dans cette approche cherchent à construire un modèle pour chaque
classe, ainsi la catégorisation d’un objet dans une image est estimée d’après sa
ressemblance au modèle. En d’autres mots, les modelés génératifs modélisent
directement les données. Elles permettent une vraie modélisation de chaque
classe et le modèle obtenu peut être appris indépendamment.

6.2 - Approche discriminative SVM :

Les méthodes dans cette approche visent à apprendre directement une fonction de
décision qui sépare deux classes. En d’autres mots, ces méthodes modélisent
directement la distribution de probabilité du label y sachant l’observation x.

27
3. Conclusion

Dans ce chapitre, nous avons évoqué les différentes étapes nécessaires pour construire
un système de reconnaissance d’objets classique. Nous avons présenté les différents
travaux proposes pour détecter les points d’intérêts la première étape d’un système de
reconnaissance d’objets, dans la section 2. Nous avons pu conclure qu’il n’y a pas
jusqu’à présent un type de détecteur des points d’intérêts universel. L’utilisation d’un
détecteur de points d’intérêts dépend de l’objectif du système proposé et de la
structure des objets à détecter. Récemment, plusieurs travaux proposés dans le
domaine de la reconnaissance d’objets se basent sur les grilles denses pour extraire les
informations des images vu que la grille dense ne dépend pas de la structure
géométrique de l’objet. Mais, comme mentionne dans l’introduction, celles-ci
nécessitent des calculs très importants ainsi qu’une large allocation de mémoire,
puisqu’elle considère l’image toute entière. Enfin, comme Frintrop, nous pensons que
le système d’attention visuelle peut être un premier pas pour résoudre le challenge de
la détection des points d’intérêts stables et robustes aux différentes variations que
l’image peut subir.

Par ailleurs, nous avons présenté les différentes techniques proposées pour calculer la
deuxième étape du système de reconnaissance d’objets : la description des primitives
dans la section 3. Dans ce cadre, nous avons abordé leurs points faibles et forts afin
d’aider au choix des descripteurs adéquats. Nous pouvons déduire de notre
comparaison, qu’il n’y a pas jusqu’à présent un descripteur universel pour décrire tout
type d’objets ou toutes les caractéristiques de l’image. Le choix du descripteur dépend
en général des objectifs des systèmes de reconnaissance.

28
PARTIE 2 : CONCEPTION DE SYSTEME DE DETECTION
DE FUMEE :

Figure 5 : Exemple de détection de fumée.

Dans cette partie :

 Introduction.

 Spécification des besoins.

29
1. Introduction :

La phase de conception est la première étape dans la réalisation d'un projet, elle doit
d'écrire de manière non ambiguë le fonctionnement futur du système, afin d'en
faciliter la réalisation. Pour cela, différentes méthodes existent permettant de
formaliser les étapes préliminaires du développement.

Dans ce chapitre, nous présentons les objectifs de notre application, ce qui nous
amène à identifier les possibilités du système et les besoins des utilisateurs que nous
essayons de projeter dans des diagrammes de cas d'utilisations globaux et détaillés.

2. Spécification des besoins :

L'application envisagée doit satisfaire les besoins fonctionnels qui seront exécutés par
le système et les besoins non fonctionnels qui perfectionnent la qualité logicielle du
système.

2-1- Les besoins fonctionnels :

Les besoins fonctionnels ou besoins métiers représentent les actions que le

système doit exécuter, il ne devient opérationnel que s'il les satisfait. Cette
application doit couvrir principalement les besoins fonctionnels suivants :

- Détection de l’emplacement de la fumée.

- Afficher le pourcentage de précision s’il s’agit de la fumée.

- Stocker les données dans un espace de stockage.

2.2 Les besoins non fonctionnels :

Ce sont des exigences qui ne concernent pas spécifiquement le comportement du

système mais plutôt identifient des contraintes internes et externes du système.
Les principaux besoins non fonctionnels de notre application se résument comme
suit :

- Pour tester notre détecteur d'objet, déplacez une image de l'objet ou des
objets dans le dossier \ object_detection et modifiez la variable
IMAGE_NAME dans

30
Object_detection_image.py pour qu'elle corresponde au nom de fichier de
l'image. Vous pouvez également utiliser une vidéo des objets (en utilisant
Object_detection_video.py) ou simplement brancher une webcam USB et la
pointer sur les objets (en utilisant Object_detection_webcam.py).

- Si tout fonctionne correctement, le détecteur d'objet s'initialisera pendant

environ 10 secondes, puis affichera une fenêtre montrant l’emplacement de la
fumée détecté dans l'image!

31
 PANDAS :

Est une bibliothèque écrite pour le langage de programmation Python

permettant la manipulation et l'analyse des données. Elle propose en
particulier des structures de données et des opérations de manipulation de
tableaux numériques et de séries temporelles.

Les principales structures de données sont les séries (pour stocker des
données selon une dimension - grandeur en fonction d'un index), les
DataFrames (pour stocker des données selon 2 dimensions - lignes et
colonnes), les Panels (pour représenter des données selon 3 dimensions), les
Panels4D ou les DataFrames avec des index hiérarchiques aussi nommés
MultiIndex (pour représenter des données selon plus de 3 dimensions -
hypercube)

OPENCV :

Est une bibliothèque graphique libre, initialement développée par Intel,

spécialisée dans le traitement d'images en temps réel. La bibliothèque
contient plus de 2500 algorithmes optimisés, qui incluent un ensemble
complet d'algorithmes classiques et de pointe en matière de vision par
ordinateur et d'apprentissage automatique. Ces algorithmes peuvent être
utilisés pour détecter et reconnaître des visages, identifier des objets, classer
les actions humaines dans des vidéos, suivre les mouvements d’une caméra et
suivre des objets en mouvement.

3. Environnement logiciel :

CUDA Tool Kit :

NVIDIA® CUDA® Toolkit fournit un environnement de développement pour la

création d’applications hautes performances avec accélération de GPU. Avec
CUDA Toolkit, vous pouvez développer, optimiser et déployer vos applications

42
sur des systèmes intégrés, des stations de travail de bureau, des centres de
données d'entreprise, des plates-formes basées sur le cloud et des
supercalculateurs HPC accélérés par GPU. Le kit d'outils comprend des
bibliothèques accélérées par GPU, des outils de débogage et d'optimisation, un
compilateur C / C ++ et une bibliothèque d'exécution pour déployer votre
application.

Les bibliothèques CUDA accélérées par GPU permettent une accélération

immédiate dans de nombreux domaines tels que l'algèbre linéaire, le traitement
d'images et de vidéos, l'apprentissage en profondeur et l'analyse de graphes. Pour
développer des algorithmes personnalisés, vous pouvez utiliser les intégrations
disponibles avec les langages et packages numériques couramment utilisés, ainsi
que les API de développement publiées. Vos applications CUDA peuvent être
déployées sur toutes les familles de GPU NVIDIA disponibles sur site et sur les
instances de GPU dans le cloud. En utilisant des fonctionnalités intégrées pour la
répartition des calculs entre plusieurs configurations de GPU, les scientifiques et
les chercheurs peuvent développer des applications évolutives, allant de stations
de travail à GPU uniques à des installations en nuage avec des milliers de GPU.

CUDNN 6.0 :

La bibliothèque de réseaux de neurones profonds NVIDIA CUDA® (cuDNN) est

une bibliothèque de primitives accélérées par GPU pour les réseaux de neurones
profonds. cuDNN fournit des implémentations hautement optimisées pour les
routines standard telles que les couches de convolution en amont et en aval, de
regroupement, de normalisation et d'activation.

Les chercheurs en apprentissage approfondi et les développeurs d'infrastructure

du monde entier font confiance à cuDNN pour une accélération des GPU hautes
performances. Cela leur permet de se concentrer sur la formation des réseaux de
neurones et le développement d'applications logicielles plutôt que de consacrer du

43
 temps à l'optimisation des performances des GPU de bas niveau. cuDNN accélère
les frameworks d’apprentissage en profondeur largement utilisés, tels que Caffe ,
Caffe2 , Chainer , Keras , MATLAB , MxNet , TensorFlow et PyTorch.

GPU Driver :

Le pilote (en anglais, driver) de la carte graphique, c'est avant tout un logiciel qui
s'intercale entre le système d'exploitation et le matériel. On peut le comparer à un
interprète traduisant automatiquement le langage de Windows dans celui de la
carte d'affichage.

LabelImg :

LabelImg est un excellent outil pour étiqueter des images. LabelImg enregistre un
fichier .xml contenant les données d'étiquette pour chaque image. Ces fichiers
.xml seront utilisés pour générer des TFRecords, qui sont l’une des entrées du
formateur TensorFlow.

4. Modèle de détection utilisé :

Faster R-CNN est maintenant un modèle canonique pour la détection d'objet basée
sur l'apprentissage en profondeur. Cela a inspiré de nombreux modèles de détection et
de segmentation qui ont suivi, y compris les deux autres que nous allons examiner
aujourd'hui. Malheureusement, nous ne pouvons vraiment pas commencer à
comprendre Faster R-CNN sans comprendre ses propres prédécesseurs, R-CNN et
Fast R-CNN, alors plongeons-nous rapidement dans son ascendance.

R-CNN :

R-CNN est le grand-père de Faster R-CNN. En d'autres termes, R-CNNa

vraiment lancé les choses.

44
R-C NN, ou RÉGION à base de Convolutional NEural Network, consistait en 3 étapes:

1. Numérisez l'image d'entrée pour les objets possibles à l'aide d'un algorithme
appelé Recherche sélective, générant ~ 2000 propositions de région.

2. Exécuter un réseau neuronal convolutionnel ( CNN ) au-dessus de chacune de

ces propositions de région

3. Prenez la sortie de chaque CNN et introduisez-la dans a) un SVM pour

classifier la région et b) un régresseur linéaire pour resserrer le cadre de sélection
de l'objet, si un tel objet existe.

Ces 3 étapes sont illustrées dans l'image ci-dessous:

Figure 6 : Modèle de détection R-CNN.

En d’autres termes, nous proposons d’abord des régions, puis extrayons des entités,
puis nous les classons en fonction de leurs caractéristiques. Pour l’essentiel, nous
avons transformé la détection d’objet en problème de classification d’image. R-CNN
était très intuitif, mais très lent.

45
 R-CNN rapide

Le descendant immédiat de R-CNN était Fast-R-CNN. Fast R-CNN ressemblait à

l'original à bien des égards, mais sa vitesse de détection était améliorée grâce à deux
augmentations principales:

1. Effectuer l'extraction de caractéristiques sur l'image avant de proposer des

régions, n'exécutant ainsi qu'un seul CNN sur toute l'image au lieu de 2 000 CNN
sur 2 000 régions qui se chevauchent

2. Remplacement du SVM par une couche softmax, étendant ainsi le réseau de

neurones pour les prédictions au lieu de créer un nouveau modèle

Le nouveau modèle ressemblait à ceci :

Figure 7 : Modèle de détection fast R-CNN.

Comme nous pouvons le voir sur l'image, nous générons maintenant des propositions
de région basées sur la dernière carte de caractéristiques du réseau, et non à partir de
l'image d'origine elle-même. En conséquence, nous pouvons former un seul CNN
pour l’ensemble de l’image.

46
En outre, au lieu de former de nombreux SVM différents à la classification de chaque
classe d'objets, il existe un seul calque softmax qui génère directement les probabilités
de la classe. Maintenant, nous n’avons plus qu’un réseau de neurones à former, par
opposition à un réseau de neurones et de nombreux SVM.

Fast R-CNN a eu de bien meilleurs résultats en termes de rapidité. Il ne restait plus

qu'un seul gros goulot d'étranglement: l'algorithme de recherche sélective permettant
de générer des propositions de région.

Faster R-CNN :

À ce stade, nous revenons à notre objectif initial: Faster R-CNN. L’intérêt principal de
Faster R-CNN était de remplacer l’algorithme de recherche sélective lente par un
réseau neuronal rapide. Plus précisément, il a introduit le réseau de proposition de
région (RPN).

Voici comment le RPN a fonctionné:

 Sur la dernière couche d'un CNN initial, une fenêtre glissante 3x3 se déplace
sur la carte des fonctionnalités et la mappe vers une dimension inférieure (par
exemple, 256-d)

 Pour chaque emplacement de fenêtre coulissante, il génère plusieursrégions

possibles en fonction de k boîtes d'ancrage à rapport fixe (boîtes englobantes
par défaut).

 Chaque proposition de région comprend a) un score d'objectivité pour cette

région et b) 4 coordonnées représentant le cadre de sélection de la région.

En d’autres termes, nous examinons chaque emplacement de notre dernière carte de

caractéristiques et considérons k cases différentes centrées autour de celle-ci: une
grande

47
case, une large case, une grande case, etc. Pour chacune de ces cases, nous indiquons
si nous pensons ou non: il contient un objet et quelles sont les coordonnées pour cette
boîte. Voici à quoi ressemble une fenêtre glissante:

Figure 8 : fonctionnement du modèle de détection R-CNN.

Les 2 k scores représentent la probabilité softmax de chacune des k boîtes englobantes

se trouvant sur un «objet». Notez que bien que l'ANP produise les coordonnées de la
boîte englobante, il n'essaie pas de classer les objets potentiels: son seul travail est
toujours de proposer des régions d'objet. Si une case d'ancrage a un score d'objectivité
supérieur à un certain seuil, ses coordonnées sont transmises en tant que proposition
de région.

Une fois que nous avons nos propositions de région, nous les alimentons directement
dans ce qui est essentiellement un Fast R-CNN. Nous ajoutons une couche de
regroupement, certaines couches entièrement connectées, et enfin une couche de
classification Softmax et un régresseur de zone de délimitation. Dans un sens, Faster
R- CNN = RPN + Fast R-CNN.

48
 Figure 9 : La classififcation du modèle de détection R-CNN.

Au total, le Faster R-CNN a atteint des vitesses bien meilleures et une précision de
pointe. Il convient de noter que, bien que les futurs modèles aient beaucoup contribué
à augmenter les vitesses de détection, peu de modèles ont réussi à surpasser Faster R-
CNN de manière significative. En d'autres termes, Faster R-CNN n'est peut-être pas la
méthode la plus simple ou la plus rapide pour la détection d'objet, mais reste l'une des
plus performantes. Exemple: Faster R-CNN avec Inception ResNet de Tensorflow est
leur modèle le plus lent mais le plus précis .

En fin de compte, Faster R-CNN peut sembler compliqué, mais sa conception de base
est identique à celle du R-CNN d'origine: supposez des régions d'objet, puis les
classent. C’est maintenant le pipeline prédominant pour de nombreux modèles de
détection d’objets, y compris le prochain.

49
3. Rassembler et étiqueter des images :

Maintenant que l'API de détection d'objets TensorFlow est entièrement configurée et

prête à fonctionner, nous devons fournir les images qu'elle utilisera pour former notre
détecteur de fumée.

3a. Rassembler des photos :

TensorFlow a besoin de centaines d'images de la fumée pour former un bon classifieur

de détection. Pour former un classificateur robuste, les images d'apprentissage doivent
comporter des objets aléatoires dans l'image ainsi que l’objet souhaité (fumée), ainsi
que divers arrière-plans et conditions d'éclairage. Il doit y avoir des images où la
fumée est partiellement masquée.

3b. étiqueter la fumée :

Avec toutes les images rassemblées, il est temps d'étiqueter la fumée dans chaque
image. LabelImg est un excellent outil pour étiqueter des images.

LabelImg enregistre un fichier .xml contenant les données d'étiquette pour chaque
image. Ces fichiers .xml seront utilisés pour générer des TFRecords, qui sont l’une
des entrées du formateur TensorFlow. Une fois que nous avons étiqueté et enregistré
chaque image, il y aura un fichier .xml pour chaque image dans les répertoires \test et
\train.

4. Générer des données d'entraînement :

Avec les images étiquetées, il est temps de générer les TFRecords qui servent de
données d'entrée au modèle de formation TensorFlow. Ce référentiel utilise les
scripts xml_to_csv.py et generate_tfrecord.py du jeu de données du détecteur de
raton laveur de Dat Tran , avec quelques légères modifications pour fonctionner
avec notre structure de répertoires.

54
Premièrement, les données image .xml seront utilisées pour créer des fichiers .csv
contenant toutes les données du train et des images d’essai. A partir du dossier \
object_detection, nous avons lancé la commande suivante dans l'invite de commande
Anaconda:

(tensorflow1)C:\tensorflow1\models\research\object_detection>python xml_to_csv.py

Cela crée un fichier train_labels.csv et test_labels.csv dans le dossier \ object_detection

\ images.

Ensuite, nous avons ouvrert le fichier generate_tfrecord.py dans un éditeur de texte.

Remplacer la mappe d'étiquettes à partir de la ligne 31 par notre propre mappe
d'étiquettes, où un numéro d'identification est attribué à chaque objet. Cette même
affectation de numéro sera utilisée lors de la configuration du fichier labelmap.pbtxt à
l'étape 5b.

Dans notre application, nous avons remplacé le code suivant dans generate_tfrecord.py:

def class_text_to_int(row_label):
if row_label == 'ace':
return 1
elif row_label == two:
return 2
else:
return None
Avec ça:
def class_text_to_int(row_label):
if row_label == 'smoke':

return 1
Générer ensuite les fichiers TFRecord en exécutant ces commandes à partir du dossier
\ object_detection:

pythongenerate_tfrecord.py--csv_input=images\train_labels.csv-- image_dir=images\
train --output_path=train.record

55
 pythongenerate_tfrecord.py--csv_input=images\test_labels.csv-- image_dir=images\
test --output_path=test.record

Celles-ci génèrent un fichier train.record et un fichier test.record dans \

object_detection. Celles-ci seront utilisées pour former le nouveau classifieur de
détection d'objets.

5. Créer une mappe d'étiquettes et configurer model de training :

La dernière chose à faire avant le training consiste à créer une mappe d'étiquettes et à
modifier le fichier de configuration de model.

Enfin, le pipeline de training de détection de fumée doit être configuré. Il définit quel
modèle et quels paramètres seront utilisés pour le training. C'est la dernière étape
avant de lancer le training.

6. training :

Depuis le répertoire \ object_detection, nous avons lancé la commande suivante pour

commencer le Training :

Pythontrain.py--logtostderr--train_dir=training/--
pipeline_config_path=training/faster_rcnn_inception_v2_pets.config

TensorFlow initialisera la formation. L'initialisation peut prendre jusqu'à 30 secondes

avant le début du Training. Lorsque le training commence, cela ressemblera à ceci:

56
 Figure 10 : Le résultat de l’invite de commande après le lancement de training.

Chaque étape du Training rapporte la perte. Il commencera haut et diminuera au fur et

à mesure que la formation avance. Pour notre entraînement sur le modèle Faster-
RCNN-Inception-V2, il a commencé aux environs de 3,0 et est rapidement passé sous
la barre des 0,8.

7. Exportation du graphe d'inférence :

Maintenant que le Training est terminé, la dernière étape consiste à générer le graphe
d'inférence gelé (fichier .pb). A partir du dossier \ object_detection, nous avons lancé
la commande suivante, où "XXXX" dans "model.ckpt-XXXX" doit être remplacé par
le fichier .ckpt portant le numéro le plus élevé dans le dossier de formation:

python export_inference_graph.py --input_type image_tensor --pipeline_config_path

training/faster_rcnn_inception_v2_pets.config--trained_checkpoint_prefix
training/model.ckpt-XXXX --output_directory inference_graph

57
Cela crée un fichier frozen_inference_graph.pb dans le dossier \ object_detection \
inference_graph.

8. Utilisation de notre détecteur de fumée :

Nous avons modifié la variable NUM_CLASSES dans le script afin qu'elle

corresponde au nombre de classes que nous souhaitons détecter. (Pour notre détecteur
de fumée, la variable NUM_CLASSES = 1.).

Pour tester notre détecteur de fumée, on a déplacé une image de fumée dans le dossier
object_detection et nous avons modifié la variable IMAGE_NAME dans
Object_detection_image.py pour qu'elle corresponde au nom de fichier de l'image.
Nous pouvons également utiliser une vidéo contenant de la fumée (en utilisant
Object_detection_video.py) ou simplement brancher une webcam USB (en utilisant
Object_detection_webcam.py).

58
 Conclusion :

Le Stage qu’on a effectué au sein de la société GLOBAL VISION, d’une durée d’un
mois et demi, était une expérience fructueuse. Au cours de cette période, on a pu
acquérir tant d’informations qui représentent des plus non négligeables pour nos
connaissances et une motivation supplémentaire pour notre poursuite d’étude dans
notre spécialité, de s'affronter aux vraies difficultés de travail mais avant tout de
s’intégrer dans des groupes de personnes et de travailler en collaboration avec eux et
aussi de se familiariser avec cet environnement.

Nous pouvons ajouter aussi que ce stage nous a permis le réel contact avec la vie
professionnelle et nous a facilité les tâches suivantes :

- L’adaptation à la vie active de la direction ;

- La participation aux différentes activités ;

- Le développement de nos connaissances professionnelles.

La société GLOBAL VISION était un bon choix pour renfler l’importance et la valeur
de nos acquis professionnels. En effet cette expérience nous a permis de voir et
d’assister chaque jour le succès quotidien de cet organisme dirigé et mené par une
grande équipe.

De notre côté, on a apporté à l'entreprise une vision jeune et dynamique et une

application de détection de fumée.

Malgré le bon déroulement du stage nous avons rencontré quelques problèmes en ce

qui concerne :

- Le manque de connaissances à propos de l’intelligence artificielle et le language de

programmation utilisé vue que nous n’avons reçu aucun cours à propos de ces
derniers au sein de notre école.

- Le manque de temps pour améliorer nos connaissances à propos du sujet.

- Le manque d’information à propos du sujet.

- Le manque d’information à propos de l’entreprise vue qu’elle est nouvellement créé.

60
Mais ça ne reflète pas sur la qualité du stage qu’on a passé.

Nous avons été par conséquent satisfaits de notre stage au sein de la société et nous
espérons y avoir laissé une bonne impression de notre passage auprès des
responsables qui nous ont encadrés tout au long de notre stage.

61