Discussion :

[aaronprince]

Bonjour,

Je dois écrire un programme en python pour faire un résau MLP (multilayer perceptron) en m'inspirant d'un code écrit en c le probleme est que je n'ai aucune connaissance en C
Du coup si quelqu'un peut me le traduire ou m'expliquer par quoi je dois remplacer les structures en c en python et d'autres explications je suis prenant !

Code C :

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
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
 
////////////////////////////////////////////////////////////////////////////////
 
//debut des structures de donnees
 
#define coef 2.0   //pente de la fonction sigmoide en zero
#define coed 1.0   //demi-pente (pour l'oprerateur derive)
 
// sera lue dans le fichier #define diment 26  //dimension de l'espace d'entree
#define dimsor 1   //dimension de l'espace de sortie
#define maxcar 50  //nombre maximum de caracteres pour les noms des fichiers
 
typedef struct // -- structure d'un neurone --
{
    int nbent;	//nombre d'entrees du neurone
    double *x;	//tableau des entrees X
    double *w;	//tableau des poids W
    double a;	//activation (somme ponderee des entrees = somme(WiXi))
    double s;	//sortie (fonction sigmoide de l'activation =f(a))
    double y;	//gradient
}strucNeurone;
 
 
typedef struct // -- structure d'une couche --
{
    int nbneu;		//nombre de neurones
    strucNeurone *neurone;	//tableau de neurones
}strucCouche;
 
 
typedef struct // -- structure d'un reseau --
{
  int nbcou;		//nombre de couches
  strucCouche *couche;	//tableau de couches
}strucReseau;
 
typedef struct // -- base d'exemples --
{
  int nbex;     //nombre d'exemples
  double **xx;  //vecteurs des entrees
  double **sd;  //vecteurs des sorties desirees
}strucBase;
 
strucReseau res;  //le reseau MLP
 
char nficapp[maxcar]; //nom du fichier d'apprentissage
char nficgen[maxcar]; //nom du fichier de generalisation
strucBase app,gen;    //les bases d'apprentissage et de generalisation
 
char nresult[maxcar]; //nom du fichier de stockage des resultats
FILE *ficresu;        //fichier dans lequel on stockera les parametres et les resultats
 
float alpha;  //coefficient d'apprentissage (pas de gradient)
int nbpass;   //nombre de passes de la base d'exemples
int diment;   //dimension d'entree
 
//fin des structures de donnees
 
/////////////////////////////////////////////////////////////////
 
//fonctions mathematiques ///////////////////
 
double sigmo(double a)    //fonction sigmoide -- s'applique a l'activation a
{
	double aux;
 
	aux=exp(coef*a);
	return((aux-1)/(aux+1));  //fonction impaire, a valeurs dans ]-1;+1[
}
 
double deriv(double fa)   //operateur derive -- s'applique a la sortie s=f(a)
{
  return(coed*(1+fa)*(1-fa));  //formule pour calculer f'(a) a partir de f(a)
}
 
//procedures d'initialisation ///////////////////
 
void initNeurone(int i, int k)
{
  int j;
 
  // printf("initialisation du neurone %d de la couche %d\n",i+1,k);
  res.couche[k].neurone[i].nbent=res.couche[k-1].nbneu;
  res.couche[k].neurone[i].x=(double*)malloc(sizeof(double)*res.couche[k].neurone[i].nbent);
  res.couche[k].neurone[i].w=(double*)malloc(sizeof(double)*res.couche[k].neurone[i].nbent);;
  for (j=0;j<res.couche[k].neurone[i].nbent;j++)
    { res.couche[k].neurone[i].w[j]=0.6*rand()/RAND_MAX-0.3;  //poids initiaux dans [-0.3;+0.3]
     // printf("w[%d,%d,%d]=%lf\t",i,j,k,res.couche[k].neurone[i].w[j]);
    }
}
 
