Vous êtes sur la page 1sur 34

Université de Béjaia

Capteurs Intelligents

Chapitre 4

Conception de capteurs intelligents par Deeplearning


1. Introduction

Nous avons présenté dans les chapitres précédents les réseaux de neurones, mono couche
et multi couches, les principes de l’apprentissage automatique et les règles d’entrainement SGD,
Batch et Mini Batch. Nous allons présenter dans ce chapitre le Deeplearning et son application
pour la conception des interfaces intelligentes capables de traiter les données issues d’un
capteur et faire un traitement adéquat pour en extraire des paternes, même quand l’information
est complexe et (peu) non-structurées (image, son …). A la fin de ce chapitre, nous allons
donner une application sur une caméra capable de reconnaitre des chiffres écrits à la main.

2. Deeplearning
Le deep learning ou apprentissage profond est un type d'intelligence artificielle dérivé
du machine learning (apprentissage automatique) où la machine est capable d'apprendre par
elle-même, contrairement à la programmation où elle se contente d'exécuter à la lettre des règles
prédéterminées.

Comment en faire des capteurs intelligents ?

Base de données

Apprentissage

Capteur Interface Extraction de


Intelligente l’information
(Caméra,
désirée
microphone …)

Fig.1. Apprentissage pour conception d’un capteur intelligent

La base de données sert pour le processus d’apprentissage. La règle d’apprentissage et le


réseau utilisé peuvent, si les données sont suffisantes, d’établir un modèle exploitable en
pratique (apte à apprendre). Une fois le processus d’apprentissage est terminé, l’interface
intelligente (généralement un réseau profond) peut être connectée au capteur. Les données
issues du capteur peuvent alors être traitées par l’interface pour extraire l’information désirée.
Cette même architecture est utilisée dans tous les domaines où le deeplearning est exploitable
(en médecine pour identifier des tumeurs, diagnostic des maladies, diagnostic des systèmes
industriels, reconnaissance faciale, reconnaissance de forme, voiture autonome, pilotage
automatique…).

Fonctionnement du deep Learning

Le deep Learning s'appuie sur un réseau de neurones artificiels s'inspirant du cerveau


humain. Ce réseau est composé de dizaines voire de centaines de « couches » de neurones,
chacune recevant et interprétant les informations de la couche précédente. Le système
apprendra par exemple à reconnaître les lettres avant de s'attaquer aux mots dans un texte, ou
détermine s'il y a un visage sur une photo avant de découvrir de quelle personne il s'agit.

À travers un processus d’autoapprentissage, le deep Learning est capable d’identifier un


chat sur une photo. À chaque couche du réseau neuronal correspond un aspect particulier de
l’image.

À chaque étape, les « mauvaises » réponses sont éliminées et renvoyées vers les niveaux
en amont pour ajuster le modèle mathématique. Au fur et à mesure, le programme réorganise
les informations en blocs plus complexes. Lorsque ce modèle est par la suite appliqué à d'autres
cas, il est normalement capable de reconnaître un chat sans que personne ne lui ait jamais
indiqué qu'il n'ai jamais appris le concept de chat. Les données de départ sont essentielles : plus
le système accumule d'expériences différentes, plus il sera performant.

Publicité

Applications du deep Learning

Le deep Learning est utilisé dans de nombreux domaines :

 reconnaissance d'image,
 traduction automatique,
 voiture autonome,
 diagnostic médical,
 recommandations personnalisées,
 modération automatique des réseaux sociaux,
 prédiction financière et trading automatisé,
 détection par caméra de pièces défectueuses,
 détection de malwares ou de fraudes,
 chatbots (agents conversationnels),
 exploration spatiale,
 robots intelligents.
 Ville intelligente

C'est aussi grâce au deep Learning que l'intelligence artificielle de Google Alpha Go a
réussi à battre les meilleurs champions de Go en 2016. Le moteur de recherche du géant
américain est lui-même de plus en plus basé sur l'apprentissage par deep Learning plutôt que
sur des règles écrites.

Dans le domaine artistique, aujourd'hui le deep Learning est même capable de « créer »
tout seul des tableaux de Van Gogh ou de Rembrandt, d'inventer un langage totalement nouveau
pour communiquer entre deux machines. La musique aussi peut être composée par des
algorithmes du DEEPLEARNING.

3. Histoire du deeplearning

Ainsi, pour revenir à ses origines, il faut remonter au milieu du XXe siècle. En particulier
en 1943, avec l’apparition du modèle du « neurone formel », représentation schématique du
fonctionnement du cerveau humain. Ainsi qu’en 1957, avec l’invention du « perceptron »,
considéré comme le premier réseau de neurones artificiels.

Fig2. Premier réseau de neurones de l’histoire

Parallèlement à ces travaux, en 1950, le « test de Turing » voit le jour. Il s’agit d’une
épreuve dont le but est de tester la capacité d’une machine à reproduire le comportement
humain. Elle marque alors un tournant dans l’histoire de l’intelligence artificielle, dont
l’évolution connaîtra pourtant un sérieux ralentissement, jusque dans les années 1980

Freiné par les limites technologiques


Durant cette décennie, les recherches sur le deep learning affichent des progrès notables.
De nouveaux concepts sont mis au point, tels que le perceptron multicouche ou les réseaux de
neurones convolutifs, inspirés du système de vision des animaux. Et ce, grâce notamment au
travail d’un chercheur français : Yann LeCun. Celui-ci, qui travaille aujourd’hui sur
l’intelligence artificielle pour Facebook, est considéré comme l’un des inventeurs du deep
learning.

Problème : ces nouveaux réseaux de neurones, qui comportent plusieurs couches, nécessitent
une grande puissance de calcul pour être efficaces. De même, pour « entraîner » ces
algorithmes, il faut pouvoir accéder à une grande quantité de données… Des obstacles
difficiles à franchir à l’époque. Ce qui conduit la communauté scientifique à se détourner de
l’apprentissage profond dans les années 1990.

2012 : année charnière

Par la suite, seuls quelques chercheurs continuent de croire en cette technologie. Et son
retour en grâce n’interviendra véritablement qu’en 2012. Cette année-là, comme tous les ans
depuis 2010, le concours ImageNet Large Scale Visual Recognition Challenge, de l’université
de Stanford, met aux prises des équipes de recherche en informatique du monde entier, sur un
défi de reconnaissance d’images. Et lors de cette édition, le programme vainqueur pulvérise les
records établis jusqu’à présent, en s’appuyant pour la première fois sur le deep learning.

Cette même année, Google dévoile son projet « Google Brain », un programme capable
d’analyser des images. D’après la firme, l’ordinateur a alors étudié des millions de captures
d’écran de vidéos, sélectionnées aléatoirement et sans information supplémentaire. Et la
machine aurait fini par découvrir par elle-même le concept de chat et par savoir détecter la
présence d’un tel animal sur les clichés.

4. Rappelle sur l’adaptation SGD


