Discussion :

[DJEcalcul]

Bonjour a tous,

Grâce a un récent message j'ai pu un peu mieux comprendre les réseaux de neurones, mais c'est vraiment en mettant les mains dans le moteur qu'on comprend. J'ai implémente un "feed forward" qui fonctionne très bien. Je suis ensuite passe a un "back propagation" et la les résultats sont assez mauvais, ce qui évidement n'est pas logique.
Je vous laisse tester et surtout dites moi si vous voyez pourquoi les résultats ne sont pas bons.

Code MATLAB :

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
% ----------------------Initialization-------------------------------------
 
% XOR input for x1 and x2
input = [0 0; 0 1; 1 0; 1 1];
% Desired output of XOR
output = [0;1;1;0];
% Initialize the bias
bias = [-1 -1 -1];
% Learning coefficient
coeff = 0.7;
% Number of learning iterations
iterations = 100000;
% Calculate weights randomly.
weights = -1 +2.*rand(3,3);
 
% -------------------Back Propagation -------------------------------------
 
for i = 1:iterations
   %Initialization
   out = zeros(4,1);
   numIn = length (input(:,1));
   for j = 1:numIn
      % Hidden layer
      H1 = bias(1,1)*weights(1,1)      
          + input(j,1)*weights(1,2)
          + input(j,2)*weights(1,3);
 
      % Send data through sigmoid activation function 1/1+e^-x 
      %(values between 0 to 1)
      x2(1)= 1./(1+exp(-H1));
 
      H2 = bias(1,2)*weights(2,1)
           + input(j,1)*weights(2,2)
           + input(j,2)*weights(2,3);
 
      % sigmoid function     
      x2(2)= 1./(1+exp(-H2));
 
      % Output layer
      x3_1 = bias(1,3)*weights(3,1)
             + x2(1)*weights(3,2)
             + x2(2)*weights(3,3);
 
      % sigmoid function
      out(j) = 1./(1+exp(-x3_1));
 
      % Adjust delta values of weights
      % For output layer:
      % delta(wi) = xi*delta,
      % delta = (1-actual output)*(desired output - actual output) 
      delta3_1 = out(j)*(1-out(j))*(output(j)-out(j));
 
      % Propagate the delta backwards into hidden layers
      % Here is really the back propagation
      delta2_1 = x2(1)*(1-x2(1))*weights(3,2)*delta3_1;
      delta2_2 = x2(2)*(1-x2(2))*weights(3,3)*delta3_1;
 
      % Add weight changes to original weights 
      % And use the new weights to repeat process.
      % delta weight = coeff*x*delta
      for k = 1:3
         if k == 1 % Bias cases
            weights(1,k) = weights(1,k) + coeff*bias(1,1)*delta2_1;
            weights(2,k) = weights(2,k) + coeff*bias(1,2)*delta2_2;
            weights(3,k) = weights(3,k) + coeff*bias(1,3)*delta3_1;
         else % When k=2 or 3 input cases to neurons
            weights(1,k) = weights(1,k) + coeff*input(j,1)*delta2_1;
            weights(2,k) = weights(2,k) + coeff*input(j,2)*delta2_2;
            weights(3,k) = weights(3,k) + coeff*x2(k-1)*delta3_1;
         end
      end
   end   
end
 
% Display the trained NN
weights
out

J'obtiens comme output :
0.4995
0.4777
0.5005
0.5223

Alors que je devrais être proche de :
0
1
1
0

[DJEcalcul]

Je me permets d'ajouter une couche,
en faisant varier le learning rate (plus proche de 0.5) et le nbr d'iterations, disons que j'obtiens plus souvent de bons resultats, mais je tombe aussi 1 fois sur 3 en moyenne sur de mauvais resultat. Quelqu'un voit-il une erreur dans mon code, ou cette variation que je trouve assez forte dans les resultats est normale ? Parceque du coup c'est mieux de faire un simple forward, ce qui n'est pas vraiment logique, puisque le back propagation devrait etre mieux en terme de resultat.