void initCouche(int k)
{
  int i;
 
  printf("initialisation de la couche %d\n",k);
  if (k==0)                 // couche d'entree
    res.couche[k].nbneu=diment;
  else if (k==res.nbcou-1)  // couche de sortie
    res.couche[k].nbneu=dimsor;
  else                      // couches cachees
    { printf("\nNombre de neurones sur la couche cachee %d : ",k);
      scanf("\n%d",&res.couche[k].nbneu);
      fprintf(ficresu,"Nombre de neurones sur la couche cachee %d : %d\n",k,res.couche[k].nbneu);
    }
  res.couche[k].neurone=(strucNeurone*)malloc(sizeof(strucNeurone)*res.couche[k].nbneu);
  if (k>0)
    for (i=0;i<res.couche[k].nbneu;i++)  //initialisation de chaque neurone i de la couche k
      { // printf("\n -- appel initNeurone avec i=%d et k=%d\n",i,k);
        initNeurone(i,k);
      }
}
 
void initReseau()
{
  int k,nbcach;
 
  printf("initialisation du reseau MLP\n");
  printf("\nNombre de couches cachees : ");
  scanf("\n%d",&nbcach);
  res.nbcou=nbcach+2;
  fprintf(ficresu,"Nombre de couches cachees : %d\n",nbcach);
 
  res.couche=(strucCouche*)malloc(sizeof(strucCouche)*(nbcach+2));
  for (k=0;k<res.nbcou;k++)
    { printf("\n -- appel initCouche avec k=%d\n",k); initCouche(k);}
}
 
void initBase(char *nomfich, strucBase *base)
{
  int i,j;
  char c;
  FILE *fich;
 
  printf("Lecture des motifs, a partir du fichier %s\n",nomfich);
  fich=fopen(nomfich,"r");
  fscanf(fich,"%d",&(base->nbex));     //le nombre d'exemples est en 1ere ligne du fichier
  printf("nbex = %d \n",base->nbex);
  fscanf(fich,"%d",&diment);   //la dim. des entrees est en 2eme ligne du fichier
  printf("diment = %d \n",diment);
  base->xx=(double**)malloc(sizeof(double)*base->nbex);
  base->sd=(double**)malloc(sizeof(double)*base->nbex);
  for (i=0;i<base->nbex;i++)         //on lit, l'un apres l'autre, tous les exemples de la base
    { base->xx[i]=(double*)malloc(sizeof(double)*diment); //le vecteur des entrees, suivi de...
      for (j=0;j<diment;j++)
	fscanf(fich,"%lf",&(base->xx[i][j]));
      base->sd[i]=(double*)malloc(sizeof(double)*dimsor); //...le vecteur des sorties desirees
      for (j=0;j<dimsor;j++)
	fscanf(fich,"%lf",&(base->sd[i][j]));
    }
  fclose(fich);
  printf("fin de la lecture des motifs\n");
}
 
//procedures de presentation d'un exemple au reseau ///////////////////
 
void prezEntrees(int numex, strucBase base)  //presentation d'un exemple au reseau
{
  int i;
 
//les composantes de l'exemple numex sont les sorties des neurones de la couche 0 du reseau
  for (i=0;i<diment;i++)
      res.couche[0].neurone[i].s=base.xx[numex][i];
}
 
//procedures de fonctionnement du reseau ///////////////////
 
void aller()  //passe avant : calcul de la sortie du reseau, pour l'exemple presente
{
  int i,j,k;
 
  for (k=1;k<res.nbcou;k++)
    for (i=0;i<res.couche[k].nbneu;i++)
      { res.couche[k].neurone[i].a=0.0;
	for (j=0;j<res.couche[k].neurone[i].nbent;j++)
	  { res.couche[k].neurone[i].x[j]=res.couche[k-1].neurone[j].s;
	    res.couche[k].neurone[i].a+=res.couche[k].neurone[i].w[j]*res.couche[k].neurone[i].x[j];
	  }
	res.couche[k].neurone[i].s=sigmo(res.couche[k].neurone[i].a);
      }
}
 