Nous allons étudier ici l’apprentissage de la fonction XOR par un réseau de neurones.

Problème XOR La fonction BackpropXOR, qui implémente l'algorithme de


rétropropagation à l'aide de la méthode SGD, prend les poids et les données d'entraînement du
réseau et renvoie les poids ajustés.
[W1 W2] = BackpropXOR(W1, W2, X, D)
où W1 et W2 sont les matrices de poids des couches une et deux, respectivement. W1 est
la matrice de poids entre la couche d'entrée et la couche cachée et W2 est la matrice de poids
entre la couche cachée et la couche de sortie. X et D sont respectivement l'entrée et la sortie
correcte des données d'apprentissage. Le code suivant montre le fichier BackpropXOR.m, qui
implémente la fonction BackpropXOR
Fonction : BackpropXOR
1. function [W1, W2] = BackpropXOR(W1, W2, X, D)
2. alpha = 0.9;
3. N = 4;
4. for k = 1:N
5. x = X(k, :)';
6. d = D(k);
7. v1 = W1*x;
8. y1 = Sigmoid(v1);
9. v = W2*y1;
10. y = Sigmoid(v);
11. e = d - y;
12. delta = y.*(1-y).*e;
13. e1 = W2'*delta;
14. delta1 = y1.*(1-y1).*e1;
15. dW1 = alpha*delta1*x';
16. W1 = W1 + dW1;
17. dW2 = alpha*delta*y1';
18. W2 = W2 + dW2;
19. end
20. end

Script : TestBackpropXOR
1. clear all
2. X = [ 0 0 1;
3. 0 1 1;
4. 1 0 1;
5. 1 1 1;
6. ];
7. % Verifiez les valeurs de D
8. D = [ 0
9. 1
10. 1
11. 0
12. ];
13. W1 = 2*rand(4, 3) - 1;
14. W2 = 2*rand(1, 4) - 1;
15. for epoch = 1:10000 % train

16. [W1 W2] = BackpropXOR(W1, W2, X, D);

17. end

18. N = 4; % inference
19. for k = 1:N
20. x = X(k, :)';
21. v1 = W1*x;
22. y1 = Sigmoid(v1);
23. v = W2*y1;
24. y(k) = Sigmoid(v)

25. end
26. y'

Le code prend le point de l'ensemble de données d'entraînement, calcule la mise à jour du


poids, dW, en utilisant la règle delta et ajuste les poids. Jusqu'à présent, le processus est presque
identique à celui de l'exemple de code du chapitre précédent. Les légères différentes sont les
deux appels de la fonction Sigmoïde pour le calcul de sortie et l'ajout du calcul delta (delta1)
en utilisant la rétropropagation du delta de sortie comme suit:

e1 = W2'*delta;
delta1 = y1.*(1-y1).*e1;

Comme cela implique la rétro propagation du delta, nous utilisons la matrice de


transposition, W2 '. Le calcul delta (delta1) a un opérateur de produit élément par élément,. *,
Car les variables sont des vecteurs. L'opérateur élément par élément de MATLAB a un point
devant l'opérateur normal et effectue une opération sur chaque élément du vecteur. Cet
opérateur permet des calculs simultanés des « deltas » à partir de nombreux nœuds. La fonction
Sigmoid, que le code BackpropXOR appelle, a également remplacé la division par la division
élémentaire ./ pour tenir compte du vecteur.

function y = Sigmoid(x)
y = 1 ./ (1 + exp(-x));
end

Le programme du fichier TestBackpropXOR.m teste la fonction BackpropXOR. Ce


programme appelle la fonction BackpropXOR et entraine 10 000 fois le réseau neuronal.
L'entrée est donnée au réseau formé et sa sortie est affichée à l'écran. Les performances
d'entraînement peuvent être vérifiées lorsque nous comparons la sortie aux sorties correctes
(désirées) des données d'entraînement. D'autres détails sont omis, car le programme est presque
identique à celui du chapitre précédent.

5. Adaptation par moment (momentum)


Cette section explore une nouvelle variante très efficace de l'ajustement du poids. Elle
sera utilisée dans la suite de ce cours. Jusqu'à présent, l'ajustement du poids s'est appuyé sur les
formes les plus simples données au chapitre précédent et l’exemple précédent du fichier
BackpropXOR :

e1 = W2'*delta;
delta1 = y1.*(1-y1).*e1;
dW1 = alpha*delta1*x';
W1 = W1 + dW1;

. Cependant, il existe différentes formes d'ajustement du poids. Les avantages de


l'utilisation des formules avancées d'ajustement du poids incluent une stabilité plus élevée et
des vitesses plus rapides dans le processus d'entraînement du réseau neuronal. Ces
caractéristiques sont particulièrement favorables au Deep Learning, car il est difficile à former.
Cette section ne couvre que les formules qui vont nous intéresser par la suite. Si nécessaire,
vous voudrez peut-être étudier cela plus en détail en consultant les travaux de référence.

La variable m, est un terme qui est ajouté à la règle du delta pour ajuster le poids.
L'utilisation du terme de momentum conduit l'ajustement du poids dans une certaine direction
dans une certaine mesure, plutôt que de produire un changement immédiat. Il agit de manière
similaire au moment physique, ce qui entrave la réaction du corps aux forces externes.

où m- est la valeur du moment précédent (itération k-1 )et β est une constante positive
inférieure à 1. Voyons brièvement pourquoi nous modifions la formule d'ajustement du poids
de cette manière. Les étapes suivantes montrent comment l'élan change au fil du temps.
il ressort de ces étapes que la mise à jour de poids précédente, à savoir ∆w (1), ∆w (2),
∆w (3), etc., est ajoutée à chaque itération au cours du processus. Étant donné que β est inférieur
à 1, l'ancienne mise à jour du poids exerce une influence moindre sur le moment. Bien que
l'influence diminue avec le temps, les anciennes mises à jour de poids restent dans le moment.
Par conséquent, le poids n'est pas uniquement affecté par une valeur de mise à jour de poids
particulière. Par conséquent, la stabilité d'apprentissage s'améliore. De plus, le moment se
développe de plus en plus avec les mises à jour de poids. En conséquence, la mise à jour du
poids devient également de plus en plus importante. Par conséquent, le taux d'apprentissage
augmente (regarder les équations suivantes développées pour plusieurs itérations)
Le code suivant montre le fichier BackpropMmt.m, qui implémente l'algorithme de
rétropropagation avec moment. La fonction BackpropMmt fonctionne de la même manière que
celle de l'exemple précédent; il prend les poids et les données d'entraînement et renvoie les
poids ajustés. Ce code utilise les mêmes variables que celles définies dans la fonction
BackpropXOR.

