Merge branch 'main' of https://git.efi.th-nuernberg.de/gitea/turtschinba100320/info2Praktikum-NeuronalesNetzBastiBjoern

imageInput.c

@@ -46,9 +46,9 @@ GrayScaleImageSeries *readImages(const char *path)
         return NULL;
     }
     unsigned short image_count, width, height;
-    fread(&image_count,1,sizeof(unsigned short),datei);
-    fread(&width,1,sizeof(unsigned short),datei);
-    fread(&height,1,sizeof(unsigned short),datei);
+    fread(&image_count,sizeof(unsigned short),1,datei);
+    fread(&width,sizeof(unsigned short),1,datei);
+    fread(&height,sizeof(unsigned short),1,datei);
     //printf("%u Bilder und %u mal %u",image_count,width,height);
     GrayScaleImageSeries *series = NULL;
     series = malloc(sizeof(GrayScaleImageSeries));
@@ -57,6 +57,8 @@ GrayScaleImageSeries *readImages(const char *path)
     series->labels = malloc(image_count*sizeof(unsigned char));
     for(unsigned short i = 0;i<image_count;i++)
     {
+        series->images[i].width  = width;
+        series->images[i].height = height;
         series->images[i].buffer = malloc(width*height);
     }
     for(unsigned short i = 0;i<image_count;i++)
@@ -94,4 +96,4 @@ void clearSeries(GrayScaleImageSeries *series)
     printf("Serie freigegeben\n");
     return;
     
-}
+}

imageInputTests.c

@@ -54,7 +54,7 @@ void test_readImagesReturnsCorrectImageWidth(void)
     GrayScaleImageSeries *series = NULL;
     const unsigned short expectedWidth = 10;
     const char *path = "testFile.info2";
-    prepareImageFile(path, 8, expectedWidth, 2, 1);
+    prepareImageFile(path, expectedWidth, 8, 2, 1);
     series = readImages(path);
     TEST_ASSERT_NOT_NULL(series);
     TEST_ASSERT_NOT_NULL(series->images);
@@ -70,7 +70,7 @@ void test_readImagesReturnsCorrectImageHeight(void)
     GrayScaleImageSeries *series = NULL;
     const unsigned short expectedHeight = 10;
     const char *path = "testFile.info2";
-    prepareImageFile(path, expectedHeight, 8, 2, 1);
+    prepareImageFile(path,8, expectedHeight, 2, 1);
     series = readImages(path);
     TEST_ASSERT_NOT_NULL(series);
     TEST_ASSERT_NOT_NULL(series->images);

main.c

@@ -1,3 +1,4 @@
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "imageInput.h"
@@ -6,7 +7,7 @@
 
 int main(int argc, char *argv[])
 {
-    readImages("mnist_test.info2");
+    //readImages("mnist_test.info2");
     
     const unsigned int windowWidth = 800;
     const unsigned int windowHeight = 600;
@@ -31,7 +32,7 @@ int main(int argc, char *argv[])
                 unsigned char *predictions = NULL;
                 
                 printf("Processing %u images ...\n", series->count);
-
+                
                 predictions = predict(model, series->images, series->count);
 
                 if(predictions != NULL)
@@ -68,4 +69,4 @@ int main(int argc, char *argv[])
 
     return exitCode;
     
-}
+}

matrix.c

@@ -1,8 +1,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include "matrix.h"
+#include <stdio.h>
 
-// TODO Matrix-Funktionen implementieren
 
 // Matrix erzeugen
 Matrix createMatrix(unsigned int rows, unsigned int cols)
@@ -11,29 +11,33 @@ Matrix createMatrix(unsigned int rows, unsigned int cols)
     matrix.buffer = NULL;
     matrix.rows = 0;
     matrix.cols = 0;
-    
 
-    // Wenn die Dimensionen gültig sind, Speicher reservieren
-    if (rows > 0 && cols > 0) 
-    {
-        matrix.buffer = (MatrixType *)malloc(rows * cols * sizeof(MatrixType));
-        if (matrix.buffer != NULL)
-        {
-            matrix.rows = rows;
-            matrix.cols = cols;
-        }
-    }
+    if (rows == 0 || cols == 0)
+        return matrix; // leere Matrix
+
+    matrix.buffer = (MatrixType *)malloc(rows * cols * sizeof(MatrixType));
+    if (!matrix.buffer)
+        return matrix; // Speicher konnte nicht reserviert werden
+
+    matrix.rows = rows;
+    matrix.cols = cols;
+
+    // Initialisiere alle Werte auf UNDEFINED_MATRIX_VALUE
+    for (unsigned int i = 0; i < rows * cols; i++)
+        matrix.buffer[i] = UNDEFINED_MATRIX_VALUE;
+
     return matrix;
 }
 
 // Matrix Speicher freigeben
 void clearMatrix(Matrix *matrix)
 {
-    if (matrix->buffer != NULL)
-    {
+    if (!matrix) return;
+
+    if (matrix->buffer)
         free(matrix->buffer);
-        matrix->buffer = NULL;
-    }
+
+    matrix->buffer = NULL;
     matrix->rows = 0;
     matrix->cols = 0;
 }
