Rapport Pfe Ihab Bendidi

ROYAUME DU MAROC
*-*-*-*-*
HAUT COMMISSARIAT AU PLAN
*-*-*-*-*-*-*-*
INSTITUT NATIONAL
DE STATISTIQUE ET D’ECONOMIE APPLIQUEE
Projet de Fin d’Etudes
*****
Bibliothèque et container de vision d’ordinateur
Préparé par : M. Ihab Bendidi
Sous la direction de : M. Adil Kabbaj (INSEA)

Mme Andreea Dumitrascu (Zenika)
Soutenu publiquement comme exigence partielle en vue de l’obtention du
Diplôme d’Ingénieur d’Etat

Filière : Informatique
Devant le jury composé de :
▪ M. Adil Kabbaj (INSEA)

▪ M. Nabil Saidi (INSEA)
▪ Mme Andreea Dumitrascu (Zenika)
Juin 2019/ PFE N° 35

*****
2
Dédicace
Dédicace
A ma très chère mère Najat, à mon frère Ouail, à ma sœur Wissal, qui
représentez pour moi ce qui a de plus important. Pour toute ma famille, qui n’a
jamais arrêté de me soutenir et de m’encourager pour avancer et dépasser mes
limites.
A mes très chers professeurs, qui m’ont beaucoup offert, et sont les vrais
piliers de ce travail, vous nous avez tant donné, et c’est maintenant de notre tour
de contribuer et ajouter de la valeur à notre société.
A tous mes amis, ma seconde famille, qui aviez été un support tout au long
de ce parcours. Que la distance entre nous soit lointaine ou proche, vous resterez
toujours près du cœur.
A Andreea, ma chère encadrante qui m’a permis de travailler sur un sujet qui
explore les limites, à M. Kabbaj, mon cher encadrant qui m’a encouragé à
poursuivre dans ce parcours.
A mes meilleurs amis, Nacer, Zakaria, Kabil, Fouad, Nisrine, Nada et

Marwa. A mes très chers proches camarades Sabah, Anass, Hamza et Khaoula.
A toute l’INSEA, qui m’a été un second berceuil, et à Zenika, qui m’a offert
l’opportunité de voir un nouvel univers.
3
Remerciements
En tout premier lieu, je devrais adresser mes remerciements à mes encadrant,
M. Kabbaj et Mme. Dumitrascu, pour leur soutien, leurs encouragements et leur
bonne volonté, dont ils ont amplement fait preuve pour la durée de mon stage,
ainsi que leurs conseils et leur judicieux encadrement qu’ils m’ont prodigués en
abondance.
Je tiens encore à remercier l’équipe Zenika, qui m’a chaleureusement

accueilli et donné l’opportunité de travailler avec une équipe d’experts
informatiques, et pour leur aide et collaboration pour mener à point
l’aboutissement et la complétion de ma mission.
Mes remerciements sont aussi pour tous mes enseignants à l’Institut National
de Statistique et Economie Appliquée, m’ayant offert une formation qui est à
jour avec les demandes internationales du monde professionnel, et qui m’a
permis de travailler sur les sujets de pointe du monde.
Et je remercie de tout cœur les respectueux membres du jury, qui m’ont

offert l’honneur de juger mon travail.
Enfin, je remercie toute personne ayant contribué de loin ou de proche à

l’aboutissement et réalisation de ce travail.
A toutes et à tous, Je vous remercie infiniment.
4
Résumé
Résumé
Mon projet de fin d’études au sein de Zenika s’inscrit dans le cadre d’un
projet de recherche et développement de l’entreprise, qui consiste à offrir aux
développeurs et entreprises une bibliothèque de modèles d’intelligence
artificielle optimisés pour utilisation production.
En effet, les développeurs et entreprises ont de plus en plus besoin de

capacités d’intelligence artificielle dans leurs services et processus. Pourtant, la
main d’œuvre dans ce domaine est rare est coûteuse, et la barre technique
élevée. Afin de remédier à cela, nous développons une bibliothèque
d’intelligence artificielle, intégrant des modèles pré-entrainés et des APIs pour
manipulation, permet à ces développeurs et entreprises d’intégrer des services
IA dans leurs systèmes et applications, avec toutes les dernières avancées dans
le domaine, notamment le machine learning quantique.
Mon projet consiste alors en premier lieu de développer une bibliothèque et

container de IA et vision d’ordinateur, qui permet la reconnaissance des identités
des personnes, la détection des émotions, et la reconnaissance des objets, et
implémentant les concepts des systèmes quantiques pour optimisation des
ressources d’inférence et augmentation de précision, avec des APIs qui
permettent à des non connaisseurs dans le domaine d'entraîner les modèles et les
manipuler en milieu de production sans avoir besoin de connaissances
techniques.
Mots clés : Machine Learning, Deep Learning, Library, Tensorflow,

Machine Learning Quantique, Container, Docker, Serveur, Intelligence
Artificielle, Quantum Computing, Computer vision. Object recognition, Face
recognition.
5
Table de matières
Table de matières
***** ..................................................................................................................... 1
Dédicace : .............................................................................................................. 3
Remerciements ...................................................................................................... 4
Résumé .................................................................................................................. 5
Table de matières................................................................................................... 6
Liste des figures..................................................................................................... 8
Liste des Abréviations ......................................................................................... 10
Introduction ......................................................................................................... 11
Chapitre 1 : Contexte ........................................................................................... 12
1. Organisme d’accueil : ................................................................................ 13
a. Présentation socio-économique de l’entreprise ...................................... 13
b. Présentation générale de l’entreprise ...................................................... 14
c. Management de l’entreprise ................................................................... 15
d. Clientèle et partenariat ............................................................................ 15
e. Récompenses et prix ............................................................................... 15
a. Présentation du projet : .............................................................................. 16
a. Contexte du projet : ................................................................................ 16
b. Problématique abordée : ......................................................................... 17
c. Solution envisagée : ................................................................................ 20
2. Conduite du projet : ................................................................................... 23
a. Démarche de gestion de projet : ............................................................. 23
b. Planification du projet : .......................................................................... 26
3. Conclusion : ............................................................................................... 27
Chapitre 2 : Analyse ............................................................................................ 28
1. Revue et littérature : ................................................................................... 29
a. La vision par ordinateur : ........................................................................ 29
b. Auto-ML (Machine Learning Automatique) : ........................................ 32
c. Le Quantum Computing ......................................................................... 32
d. Le Quantum Machine Learning .............................................................. 35
2. Etat d’art et étude des solutions existantes : .............................................. 36
a. Open CV : ............................................................................................... 36
b. TF-Insightface : ...................................................................................... 36
c. Dlib : ....................................................................................................... 37
d. Face_recognition : .................................................................................. 37
2. Analyse des besoins : ................................................................................. 37
6
Table de matières
a. Spécification des besoins : ...................................................................... 37
b. Cas d’utilisations : .................................................................................. 39
c. Architecture du système : ....................................................................... 40
3. Conclusion : ............................................................................................... 42
Chapitre 3 : Environnement ................................................................................ 43
1. Outils de bibliothèque : .............................................................................. 44
a. Python 3 : ................................................................................................ 44
b. Tensorflow : ............................................................................................ 45
c. Numpy : .................................................................................................. 47
d. Pandas : ................................................................................................... 48
e. Jupyter Notebook : .................................................................................. 49
f. Qiskit :..................................................................................................... 50
g. AutoKeras : ............................................................................................. 50
h. Dlib : ....................................................................................................... 51
2. Environnement et container : ..................................................................... 52
a. Flask : ...................................................................................................... 52
b. Docker :................................................................................................... 53
2. Conclusion : ............................................................................................... 54
Chapitre 4 : Réalisation ....................................................................................... 55
1. Bibliothèque de Vision d’ordinateur : ....................................................... 56
a. Reconnaissance Faciale : ........................................................................ 56
b. Reconnaissance d’objet : ........................................................................ 58
c. Algorithme quantique : ........................................................................... 60
d. Modularisation de la bibliothèque : ........................................................ 62
2. Mise en production de la solution :............................................................ 63
a. Mise en place du serveur et container : .................................................. 63
b. Spécification des accès APIs : ................................................................... 63
2. Conclusion : ............................................................................................... 65
Conclusion Générale : ......................................................................................... 66
Webographie : ..................................................................................................... 67
7
Liste des figures
Liste des figures

Figure 1. Logo de l’entreprise Zenika………………………………………13
Figure 2. Phase de processus CRISP-DM…………………………………..23
Figure 3. Logo de Gantt Project…………………………………………….25
Figure 4. Diagramme Gantt du projet…………………………………….26
Figure 5. Architecture d’un réseau de neurones…………………………….29
Figure 6. Représentation d’un qubit avec une Bloch Sphere……………...32
Figure 7. Diagramme de cas d’utilisation…………………………………..39
Figure 8. Architecture de la solution………………………………………..40
Figure 9. Logo de Python……………………………………………….…..43
Figure 10. Logo de Tensorflow……………………………………………..44
Figure 11. Hiérarchie des composants de Tensorflow…………………...…46
Figure 12. Logo de Numpy………………………………………………....46
Figure 13. Logo de Pandas………………………………………………….48
Figure 14. Logo de Jupyter……………………………………………..….48
Figure 15. Logo de Qiskit…………………………………………………..49
Figure 16. Logo d’AutoKeras…………………………………………...….50

8
Liste des figures
Figure 17. Logo de Flask…………………………………………………....51
Figure 18. Logo de Docker………………………...……………………….52
Figure 19. Schéma de flux de reconnaissance faciale………………………55
Figure 20. Architecture du modèle Inception…………………………...…..57
Figure 21. Vue abstraite du modèle Inception……………………………...58
Figure 22. Saut de connexion utilisée dans le réseau résiduel……………...58
Figure 23. Circuit présentant la téléportation quantique………………..…..61
9
Liste des Abréviations
Liste des Abréviations

ANN – Les réseaux de neurones artificiels
API – Application Programming Interface
CNN – Réseaux de neurones convolutionnels
CPU – Central Processing Unit
GPU – Graphical Processing Unit
IT – Information Technologies
IA – Intelligence Artificielle
IoT – Internet des Objets
LSTM – Long Short-Term Memory
ORM – Object to Relational Mapping
R&D – Recherche et Développement
ROI – Retour sur Investissement
REST – Representational State Transfer
RNN – Réseaux de neurones récurrents
SVM – Machines à vecteurs de support
10
Introduction
Introduction
Beaucoup d’entreprises et développeurs sont de plus en plus intéressés par
l’intelligence artificielle, vu les avantages qu’elle offre, et l’avancement qu’elle
a atteint dans les dernières décennies. Chatbots, vision d’ordinateur, ou moteurs
de recommandations, ils peuvent reconnaître leur importance dans le monde
futur, et essaient d’en faire partie, que ce soit pour développer de nouveaux
services et applications, optimiser des processus, ou exploration en R&D.
Or, les compétences avancées dans ce domaine se retrouvent coûteuses et peu

nombreuses comparées au besoin. Pour les développeurs, et surtout les
freelances, ils trouvent des difficultés à entamer ce nouveau domaine
d’intelligence artificielle, pour l’intégrer dans leurs services et applications, vu
le coût de ce choix en temps et opportunités. En même temps, les entreprises
font face à la difficulté de retrouver des perles rares qui maîtrisent ce domaine,
demandant des salaires raisonnables, avec un retour sur investissement
suffisamment positif.
Ceci a alors lancé la réflexion de développement de bibliothèque pour les

