Bonjour,

Je code une IA pour un projet et je suis confronté à un petit problème sur mon réseau.

J'aurais besoin de vos conseils sur ce petit bout de code :

void afficheReseau(Reseau * r){
  int i,j,k;
  int couche_precedente = 0;
  fprintf(stderr, "     Le réseau contient :\n");
  for (i = 0; i < r->nbr_couche; i++) {
    fprintf(stderr, "         Dans la couche %d :\n", i);
    for (j = 0; j < r->nbr_par_couche[i]; j++) {
      fprintf(stderr, "             - Le neurones %d à pour paramètres : \n", j);
      fprintf(stderr, "                 - Poids : [ ");
      for (size_t k = 0; k < r->nbr_par_couche[couche_precedente]; k++) {
        fprintf(stderr, "%f, ", r->couches_contenus[i][j]->poids[k]);
      }
      fprintf(stderr, "]\n");
      fprintf(stderr, "                 - Biais : %f", r->couches_contenus[i][j]->biais);
      fprintf(stderr, "                 - Sensibilité : %f ", r->couches_contenus[i][j]->sensibilite);
      fprintf(stderr, "                 - Résultat : %f ",r->couches_contenus[i][j]->results);

    }
  }

}

Mes structures de données sont :

typedef struct{

  	double * poids;

  	double biais;

  	double sensibilite;

  	double results;

  } Neurone;

  typedef struct{

    int nbr_couche;

    int nbr_max_par_couche;

    int * nbr_par_couche;

  	Neurone *** couches_contenus;

  } Reseau;

Le choix de la structure en "Neurone ***" est motivé par le fait que je doive enregistrer et surtout charger le réseau à partir d'un fichier, la taille d'une couche à l'autre étant variable tout comme le tableau des poids entre les différents neurones sans cette implantation la création renvoie des erreurs de stack overflow. 

Voici ce qui s'affiche en console lors de l'exécution sur un réseau exemple :

