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...

[frihat mohamed]

j'ai fait la création et l'apprentissage de réseaux de neurones avec matlab
la création avec la commande newff l'apprentissage avec la commande train
lors de la simulation de mon réseau avec la commande sim je constate que quel que soit l'entée toujours la sortie égale à 1
j' ai besoin de quelqu'un pour m'aider ( c'est mon projet de fin d'année)
merci d'avance

[Franck Dernoncourt]

Regarde l'exemple de la documentation ('doc newff') :

Here is a problem consisting of inputs P and targets T to be solved with a network.
P = [0 1 2 3 4 5 6 7 8 9 10];
T = [0 1 2 3 4 3 2 1 2 3 4];

Here a network is created with one hidden layer of five neurons.
net = newff(P,T,5);

The network is simulated and its output plotted against the targets.
Y = sim(net,P);
plot(P,T,P,Y,'o')

The network is trained for 50 epochs. Again the network's output is plotted.
net.trainParam.epochs = 50;
net = train(net,P,T);
Y = sim(net,P);
plot(P,T,P,Y,'o')

Sinon pour l'aide sur MATLAB tu auras probablement davantage de réponses sur la ML http://www.mathworks.com/matlabcentral/newsreader

[frihat mohamed]

j'ai fait la création et l'apprentissage de réseaux de neurones avec matlab
la création avec la commande newff l'apprentissage avec la commande train
lors de la simulation de mon réseau avec la commande sim je constate que quel que soit l'entée toujours la sortie égale à 1
j' ai besoin de quelqu'un pour m'aider ( c'est mon projet de fin d'année)
merci d'avance

[frihat mohamed]

merci FRANKY pour ta réponse
mon problème est avec LA COMMANDE SIM la sortie est toujours égalé a 1

[Franck Dernoncourt]

Envoie ton code ici ou sur http://www.mathworks.com/matlabcentral/newsreader, sans cela on ne peut pas voir d'où vient le problème.

[frihat mohamed]

sal=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.911 5.4038 1.1263 2.2542 5.178 0.6239 2.643 4.779 6.3231 1.2566 3.03 4.281 0.19101 2.5357 3.9086 5.9291 1.1735 3.0542 5.7635 1.253 3.467 5.3929 6.4064 1.683 3.3541 4.876 0.6887 2.6012 4.4208 6.4108];
sall=(sal-mean(sal))/std(sal);

BPT=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120 60 60 60 80 80 80 80 100 100 100 120 120 120 120 60 60 60 80 80 80 80 100 100 100 120 120 120 120 ];
BPTT= (BPT-mean(BPT))/std(BPT);
TE=[ 0.0710 0.0720 0.1780 0.1920 0.4400 0.5420 0.8030 0.9070 0.2410 0.3320 0.4610 0.5420 0.8160 0.8300 0.1180 0.1470 0.2510 0.3180 0.5240 0.5470 0.7890 0.7900 0.2130 0.3240 0.5160 0.5670 0.8560 0.9510 0.128 0.258 0.629 0.081 0.347 0.654 0.894 0.185 0.454 0.657 0.033 0.425 0.670 1.056 0.134 0.356 0.709 0.163 0.461 0.654 0.894 0.248 0.505 0.756 0.116 0.437 0.764 1.154];

TEE=(TE-mean(TE))/std(TE);
p=[sall;BPTT];
pr=minmax(p);
net=newff(pr,[4 1]);
sal1=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.9sal1=(sal1-mean(sal))/std(sal);
BPT1=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120]
11 5.4038];
BPT1=(BPT1-mean(BPT))/std(BPT);
TE1=[ 0.0710 0.0720 0.1780 0.1920 0.4400 0.5420 0.8030 0.9070 0.2410 0.3320 0.4610 0.5420 0.8160 0.8300 0.1180 0.1470 0.2510 0.3180 0.5240 0.5470 0.7890 0.7900 0.2130 0.3240 0.5160 0.5670 0.8560 0.9510] ;
TE1=(TE1-mean(TE))/std(TE);
trainv.P=[sal1;BPT1] ;
trainv.T=TE1 ;
sal2=[1.1263 2.2542 5.178 0.6239 2.643 4.779 6.3231 1.2566 3.03 4.281 0.19101 2.5357 3.9086 5.9291];

sal2=(sal2-mean(sal))/std(sal);

[Franck Dernoncourt]

Le code est coupé ici :

sal1=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.9sal1=(sal1-mean(sal))/std(sal);
BPT1=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120]
11 5.4038];

[frihat mohamed]

dzl j'ai pas envoyé tout le programme je t'envoyerai le programme

[frihat mohamed]

voici mon programme