développeurs, et de conteneur pour les entreprises, qui permet l’utilisation et
contrôle des dernières avancées de l’IA, sans la nécessité de connaissances dans
le domaine d’intelligence artificielle, même dans des systèmes d’informations et
applications en production. Ce produit sera alors utilisé par les clients et intégré
dans leurs propres systèmes, et n’auront alors à partager leurs données ou à avoir
une main d’œuvre technique très élevée.
Le présent rapport, dédié à la présentation de notre projet de fin d’études,

s’articule autour de quatre chapitres :
Un premier chapitre qui explique le contexte du projet, ainsi que la

problématique qu’il résout. Un deuxième chapitre pour présenter un état d’art
des solution existantes, et l’utiliser pour présenter une analyse de besoins, ainsi
que l’architecture de notre solution. Le troisième chapitre traitera alors les
technologies utilisées dans le développement de la solution, et puis le quatrième
chapitre clôturera en explication la réalisation de la solution.
11
Chapitre 1 : Contexte
Contexte général du projet
Dans ce chapitre, nous allons aborder le contexte général du projet. Tout

d’abord nous présentons l’organisme d’accueil, ses produits et services et son
organisation, puis nous allons citer les différentes parties du projet.
Pour mettre en exergue l’objectif de ce travail, nous présentons les

problématiques ainsi que les objectifs visés. Et pour assurer la bonne conduite
du projet, un plan d’action est présenté avec la méthodologie adoptée.
12
1. Organisme d’accueil :
a. Présentation socio-économique de l’entreprise
Zenika [1] est une entreprise de services du numérique, créée en 2006 à Paris
par un groupe de quatre développeurs : Carl Azoury, Laurent Delvaux, Nicolas
André et Pierre Queinnec. Aujourd’hui Zenika est considérée comme une
entreprise internationale, elle est située dans trois continents et 10 villes, qui sont
Paris, Lyon, Rennes, Nantes, Lille, Bordeaux, Singapour, Montréal, Grenoble et
Brest. L’agence de Paris au sein de laquelle j’ai effectué mon stage était fondée
en 2006.
Figure 1. Logo de l’entreprise Zenika
La mission de cette société est d’accompagner les entreprises dans leur

transformation numérique. Zenika, qui se hisse à la première place du Palmarès
Great Place to Work France 2018 des entreprises de moins de 500 salariés, est
classée parmi les grandes sociétés internationales, par sa capacité de s’adapter
aux ouvertures technologiques dans les différents domaines : Mobilité, Web,
Java, Big Data, IoT, DeVops, Craftsmanship, Sécurité et Agilité. Grâce à ses
460 collaborateurs, qualifiés en tant que experts dans leurs domaines, Zenika a
pu acquérir un chiffre d’affaire de 36 Millions € en 2019.
Zenika offre principalement quatre services qui peuvent être catégorisés en :
13
- Services de formation : la veille technologique et l’adaptation aux futurs
besoins technologiques se considèrent comme une nécessité au sein de Zenika.
Dans cette perspective des formations dans tous les domaines sont programmées
par les consultants.
- Services de conseil : Zenika accompagne ses clients dans leurs

transformations numériques, sur le plan organisationnel, managérial et
technique.
- Services de réalisation : Ces services sont assurés par les consultants

hautement qualifiés dans leurs domaines, qui accompagnent les entreprises dans
leurs projets.
- Service de recherche et développement : Tout dernièrement créé au début

de 2019, ce service a pour but de faire de la recherche et créer des solutions et
avancées diverses dans les nouvelles technologies.
b. Présentation générale de l’entreprise
Concernant son organisation générale, Zenika se découpe en agences et en

pôles. Pour assurer l’autonomie de chaque agence, un directeur managérial
d’agence et un directeur technique sont désignés. Les pôles Zenika sont
découpés selon la spécialité :
- AYA : le pôle qui regroupe le Design et le développement Web.
- Zinc AI : Le pôle Intelligence artificielle.
- KAI : le pôle Agile.
- Unkipple : le pôle Data et analyses des données.
- Craftmanship : le pôle de l’audit de code et refactoring.
- DevOps : le pôle d’administration des infrastructures informatique.
- Java : le pôle développement Java.

14
- IoT : le pôle de l’innovation.
- Formation : le pôle responsable des formations.
c. Management de l’entreprise
Zenika Applique un modèle de fonctionnement qui place les collaborateurs

au centre de l’entreprise, avec un management basé sur la responsabilisation et
l’autonomie.
La direction et les managers sont présents pour accompagner et faciliter

l’évolution du collaborateur tout au long de sa carrière chez Zenika.
Dans son modèle d’entreprise de type horizontal, les niveaux hiérarchiques

sont limités. Les collaborateurs bénéficient de plans de formations sur mesure
qui répondent à leurs besoins. Une journée de formation intra, appelée
Technozaure, est également organisée pour les consultants.
d. Clientèle et partenariat
Zenika travaille actuellement avec des nombreux groupes de différents

secteurs :
- Secteur Financier : Société Générale, BNP, NATIXIS...
- Secteur de la télécommunication et de l’industrie : SFR, SAGEM,

ORANGE, MICHELIN, AIRBUS...
- Secteur des services de l’administration : La POSTE, MINISTÈRE DE LA

DÉFENSE...
Également, Zenika est partenaire des sociétés les plus connues dans le monde
comme : Pivotal (Spring), MongoDB, Elastic, Docker...
e. Récompenses et prix
Zenika a remporté plusieurs prix au cours des années, dont les prix phares :
15
• Best Workplace : Chaque année, Great Place To Work étudie les
meilleures entreprises françaises où il fait bon de travailler. Pour sa
cinquième participation, Zenika occupe la 1ère place du Palmarès Great
Place to Work France 2018 dans la catégorie de moins de 500 salariés, et
la 9ème place au classement Européen.
• HappyTrainees : Une enquête européenne sur la satisfaction des stagiaires
et alternants. Les étudiants en mission chez Zenika ont attribué la note de
4.28 / 5 pour la qualité de leur stage, ce qui a propulsé Zenika à la 7ème
place du classement HappyTrainees 2015/2016.
• Deloitte Technology Fast50 : Pour la quatrième année consécutive,
Zenika fait partie des 500 entreprises à plus forte croissance dans la zone
EMEA.
• Systematic Paris Region Digital Ecosystem : Zenika est lauréate des
entreprises innovantes 2013 du pôle de compétitivité.
Zenika continue de recevoir des prix et récompenses chaque année dans ces
catégories.
a. Présentation du projet :
a. Contexte du projet :
Dans un monde où l’intelligence artificielle devient le nouvel or, ainsi que la

prochaine menace pour la race humaine, ce domaine devient le point de
focalisation des efforts des chercheurs et organisations du monde. Avec de
nouvelles avancées annoncées chaque jour dans l’IA, quelques-unes étant bien
très inquiétantes, les entreprises retrouvent de plus en plus d’usages de l’IA pour
ajouter une grande valeure à leurs processus et services, de la finance et sécurité,
à l’agriculture et même la musique.
L’IA peut certainement résoudre de nombreux problèmes, notamment les

problèmes d’optimisation et d’automatisation, ainsi que d’offrir de nouveaux
services, comme les agents conversationnels et les assistants virtuels, en plus
d’une capacité cognitique qui leur permet de résoudre des tâches complexes.
Ce domaine alors devint reconnu comme un standard d’avancement des

entreprises dans l’Europe, où l’adoption de ses techniques permet à
16
l’organisation de passer à une étape supérieure et à élargir leurs services, ce qui
a poussé les universités à créer des cursus dans ce domaine, pour produire des
promotions compétentes et capables de suivre les dernières avancées de l’IA et
de les implémenter.
En plus, des entreprises sont apparus chevauchant la vague du Cloud

Computing, qui offrent des solutions IA sur leurs Cloud comme service aux
autres entreprises encore novices dans le domaine.
En même temps, avec l’explosion des données, et le ralentissement de

l’augmentation de la puissance des nouveaux ordinateurs, tous les organismes
cherchent de nouveaux moyens pour optimiser les algorithmes de l’IA, afin de
garantir les avantages qu’elle leur offre même dans l’ère future.
b. Problématique abordée :
Malgré l’intérêt des entreprises dans ce domaine, plusieurs défis doivent

premièrement être relevés avant de pouvoir adopter l’IA. Dans ce contexte, elles
se retrouvent avec un nombre de problématiques qui rendent cette tâche plus
difficile, et qui peuvent être présentées comme suit :
• Rareté des compétences en IA :
Malgré l’existence de ce domaine depuis le milieu du dernier siècle, les

dernières avancées ne furent leurs premières apparitions qu’à la fin de ce siècle,
et ne furent adaptables au monde professionnel qu’à la dernière décennie.
Un tel jeune domaine, qui n’a aussi gagné en popularité qu’aux dernières
années, a certainement des experts très compétents qui le maîtrisent. Ils restent
néanmoins très rares, et ne pourront jamais couvrir le besoin et la demande
énorme de toutes les entreprises du monde intéressées.
Nombreux sont les écoles et instituts qui lancent des filières et modules qui
initient leurs étudiants en IA, mais il a été apparent que ça ne pourrait résoudre
cette problématique en court terme, et aura besoin de plusieurs années pour
combler le besoin.
17
Les entreprises se lancent alors dans des chasses désespérées pour recruter
des personnes expertes, qui seront la clé à l’adoption de l’IA en interne. Ils ont
commencé à recruter, même à l'étranger, après que leurs gouvernements eurent
fait des offres alléchantes de nationalité et d'autres avantages aux talents
étrangers. Sur le plan politique, des pays comme le Canada et la France adoptent
de nombreuses règles en matière de recrutement dans le domaine des TI et de
l'IA, ce qui simplifie la tâche d'avoir de meilleurs talents et de les faire rester au
pays.
Cet intérêt très élevé, conjugué au manque de talent, a fait monter en flèche
les coûts de recrutement et les salaires. Pour les entreprises qui essaient encore
d'expérimenter l'utilisation de l'IA et celles qui n'ont pas atteint une maturité et
une taille suffisantes, ces coûts peuvent être très démotivants et les pousser à
abandonner cette vague de changement.
• Barre technique élevée :
Un certain nombre d'entreprises du monde entier ont choisi une autre

alternative, à savoir former leurs propres experts en IA en interne, les fidéliser
dans un marché du recrutement très concurrentiel et agressif, tout en réduisant
certains des coûts de recrutement tout en assurant la qualité. Ce type de solutions
de rechange avait eu beaucoup de succès dans le domaine des TI, en
abandonnant la nécessité d'un diplôme d'ingénieur et en se concentrant sur
l'enseignement aux personnes talentueuses des bases et des connaissances
avancées en programmation et en développement par la pratique.
Cette méthode a perdu une partie de son efficacité en IA, car la barre
technique est extrêmement haute dans ce domaine, avec la nécessité de
connaissances avancées en mathématiques et en statistiques, ce qui est
certainement une rareté, et de l'utiliser efficacement en conjonction avec de
bonnes compétences informatiques pour se lancer en IA.
Maîtriser ce domaine, c'est aussi avoir un esprit très analytique et passionné

