Chapitre 6 - Université de Moncton

Transcription

GIND5439
Systèmes Intelligents
Chapitre 6: Réseaux de neurones.
Apprentissage machine

Comprend des mécanismes adaptifs qui permettent
à un ordinateur:

D’apprendre par expérience
D’apprendre par exemples
D’apprendre par analogie
Les capacités d’apprentissage peuvent améliorer la
performance d’un système intelligent au fil du
temps.
Les deux approches populaires sont:

Réseaux de neurones
Algorithme génétique
GIND5439 – Gabriel Cormier, Université de Moncton
2
Qu’est-ce qu’un réseau de neurones?

C’est un modèle de raisonnement basé sur le
cerveau humain.
Le cerveau est constitué d’un ensemble de cellules
nerveuses, ou unités de traitement d’information,
appelés neurones.
Cerveau

Près de 10 milliards de neurones
60 trillions de connexions, des synapses, entre eux.
Un neurone est constitué de:

Un corps de cellule, le soma
Un nombre de fibres appelés dendrites
Un fibre long appelé axone.
3
Réseau de neurones biologique
Synapse
Axon
Soma
Dendrites
Synapse
Axon
Soma
Dendrites
Synapse
4

C’est un ensemble de processeurs très simples,
appelés neurones.
Les neurones sont branchés ensemble à l’aide de
liens pondérés qui passent des signaux d’un
neurone à un autre.
Le signal de sortie est transmis à travers la
connexion de sortie du neurone.
La sortie se divise en un nombre de branches qui
transmettent tous le même signal.
Les branches de sortie se terminent à l’entrée de
d’autres neurones dans le réseau.
5

Chaque neurone reçoit un nombre de
signaux d’entrée xi à travers ses connexions.
Un ensemble de poids réels wi sont utilisés
pour décrire la force de la connexion.
Le niveau d’activation Σxiwi détermine la
force cumulative des signaux d’entrée.
Une fonction seuil f calcule l’état final de la
sortie. Ça simule le comportement ON/OFF
de neurones réels.
6

Chaque neurone produit une seule sortie.
Le signal de sortie est transmis à travers la
connexion de sortie du neurone.
La connexion de sortie se sépare en un
nombre de branches

Le même signal se propage sur chaque branche.
Les branches de sortie se terminent aux
connexions d’entrée de d’autre neurones.
7

Chaque réseau est aussi caractérisé par des
propriétés globales tel que:

Topologie du réseau
Algorithme d’apprentissage
Technique d’encodage
8
Signaux de sortie
Signaux d’entrée
Architecture typique d’un réseau de
neurones.
Niveau intermédiaire
Niveau d’entrée
Niveau de sortie
9
Équivalences
Réseau de neurones
biologique
Soma
Réseau de neurones
artificiel
Neurone
Dendrite
Entrée
Axon
Sortie
Synapse
Poids
10
Neurone McCulloch-Pitts

Les entrées sont excitatrices (+1) ou inhibitrices (-1)
La fonction d’activation multiplie chaque entrée par
son poids correspondant et fait la somme du
résultat.
Si le résultat est > 0, la sortie du neurone est 1;
sinon -1.
On a démontré que ces neurones peuvent être
construites pour calculer n’importe quelle fonction
logique.
On a démontré qu’un système de ces neurones
peut produire un modèle informatique complet.
11
Le neurone
Entrées
Poids
Sorties
x1
Y
w1
x2
w2
Neurone
wn
xn
Y
Y
Y
12
Calcul de la sortie

Le neurone calcul la somme pondérée des entrées et compare le
résultat avec la valeur seuil θ.
Si l’entrée nette est moins que la valeur seuil, la sortie du neurone
est -1.
Si l’entrée nette est plus grande que la valeur seuil, le neurone est
activé et la sortie est +1.
La fonction d’activation (ou fonction de transfert) du neurone est:
n
X = ∑ xi wi
i =1

⎧+ 1, si X ≥ θ
Y =⎨
⎩− 1, si X < θ
Ce type de fonction est la fonction sign.
13
Fonctions d’activation
Step function
Linear function
Y
Y
Y
Y
+1
+1
+1
+1
0
X
-1
Y
Sigmoid function
Sign function
step ⎧1, if X ≥ 0
=⎨
⎩0, if X < 0
0
-1
0
X
⎩−1, if X < 0
X
-1
-1
sign ⎧+1, if X ≥ 0 Y sigmoid=
Y
=⎨
0
X
1
1+ e− X
Y linear= X
14
Apprentissage d’un neurone

