Discussion :

[brotelle]

Bonjour,

Je dois faire un gros projet pour mon année, qui consiste à faire un jeu de dame qui apprend à l'aide d'un réseau de neurones et de l'algorithme de rétropropagation.
Le problème est que je cherche et je cherche mais je ne sais absolument pas comment entrainer ce réseau de neurones. Pour le moment je n'ai que fait la classe du réseau de neurones (qui permet de le construire) avec l'algorithme.
Pour le moment je suis bloquée et je ne sais pas comment avancer, comment utiliser des patterns, comme donner les signaux, etc....

Je vous donne ci-dessous la classe réseau de neurones (NeuralNetworks), je sais que c'est assez long mais svp j'ai vraiment besoin d'aide :

Code java :

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
package CheckersGame;
 
import java.awt.TextArea;
import java.util.Vector;
 
public class NeuralNetworks {
 
    public NeuralNetworks() {
    }
 
    String name;
 
 
    //network architecture parameters
    int numInputs;
    int numOutputs;
    int numHid;
    int numUnits;
    int numWeights;
 
    int bias;
 
    float learnRate;
 
    //network data
    float activations[];
    float weights[];
    float teach[]; //target output value
    float error[];
    float tDeltas[];
    float deltas[]; //the error deltas
    float wDeltas[];
    float tDerivs[];
    float wDerivs[];
    //float thresholds[];
 
    TextArea textarea1;
 
    /** Creates a new instance of NeuralNetworks */
    public NeuralNetworks(String Name) {
        name = Name ;
    }
 
    //create a NeuralNetworks network with specified architecture
    public void createNetwork(int NumIn, int NumHid, int NumOut, int Bias) {
        //set the network architecture
        numInputs = NumIn;
        numHid = NumHid;
        numOutputs = NumOut;
        numUnits = numInputs + numHid + numOutputs;
        numWeights = (numInputs*numHid) + (numHid*numOutputs);
        bias = Bias;
 
        //initialise control parameters
        learnRate = (float)0.2;
 
        //create weight and error arrays
        activations = new float[numUnits]; //unit activations
        weights = new float[numWeights];
        wDerivs = new float[numWeights]; //accumulated wDeltas
        wDeltas = new float[numWeights]; //weight changes
        tDerivs = new float[numUnits]; //accumulated tDeltas
        tDeltas = new float[numUnits]; //threshold changes
        teach = new float[numOutputs]; //desired outputs
        deltas = new float[numUnits];
        error = new float[numUnits];
 
        reset(); //reset and initialize the weight array
 
        return;        
    }
 
    public void reset() {
        int i;
        for (i=0 ; i < weights.length ; i++) {
            weights[i] = (float)Math.random();
            wDeltas[i] = (float)0.0;
            wDerivs[i] = (float)0.0;
        }
        for (i=0 ; i < numUnits ; i++) {
            tDeltas[i] = (float)0.0;
            tDerivs[i] = (float)0.0;
        }
    }
 
    public float logistic(double sum) {
        return (float)(1.0 / (1 + Math.exp(-1.0*sum)));
    }
 
 
    //do a single forward pass through the network
    public void computeOutputs() {
        int i, j;
        int firstHid1 = numInputs;
        int firstOut = numInputs + numHid;
 
        //first layer
        int inx = 0;
        float sum = bias;
        for(i = firstHid1 ; i < firstOut ; i++) {
            for (j=0 ; j < numInputs ; j++) { //compute net inputs
                sum += activations[j]*weights[inx++];
            }
            activations[i] = logistic(sum); //compute activation
        }
 
        //second layer
        sum = bias;
        for(i = firstOut ; i < numUnits ; i++) {
            for(j = firstHid1 ; j < firstOut ; j++) { //compute sum
                sum += activations[j]*weights[inx++];
            }
            activations[i] = logistic(sum); //compute activation
        }
    }
 