par l'intelligence artificielle, car c'est un domaine en pleine croissance, qui a
encore beaucoup de chemin à faire, et seule la passion permet d'y rester, et c'est
par une analyse très précise que l'on peut apporter de la valeur à son entreprise.
18
Cet obstacle a rendu un peu difficile la mise en œuvre de cette solution, en
particulier pour les petites entreprises, tant pour les coûts que pour
l'investissement de temps important. Les talents ont également choisi d'autres
domaines de l'informatique, qu'ils pourraient maîtriser plus facilement dans un
avenir prévisible, au lieu de se débattre avec les mathématiques avancées et
leurs utilisations en informatique.
• Difficultés d’intégration dans les SI :
Certaines entreprises ont encore fait le saut et ont créé des équipes d'experts
en intelligence artificielle, qui ont analysé les structures internes de l'entreprise
et conçu des modèles qui permettraient de l'optimiser et de fournir de meilleurs
services. Ils ont ensuite été confrontés à l'obstacle suivant : l'exploitation des
modèles d'IA dans un environnement de production est presque aussi difficile
que leur création, et c'est un autre domaine différent. Les approches permettant
de mettre en œuvre cela d'une manière rentable font qu'il est important pour
l'entreprise d'avoir des ingénieurs de données pour l'architecture de base, afin de
rendre les modèles exploitables et de les pousser sur les serveurs de manière
fiable, de créer des API pour traiter les requêtes internes et externes, et de mettre
en œuvre des architectures Big Data pour traiter d'énormes volumes de données.
Pour améliorer en permanence les performances et gérer les différentes

versions des modèles, et afin de créer des pipelines pour les données nécessaires
à l'exploitation et à la formation en temps réel, et de pérenniser le changement
dans le temps, des équipes DevOps et DataOps seraient également nécessaires
pour assurer le développement continu.
Pour les entreprises qui n'avaient pas déjà investi dans ces équipes
auparavant, leurs coûts seraient triplés, car elles sont incapables de gérer
l'intégration transparente de l'IA et de ses complexités.
• Nécessité de partage de données confidentielles :
Face à tous ces problèmes, plusieurs solutions ont tenté de les résoudre.
L'une de ces solutions est rapidement devenue la plus populaire, l'IA en tant que
service. Elle est basée sur le concept d'hébergement de modèles d'IA sur les
19
nuages des fournisseurs du service, des clients et des entreprises exploitant ces
modèles via des API.
Tous les fournisseurs de cloud Computing ayant une certaine expertise en

intelligence artificielle ont commencé à offrir leurs services, en fournissant des
modèles de vision par ordinateur, de recommandation et bien d'autres, hébergés
et prêts pour mise en production dans ces mêmes nuages. Les plus connus sont
Google, Amazon, Microsoft et IBM, offrant des API qui fournissent tous ces
services.
Cela a certainement résolu tous les problèmes mentionnés ci-dessus, car les
entreprises n'ont pas besoin d'avoir des experts dédiés dans le domaine pour
bénéficier de l'IA. Ils pourraient payer directement pour l'IA sur le cloud, qui
serait ensuite utilisé dans leurs propres services.
Néanmoins, avec le temps, deux problèmes sont apparus. Tout d'abord, il

s'est accompagné d'un surcoût de continuer à envoyer et à recevoir des données
vers un Cloud externe pour des prédictions en temps réel. Les entreprises ont
commencé à éviter cela, car ça ajoutait trop de coûts supplémentaires aux coûts
déjà élevés de l'IA sur le service en nuage.
Deuxièmement, ces services ont été conçus dans le but d'envoyer les données
des entreprises aux fournisseurs de services dans les nuages. En d'autres termes,
on perdait le contrôle absolu de ses propres données, qui est le pétrole du siècle
en cours, au profit d'autres entreprises. Pour de nombreuses entreprises, en
particulier les sociétés financières et de sécurité, il est tabou de laisser leurs
données quitter l'entreprise sous n'importe quelle situation.
c. Solution envisagée :
En première étape, nous avons divisé l’intelligence artificielle en parties, et

avons décidé de commencer par la vision d’ordinateur. La solution proposée
pour résoudre ce problème se compose de trois composants différents :
• Bibliothèque de vision d’ordinateur pour les développeurs :
Nous avons travaillé sur le développement d'une bibliothèque open source

pour les développeurs, qui leur permet d'utiliser les capacités d'IA sans avoir
20
besoin d'expertise dans le domaine. À l'heure actuelle, il existe de nombreux
Framework et outils qui aident les data scientists et les experts de l'IA à
accomplir leurs tâches de façon plus efficace et encore plus performante.
Néanmoins, ces outils nécessitent encore une connaissance de base approfondie,
et les développeurs normaux ne peuvent donc pas comprendre les méthodes
d'utilisation de ces outils.
Au lieu d'emprunter cette voie, notre bibliothèque se concentrerait davantage

sur la fourniture aux développeurs de capacités IA prêts à l'emploi qui leur
permettraient d'utiliser la vision par ordinateur sous toutes ses formes et cas
d'utilisation par un simple appel de fonction, et de former leurs modèles dans
différentes situations par des méthodes et fonctions simples.
La bibliothèque serait en mesure de donner la reconnaissance faciale,

l'émotion, la reconnaissance de l'âge et du sexe, ainsi que l'API de
reconnaissance d'objets aux utilisateurs, pour les utiliser immédiatement sur
leurs problèmes, et même de les entraîner d'une manière simple et fiable sur
leurs propres données pour une meilleure précision. Ils pourraient les intégrer
facilement dans leurs applications, et ainsi fournir de meilleures applications qui
intègrent toutes les solutions de vision par ordinateur, sans avoir besoin
d'expertise dans le domaine.
De cette façon, même si les experts en IA restent rares par rapport aux
besoins du marché, les entreprises et les développeurs seraient toujours en
mesure de produire et d'expérimenter en utilisant l'IA sans les coûts élevés de
recrutement.
• Algorithmes quantiques pour optimisation :
À une époque où les données sont de plus en plus nombreuses et où nous

aurions besoin de plus d'infrastructure que jamais pour continuer à les traiter,
l'informatique quantique a donné naissance à une nouvelle ère, où les
ordinateurs quantiques ont changé la façon dont les algorithmes fonctionnent et
les ont rendus beaucoup plus performants sur des données extrêmement
énormes.
21
Au fur et à mesure que cette nouvelle vague d'informatique s'installe, tous les
domaines de l'informatique ont lentement commencé à connaître certains
changements, afin de pouvoir s'y adapter correctement. L'IA a également
commencé à connaître certains de ces changements, avec l'émergence de
l'apprentissage par machine quantique, qui utilise des algorithmes adaptés à
l'utilisation des ordinateurs quantiques.
Les entreprises qui s'intéressent alors à l'IA devront nécessairement suivre la

vague et s'adapter aux nouveaux changements qui se produiront au cours des
prochaines années. Pourtant, pour les entreprises déjà en difficulté avec l'IA,
elles seraient confrontées à deux fois plus de difficultés et ne seraient pas en
mesure de suivre le rythme des changements, surtout en ce qui concerne
l'informatique quantique, où tous les problèmes mentionnés précédemment sont
encore plus prononcés.
Dans ce domaine de l'IA quantique, où il n'existe que des Framework de code

de base et de bas niveau avec peu d'abstraction, on aurait du mal à mettre chaque
algorithme quantique dans son bon usage, pour optimiser le traitement
d'énormes ensembles de données et obtenir des résultats encore meilleurs.
Notre objectif est de fournir des algorithmes quantiques qui sont incorporés
dans notre bibliothèque de vision par ordinateur, ce qui aiderait à classer les
catégories dans la détection des catégories et la classification des images
beaucoup plus facilement sur de nombreuses catégories. Avec ces algorithmes,
même avec des catégories extrêmement nombreuses, que ce soit en
reconnaissance faciale ou en reconnaissance d'objets, les résultats resteraient
toujours rapides et utilisables en temps réel, et les entreprises et les développeurs
pourraient suivre la vague quantique, sans avoir besoin de connaissances
techniques, grâce au niveau élevé d'abstraction.
La bibliothèque aurait alors un niveau de performance élevé, très proche des

performances des géants de la technologie, et permettrait aux développeurs
d'utiliser l'intelligence artificielle même dans ses formes les plus avancées et
dans tous les cas d'utilisation classiques, facilement et de manière fiable.
• Un container d’intelligence artificielle prêt à utilisation :
22
Après avoir constaté les nombreuses difficultés rencontrées par les
entreprises pour mettre en production leurs propres modèles d'IA, il est apparu
qu'il s'agit d'une tâche nécessitant un ensemble de compétences différentes et
rares.
Nous avons décidé d'utiliser notre bibliothèque comme base pour fournir un
serveur, qui a ensuite été placé dans un conteneur, aux entreprises qui ont
l'intention d'utiliser l'IA en production, en prenant en charge la mise en
production des modèles. Ces entreprises pourraient alors très facilement placer
ces conteneurs sur leurs propres instances de serveur et accéder aux cas
d'utilisation de l'IA et de la vision par ordinateur que nous fournissons via une
API REST sur leur propre réseau local.
Un autre avantage pour les entreprises serait la possibilité de conserver leurs

propres données sur leur infrastructure, gardant la confidentialité, car les
conteneurs seraient appropriés par elles et hébergés sur leurs propres serveurs.
2. Conduite du projet :
a. Démarche de gestion de projet :
Concernant la démarche du projet, j’ai choisi une démarche de gestion de

projet data science appelée DM-CRISP, qui signifie ‘Cross-Industry Standard
Process for Data Mining’. Cette méthode a été éprouvée de façon empirique,
permettant d’orienter les travaux d’exploration de données lancé en 1997 et
adopté depuis 2011 par l’entreprise IBM.
En tant que méthodologie, CRISP-DM comprend des descriptions des phases

typiques d’un projet et les tâches comprises dans chaque phase ainsi qu’une
explication des relations entre ces tâches. Et en tant que modèle de processus,
CRISP-DM offre un aperçu du cycle de vie de l’exploration de données.
23
Figure 2. Phase de processus CRISP-DM
Le modèle de cycle de vie comporte six phases dotées de flèches indiquant

les dépendances les plus importantes et les plus fréquentes entre les phases. La
séquence des phases n’est pas strictement établie. De ce fait, les projets, pour la
plupart, passent d’une phase à l’autre en fonction des besoins.
• Compréhension de business :
Cette étape vise principalement à comprendre le monde des affaires sous tous
ses aspects. Il suit les différentes étapes ci-dessous :
a. Identifier l'objectif et cadrer le problème de l'entreprise.
b. Recueillir des informations sur les ressources, les contraintes, les

hypothèses, les risques, etc.
c. Préparer l'objectif analytique.
• Compréhension de données :
Cette phase dans le processus DM-CRISP réside dans la collecte et l’analyse

des données pour comprendre les différentes variables et effectuer des tests
24
statistiques multiples afin d’identifier les différentes distributions suivies par les
données.
• Préparation de données :
Cette étape consiste à la préparation et au nettoyage des données fournies et

collectées. Plusieurs étapes doivent être suivies pour achever la phase de
préparation des données à savoir :
1. Traitement de données manquantes.
2. Traitement de données aberrantes.
3. Normalisation/standardisation de données.
4. Extraction des variables significatives.
5. Ajout de nouvelles variables (carrés, logarithmes, etc.).
6. Réduction de la dimensionnalité.
• Création des modèles :
Une fois les étapes ci-dessus terminées, la création d’un algorithme de

Machine Learning (apprentissage automatique) est fondamentale et le test des
différents algorithmes devient possible et plus significatif. L'algorithme à
sélectionner dépend entièrement des besoins du projet, des données disponibles
et du résultat souhaité.
• Evaluation des modèles :
Cette étape repose sur le test et l’évaluation du modèle. Les mesures

d'évaluation à choisir dépendent des critères d'évaluation, du résultat final
souhaité du modèle, des exigences de l'entreprise et de l'algorithme du modèle
utilisé.
• Déploiement du modèle :
25
Une fois que le modèle est bien évalué et confirmé, il peut être déployé et
mis en production pour répondre aux problématiques du projet.
La motivation derrière le choix de cette méthode est que le modèle CRISP-

