Discussion :

[raphchar]

Bonjour

Je viens de lire Introduction aux Réseaux de Neurones Artificiels Feed Forward sur http://alp.developpez.com/ et j'ai une question sur l'algorithme de rétro-propagation du gradient.
J'ai essayé de créer du code C++ pour l'appliquer et ca ne fonctionne pas, alors il y a des points obscurs que j'aimerai éclaircir:

Pour tout poids w_ij <- w_ij + epsilon*di*x_ij finPour

x_ij, c'est quoi? parce que ce n'est pas défini

[Franck Dernoncourt]

On note (x i ) 1 <= i < k les k informations parvenant au neurone.

[raphchar]

On note (x i ) 1 <= i < k les k informations parvenant au neurone.

Oui, parfaitement, et donc x n'a pas de double indexation, en bref x_ij n'est pas défini, seul x_i est défini peut-être faut-il comprendre (x_i) pour le neuron j... je ne suis pas sur de bien comprendre

J'ai fait un programme avec cela et... ca ne fonctionne pas bien , le reseau donne 0.5 à toutes les sorties, quelque soit l'entrée...

J'aimerai que quelqu'un me dise si ce que je fai est juste

poids est un vector<vector<vector<float>>> l'indice i,j,k correspond au poids pour la neurone (couche i,j) du kième coefficiant du signal entrant dans la couche i

Code :

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

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
void reseau::apprendre(vector<float> entree, vector<float> sortie /*attendue*/)
{
float coef;
vector<vector<float>> signal; // ici sont collectionnes toutes les valeurs qui transitent
signal.push_back(entree);// a commencer par l'entrée
 
for(int i=0; i<this->couches;i++)
{
signal.push_back(vector<float>());
for(int j=0;j<this->taille_couche[i];j++)//pour chaque neurone (i,j)
{
coef=-biais;
for(int k=0;k<poids[i][j].size();k++)
coef+=this->poids[i][j][k]*signal[i][k];
signal[i+1].push_back(transfert(coef));
//on calcule la valeur de sortie
}
}
 
vector<vector<float>> d;//les d_ij
for(int i=0;i<this->couches;i++)
d.push_back(vector<float>());
 
int fin=this->couches-1;
 
//on remplit les d de la dernières couches
for(int i=0;i<this->taille_couche[fin];i++)
d[fin].push_back(signal[couches][i] * (1.0f-signal[couches][i]) * (sortie[i]-signal[couches][i]));
//puis couches par couche
for(int i=couches-2;i>=0;i--)
{
for(int j=0;j<taille_couche[i];j++)//neurone par neurone
{
float coeff=0.0f;
for(int k=0;k<d[i+1].size();k++)
coeff+=d[i+1][k] * poids[i+1][k][j];
coeff*=signal[i+1][j]*(1.0f-signal[i+1][j]);
d[i].push_back(coeff);
}
}
//traduit le passage Pour tout poids w_ij <- w_ij + epsilon*di*x_ij finPour 
for(int i=0;i<couches;i++)
{
for(int j=0;j<taille_couche[i];j++)
{
for (int k=0;k<poids[i][j].size();k++)
{
poids[i][j][k]+=EPSILON * d[i][j] * signal[i][k];
}
}
}
}