@@ -41,67 +45,84 @@ void clearMatrix(Matrix *matrix)
 // Wert setzen
 void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    if (rowIdx < matrix.rows && colIdx < matrix.cols)
-    {
-        matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
-    }
+    if (!matrix.buffer) return;
+    if (rowIdx >= matrix.rows || colIdx >= matrix.cols) return;
+
+    matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
 }
 
 // Wert auslesen
 MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    if (rowIdx < matrix.rows && colIdx < matrix.cols)
-    {
-        return matrix.buffer[rowIdx * matrix.cols + colIdx];
-    }
-    return 0; // Fallback
-}
+    if (!matrix.buffer) return UNDEFINED_MATRIX_VALUE;
+    if (rowIdx >= matrix.rows || colIdx >= matrix.cols) return UNDEFINED_MATRIX_VALUE;
 
+    return matrix.buffer[rowIdx * matrix.cols + colIdx];
+}
 // Matrizen addieren
 Matrix add(const Matrix m1, const Matrix m2)
 {
-    if (m1.rows != m2.rows || m1.cols != m2.cols)
+    if (!m1.buffer || !m2.buffer) return createMatrix(0,0);
+
+    // gleiche Dimension
+    if (m1.rows == m2.rows && m1.cols == m2.cols)
     {
-        return createMatrix(0, 0); // Falls Matrix-Dimensionen nicht passen
+        Matrix result = createMatrix(m1.rows, m1.cols);
+        if (!result.buffer) return result;
+
+        for (unsigned int r = 0; r < m1.rows; r++)
+            for (unsigned int c = 0; c < m1.cols; c++)
+                result.buffer[r * result.cols + c] = m1.buffer[r * m1.cols + c] + m2.buffer[r * m2.cols + c];
+
+        return result;
     }
 
-    Matrix result = createMatrix(m1.rows, m1.cols);
-    if (result.buffer == NULL) return result;
-
-    for (unsigned int r = 0; r < m1.rows; r++)
+    // Matrix2 ist ein Spaltenvektor
+    if (m1.rows == m2.rows && m2.cols == 1)
     {
-        for (unsigned int c = 0; c < m1.cols; c++)
-        {
-            result.buffer[r * m1.cols + c] =
-                getMatrixAt(m1, r, c) + getMatrixAt(m2, r, c);
-        }
+        Matrix result = createMatrix(m1.rows, m1.cols);
+        if (!result.buffer) return result;
+
+        for (unsigned int r = 0; r < m1.rows; r++)
+            for (unsigned int c = 0; c < m1.cols; c++)
+                result.buffer[r * result.cols + c] = m1.buffer[r * m1.cols + c] + m2.buffer[r];
+
+        return result;
     }
-    return result;
+
+    // Matrix1 ist ein Spaltenvektor
+    if (m1.rows == m2.rows && m1.cols == 1)
+    {
+        Matrix result = createMatrix(m2.rows, m2.cols);
+        if (!result.buffer) return result;
+
+        for (unsigned int r = 0; r < m2.rows; r++)
+            for (unsigned int c = 0; c < m2.cols; c++)
+                result.buffer[r * result.cols + c] = m1.buffer[r] + m2.buffer[r * m2.cols + c];
+
+        return result;
+    }
+
+    // passt nicht
+    return createMatrix(0,0);
 }
-
 // Matrizen multiplizieren
 Matrix multiply(const Matrix m1, const Matrix m2)
 {
-    if (m1.cols != m2.rows)
-    {
-        return createMatrix(0, 0); // Falls Matrix-Dimensionen nicht passen
-    }
+    if (!m1.buffer || !m2.buffer) return createMatrix(0,0);
+    if (m1.cols != m2.rows) return createMatrix(0,0);
 
     Matrix result = createMatrix(m1.rows, m2.cols);
-    if (result.buffer == NULL) return result;
+    if (!result.buffer) return result;
 
     for (unsigned int r = 0; r < m1.rows; r++)
-    {
         for (unsigned int c = 0; c < m2.cols; c++)
         {
             MatrixType sum = 0;
             for (unsigned int k = 0; k < m1.cols; k++)
-            {
-                sum += getMatrixAt(m1, r, k) * getMatrixAt(m2, k, c);
-            }
-            result.buffer[r * m2.cols + c] = sum;
+                sum += m1.buffer[r * m1.cols + k] * m2.buffer[k * m2.cols + c];
+            result.buffer[r * result.cols + c] = sum;
         }
-    }
 
     return result;
 }

neuralNetwork.c

@@ -197,7 +197,7 @@ static Matrix forward(const NeuralNetwork model, Matrix inputBatch)
 
     if(result.buffer != NULL)
     {
-        for(int i = 0; i < model.numberOfLayers; i++)
+                for(int i = 0; i < model.numberOfLayers; i++)
         {
             Matrix biasResult;
             Matrix weightResult;
@@ -246,7 +246,7 @@ unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[],
 {
     Matrix inputBatch = imageBatchToMatrixOfImageVectors(images, numberOfImages);
     Matrix outputBatch = forward(model, inputBatch);
-
+    
     unsigned char *result = argmax(outputBatch);
     
     clearMatrix(&outputBatch);