DM peut être aisément personnalisé.
b. Planification du projet :
La planification fait partie des étapes les plus importantes pour la réalisation
efficace d’un projet, elle permet de s’assurer que ce dernier va atteindre ses
objectifs dans des délais bien définis et contrôlés. Le diagramme GANTT
permet d’évaluer et de suivre la réalisation du projet tout en spécifiant les phases
de chaque partie et les délais pour lesquels elles doivent être réalisées. Le
diagramme de GANTT, couramment utilisé en gestion de projet, est l’un des
outils les plus efficaces pour représenter visuellement l’état d’avancement des
différentes activités et tâches qui constituent les phases d’un projet. La colonne
gauche de diagramme GANTT énumère toutes les tâches à effectuer et la ligne
d'en-tête représente les unités de temps le plus adaptés au projet (jours,
semaines, mois, etc.), cette représentation se fait sur le logiciel Gantt Project.
Figure 3. Logo de Gantt Project
Gantt Project est un logiciel libre permettant de modifier la planification des

différentes tâches qui sont nécessaires à un projet. Chaque tâche pourra être
définie par sa durée et par les ressources qui pourront lui être affectées.
26
Figure 4. Diagramme de Gantt du projet
3. Conclusion :
Ce chapitre explique le contexte de notre projet et comment, avec cette
solution pour les entreprises et les développeurs, il est devenu plus facile
d'utiliser l'IA à travers le monde. Le chapitre suivant discutera ensuite de notre
analyse des besoins et des spécifications, afin d'obtenir une architecture
adéquate de notre solution.
27
Chapitre 2 : Analyse
Analyse et conception du projet
Dans ce chapitre, nous établirons une étude et comparaison des solutions

existantes dans le marché, qui résulte en une analyse des spécifications de notre
projet sur le plan fonctionnel et technique, avec une présentation des acteurs et
de l’architecture applicative.
28
1. Revue et littérature :
a. La vision par ordinateur :
• Présentation
La vision par ordinateur est un domaine scientifique interdisciplinaire qui

traite de la façon dont les ordinateurs peuvent être conçus pour acquérir une
compréhension de haut niveau à partir d’images ou de vidéos numériques. Du
point de vue de l'ingénierie, il cherche à automatiser les tâches que le système
visuel humain peut effectuer.
Les tâches de la vision par ordinateur comprennent des méthodes pour

acquérir, traiter, analyser et comprendre des images numériques et extraire des
données de grande dimension du monde réel afin de produire des informations
numériques ou symboliques. Comprendre, dans ce contexte, signifie transformer
les images visuelles en description du monde pouvant s’interfacer avec d’autres
processus de la pensée et susciter une action appropriée. Cette compréhension de
l'image peut être vue comme le démêlage d'informations symboliques à partir de
données d'images, à l'aide de modèles construits grâce à la géométrie, la
physique, les statistiques et à la théorie de l'apprentissage.
En tant que discipline scientifique, la vision par ordinateur se préoccupe de la

théorie sous-jacente aux systèmes artificiels qui extraient des informations
d’images. Les données d'image peuvent prendre de nombreuses formes, telles
que des séquences vidéo, des vues de plusieurs caméras ou des données
multidimensionnelles d'un scanner médical. En tant que discipline
technologique, la vision par ordinateur cherche à appliquer ses théories et ses
modèles à la construction de systèmes de vision par ordinateur.
Les sous-domaines de la vision par ordinateur comprennent la reconstruction

de scènes, la détection d'événements, le suivi vidéo, la reconnaissance d'objets,
l'estimation de pose en 3D, l'apprentissage, l'indexation, l'estimation de
mouvements et la restauration d'images.
29
L'implémentation et les étapes d’un système de vision par ordinateur de la
fonction ou des fonctions qu’il va réaliser. De nombreuses étapes et traitements
sont uniques à l'application. Il existe, cependant, des traitements typiques que
l'on retrouve dans de nombreux systèmes de vision par ordinateur.
En même temps, plusieurs méthodes d’implémentation de vision d’ordinateur

ont connu le jour, se concluant par la méthode des réseaux de neurones, étant
celle qui a obtenu les meilleurs résultats.
• Réseaux de neurones et apprentissage profond :
L'apprentissage profond (plus précisément « apprentissage approfondi », et

en anglais deep learning, deep structured learning, hierarchical learning) est un
ensemble de méthodes d'apprentissage automatique tentant de modéliser avec un
haut niveau d’abstraction des données grâce à des architectures articulées de
différentes transformations non linéaires.
Ces techniques ont permis des progrès importants et rapides dans les
domaines de l'analyse du signal sonore ou visuel et notamment de la
reconnaissance faciale, de la reconnaissance vocale, de la vision par ordinateur,
du traitement automatisé du langage et bien d’autres.
Les algorithmes de Deep Learning reposent sur des réseaux de neurones

artificiels (profonds), c’est-à-dire un ensemble de neurones, qui s’envoient des
nombres en fonction de leurs liaisons, jusqu'à des neurones de la dernière
couche (couche de sortie).
30
Figure 5. Architecture d’un réseau de neurones
Ces algorithmes d'apprentissage profond peuvent être classifiés selon

différents types :
• Les réseaux de neurones artificiels (ANN) : ce sont les plus simples et les
plus souvent utilisés en complément car ils trient correctement les
informations et font preuve de bonnes performances dans les tâches de
classification et régression.
• Les réseaux de neurones convolutifs (CNN) : spécialisés dans le
traitement de l’image en général, ils appliquent des filtres à des données
pour en faire ressortir de nouvelles informations (par exemple, faire
ressortir les contours dans une image peut aider à trouver où se trouve le
visage ou reconnaître les différents objets dans une image).
• Les réseaux de neurones récurrents (RNN) : les plus connus sont les
LSTM (Long Short-Term Memory), qui ont pour faculté de retenir de
l’information et de la réutiliser peu après, chose qui est très utile pour le
traitement des données séquentielles comme les séries temporelles et
l’audio et le texte. Ils servent par exemple pour l’analyse de texte (NLP)
pour la traduction ou la génération de texte et développement des
assistants intelligents, puisque chaque mot dépend des quelques mots
précédents (pour que la grammaire soit correcte).
• Ainsi que des versions plus avancées, comme les auto-encodeurs, les
machines de Boltzmann et les machines de Boltzmann Restreintes, les
cartes auto-adaptatives aussi appelées self-organizing maps (SOM), etc.
Les dernières couches peuvent indépendamment être entraînées dans les

réseaux de neurones, pour pouvoir les réutiliser dans plusieurs cas d’usage.
31
b. Auto-ML (Machine Learning Automatique) :
L'apprentissage machine automatisé (Auto-ML) est le processus

d'automatisation du processus de bout en bout de l'application de l'apprentissage
automatique aux problèmes du monde réel. Dans une application typique
d'apprentissage automatique, les praticiens doivent appliquer les méthodes
appropriées de pré-traitement des données, d'ingénierie des caractéristiques,
d'extraction des caractéristiques et de sélection des caractéristiques qui rendent
l'ensemble de données apte à l'apprentissage automatique. Après ces étapes de
prétraitement, les praticiens doivent ensuite sélectionner des algorithmes et
optimiser les hyperparamètres pour maximiser la performance prédictive de leur
modèle final d'apprentissage automatique. Comme beaucoup de ces étapes
dépassent souvent les capacités des non-experts, Auto-ML a été proposé comme
une solution basée sur l'intelligence artificielle pour relever le défi toujours
croissant de l'application de l'apprentissage machine. L'automatisation du
processus de bout en bout de l'apprentissage machine offre l'avantage de
produire des solutions plus simples, une création plus rapide de ces solutions et
des modèles souvent plus performants que les modèles conçus à la main.
c. Le Quantum Computing
• Présentation :
L'informatique quantique est l'utilisation de phénomènes mécaniques

quantiques tels que la superposition et l'enchevêtrement pour effectuer des
calculs. Un ordinateur quantique est utilisé pour effectuer ce calcul, qui peut être
implémenté théoriquement ou physiquement.
Le domaine de l'informatique quantique est en fait un sous-domaine des

sciences de l'information quantique, qui comprend la cryptographie quantique et
la communication quantique.
Il existe actuellement deux approches principales pour la mise en œuvre

physique d'un ordinateur quantique : analogique et numérique. Les approches
analogiques sont ensuite divisées en simulation quantique, recuit quantique et
calcul quantique adiabatique. Les ordinateurs quantiques numériques utilisent
des portes logiques quantiques pour effectuer les calculs. Les deux approches
utilisent des bits quantiques ou qubits.
32
Les Qubits sont fondamentaux pour l'informatique quantique et sont quelque
peu analogues aux bits d'un ordinateur classique. Les Qubits peuvent être dans
un état quantique 1 ou 0. Mais ils peuvent aussi être dans une superposition des
états 1 et 0. Cependant, lorsque les qubits sont mesurés, le résultat est toujours
un 0 ou un 1 ; les probabilités des deux résultats dépendent de l'état quantique
dans lequel ils se trouvent.
Figure 6. Représentation d’un qubit avec une Bloch Sphere
• Principe d’opération :
Un ordinateur quantique avec un nombre donné de qubits est

fondamentalement différent d'un ordinateur classique composé du même nombre
33
de bits classiques. Par exemple, représenter l'état d'un système à n bits sur un
ordinateur classique nécessite le stockage de 2 puissances n coefficients
complexes, alors que pour caractériser l'état d'un système classique à n bits il
suffit de fournir les valeurs des n bits, c'est-à-dire seulement n nombres. Bien
que ce fait puisse sembler indiquer que les qubits peuvent contenir
exponentiellement plus d'informations que leurs homologues classiques, il ne
faut pas oublier que les qubits ne sont que dans une superposition probabiliste de
tous leurs états. Cela signifie que lorsque l'état final des qubits est mesuré, ils ne
seront trouvés que dans l'une des configurations possibles dans lesquelles ils se
trouvaient avant la mesure. Il est généralement incorrect de penser qu'un
système de qubits est dans un état particulier avant la mesure. Les qubits sont en
superposition d'états avant toute mesure, ce qui affecte directement les résultats
possibles du calcul.
Pour mieux comprendre ce point, considérons un ordinateur classique qui

fonctionne sur un registre à trois bits. Si l'état exact du registre à un moment
donné n'est pas connu, il peut être décrit comme une distribution de probabilités
sur l'intervalle 2 puissance 3 = 8 différentes chaînes de trois bits 000, 001, 010,
011, 100, 101, 110 et 111. S'il n'y a pas d'incertitude sur son état, alors il se
trouve dans l'un de ces états avec une probabilité de 1, mais s'il s'agit d'un
ordinateur probabiliste, il est possible qu'il se trouve dans l'un de plusieurs états
différents.
Bien qu'un état classique de 3 bits et un état quantique de 3 bits soient chacun
des vecteurs à huit dimensions, ils sont manipulés de façon très différente pour
le calcul classique ou quantique. Dans un cas comme dans l'autre, le système
doit être initialisé, par exemple dans la chaîne all-zéros, |000⟩, correspondant au
vecteur (1,0,0,0,0,0,0,0,0,0,0,0). Dans le calcul aléatoire classique, le système
évolue en fonction de l'application de matrices stochastiques, qui préservent que
les probabilités s'additionnent en un (c.-à-d. préservent la norme L1). Dans le
calcul quantique, cependant, les opérations autorisées sont des matrices
unitaires, qui sont effectivement des rotations (elles préservent que la somme
des carrés s'additionne à un, la norme euclidienne ou L2). (Les unités exactes
qui peuvent être appliquées dépendent de la physique de l'appareil quantique.)
Par conséquent, puisque les rotations peuvent être annulées en tournant vers
l'arrière, les calculs quantiques sont réversibles. (Techniquement, les opérations
quantiques peuvent être des combinaisons probabilistes d'unités, de sorte que le
34
calcul quantique généralise vraiment le calcul classique. Voir circuit quantique
pour une formulation plus précise.)
d. Le Quantum Machine Learning

