[Réseau de neurones] Idées d'exercices

Version imprimable

Voir 40 message(s) de cette discussion en une page

29/10/2008, 18h02
Alp

Fallait chercher dans l'article :aie:

Si tu veux, lors de l'apprentissage, t'as un ensemble d'exemples, c'est à dire de (n informations en entrée, la sortie attendue pour le réseau de neurones lorsqu'on donne précisément ces n informations).
yk c'est précisément la sortie attendue pour les n informations du k-ème exemple.

Tu as compris ?
29/10/2008, 18h09
maxiter
J'ai pas vraiment compris, désolé :oops: .

Ma fonction pourrait donner quelque chose comme ça :
Code:

1 2 3 4 5 void learn(float *poids, float alpha, float entree, float x) { *poids += alpha*(x - entree)*x; }
Avec:
x L'entré (x1 ou x2)
entree le résultat retourné par le neurone.

?

Merci.
29/10/2008, 18h18
Alp

Non.

Tu donnes x1, x2, ..., xn à ton réseau de neurones, qui sont n informations.
Lors de l'apprentissage, tu vas dire à ton réseau de neurones : alors, si tu reçois x1 comme 1ère information, x2 comme 2è, ..., xn comme n-ème, alors moi j'attendrais en fait de toi que tu me donnes y en sortie.

Sauf qu'ici, on va dire ça, mais pour différentes informations x1, ..., xn.
Du coup, la sortie attendue n'est pas toujours la même. Pour l'exemple numéro k, la sortie attendue est yk.

Un exemple, je le rappelle, c'est 2 choses :
- n informations, que je note x1, x2, ..., xn
- yk qui est la sortie (c'est à dire f( somme pondérée des x1, x2, ..., xn ) ) de ton neurone.

Ca va mieux ?

Donc en suivant tes indications, j'ai ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
int neurone(float x1, float x2, float seuil, float poids)
{
    float result = poids*(x1+x2);
    if(result <= seuil)
        return 0;
    if(result >= seuil)
        return 1;
}
 
void learn(float *poids, float alpha, float seuil, float x1, float x2, float entreeAct)
{
    int yk = neurone(x1, x2, seuil, *poids); // Calcul du résultat actuel avec les entrées x1 et x2
    *poids += alpha*(yk - *poids)*entreeAct; // Correction du poids
}
 
int main()
{
    // Apprentissage pour l'entrée x1
    for(int i = 1; i < nbIter + 1; i++)
    {
        learn(pPoids, alpha, seuil, x1, x2, x1);
    }
 
    // Apprentissage pour l'entrée x2
    for(int i = 1; i < nbIter + 1; i++)
    {
        learn(pPoids, alpha, seuil, x1, x2, x2);
    }
}

Les résultats me semblent plus corrects qu'avant mais je ne suis pas sûr que mon code soit bon.

Merci d'avance.

29/10/2008, 19h05
Alp
Ce passage est faux (au moins) :
Code:

1 2 *poids += alpha*(yk - *poids)*entreeAct;
Regarde bien la formule... En français, elle donnerait :

Citation:

poids_numero_i = poids_numero_i + une_constante*(sortie_attendue - sortie_obtenue)*poids_numero_i

Sortie obtenue c'est la sortie qui est calculée à partir des entrées que tu donnes et étant donnés les poids actuels.
Sortie attendue c'est la sortie que TOI, l'homme, supérieur à la machine (:aie:), tu demanderais à ton neurone de te donner.
Par exemple, si tu veux faire apprendre la fonction OU...
Imaginons qu'ici les xi soient tout simplement x1 = 1 et x2 = 0.8.
Ton neurone a au début des poids aléatoires...
Donc il ne te donnera probablement pas 1, qui est ce que tu attendrais !

Or, toi tu vas lui dire "si je te donne x1 = 1, x2 = 0.8, et que j'aimerais avoir 1 en sortie, est-ce que tu peux appliquer la formule pour corriger tes poids, comme ça la prochaine fois tu seras plus proche du bon résultat". L'algo ne fait que dire ça au neurone, vraiment :)
29/10/2008, 19h06
Alp
Ah et aussi : tu dois changer :
Code:

1 2 if(result <= seuil)
en
Code:

1 2 if(result < seuil)
Si result == seuil, le résultat à renvoyer est 1.

Ok, merci.
Donc j'ai complètement remanié mon code et j'obtiens ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 int neurone(float x1, float x2, float seuil, float poids) { float result = poids*(x1+x2); if(result < seuil) return 0; if(result >= seuil) return 1; } int main() { cout << "\nApprentissage en cours..." << endl; for(int i = 1; i < nbIter + 1; i++) { float yk = neurone(x1, x2, seuil, poids); poids = poids+alpha*(1 - yk)*poids; cout << poids << endl; } cout << "\nApprentissage termine !\n" << endl; cout << "Sortie du neurone : " << neurone(x1, x2, seuil, poids) << endl; }
En exécutant le programme avec la configuration suivante :
Seuil : 0.5
Alpha : 0.8
Nombre d'itérations : 5
Entree 1 : 0
Entree 2 : 1
Poids aléatoire : 0.23

J'obtiens :
Phase d'apprentissage :
0.414
0.7452
0.7452
0.7452
0.7452

Sortie du neurone : 1

Le programme simule la fonction OR ;) .

Je pense que c'est correct, mais je voudrais être sur surtout au niveau de l'apprentissage, car j'obtiens 4 fois la même valeur pour le poids.

Voilà, je commence à voir le jour.
Merci encore.

29/10/2008, 19h44
Alp

Je te conseille de bien relire en détails et encore relire avant de te replonger dans le code.

Relis vraiment bien et prends ton temps, car beaucoup de choses semblent mal comprises :?
29/10/2008, 20h25
maxiter

J'ai pourtant tout bien relu, même l'article lui même :oops: .
Qu'est-ce qui ne va pas exactement ?

Merci.
29/10/2008, 20h27
Alp

Il n'y a pas un poids tout seul qui est affecté à l'ensemble des n informations, mais il y a un poids par information.
Dans ton code il n'y a qu'un poids, normal qu'il soit partout pareil.

Vraiment, relis le à tête froide, et lis un cours de niveau L1 en maths, pour ce qui concerne les ensembles, les sommes, etc.
29/10/2008, 21h00
maxiter

Si ce n'est que sa, ça va. En effet, j'utilise qu'un poids pour les 2 informations et c'est voulu.
J'ai pensé que ça ne changerai pas grand chose.

Bonjour,

cette fois, c'est la bonne (du moins j'espère).
Comme tu me l'a dit, j'ai relu l'article, les messages de ce topic et mon cours de math sur les sommes pondérées.