Est-ce qu’un seul neurone peut apprendre
une tâche?

Le Perceptron

1958, Frank Rosenblatt
Basé sur le modèle de McCulloch-Pitts
Un algorithme d’apprentissage qui a produit la première
procédure pour entraîner un réseau de neurones.
La forme la plus simple d’un réseau de neurones.
Est constitué d’un seul neurone avec des poids
ajustables et un limiteur brusque: fonction échelon
ou sign.
15
Perceptron à un seul niveau, 2 entrées
Entrées
x1
w1
Combineur Limiteur
linéaire
brusque
∑
w2
x2
Sortie
Y
θ
Seuil
16
Perceptron

La somme pondérée des entrées est
appliquée au limiteur brusque qui produit une
sortie de +1 si l’entrée est positive et -1 si
l’entrée est négative.
Le but est de classifier les entrées, les stimuli
externes x1, x2, …, xn, en l’une de deux
classes A1 et A2.
17
Perceptron

Comment le perceptron apprend-t-il sa tâche de
classification?

On utilise une forme d’apprentissage supervisé.
De faibles ajustements sont fait aux poids pour réduire la
différence entre la sortie réelle et la sortie désirée.
Les poids initiaux sont assignés de façon aléatoire,
typiquement entre -0.5 et +0.5.
Après un essai pour résoudre le problème, un
« enseignant » donne le résultat correct.
Les poids sont ensuite modifiés pour réduire l’erreur.
18
Apprentissage du perceptron

Si, à une itération p, la sortie réelle est Y(p)
et la sortie voulue est Yd(p), alors l’erreur est:
e( p ) = Yd ( p ) − Y ( p )

où p = 1, 2, 3K
L’itération p représente le pième exemple
d’entraînement présenté au perceptron.
Si l’erreur e(p) est positive, il faut augmenter
la sortie Y(p) du perceptron; si l’erreur est
négative, il faut diminuer la sortie.
19
Règle d’apprentissage du perceptron
wi ( p + 1) = wi ( p ) + α ⋅ xi ( p ) ⋅ e( p )
Où
p = 1, 2, 3, …
α est le taux d’apprentissage, 0 < α < 1
En utilisant cette règle, on peut construire un
algorithme d’apprentissage pour des tâches de
classification.
20

Étape 1: initialisation

On crée les poids initiaux w1, w2, …, wn et le seuil
θ à des valeurs aléatoires dans l’intervalle [-0.5,
0.5].
Rappel: Si l’erreur e(p) est positive, il faut
augmenter la sortie Y(p) du perceptron; si l’erreur
est négative, il faut diminuer la sortie.
21

Étape 2: activation

On active le perceptron en y appliquant les
entrées x1(p), x2(p), …, xn(p), et la sortie voulue
Yd(p). On calcule la sortie réelle à l’itération p = 1.
⎡ n
⎤
Y ( p ) = step ⎢ ∑ x i ( p ) w i ( p ) − θ ⎥
⎢⎣ i = 1
⎥⎦
où n est le nombre d’entrées du perceptron, et
step est une fonction d’activation échelon.
22

Étape 3: Mise à jour du poids

On met à jour le poids du perceptron:
wi ( p + 1) = wi ( p ) + ∆wi ( p )

où ∆wi est la correction au poids à l’itération p.
La correction au poids est:
∆wi ( p) = α ⋅ xi ( p) ⋅ e( p )