Fonction : BackpropMmt
1. function [W1, W2] = BackpropMmt(W1, W2, X, D)
2. alpha = 0.9;
3. beta = 0.9;
4. mmt1 = zeros(size(W1));
5. mmt2 = zeros(size(W2));
6. N = 4;
7. for k = 1:N
8. x = X(k, :)';
9. d = D(k);
10. v1 = W1*x;
11. y1 = Sigmoid(v1);
12. v = W2*y1;
13. y = Sigmoid(v);
14. %%
15. e = d - y;
16. delta = y.*(1-y).*e;
17. e1 = W2'*delta;
18. delta1 = y1.*(1-y1).*e1;
19. %%
20. dW1 = alpha*delta1*x';
21. mmt1 = dW1 + beta*mmt1;
22. W1 = W1 + mmt1;
23. dW2 = alpha*delta*y1';
24. mmt2 = dW2 + beta*mmt2;
25. W2 = W2 + mmt2;
26. end
27. end

Script : TestBackpropXOR
1. clear all
2. X = [ 0 0 1;
3. 0 1 1;
4. 1 0 1;
5. 1 1 1;
6. ];

7. D = [ 0
8. 1
9. 1
10. 0
11. ];
12. W1 = 2*rand(4, 3) - 1;
13. W2 = 2*rand(1, 4) - 1;
14. for epoch = 1:10000 % train
15. [W1 W2] = BackpropMmt(W1, W2, X, D);
16. end
17. N = 4; % inference
18. for k = 1:N
19. x = X(k, :)';
20. v1 = W1*x;
21. y1 = Sigmoid(v1);
22. v = W2*y1;
23. y(k) = Sigmoid(v);
24. end
25. y'

Le code initialise mmt1 et mmt2, sous forme de zéros lorsqu'il démarre le processus
d'apprentissage. La formule d'ajustement du poids est modifiée ici :

dW1 = alpha*delta1*x';
mmt1 = dW1 + beta*mmt1;
W1 = W1 + mmt1;

La liste du programmes du fichier TestBackpropMmt.m, qui teste la fonction


BackpropMmt. Ce programme appelle la fonction BackpropMmt et l’entraine 10 000 fois le
réseau neuronal. Les données d'entraînement sont transmises au réseau neuronal et la sortie est
affichée à l'écran. Les performances de la formation sont vérifiées en comparant la sortie à la
sortie correcte des données de formation. Comme ce code est presque identique à celui de
l'exemple précédent, d'autres explications sont omises.

6. Fonction de coût et règle d'apprentissage

Cette section explique brièvement ce qu'est la fonction de coût et comment elle affecte
la règle d'apprentissage du réseau neuronal. La fonction de coût est un concept plutôt
mathématique associé à la théorie de l'optimisation (autre grande bronche de l’IA). Vous n'avez
pas besoin de le savoir pour le moment. Cependant, il est bon de savoir si vous souhaitez mieux
comprendre la règle d'apprentissage du réseau neuronal.
Ce n'est pas un concept difficile à suivre. La fonction de coût est liée à l'apprentissage
supervisé du réseau neuronal. Le chapitre précédent a expliqué que l'apprentissage supervisé
du réseau de neurones est un processus d'ajustement des poids pour réduire l'erreur des données
d'entraînement. Dans ce contexte, la mesure de l'erreur du réseau neuronal est la fonction de
coût. Plus l'erreur du réseau de neurones est grande, plus la valeur de la fonction de coût est
élevée. Il existe deux principaux types de fonctions de coût pour l'apprentissage supervisé du
réseau de neurones qui sont données ici.

