Anpassungen für neuralNetworkTests.c

Reviewed-on: #2

Start_Windows/makefile

@@ -39,8 +39,8 @@ mnistVisualization.o: mnistVisualization.c
 matrixTests: matrix.o matrixTests.c
 	$(CC) $(CFLAGS) -I$(unityfolder) -o runMatrixTests matrixTests.c matrix.o $(BINARIES)/libunity.a
 
-neuralNetworkTests: neuralNetwork.o neuralNetworkTests.c
-	$(CC) $(CFLAGS) -I$(unityfolder) -o runNeuralNetworkTests neuralNetworkTests.c neuralNetwork.o $(BINARIES)/libunity.a
+neuralNetworkTests: neuralNetwork.o matrix.o neuralNetworkTests.c
+	$(CC) $(CFLAGS) -I$(unityfolder) -o runNeuralNetworkTests neuralNetworkTests.c neuralNetwork.o matrix.o $(BINARIES)/libunity.a
 
 imageInputTests: imageInput.o imageInputTests.c
 	$(CC) $(CFLAGS) -I$(unityfolder) -o runImageInputTests imageInputTests.c imageInput.o $(BINARIES)/libunity.a

Start_Windows/matrix.c

@@ -12,64 +12,128 @@ Matrix createMatrix(unsigned int rows, unsigned int cols)
   Matrix matrix;
   matrix.rows = rows;
   matrix.cols = cols;
-  matrix.data = EMPTY_CHAR;
+  matrix.buffer = EMPTY_CHAR;
+
+  if(rows == 0 || cols == 0)
+  {
+    Matrix emptyMatix = {
+      .rows = 0,
+      .cols = 0,
+      .buffer = NULL};
+    return emptyMatix;
+  
+  }
 
   if(rows > 0 && cols > 0) 
   {
-    matrix.data = (MatrixType*) calloc(rows * cols, sizeof(MatrixType));
+    matrix.buffer = (MatrixType*) calloc(rows * cols, sizeof(MatrixType));
   }
   return matrix;
 }
 
+
+
+
 void clearMatrix(Matrix *matrix)
 {
-  if(matrix && matrix->data)
+  if(matrix && matrix->buffer)
   {
-    free(matrix->data);
-    matrix->data = EMPTY_CHAR;
+    free(matrix->buffer);
+    matrix->buffer = EMPTY_CHAR;
     matrix->rows = 0;
     matrix->cols = 0;
   }
   
 }
 
+
+
+
 void setMatrixAt(MatrixType value, Matrix *matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-  if(matrix && matrix->data && rowIdx < matrix->rows && colIdx < matrix->cols)
+  if(matrix && matrix->buffer && rowIdx < matrix->rows && colIdx < matrix->cols)
   {
-    matrix->data[rowIdx * matrix->cols + colIdx] = value;
+    matrix->buffer[rowIdx * matrix->cols + colIdx] = value;
   }
     
 }
 
+
+
 MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-  if(matrix.data && rowIdx < matrix.rows && colIdx < matrix.cols)
+  if(matrix.buffer && rowIdx < matrix.rows && colIdx < matrix.cols)
   {
-    return matrix.data[rowIdx * matrix.cols + colIdx];
+    return matrix.buffer[rowIdx * matrix.cols + colIdx];
   }
   return UNDEFINED_MATRIX_VALUE;
 }
 
+
+
+
 Matrix add(const Matrix matrix1, const Matrix matrix2)
 {
-  if(matrix1.rows != matrix2.rows || matrix1.cols != matrix2.cols)
+  unsigned int resRows = 0;
+  unsigned int resCols = 0;
+
+  //Ergebniszeilenbestimmung
+  if(matrix1.rows == matrix2.rows)
+  {
+    resRows = matrix1.rows;
+  }else if(matrix1.rows == 1)
+  {
+    resRows = matrix2.rows;
+  }else if(matrix2.rows == 1)
+  {
+    resRows = matrix1.rows;
+  }else
+  {
+    return createMatrix(0, 0);
+  }
+
+  //Ergebnisspaltenbestimmung
+  if(matrix1.cols == matrix2.cols)
+  {
+    resCols = matrix1.cols;
+  }else if(matrix1.cols == 1)
+  {
+    resCols = matrix2.cols;
+  }else if(matrix2.cols == 1)
+  {
+    resCols = matrix1.cols;
+  }else
   {
     return createMatrix(0,0);
   }
-  Matrix result = createMatrix(matrix1.rows, matrix1.cols);
-  for(unsigned int i = 0; i < result.rows; ++i)
+
+  //Ergebnismatrix
+  Matrix result = createMatrix(resRows, resCols);
+  if(result.buffer == NULL && (resRows > 0 && resCols > 0))
   {
-    for(unsigned int j = 0; j < result.cols; ++j)
+    return createMatrix(0, 0);
+  }
+
+  for(unsigned int i = 0; i < resRows; ++i)
   {
-      MatrixType val = getMatrixAt(matrix1, i, j) + getMatrixAt(matrix2, i, j);
+    for(unsigned int j = 0; i < resCols; ++j)
+    {
+      unsigned int i1 = (matrix1.rows == 1) ? 0 : i;
+      unsigned int j1 = (matrix1.cols == 1) ? 0 : j;
+
+      unsigned int i2 = (matrix2.rows == 1) ? 0 : i;
+      unsigned int j2 = (matrix2.cols == 1) ? 0 : j;
+
+      MatrixType val = getMatrixAt(matrix1, i1, j1) + getMatrixAt(matrix2, i2, j2);
       setMatrixAt(val, &result, i, j);
     }
   }
   return result;
-
 }
 
