RAPPORT DE PROJET

D’INNOVATION
Les modèles de Deep Learning adaptés aux Applications
mobiles pour faire le traitement d’images en temps réel

Présenté par :
Encadrant :
M. Mohamed Seinkou DIAKITE M. Abdessamad EL RHARRAS
&
M. Ayoub EL GHAFRAOUI
 Remerciements

Nous rendons grâce à Dieu de nous avoir permis de réaliser ce

travail.

Toute notre gratitude à nos parents pour leurs amours et soutiens,

et nous remercions la commission de l’UEMOA pour son soutien.

J’adresse mes sincères remerciements à notre encadrants M.

Abdessamad EL RHARRAS professeur à l’EHTP, à qui nous
exprimons toute notre reconnaissance, de nous avoir encadré et
encouragé tout au long de la formation. Merci pour sa disponibilité
et ses précieux conseils.

Nous exprimons nos vifs remerciements à M. Hafid pour sa

disponibilité et ses conseils qui ont nourrit nos réflexions, aux
professeurs de l’Ecole Hassania des Travaux Publics pour la qualité
de l’enseignement dispensé, et aux membres du jury qui ont
accepté d’examiner notre travail et de l’enrichir par leurs
remarques.

Une pensée particulière à nos camarades de la troisième

promotion du MSAIOT, nous souhaitons que ce travail soit à la
hauteur de toutes les espérances.
 Résumé

L’utilisation de l’intelligence artificielle dans le traitement d’images sur les

périphériques légers (smartphone, Single Board Computer) est un challenge au quel
il faut utiliser des modèles d’IA particuliers. Les modèles classiques ne sont pas
adaptés à ces appareils légers, car très lourd en taille, temps de calcul CPU élevé et
consomme trop d’énergie. Nous allons faire une étude de quelque modèles adaptés
aux appareils légers, faire des comparaisons et puis les intégrer dans une application
mobile pour faire la détection d’objets en temps réel avec ces modèles. Nous avons
utilisé un processus de text-to-speech pour dire à voix haute les objets détectés. Le
sujet de l’application mobile que nous avons développé en java ne sera pas abordé
dans ce rapport on se focalisera sur les modèles d’IA.

Ce rapport est destiné à faire une étude comparative entre différents modèles d’IA
qui peuvent être intégrés dans une application mobile pour la détecter d’objets en
temps réel.
 Sommaire
Remerciements ............................................................................................................................................. 1
Résumé .......................................................................................................................................................... 2
Table de figures ............................................................................................................................................. 4
Introduction................................................................................................................................................... 5
1 Contexte du projet ................................................................................................................................ 6
1.1 Qui sont les développeurs d'applications deep Learning (DL)? ................................................... 6
1.2 Les rôles de l’apprentissage profond (DL) dans les applications................................................... 7
2 Les Modèles disponibles........................................................................................................................ 8
2.1 Tensorflow LITE ........................................................................................................................... 10
2.1.1 Principales caractéristiques ................................................................................................. 10
2.1.2 Optimisation du modèle ...................................................................................................... 11
2.1.3 Pourquoi les modèles doivent être optimisés ? .................................................................. 11
[Link] Réduction de la taille .................................................................................................. 11
[Link] Réduction de la latence ................................................................................................... 12
[Link] Compromis ...................................................................................................................... 12
2.1.4 Types d'optimisation ........................................................................................................... 13
2.1.5 Quantification ...................................................................................................................... 13
2.1.6 Générer un modèle TensorFlow Lite ................................................................................... 14
2.2 SSD MobileNet architecture ........................................................................................................ 15
2.2.1 MobileNet............................................................................................................................ 15
2.2.2 SSD ....................................................................................................................................... 17
2.2.3 SSD MobileNet..................................................................................................................... 18
2.2.4 Non-max supression (NMS) ................................................................................................. 18
2.3 YOLO Tiny .................................................................................................................................... 20
2.3.1 Qu'est-ce que YOLO-Tiny ? .................................................................................................. 22
2.4 Notre dataset............................................................................................................................... 23
3 Les résultats ......................................................................................................................................... 24
3.1 YoloV4-Tiny.................................................................................................................................. 24
3.2 MobilenetV2_SSD ........................................................................................................................ 27
Conclusion ................................................................................................................................................... 30
Références ................................................................................................................................................... 31
 Table de figures
Figure 1:Distributions of DL apps over categories defined by ...................................................................... 8
Figure 2: deux étapes de détection ............................................................................................................... 9
Figure 3: une seule étape de détection ......................................................................................................... 9
Figure 4:Tensorflow to TFlite ...................................................................................................................... 15
Figure 5:MobileNet ..................................................................................................................................... 16
Figure 6:SSD architecture ............................................................................................................................ 17
Figure 7: MobileNet SSD.............................................................................................................................. 18
Figure 8:non-max supression ...................................................................................................................... 19
Figure 9:Yolo-Tiny performance on COCO Dataset ..................................................................................... 22
Figure 10:Dataset composition ................................................................................................................... 23
Figure 11:notre dataset ............................................................................................................................... 24
Figure 12: Architecture de Yolo-Tiny ........................................................................................................... 25
Figure 13: Loss et Accuracy de YOLO-Tiny................................................................................................... 26
Figure 14: MAP de notre modele ................................................................................................................ 27
Figure 15:images de test ............................................................................................................................. 27
Figure 16: classification et localisation graph loss ...................................................................................... 28
Figure 17:regularization et total loss........................................................................................................... 28

