J'essaie de programmer un réseau de neurones en C++ mais je rencontre un problème: le programme se compile correctement mais lors de l’exécution il plante et me renvoie un code erreur (0xC0000005).
Je programme avec Code::Blocks.
Si quelqu'un peut m'indiquer ce que signifie cette erreur ce serait sympa, et merci d'avance.
PS: le code
main.cpp (certaines parties ne sont pas encore écrite mais elle ne devrai pas gêner l'execution.)
#include <iostream>
#include <cstdio>
#include <string>
#include "neurone.h"
using namespace std;
void charger_image(string texte);
void changer_exemple(string chemin);
int main()
{
unsigned int const nb_couches(4);
unsigned int taille_couches[nb_couches];
taille_couches[0] = 2;
taille_couches[1] = 2;
taille_couches[2] = 2;
taille_couches[3] = 1;
char image[taille_couches[0]];
double x[taille_couches[0]];
double p[taille_couches[nb_couches-1]], y[taille_couches[nb_couches-1]];
double alpha(0.1), alphak(alpha), beta(0.01), critere_arret(0.001);
Reseau reseau_neurone(nb_couches, taille_couches);
unsigned int i, j, k;
for (k = 0; alphak >= critere_arret ; k++)
{
alphak = alpha/(1+beta*k);
for (i = 0; i < taille_couches[0]; i++)
{
x[i]=image[i];
}
reseau_neurone.setX(x);
reseau_neurone.init();
reseau_neurone.propagation();
for (j = 0; j < taille_couches[nb_couches-1]; j++)
{
p[j] = reseau_neurone.sortie(j);
}
reseau_neurone.retropropagation(alphak);
}
return 0;
}
void charger_image(string texte, char tab[], int taille_tab)
{
FILE * f;
f = fopen(texte.c_str(), "rb");
if (f == NULL)
{
cout << "impossible d'ouvrir l'image en lecture !" << endl;
}
else
{
fread(tab, sizeof(char), taille_tab, f);
}
}
void changer_exemple(string chemin)
{
}
neurone.h
#ifndef NEURONE_H_INCLUDED
#define NEURONE_H_INCLUDED
#include <cmath>
#include <cstdlib>
#include <vector>
#include <iostream>
class Neurone
{
public:
Neurone(unsigned int xw_size);
~Neurone();
void setX(double x_1, unsigned int i);
void setW(double w_1, unsigned int i);
double return_s() const;
double return_a() const;
void sigma(unsigned int i);
void logistic();
private:
double x[];
double w[];
unsigned int xw_size;
double s; // Activité du neurone avant la non-linéarité logistique
double a; // Activité du neurone apres la fonction sigmoide
};
class Reseau
{
public:
Reseau(unsigned int nb_couches, unsigned int tab_couches[]);
~Reseau();
void setX(double x[]);
void setY(double y_1, unsigned int i);
void init();
void propagation();
void retropropagation(double taux_alpha);
double sortie(unsigned int nb_sortie) const;
private:
double ***w; // w[couche][neurone_prec][neurone]
double **s; // s[couche][neurone]
double **a; // a[couche][neurone]
double **delta;
double y[];
int couches;
unsigned int taille_couche[];
};
#endif // NEURONE_H_INCLUDED
neurone.cpp (là aussi, il manque certaines parties)
#include "neurone.h"
using namespace std;
// Neurone artificiel
Neurone::Neurone(unsigned int _size)
{
x[_size];
w[_size];
a = 0;
s = 0;
xw_size = _size;
}
Neurone::~Neurone()
{
}
void Neurone::setX(double x_1, unsigned int i)
{
x[i] = x_1;
}
void Neurone::setW(double w_1, unsigned int i)
{
w[i] = w_1;
}
double Neurone::return_s() const
{
return s;
}
double Neurone::return_a() const
{
return a;
}
void Neurone::sigma(unsigned int i)
{
s += x[i]*w[i];
}
void Neurone::logistic()
{
a = 1/(1 + exp(-s));
}
// Reseau de neurone
Reseau::Reseau(unsigned int nb_couches, unsigned int tab_couches[])
{
couches = nb_couches;
unsigned int i,j;
for (i = 0; i < nb_couches; i++)
{
taille_couche[i] = tab_couches[i];
}
y[taille_couche[couches-1]];
// Allocation dynamique tableau A
a = (double**)malloc(couches * sizeof(*a));
if (a == NULL)
{
cout << "Erreur construction D1 tableau 'a' " << endl;
}
for (i = 0; i < couches; i++)
{
a[i] = (double*)malloc(taille_couche[i] * sizeof(*(a[i])));
if (a[i] == NULL)
{
cout << "Erreur construction D2 tableau 'a' " << endl;
for(i = i-1 ; i >= 0 ; i--)
{
free(a[i]);
}
free(a);
}
}
// Allocation dynamique tableau S
s = (double**)malloc((couches-1) * sizeof(*s));
if (s == NULL)
{
cout << "Erreur construction D1 tableau 's' " << endl;
}
for (i = 1; i < couches; i++)
{
s[i] = (double*)malloc(taille_couche[i] * sizeof(*(s[i])));
if (s[i-1] == NULL)
{
cout << "Erreur construction D2 tableau 's' " << endl;
for(i = i-1 ; i >= 0 ; i--)
{
free(s[i-1]);
}
free(s);
}
}
// Allocation dynamique tableau w
w = (double***)malloc((couches-1) * sizeof(*w));
if(w == NULL)
{
cout << "Erreur construction D1 tableau 'w' " << endl;
}
for (i = 0; i < couches-1; i++)
{
w[i] = (double**)malloc(taille_couche[i] * sizeof(**w));
if (w[i] == NULL)
{
cout << "Erreur construction D2 tableau 'w' " << endl;
for(i = i-1 ; i >= 0 ; i--)
{
free(w[i]);
}
free(w);
}
}
for (i = 0; i < couches-1; i++)
{
for (j = 0; j < taille_couche[i]; j++)
{
w[i][j] = (double*)malloc(taille_couche[i+1] * sizeof(***w));
if (w[i][j] == NULL)
{
cout << "Erreur construction D3 tableau 'w' " << endl;
for(i = i-1 ; i >= 0 ; i--)
{
for (j = j-1 ; j >= 0 ; j--)
{
free(w[i][j]);
}
free(w[i]);
}
free(w);
}
}
}
// Allocation dynamique tableau delta
delta = (double**)malloc((couches-1) * sizeof(*delta));
if (delta == NULL)
{
cout << "Erreur construction D1 tableau 'delta' " << endl;
}
for (i = 1; i < couches; i++)
{
delta[i] = (double*)malloc(taille_couche[i] * sizeof(*(delta[i])));
if (delta[i-1] == NULL)
{
cout << "Erreur construction D2 tableau 'delta' " << endl;
for(i = i-1 ; i >= 0 ; i--)
{
free(delta[i-1]);
}
free(delta);
}
}
}
Reseau::~Reseau()
{
for (int i_1(0); i_1 < couches; i_1++)
{
free(a[i_1]);
}
free(a);
a = NULL;
for (int i_2(0); i_2 < couches-1; i_2++)
{
free(s[i_2]);
}
free(s);
s = NULL;
for (int i_3(0); i_3 < couches-1; i_3++)
{
for (unsigned int j(0); j < taille_couche[i_3]; j++)
{
free(w[i_3][j]);
}
free(w[i_3]);
}
free(w);
w = NULL;
for (int i_3(0); i_3 < couches-1; i_3++)
{
free(delta[i_3]);
}
free(delta);
delta = NULL;
}
void Reseau::setX(double x[])
{
for (unsigned int i(0); i < taille_couche[0]; i++)
{
a[0][i] = x[i];
}
}
void Reseau::setY(double y_1, unsigned int i)
{
y[i] = y_1;
}
void Reseau::init()
{
}
void Reseau::propagation()
{
Neurone * neurone;
for (int i(1); i < couches; i++)
{
for (unsigned int j(0); j < taille_couche[i]; j++)
{
neurone = new Neurone(taille_couche[i-1]);
for(unsigned int k(0); k < taille_couche[i-1]; k++)
{
neurone->setX(a[i-1][k], k);
neurone->setW(w[i-1][k][j], k);
neurone->sigma(k);
}
neurone->logistic();
s[i-1][j] = neurone->return_s();
a[i][j] = neurone->return_a();
delete neurone;
}
}
}
void Reseau::retropropagation(double taux_alpha)
{
unsigned int i, j, k;
double in(0);
for (i = 0; i < taille_couche[couches-1]; i++)
{
delta[couches-1][i] = y[i] - a[couches-1][i];
}
for (i = couches-2; i >= 0; i--)
{
for (j = taille_couche[i]-1; j >= 0; i--)
{
for (k = 0; k < taille_couche[i+1]; k++)
{
in += delta[i+1][k]*w[i+1][j][k];
}
delta[i][j] = a[i][j]*(1 - a[i][j])*in;
}
}
cout << "calcul delta fait" << endl;
for (int i_1(0); i_1 < couches-1; i_1++)
{
for(unsigned int j_1(0); j_1 < taille_couche[i_1]; j_1++)
{
for(unsigned int k_1(0); k_1 < taille_couche[i_1+1]; k_1++)
{
w[i_1][j_1][k_1] = w[i_1][j_1][k_1] + taux_alpha*a[i_1][j_1]*delta[i_1][k_1];
}
}
}
cout << "modification des poids fait" << endl;
}
double Reseau::sortie(unsigned int nb_sortie) const
{
return a[couches-1][nb_sortie];
}
PSS:
Je suis obligé de procéder par allocation dynamique pour les tableau multidimensionnels puisqu'il possèdent des lignes de différentes tailles.