Étape 4: Prochaine itération (p = p + 1), on retourne
à l’étape 2, et on continue jusqu’à ce qu’on
converge.
23
Est-ce qu’un perceptron peut réaliser les
opérations logiques de base?
Entrée
x1
Entrée
x2
AND
x1 ∩ x2
OR
x1 ∪ x2
XOR
x1 ⊕ x2
0
0
0
0
0
0
1
0
1
1
1
0
0
1
1
1
1
1
1
0
24
Apprentissage du perceptron: AND
Époch
Entrées
x1
x2
1
0
0
1
1
0
1
0
1
2
0
0
1
1
3
Sortie
voulue Yd
Poids initial
Sortie
réelle Y
Erreur
w1
w2
0
0
0
1
0.3
0.3
0.3
0.2
-0.1
-0.1
-0.1
-0.1
0
0
1
0
0
1
0
1
0
0
0
1
0.3
0.3
0.3
0.2
0.0
0.0
0.0
0.0
0
0
1
1
0
1
0
1
0
0
0
1
0.2
0.2
0.2
0.1
4
0
0
1
1
0
1
0
1
0
0
0
1
5
0
0
1
1
0
1
0
1
0
0
0
1
Poids final
w1
w2
0
0
-1
1
0.3
0.3
0.2
0.3
-0.1
-0.1
-0.1
0.0
0
0
1
1
0
0
-1
0
0.3
0.3
0.2
0.2
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0
0
1
0
0
0
-1
1
0.2
0.2
0.1
0.2
0.0
0.0
0.0
0.1
0.2
0.2
0.2
0.1
0.1
0.1
0.1
0.1
0
0
1
1
0
0
-1
0
0.2
0.2
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0
0
0
1
0
0
0
0
0.1
0.1
0.1
0.1
0.1
0.1
0.1
0.1
Seuil: θ = 0.2; Taux d’apprentissage: α = 0.1
25
Représentation des opérations de base
x2
x2
x2
1
1
1
x1
x1
0
1
(a) AND (x 1 ∩ x 2 )
0
x1
1
(b) OR (x 1 ∪ x 2 )
0
1
(c) Exclusive -OR
(x 1 ⊕ x 2 )
Un perceptron peut apprendre AND et OR, mais pas XOR.
26
Pourquoi?

Ça provient directement de l’équation
n
X = ∑ xi wi
i =1

⎧+ 1, si X ≥ θ
Y =⎨
⎩− 1, si X < θ
La sortie Y est 1 seulement si la somme
pondérée totale X est plus grande ou égale à
la valeur seuil θ.
L’espace d’entrée doit être divisé en deux le
long d’une frontière définie par X = θ.
27
Fonctions d’activation

Est-ce qu’une fonction sigmoïde ou linéaire
permettrait de réaliser XOR?

Un perceptron à un seul niveau fait des décisions
de la même façon peu importe la fonction
d’activation.
Minsky et Papert (1969) ont démontré que le
perceptron de Rosenblatt ne peut pas faire des
généralisations globales basé sur des exemples
locaux.
28
Réseaux de neurones multi-niveau

Un perceptron à plusieurs niveaux est un
réseau à réaction directe ayant un ou
plusieurs niveaux cachés.
Le réseau est constitué de:

Un niveau d’entrée
Au moins 1 niveau intermédiaire ou caché de
neurones
Un niveau de sortie
Les entrées se propagent vers l’avant (la
sortie) niveau par niveau.
29
Réseau de neurones à 2 niveaux
30
Niveau intermédiaire

Que cache le niveau intermédiaire?

Les neurones dans le niveau intermédiaire

Ne peuvent pas être observés à partir du comportement
entrée/sortie du réseau.
Les poids des neurones intermédiaires représentent des
entités cachées.
Les entités sont utilisés dans le niveau de sortie pour
déterminer la sortie.
31
Apprentissage dans réseaux multi-niveau

Propagation arrière (Bryson et Ho, 1969)
Un ensemble d’entrées est présenté au
réseau.
Le réseau calcule les sorties, et s’il y a une
erreur (une différence entre la sortie réelle et
la sortie voulue), les poids sont ajustés pour
réduire cette erreur.
32
Apprentissage dans des réseaux multiniveau

L’apprentissage est déterminé par:

Connexions entre les neurones (architecture)
Les fonctions d’activation utilisées par les
neurones.
L’algorithme d’apprentissage qui spécifie la
procédure pour ajuster les poids.
33

Dans un réseau de neurones à propagation arrière,
l’algorithme d’apprentissage a deux phases:

Un ensemble d’entrées d’entraînement est présenté au
niveau d’entrée.
Le réseau propage ces entrées niveau par niveau jusqu’à
ce qu’une (ou des) sortie soit générée.
Si la sortie est différente de la sortie voulue, une erreur est
calculée et puis propagée dans le réseau de la sortie vers
l’entrée.
Les poids sont ajustés au fur et à mesure que l’erreur se
propage.
34
Réseaux à 3 niveaux, propagation arrière
Entrées
1
x1
x2
xi
y1
2
y2
k
yk
l
yl
1
2
2
i
1
wij
j
wjk
m
n
xn
Niveau d’entrée
Niveau caché
Niveau de sortie
Erreurs
35