• Présentation :
Le Quantum machine learning est un domaine de recherche interdisciplinaire

émergent à l'intersection de la physique quantique et de l'apprentissage
automatique. L'utilisation la plus courante du terme renvoie aux algorithmes
d'apprentissage automatique pour l'analyse de données classiques exécutées sur
un ordinateur quantique. Si les algorithmes d'apprentissage automatique servent
à calculer des quantités de données énormes, l'apprentissage quantique augmente
ses capacités de manière intelligente en donnant la possibilité de réaliser une
analyse sur les états quantiques et les systèmes. Cela inclut les méthodes
hybrides qui impliquent à la fois le traitement classique et quantique, où des
sous-programmes difficiles à calculer sont sous-traités à un dispositif quantique.
Ces routines peuvent être de nature plus complexe et exécutées plus rapidement
à l'aide de dispositifs quantiques. De plus, les algorithmes quantiques peuvent
être utilisés pour analyser des états quantiques au lieu de données classiques.
Les algorithmes quantiques se réfèrent à des algorithmes qui résolvent des

tâches dans l'apprentissage automatique, améliorant et souvent accélérant ainsi
les techniques classiques d'apprentissage automatique. De tels algorithmes
nécessitent généralement d'encoder l'ensemble de données classique donné dans
un ordinateur quantique pour le rendre accessible pour le traitement de
l'information quantique. Ensuite, des routines de traitement de l'information
quantique sont appliquées et le résultat du calcul quantique est lu en mesurant le
système quantique. Par exemple, le résultat de la mesure d'un qubit révèle le
résultat d'une tâche de classification binaire.
L'apprentissage par renforcement est une branche de l'apprentissage

automatique distincte de l'apprentissage supervisé et non supervisé, qui admet
également des améliorations quantiques. Dans l'apprentissage du renforcement
quantique, un agent quantique interagit avec un environnement classique et
reçoit parfois des récompenses pour ses actions, ce qui lui permet d'adapter son
comportement - autrement dit d'apprendre quoi faire pour obtenir davantage de
récompenses. Dans certaines situations, soit en raison de la capacité de
35
traitement quantique de l'agent, soit en raison de la possibilité de sonder
l'environnement en superpositions, une accélération quantique peut être obtenue.
• Réseaux de neurones quantiques
Les analogues quantiques ou les généralisations des réseaux neuronaux

classiques sont souvent appelés réseaux neuronaux quantiques. Le terme est
revendiqué par un large éventail d'approches, y compris la mise en œuvre et
l'extension de réseaux neuronaux utilisant des photons, des circuits variationnels
en couches ou des modèles quantiques. Dans ce modèle, des portes logiques non
linéaires et irréversibles sont déployées pour spéculer l'ensemble de données
donné. Ces portes rendent certaines phases impossibles à observer et génèrent
des oscillations spécifiques. Les réseaux neuronaux quantiques appliquent les
principes de l'information quantique et les calculs quantiques au
neurocomputing classique. Les expériences actuelles montrent que les réseaux
neuronaux quantiques peuvent augmenter de façon exponentielle la puissance de
calcul et le degré de liberté d'un ordinateur, qui est limité à sa taille pour un
ordinateur classique. Un réseau neuronal quantique possède des capacités de
calcul pour diminuer le nombre de pas, les qubits utilisés et le temps de calcul.
La fonction des ondes en mécanique quantique est le neurone des réseaux
neuraux.
2. Etat d’art et étude des solutions existantes :

a. Open CV :
Open CV (pour Open Computer Vision) est une bibliothèque graphique libre,
initialement développée par Intel, spécialisée dans le traitement d'images en
temps réel. Cette bibliothèque met à disposition de nombreuses fonctionnalités
très diversifiées permettant de créer des programmes partant des données brutes
pour aller jusqu'à la création d'interfaces graphiques basiques. Certains
algorithmes classiques dans le domaine de l'apprentissage artificiel sont aussi
disponibles, qui permettent de traiter les images et de les classifier. Pourtant,
Cette bibliothèque requiert des connaissances en IA, et ne peut être facilement
utilisée pour traiter et classifier une image par un débutant.
b. TF-Insightface :
36
Une solution chinoise d’origine, Open Source, qui offre un serveur capable
de d’encoder les images, pour pouvoir passer à l’étape de classification. Il est
surtout utilisé dans la reconnaissance faciale. Il donne une précision de
prédiction surprenante, et est basé sur le langage Python. En revanche, il n’est
pas complet, et requiert d’autres modèles de machine learning et apprentissage
profond pour le complémenter et offrir des résultats pour l’entreprise. En plus, le
serveur ne couvre les questions de déploiement et intégration dans un container.
c. Dlib :
Dlib est une boîte à outils C++ moderne contenant des algorithmes
d'apprentissage automatique et des outils pour créer des logiciels complexes en
C++ pour résoudre des problèmes réels d'IA. Il est utilisé dans l'industrie et le
monde universitaire dans un large éventail de domaines, notamment la
robotique, les appareils intégrés, les téléphones mobiles et les grands
environnements informatiques à haute performance. Il comporte aussi plusieurs
modèles pré-entraînés de traitement et classification d’image, ainsi qu’un API
pour utilisation en Python. Cependant, il nécessite une grande connaissance dans
les processus de machine learning pour être utilisé efficacement.
d. Face_recognition :
Reconnue comme la bibliothèque la plus simple et complète de

reconnaissance faciale, cette bibliothèque permet d’utiliser toutes les capacités
de détection et reconnaissance faciale, ainsi que d’entraîner les classifieurs sur
de nouvelles données très facilement à travers de simples fonctions en Python.
Agissant comme surcouche de Dlib afin de simplifier son usage, cette
bibliothèque a gagné en popularité chez les développeurs pour sa facilité
d’usage. Néanmoins, elle n’est pas rentable à utiliser par les entreprises, car elle
ne gère pas les cas classiques de mise en production, et ne traite pas la méthode
de mise et exploitation des modèles sur un serveur ou container.
2. Analyse des besoins :

a. Spécification des besoins :
Afin de réaliser notre projet ; il est impératif d’expliciter les différents besoins fonctionnels et
techniques, comme il suit :
37
• Besoins fonctionnels
Dans le cadre de la bibliothèque de la vision d’ordinateur, l’objectif sera de

rendre abstraite toute la complexité derrière chaque réponse de l’IA dans une
utilisation en industrie et entreprise. L’utilisateur devra donc être capable
d’accéder à des capacités déjà prêtes, à travers des fonctions simples et claires.
En même temps, dans des situations où il lui sera impératif d’entraîner des
modèles, il sera nécessaire d’implémenter les modèles les plus performants sur
les données de l’utilisateur, afin de sous-traiter le choix du modèle au lieu de le
laisser dans les mains du développeur non expert dans le domaine.
Ceci entraîne l’utilisation d’algorithmes de choix de modèles performants

dans les cas d’usages offerts à l’utilisateur qui permettront de basculer
automatiquement sur les modèles nécessaires.
En même temps, l’IA est connue pour la nécessité d’ordinateurs puissants,

surtout en matière de GPU. Pourtant, nombre de développeurs et entreprises
utilisent encore des CPU, et quelques cas d’usage en IoT nécessiteront des
algorithmes légers capables de tourner sur des composants faibles.
Pour cela, vu le grand nombre de hardware existant sur le marché, chacun

ayant son propre Framework d’utilisation, la bibliothèque devra être en mesure
de reconnaître le hardware de l’utilisateur, et faciliter l’installation et
l’utilisation des bibliothèques et Framework nécessaires pour son utilisation.
La bibliothèque devra aussi offrir plusieurs modèles offrant le même service,

mais qui peuvent tourner sur des ordinateurs ou serveurs de puissance différente,
pour assurer une utilisation générale dans toutes les situations classiques.
En deuxième lieu, le serveur et Container devront être sécurisés

convenablement, pour permettre aux entreprises de les exploiter en toute
sécurité. Toutes les requêtes API suivraient des conventions strictes.
En outre, le conteneur doit être capable de gérer toutes les données qui lui
sont envoyées, de les stocker et de les transformer de manière fiable en fonction
des besoins, ainsi que de gérer différentes versions de modèles entraînés par
38
l'utilisateur, qui seront utilisés et contrôlés en utilisant des commandes de
contrôle de version même en production.
• Besoins non fonctionnels :
Ce projet étant Open Source, offert au grand public gratuitement, il lui est
nécessaire d’assurer un nombre de besoins pour assurer son succès et
complétion :
• Pérennité : Le projet devra utiliser dans technologies qui suivent la vague

de changement et vont durer dans le temps, pour pouvoir rester dans le
marché et être rentable aux entreprises même dans le futur. Le choix des
technologies devrait être alors justifié et bien planifié avec des projections
sur les perspectives de ce projet dans le futur.
• Légèreté : Avec l’intégration de plus en plus de modèles, les containers
deviendront de plus en plus lourds, et comme leur but est de les utiliser
comme micro-services, ils ne pourront satisfaire ce rôle en atteignant des
tailles énormes, et feront perdre aux entreprises en matière de coûts. Les
modèles devront alors être organisés et optimisés pour assurer leur
réutilisation, qui résulte en la légèreté des containers.
• Rapidité : Avec l’utilisation de cette solution dans les systèmes et
applications de l’entreprises, les utilisateurs auront besoin de réponses
rapides et exactes, cela étant la condition du succès de ce projet. Les
modèles devront être ainsi capable de traiter des volumes énormes de
données et de nombreuses catégories rapidement.
b. Cas d’utilisations :
Après l’étude et analyse des besoins, les cas d’utilisation de notre solution
commencent à apparaître plus claires, et peuvent se résumer dans un diagramme
de cas d’utilisations. (Voir figure 7)
39
Figure 7. Diagramme de cas d’utilisation
• Détecter sur images : L’utilisateur recevra des informations reçues de

l’image, comme l’identité des personnes, ainsi que les objets reconnus,
etc.
• Consulter version : Consulter la version de modèle utilisé et les
métadonnées de son entraînement et exploitation.
• Consulter Catégories : Consulter les catégories que la bibliothèque permet
de reconnaître.
• Modifier Catégorie : Ajouter ou supprimer de nouvelles photos
d’entraînement pour la catégorie.
• Ajouter Catégorie : Ajouter une nouvelle catégorie sur laquelle le modèle
sera entraîné.
• Supprimer Catégorie : Supprimer une catégorie et ses données du modèle
entraîné.
• Entraîner Modèle : Entraîne les modèles classifieurs en dernière couche.
c. Architecture du système :
40
Selon le précédent diagramme d’utilisations (Voir figure 7), nous avons été
capables de proposer une architecture à notre solution. (Voir figure 8)
Figure 8. Architecture de la solution
La bibliothèque se compose de modèles pré-entraînés, ainsi que des modules