Tableau 1:The DL usage in different apps. .................................................................................................... 7

Tableau 2:Quantification TFlite ................................................................................................................... 13
 Introduction
La vision par ordinateur est le domaine de l'informatique qui vise à reproduire une
partie de la complexité du système de vision humain et à permettre aux ordinateurs
d'identifier et de traiter des objets dans des images et des vidéos de la même manière
que les humains. Jusqu'à récemment, la vision par ordinateur ne fonctionnait que de
manière limitée.

Grâce aux progrès de l'intelligence artificielle et aux innovations en matière de deep

Learning et de réseaux neuronaux, le domaine a pu faire de grands bonds en avant
ces dernières années et a pu surpasser les humains dans certaines tâches liées à la
détection et à l'étiquetage des objets.

La vision par ordinateur est l'un des domaines de machine learning où les concepts
fondamentaux sont déjà intégrés dans les principaux produits que nous utilisons
tous les jours.

La vision par ordinateur joue également un rôle important dans la réalité augmentée
et mixte, une technologie qui permet aux appareils informatiques tels que les
smartphones, les tablettes et les lunettes intelligentes de superposer et d'intégrer
des objets virtuels à des images du monde réel.

Une armée d’assistants non humains résultant de l’intelligence artificielle est là, ou
en route, pour nous faciliter la vie.
1 Contexte du projet
Le projet consiste à la conception et au développement d’une application mobile
capable de faire la reconnaissance et la détection d’objets, les images seront prises
par l’appareil photo du mobile (smart Phone) et les modèles d’IA font les traitements.
En effet, intégré un modèle Deep Learning dans une application mobile est une
nécessité sociale qui est présente et qui est liée notamment à l'ère de l'intelligence
artificielle.

Généralement les modèles machine Learning et deep Learning sont déployés sur des
serveurs et des PC, pour des raisons de puissance de calcul. Ce qui rend l’usage de
l’IA limité et restreint, nous devons être capable d’utiliser les modèles d’IA sur les
appareils léger mobile afin d’optimiser certaines tâches quotidiennes.

En effet, plusieurs applications sont actuellement disponibles et offrent une aide

précieuse aux utilisateurs. Tel que Google Maps, Microsoft Soundscape, Evelity,
MyMoveo, Seeing AI.

1.1 Qui sont les développeurs d'applications deep Learning (DL)?

Nous avons également fait des recherches sur les développeurs d'applications DL.
Les résultats montrent que les 211 applications DL identifiées appartiennent à 172
développeurs (entreprises), parmi lesquels 27 développeurs ont plus d'une
application DL. Les développeurs possédant le plus d'applications DL sont "Google
LLC" (10) et "Fotoable,Inc" (6). Nous observons que de nombreuses grandes
entreprises possèdent plus d'une application DL, notamment Google, Adobe,
Facebook, Kakao, Meitu, etc. Cela suggère que ces grandes entreprises sont des
pionnières dans l'adoption de la DL dans leurs produits. (Mengwei, et al., 2019)

Nous vous présentons le tableau ci-dessous pour avoir un aperçu des différents cas
d’utilisation de l’IA les plus fréquents dans les applications mobiles.

Note : la somme des utilisations détaillées (colonne 2) peut dépasser l'utilisation

globale correspondante (colonne 1), car une application peut avoir plusieurs
utilisations de DL.
 Tableau 1:The DL usage in different apps.

1.2 Les rôles de l’apprentissage profond (DL) dans les applications

Quelles sont les utilisations populaires de DL ? Pour comprendre les rôles joués par
le DL, nous classons manuellement l'usage du DL dans différentes applications. Pour
ce faire, nous examinons la description et le contenu de l'application.

Les résultats sont présentés dans le tableau 1. Chaque application a une ou plusieurs
usages, et l'usage est représenté à deux niveaux différents (global et détaillé).

Dans l'ensemble, le traitement d'images est l'utilisation la plus populaire de DL sur

les smartphones, bien plus que le traitement du texte et de l'audio.

Cela n'a rien de surprenant puisque la vision par ordinateur est le domaine où le DL
est à l'origine de la révolution, et les progrès réalisés dans ce domaine n'ont pas cessé
depuis lors (Yann, Yoshua, & Geoffrey, 2015) . Plus précisément, le traitement des
photos (97) et la détection des visages (52) sont les plus largement utilisées dans les
applications de DL,

Figure 1:Distributions of DL apps over categories defined by

On les trouve généralement dans les applications de retouche photo et d'appareil

photo pour embellir les images. Dans le domaine du texte, la prédiction des mots et
d'emoji et la correction automatique sont également populaires et se trouvent
généralement dans les applications de méthode de saisie comme GBoard. Pour le
traitement audio, le DL est principalement utilisé pour la reconnaissance vocale.

2 Les Modèles disponibles