-------------------------------------------
 Teste de d'affichage d'un réseau

     Le réseau contient :
         Dans la couche 0 :
             - Le neurones 0 à pour paramètres : 
                 - Poids : [ Segmentation fault: 11

Si vous arrivez à trouver l'erreur je veux bien un coup de pouce car je viens d'y passer 3h et je ne vois pas (ou plus ...)

Salut,

Je pense que ca vient de la ligne 10, tu declares k de type size_t mais il est deja int.

Et tu n'incrémentes jamais couche_precedente.

-
Edité par thetui 17 mai 2017 à 9:00:57

C'était un typo (auto complétion de mon éditeur)

Je viens de faire la modification mais pas de changement dans l'erreur ^^' 

Pas de soucis voici la partie du main concernée et la fonction de déclaration du réseau de teste :

Reseau * test_creat(Reseau * r);

void afficheReseau(Reseau * r);

int main(int argc,char *argv[]){
  fprintf(stderr,"\n\n\n************************************************\n");
  fprintf(stderr,"******* Début des teste réseau de neurones *****\n");
  fprintf(stderr,"************************************************\n\n\n\n\n\n");

  Reseau r;
  Reseau * pr = &r;

  fprintf(stderr," -------------------------------------------\n");
  fprintf(stderr," Teste de création d'un réseau\n\n");
  pr = test_creat(&r);
  r = *pr;
  fprintf(stderr," Teste de création : OK  \n");
  fprintf(stderr," -------------------------------------------\n\n\n\n\n\n");

  fprintf(stderr," -------------------------------------------\n");
  fprintf(stderr," Teste de d'affichage d'un réseau\n\n");
  afficheReseau(&r);
  fprintf(stderr," Teste de d'affichage : OK  \n");
  fprintf(stderr," -------------------------------------------\n\n\n\n\n\n");

return 0;
}


Reseau * test_creat(Reseau * r){

  Neurone n1,n2,n3,n4,n5,n6,n7;

  // Initialisation des Poids
  fprintf(stderr," Malloc des poids neurone : ");
  n1.poids = malloc(sizeof(double)*2);
  if (n1.poids == NULL) {
    fprintf(stderr,"     Malloc FAIL 1 ");
  }
  n2.poids = malloc(sizeof(double)*2);
  if (n2.poids == NULL) {
    fprintf(stderr,"     Malloc FAIL 2 ");
  }
  n3.poids = malloc(sizeof(double)*2);
  if (n3.poids == NULL) {
    fprintf(stderr,"     Malloc FAIL 3 ");
  }
  n4.poids = malloc(sizeof(double)*2);
  if (n4.poids == NULL) {
    fprintf(stderr,"     Malloc FAIL 4 ");
  }
  n5.poids = malloc(sizeof(double)*2);
  if (n5.poids == NULL) {
    fprintf(stderr,"     Malloc FAIL 5 ");
  }
  n6.poids = malloc(sizeof(double)*2);
  if (n6.poids == NULL) {
    fprintf(stderr,"     Malloc FAIL 6 ");
  }
  n7.poids = malloc(sizeof(double)*2);
  if (n7.poids == NULL) {
    fprintf(stderr,"     Malloc FAIL 7 ");
  }
  fprintf(stderr,"OK \n");
  fprintf(stderr," Attribution des valeurs neurones : ");
  n1.poids[0] = 0.0;
  n2.poids[0] = 0.0;
  n3.poids[0] = 0.5;
  n4.poids[0] = -1.0;
  n5.poids[0] = 1.0;
  n6.poids[0] = -1.0;
  n7.poids[0] = 1.0;

  n1.poids[1] = 0.0;
  n2.poids[1] = 0.0;
  n3.poids[1] = 1.5;
  n4.poids[1] = -2.0;
  n5.poids[1] = 3.0;
  n6.poids[1] = -4.0;
  n7.poids[1] = -3.0;

  // Initialisation des biais
  n1.biais = 0.0;
  n2.biais = 0.0;
  n3.biais = 0.0;
  n4.biais = 0.0;
  n5.biais = 0.0;
  n6.biais = 0.0;
  n7.biais = 0.0;

  // Initialisation de la sensibilite
  n1.sensibilite = 0.0;
  n2.sensibilite = 0.0;
  n3.sensibilite = 0.0;
  n4.sensibilite = 0.0;
  n5.sensibilite = 0.0;
  n6.sensibilite = 0.0;
  n7.sensibilite = 0.0;

  // Initialisation des resultats
  n1.results = 2.0;
  n2.results = -1.0;
  n3.results = 0.0;
  n4.results = 0.0;
  n5.results = 0.0;
  n6.results = 0.0;
  n7.results = 0.0;
  fprintf(stderr,"OK \n");

  // Initialisation du réseau
  fprintf(stderr," Création du réseau : ");
  r->nbr_couche = 4;
  r->nbr_max_par_couche = 2;

  r->nbr_par_couche = malloc(sizeof(int)*4);
  r->nbr_par_couche[0] = 2;
  r->nbr_par_couche[1] = 2;
  r->nbr_par_couche[2] = 2;
  r->nbr_par_couche[3] = 1;

  r->couches_contenus = malloc(sizeof(Neurone **)*4);
  r->couches_contenus[0] = malloc(sizeof(Neurone *)*2);
  r->couches_contenus[1] = malloc(sizeof(Neurone *)*2);
  r->couches_contenus[2] = malloc(sizeof(Neurone *)*2);
  r->couches_contenus[3] = malloc(sizeof(Neurone *));
  fprintf(stderr,"OK \n");

  fprintf(stderr," Peuplage du réseau : ");
  r->couches_contenus[0][0] = &n1;
  if (r->couches_contenus[0][0] == NULL) {
    fprintf(stderr," \n ERREUR 1 ");
  }
  r->couches_contenus[0][1] = &n2;
  if (r->couches_contenus[0][1] == NULL) {
    fprintf(stderr," \n ERREUR 2 ");
  }
  r->couches_contenus[1][0] = &n3;
  if (r->couches_contenus[1][0] == NULL) {
    fprintf(stderr," \n ERREUR 3 ");
  }
  r->couches_contenus[1][1] = &n4;
  if (r->couches_contenus[1][1] == NULL) {
    fprintf(stderr," \n ERREUR 4 ");
  }
  r->couches_contenus[2][0] = &n5;
  if (r->couches_contenus[2][0] == NULL) {
    fprintf(stderr," \n ERREUR 5 ");
  }
  r->couches_contenus[2][1] = &n6;
  if (r->couches_contenus[2][1] == NULL) {
    fprintf(stderr," \n ERREUR 6 ");
  }
  r->couches_contenus[3][0] = &n7;
  if (r->couches_contenus[3][0] == NULL) {
    fprintf(stderr," \n ERREUR 7 ");
  }
  if (r->couches_contenus[0][0]->poids[0] == 0.0 && r->couches_contenus[0][0]->poids[1] == 0.0 &&
      r->couches_contenus[0][1]->poids[0] == 0.0 && r->couches_contenus[0][1]->poids[1] == 0.0 &&
      r->couches_contenus[1][0]->poids[0] == 0.5 && r->couches_contenus[1][0]->poids[1] == 1.5 &&
      r->couches_contenus[1][1]->poids[0] == -1.0 && r->couches_contenus[1][1]->poids[1] == -2.0 &&
      r->couches_contenus[2][0]->poids[0] == 1.0 && r->couches_contenus[2][0]->poids[1] == 3.0 &&
      r->couches_contenus[2][1]->poids[0] == -1.0 && r->couches_contenus[2][1]->poids[1] == -4.0 &&
      r->couches_contenus[3][0]->poids[0] == 1.0 && r->couches_contenus[3][0]->poids[1] == -3.0) {
    fprintf(stderr,"OK \n\n");
  } else{
    fprintf(stderr,"NOP \n\n");
  }
  return r;
}

Salut

Quant tu crées ton réseau, les neurones que tu assignes a ton réseau sont alloues sur la stack de la fonction, et ne sont plus "valable" quand tu en sors.

Forcément ça pète quand tu essaies d'y accéder lors de l'affichage de ton réseau

Yep en effet erreur de débutant déso ^^',

Je viens de modifier tout ça avec des pointeurs sur lesquels je fait un malloc(sizeof(Neurone))

Merci pour le coup de main.