diff --git a/src/cnn/cnn.c b/src/cnn/cnn.c
index ef48df9..03daa07 100644
--- a/src/cnn/cnn.c
+++ b/src/cnn/cnn.c
@@ -41,11 +41,12 @@ void forward_propagation(Network* network) {
     int n = network->size;
     float*** input;
     float*** output;
+    float*** output_a;
     Kernel* k_i;
     for (int i=0; i < n-1; i++) {
         // Transférer les informations de 'input' à 'output'
         k_i = network->kernel[i];
-        output_a = network->input_a[i+1];
+        output_a = network->input_z[i+1];
         input = network->input[i];
         input_depth = network->depth[i];
         input_width = network->width[i];
@@ -56,7 +57,7 @@ void forward_propagation(Network* network) {
 
         if (k_i->cnn) { // Convolution
             make_convolution(k_i->cnn, input, output, output_width);
-            copy_input_to_input_a(outtput, output_a, outpu_width, output_width, ouput_depth);
+            copy_input_to_input_z(output, output_a, output_depth, output_width, output_width);
             choose_apply_function_matrix(activation, output, output_depth, output_width);
         }
         else if (k_i->nn) { // Full connection
@@ -65,6 +66,7 @@ void forward_propagation(Network* network) {
             } else { // Matrice -> Vecteur
                 make_dense_linearised(k_i->nn, input, output[0][0], input_depth, input_width, output_width);
             }
+            copy_input_to_input_z(output, output_a, 1, 1, output_width);
             choose_apply_function_vector(activation, output, output_width);
         }
         else { // Pooling
@@ -74,6 +76,7 @@ void forward_propagation(Network* network) {
             } else { // Pooling sur une matrice
                 make_average_pooling(input, output, activation/100, output_depth, output_width);
             }
+            copy_input_to_input_z(output, output_a, output_depth, output_width, output_width);
         }
     }
 }
@@ -82,15 +85,12 @@ void backward_propagation(Network* network, float wanted_number) {
     printf_warning("Appel de backward_propagation, incomplet\n");
     float* wanted_output = generate_wanted_output(wanted_number);
     int n = network->size;
-    //float loss = compute_mean_squared_error(network->input[n][0][0], wanted_output, network->width[n]);
-    // -> will it really be used ?
     int activation, input_depth, input_width, output_depth, output_width;
     float*** input;
     float*** output;
     Kernel* k_i;
     Kernel* k_i_1;
-
-    rms_backward(network->input[n-1][0][0], wanted_output); // Backward sur la dernière colonne
+    // rms_backward(network->input[n-1][0][0], wanted_output); // Backward sur la dernière colonne
 
     for (int i=n-3; i >= 0; i--) {
         // Modifie 'k_i' à partir d'une comparaison d'informations entre 'input' et 'output'
@@ -114,27 +114,40 @@ void backward_propagation(Network* network, float wanted_number) {
 
             }
         } else { // Pooling
-            backward_2d_pooling(input, output, input_width, output_width, input_depth) // Depth pour input et output a la même valeur
+            // backward_2d_pooling(input, output, input_width, output_width, input_depth) // Depth pour input et output a la même valeur
         }
     }
     free(wanted_output);
 }
 