void gradsor(int numex)  //calcul des gradients d'erreur, sur la couche de sortie
{
  int i;
  double dsig;  //derivee de la sigmoide
 
  for (i=0;i<dimsor;i++)
    { dsig=deriv(res.couche[res.nbcou-1].neurone[i].s);
      res.couche[res.nbcou-1].neurone[i].y=2*dsig*(app.sd[numex][i]-res.couche[res.nbcou-1].neurone[i].s);
    }
}
 
void retour()  //passe arriere : calcul des gradients retropropages, dans les couches cachees
{
  int i,m,k;
  double dsig;
  double somm;
 
  for (k=res.nbcou-2;k>0;k--)
    for (i=0;i<res.couche[k].nbneu;i++)
      { dsig=deriv(res.couche[k].neurone[i].s);
	somm=0.0;
	for(m=0;m<res.couche[k+1].nbneu;m++)
	  somm+=res.couche[k+1].neurone[m].w[i]*res.couche[k+1].neurone[m].y;
	res.couche[k].neurone[i].y=dsig*somm;
      }
}
 
void modifw()  //mise a jour des poids du reseau (toutes les couches)
{
  int i,j,k;
 
  for (k=1;k<res.nbcou;k++)
    for (i=0;i<res.couche[k].nbneu;i++)
      for (j=0;j<res.couche[k].neurone[i].nbent;j++)
	res.couche[k].neurone[i].w[j]+=alpha*res.couche[k].neurone[i].y*res.couche[k].neurone[i].x[j];
}
 
//fonctions d'evaluation des perfromances ///////////////////
 
int tstsor(int numex, strucBase base)  //resultat booleen -- version actuelle : pour dimsor=1
{
//test actuel implemente pour le seul cas ou il n'y a qu'une seule sortie, valant -1 ou +1
    if (res.couche[res.nbcou-1].neurone[0].s*base.sd[numex][0]>0)
      return(1);
    else
      return(0);
}
 
double tauxSucces(strucBase base)
{
  int i,nbsuc;
 
  nbsuc=0;
  for(i=0;i<base.nbex;i++)
    { prezEntrees(i,base);
      aller();
      if (tstsor(i,base)==1)
	nbsuc++;
    }
  return((double) nbsuc/base.nbex);
}
 
//procedure de controle des processus d'apprentissage et de generalisation ///////////////////
 
void melange(int n) //optionnel : change l'ordre de presentation des exemples
{
//non implemente actuellement
}
 
void appren(int nbpass) //apprentissage sur nbpass passes de la base d'exemples
{
//non implemente actuellement
}
 
void general()  //teste le reseau sur la base de generalisation
{
//non implemente actuellement
}
 
void appgen(int nbpass) //apprentissage avec test en generalisation a chaque passe
{
  int p,i;
  double taux;
 
  for (p=0;p<nbpass;p++)
    { printf("Passe n. %d\t",p+1);
      fprintf(ficresu,"Passe n. %d\t",p+1);
      for (i=0;i<app.nbex;i++) //une passe d'apprentissage sur toute la base d'exemples
	{ prezEntrees(i,app);
	  aller();
	  gradsor(i);
	  retour();
	  modifw();
	}
      taux=tauxSucces(app); //evaluation du taux de succes en apprentissage
      printf("taux app : %lf\t",taux);
      fprintf(ficresu,"taux app : %lf\t",taux);
      taux=tauxSucces(gen); //evaluation du taux de succes en generalisation
      printf("taux gen : %lf\n",taux);
      fprintf(ficresu,"taux gen : %lf\n",taux);
    }
}
 
/////////////////////////////////////////////////////////////////
 
//programme principal ///////////////////
 
