- L'apprentissage non supervisé (lors de la phase d'apprentissage, on ne dispose que de l'Entrée; mais il est nécessaire de faire une étape de labélisation (qui est en quelque sorte une étape de supervisation) )
- L'apprentissage supervisé (lors de la phase d'apprentissage, on a un couple (Entrée(s)/Sortie(s) ;-)
I] Apprentissage non supervisé :
La loi de Hebb (1949) : "Si 2 cellules sont activées en même temps, alors la force de la connexion augmente." est à la base de l'apprentissage non supervisé !
Prenons deux neurones :
i : le neurone amont (ou présynaptique)
j : le neurone aval (ou post-synaptique)
wij : le poids de la connexion.
La modification du poids wij dépend de l'activation des deux neurones.
Par exemple, dans le tableau suivant : - Xi : valeur d'activation du neurone i
- Xj : valeur d'activation du neurone j
- sWij : modification apportée au poids !
La loi de Hebb peut s'écrire sous forme d'équations :
(
Wij(t+1) est le nouveau poids,
Wij(t) est l'ancien poids)
L'algorithme modifie le poids, de manière itérative, seulement quand il y a erreur :
1/ Initialisation des poids et du seuil S à des valeurs (petites) choisies au hasard.
2/ Présentation d'une entrée El = (E1, E2, ..., En) de la base d'apprentissage. (l est l'indice de l'entrée dans la base d'apprentissage.)
3/ Calcul de la sortie (x) obtenue pour cette entrée :
a = Somme (Wi * Ei) - S (S est la valeur de seuil !)
x = Signe (a) ( si a > 0 alors x = +1, sinon a = 0, alors x = -1 )
4/ Si la sortie x est différente de la sortie désirée Sl pour l'exemple d'entrée El alors il y a modification des poids :
Wij(t+1) = Wij(t) + µ*(Xi * Xj) (µ est une constante positive, qui spécifie le pas de modification des poids. Permet un apprentissage plus rapide !)
5/ Tant que tous les exemples de la base d'apprentissage ne sont pas traités correctement, on retourne à l'étape 2.
Exemple d'application de l'algorithme d'apprentissage de Hebb :
Choisissons pour les neurones un comportement binaire (le -1 représente la valeur 0).
(Les entrées e1 et e2 sont considérées comme des neurones.)
Essayons à présent de faire apprendre cette table :
E1 | E2 | x | l |
1 | 1 | 1 | (1) |
1 | -1 | 1 | (2) |
-1 | 1 | -1 | (3) |
-1 | -1 | -1 | (4) |
1/ Conditions initiales : µ = +1, les poids et le seuil sont nuls.
2/ Calculons la valeur de x pour l'exemple (1) :
3/ a = W1*E1 + W2*E2 - S = 0*1 + 0*1 - 0 = 0
a = 0
d'où : x = -1
4/ La sortie est fausse, il faut donc modifier les poids en applicant la loi d'Hebb :
-------------------------------- Mise à jour () --------------------------------
Ce n'est plus :
W1 = W1 + µ*E1 = 0 + 1*1 = 1
W2 = W2 + µ*E2 = 0 + 1*1 = 1
Mais, comme la loi d'Hebb le dit :
W1 = W1 + µ*(E1*X) = 0 + 1*(1*(-1)) = -1
W2 = W2 + µ*(E2*X) = 0 + 1*(1*(-1)) = -1
2/ On passe à l'exemple suivant (2) :
3/ a = (-1)*1 + (-1)*(-1) - 0 = 0
a = 0
d'où : x = -1
4/ La sortie est fausse, il faut donc modifier les poids en applicant la loi d'Hebb :
W1 = (-1) + 1*(1*(-1)) = -2
W2 = (-1) + 1*((-1)*(-1)) = 0
--------------------------- Fin de Mise à jour () ---------------------------
…/ L'exemple suivant (3) est correctement traité : a = -2 et x = -1.
On passe directement, sans modification des poids à l'exemple (4). Celui-ci aussi est correctement traité.
On revient alors au début de la base d'apprentissage : l'exemple (1). Il est correctement traité, de même pour le second (2).
L'algorithme d'apprentissage est alors terminé : toute la base d'apprentissage a été passée en revue sans modification des poids.
II] Apprentissage supervisé, le Perceptron :
La loi d'Hebb ne s'applique pas dans certain cas (bien qu'une solution existe).
Un autre algorithme d'apprentissage a donc été proposé, qui tient compte de l'erreur observée en sortie.
L'algorithme d'apprentissage du Perceptron est semblable à celui utilisé pour la loi de Hebb.
Les différences se situent au niveau de la modification des poids.
Algorithme :
1/ Initialisation des poids et du seuil S à des valeurs (petites) choisies au hasard.
2/ Présentation d'une entrée El = (E1, E2, ..., En) de la base d'apprentissage. (l est l'indice de l'entrée dans la base d'apprentissage.)
3/ Calcul de la sortie (x) obtenue pour cette entrée :
a = Somme (Wi * Ei) - S (S est la valeur de seuil !)
x = Signe (a) ( si a > 0 alors x = +1, sinon a = 0, alors x = -1 )
4/ Si la sortie x est différente de la sortie désirée Sl pour l'exemple d'entrée El alors il y a modification des poids :
Wi(t+1) = Wi(t) + µ*((Sl - x)*Ei)
Information : (Sl - x) est une estimation de l'erreur.
5/ Tant que tous les exemples de la base d'apprentissage ne sont pas traités correctement, on retourne à l'étape 2.
Pour comprendre cet algorithme, nous allons faire une version VB.Net de la source suivante : IA - RESEAU DE NEURONE: LE PERCEPTRON
Commencez par créez un nouveau projet VB.Net
Sur votre Form, vous mettez :
2 TextBoxs (Name = Entree1 et Entree2)
2 TextBoxs (Name = Poids1 et Poids2)
1 Button (Name = Calculer)
1 TextBox (Name = X)
1 TextBox (Name = Seuil)
1 TextBox (Name = PasDeModificiation [µ], Text = 0.1)
1 TextBox (Name = ResObt)
1 TextBox (Name = ResAtt)
1 Button (Name = Corriger)
La première chose qu'il faut faire, c'est d'initialiser les valeurs des poids et du seuil aléatoirement :
'Pour cela, utiliser cette fonction :
String.Format("{0:F2}", (Rnd() * 100) / 100 * 2 - 1)
Ensuite il faut calculer la valeur de X et enfin le résultat.
Dans l'événement "Calculer.Click" (la fonction du neurone) :
If (Entree1.TextLength > 0 And Entree2.TextLength > 0) Then 'Vérification des valeurs des Entrées
'Calcul de la valeur X :
X.Text = Entree1.Text * Poids1.Text + Entree2.Text * Poids2.Text - Seuil.Text
'Affichage du résultat selon le signe de X :
If X.Text < 0 Then ResObt.Text = -1 Else ResObt.Text = 1
End If
Finalement, on modifie les poids.
On passe maintenant à un peu plus dur, l'apprentissage :
'Calcul des nouveaux poids :
Poids1.Text += PasDeModificationDuPoids.Text * (ResAtt.Text - ResObt.Text) * Entree1.Text
Poids2.Text += PasDeModificationDuPoids.Text * (ResAtt.Text - ResObt.Text) * Entree2.Text
'On appelle l'évenement Calculer.Click pour mettre à jour les valeurs X et ResObt
On_Clique_Sur_Calculer(sender, e)
Maintenant, voyons voir un example avec le programme :
J'ai décidé de faire apprendre à mon réseau de neurones artificiels l'opération binaire : And.
Petit rappel : Tableau de Or
a : | b : | Résultat : |
0 | 0 | 0 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 1 |
Je lance l'application est j'inscris : § dans Entree1 : -1
§ dans Entree2 : -1
Je vois : § Poids1 : 0,00
§ Poids2 : 0.16
§ Seuil : -0.99
Je clique sur "Calculer" : § X : 0.85
§ ResObt : 1
Ce n'est pas le résultat attendu, donc :
J'entre : § ResAtt : -1
Puis je clique sur "Corriger" (3 fois) : § Poids1 : 0.7
§ Poids2 : 0.64
§ X : -0.35
§ ResObt : -1
C'est bon, donc je continue.
J'entre : § Poids2 : 1
Puis je clique sur "Calculer" :
(...)
Et ainsi de suite, j'arrive à :
§ Poids1 : 1.3
§ Poids2 : 0.04
§ avec un Seuil de : -0.99
Mon réseau à enfin appris cette opération !!!
Voilà, c'est si simple que ça !!!
Etonnant, non ??
Si vous voulez ma source : Simple Perceptron.zip
Elle est un peu amélioré, mais c'est quand même compréhensible même pour un débutant en VB.Net !
Maintenant, j'ai une 
à vous poser : Sauriez-vous apprendre à votre réseau de neurones artificiels l'opérateur binaire : Xor ?? Pourquoi ??
Petit rappel : Tableau du Xor 
a : | b : | Résultat : |
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 0 |
(...)
Grande aide pour répondre à la : XOR = [a OU b] ET [ NON (a ET b) ]
III] Conclusion :
Voilà, donc maintenant, vous savez comment faire un réseau de neurones artificiels qui "apprends" !
Vous pouvez vous amuser avec les sources elles sont FREE DROITS !!
La prochaine fois, nous verrons (ce que j'ai compris de) la Rétro Propagation !
ZogStriP
IA pour : Incomplet de l'Ancéphale.
Source : http://avalon.epm.ornl.gov/~touzetc/Book/Bouquin.htm
