Changes in neuron struct

src/mnist/neural_network.c

@@ -208,7 +208,6 @@ void modification_du_reseau_neuronal(Reseau* reseau, uint32_t nb_modifs) {
             if (neurone->biais != 0 && PRINT_BIAIS)
                 printf("C %d\tN %d\tb: %f      \tDb: %f\n", i, j, neurone->biais,  (TAUX_APPRENTISSAGE/nb_modifs) * neurone->d_biais);
             neurone->biais -= (TAUX_APPRENTISSAGE/nb_modifs) * neurone->d_biais; // On modifie le biais du neurone à partir des données de la propagation en arrière
-
             neurone->d_biais = 0;
 
             if (neurone->biais > MAX_RESEAU)
@@ -241,7 +240,7 @@ void modification_du_reseau_neuronal(Reseau* reseau, uint32_t nb_modifs) {
 
 
 void initialisation_du_reseau_neuronal(Reseau* reseau) {
-    /* Initialise les variables du réseau neuronal (activation, biais, poids, ...)
+    /* Initialise les variables du réseau neuronal (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 */
     Neurone* neurone;
     double borne_superieure;
@@ -258,8 +257,6 @@ void initialisation_du_reseau_neuronal(Reseau* reseau) {
             borne_inferieure = -borne_superieure;
             ecart_bornes = borne_superieure - borne_inferieure;
 
-            neurone->activation = borne_inferieure + RAND_DOUBLE()*ecart_bornes;
-
             for (int k=0; k < reseau->couches[i+1]->nb_neurones; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié
                 neurone->poids_sortants[k] = borne_inferieure + RAND_DOUBLE()*ecart_bornes;
                 neurone->d_poids_sortants[k] = 0;

src/mnist/neural_network.h

@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 #include <math.h>
 #include <time.h>

src/mnist/neuron_io.c

@@ -17,16 +17,15 @@ Neurone* lire_neurone(uint32_t nb_poids_sortants, FILE *ptr) {
     fread(&activation, sizeof(float), 1, ptr);
     fread(&biais, sizeof(float), 1, ptr);
 
-    neurone->activation = activation;
     neurone->biais = biais;
 
     neurone->z = 0.0;
-    neurone->d_activation = 0.0;
+    neurone->last_d_biais = 0.0;
     neurone->d_biais = 0.0;
-    neurone->d_z = 0.0;
 
     float* poids_sortants = malloc(sizeof(float)*nb_poids_sortants);
 
+    neurone->last_d_poids_sortants = malloc(sizeof(float)*nb_poids_sortants);
     neurone->d_poids_sortants = malloc(sizeof(float)*nb_poids_sortants);
     neurone->poids_sortants = poids_sortants;
 
@@ -34,6 +33,7 @@ Neurone* lire_neurone(uint32_t nb_poids_sortants, FILE *ptr) {
         fread(&tmp, sizeof(float), 1, ptr);
         neurone->poids_sortants[i] = tmp;
         neurone->d_poids_sortants[i] = 0.0;
+        neurone->last_d_poids_sortants[i] = 0.0;
     }
 
     return neurone;
@@ -99,7 +99,6 @@ Reseau* lire_reseau(char* filename) {
 void ecrire_neurone(Neurone* neurone, int poids_sortants, FILE *ptr) {
     float buffer[poids_sortants+2];
 
-    buffer[0] = neurone->activation;
     buffer[1] = neurone->biais;
     for (int i=0; i < poids_sortants; i++) {
         buffer[i+2] = neurone->poids_sortants[i];

src/mnist/struct/neuron.h

@@ -2,17 +2,14 @@
 #define DEF_NEURON_H
 
 typedef struct Neurone{
-    float activation; // Caractérise l'activation du neurone
     float* poids_sortants; // Liste de tous les poids des arêtes sortants du neurone
     float biais; // Caractérise le biais du neurone
     float z; // Sauvegarde des calculs faits sur le neurone (programmation dynamique)
 
-    float d_activation; // Changement d'activation lors de la backpropagation
     float *d_poids_sortants; // Changement des poids sortants lors de la backpropagation
-    float *last_d_poids_sortants;
+    float *last_d_poids_sortants; // Dernier changement de d_poid_sortants
     float d_biais; // Changement du biais lors de la backpropagation
-    float last_d_biais;
+    float last_d_biais; // Dernier changement de d_biais
-    float d_z; // Quantité de changements générals à effectuer lors de la backpropagation
 } Neurone;
 
 

src/mnist/utils.c

@@ -91,19 +91,19 @@ void creer_reseau(char* filename, int sortie) {
             couche->neurones[j] = malloc(sizeof(Neurone));
             neurone = couche->neurones[j];
 
-            neurone->activation = 0.;
             neurone->biais = 0.;
             neurone->z = 0.;
 
-            neurone->d_activation = 0.;
             neurone->d_biais = 0.;
-            neurone->d_z = 0.;
+            neurone->last_d_biais = 0.;
 
             neurone->poids_sortants = malloc(sizeof(float)*neurones_par_couche[i+1]);
             neurone->d_poids_sortants = malloc(sizeof(float)*neurones_par_couche[i+1]);
+            neurone->last_d_poids_sortants = malloc(sizeof(float)*neurones_par_couche[i+1]);
             for (int k=0; k < neurones_par_couche[i+1]; k++) {
                 neurone->poids_sortants[k] = 0.;
                 neurone->d_poids_sortants[k] = 0.;
+                neurone->last_d_poids_sortants[k] = 0.;
             }
         }
     }

test/neuron_io.c

@@ -10,17 +10,17 @@ Neurone* creer_neurone(int nb_sortants) {
     Neurone* neurone = malloc(2*sizeof(float*)+6*sizeof(float));
     neurone->poids_sortants = malloc(sizeof(float)*nb_sortants);
     neurone->d_poids_sortants = malloc(sizeof(float)*nb_sortants);
+    neurone->last_d_poids_sortants = malloc(sizeof(float)*nb_sortants);
 
     for (int i=0; i < nb_sortants; i++) {
         neurone->poids_sortants[i] = 0.5;
         neurone->d_poids_sortants[i] = 0.0;
+        neurone->last_d_poids_sortants[i] = 0.0;
     }
-    neurone->activation = 0.0;
-    neurone->biais = 0.0;
     neurone->z = 0.0;
-    neurone->d_activation = 0.0;
+    neurone->biais = 0.0;
     neurone->d_biais = 0.0;
-    neurone->d_z = 0.0;
+    neurone->last_d_biais = 0.0;
 
     return neurone;
 }