Perceptron simple et multi-couche

Bonjour,

Je sais qu'il y a déjà des discussions à ce sujet sur le forum mais cela ne m'a pas aidé à trouver les réponses que je cherchais.

Je tiens aussi à préciser que j'ai qu'un CFC d'informatique donc je ne suis pas ingénieur ou scientifique (donc nul dans le domaine ;)).

PS: J'ai lu le tutoriel sur les réseaux de neurones présent sur ce site. J'ai aussi consulter environ une trentaine de document traitant à ce sujet pour faire un perceptron simple.

A) Voilà, mes différentes questions concernant le perceptron simple :

1) Dans mon premier projet concernant l'apprentissage d'un perceptron au 14 fonctions logiques (OR, AND, NOR, etc) j'ai eu un problème à trouver un seuil et des poids valide pour le calcul du NOR, NAND et du NO. En effet, d'après mes observations lors de l'apprentissage, le perceptron devrait trouver un seuil et des poids inférieur à 0 (Je me sers de la fonction d'activation: Heaviside).

NOR:
0 - 0 = 1
0 - 1 = 0
1 - 0 = 0
1 - 1 = 0

Seuil du perceptron après l'apprentissage = -0.109134
Poids synaptiques = -0.324819 et -0.128077

Etant donné que le seuil est initialisé (aléatoire entre 1 et -1) au début de mon algorithme, il m'était impossible de pouvoir trouver toutes les fonctions "NO". Donc pour remediez à ça, j'ai donc permis à l'algorithme de redéfinir le seuil (aléatoirement entre -1 et 1) lors de la correction des poids.

Est-ce correcte de ma part de rendre le seuil modifiable étant donné que ça donne des résultats plutôt satisfaisant de mon points de vue ?

B) Voilà, mes différentes questions concernant le perceptron multi-couche :

1) Comment serait disposé (schématiquement) les neurones, combien y en auraient-ils dans un réseau servant à calculer le XOR ?

2) Je ne comprends vraiment pas le fonctionnement de la retropropagation par gradient. Si quelqu'un à le pouvoir de rendre ça compréhensible par l'humain lambda je le remercie d'avance ;)

Je pense que je vais m'arrêter là avec les questions, je me permettrais de boucler cette discussion seulement au moment ou j'aurais les connaissances pour créer un Perceptron capable d'apprendre le XOR et le XNOR. Je mettrais surement la source ici pour les autres qui s'y intéresse.

En attendant, je vous remets déjà un zip contenant le fichier Main.cpp contenant les sources de mon perceptron simple puis l'exécutable ;).

Amusez-vous bien avec mon perceptron maison (oui j'en suis un minimum fière je dois l'avouer).

Merci d'avance pour vos réponses !

Bonjour,

Le seuil en fait doit être appris en même temps que les poids synaptiques.
Souvent le seuil est intégré aux poids synaptiques en considérant que tous les points d'entraînement ont une composante supplémentaire fixée à 1 (ou -1)
suivant si tu considère un seuil ou un biais.

Il est toujours intéressant de comprendre qu'elle fonction on optimise.
Ici on à un problème de moindre carrés

\sum_i (a(w.x_i - b) - y_i)^2

où w est le vecteur des poids synaptiques et ou '.' désigne le produit scalaire. a est la fonction d'activation.

Le gradient par rapport a w est:

sum_i 2(a(w.x_i - b) - y_i) * a'(w.x_i - b) x_i

est par rapport à b

sum_i - 2(a(w.x_i - b) - y_i) * a'(w.x_i - b)

Ce qui pour une déscente suivant la plus grande pente donne:

w' = w - learning_rate * sum_i 2(a(w.x_i - b) - y_i) * a'(w.x_i - b) x_i
b' = b + learning_rate * sum_i 2(a(w.x_i - b) - y_i) * a'(w.x_i - b)

La règle de Hebbs peut être vue comme une version stochastique où le
gradient est approximé à chaque itération par le gradient pour le points courant uniquement (on supprime la somme), une descente de gradient stochastique donnerait:

w' = w - learning_rate * 2(a(w.x_i - b) - y_i) * a'(w.x_i - b) x_i
b' = b + learning_rate * 2(a(w.x_i - b) - y_i) * a'(w.x_i - b)

Il reste le terme faisant intervenir la dérivée de la fontion d'activation.
Le fonction de Heavside n'est pas très appropriée pour une descente de gradient. Il est commun de la remplacer par une fonction sigmoide qui est une approximation lisse. Aux alentours de 0 cette fontion se comporte comme une fonction linéaire donc a'(x) est plus ou moins constant autour de 0. D'où la règle de Hebbs avec tous les coefficients passé dans le 'learning_rate':

w' = w - learning_rate * (a(w.x_i - b) - y_i) * x_i
b' = b + learning_rate * (a(w.x_i - b) - y_i)

Au passage, le perceptron seul, est un séparateur linéaire, il est donc possible de trouver les poids qui conviennent en résolvant le problème
suivant au sens des moindres carrés:
X = [
0 0 1
0 1 1
1 0 1
1 1 1
]

y = [1 -1 -1 -1]'
d'où
X [w -b] = y

avec n'importe qu'elle solveur de moindres carré tu obtiens:

w = [-1 -1]
b = -0.5

dans X tu as tes points avec un 1 supplémenaire et j'ai remis à l'échelle y
pour que ce soit centré autour de 0

tu as donc bien :
- 0 - 0 + 0.5 >0
- 0 - 1 + 0.5 <0
-1 - 0 + 0.5 <0
-1 -1 + 0.5 <0

Pour le XOR, le résultat est classique, il faut une couche cachée avec 2 neurones et un neurone en sortie.

L'algorithme de rétropropagation suit le même résonnement que celui que j'ai donné pour le perceptron seul. La forme analytique de la formule fait que lorque tu veux calculer le gradient par rapport au poids d'un neurone d'une couche, le développement fait intervenir des quantités qui intervienne dans la couche suivante. C'est pour quoi on commence par calculer le gradient (stochastique) pour la dernière couche et que l'on rétro propage les informations vers les couches supérieures.

Salut, je tiens d'abord à te remercier pour ta réponse.

Enfaite désolé de dire ça mais j'ai pas très bien compris, le raisonnement sur la méthode des moindre carré.

Mais j'ai plus au moins compris le reste.

J'aimerais juste m'attarder sur le seuil ou le biais.

Si dans mon cas mon perceptron simple a la capacité d'apprendre un AND, OR, NAND, NOR et NO il aura obligatoirement un seuil qui sera modifié ?

Pourquoi utilise-on deux termes différents (biais et seuil) ?
Comment c'est on si il devra être à 1 ou -1 ?

Je sais juste que dans le cas du NAND, NOR, ou NO le seuil doit obligatoirement être inférieur à 0.

Merci d'avance !

Bonjour,
le premier neurone formel était déterministe et permettait de représenter des fonctions logiques en prenant pour fonction d'activation la fonction d'Heavyside, d'où la notion de seuil.

Merci pour ta réponse, je mettrais le code source du perceptron multi-couche une fois que je l'aurais terminé. Merci