+
+
+
 Matrix multiply(const Matrix matrix1, const Matrix matrix2)
 {
   if(matrix1.cols != matrix2.rows)
@@ -92,15 +156,3 @@ Matrix multiply(const Matrix matrix1, const Matrix matrix2)
   return result;
     
 }
-
-
-//Vergleich der MatrixReihen/Zeilen
-   // if((sizeof(matrix1) / sizeof(matrix1[0])) == sizeof(matrix2) / sizeof(matrix2[0]))
- //   {
-   //     if(sizeof(matrix1[0]) / sizeof(matrix1[0][0]) == sizeof(matrix2[0] / sizeof(matrix2[0][0])))
- //       {
-            
-
-
-  //      }
- //}

Start_Windows/matrix.h

@@ -8,7 +8,7 @@ typedef float MatrixType;
 // TODO Matrixtyp definieren
 
 typedef struct {
-    MatrixType* data;
+    MatrixType* buffer;
     unsigned int cols;
     unsigned int rows;
 }Matrix;

Start_Windows/matrixTests.c

@@ -153,7 +153,7 @@ void test_setMatrixAtSetsCorrectValue(void)
     MatrixType buffer[] = {1, 2, 3, 4, 5, 6};
     Matrix matrixUnderTest = {.rows=2, .cols=3, .buffer=buffer};
 
-    setMatrixAt(expectedResult, matrixUnderTest, 1, 2);
+    setMatrixAt(expectedResult, &matrixUnderTest, 1, 2);
     TEST_ASSERT_EQUAL_INT(expectedResult, buffer[5]);
 }
 
@@ -163,7 +163,7 @@ void test_setMatrixAtFailsOnIndicesOutOfRange(void)
     MatrixType buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer};
 
-    setMatrixAt(-1, matrixToTest, 2, 3);
+    setMatrixAt(-1, &matrixToTest, 2, 3);
     TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, matrixToTest.buffer, matrixToTest.cols * matrixToTest.rows);
 }
 

Start_Windows/neuralNetwork.c

@@ -20,7 +20,7 @@ static void softmax(Matrix *matrix)
                 for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++)
                 {
                     MatrixType expValue = exp(getMatrixAt(*matrix, rowIdx, colIdx));
-                    setMatrixAt(expValue, *matrix, rowIdx, colIdx);
+                    setMatrixAt(expValue, matrix, rowIdx, colIdx);
                     colSums[colIdx] += expValue;
                 }
             }
@@ -30,7 +30,7 @@ static void softmax(Matrix *matrix)
                 for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++)
                 {
                     MatrixType normalizedValue = getMatrixAt(*matrix, rowIdx, colIdx) / colSums[colIdx];
-                    setMatrixAt(normalizedValue, *matrix, rowIdx, colIdx);
+                    setMatrixAt(normalizedValue, matrix, rowIdx, colIdx);
                 }
             }
             free(colSums);
@@ -182,7 +182,7 @@ static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[], un
             {
                 for(int j = 0; j < images[i].width * images[i].height; j++)
                 {
-                    setMatrixAt((MatrixType)images[i].buffer[j], matrix, j, i);
+                    setMatrixAt((MatrixType)images[i].buffer[j], &matrix, j, i);
                 }
             }
         }

Start_Windows/neuralNetworkTests.c

@@ -23,49 +23,94 @@
 // 2) Stellen Sie sicher, dass alle Unittests erfolgreich durchlaufen.
 // make neuralNetworkTests && ./runNeuralNetworkTests
 