void main()
{
  srand(1234);
  double tt1,tt2;
 
  printf("\nNom du fichier d'apprentissage : ");
  scanf("\n%s",nficapp);
  //strcpy(nficapp,"testOdeur/odeur8.app");
  printf("Nom du fichier de generalisation : ");
  scanf("\n%s",nficgen);
  //strcpy(nficgen,"testOdeur/odeur8.gen");
  printf("\nNom du fichier de resultats : ");
  scanf("\n%s",nresult);
  //strcpy(nresult,"toto");
 
  ficresu=fopen(nresult,"w");
  fprintf(ficresu,"Apprentissage sur %s\t",nficapp);
  printf("\n -- appel initBase, pour les donnees d'apprentissage\n");
  initBase(nficapp,&app);
  fprintf(ficresu,"  [ %d exemples ]\n",app.nbex);
  fprintf(ficresu,"Generalisation sur %s\t",nficgen);
  printf("\n -- appel initBase, pour les donnees de generalisation\n");
  initBase(nficgen,&gen);
  fprintf(ficresu,"  [ %d exemples ]\n",gen.nbex);
 
  printf("\nValeur du pas de gradient : ");
  scanf("%f",&alpha);
  fprintf(ficresu,"alpha=%f\t",alpha);
  printf("Nombre de passes de la base d'exemples : ");
  scanf("%d",&nbpass);
  fprintf(ficresu,"nbpass=%d\n",nbpass);
 
  fprintf(ficresu,"Taille de la couche d'entree = %d\n",diment);
  fprintf(ficresu,"Taille de la couche de sortie = %d\n",dimsor);
  printf("\n -- appel initReseau\n");
  initReseau();
 
  printf("\n\nPhase d'apprentissage, avec test en apprentissage et en generalisation, apres chaque passe de la base d'exemples.\n\n");
tt1=clock();
  appgen(nbpass);
tt2=clock(); printf("temps--->%f s\n",(tt2-tt1)*0.000001);
  fprintf(ficresu,"\ntemps--->%f s\n",(tt2-tt1)*0.000001);
 
  fclose(ficresu);
}
 
//fin du programme
 
/////////////////////////////////////////////////////////////////

j'ai essayé de commencer mais ça ne fonctionne pas :

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
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
import os
import sys
import math
import random
def dimsor():
    return 1
 
nficapp = input("Nom du fichier d'apprentissage : " )
nficgen = input("Nom du fichier de generalisation : " )
nresult = input("Nom du fichier de resultat : " )
try:
    ficresu = open(nresult, 'w')
except IOError:
    print(e)
    sys.exit(0)
 
 
class Base:
    "Base d'exemples"
    def __init__(self, fichier):
 
        print("Lecture des motifs, a partir du fichier ",fichier)
        f = open(fichier, 'r')
        self.nbex = [int(x) for x in f.readline().split()][0] 
        self.diment = [int(x) for x in f.readline().split()][0]
        self.dimsor = dimsor()
        self.entrees = []
        self.sorties_desirees = []
        for i in range(self.nbex):
            temp = [float(x) for x in f.readline().split()]
            # les self.diment premières valeurs
            self.entrees.append(temp[:self.diment])
            # les self.dimsor valeurs suivantes
            self.sorties_desirees.append(temp[self.diment:][:self.dimsor])
        f.close()
        print("fin de la lecture des motifs\n" )
 
    def __repr__(self):
        from pprint import pformat
        return pformat(vars(self)) 
print("Apprentissage sur ",nficapp,file = ficresu)
print(" -- Creation de la base, pour les donnees d'apprentissage" )
base_app = Base(nficapp)
print("  [  exemples ]",base_app.nbex,file = ficresu)
print(base_app)
 
