Discussion :

[Courieux]

Bonsoir.

Désolé de encore venir vous demander votre aide... mais là je sèche !

J'ai intégré l'algorithme de rétro propagation dans un programme C++ de la plus simple facture cependant je rencontre un résultat qui me laisse perplexe.
J'ai commencé par vouloir faire apprendre à mon réseau la fonction booléenne XOR et après plusieurs cycles d'apprentissages j'ai récupéré les différentes erreurs calculées pendant la correction.
L'erreur "pure", c'est-à-dire la moyenne de (sortie_voulue - sortie_obtenue) pour chaque couple entrée/sortie reste environ constante entre 50% et 49%. Je pourrais penser que le problème vient directement de l'algorithme.
Or, lorsque je regarde la variation de l'erreur quadratique (définie par E = (1/2)(sum(sortie_voulue - sortie_obtenue)²) force est de constater que le programme fonctionne puisqu'en partant d'une erreur quadratique d'environ 45%, je tombe rapidement en dessous de 1% après quelques cycles de corrections.

L'objectif de l'apprentissage étant de diminuer l'erreur quadratique, on pourrait se réjouir de sa très faible valeur.
Oui mais l'erreur "pure" reste à environ 50% ! Si bien que lorsque je souhaite obtenir "0", le réseau calcule "0.56" et lorsque je souhaite avoir 1, j'obtiens des valeurs comme "0.42".

Il y aurait-il alors des problèmes théoriques qui m'auraient échappés ou pensez-vous que cela vienne de mon programme ?

Merci pour votre lecture.

[Clercq]

L'erreur "pure", c'est-à-dire la moyenne de (sortie_voulue - sortie_obtenue) pour chaque couple entrée/sortie reste environ constante entre 50% et 49%.

Première question, c'est l'erreur moyenne sur la base de teste ou bien d'apprentissage?
Il en reste que... Un algorithme stochastique ferait aussi bien.

Or, lorsque je regarde la variation de l'erreur quadratique (définie par E = (1/2)(sum(sortie_voulue - sortie_obtenue)²) force est de constater que le programme fonctionne puisqu'en partant d'une erreur quadratique d'environ 45%, je tombe rapidement en dessous de 1% après quelques cycles de corrections.

Dexieme question, tu as combien de sortie? A priori, pour la fonction XOR tu as besoin d'une seul sortie -/+. Donc, d'ou vient le sum?

L'objectif de l'apprentissage étant de diminuer l'erreur quadratique, on pourrait se réjouir de sa très faible valeur.

Un meilleurs objectif est la stabilisation de l'erreur sur une erreur quadratique basse, ce qui évite de s'arrêter sur une bonne classification "chanceuse".

Il y aurait-il alors des problèmes théoriques qui m'auraient échappés ou pensez-vous que cela vienne de mon programme ?