En général, les modèles de détection d'objets sont classés en deux grands types
d'architecture : les détecteurs d'objets en une seule étape comme YOLO et SSD et les
détecteurs d'objets à deux (double) étapes comme R-CNN. La principale différence
entre les deux est que dans les modèles de détection d'objets à deux étapes, la région
d'intérêt est d'abord déterminée et la détection est ensuite effectuée uniquement sur
la région d'intérêt. Cela implique que les modèles de détection d'objets en deux
étapes sont généralement plus précis que les modèles en une étape, mais ils
nécessitent plus de ressources informatiques et sont plus lents. Ce qui les rendent
inadaptés pour des périphériques légers ou embarquées ne disposant que de peu
de mémoire et de capacités de calcul réduites. Ces inconvénients ont encouragé le
développement de réseaux plus petits, dits one-stage detectors, qui localisent et
identifient les objets en une seule étape pour un temps d’inférence largement réduit.
(Cohen, Crispim-Junio, Jean-Marc, & Tougne, 2022)

Les figures ci-dessous montrent une représentation des deux types de modèles de
détection d'objets.

Figure 2: deux étapes de détection1

Figure 3: une seule étape de détection2

Les modèles de détection en une étape sont mieux adaptés à notre projet, nous
allons faire une étude entre trois modèles à savoir : YOLO, MobileNet SSD et
Tensorflow Lite.

1
Source : [Link]
2
Source : [Link]
2.1 Tensorflow LITE
Les framework DL mobiles (légers) gagnent en popularité alors que les framework DL
classiques, tels que TensorFlow, sont toujours populaires parmi les applications DL
en raison de leur dynamisme. Les modèles DL conçus et optimisés pour les
périphériques mobiles avec des ressources limitées sont de plus en plus populaires.
Par exemple, le nombre d'applications DL utilisant TFLite a augmenté de 258 % sur
une période de trois mois (Mengwei, et al., 2019).

Malgré des optimisations bien connues, par exemple la quantification qui peut
réduire La taille du DL jusqu'à deux ordres de grandeur avec une faible perte de
précision, nous trouvons très peu des modèles DL avec de telles optimisations. (Han,
Mao, & Dally, 2015)

Le modèle DL sur mobile est plus léger que ce à quoi on peut s'attendre.

Malgré la croyance commune selon laquelle la puissance des modèles DL provient

des paramètres riches et des couches profondes, nous constatons que les modèles
DL utilisés dans les applications légères sont plutôt petits, avec une utilisation
mediane de la mémoire de 2,47 Mo et un calcul d'inférence de 10M FLOPs, ce qui
implique généralement le délai d'inférence de quelques dizaines de millisecondes.
FLOPS est le nombre d'opérations en virgule flottante par seconde (floating-point
operations per second), c’est une unité de mesure de la rapidité de calcul d'un
système informatique et donc d'une partie de sa performance. Ces modèles sont non
seulement beaucoup plus légers que les modèles classiques conçus pour le cloud ou
les serveurs (p. ex. ResNet-50 avec 200 Mo de mémoire et des calculs d'inférence de
4G FLOPs), mais aussi plus légers que les modèles conçus spécifiquement pour les
appareils mobiles, par exemple MobileNet avec 54 Mo de mémoire et 500 M FLOPs
de calculs d'inférence.

2.1.1 Principales caractéristiques

