département : rapport de projet de fin d’études
Post on 02-Oct-2021
6 Views
Preview:
TRANSCRIPT
5, Avenue Taha Hussein –Tunis
B.P.56, BabMenara 1008
Tél. :71.496.066
Fax : 71.391.166
Université de Tunis
Ecole Nationale Supérieure d’Ingénieurs de Tunis
Département : GENIE ELECTRIQUE
Rapport de projet de fin d’études
Pour l’obtention du
DIPLOME NATIONAL D’INGENIEUR
Spécialité : GENIE ELECTRIQUE
Option : automatique et informatique industriel
Année Universitaire : 2017– 2018
Élaboré par :
Chaarana Anis
Soutenu le, 7/7/2018 devant le Jury composé de MM :
Ben Hmida Faycel : Président
Belkhiria Hela : Rapporteur
Sellami Anis : Encadreur Universitaire
Ben Othmen Slim : Encadreur Professionnel
TITRE
Prototype de conduite autonome d’un véhicule
Remerciements
Tout d’abord et avant tout, je remercie DIEU le tout-puissant qui m’ a donné la
patience de faire cette expérience à la fois enrichissante et gratifiante.
Puis, au terme de ce PFE, je tiens à présenter mes vifs remerciements à mon encadreur
universitaire Monsieur Sellami Anis, mon encadreur professionnel Monsieur Ben Othmen
Slim et mon enseignent Monsieur Fathallah Mourad qui m’ont aidés à élaborer ce travail,
pour leurs conseils précieux afin d’enrichir mes connaissances et de leur soutien continu.
Aussi, J'adresse mes sincères remerciements aux membres de jury de bien vouloir
accepter d’évaluer et de juger mon travail.
Table des matières
Introduction générale .............................................................................................................................. 1
Chapitre 1 : Présentation de la société et du cadre du projet ................................................................ 3
1.1. Introduction .................................................................................................................................. 4
1.2. Présentation de la société ............................................................................................................ 4
1.3. Contexte général .......................................................................................................................... 5
1.4. Généralité sur les véhicules autonomes ...................................................................................... 6
1.4.1. Définition et types des véhicules autonomes ...................................................................... 6
1.4.2. Avantages des véhicules autonomes .................................................................................... 7
1.4.2.1. Les avantages sociétaux ................................................................................................. 7
1.4.2.2. Les avantages écologiques ............................................................................................. 8
1.4.2.3. Les avantages économiques ........................................................................................... 8
1.5. Etude de l’existant ...................................................................................................................... 10
1.6. Cahier de charge ......................................................................................................................... 11
1.6.1. Autonomie ........................................................................................................................... 12
1.6.2. Contrôle interne .................................................................................................................. 13
1.6.3. Validation ............................................................................................................................ 13
1.7. Conclusion .................................................................................................................................. 13
Chapitre 2 : Conduite autonome et réalisation du prototype .............................................................. 14
2.1. Introduction ................................................................................................................................ 15
2.2. Fonctionnement et système de pilotage des voitures autonomes ............................................ 15
2.2.1. Yeux du véhicule .................................................................................................................. 15
2.2.2. Cerveau du véhicule ............................................................................................................ 16
2.3. Prototype .................................................................................................................................... 16
2.3.1. Problématique ..................................................................................................................... 16
2.3.2. Analogie entre prototype et modèle réel ........................................................................... 16
2.3.3. Étape de réalisation du prototype....................................................................................... 17
2.3.3.1. Unité d’acquisition ....................................................................................................... 17
2.3.3.2. Unité de traitement ...................................................................................................... 17
2.3.3.3. Unité de commande ..................................................................................................... 20
2.4. Conclusion .................................................................................................................................. 20
Chapitre 3 : contrôle interne du véhicule « assistant virtuel » ............................................................. 21
3.1. Introduction ................................................................................................................................ 22
3.2. Présentation de l'intelligence artificielle .................................................................................... 22
3.2.1. Introduction ......................................................................................................................... 22
3.2.2. L'Apprentissage Automatique ............................................................................................. 23
3.2.2.1. Apprentissage supervisé ............................................................................................... 23
3.2.2.2. Apprentissage non supervisé ....................................................................................... 24
3.2.2.3. Apprentissage par renforcement ................................................................................. 24
3.2.3. Les différents types d'algorithmes ...................................................................................... 25
3.2.3.1. Régression linéaire ....................................................................................................... 25
3.2.3.2. Arbre de décision.......................................................................................................... 26
3.2.3.3. KNN « Plus proches voisins » ........................................................................................ 26
3.2.3.4. Réseaux de neurones artificiels .................................................................................... 26
3.3. L’apprentissage profond ............................................................................................................. 27
3.3.1. Le réseau de neurones multicouches MLP « Multi Layer Perceptron » ............................. 27
3.3.2. Réseaux de neurones récurrents « RNN » .......................................................................... 28
3.3.2.1. Dépendances à long terme........................................................................................... 29
3.3.2.2. Réseaux LSTM ............................................................................................................... 30
3.3.2.3. Modèles de séquence à séquence « Seq2seq » ........................................................... 31
3.3.2.4. Neural Machine Translation « NMT » .......................................................................... 31
3.3.3. Réseaux de neurone convolutionnels « CNN / ConvNets » ............................................ 32
3.3.3.1. Architecture des ConvNets ........................................................................................... 32
3.3.3.2. Couche convolutionnelle .............................................................................................. 33
3.3.3.3. Connectivité locale ....................................................................................................... 34
3.3.3.4. Partage des paramétrés ............................................................................................... 35
3.4. Comparaison entre les « Framework » ...................................................................................... 37
3.4.1. scikit-learn .......................................................................................................................... 37
3.4.2. Tensorflow ......................................................................................................................... 37
3.4.3. Theano ................................................................................................................................ 38
3.4.4. Keras ................................................................................................................................... 38
3.4.5. Caffe .................................................................................................................................... 38
3.4.6. Pytorch ................................................................................................................................ 39
3.5. Apprentissage de l’assistant conversationnel « chatbot » ......................................................... 39
3.6. Reconnaissance de parole .......................................................................................................... 42
3.6. 1. Historique ........................................................................................................................... 42
3.6.2. Réalisation ........................................................................................................................... 42
3.6.3. Problème et solution ........................................................................................................... 43
3.7. Détection faciale « Méthode de Vola et Jones » ........................................................................ 43
3.7.1. Introduction ......................................................................................................................... 43
3.7.2. Principe ................................................................................................................................ 43
3.7.3. Les caractéristiques pseudoHaar ...................................................................................... 44
3.7.4. L’image intégrale ................................................................................................................. 44
3.7. 5. Adaboost............................................................................................................................. 45
3.7.6. Cascade de classifieurs ........................................................................................................ 47
3.7.7. Apprentissage du classifieur ................................................................................................ 48
3.7.8. Les étapes de création et entrainement des classifieurs .................................................... 48
3.8. Détection de fatigue ................................................................................................................... 50
3.9. Sécurité ....................................................................................................................................... 51
3.9.1. Problématique ..................................................................................................................... 51
3.9.2. Reconnaissance faciale moderne avec apprentissage profond .......................................... 52
3.9.2.1. Détection faciale .......................................................................................................... 52
3.9.2.2. Projection des visages .................................................................................................. 55
3.9.2.3. Encodage des visages ................................................................................................... 56
3.9.2.4. Trouver le nom de la personne à partir de l'encodage ................................................ 58
3.10. Détection d’émotion ................................................................................................................ 59
3.10.1. Introduction ....................................................................................................................... 59
3.10.2. Réalisation ......................................................................................................................... 59
3.11. Conclusion ................................................................................................................................ 61
Conclusion générale .............................................................................................................................. 62
Bibliographie.......................................................................................................................................... 63
Liste des figures
Figure 1: Acquisition des données d'apprentissage. ............................................................................. 18
Figure 2: Conception du réseau de neurones. ...................................................................................... 18
Figure 3: Détection d'objets. ................................................................................................................. 19
Figure 4: Processus de l'apprentissage supervisé. ................................................................................ 23
Figure 5: Schéma de principe de l'apprentissage supervisé. ................................................................ 24
Figure 6: Schéma de principe de l'apprentissage non supervisé. ......................................................... 24
Figure 7: Schéma de principe de l'apprentissage par renforcement. ................................................... 25
Figure 8: Une représentation des données d’entrée par rapport à un classificateur linéaire. ............. 25
Figure 9: Fonctionnement d'un neurone. ............................................................................................. 26
Figure 10: Réseau de neurones multicouches. ..................................................................................... 27
Figure 11: Réseau de neurones récurrents. .......................................................................................... 28
Figure 12: Décomposition du CNN. ....................................................................................................... 28
Figure 13: Exemple de production sans contexte. ................................................................................ 29
Figure 14: Exemple de production impossible sans contexte. .............................................................. 30
Figure 15: Architecture interne des LSTM. ............................................................................................ 30
Figure 16: Composition du modèle séquence à séquence. .................................................................. 31
Figure 17: Modèle séquence à séquence. ............................................................................................. 31
Figure 18: ConvNet 3D. ......................................................................................................................... 33
Figure 19: Réseau de neurones traditionnels à 3 couches. ................................................................... 33
Figure 20: Connectivité locale. .............................................................................................................. 34
Figure 21: Exemple de liaison entre la couche d'entrée et la couche conv. ......................................... 34
Figure 22: Pooling. ................................................................................................................................. 36
Figure 23: Pooling maximum. ................................................................................................................ 36
Figure 24: Exemple d'exécution d'un modèle seq2seq. ........................................................................ 40
Figure 25: Attribution de quelques caractéristiques au visage humain. .............................................. 44
Figure 26: Image intégrale. .................................................................................................................... 45
Figure 27: Image d'entrée. .................................................................................................................... 45
Figure 28: Caractéristique inutiles......................................................................................................... 45
Figure 29: Caractéristique utiles............................................................................................................ 45
Figure 30: Résultat de l'apprentissage d'un classifieur faible. .............................................................. 46
Figure 31: Adaboost algorithme. ........................................................................................................... 47
Figure 32: Détection de fatigue. ............................................................................................................ 51
Figure 33: Examinassions de tous les pixels de l'image. ....................................................................... 53
Figure 34: Représentation des flèches. ................................................................................................. 53
Figure 35: Convection des pixels en flèches. ......................................................................................... 53
Figure 36: Représentation finale de l'image. ........................................................................................ 54
Figure 37: Technique de détection faciale HOG. ................................................................................... 54
Figure 38: Les 68 points spécifiques. ..................................................................................................... 55
Figure 39: Application du RNN pour trouver les points spécifiques. .................................................... 55
Figure 40: Les étapes de projection des visages. .................................................................................. 56
Figure 41: Une itération d'apprentissage. ............................................................................................. 57
Figure 42: Génération des mesures ...................................................................................................... 58
Figure 43: Identification. ....................................................................................................................... 59
Figure 44: Exemple des images de la base de données FER-2013. ....................................................... 60
Figure 45: Test de la prédiction d'émotion. .......................................................................................... 60
1
Introduction générale
Chaque année, plus de 1,25 million de personnes perdent la vie dans des accidents de
la route. On recense en plus de 20 à 50 millions de blessés, nombre d’entre eux gardant une
invalidité à la suite de leurs blessures. La réduction du nombre d'accidents est donc
obligatoire.
D’après l’association de la prévention routière, les facteurs humains sont responsables
de plus de 90% des accidents corporels, [1]. Ainsi, le fait que la voiture prend une partie plus
ou moins importante des décisions réduiraient considérablement les risques d'accident. Les
chercheurs technologiques et les constructeurs automobiles aujourd’hui pensent à des voitures
capables de circuler dans le trafic réel en toute situation et sans aucune intervention humaine,
« des voitures autonomes ». Pour cela, ils mettent à profit les dernières avancées
technologiques telle que l’intelligence artificielle qui sera également une composante
primordiale des futurs véhicules autonomes. Les véhicules autonomes seront capables, grâce
au « deep learning » de brasser d’immenses quantités de données, de déterminer ainsi quels
types de situations produisent généralement un accident, et ainsi de réagir lorsqu’une situation
similaire se présente.
Notre projet de fin d’étude « PFE » vient comme avantage et contribution à cette idée
qui est un thème d’actualité surtout qu’aujourd’hui une course s'élance chez les constructeurs
automobiles du monde entier pour obtenir rapidement des résultats concluants.
Le présent rapport décrit, en trois chapitres, le travail que nous avons réalisé le long du
stage.
Nous avons déjà commencé par un chapitre introductif présentant la société et
expliquant le sujet et le travail demander.
Le deuxième chapitre sera consacré à la tâche principale des voitures autonomes qui
est la conduite autonome tout en respectant le code de la route, la sécurité routière et toutes
les règles acquissent à la phase d’apprentissage. Aussi, ce chapitre explique en détail les
étapes de réalisation du prototype.
Dans le dernier chapitre, nous évoquerons le contrôle intuitif du véhicule à l’aide du
l’assistant virtuel intelligent. En effet face à la multiplication des fonctions offertes par les
véhicules connectés, l’assistant virtuel s’impose comme un copilote indispensable. L’assistant
virtuel donne l’accès aux différentes fonctions offert par le véhicule connecté à l’aide de
commandes vocales, permettant ainsi de ne pas détacher les yeux de la route. L’assistant
virtuel permet de contrôler son véhicule de manière parfaitement naturelle et intuitive, à l’aide
2
d’un mélange de commandes vocales et de gestes. Il peut également interpréter les
expressions faciales du conducteur. En plus d’exercer un empire total sur son véhicule,
l’assistant virtuel permet aussi de sécuriser le véhicule contre le vol grâce à la reconnaissance
faciale. Il peut ainsi détecter la fatigue du conducteur ou encore prendre des « selfies ».
Enfin, nous produisons une conclusion générale présentant une synthèse du projet et
les perspectives futures pour pouvoir l’exploiter.
3
Chapitre 1 :
Présentation de la société et du cadre du
projet
4
1.1. Introduction
Ce premier chapitre a pour objet d’expliquer le cadre du projet. Nous présentons la
société d’accueil « TASEMCO SYSTEMS TUNISIE », [2]. Notamment, nous définissons les
voitures autonomes, nous énumérons leurs avantages et nous expliquons d’avantage le cahier
de charge.
1.2. Présentation de la société
TASEMCO Systems est l’assistante technique dans les systèmes informatiques
embarqués. De la conception à la réalisation, l’équipe TASEMCO Systems multidisciplinaire
imagine des nouvelles installations, précise les cahiers des charges et anticipe les exigences
Les services proposés TASEMCO Systems par sont les suivants :
• R&D Industriels
TASEMCO Systems développe et installe des solutions industrielles par: étude et
installation de processus industriel, équipements de test, conception et maintenance des
systèmes automatisés, Conception des IHM pour la supervision des processus industriels.
Elle est aussi spécialisée dans la conception des installations électriques par ses
différents lots.
• Formations
TASEMCO Systems exerce son activité de formation de haute qualité sous l’agrément de
formation N° 11−1386/15. Notre talentueuse équipe contribue au développement de vos
ressources humaines à travers des modules de formations métier en : Systèmes
embarqués, Automatisme, Sécurité Électrique, Distribution Électrique, Production-
Qualité-Maintenance.
• ÉTUDE ÉNERGITIQUE
TASEMCO Systems est spécialisée dans la conception des installations électriques par
ses différents lots : Courants Forts, Poste de Transformation, Courants Faibles, Audit
Énergétique.
Les différents clients du TASEMCO Systems :
• IRIS TECHNOLOGIES
• TIS CIRCUITS
• LETI
• CRMN
5
1.3. Contexte général
On n’a pas besoin d'être un expert en technologie pour savoir que le sujet
technologique le plus brûlant aujourd'hui est l'intelligence artificielle. Il y a beaucoup de
polémique autour de ce sujet d’actualité. Pour mieux comprendre ce terme, nous devons
revenir à l’année 1955 quand Jay McCartney a inventé l'IA à la conférence de Dartmouth. IA
est une machine capable de résoudre des problèmes proposés par l’intelligence naturelle
humaine. En ce qui concerne la définition du terme intelligence Jack Copeland, l’écrivant de
plusieurs livres sur AI, pense qu’elle est la fusion de certains facteurs tels que: l'apprentissage
de la généralisation qui permet à l'apprenant de mieux performé dans des situations non
précédemment rencontrés, le raisonnement qui permet de tirer les conclusions appropriées à la
situation, la résolution des problèmes, l'environnement et l'analyse des caractéristiques et des
relations entre les objets. Il existe principalement deux catégories d’IA la super intelligence
ou l’intelligence forte qui est plus intelligente que l’intelligence humaine, ça semble quelques
choses bizarres qu’un homme conçu une machine plus intelligente que lui mais elle reste
théoriquement possible. Le deuxième type est l’IA faible qui est un système similaire à
l’homme en réalisant une seule tâche spécifique. Il fait ce que nous pouvons faire sans erreur
et beaucoup plus rapide. Jeff Dean le chercheur principal de « Senior Fellow » chez Google a
expliqué la performance du IA faible aujourd’hui au cours d’une présentation chez TEDx, [3]
en misant le point sur l’amélioration du taux d’erreur des IA dans certaines tâches de 26% en
2011 à 3% aujourd’hui. Sachant que le taux d’erreur de l’être humain est de l’ordre de 5%. En
guise de conclusion que les machines peuvent maintenant voir et reconnaître les objets mieux
que nous pour la première fois ce qui guide notre humanité vers une révolution technologique.
En effet les machines nous ont déjà dépassés dans certains domaines limités tels que les jeux
d’échec et GO les plus fameux jeux d’intelligente. Les meilleurs joueurs du monde ont été
vaincus par l'intelligence artificielle. Aucun joueur humain ne deviendra jamais le meilleur à
l'un ou l'autre de ces deux jeux, peu importe combien vous essayez même si vous entrainez
votre vie entière. Cette technologie a connu un énorme progrès pendant les cinq dernières
années grâce au développement des GPU. On connaît les techniques de l’IA depuis longtemps
mais elles n’étaient plus efficaces parce qu’il n’existe pas les moyens de calcul pour simuler
ces algorithmes mais aujourd’hui grâce au GPU ce problème est résolu. Ce progrès est
considéré comme une continuation de la révolution industrielle qui a eu lieu au cours des 200
dernières années. Aujourd’hui, l’IA est à la fois partout et invisible. Nous la retrouvons dans
nos machines informatiques, objets connectés, transports, réseaux sociaux applications et
6
même dans la publicité, [4]. Si vous avez un Smartphone vous utiliser une machine équipé
d’IA déjà. Cette technologie s’essaye aussi dans les domaines plus créatifs comme
« Wavenet » l’IA qui peut générer des sons bruts tels que la parole et la musique, « PBS idea
channel » l’IA qui écrit des courts-métrages et des films et « StackGAN » l’IA qui génère une
image réaliste à partir d’un texte descriptif. Il existe encore des IA très amusants qui regardent
une image statique et génèrent une vidéo de ce qu'il pensait arriverait dans les prochaines
secondes et d’autres qui pourraient deviner ce qui se passe sur la scène juste en écoutant
l’audio et qui peuvent aussi prédire le comportement humain dans un film. Les machines ont
également commencé à s’adapter au langage humain en écrivant des poèmes, publiant des
articles de presse et même à discuter avec les humains tels que « watson » l’IA de IBM qui
répond à des questions formulées. Et l’IA surprise de cette année a été publiée par
« gamilon » une société de Boston. Il est capable de réécrire son propre code en se basant sur
l'expérience et la probabilité. L'intelligence artificielle alors dominera les affaires pendant le
reste de l'histoire humaine, mais nous pouvons l'utiliser à notre service aujourd’hui et rendre
les tâches risquées plus sures et sans danger tel que la conduite. D’où l’idée de profiter le
maximum de cette technologie pour assurer l’automatisation et l’intelligence des véhicules.
1.4. Généralité sur les véhicules autonomes
1.4.1. Définition et types des véhicules autonomes
La voiture autonome c'est aujourd'hui une réalité, pas encore très développée c'est vrai
mais c'est une technologie promise à un bon avenir. Un véhicule autonome c'est un véhicule
capable de circuler dans le trafic réel en toute situation et sans aucune intervention humaine.
En effet elle avance, adapte sa vitesse, freine devant un piéton qui traverse, s'arrête au feu et
se gare tout seule. Ce qu'il faut savoir avant tout c'est qu'il n'y a pas d'un côté les voitures
autonomes et de l'autre côté les voitures classiques. Selon l'agence fédérale chargée de la
sécurité routière aux États-Unis, [5] il existe cinq niveaux d'autonomie. Le niveau 0
correspondant en gros à une voiture assez ancienne sans option et le niveau 4 à une voiture
complètement autonome n'ayant pas besoin d'intervention humaine pour se déplacer. Il y a
donc une augmentation progressive de l'autonomie des voitures et non une transformation du
niveau zéro au niveau 4. Par exemple les voitures ayant l'aide au stationnement ou encore le
régulateur de vitesse sont considérés comme étant au niveau 2 d'autonomie.
7
1.4.2. Avantages des véhicules autonomes
Les véhicules autonomes vont marquer un tournant dans l'histoire de l'automobile et
vont apporter de nombreux avantages sur différents aspects même s'il est compliqué de tous
les imaginer et de voir tous les secteurs qui vont être impactés mais on va essayer de citer le
maximum de ces avantages.
1.4.2.1. Les avantages sociétaux
Un des atouts majeurs de la voiture autonome est la sécurité qu'elle va apporter. C'est
d'ailleurs ce qui va permettre son adoption par le public. Aujourd'hui 90% des accidents de la
route sont provoqués par des humains, il est donc envisageable dans un monde rempli de
voitures sans conducteur de voir les accidents de la route diminue de plus de 90 %. En effet la
technologie à l'intérieur de la voiture ne peut pas ressentir de fatigue et peut rester
constamment concentrée sur la route. Elle est donc, même sur des longs trajets, 100% fiable
comparée à un être humain qui peut être distrait fatigué énervé alcoolisé etc. Ces voitures
deviendront de plus en plus sécurisées très rapidement. En effet, contrairement aux humains
qui apprennent principalement de leurs erreurs les voitures autonomes peuvent apprendre des
erreurs de toutes les voitures autonomes avec lesquels elles sont connectées. C'est d'ailleurs
pour ça que Google a lancé de son côté plusieurs prototypes sur les routes le plus tôt possible
afin d'acquérir un maximum de données et donc d'expérience. Elle permettra par conséquent
d'épargner de nombreuses vies dues aux erreurs humaines. Ensuite, la population amenée à se
déplacer va pouvoir s'élargir. En effet, si la voiture n'a plus besoin de conducteurs pour se
déplacer, on peut facilement imaginer que des enfants ou des personnes âgées n'ayant plus les
capacités de conduire pour se déplacer à l'aide de ces véhicules sans chauffeur. Les jeunes
n'auront donc plus besoin de passer le permis. Le temps de voiture ne sera plus perdu car les
occupants pour focaliser leur concentration sur autre chose comme lire dormir ou tout
simplement réfléchir tranquillement. Les limitations de vitesse pourront augmenter
considérablement ce qui permettra de réduire le temps de trajet. La disparition des
embouteillages dus à une régulation instantanée du trafic grâce à la communication entre
véhicules accentuera encore ces diminutions de trajet. En effet on peut imaginer que si la
voiture de devant Freines toutes les voitures de derrière soit au courant en une fraction de
seconde et prenne la même décision il en est de même pour les démarrages et d'accélération
ce qui améliorera de façon considérable la fluidité sur les routes. De plus, lorsqu’un accident
se produit, les conducteurs humains de la voie opposée ralentissent pour regarder et ainsi
8
satisfaire leur curiosité, créant un embouteillage. Ce problème ne se pose pas avec l’IA. Enfin
la voiture autonome pourra vous déposer devant votre point d'arrivée pour aller se garer plus
loin tout seul et reviendra vous chercher quand vous le voudrez ce qui évitera de chercher une
place et de marcher inutilement.
1.4.2.2. Les avantages écologiques
Comme indiqué précédemment les voitures autonomes auront un style de conduite
beaucoup plus linéaire et fluide et vont donc permettre d'avoir une consommation inférieure à
une voiture pilotée par un humain. Pour information on roulait juste derrière une autre voiture
peut faire économiser plus de 25% de la consommation de carburant et les voitures autonomes
seront tout à fait capables de rouler à quelques centimètres les unes des autres grâce à leur
rapidité de communication et de réaction. La diminution dans la disparition des
embouteillages va permettre de réduire considérablement notre impact sur le réchauffement
climatique et la pollution dans les grandes villes. La qualité de l'air va s'améliorer en
entraînant de nombreux avantages au niveau de la santé et de l'environnement n'oublions pas
que ces voitures seront probablement tout électriques ce qui permettra de s'affranchir du
pétrole et des rejets toxiques. Les voitures autonomes pourront faciliter la mise en place de
covoiturage car elles connaîtront le trajet de chaque utilisateur avant le départ et pourront
trouver des itinéraires optimaux en prenant un maximum de personnes au passage ce qui
baisserait à la fois le nombre de voitures sur les routes et l'énergie utilisée. Enfin dans la
mesure où le besoin de sécurité de ses véhicules sera amoindrie de par leur fiabilité ces
derniers auront besoin de moins de protection et d'une carrosserie moins épaisse qui fera
encore économiser en énergie car la voiture sera plus légère et donc plus facile à déplacer. De
plus les ressources telles que les métaux et les plastiques utilisés pour la construction des
voitures seront réduites. Il ne faut pas oublier qu'aujourd'hui les gaz à effet de serre émis au
cours de la fabrication d'une voiture peuvent représenter jusqu'à 10% des émissions sur sa
durée de vie totale.
1.4.2.3. Les avantages économiques
Commençons par quelques chiffres, en 2009 environ 5,5 millions d'accidents de
voiture sont arrivés aux États unis impliquant au total 9,5 millions de véhicules, en
additionnant les coûts liés aux accidents eux-mêmes plus les dommages collatéraux à savoir
les frais médicaux et hospitaliers, les dommages matériels sur les voies et les chaussées, les
frais juridiques, les retards sur les trajets causés par les embouteillages et la dégradation de la
qualité de vie pour les habitants l’American Automobile Association, [6] qui a étudié les
9
données des accidents dans les 99 plus grandes villes américaines, estime le total des coûts à
300 milliards de dollars. Si ce chiffre est ajusté à non plus et 99 villes mais aux États unis
dans leur ensemble ils se rapprochent des 450 milliards de dollars si on prend maintenant on
compte le fait que Google annonce une réduction de 90% des accidents avec les voitures
autonomes les dépenses peuvent être réduites d'au moins 400 milliards de dollars par an aux
États unis. De plus une étude estime que les embouteillages on perd 4,8 milliards d'euros
chaque année et 1,9 milliard de litres de carburant ce qui représente environ 100 milliards de
dollars de pertes en productivité pour les entreprises et en combustible. Ajouté au chiffre
précédent les voitures autonomes pourraient permettre de faire économiser 550 milliards de
dollars par an aux États unis. Les assurances automobiles seraient fortement impactées au
niveau économique. En effet au lancement des premières voitures autonomes sur les routes
étant qu'elles ne seront pas considérés comme 100% fiable par la loi les assureurs
bénéficieront d'une période où leur chiffre d'affaires augmentera car les gens continueront de
payer par obligation mais n'auront plus d'accidents. Mais à long terme le système d'assurance
va devenir complètement obsolète ou du moins les structures d'assurances et de mutuelles
comme nous connaissons aujourd'hui devraient disparaître au profit des assurances dispensées
par les constructeurs automobiles eux-mêmes. En France par exemple on peut voir que la
MAIF, société d'assurance mutuelle française, [7] a très bien compris ces évolutions futures et
commencer à les appréhender en adoptant une vraie transformation digitale ce qui est
nécessaire car 60% de son chiffre d'affaires est basé sur l'assurance automobile. Son directeur
Pascal Démurger publie d'ailleurs régulièrement des articles sur le sujet des voitures
autonomes ce qui montre encore une fois une prise de conscience importante non pas
uniquement chez les constructeurs automobiles mais surtout les services qui sont amenés à
être impactée dans un futur proche et qui ont besoin de se réinventer pour survivre à ce
bouleversement. On peut par exemple imaginer un modèle comme celui des régies
publicitaires sur internet. Lorsque quelqu'un lancera un trajet à partir d'une voiture autonome
une petite vente aux enchères de ce voyage sera disponible aux potentiels assureurs qui
pourront ajuster les prix en fonction du trajet choisi de la météo du nombre de véhicules sur
les routes de l'état des voies etc. Les voitures deviendront donc des plateformes d'information
à part entières pour les assureurs. Le changement va également impacter les villes et les états
aussi. Une étude du l’MIT affirme que dans certaines villes des États unis les parkings
couvrent plus d'un tiers de la surface disponible. D'autres études estiment qu'il y a environ 2
milliards de places de parking aux États unis. Si les personnes ne sont plus propriétaires de
leurs voitures mais que les voitures autonomes deviennent des services qui se baladent de
10
point en point pour transporter des clients on peut imaginer que la quasi-totalité des places de
parking deviennent inutiles. L'espace libéré pourrait faire apparaître de nouveaux logements et
donc faire baisser considérablement le prix de l'immobilier dans les grandes villes. Les
nouvelles infrastructures des routes permettront également de faire des économies pour les
états. En effet les feux de circulation ne seront plus nécessaires dans les rues ou encore
l'éclairage public devrait être amené à disparaître en particulier en campagne car les capteurs
de voitures autonomes peuvent se diriger sans problème dans le noir. Les nouvelles roues
pourront également être beaucoup plus étroites car ces voitures étant connecté ayant des
temps de réaction extrêmement rapide elles ne seront pas obligées d'avoir des distances de
sécurité aussi grandes que nous avons aujourd'hui. Le côté services pourra énormément se
développer grâce aux temps libres des anciens conducteurs durant leur trajet. Les entreprises
pourront proposer des divertissements et des distractions accompagnées certainement de
publicité. Enfin les usagers ne seront pas obligés de posséder des voitures mais pourront louer
uniquement quand ils en auront besoin pour se déplacer. En moyenne une voiture est utilisée
33 minutes par jour ce qui correspond en gros à 2,3 % de la journée et elle est à l'arrêt le reste
du temps. L'avantage de cette location permettrait d'optimiser la possession d'une voiture en
fonction de son trajet et donc de ne payer que pour les 15 ou 20 minutes par jour selon les
besoins au lieu de louer des voitures à la journée pour ne pas s'en servir ce qui fera
économiser beaucoup d'argent aux consommateurs, [8],[9].
1.5. Etude de l’existant
Actuellement les voitures les plus avancées telles que la Google car où le tesla, pour
citer les plus connus, sont au niveau 3 d'autonomie c’est-à-dire que dans de bonnes conditions
de circulation la voiture arrive à se diriger seul mais le conducteur a toujours besoin d'être
attentif pour pouvoir reprendre le contrôle du véhicule à n'importe quel moment si des
événements inhabituels ce produit sur la route. Parmi les entreprises technologiques qui ne
compte pas dans leur cœur de métier la construction de voitures mais qui se sont penchés sur
cette nouvelle technologie on peut citer par exemple : Google, Apple, Baidu, Microsoft ou
Uber. Jusqu'à maintenant c'est Google qui a le record de la plus longue distance parcourue
sans prise de volant par un humain avec 3,2 millions de km au total. La voiture complètement
autonome n'est donc plus très loin et le niveau d'autonomie 4 devrait voir le jour dans les
prochaines années. Parlons donc des prévisions de la date d'arrivée de ces véhicules en
s'appuyant sur les dires des constructeurs et des entreprises technologiques. On parle des
prévisions de l'arrivée du niveau 4 uniquement et non de sa mise en libre circulation publique
11
et de son adoption réglementaire. Elon Musk le fondateur du tesla a prévu d'avoir une voiture
complètement autonome en 2018. Google de son côté se positionne entre 2017 et 2020 mais
n'a pas donné de date précise quant à l'arrivée de la voiture complètement autonome. On peut
noter toutefois sa volonté d'accélérer les choses en ouvrant une nouvelle filiale appelée
WAYMO spécialisé dans les voitures autonomes. Audi Nissan et Volvo annoncent la date de
2020. Vous avez d'ailleurs dû voir la pub Volvo qui assure qu'à partir de 2020 il n'y aura plus
de tués et de blessés dans leur voiture. Ford annonce des prévisions légèrement supérieures
avec la date de 2021 Jaguar, Intel et l'équipementier automobile continental prévoit une date
un peu plus éloignée à savoir 2025. Enfin Uber avance une flotte de véhicules autonomes à
l'horizon 2030. Avec toutes ces déclarations on peut probablement compter sur une voiture
complètement autonome avant 2022 pour les premiers dans la course et une arrivée massive
vers 2025 de la part de tous les constructeurs. En guise de conclusion que le sujet des voitures
autonomes est un sujet technologique d’actualité en cours de recherche et de développement
et donc nous pouvant dans le cadre d’un PFE développer une solution technologique
permettant d’affranchir le niveau 3 et passer vers le niveau 4.
1.6. Cahier de charge
L’objectif de ce projet de fin d’études est de chercher une solution technologique
réelle pour rendre les véhicules autonomes capables de passer du niveau 3 au niveau 4
d’autonomie. De même on cherche à construire un logiciel de tableau de bord contenant des
applications qui facilite le contrôle interne du véhicule tout en assurant la sécurité interne et
externe et l’intelligence du véhicule. Le travail se divise donc en deux grandes parties la
première s’intéresse à l’autonomie du véhicule et la seconde se concentre sur les applications
de contrôles comme le montre le graphe suivant :
12
1.6.1. Autonomie
L’extension du block autonomie de conduite est illustrée dans l’organigramme suivant.
Véhicule intelligente autonome
Autonomie de Conduire en respectant le code de
la route.
Détection des objets en dehors du
véhicule
Traitement des données et contrôle
Contrôle interne
Application androïde
Surveillance
Stationnement (commande)
Connexion avec le véhicule
Reconnaissance faciale
Sécurité du véhicule
Détection du fatigue
Assistante vocale
Commande de quelque fonctions
internes
Détection d’émotion
Commandes vocales et de gestes
13
1.6.2. Contrôle interne
Le block contrôle interne est détaillé dans l’organigramme suivant.
1.6.3. Validation
En ce qui concerne la validation elle se divise en 2 volés comme il montre le schéma suivant.
1.7. Conclusion
Dans ce chapitre, nous avons présenté la société d’accueil. Puis, nous avons parlé des
voitures autonomes. Ensuite, nous avons fixé l’objectif du stage en détaillant notre cahier de
charge. Cela nous amène au chapitre suivant pour présenter d’une manière détaillée les deux
grandes parties de notre projet.
14
Chapitre 2 :
Conduite autonome et réalisation du
prototype
15
2.1. Introduction
Ce chapitre expose le prototype réalisé en expliquant en détaille les problèmes
affrontés et les solutions trouvées. Nous commencerons par une analogie de notre modèle
avec le modèle réel. Puis, nous diviserons le projet en des petites unités. Par la suite, nous
consacrerons une partie pour expliquer la réalisation de chacune de ces unités à part.
2.2. Fonctionnement et système de pilotage des voitures autonomes
Il existe plusieurs technologies de voiture autonome mais grosso modo elle fonctionne
tout à peu près de la même manière. En effet la voiture doit avoir des yeux, mais elle doit
aussi avoir un cerveau, une intelligence artificielle infaillible, pour analyser son
environnement et pour prendre les bonnes décisions au bon moment.
2.2.1. Yeux du véhicule
Pour que la voiture conduise à notre place, elle doit d'abord avoir des yeux. Il lui faut
donc installer une multitude de capteurs, comme des caméras, des radars, un laser au niveau
des pare-chocs, ou encore des capteurs ultrasons tout autour de la voiture. Ils collectent toutes
les informations extérieures utiles à la conduite, comme le trafic routier ou les panneaux de
signalisation. Si la voiture se maintient toute seule au centre de sa voie de circulation, c’est
grâce à une caméra placée au niveau du pare-brise. Elle détecte au sol les lignes à suivre. Elle
repère aussi la forme, la couleur et lit les panneaux pour respecter les limitations de vitesse.
Cette caméra identifie aussi les voitures, les deux-roues, éventuellement les piétons ou les
animaux présents sur la route. Sur les véhicules haut de gamme il y a même une caméra
infrarouge servante à déceler les mêmes obstacles la nuit. Les informations recueillies par les
caméras sont aussi collectées par d’autres capteurs, comme des radars longs portés à l’avant et
à l’arrière, qui fonctionnent quelle que soit la météo. Le véhicule est également équipé de
lasers que l’on appelle LIDAR. En effet, les LIDARS sont des radars qui n'ont pas des ondes
radio comme dans les avions mais un faisceau laser. Ils reconstituent en 3D l'environnement
situé à 360° autour de la voiture. En plus de détecter les lignes et les panneaux, ils apportent
d'autres informations. Ils mesurent précisément la distance qui sépare la voiture autonome des
autres véhicules, et ils estiment leur vitesse. C’est un peu comme si la voiture avait des yeux
et si elle pouvait voir littéralement la route ainsi que les obstacles. Il y a enfin les capteurs à
ultrasons y compris sur les côtés qui servent à détecter les obstacles à faible distance par
exemple une voiture en train de doubler.
16
2.2.2. Cerveau du véhicule
Les informations brutes collectées par tous les capteurs sont acheminées vers le
cerveau de la voiture, le logiciel informatique. C’est lui le pilote. En temps réel, il analyse,
recoupe et donne un sens aux données en tenant compte évidemment des règles de conduite
qu'on lui est entré en mémoire. C’est une véritable intelligence artificielle. Par exemple si la
caméra et le LIDAR détectent une forme. Le logiciel reconnaît une apparence humaine et
l'interprète donc comme étant un piéton. C'est à partir de cette interprétation que le logiciel
anticipe et comprend que le piéton s'engage sur le passage piéton. Il prend donc la décision
d'activer les freins pour stopper la voiture. Mais pour prendre des décisions dans toutes les
situations, le logiciel doit d'abord passer son permis en apprenant à reconnaître les panneaux,
à différencier les voitures, les deux-roues, les camions, les piétons, et à mémoriser une grande
diversité de scénarios, comme l'arrêt brutal d'une voiture, pour être capable d'adapter la
réponse dans toutes les circonstances.
2.3. Prototype
2.3.1. Problématique
Dans un modèle réel d’une voiture autonome, il existe plusieurs composants
indispensables pour la conduite sans volant. Ces composants sont généralement très chers. Tel
que le kit « NVIDIA DRIVE » qui contient une plateforme IA qui permet aux constructeurs
de l’industrie automobile, aux startups et à leurs fournisseurs directs d’accélérer la production
des véhicules automatisés et autonomes. Cette plateforme peut fusionner les données
transmises par un total de 12 caméras, radars, modules de télédétection et capteurs
ultrasoniques. Les algorithmes automobiles peuvent ainsi analyser avec précision
l'environnement du véhicule sur 360 degrés afin de produire une représentation réaliste et
fiable incluant les objets statiques et dynamiques. Ce kit contient aussi l’un des composants
chers et indispensables au véhicule autonome qui représente son côté hardware. C’est son
cerveau le supercalculateur NVIDIA DRIVE PX Pegasus qui délivre plus de 320 trillions
d'opérations « deep learning » par seconde, [10]. Cette énorme puissance de calcul s’impose
dans les marchés avec des prix imaginaires. Pour cela il faut chercher une solution adaptée à
nos moyens.
2.3.2. Analogie entre prototype et modèle réel
Notre prototype est constitué essentiellement de 3 unités qui imitent identiquement le
modèle réel. Une unité d’acquisition des donnés externes qui reproduit le même
17
fonctionnement des radars, des lidars, des caméras et des capteurs ultrason. Elle ramasse et
transmise les données vers l’unité de traitement qui reçoit, traite, raisonne, apprit et prend des
décisions. Cette unité est en fait dédiée essentiellement au calcul. Telle que le
supercalculateur de la société NVIDIA. En ce qui concerne les actions humaines nécessaires
pour conduire un véhicule ils sont remplacés par une unité de commande.
2.3.3. Étape de réalisation du prototype
2.3.3.1. Unité d’acquisition
Cette unité est constituée d’une carte Raspberry Pi lié à un module de caméra et un
capteur ultrason HC-SR04. Cette unité doit être obligatoirement attachée au prototype pour
collecter les données d’entrées de traitement et d’apprentissage lors du déplacement de notre
voiture. Et vu qu’on n’a pas une carte à intégrer dans notre prototype qui fournit la puissance
de calcul nécessaire on a séparé les autres unités du véhicule. L’unité d’acquisition des
données doit transmettre les valeurs du capteur et la vidéo de la caméra en temps réel vers
l’unité de traitement.
2.3.3.2. Unité de traitement
L'unité de traitement est substituée par un GPU NVIDIA GTX 1050. Elle gère
plusieurs tâches : la réception de données de Raspberry Pi, apprentissage au début et
prédiction ensuite de la direction du freinage et de l’accélération grâce à un réseau de
neurones profonds, détection d'objets « stop et feu de circulation », mesure de distance et
envoi d'instructions vers l’unité de commande via connexion USB.
À travers l’exécution d’un programme pendant les deux phases l’apprentissage et la
conduite notre ordinateur reçoit d’une façon continue les vidéos pour la conduite, les mesures
du capteur pour éviter des collisions et les images d’apprentissage qui se convertie en
intensité de gris et se transforme en un tableau de données numériques.
Comme indiqué précédemment le cerveau de la voiture doit d'abord passer son permis,
et donc passer obligatoirement par une phase d’apprentissage. Au cours de cette phase notre
prototype apprend les règles de conduite en entrainent un réseau de neurones profond
multicouches par des données déjà acquises au cours de la phase de la conduite manuelle. En
effet, chaque image captée à la conduite manuelle est préparée pour les taches d’apprentissage
et couplée avec l’entrée humaine la décision du conducteur humain à cet instant et
sauvegardée sous la forme d’un fichier « npz ».
18
L’entrée du réseau est une image QVGA de résolution (320×240) et puisque la caméra
raisonne sur les lignes tracées sur les routes on peut se limiter au cours de l’apprentissage à la
moitié inférieure de l’image. La résolution d’entrée devient (320×120) et donc la couche
d’entrée doit contenir 38400 nœuds. Le nombre de nœuds dans la couche cachée est choisi
arbitrairement et modifier avec chaque essai pour améliorer la prédiction. Il y a quatre nœuds
dans la couche de sortie où chaque nœud correspond aux instructions de l’accélération, du
freinage et du contrôle de direction: gauche, droite.
Figure 2: Conception du réseau de neurones.
Figure 1: Acquisition des données d'apprentissage.
19
Le réseau de neurones est finalement formé en utilisant la méthode de rétro-propagation à
l’aide de la bibliothèque Open CV, [11]. Une fois l'entraînement terminé, les poids sont
enregistrés dans un fichier XML. Pour générer des prédictions, le même réseau de neurones
est construit et chargé avec le fichier XML formé.
Le prototype est capable de localiser et d'identifier plusieurs objets dans une même
image grâce à l’API TensorFlow Object Détection. Cet API peut être utilisé pour détecter,
avec des boîtes, des objets dans des images et des vidéos en utilisant certains des modèles pré-
entrainer mis à disposition tel que YOLO « You only look once » qui est très performant aux
détections en temps réel ou à travers des modèles qu’on peut former nous-même facilement.
Figure 3: Détection d'objets.
Ce projet a adapté un modèle géométrique de détection de distance à un objet en
utilisant la méthode de vision monoculaire.
20
2.3.3.3. Unité de commande
La voiture utilisée dans ce projet a une manette de type interrupteur marche arrêt.
Quand un bouton est enfoncé, la résistance entre la broche de puce et la masse est nulle.
Ainsi, une carte Arduino est utilisée pour simuler des actions de bouton-presse. Quatre
broches Arduino sont choisies pour connecter quatre broches de puce sur la manette,
correspondant respectivement aux actions avant, arrière, gauche et droite. L'Arduino est
connecté à l'ordinateur via USB. L'ordinateur envoie les commandes à Arduino à l'aide de
l'interface série, puis l'Arduino lit les commandes et écrit les signaux LOW ou HIGH,
simulant des actions de bouton-pression pour conduire la voiture.
2.4. Conclusion
Dans ce chapitre, nous avons détaillé le prototype développé. Puis nous avons décrit
une analogie de notre modèle avec le modèle réel. Ensuite, nous avons expliqué les étapes de
la réalisation de chacune des unités.
21
Chapitre 3 :
Contrôle interne du véhicule « assistant
virtuel »
22
3.1. Introduction
Ce chapitre expose l’assistant virtuel en expliquant ses différentes fonctions. D’abord,
une initiation à l’intelligence artificielle et une comparaison entre les « Framework » seront
détaillées. Par la suite, une partie est consacrée pour expliquer les options de l’assistant
virtuel.
3.2. Présentation de l'intelligence artificielle
3.2.1. Introduction
Le concept d'intelligence artificielle est né dans la tête de scientifiques qui évoque
l'idée d'une machine pouvant être doté de capacités cognitive similaire à l'homme. En gros
une machine qui résonne, réfléchi, analyse et apprend comme l'humain. Plus précisément
l'intelligence artificielle c'est une technique informatique qui permet aux machines de
reproduire des fonctions que seul un être humain peut faire du fait de leur complexité comme
traiter une grosse quantité d'informations là où il faut beaucoup de monde et beaucoup de
temps. Une intelligence artificielle le fera en quelques secondes laissant du coup du temps
pour d'autres occupations. Le terme intelligence artificielle est apparu pour la première fois
lors d'une conférence à l'université de Dartmouth en 1956 mais le premier exploit de
l'intelligence artificielle c'est quand l'ordinateur « Deep Blue » bat le génie des échecs
« Kasparov » en 1997, [12]. À l'avenir c'est elle qui nous permettra de se déplacer dans des
voitures autonomes et d'avoir des robots domestiques. L’intelligence artificielle aujourd’hui
existe partout dans notre quotidien par exemple avec les chat-boot, les programmes
intelligents de discussions, ou dans l'autocorrection des Smartphones qui permet d'envoyer
des SMS sans fautes d'orthographe ou encore avec la commande sans les mains grâce à la
reconnaissance vocale. Voilà l'intelligence artificielle est partout mais pour le moment c'est
encore l'homme qui est obligé de montrer à la machine ce qu’elle doit comprendre pour l'aider
à se fabriquer sa propre représentation du monde ça s'appelle le Machine Learning ou
l'apprentissage automatisé : c'est comme si la machine était un enfant qui découvre un chat et
apprend en même temps que ça s'appelle un chat sauf que tu n'es pas obligé de répéter 200
fois l'information pour qu'ils intègrent. Mais très vite on va passer au stade supérieur avec le
Deep Learning ou l'apprentissage profond. L'homme conçoit la machine de demain pour
qu'elle fonctionne comme le cerveau humain et ses réseaux neuronaux pour qu'elle fasse tout
seul son l'apprentissage qu'elle découvre par elle-même et qu'elle se fasse ses propres
raisonnements comme l’homme. C’est comme ça par exemple qu'une voiture peut se conduire
23
toute seule. Elle apprend par elle-même à comprendre le système de circulation et peut même
anticiper le comportement d'autres véhicules imprudents ou potentiellement dangereux.
3.2.2. L'Apprentissage Automatique
De nos jours, les techniques mises en œuvre pour doter les machines de capacités
cognitives similaire à l'homme sont nombreuses, citant par exemple la logique floue, les
algorithmes génétiques, l’inférence bayésienne. Mais aujourd’hui c’est l’apprentissage
automatique et plus précisément les réseaux de neurones et l’apprentissage profond qui
représente la branche la plus active de cette discipline au point d'être sur les lèvres de toutes
les grandes entreprises. Selon Arthur Lee Samuel, le pionnier américain d’intelligence
artificielle de l’apprentissage automatique, « l'apprentissage automatique peut être vu comme
l’ensemble des techniques permettant à une machine d’apprendre à réaliser une tâche sans
avoir à la programmer explicitement pour cela ». Il existe principalement 3 types
d’apprentissage : supervisé, non supervisé et par renforcement.
3.2.2.1. Apprentissage supervisé
L’apprentissage supervisé consiste à déterminer automatiquement des règles pour
étiqueter correctement des exemples en se basant sur des donnés d’apprentissage contenant
des exemples généralement traités et validés.
Figure 4: Processus de l'apprentissage supervisé.
24
Figure 5: Schéma de principe de l'apprentissage supervisé.
Dépendant de la nature de la sortie que l'on cherche à estimer « une valeur dans un ensemble
continu de réels ou des valeurs finies » l’apprentissage peut être une régression ou une
classification.
3.2.2.2. Apprentissage non supervisé
L'apprentissage non supervisé consiste à apprendre sans superviseur. L'algorithme doit
donc découvrir par lui-même la structure des données puisqu’il ne possède pas des données
classées.
Figure 6: Schéma de principe de l'apprentissage non supervisé.
3.2.2.3. Apprentissage par renforcement
L’apprentissage par renforcement consiste à prendre des décisions qui conviennent
pour différentes situations à partir de l’expérience l’algorithme apprend un certain
comportement en s’interagissant répétitivement avec l’environnement, [13].
25
Figure 7: Schéma de principe de l'apprentissage par renforcement.
3.2.3. Les différents types d'algorithmes
Chaque type d'apprentissage peut s'appuyer sur différents algorithmes. En effet, ces
algorithmes sont nombreux. Aujourd’hui je vais citer les plus important et que je vais utiliser
ultérieurement au sin de ce projet.
3.2.3.1. Régression linéaire
La régression linéaire est l’algorithme le plus basique et qui cherche à établir une
relation linéaire entre la variable prédictive et la variable à prédire. Ça revient à déterminer les
paramètres du modèle qui sont les coefficients ‘a’ et ‘b’ de l’équation suivante:
Figure 8: Une représentation des données d’entrée par rapport à un classificateur linéaire.
Ou ‘a’ est la pente, ‘b’ est la constante et est un bruit qui permet la bonne identification de
la relation.
26
Après avoir déterminé tous ces paramètres on utilise cette équation pour prédire des nouvelles
données. Le majeur inconvénient de ce système est qu’il n’est performant que pour les
relations simples entre les données. Pour le cas des courbes plus complexes les algorithmes du
type SVM sont très efficaces.
3.2.3.2. Arbre de décision
L’arbre de décision est une technique simple d’aide à la décision utilisée en
apprentissage automatique. Cet outil essaye de distribuer les données d’apprentissage sur les
paramètres des vecteurs en associant aux nœuds internes des tests sur les paramètres, aux
branches les solutions du test et aux feuilles les valeurs des variables cibles.
3.2.3.3. KNN « Plus proches voisins »
La méthode des K plus proches voisins « k-NN k-nearest neighbor » est une approche
simple. Elle consiste à estimer la sortie associée à une nouvelle entrée en tenant compte des K
voisins plus proches des données connues, [12].
3.2.3.4. Réseaux de neurones artificiels
Actuellement, les algorithmes de type des réseaux de neurones artificiels sont des
outils qui tirent le domaine d’intelligence artificiel vers le haut. Ils sont appliqués pour
résoudre des problèmes difficiles tels que les problèmes de classification, de prédiction,
d’optimisation et de reconnaissance des formes. Les neurones artificiels tendent à reproduire
le fonctionnement des neurones biologiques. En fait, ils sont une façon de construire
facilement des modèles très complexes et non linéaires. Le bloc de base d’un réseau de
neurones est le PERCEPTRON : c’est système avec n entrées « variables du modèle »
pondérées par des poids de connexion, et autant de sorties que classes à prédire. Les poids de
connexion représentent la force de production de la variable pour le problème.
Figure 9: Fonctionnement d'un neurone.
27
Les entrées pondérées passent par une fonction dite « de combinaison » qui produit une seule
valeur dite somme pondérée qui va être soumise à son tour à une fonction « seuil ».
3.3. L’apprentissage profond
Cette nouvelle méthode existe depuis un certain temps, elle évolue rapidement et
construit maintenant notre avenir. L'apprentissage profond est une branche de l'apprentissage
automatique qui cherche à imiter l'activité neuronale du cerveau humain sur des réseaux de
neurones artificiels afin qu'il puisse apprendre à identifier les caractéristiques de données
numériques telles que l'image ou la voix. L'apprentissage en profondeur nous permet de
trouver facilement des solutions à des problèmes très complexes. Le « Deep Learning » se
repose sur les réseaux de neurones juxtaposés « des réseaux de neurones constitués de
plusieurs couches ». Plus le nombre de couches de neurones est élevé, plus le réseau est
profond. Cette technologie à de nombreuses utilités. Elle est efficace sur le traitement de
donnés et existe partout dans notre quotidien. Dans cette partie on va citer quelques
algorithmes de « Deep learning » qu’on a utilisés pour la création de l’assistant.
3.3.1. Le réseau de neurones multicouches MLP « Multi Layer Perceptron »
L’incontinent majeur du perceptron c’est qu’il n’apprend que les fonctions
linéairement séparables. Pour résoudre ce problème nous avons passé à un perceptron
multicouche. C’est une composition de plusieurs perceptrons pour créer un mécanisme plus
puissant. Ces perceptrons sont organisés sous forme de plusieurs couches et l’information
circule de la couche d’enter vers la couche de sortie en passant par les couches cachées
« feedforward ».
Figure 10: Réseau de neurones multicouches.
28
3.3.2. Réseaux de neurones récurrents « RNN »
Les humains ne commencent pas leur réflexion à partir de zéro chaque seconde, on
comprend chaque mot en fonction de notre compréhension des mots précédents. On ne jette
pas tout et on recommence à penser à partir de zéro. Nos pensées ont de la persévérance. Les
réseaux de neurones traditionnels ne peuvent pas le faire, et cela semble être une lacune
majeure. Par exemple, imaginant que nous souhaitons classer le type d'événement qui se
produit à chaque étape d'un film. Un réseau de neurones traditionnel ne pourrait pas utiliser
son raisonnement sur des événements antérieurs dans le film pour nous informer des
événements postérieurs. Les réseaux de neurones récurrents résolvent ce problème. Ce sont
des réseaux avec des boucles qui permettent à l'information de persister.
Figure 11: Réseau de neurones récurrents.
Dans le schéma ci-dessus, un segment de réseau neuronal, A, traite une entrée xt et fournit
une valeur ht. Une boucle permet de passer des informations d'une étape du réseau à l'autre.
Un réseau de neurones récurrent peut être considéré comme des copies multiples du même
réseau, chacune transmettant un message à un successeur. Considérons ce qui se passe si nous
déroulons la boucle:
Figure 12: Décomposition du CNN.
Cette nature en chaîne révèle que les réseaux neuronaux récurrents sont liés aux séquences et
aux listes. Ils sont l'architecture naturelle du réseau de neurones à utiliser pour de telles
données. Au cours des dernières années, il y a eu un succès incroyable en appliquant les RNN
29
à une variété de problèmes: la reconnaissance de la parole, la modélisation du langage, la
traduction, le sous-titrage des images ...surtout avec l'utilisation de "LSTM", un type de
réseau de neurones récurrent très spécial, qui fonctionne pour beaucoup de tâches, ce type est
beaucoup plus efficace que la version standard. Presque tous les résultats excitants basés sur
des réseaux neuronaux récurrents sont atteints avec eux.
3.3.2.1. Dépendances à long terme
Parfois, nous avons seulement besoin de regarder des informations récentes pour
effectuer la tâche actuelle. Par exemple, considérons un modèle de langage essayant de
prédire le mot suivant sur la base des précédents. Si nous essayons de prédire le dernier mot
dans "les nuages sont dans le ciel", nous n'avons pas besoin de plus de contexte - il est assez
évident que le prochain mot va être le ciel. Dans tels cas, où l'écart entre l'information
pertinente et l'endroit du mot à prédire est faible, les RNN peuvent apprendre à utiliser
l'information passée.
Figure 13: Exemple de production sans contexte.
Mais il y a aussi des cas où nous avons besoin de plus de contexte. Essayons de prédire le
dernier mot du texte «J'ai grandi en Tunisie ... Je parle couramment l’arabe.» Des
informations récentes suggèrent que le mot suivant est probablement le nom d'une langue,
mais si nous voulons réduire la langue, nous devons avoir le contexte de la Tunisie, des
segments des réseaux neuronaux. Il est possible que l'écart entre l'information pertinente et le
point où il est nécessaire de devenir le mot soit très grand. Malheureusement, dans ce cas, les
RNNs deviennent incapables d'apprendre à connecter l'information.
30
Figure 14: Exemple de production impossible sans contexte.
En théorie, les RNNs sont absolument capables de gérer telles «dépendances à long terme».
Un humain pourrait choisir avec soin des paramètres pour résoudre les problèmes de cette
forme. Malheureusement, dans la pratique, les RNN ne semblent pas être capables de les
apprendre. Le problème a été étudié en profondeur par Hochreiter (1991) et Bengio, et al.
(1994), qui ont trouvé des raisons assez fondamentales pour lesquelles cela pourrait être
difficile. Heureusement, les LSTM n'ont pas ce problème!
3.3.2.2. Réseaux LSTM
Les réseaux de mémoire à long terme à court terme, généralement appelés simplement
«LSTM», sont un type spécial de RNN, capable d'apprendre les dépendances à long terme. Ils
ont été introduits par Hochreiter & Schmidhuber (1997) et ont été affinés et popularisés par de
nombreuses personnes dans le cadre de leurs travaux. Ils travaillent très bien sur une grande
variété de problèmes et sont maintenant largement utilisés. Les LSTM sont explicitement
conçus pour éviter le problème de dépendance à long terme. Se souvenir d'une information
pendant de longues périodes est pratiquement leur comportement par défaut, pas quelque
chose qu'ils ont du mal à apprendre. Tous les réseaux neuronaux récurrents ont la forme d'une
chaîne de modules répétitifs de réseau neuronal. Dans les RNN standard, ce module répétitif
aura une structure très simple, telle qu'une couche de tanh unique, [14].
Figure 15: Architecture interne des LSTM.
31
3.3.2.3. Modèles de séquence à séquence « Seq2seq »
Le noyau du modèle consiste en une cellule LSTM qui traite un mot à la fois et calcule
les probabilités des valeurs possibles pour le mot suivant dans la phrase. L'état de la mémoire
du réseau est initialisé avec un vecteur de zéros et est mis à jour après la lecture de chaque
mot. Un modèle séquence à séquence de base est constituée de deux réseaux neuronaux
récurrents « RNN »: un codeur qui traite l'entrée et un décodeur qui génère la sortie. Cette
architecture de base est décrite ci-dessous.
Figure 16: Composition du modèle séquence à séquence.
Chaque case de l'image ci-dessus représente une cellule du RNN, le plus souvent une cellule
LSTM. L'encodeur et le décodeur peuvent partager des poids ou utiliser un ensemble différent
de paramètres. Des cellules multicouches ont également été utilisées avec succès dans des
modèles séquence-à-séquence, par exemple pour la traduction. Dans le modèle de base décrit
ci-dessus, chaque entrée doit être codée dans un vecteur d'état de taille fixe, car c'est la seule
chose transmise au décodeur. Pour permettre au décodeur un accès plus direct à l'entrée, [15].
Figure 17: Modèle séquence à séquence.
3.3.2.4. Neural Machine Translation « NMT »
Les modèles Séquence à Séquence ont connu un grand succès dans diverses tâches
telles que la traduction automatique, la reconnaissance vocale et la synthèse de texte. Nous
nous concentrons sur la tâche de Neural Machine Translation « NMT » qui fut le premier
banc d'essai pour les modèles seq2seq avec un succès fou. Au cours des dernières années, les
32
systèmes de traduction traditionnels basés sur les phrases accomplissaient leur tâche en
décomposant les phrases sources en plusieurs morceaux, puis les traduisaient phrase par
phrase. Cela a conduit à la diffluence dans les sorties de traduction et n'était pas tout à fait
comme la façon dont nous, les humains, traduisons. Nous lisons toute la phrase source,
comprenons sa signification, puis produisons une traduction. « Neural Machine Translation »
« NMT » imite cela.
3.3.3. Réseaux de neurone convolutionnels « CNN / ConvNets »
Le concept de réseaux de neurones convolutionnels est le résultat de l’exploitation de
deux éléments : algorithme de réseaux neuronaux artificiels et un ensemble d'opérations que
nous appellerons convolution. En combinant ces deux sortes d'idées nous obtenons les
réseaux de neurones convolutionnels ou simplement CNN. Comme nous l'avons vu, les
réseaux neuronaux reçoivent une entrée « un seul vecteur » et le propage dans une série de
couches cachées. Chaque couche cachée est constituée d'un ensemble de neurones, où chaque
neurone est entièrement connecté à tous les neurones de la couche précédente et les neurones
d'une même couche fonctionnent de manière complètement indépendante et ne partagent
aucune connexion. Les réseaux neuronaux réguliers ne s'adaptent pas bien aux images
complètes. Dans CIFAR-10, les images sont seulement de taille 32x32x3 « 32 larges, 32
hautes, 3 canaux de couleur », donc un seul neurone entièrement connecté dans une première
couche cachée d'un réseau neuronal régulier aurait 32 * 32 * 3 = 3072 poids. Cette quantité
semble encore gérable, mais il est clair que cette structure entièrement connectée ne s'adapte
pas à des images plus grandes. Par exemple, une image de taille plus important, par exemple
200x200x3, conduirait à des neurones qui ont 200 * 200 * 3 = 120 000 poids. De plus, nous
voudrions avoir plusieurs de ces neurones, donc les paramètres se multiplient rapidement.
Cette connectivité totale est gaspilleuse et le grand nombre de paramètres conduirait
rapidement à un sur apprentissage.
3.3.3.1. Architecture des ConvNets
Les réseaux de neurones convolutionnels profitent du fait que l'entrée est une image
pour construire l'architecture adaptée. En particulier, contrairement à un réseau neuronal
régulier, les couches d'un ConvNet ont des neurones disposés en 3 dimensions: largeur,
hauteur, profondeur. Par exemple, les images d'entrée dans CIFAR- 10 ont un volume d'entrée
d'activations, et le volume à des dimensions 32x32x3 « largeur, hauteur, profondeur ».
33
Comme nous le verrons bientôt, les neurones d'une couche ne seront connectés qu'une petite
région de la couche d’avant.
De plus, la couche de sortie finale pour CIFAR-10 aurait des dimensions 1x1x10, car à la fin
de l'architecture ConvNet, nous réduirons l'image complète en un seul vecteur de scores de
classe, disposés le long de la dimension de profondeur. Voici une visualisation:
Dans l’exemple du neurone ConvNet Figure 2 la couche d'entrée rouge contient l'image, donc
sa largeur et sa hauteur seraient les dimensions de l'image, et la profondeur serait 3 « canaux
rouge, vert, bleu ». Pour former une architecture ConvNet complète nous allons utiliser trois
types principaux de couches: Couche convolutionnelle, Couche de mise en commun et couche
entièrement connectée « exactement comme dans les réseaux de neurones réguliers ».Les
ConvNets transforment l'image originale couche par couche de la valeur des pixels d'origine
aux scores de classe finales.
3.3.3.2. Couche convolutionnelle
La couche convolutionnelle est le bloc de construction principale d'un réseau
convolutionnel. Elle effectue la plus grande partie du calcul lourd. Les paramètres de cette
couche se composent d’un ensemble de filtres doté de la capacité d’apprendre. Chaque filtre
est de petite largeur et de de petites hauteurs, mais s'étend sur toute la profondeur du volume
d'entrée. Par exemple, un filtre typique sur une première couche d'un ConvNet peut avoir une
taille 5x5x3 « c'est-à-dire 5 pixels de largeur et de hauteur, et 3 parce que les images ont une
profondeur 3, les canaux de couleur ». Pendant le passage avant, nous glissons, plus
précisément convolons, chaque filtre sur la largeur et la hauteur du volume d'entrée et
calculons les produits scalaires entre le filtre et l'entrée à n'importe quelle position. Lorsque
nous faisons glisser le filtre sur la largeur et la hauteur du volume d'entrée, nous produisons
une carte d'activation bidimensionnelle qui donne les réponses de ce filtre à chaque position
spatiale.
Figure 19: Réseau de neurones traditionnels à 3 couches. Figure 18: ConvNet 3D.
34
Intuitivement, le réseau apprend les filtres à s'activer lorsqu'ils voient un type de
caractéristique visuelle telle qu'un contour ou une tache de couleur sur la première couche.
Maintenant, nous aurons un ensemble complet de filtres dans chaque couche, et chacun d'eux
produira une carte d'activation à 2 dimensions séparée. Nous empilerons ces cartes
d'activation le long de la cote de profondeur et produirons le volume de sortie. Les CNN sont
basés essentiellement donc sur trois idées : les champs réceptifs locaux, les poids partagés et
la mise en commun. Regardons de près chacune de ces idées :
3.3.3.3. Connectivité locale
Lorsque nous traitons des entrées de grandes dimensions telles que les images, comme
nous l'avons vu, il est impossible de connecter les neurones à tous les neurones du volume
précédent. Au lieu de cela, nous allons connecter chaque neurone à seulement une région
locale du volume d'entrée. L'étendue spatiale de cette connectivité est un hyper paramètre
appelé le champ réceptif du neurone « c'est la taille du filtre ». L'étendue de la connectivité le
long de l'axe de profondeur est toujours égale à la profondeur du volume d'entrée. Il est
important de souligner à nouveau cette asymétrie dans la façon de traiter les dimensions
spatiales « largeur et hauteur » et la dimension de profondeur: les connexions sont locales
dans l'espace « largeur et hauteur », mais toujours pleines sur toute la profondeur du volume
d'entrée.
Figure 21: Exemple de liaison entre la couche d'entrée et la couche conv.
Figure 20: Connectivité locale.
35
3.3.3.4. Partage des paramétrés
Le schéma de partage de paramètres est utilisé dans La couche convolutionnelle pour
contrôler le nombre de paramètres. En utilisant l'exemple du monde réel ci-dessus, nous
voyons qu'il y a 55 * 55 * 96 = 290 400 neurones dans la première couche de
convolutionnelle, et chacun a 11 * 11 * 3 = 363 poids et 1 biais. Ensemble, cela équivaut à
290400 * 364 = 105 705 600 paramètres sur la première couche du ConvNet seul. Il est clair
que ce nombre est très élevé. Il est possible de réduire considérablement le nombre de
paramètres en faisant une hypothèse raisonnable: Si une caractéristique est utile pour le calcul
à une position spatiale « x, y », alors il devrait aussi être utile pour le calcul à une position
différente « x2, y2 ». En d'autres termes, en indiquant une tranche de profondeur
bidimensionnelle comme une tranche de profondeur « par exemple un volume de taille
[55x55x96] a 96 tranches de profondeur, chacune de taille [55x55] » nous allons forcer les
neurones dans chaque tranche de profondeur à utiliser les mêmes poids et biais. Avec ce
schéma de partage de paramètres, la première couche convolutionnelle dans notre exemple
aurait maintenant seulement 96 ensembles de poids uniquement « un pour chaque tranche de
profondeur », pour un total de 96 * 11 * 11 * 3 = 34 848 poids, soit 34 944 paramètres « +96
biais ». Alternativement, tous les 55 * 55 neurones dans chaque tranche de profondeur vont
maintenant utiliser les mêmes paramètres. En pratique pendant la rétro propagation, chaque
neurone dans le volume calculera le gradient pour ses poids, mais ces gradients seront
additionnés à travers chaque tranche de profondeur et ne mettront à jour qu'un seul ensemble
de poids par tranche. Notez que si tous les neurones dans une seule tranche de profondeur
utilisent le même vecteur de poids, la passe avant de la couche convolutionnelle peut dans
chaque tranche de profondeur être calculée comme une convolution des poids du neurone
avec le volume d'entrée d'où le nom de la couche convolutionnelle.
3.3.3.5. Couche de mise en commun « Pooling »
Il est courant d'insérer périodiquement une couche de mise en commun entre des
couches convolutionnelles successives dans une architecture ConvNet. Sa fonction est de
réduire progressivement la taille spatiale de la représentation afin de réduire la quantité de
paramètres et de calculs dans le réseau, et donc de contrôler également le sur apprentissage.
La couche Pooling fonctionne indépendamment sur chaque tranche de profondeur de l'entrée
et la redimensionne spatialement, en utilisant l'opération de maximisation. La forme la plus
commune est une couche de regroupement avec des filtres de taille 2x2 appliquée avec une
36
foulée de 2 sous-échantillons. Chaque tranche de profondeur dans l'entrée est divisée par 2 le
long de la largeur et la hauteur, rejetant 75% des activations. Chaque opération de
maximisation prendrait dans ce cas un maximum de 4 chiffres « petite région 2x2 dans une
tranche de profondeur ». La dimension de profondeur reste inchangée.
Figure 22: Pooling.
Dans cet exemple, le volume d'entrée de taille [224x224x64] est regroupé avec un filtre de
taille 2, la foulée 2 dans le volume de sortie de taille [112x112x64]. Notez que la profondeur
du volume est préservée.
Figure 23: Pooling maximum.
L'opération de sous-échantillonnage la plus courante est max, ce qui donne lieu à un pooling
maximum, ici représenté avec une foulée de 2, c'est-à-dire que chaque max est pris sur 4
nombres « petit carré 2x2 ».
37
3.4. Comparaison entre les « Framework »
De nos jours, les algorithmes de Deep Learning sont encore difficilement utilisables
dans la grande majorité des entreprises, du fait des connaissances et de l'architecture
nécessaire à la mise en œuvre de tels modèles « notamment de calcul sur gpu » qui a l'heure
actuelle demeurent encore relativement coûteux. Cependant, des bibliothèques logicielles
commencent à apparaitre ces dernières années, afin de proposer des solutions plus hautes
niveau permettant d'accéder à ce genre de technologies, [16]. Les « Frameworks »
d'apprentissage profond alimentent la révolution de l'intelligence artificielle. Sans eux, il
serait presque impossible pour les développeurs d’atteindre un certain niveau de
sophistication dans leurs algorithmes d'apprentissage profond. En d'autres termes, ils facilitent
la création d'algorithmes d'apprentissage. Aujourd’hui l’espace d'apprentissage profond
s’éclate avec des « Frameworks », chaque semaine une entreprise de technologie majeure
décide d'ouvrir sa propre bibliothèque d'apprentissage profond. Le « Framework » que vous
choisissez d'utiliser est en fin de compte ce que vous essayez de faire et comment vous
travaillez déjà. Pour cela nous allons comparer les « Frameworks » les plus populaires pour
voir qui est mieux adapté à notre travail.
3.4.1. scikit-learn
scikit-learn a été fait pour fournir une interface facile à utiliser pour les développeurs
des algorithmes d'apprentissage automatique pour les deux apprentissages supervisé et non
supervisé. scikit-learn fournit des fonctions qui vous permettent d’appliquer l'apprentissage
automatique classique et des algorithmes comme les machines à vecteurs de support,
régressions logistiques et k plus proche voisin très facilement, mais cette bibliothèque ne
fournit pas les réseaux de neurones et le support GPU qui facilite énormément l’apprentissage
des réseaux de neurones.
3.4.2. Tensorflow
Sans doute c’est l'un des meilleurs « Frameworks » d'apprentissage profond,
Tensorflow, a été développée par l'équipe Google Brain et ouverte en 2015. Elle a été adopté
par plusieurs géants comme Airbus, Twitter, IBM et d'autres principalement en raison de son
architecture système très flexible. Le cas d'utilisation le plus connu de TensorFlow doit être
Google Translate couplé à des fonctionnalités telles que le traitement du langage naturel, la
classification / synthèse de textes, la reconnaissance de la parole / image / écriture manuscrite,
la prévision et le marquage. TensorFlow est une bibliothèque basée sur Python capable de
38
fonctionner sur plusieurs processeurs et GPU, disponible sur le bureau et le mobile et prend
également en charge des langages tels que C ++ et R pour créer des modèles d'apprentissage
en profondeur avec des bibliothèques d'encapsuleurs.
3.4.3. Theano
Theano c’est où toute l'histoire a commencé. Il a été créé en 2007 par Yoshua Bengio
et l'équipe de recherche de l'Université de Montréal et a été le premier cadre de Deep
Learning largement utilisé. Theano est une bibliothèque Python, extrêmement rapide et
puissante, mais critiquée pour être un « framework » d'apprentissage profond de bas niveau.
L'équipe derrière Theano a annoncé en 2017 qu'après la publication de la dernière version il
n'y aura pas d'autres développements.
3.4.4. Keras
Keras a été développé comme une interface facile à utiliser pour simplifier la
construction de réseaux de neurones avec une approche rapide. Il est écrit en Python et peut
être utilisé en plus de TenserFlow et Theano. Nous sommes susceptibles d'entendre plus sur
Keras en 2018 puisque Google inclura Keras dans les prochaines versions de TenserFlow.
3.4.5. Caffe
Caffe est un « Framework » d'apprentissage profond qui est pris en charge des
langages telle que C, C ++, Python et MATLAB, ainsi que l'interface de ligne de commande.
Il est bien connu pour sa vitesse et sa transposabilité et son applicabilité dans la modélisation
des réseaux de neurones conventionnelles « CNN ». Le plus grand avantage de l'utilisation de
la bibliothèque C ++ de Caffe « livré avec une interface Python » est la possibilité d'accéder
aux réseaux disponibles à partir du référentiel deep net Caffe Model Zoo qui sont préformés et
peuvent être utilisés immédiatement. Quand il s'agit de modéliser des CNN ou de résoudre
des problèmes de traitement d'images, cela devrait être votre bibliothèque de référence. Le
plus grand avantage de Caffe est la vitesse. Il peut traiter plus de 60 millions images
quotidiennement avec un seul GPU Nvidia K40. C'est 1 ms / image pour l'inférence et 4 ms /
image pour l’apprentissage. Les versions plus récentes de la bibliothèque sont les plus rapides.
Caffe est un réseau d'apprentissage populaire pour la reconnaissance visuelle. Cependant,
Caffe ne prend pas en charge les couches réseau fines et granulaires comme celles de
TensorFlow ou de CNTK. Compte tenu de l'architecture, de la prise en charge globale des
réseaux récurrents et de la modélisation du langage, elle est limitée et l'établissement de types
de couches complexes doit se faire dans un langage de bas niveau.
39
3.4.6. Pytorch
Pytorch est une version python du « Framework » Torch qui a été publiée par
Facebook début 2017. Elle utilise des graphes de calcul dynamiques qui contribuent de
manière significative à l'analyse de données non structurées. Pytorch a personnalisé
l'allocateur GPU qui rend les modèles Deep Learning plus efficace sur le plan de la mémoire.
Pytorch est un « Framework » simple qui offre une grande vitesse et flexibilité. Pytorch est
utilisé par de nombreuses entreprises technologiques telles que Twitter, Facebook et Nvidia
pour former des modèles Deep Learning. Il est convivial pour les développeurs et très
efficace. Certains des principaux inconvénients sont qu'il s'agit encore d'une nouvelle version
bêta et qu'il n'y a pas assez de soutien communautaire. Cependant, il a le potentiel de défier
TensorFlow avec son élan grandissant dans les années à venir.
On remarque que chaque « Framework » a ces avantages et ces inconvénients. Mais
on constate que les plus flexibles, rapides et les plus riches en termes techniques
d’apprentissages sont « Tensorflow » et « keras ». Ils facilitent énormément l’utilisation des
algorithmes de type réseau de neurones et ils sont les plus adaptés aux tâches d’apprentissages
réalisés au cours du stage.
3.5. Apprentissage de l’assistant conversationnel « chatbot »
Dans cette partie on va expliquer comment on a réalisé un agent conversationnel
intelligent capable de parler au conducteur en temps réel.
Les modèles basés sur des règles facilitent la création d'un bot. Mais ils souffrent
lorsqu'ils rencontrent une phrase qui ne contient aucun motif connu. En outre, cela prend du
temps et demande beaucoup d'efforts pour écrire les règles manuellement et prédire tous les
conversations possibles. Pour cela on a pensé à construire un bot qui apprendrait des
conversations existantes à travers un apprentissage profond. Appelons ces modèles qui
apprennent automatiquement à partir de données, les modèles intelligents. Les modèles
intelligents peuvent être classés en:
Modèles basés sur la récupération : Ils sélectionnent une réponse à partir d'une
collection de réponses basée sur la requête. Il ne génère aucune nouvelle phrase, donc nous
n'avons pas besoin de nous soucier de la grammaire.
Modèles génératifs : Ils sont assez intelligents. Ils génèrent une réponse, mot à mot, en
fonction de la requête. Pour cette raison, les réponses générées peuvent contenir des erreurs
40
grammaticales. Ces modèles sont difficiles à entrainer, car ils ont besoin d'apprendre la
structure de phrase appropriée par eux-mêmes. Cependant, une fois entrainés, les modèles
génératifs surpassent les modèles basés sur la récupération en termes de gestion de requêtes
inédites et créent une impression de conversation avec un humain « un tout-petit peut être »
pour l'utilisateur. Le choix s’est fixé directement sur Tensoflow et plus précisément sur le
tutoriel seq2seq et MNT pour cette tâche d’apprentissage pour plusieurs raisons expliquées
déjà dans la partie précédente. En effet le modèle séquence à séquence est le modèle
fondamental pour les systèmes de dialogue ou la traduction. Son objectif est de générer une
repense à travers un encodeur qui convertit une séquence de symboles en un vecteur de
caractéristiques de taille fixe qui code uniquement les informations importantes dans la
séquence tout en prenant les informations inutiles. Donc il construit à chaque état caché le
contexte ou le vecteur de pensée et à partir de ce vecteur et des symboles précédemment
générés, le décodeur génère une autre séquence de mot.
Pour créer un chatbot, ou faire une tâche d'apprentissage automatique le premier
travail à faire est d'acquérir une base de données d'apprentissage. Ensuite il faut structurer ces
informations sous forme de "donnés d’entrée" et "donnés de sortie" pour qu’un algorithme
d’apprentissage puisse les traitées. Sur internet il y a quelques sources qui fournissent des
bases de données de dialogue entre humains mais ils sont tous en anglais. Après une longue
recherche on a trouvé une énorme base de données qui contient 1.7 Billion de commentaires :
Reddit. En effet Reddit est un site communautaire et social qui propose de l’information et du
contenu sur absolument tout. La structure de Reddit est un peu différente. Elle n’est pas
comme un forum ou quelque site de discussion où tout est linéaire. Les commentaires parent
sont linéaires, mais les réponses aux commentaires parent se ramifient.
Figure 24: Exemple d'exécution d'un modèle seq2seq.
41
-meilleur réponse 1
-- réponse 1 de la meilleure réponse 1
-- réponse 2 de la meilleure réponse 1
--- réponse de la réponse...
- meilleur réponse 2
-- réponse 3 de la meilleure réponse 1
- meilleur réponse 3
La structure demandée pour l’apprentissage est organisée sous la forme de pair de questions
réponses telle que la suivante :
-meilleur réponse 1 et -- réponse 1 de la meilleure réponse 1
-- réponse 1 de la meilleure réponse 1 et --- réponse de la réponse...
Donc dans une première étape nous avons produit ces paires tout en assurant que chaque
commentaire possède une seule réponse, la plus voté et ne pas avoir des réponses sans
commentaire.
La forme générale des données télécharger de Reddit est la suivante :
{"author":"Arve","link_id":"t3_5yba3","score":0,"body":"Can we please
deprecate the word \"Ajax\" now? \r\n\r\n(But yeah, this _is_ much
nicer)","score_hidden":false,"author_flair_text":null,"gilded":0,"subre
ddit":"reddit.com","edited":false,"author_flair_css_class":null,"retrie
ved_on":1427426409,"name":"t1_c0299ap","created_utc":"1192450643","pare
nt_id":"t1_c02999p","controversiality":0,"ups":0,"distinguished":null,"
id":"c0299ap","subreddit_id":"t5_6","downs":0,"archived":true}
Il est clair qu’il y a plein de données inutiles donc nous l’avons éliminé en créant une
nouvelle base de données SQLite qui stocke uniquement dans un tableau déjà créé le
parent_id, comment_id, parent comment, reply « comment », subreddit, le temps, le score.
Ensuite on a créé les fichiers texte « commentaire » et « réponse » pour l’entrainement et le
test tell que le 20éme ligne dans le fichier « réponse » est la réponse au commentaire du
20éme ligne du fichier « commentaire ». Une fois notre base d’apprentissage est prête, en a
implémenté le modèle Séquanes a séquence de Tenserflow pour entrainer notre agent
conversationnel sur cette base. On a utilisé deux réseaux de neurones l’un qui représente
l’encodeur et donc traite les commentaires et l’autre représente un décodeur et donc traite les
réponses tout en modifiant quelques paramètres tell que les chemins des fichiers
d’entrainement, le nombre de couches, nombre d’itérations et le taux d'apprentissage.
Finalement on a exécuté notre code et commencer la tâche d’apprentissage.
42
3.6. Reconnaissance de parole
La reconnaissance automatique de la parole « ou reconnaissance vocale » est une
technique informatique qui permet d'analyser la voix humaine captée au moyen d'un
microphone pour la transcrire sous la forme d'un texte exploitable par une machine, [17].
3.6. 1. Historique
Les travaux sur la reconnaissance de la parole datent du début du xxe siècle. La
technique à cette époque consiste à diviser le signal en petites unités phonétiques, puis les
groupées en mots. Le premier système de la reconnaissance de la parole est développé aux
laboratoires Bell Labs en 1952. Ce système électronique câblé est capable uniquement à
reconnaître 10 chiffres. Les recherches sur la reconnaissance vocale ont été interrompues par
John Pierce, vice-président de Bell Labs, en 1969 à cause de l’énorme échec de cette
approche. La recherche s'est ensuite considérablement accrue durant les années 1970 avec
le lancement du projet ARPA aux États-Unis pour tester la faisabilité de la compréhension
automatique de la parole continue avec des contraintes raisonnables d’une coté et avec la mise
au point du modèle caché de Markov, très utilisé en reconnaissance vocale par Leonard E.
Baum d’une autre coté. Même avec l’utilisation des réseaux de neurones aux années 90 la
reconnaissance de la parole n’a pas obtenu des bons résultats. Au début des années 2000, la
reconnaissance vocale était encore dominée par des approches traditionnelles telles que les
modèles de Markov cachés combinés avec des réseaux de neurones artificiels. Mais
aujourd'hui, grâce à l’apprentissage profond et au LSTM la reconnaissance de la parole a subi
une évolution rapide. Cette technique est devenue commerciale applicable en temps réel et
partout dans notre quotidien.
3.6.2. Réalisation
Pour assurer la communication vocale avec l’assistant intelligent on a utilisé TFlearn,
la bibliothèque d'apprentissage profond de haut niveau construite au-dessus de TensorFlow,
pour construire un réseau de neurones profonds qui apprend à convertir les commandes
vocales en un texte exploitable par notre assistant. Pour cela on a téléchargé un ensemble de
données étiqueté de personnes disant des mots, crée un réseau de neurones et on a passé à la
phase entrainement sur ces données. Notre modèle est un réseau de neurones récursifs du type
LSTM.
43
3.6.3. Problème et solution
L’utilisation des réseaux de neurones récursifs du type LSTM et Tflearn de
TensorFlow facilite énormément la création d’une reconnaissance vocale. Mais la
performance de cette dernière reste toujours limitée à cause du manque des données
d’entrainement. En effet, pour assurer un bon apprentissage, il faut une grande base de
données vocale, ce qui est difficile à trouver sur internet et n’existe pas en d’autres langues
telles qu’en arabe. Pour cette raison, nous avons référé à une bibliothèque qui fournit d’un
modèle pré-entraîné par Google.
3.7. Détection faciale « Méthode de Vola et Jones »
3.7.1. Introduction
Une révolution majeure dans le domaine de vision par ordinateur et détection de
visage est réalisée par les chercheurs Paul Viola et Michael Jones, [18]. Ces derniers ont
publié une méthode qui porte leur nom pour la première fois le 13 juillet 2001 dans le journal
scientifique ‘International Journal of Computer Vision’ « IJCV ». La méthode de Vola et
Jones est l’une des premières méthodes de détection de visage dans une image numérique.
Cet algorithme est inventé au début pour détecter des visages uniquement, mais aujourd’hui
on peut également l’utiliser pour détecter efficacement et en temps réel d'autres types
d'objets dans une image. En tant que processus d'apprentissage supervisé, cette méthode a
besoin des images positives « contenant l’objet a détecté » et des images négatives « ne
contenant pas l’objet a détecté » pour entraîner un classifieur capable, après achever son
apprentissage, de détecter la présence éventuelle de l’objet à chercher en parcourant de
manière exhaustive l’image à tester à toutes les positions et dans toutes les tailles possibles.
3.7.2. Principe
La méthode de Viola et Jones consiste à balayer une image à l’aide d’une fenêtre de
détection de taille initiale 24px par 24px « dans l’algorithme original » et de déterminer si un
visage y est présent. Cette méthode se repose sur la recherche de quelques caractéristiques
bien déterminées dans un visage tel que les yeux et le nez… pour cela Viola et Jones
proposent d'utiliser des caractéristiques très simples, Les caractéristiques pseudo-Haar,
construites à partir d'un ensemble d'ondelettes de Haar « une ondelette créée par Alfréd Haar
en 1909 très similaire à la série de fourier ».
44
3.7.3. Les caractéristiques pseudoHaar
Une caractéristique est une représentation synthétique et informative, calculée à partir
des valeurs des pixels. Les caractéristiques de Haar sont similaires aux noyaux de
convolution. Ils sont utilisés pour détecter la présence des motifs dans une image donnée en
attribuant l’une de ses caractéristiques à chaque caractéristique important du visage humain.
Chaque caractéristique résulte une valeur unique qui est calculée en soustrayant la
somme des pixels sous le rectangle blanc de la somme des pixels sous le rectangle noir. Ils
sont appliqués à toutes les tailles et les positions de l'image. Une caractéristique est donc un
nombre réel qui code les variations du contenu pixellique à une position donnée dans la
fenêtre de détection. Viola et Jones donnant l’exemple d’une fenêtre de taille 24 x 24. Si nous
considérons tous les paramètres possibles des caractéristiques du haar comme la position,
l'échelle et le type, un très grand nombre de caractéristiques par fenêtre sont ainsi générées,
environ 160 000 caractéristiques. Malheureusement, le calcul de ses caractéristiques de
manière classique coûte cher en terme de ressources processeur, c’est là qu’interviennent les
images intégrales, [19].
3.7.4. L’image intégrale
L’image intégrale est une méthode qui permet de calculer plus rapidement les
caractéristiques. En effet elle est une présentation sous la forme d’une image numérique, qui
en chacun de ses ponts contient la somme des pixels situés au-dessus et à gauche de ce point.
Figure 25: Attribution de quelques caractéristiques au visage humain.
45
Figure 27: Image d'entrée.
Cette méthode permet de calculer la somme de tous les pixels à l'intérieur d'un rectangle
donné en utilisant seulement quatre valeurs aux coins du rectangle.
D = 1+4-(2+3)
= A+ (A+B+C+D)-(A+C+A+B)
= D
3.7. 5. Adaboost
Dans un détecteur à une résolution de base de 24x24 on peut aboutir jusqu’aux
160 000 caractéristiques à calculé, ce qui rend l’évaluation au moment du test très difficile ou
presque impossible. Pour cela Viola et Jones, ont pensé à éliminer les caractéristiques
redondantes et garder que les plus informatives et les plus utiles.
Figure 26: Image intégrale.
Figure 29: Caractéristique utiles. Figure 28: Caractéristique inutiles.
46
La méthode de boostiong s’impose à ce niveau. En effet Le Adaboost est un
algorithme d'apprentissage automatique qui nous aide à trouver les meilleures caractéristiques
parmi les 160 000. Chacune des caractéristiques choisies à la première sélection est
considérée comme acceptable si elles peuvent au moins mieux performer qu’un tirage
aléatoire c’est-à-dire deviner correctement plus de la moitié des cas. Viola et Jones assimilant
les caractéristiques filtrées à des classifieurs faibles. L’apprentissage du classifieur faible
consiste alors à trouver la valeur seuil de la caractéristique qui permet de mieux séparer les
exemples positifs « visages » des exemples négatifs « non-visages ». Un classifieur se réduit
donc à une association entre une caractéristique pseudoHaar et un seuil.
Seuil du classifieur ht
Figure 30: Résultat de l'apprentissage d'un classifieur faible.
Adaboost construit un classificateur fort comme une combinaison linéaire de ces
classificateurs faibles.
Énoncé de l'algorithme
On considère un ensemble de n images (x1,…, xn) et leurs étiquettes associées
(y1,…,yn), qui sont telles que yi =0 si l'image xi est un exemple négatif et
yi=1 si xi est un exemple de l'objet à détecter.
Initialiser les poids wt,i=
si yi =0 et wt,i=
si yi =1, où m est le nombre d’exemple
négatif et l est le nombre d’exemple positif.
Pour t = 1,…, T :
Normalisation des poids
wt,i=
∑
Pour chaque itération t et chaque caractéristique j on construit un classifieur faible hj
l'erreur engendrée par ce classifieur est donnée par :
47
∑
Choisir le classifieur ht présentant l'erreur la plus faible
Mettre les poids à jour :
Où ei=0 si xi est bien classifier
ei=1 sinon, =
Le classifieur fort final est donné par :
02
1)(1
)(11
T
tt
T
ttt
xxh h Où )
1log(
t
t
Figure 31: Adaboost algorithme.
3.7.6. Cascade de classifieurs
La méthode de Viola et Jones est, comme on a vu, extrêmement coûteuse en calcul.
L’une des idées-clés de la méthode pour réduire ce coût réside dans l’organisation de
l’algorithme de détection en une cascade de classifieurs. Appliqués séquentiellement, ces
48
classifieurs prennent une décision d’acceptation ou de rejet : la fenêtre ne contient pas l’objet
et dans ce cas l’exemple est définitivement écarté. L’idée est que l’immense majorité des
fenêtres testées étant négatives « c.-à-d. ne contiennent pas l’objet », il est avantageux de
pouvoir les rejeter avec le moins possible de calculs. Ici, les classifieurs les plus simples, donc
les plus rapides, sont situés au début de la cascade, et rejettent très rapidement la grande
majorité des exemples négatifs, [20].
3.7.7. Apprentissage du classifieur
Une étape préliminaire et très importante est l’apprentissage du classifieur. Il s’agit
d’entraîner le classifieur afin de le sensibiliser à ce que l’on veut détecter, ici des visages.
Pour cela, il est mis dans deux situations : la première où une énorme quantité de cas positifs
lui sont présentés et la deuxième où, à l’inverse, une énorme quantité de cas négatifs lui sont
présentés. Concrètement, une banque d’images contenant des visages de personnes est passée
en revue afin d’entraîner le classifieur. Ensuite, une banque d’images ne contenant pas de
visages humains est passée. Dans le cas présent, Viola et Jones ont entraîné leur classifieur à
l’aide d’une banque d’images du MIT. Il en résulte un classifieur sensibles aux visages
humains. Il se présente sous la forme d’un fichier XML. Dans l’absolu, on serait en mesure de
détecter n’importe quel signe distinctif à partir d’un classifieur entrainé à cela, [20].
3.7.8. Les étapes de création et entrainement des classifieurs
Afin d’intégrer la détection faciale a l’assistant virtuel, nous avons utilisé la
bibliothèque Open CV « Open Source Computer vision » qui est une bibliothèque graphique
libre, initialement développée par Intel et maintenant soutenu par la société de robotique
Willow Garage, spécialisée dans le traitement d’images en temps réel, [11]. La bibliothèque
Open CV met à disposition de nombreuses fonctionnalités très diversifiées, elle propose la
plupart des opérations classiques en traitement d’images tell que la lecture, l’écriture,
l’affichage, le lissage, le filtrage des images et le calcul des histogrammes. Cette bibliothèque
s’est imposée comme un standard dans le domaine de la recherche parce qu’elle propose un
nombre important d’outils en traitement vidéo. Avec Open CV il est assez facile de détecter
un objet dans une image par la méthode de Viola et Jones, qui est déjà implémentée dans la
fonction cvHaarDetectObjects, en utilisant son détecteur Haar Cascade. Le classifieur utilise
des données stockées dans un fichier XML pour décider comment classifier chaque image.
Open CV est livré avec quelques classifieur pour la détection de visage uniquement qui sont
déjà insuffisant pour notre projet. Nous somme alors obligés de créer nos propres classifieurs
49
de détection. Comme il a déjà été mentionné, la première étape pour faire une tâche
d'apprentissage automatique est d'acquérir une base de données. Mais cette fois ci notre base
de données est un peu différente. Elle se divise en deux parties :
La partie des images négatives qui contiennent n’importe quoi sauf l’objet à détecter. Cette
partie doit contenir des milliers d’exemples négatifs. Sur internet il existe quelques sites
internet qui classifient les images par catégorie telle qu’ImageNet et donc on peut facilement
télécharger nos images négatives.
La partie des images positives qui contiennent l’objet que nous voulons chercher. Cette partie
peut contenir une ou plusieurs images des objets à détecter selon nos besoins. En effet si nous
cherchant toute une catégorie d’objets on doit avoir des milliers d’images de cette famille
sinon, si on cherche un objet bien spécifique on doit utiliser une seule image positive et créer
par la commande opencv_createsamples d’autres exemples positifs en superposant cette photo
unique aux images négatives.
Il ne faut pas oublier que toutes les images doivent être à la même taille et puisque les
exemples négatifs sont très nombreux il est difficile de redimensionner toutes les images
manuellement pour cela on a écrit un script rapide qui va visiter ces listes d'URL, tirer les
images, les convertir en niveaux de gris, les redimensionner et les enregistrer. Ensuite on a
créé un fichier de description des images négatives à travers un petit script python. Ce fichier
contient uniquement l’emplacement des images contrairement au fichier de description des
images positives qui contient de plus la région d’intérêt (region of interest) et la récurrence de
l'objet. Ce fichier a été créé à travers la fonction opencv_createsamples comme suit :
opencv_createsamples -img -bg -info -pngoutput –maxxangle -maxyangle -maxzangle -num
-img : l’image positive de base pour la création des exemples positifs.
-bg : l'information de fond.
-info : ou on stocke les sorties « similaire au fichier de description des images négatives ».
-pngoutput : l’emplacement des images positives.
-maxxangle, -maxyangle, -maxzangle : quelques optionnels pour rendre notre image originale
un peu plus dynamique.
-num : est le nombre d’exemples à créer.
50
Le dernier fichier à préparer pour l’entrainement est le fichier vecteur où on stocke tous les
images positives ensemble. Ce fichier a été créé encore à par la fonction
opencv_createsamples comme suit :
opencv_createsamples -info -num -w -h -vec
-info : l’emplacement du fichier de description des images positives.
-num : nombre d’image à stockée dans le fichier.
-w -h : dimension des images.
-vec : nom du fichier vecteur.
Finalement, comme tout est prêt on a trainé notre cascade par la fonction opencv_traincascade
comme suit :
opencv_traincascade -data -vec -bg –numPos –numNeg –numStages -w -h
-data : l’emplacement d’enregistrement des données.
-vec : l’emplacement du fichier vecteur.
-bg : l’emplacement de l'information de fond.
-numPos : nombre des images positives.
-numNeg : nombre des images négatives.
-numStages : nombre de stages.
-w -h : dimensions.
3.8. Détection de fatigue
La fatigue est un facteur important de cause d’accidents mortels, notamment sur voie
rapide. Au volant, la fatigue se traduit par une attention moins forte, un temps de réaction plus
long et une analyse des situations beaucoup plus longue. De fait, la prise de décision face à un
danger est beaucoup moins évidente, multipliant les risques d’accidents. Dans sa globalité, la
fatigue joue un rôle dans environ 10% des accidents mortels, [21]. Pour réduire ce risque dans
les routes, les constructeurs automobiles ont créé des systèmes de détection de fatigue
indiquant au conducteur lorsqu'il est temps de faire une pause. Cette technique est très
51
importante aujourd’hui et donc on a pensé à intégrer un mode de détection de fatigue dans
notre assistant virtuel. Au « tired mode » l’assistant avertit le conducteur par un signal sonore
lorsqu'il détecte une baisse de concentration. Grâce à une caméra fixée au tableau de bord
l’assistant virtuel détecte le visage du conducteur et plus précisément ces yeux avec la
méthode de Viola et Jones en utilisant des classifieurs qu’on a déjà entrainés. Il résonne sur
l’état des yeux en traitant ces images en temps réel et prendre une décision. Si le conducteur
est fatigué l’assistant lance une pip et propose au conducteur de passer au mode autonome si
c’est possible.
3.9. Sécurité
3.9.1. Problématique
L’idée consiste à utiliser la caméra interne pour identifier l’utilisateur de la voiture.
L’assistant ne discute et ne démarre le véhicule que s’il identifie l’une des personnes qu’il
connaît a l’avance. Ces personnes envoient leurs photos par une application androïde
connectée au véhicule. Au début, on a pensé à utiliser la méthode de Viola et Jones et à créer
des clasifieurs qui distinguent entre une personne connue et une autre inconnue mais
malheureusement d’apprentissage du classifieur nécessite une longue période ce qui n’est pas
pratique. Il faut donc chercher un nouveau moyen pour assurer cette identification.
Figure 32: Détection de fatigue.
52
3.9.2. Reconnaissance faciale moderne avec apprentissage profond
La reconnaissance faciale est vraiment une série de plusieurs problèmes connexes.
D'abord, on regarde une photo et on trouve tous les visages dedans. Deuxièmement, on
concentre sur chaque visage et on comprend que même si le visage est tourné dans une
direction étrange ou dans un mauvais éclairage, il s’agit toujours de la même personne.
Troisièmement, on choisit les caractéristiques uniques du visage que nous pouvons utiliser
pour le distinguer des autres personnes - comme la taille des yeux, la longueur du visage, etc.
Enfin, on compare les caractéristiques uniques de ce visage à toutes les personnes que nous
connaissons déjà pour déterminer le nom de la personne.
Nous devons construire un pipeline où nous résolvons chaque étape de la
reconnaissance faciale séparément et transmettons le résultat de l'étape en cours à l'étape
suivante. En d'autres termes, nous allons enchaîner plusieurs algorithmes d'apprentissage
automatique.
3.9.2.1. Détection faciale
La première étape de notre pipeline est la détection des visages. Évidemment nous
devons localiser les visages dans une photographie avant que nous essayons de les
différencier. Comme on a indiqué précédemment la détection faciale a connu son énorme
développement au début des années 2000 quand Paul Viola et Michael Jones ont inventé un
moyen de détecter les visages suffisamment rapides pour fonctionner en temps réel.
Cependant, des solutions plus fiables existent maintenant telles que la méthode
« Histogramme des gradients orientés » ou HOG inventée en 2005.
Une étape primordiale au début est la conversion de notre image en une image
intensité de gris pour réduire le calcul lors du traitement de l’image. Ensuite, nous
concentrons sur chaque pixel de notre image en regardant les pixels qui l’entourent
directement.
53
Notre objectif est de comprendre à quel point le pixel actuel est sombre par rapport aux pixels
qui l'entourent directement. Ensuite, nous dessinons une flèche montrant dans quelle direction
l'image devient plus sombre.
Figure 34: Représentation des flèches.
Si nous répétons ce processus pour chaque pixel de l'image, on remplace chaque pixel de
l’image par une flèche.
Figure 33: Examinassions de tous les pixels de l'image.
Figure 35: Convection des pixels en flèches.
54
Cette conversion semble inutile mais si on traite l’image par pixels les zones sombres et les
zones très claires auront des valeurs complètement différents alors que si on considère que la
direction dans laquelle la luminosité change, les images sombres auront la même
représentation que les images brillantes. Ce qui rend le problème beaucoup plus facile à
résoudre. De plus en considérant l’image comme des petits carrés de 16x16 pixels nous
puissions voir le flux de lumière / obscurité à un niveau plus élevé afin que nous puissions
voir le motif de base de l'image. Dans chaque carré, nous comptons combien de gradients
pointent dans chaque direction principale « combien de points en haut, point en haut à droite,
point à droite, etc ... ». Ensuite, nous remplaçons ces carrés dans l'image avec les directions de
la flèche dominante.
Figure 36: Représentation finale de l'image.
Enfin pour trouver des visages dans cette image HOG, tout ce qu’on doit faire est de trouver
la partie de notre image qui ressemble le plus à un modèle HOG connu, qui a été extrait
d'autres visages d'entraînement.
Figure 37: Technique de détection faciale HOG.
55
3.9.2.2. Projection des visages
Après isolation des visages, nous devons résoudre le problème des visages tournés en
différentes directions. Ils ont l'air d’être totalement différent pour un ordinateur. Pour cela
nous essayons de déformer chaque image de sorte que les yeux et les lèvres soient toujours à
en face dans l'image. Pour appliquer cette déformation on utilise un algorithme appelé « face
landmark estimation » qui trouve 68 points spécifiques « appelés points de repère » qui
existent sur chaque visage, le haut du menton, le bord extérieur de chaque œil, le bord
intérieur de chaque sourcil, etc. Ensuite, on entraine un réseau de neurones pour être capable
de trouver ces 86 points spécifiques sur n’importe quel visage.
Figure 39: Application du RNN pour trouver les points spécifiques.
Figure 38: Les 68 points spécifiques.
56
Une fois on connaît où ils sont les yeux et la bouche, on va pivoter, mettre à l'échelle et
cisailler l'image des visages tournés de sorte que les yeux et la bouche soient centrés le mieux
possible sans introduire des distorsions dans l'image.
3.9.2.3. Encodage des visages
Maintenant les choses deviennent vraiment intéressantes, on va distinguer les visages
connus des autres inconnues. L'approche la plus simple consiste à comparer directement le
visage inconnu trouvé à l'étape 2 avec toutes les images que nous avons des personnes
connues. Mais cette approche prendrait trop de temps. Il faut donc extraire quelques mesures
de base pour chaque visage par exemple, nous pourrions considérer la taille de chaque oreille,
l'espacement entre les yeux, la longueur du nez, etc. Ensuite, nous mesurons notre visage
inconnu de la même manière et trouver le visage connu avec les mesures les plus proches.
Alors quelles mesures devrions-nous collecter de chaque visage pour construire notre base de
données de visage connu ? Il faut savoir que les mesures qui nous semblent évidentes pour les
humains « comme la couleur des yeux » n'ont pas vraiment de sens pour un ordinateur qui
regarde des pixels individuels dans une image. Les chercheurs ont découvert que l'approche la
plus précise consiste à laisser l'ordinateur déterminer les mesures à recueillir lui-même.
L'apprentissage profond fait un meilleur travail que les humains pour déterminer quelles
parties d'un visage sont importants à mesurer. La solution donc est d’entrainer un réseau de
neurones profond à générer 128 mesures pour chaque visage. Le processus d’entrainement
fonctionne en regardant 3 images de visage à la fois : 2 images du même visage et une image
d’une personne totalement différante. Notre algorithme examine les mesures qu’il a générées
pour chacune de ces 3 images et ajuste légèrement le réseau de neurones pour s'assurer que les
Isolation de visage détecté Détection de repères de visage
Résultat parfaite désiré
Résultat finale
Figure 40: Les étapes de projection des visages.
57
mesures qu'il génère pour les 2 images du même visage sont très proches contrairement aux
mesures générer pour la 3éme image.
Figure 41: Une itération d'apprentissage.
Après avoir répété cette étape des millions de fois pour des millions d'images de milliers de
personnes différentes, le réseau de neurones apprend à générer de manière fiable 128 mesures
pour chaque personne. Ce processus d’apprentissage du réseau de neurones convolutionnels
nécessite beaucoup de données et de puissance informatique. Même avec une chaire carte
vidéo NVidia Telsa, il faut environ 24 heures de formation continue pour obtenir une bonne
précision. Mais une fois que le réseau a été formé, il peut générer des mesures pour n'importe
quel visage, même celui qu'il n'a jamais vu auparavant. Pour ces raisons on a tourné nos
images de visage à travers un réseau déjà formé afin d’obtenir les 128 mesures pour chaque
visage.
58
Figure 42: Génération des mesures
Il est à noter que le réseau de neurones génère les mêmes nombres quand il regarde des
images différentes de la même personne.
3.9.2.4. Trouver le nom de la personne à partir de l'encodage
Cette dernière étape est en fait l'étape la plus facile dans tout le processus. Tout ce que
nous avons à faire est de trouver la personne dans notre base de données de personnes
connues qui a les mesures les plus proches de notre image de test. Vous pouvez le faire en
utilisant un algorithme de classification de base de l'apprentissage automatique. Aucune
astuce d'apprentissage profond n’est nécessaire. Nous utiliserons un simple classificateur
SVM linéaire. Tout ce que nous devons faire est de former un classificateur qui peut prendre
les mesures d'une nouvelle image de test et indique quelle personne est la plus proche.
L'exécution de ce classificateur prend des millisecondes et le résultat du classificateur est le
nom de la personne.
Pour faciliter d’avantage ce long processus on peut utiliser plusieurs environnements
tels que l’API de reconnaissance faciale « Face Recognition ». Cette bibliothèque est
construite en utilisant Dlib, la boite à outils traitant des problèmes de machine learning. On a
adapté cet api pour l’utilisation sous python et pour faciliter les étapes précédentes afin
d’assurer la reconnaissance faciale dans un temps record en utilisant notre modèle qui a une
précision de 99,38%.
59
3.10. Détection d’émotion
3.10.1. Introduction
Pour que l’assistant soit le plus intelligent possible il vaut mieux s’il interagit avec
l'utilisateur d’une façon innovante. Ainsi un assistant capable d'extraire des informations
seulement du visage de son utilisateur, par exemple identifier l'état émotionnel ou déduire son
genre sera quelque chose très original.
3.10.2. Réalisation
Comme d’habitude on a basé notre option sur l’une des techniques d'apprentissage
automatique. Mais il faut savoir que la précision humaine pour classer une image d'un visage
dans l'une des 7 émotions différentes est de 65% ± 5%. On peut remarquer la difficulté de
cette tâche en essayant de classifier manuellement les images de la base de données FER-
2013 dans la figure si contre selon les 7 émotions {"fâché", "dégoût", "avoir peur", "heureux",
"triste", "surpris", "Naturel"}.
Figure 43: Identification.
60
On a donc entrainé un simple réseau de neurones convolutionel conçue avec keras sur
une base de données FER-2013. En effet elle se compose d'images en niveaux de gris 48x48
pixels de visages. Les visages ont été plus ou moins centrés et occupent à peu près la même
position dans chaque image, [22]. La tâche consiste à classer chaque visage en fonction de
l'émotion montrée dans l'expression faciale dans l'une des sept catégories déjà mentionnées.
Il existe dans cette base deux fichiers l’un pour la phase d’entrainement et un autre pour la
phase de test. Le fichier d’entrainement contient deux colonnes, "émotion" et "pixels". La
colonne "émotion" contient un code numérique compris entre 0 et 6 indiquant l'émotion
présente dans l'image. La colonne "pixels" contient une chaîne pour chaque image qui
contient des pixels séparés par des espaces. Alors que le fichier test ne contient que la
colonne "pixels" et notre tâche est de prédire la colonne des émotions.
Figure 45: Test de la prédiction d'émotion.
Figure 44: Exemple des images de la base de données FER-2013.
61
3.11. Conclusion
Dans ce chapitre, nous avons utilisé l’intelligence artificielle et ces techniques. Ainsi
que nous avons mis en œuvre plusieurs « Framework » et plusieurs algorithmes pour réaliser
un assistant virtuel qui assure les commandes internes.
62
Conclusion générale
Tourner le dos à la route plutôt que de tenir le volant, fixer les yeux sur l'écran de notre
tablette au lieu de s'intéresser à la voiture que l'on suit, téléphoner ou gérer nos emails sans se
préoccuper du trafic, tout cela sans quitter nos sièges de conducteur était toujours le rêve de
toutes les firmes de l'industrie automobile. Aujourd’hui grâce au progrès de l’intelligence
artificielle et au développement au moyen du calcul rapide ce rêve s’approche de la réalité. Ce
qui nous motive pour étudier ce sujet intéressant.
Notre objectif est en fait de présenter notre propre modèle de véhicule autonome.
Donc, pour la réalisation de notre travail, nous avons utilisé plusieurs « Framework »,
plusieurs bibliothèques, plusieurs algorithmes et plusieurs techniques d’IA qui ont facilité nos
tâches. Ils nous ont fourni de plus la grande source pour établir les liens entre la théorie et la
pratique. Le fait de rechercher une solution a un tel sujet, de s’engager à développer un
modèle très similaire au modèle réel et à réaliser un prototype, que nous avons élaboré dans le
second chapitre, avec les moyens disponibles nous a appris comment généraliser dans un
cadre professionnel les connaissances théoriques acquises pour pouvoir concrétiser et
critiquer.
Comme nous pouvons le constater, le concept que nous avons étudié reste un thème
d’actualité puisque les firmes de l'industrie automobile mondiale sont aujourd'hui engagées
dans une course folle pour élaborer le modèle parfait. Notre travail peut être encore plus utile
et peut se développer encore grâce à la plus grande base de données auto-conduite d’UC
Berkeley qui a été ouvert au grand public dernièrement. L'énorme base de données contient
100 000 séquences vidéo qui peuvent être utilisées pour développer davantage notre modèle
en l’entrainant aux conduites et à s’adapter à des scénarios complexes sans avoir besoin de se
déplacer. Sans doute le modèle fini, qui représente l'avenir du transport, va basculer notre vie
et peut être élimine le modèle de toutes les voitures qu’on connaît aujourd’hui. Il y a dix ans
nous n'avons pas de portable dans dix ans nous n'aurons peut-être plus de voitures.
63
Bibliographie
[1]. (s.d.). Association Prévention Routière. Consulté le 2018, sur
https://www.preventionroutiere.asso.fr/
[2]. (s.d.). TASEMCO Systems. Consulté le 2018, sur https://tasemco.pro/
[3]. Dean, J. (s.d.). Consulté le 2018, sur https://www.ted.com/
[4]. Suard, C. (2018, février 22). journaldugeek. Consulté le 2018, sur
https://www.journaldugeek.com/dossier/intelligence-artificielle-aujourdhui-fantasme-
demain-revolution/
[5]. (s.d.). Consulté le 2018, sur National Highway Traffic Safety Administration:
https://www.nhtsa.gov/
[6]. (s.d.). American Automobile Association. Consulté le 2018, sur
https://www.aaa.com/International/
[7]. (s.d.). société d'assurance mutuelle française. Consulté le 2018, sur https://www.maif.fr/
[8]. (s.d.). voiture autonome. Consulté le 2018, sur https://www.voiture-autonome.net
[9]. chunka, m. (s.d.). voiture-autonome. Consulté le 2018, sur
http://voitureautonome.com/modele/chunka-mui/
[10]. (s.d.). Consulté le 2018, sur nvidia: https://www.nvidia.fr/self-driving-cars/
[11]. (s.d.). OpenCV 2.4.6.0 documentation. Consulté le 2018, sur Face Recognition with OpenCV:
https://docs.opencv.org/2.4/index.html
[12]. Daniel, K. (1997). x1 Kasparov v Deeper Blue: The Ultimate Man v Machine Challenge,.
[13]. (s.d.). Initiation au Machine Learning. Consulté le 2018, sur https://makina-
corpus.com/blog/metier/2017/initiation-au-machine-learning-avec-python-theorie
[14]. (2015, August 27). Understanding LSTM Networks. Consulté le 2018, sur
http://colah.github.io/posts/2015-08-Understanding-LSTMs/
[15]. (s.d.). Consulté le 2018, sur tensorflow:
https://www.tensorflow.org/versions/r1.1/tutorials/seq2seq
[16]. (s.d.). microsoft developer. Consulté le 2018, sur Une première introduction au Deep
Learning: https://blogs.msdn.microsoft.com/mlfrance/2016/04/28/une-premiere-
introduction-au-deep-learning/
[17]. Haton, J.-P. (2018). Reconnaissance automatique de la parole.
[18]. (2001). Paul Viola et Michael Jones, Rapid Object Detection using a Boosted Cascade of
Simple Features. IEEE CVPR.
64
[19]. [P. V. (2001). Robust real-time object detection. Second
internationalworkshoponstatisticalandcomputationatheoriesofvision.
[20]. Khefif, B. (2013). Mise au point d’une application de reconnaissance faciale.
[21]. Darding, G. (2016, 09 06). Consulté le 2018, sur Technique: le détecteur de fatigue:
www.guillaumedarding.fr
[22]. (s.d.). Learn facial expressions from an image. Consulté le 2018, sur
https://www.kaggle.com/c/challenges-in-representation-learning-facial-expression-
recognition-challenge/data
_________________________________________________________________
RESUME
L’objectif principal de ce travail de PFE consiste à élaborer une solution technologique réelle
pour rendre les véhicules autonomes capables de passer du niveau 3 au niveau 4 d’autonomie.
De même, on a construit un logiciel de tableau de bord contenant des applications qui facilite
le contrôle interne du véhicule tout en assurant la sécurité interne et externe et l’intelligence
du véhicule.
Mots clés : voiture autonome, intelligence artificiel, assistant virtuel.
_________________________________________________________________
ABSTRACT
This final of studies project aims to develop a real technological solution to make autonomous
cars able to pass from level 3 to level 4 of autonomy.
In the same way, we have built a dashboard application that provides security, intelligence of
the car. Also it makes communication and control easier.
Keywords: self-driving car, artificial intelligence, chatboot.
top related