complémentaires comprenant l’Auto-ML, pour le choix automatique de modèles
agissant en dernière couche comme classifieurs, et des algorithmes quantiques
pour utilisation sur ordinateurs quantiques. Un module permettra également de
gérer les encodings générés par les modèles pré-entraînés, pour les envoyer vers
les classifieurs en dernière couche.
Cette partie sera mise dans un serveur, qui sera englobé dans un container.
En même temps, le container permettra la gestion des logs de toutes les actions
et erreurs, ainsi que gérer les fichiers temporaires résultants de l’utilisation de la
bibliothèque, en plus de gérer les différentes versions des modèles et
bibliothèque.
41
Pour garantir une bonne gestion des requêtes reçues par le container, un API
Gateway a été mis en place pour gérer, sécuriser et guider toutes les requêtes
reçues.
3. Conclusion :
Cette analyse de besoin nous a permis d’éclaircir les cas d’utilisations, ainsi
que les points focaux et prioritaires de notre solution. Ceci nous a poussé à
proposer une architecture du système, qui permettra de mettre en réalité notre
projet.
Dans le chapitre qui suit, nous allons présenter les technologies utilisées pour
la mise en place de notre solution.
42
Chapitre 3 : Environnement
Outils et environnement
Dans ce chapitre, nous allons aborder les outils et technologies utilisées

pour la mise en place de notre solution. Pour assurer la pérennité de notre
projet, le choix de solution a été important et a requis une réflexion importante
ainsi que des projections futures de l’utilisation de ces technologies sur notre
projet.
43
1. Outils de bibliothèque :
a. Python 3 :
Figure 9. Logo de Python
Python [2] est un langage de programmation interprété, multiparadigme et

multiplateformes. Il favorise la programmation impérative structurée,
fonctionnelle et orientée objet. Il est doté d'un typage dynamique fort, d'une
gestion automatique de la mémoire par ramasse-miettes et d'un système de
gestion d'exceptions ; il est ainsi similaire à Perl, Ruby, Scheme, Smalltalk et
Tcl.
Le langage Python est placé sous une licence libre proche de la licence BSD
et fonctionne sur la plupart des plates-formes informatiques, des smartphones
aux ordinateurs centraux, de Windows à Unix avec notamment GNU/Linux en
passant par macOS, ou encore Android, iOS, et peut aussi être traduit en Java ou
.NET. Il est conçu pour optimiser la productivité des programmeurs en offrant
des outils de haut niveau et une syntaxe simple à utiliser.
Il est également apprécié par certains pédagogues qui y trouvent un langage

où la syntaxe, clairement séparée des mécanismes de bas niveau, permet une
initiation aisée aux concepts de base de la programmation.
Python est un langage qui peut s'utiliser dans de nombreux contextes et

s'adapter à tout type d'utilisation grâce à des bibliothèques spécialisées. Il est
44
cependant particulièrement utilisé comme langage de script pour automatiser des
tâches simples mais fastidieuses, comme un script qui récupérerait la météo sur
Internet ou qui s'intégrera dans un logiciel de conception assistée par ordinateur
afin d'automatiser certains enchaînements d'actions répétitives. On l'utilise
également comme langage de développement de prototype lorsqu'on a besoin
d'une application fonctionnelle avant de l'optimiser avec un langage de plus bas
niveau. Il est particulièrement répandu dans le monde scientifique, et possède de
nombreuses bibliothèques optimisées destinées au calcul numérique.
b. Tensorflow :
Figure 10. Logo de Tensorflow
Créé par l’équipe Google Brain en 2011, sous la forme d’un système
propriétaire dédié aux réseaux de neurones profonds, Tensorflow [3] s’appelait à
l’origine DistBelief. Par la suite, le code source de DistBelief a été modifié et cet
outil est devenu une bibliothèque basée application. En 2015, il a été renommé
Tensorflow et est devenu open source.
C’est une bibliothèque de Machine Learning regroupant un grand nombre de

modèles et d’algorithmes permettant de résoudre des problèmes mathématiques
extrêmement complexes avec aisance et de développer des architectures
d’apprentissage expérimentales et de les transformer en logiciels.
45
Nous pouvons la concevoir comme un système de programmation dans
lequel les calculs sont représentés sous forme de graphiques tels que les nœuds
du graphique représentent les opérations mathématiques et les bordures
représentent des flèches de données multidimensionnelles communiquées entre
elles : les tensors.
Son API frontend de développement d’applications repose sur python, tandis

que l’exécution de ces applications s’effectue en C++ haute-performance.
Nous l’avons choisi pour son très grand support dans la communauté, ainsi
que son aise dans la mise en production de modèles.
L'architecture de Tensorflow fonctionne en trois parties :
• Prétraitement des données

• Construire le modèle
• Former et estimer le modèle
Il est appelé Tensorflow parce qu'il prend l'entrée comme un tableau

multidimensionnel, également connu sous le nom de tenseurs. Nous pouvons
construire une sorte d'organigramme des opérations (appelé graphique) que nous
voulons effectuer sur cette entrée. L'entrée entre d'un côté, puis passe à travers
ce système d'opérations multiples et sort de l'autre côté comme sortie.
C'est pourquoi on l'appelle TensorFlow parce que le tenseur passe par une
liste d'opérations, puis il sort par l'autre côté.
TensorFlow est la meilleure des bibliothèques car elle est conçue pour être
accessible à tous. La bibliothèque Tensorflow intègre différentes API pour
construire à l'échelle une architecture d'apprentissage profond comme CNN ou
RNN. TensorFlow est basé sur le calcul graphique ; il permet au développeur de
visualiser la construction du réseau neuronal avec Tensorboad. Cet outil est utile
pour déboguer le programme. Enfin, Tensorflow est conçu pour être déployé à
grande échelle. Il fonctionne sur CPU et GPU.
Tensorflow attire la plus grande popularité sur GitHub par rapport aux autres
cadres d'apprentissage profond.
46
Figure 11. Hiérarchie des composants de Tensorflow
c. Numpy :
NumPy [3] est une extension du langage de programmation Python, destinée

à manipuler des matrices ou tableaux multidimensionnels ainsi que des fonctions
mathématiques opérant sur ces tableaux.
Figure 12. Logo de Numpy
Plus précisément, cette bibliothèque logicielle libre et open source fournit de

multiples fonctions permettant notamment de créer directement un tableau
depuis un fichier ou au contraire de sauvegarder un tableau dans un fichier, et
manipuler des vecteurs, matrices et polynômes.
NumPy est la base de SciPy, regroupement de bibliothèques Python autour

du calcul scientifique.
47
d. Pandas :
Pandas [4] est une bibliothèque écrite pour le langage de programmation