• Optimisé pour la machine learning sur appareil léger, il répond à cinq
contraintes principales : latence (pas d'aller-retour avec un serveur),
confidentialité (aucune donnée personnelle ne quitte l'appareil), connectivité
(aucune connexion Internet requise), taille (modèle réduit et taille binaire) et
consommation d'énergie (inférence efficace et absence de connexions réseau).
 • Compatibilité avec plusieurs plates-formes, dont les appareils Android et iOS,
les appareils avec système d'exploitation Linux intégré, et
les microcontrôleurs.

• Compatibilité avec de nombreux langages, dont Java, Swift, Objective-C, C++ et

Python.

• Hautes performances, avec accélération matérielle et optimisation du modèle.

• Exemples de bout en bout, pour les tâches de machine learning courantes

comme la classification d'images, la détection d'objets, l'analyse des postures,
la réponse à des questions, la classification de texte, etc., sur plusieurs plates-
formes.

2.1.2 Optimisation du modèle

Les appareils Edge (smartphone, SBC…) ont souvent une mémoire ou une puissance
de calcul limitée. Diverses optimisations peuvent être appliquées aux modèles afin
qu'ils puissent être exécutés sous ces contraintes. De plus, certaines optimisations
permettent l'utilisation de matériel spécialisé pour une inférence accélérée.

TensorFlow Lite et le kit d'outils d’optimisation du modèle TensorFlow fournissent

des moyens permettant de minimiser la complexité de l'optimisation de l'inférence.

2.1.3 Pourquoi les modèles doivent être optimisés ?

La principale raison de l’optimisation est d’adapter le modèle aux appareils mobiles
tout en minimisant la perte de précision.

Il existe plusieurs manières principales dont l'optimisation des modèles, peut aider
au développement d'applications.

[Link] Réduction de la taille

Certaines formes d'optimisation peuvent être utilisées pour réduire la taille d'un
modèle. Les modèles plus petits présentent les avantages suivants :

• Taille de stockage plus petite : les modèles plus petits occupent moins
d'espace de stockage sur les appareils de nos utilisateurs. Par exemple, une
application Android utilisant un modèle plus petit occupera moins d'espace de
stockage sur l'appareil mobile d'un utilisateur.
 • Taille de téléchargement plus petite : les modèles plus petits nécessitent
moins de temps et de bande passante pour télécharger sur les appareils des
utilisateurs.

• Moins d'utilisation de la mémoire : les modèles plus petits utilisent moins

de RAM lorsqu'ils sont exécutés, ce qui libère de la mémoire pour d'autres
parties de votre application et peut se traduire par de meilleures performances
et stabilité.

La quantification peut réduire la taille d'un modèle dans tous les cas, potentiellement
au détriment d'une certaine précision. L'élagage et le regroupement peuvent réduire
la taille d'un modèle à télécharger en le rendant plus facilement compressible.

[Link] Réduction de la latence

La latence est le temps nécessaire pour exécuter une seule inférence avec un modèle
donné. Certaines formes d'optimisation peuvent réduire la quantité de calculs
nécessaires pour exécuter l'inférence à l'aide d'un modèle, ce qui réduit la latence. La
latence peut également avoir un impact sur la consommation d'énergie.

Actuellement, la quantification peut être utilisée pour réduire la latence en simplifiant

les calculs qui se produisent pendant l'inférence, potentiellement au détriment d'une
certaine précision.

[Link] Compromis
Les optimisations peuvent potentiellement entraîner des modifications de la
précision du modèle, qui doivent être prises en compte lors du processus de
développement de l'application.

Les changements de précision dépendent du modèle individuel à optimiser et sont

difficiles à prévoir à l'avance. En règle générale, les modèles optimisés en termes de
taille ou de latence perdent un peu en précision. Selon votre application, cela peut ou
non avoir un impact sur l'expérience de vos utilisateurs. Dans de rares cas, certains
modèles peuvent gagner en précision à la suite du processus d'optimisation.
2.1.4 Types d'optimisation
TensorFlow Lite prend actuellement en charge l'optimisation via la quantification,
l'élagage3 et le clustering.

Ceux-ci font partie du kit d'outils d'optimisation du modèle TensorFlow, qui fournit
des ressources pour les techniques d'optimisation des modèle compatibles avec
TensorFlow Lite.

2.1.5 Quantification
La quantification fonctionne en réduisant la précision des nombres utilisés pour
représenter les paramètres d'un modèle, qui sont par défaut des nombres à virgule
flottante de 32 bits. Cela se traduit par une taille de modèle plus petite et un calcul
plus rapide. Cette technique peut être exécutée sur un modèle TensorFlow déjà
entrainé et appliquée lors de la conversion TensorFlow Lite. Ces techniques sont
activées en tant qu'options dans le convertisseur TensorFlow Lite.

Les types de quantification suivants sont disponibles dans TensorFlow Lite :

Tableau 2:Quantification TFlite

Reduction de la Matériel pris en

Technique Précision
taille charge

Quantification Jusqu'à 50% Perte de précision CPU, GPU

float16 post- insignifiante
entrainement

Quantification de Jusqu'à 75% Petite perte de Processeur, GPU

plage dynamique précision (Android)
post-entraînement

Quantification Jusqu'à 75% Perte de précision Processeur, GPU

entière post- insignifiante (Android), EdgeTPU,
entrainement Hexagon DSP

3
Processus de réduction du nombre des embranchements d’un réseau neuronal.
 Entrainement Jusqu'à 75% Plus petite perte de Processeur, GPU
sensible à la précision (Android), EdgeTPU,
quantification Hexagon DSP

2.1.6 Générer un modèle TensorFlow Lite

Un modèle TensorFlow Lite est représenté dans un format portable efficace spécial,
appelé FlatBuffers (identifié par l'extension de fichier .tflite). Ce format procure divers
avantages par rapport au format de modèle de tampon de protocole de TensorFlow,
comme une taille moindre (empreinte du code faible) et une inférence plus rapide
(accès direct aux données, sans étape d'analyse/décompression supplémentaire). Il
permet également à TensorFlow Lite de s'exécuter efficacement sur des
périphériques dont les ressources mémoire et de calcul sont limitées.

Un modèle TensorFlow Lite peut éventuellement inclure des métadonnées, d'une

part, une description lisible par un humain du modèle et, d'autre part, des données
lisibles par une machine pour créer automatiquement des pipelines de prétraitement
et de post-traitement durant l'inférence sur l'appareil.

Vous pouvez générer un modèle TensorFlow Lite de plusieurs manières :

• Utilisez un modèle TensorFlow Lite existant : choisir un modèle

TensorFlow Lite pré-entraînés et apprenez à les utiliser dans des exemples
d'applications avec divers scénarios de ML. Les modèles peuvent
éventuellement contenir des métadonnées.
• Créez un modèle TensorFlow Lite : utilisez TensorFlow Lite
Model Maker pour créer un modèle avec votre ensemble de données
personnalisé. Par défaut, tous les modèles contiennent des métadonnées.
• Convertissez un modèle TensorFlow en modèle TensorFlow Lite :
utilisez l'outil de conversion TensorFlow Lite pour convertir un modèle
TensorFlow en modèle TensorFlow Lite. Durant la conversion, vous pouvez
appliquer des optimisations telles que la quantification pour réduire la taille
et la latence du modèle sans perte de justesse (ou minime). Par défaut, aucun
modèle ne contient de métadonnées.
 Figure 4:Tensorflow to TFlite

2.2 SSD MobileNet architecture

2.2.1 MobileNet
MobileNet est l'un des nombreux modèles de convolution à notre disposition. Dans
ce rapport, nous allons rentrer en détail de ce qu'est MobileNet, ce qui le rend spécial
parmi les autres architectures de réseaux neuronaux à convolution, Dans cette partie
dédiée aux MobileNet-SSD, nous allons voir comment l’algorithme de
classification MobileNet a été combiné à l’incroyable framework Single Shot multibox
Detector (SSD) pour donner les MobileNet-SSD.

MobileNet est un modèle architectural du réseau neuronal à convolution (CNN) qui se

concentre explicitement sur la classification d'images pour les applications mobiles.
Plutôt que d'utiliser les couches de convolution standard, il utilise des couches de
convolution séparables en profondeur. Ce qui distingue ce modèle, c'est que son
architecture réduit le coût de calcul et qu'une très faible puissance de calcul est
nécessaire pour exécuter ou appliquer l'apprentissage par transfert (transfert
learning). C’est un modèle couramment déployé sur des appareils à faible capacité
de calcul tels que les mobiles (d'où le nom de Mobilenet) avec des performances de
haute précision.

L’extraction de caractéristiques étant une étape cruciale, de nombreuses

architectures ont été proposées, comme la série des réseaux MobileNet. MobileNet-
V1 d’abord introduit la notion de convolution séparable et en profondeur (depth-wise
separable convolution), ainsi que deux nouveaux hyper-paramètres pour ajuster la
taille du réseau. Ces propositions permettent de diminuer le nombre de poids dans
l’architecture sans perdre en performance par rapport à un réseau classique. Avec
MobileNet-V24 , les couches de convolution simples ont été remplacées par des blocs
résiduels inversés (inverted residual blocks). Ces blocs résiduels sont plus efficaces en
mémoire et favorise la compression de l’information dans un espace disque plus
petit.

Figure 5:MobileNet5

Enfin, MobileNet-V36 combine les différents éléments proposés précédemment en

définissant comme bloc de base la séquence de modules inverted residual+squeeze-
and-excite. L’architecture est encore optimisée en remplaçant les fonctions
d’activation non-linéaires par leur équivalent linéaire par morceaux, plus efficaces à
calculer. Un algorithme de recherche d’architecture est utilisé pour identifier la
séquence de couches, ainsi que les paramètres de chaque couche (profondeur et
résolution des couches, type de non-linéarité...), qui réduisent le nombre de poids
tout en améliorant la performance. Alors que MobileNet-V3 a un temps d’inférence
inférieur et obtient une meilleure performance de classification que son
prédécesseur MobileNetV2, son adoption par la communauté est encore très limitée.

4
(Sandler, Howard, Zhu, Zhmoginov, & Chen, MobileNetV2: Inverted Residuals and Linear Bottlenecks, 2018)
5
Source: [Link]
6
(Howard, et al., 2019)
2.2.2 SSD
Single shot Multibox detector est un framework qui permet de détecter en une seule
fois de nombreux objets dans l'image à l'aide de multiboxes. Il utilise un seul réseau
neuronal profond pour y parvenir. Ce détecteur fonctionne à différentes échelles, il
est donc capable de détecter des objets de différentes tailles (dimensions) dans
l'image. L'architecture du SSD est présentée ci-dessous :

Figure 6:SSD architecture7

En général, le SSD utilise un réseau auxiliaire pour l'extraction de caractéristiques

(features extraction). Ce réseau est également appelé réseau de base. Dans l'image ci-
dessus, l'algorithme utilise VGG pour extraire les caractéristiques (features). Mais les
dernières couches de VGG comme le maxpool, FC et Softmax sont omises et la sortie
de VGG est utilisée comme entrée sur laquelle se base la détection.

D'autres couches de convolution sont ajoutées, dans lesquelles les tenseurs

intermédiaires sont conservés, de sorte qu'une pile de cartes de caractéristiques de
différentes tailles est générée pour effectuer la détection.

Enfin, Non-max supression est utilisée pour s'assurer qu'il n'y ait qu'une seule boîte
délimitée (bounding box) autour d'un objet.

7
Source : [Link]
2.2.3 SSD MobileNet
Comme le SSD est indépendant de son réseau de base, peut donc fonctionner au-
dessus de n'importe quel réseau de base, tel que VGG, YOLO ou MobileNet (POKHREL,
2020). Pour résoudre les problèmes pratiques liés à l'exécution de réseaux neuronaux
gourmands en ressources et en énergie sur des terminaux de faible puissance dans
des applications en temps réel, MobileNet a été associé au framework SSD. Ainsi,
lorsque MobileNet est utilisé comme réseau de base dans le SSD, il devient MobileNet
SSD.

Lorsque MobileNet est utilisé avec SSD, les dernières couches telles que FC, Maxpool
et Softmax sont omises. Ainsi, les sorties de la dernière couche de convolution du
MobileNet sont utilisées, ainsi que quelques convolutions supplémentaires pour
obtenir une pile de cartes de caractéristiques, qui sont ensuite utilisées comme
entrées pour faire la détection. L'architecture du MobileNet peut être modifiée selon
les besoins.

Figure 7: MobileNet SSD

Le modèle MobileNet SSD a d'abord été entraînée sur le jeu de données COCO, puis
optimisée sur PASCAL VOC pour atteindre une précision moyenne (MAP) de 72,7 %.

2.2.4 Non-max supression (NMS)

C’est une technique pour filtrer les prédictions des détecteurs d'objets.
Une pipeline de détection d'objets typique comporte un composant permettant de
générer des propositions de classification. Les propositions ne sont rien d'autre que
les régions candidates pour l'objet d'intérêt. La plupart des approches utilisent une
fenêtre glissante (sliding window) sur la zone de caractéristiques et attribuent des
scores d'avant-plan/arrière-plan en fonction des caractéristiques calculées dans cette
fenêtre. Les fenêtres voisines ont des scores similaires dans une certaine mesure et
sont considérées comme des régions candidates. Cela conduit à des centaines de
propositions. Comme la méthode de génération de propositions doit avoir un rappel
élevé. Cependant, le traitement de ces nombreuses propositions tout au long du
réseau de classification est fastidieux. Cela conduit à une technique qui filtre les
propositions sur la base de certains critères. (Sambasivarao, 2019)

Figure 8:non-max supression8

L’ensemble du processus de filtrage dépend d'une seule valeur de seuil. La sélection

de la valeur seuil est donc essentielle pour la performance du modèle. Cependant, la
détermination de ce seuil est délicate.

Tout d'abord, toutes les boîtes de délimitation autour des objets dont la probabilité
est inférieure à un certain seuil (ex 0,5) sont filtrées. Ensuite, parmi les boîtes
restantes, la boîte ayant le plus grand pourcentage de probabilité est examinée pour

8
Source : [Link]
chaque objet et les autres boîtes sont supprimées. Il ne reste donc qu'une seule boîte
délimitée autour d'un seul objet identifié.

2.3 YOLO Tiny

You Only Look Once (YOLO) est un système de détection d'objets en temps réel avec
une grande performance, c’est un modèle de détection en une seule étape. Nous
appliquons un seul réseau neuronal à l'ensemble de l'image. Ce réseau divise l'image
en régions et prédit des boîtes de délimitation et des probabilités pour chaque région.
Ces boîtes de délimitation sont pondérées par les probabilités prédites.

Nous considérons la détection d'objets comme un problème de régression unique,

allant directement des pixels de l'image aux coordonnées de la boîte de délimitation
et aux probabilités de classe. Avec YOLO, il suffit de regarder une seule fois une image
pour prédire quels objets sont présents et où ils se trouvent.
YOLO est d'une simplicité surprenante. Un seul réseau convolutif prédit
simultanément plusieurs boîtes de délimitation et les probabilités de classe pour ces
boîtes. YOLO s'entraîne sur des images complètes et optimise directement les
performances de détection. Ce modèle unifié présente plusieurs avantages par
rapport aux méthodes traditionnelles de détection d'objets.

Premièrement, YOLO est extrêmement rapide. Puisque nous considérons la détection

comme un problème de régression, nous n'avons pas besoin d'un processus
complexe. Il suffit d'exécuter notre réseau neuronal sur une nouvelle image au
moment du test pour prédire les détections (Redmon, Divvala, Girshick, & Ali, 2016).

Deuxièmement, YOLO analyse de façon globale l'image lors de ses prédictions.

Contrairement aux techniques basées sur les fenêtres glissantes et les propositions
de région, YOLO voit l'image entière pendant l'apprentissage et le test, ce qui lui
permet d'encoder implicitement des informations contextuelles sur les classes ainsi
que sur leur appartenance (Redmon, Divvala, Girshick, & Ali, 2016).

Enfin, YOLO apprend des représentations généralisées des objets. Lorsqu'il est
entraîné sur des images naturelles et testé, YOLO surpasse de loin certains modèles
de détection comme DPM et R-CNN. Puisque YOLO est hautement personnalisable, il
est moins susceptible de faire une panne (bug) lorsqu'il est appliqué à de nouveaux
domaines ou à des entrées inattendues.

YOLO est encore en dessous des systèmes de détection de pointe en matière de

précision. Bien qu'il puisse identifier rapidement des objets dans les images, il a du
mal à localiser précisément certains objets, en particulier les petits.

L'idée de base de YOLO est présentée dans la figure ci-dessus. YOLO divise l'image
d'entrée en une grille S × S et chaque cellule de la grille est responsable de la
prédiction de l'objet centré dans cette cellule.

Chaque cellule de la grille prédit des boîtes de délimitation et des scores de confiance
pour ces boîtes. Ces scores de confiance reflètent le degré de confiance du modèle
dans le fait que la boîte contient un objet, ainsi que la précision de la boîte qu'il pense
prédire.
Cependant, même avec toute cette vitesse, YOLO n'est toujours pas assez rapide
pour fonctionner sur des appareils embarqués tels que le Raspberry Pi, smart
phone …

2.3.1 Qu'est-ce que YOLO-Tiny ?

Pour rendre YOLO encore plus rapide, Redmon et al. (les créateurs de YOLO) ont
défini une variante de l'architecture YOLO appelée YOLO-Tiny.

L'architecture YOLO-Tiny est environ 442% plus rapide que ses grands frères,
atteignant jusqu'à 244 FPS sur un seul GPU (Rosebrock, 2020).

Figure 9:Yolo-Tiny performance on COCO Dataset9

La petite taille du modèle (< 50 Mo) et la vitesse d'inférence rapide rendent le

détecteur d'objets YOLO-Tiny naturellement adapté aux périphériques légers
(smartphone) pour le traitement d’images en temps réel et l’apprentissage profond
intégrés.

Puisque YOLO-Tiny est une version plus petite que ses grands frères, cela signifie
également que YOLO-Tiny est malheureusement encore moins précis.

Selon, Redmon et al. rapportent ~51-57% mAP pour YOLO sur le dataset COCO alors
que YOLO-Tiny n'est que 23.7% mAP - moins de la moitié de la précision du modèle
classique. Cela dit, 23% mAP est encore assez raisonnable pour certaines
9
Source : YOLO: Real-Time Object Detection ([Link])
applications. YOLO et YOLO-Tiny ont tendance à produire un grand nombre de faux
positifs, pour remédier à cela, nous utilisons des filtres de détection faibles.

YOLO impose de fortes contraintes spatiales sur les prédictions des boîtes de
délimitation puisque chaque cellule de la grille ne prédit que deux boîtes et ne peut
avoir qu'une seule classe. Cette contrainte spatiale limite le nombre d'objets proches
que notre modèle peut prédire. Notre modèle éprouve des difficultés avec les petits
objets qui apparaissent en groupes, comme les colonies d'oiseaux.

2.4 Notre dataset

Notre dataset comprend des images d'un seul objet et des images encombrées avec
plusieurs objets.

Figure 10:Dataset composition

Nous avons collecté un dataset sur les billets de banque marocain avec 4 classes 200,
100, 50 et 20 Dirhams. Nous avons pris les images avec notre téléphone enfin de
créer le dataset. Nous avions au total 1361 images, on a utilisé le site makesense
([Link] pour labeliser les images aux différents formats
préférés (CSV, XML and txt). Toutes les images ont été redimensionnées à 416x416
de résolution en pixels.

Nous avons utilisé le mécanisme de data augmentation avec une rotation de 90º dans
le sens de l’aiguille d’une montre pour que notre dataset soit un peu grand. Apres
augmentation nous avons un dataset de 2722 images.
 Figure 11:notre dataset

3 Les résultats
3.1 YoloV4-Tiny
Nous avons entrainé notre modèle sur google colab en utilisant le modèle pré-
entrainé [Link].29 pour faire du transfert learning. Cela permet de gagner
un temps énorme lors de l’apprentissage et surtout d’avoir une précision plus élevée
car on bénéficie des gains du modèle pré-entrainé.
Achitecture de notre modèles :
Figure 12: Architecture de Yolo-Tiny
 Figure 13: Loss et Accuracy de YOLO-Tiny

Dans la figure 13 nous constatons que la perte (loss) loss = 0.0693 nous avions un
max_step de 8000 steps. Nous avons interrompu l’apprentissage au 5100 steps vu
qu’on avait une bonne précision pour chacune des classes.
 Figure 14: MAP de notre modele

Les images de test :

Figure 15:images de test

Lors du test sur les vidéos le résultat était impressionnant, nous avons intégré le
modèle a notre application. Le FPS (Frame per second) atteigne 50 FPS.

3.2 MobilenetV2_SSD
Ce modèle est basé sur tensorflow, il y’a souvent des problèmes de dépendance des
packages, il faut faire des downgrade de plusieurs versions avant de trouver les
bonnes versions compatibles. Nous avons utilisé le modèle pre-entraine
« ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8 », le modèle a été entrainé sur un
ordinateur core I7 8eme génération avec carte graphique GeForce GTX 1050. Le
nombre de steps=15000. Nous avons arrêté l’apprentissage lors des 11000 steps.

Les graphes des loss :

Figure 16: classification et localisation graph loss

Figure 17:regularization et total loss

Nous avons pu avoir des loss tres faible le total_loss = 0.52 ce qui signifie que notre
modele ne va pas commettre beaucoup d’erreurs.
Les precision et recall

Images de Test :

Nous constatons que notre modèle détecte certains objets et pas d’autre. Mais il n’a
pas de faux positif. Nous avions un seuil de 0.3 alors tout objets n’ayant pas atteint
30% de précision sera abandonné.

Nous avons exporté le modèle mobileNetV2-SSD en TFlite puis faire la conversion.

Notre modèle convertis en TFlite est prêt à l’emploi.
 Conclusion

Nous avons analysé la pertinence de différents réseaux de neurones profond à faible

empreinte mémoire qui peut être embarqué pour la détection d’objets en réel, avec
un entraînement entièrement sur des images collectées par nous-même.

En testant le modèle MobileNetV2_SSD, nous avons constaté qu'il fonctionnait bien

avec certaines images/vidéos, et avec d'autres il était totalement inutilisable.

Si le modèle ne vous donne pas les résultats que vous souhaitez, il est probable que
le modèle ne soit pas adapté à votre application particulière.

L'apprentissage de ces modèles est difficile (optimisation des hyperparamètres), mais

une fois que vous avez un modèle solide, le compromis entre vitesse et précision sera
à hauteur de souhait.

Ce travail nous a permis d’approfondir nos connaissances dans le domaine des

modèles d’algorithmes utilisés par les appareils mobiles et de mettre en évidence les
différentes architectures disponibles dans ce domaine. Ce projet a augmenté nos
capacités d’analyse, de curiosité et surtout d’être autonome dans l’implémentation
des différents modèles d’IA. Le domaine de l’IA est en perpétuel évolution notre
motivation est grande pour découvrir plus cet univers.
 Références
AlexeyAB. (2022). AlexeyAB/darknet. Récupéré sur GitHub: [Link]

Anton, M. (2022, July 21). TensorFlow Object Detection API: Best Practices to Training, Evaluation &
Deployment. Récupéré sur Neptune Labs: [Link]
api-best-practices-to-training-evaluation-deployment

Bochkovskiy, A., Wang, C.-Y., & Liao, H.-Y. M. (2020). YOLOv4: Optimal Speed and Accuracy of Object
Detection. arXiv preprint arXiv:2004.10934.

Cheng, R., He, X., Zheng, Z., & Wang, Z. (2021). Multi-Scale Safety Helmet Detection Based on SAS-
YOLOv3-Tiny. Appl. Sci.

Cohen, J., Crispim-Junio, C. F., Jean-Marc, C., & Tougne, L. (2022). MobileNet SSD : étude d’un détecteur
d’objets embarquable entraîné sans images réelles. HAL Id: hal-03531390.

Han, S., Mao, H., & Dally, W. J. (2015). Deep compression: Compressing deep neural networks with
pruning, trained quantization and huffman. arXiv preprint arXiv:1510.00149.

Hashir, A., Mahrukh, K., Syeda Kulsoom, F., Syed Muhammad, S., & Shaheena, N. (2019). Object
Recognition for Dental Instruments Using SSD-MobileNet. International Conference on
Information Science and Communication Technology (ICISCT).

He, W., Huang, Z., Wei, Z., Cheng, L., & Guo, B. (2019). TF-YOLO: An Improved Incremental Network for
Real-Time Object Detection. Appl. Sci. 2019.

Howard, A. G., Zhu, M., Chen, B., Kalenichenko, D., Wang, W., Weyand, T., . . . Adam, H. (2017).
MobileNets: Efficient Convolutional Neural Networks for Mobile Vision. arXiv preprint
arXiv:1704.04861v1.

Howard, A., Sandler, M., Chu, G., Chen, L.-C., Chen, B., Tan, M., . . . Adam, H. (2019). Searching for
MobileNetV3. IEEE Xplore, 1314-1324.

Matsubara, Y., & Levorato, M. (2020). Neural Compression and Filtering for Edge-assisted Real-time
Object Detection in Challenged Networks. arXiv:2007.15818v2 [[Link]] 18 Oct 2020.

Mengwei, X., Jiawei, L., Yuanqiang, L., Felix, X. L., Yunxin, L., & Liu, X. (2019). A First Look at Deep
Learning Apps on Smartphones. In Proceedings of the 2019 World Wide Web Conference (WWW
’19), 2125-2136.

POKHREL, S. (2020, August 25). Real-Time Vehicle Detection with MobileNet SSD and Xailient. Récupéré
sur xailient: [Link]
xailient/

Redmon, J., & Anelia, A. (2015). Real-Time Grasp Detection Using Convolutional Neural Networks.
arXiv:1412.3128v2.

Redmon, J., Divvala, S., Girshick, R., & Ali, F. (2016). You Only Look Once Unified, Real-Time Object
Detection. arXiv preprint arXiv:1506.02640v5.
Rosebrock, A. (2020, January 27). YOLO and Tiny-YOLO object detection on the Raspberry Pi and Movidius
NCS. Récupéré sur pyimagesearch: [Link]
object-detection-on-the-raspberry-pi-and-movidius-ncs/

Sambasivarao, K. (2019, Octobre 1). Non-maximum Suppression (NMS). Récupéré sur Towards Data
Science: [Link]

Sandler, M., Howard, A., Zhu, M., Zhmoginov, A., & Chen, L.-C. (2018). MobileNetV2: Inverted Residuals
and Linear Bottlenecks. IEEE/CVF Conference on Computer Vision and Pattern Recognition, 4510-
4520.

Sandler, M., Howard, A., Zhu, M., Zhmoginov, A., & Chen, L.-C. (2019). MobileNetV2: Inverted Residuals
and Linear Bottlenecks. arXiv:1801.04381v4 [[Link]] .

Shin, D.-J., & Kim, J.-J. (2022). A Deep Learning Framework Performance Evaluation to Use YOLO in Nvidia
Jetson Platform. Appl. Sci.

Vladimirov, L. (2021, september 13). TensorFlow 2 Object Detection tutorial . Récupéré sur Tensorflow:
[Link]
[Link]

Wang, G., Bhat, Z. P., Jiang, Z., Chen, Y.-W., Zha, D., Reyes, A. C., . . . Hu, X. (2022). BED: A Real-Time
Object Detection System for Edge Devices. arXiv:2202.07503v3 [[Link]] 14 Aug 2022.

Wang, R. J., Li, X., & Ling, C. X. (2019). Pelee: A Real-Time Object Detection System on Mobile Devices.
arXiv preprint arXiv:1804.06882v3.

Wei, L., Dragomir, A., Dumitru, E., Christian, S., Scott, R., Cheng-Yang, F., & Alexander C, B. (2016). SSD:
Single Shot MultiBox Detector. ECCV 2016, 21-37.

Yann, L., Yoshua, B., & Geoffrey, H. (2015). Deep learning. Nature 521, 436-444.

Yu-Chen, C., Tsai, C.-Y., Ruan, M.-D., Shen, G.-Y., & Lee, T.-T. (2020). Mobilenet-SSDv2: An Improved
Object Detection Model for Embedded Systems. 2020 International Conference on System
Science and Engineering (ICSSE).

Yue, X., Wang, Q., He, L., Li, Y., & Tang, D. (2022). Research on Tiny Target Detection Technology of Fabric
Defects Based on Improved YOLO. Appl. Sci. 2022, 12, 6823.