Pour répondre a cette question il faudrait que tu "traduise" ce que tu as fait en C++ en pseudo-code, que l'on puisse voir si tu as compris le principe déjà.
Ensuite, s'il n'est pas trop long tu peut poster ton code, ça peut provenir d'une erreur dedans. Mais la c'est plus du ressort du forum C++ (sans me prendre pour un admin^^").

Tcho.

[Courieux]

Salut, merci pour ta réponse.

Première question, c'est l'erreur moyenne sur la base de teste ou bien d'apprentissage?
Il en reste que... Un algorithme stochastique ferait aussi bien.

Je ne comprends pas bien ta question. En fait la base de test est la base d'apprentissage (Pour x1 = 1 et x2 = 1, je souhaite s = 0...). Mais à la base il s'agit de la base d'apprentissage.

Dexieme question, tu as combien de sortie? A priori, pour la fonction XOR tu as besoin d'une seul sortie -/+. Donc, d'ou vient le sum?

Oui je n'en ai qu'une, je citais la formule générale.

Un meilleurs objectif est la stabilisation de l'erreur sur une erreur quadratique basse, ce qui évite de s'arrêter sur une bonne classification "chanceuse".

J'y penserai, pour l'instant mon objectif premier est d'obtenir simplement 0 si les deux entrées valent 1.

Pour répondre a cette question il faudrait que tu "traduise" ce que tu as fait en C++ en pseudo-code, que l'on puisse voir si tu as compris le principe déjà.
Ensuite, s'il n'est pas trop long tu peut poster ton code, ça peut provenir d'une erreur dedans. Mais la c'est plus du ressort du forum C++ (sans me prendre pour un admin^^").

L'une de mes interrogations est là, penses-tu que cela puisse venir du code alors que l'erreur quadratique diminue normalement ?

Bon, on ne pourra pas appeler cela une écriture algorithmique mais bon...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 Avec une fonction d'activation dérivable...
Pour UN jeu d'entrée / sortie choisi aléatoirement :
 Calculer la sortie du réseau.
 Calculer l'importance de l'erreur de chaque neurones de la couche de sortie par :
 importance_sortie = sortie_obtenue_sortie * (1 - sortie_obtenue_sortie) * (sortie_désirée - sortie_obtenue_sortie)
 
 Rétro propager l'erreur en calculant l'importance de l'erreur commise par chaque neurones des couches cachées (de la couche de sortie vers la couche 'd'entrée'):
 importance_cachée = sortie_obtenue_cachée * (1 - sortie_obtenue_cachée) * (SOMME DE (importance_erreur_neurone£(couche+1) * poids_connexion_entre_neurone-travaillé_et_neurone£(couche+1) avec £ désigne chaque neurone de la couche suivante)
 
Mettre à jour tous les poids du réseau par :
 
nouveau_poids = ancien_poids + (taux_apprentissage * importance_erreur_neurone_au_bout_de_la_connexion * valeur_de_la_connexion)

J'ai bon ?


Merci encore pour ta réponse.

[Clercq]

Je ne comprends pas bien ta question. En fait la base de test est la base d'apprentissage (Pour x1 = 1 et x2 = 1, je souhaite s = 0...). Mais à la base il s'agit de la base d'apprentissage.

En effet... C'était un réflexe ^^"

Oui je n'en ai qu'une, je citais la formule générale.

Va pour la formule générale, mais pour ma défense, on est la pour comprendre ton cas spécifique

L'une de mes interrogations est là, penses-tu que cela puisse venir du code alors que l'erreur quadratique diminue normalement ?

Bonne question... Si tu la trace, tu obtiens bien une courbe décroissante? Ou plutôt convergente, non oscillante ou divergente (pour le dernier cas je suppose fortement que non)

J'ai bon ?

ça me parait bon, sauf pour la lisibilité

Autre question:
L'erreur de classification et l'erreur quadratique sont très différentes,
- Dans l'erreur quadratique, tu regarde a quelle point tu es loin de la réponse attendu, ce qui te permet de corriger tes poids par descente de gradient. Tu fais donc une simple soustraction entre Y (sortie attendue) et Y_hat (prédiction).

- Dans le cas de l'erreur de classification tu regarde si oui ou non la donnée est bien classée (cas simple a deux classes).
-> Dans ton cas tu cherche a savoir si la sortie est oui:+, ou non:-. En gros tu dois regarder si la fonction sign() te "renvoie" la bonne classe ou non (le bon signe).
En gros tu ne compare pas 1-0.42 mais 1-sign(0.42).
Dans le cas ou tu as plus de deux classes (et si tu ne fais pas du un contre tous), il faut comparer la sortie attendu avec le maximum de vraisemblance, mais nous nous éloignons de ma question:
Comment calcul tu ta moyenne d'erreur en prédiction?
-moy_i(Y_j-Y_hat_ij)
ou
-moy_i(Y_j-sign(Y_hat_ij))

Tcho.

[Courieux]

Va pour la formule générale, mais pour ma défense, on est la pour comprendre ton cas spécifique

Oui oui c'est ma faute.
En fait j'ai dis une bêtise. Dans mon programme je faisais effectivement la somme de (sortie_attendue - sortie_obtenue) pour chaque coupe entrée/sortie après quelques cycles de correction.

Bonne question... Si tu la trace, tu obtiens bien une courbe décroissante? Ou plutôt convergente, non oscillante ou divergente (pour le dernier cas je suppose fortement que non)

Concernant l'erreur quadratique (calculée comme dit précemment), il s'agit d'une courbe strictement décroissante.
Et en ce concerne l'erreur de classification, elle oscille entre 50% et 49%

- Dans l'erreur quadratique, tu regarde a quelle point tu es loin de la réponse attendu, ce qui te permet de corriger tes poids par descente de gradient.

Donc par définition si l'erreur quadratique est faible, je devrais être proche des réponses attendues, or ce n'est pas le cas... Il y a-t-il vraiment quelque chose que je ne comprends pas ?

- Dans le cas de l'erreur de classification tu regarde si oui ou non la donnée est bien classée (cas simple a deux classes).
-> Dans ton cas tu cherche a savoir si la sortie est oui:+, ou non:-. En gros tu dois regarder si la fonction sign() te "renvoie" la bonne classe ou non (le bon signe).
En gros tu ne compare pas 1-0.42 mais 1-sign(0.42).

Je comprends ce que tu veux dire par erreur de classification, mais cela n'est alors pas la réelle erreur du réseau, sauf si la fonction d'activation de la couche de sortie est Heaviside, non ? Actuellement, j'ai une couche cachée à 2 ou 3 neurones et une couche de sortie à un neurone où tous ont la fonction d'activation de sigmoide.

Comment calcul tu ta moyenne d'erreur en prédiction?
-moy_i(Y_j-Y_hat_ij)
ou
-moy_i(Y_j-sign(Y_hat_ij))

Si je comprends bien ce que tu écris, j'utilise "moy_i(Y_j-Y_hat_ij)" soit moyenne des sorties_désirée - sorties_obtenues pour chaque couple entrée/exemple.

[Clercq]

Donc par définition si l'erreur quadratique est faible, je devrais être proche des réponses attendues, or ce n'est pas le cas... Il y a-t-il vraiment quelque chose que je ne comprends pas ?

Il y a en effet quelque-chose d'étrange ... L'erreur quadratique, si je ne me trompe, est la distance euclidienne au carré, et donc une évaluation de ce qui sépare la prédiction de la sortie désiré.
Quand tu fais la somme sur un cycle, et si tes cycle sont constant, alors les erreurs quadratiques cumulées sont comparable entre elle (normalement on utilise la moy -> MSE). Si elle décroit, alors tu te rapproche de la sortie désirée (en moy), et donc... tu classifie mieux...

IDEE LUMINEUSE, s'il en ai: tu peux très bien te rapprocher de ton but tout en étant dans la mauvaise classe... En fait tu peux te trouver n'importe où sur le cercle de centre sortie désirée.

Donc en fait tu ne classifie pas forcement mieux, tu te rapproche, mais ça ne veux pas dire que tu y arrive...

Je comprends ce que tu veux dire par erreur de classification, mais cela n'est alors pas la réelle erreur du réseau, sauf si la fonction d'activation de la couche de sortie est Heaviside, non ? Actuellement, j'ai une couche cachée à 2 ou 3 neurones et une couche de sortie à un neurone où tous ont la fonction d'activation de sigmoide.

Je n'ai jamais utilisé la fonction d'activation Heavyside , j'ai appris les réseaux de neurone avec les fonctions sigmoïde ou tangente hyperbolique.
Les réseaux de neurones peuvent être utilisé dans deux domaines différents:
- La classification, où l'on cherche à "ranger" des séparées les données.
- L'apprentissage de fonction, où l'on cherche à prédire le résultat d'une fonction (apprentissage de modèle cinématique par exemple).
Dans ton cas, tu fais de la classification. Tu ne cherche donc pas réellement à comparer la sortie prédite avec la sortie désiré, mais la classe prédite avec la classe désirée. Et donc tu compare le signe de ta prédiction avec le signe de la classe désirée.

Si je comprends bien ce que tu écris, j'utilise "moy_i(Y_j-Y_hat_ij)" soit moyenne des sorties_désirée - sorties_obtenues pour chaque couple entrée/exemple.

J'avoue que c'est super mal écris... Mais en effet, le critère d'arrêt porte non pas sur l'erreur quadratique, mais sur l'erreur de classification. Comme erreur de classification on prends l'erreur moyenne pour un cycle entier.
Par contre il faut comparer les signes, et n'ont pas la valeur.

[Courieux]

J'avoue que c'est super mal écris... Mais en effet, le critère d'arrêt porte non pas sur l'erreur quadratique, mais sur l'erreur de classification. Comme erreur de classification on prends l'erreur moyenne pour un cycle entier.
Par contre il faut comparer les signes, et n'ont pas la valeur.

Merci encore beaucoup pour tes réponses.

En effet mon but une fois que le programme fonctionnera (s'il fonctionnera... ) est bien de faire de la classification avec des mises en scène bidons.
Cependant, quand bien même je comparerais les signes, après plusieurs milliers de cycles de correction, le réseau me ressort toujours des sorties qui n'ont strictement rien à voir avec ce que j'attendais... Tu n'as pas une piste d'où pourrait provenir cet oscillement des erreurs ? (je sais que tu t'efforces de le faire et je t'en remercie mais c'est juste pour recentrer un peu le topic )

[Clercq]

Tu n'as pas une piste d'où pourrait provenir cet oscillement des erreurs ?

En générale, oscillement est synonyme de taux d'apprentissage trop élevé.

e réseau me ressort toujours des sorties qui n'ont strictement rien à voir avec ce que j'attendais...

Que l'on soit bien d'accord, ce que tu attends, c'est:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
0 0 -> -1 soit sign(Y_hat)=-
0 1 -> +1 soit sign(Y_hat)=+
1 0 -> +1 soit sign(Y_hat)=+
1 1 -> -1 soit sign(Y_hat)=-

Sinon on ne parle pas de la même chose ^^"

[Courieux]

En générale, oscillement est synonyme de taux d'apprentissage trop élevé.

Je l'ai remarqué avec mon autre programme qui simulait un neurone seul.
En tout cas, ici le taux d'apprentissage est fixé à 0.1, ce qui me semble ni trop important, ni trop élevé.

Que l'on soit bien d'accord, ce que tu attends, c'est:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
0 0 -> -1 soit sign(Y_hat)=-
0 1 -> +1 soit sign(Y_hat)=+
1 0 -> +1 soit sign(Y_hat)=+
1 1 -> -1 soit sign(Y_hat)=-

Sinon on ne parle pas de la même chose ^^"

En effet mon réseau reçoit bien ces entrées avec ces sorties attendues. Les connexions entre les entrées et les neurones de la couche cachée sont générés aléatoirements, de même pour les poids des connexions entre la couche cachée et la couche de sortie. Ils sont ensuite modifiés par l'apprentissage (peu glorieux).
EDIT : En vérité pour "0 0" et "1 1", la sortie attendue est égale à "0" au lieu de "-1" comme tu le marques toi. Cela a-t-il une importance ? (Je fais des essais de toute manière )

[Clercq]

En tout cas, ici le taux d'apprentissage est fixé à 0.1, ce qui me semble ni trop important, ni trop élevé.

ce qui te semble... , mais a tu fais des essaies avec des valeurs plus basses? Parce que même s'il te semble, ça peut très bien être encore trop. Dans ce cas je suis fan de la dichotomie.

EDIT : En vérité pour "0 0" et "1 1", la sortie attendue est égale à "0" au lieu de "-1" comme tu le marques toi. Cela a-t-il une importance ? (Je fais des essais de toute manière )

Disons que c'est en générale -1/+1 dans le cas d'une seul sortie. Si tu prends 0/1, alors au lieu de la fonction sign(), il faut que tu utilise une fonction threshold() définie tels que:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

th(x) = 1 si x>= 0.5; 0 sinon.

Question: Pourquoi m'avoir laissé parlé de fonction sign() si toutes tes sorties désirées sont positives?

[Courieux]

ce qui te semble... , mais a tu fais des essaies avec des valeurs plus basses? Parce que même s'il te semble, ça peut très bien être encore trop. Dans ce cas je suis fan de la dichotomie.

Je viens d'essayer avec 0.01 ou même 0.00001 une fois, sans succès.

Disons que c'est en générale -1/+1 dans le cas d'une seul sortie. Si tu prends 0/1, alors au lieu de la fonction sign(), il faut que tu utilise une fonction threshold() définie tels que:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

th(x) = 1 si x>= 0.5; 0 sinon.

Question: Pourquoi m'avoir laissé parlé de fonction sign() si toutes tes sorties désirées sont positives?

Tout simplement parce que je lis ce que tu dis avec la bouche grande ouverte d'admiration.
Je viens d'essayer en changeant la sortie voulue "0" par "-1" et bizarrement le réseau me renvoit pour tous les couples exemples ("0 0" ; "0 1" etc.) une sortie approchant 1 à 0.001 près.
EDIT : j'ajoute aussi que mon calcul (mauvais certes) de l'erreur (moyenne de sortie_désirée - sortie_obtenue pour chaque entrée) oscille ici autour de 100% même avec un faible taux d'apprentissage.

Merci encore.

[Clercq]

Je viens d'essayer avec 0.01 ou même 0.00001 une fois, sans succès.

Le problème vient probablement d'autre part .

Je viens d'essayer en changeant la sortie voulue "0" par "-1" et bizarrement le réseau me renvoit pour tous les couples exemples ("0 0" ; "0 1" etc.) une sortie approchant 1 à 0.001 près.

Pour le coup il faudrait aussi changer ta fonction d'activation, passer de la sigmoïde a la tangente hyperbolique... Oublions.
Au lieu de prendre -1 a la place de 0, garde 0 mais utilise une la fonction threshold a 0.5.

EDIT : j'ajoute aussi que mon calcul (mauvais certes) de l'erreur (moyenne de sortie_désirée - sortie_obtenue pour chaque entrée) oscille ici autour de 100% même avec un faible taux d'apprentissage.

En gros tu n'apprends pas... grand chose tout du moins ... S'il n'est pas secret défense, a ce niveau il est peut être préférable que je regarde directement ton code.