On calcule le poids net comme avant:
n
X = ∑ xi wi − θ
i =1

On passe ensuite cette valeur à la fonction
d’activation: fonction sigmoïde.
Y
sigmoïde
1
=
1 + e− X
36
Présenter les entrées et déterminer les valeurs
des niveaux cachés et du niveau de sortie.
2. Comparer les résultats du niveau de sortie aux
résultats corrects.
3. Modifier les poids du niveau d’entrée et des
niveaux cachés pour réduire l’erreur.
4. La règle utilisée pour modifier les poids se nomme
règle delta, parce qu’elle change chaque poids
selon sa pondération par rapport à la sortie.
1.
1.
Le delta, ou dérivée partielle de la sortie par rapport au
poids.
37

La plupart des réseaux de neurones multi-niveau
fonctionnent avec des entrées qui varient de 0 à 1.
Les poids varient à chaque itération d’une fraction
du changement nécessaire pour corriger l’erreur à la
sortie. Cette fraction, α, est le taux d’apprentissage.

Si le taux d’apprentissage est trop élevé, l’algorithme prend
des grands pas et risque de manquer le point d’erreur
minimale, ou même osciller autour du minimum.
Des petits pas, qui viennent d’un taux d’apprentissage
petit, trouveront éventuellement un minimum, mais risquent
de prendre beaucoup de temps.
38
Paramètres d’apprentissage

Taux d’apprentissage
Contrôle l’amplitude des pas utilisés pour ajuster les poids. Dans
certains réseaux de neurones, diminue avec le nombre
d’itérations.
Momentum
Propagation arrière
Lissage de l’effet des ajustements aux poids au fil des itérations.
Tolérance (erreur)
Propagation arrière
Spécifie la différence acceptable entre la sortie réelle et la sortie
voulue.
Fonction d’activation
La fonction utilisée à chaque neurone pour générer la sortie à
partir des entrées pondérés. La fonction la plus commune est la
fonction sigmoïde.
39
Algorithme d’apprentissage, propagation
arrière

Étape 1: Initialisation

On règle tous les poids et seuils du réseau à une
valeur aléatoire dans l’intervalle:
⎛ 2. 4
2. 4 ⎞
⎜⎜ −
⎟⎟
, +
Fi ⎠
⎝ Fi

Où Fi est le nombre total d’entrées au neurone i
dans le réseau. L’initialisation des poids n est faite
neurone par neurone.
40
arrière

Étape 2: Activation

On active le réseau de neurone à propagation arrière en y
appliquant les entrées x1(p), x2(p), …, xn(p), et les sorties
voulues yd1(p), yd2(p), …, ydn(p),
⎤
⎡ n
y j ( p ) = sigmoid ⎢ ∑ x i ( p ) ⋅ w ij ( p ) − θ j ⎥
⎦
⎣ i =1

On calcule les sorties des neurones dans les niveaux
cachés

Où n est le nombre d’entrées au neurone j dans le niveau
caché, et sigmoid est la fonction sigmoïde.
41
arrière

Étape 2 (suite)

On calcule la sortie des neurones du niveau de
sortie:
⎤
⎡m
y k ( p ) = sigmoid ⎢ ∑ x jk ( p ) ⋅ w jk ( p ) − θ k ⎥
⎥⎦
⎢⎣ j =1
où m est le nombre d’entrées du neurone k dans
le niveau de sortie.
42
arrière

Étape 3: Poids

On ajuste les poids dans le réseau à propagation arrière
qui propage vers l’arrière les erreurs.
Calculer le gradient d’erreur pour les neurones du niveau
de sortie:
δ k ( p ) = yk ( p ) ⋅ [1 − yk ( p )]⋅ ek ( p )
où

e k ( p ) = y d ,k ( p ) − y k ( p )
Calculer les corrections aux poids.
∆w

jk
( p) = α ⋅ y j ( p) ⋅δ k ( p)
Ajuster les poids aux neurones de sortie.
w jk ( p + 1) = w jk ( p ) + ∆ w jk ( p )
43
arrière

Étape 3 (suite)

Calculer le gradient d’erreur pour les neurones
dans le niveau caché:
l
δ j ( p ) = y j ( p ) ⋅ [1 − y j ( p ) ] ⋅ ∑ δ k ( p ) w
k =1