print("Generalisation sur ",nficgen,file = ficresu)
print("-- Creation de la base, pour les donnees de generalisation" )
base_gen = Base(nficgen)
print("  [  exemples ]",base_gen.nbex,file = ficresu)
print(base_gen) 
alpha = input("Valeur du pas de gradient : " )
print("alpha = ",alpha, file = ficresu)
nbpass = input("Nombre de passes de la base d'exemples : " )
print("nbpass = ",nbpass, file = ficresu)
print("Taille de la couche d'entree = ",base_gen.diment, file = ficresu)
print("Taille de la couche de sortie = ",base_gen.dimsor , file = ficresu)
 
 
class Struct:
    "definition de la structure du reseau"
    def __init__(self,neurone,couche,reseau,base,MLP):
        #structure d'un neurone
        self.nbent=len(base_app.entrees)
        self.x=[]
        self.w=[]
        self.a=sum(w[i]*x[i])
        self.s=sigmo(a)
        self.y=ampha
        #structure d'une couche
        self.nbneu=int(nbneu)
        self.neurone=[]
        #structure d'un reseau
        self.nbcou=int(nbcou)
        self.couche=[]
        #structure de la base d'exemples
        self.nbex=int(nbex)
        self.xx=[[]]
        self.sd=[[]]
        #le reseau MLP
        self.alpha=float(alpha)
        self.nbpass=int(nbpass)
        self.diment=int(diment)
 
 
 
 
# fonctions mathématiques
def sigmo(a):
    aux = exp(coef*a)
    print("sigmo = ",((aux-1)/(aux+1)))
    return ((aux-1)/(aux+1))
 
def deriv(fa):
    print("deriv = ",(coed*(1+fa)*(1-fa)))
    return (coed*(1+fa)*(1-fa))
 
# procédures d'initialisation
 
def initNeurone(i,k):
    print("initialisation du neurone ",i+1,"de la couche ",k)
    for j in range(0,self.nbent):
        neurone = [[]]
        neurone[j] =[ base_app[i],base_app[i+1]]
        w[j] = random(-0.3,0.3)
 
def initCouche(k):
    global nbneucach
    print("initialisation de la couche ", k)
    if k==0:
        nbneu = base_app.diment
    if k==nbcou-1:
        nbneu = dimsor()
    else :
        nbneucach = int(input("Nombre de neurones sur la couche cachee : "))
        print("Nombre de neurones sur la couche cachee : ", nbneucach , file = ficresu)
 
    for i in range(0,nbneu):
         initNeurone(i,k)
 
def initReseau():
    global nbcou
    print("initialisation du reseau MLP\n")
    nbcoucach=int(input(("Nombre de couches cachees : ")))
    nbcou=nbcoucach+2
    print("Nombre de couches cachees : ",nbcoucach , file = ficresu)
    for k in range(0,nbcou):
        initCouche(k)
 
 
 
initReseau()    
 
ficresu.close()

[fifafou]

deja,dans ton programme,il n'y a qu'une classe alors que dans le code C,chaque

Code :

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

typedef struct

cree une classe qui sera utilisé avec le nom ecrit à la fin des }
ensuite,double signifie un decimal,pense a mettre un float(x) pour obliger l'argument a etre decimal

[aaronprince]

