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 ?