    //compute the errors using backward error propagation
    //weight changes get placed in (or added to) wDerivs
    //threshold changes get placed in (or added to) tDerivs
    public void computeError() {
        int i, j;
        int firstHid1 = numInputs;
        int firstOut = numInputs + numHid;
 
        //clear hidden unit errors
        for(i = numInputs ; i < numUnits ; i++) {
            error[i] = (float)0.0;
        }
 
        //compute output layer errors and deltas
        for(i = firstOut ; i < numUnits ; i++) {
            error[i] = teach[i-firstOut] - activations[i];
            if (Math.abs(error[i]) < (float)0.1) error[i] = (float)0.0;
                deltas[i] = error[i]*activations[i]*(1-activations[i]);
        }
 
        //compute hidden layer errors
        int winx = numInputs*numHid; //offset into weight array
        for(i = firstOut ; i<numUnits ; i++) {
            for(j=firstHid1; j<firstOut; j++) {
                wDerivs[winx] += deltas[i]*activations[j];
                error[j] += weights[winx]*deltas[i];
                winx++;
            }
            tDerivs[i] += deltas[i];
        }
 
        //compute hidden layer deltas
        for(i=firstHid1 ; i<firstOut ; i++) {
            deltas[i] = error[i]*activations[i]*(1-activations[i]);
        }
 
        //compute input layer errors
        winx = 0; //offset into weight array
        for(i = firstHid1 ; i<firstOut ; i++) {
            for(j=0 ; j < firstHid1 ; j++) {
               wDerivs[winx] += deltas[j]*activations[j];
               error[j] += weights[winx]*deltas[i];
               winx++; 
            }
            tDerivs[i] += deltas[i];
        }
 
    }
 
    //apply the changes to the weights
    public void adjustWeights() {
        int i;
 
        //first walk through the weights array
        for(i=0; i<weights.length; i++) {
            wDeltas[i] = (learnRate*wDerivs[i]) + wDeltas[i];
            weights[i] += wDeltas[i]; //modify the weight
            wDerivs[i] = (float)0.0;
        }
    }
 
    public void process() {
        computeOutputs(); //do forward pass through network
        computeError(); //compute error and deltas
       adjustWeights(); //apply changes to weights
    }
 
}

Merci d'avoir pris le temps de lire

Brotelle

[gorgonite]

le réseau de neurones est assez difficile à "suivre" dans son évolution... tout ce que tu peux faire, c'est le nourrir sur un jeu de données suffisamment varié pour éviter l'overfitting, et patienter.

test sur un deuxième jeu les résultats au bout d'un certain temps, et arrêtes avant l'overfitting... puis fais un test final sur un troisième jeu "jamais vu auparavant"

si les perf sont correctes, ça ira

[brotelle]

Hum merci pour ta réponse mais je n'ai pas vraiment compris... qu'est-ce que l'overfitting ?
Pour l'instant tout ce que j'aimerais faire c'est entrainer mon réseau de neurones, lui donner des inputs et utiliser des pattern mais pour moi tout ça est très abstrait et je n'ai aucune idée de comment faire

Pardon je viens de relire, tu me parles de tester un jeu de données, c'est bien là le problème je ne sais pas comment il doit être, comment lui donner, comment utiliser un pattern... etc....

[goldorax113]

Salut,

je ne peux pas trop t'aider, si ce n'est pour la définition d'overfitting sur wikipedia

http://en.wikipedia.org/wiki/Overfitting

Bonne chance

[Sylvain Togni]

D'abord, il y a deux sortes d'apprentissages : apprendre une fois pour toutes "en laboratoire", ou apprendre au fur et à mesure en situation réelle.

Pour la première, il te faudrait une base de données de parties de dames de bons joueurs. Tu présente une ou plusieurs positions intermédiaires en entrée et le résultat de la partie en sortie.

Mais je ne sais pas ce que cela donnera, le jeu de dames est plus tactique (algorithme Min-Max et ses dérivés) que stratégique.

[Sivrît]

Mais je ne sais pas ce que cela donnera, le jeu de dames est plus tactique (algorithme Min-Max et ses dérivés) que stratégique.

Ca serait une piste ça, l'entrainer à faire comme le MinMax Je ne sais pas si ça ira bien loin mais il serait possible de constituer une base de parties réalisées avec du MinMax "plutôt bon" (et un brin de hasard pour qu'elles soient différentes), ou alors des positions plus ou moins aléatoires avec la réponse que donne le MinMax. Le laisser ramer toute la semaine peut se faire pour enrichir la collection.