jk
( p)
Calculer les corrections aux poids:
∆ w ij ( p ) = α ⋅ x i ( p ) ⋅ δ j ( p )

Ajuster les poids aux neurones cachés:
w ij ( p + 1) = w ij ( p ) + ∆ w ij ( p )
44
arrière

Étape 4: Itération

On augmente l’itération p de 1 (p = p + 1), on
retourne à l’étape 2 et on refait le processus
jusqu’à ce que le critère d’erreur soit satisfait (ex:
erreur plus petite que 0.1%).
45
Exemple: propagation arrière

On utilise ici un réseau simple à 3 niveaux
pour apprendre la fonction XOR:
Entrée 1
Entrée 2
Sortie
0
0
0
0
1
1
1
0
1
1
1
0
C’est l’exemple p.178 – 181 du manuel.
46
-1
θ3
x1
1
w13
3
-1
w35
w23
θ5
5
w14
x2
2
w24
y5
w45
4
θ4
-1
Dans ce réseau, les neurones 1 et 2
du niveau d’entrée n’ont aucun effet
et ne font que passer l’entrée au
niveau 2.
47

Les poids initiaux et niveaux seuils sont créés
aléatoirement. Pour cet exemple, on obtient:

w13 = 0.5, w14 = 0.9, w23 = 0.4, w24 = 1.0,
w35 = -1.2, w45 = 1.1
θ3 = 0.8, θ4 = -0.1, θ5 = 0.3
On suppose un taux d’apprentissage α = 0.1
On prend ici un exemple d’entraînement où
les deux entrées x1 et x2 sont 1. La sortie
voulue yd,5 est donc 0 (fonction XOR).
48

On calcul maintenant la sortie des neurones
3 et 4 (puisque 1 et 2 n’ont aucun effet):
y3 = sigmoid ( x1w13 + x2 w23 − θ 3 ) =
y4 = sigmoid ( x1w14 + x2 w24 − θ 4 ) =

1+ e
1
= 0.5250
1
= 0.8808
− (1×0.5+1×0.4 − 0.8 )
1+ e
− (1×0.9 +1×1.0 + 0.1)
Et la sortie réelle du neurone 5:
y5 = sigmoid ( y3 w35 + y4 w45 − θ 5 ) =
1
1+ e
− (0.5250×( −1.2 ) + 0.8808×1.1− 0.3 )
= 0.5097
49

L’erreur peut maintenant être calculée:
e = yd ,5 − y5 = 0 − 0.5097 = −0.5097

La prochaine étape est de propager cette
erreur vers l’arrière pour modifier les poids et
niveaux seuils.
50

On calcule en premier le gradient d’erreur δ:
δ 5 = y5 (1 − y5 )e = 0.5097(1 − 0.5097 )(− 0.5097 ) = −0.1274

On modifie maintenant les poids et le niveau
seuil:
∆w35 = α × y3 × δ 5 = (0.1)(0.5250 )(− 0.1274 ) = −0.0067
∆w45 = α × y4 × δ 5 = (0.1)(0.8808)(− 0.1274 ) = −0.0112
∆θ 5 = α × (− 1)× δ 3 = (0.1)(− 1)(− 0.1274 ) = −0.0127
51

On calcule maintenant le gradient d’erreur
pour les neurones 3 et 4:
δ 3 = y3 (1 − y3 )δ 5 w35 = 0.5250(1 − 0.5250)(− 0.1274)(− 1.2) = 0.0381
δ 4 = y4 (1 − y4 )δ 5 w45 = 0.8808(1 − 0.8808)(− 0.1274)(1.1) = −0.0147

Ces valeurs seront maintenant utilisées pour
ajuster les poids des neurones 3 et 4.
52

On calcule les variations des poids pour les
neurones 3 et 4:
∆w13
∆w23
∆θ 3
∆w14
= α × x1 × δ 3 = (0.1)(1)(0.0381) = 0.0038
= α × x2 × δ 3 = (0.1)(1)(0.0381) = 0.0038
= α × (− 1)× δ 3 = (0.1)(− 1)(0.0381) = −0.0038
= α × x1 × δ 4 = (0.1)(1)(− 0.0147 ) = −0.0015
∆w24 = α × x2 × δ 4 = (0.1)(1)(− 0.0147 ) = −0.0015
∆θ 4 = α × (− 1)× δ 4 = (0.1)(− 1)(− 0.0147 ) = 0.0015
53
Exemple: propagation

