Université de Béjaia Capteurs Intelligents Chapitre 4

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 ?

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

Interface

Intelligente

Capteur

(Caméra,

microphone …)

Base de données

Apprentissage

Extraction de

l’information

désirée

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,

https://www.futura-sciences.com/sante/definitions/biologie-neurone-209/

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;


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. %%


21. mmt1 = dW1 + beta*mmt1;

22. W1 = W1 + mmt1;


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;


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 :


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. %%%%%%%%%%%%%


20. W1 = W1 + dW1;


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;


29. v = W12*y1;

30. y = Sigmoid(v);

31. es1 = es1 + (d - y)^2;

32. v1 = W21*x;


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 :

𝛹(𝑣) = max(𝑉, 0) = {𝑣 𝑠𝑖 𝑣 > 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;


25. W4 = W4 + dW4;

26. dW3 = alpha*delta3*y2';

27. W3 = W3 + dW3;

28. dW2 = alpha*delta2*y1';

29. W2 = W2 + dW2;


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;


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.

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

Caméra Réseau ConvNet Reconnaissance

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]')


for i = 1:20



end

figure


title('Features [Convolution + ReLU]')


for i = 1:20



end

figure


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.

Université de Béjaia Capteurs Intelligents Chapitre 4

Documents

Transcript of Université de Béjaia Capteurs Intelligents Chapitre 4