L'expérience pourrait être d'entrainer le réseau avec un MinMax "profond", puis de voir comment il se défend contre lui et s'il peut battre un MinMax inférieur.

Sinon trouver un historique de parties de maitres serait mieux mais faut trouver...

[brotelle]

Merci pour vos réponses !

En fait pour l'instant je ne suis pas encore à entrainer le jeu de dames car je n'ai fait que la classe neural networks. Pour le moment je dois d'abord entrainer simplement le réseau de neurones tout seul, pour voir s'il est bien programmé et s'il apprend. Je dois apparamment tester avec différents jeux de données comme AND, OR, XOR. Mais je ne sais pas comment lui donner les données, sous quelle forme, si je dois utiliser une fonction, faire une fonction, etc...

[Sylvain Togni]

Pour apprendre un réseau de neurones il faut lui présenter en entrée des données, lui présenter en sortie le résultat voulu et mettre à jour ses poids (par rétro-propagation du gradient par exemple). Répéter cela un grand nombre de fois avec des données différentes (la convergence d'un réseau peut être assez longue).

EDIT:
Exemple : les entrées pour une porte OU seront 2 valeurs comprises entre 0 et 1 (la probabilité a et la probabilité b) et en sortie une valeur entre 0 et 1 (la probabilité de a OU b)

[brotelle]

J'ai un peu mieux compris merci.
Je vais essayer de programmer ça mais c'est encore un peu flou dans ma tête, je reviendrais demander conseil si je n'arrive toujours pas à entrainer ce foutu réseau de neurones...

[jobherzt]

il me semble qu'un bon premier exemple non trivial pour verifier que ton reseau de neurone foncrionne est de lui apprendre a imiter le ou exclusif (XOR). ca a l'air idiot, mais c'est un exemple pertinent. de memoire, il faut utiliser une couche intermediaire avec 3 neurones.

[brotelle]

Après une séance de tests sur mon réseaux de neurones et de tentage de débuggages de celui-ci je reviens sur ce post pour demander de l'aide...

Alors, en fait j'ai fait quelques modifications. J'ai crée une fonction getInputs() qui donne les signaux d'entrées du réseaux de neurones. Je commence par tester le ET avec une couche d'entrée de deux neurones. Je donne donc la valeur 1 aux neurones d'entrée et la valeur Out (qui est la valeur du neurones de sortie que je veux) prends donc la valeur 1.
Ensuite avec la classe Start.java je lance mon programme. J'enregistre les valeurs mon réseau de neurones dans un fichier. Ensuite quand j'essai de lancer mon programme en chargeant le réseau de neurones dans le fichier ça ne marche pas car j'ai une exception.
Il ya des valeurs qui sont vides mais je ne comprends pas pourquoi, comme "Out[0] = 1;".

Voici ma classe NeuralNetworks modifiées :

Code java :

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
package CheckersGame;
 
import java.awt.TextArea;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Vector;
 
public class NeuralNetworks {
 
    public NeuralNetworks() {
    }
 
    String name;
 
 
    //network architecture parameters
    int numInputs;
    int numOutputs;
    int numHid;
    int numUnits;
    int numWeights;
 
    float bias;
 
    float learnRate;
 
    //network data
    float activations[];
    float weights[];
    float Out[]; //target output value. The output pattern we want    
    float error[];
    float tDeltas[];
    float deltas[]; //the error deltas
    float wDeltas[];
    float tDerivs[];
    float wDerivs[];
    //float thresholds[];
    //float teach[];
    //TextArea textarea1;
 
    /** Creates a new instance of NeuralNetworks */
    public NeuralNetworks(String Name) {
        name = Name ;
    }
 
    //read intputs
    public void getInputs(){ //AND pattern
        Out[0] = 1; //set the output pattern
        activations[0] = 1;
        activations[1] = 1;        
    }
 
    //create a NeuralNetworks network with specified architecture
    public void createNetwork(int NumIn, int NumHid, int NumOut, float Bias) {
        //set the network architecture
        numInputs = NumIn;
        numHid = NumHid;
        numOutputs = NumOut;
        numUnits = numInputs + numHid + numOutputs;
        numWeights = (numInputs*numHid) + (numHid*numOutputs);
        bias = Bias;
 
        //initialise control parameters
        learnRate = (float)0.2;
 
        //create weight and error arrays
        activations = new float[numUnits]; //unit activations
        weights = new float[numWeights];
        wDerivs = new float[numWeights]; //accumulated wDeltas
        wDeltas = new float[numWeights]; //weight changes
        tDerivs = new float[numUnits]; //accumulated tDeltas
        tDeltas = new float[numUnits]; //threshold changes
        Out = new float[numOutputs]; //desired outputs
        //teach = new float[numOutputs];
        deltas = new float[numUnits];
        error = new float[numUnits];
 
        reset(); //reset and initialize the weight array
 
        return;        
    }
 
    public void reset() {
        int i;
        for (i=0 ; i < weights.length ; i++) {
            weights[i] = (float)Math.random();
            wDeltas[i] = (float)0.0;
            wDerivs[i] = (float)0.0;
        }
        for (i=0 ; i < numUnits ; i++) {
            tDeltas[i] = (float)0.0;
            tDerivs[i] = (float)0.0;
        }
    }
 
    public float logistic(double sum) {
        return (float)(1.0 / (1 + Math.exp(-1.0*sum)));
    }
 
 
    //do a single forward pass through the network
    public void computeOutputs() {
        int i, j;
        int firstHid1 = numInputs;
        int firstOut = numInputs + numHid;
 
        //first layer
        int inx = 0;
        float sum = bias;
        for(i = firstHid1 ; i < firstOut ; i++) {
            for (j=0 ; j < numInputs ; j++) { //compute net inputs
                sum += activations[j]*weights[inx++];
            }
            activations[i] = logistic(sum); //compute activation
        }
 
        //second layer
        sum = bias;
        for(i = firstOut ; i < numUnits ; i++) {
            for(j = firstHid1 ; j < firstOut ; j++) { //compute sum
                sum += activations[j]*weights[inx++];
            }
            activations[i] = logistic(sum); //compute activation
        }
    }
 
    //compute the errors using backward error propagation
    //weight changes get placed in (or added to) wDerivs
    //threshold changes get placed in (or added to) tDerivs
    public void computeError() {
        int i, j;
        int firstHid1 = numInputs;
        int firstOut = numInputs + numHid;
 
        //clear hidden unit errors
        for(i = numInputs ; i < numUnits ; i++) {
            error[i] = (float)0.0;
        }
 
        //compute output layer errors and deltas
        for(i = firstOut ; i < numUnits ; i++) {
            error[i] = Out[0] - activations[i];
            if (Math.abs(error[i]) < (float)0.1) error[i] = (float)0.0;
                deltas[i] = error[i]*activations[i]*(1-activations[i]);
        }
 
        //compute hidden layer errors
        int winx = numInputs*numHid; //offset into weight array
        for(i = firstOut ; i<numUnits ; i++) {
            for(j=firstHid1; j<firstOut; j++) {
                wDerivs[winx] += deltas[i]*activations[j];
                error[j] += weights[winx]*deltas[i];
                winx++;
            }
            tDerivs[i] += deltas[i];
        }
 
        //compute hidden layer deltas
        for(i=firstHid1 ; i<firstOut ; i++) {
            deltas[i] = error[i]*activations[i]*(1-activations[i]);
        }
 
        //compute input layer errors
        winx = 0; //offset into weight array
        for(i = firstHid1 ; i<firstOut ; i++) {
            for(j=0 ; j < firstHid1 ; j++) {
               wDerivs[winx] += deltas[j]*activations[j];
               error[j] += weights[winx]*deltas[i];
               winx++; 
            }
            tDerivs[i] += deltas[i];
        }
 
    }
 
    //apply the changes to the weights
    public void adjustWeights() {
        int i;
 
        //first walk through the weights array
        for(i=0; i<weights.length; i++) {
            wDeltas[i] = (learnRate*wDerivs[i]) + wDeltas[i];
            weights[i] += wDeltas[i]; //modify the weight
            wDerivs[i] = (float)0.0;
        }
    }
 
//Save the Neural Networks
    public void saveNetworks(String FileName) {
        if (FileName != null) {
            try {
                ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(FileName, false));
                out.writeInt(numInputs);
                out.writeInt(numOutputs);
                out.writeInt(numHid);
                out.writeInt(numUnits);
                out.writeInt(numWeights);
                out.writeFloat(bias);
                out.writeFloat(learnRate);
                //out.writeObject(activations);
                out.writeObject(weights);
                out.writeObject(error);
                out.writeObject(tDeltas);
                out.writeObject(deltas);
                out.writeObject(tDerivs);
                out.writeObject(wDerivs);
                out.close();
            } catch (Exception E) {
 
            }
        }
    }
 
 //Load a Neural Networks   
 public static NeuralNetworks loadNetworks(String FileName) {
        NeuralNetworks Net = null;
 
        if (FileName != null) {
            try {
                ObjectInputStream in = new ObjectInputStream(new FileInputStream(FileName));
                Net = new NeuralNetworks();
                Net.numInputs = in.readInt();
                Net.numOutputs = in.readInt();
                Net.numHid = in.readInt();
                Net.numUnits = in.readInt();
                Net.numWeights = in.readInt();
                Net.bias = in.readFloat();
                Net.learnRate = in.readFloat();                
                //Net.activations = (float[]) in.readObject();
                Net.weights = (float[]) in.readObject();
                Net.error = (float[]) in.readObject();
                Net.tDeltas = (float[]) in.readObject();
                Net.deltas = (float[]) in.readObject();
                Net.tDerivs = (float[]) in.readObject();
                Net.wDerivs = (float[]) in.readObject();
                in.close();
            } catch (Exception E) {
				Net = null;
            }
        }
        return Net;
    }
 
    public void process() {
        computeOutputs(); //do forward pass through network
        computeError(); //compute error and deltas
       adjustWeights(); //apply changes to weights
    }
 
}