Où d est la valeur désirée, y est la sortie du réseau et i et l’indice de la sortie (première


sortie, deuxième sortie …). M est le nombre de sorties du réseau.
Il est clair que la valeur de la fonction de coût est proportionnelle à l'erreur. Cette relation
est si intuitive qu'aucune autre explication n'est nécessaire.
a. Erreur quadratique
La plupart des premières études sur le réseau neuronal ont utilisé la première fonction de
𝟏
coût (erreur quadratique 𝑱 = ∑𝑴
𝒊=𝟏 𝟐 (𝒅𝒊 − 𝒚𝒊 ) pour dériver des règles d'apprentissage. Non
seulement la règle delta du chapitre précédent était dérivée de cette fonction, mais l'algorithme
de rétro propagation l'était également. Les problèmes de régression utilisent toujours cette
fonction de coût.

Fig.3 Fonction d’erreur quadratique

b. Fonction d’entropie croisée (cross entropie)


La deuxième fonction,
𝐽 = ∑𝑀 𝑖=1 −𝑑𝑖 𝑙𝑛(𝑦𝑖 ) − (1 − 𝑦𝑖 )𝑙𝑛(1 − 𝑦𝑖 ), dite fonction de cross entropie affecte
directement la règle delta utilisée dans tous les exemples précédents de sorte que, à la couche
de sortie on aura :

𝜹 = 𝑬 à la place de 𝜹 = 𝜳′ (𝒗) ∗ 𝑬

Fig.4 Fonction d’entropie croisée

La principale différence entre la fonction d'entropie croisée et la fonction quadratique de


est son augmentation géométrique. En d'autres termes, la fonction d'entropie croisée est
beaucoup plus sensible à l'erreur. Pour cette raison, les règles d'apprentissage dérivées de la
fonction d'entropie croisée sont généralement connues pour donner de meilleures
performances. Il est recommandé d'utiliser les règles d'apprentissage axées sur l'entropie
croisée, sauf dans les cas inévitables tels que la régression. Nous avons eu une longue
introduction à la fonction de coût car la sélection de la fonction de coût affecte la règle
d'apprentissage, c'est-à-dire la formule de rétro propagation. Plus précisément, le calcul du delta
au nœud de sortie change légèrement. Les étapes suivantes détaillent la procédure de formation
du réseau neuronal avec la fonction d'activation sigmoïde au nœud de sortie à l'aide de
l'algorithme de rétro propagation induite par l'entropie croisée.

Algorithme de rétro propagation avec entropie croisée


1. Initialisez les poids du réseau neuronal avec des valeurs adéquates.
2. Entrez l'entrée des données d'entraînement {entrée, sortie correcte} sur
le réseau neuronal et obtenez la sortie.
Comparez cette sortie à la sortie correcte, calculez l'erreur et calculez le
delta, δ, des nœuds de sortie.

𝐞=𝐝−𝐲
𝛅=𝐞
3. Propagez le delta du nœud de sortie vers l'arrière et calculez le delta des
nœuds cachés suivants.

𝑒 (𝑘) = 𝑊 𝑇 ∗ 𝛿
𝛿 (𝑘) = 𝛹 ′(𝑣 (𝑘) ) ∗ 𝑒 (𝑘)

4. Répétez l'étape 3 jusqu'à ce qu'il atteigne le calque masqué situé à côté


du calque d'entrée
5. Ajustez les poids du réseau de neurones de chaque couche k en utilisant
la règle d'apprentissage suivante:
𝒘𝒊𝒋 = 𝒘𝒊𝒋 + 𝜶𝜹𝒊 𝒙𝒋
xj est l’entrée de la couche k (sortie de la couche k-1)

6. Répétez les étapes 2 à 5 pour chaque point de données d'entraînement.


7. Répétez les étapes 2 à 6 jusqu'à ce que le réseau soit correctement formé.

c. Exemple: fonction d'entropie croisée

Cette section revisite l'exemple de rétropropagation. Mais cette fois, la règle d'apprentissage
dérivée de la fonction d'entropie croisée est utilisée. Considérez l’entrainement du réseau
neuronal qui se compose d'une couche cachée avec quatre nœuds, trois nœuds d'entrée et un
nœud de sortie unique. La fonction sigmoïde est utilisée pour la fonction d'activation des nœuds
cachés et du nœud de sortie.
La fonction BackpropCE forme les données de XOR à l'aide de la fonction d'entropie
croisée. Il prend les poids et les données d'entraînement du réseau neuronal et renvoie les poids
ajustés.

[W1 W2] = BackpropCE (W1, W2, X, D)

où W1 et W2 sont les matrices de pondération pour les couches d'entrée cachées et les couches
de sortie cachées, respectivement. De plus, X et D sont respectivement les matrices d'entrée et
de sortie correctes des données. Le code suivant montre le fichier BackpropCE.m, qui
implémente la fonction BackpropCE. (rétro propagation avec la fonction d’entropie croisée)

Fonction : BackpropCE
1. function [W1, W2] = BackpropCE(W1, W2, X, D)

2. alpha = 0.9;
3. N = 4;

4. for k = 1:N
5. x = X(k, :)'; % x = a column vector
6. d = D(k);
7. v1 = W1*x;
8. y1 = Sigmoid(v1);
9. v = W2*y1;
10. y = Sigmoid(v);
11. %%%%%%%%%%%%%
12. %%%%%%%%%%%%% PARTIE 2
13. e = d - y;
14. delta = e;
15. e1 = W2'*delta;
16. delta1 = y1.*(1-y1).*e1;
17. %%%%%%%%%%%%%
18. %%%%%%%%%%%%%
19. dW1 = alpha*delta1*x';
20. W1 = W1 + dW1;
21. dW2 = alpha*delta*y1';
22. W2 = W2 + dW2;
23. end
24. end
Ce code (la fonction BackpropCE) extrait les données d'entraînement, calcule les mises
à jour de poids (dW1 et dW2) en utilisant la règle delta et ajuste les poids du réseau de neurones
en utilisant ces valeurs. Jusqu'à présent, le processus est presque identique à celui de l'exemple
précédent. La différence survient lorsque nous calculons le delta du nœud de sortie comme

e = d - y;
delta = e;

Contrairement à l'exemple de code précédent, la dérivée de la fonction sigmoïde n'existe


plus. En effet, pour la règle d'apprentissage de la fonction d'entropie croisée, si la fonction
d'activation du nœud de sortie est le sigmoïde, le delta est égal à l'erreur de sortie. Bien sûr, les
nœuds cachés suivent le même processus que celui utilisé par l'algorithme de
rétropropagation précédent.

e1 = W2'*delta;
delta1 = y1.*(1-y1).*e1;

Le programme du fichier TestBackpropCE.m qui teste la fonction BackpropCE. Ce


programme appelle la fonction BackpropCE et entraîne le réseau neuronal 10 000 fois. Le
réseau neuronal entraîné donne la sortie pour l'entrée des données d'entraînement et le résultat
est affiché à l'écran. Nous vérifions le bon apprentissage du réseau neuronal en comparant la
sortie à la sortie correcte. Une explication supplémentaire est omise, car le code est presque
identique à celui d'avant.

L'exécution de ce code produit les valeurs affichées ici. La sortie est très proche de la
sortie correcte, D. Cela prouve que le réseau neuronal a été formé avec succès

d. Comparaison
La seule différence entre la fonction BackpropCE de la section précédente et la fonction
BackpropXOR de la section «Problème XOR» est le calcul du delta du nœud de sortie. Nous
examinerons comment cette différence presque insignifiante affecte les performances
d'apprentissage. Le code suivant montre le fichier CEvsSSE.m qui compare les erreurs
moyennes des deux fonctions.

Script : CEvsSSE.m
1. clear all
2. X = [ 0 0 1;
3. 0 1 1;
4. 1 0 1;
5. 1 1 1;
6. ];
7. D = [ 0
8. 0
9. 1
10. 1
11. ];
12. E1 = zeros(1000, 1);
13. E2 = zeros(1000, 1);
14. W11 = 2*rand(4, 3) - 1; % Cross entropy
15. W12 = 2*rand(1, 4) - 1; %
16. W21 = W11; % Sum of squared error
17. W22 = W12; %
18. for epoch = 1:1000
19. [W11 W12] = BackpropCE(W11, W12, X, D);
20. [W21 W22] = BackpropXOR(W21, W22, X, D);
21. es1 = 0;
22. es2 = 0;
23. N = 4;
24. for k = 1:N
25. x = X(k, :)';
26. d = D(k);
27. v1 = W11*x;
28. y1 = Sigmoid(v1);
29. v = W12*y1;
30. y = Sigmoid(v);
31. es1 = es1 + (d - y)^2;
32. v1 = W21*x;
33. y1 = Sigmoid(v1);
34. v = W22*y1;
35. y = Sigmoid(v);
36. es2 = es2 + (d - y)^2;
37. end
38. E1(epoch) = es1 / N;
39. E2(epoch) = es2 / N;
40. end
41. plot(E1, 'r')
42. hold on
43. plot(E2, 'b:')
44. xlabel('Epoch')
45. ylabel('Average of Training error')
46. legend('Cross Entropy', 'Sum of Squared Error')

Ce programme appelle les fonctions BackpropCE et BackpropXOR et entraîne les


réseaux de neurones 1000 fois chacun. La somme au carré de l'erreur de sortie (es1 et es2) est
calculée à chaque époque pour chaque réseau de neurones, et leur moyenne (E1 et E2) est
calculée. W11, W12, W21 et W22 sont les matrices de poids des réseaux neuronaux respectifs.
Une fois les 1 000 itérations terminées, les erreurs moyennes sont comparées au cours du temps
sur le graphique. Comme le montre la figure, l’apprentissage basé sur l'entropie croisée réduit
l'erreur à un rythme beaucoup plus rapide. En d'autres termes, la règle d'apprentissage basée sur
l'entropie croisée permet un processus d'apprentissage plus rapide. C'est la raison pour
laquelle la plupart des fonctions de coût du Deep Learning utilisent la fonction d'entropie
croisée.

Fig. 5 comparaison entre la fonction cout quadratique et le fonction d’entropie


croisée

8. La fonction d’activation Softmax

Très utilisée pour la classification, la formule mathématique est donnée par :

𝑒 𝑣𝑖
𝛹 (𝑣𝑖 ) = 𝑀 𝑣
∑𝑖=1 𝑒 𝑖

La majorité des algorithmes du Deeplearning utilisent cette fonction d’activation pour la


couche de sortie.
La fonction softmax maintient la somme des valeurs de sortie à un et limite également les
sorties individuelles à des valeurs de 0 à 1. Comme elle tient compte des grandeurs relatives de
toutes les sorties, la fonction softmax est un choix approprié pour les réseaux de neurones de
classification multiclasses.

9. Deeplearning
Il est temps de présenter le DeepLearning. Le Deep Learning étant toujours une extension
du réseau neuronal, la plupart de ce que vous avez lu précédemment est applicable. Par
conséquent, vous n'avez pas beaucoup de concepts supplémentaires à apprendre. En bref, le
Deep Learning est une technique d'apprentissage automatique qui utilise le réseau neuronal
profond. Comme vous le savez, le réseau neuronal profond est le réseau neuronal multicouche
qui contient deux couches cachées ou plus. Bien que cela puisse être d'une simplicité décevante,
c'est la véritable essence du Deep Learning. La figure 5-1 illustre le concept du Deep Learning
et sa relation avec le Machine Learning

Fig.6 architecture du Deeplearning

a. Réseaux profonds avec la fonction ReLU


La fonction ReLU est ne fonction d’activation qui sert à réduire certaines connexions du
réseau profond. Sa formule mathématique est la suivante :

𝑣 𝑠𝑖 𝑣 > 0
𝛹(𝑣) = max(𝑉, 0) = {
0 𝑎𝑖𝑙𝑙𝑒𝑢𝑟𝑠
Le code Matlabe de Softmax est donnée en activité.

Le dernier défi est le temps requis pour terminer l’apprentissage quand les données sont
gigantesques. Le nombre de poids augmente géométriquement avec le nombre de couches
cachées, nécessitant ainsi plus de données d'apprentissage. Cela nécessite finalement plus de
calculs. Plus le réseau de neurones effectue de calculs, plus l’apprentissage prend de temps. Ce
problème est une préoccupation sérieuse dans le développement pratique du réseau neuronal.
Si un réseau de neurones profond nécessite un mois de formation (d’apprentissage), il ne peut
être modifié que 20 fois par an. Une étude utile n'est guère possible dans cette situation. Ce
problème a été résolu dans une large mesure par l'introduction de matériel haute performance,
tel que le GPU, et d'algorithmes, tels que la normalisation par lots. Les améliorations mineures
que cette section a introduites sont les pilotes qui ont fait du Deep Learning le héros du Machine
Learning . le Deep Learning surpasse actuellement toutes les techniques auparavant utilisées.

Exemple de reconnaissance des chiffres par deeplearning

Soit les images suivantes. Chaque carré est pixel, pour le blanc la valeur est 0 et pour le
noir la valeur sert 1. On obtient alors des matrices 5×5. (voir activité 6 )

Fig. 7 . exemple de codage des chiffres

Considérez le réseau neuronal profond avec les trois couches cachées, comme le montre
la figure suivante. Chaque couche cachée contient 20 neurones, fonction d’activation ReLu
(REctified Linear Unit). Le réseau possède 25 neurones d'entrée pour l'entrée matricielle et cinq
neurones de sortie pour les cinq classes (1, 2, 3, 4, 5). Les neurones de sortie utilisent la fonction
d'activation softmax (car c’est un problème de classification).

Fig.8 Réseau de neurones profond 5 couches.


Cette section présente la fonction ReLU via l'exemple. La fonction DeepReLU entraîne
le réseau neuronal profond donné à l'aide de l'algorithme de rétropropagation. Il prend les
poids du réseau et des données d'entraînement et renvoie les poids entraînés.

[W1, W2, W3, W4] = DeepReLU (W1, W2, W3, W4, X, D)

où W1, W2, W3 et W4 sont des matrices de pondération des couches d'entrée-caché1, caché1-
caché2, caché2-caché3 et caché3-sorties, respectivement. X et D sont des matrices d'entrée et
de sortie correctes des données d'entraînement. Le code suivant montre le fichier DeepReLU.m,
qui implémente la fonction DeepReLU.

Fonction : DeepReLU
1. function [W1, W2, W3, W4] = DeepReLU(W1, W2, W3, W4, X,
D)
2. alpha = 0.01;
3. N = 5;
4. for k = 1:N
5. x = reshape(X(:, :, k), 25, 1);
6. v1 = W1*x;
7. y1 = ReLU(v1);
8. v2 = W2*y1;
9. y2 = ReLU(v2);
10. v3 = W3*y2;
11. y3 = ReLU(v3);
12. v = W4*y3;
13. y = Softmax(v);
14. d = D(k, :)';
15. %%%%%%%%%%%%
16. e = d - y;
17. delta = e;
18. e3 = W4'*delta;
19. delta3 = (v3 > 0).*e3;
20. e2 = W3'*delta3;
21. delta2 = (v2 > 0).*e2;
22. e1 = W2'*delta2;
23. delta1 = (v1 > 0).*e1;
24. dW4 = alpha*delta*y3';
25. W4 = W4 + dW4;
26. dW3 = alpha*delta3*y2';
27. W3 = W3 + dW3;
28. dW2 = alpha*delta2*y1';
29. W2 = W2 + dW2;
30. dW1 = alpha*delta1*x';
31. W1 = W1 + dW1;
32. end
33. end
Script : TestDeepReLU
1. clear all
2. X = zeros(5, 5, 5);
3. X(:, :, 1) =[...
4. 0 1 1 0 0;
5. 0 0 1 0 0;
6. 0 0 1 0 0;
7. 0 0 1 0 0;
8. 0 1 1 1 0
9. ];
10. X(:, :, 2) = [...
11. 1 1 1 1 0;
12. 0 0 0 0 1;
13. 0 1 1 1 0;
14. 1 0 0 0 0;
15. 1 1 1 1 1
16. ];
17. X(:, :, 3) = [ ...
18. 1 1 1 1 0;
19. 0 0 0 0 1;
20. 0 1 1 1 0;
21. 0 0 0 0 1;
22. 1 1 1 1 0
23. ];
24. X(:, :, 4) = [...
25. 0 0 0 1 0;
26. 0 0 1 1 0;
27. 0 1 0 1 0;
28. 1 1 1 1 1;
29. 0 0 0 1 0
30. ];
31. X(:, :, 5) = [...
32. 1 1 1 1 1;
33. 1 0 0 0 0;
34. 1 1 1 1 0;
35. 0 0 0 0 1;
36. 1 1 1 1 0
37. ];
38. D = [ ...
39. 1 0 0 0 0;
40. 0 1 0 0 0;
41. 0 0 1 0 0;
42. 0 0 0 1 0;
43. 0 0 0 0 1
44. ];

45. W1 = 2*rand(20, 25) - 1;


46. W2 = 2*rand(20, 20) - 1;
47. W3 = 2*rand(20, 20) - 1;
48. W4 = 2*rand( 5, 20) - 1;
49. for epoch = 1:10000 % train
50. [W1, W2, W3, W4] = DeepReLU(W1, W2, W3, W4, X, D);
51. end
52. N = 5; % inference
53. for k = 1:N
54. x = reshape(X(:, :, k), 25, 1);
55. v1 = W1*x;
56. y1 = ReLU(v1);
57. v2 = W2*y1;
58. y2 = ReLU(v2);
59. v3 = W3*y2;
60. y3 = ReLU(v3);
61. v = W4*y3;
62. y = Softmax(v)
63. [~,i]=max(y)
64. end

Ce code importe les données d'entraînement, calcule les mises à jour de poids (dW1, dW2,
dW3 et dW4) à l'aide de la règle delta et ajuste le poids du réseau neuronal. Jusqu'à présent, le
processus est identique aux codes précédents. Il ne diffère que par le fait que les nœuds cachés
utilisent la fonction ReLU, à la place de sigmoïde. Bien sûr, l'utilisation d'une fonction
d'activation différente entraîne également une modification de sa dérivée.
Considérons la partie de l'algorithme de rétropropagation, qui ajuste les poids à l'aide de
l'algorithme de rétropropagation. Le code suivant montre l'extrait du calcul delta du fichier
DeepReLU.m. Ce processus commence à partir du delta du nœud de sortie, calcule l'erreur du
nœud (couche) caché et l'utilise pour l'erreur suivante. Il répète les mêmes étapes via delta3,
delta2 et delta1.

e = d - y;
delta = e;e
3 = W4'*delta;
delta3 = (v3 > 0).*e3;
e2 = W3'*delta3;
delta2 = (v2 > 0).*e2;
e1 = W2'*delta2;
delta1 = (v1 > 0).*e1;

le Script : TestDeepReLU donne un code ou la fonction DeepReLU est appelée pour


entrainer le réseaux 10000 fois afin d’apprendre le contenue des matrices X, qui contiennent
des images de chiffres de 1 à 5 codées en noir et blanc (binaire).

b. Réseaux profonds avec la fonction DropOut


Cette section présente le code qui implémente la fonction dropout (décrochage). Nous
utilisons la fonction d'activation sigmoïde pour les nœuds (couche) cachés. Ce code est
principalement utilisé pour voir comment dropout est codés. La fonction DeepDropout forme
l'exemple de réseau neuronal en utilisant l'algorithme de rétropropagation. Il prend les poids et
les données d'entraînement du réseau neuronal et renvoie les poids entraînés pour chaque
itération.
Fonction : DeepDropout
function [W1, W2, W3, W4] = DeepDropout(W1, W2, W3, W4, X, D)
alpha = 0.01;
N = 5;
for k = 1:N
x = reshape(X(:, :, k), 25, 1);
v1 = W1*x;
y1 = Sigmoid(v1);
y1 = y1 .* Dropout(y1, 0.2);
v2 = W2*y1;
y2 = Sigmoid(v2);
y2 = y2 .* Dropout(y2, 0.2);
v3 = W3*y2;
y3 = Sigmoid(v3);
y3 = y3 .* Dropout(y3, 0.2);
v = W4*y3;
y = Softmax(v);
d = D(k, :)';
e = d - y;
delta = e;
e3 = W4'*delta;
delta3 = y3.*(1-y3).*e3;
e2 = W3'*delta3;
delta2 = y2.*(1-y2).*e2;
e1 = W2'*delta2;
delta1 = y1.*(1-y1).*e1;
dW4 = alpha*delta*y3';
W4 = W4 + dW4;
dW3 = alpha*delta3*y2';
W3 = W3 + dW3;
dW2 = alpha*delta2*y1';
W2 = W2 + dW2;
dW1 = alpha*delta1*x';
W1 = W1 + dW1;
end
end

Fonction : DroupOut

function ym = Dropout(y, ratio)


[m, n] = size(y);
ym = zeros(m, n);
num = round(m*n*(1-ratio));
idx = randperm(m*n, num);
ym(idx) = 1 / (1-ratio);
end
Script : TestDeepDroupOut
1. clear all
2. X = zeros(5, 5, 5);
3. X(:, :, 1) =[...
4. 0 1 1 0 0;
5. 0 0 1 0 0;
6. 0 0 1 0 0;
7. 0 0 1 0 0;
8. 0 1 1 1 0
9. ];
10. X(:, :, 2) = [...
11. 1 1 1 1 0;
12. 0 0 0 0 1;
13. 0 1 1 1 0;
14. 1 0 0 0 0;
15. 1 1 1 1 1
16. ];
17. X(:, :, 3) = [ ...
18. 1 1 1 1 0;
19. 0 0 0 0 1;
20. 0 1 1 1 0;
21. 0 0 0 0 1;
22. 1 1 1 1 0
23. ];
24. X(:, :, 4) = [...
25. 0 0 0 1 0;
26. 0 0 1 1 0;
27. 0 1 0 1 0;
28. 1 1 1 1 1;
29. 0 0 0 1 0
30. ];
31. X(:, :, 5) = [...
32. 1 1 1 1 1;
33. 1 0 0 0 0;
34. 1 1 1 1 0;
35. 0 0 0 0 1;
36. 1 1 1 1 0
37. ];
38. D = [ ...
39. 1 0 0 0 0;
40. 0 1 0 0 0;
41. 0 0 1 0 0;
42. 0 0 0 1 0;
43. 0 0 0 0 1
44. ];
45.
46. W1 = 2*rand(20, 25) - 1;
47. W2 = 2*rand(20, 20) - 1;
48. W3 = 2*rand(20, 20) - 1;
49. W4 = 2*rand( 5, 20) - 1;
50. for epoch = 1:20000 % train
51. [W1, W2, W3, W4] = DeepDropout(W1, W2, W3, W4, X, D);
52. end
53. N = 5; % inference
54. for k = 1:N
55. x = reshape(X(:, :, k), 25, 1);
56. v1 = W1*x;
57. y1 = Sigmoid(v1);
58. v2 = W2*y1;
59. y2 = Sigmoid(v2);
60. v3 = W3*y2;
61. y3 = Sigmoid(v3);
62. v = W4*y3;
63. y = Softmax(v)
64. end

c. Réseaux profond avec convolution


Réseaux profonds à convolution
Le travail présenté jusqu’ici a montré qu'une comment le Deep Learning a résolu le
problème d’apprentissage dans un réseau contenant plusieurs couches cachées. L'importance
du réseau neuronal profond réside dans le fait qu'il a ouvert la porte au modèle on-line complexe
et à l'approche systématique pour le traitement hiérarchique des connaissances où chaque
couche s’occupe d’une partie de l’information reçue.
Cette section présente le réseau neuronal convolutif (ConvNet), qui est un réseau neuronal
profond spécialisé dans la reconnaissance intelligente d'images. Technique implémentée pour
interpréter ou reconnaitre le contenu d’une information reçue par une caméra. En fait, ConvNet
est une ancienne technique, qui a été développée dans les années 1980 et 1990. Cependant, elle
a été oubliée pendant un certain temps, car elle n'était pas pratique pour les applications du
monde réel avec des images à haute dimension et contenant plusieurs informations (objets).
Depuis 2012, date à laquelle il a été radicalement relancé, ConvNet a conquis la plupart des
domaines de la vision artificielle et se développe à un rythme rapide.

Couche de convolution
Cette section explique comment fonctionne la couche de convolution, qui sert à
l’extraction d'entités à partir d’images. La couche de convolution génère de nouvelles images
appelées cartes d'entités. La carte des entités accentue les caractéristiques uniques de l'image
d'origine. La couche de convolution fonctionne de manière très différente par rapport aux autres
couches du réseau neuronal. Cette couche n'utilise pas une somme pondérée des connexions.
Au lieu de cela, elle contient des filtres qui convertissent les images. Nous appellerons ces
filtres des filtres convolutifs. Le processus d'entrée de l'image à travers les filtres de convolution
donne la carte des caractéristiques (des entités).
Fig.9 Effet de la couche de convolution
La figure précédente montre le processus effectué par la couche de convolution, où la
marque encerclée * indique l'opération de convolution et la marque φ est la fonction
d'activation. Les icônes carrées en niveaux de gris entre ces opérateurs indiquent les filtres de
convolution. La couche de convolution génère le même nombre de cartes d'entités que les filtres
de convolution. Par conséquent, par exemple, si la couche de convolution contient quatre filtres,
elle génèrera quatre cartes d'entités.
Convolution matricielle
Une image est représentée généralement sur ordinateur comme une matrice. En noir est
blanc, le cas le plus simple, serait de considérer chaque pixel en binaire (noir =1, blanc=0). Le
pixel peut contenir aussi le niveau en gris (méthode utilisée dans les écrans noir et blanc). Les
images en couleurs sont codées en RGB, c’est-à-dire trois matrices (R pour le niveau de la
couleur rouge, G pour le niveau de la couleur verte, B pour le niveau de la couleur bleue), ceci
donne trois valeurs pour chaque pixel.
Nous allons alors considérer l’image comme une matrice. Regardons maintenant la
convolution suivante entre une image de 4×4 pixels et un filtre de 2×2.

L'opération de convolution est la somme des produits des éléments qui se trouvent aux
mêmes positions des deux matrices. Le résultat de 7 dans le calcul précédent est calculé comme
suit:
(1×1) + (1×0) + (4×0) + (6×1) = 7
La convolutions complète donne alors :
Un autre exemple ici

Couche de POOLING
La couche de regroupement (POOLING) réduit la taille de l'image, car elle combine les
pixels voisins d'une certaine zone de l'image en une seule valeur représentative. Afin de mener
les opérations dans la couche de POOLING, nous devons déterminer comment sélectionner les
pixels de POOLING de l'image et comment définir la valeur représentative. Les pixels voisins
sont généralement sélectionnés dans la matrice carrée et le nombre de pixels combinés diffère
d'un problème à l'autre. La valeur représentative est généralement définie comme la moyenne
( mean pooling) ou le maximum (max pooling) des pixels sélectionnés. Le fonctionnement de
la couche de mise en commun est étonnamment simple. Comme il s'agit d'une opération
bidimensionnelle et qu'une explication dans le texte peut créer plus de confusion, passons en
exemple. Considérons l'image d'entrée de 4 × 4 pixels, qui est exprimée par la matrice suivante :
Fig.10 Illustration de l’opération de pooling.

En fait, dans un sens mathématique, le processus de regroupement (pooling) est un type


d'opération de convolution. La différence avec la couche de convolution est que le filtre de
convolution est stationnaire et que les zones de convolution ne se chevauchent pas. L'exemple
fourni dans la section suivante développera cela. La couche POOLING compense dans une
certaine mesure les objets excentriques et inclinés. Par exemple, elle peut améliorer la
reconnaissance d'un chat, qui peut être décentré dans l'image d'entrée. De plus, comme le
processus POOLING réduit la taille de l'image, il est très bénéfique pour soulager la charge
de calcul et empêcher le sur-ajustement.

Exemple: MNIST
Nous implémentons un réseau neuronal qui prend l'image d'entrée et reconnaît le chiffre
qu'elle représente. Les données d’apprentissage sont la base de données MNIST, qui contient
70 000 images de nombres manuscrits (écrit à la main). En général, 60 000 images sont utilisées
pour la formation (l’apprentissage) et les 10 000 images restantes sont utilisées pour le test de
validation. Chaque image à chiffres est une image en noir et blanc de 28 x 28 pixels, comme
illustré à la figure suivante.
Fig 11. Base MNIST

Compte tenu du temps de formation (d’apprentissage), cet exemple n'utilise que 10 000
images avec les données de formation et les données de vérification dans un rapport 8 à 2. Par
conséquent, nous avons 8 000 images MNIST pour la formation et 2 000 images pour la
validation des performances du réseau neuronal. Comme vous le savez peut-être maintenant, le
problème MNIST consiste en la classification multiclasse de l'image de 28×28 pixels dans l'une
des dix classes de chiffres de 0 à 9. Ceci dans l’objectif est depermettre une reconnaissance
intelligente.
Prenons un ConvNet (réseau profond avec des convolution ) qui reconnaît les images du
MNIST. L'entrée étant une image en noir et blanc de 28×28 pixels, nous autorisons 784 (=
28x28) noeuds d'entrée. Le réseau d'extraction d'entités contient une seule couche de
convolution avec 20 filtres de convolution de 9×9. La sortie de la couche de convolution passe
par la fonction ReLU, suivie de la couche de regroupement (pooling). La couche de pooling
utilise le processus mean pooling de deux par deux. Le réseau neuronal de classification se
compose d'une seule couche cachée et d'une couche de sortie. Cette couche cachée a 100 nœuds
(neurones) qui utilisent la fonction d'activation ReLU. Puisque nous avons 10 classes à classer,
la couche de sortie est construite avec 10 nœuds. Nous utilisons la fonction d'activation softmax
pour les nœuds de sortie.
La figure suivante montre l'architecture de ce réseau de neurones. Bien qu'il comporte de
nombreuses couches, seules trois d'entre elles contiennent les matrices de poids qui nécessitent
une adaptation; ils sont W1, W5 et Wo dans les blocs carrés. W5 et Wo contiennent les poids
de connexion du réseau neuronal de classification, tandis que W1 est le poids de la couche
de convolution, qui est utilisé par les filtres de convolution pour le traitement d'image.
Fig.12 Architecture du réseau utilisé pour reconnaitre les chiffres.

