diff --git a/src/mnist/main.c b/src/mnist/main.c
index 26b73d2..3ced45b 100644
--- a/src/mnist/main.c
+++ b/src/mnist/main.c
@@ -42,7 +42,7 @@ void help(char* call) {
 void ecrire_image_dans_reseau(int** image, Reseau* reseau, int height, int width) {
     for (int i=0; i < height; i++) {
         for (int j=0; j < width; j++) {
-            reseau->couches[0]->neurones[i*height+j]->activation = (float)image[i][j] / 255.0;
+            reseau->couches[0]->neurones[i*height+j]->z = (float)image[i][j] / 255.0;
         }
     }
 }
diff --git a/src/mnist/neural_network.c b/src/mnist/neural_network.c
index adc94fa..1a63130 100644
--- a/src/mnist/neural_network.c
+++ b/src/mnist/neural_network.c
@@ -26,23 +26,23 @@ float ReLU(float x){
     return max(x, 0);
 }
 
-void creation_du_reseau_neuronal(Reseau* reseau_neuronal, int* neurones_par_couche, int nb_couches) {
+void creation_du_reseau_neuronal(Reseau* reseau, int* neurones_par_couche, int nb_couches) {
     /* Créé et alloue de la mémoire aux différentes variables dans le réseau neuronal*/
     Couche* couche;
 
-    reseau_neuronal->nb_couches = nb_couches;
-    reseau_neuronal->couches = (Couche**)malloc(sizeof(Couche*)*nb_couches);
+    reseau->nb_couches = nb_couches;
+    reseau->couches = (Couche**)malloc(sizeof(Couche*)*nb_couches);
 
     for (int i=0; i < nb_couches; i++) {
-        reseau_neuronal->couches[i] = (Couche*)malloc(sizeof(Couche));
-        couche = reseau_neuronal->couches[i];
+        reseau->couches[i] = (Couche*)malloc(sizeof(Couche));
+        couche = reseau->couches[i];
         couche->nb_neurones = neurones_par_couche[i]; // nombre de neurones pour la couche
-        couche->neurones = (Neurone**)malloc(sizeof(Neurone*)*reseau_neuronal->couches[i]->nb_neurones); // Création des différents neurones dans la couche
+        couche->neurones = (Neurone**)malloc(sizeof(Neurone*)*reseau->couches[i]->nb_neurones); // Création des différents neurones dans la couche
 
         for (int j=0; j < couche->nb_neurones; j++) {
             couche->neurones[j] = (Neurone*)malloc(sizeof(Neurone));
 
-            if (i != reseau_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
+            if (i != reseau->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
                 couche->neurones[j]->poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]);// Création des poids sortants du neurone
                 couche->neurones[j]->d_poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]);
             }
@@ -53,35 +53,35 @@ void creation_du_reseau_neuronal(Reseau* reseau_neuronal, int* neurones_par_couc
 
 
 
-void suppression_du_reseau_neuronal(Reseau* reseau_neuronal) {
+void suppression_du_reseau_neuronal(Reseau* reseau) {
     /* Libère l'espace mémoire alloué aux différentes variables dans la fonction
-    'creation_du_reseau_neuronal' */
+    'creation_du_reseau' */
 
-    for (int i=0; i<reseau_neuronal->nb_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; j<reseau_neuronal->couches[i]->nb_neurones; j++) {
-                free(reseau_neuronal->couches[i]->neurones[j]->poids_sortants);
-                free(reseau_neuronal->couches[i]->neurones[j]->d_poids_sortants);
+    for (int i=0; i<reseau->nb_couches; i++) {
+        if (i!=reseau->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
+            for (int j=0; j<reseau->couches[i]->nb_neurones; j++) {
+                free(reseau->couches[i]->neurones[j]->poids_sortants);
+                free(reseau->couches[i]->neurones[j]->d_poids_sortants);
             }
         }
-        free(reseau_neuronal->couches[i]->neurones); // On libère enfin la liste des neurones de la couche
+        free(reseau->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
+    free(reseau); // Pour finir, on libère le réseau neronal contenant la liste des couches
 }
 
 
 
 
-void forward_propagation(Reseau* reseau_neuronal) {
+void forward_propagation(Reseau* reseau) {
     /* Effectue une propagation en avant du réseau neuronal lorsque les données 
     on été insérées dans la première couche. Le résultat de la propagation se 
     trouve dans la dernière couche */
     Couche* couche; // Couche actuelle
     Couche* pre_couche; // Couche précédante
 
-    for (int i=1; i < reseau_neuronal->nb_couches; i++) { // La première couche contient déjà des valeurs
-        couche = reseau_neuronal->couches[i];
-        pre_couche = reseau_neuronal->couches[i-1];
+    for (int i=1; i < reseau->nb_couches; i++) { // La première couche contient déjà des valeurs
+        couche = reseau->couches[i];
+        pre_couche = reseau->couches[i-1];
 
         for (int j=0; j < couche->nb_neurones; j++) {
             couche->neurones[j]->z = couche->neurones[j]->biais;
@@ -90,7 +90,7 @@ void forward_propagation(Reseau* reseau_neuronal) {
                 couche->neurones[j]->z += pre_couche->neurones[k]->z * pre_couche->neurones[k]->poids_sortants[i]; // CHECK: ->poids_sortants[k] plutôt que i
             }
 
-            if (i < reseau_neuronal->nb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction ReLU (0 si z<0,  z sinon)
+            if (i < reseau->nb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction ReLU (0 si z<0,  z sinon)
                 couche->neurones[j]->z = ReLU(couche->neurones[j]->z);  
             }
             else { // Pour la dernière couche on utilise la fonction sigmoid permettant d'obtenir un résultat entre 0 et 1 à savoir une probabilité
@@ -103,11 +103,11 @@ void forward_propagation(Reseau* reseau_neuronal) {
 
 
 
-int* creation_de_la_sortie_voulue(Reseau* reseau_neuronal, int pos_nombre_voulu) {
+int* creation_de_la_sortie_voulue(Reseau* reseau, int pos_nombre_voulu) {
     /* Renvoie la liste des sorties voulues à partir du nombre
     de couches, de la liste du nombre de neurones par couche et de la
     position du résultat voulue, */
-    int nb_neurones = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones;
+    int nb_neurones = reseau->couches[reseau->nb_couches-1]->nb_neurones;
 
     int* sortie_voulue = (int*)malloc(sizeof(int)*nb_neurones);
 
@@ -121,20 +121,20 @@ int* creation_de_la_sortie_voulue(Reseau* reseau_neuronal, int pos_nombre_voulu)
 
 
 
-void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue) {
+void backward_propagation(Reseau* reseau, int* sortie_voulue) {
     /* Effectue une propagation en arrière du réseau neuronal */
     Neurone* neurone;
     Neurone* neurone2;
 
     // On commence par parcourir tous les neurones de la couche finale
-    for (int i=0; i < reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; i++) {
+    for (int i=0; i < reseau->couches[reseau->nb_couches-1]->nb_neurones; i++) {
         // On calcule l'erreur de la sortie 
-        neurone = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i];
+        neurone = reseau->couches[reseau->nb_couches-1]->neurones[i];
 
         neurone->d_z = (neurone->z - sortie_voulue[i])*(neurone->z - sortie_voulue[i]);
 
-        for(int k=0; k<reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->nb_neurones; k++) { // Pour chaque neurone de l'avant dernière couche
-            neurone2 = reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k];
+        for(int k=0; k<reseau->couches[reseau->nb_couches-2]->nb_neurones; k++) { // Pour chaque neurone de l'avant dernière couche
+            neurone2 = reseau->couches[reseau->nb_couches-2]->neurones[k];
 
             neurone2->d_poids_sortants[i] = neurone->d_z;
             neurone2->d_activation = neurone2->poids_sortants[i] * neurone->d_z;
@@ -143,17 +143,17 @@ void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue) {
         neurone->d_biais = neurone->d_z;
     }
 
-    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; j<reseau_neuronal->couches[i]->nb_neurones; j++) {
-            neurone = reseau_neuronal->couches[i]->neurones[j];
+    for(int i=reseau->nb_couches-2; i > 0; i--) { // On remonte les couche de l'avant dernière jusqu'à la première
+        for(int j=0; j<reseau->couches[i]->nb_neurones; j++) {
+            neurone = reseau->couches[i]->neurones[j];
 
             if(neurone->z >= 0) // ??? ...
                 neurone->d_z = neurone->d_activation;
             else // ??? ...
                 neurone->d_z = 0;
 
-            for(int k=0; k<reseau_neuronal->couches[i-1]->nb_neurones; k++) {
-                neurone2 = reseau_neuronal->couches[i-1]->neurones[k];
+            for(int k=0; k<reseau->couches[i-1]->nb_neurones; k++) {
+                neurone2 = reseau->couches[i-1]->neurones[k];
 
                 neurone2->d_poids_sortants[j] = neurone->d_z;
                 if(i>1) // ??? ...
@@ -168,17 +168,17 @@ void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue) {
 
 
 
-void modification_du_reseau_neuronal(Reseau* reseau_neuronal) {
+void modification_du_reseau_neuronal(Reseau* reseau) {
     /* 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 */
     Neurone* neurone;
 
-    for (int i=0; i < reseau_neuronal->nb_couches-1; i++) { // on exclut la dernière couche
-        for (int j=0; j < reseau_neuronal->couches[i]->nb_neurones; j++) {
-            neurone = reseau_neuronal->couches[i]->neurones[j];
+    for (int i=0; i < reseau->nb_couches-1; i++) { // on exclut la dernière couche
+        for (int j=0; j < reseau->couches[i]->nb_neurones; j++) {
+            neurone = reseau->couches[i]->neurones[j];
             neurone->biais = neurone->biais - (TAUX_APPRENTISSAGE * neurone->d_biais); // On modifie le biais du neurone à partir des données de la propagation en arrière
 
-            for (int k=0; k < reseau_neuronal->couches[i+1]->nb_neurones; k++) {
+            for (int k=0; k < reseau->couches[i+1]->nb_neurones; k++) {
                 neurone->poids_sortants[k] = neurone->poids_sortants[k] - (TAUX_APPRENTISSAGE * neurone->d_poids_sortants[k]); // On modifie le poids du neurone à partir des données de la propagation en arrière
             }
         }
@@ -188,7 +188,7 @@ void modification_du_reseau_neuronal(Reseau* reseau_neuronal) {
 
 
 
-void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal) {
+void initialisation_du_reseau_neuronal(Reseau* reseau) {
     /* 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 */
     Neurone* neurone;
@@ -196,17 +196,17 @@ void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal) {
     double borne_inferieure;
 
     srand(time(0));
-    for (int i=0; i < reseau_neuronal->nb_couches-1; i++) { // On exclut la dernière couche
-        for (int j=0; j < reseau_neuronal->couches[i]->nb_neurones-1; j++) {
+    for (int i=0; i < reseau->nb_couches-1; i++) { // On exclut la dernière couche
+        for (int j=0; j < reseau->couches[i]->nb_neurones-1; j++) {
 
-            neurone = reseau_neuronal->couches[i]->neurones[j];
+            neurone = reseau->couches[i]->neurones[j];
             // Initialisation des bornes supérieure et inférieure
-            borne_superieure = 1/sqrt(reseau_neuronal->couches[i]->nb_neurones);
+            borne_superieure = 1/sqrt(reseau->couches[i]->nb_neurones);
             borne_inferieure = - borne_superieure;
 
             neurone->activation = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure);
 
-            for (int k=0; k < reseau_neuronal->couches[i+1]->nb_neurones-1; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié
+            for (int k=0; k < reseau->couches[i+1]->nb_neurones-1; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié
                 neurone->poids_sortants[k] = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // Initialisation des poids sortants aléatoirement
                 neurone->d_poids_sortants[k] = 0.0; // ... ???
             }
@@ -215,12 +215,12 @@ void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal) {
             }
         }
     }
-    borne_superieure = 1/sqrt(reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones);
+    borne_superieure = 1/sqrt(reseau->couches[reseau->nb_couches-1]->nb_neurones);
     borne_inferieure = - borne_superieure;
 
-    for (int j=0; j < reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; j++) {// Intialisation de la dernière couche exclue ci-dessus
-        neurone = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[j];
+    for (int j=0; j < reseau->couches[reseau->nb_couches-1]->nb_neurones; j++) {// Intialisation de la dernière couche exclue ci-dessus
+        neurone = reseau->couches[reseau->nb_couches-1]->neurones[j];
         neurone->activation = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure);
         neurone->biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement
     }
-}
+}
\ No newline at end of file