Memoire
Memoire
Memoire
MEMOIRE
Présenté à
En vue de l’obtention
Par
Oussema OULEDABDALLAH
Encadrant professionnel :
Monsieur SGHARI Firas
Signature et cachet
Encadrants académique :
Madame Nouha BACCOUR
Signature
Dédicaces
A ma chère maman Fathia qui m’a soutenu et encouragé durant ces années d’études.
Tu m’as comblé avec ta tendresse et affection tout au long de mon parcours.
A mon cher père Abdessattar qui m’a inculqué le sens de la responsabilité, de l’optimisme
et de la confiance en soi face aux difficultés de la vie.
A mes chères frères Eya & Youssef qui ont partagés avec moi tous les moments d’émotions
lors de la réalisation de ce travail, merci énormément pour votre soutien.
Ma vie ne serait pas aussi magique sans votre présence et votre amour
Je tiens, avant de présenter mon travail, à exprimer ma grande reconnaissance envers les
personnes qui m’ont, de près ou de loin, apporter leurs soutiens.
Qu’ils trouvent ici collectivement et individuellement l’expression de toute ma gratitude.
A Monsieur SGHARI Firas, mon encadrant professionnel pour leur accueil et leur confiance
qu’ils m’ont témoigné, leurs disponibilités tout au long de ce stage, leur judicieux conseils et
leur encouragements, qu’ils trouvent ici ma respectueuse gratitude.
Aussi, Je voudrais saluer avec beaucoup d’appréciation le rôle crucial de mon encadrante
académique, Madame Nouha BACCOUR, d’avoir accepté de diriger ce travail sans oublier
leurs conseils, leur supervision étroite et leurs suggestions importantes afin de cheminement ce
rapport.
Mes sincères remerciements s s’adressent également à tous mes enseignants à ENIS pour la
qualité de l’enseignement qu’ils ont bien voulu nous prodiguer durant les années d’études afin
de nous donner une formation efficace, qu’ils ont participé à notre évolution scientifique et
nous ont offert cette opportunité pour travailler un tel projet consistant.
Que les membres de jury trouvent, ici, l’expression de mes remerciements pour l’honneur
qu’ils me font en acceptant d’évaluer ce travail.
Introduction générale 1
1 Contexte du projet 2
1.1 Présentation de l’organisme d’accueil . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Présentation du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Etude de l’existant . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.3 Solution proposée . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Organisation de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1 Méthodes agiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Méthodologie de travail adoptée : Agile CRISP-DM . . . . . . . . . . 7
2 Etude de l’art 10
2.1 Fondements de l’intelligence artificielle . . . . . . . . . . . . . . . . . . . . . 11
2.1.1 Intelligence Artificielle . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.2 Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.3 Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.4 Convolution Neural Networks . . . . . . . . . . . . . . . . . . . . . . 12
2.1.4.1 Couche de convolution . . . . . . . . . . . . . . . . . . . . 13
2.1.4.2 Couche de Pooling . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.4.3 Couche d’activation . . . . . . . . . . . . . . . . . . . . . . 15
2.1.4.4 Couche Fully Connected . . . . . . . . . . . . . . . . . . . 15
2.1.5 L’apprentissage par transfert . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.5.1 Alex Net . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.5.2 VGG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.1.5.3 Resnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.1.5.4 Densenet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2 Fonction de perte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Les métriques d’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4 Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.5 Présention d’Amazon Web Service . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5.1 Le cloud computing . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5.2 Amazon Web Service . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.5.3 Avantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.4 Les services utilisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.5.4.1 Amazon S3 . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.5.4.2 Amazon ECR . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.5.4.3 Amazon Sagemaker . . . . . . . . . . . . . . . . . . . . . . 29
2.5.4.4 Amazon Lambda . . . . . . . . . . . . . . . . . . . . . . . 29
IT :Information Technology
IA :Intelligence artificielle
DL :Deep learning
ML :Machine learning
Aujourd’hui, l’une des blessures les plus fréquentes est la fracture d’un os. Un nombre
effarant de personnes souffrent de ce trouble, et les effets d’une fracture non traitée peuvent
entraîner des dommages à vie, voire la mort. Les médecins, qui sont chargés d’évaluer des
dizaines de radiographies par jour, sont en grande partie responsables de cette situation.
l’IA, en particulier l’apprentissage profond, a récemment fait des progrès importants dans la
perception des données d’imagerie, permettant aux machines de représenter et d’interpréter
plus précisément des données compliquées.
La classification des images est l’une des applications qui nécessitent un énorme stockage
avant l’apprentissage. Un tel stockage est généralement assuré par la technologie du cloud. De
nombreuses méthodes de traitement d’images médicales ont été appliquées dans un contexte
de cloud computing. Ces méthodes permettent un accès rapide à l’imagerie médicale et à son
traitement en fonction du temps.
Dans ce cadre s’inscrit ce projet de fin d’études intitulé “Développement d’un api rest de
diagnostic des images de traumatisme radiologiques en utilsant AWS Sagemaker”. Il vise à
faciliter le déroulement du service d’urgence.
Ce présent projet est subdivisé en 5 chapitres précédés par une introduction générale.
Le premier chapitre présente l’organisme d’accueil qui est NewGen Technologies ,et vise à
situer notre projet dans son cadre général l’IA et son exploitation dans le domaine médicale et
à présenter notre problématique générale qui nous mène à mettre en place notre solution pour
classifier les images de traumatisme.
Dans le deuxième chapitre nous détaillons les notions de base d’intelligence artificielle, nous
présentons l’état de l’art ainsi que les services cloud utilisés.
Ensuite dans le troisième chapitre, nous présentons un enchaînement précis pour traiter les
données, déterminer le bon modèle, entraîner et évaluer le modèle de classification des images
de traumatisme.
Dans le quatrième chapitre, nous détaillons la procédure de conteneurisation et de déploiement
dans AWS ECR .
Finalement dans le cinquième chapitre ,nous expliquons par étapes la procédure de déploiement
de l’application sur AWS Sagemaker et la création d’un API Gateway.
Enfin, nous clôturons le présent rapport en concluant le travail effectué et en exposant quelques
perspectives qui peuvent l’enrichir et pour améliorer de notre solution.
1
Contexte du projet
Sommaire
1.1 Présentation de l’organisme d’accueil . . . . . . . . . . . . . . 3
1.2 Présentation du projet . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Etude de l’existant . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.3 Solution proposée . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Organisation de travail . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1 Méthodes agiles . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Méthodologie de travail adoptée : Agile CRISP-DM . . . . . . . 7
Introduction
L’objectif de ce premier chapitre est de situer le projet dans son cadre général. Nous commençons
par présenter l’organisme d’accueil "NewGen technologies". Ensuite, nous présenterons le contexte
du projet, la problématique, les objectifs et les résultats attendus. La dernière partie sera consacrée
à la méthodologie du travail.
NewGen Technologies est une jeune entreprise fondée en Février 2022 par Mr Firas Sghari,
spécialisée essentiellement dans l’ingénierie des systèmes d’information et des réseaux d’une
part, et le consulting en intelligence artificielle et Big Data dans les environnement hybrides et
Cloud d’autre part.
Dans cette section, nous présentons tout d’abord la problématique qui a été a l’origine de la
réalisation de notre projet, puis nous présentons la solution proposée.
1.2.1 Problématique
Les chutes, les collisions, les bagarres et autres mésaventures entraînent fréquemment des
fractures chez les nourrissons, les personnes âgées et les jeunes. De nombreux cliniciens utilisent
les images médicales pour évaluer la probabilité de fractures osseuses. Il existe de nombreuses
techniques permettant d’obtenir différents types d’images médicales de haute qualité grâce au
développement d’appareils médicalement complexes, notamment les rayons X et l’imagerie
par résonance magnétique (IRM). Il s’agit d’une méthode courante pour identifier la présence
et la gravité d’une fracture osseuse par l’évaluation visuelle d’une image radiographique et pour
tenter d’obtenir des traitements appropriés. Un médecin expert doit passer beaucoup de temps
à examiner l’emplacement exact d’une fracture osseuse sur une image radiographique. Dans
de nombreux hôpitaux, il n’y a pas assez de radiologues expérimentés pour traiter ces images
médicales. Le diagnostic assisté par ordinateur a été largement utilisé dans l’interprétation des
images médicales pour aider les chirurgiens à trouver les fractures osseuses, et il a gagné en
importance ces dernières années.
F IGURE 1.2 – Etude comparative entre les radiologues et le modèle développé par
Stanfordmlgroup [1]
Pour chaque type d’étude, y compris le coude, le doigt, l’avant-bras, la main, l’humérus,
l’épaule et le poignet, nous avons comparé les performances du modèle avec les meilleures
performances en termes de précision des radiologues. La meilleure précision du radiologue
sur les études du doigt était de 0,410, alors que la performance du modèle sur les mêmes
données était de 0,389. Comme dans les études sur les poignets, la performance du modèle
sur ces mesures, 0,931 , était égale à la performance du meilleur radiologue pour ces tests. Dans
l’ensemble, la performance du modèle était inférieure à celle du meilleur radiologue pour tous
les autres types d’études.
De plus, nous avons comparé la performance du modèle avec la performance la plus faible du
radiologue pour chaque type d’essai. La performance du radiologue le plus mauvais sur les
études de l’avant-bras était de 0,796, alors que la performance du modèle était de 0,737. De
même, la performance du modèle sur les études de l’humérus et de l’épaule était inférieure à
celle du radiologue le plus mauvais. Pour les études des doigts, le modèle a été aussi performant
que le plus mauvais radiologue, qui a obtenu un score de 0,304, avec une performance de 0,389.
Les performances du modèle sur les études du coude étaient également équivalentes à celles du
plus mauvais radiologue. La performance du modèle a été supérieure à celle du radiologue le
plus mauvais pour tous les autres types d’études. Dans l’ensemble, la performance du modèle
était inférieure à celle du radiologue le moins performant, qui était de 0,731, à 0,705.
MURA est l’un des plus grands ensembles de données de radiographie disponibles publiquement,
cette base d’apprentissage est développé par Stanfordmlgroup. Nous avons exploité partagé la
même base d’apprentissage. Plus précisément, notre tâche consiste à résoudre les problèmes de
précision du modèle existant de Stanfordmlgroup. Pour commencer ,nous allons nous focaliser
sur les images radiologiques portant sur les traumatismes des doigts. Ensuite, nous allons tenter
de rendre notre modèle généraliste, c’est-à-dire une solution qui donne de bons résultats en
terme de précision dans tous les études de notre base d’apprentissage.
Notre solution consiste tout d’abord à recueillir les besoins auprès d’experts comme un
orthopédiste chez l’hôpital universitaire Habib Bourguiba et un radiologue chez hôpital régional
Bir Ali Ben Khelifa avant de commencer la création d’un modèle d’apprentissage profond.
Le pipeline de notre solution est présenté dans la figure ci-dessus 1.3.
Afin de réussir notre projet en respectant les délais et les ressources, il est nécessaire que
l’équipe soit bien organisée et efficace. Dans ce contexte, nous avons dû fixer l’une des méthodes
de gestion des projets existantes afin de nous aider à organiser notre projet de façon rationalisée
et structurée.
Le but de ce projet est d’établir des modèles permettant d’atteindre nos objectifs. Nous
avons décidé d’adapter le processus standard intersectoriel bien connu et largement accepté
pour le “Data Mining” CRISP-DM [2] (qui a été au départ développé par IBM dans les années
60 pour réaliser les projets Datamining) pour refléter les spécificités de l’apprentissage machine
et assurer une exécution réussie des projets d’apprentissage machine.
Cette méthodologie sépare les projets de Data Science en 6 étapes. La figure ci-contre 1.4 les
présente.
1. Connaissance du métier
2. Connaissance des données
3. Préparation des données
4. Modélisation des données
5. Évaluation
6. Déploiement
Conclusion
Ce premier chapitre nous a permis de définir en premier lieu le cadre général de notre projet
à travers la présentation de l’entreprise d’accueil. En second lieu, nous avons défini le contexte
général, la problématique, les objectifs de notre projet ainsi que la solution que nous avons
proposé.
Enfin, nous avons défini la méthodologie de travail adoptée pour la réalisation du projet. En vue
d’avoir une idée plus claire sur le projet, nous présentons dans le chapitre suivant les fondements
de l’intelligence artificielle et les service utilisés par le cloud.
2
Etude de l’art
Sommaire
2.1 Fondements de l’intelligence artificielle . . . . . . . . . . . . . 11
2.1.1 Intelligence Artificielle . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.2 Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.3 Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.4 Convolution Neural Networks . . . . . . . . . . . . . . . . . . . 12
2.1.5 L’apprentissage par transfert . . . . . . . . . . . . . . . . . . . 16
2.2 Fonction de perte . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Les métriques d’évaluation . . . . . . . . . . . . . . . . . . . . . 22
2.4 Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.5 Présention d’Amazon Web Service . . . . . . . . . . . . . . . . 25
2.5.1 Le cloud computing . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5.2 Amazon Web Service . . . . . . . . . . . . . . . . . . . . . . . . 26
2.5.3 Avantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.4 Les services utilisés . . . . . . . . . . . . . . . . . . . . . . . . . 28
Introduction
L’IA désigne la possibilité pour une machine de reproduire des comportements liés aux
humains, tels que le raisonnement, la planification et la créativité. L’IA permet à des systèmes
techniques de percevoir leur environnement, gérer ces perceptions, résoudre des problèmes et
entreprendre des actions pour atteindre un but précis. L’ordinateur reçoit des données les analyse
et réagit. Les systèmes dotés d’IA sont capables d’adapter leurs comportements en analysant les
effets produits par leurs actions précédentes, travaillant de manière autonome.[3]
Une branche de l’intelligence artificielle connue sous le nom de vision par ordinateur est
souvent liée à l’apprentissage automatique, en particulier aux réseaux neuronaux. La vision par
ordinateur se concentre sur la manière dont les machines peuvent comprendre les images et les
vidéos numériques à un niveau profond. Elle vise à émuler les capacités du système visuel du
corps humain.
Dans de nombreuses tâches de vision par ordinateur, les réseaux de neurones convolutifs (CNN)
sont aujourd’hui la méthode de facto. Depuis leur invention il y a une dizaine d’années, les
réseaux de neurones convolutifs ont réalisé des percées révolutionnaires dans les applications
de vision par ordinateur, notamment la classification d’images et la reconnaissance d’objets,
comme la détection de gestes, d’iris, de plaques d’immatriculation, de visages et d’activités
humaines.
À première vue, le mode de fonctionnement d’un réseau neuronal convolutif semble simple :
l’utilisateur saisit une image sous la forme d’une matrice de pixels. Celle-ci a trois dimensions :
— une troisième dimension avec une profondeur de trois pour représenter les couleurs primaires
(rouge, vert et bleu).
Une opération mathématique simple est la convolution. Le travail de cette couche initiale
consiste à examiner les images d’entrée et à trouver l’existence d’un ensemble particulier de
caractéristiques [7]. Cette couche produit un ensemble de caractéristiques en sortie. Comme le
montre la figure suivante 2.2, son effet sur une image est comparable à celui d’un filtre :
— On commence par spécifier les dimensions de la fenêtre de filtrage dans le coin supérieur
gauche.
— Une carte d’activation de sortie qui montre où se trouvent les caractéristiques dans l’image
est produite après avoir effectué un calcul de convolution sur chaque zone de l’image
rencontrée.
Une procédure appelée couche de mise en commun est généralement utilisée entre deux
couches de convolution. Son rôle est de réduire la taille des images tout en conservant leurs
caractéristiques les plus importantes. Elle prend en entrée les caractéristiques créées à la sortie
de la couche de convolution.[7]
Le pooling maximum est parmi les types de pooling les plus populaires.Son objectif est de
réduire le coût de calcul en réduisant le nombre de paramètres à apprendre et de prendre le
maximum.Pour rendre plus concret l’action du Max-Pooling, voici l’exemple présenté par la
figure ci-dessous 2.3 : nous avons une matrice 4×4 représentant notre entrée initiale et un
filtre d’une fenêtre de taille 2×2 que nous appliquerons sur notre entrée. Pour chacune des
régions balayées par le filtre, le max-pooling prendra le maximum, créant ainsi par la même
occasion une nouvelle matrice de sortie où chaque élément correspondra aux maximums de
chaque région rencontrée.
L’élément central des réseaux neuronaux convolutifs est la couche d’activation. Elle constitue
toujours la première couche. Son objectif est de trouver un certain groupe de caractéristiques
dans les images d’entrée.[7]
Nous utilisons comme exemple la couche d’activation ReLU présenté par la figure ci-dessus
2.4, qui remplace toutes les valeurs d’entrée négatives par des zéros. Ces couches d’activation
sont motivées par la nécessité de non-linéariser le modèle.
La couche entièrement connectée d’un réseau neuronal est toujours la dernière couche.
Ce type de couche prend un vecteur en entrée et retourne un autre vecteur. Pour ce faire, elle
applique une combinaison linéaire et éventuellement une fonction d’activation aux données
d’entrée.
La dernière couche entièrement connectée du réseau est utilisée pour catégoriser l’image d’entrée
comme l’indique la figure ci-dessous 2.5. Elle produit un vecteur de taille N, où N est le nombre
total de classes dans notre problème de classification d’images. Chaque composante du vecteur
représente la probabilité que l’image d’entrée appartienne à une classe particulière.[7]
Le Transfert Learning, ou apprentissage par transfert, désigne l’ensemble des méthodes qui
permettent de transférer les connaissances acquises à partir de la résolution de problèmes donnés
pour traiter un autre problème.
L’apprentissage par transfert, quant à lui, permet de développer rapidement des modèles performants
et de résoudre efficacement des problèmes de vision par ordinateur difficiles en employant des
modèles pré-entraînés comme point de départ.[8]
La figure ci-dessous 2.6 montre la différence entre l’approche traditionnelle et l’approche tranfert
learning.
Plusieurs modèles bien connus ont été pré-entraînés tout au long de la longue histoire des
conceptions de réseaux neuronaux profonds, en particulier les réseaux neuronaux convolutifs,
et ils sont toujours utilisés pour de nombreux ensembles de données médicales ainsi que pour
des ensembles de données liés à d’autres domaines.
Ces modèles ont été régulièrement mis à jour et optimisés, et leurs performances en matière de
classification de photos de diverses catégories se sont améliorées et ont répondu aux attentes
dans de nombreux domaines.
Ci-dessous des exemples de modèles pré-entrainé, ainsi qu’une description de leurs attributs et
des mesures de leurs performances :
2.1.5.2 VGG
Le groupe de géométrie visuelle, ou VGG, est une conception standard de réseau neuronal
à convolution (CNN) profond comportant un certain nombre de couches. Le terme "profond"
décrit la quantité de couches VGG-16 ou VGG-19, qui se composent respectivement de 16
couches convolutifs pour le VGG-16 et de 19 pour le VGG-19. Le réseau VGG est construit
à l’aide de filtres convolutifs incroyablement petits. Le VGG-16 est composé de trois couches
entièrement liées et de 13 couches convolutives.
L’un de ses principaux inconvénients est sa taille, qui rend plus difficile l’apprentissage de ses
paramètres, est l’un de ses principaux inconvénients. En conséquence, le VGG16 est un grand
réseau avec un total de 138 millions de paramètres. Il s’agit d’un réseau énorme, même selon
les normes contemporaines.[10]
La figure ci-dessous 2.8 présente l’architecture VGG-16.
2.1.5.3 Resnet
Auparavant, on pensait qu’il n’était pas possible de former des modèles comportant plus
de 20 couches. La meilleure architecture CNN avant ResNet était VGG19. Comme son nom
l’indique, ce modèle comporte 19 couches convolutifs. Et il n’était pas possible d’ajouter des
couches supplémentaires à cette architecture, car lors de l’ajout de couches supplémentaires,
nous nous heurtions à un problème appelé "vanishing gradient". Cela signifie que si nous avons
plus de 8 couches dans notre architecture, nous atteindrons un point pendant l’apprentissage où
les gradients deviendront infiniment grands ou deviendront nuls, rendant impossible l’apprentissage
du modèle.
ResNet offre une solution à ce problème en permettant la création de modèles comportant
jusqu’à 1000 couches, ce qui permet de représenter des caractéristiques plus complexes. nous
permettant de créer des modèles pouvant représenter des caractéristiques plus complexes.
ResNet nous a fourni la solution d’utiliser les Skip Connections. Cela signifie que si deux
couches convolutives sont combinées en un seul bloc, que nous appellerons le ResBlock, l’entrée
du ResBlock a un chemin différent menant à la sortie du ResBlock. La sortie finale de ce
ResBlock particulier est alors obtenue en ajoutant ces entrées à la sortie du ResBlock.[11]
La figure ci-dessous 2.9 présente l’architecture Resnet.
2.1.5.4 Densenet
À l’exception de la première couche convolutive, qui utilise l’image d’entrée, toutes les
couches convolutives suivantes créent une carte de caractéristiques de sortie à partir de la sortie
de celle qui les précède. Il existe un nombre L de connexions directes entre chaque couche
et la couche qui la précède pour un nombre L de couches. La figure ci-dessous 2.10 présente
l’architecture Densenet.
L’une des caractéristiques les plus cruciales des réseaux neuronaux est constituée par les
fonctions de perte, qui, avec les fonctions d’optimisation, sont directement chargées de l’ajustement
du modèle.
Cette section présente les fonctions de perte les plus courantes utilisées dans les réseaux neuronaux,
ainsi que les nombreux types de fonctions de perte. Mais d’abord, nous aborderons les concepts
de propagation vers l’avant et vers l’arrière des réseaux neuronaux, qui nous aideront à comprendre
les processus internes d’apprentissage du modèle.[13]
données sont acceptées par chaque couche cachée, qui les traite ensuite en fonction de la
fonction d’activation avant de passer à la couche suivante.
Les données d’entrée ne peuvent être saisies qu’en avançant afin de produire une sortie. Lors de
la création de la sortie, les données ne peuvent pas revenir en arrière, car cela créerait un cycle
et empêcherait la création de la sortie. Un réseau feed-forward est une configuration de ce type
de réseau. Le réseau feed-forward facilite la diffusion de l’information.
Le traitement s’effectue à chaque neurone d’une couche cachée ou de sortie en deux étapes :
— Pré-activation : La transformation linéaire des poids par rapport aux entrées disponibles
aboutit à une somme pondérée des entrées. Le neurone décide de transmettre ou non cette
information en fonction de ce total agrégé et de la fonction d’activation.
les modèles ne comportant que deux classes, comme c’est le cas dans notre projet, où le modèle
doit classer les entrées dans l’une des deux catégories prédéterminées.
Le modèle d’apprentissage prédit des résultats dans des problèmes de classification qui
doivent être comparés à la réalité pour évaluer son efficacité. Typiquement, on utilise la matrice
de confusion. Elle montrera non seulement quelles prévisions étaient bonnes et mauvaises, mais
aussi quels types d’erreurs ont été commises. Nous avons besoin d’un ensemble de données de
test et d’un ensemble de données de validation qui contiennent tous deux les valeurs des résultats
acquis afin de créer une matrice de confusion.
Les lignes des colonnes du tableau correspondent aux classes réelles, et chaque colonne contient
une classe prédite par l’algorithme.[14]
Nous divisons les résultats dans les 4 groupes suivants :
La figure ci-dessus 2.11 présente la matrice de confusion qui nous fournit quatre mesures
distinctes et distinctives. D’autres métriques qui fournissent plus de détails sur le comportement
du modèle peuvent être générées à partir de ces quatre mesures :
• Accuracy :
La performance du modèle sur toutes les classes est souvent décrite par la précision, qui est une
mesure. Lorsque toutes les classes ont la même importance, elle est utile. Pour la calculer, on
utilise le nombre de prévisions exactes divisé par le nombre total de prévisions.
• Précision :
La précision est calculée comme la proportion d’échantillons positifs catégorisés avec précision
par rapport à tous les échantillons considérés comme positifs (correctement ou incorrectement).
La précision est une mesure de l’exactitude avec laquelle un modèle classe un échantillon
comme positif.
• Rappel ou Recall :
Le pourcentage d’échantillons positifs qui ont été correctement identifiés comme positifs sur
l’ensemble des échantillons positifs est utilisé pour calculer le rappel. Le rappel évalue la
capacité du modèle à identifier les échantillons positifs. Plus le nombre d’échantillons positifs
est élevé, plus le rappel est important.
2.4 Docker
Docker est un outil qui permet de conteneuriser une application.La conteneurisation est le
fait d’isoler une application de son environnement.
Avec Docker il y a deux mots qui sont omniprésents : les conteneurs et les images.
— Une image :
Une image est une version immuable d’une application. Une image Docker fournit les
dépendances,les fichiers de configuration et tout ce qui est nécessaire à l’exécution de
l’application.Nous pouvons construire une image en utilisant un Dockerfile.
Si nous faisons le parallèle avec la programmation orienté objet, une image peut être
comparée a une classe.
Il faut aussi mentionner que par défaut une application conteneurisée est une application sans
état dit ”stateless”.En quelques mots une application ’stateless’ est une application qui ne stocke
Le terme "cloud" désigne à la fois les systèmes d’exploitation et les bases de données qui
fonctionnent sur des serveurs accessibles via l’internet. Des centres de données répartis dans le
monde entier hébergent les serveurs du nuage.
Les utilisateurs et les entreprises peuvent éliminer la nécessité de gérer des serveurs physiques
ou d’exécuter des programmes logiciels sur leur propre matériel en utilisant le cloud.
En raison du fait que les fonctions de calcul et de stockage sont gérées par des serveurs dans
un centre de données plutôt que directement sur l’ordinateur de l’utilisateur, le cloud permet
aux utilisateurs d’accéder aux mêmes fichiers et programmes depuis presque n’importe quel
appareil. Ainsi, un utilisateur d’Instagram qui perd son téléphone peut toujours accéder à son
compte à partir d’un nouveau téléphone et le trouver actif, avec toutes ses photos, ses vidéos et
son historique de chat. Il en va de même pour les services de stockage en ligne comme Dropbox
ou Google Drive et les services de messagerie en nuage comme Gmail ou Microsoft Office 365.
Les entreprises peuvent réduire leurs coûts et dépenses informatiques en passant au cloud.
Par exemple, elles n’ont plus à mettre à niveau et à entretenir leurs propres serveurs, car le
fournisseur de services en nuage s’occupe de tout. Ce facteur impacte particulièrement les
petites entreprises car elles manquent souvent de ressources pour maintenir leur propre infrastructure
interne. En utilisant le cloud, elles n’ont plus besoin de gérer des serveurs physiques ou d’exécuter
des programmes logiciels sur leur propre matériel.
Comme les utilisateurs peuvent accéder aux mêmes données et programmes de n’importe où,
le "cloud" peut également faciliter les opérations transfrontalières des entreprises.[15]
La plateforme de cloud computing la plus complète et la plus utilisée au monde est Amazon
Web Services (AWS). Avec des centres de données situés dans le monde entier, elle fournit plus
de 200 services complets. Le nuage AWS fournit une large gamme de services d’infrastructure,
tels que des services d’optimisation de calcul, des options de stockage, des réseaux et des
bases de données proposés sous forme de ressources pratiques à la demande, accessibles en
quelques secondes et facturées en fonction de leur utilisation. Sans frais initiaux, de nouveaux
services peuvent être attribués immédiatement. Les entreprises, les jeunes pousses et les clients
du secteur public peuvent ainsi avoir accès aux éléments fondamentaux dont ils ont besoin pour
réagir rapidement à l’évolution de leurs besoins. En 2006, Amazon Web Services a commencé à
fournir aux entreprises des services web - aujourd’hui connus sous le nom de "cloud computing"
- sous la forme de services d’infrastructure informatique.[?]
2.5.3 Avantages
Nous disposons d’un environnement virtuel avec AWS qui nous permet de charger les
applications et les services requis par notre application. Par conséquent, les applications existantes
peuvent être plus facilement migrées tout en ayant la possibilité de développer de nouvelles
solutions.L’utilisation d’AWS offre les principaux avantages suivants :
— L’agilité : Vous ne payez que ce que vous utilisez avec AWS. L’équipement est élastique
et de taille adaptable. Les obligations et les coûts de résiliation sont absents.
— La rentabilité : Il n’y a pas de contrat à long terme ou de paiement initial requis ; vous
payez simplement pour la puissance de traitement, le stockage et les autres ressources que
vous utilisez réellement.
— La sécurité : La sécurité était une autre considération lors de la création d’AWS. Outre
la protection native du réseau, il existe toute une série de services qui vous permettent de
configurer précisément les services souscrits afin de filtrer les accès de manière rapide et
efficace. Aucun contrat ou paiement initial n’est requis ; vous payez simplement pour la
puissance de traitement, le stockage et les autres ressources que vous utilisez réellement.
Comme nous l’avons mentionné, AWS nous fournit un large éventail de services, dont
chacun est important pour notre projet :
2.5.4.1 Amazon S3
Selon AWS, un objet sur Amazon S3 est un fichier de données ou une "entité de base". Il
peut s’agir d’une vidéo, d’un document, d’une photo ou de tout autre type de fichier.
Une clé spéciale est associée à chaque objet. Ces clés sont utilisées pour distinguer et identifier
les objets dans l’environnement S3. Lors du téléchargement, un objet peut avoir une taille
maximale de 160 Go, bien qu’il existe un certain nombre de méthodes AWS pour contourner
cette restriction.[16]
Les développeurs peuvent rapidement stocker, gérer et déployer des images de conteneurs
Docker à l’aide d’Amazon Elastic Container Registry (ECR), un registre privé de conteneurs
Docker.
Comme Amazon ECR et Amazon Elastic Container Service (ECS) sont connectés, notre processus
de développement à la production est simplifié. Grâce à Amazon ECR, nous n’avons plus besoin
de gérer nos propres dépôts de conteneurs ni de nous soucier de la croissance de l’infrastructure
sous-jacente.
Vous pouvez déployer de manière fiable des conteneurs pour vos applications en utilisant l’architecture
hautement disponible et évolutive qu’Amazon ECR utilise pour héberger nos images.[17]
Vous pouvez créer des pipelines d’apprentissage automatique de bout en bout à l’aide du
service Amazon SageMaker sur AWS, de l’apprentissage des modèles au déploiement de la
production. Il dispose d’une importante collection de modèles préinstallés qui peuvent être
utilisés immédiatement, mais vous pouvez également utiliser des images Docker pour créer
vos propres modèles uniques.
Les conteneurs Docker sont fréquemment utilisés par SageMaker pour permettre aux utilisateurs
de former et de déployer des algorithmes.
Les développeurs et les scientifiques des données peuvent conditionner les logiciels en unités
standardisées qui fonctionnent de manière fiable sur Docker grâce aux conteneurs.[18]
Avec l’aide du service informatique AWS Lambda, vous pouvez exécuter du code sans
avoir à configurer ou à entretenir des serveurs. Lambda exécute le code sur une infrastructure
informatique hautement disponible et gère tous les aspects des ressources informatiques, notamment
l’allocation et la mise à l’échelle automatiques de la capacité, l’entretien du serveur et du
système d’exploitation, ainsi que la surveillance et la journalisation du code.
En utilisant l’un des langages pris en charge par Lambda (Java, Python, C, Node.js, Go, PowerShell,
Ruby, etc.), vous pouvez utiliser Lambda pour exécuter du code pour presque tout type d’application
ou de service dorsal.
Conclusion
3
Développement du modèle d’apprentissage
pour la classification des images radiologiques
Sommaire
3.1 Présentation de la base d’apprentissage . . . . . . . . . . . . . 32
3.2 Préparation de la base d’apprentissage . . . . . . . . . . . . . . 33
3.3 Prétraitement des données . . . . . . . . . . . . . . . . . . . . . 35
3.3.1 Normalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3.2 Réduction dimensionnelle . . . . . . . . . . . . . . . . . . . . . 36
3.4 Choix du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4.1 CNN de zéro . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4.2 Apprentissage par transfert . . . . . . . . . . . . . . . . . . . . 38
3.5 Amélioration et optimisation . . . . . . . . . . . . . . . . . . . 40
3.5.1 Data Augmentation . . . . . . . . . . . . . . . . . . . . . . . . 40
3.5.2 k-fold cross validation . . . . . . . . . . . . . . . . . . . . . . . 42
3.5.3 Les optimiseurs et leurs performances . . . . . . . . . . . . . . 43
Introduction
L’objectif d’un projet d’apprentissage automatique est de créer des modèles d’apprentissage
efficaces à partir d’un ensemble de données.
Mais pour ce faire, nous allons suivre une procédure spécifique qui implique la collecte et
la préparation des données, le choix du modèle approprié, l’apprentissage et l’évaluation du
modèle.
Dans ce chapitre, nous allons détailler toutes ces étapes.
Nous travaillerons avec la base de données d’apprentissage MURA, une importante collection
de radiographies musculo-squelettiques comprenant 40 561 images provenant de 14 863 examens,
chacune d’entre elles comportant une ou plusieurs vues et ayant été classée manuellement
comme normale ou pathologique par des radiologues.
9045 de ces images radiographiques étaient normales, tandis que 5818 étaient pathologiques.
Il y a sept classes dans la base d’apprentissage MURA : coude, doigt, avant-bras, main,
poignet, épaule et humérus.
Afin d’obtenir des résultats notables, il était crucial de disposer d’une base d’apprentissage vaste
et de qualité.
Le tableau ci-dessous 3.1 présente le partitionnement de la base d’apprentissage MURA.
apprentissage Validation
Classe Total
Normal pathologique Normal pathologique
Nous discuterons de la structure de notre base d’apprentissage MURA après l’avoir présentée.
En effet, il y a deux sous-dossiers dans le dossier MURA l’un pour la formation et l’autre pour
la validation comme l’indique la figure ci-dessous 3.1.
Chacun de ces sous-dossiers comporte sept sous-dossiers comme il est presenté par la figure
ci-dessous 3.2 . A chaque sous-répertoire correspond une catégorie de classification qui sont le
coude, le doigt, l’avant-bras, la main, l’humérus, l’épaule et le poignet.
Chacun de ces sept sous-dossiers ou divisions dans la hiérarchie possède ensuite une collection
de tous les identifiants de patients qui ont ensuite été divisés en différentes études, chacune
d’entre elles pouvant être soit une étude positive, soit une étude négative.
La figure ci-contre 3.3 présente un exemple d’une étude négative correspondante à la catégorie
poignet.
F IGURE 3.5 – Dossier Train contient tous les images négatives et positives
Le prétraitement des données est crucial car de bonnes données représentent le fondement
d’un modèle d’apprentissage efficace et performant.
Afin de rendre nos modèles plus fiables, nous avons utilisé une variété de méthodes de prétraitement.
La normalisation et la réduction dimensionnelle sont les deux méthodes les plus fréquemment
utilisées pour améliorer les performances de notre CNN.
3.3.1 Normalisation
Les pixels peuvent être utilisés pour représenter n’importe quelle image. Les images ne sont
essentiellement que des tableaux dont les données de pixel sont stockées dans chaque cellule
unique et dont les valeurs vont de 0 à 255.
Les images d’entrée normalisées sont nécessaires pour que les réseaux neuronaux s’entraînent
plus rapidement.
En soustrayant le minimum, qui est égal à 0, et en le divisant par le maximum de toutes les
observations, qui est égal à 255, nous pouvons normaliser les variables et ramener les données
sur une échelle de 0 à 1.Cela permet de conserver la forme de la distribution de chaque variable
tout en facilitant la comparaison sur la même "échelle".[19]
Nous allons travailler avec une résolution spatiale très élevée car les photographies que nous
avons utilisées peuvent être très volumineuses.
Ainsi, avant d’utiliser les images pour entraîner notre modèle, nous avons effectué une réduction
de la dimensionnalité.
Rappelons que le RVB est le type de codage le plus courant et est utilisé pour la majorité des
images naturelles que nous voyons.D’ailleurs, la conversion en niveaux de gris des images RVB
est une forme de réduction de la dimensionnalité.
Nous avons utilisé cette méthode parce que les images de notre base d’apprentissage se composent
à la fois d’images de trois dimensions et d’images en niveaux de gris. Comme le modèle
n’accepte que les images de même dimension, nous devons rendre toutes les images de la même
dimension.
La préparation des données étant maintenant terminée, la sélection du modèle approprié est
l’étape suivante.
Les réseaux de neurones convolutifs (CNN) peuvent être construits à partir de zéro ou des
modèles pré-entraînés comme VGG, Resnet, Alexnet et Densenet peuvent être utilisés pour
construire un modèle d’apprentissage profond.
Dans cette section, en utilisant notre propre architecture, nous avons créé un modèle CNN à
partir de zéro. Nous avons employé un type de modèle séquentiel.
La technique la plus simple pour construire un modèle dans Keras est séquentielle.
Elle permet de construire un modèle couche par couche.
Afin d’ajouter des couches à notre modèle, nous utilisons la fonction ’add’.
Les couches Conv2D, qui sont nos deux premières couches, traitent nos images d’entrée, qui
sont considérées comme des matrices bidimensionnelles.
Le nombre de nœuds dans chaque couche est de 64 dans la première couche et de 32 dans la
deuxième. La taille de l’ensemble de données déterminera si cette valeur doit être augmentée
ou diminuée. Dans notre situation, 64 et 32 sont efficaces.
Pour notre convolution, la taille du noyau détermine la taille de la matrice de filtre.Par conséquent,
une taille de noyau de 3 indique que la matrice de filtre sera de 3x3.
L’activation linéaire rectifiée, souvent appelée ReLU, servira de fonction d’activation pour nos
deux premières couches. Il a été démontré que les réseaux neuronaux utilisent efficacement
cette fonction d’activation.
Notre première couche accepte également une forme en entrée. Chaque image d’entrée a la
forme suivante : (28,28,1), où 1 indique que les images sont en niveaux de gris.
Il y a une couche appelée "Flatten" qui se trouve entre les couches Conv2D et la couche dense ;
cette couche relie les couches Conv2D et dense.
Dans notre couche de sortie, nous aurons deux nœuds, un pour chaque résultat potentiel (0-1).
L’activation "Softmax" est utilisée. Afin que la sortie soit comprise comme des probabilités,
softmax additionne la sortie à 1. Le choix avec la plus grande probabilité sera alors utilisé par
le modèle pour baser sa prévision.
Nous avons donc décrit l’architecture de notre modèle CNN, qui permet la classification d’images.
En raison du petit nombre de couches dans notre modèle, la précision de notre modèle cnn de
zéro après trois époques est faible, comme le montre la figure ci-dessous 3.6. Comme notre
modèle ne comporte que deux couches convolutifs et qu’il ne dispose pas de l’augmentation
des données, une méthode permettant d’augmenter la quantité de données, ses performances
sont faibles. Donc, Nous avons utilisé l’apprentissage par transfert afin de résoudre le problème
des mauvaises performances.
Les réseaux neuronaux convolutifs sont particulièrement coûteux à former, car des couches
supplémentaires signifient plus de convolutions et plus de paramètres à optimiser. L’ordinateur
doit être capable d’effectuer efficacement les calculs et de stocker plusieurs gigaoctets de données.
Grâce à l’apprentissage par transfert, l’apprentissage profond peut être réalisé sans avoir besoin
de consacrer un mois aux calculs. L’idée est d’utiliser les connaissances qu’un réseau de neurones
apprend en résolvant un problème pour en résoudre un autre plus ou moins similaire.
En fait, il n’est pas conseillé d’entraîner le réseau neuronal dès le départ lorsque la collection
d’images d’entrée est minuscule, comme dans notre cas. En effet, il y a beaucoup plus de
Nous remplaçons la dernière couche entièrement connectée du réseau pré-entraîné par un classificateur
qui a été modifié pour le nouveau problème et qui a reçu une initialisation aléatoire. Les
nouvelles images sont ensuite utilisées pour entraîner toutes les couches.
Lorsqu’une nouvelle collection d’image est vaste, ce qui n’est pas le cas dans notre situation,
la stratégie 1 doit être appliquée. De plus, la phase d’apprentissage sera plus rapide que si
l’initialisation avait été aléatoire car les paramètres de chaque couche (sauf la dernière) sont
ceux du réseau pré-entraîné.
• Stratégie 2 : extraction des features
Cette méthode consiste à représenter les images du nouveau défi en utilisant les caractéristiques
du réseau pré-entraîné. Pour ce faire, nous fixons tous les autres paramètres tout en supprimant
la dernière couche entièrement liée. La représentation de chaque image d’entrée sera alors
calculée par ce réseau raccourci en utilisant les caractéristiques pré-apprises. Nous entraînons
ensuite un classificateur avec une initialisation aléatoire sur ces représentations.
Lorsque la nouvelle collection d’images est modeste et comparable aux images de pré-apprentissage,
cette approche devrait être employée. En effet, le risque de sur-apprentissage étant important,
il est risqué d’entraîner le réseau sur relativement peu d’images. De plus, si les nouvelles et
les anciennes images ont des caractéristiques communes, elles peuvent être représentées par les
mêmes caractéristiques.
• Stratégie 3 : fine-tuning partiel
En combinant les méthodes 1 et 2, nous remplaçons une fois de plus la dernière couche entièrement
connectée par le nouveau classificateur qui a été initialisé de manière aléatoire, et nous ajustons
les paramètres de quelques niveaux dans le réseau pré-entraîné.
Par conséquent, nous entraînons les couches non fixées - qui correspondent généralement aux
couches supérieures du réseau - sur les nouvelles images en plus du classificateur.
Lorsque la nouvelle collection d’images est minuscule mais significativement différente des
images de pré-apprentissage, comme dans notre cas, cette méthode est employée. D’une part,
comme il n’y a pas beaucoup d’images de formation, la méthode 1 - former le réseau entier -
n’est pas pratique en raison de la possibilité de sur-apprentissage.Inversement, la méthode 2 est
également abandonnée car il y a peu de similitudes entre les nouvelles et les anciennes images.
Comme mentionné précédemment, nous avons utilisé les modèles pré-entraînés VGG-16, Resnet,
Alexnet, Mobilenet et Densenet dans notre projet.
Sur notre base apprentissage, nous avons effectué une comparaison des performances de différents
modèles pré-entraînés.
TABLE 3.2 – Les performances des modèles pré-entrainé sur notre base d’apprentissage
Nous constatons que le modèle pré-entraîné Densenet-169 est le plus efficace en termes
de précision, et pour cette raison, nous avons choisi ce modèle comme classificateur d’images
pour notre application. Nous allons parler de la performance de ce modèle en utilisant différents
paramètres tels que l’optimiseur, la perte et les fonctions d’activation.
Une stratégie visant à augmenter la quantité de données utilisées pour former un modèle est
appelée augmentation des données.
Les modèles d’apprentissage profond ont souvent besoin d’une grande quantité de données
d’apprentissage, qui ne sont pas toujours disponibles, pour obtenir des prédictions précises.
Par conséquent, les données existantes sont étendues pour fournir un modèle généralisé plus
précis. Bien qu’elle puisse être utilisée dans de nombreux domaines différents, l’augmentation
des données est fréquemment employée en vision par ordinateur.
Nous diviserons les transformations d’augmentation des données en 4 catégories pour les besoins
de notre projet :
— verticalflip =True
— horizontalflip=True
— Rotation-range=90
— RandomZoom(0.3)
— RandomCrop(height,width)
— RandomBrightness([-0.8,0.8])
— RandomContrast(0.2)
Nous observons une augmentation de la précision de notre modèle grâce à cette stratégie,
ce qui souligne l’importance de l’augmentation des données dans l’apprentissage profond.
La validation croisée est une aide à l’évaluation des modèles d’apprentissage automatique.
Le terme "k-fold" décrit le nombre de fois que l’ensemble de données est divisé.
L’ensemble de données est divisé au point où chaque pli est utilisé dans l’ensemble de test.
Dans notre exemple, nous avons utilisé la validation croisée avec k = 5.
L’approche divise l’ensemble de données en cinq portions égales dans ce cas. Le modèle est
testé en utilisant le premier pli de l’itération initiale. Pour former le modèle, il utilise les autres
jeux de données. Le deuxième pli permet de tester le jeu de données et d’autres éléments liés à
la formation. La même procédure est répétée jusqu’à ce que les cinq plis aient été utilisés dans
l’ensemble de test.
Les optimiseurs sont des algorithmes ou des techniques qui réduisent la fonction de perte
(fonction d’erreur) ou augmentent l’efficacité de la production.
Les optimiseurs sont des opérations mathématiques qui dépendent des poids et des biais, ou
paramètres apprenables, du modèle.
Les optimiseurs fournissent des indications sur la manière de modifier les poids et le taux
d’apprentissage du réseau neuronal afin de minimiser les pertes.
Nous aborderons les nombreux types d’optimiseurs et la manière dont ils réduisent précisément
la fonction de perte.
• Descente de gradient stochastique
La descente par gradient en est une version. Les paramètres du modèle sont mis à jour un par
un. SGD mettra à jour les paramètres du modèle 10 000 fois si l’ensemble de données pour le
modèle est de 10 000.
Les avantages de la descente de gradient stochastique sont :
— La fréquence peut également entraîner des gradients bruyants qui peuvent faire augmenter
l’erreur au lieu de la diminuer.
Nous avons donc décrit le fonctionnement du SGD, et nous allons maintenant observer comment
il réagit à notre modèle et à notre base d’apprentissage en termes de performances.
nombre des epoches Présicion d’apprentissage précision de validation Perte d’apprentissage perte de validation Loss
Comme nous pouvons le voir dans le tableau ci-dessus 3.3,après 25 epoches le modèle
optimisé par SGD a atteint une précision d’apprentissage de 85.94% et une précision de validation
de 83,43%.De même, pour la perte, la perte de validation et d’apprentissage obtenus sont
respectivement 0.4846% et 0.3411%.
• AdaGrad (descente de gradient adaptative) :
L’intuition derrière AdaGrad est de pouvoir utiliser différents taux d’apprentissage pour chaque
neurone dans chaque couche cachée en fonction des différentes itérations.
L’avantages d’AdaGrad est :
— Si le réseau de neurones est profond, le taux d’apprentissage devient très petit, ce qui
entraînera un problème de neurones morts.
Après que nous avons présenté le fonctionnement du AdaGrad.Nous allons voir sa réaction en
terme de performance avec notre modèle et notre base d’apprentissage.
nombre des epoches Présicion d’apprentissage précision de validation Perte d’apprentissage perte de validation Loss
Comme nous pouvons le voir dans le tableau ci-dessus 3.4,après 25 epoches le modèle
optimisé par adaGrad a atteint une précision d’apprentissage de 90.64% et une précision de
validation de 87,87%.De même, pour la perte, la perte de validation et d’apprentissage obtenus
sont respectivement 0.3803% et 0.2884%.
• RMS-Prop (propagation racine quadratique moyenne) :
Contrairement à la somme cumulative des gradients au carré, le taux d’apprentissage dans
RMS-Prop est la moyenne exponentielle des gradients. L’avantage de RMS-Prop est qu’il :
— Apprentissage lent
Après avoir décrit le fonctionnement du RMS-Prop, nous allons voir comment il se comporte
lorsqu’il est utilisé avec notre modèle et notre base d’apprentissage.
nombre des epoches Présicion d’apprentissage précision de validation Perte d’apprentissage perte de validation Loss
Comme nous pouvons le voir dans le tableau ci-dessus 3.5, après 25 epoches le modèle
optimisé par RMS-Prop a atteint une précision d’apprentissage de 84.29% et une précision de
validation de 80,25%.De même, pour la perte, la perte de validation et d’apprentissage obtenus
sont respectivement 0.7125% et 0.6063%.
• Adam
L’une des méthodes d’optimisation par descente de gradient les plus connues et les plus appréciées
est l’optimiseur d’Adam. Pour chaque paramètre, il s’agit d’une méthode qui détermine des taux
d’apprentissage adaptatifs. Les avantages d’Adam sont les suivants :
— Calcul efficace.
Après avoir exposé les avantages de l’Adam, nous allons voir comment il se comporte en
utilisant notre modèle et notre base d’apprentissage.
nombre des epoches Présicion d’apprentissage précision de validation Perte d’apprentissage perte de validation Loss
Comme nous pouvons le voir dans le tableau ci-dessus 3.6, après 25 epoches le modèle
optimisé par Adam a atteint une précision d’apprentissage de 94.46% et une précision de
validation de 91,77%.De même, pour la perte, la perte de validation et d’apprentissage obtenus
sont respectivement 0.281% et 0.1757%.
En général, l’optimiseur Adam est plus performant que les autres algorithmes d’optimisation,
et nous sommes convaincus que Adam a obtenu de meilleurs performances que les autres
optimiseurs. Adam est plus efficace en termes de temps de calcul et nécessite moins de paramètres
de réglage. En conséquence de tout cela, Adam est suggéré comme optimiseur par défaut pour
la majorité des applications.
Nous allons démontrer les performances d’Adam dans chaque classe de notre base d’aprentissage.
• La classe coude
L’optimiseur Adam a été exécuté pendant 50 époques afin de fournir les résultats de performance
présentés ci-dessous pour l’étude de la coude . Les résultats sont résumés dans le tableau
ci-dessous 3.7 en termes de précision et de perte.
nombre des epoches Perte d’apprentissage Précision d’apprentissage Perte de validation Précision de validation
TABLE 3.7 – Les performances du modèle sur la classe Coude en utilisant Adam
Comme nous pouvons le voir dans le tableau ci-dessus 3.7, le modèle optimisé par Adam
a atteint une précision d’apprentissage pour l’étude du coude de 95,68 % et une précision de
validation de 91,40 %.
• La classe doigt
En utilisant l’optimiseur Adam et en s’exécutant pendant 50 époques, nous avons obtenu les
résultats de performance indiqués ci-dessous pour l’étude des doigts. Les résultats pour la perte
et les résultats pour la perte et la précision sont mis en évidence dans le tableau 3.8.
nombre des epoches Perte d’apprentissage Précision d’apprentissage Perte de validation Précision de validation
TABLE 3.8 – Les performances du modèle sur la classe doigt en utilisant Adam
Comme nous pouvons le voir dans le tableau ci-dessus 3.8, la précision d’apprentissage du
modèle amélioré pour l’étude des doigts était de 88,58 %, et sa précision de validation était de
87,01 %.
• La classe main
En utilisant l’optimiseur Adam et en l’exécutant pendant 50 époques, nous avons pu obtenir les
résultats de performance pour l’étude de la main qui sont présentés ci-dessous. Les résultats en
termes de perte et de précision sont présentés dans le tableau 3.9.
nombre des epoches Perte d’apprentissage Précision d’apprentissage Perte de validation Précision de validation
TABLE 3.9 – Les performances du modèle sur la classe main en utilisant Adam
Comme nous pouvons le voir dans le tableau ci-dessus 3.9, la précision de formation du
modèle optimisé pour l’étude de la main était de 95,62 %, et sa précision de validation était de
88,33 %.
• La classe humérus
Nous avons utilisé l’optimiseur Adam au cours de l’exécution à 50 époques pour obtenir les
résultats de performance suivants pour l’investigation de l’humérus : Les résultats en termes de
perte et de précision sont mis en évidence dans le tableau 3.10.
nombre des epoches Perte d’apprentissage Précision d’apprentissage Perte de validation Précision de validation
Comme nous pouvons le voir dans le tableau ci-dessus 3.10, la précision d’apprentissage du
modèle amélioré pour l’étude de l’humérus était de 99,4 %, et sa précision de validation était
de 90,83 %.
• La classe épaule
En utilisant l’optimiseur Adam au moment de l’exécution pour 50 époques, nous avons pu
obtenir les résultats de performance suivants pour l’étude de l’épaule. Les résultats en termes
de perte et de précision sont mis en évidence dans le tableau 3.11.
nombre des epoches Perte d’apprentissage Précision d’apprentissage Perte de validation Précision de validation
TABLE 3.11 – Les performances du modèle sur la classe épaule en utilisant Adam
Comme nous pouvons le voir dans le tableau ci-dessus 3.11, la précision de formation du
modèle amélioré pour l’étude de l’épaule était de 94,22 %, et sa précision de validation était de
88,96 %.
• La classe épaule
Nous avons utilisé l’optimiseur Adam pour fonctionner pendant 50 époques et obtenu les résultats
de performance pour l’étude du poignet présentés ci-dessous 3.12. Les résultats sont résumés
dans le tableau 3.11 en termes de perte et de précision.
nombre des epoches Perte d’apprentissage Précision d’apprentissage Perte de validation Précision de validation
TABLE 3.12 – Les performances du modèle sur la classe poignet en utilisant Adam
Comme nous pouvons le constater à partir des données ci-dessus 3.12, le modèle optimisé
par Adam a obtenu une précision d’apprentissage pour l’étude de l’épaule de 96,68 % et une
précision de validation de 96,4 %.
Conclusion
4
Déploiement de la solution de classification
dans le cloud AWS
Sommaire
4.1 Étude comparative entre les fournisseurs du cloud . . . . . . 52
4.2 Transfert de la base d’apprentissage vers AWS S3 . . . . . . . 53
4.3 Conteneurisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.3.1 L’apport de GPU . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.3.2 La configuration de l’infrastructure d’un conteneur . . . . . . . 55
4.4 Déploiement de l’image Docker dans AWS ECR . . . . . . . . 60
Introduction
Afin de résoudre le problème du temps d’exécution, nous avons déployé notre solution de
classification sur Amazon Web Services en la conteneurisant. Cette conteneurisation permet de
fournir à notre modèle toutes les ressources nécessaires pour l’exécution et elle est assuré par
Docker, un outil très populaire pour la conteneurisation.
Dans ce chapitre, nous allons présenter notre image Docker qui représente notre solution de
classification. Cette image est depoyé sur AWS ECR.Finalement, nous avons migré notre base
d’apprentissage vers AWS S3.
Après avoir donné une définition générale du cloud, nous allons maintenant aborder les
plates-formes de services de cloud.
Actuellement, AWS, Microsoft Azure et Google Cloud Platform sont les leaders du secteur pour
l’infrastructure en tant que service (IaaS) et la plate-forme en tant que service (PaaS).
Comme la figure 4.1 montre, avec 33 % du marché, Amazon occupe sans conteste la première
place depuis trois ans, même si la taille du marché a pratiquement triplé.
Chacun des trois géants fournisseurs du cloud présente en effet des avantages et des inconvénients.Nous
devons identifier les points forts et les points à améliorer des fournisseurs dans le tableau
ci-dessous 4.1 afin de parvenir à une conclusion équitable.
En outre, nous devons mettre en évidence que les plateformes des services cloud regroupent
plus de 100 services répartis en diverses catégories telles que le stockage cloud, la puissance
de calcul, l’analyse des données, l’intelligence artificielle ou même le développement des jeux
vidéo.
4.3 Conteneurisation
La conteneurisation est une méthode qui permet de virtualiser, dans un conteneur, les ressources
matérielles systèmes de fichiers, réseau, processeur, mémoire vive,...nécessaires à l’exécution
d’une application. Dans cet espace sont aussi stockées toutes les dépendances des applications :
fichiers, bibliothèques, etc. Pour déplacer les applications virtuelles d’un système d’exploitation
à un autre, le conteneur se connecte à leur noyau, ce qui permet aux différents composants
matériels et logiciels de communiquer entre eux. Alors que la conteneurisation est cruciale pour
notre travail, le gpu sera crucial étant donné que le but de notre projet est de créer un modèle
d’apprentissage profond.
Nous comparerons les avantages et les inconvénients d’un processeur et d’un processeur
graphique, ainsi que leur utilisation dans l’apprentissage profond, les réseaux neuronaux et
l’apprentissage automatique.
• CPU :
Une unité centrale de traitement, parfois appelée CPU, est un processeur qui gère les commandes
fondamentales d’un ordinateur, notamment les opérations arithmétiques, logiques et d’entrée/sortie.
Il s’agit généralement d’une puce compacte mais puissante qui est intégrée à la carte mère de
l’ordinateur.Étant donné que l’unité centrale lit et exécute la majorité des instructions matérielles
et logicielles de l’ordinateur, on l’appelle le "cerveau de la machine". Un ou plusieurs cœurs,
une mémoire cache, une unité de gestion de la mémoire (MMU), l’horloge de l’unité centrale
et l’unité de contrôle sont tous des éléments communs d’une unité centrale. Ensemble, ils
permettent à l’ordinateur d’exécuter de nombreuses applications simultanément.
• GPU :
Un GPU, ou unité de traitement graphique, est un type de processeur informatique utilisé pour
créer des visuels et des images complexes en haute résolution. Les GPU d’aujourd’hui sont
utilisés dans des applications qui vont bien au-delà du traitement graphique, comme l’analyse
des données et l’apprentissage automatique, bien que leur conception initiale ait été destinée à
rendre des images, des films et des animations 2D et 3D sur un ordinateur. Ce type de calcul
est souvent appelé "GPGPU" ou "General Purpose GPU". Les GPU ont des performances
similaires à celles des CPU et possèdent des composants similaires (par exemple, des cœurs,
de la mémoire, etc.). Ils peuvent être discrets ou intégrés au CPU (c’est-à-dire séparés du CPU
avec leur propre RAM). En divisant les charges de travail en sous-tâches plus petites et en les
répartissant entre les nombreux cœurs de processeur du GPU, les GPU utilisent le traitement
parallèle.
En effet,Les GPU sont plus efficaces que les CPU lorsqu’il s’agit d’apprentissage profond, dont
les opérations sont simplement des multiplications de matrices.Pour cette raison, l’utilisation
des GPU a augmenté récemment. En effet, en raison de leur architecture massivement parallèle,
les GPU sont considérés comme le cœur de l’apprentissage profond.
Les GPU ne peuvent toutefois pas exécuter n’importe quelle application. En fait, ils emploient
un langage particulier s’appelle CUDA de NVIDIA pour tirer parti de leur conception.
L’architecture Compute Unified Device, également connue sous le nom de CUDA, est l’un
des cadres les plus appréciés pour la programmation des GPU. Avec l’aide de ce cadre, nous
pouvons utiliser efficacement la capacité de calcul parallèle du GPU.
Comme le runtime CUDA possède ses propres pilotes, il peut communiquer avec le GPU. En
outre, CUDA est un langage de programmation créé spécialement pour fournir des instructions
au GPU afin qu’il exécute une tâche.En effet,Le code d’application est converti par CUDA en
un ensemble d’instructions que les GPU peuvent utiliser.
Pour s’interfacer efficacement avec un GPU, un SDK CUDA et des bibliothèques comme
cuBLAS (basic linear algebra subroutines) et cuDNN (deep neural networks) ont été créés.
• cuDNN :
Comme elle est optimisée pour les GPU, la bibliothèque de réseaux de neurones cuDNN peut
utiliser pleinement les cartes graphiques Nvidia.
La convolution, la propagation avant et arrière, les fonctions d’activation et le pooling sont tous
implémentés dans cette bibliothèque.
il est impossible de former des réseaux neuronaux sur des GPU sans ce package. Par conséquent,
il s’agit d’un outil indispensable.
Il existe des versions CUDA pour C, C++ et Fortran. Pour d’autres langages comme Java,
Python et R, des wrappers sont disponibles. Par exemple, ces technologies constituent la base
des paquets d’apprentissage profond comme TensorFlow et Keras.
4.3.2.2 Nvidia-docker
L’installation de CUDA et l’octroi de droits d’accès sont nécessaires avant d’utiliser un GPU
en natif dans un conteneur. Le programme nvidia-docker a été créé dans cet esprit, permettant
aux GPU NVIDIA d’être exposés dans des conteneurs de manière sécurisée et séparée. Les
éléments suivants sont nécessaires pour utiliser nvidia-docker :
• exécuteur des conteneurs :
Le NVIDIA Container Toolkit a besoin d’un runtime de conteneur pour fonctionner.Dans notre
projet nous avons utilisé le Docker comme un exécuteur des conteneurs.
• Les pilotes NVIDIA :
Pour utiliser un périphérique GPU, des pilotes de NVIDIA sont nécessaires
• Les outils de NVIDIA-docker :
Après avoir installé les pilotes Nvidia et un conteneur d’exécution,nous disposons actuellement
d’un système qui permet des réglages isolés avec accès aux ressources GPU. NVIDIA a créé un
certain nombre d’outils pour activer l’accélération GPU dans les applications :
— CUDA Toolkit : une collection d’outils pour créer des applications et des programmes
qui peuvent tourner simultanément sur les GPU, la RAM et les CPU.
Les tâches impliquant l’IA et l’algèbre linéaire sont accélérées par l’intégration de ces techniques
dans le code de l’application. L’application peut maintenant soumettre des données et des
actions à traiter sur le GPU car les GPU sont maintenant visibles. Le choix le plus basique
est le CUDA Toolkit. Elle offre le plus de flexibilité (mémoire et instructions) pour développer
des applications uniques. Les bibliothèques offrent une abstraction de la fonctionnalité CUDA.
Elles nous permettent de nous concentrer sur le développement d’applications plutôt que sur
l’implémentation de CUDA.
L’architecture qui utilise le service Docker de nvidia est prête à être utilisée une fois que chacun
de ces composants a été développé. La figure ci-dessous 4.3 résume toute infrastructure de notre
conteneur.
Après avoir créé une architecture qui prend en charge l’utilisation des GPU, nous sommes
prêts à installer TensorFlow , Python et d’autres dépendances.
• L’installation de tensorflow :
Les pilotes GPU pour Nvidia sont utilisés par Tensorflow. L’étape la plus importante consiste
à choisir la version et le tag CUDA appropriés, cuDNN pour l’image Docker de Nvidia, et
TensorFlow par rapport à celle-ci. de sorte que le matériel GPU sous-jacent puisse être utilisé
par le système ML. Étant donné que,la compatibilité des versions entre CUDA, cuDNN et
tensorflow est l’un des défis auxquels nous avons été confrontés. En effet, Tensorflow doit être
compatible avec ces versions de CUDA et cuDNN en plus d’installer les versions exactement
identiques de ces bibliothèques dans l’image Docker. Par exemple, CUDA et cuDNN sont
incompatibles avec la version la plus récente de Tensorflow. Dans notre cas, il s’agissait de
Tensorflow=1.15, qui se trouvait dans un fichier requirements.txt, un type de fichier qui contient
généralement des informations sur toutes les bibliothèques, les modules et les paquets utilisés
pendant le développement d’un projet. Il conserve également tous les fichiers et paquets nécessaires
à l’exécution ou à la dépendance de ce projet.
La figure ci-dessous 4.4 présente les bibliothèques que nous avons utilisées et leurs versions
dans le fichier requirements.txt .
• L’installation de python :
Nous devons installer Python dans notre Dockerfile car nous avons créé notre modèle à l’aide
du langage de programmation Python. Les étapes requises pour installer Python dans notre
Dockerfile sont présentées dans la figure ci-dessous 4.5.
Nous avons mis en place une architecture qui permet l’utilisation ségréguée des ressources
GPU par notre application.En conclusion, les briques suivantes constituent la structure :
Nous avons construit l’image d’apprentissage et la télécharger sur Elastic Container Registry,
un registre de conteneurs AWS, avant de pouvoir utiliser notre Dockerfile pour créer les conteneurs
d’apprentissage. Il s’agit du registre personnel d’AWS pour les conteneurs Docker. Il nous
permet de stocker et de distribuer les images Docker qui incluent nos applications.
Ces actions doivent être effectuées afin de pousser une image Docker vers ECR :
• Nous devons d’abord obtenir un jeton d’authentification du client Docker et l’utiliser pour
établir une connexion. Pour ce faire, nous avons exécuté la commande indiqué dans la figure
ci-dessous 4.7 et vu le message "Connexion réussie".
• dans la deuxième phase nous avons stocké les images d’apprentissage dans un référentiel
ECR que nous appelons "sagemaker-xray" comme il est indiqué dans la figure ci-dessous 4.8
• L’image Docker doit être créée et poussée vers le nouveau référentiel en tant que dernière
et troisième étape. la figure ci-dessous 4.9 présente la commande qui permet de créer notre
image.
La commande et la procédure pour envoyer notre image à AWS ECR sont présentées dans
la figure ci-dessous 4.10.
Pour confirmer que l’image a été envoyée, nous avons accédez au service Elastic Container
Registry dans le tableau de bord AWS comme il est indiqué dans la figure ci-dessous 4.11.
Conclusion
Les étapes nécessaires pour créer une image docker et la pousser sur AWS ECR sont décrites
en détail dans ce chapitre.
Nous détaillerons la manière de créer une tâche d’apprentissage sur AWS Sagemaker dans le
chapitre suivant.
5
Exécution de la solution en utilisant
le conteneur SageMAker
de amazon et generation de l’API
Sommaire
5.1 Etude comparative entre les fournisseurs MLaaS . . . . . . . 66
5.2 Utilisation des conteneurs Docker avec AWS SageMaker . . . 71
5.2.1 Création,configuration et lancement d’une tâche d’apprentissage
SageMaker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.2.2 Structure du conteneur Amazon SageMaker . . . . . . . . . . . 76
5.2.3 Déploiement d’application avec le service Amazon Sagemaker . 77
5.3 Création d’un rôle dans AWS IAM . . . . . . . . . . . . . . . . 80
5.4 Création de la fonction Lambda . . . . . . . . . . . . . . . . . 83
5.5 Création d’un API Gateway . . . . . . . . . . . . . . . . . . . 85
Introduction
Dnasce chapitre, nous comparons les fournisseurs de machine learning as a service. Nous
aborderons ensuite le processus de développement et de configuration de la tâche d’apprentissage
ainsi que le déploiement de l’application sur AWS Sagemaker. Enfin, nous conclurons par la
construction d’une passerelle API.
Nous avons discuté de la variété des services offerts par les fournisseurs de cloud computing
dans les sections précédentes. Dans ce cas, nous nous concentrerons sur l’apprentissage en tant
que service (MLaaS), qui est un terme générique pour une variété de plates-formes basées sur le
cloud qui répondent à la majorité des problèmes d’infrastructure, y compris le prétraitement des
données, l’apprentissage du modèle et l’évaluation du modèle avec des prédictions supplémentaires.
Les quatre principaux services cloud MLaaS qui permettent un apprentissage et un déploiement
rapides des modèles sont Amazon Machine Learning, Azure Machine Learning, Google AI
Platform et IBM Watson Machine Learning.
Le projet doit être mené à bien dans le respect du calendrier, du budget et des normes requises.
Un projet a un objectif clair et doit être achevé dans les limites des coûts et des délais prévus au
budget.
Avant de comparer les API d’apprentissage automatique fournies par différents fournisseurs,
nous allons d’abord donner un aperçu des principales plateformes d’apprentissage automatique
en tant que service d’Amazon, Google, Microsoft et IBM comme il est présenté dans la figure
ci-dessous 5.1.
AWS Sagemaker
La plateforme SageMaker d’Amazon Web Services facilite le développement, le test et le
déploiement de modèles d’apprentissage automatique. Les avantages d’Amazon SageMaker
sont :
Scikit-Learn Scikit-learn est un autre cadre d’apprentissage automatique basé sur Python
qui a été créé dans le cadre du projet Google Summer of Code. Il est entièrement open
source.
Simplifier la création, l’apprentissage et le déploiement de modèles d’apprentissage automatique
en combinant les bibliothèques Python Scikit-learn et XGBoost.
Rétrospectivement, la modélisation est réalisée avec XGBoost et le traitement des données
est réalisé avec Scikit-learn.
2. Prise en charge concomitante de la modélisation et du déploiement
GCP ML Engine offre de nombreux outils et capacités automatisés pour faciliter la modélisation
et le déploiement, à l’instar du large éventail de services proposés par AWS SageMaker.
3. Surveillance des modèles
Le suivi des modèles est pris en charge par le moteur ML de Google. Le moteur ML offre
Microsoft Azure
Azure AI est la réponse de Microsoft à Amazon et Google, tout comme SageMaker d’Amazon
et ML Engine de Google.
Azure AI offre également une variété de plateformes gratuites et tout compris pour construire,
tester et déployer des modèles d’apprentissage automatique, ainsi qu’un large éventail de capacités
supplémentaires qui prennent en charge un certain nombre de cadres d’IA différents comme
PyTorch, TensorFlow, Sci-kit Learn, Chainer, Caffe2, MxNet et Suite. En outre, une variété
d’autres capacités et fonctionnalités inégalées sont offertes par Azure Machine Learning Studio
et Azure AI.
À la suite de cette analyse, nous avons opté pour AWS, qui propose des outils créés spécialement
pour les MLOps (machine learning operations), qui aident à automatiser et à normaliser les
procédures tout au long du cycle de vie des MLL. Pour stimuler la productivité des data
scientists et des ingénieurs ML tout en maintenant les performances des modèles en production,
nous pouvons rapidement former, tester, dépanner, déployer et gouverner des modèles ML à
grande échelle grâce aux outils MLOps de SageMaker.
AWS SageMaker utilise largement les conteneurs Docker pour permettre aux clients de
former et de déployer des algorithmes.
Les développeurs et les scientifiques des données peuvent regrouper les logiciels en unités
standardisées à l’aide de conteneurs, qui s’exécutent de manière cohérente sur Docker.
La conteneurisation isole le code de son environnement, regroupe l’environnement d’exécution,
les outils système, les bibliothèques système et les paramètres en un seul endroit, et garantit une
exécution cohérente quel que soit l’endroit où il est exécuté.
Nous devons d’abord construire un rôle qui accordera à AWS SageMaker l’accès à toutes
les ressources requises afin d’effectuer des tâches d’apprentissage sur AWS SageMaker. Pour
garder les choses simples, nous avons créé un rôle pour aws sagemaker " AmazonSagemakerFullAccess
". Ce rôle accorde à AWS SageMaker l’accès à tous les buckets S3, images ECR et autres
ressources, tant que leurs noms contiennent le mot "sagemaker". La figure ci-dessous 5.2 présente
le rôle créé pour aws sagemaker.
Pour que nous puissions accéder au service S3, des permissions supplémentaires doivent
être créées.
la figure ci-dessous 5.3 présente les autorisations d’accès au service S3 en tenant compte des
autorisations supplémentaires.
Comme indiqué précédemment, nous avons accordé au service Sagemaker l’accès à S3, qui
abrite notre base d’apprentissage.
Ensuite, nous avons conçu une tâche d’apprentissage afin d’apprendre notre modèle à l’aide de
aws sagemaker.
Un fichier appelé training-job-config.json a donc été créé il présenté par la figure ci-dessous 5.4.
— TrainingJobName : un nom pour notre tâche d’apprentissage qui occupe le rôle d’identifiant.
— StoppingCondition : Nous pouvons spécifier des critères d’arrêt tels que le temps d’exécution
maximum en secondes. Amazon SageMaker arrête automatiquement les instances de
création après un jour.
Nous devons utiliser AWS Sagemaker pour exécuter la tâche d’apprentissage après l’avoir
générée et configurée.
La figure ci-dessous 5.5 montre que depuis la console AWS, nous pouvons maintenant garder
un œil sur la progression de la tâche d’apprentissage.
Le tableau de bord de nos tâches d’apprentissage Amazon SageMaker montre les tâches qui
ont été terminées avec succès et celles qui ont échoué en raison de problèmes de codage.
Un schéma qui démontre comment former un modèle à l’aide d’AWS Sagemaker est fourni
par la figure ci-dessous 5.6.
en effet, AWS Sagemaker est exécuté sur une instance de calcul pour l’apprentissage automatique.
La figure ci-dessus 5.6 présente une instance de calcul pour l’apprentissage, deux buckets
S3 et un ECR pour déployer l’image docker. Il existe quelques exigences pour que la tâche
d’apprentissage fonctionne :
L’instance de calcul est lancée par AWS Sagemaker une fois la tâche d’apprentissage préparée,
et l’apprentissage du modèle à l’aide du code d’apprentissage et de la base d’apprentissage
commence.
Une fois la tâche d’apprentissage terminée, nous pouvons obtenir les poids de notre modèle à
partir de la sortie aws S3 .
Les artefacts du modèle d’apprentissage sont affichés dans la figure ci-dessous 5.7 dans un
dossier de sortie qui est hébergé dans AWS S3.
Amazon SageMaker est un service qui fournit des pipelines d’apprentissage automatique
complets de bout en bout, de l’apprentissage des modèles au déploiement en production, et cela
mérite d’être mentionné.
Trois étapes doivent être suivies afin de déployer l’application à l’aide du service Amazon
Sagemaker :
Jusqu’à présent, nous avons réussi à utiliser Amazon Sagemaker pour générer une définition
de modèle qui relie l’artefact du modèle au conteneur qui abrite la tâche d’apprentissage.
Nous devons d’abord établir une configuration, choisir le modèle déployé et fournir les
ressources que nous voulons qu’Amazon Sagemaker provisionne avant de pouvoir construire
un point de terminaison.
Finalement, on a créé notre point de terminaison comme il est indiqué dans la figure ci-dessous
5.11
Afin d’accorder à une fonction lambda toutes les autorisations nécessaires pour exécuter sa
fonction et appeler le service Sagemaker, nous devons d’abord définir un rôle pour la fonction.
Le processus de définition d’un rôle pour notre fonction à l’aide du service IAM dans AWS est
décrit en détail.
La figure ci-dessous 5.12 présente la sélection de Lambda comme cas d’utilisation pour ce rôle
est la première étape :
Ensuite, pour que la fonction lambda fonctionne correctement, les autorisations requises
doivent être ajoutées :
- L’accès complet aux journaux de surveillance du cloud est fourni par CloudWatchLogsFullAccess
comme il est indiqué par la figure ci-dessous 5.13.
- Pour permettre à notre fonction Lambda d’invoquer le point de terminaison Sagemaker que
nous avons défini précédemment (InvokeEndpoint) et de l’associer au rôle que nous construisons,
nous devons élaborer une politique d’autorisation. La figure ci-dessous 5.14 présente la politique
d’autorisation créé.
La figure ci-dessous 5.15 indique que nous avons ajouté ces permissions.
La dernière étape comme elle presenté dans la figure ci-dessous 5.16 est juste de nommer,
vérifier et créer le rôle.
Dans cette section, nous allons expliquer comment créer une fonction lambda qui appellera
le point de terminaison du modèle qu’Amazon Sagemaker a été utilisé pour générer précédemment.
Nous sélectionnons en premier lieu le rôle que nous avons déjà crée comme il est indiqué dans
la figure ci-dessous 5.17.
La figure ci-dessus 5.18 présente le code de la fonction lambda. Nous arrivons alors à créer
avec succès notre fonction Lambda.
Il nous reste juste de créer un API Gateway et l’accrocher à cette fonction.
Afin de construire, publier, maintenir, surveiller et protéger des API, les développeurs peuvent
utiliser le service entièrement géré connu sous le nom d’Amazon API Gateway. Les applications
utilisent les API comme leur "porte d’entrée" vers les données, la logique commerciale ou les
fonctionnalités de nos services dorsaux.
Nous commencons par construire notre API Gateway en ajoutant une méthode POST comme il
est indiqué dans la figure ci-dessous 5.19
La seule chose qui reste à faire est de mettre notre API en production.La figure ci-dessous
5.20 présente l ’étape de déploiement de l’API Gateway.
Nous recevons une URL d’invocation comme il est indiqué dans la figure ci-dessous 5.21
après l’installation de l’API Gateway qui peut être utilisée pour tester l’application en utilisant,
par exemple, le logiciel Postman (un client API qui permet aux développeurs de créer, partager,
tester et documenter facilement les API).
Ainsi, en utilisant le service Amazon Sagemaker, qui nous donne accès à un point de
terminaison qui sera utilisé par une fonction Lambda et livré par une passerelle API, nous avons
finalement terminé de mettre l’application en production.
Conclusion
Ce chapitre a commencé par une comparaison des fournisseurs de MLaaS, suivie d’une
explication sur la façon de créer, de configurer et de commencer une mission d’apprentissage.
Enfin, une passerelle API a été créée.
Ce travail a été réalisé dans le cadre du projet de fin d’études pour l’obtention du Diplôme
National d’ingénieur en Génie Informatique, il a été élaboré au sein de la société "NewGen
technologies". Dans le cadre de ce stage, nous avons réussi à développer un Api Rest permet de
classifier les images de traumatisme radiologique en utilisant aws sagemaker.
Comme dans tout processus de réalisation d’un projet et recherche, nous avons dû nous
entraîner à resoudre une variété de problèmes qui se sont présentés. Ces problèmes étaient
principalement liés à notre compréhension d’un nouveau domaine, à la lecture non seulement
de références théoriques mais aussi de se familiariser avec des nouvelles outils. De plus, pendant
la période de stage on a dû se familiariser à de nouveaux concepts comme : amazon web
services , docker et tensorflow. En outre, la résolution des problèmes de performance du modèle
développé par StanfordMlgroup a été un défi qui a été relevé avec succès. De plus, l’utilisation
du cloud computing et un outil de conteneurisation était une opportunités de s’intégrer dans un
tout nouveau domaine comme MlOps.
Bien que la majorité des exigences soient satisfaites par notre projet puisque la majeure
partie du travail a été consacrée à la classification des os fracturés et non fracturés, sans
élargir la tâche aux différents types de fractures, il reste ouvert à de nouvelles idées,
comme la classification générique qui est capable de différencier les différentes formes
de fracture.C’est-à-dire que chaque os est séparé en sous-groupes successifs de fractures
selon l’emplacement et la configuration des lignes de fracture.En effet, cette stratégies de
classification a une meilleure reproductibilité que les autres méthodes de classification et sa
configuration la rend idéale pour une tâche de classification. L’approche pourrait également
être simplement étendue car différents os du corps humain partagent la même structure. Un
ensemble de données suffisant est sans aucun doute l’un des composants les plus cruciaux
pour qu’une application basée sur l’apprentissage profond fonctionne bien après la définition
d’un système de classification approprié. Si possible, plus d’un expert de diverses spécialités
devrait être engagé pour l’étiquetage et l’évaluation afin d’obtenir de nombreux points de vue.
L’objectif ultime de cet outil serait de démontrer dans quelle mesure cette solution aide les
médecins dans leurs diagnostics.
Au terme de ce projet, nous pouvons s’assurer qu’il nous a été très bénéfique dans la mesure
ou il nous a donné l’occasion d’apprendre de nouveaux domaines et concepts. Les avantages
se sont fait sentir aussi bien dans la pratique qu’au niveau théorique. Nous étions bien intégrés
dans le monde professionnel, conscients de nos limites, de nos forces et de nos faiblesses, ce
qui a rendu ce projet très précieux sur le niveau personnel.
En guise de conclusion, il est important de noter que la réalisation de ce projet a été une
expérience très agréable qui nous a donné la chance d’être sur la pointe de la technologies
et d’élargir notre compréhension existante de l’analyse, de l’analyse, de l’interprétation et de
synthèse.
Webographie
[2] https://fr.blog.businessdecision.com/methode-crisp-la-cle-de-la-reussite-en-data-science/.
[Consulté le : avril 2022].
[5] https://www.futura-sciences.com/tech/definitions/intelligence-artificielle-deep-learning-17262/.
[Consulté le : mars 2022].
[6] https://towardsdatascience.com/a-comprehensive-guide-to-convolutional-neural-networks-the-eli5-way-
[Consulté le : avril 2022].
[7] https://openclassrooms.com/fr/courses/4470531-classez-et-segmentez-des-donnees-visuelles/
5083336-decouvrez-les-differentes-couches-dun-cnn/. [Consulté le : avril 2022].
[9] https://towardsdatascience.com/alexnet-the-architecture-that-challenged-cnns-e406d5297951.
[Consulté le : mai 2022].
[10] Wikipédia, “Gestion des ressources numériques — wikipédia, l’encyclopédie libre.” https:
//datacorner.fr/vgg-transfer-learning/, 2019. [Consulté le le 16 juin 2019].
[14] https://www.saagie.com/fr/blog/machine-learning-comment-evaluer-vos-modeles-analyses-et-metriques
[Consulté le le 16 juin 2019].
Résumé :Ce projet a été réalisé dans le cadre du projet de fin d’études pour
l’obtention du Diplôme National d’ingénieur en Génie Informatique, il a été élaboré
au sein de la société "NewGen technologies" à pour but de développer un Api Rest
permet de classifier les images de traumatisme radiologique en utilisant aws
sagemaker. Nous avons commencé par le prétraitement de notre base
d’apprentissage MURA puis choisir le modèle d’apprentissage le plus performant
ainsi que l’optimiseur le plus efficace. Ensuite, nous avons déployé notre solution
conteneurisée sous forme d'image docker à un référentiel sur un fournisseur de
cloud qui est amazon, où elle a été utilisée pour exécuter une tâche d'apprentissage
AWS Sagemaker. En fin, nous avons créé un api rest qui contient notre solution et le
mettre en production à travers AWS API Gateway.
Abstract : This project was carried out within the framework of the project for the end
of studies for the obtaining of the National Diploma of Engineer in Data-processing
Engineering. It was worked out within the company "NewGen Technologies" with the
goal to develop an API Rest that makes it possible to classify the images of
radiological trauma by using AWS Sagemaker. We started by preprocessing our
MURA learning base and then choosing the most efficient learning model and the
most efficient optimizer. Next, we deployed our containerized solution as a Docker
image to a repository on a cloud provider, which is Amazon, where it was used to run
an AWS Sagemaker learning task. Finally, we created an API Rest that contains our
solution and put it into production through AWS API Gateway.