En pratique ce réseau, après apprentissage, doit être utilisé en série avec une caméra.

Caméra Réseau ConvNet Reconnaissance

Fig. 13 Caméra Intelligente

Le code d’apprentissage et de teste :


Ce code a été expliqué en détail, ligne par ligne, durant le cours. D’autres explications sont
alors omises.

Fonction : MnistConv
1. function [W1, W5, Wo] = MnistConv(W1, W5, Wo, X, D)
2. %
3. %
4. alpha = 0.01;
5. beta = 0.95;
6. momentum1 = zeros(size(W1)); % revoir Activité 3
7. momentum5 = zeros(size(W5));
8. momentumo = zeros(size(Wo));
9. N = length(D);
10. bsize = 100;
11. blist = 1:bsize:(N-bsize+1);
12. % One epoch loop
13. %
14. for batch = 1:length(blist)
15. dW1 = zeros(size(W1));
16. dW5 = zeros(size(W5));
17. dWo = zeros(size(Wo));
18. % Mini-batch loop
19. %
20. begin = blist(batch);
21. for k = begin:begin+bsize-1
22. % Forward pass = inference
23. %
24. x = X(:, :, k); % Input, 28x28
25. y1 = Conv(x, W1); % Convolution, 20x20x20
26. y2 = ReLU(y1); %
27. y3 = Pool(y2); % Pool, 10x10x20
28. y4 = reshape(y3, [], 1); % 2000
29. v5 = W5*y4; % ReLU, 360
30. y5 = ReLU(v5); %
31. v = Wo*y5; % Softmax, 10
32. y = Softmax(v); %
33. % One-hot encoding
34. %
35. d = zeros(10, 1);
36. d(sub2ind(size(d), D(k), 1)) = 1;
37. % Backpropagation
38. %
39. e = d - y; % Output layer
40. delta = e;
41. e5 = Wo' * delta; % Hidden(ReLU) layer
42. delta5 = (y5 > 0) .* e5;
43. e4 = W5' * delta5; % Pooling layer
44. e3 = reshape(e4, size(y3));
45. e2 = zeros(size(y2));
46. W3 = ones(size(y2)) / (2*2);
47. for c = 1:20
48. e2(:, :, c) = kron(e3(:, :, c), ones([2 2])) .* W3(:, :, c);
49. end
50. delta2 = (y2 > 0) .* e2; % ReLU layer
51. delta1_x = zeros(size(W1)); % Convolutional layer
52. for c = 1:20
53. delta1_x(:, :, c) = conv2(x(:, :), rot90(delta2(:, :, c), 2),
54. 'valid');
55. end
56. dW1 = dW1 + delta1_x;
57. dW5 = dW5 + delta5*y4';
58. dWo = dWo + delta *y5';
59. end
60. % Update weights
61. %
62. dW1 = dW1 / bsize;
63. dW5 = dW5 / bsize;
64. dWo = dWo / bsize;
65. momentum1 = alpha*dW1 + beta*momentum1;
66. W1 = W1 + momentum1;
67. momentum5 = alpha*dW5 + beta*momentum5;
68. W5 = W5 + momentum5;
69. momentumo = alpha*dWo + beta*momentumo;
70. Wo = Wo + momentumo;
71. end
72. end