+void copy_input_to_input_z(float*** output, float*** output_a, int output_depth, int output_rows, int output_columns) {
+    for (int i=0; i<output_depth; i++) {
+        for (int j=0; j<output_rows; j++) {
+            for (int k=0; k<output_columns; k++) {
+                output_a[i][j][k] = output[i][j][k];
+            }
+        }
+    }
+}
+
 void update_weights(Network* network) {
     int n = network->size;
-    int input_depth, input_width, output_width;
+    int input_depth, input_width, output_depth, output_width;
+    Kernel* k_i;
+    Kernel* k_i_1;
     for (int i=0; i<(n-1); i++) {
         k_i = network->kernel[i];
         k_i_1 = network->kernel[i+1];
         input_depth = network->depth[i];
         input_width = network->width[i];
+        output_depth = network->depth[i+1];
         output_width = network->width[i+1];
 
         if (k_i->cnn) { // Convolution
             Kernel_cnn* cnn = k_i_1->cnn;
             int k_size = cnn->k_size;
             for (int a=0; a<input_depth; a++) {
-                for (int b=0; b<ouput_depth; b++) {
+                for (int b=0; b<output_depth; b++) {
                     for (int c=0; c<k_size; c++) {
                         for (int d=0; d<k_size; d++) {
                             cnn->w[a][b][c][d] += cnn->d_w[a][b][c][d];
@@ -167,15 +180,18 @@ void update_weights(Network* network) {
 
 void update_bias(Network* network) {
     int n = network->size;
-    int output_width;
+    int output_width, output_depth;
+    Kernel* k_i;
+    Kernel* k_i_1;
     for (int i=0; i<(n-1); i++) {
         k_i = network->kernel[i];
         k_i_1 = network->kernel[i+1];
         output_width = network->width[i+1];
+        output_depth = network->depth[i+1];
 
         if (k_i->cnn) { // Convolution
             Kernel_cnn* cnn = k_i_1->cnn;
-            for (int a=0; a<ouput_depth; a++) {
+            for (int a=0; a<output_depth; a++) {
                 for (int b=0; b<output_width; b++) {
                     for (int c=0; c<output_width; c++) {
                         cnn->bias[a][b][c] += cnn->d_bias[a][b][c];
diff --git a/src/cnn/creation.c b/src/cnn/creation.c
index 8162b76..7a004ef 100644
--- a/src/cnn/creation.c
+++ b/src/cnn/creation.c
@@ -17,6 +17,7 @@ Network* create_network(int max_size, int learning_rate, int dropout, int initia
     network->initialisation = initialisation; 
     network->size = 1; 
     network->input = (float****)malloc(sizeof(float***)*max_size); 
+    network->input_z = (float****)malloc(sizeof(float***)*max_size); 
     network->kernel = (Kernel**)malloc(sizeof(Kernel*)*max_size); 
     network->width = (int*)malloc(sizeof(int*)*max_size); 
     network->depth = (int*)malloc(sizeof(int*)*max_size); 
@@ -28,6 +29,7 @@ Network* create_network(int max_size, int learning_rate, int dropout, int initia
     network->kernel[0]->nn = NULL; 
     network->kernel[0]->cnn = NULL; 
     create_a_cube_input_layer(network, 0, input_depth, input_dim); 
+    create_a_cube_input_z_layer(network, 0, input_depth, input_dim); 
     return network;
 }
 
@@ -57,6 +59,18 @@ void create_a_cube_input_layer(Network* network, int pos, int depth, int dim) {
     network->depth[pos] = depth;
 }
 
+void create_a_cube_input_z_layer(Network* network, int pos, int depth, int dim) {
+    network->input_z[pos] = (float***)malloc(sizeof(float**)*depth);
+    for (int i=0; i < depth; i++) {
+        network->input_z[pos][i] = (float**)malloc(sizeof(float*)*dim);
+        for (int j=0; j < dim; j++) {
+            network->input_z[pos][i][j] = (float*)malloc(sizeof(float)*dim);
+        }
+    }
+    network->width[pos] = dim;
+    network->depth[pos] = depth;
+}
+
 void create_a_line_input_layer(Network* network, int pos, int dim) {
     network->input[pos] = (float***)malloc(sizeof(float**));
     network->input[pos][0] = (float**)malloc(sizeof(float*));
@@ -65,7 +79,15 @@ void create_a_line_input_layer(Network* network, int pos, int dim) {
     network->depth[pos] = 1;
 }
 
-void add_2d_average_pooling(Network* network, int dim_ouput) {
+void create_a_line_input_z_layer(Network* network, int pos, int dim) {
+    network->input_z[pos] = (float***)malloc(sizeof(float**));
+    network->input_z[pos][0] = (float**)malloc(sizeof(float*));
+    network->input_z[pos][0][0] = (float*)malloc(sizeof(float)*dim);
+    network->width[pos] = dim;
+    network->depth[pos] = 1;
+}
+
+void add_2d_average_pooling(Network* network, int dim_output) {
     int n = network->size;
     int k_pos = n-1;
     int dim_input = network->width[k_pos];
@@ -73,8 +95,8 @@ void add_2d_average_pooling(Network* network, int dim_ouput) {
         printf("Impossible de rajouter une couche d'average pooling, le réseau est déjà plein\n");
         return;
     }
-    int kernel_size = dim_input/dim_ouput;
-    if (dim_input%dim_ouput != 0) {
+    int kernel_size = dim_input/dim_output;
+    if (dim_input%dim_output != 0) {
         printf("Erreur de dimension dans l'average pooling\n");
         return;
     }
@@ -82,6 +104,7 @@ void add_2d_average_pooling(Network* network, int dim_ouput) {
     network->kernel[k_pos]->nn = NULL;
     network->kernel[k_pos]->activation = 100*kernel_size; // Ne contient pas de fonction d'activation
     create_a_cube_input_layer(network, n, network->depth[n-1], network->width[n-1]/2);
+    create_a_cube_input_z_layer(network, n, network->depth[n-1], network->width[n-1]/2);
     network->size++;
 }
 
@@ -137,6 +160,7 @@ void add_convolution(Network* network, int depth_output, int dim_output, int act
         }
     }
     create_a_cube_input_layer(network, n, depth_output, bias_size);
+    create_a_cube_input_z_layer(network, n, depth_output, bias_size);
     int n_int = network->width[n-1]*network->width[n-1]*network->depth[n-1];
     int n_out = network->width[n]*network->width[n]*network->depth[n];
     /* Not currently used 
@@ -174,6 +198,7 @@ void add_dense(Network* network, int output_units, int activation) {
         nn->last_d_weights[i] = (float*)malloc(sizeof(float)*output_units);
     }
     create_a_line_input_layer(network, n, output_units);
+    create_a_line_input_z_layer(network, n, output_units);
     /* Not currently used
     initialisation_1d_matrix(network->initialisation, nn->bias, output_units, output_units+input_units);
     initialisation_1d_matrix(ZERO, nn->d_bias, output_units, output_units+input_units);
@@ -217,6 +242,7 @@ void add_dense_linearisation(Network* network, int output_units, int activation)
     initialisation_2d_matrix(network->initialisation, nn->weights, input_units, output_units, output_units+input_units);
     initialisation_2d_matrix(ZERO, nn->d_weights, input_units, output_units, output_units+input_units); */
     create_a_line_input_layer(network, n, output_units);
+    create_a_line_input_z_layer(network, n, output_units);
 
     network->size++;
 }
\ No newline at end of file
diff --git a/src/cnn/free.c b/src/cnn/free.c
index 5866341..c4092b6 100644
--- a/src/cnn/free.c
+++ b/src/cnn/free.c
@@ -7,16 +7,22 @@ void free_a_cube_input_layer(Network* network, int pos, int depth, int dim) {
     for (int i=0; i < depth; i++) {
         for (int j=0; j < dim; j++) {
             free(network->input[pos][i][j]);
+            free(network->input_z[pos][i][j]);
         }
         free(network->input[pos][i]);
+        free(network->input_z[pos][i]);
     }
     free(network->input[pos]);
+    free(network->input_z[pos]);
 }
 
 void free_a_line_input_layer(Network* network, int pos) {
     free(network->input[pos][0][0]);
+    free(network->input_z[pos][0][0]);
     free(network->input[pos][0]);
+    free(network->input_z[pos][0]);
     free(network->input[pos]);
+    free(network->input_z[pos]);
 }
 
 void free_2d_average_pooling(Network* network, int pos) {
@@ -114,6 +120,7 @@ void free_network_creation(Network* network) {
     free(network->depth);
     free(network->kernel);
     free(network->input);
+    free(network->input_z);
 
     free(network);
 }
diff --git a/src/cnn/function.c b/src/cnn/function.c
index 9e1b0b0..c89df78 100644
--- a/src/cnn/function.c
+++ b/src/cnn/function.c
@@ -100,25 +100,3 @@ void choose_apply_function_vector(int activation, float*** input, int dim) {
         printf("Erreur, fonction d'activation inconnue (choose_apply_function_vector): %d\n", activation);
     }
 }
-
-void* get_function_activation(int activation) {
-    if (activation == RELU) {
-        return relu;
-    } else if (activation == -RELU) {
-        return relu_derivative;
-    } else if (activation == SIGMOID) {
-        return sigmoid;
-    } else if (activation == -SIGMOID) {
-        return sigmoid_derivative
-    } else if (activation == SOFTMAX) {
-        printf("Erreur, impossible de renvoyer la fonction softmax");
-    } else if (activation == -SOFTMAX) {
-        printf("Erreur, impossible de renvoyer la dérivée de la fonction softmax");
-    } else if (activation == TANH) {
-        return tanh_;
-    } else if (activation == -TANH) {
-        return tanh_derivative;
-    } else {
-        printf("Erreur, fonction d'activation inconnue (choose_apply_function_vector): %d\n", activation);
-    }
-}
\ No newline at end of file
diff --git a/src/cnn/include/cnn.h b/src/cnn/include/cnn.h
index 5fca4d6..72b7f33 100644
--- a/src/cnn/include/cnn.h
+++ b/src/cnn/include/cnn.h
@@ -24,6 +24,11 @@ void forward_propagation(Network* network);
 */
 void backward_propagation(Network* network, float wanted_number);
 
+/*
+* Copie les données de output dans output_a (Sachant que les deux matrices ont les mêmes dimensions)
+*/
+void copy_input_to_input_z(float*** output, float*** output_a, int output_depth, int output_rows, int output_columns);
+
 /*
 * Bascule les données de d_weights dans weights
 */
@@ -33,7 +38,6 @@ void update_weights(Network* network);
 * Bascule les données de d_bias dans bias
 */
 void update_bias(Network* network);
-
 /*
 * Renvoie l'erreur du réseau neuronal pour une sortie (RMS)
 */
diff --git a/src/cnn/include/creation.h b/src/cnn/include/creation.h
index f18378c..081a8b2 100644
--- a/src/cnn/include/creation.h
+++ b/src/cnn/include/creation.h
@@ -17,7 +17,12 @@ Network* create_network_lenet5(int learning_rate, int dropout, int activation, i
 /*
 * Créé et alloue de la mémoire à une couche de type input cube
 */
-void create_a_cube_input_layer(Network* network, int pos, int depth, int dim); // CHECKED
+void create_a_cube_input_layer(Network* network, int pos, int depth, int dim);
+
+/*
+* Créé et alloue de la mémoire à une couche de type input_z cube
+*/
+void create_a_cube_input_z_layer(Network* network, int pos, int depth, int dim);
 
 /*
 * Créé et alloue de la mémoire à une couche de type ligne
@@ -27,7 +32,7 @@ void create_a_line_input_layer(Network* network, int pos, int dim);
 /*
 * Ajoute au réseau une couche d'average pooling valide de dimension dim*dim
 */
-void add_2d_average_pooling(Network* network, int dim_ouput);
+void add_2d_average_pooling(Network* network, int dim_output);
 
 /*
 * Ajoute au réseau une couche de convolution dim*dim et initialise les kernels
diff --git a/src/cnn/include/function.h b/src/cnn/include/function.h
index 50f89c6..78189af 100644
--- a/src/cnn/include/function.h
+++ b/src/cnn/include/function.h
@@ -1,6 +1,8 @@
 #ifndef DEF_FUNCTION_H
 #define DEF_FUNCTION_H
 
+
+typedef float (*returnFunctionType)(float, float);
 // Les dérivées sont l'opposé
 #define TANH 1
 #define SIGMOID 2
@@ -44,9 +46,4 @@ void choose_apply_function_matrix(int activation, float*** input, int depth, int
 */
 void choose_apply_function_vector(int activation, float*** input, int dim);
 
-/*
-* Renvoie un pointeur vers la fonction d'activation correspondante
-*/
-void* get_function_activation(int activation)
-
 #endif
\ No newline at end of file
diff --git a/src/cnn/include/struct.h b/src/cnn/include/struct.h
index 47ecd6b..5e4a6bf 100644
--- a/src/cnn/include/struct.h
+++ b/src/cnn/include/struct.h
@@ -42,6 +42,7 @@ typedef struct Network{
     int* depth; // depth[size]
     Kernel** kernel; // kernel[size], contient tous les kernels
     float**** input; // Tableau de toutes les couches du réseau input[size][couche->depth][couche->width][couche->width]
+    float**** input_z; // Même tableau que input mais ne contient paas la dernière fonction d'activation à chaque ligne
 } Network;
 
 #endif
\ No newline at end of file