% les données de reseaux (l'entrée: (sal, BPT ), la sortie:TE
sal=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.911 5.4038 1.1263 2.2542 5.178 0.6239 2.643 4.779 6.3231 1.2566 3.03 4.281 0.19101 2.5357 3.9086 5.9291 1.1735 3.0542 5.7635 1.253 3.467 5.3929 6.4064 1.683 3.3541 4.876 0.6887 2.6012 4.4208 6.4108];
sall=(sal-mean(sal))/std(sal);

BPT=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120 60 60 60 80 80 80 80 100 100 100 120 120 120 120 60 60 60 80 80 80 80 100 100 100 120 120 120 120 ];
BPTT= (BPT-mean(BPT))/std(BPT);
TE=[ 0.0710 0.0720 0.1780 0.1920 0.4400 0.5420 0.8030 0.9070 0.2410 0.3320 0.4610 0.5420 0.8160 0.8300 0.1180 0.1470 0.2510 0.3180 0.5240 0.5470 0.7890 0.7900 0.2130 0.3240 0.5160 0.5670 0.8560 0.9510 0.128 0.258 0.629 0.081 0.347 0.654 0.894 0.185 0.454 0.657 0.033 0.425 0.670 1.056 0.134 0.356 0.709 0.163 0.461 0.654 0.894 0.248 0.505 0.756 0.116 0.437 0.764 1.154];

TEE=(TE-mean(TE))/std(TE);
p=[sall;BPTT];
%creation de reseaux
pr=minmax(p);
net=newff(pr,[4 1]);
sal1=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.9sal1=(sal1-mean(sal))/std(sal);
%division de donées
BPT1=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120]
11 5.4038];
BPT1=(BPT1-mean(BPT))/std(BPT);
TE1=[ 0.0710 0.0720 0.1780 0.1920 0.4400 0.5420 0.8030 0.9070 0.2410 0.3320 0.4610 0.5420 0.8160 0.8300 0.1180 0.1470 0.2510 0.3180 0.5240 0.5470 0.7890 0.7900 0.2130 0.3240 0.5160 0.5670 0.8560 0.9510] ;
TE1=(TE1-mean(TE))/std(TE);
trainv.P=[sal1;BPT1] ;
trainv.T=TE1 ;
sal2=[1.1263 2.2542 5.178 0.6239 2.643 4.779 6.3231 1.2566 3.03 4.281 0.19101 2.5357 3.9086 5.9291];

sal2=(sal2-mean(sal))/std(sal);

BPT2= [60 60 60 80 80 80 80 100 100 100 120 120 120 120 ] ;

BPT2=(BPT2-mean(BPT))/std(BPT);
TE2= [ 0.128 0.258 0.629 0.081 0.347 0.654 0.894 0.185 0.454 0.657 0.033 0.425 0.670 1.056];
valv.P=[sal2;BPT2] ;
valv.T=TE2;
sal3=[ 1.1735 3.0542 5.7635 1.253 3.467 5.3929 6.4064 1.683 3.3541 4.876 0.6887 2.6012 4.4208 6.4108];
sal3=(sal3-mean(sal))/std(sal);
BPT3= [60 60 60 80 80 80 80 100 100 100 120 120 120 120] ;
BPT3=(BPT3-mean(BPT))/std(BPT);
TE3= [ 0.134 0.356 0.709 0.163 0.461 0.654 0.894 0.248 0.505 0.756 0.116 0.437 0.764 1.154];
TE3=(TE3-mean(TE))/std(TE) ;
testv.P=[sal3;BPT3];
testv.T=TE3 ;
%apprentissage de reseaux
[net,tr]=train( net,trainv.P,trainv.T,[],[],valv,testv)
%SIMULATION DE RESEAU
y=sim(net,[1.1735;60])

le probleme est au niveau de la simulation qq soit les entrées je trouve toujours y=1

[Franck Dernoncourt]

Le code est coupé ici :

sal1=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.9sal1=(sal1-mean(sal))/std(sal);
%division de donées
BPT1=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120]
11 5.4038];
BPT1=(BPT1-mean(BPT))/std(BPT);

[frihat mohamed]

Francry voici mon programme dans le programme précédent j'ai fait une faute (de copier coller) normalement j'ai pas de fautes au niveau des instructions de programme
% les données de reseaux (l'entrée: (sal, BPT ), la sortie:TE
sal=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.911 5.4038 1.1263 2.2542 5.178 0.6239 2.643 4.779 6.3231 1.2566 3.03 4.281 0.19101 2.5357 3.9086 5.9291 1.1735 3.0542 5.7635 1.253 3.467 5.3929 6.4064 1.683 3.3541 4.876 0.6887 2.6012 4.4208 6.4108];
sall=(sal-mean(sal))/std(sal);