J'ai donc complètement recommencé mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 int neurone(float *entrees, float *poids, float seuil) { float resultat; resultat = entrees[0] * poids[0]; resultat += entrees[1] * poids[1]; if(resultat < seuil) return 0; if(resultat >= seuil) return 1; } int main() { // ------------- Apprentissage -------------- cout << "\nApprentissage en cours..." << endl; for(int i = 0; i < nbIter; i++) { ponder[0] = poids[0] * entrees[0]; ponder[1] = poids[1] * entrees[1]; poids[0] += alpha * (valeurVoulue - ponder[0]) * poids[0]; poids[1] += alpha * (valeurVoulue - ponder[1]) * poids[1]; cout << poids[0] << "\t\t" << poids[1] << endl; } cout << "Sortie du neurone : " << neurone(entrees, poids, seuil); return 0; }
J'obtiens de meilleurs résultats :
ScreenShot

Pendant l'apprentissage, la colonne de gauche indique les poids de l'entrée 1 et celle de droite les poids de l'entrée 2.

Les poids aléatoirement sélectionnés sont :
Pour l'entrée 1 : 0.234476
Pour l'entrée 2 : 0.134657

Sur la capture, j'ai voulu simuler la fonction OR et on dirait que ça fonctionne.

Voilà, merci d'avance (encore une fois :oops: ).

30/10/2008, 14h35
Alp

http://www.developpez.net/forums/ima...ons/resolu.gif ?