et ma classe Start.java :

Code java :

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
 
 
package CheckersGame;
 
import com.thoughtworks.xstream.XStream;
 
 
public class Start {
 
public static void main(String[] argv) {
    NeuralNetworks nene = new NeuralNetworks();
    //nene.createNetwork(2,2,1,1);
    nene.loadNetworks("firstTrainAnd.txt");
    nene.getInputs();
    nene.process();
    XStream xstream = new XStream();
    System.out.println(xstream.toXML(nene));
    nene.saveNetworks("firstTrainAnd.txt");
 
}
 
}

Voilà je sais que c'est long mais j'espère que vous prendrez le temps de lire... Et j'espère avoir été assez claire dans mes explications.

Merci beaucoup

[Sivrît]

Ben normal : "nene.getInputs();" va taper dans Out[0]. Or "Out" n'est instancié que dans "createNetwork" dont l'appel est commenté.

Dans ces cas là je conseille l'utilisation d'un débugger, et de donner l'exception et toute sa pile d'appels quand on va dans un forum. Ca permet de savoir ce qui coince et comment on y est arrivé.

[ignis666]

un RdN pour jouer aux dame?
hum, ce n'est pas trop approprié, il vaudrait mieux utiliser une algo de resolution comme A*, NegaMax ou AlphaBeta enfin bon.