BPT=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120 60 60 60 80 80 80 80 100 100 100 120 120 120 120 60 60 60 80 80 80 80 100 100 100 120 120 120 120 ];
BPTT= (BPT-mean(BPT))/std(BPT);
TE=[ 0.0710 0.0720 0.1780 0.1920 0.4400 0.5420 0.8030 0.9070 0.2410 0.3320 0.4610 0.5420 0.8160 0.8300 0.1180 0.1470 0.2510 0.3180 0.5240 0.5470 0.7890 0.7900 0.2130 0.3240 0.5160 0.5670 0.8560 0.9510 0.128 0.258 0.629 0.081 0.347 0.654 0.894 0.185 0.454 0.657 0.033 0.425 0.670 1.056 0.134 0.356 0.709 0.163 0.461 0.654 0.894 0.248 0.505 0.756 0.116 0.437 0.764 1.154];

TEE=(TE-mean(TE))/std(TE);
p=[sall;BPTT];
%creation de reseaux
pr=minmax(p);
net=newff(pr,[4 1]);
sal1=[0.6186 0.6369 1.5707 1.6867 3.735 4.5285 6.4212 7.1354 1.8504 2.5375 3.469 4.0254 5.8352 5.9126 0.7981 1.001 1.7117 2.151 3.473 3.618 5.0555 5.0648 1.2813 1.9457 3.0582 3.3534 4.911 5.4038] ;
sal1=(sal1-mean(sal))/std(sal);
%division de donées
BPT1=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120]
11 5.4038];
BPT1=(BPT1-mean(BPT))/std(BPT);
TE1=[ 0.0710 0.0720 0.1780 0.1920 0.4400 0.5420 0.8030 0.9070 0.2410 0.3320 0.4610 0.5420 0.8160 0.8300 0.1180 0.1470 0.2510 0.3180 0.5240 0.5470 0.7890 0.7900 0.2130 0.3240 0.5160 0.5670 0.8560 0.9510] ;
TE1=(TE1-mean(TE))/std(TE);
trainv.P=[sal1;BPT1] ;
trainv.T=TE1 ;
sal2=[1.1263 2.2542 5.178 0.6239 2.643 4.779 6.3231 1.2566 3.03 4.281 0.19101 2.5357 3.9086 5.9291];

sal2=(sal2-mean(sal))/std(sal);

BPT2= [60 60 60 80 80 80 80 100 100 100 120 120 120 120 ] ;

BPT2=(BPT2-mean(BPT))/std(BPT);
TE2= [ 0.128 0.258 0.629 0.081 0.347 0.654 0.894 0.185 0.454 0.657 0.033 0.425 0.670 1.056];
TE2=(TE2-mean(TE))/std(TE) ;
valv.P=[sal2;BPT2] ;
valv.T=TE2;
sal3=[ 1.1735 3.0542 5.7635 1.253 3.467 5.3929 6.4064 1.683 3.3541 4.876 0.6887 2.6012 4.4208 6.4108];
sal3=(sal3-mean(sal))/std(sal);
BPT3= [60 60 60 80 80 80 80 100 100 100 120 120 120 120] ;
BPT3=(BPT3-mean(BPT))/std(BPT);
TE3= [ 0.134 0.356 0.709 0.163 0.461 0.654 0.894 0.248 0.505 0.756 0.116 0.437 0.764 1.154];
TE3=(TE3-mean(TE))/std(TE) ;
testv.P=[sal3;BPT3];
testv.T=TE3 ;
%apprentissage de reseaux
[net,tr]=train( net,trainv.P,trainv.T,[],[],valv,testv)
%SIMULATION DE RESEAU
y=sim(net,[1.1735;60])

le probleme est au niveau de la simulation qq soit les entrées je trouve toujours y=1
MERCI énormément

[Franck Dernoncourt]

Le code est coupé ici :

BPT1=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120]
11 5.4038];

En fait je veux d'abord vérifier si tes sorties dans ton ensemble d'apprentissage ne sont pas toujours égales à 1 :-)

[frihat mohamed]

j'ai pas mis cette faute dans mon programme juste faute de copier coller
BPT1=[60 60 60 60 60 60 60 60 80 80 80 80 80 80 100 100 100 100 100 100 100 100 120 120 120 120 120 120]
11 5.4038]
il faut effacer la ligne (11 5.4038 ] )
lorsque ai tapé mon programme sur matlab j'ai vérifié au fur et au mesure les instructions
normalement le programme marche bien j'ai obtenu déjà les paramétrés de réseaux (les poids et les bias) et la courbes des erreurs en fct de nombres d'itérations
après j'ai voulu vérifier la performance de mon réseau alors je choisi une valeur da sal3 (ensemble de test) et sa valeur correspondante de BPT3 LA COMMANDE SIM ME DONNE TOUJOURS la sortie égale 1 c'est comme si le réseaux n'est pas appris alors que ce n'est pas le cas j'ai obtenue les courbes et les paramètres de réseaux

[Franck Dernoncourt]

mon problème est avec LA COMMANDE SIM la sortie est toujours égalé a 1

Pas toujours, par exemple :

Code :

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

1
2
3
4
5
>> y=sim(net,[0;2])
 
y =
 
    0.5785