Update cnn/neuron_io

doc/cnn.md

@@ -7,7 +7,7 @@ Les informations sont stockées de la manière suivante:
 ### Header
 type | nom de la variable | commentaire
 :---:|:---:|:---:
-uint32_t|magic_number|Variable servant à vérifier que le fichier n'est pas corrompu, vaut ...
+uint32_t|magic_number|Variable servant à vérifier que le fichier n'est pas corrompu, vaut 1012
 uint32_t|size|Nombre de couches du réseau
 uint32_t|initialisation|Fonction d'initialisation du réseau
 uint32_t|dropout|Probabilité d'abandon
@@ -15,11 +15,11 @@ uint32_t|input_width[0]|
 uint32_t|input_depth[0]|
 uint32_t|...|
 uint32_t|...|
-uint32_t|input_width[n]|
-uint32_t|input_depth[n]|
+uint32_t|input_width[size-1]|
+uint32_t|input_depth[size-1]|
 uint32_t|type_couche[0]|
 uint32_t|...|
-uint32_t|type_couche[n]|
+uint32_t|type_couche[size-1]|
 
 > type_couche:  
 > | 0 -> cnn  

make.sh

@@ -27,7 +27,7 @@ build () {
 		echo "Fait."
 		return 0
 	elif [[ $1 == "test" ]]; then
-		[ -f "$OUT/test_"* ] && rm "$OUT/test_"*
+		[[ -f "$OUT/test_"* ]] && rm "$OUT/test_"*
 		for i in "test/"*".c"; do
 			echo "Compilation de $i"
 			$CC "$i" -o "$OUT/test_$(echo $i | awk -F. '{print $1}' | awk -F/ '{print $NF}')" $FLAGS

src/cnn/include/neuron_io.h

@@ -21,4 +21,17 @@ void write_network(char* filename, Network* network);
 * Écrit une couche dans le fichier spécifié par le pointeur ptr
 */
 void write_couche(Kernel* kernel, int type_couche, FILE* ptr);
+
+
+// Lecture d'un réseau neuronal 
+
+/*
+* Lit un réseau neuronal dans un fichier donné
+*/
+Network* read_network(char* filename);
+
+/*
+* Lit une kernel dans le fichier spécifié par le pointeur ptr
+*/
+Kernel* read_kernel(int type_couche, FILE* ptr);
 #endif

src/cnn/neuron_io.c

@@ -6,7 +6,7 @@
 #include "include/neuron_io.h"
 #include "include/struct.h"
 
-#define MAGIC_NUMBER 9023
+#define MAGIC_NUMBER 1012
 
 void write_network(char* filename, Network* network) {
     FILE *ptr;
@@ -93,4 +93,80 @@ void write_couche(Kernel* kernel, int type_couche, FILE* ptr) {
         }
         fwrite(buffer, sizeof(buffer), 1, ptr);
     }
+}
+
+
+Network* read_network(char* filename) {
+    FILE *ptr;
+    Network* network = (Network*)malloc(sizeof(Network));
+    // TODO: malloc pour network -> input
+
+    ptr = fopen(filename, "rb");
+
+    uint32_t magic;
+    uint32_t size;
+    uint32_t initialisation;
+    uint32_t dropout;
+    uint32_t tmp;
+
+    fread(&magic, sizeof(uint32_t), 1, ptr);
+    if (magic != MAGIC_NUMBER) {
+        printf("Incorrect magic number !\n");
+        exit(1);
+    }
+
+    // Lecture des constantes du réseau
+    fread(&size, sizeof(uint32_t), 1, ptr);
+    network->size = size;
+    fread(&initialisation, sizeof(uint32_t), 1, ptr);
+    network->initialisation = initialisation;
+    fread(&dropout, sizeof(uint32_t), 1, ptr);
+    network->dropout = dropout;
+
+    // Lecture de la taille de l'entrée des différentes matrices
+    network->width = (int*)malloc(sizeof(int)*size);
+    network->depth = (int*)malloc(sizeof(int)*size);
+
+    for (int i=0; i < (int)size; i++) {
+        fread(&tmp, sizeof(tmp), 1, ptr);
+        network->width[i] = tmp;
+        fread(&tmp, sizeof(tmp), 1, ptr);
+        network->depth[i+1] = tmp;
+    }
+
+    // Lecture du type de chaque couche
+    uint32_t type_couche[size];
+
+    for (int i=0; i < (int)size; i++) {
+        fread(&tmp, sizeof(tmp), 1, ptr);
+        type_couche[i] = tmp;
+    }
+
+    // Lecture de chaque couche
+    network->kernel = (Kernel**)malloc(sizeof(Kernel*)*size);
+
+    for (int i=0; i < (int)size; i++) {
+        network->kernel[i] = read_kernel(type_couche[i], ptr);
+    }
+    
+    fclose(ptr);
+    return network;
+}
+
+Kernel* read_kernel(int type_couche, FILE* ptr) {
+    Kernel* kernel = (Kernel*)malloc(sizeof(Kernel));
+    if (type_couche == 0) {
+        // TODO: lecture d'un CNN
+    } else if (type_couche == 1) {
+        // TODO: lecture d'un NN
+    } else if (type_couche == 2) {
+        uint32_t pooling;
+        fread(&pooling, sizeof(pooling), 1, ptr);
+
+        kernel->cnn = NULL;
+        kernel->nn = NULL;
+        kernel->activation = pooling;
+        kernel->linearisation = pooling; // TODO: mettre à 0 la variable inutile
+    }
+    return kernel;
 }