La dernière étape est de mettre à jour les poids:
w13 = w13 + ∆w13 = 0.5 + 0.0038 = 0.5038
w14 = w14 + ∆w14 = 0.9 − 0.0015 = 0.8985
w23 = w23 + ∆w23 = 0.4 + 0.0038 = 0.4038
w24 = w24 + ∆w24 = 1.0 − 0.0015 = 0.9985
w35 = w35 + ∆w35 = −1.2 − 0.0067 = −1.2067
w45 = w45 + ∆w45 = 1.1 − 0.0112 = 1.0888
θ 3 = θ 3 + ∆θ 3 = 0.8 − 0.0038 = 0.7962
θ 4 = θ 4 + ∆θ 4 = −0.1 + 0.0015 = −0.0985
θ 5 = θ 5 + ∆θ 5 = 0.3 + 0.0127 = 0.3127

On répète le processus jusqu’à ce que la somme
des erreurs au carré soit plus petite que 0.001.
54
On obtient une solution après 224 époch.
55

Résultats:

w13 = 4.7621, w14 = 6.3917, w23 = 4.7618,
w24 = 6.3917, w35 = -10.3788, w45 = 9.7691
θ3 = 7.3061, θ4 = 2.8441, θ5 = 4.5589
Il a fallu entraîner le réseau pour 224
époques (epoch) avec les 4 entrées, pour
obtenir la solution.
56
Entrées
x1
x2
Sortie
voulue
yd
Sortie
réelle
y5
Erreur
0
0
0
0.0155 -0.0155
0
1
1
0.9849
0.0151
1
0
1
0.9849
0.0151
1
1
0
0.0175 -0.0175
e
Somme
des
erreurs
0.0010
57
Overfitting

Le « overfitting » arrive quand le réseau de
neurones apprend les détails spécifiques des
entrées et non pas leur caractéristique générale
trouvée dans les données présentes et futures.
Deux causes possibles:

Entraînement trop long. Solution:

Tester contre un ensemble de données différentes de temps
en temps.
Arrêter quand les résultats commencent à devenir pires.
Trop de nœuds cachés

Un nœud peut modéliser une fonction linéaire.
Plusieurs nœuds peuvent modéliser des fonctions d’ordre
supérieur, ou plusieurs ensembles d’entrées.
Trop de nœuds vont modéliser les données trop près,
empêchant donc la généralisation.
58
Récolte de données

Les données d’apprentissages contiennent
un nombre de cas:

Contient des valeurs pour une gamme de
variables d’entrées et de sorties.
On doit décider

Combien de variables utiliser
Combien (et quels) de cas à récolter.
59

Les réseaux de neurones traitent des
données numériques dans une gamme assez
limitée.
Données manquantes?

On substitue la valeur moyenne des autres
ensembles de données (ou une autre statistique).
Données non-numériques

On assigne une valeur nominale
60

On choisit des variables qu’on pense être critiques.
Des variables numériques et nominales peuvent être traitées.
On convertit d’autres variables en l’une de ces formes.
Des centaines ou milles cas sont nécessaires; plus il y a de
variables, plus il faut de cas.
Des cas ayant des données manquantes peuvent être utilisés, si
nécessaire, mais des données aberrantes peuvent causer des
problèmes.
Enlever les données aberrantes si possible.
Si on a assez de données, éliminer les cas ayant des données
manquantes.
Si la quantité de données disponibles est petite, on peut
considérer l’utilisation d’ensemble.
61
Réseau Hopfield

Les réseaux de neurones furent développés par
analogie au cerveau humain.
La mémoire du cerveau, cependant, fonctionne par
association.
Par exemple, on peut reconnaître des visages
familiers dans un environnement nouveau dans
100-200ms. On peut aussi se souvenir d’une
expérience sensorielle, incluant des sons et scènes,
quand on entend que quelques notes de musique.
Le cerveau associe régulièrement une chose à une
autre.
62
Réseau Hopfield

Les réseaux de neurones à niveaux multiples
entraînés par l’algorithme de propagation
arrière sont utilisés dans des problèmes de
reconnaissance de formes.
Pour simuler le comportement de la mémoire
humaine, on a besoin d’un différent type de
réseau: un réseau de neurones récurrent.
Un réseau de neurones récurrent a des
boucles de feedback entre les sorties et les
entrées.
63
x1
1
y1
x2
2
y2
xi
i
yi
xn
n
yn
Sorties
Entrées
Réseau Hopfield à 1 niveau, n neurones
64
Réseau Hopfield