Script : TestMinistConv
1. clear all
2. Images = loadMNISTImages('./ t10k-images-idx3-ubyte/t10k-
images.idx3-ubyte');
3. Images = reshape(Images, 28, 28, []);
4. Labels = loadMNISTLabels('./ t10k-labels-idx1-ubyte/t10k-
labels.idx1-ubyte');
5. Labels(Labels == 0) = 10; % 0 --> 10
6. rng(1);
7. % Learning
8. %
9. W1 = 1e-2*randn([9 9 20]);
10. W5 = (2*rand(100, 2000) - 1) * sqrt(6) / sqrt(360 + 2000);
11. Wo = (2*rand( 10, 100) - 1) * sqrt(6) / sqrt( 10 + 100);
12. X = Images(:, :, 1:8000);
13. D = Labels(1:8000);
14. for epoch = 1:3
15. epoch
16. [W1, W5, Wo] = MnistConv(W1, W5, Wo, X, D);
17. end
18. save('MnistConv.mat');
19. % Test
20. %
21. X = Images(:, :, 8001:10000);
22. D = Labels(8001:10000);
23. acc = 0;
24. N = length(D);
25. for k = 1:N
26. x = X(:, :, k); % Input, 28x28
27. y1 = Conv(x, W1); % Convolution, 20x20x20
28. y2 = ReLU(y1); %
29. y3 = Pool(y2); % Pool, 10x10x20
30. y4 = reshape(y3, [], 1); % 2000
31. v5 = W5*y4; % ReLU, 360
32. y5 = ReLU(v5); %
33. v = Wo*y5; % Softmax, 10
34. y = Softmax(v); %
35. [~, i] = max(y);
36. if i == D(k)
37. acc = acc + 1;
38. end
39. end
40. acc = acc / N;
41. fprintf('Accuracy is %f\n', acc);

Script : PlotFeatures
% Ce code sert à visualiser les différentes couche du réseau de
% neurones.
clear all
load('MnistConv.mat')
k = 2;
x = X(:, :, k); % Input, 28x28
y1 = Conv(x, W1); % Convolution, 20x20x20
y2 = ReLU(y1); %
y3 = Pool(y2); % Pool, 10x10x20
y4 = reshape(y3, [], 1); % 2000
v5 = W5*y4; % ReLU, 360
y5 = ReLU(v5); %
v = Wo*y5; % Softmax, 10
y = Softmax(v); %
figure;
display_network(x(:));
title('Input Image')
convFilters = zeros(9*9, 20);
for i = 1:20
filter = W1(:, :, i);
convFilters(:, i) = filter(:);
end
figure
display_network(convFilters);
title('Convolution Filters')
fList = zeros(20*20, 20);
for i = 1:20
feature = y1(:, :, i);
fList(:, i) = feature(:);
end
figure
display_network(fList);
title('Features [Convolution]')
fList = zeros(20*20, 20);
for i = 1:20
feature = y2(:, :, i);
fList(:, i) = feature(:);
end
figure
display_network(fList);
title('Features [Convolution + ReLU]')
fList = zeros(10*10, 20);
for i = 1:20
feature = y3(:, :, i);
fList(:, i) = feature(:);
end
figure
display_network(fList);
title('Features [Convolution + ReLU + MeanPool]')

Conclusion

Ce chapitre a présenté l’apprentissage profond, les réseaux profonds, les réseaux


convolutifs, la reconnaissance d’image et a donné les codes Matlab nécessaires à
l’apprentissage. Ce même processus peut être utilisé pour le diagnostic des maladies, détection
intelligente des tumeurs, la reconnaissance intelligente d’objet pour une voiture, le diagnostic
des pièces fabriquées en industrie…
Le chapitre suivant présente l’application du deeplearning sur le son. On présentera aussi
des architectures pratiques en mode réel pour la conception d’une caméra capable de
reconnaitre des objets et un microphone capable de reconnaitre la voix.

Vous aimerez peut-être aussi