Erreur lors de l’exécution.

Fermé
Jeremy - 11 févr. 2018 à 21:18
Bonjour,

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.