+// static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
+// {
+//     // First Draft
+//
+//     // 1. Datei im binären Schreibmodus öffnen
+//     FILE *file = fopen(path, "wb");
+//     if (file == NULL) {
+//         perror("Fehler beim Öffnen der Datei");
+//         return;
+//     }
+//
+//     // 2. Den Identifikations-Tag schreiben
+//     const char *fileTag = "__info2_neural_network_file_format__";
+//     fwrite(fileTag, sizeof(char), strlen(fileTag), file);
+//
+//     // 3. Die Anzahl der Schichten schreiben
+//     fwrite(&nn.numberOfLayers, sizeof(int), 1, file);
+//
+//     // 4. Schleife über alle Schichten, um deren Daten zu schreiben
+//     for (int i = 0; i < nn.numberOfLayers; i++) {
+//         Layer currentLayer = nn.layers[i];
+//
+//         // 4a. Daten der Gewichts-Matrix (weights) schreiben
+//         Matrix weights = currentLayer.weights;
+//         int weightElements = weights.rows * weights.cols;
+//
+//         // Schreibe Dimensionen (Zeilen, Spalten)
+//         fwrite(&weights.rows, sizeof(int), 1, file);
+//         fwrite(&weights.cols, sizeof(int), 1, file);
+//         // Schreibe den Daten-Buffer (die eigentlichen Zahlen)
+//         fwrite(weights.buffer, sizeof(MatrixType), weightElements, file);
+//
+//         // 4b. Daten der Bias-Matrix (biases) schreiben
+//         Matrix biases = currentLayer.biases;
+//         int biasElements = biases.rows * biases.cols;
+//
+//         // Schreibe Dimensionen (Zeilen, Spalten)
+//         fwrite(&biases.rows, sizeof(int), 1, file);
+//         fwrite(&biases.cols, sizeof(int), 1, file);
+//         // Schreibe den Daten-Buffer
+//         fwrite(biases.buffer, sizeof(MatrixType), biasElements, file);
+//     }
+//     // 5. Datei schließen
+//     fclose(file);
+// }
+
 static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
 {
-    // First Draft
-
-    // 1. Datei im binären Schreibmodus öffnen
     FILE *file = fopen(path, "wb");
     if (file == NULL) {
-        perror("Fehler beim Öffnen der Datei");
         return;
     }
 
-    // 2. Den Identifikations-Tag schreiben
-    const char *fileTag = "__info2_neural_network_file_format__";
-    fwrite(fileTag, sizeof(char), strlen(fileTag), file);
+    // 1. Header schreiben
+    const char *fileHeader = "__info2_neural_network_file_format__";
+    fwrite(fileHeader, sizeof(char), strlen(fileHeader), file);
 
-    // 3. Die Anzahl der Schichten schreiben
-    fwrite(&nn.numberOfLayers, sizeof(int), 1, file);
+    // Prüfen ob Layer existieren
+    if (nn.numberOfLayers > 0)
+    {
+        // 2. Die Input-Dimension der ALLERERSTEN Schicht schreiben
+        // (Das sind die Spalten der Gewichtsmatrix der ersten Schicht)
+        int inputDim = nn.layers[0].weights.cols;
+        fwrite(&inputDim, sizeof(int), 1, file);
 
-    // 4. Schleife über alle Schichten, um deren Daten zu schreiben
-    for (int i = 0; i < nn.numberOfLayers; i++) {
-        Layer currentLayer = nn.layers[i];
+        // 3. Durch alle Schichten iterieren
+        for(int i = 0; i < nn.numberOfLayers; i++)
+        {
+            // Die Output-Dimension dieser Schicht schreiben (Zeilen der Gewichtsmatrix)
+            int outputDim = nn.layers[i].weights.rows;
+            fwrite(&outputDim, sizeof(int), 1, file);
 
-        // 4a. Daten der Gewichts-Matrix (weights) schreiben
-        Matrix weights = currentLayer.weights;
-        int weightElements = weights.rows * weights.cols;
+            // 4. Gewichte (Weights) schreiben (nur den Buffer, keine Dimensionen mehr!)
+            // loadModel weiß durch inputDim und outputDim schon, wie groß die Matrix ist.
+            int weightsCount = nn.layers[i].weights.rows * nn.layers[i].weights.cols;
+            fwrite(nn.layers[i].weights.buffer, sizeof(MatrixType), weightsCount, file);
 
-        // Schreibe Dimensionen (Zeilen, Spalten)
-        fwrite(&weights.rows, sizeof(int), 1, file);
-        fwrite(&weights.cols, sizeof(int), 1, file);
-        // Schreibe den Daten-Buffer (die eigentlichen Zahlen)
-        fwrite(weights.buffer, sizeof(MatrixType), weightElements, file);
-
-        // 4b. Daten der Bias-Matrix (biases) schreiben
-        Matrix biases = currentLayer.biases;
-        int biasElements = biases.rows * biases.cols;
-
-        // Schreibe Dimensionen (Zeilen, Spalten)
-        fwrite(&biases.rows, sizeof(int), 1, file);
-        fwrite(&biases.cols, sizeof(int), 1, file);
-        // Schreibe den Daten-Buffer
-        fwrite(biases.buffer, sizeof(MatrixType), biasElements, file);
+            // 5. Biases schreiben (nur den Buffer)
+            int biasCount = nn.layers[i].biases.rows * nn.layers[i].biases.cols;
+            fwrite(nn.layers[i].biases.buffer, sizeof(MatrixType), biasCount, file);
         }
-    // 5. Datei schließen
+    }
+
+    // 6. Eine 0 schreiben, um das Ende der Dimensionen zu signalisieren
+    // (loadModel bricht die while-Schleife ab, wenn readDimension 0 liefert)
+    int stopMark = 0;
+    fwrite(&stopMark, sizeof(int), 1, file);
+
     fclose(file);
 }