Utilise des neurones du type McCulloch-Pitts
avec une fonction d’activation sign.

Si l’entrée pondérée < 0 alors la sortie = -1
Si l’entrée pondérée > 0 alors la sortie = +1
Si l’entrée pondérée = 0 alors la sortie ne change
pas.
Y sign
⎧+ 1 si X > 0
⎪
= ⎨− 1 si X < 0
⎪Y si X = 0
⎩
65
Réseau Hopfield

L’état présent du réseau Hopfield est
déterminé par la sortie présente de tous les
neurones, y1(p), y2(p), …, yn(p).
Donc, pour un réseau à un seul niveau ayant
n neurones, l’état peut être défini par un
vecteur d’état:
y
⎡ 1
⎢ y
2
⎢
Y =
⎢ M
⎢
⎢⎣ y n
⎤
⎥
⎥
⎥
⎥
⎥⎦
66
Réseau Hopfield

Dans un réseau Hopfield, les poids entre les
neurones sont typiquement représentés sous forme
de matrice:
W=
où

M
T
Y
Y
∑ m m −M I
m=1
M est le nombre d’états à être mémorisés par le réseau
YM est le vecteur binaire de dimension n
I est la matrice identité de dimension n x n
L’indice T veut dire la transposée
67
États possibles, réseau Hopfield
y2
(−1, 1, −1)
(1, 1, −1)
(−1, 1, 1)
(1, 1, 1)
y1
0
(1, −1, −1)
(−1, −1, −1)
(−1, −1, 1)
(1, −1, 1)
y3
68
Utilité des réseaux de neurones

Analyse des investissements

Analyse de signature

Pour prédire le mouvement des actions (stocks),
monnaies, etc à partir de données précédentes.
Comme mécanisme pour comparer des
signatures sur des chèques.
Prévision de la quantité de pluie

Permet aux fermiers d’optimiser la récolte;
prévisions de sécheresse, niveau d’eau dans des
rivières.
69
Utilisation des réseaux de neurones

Industrie

Prévision de la demande des consommateurs;
permet de réduire l’entreposage.
Surveillance

Surveillance des défaillances dans les moteurs
d’avions.
70

Quand est-il utile d’utiliser un réseau de neurones?

Un des avantages principaux des réseaux de neurones par
rapport aux autres systèmes (règles, logique floue, etc.) est
qu’ils nécessitent moins d’input des experts.

Dans certains cas il peut être très difficile de parler à un
expert; ex: on ne peut pas passer 2 heures à parler avec un
expert en échanges d’obligations ; ça coûterait des millions de
dollars à son employeur.
Un bénéfice des réseaux de neurones est qu’ils trouvent
souvent des relations entre les données sans avoir besoin
d’input d’un expert, si on a des données appropriées.
71

Les réseaux de neurones sont excellents lorsqu’il
s’agit de modéliser des données incomplètes ou
contenant du bruit, comme c’est souvent le cas avec
des données réelles. Les réseaux de neurones
traitent ce sorte de problèmes souvent mieux que
les méthodes statistiques.
Cependant, ceci ne veut pas dire qu’il suffit juste de
ramasser de l’information et entraîner le réseau pour
obtenir de bons résultats.
Il faut s’assurer que l’information récoltée est bien
inspectée et présentée de façon convenable au
réseau.
72

Les réseaux de neurones sont excellents pour
trouver des relations subtiles entre les données, ce
qui peut être un avantage et un désavantage.

Ex: une équipe de recherche voulait entraîner un réseau de
neurones à détecter des chars d’assaut dans des photos.
Le réseau devait détecter s’il y avait des chars ou non dans
des photos. Des photos furent prises avec des chars et
sans des chars, puis converties en format lisible par le
réseau de neurones. Le réseau fut entraîné, et fonctionnait
à merveille pour distinguer entre les deux groupes de
photos. Cependant, le réseau donnait de très mauvais
résultats quand de nouvelles photos étaient présentées.
73

Finalement, les chercheurs se sont aperçus que
les photos avec des chars furent prisent quand il
faisait soleil, tandis que les photos sans chars
furent prisent quand le temps était nuageux. Le
réseau avait apprit à distinguer entre des jours
ensoleillés ou nuageux, et non entre des photos
avec chars ou pas.
74
Exemple d’application