[ToTo13]

Je ne connais pas Matlab ni ton architecture, donc je ne peux critiquer directement ton code.
L'architecture classique pour tester le XOR, c'est une couche cachée avec deux neurones (+ biais ?) et une couche de sortie avec un seul neurones (+ biais ?).
Contrairement à ce que l'on pourrait croire, ce n'est pas un problème trivial et la convergence vers la solution n'est pas assurée.
Ce n'est pas parfait, mais sur mon RdN, j'obtiens une convergence dans 97.5% des cas, mais avec un très faible learning rate et en utilisant le momentum (ce que tu ne sembles pas faire).

[DJEcalcul]

Merci a toi,
En effet je pensais ajouter un momentum ..

[ToTo13]

Le plus simple serait de faire tourner un exemple à la main, avec des valeurs de poids très faciles. Tu verras vite où tu as des erreurs.
De plus, tu peux aussi calculer l'erreur avant et après rétro-propagation, cela te diras si tes poids sont correctement modifiés.

Dans le cas d'un RdN basique, il faut souvent utiliser des learning rates très faibles.

[DJEcalcul]

Le plus simple serait de faire tourner un exemple à la main, avec des valeurs de poids très faciles. Tu verras vite où tu as des erreurs.
De plus, tu peux aussi calculer l'erreur avant et après rétro-propagation, cela te diras si tes poids sont correctement modifiés.

Dans le cas d'un RdN basique, il faut souvent utiliser des learning rates très faibles.

Merci ToTo, tres faible c'est a dire ? 0.01 ?

[ToTo13]

Merci ToTo, tres faible c'est a dire ? 0.01 ?

Par example, mais il n'y a pas de valeur miracle passe partout :-(
Cela dépend beaucoup de l'algorithme utilisé pour modifier les poids : la rétro-propagation basique c'est bien, mais ça marche moyennement. Il faut souvent ajouter un learning rate par poids (et non un global), puis un algorithme intelligent pour les modifiers (comme AdaGrad ou AROW).
Dans le cas du DropOut, Hinton modifie la fonction d'erreur en introduisant la norme L2 (ne me demande pas exactement comment), ce qui lui permet d'utiliser des learning rates initiaux élevé et ainsi de converger plus rapidement vers la solution.

[DJEcalcul]

Hum..
ok,
merci toto.

Donc finalement pour une vrai application mieux vaudrait utiliser la toolbox matlab ou celle de R par exemple (qui a le mérite d'être gratuit).

[ToTo13]

Si tu veux quelque chose de vraiment bien, il te faut un learning rate modifiable par poids. Cela implique d'utiliser une des deux méthodes citées (il y en a d'autres, mais ce sont les plus connues/efficaces... me semble t-il).
Sinon tu auras des soucis de convergence/oscillation. Fais donc le test sur le problème "double spirales", tu devrais déjà t'en rendre compte.

Je déteste MatLab car cela impose un langage dans un environnement payant et EXTREMEMENT LENT !!!
R je ne connais pas assez, mais il semblerait que le souci soit de trouver LA bonne classe au milieu des milliers de choix possibles.

Dans TOUT les cas, il faut bien regarder l'implémentation. J'ai récemment découvert en développant mon propre RdN/DNN/CNN que les libraires (méga connues/répandues) que j'utilisais n'utilisaient pas ce que j'ai cité précédemment et du coup n'arrivaient pas à résoudre le XOR et le deux spirales :-(
Donc méfiance !!!

[DJEcalcul]

hum.. oki.

C'est quoi le probleme des doubles spirales ? Tu as un lien ?

merci ToTo.

[ToTo13]

Voici

.
C'est le deuxième problème basique après le XOR.

Sinon tu as plein d'exemples dans Google en tapant : "two spirals problem neural network".

[DJEcalcul]

merci toto.