finale Änderungen

info2praktikum-neuronalesnetz/neuralNetwork.c

@@ -125,50 +125,51 @@ static void assignActivations(NeuralNetwork model)
 
 NeuralNetwork loadModel(const char *path)
 {
-    NeuralNetwork nn = {.layers = NULL, .numberOfLayers = 0};
+    NeuralNetwork model = {NULL, 0};
     FILE *file = fopen(path, "rb");
-    if (!file) return nn;
 
-    const char *header = "__info2_neural_network_file_format__";
+    if(file != NULL)
-    size_t headerLen = strlen(header);
+    {
-    char buffer[64] = {0};
+        if(checkFileHeader(file))
+        {
+            unsigned int inputDimension = readDimension(file);
+            unsigned int outputDimension = readDimension(file);
 
-    if (fread(buffer, sizeof(char), headerLen, file) != headerLen ||
+            while(inputDimension > 0 && outputDimension > 0)
-        strncmp(buffer, header, headerLen) != 0) {
+            {
+                Layer layer = readLayer(file, inputDimension, outputDimension);
+                Layer *layerBuffer = NULL;
+
+                if(isEmptyLayer(layer))
+                {
+                    clearLayer(&layer);
+                    clearModel(&model);
+                    break;
+                }
+
+                layerBuffer = (Layer *)realloc(model.layers, (model.numberOfLayers + 1) * sizeof(Layer));
+
+                if(layerBuffer != NULL)
+                    model.layers = layerBuffer;
+                else
+                {
+                    clearModel(&model);
+                    break;
+                }
+
+                model.layers[model.numberOfLayers] = layer;
+                model.numberOfLayers++;
+
+                inputDimension = outputDimension;
+                outputDimension = readDimension(file);
+            }
+        }
         fclose(file);
-        return nn;
+
+        assignActivations(model);
     }
 
-    Layer *layers = NULL;
+    return model;
-    unsigned int inputDim = 0, outputDim = 0;
-
-    while (fread(&inputDim, sizeof(unsigned int), 1, file) == 1 && inputDim != 0) {
-        fread(&outputDim, sizeof(unsigned int), 1, file);
-
-        layers = realloc(layers, (nn.numberOfLayers + 1) * sizeof(Layer));
-
-        Matrix weights;
-        weights.rows = outputDim;
-        weights.cols = inputDim;
-        weights.buffer = malloc(weights.rows * weights.cols * sizeof(MatrixType));
-        fread(weights.buffer, sizeof(MatrixType), weights.rows * weights.cols, file);
-
-        Matrix biases;
-        biases.rows = outputDim;
-        biases.cols = 1;
-        biases.buffer = malloc(biases.rows * biases.cols * sizeof(MatrixType));
-        fread(biases.buffer, sizeof(MatrixType), biases.rows * biases.cols, file);
-
-        layers[nn.numberOfLayers].weights = weights;
-        layers[nn.numberOfLayers].biases = biases;
-        layers[nn.numberOfLayers].activation = NULL;
-
-        nn.numberOfLayers++;  // **WICHTIG**
-    }
-
-    nn.layers = layers;
-    fclose(file);
-    return nn;
 }
 
 
@@ -259,15 +260,15 @@ unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[],
 }
 
 
-void clearModel(NeuralNetwork *nn)
+void clearModel(NeuralNetwork *model)
 {
-    if (!nn || !nn->layers) return;
+    if(model != NULL)
-
+    {
-    for (unsigned int i = 0; i < nn->numberOfLayers; i++) {
+        for(int i = 0; i < model->numberOfLayers; i++)
-        free(nn->layers[i].weights.buffer);
+        {
-        free(nn->layers[i].biases.buffer);
+            clearLayer(&model->layers[i]);
+        }
+        model->layers = NULL;
+        model->numberOfLayers = 0;
     }
-    free(nn->layers);
+}
-    nn->layers = NULL;
-    nn->numberOfLayers = 0;
-}