From 991ecebcf46b2029a3423094aea13f2a74192377 Mon Sep 17 00:00:00 2001 From: Julien Chemillier Date: Mon, 28 Mar 2022 13:29:29 +0200 Subject: [PATCH] Change struct names --- src/mnist/neural_network.c | 84 +++++++++++++++++++------------------- src/mnist/neuron_io.c | 8 ++-- src/mnist/struct/neuron.c | 8 ++-- test/neuron_io.c | 10 ++--- 4 files changed, 55 insertions(+), 55 deletions(-) diff --git a/src/mnist/neural_network.c b/src/mnist/neural_network.c index 9c252c4..dd44519 100644 --- a/src/mnist/neural_network.c +++ b/src/mnist/neural_network.c @@ -24,15 +24,15 @@ void creation_du_reseau_neuronal(int* neurones_par_couche) { /* Créé les différentes variables dans la variable du réseau neuronal à partir du nombre de couches et de la liste du nombre de neurones par couche */ - reseau_neuronal->couche = (Couche*)malloc(sizeof(Couche)*reseau_neuronal->nb_couche); // Création des différentes couches - for (int i=0; inb_couche; i++) { + reseau_neuronal->couches = (Couche**)malloc(sizeof(Couche*)*reseau_neuronal->nb_couches); // Création des différentes couches + for (int i=0; inb_couches; i++) { - reseau_neuronal->couche[i].nb_neurone = neurones_par_couche[i]; // nombre de neurones pour la couche - reseau_neuronal->couche[i].neurone = (Neurone*)malloc(sizeof(Neurone)*neurones_par_couche[i]); // Création des différents neurones dans la couche + reseau_neuronal->couches[i]->nb_neurones = neurones_par_couche[i]; // nombre de neurones pour la couche + reseau_neuronal->couches[i]->neurones = (Neurone**)malloc(sizeof(Neurone*)*neurones_par_couche[i]); // Création des différents neurones dans la couche - if (i!=reseau_neuronal->nb_couche-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants + if (i!=reseau_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants for (int j=0; jcouche[i].neurone[j].poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]) ;// Création des poids sortants du neurone + reseau_neuronal->couches[i]->neurones[j]->poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]) ;// Création des poids sortants du neurone } } } @@ -46,13 +46,13 @@ void suppression_du_reseau_neuronal(int* neurones_par_couche) { 'creation_du_reseau_neuronal' à partir du nombre de couche et de la liste du nombre de neurone par couche */ - for (int i=0; inb_couche; i++) { - if (i!=reseau_neuronal->nb_couche-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants + for (int i=0; inb_couches; i++) { + if (i!=reseau_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants for (int j=0; jcouche[i].neurone[j].poids_sortants); // On libère la variables des poids sortants + free(reseau_neuronal->couches[i]->neurones[j]->poids_sortants); // On libère la variables des poids sortants } } - free(reseau_neuronal->couche[i].neurone); // On libère enfin la liste des neurones de la couche + free(reseau_neuronal->couches[i]->neurones); // On libère enfin la liste des neurones de la couche } free(reseau_neuronal); // Pour finir, on libère le réseau neronal contenant la liste des couches } @@ -64,22 +64,22 @@ void forward_propagation(int* neurones_par_couche) { /* Effectue une propagation en avant du réseau neuronal à partir du nombre de couches et de la liste du nombre de neurones par couche */ - for (int i=1; inb_couche; i++) { // La première couche contient déjà des valeurs + for (int i=1; inb_couches; i++) { // La première couche contient déjà des valeurs for (int j=0; jcouche[i].neurone[j].z = reseau_neuronal->couche[i].neurone[j].biais; // On réinitialise l'utilisation actuelle du neurone à son biais + reseau_neuronal->couches[i]->neurones[j]->z = reseau_neuronal->couches[i]->neurones[j]->biais; // On réinitialise l'utilisation actuelle du neurone à son biais for (int k=0; kcouche[i].neurone[j].z += reseau_neuronal->couche[i-1].neurone[k].activation * reseau_neuronal->couche[i-1].neurone[k].z * reseau_neuronal->couche[i-1].neurone[k].poids_sortants[i]; // ??? + reseau_neuronal->couches[i]->neurones[j]->z += reseau_neuronal->couches[i-1]->neurones[k]->activation * reseau_neuronal->couches[i-1]->neurones[k]->z * reseau_neuronal->couches[i-1]->neurones[k]->poids_sortants[i]; // ??? } - if (inb_couche-1) { // Pour toutes les couches sauf la dernière on utilise la fonction relu - if (reseau_neuronal->couche[i].neurone[j].z < 0) - reseau_neuronal->couche[i].neurone[j].activation = 0; + if (inb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction relu + if (reseau_neuronal->couches[i]->neurones[j]->z < 0) + reseau_neuronal->couches[i]->neurones[j]->activation = 0; else - reseau_neuronal->couche[i].neurone[j].activation = reseau_neuronal->couche[i].neurone[j].z; + reseau_neuronal->couches[i]->neurones[j]->activation = reseau_neuronal->couches[i]->neurones[j]->z; } else{ // Pour la dernière couche on utilise la fonction sigmoid permettant d'obtenir un résultat entre 0 et 1 étant une probabilité - reseau_neuronal->couche[i].neurone[j].activation = 1/(1 + exp(reseau_neuronal->couche[i].neurone[j].activation)); + reseau_neuronal->couches[i]->neurones[j]->activation = 1/(1 + exp(reseau_neuronal->couches[i]->neurones[j]->activation)); } } } @@ -94,7 +94,7 @@ int* creation_de_la_sortie_voulue(int* neurones_par_couche, int pos_nombre_voulu position du résultat voulue, */ int* sortie_voulue = (int*)malloc(sizeof(int)); - for (int i=0; inb_couche-1]; i++) // On initialise toutes les sorties à 0 par défault + for (int i=0; inb_couches-1]; i++) // On initialise toutes les sorties à 0 par défault sortie_voulue[i]=0; sortie_voulue[pos_nombre_voulu]=1; // Seule la sortie voulue vaut 1 return sortie_voulue; @@ -109,31 +109,31 @@ void backward_propagation(int* neurones_par_couche, int* sortie_voulue) { la liste des sorties voulues*/ // On commence par parcourir tous les neurones de la couche finale - for (int i=0; inb_couche-1]; i++) { + for (int i=0; inb_couches-1]; i++) { // On applique la formule de propagation en arrière - reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz = (reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].activation - sortie_voulue[i]) * (reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].activation) * (1- reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].activation); + reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz = (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->activation - sortie_voulue[i]) * (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->activation) * (1- reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->activation); - for(int k=0; knb_couche-2]; k++) { // Pour chaque neurone de l'avant dernière couche - reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].dw[i] = (reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz * reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].activation); - reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].dactivation = reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].poids_sortants[i] * reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz; + for(int k=0; knb_couches-2]; k++) { // Pour chaque neurone de l'avant dernière couche + reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->dw[i] = (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz * reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->activation); + reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->dactivation = reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->poids_sortants[i] * reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz; } // ??? - reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dbiais = reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz; + reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dbiais = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz; } - for(int i=reseau_neuronal->nb_couche-2; i>0; i--) { // On remonte les couche de l'avant dernière jusqu'à la première + for(int i=reseau_neuronal->nb_couches-2; i>0; i--) { // On remonte les couche de l'avant dernière jusqu'à la première for(int j=0; jcouche[i].neurone[j].z >= 0) // ??? ... - reseau_neuronal->couche[i].neurone[j].dz = reseau_neuronal->couche[i].neurone[j].dactivation; + if(reseau_neuronal->couches[i]->neurones[j]->z >= 0) // ??? ... + reseau_neuronal->couches[i]->neurones[j]->dz = reseau_neuronal->couches[i]->neurones[j]->dactivation; else // ??? ... - reseau_neuronal->couche[i].neurone[j].dz = 0; + reseau_neuronal->couches[i]->neurones[j]->dz = 0; for(int k=0; kcouche[i-1].neurone[k].dw[j] = reseau_neuronal->couche[i].neurone[j].dz * reseau_neuronal->couche[i-1].neurone[k].activation; + reseau_neuronal->couches[i-1]->neurones[k]->dw[j] = reseau_neuronal->couches[i]->neurones[j]->dz * reseau_neuronal->couches[i-1]->neurones[k]->activation; if(i>1) // ??? ... - reseau_neuronal->couche[i-1].neurone[k].dactivation = reseau_neuronal->couche[i-1].neurone[k].poids_sortants[j] * reseau_neuronal->couche[i].neurone[j].dz; + reseau_neuronal->couches[i-1]->neurones[k]->dactivation = reseau_neuronal->couches[i-1]->neurones[k]->poids_sortants[j] * reseau_neuronal->couches[i]->neurones[j]->dz; } - reseau_neuronal->couche[i].neurone[j].dbiais = reseau_neuronal->couche[i].neurone[j].dz; // ??? ... + reseau_neuronal->couches[i]->neurones[j]->dbiais = reseau_neuronal->couches[i]->neurones[j]->dz; // ??? ... } } @@ -146,11 +146,11 @@ void modification_du_reseau_neuronal(int* neurones_par_couche) { /* Modifie les poids et le biais des neurones du réseau neuronal à partir du nombre de couches et de la liste du nombre de neurone par couche */ - for (int i=0; inb_couche-1; i++) { // on exclut la dernière couche + for (int i=0; inb_couches-1; i++) { // on exclut la dernière couche for (int j=0; icouche[i].neurone[j].biais = reseau_neuronal->couche[i].neurone[j].biais - (TAUX_APPRENTISSAGE * reseau_neuronal->couche[i].neurone[j].dbiais); // On modifie le biais du neurone à partir des données de la propagation en arrière + reseau_neuronal->couches[i]->neurones[j]->biais = reseau_neuronal->couches[i]->neurones[j]->biais - (TAUX_APPRENTISSAGE * reseau_neuronal->couches[i]->neurones[j]->dbiais); // On modifie le biais du neurone à partir des données de la propagation en arrière for (int k=0; kcouche[i].neurone[j].poids_sortants[k] = reseau_neuronal->couche[i].neurone[j].poids_sortants[k] - (TAUX_APPRENTISSAGE * reseau_neuronal->couche[i].neurone[j].dw[k]); // On modifie le poids du neurone à partir des données de la propagation en arrière + reseau_neuronal->couches[i]->neurones[j]->poids_sortants[k] = reseau_neuronal->couches[i]->neurones[j]->poids_sortants[k] - (TAUX_APPRENTISSAGE * reseau_neuronal->couches[i]->neurones[j]->dw[k]); // On modifie le poids du neurone à partir des données de la propagation en arrière } } } @@ -163,21 +163,21 @@ void initialisation_du_reseau_neuronal(int* neurones_par_couche) { /* Initialise les variables du réseau neuronal (activation, biais, poids, ...) en suivant de la méthode de Xavier ...... à partir du nombre de couches et de la liste du nombre de neurone par couche */ srand(time(0)); - for (int i=0; inb_couche-1; i++) { // on exclut la dernière couche + for (int i=0; inb_couches-1; i++) { // on exclut la dernière couche for (int j=0; jcouche[i].neurone[j].poids_sortants[k] = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // Initialisation des poids sortants aléatoirement - reseau_neuronal->couche[i].neurone[j].dw[k] = 0.0; // ... ??? + reseau_neuronal->couches[i]->neurones[j]->poids_sortants[k] = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // Initialisation des poids sortants aléatoirement + reseau_neuronal->couches[i]->neurones[j]->dw[k] = 0.0; // ... ??? } if(i>0) // Pour tous les neurones n'étant pas dans la première couche - reseau_neuronal->couche[i].neurone[j].biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement + reseau_neuronal->couches[i]->neurones[j]->biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement } } - double borne_superieure = 1/sqrt(neurones_par_couche[reseau_neuronal->nb_couche-1]); + double borne_superieure = 1/sqrt(neurones_par_couche[reseau_neuronal->nb_couches-1]); double borne_inferieure = - borne_superieure; - for (int j=0; jnb_couche-1]; j++) // Pour chaque neurone de la dernière couche - reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[j].biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement + for (int j=0; jnb_couches-1]; j++) // Pour chaque neurone de la dernière couche + reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[j]->biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement } diff --git a/src/mnist/neuron_io.c b/src/mnist/neuron_io.c index 1084a8f..be436f5 100644 --- a/src/mnist/neuron_io.c +++ b/src/mnist/neuron_io.c @@ -70,7 +70,7 @@ void ecrire_neurone(Neurone* neurone, int poids_sortants, FILE *ptr) { // Stocke l'entièreté du réseau neuronal dans un fichier binaire int ecrire_reseau(char* filename, Reseau* reseau) { FILE *ptr; - int nb_couches = reseau->nb_couche; + int nb_couches = reseau->nb_couches; int nb_neurones[nb_couches+1]; ptr = fopen(filename, "wb"); @@ -80,8 +80,8 @@ int ecrire_reseau(char* filename, Reseau* reseau) { buffer[0] = MAGIC_NUMBER; buffer[1] = nb_couches; for (int i=0; i < nb_couches; i++) { - buffer[i+2] = reseau->couche[i]->nb_neurone; - nb_neurones[i] = reseau->couche[i]->nb_neurone; + buffer[i+2] = reseau->couches[i]->nb_neurones; + nb_neurones[i] = reseau->couches[i]->nb_neurones; } nb_neurones[nb_couches] = 0; @@ -89,7 +89,7 @@ int ecrire_reseau(char* filename, Reseau* reseau) { for (int i=0; i < nb_couches; i++) { for (int j=0; j < nb_neurones[i]; j++) { - ecrire_neurone(reseau->couche[i]->neurone[j], nb_neurones[i+1], ptr); + ecrire_neurone(reseau->couches[i]->neurones[j], nb_neurones[i+1], ptr); } } diff --git a/src/mnist/struct/neuron.c b/src/mnist/struct/neuron.c index adc98c4..b87e320 100644 --- a/src/mnist/struct/neuron.c +++ b/src/mnist/struct/neuron.c @@ -12,11 +12,11 @@ typedef struct Neurone{ typedef struct Couche{ - int nb_neurone; // Nombre de neurones dans la couche (longueur de la liste ci-dessous) - Neurone** neurone; // Liste des neurones dans la couche + int nb_neurones; // Nombre de neurones dans la couche (longueur de la liste ci-dessous) + Neurone** neurones; // Liste des neurones dans la couche } Couche; typedef struct Reseau{ - int nb_couche; - Couche** couche; + int nb_couches; + Couche** couches; } Reseau; diff --git a/test/neuron_io.c b/test/neuron_io.c index 27d4805..3adf199 100644 --- a/test/neuron_io.c +++ b/test/neuron_io.c @@ -30,8 +30,8 @@ Couche* creer_couche(int nb_neurones, int nb_sortants) { Couche* couche = malloc(sizeof(int)+sizeof(Neurone**)); Neurone** tab = malloc(sizeof(Neurone*)*nb_neurones); - couche->nb_neurone = nb_neurones; - couche->neurone = tab; + couche->nb_neurones = nb_neurones; + couche->neurones = tab; for (int i=0; icouche = malloc(sizeof(Couche*)*nb_couches); + reseau->couches = malloc(sizeof(Couche*)*nb_couches); int nb_neurones[nb_couches+1]; - reseau->nb_couche = nb_couches; + reseau->nb_couches = nb_couches; for (int i=0; i < nb_couches; i++) { nb_neurones[i] = i*(nb_min_neurones-nb_max_neurones)/(nb_couches-1) + nb_max_neurones; @@ -53,7 +53,7 @@ Reseau* creer_reseau(int nb_couches, int nb_max_neurones, int nb_min_neurones) { nb_neurones[nb_couches] = 0; for (int i=0; i < nb_couches; i++) { - reseau->couche[i] = creer_couche(nb_neurones[i], nb_neurones[i+1]); + reseau->couches[i] = creer_couche(nb_neurones[i], nb_neurones[i+1]); } return reseau; }