On fera ici un exemple d’utilisation des
réseaux de neurones pour distinguer des
formes, plus spécifiquement des chiffres.
On utilisera la boîte à outil Neural Networks
de Matlab.
75

On doit reconnaître 3 chiffres (1, 2 et 3):
76

Il faut rendre ces données disponibles de
façon informatique: on va faire une
pixelisation des images:
77

On a choisit une grille 5×4 pour pixeliser les
images. On aurait pu choisir quelque chose
avec plus de pixels, mais ceci augmente le
nombre d’entrées.
Avec cette grille 5×4, comme entrée, un point
noir représentera un 1, et un point jaune
représentera un 0. On a donc 20 entrées au
réseau de neurones.
78

L’entrée sera donc composée de 20 « bits »,
de valeur 0 ou 1.
Exemple, entrée 1:
input1 = [ 0; 0; 1; 0; 0; 0; 1; 0; 0; 0; 1; 0; 0; 0; 1; 0; 0; 0; 1; 0;];

Bit 1
1
2
3
4
5
6
7
8
9
10 11 12
13 14 15 16
Les pixels 3, 7, 11, 15
et 19 ont la valeur 1.
Les autres ont la
valeur 0.
17 18 19 20
79

On refait le processus de pixelisation pour les deux
autres entrées:

input2 = [ 1; 1; 1; 1; 0; 0; 0; 1; 1; 1; 1; 1; 1; 0; 0; 0; 1; 1; 1; 1;];
input3 = [ 1; 1; 1; 1; 0; 0; 0; 1; 1; 1; 1; 1; 0; 0; 0; 1; 1; 1; 1; 1;];
Il faut maintenant créer le réseau de neurones:

net = newff([0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1; 0
1; 0 1; 0 1; 0 1; 0 1; 0 1; 0 1],[5 2],{'logsig','logsig'});
On crée un réseau à deux niveaux, où les entrées varient
entre 0 et 1. Le premier niveau a 5 neurones, le deuxième
niveau en a 2 (2 sorties). La fonction d’activation utilisée
est « logsig ».
80

Pourquoi y a-t’il 2 sorties?

On va coder la sortie de façon binaire:

00 représente un 0 (le réseau détecte un « 0 »)
On aura aussi pu utiliser un autre codage à la
sortie:

000 représente 0
001 représente 1
010 représente 2
100 représente 3
81

On spécifie quelques paramètres:

net.trainParam.goal = 1e-10;
net.trainParam.epochs = 200;
Soit le but (somme des erreurs = 1e-10) et le
nombre maximal d’époques: 200.
On entraîne maintenant le réseau:

input = [input1 input2 input3];
target = [1 0 1; 0 1 1];
net = train(net,input,target);
82
Performance is 2.96561e-011, Goal is 1e-010
0
10
-2
Training-Blue Goal-Black
10
-4
10
-6
10
-8
10
-10
10
0
2
4
6
8
10
12
21 Epochs
14
16
18
20
Entraînement du réseau de neurones.
83

On vérifie la sortie réelle avec les entrées
d’entraînement:

output = sim(net,input)
On obtient:

output =
1.0000
0.0000
0.0000
1.0000
1.0000
1.0000
« 01 » veut dire que le
réseau détecte un 1
84

On vérifie maintenant la performance du
réseau avec des entrées un peu différentes:
85

On obtient comme résultat:

test1 = [ 0; 0; 1; 0; 0; 1; 1; 0; 0; 0; 1; 0; 0; 0; 1; 0; 0; 1; 1; 1;];
output1 = sim(net,test1)
test2 = [ 1; 1; 1; 0; 0; 0; 0; 1; 0; 1; 1; 0; 1; 0; 0; 0; 1; 1; 1; 1;];
test3 = [ 1; 1; 1; 1; 0; 0; 0; 1; 0; 1; 1; 0; 0; 0; 0; 1; 1; 1; 1; 0;];
Résultats:

output1 = 0.0002
output2 = 1.0000
output3 = 0.9999
1.0000 “c’est comme un 1”
86

Si on entraîne le réseau avec d’autres
données, est-ce que la performance sera la
même?
87

Dans ce cas-ci, on obtient la même performance:

output1 =
1.0000
0.0016
output2 =
0.0000
1.0000
output3 =
1.0000
1.0000
88