pour commencer il faur savoir quelles sont les donnée en entrées et en sorties
dans ton cas c par ex:
-les case du jeu de dame pour l'entrée
-et les case du jeu dans leur nouvelle configuration pour la sortie

ensuite il faut decider de quel type de reseau tu vas avoir besoin:
-retropropagation gradient
-WTA
-Hopfield
-etc

dans ton je ne sais pas le quel est le mieux adapté
tous ce que je peux fair c te donner mon code (en C++) avec un apprentissage par retropropagation du gradient
(comme c ca que tu utilise pour le moment...)

petite remarque a ce sujet ton coef d'apprentissage est trop elever alpha=0.001 ou moins en general
c pour cela qu'on doit fair un grand nombre d'apprentissage

vous me suivez toujours? non, bon je continu

ensuite il faut que tu code ton reseau, pour cela tu a besoin des classes:
-neurone
-couche (regroupe les neurones)
-reseau (le reseau en lui meme)

enfin il faut decider de combien de couche cache tu as besion et conbien de neuronne pour c couches
et ca c le plus dure car il n'y a aucun myenne de savoir s'il faut 1,2 ou 3 couche caché (en general 2 c le max)
et combien il faut de neuronne pour chacune (moi je fait la moyenne du nb de neuronne d'entre et de sortie, mais c pas une regle)

comme tu peut le voir les RdN ca fait mal a la tete

si tu veux le code dit le moi
mais je te previent il est pas forcement adapter a tes besion ni parfaitement au point

[brotelle]

Salut ignis666,

Je suis désolée je viens de voir ton post que maintenant.... Donc finalement mon réseau de neurones avec algorithme de rétropropagation fonctionne. Je suis en phase de test sur un petit réseau de neurones : 2 neurones d'entrée, 2 neurones sur la couche cachée (une seule couche cachée) et un neurone en sortie.
J'ai donc testé sur le patterne (1,1,1) (les deux premiers 1 c'est l'activation des deux neurones d'entrées, et le dernier 1 le résultat qu'on aimerait avoir) et il marche.
Maintenant je suis en train de l'entrainer avec les patternes ET.
Voici mon code d'entrainement :

Code java :

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
 
NeuralNetworks nene = new NeuralNetworks(2,2,1,1);
 
 
int epoch;
for (epoch=0; epoch<80; epoch++) {
 
nene.getInputs(1,1,1); //pattern one
nene.process();
 
nene.getInputs(1,0,0);//pattern two
nene.process();
 
nene.getInputs(0,1,0);//pattern three
nene.process();
 
nene.getInputs(0,0,0);//pattern four
nene.process();
 
 
}
saveNetworkXML(nene);

J'entraine le réseau de neurones sur les patternes ET un nombre d'époques. Ice le nombre d'époque est égal à 80. J'enregistre ensuite mon réseau de neurones entrainé, et il me donne une valeur de 6.8770136E-30 pour l'activation du neurones de sortie, ce qui est correcte car cette valeur est proche de zéro.

Ensuite, je réutilise ce réseau de neurones entrainé et je lui donne les valeurs (1,1) aux neurones d'entrées, et je vais simplement calculer l'activation du neurone de sortie sans faire de rétropropagation, ce qui devrait donner une valeur proche de 1.

Voici mon code :

Code java :

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

1
2
3
4
5
6
7
8
9
NeuralNetworks nene = new NeuralNetworks(2,2,1,1);
NeuralNetworks neneLoad = new NeuralNetworks(2,2,1,1);
 
nene = loadNetworkXML(neneLoad); //je charge le réseau de neurones entrainé
 
nene.getInputs(1,1,1); //je lui donne les neurones d'entrées, meme si je donne le neurone de sortie je ne vais pas l'utiliser
 
nene.computeOutputs();
saveNetworkXML(nene);

Or cela ne marche pas car cela me donne une valeur de 1.9790616E-34 pour le neurone de sortie... J'ai beau cherché mais je ne trouve pas où est le problème...

Pourriez-vous m'aider ?

Si vous avez besoin, je remettrais le code complet du réseau de neurones...

Merci

[ignis666]

alu

normalement pour fair un ET avec un RdN on a besoin que d'UN neuronne donc
je vois pas bien ou tu veux en venir avec cet exemple.

il faudrait voir la fonction de propagation et de repropagation
il se peut que l'algorythme ne soit pas bon
par ex: la constante d'apprentissage n'est pas bonne (typ: 10E-3)

de plus il ne faut pas faire apprendre trop au RdN sinon il ne fonctionne plus
en effet on peut approximer (a la louche) la courbe d'apprendtissage par un parabole ou le minimun est le lieu ou le RdN est le + performant donc si on fait trop apprendre on divient moins performant (c comme toi quand tu bosse trop les math tu finis par ne plus rien comprendre )

ensuite si tu fait apprendre la meme chose suivant toujours le meme ordre la aussi on a des pb d'apprentissage car le RdN reste sur la derniere valeur apprise.

je te met le code de mon RdN
il est fait pour reconnaitre les lettre de l'aphabet

avec un patron de lettre du type:
010
101
111 = A
101
101

3 couche (1 couche caché)
3*5 neurones d'entrees
10 neurone cachés
26 neurones de sortie

il est ecrit en C++ donc facillement traduisible en Java
tu remarquera le nombre d'apprentisasge est partiellement aleatoire et que l'ordre dl'apprentissage est COMPTEMENT alétoire.
les fonctions les + importantes sont Neurone::calcActivité et Neurone::updatePoids, se sont elles qui determinent comment le RdN apprend.

bon courage

[acx01b]

salut ignis666

le problème est que ton réseau ne fonctionne pas on dirait

voilà la sortie que j'ai avec 2000 apprentissages

verifications de l'apprentissage
essai de reconnaissance de A
sortie A = 0.039308
max: sortie Y = 0.048871
essai de reconnaissance de B
sortie B = 0.039073
max: sortie Y = 0.047513
essai de reconnaissance de C
sortie C = 0.034132
max: sortie Y = 0.043289
essai de reconnaissance de D
sortie D = 0.024631
max: sortie Y = 0.044491
essai de reconnaissance de E
sortie E = 0.044798
max: sortie Y = 0.050334
essai de reconnaissance de F
sortie F = 0.034318
max: sortie Y = 0.050334
essai de reconnaissance de G
sortie G = 0.027927
max: sortie Y = 0.044819
essai de reconnaissance de H
sortie H = 0.043516
max: sortie Y = 0.054097
essai de reconnaissance de I
sortie I = 0.031006
max: sortie Y = 0.044653
essai de reconnaissance de J
sortie J = 0.025961
max: sortie Y = 0.044653

[owomax]

Bonjour les Amis ,

Je suis un amoureux des réseaux de neurones et j'ai eu à lire plein de cours sur ce sujet. Mais jusque là, je n'ai pas encore compris comment ou sur quel base fonctionne la rétropropagation du gradient avec les MLP.
Je veux programmer un réseau de neurones ayant 2 couches: 2 neurones sur la couche cachée et 1 seul pour la sortie en vue de faire la régression de la fonction y=x^2.
Je m'étais dis que ce sera simple et qu'après je pourrai le tester avec les mêmes points de ma base d'apprentissage afin de m'assurer qu'il marche. J'ai choisi un intervalle x=[-2 2] avec un pas de 0.1 comme valeurs xi d'entrée de mon réseau ( qui n'a qu'une seule entrée outre le bias).
Au lieu de vous raconter des coups sur comment j'ai écris le programme qui m'a donné des poids ne permettant pas de calculer f(xi) pour tout xi de la base d'apprentissage mais qui arrive à faire une bonne regression en tracé, j'aimerais bien que vous m'aidiez à pouvoir écrire le bon algorithme me permettant d'obtenir une bonne régression et de bons résultats.
Si vous avez des conseils et suggestions ou des liens pouvant m'aider à résoudre ce problème, cela me ferait grandement plaisir.

un petit algo de votre part serait aussi le bienvenu. C'est vraiment urgent pour moi. ils'agit d'un TP de classe à remettre demain au plus grand tard.

[ToTo13]

Bonjour,

je ne peux pas trop aider brotelle sur la théorie, mais puisque tu programme en Java, est ce que tu as regardé du coté du package weka, qui propose déjà plusieurs RdN ?
Tu pourrais les utiliser ou au minimum te servir de ce package pour vérifier tes résultats.

[ignis666]

si cela peut aider je vous conseille Joone
c un prog de modelisation de RdN ecrit en java
il permet de faire des simulations et de faire varier un tas de parametres comme:
-le nombre de neurones
-l'algo d'apprentissage
-le bias
-etc

vous pouvez trouvez ce programme a l'adresse suivante:
http://www.jooneworld.com/

[owomax]

Bonjour,

Je voudrais que quelqu'un m'aide à écrire en quelques lignes fondamentalement, les codes algorithmiques de la méthode de Rétropropagation du gradient. J'aimerais bien que vous me donnez aussi quelques liens utiles pouvant m'aider à mieux comprendre des exemples pratiques en Réseaux de neurones.

Merci de me répondre