PS : 10 secondes l'exécution ?!
30/10/2008, 15h06
maxiter

Citation:

Envoyé par Alp

http://www.developpez.net/forums/ima...ons/resolu.gif ?

Ca veut dire que mon code est correct cette fois ? :P

10 secondes pour l'exécution totale du programme, pas pour le calcul. C'est le temps que j'entre les valeurs etc... ;) .
30/10/2008, 15h50
Alp

Ok pour le temps d'exec.

Le programme semble correct oui :)

Le seuil est généralement compté parmi les poids, mais ce n'est qu'un détail :)
30/10/2008, 16h16
maxiter

Citation:

Envoyé par Alp

Le seuil est généralement compté parmi les poids, mais ce n'est qu'un détail :)

C'est à dire ? L'apprentissage doit corriger le seuil et les poids ? Dans ce cas, je peux aussi choisir un seuil aléatoirement, non ?
30/10/2008, 16h23
Alp

Citation:

Envoyé par article sur les RdN

On note (x i ) 1 <= i < k les k informations parvenant au neurone. De plus, chacune sera plus ou moins valorisée vis à vis du neurone par le biais d'un poids. Un poids est simplement un coefficient w i lié à l'information x i . La i -ème information qui parviendra au neurone sera donc en fait w i *x i . Il y a toutefois un "poids" supplémentaire, qui va représenter ce que l'on appelle le coefficien de biais . Nous le noterons w 0 et le supposerons lié à une information x 0 = -1. Nous verrons plus tard son utilité, dans la section Fonction d'activation .

Le neurone artificiel (qui est une modélisation des neurones du cerveau) va effectuer une somme pondérée de ses entrées putôt que de considérer séparément chacune des informations.

Citation:

Envoyé par article sur les RdN

La fonction d'activation, ou fonction de transfert, est une fonction qui doit renvoyer un réel proche de 1 quand les "bonnes" informations d'entrée sont données et un réel proche de 0 quand elles sont "mauvaises". On utilise généralement des fonctions à valeurs dans l'intervalle réel [0,1]. Quand le réel est proche de 1, on dit que l'unité (le neurone) est active alors que quand le réel est proche de 0, on dit que l'unité est inactive . Le réel en question est appelé la sortie du neurone et sera noté a . Si la fonction d'activation est linéaire, le réseau de neurones se réduirait à une simple fonction linéaire.

En effet, si les fonctions d'activations sont linéaires, alors le réseau est l'équivalent d'une régression multi-linéaire (méthode utilisée en statistiques) . L'utilisation du réseau de neurone est toutefois bien plus intéressante lorsque l'on utilise des fonctions d'activations non linéaires.

En notant g la fonction d'activation, on obtient donc la formule donnant la sortie d'un neurone :
http://alp.developpez.com/tutoriels/...x-15079989.png
Remarquez que le coefficient de biais est inclus dans la somme, d'où la formule plus explicite :
http://alp.developpez.com/tutoriels/...ex-9486447.png

Je te laisse relire la section sur l'apprentissage. J'ai l'impression que tu veux aller trop vite et que tu rates des détails.
30/10/2008, 16h47
maxiter

Autant pour moi :oops: .

Pour chaque entrée dans le neurone, je dois faire : x_i * w_i - w0
Ca n'a pas de rapport avec l'apprentissage, si ?
30/10/2008, 17h01
Alp

Citation:

Envoyé par maxiter

Pour chaque entrée dans le neurone, je dois faire : x_i * w_i - w0

Non, le w0 est à part, car on fait comme si il y avait un x0 et qu'il valait -1.
Donc le w0 et le x0 sont respectivement des w_i et des x_i comme les autres :)

Pour le rapport : Regarde de combien à combien va la boucle POUR dans les algos d'apprentissage ;)
30/10/2008, 17h13
maxiter

Donc si je comprends bien, j'ai en réalité 3 entrées.
Le seuil est considéré comme une entrée valant -1 donc on lui applique aussi un poids.

Pour la boucle, le nombre d'itérations doit être le nombre d'entrées, c'est bien ça ?

Merci.

Voir 40 message(s) de cette discussion en une page