Alors voici ce que j'ai fait mais j'ai l'impression que ça ne met pas les valeurs du fichier dans ma liste pour creer les vecteur de neurone avec poids entree et sorties desirées et sorties obtenue , les passes dans l'algorthme me donnent toujours le meme résultat =(

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
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
import os
import sys
import random
import logging
import math
encore = 1
while encore == 1:
    encore=int(input("Lancer MLP ? (1=oui) (2=non)"))
 
    coef = 2.0
    coed = 1.0
 
    from pprint import pformat
 
    def dimsor():
        return 1
 
    class Neurone:
        """
        Un neurone avec parametre =  nombre d'entrees
        """
        def __init__(self, nbent):
            global nbentr
            self.x = [0.0 for i in range(nbent)]# tableau des entrees X
            self.w = [random.uniform(-0.3, 0.3) for i in range(nbent)]  # tableau des poids W
            print(self.w)
            self.a = 0.0  # activation (somme ponderee des entrees = somme(WiXi))
            self.s = 0.0  # sortie (fonction sigmoide de l'activation =f(a))
            self.y = 0.0  # gradient
            nbentr = len([0.0 for i in range(nbent)]) 
        def __repr__(self):
            return pformat(vars(self))
 
    class Couche:
        """
        Une couche avec parametre nombre de neurones
        et le nombre d'entrees d'un neurone de la couche
        """
        def __init__(self, nbneu, nbent):
            self.neurone = [Neurone(nbent) for i in range(nbneu)]
 
        def __repr__(self):
            return pformat(vars(self))
 
    class Reseau:
        """
        Reseau avec parametres dimensions entree, sortie, et couches cachées
        """
        def __init__(self, diment, dimsor, dimcaches):
            couches = [0, diment]
            couches.extend(dimcaches)
            couches.append(dimsor)
            self.couche = [Couche(couches[i], couches[i-1]) for i in range(1, len(couches))]
 
        def __repr__(self):
            return pformat(vars(self))
 
    class Base:
        """
        Base d'exemples
        """
        def __init__(self, fichier):
            try:
                print("Lecture des motifs, a partir du fichier :",fichier)
                f = open(fichier, 'r')
            except IOError as e:
                print(e)
                raise IOError
            else:
                self.nbex = [int(x) for x in f.readline().split()][0] 
                self.diment = [int(x) for x in f.readline().split()][0]
                self.dimsor = dimsor()
                self.entrees = []
                self.sorties_desirees = []
                for i in range(self.nbex):
                    temp = [float(x) for x in f.readline().split()]
                    self.entrees.append(temp[:self.diment])
 
                    self.sorties_desirees.append(temp[self.diment:][:self.dimsor])
                f.close()
                print("fin de la lecture des motifs" )
 
        def __repr__(self):
            return pformat(vars(self))
 
 
    ### nficapp = input("Nom du fichier d'apprentissage : " )
    nficapp="odeur5app.txt"
    ### nficgen = input("Nom du fichier de generalisation : " )
    nficgen = "odeur5gen.txt"
    ### nresult = input("Nom du fichier de resultat : " )
    nresult = "resu.txt"
 
    logging.basicConfig(
        level = logging.INFO,
        format = '%(message)s',
        filename = nresult,
        filemode = 'w')
 
 
    print("\n -- Creation de la base, pour les donnees d'apprentissage" )
    try:
        base_app = Base(nficapp)
    except IOError:
        logging.critical("Erreur a l'ouverture du fichier d'apprentissage %s", nficapp)
        sys.exit(0)
    logging.info("Apprentissage sur %s\t[ %d exemples ]", nficapp, base_app.nbex)
 
 
    print("\n  Creation de la base, pour les donnees de generalisation" )
    try:
        base_gen = Base(nficgen)
    except IOError:
        logging.critical(" Erreur a l'ouverture du fichier de generalisation %s", nficgen)
        sys.exit(0)
    logging.info("Generalisation sur %s\t[ %d exemples ]", nficgen, base_gen.nbex)
 
    alpha = float(input("\nValeur du pas de gradient : " ))
    #alpha = 0.5
    nbpass = int(input("Nombre de passes de la base d'exemples : " ))
    #nbpass = 10
    logging.info("alpha = %d\t nbpass = %d", alpha*10, nbpass)
 
    logging.info("Taille de la couche d'entree = %d", base_gen.diment)
    logging.info("Taille de la couche de sortie = %d", base_gen.dimsor)
 
    print("\ninitialisation du reseau MLP" )
    nbcach = int(input("\nNombre de couches cachees : " ))
    ##nbcach = 4
    dimcaches = []
    # couches cachees: parametrage par l'utilisateur
    for i in range(nbcach):
        nbneu = int(input("\nNombre de neurones sur la couche cachee {} : ".format(i+1)))
        #nbneu = 2
        dimcaches.append(nbneu)
        logging.info("Nombre de neurones sur la couche cachee %d : ", i)
        logging.info(" " , nbneu)
    reseau = Reseau(base_gen.diment, base_gen.dimsor, dimcaches)
 
    nbcou = nbcach + 2
    # fonctions mathématiques
    def sigmo(a):
        aux = math.exp(coef*a)
    ##    print("sigmo = ",((aux-1)/(aux+1)))
        return ((aux-1)/(aux+1))
    def deriv(fa):
    ##    print("deriv = ",(coed*(1+fa)*(1-fa)))
        return (coed*(1+fa)*(1-fa))
 
 
 
    def prezEntrees(numex , base):
        for i in range(1,base.diment):
            reseau.couche[0].neurone[i].s=base.entrees[numex][i]
 
    def aller():
        for k in range(1,nbcou):
            for i in range(0,len(reseau.couche[k].neurone)):
                reseau.couche[k].neurone[i].a=0.0
                for j in range(0,nbentr):
                    reseau.couche[k].neurone[i].x[j]=reseau.couche[k-1].neurone[j].s
                    reseau.couche[k].neurone[i].a+=reseau.couche[k].neurone[i].w[j]*reseau.couche[k].neurone[i].x[j]
                reseau.couche[k].neurone[i].s=sigmo(reseau.couche[k].neurone[i].a)
 
    def gradsor(numex):
        for i in range(0,dimsor()):
            dsig = deriv(reseau.couche[nbcou-1].neurone[i].s)
            reseau.couche[nbcou-1].neurone[i].y=2*dsig*(base_app.sorties_desirees[numex][i]-reseau.couche[nbcou-1].neurone[i].s)
 
 
    def retour():
        for k in range(nbcou-2,1):
            for i in range(0,len(reseau.couche[k].neurone)):
                dsig = deriv(reseau.couche[k].neurone[i].s)
                somm = 0.0
                for m in range(0,len(reseau.couche[k].neurone)):
                    somm+=(reseau.couche[k+1].neurone[m].w[i]*reseau.couche[k+1].neurone[m].y)
                reseau.couche[k].neurone[i].y=dsig*somm
 
 
    def modifiw():
        for k in range(1,nbcou):
            for i in range(0,len(reseau.couche[k].neurone)):
                for j in range(0,nbentr):
                    reseau.couche[k].neurone[i].w[j]+=alpha*reseau.couche[k].neurone[i].y*reseau.couche[k].neurone[i].entrees[j]
 
 
    def tstsor(numex,base):
        if (reseau.couche[nbcou-1].neurone[0].s*base.sorties_desirees[numex][0])>0:
            return 1
        else :
            return 0
 
 
    def tauxSucces(base):
        nbsuc = 0
        for i in range(0,base.nbex):
            prezEntrees(i,base)
            aller()
            if tstsor(i,base) == 1:
                nbsuc+=1
        return nbsuc/base.nbex
 
 
    def appgen(nbpass):
        for p in range(0,nbpass):
            print("passe n°:",p+1)
            logging.info("passe n°: %d",p+1)
            for i in range(base_app.nbex):
                prezEntrees(i,base_app)
                aller()
                gradsor(i)
                retour()
                modifiw()
        taux = 100*tauxSucces(base_app)
        print("taux app : ",taux,"%")
        logging.info("taux app : %s",taux)
        taux = 100*tauxSucces(base_gen)
        print("taux gen : ",taux , "%")
        logging.info("taux gen : %s",taux ,"%")
 
    appgen(nbpass)

faut -il que je rajoute des fonctions init neurone / couche / réseau comme dans l'algorithme en C , si oui comment m'y prendre ?

[fifafou]

Vu que je suis juste collégien,je ne comprend pas le code lui même et je n'ai pas de très grandes connaissances en C donc je ne peut plus t'aider mais tu pourrai essayer de poster ton problème sur le forum C/C++,vu que le python se comprend plus facilement que le C.

[chticricri]

Si tu ne connais pas le C mais le python, la traduction d'un tel programme promet d'être laborieuse.
En outre, à mimer dans un langage ce qu'on fait dans un autre, le résulta risque d'être difficile à lire.

Ne vaut-il mieux repartir de l'algorithme utilisé par le programme C ?