Python permettant la manipulation et l'analyse des données. Elle propose en
particulier des structures de données et des opérations de manipulation de
tableaux numériques et de séries temporelles. Pandas est un logiciel libre sous
licence BSD.
Les principales structures de données sont les séries (pour stocker des
données selon une dimension - grandeur en fonction d'un index), les DataFrames
(pour stocker des données selon 2 dimensions - lignes et colonnes), les Panels
(pour représenter des données selon 3 dimensions, les Panels4D ou les
DataFrames avec des index hiérarchiques aussi nommés MultiIndex (pour
représenter des données selon plus de 3 dimensions - hypercube).
Les fonctionnalités principales de la bibliothèque se résument en :
• L'objet DataFrame pour manipuler des données aisément et efficacement

avec des index pouvant être des chaînes de caractères ;
• Des outils pour lire et écrire des données structurées en mémoire depuis et
vers différents formats : fichiers CSV, fichiers textuels, fichier du tableur
Microsoft Excel, base de données SQL ou le format rapide et permettant
de gérer de gros volume de données nommé HDF ;
• Alignement intelligent des données et gestion des données manquantes

(NaN = not a number), alignement des données basé sur des étiquettes
(chaînes de caractères), tri selon divers critères de données totalement
désordonnées ;
• Redimensionnement et table pivot ou pivot table en anglais (aussi nommé

tableau croisé dynamique) ;
• Fusion et jointure de large volume de données
• Analyse de séries temporelles
48
Figure 13. Logo de Pandas
e. Jupyter Notebook :
Jupyter [2] est une application web utilisée pour programmer dans plus de 40
langages de programmation, dont : Python, Julia, Ruby, R, ou encore Scala.
Jupyter est une évolution du projet IPython. Jupyter permet de réaliser des
calepins ou notebooks, c'est-à-dire des programmes contenant à la fois du texte
en markdown et du code en Julia, Python, R... Ces notebooks sont utilisés en
science des données pour explorer et analyser des données.
Jupyter s'appuie sur un noyau IPython pour Python 2, un noyau IPython pour
Python 3, IRkernel, un noyau pour le langage R et un noyau pour le langage
Julia, IPyLua, noyau pour le langage Lua, IRuby, noyau pour le langage Ruby,
etc. Seuls les noyaux pour les langages Julia, Python, R et Scala sont maintenus
par les développeurs principaux du projet, les autres sont développés par
différentes communautés de développeurs.
Jupyter a été utilisé car il permet de développer aussi des modèles

d’algorithmes quantiques avec Python.
49
Figure 14. Logo de Jupyter
f. Qiskit :
Figure 15. Logo de Qiskit
Qiskit [2] est un framework open-source pour l'informatique quantique. Il

fournit des outils pour créer et manipuler des programmes quantiques et les
exécuter sur des prototypes de dispositifs quantiques et des simulateurs. Il suit le
modèle de circuit pour le calcul quantique universel et peut être utilisé pour tout
matériel quantique qui suit ce modèle.
Qiskit a été fondé par IBM Research pour permettre le développement de

logiciels pour leur service d'informatique quantique en nuage. Des contributions
sont également apportées par des donateurs externes, généralement des
établissements universitaires.
La version primaire de Qiskit utilise le langage de programmation Python.

Des versions pour Swift et JavaScript sont également disponibles. Ceux-ci sont
utilisés pour créer des programmes quantiques basés sur la représentation
OpenQASM des circuits quantiques.
Une gamme d'ordinateurs portables Jupyter sont fournis avec des exemples
d'utilisation de l'informatique quantique, notamment le code source des études
scientifiques qui utilisent Qiskit, ainsi qu'un ensemble d'exercices pour aider les
gens à apprendre les bases de la programmation quantique.
g. AutoKeras :
50
Figure 16. Logo d’Auto-Keras
AutoKeras [2] est une bibliothèque de logiciels open source pour

l'apprentissage automatique (Auto-ML). Il est développé par DATA Lab à
l'Université A&M du Texas et par des collaborateurs de la communauté. Le but
ultime d’Auto-ML est de fournir des outils d'apprentissage en profondeur
facilement accessibles aux experts du domaine ayant des connaissances limitées
en science des données ou en apprentissage machine. Auto-Keras fournit des
fonctions de recherche automatique d'architecture et d'hyperparamètres de
modèles d'apprentissage profond.
h. Dlib :
Dlib [2] est une librairie logicielle multi-plateforme d'usage général écrite
dans le langage de programmation C++. Sa conception est fortement influencée
par les idées issues de la conception par contrat et du génie logiciel basé sur les
composants. Il s'agit donc avant tout d'un ensemble de composants logiciels
indépendants. Il s'agit d'un logiciel open-source publié sous une licence Boost
Software License.
Depuis le début du développement en 2002, Dlib s'est développé pour inclure

une grande variété d'outils. A partir de 2016, il contient des composants logiciels
pour traiter les réseaux, les threads, les interfaces utilisateur graphiques, les
structures de données, l'algèbre linéaire, l'apprentissage machine, le traitement
d'images, le data mining, XML et l'analyse de texte, l'optimisation numérique,
les réseaux bayésiens et de nombreuses autres tâches.
Nous utiliserons cette technologie pour fournir quelques modèles pré-

entraînés pour notre solution.
51
2. Environnement et container :
a. Flask :
Figure 17. Logo de Flask
Flask [2] est un framework open-source de développement web en Python.

Son but principal est d'être léger, afin de garder la souplesse de la
programmation Python, associé à un système de Template. Il est distribué sous
licence BSD.
Flask a été créé initialement par Armin Ronacher comme étant un poisson
d'avril. Le souhait de Ronacher était de réaliser un Framework web contenu dans
un seul fichier Python mais pouvant maintenir des applications très demandées.
Allant à contre-pied d’autres solutions de développement web, Flask est livré

avec le strict minimum, à savoir :
• Un moteur de Template (Jinja 2)

• Un serveur web de développement (Werkzeug)
• Un système de distribution de requête compatible REST (dit RESTful)
• Un support de débogage intégré au serveur web
• Un micro framework doté d’une très grande flexibilité
• Une très bonne documentation
Disposer d’un micro framework implique donc l’absence de certains

éléments out-of-the-box tels que :
52
• Une solution d’authentification
• Le support de base de données ou un ORM
• La gestion sécurisée de formulaires HTML
• Une interface d’administration
Cela n’est cependant pas un frein, car la grande flexibilité du micro

framework permet l’adjonction d’une pléthore d’extensions Flask couvrant ces
manques apparents, ce qui nous poussera à choisir ce framework pour établir
notre serveur.
b. Docker :
Figure 18. Logo de Docker
Docker [2] est un logiciel libre permettant facilement de lancer des

applications dans des conteneurs logiciels.
Selon la firme de recherche sur l'industrie 451 Research, « Docker est un

outil qui peut empaqueter une application et ses dépendances dans un conteneur
isolé, qui pourra être exécuté sur n'importe quel serveur ». Il ne s'agit pas de
virtualisation, mais de conteneurisation, une forme plus légère qui s'appuie sur
certaines parties de la machine hôte pour son fonctionnement. Cette approche
permet d'accroître la flexibilité et la portabilité d’exécution d'une application,
laquelle va pouvoir tourner de façon fiable et prédictible sur une grande variété
53
de machines hôtes, que ce soit sur la machine locale, un cloud privé ou public,
une machine nue, etc.
Techniquement, Docker étend le format de conteneur Linux standard, LXC,

avec une API de haut niveau fournissant une solution pratique de virtualisation
qui exécute les processus de façon isolée. Pour arriver à ses fins, Docker utilise
entre autres LXC, cgroups et le noyau Linux lui-même. Contrairement aux
machines virtuelles traditionnelles, un conteneur Docker n'inclut pas de système
d'exploitation, mais s'appuie au contraire sur les fonctionnalités du système
d’exploitation fournies par la machine hôte.
La technologie de conteneur de Docker peut être utilisée pour étendre des

systèmes distribués de façon qu'ils s'exécutent de manière autonome depuis une
seule machine physique ou une seule instance par nœud. Cela permet aux nœuds
d'être déployés au fur et à mesure que les ressources sont disponibles, offrant un
déploiement transparent et similaire aux PaaS pour des systèmes comme Apache
Cassandra, Riak ou d'autres systèmes distribués.
L'objectif d'un conteneur est le même que pour un serveur dédié virtuel :
héberger des services sur un même serveur physique tout en les isolant les uns
des autres. Un conteneur est cependant moins figé qu'une machine virtuelle en
matière de taille de disque et de ressources allouées.
Un conteneur permet d'isoler chaque service : le serveur web, la base de

données, une application peuvent être exécutés de façon indépendante dans leur
conteneur dédié, contenant uniquement les dépendances nécessaires. Chaque
conteneur est relié par des réseaux virtuels. Il est possible de monter des
volumes de disque de la machine hôte dans un conteneur.
2. Conclusion :
Après ce choix de technologies, nous nous sommes lancés alors dans la
réalisation de notre solution. Le prochain chapitre permettra d’expliquer les
différents algorithmes utilisés dans la réalisation de cette solution.
54
Chapitre 4 : Réalisation
Réalisation de la solution
Dans ce chapitre, nous allons présenter la phase de réalisation qui

permettra de concrétiser l’architecture et solution exposée lors des chapitres
précédents. Nous commencerons par la mise en œuvre des algorithmes de vision
d’ordinateur, ensuite nous aborderons la mise en container pour la production.
55
1. Bibliothèque de Vision d’ordinateur :

a. Reconnaissance Faciale :
Notre solution de reconnaissance faciale a été décomposée comme suit (Voir

figure 19) :
• Détection des visages dans l’image.

• Positionnement des visages dans un alignement commun.
• Détecter des encodings et caractéristiques uniques pour chaque identité.
• Comparer ces caractéristiques avec les caractéristiques des visages déjà
identifiés dans la base de données pour reconnaître l’identité de la
personne.
Figure 19. Schéma de flux de reconnaissance faciale
• Détection des visages :
A cette étape là, dans chaque image, le système détecte les pixels qui
constituent un visage, pour les transformer en une petite image et les envoyer à
l’étape suivante.
Pour cela, nous allons utiliser une méthode appelée HOG, Histogram of
Oriented Gradients, qui permet de trouver des contours dans une image en noir
et blanc.
56
Le premier pas de cette méthode est la conversion des images en noir et blanc
; puis, pour chaque point de l’image, l’algorithme trouve la direction pour
laquelle la luminosité des points aux alentours est la plus réduite. Si ces
directions sont représentées comme des flèches, aussi appelés gradients, nous
aurons une image qui représente la distribution de l’intensité du gradient.
La raison pour cela n’est pas aléatoire. Nous pouvons avoir des photos de
nous-mêmes avec des luminosités différentes, mais la mesure de l’intensité des
points autour de notre visage reste le même.
Des chercheurs ont trouvé une représentation de l’histogramme des gradients

qui est la plus commune et générale entre tous les visages. Pour trouver les
visages dans nos images alors, on devrait juste trouver les zones qui ressemble le
plus à cette représentation des gradients des visages. Cette méthode est connue
pour sa rapidité.
Pour plus de précision, au cas de possession d’ordinateurs puissants, nous

avons aussi utilisés des modèles pré-entraînés d’apprentissage profond pour la
détection faciale.
• Alignement des visages dans un alignement et angle commun :
Maintenant que nous avons détecté les visages, ceux-ci peuvent être tournés
vers différents sens, et sous différentes perspectives. Ceci donnera de la
difficulté à un algorithme de reconnaître son identité, vu l’infinité des angles
possibles pour chaque visage.
Une étape importante est alors d’avoir un alignement commun de tous les
visages. Ceci sous-entend de détecter les yeux, le nez, la bouche, et les contours
du visage, afin de bien les aligner.
La méthode utilisée pour cela, est de détecter un groupe de 68 points

commun dans les visages, qui tracent la majorité de ses contours. Ces points
sont détectés par un modèle de Machine Learning qui est pré-entraîné à les
détecter.
57
Dès que ces points sont détectés dans le visage, nous n’avons plus qu’à
effectuer des coupures et des rotations, pour avoir le visage dans le sens juste.
• Détecter des encodings et caractéristiques uniques pour chaque identité
En utilisant un type de réseaux de neurones convolutionnel, suivant le papier

de recherche de Google en 2015 (Facenet) [11], nous allons l'entraîner à codifier
chaque visage en 128 mesures de sa propre création, après avoir implémenter
une fonction de triple coût.
Cette fonction de triple coût permettra de rendre les mesures de deux images
d’une même identité presque les mêmes, et très différentes des mesures d’une
autre identité.
A la fin de cet entraînement, le modèle de réseaux de neurones génère des

mesures très proches pour les visages d’une même personne.
• Identifier l’identité de la personne
Avec une base de données déjà existantes de mesures pour chaque identité,
nous pourrons entraîner des modèles de machine learning qui permettent de
classifier chaque nouvelle mesure dans l’espace de sa vraie identité.
A cette étape-là, nous utiliserons les classifieurs quantiques dans un

ordinateur quantique, ou un des modèles de classification choisi par le moteur
d’Auto-ML, qui sera le plus adapté aux mesures déjà générées.
b. Reconnaissance d’objet :
Google a un certain nombre de modèles de réseaux neuronaux qu'ils ont mis

à disposition pour une utilisation dans TensorFlow. Les deux modèles que nous
utiliserons ici sont Inception-v3[12] et Inception-v4.
58
Figure 20. Architecture du modèle Inception
Ils utilisent tous les deux des modules de Inception qui prennent plusieurs
noyaux convolutionnels de différentes tailles et empilent leurs sorties le long de
la dimension de profondeur afin de capturer des caractéristiques à différentes
échelles. (Voir figure 21)
Figure 21. Vue abstraite du modèle Inception
Les deux réseaux empruntent également le concept d'un réseau résiduel avec
des connexions de saut où l'entrée est ajoutée à la sortie de sorte que le modèle
est forcé de prévoir le résidu plutôt que la cible elle-même. (Voir figure 22)
59
Figure 22. Saut de connexion typiquement utilisée dans le réseau résiduel
En utilisant cette architecture, Inception-v4 a pu atteindre une précision top-1

de 80,2% et une précision top-5 de 95,2% sur l'ensemble de données Imagenet,
autrement dit, le réseau a correctement déterminé l'objet dans une image 4/5 du
temps et 19/20 fois, la prédiction correcte apparaissant dans les cinq premières
probabilités fournies par le modèle. D'autres modèles développés par Google
(notamment Inception-ResNet-v2) ont obtenu des résultats légèrement meilleurs,
mais les réseaux Inception-v3 et -v4 sont toujours en tête du peloton.
Nous utiliserons ces modèles, tout en entraînant les dernières couches de

classifications sur les données de l’utilisateur pour pouvoir reconnaître les objets
de son choix, où lui offrir les modèles pré-entraînés sur les objets standards.
En dernière couche, à travers Auto-Keras, nous avions pu automatiser le

choix du réseau de neurones ainsi que ses hyperparamètres, et automatiser le
processus d’entraînement.
c. Algorithme quantique :
Il est déjà reconnu que les ordinateurs quantiques fourniront l'avantage

informatique de classer les objets dans des nième dimensions qui sont
extrêmement difficiles à mettre à l'échelle sur les ordinateurs classiques.
Pour notre solution, nous avons décidé d’implémenter des SVM [13]
(Support Vector Machines) Quantiques, dont la version en informatique
classique est reconnue pour sa grande exactitude dans la classification.
60
• Revue sur les Support Vector Machines :
Les machines à vecteurs de support ou support vector machines sont un

ensemble de techniques d'apprentissage supervisé destinées à résoudre des
problèmes de discrimination et de classification. Les SVM sont une
généralisation des classifieurs linéaires.
Ces algorithmes ont été développés dans les années 1990 à partir des
considérations théoriques de Vladimir Vapnik sur le développement d'une
théorie statistique de l'apprentissage. Ils ont rapidement été adoptés pour leur
capacité à travailler avec des données de grandes dimensions, le faible nombre
de hyperparamètres, leurs garanties théoriques, et leurs bons résultats en
pratique.
Les machines à vecteurs de support sont des classificateurs qui reposent sur
deux idées clés, qui permettent de traiter des problèmes de discrimination non
linéaire, et de reformuler le problème de classement comme un problème
d'optimisation quadratique.
La première idée clé est la notion de marge maximale. La marge est la

distance entre la frontière de séparation et les échantillons les plus proches. Ces
derniers sont appelés vecteurs supports. Dans les SVM, la frontière de
séparation est choisie comme celle qui maximise la marge. Ce choix est justifié
par la théorie statistique de l'apprentissage, qui montre que la frontière de
séparation de marge maximale possède la plus petite capacité. Le problème est
de trouver cette frontière séparatrice optimale, à partir d'un ensemble
d'apprentissage. Ceci est fait en formulant le problème comme un problème
d'optimisation quadratique, pour lequel il existe des algorithmes connus.
Afin de pouvoir traiter des cas où les données ne sont pas linéairement
séparables, la deuxième idée clé des SVM est de transformer l'espace de
représentation des données d'entrées en un espace de plus grande dimension
(possiblement de dimension infinie), dans lequel il est probable qu'il existe une
séparation linéaire. Ceci est réalisé grâce à une fonction noyau, qui a l'avantage
de ne pas nécessiter la connaissance explicite de la transformation à appliquer
pour le changement d'espace. Les fonctions noyau permettent de transformer un
produit scalaire dans un espace de grande dimension, ce qui est coûteux, en une
61
simple évaluation ponctuelle d'une fonction. Cette technique est connue sous le
nom de kernel trick (ou astuce du noyau).
• Machines à vecteurs de supports quantiques :
Lorsque les points de données sont projetés dans des dimensions plus
élevées, il est difficile pour les ordinateurs classiques d'effectuer des calculs de
cette taille. Ainsi, avec un ordinateur quantique, cette tâche peut devenir facile et
même l'ensemble de données le plus complexe peut être calculé dans des
dimensions extrêmement élevées pour une classification précise. Cet algorithme
spécifique est appelé Algorithme du noyau quantique de la machine à vecteurs
de support. Il s'agit simplement de prendre l'algorithme ML classique et de le
traduire en un circuit quantique pour qu'il puisse être exécuté efficacement sur
un ordinateur quantique.
Figure 23. Exemple d'un circuit quantique présentant la téléportation quantique
d. Modularisation de la bibliothèque :
Après avoir établi ces modèles, et établi le flux des données entre eux, vient
l’étape de les geler, afin de pouvoir les exploiter sans danger de modification des
modèles critiques par l’utilisateur.
Après les avoir gelés, ils ont été exploités à travers Tensorflow qui a permis
de les mettre en mémoire et de les utiliser pour établir des inférences.
Ensuite, deux fonctions ont été définies pour l’entraînement et la prédiction,

qui prennent en argument l’emplacement sur ordinateur de l’image pour la
prédiction, ou l’emplacement de dossier d’entraînement pour l’entraînement.
62
Optionnellement pour l’utilisateur, il peut aussi spécifier la méthode de
reconnaissance, selon ses préférences. Au cas échéant, la bibliothèque choisit la
méthode la plus efficace pour le matériel dont l’utilisateur dispose.
Ainsi, les flux internes des données ont été organisés, avec des fonctions pour
la mise en mémoire fluide des modèles lors de l’importation de la bibliothèque,
pour un usage encore plus optimisé, ainsi qu’une gestion d’erreur exhaustive
pour plus d’efficacité.
2. Mise en production de la solution :

a. Mise en place du serveur et container :
Après le développement de la bibliothèque, nous l’avons mis dans un serveur

léger développé avec Flask, puis on l’a déployé sur un Container Docker avec
une image Ubuntu.
A l’intérieur du container, une partie a été réservé pour le management des

fichier temporaires, comme images d’entraînement, images temporaires, et
autres résultats des modèles. Nous avions ensuite développé un module de
gestion des logs, pour répondre à toutes les problématiques qui pourraient
survenir en temps réel après que la solution soit mise en production.
Vu le développement continu que connaîtra la bibliothèque, et les différentes

versions de ses modèles, nous avions aussi ajouté un module de gestion de
versions, qui permettra aux utilisateurs de optionnellement choisir les versions
qu’ils veulent utiliser, ou automatiquement basculer vers la version la plus stable
ou celle ayant la meilleure performance dans une prédiction spécifique.
b. Spécification des accès APIs :
La prochaine étape a été de spécifier les APIs que l’utilisateur pourra utiliser
pour communiquer avec notre solution, et les entrées et sorties de cette
communication. Celle-ci a été établie comme suit :
• GET /vision_recognition/status
63
Retourne l'état du modèle. Peut être utilisé pour suivre les échecs de
formation, l'avancement de la mise à jour du modèle et la disponibilité du
modèle. Si le modèle est en cours d’entraînement, la version précédente sera la
version active pour la prédiction.
• GET /vision_recognition/categories
Énumérer les catégories connues par le modèle. Dans le cas où un

entraînement est toujours en cours, de nouvelles catégories sont également
retournées.
• PUT /vision_recognition/categories
Ajouter les données d’une nouvelle catégorie aux modèles. Entraînement

automatique après l’opération.
• PATCH /vision_recognition/categories/{categories}
Ajouter des données à une catégorie existante. Entraînement automatique

après l’opération.
• DELETE /vision_recognition/categories/{category}
Supprimer une catégorie à la fois du modèle. Toutes les données relatives à

cette catégorie, y compris les images traitées, seront effacées. Entraînement
automatique après l’opération.
• GET /vision_recognition/retrain
Ré-entraîner le modèle sans modifier les données. On peut utiliser ce point de

terminaison par exemple pour entraîner un modèle sur un grand ensemble de
données qui a été monté dans le dossier /data dans le container au lieu de
télécharger explicitement des fichiers via API.
• POST /vision_recognition/prediction
Obtenir les prédictions du modèle. Par défaut, seule la meilleure prédiction

pour chaque objet/personne détecté est retournée.
64
2. Conclusion :
Ce chapitre a présenté les étapes de réalisation de notre projet, ainsi que les
algorithmes et méthodes utilisées pour le développement de chaque partie. En
premier lieu, nous avons développé une bibliothèque de vision d’ordinateur
homogène adaptée à l’utilisateur non connaisseur dans l’IA, lui offrant
simplicité et performance lors de son utilisation. En deuxième lieu, nous avons
aussi résolu les problèmes de mises en productions aux entreprises, en leur
présentant un produit prêt à l’usage sur leurs serveurs.
65
Conclusion Générale :
Conclusion Générale :
L’objectif de notre stage de fin d’étude, effectué à Zenika à Paris, et dont le
présent document décrit le déroulement, a consisté en la conception et
développement d’une bibliothèque de vision d’ordinateur, opérable dans le
milieu informatique classique ainsi que le milieu informatique quantique, et de
la mettre en production dans un container réutilisable par toute entreprise
désirant intégrer les services IA dans ses processus.
Ce projet avait commencé par la spécification des besoins, qui nous avaient
permis de discerner les cas d’utilisations et les utilisateurs possibles, et d’en
conclure une architecture valable pour notre solution.
Après un choix des technologies nécessaires pour le développement de notre

solution, qui devaient assurer plusieurs contraintes pour assurer la qualité
durable de notre projet, nous avons développé en premier lieu une bibliothèque,
qui a été testé par des développeurs au sein de l’entreprise, pour reconnaître son
utilité. Ensuite, nous l’avons mise dans un serveur et container, et avons spécifié
les requêtes API nécessaires pour utiliser toutes ses capacités.
Ce projet n’est que le premier pas dans une plus grande vision, de créer des
outils permettant aux développeurs, ainsi qu’aux non-développeurs, d’utiliser les
outils de l’IA dans leurs plus grandes performances facilement sans contraintes.
Ceci s’inscrit dans la vision de l’entreprise, de faire le point de liaison entre le
monde développeur et le monde non-développeur, et de produire des solutions
qui poussent à un tel futur. Notre outil alors sera élargi, avec de nouvelles
capacités IA en plus de la vision d’ordinateur.
66
Webographie :
Webographie :
[1] : https://www.zenika.com/
[2] : https://www.tensorflow.org/
[3] : https://www.numpy.org/
[4] : https://pypi.org/project/pandas/
[5] : https://jupyter.org/
[6] : https://qiskit.org/
[7] : https://autokeras.com/
[8] : http://dlib.net/
[9] : http://flask.pocoo.org/
[10] : https://www.docker.com/
[11] : https://arxiv.org/abs/1503.03832
[12] : https://towardsdatascience.com/a-simple-guide-to-the-versions-of-the-
inception-network-7fc52b863202
[13] : https://towardsdatascience.com/support-vector-machine-introduction-
to-machine-learning-algorithms-934a444fca47
67

Rapport Pfe Ihab Bendidi

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Rapport Pfe Ihab Bendidi

Transféré par

Droits d'auteur :

Formats disponibles

ROYAUME DU MAROC

Projet de Fin d’Etudes

Préparé par : M. Ihab Bendidi

Sous la direction de : M. Adil Kabbaj (INSEA)

Soutenu publiquement comme exigence partielle en vue de l’obtention du

Diplôme d’Ingénieur d’Etat

Devant le jury composé de :

▪ M. Adil Kabbaj (INSEA)

Juin 2019/ PFE N° 35

A mes meilleurs amis, Nacer, Zakaria, Kabil, Fouad, Nisrine, Nada et

Je tiens encore à remercier l’équipe Zenika, qui m’a chaleureusement

Et je remercie de tout cœur les respectueux membres du jury, qui m’ont

Enfin, je remercie toute personne ayant contribué de loin ou de proche à

A toutes et à tous, Je vous remercie infiniment.

En effet, les développeurs et entreprises ont de plus en plus besoin de

Mon projet consiste alors en premier lieu de développer une bibliothèque et

Mots clés : Machine Learning, Deep Learning, Library, Tensorflow,

Liste des figures

Figure 2. Phase de processus CRISP-DM…………………………………..23

Figure 3. Logo de Gantt Project…………………………………………….25

Figure 4. Diagramme Gantt du projet…………………………………….26

Figure 5. Architecture d’un réseau de neurones…………………………….29

Figure 6. Représentation d’un qubit avec une Bloch Sphere……………...32

Figure 7. Diagramme de cas d’utilisation…………………………………..39

Figure 8. Architecture de la solution………………………………………..40

Figure 9. Logo de Python……………………………………………….…..43

Figure 10. Logo de Tensorflow……………………………………………..44

Figure 11. Hiérarchie des composants de Tensorflow…………………...…46

Figure 12. Logo de Numpy………………………………………………....46

Figure 13. Logo de Pandas………………………………………………….48

Figure 14. Logo de Jupyter……………………………………………..….48

Figure 15. Logo de Qiskit…………………………………………………..49

Figure 16. Logo d’AutoKeras…………………………………………...….50

Figure 18. Logo de Docker………………………...……………………….52

Figure 19. Schéma de flux de reconnaissance faciale………………………55

Figure 20. Architecture du modèle Inception…………………………...…..57

Figure 21. Vue abstraite du modèle Inception……………………………...58

Figure 22. Saut de connexion utilisée dans le réseau résiduel……………...58

Figure 23. Circuit présentant la téléportation quantique………………..…..61

Liste des Abréviations

API – Application Programming Interface

CNN – Réseaux de neurones convolutionnels

CPU – Central Processing Unit

GPU – Graphical Processing Unit

IoT – Internet des Objets

LSTM – Long Short-Term Memory

ORM – Object to Relational Mapping

R&D – Recherche et Développement

ROI – Retour sur Investissement

REST – Representational State Transfer

RNN – Réseaux de neurones récurrents

SVM – Machines à vecteurs de support

Or, les compétences avancées dans ce domaine se retrouvent coûteuses et peu

Ceci a alors lancé la réflexion de développement de bibliothèque pour les

Le présent rapport, dédié à la présentation de notre projet de fin d’études,

Un premier chapitre qui explique le contexte du projet, ainsi que la

Contexte général du projet

Dans ce chapitre, nous allons aborder le contexte général du projet. Tout

Pour mettre en exergue l’objectif de ce travail, nous présentons les

Figure 1. Logo de l’entreprise Zenika

La mission de cette société est d’accompagner les entreprises dans leur

Zenika offre principalement quatre services qui peuvent être catégorisés en :

- Services de conseil : Zenika accompagne ses clients dans leurs

- Services de réalisation : Ces services sont assurés par les consultants