From ede0bd8bd8b41c747ccde430f1add276a3312aa2 Mon Sep 17 00:00:00 2001 From: Kristin Date: Sat, 22 Nov 2025 12:15:04 +0100 Subject: [PATCH 1/6] addmatrix mit broadcasten --- makefile | 13 ++--- matrix.c | 173 +++++++++++++++++++++++++++++++++++++++++++++++++++---- matrix.h | 5 ++ 3 files changed, 172 insertions(+), 19 deletions(-) diff --git a/makefile b/makefile index 5d94684..376d643 100644 --- a/makefile +++ b/makefile @@ -57,12 +57,9 @@ imageInputTests: imageInput.o imageInputTests.c $(unityfolder)/unity.c # -------------------------- # Clean # -------------------------- -#clean: -#ifeq ($(OS),Windows_NT) -# del /f *.o *.exe -#else -# rm -f *.o mnist runMatrixTests runNeuralNetworkTests runImageInputTests -#endif -# clean für windows clean: - rm -f *.o *.exe \ No newline at end of file +ifeq ($(OS),Windows_NT) + del /f *.o *.exe +else + rm -f *.o mnist runMatrixTests runNeuralNetworkTests runImageInputTests +endif \ No newline at end of file diff --git a/matrix.c b/matrix.c index 7a8dcac..2a33d14 100644 --- a/matrix.c +++ b/matrix.c @@ -1,6 +1,8 @@ #include "matrix.h" +#include #include #include + // TODO Matrix-Funktionen implementieren /*typedef struct { unsigned int rows; //Zeilen @@ -8,6 +10,12 @@ MatrixType *buffer; //Zeiger auf Speicherbereich Reihen*Spalten } Matrix;*/ Matrix createMatrix(unsigned int rows, unsigned int cols) { + + Matrix errorMatrix = {0, 0, NULL}; + if (rows == 0 || cols == 0) { + + return errorMatrix; + } MatrixType *buffer = malloc(rows * cols * sizeof(MatrixType)); // Speicher reservieren, malloc // liefert Zeiger auf Speicher @@ -20,6 +28,7 @@ void clearMatrix(Matrix *matrix) { matrix->cols = UNDEFINED_MATRIX_VALUE; free((*matrix).buffer); // Speicher freigeben } + void setMatrixAt(const MatrixType value, Matrix matrix, const unsigned int rowIdx, // Kopie der Matrix wird übergeben const unsigned int colIdx) { @@ -40,26 +49,168 @@ MatrixType getMatrixAt(const Matrix matrix, return value; } + +Matrix broadCastCols(const Matrix matrix, const unsigned int rows, + const unsigned int cols) { + + Matrix copy = createMatrix( + rows, cols); // Matrix 1 Kopie erstellen mit Dimensionen von Matrix2 + for (int r = 0; r < rows; r++) { + + MatrixType value = getMatrixAt(matrix, r, 0); + for (int c = 0; c < cols; c++) { + + setMatrixAt(value, copy, r, c); + } + } + + return copy; +} +Matrix broadCastRows(const Matrix matrix, const unsigned int rows, + const unsigned int cols) { + + Matrix copy = createMatrix(rows, cols); + + for (int c = 0; c < cols; c++) { + MatrixType value = getMatrixAt(matrix, 0, c); + + for (int r = 0; r < rows; r++) { + + setMatrixAt(value, copy, r, c); + } + } + + return copy; +} + Matrix add(const Matrix matrix1, const Matrix matrix2) { - // Ergebnismatrix - Matrix result; + // Broadcasting nur bei Vektor und Matrix, Fehlermeldung bei zwei unpassenden + // Matrizen - // Broadcasting nur bei Vektor und Matrix, Fehlermeldung bei zwei unpassender - // Matrix - if (matrix1.rows != matrix2.rows) { + const unsigned int rows1 = matrix1.rows; + const unsigned int rows2 = matrix2.rows; + const unsigned int cols1 = matrix1.cols; + const unsigned int cols2 = matrix2.cols; - // check, which one is smaller - // realloc + const int rowsEqual = ((rows1 == rows2) ? 1 : 0); + + const int colsEqual = ((cols1 == cols2) ? 1 : 0); + + if (rowsEqual && colsEqual) // addieren + + { + Matrix result = createMatrix(rows1, cols1); // Speicher reservieren + + for (int i = 0; i < (rows1 * cols1); i++) { // addieren + + result.buffer[i] = + (matrix1.buffer[i] + + matrix2.buffer[i]); // buffer[i] ⇔ *(buffer + i) Adresse = + // Startadresse + (i * sizeof(MatrixType)) + } + + return result; // zurückgeben } - if (matrix1.cols != matrix2.cols) { + else if (rowsEqual && !colsEqual) { + + if (cols1 == 1) { + + Matrix result = createMatrix(rows2, cols2); + + Matrix copy1 = broadCastCols(matrix1, rows2, cols2); + + for (int i = 0; i < (rows2 * cols2); i++) { // addieren + + result.buffer[i] = + (copy1.buffer[i] + + matrix2.buffer[i]); // buffer[i] ⇔ *(buffer + i) Adresse = + // Startadresse + (i * sizeof(MatrixType)) + } + return result; + + // add und return + + } else if (cols2 == 1) { + + Matrix result = createMatrix(rows1, cols1); + + Matrix copy2 = broadCastCols(matrix2, rows1, cols1); + + for (int i = 0; i < (rows1 * cols1); i++) { // addieren + + result.buffer[i] = + (matrix1.buffer[i] + + copy2.buffer[i]); // buffer[i] ⇔ *(buffer + i) Adresse = + // Startadresse + (i * sizeof(MatrixType)) + } + return result; + // add und return + + } + + else { + + printf("Fehlermeldung"); // vielleicht Fehlermeldung ändern zu + // Programmabbruch + Matrix error = {0, 0, NULL}; + return error; + } + } - // Speicher reservieren + else if (!rowsEqual && colsEqual) { - // Matrix addieren + if (rows1 == 1) { - return result; + Matrix result = createMatrix(rows2, cols2); + + Matrix copy1 = broadCastRows(matrix1, rows2, cols2); + + for (int i = 0; i < (rows2 * cols2); i++) { // addieren + + result.buffer[i] = + (copy1.buffer[i] + + matrix2.buffer[i]); // buffer[i] ⇔ *(buffer + i) Adresse = + // Startadresse + (i * sizeof(MatrixType)) + } + return result; + + // add und return + + } else if (rows2 == 1) { + + Matrix result = createMatrix(rows1, cols1); + + Matrix copy2 = broadCastCols(matrix2, rows1, cols1); + // add und return + + for (int i = 0; i < (rows1 * cols1); i++) { // addieren + + result.buffer[i] = + (matrix1.buffer[i] + + copy2.buffer[i]); // buffer[i] ⇔ *(buffer + i) Adresse = + // Startadresse + (i * sizeof(MatrixType)) + } + return result; + + } + + else { + + printf("Fehlermeldung"); // vielleicht Fehlermeldung ändern zu + // Programmabbruch + Matrix error = {0, 0, NULL}; + return error; + } + } + + else { + printf( + "Fehlermeldung"); // vielleicht Fehlermeldung ändern zu Programmabbruch + Matrix error = {0, 0, NULL}; + return error; + } } Matrix multiply(const Matrix matrix1, const Matrix matrix2) { return matrix1; } diff --git a/matrix.h b/matrix.h index ca871ae..812b3a0 100644 --- a/matrix.h +++ b/matrix.h @@ -19,6 +19,11 @@ void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx); MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx); + +Matrix broadCastCols(const Matrix matrix, const unsigned int rows, + const unsigned int cols); +Matrix broadCastRows(const Matrix matrix, const unsigned int rows, + const unsigned int cols); Matrix add(const Matrix matrix1, const Matrix matrix2); Matrix multiply(const Matrix matrix1, const Matrix matrix2); From 86a9d16c4f7fe550ee5e27df68a1191a3b6aac61 Mon Sep 17 00:00:00 2001 From: Kristin Date: Sat, 22 Nov 2025 12:41:41 +0100 Subject: [PATCH 2/6] addmatrix mit broadcasten --- matrix.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/matrix.c b/matrix.c index 2a33d14..7d0a649 100644 --- a/matrix.c +++ b/matrix.c @@ -33,6 +33,11 @@ void setMatrixAt(const MatrixType value, Matrix matrix, const unsigned int rowIdx, // Kopie der Matrix wird übergeben const unsigned int colIdx) { + if (rowIdx >= matrix.rows || + colIdx >= matrix.cols) { // Speichergröße nicht überschreiten + return; + } + matrix.buffer[rowIdx * matrix.cols + colIdx] = value; // rowIdx * matrix.cols -> Beginn der Zeile colIdx ->Spalte // innerhalb der Zeile From 56d59b1b5049f20c0f75912c44eed9359483a3a2 Mon Sep 17 00:00:00 2001 From: Kristin Date: Sun, 23 Nov 2025 16:41:57 +0100 Subject: [PATCH 3/6] neuralNetworkTests --- matrix.c | 29 ++- neuralNetwork.c | 435 +++++++++++++++++-------------------- neuralNetworkTests.c | 498 ++++++++++++++++++++++++------------------- 3 files changed, 511 insertions(+), 451 deletions(-) diff --git a/matrix.c b/matrix.c index 7d0a649..ded4faa 100644 --- a/matrix.c +++ b/matrix.c @@ -218,4 +218,31 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) { return error; } } -Matrix multiply(const Matrix matrix1, const Matrix matrix2) { return matrix1; } + +Matrix multiply(const Matrix matrix1, const Matrix matrix2) { + // Spalten1 müssen gleich zeilen2 sein! dann multiplizieren + if (matrix1.cols == matrix2.rows) { + Matrix multMatrix = createMatrix(matrix1.rows, matrix2.cols); + // durch neue matrix iterieren + for (int r = 0; r < matrix1.rows; r++) { + for (int c = 0; c < matrix2.cols; c++) { + MatrixType sum = 0.0; + // skalarprodukte berechnen, k damit die ganze zeile mal die ganze + // spalte genommen wird quasi + for (int k = 0; k < matrix1.cols; k++) { + // sum+= + // matrix1.buffer[r*matrix1.cols+k]*matrix2.buffer[k*matrix2.cols+c]; + sum += getMatrixAt(matrix1, r, k) * getMatrixAt(matrix2, k, c); + } + // Ergebnisse in neue matrix speichern + setMatrixAt(sum, multMatrix, r, c); + } + } + return multMatrix; + } + // sonst fehler, kein multiply möglich + else { + Matrix errorMatrix = {0, 0, NULL}; + return errorMatrix; + } +} \ No newline at end of file diff --git a/neuralNetwork.c b/neuralNetwork.c index bd8f164..7697dd2 100644 --- a/neuralNetwork.c +++ b/neuralNetwork.c @@ -1,268 +1,235 @@ -#include -#include -#include -#include #include "neuralNetwork.h" +#include +#include +#include +#include #define BUFFER_SIZE 100 #define FILE_HEADER_STRING "__info2_neural_network_file_format__" -static void softmax(Matrix *matrix) -{ - if(matrix->cols > 0) - { - double *colSums = (double *)calloc(matrix->cols, sizeof(double)); +static void softmax(Matrix *matrix) { + if (matrix->cols > 0) { + double *colSums = (double *)calloc(matrix->cols, sizeof(double)); - if(colSums != NULL) - { - for(int colIdx = 0; colIdx < matrix->cols; colIdx++) - { - for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) - { - MatrixType expValue = exp(getMatrixAt(*matrix, rowIdx, colIdx)); - setMatrixAt(expValue, *matrix, rowIdx, colIdx); - colSums[colIdx] += expValue; - } - } - - for(int colIdx = 0; colIdx < matrix->cols; colIdx++) - { - for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) - { - MatrixType normalizedValue = getMatrixAt(*matrix, rowIdx, colIdx) / colSums[colIdx]; - setMatrixAt(normalizedValue, *matrix, rowIdx, colIdx); - } - } - free(colSums); + if (colSums != NULL) { + for (int colIdx = 0; colIdx < matrix->cols; colIdx++) { + for (int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) { + MatrixType expValue = exp(getMatrixAt(*matrix, rowIdx, colIdx)); + setMatrixAt(expValue, *matrix, rowIdx, colIdx); + colSums[colIdx] += expValue; } - } -} + } -static void relu(Matrix *matrix) -{ - for(int i = 0; i < matrix->rows * matrix->cols; i++) - { - matrix->buffer[i] = matrix->buffer[i] >= 0 ? matrix->buffer[i] : 0; - } -} - -static int checkFileHeader(FILE *file) -{ - int isValid = 0; - int fileHeaderLen = strlen(FILE_HEADER_STRING); - char buffer[BUFFER_SIZE] = {0}; - - if(BUFFER_SIZE-1 < fileHeaderLen) - fileHeaderLen = BUFFER_SIZE-1; - - if(fread(buffer, sizeof(char), fileHeaderLen, file) == fileHeaderLen) - isValid = strcmp(buffer, FILE_HEADER_STRING) == 0; - - return isValid; -} - -static unsigned int readDimension(FILE *file) -{ - int dimension = 0; - - if(fread(&dimension, sizeof(int), 1, file) != 1) - dimension = 0; - - return dimension; -} - -static Matrix readMatrix(FILE *file, unsigned int rows, unsigned int cols) -{ - Matrix matrix = createMatrix(rows, cols); - - if(matrix.buffer != NULL) - { - if(fread(matrix.buffer, sizeof(MatrixType), rows*cols, file) != rows*cols) - clearMatrix(&matrix); - } - - return matrix; -} - -static Layer readLayer(FILE *file, unsigned int inputDimension, unsigned int outputDimension) -{ - Layer layer; - layer.weights = readMatrix(file, outputDimension, inputDimension); - layer.biases = readMatrix(file, outputDimension, 1); - - return layer; -} - -static int isEmptyLayer(const Layer layer) -{ - return layer.biases.cols == 0 || layer.biases.rows == 0 || layer.biases.buffer == NULL || layer.weights.rows == 0 || layer.weights.cols == 0 || layer.weights.buffer == NULL; -} - -static void clearLayer(Layer *layer) -{ - if(layer != NULL) - { - clearMatrix(&layer->weights); - clearMatrix(&layer->biases); - layer->activation = NULL; - } -} - -static void assignActivations(NeuralNetwork model) -{ - for(int i = 0; i < (int)model.numberOfLayers-1; i++) - { - model.layers[i].activation = relu; - } - - if(model.numberOfLayers > 0) - model.layers[model.numberOfLayers-1].activation = softmax; -} - -NeuralNetwork loadModel(const char *path) -{ - NeuralNetwork model = {NULL, 0}; - FILE *file = fopen(path, "rb"); - - if(file != NULL) - { - if(checkFileHeader(file)) - { - unsigned int inputDimension = readDimension(file); - unsigned int outputDimension = readDimension(file); - - while(inputDimension > 0 && outputDimension > 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); - } + for (int colIdx = 0; colIdx < matrix->cols; colIdx++) { + for (int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) { + MatrixType normalizedValue = + getMatrixAt(*matrix, rowIdx, colIdx) / colSums[colIdx]; + setMatrixAt(normalizedValue, *matrix, rowIdx, colIdx); } - fclose(file); - - assignActivations(model); + } + free(colSums); } - - return model; + } } -static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[], unsigned int count) -{ - Matrix matrix = {NULL, 0, 0}; +static void relu(Matrix *matrix) { + for (int i = 0; i < matrix->rows * matrix->cols; i++) { + matrix->buffer[i] = matrix->buffer[i] >= 0 ? matrix->buffer[i] : 0; + } +} - if(count > 0 && images != NULL) - { - matrix = createMatrix(images[0].height * images[0].width, count); +static int checkFileHeader(FILE *file) { + int isValid = 0; + int fileHeaderLen = strlen(FILE_HEADER_STRING); + char buffer[BUFFER_SIZE] = {0}; - if(matrix.buffer != NULL) - { - for(int i = 0; i < count; i++) - { - for(int j = 0; j < images[i].width * images[i].height; j++) - { - setMatrixAt((MatrixType)images[i].buffer[j], matrix, j, i); - } - } + if (BUFFER_SIZE - 1 < fileHeaderLen) + fileHeaderLen = BUFFER_SIZE - 1; + + if (fread(buffer, sizeof(char), fileHeaderLen, file) == fileHeaderLen) + isValid = strcmp(buffer, FILE_HEADER_STRING) == 0; + + return isValid; +} + +static unsigned int readDimension(FILE *file) { + int dimension = 0; + + if (fread(&dimension, sizeof(int), 1, file) != 1) + dimension = 0; + + return dimension; +} + +static Matrix readMatrix(FILE *file, unsigned int rows, unsigned int cols) { + Matrix matrix = createMatrix(rows, cols); + + if (matrix.buffer != NULL) { + if (fread(matrix.buffer, sizeof(MatrixType), rows * cols, file) != + rows * cols) + clearMatrix(&matrix); + } + + return matrix; +} + +static Layer readLayer(FILE *file, unsigned int inputDimension, + unsigned int outputDimension) { + Layer layer; + layer.weights = readMatrix(file, outputDimension, inputDimension); + layer.biases = readMatrix(file, outputDimension, 1); + + return layer; +} + +static int isEmptyLayer(const Layer layer) { + return layer.biases.cols == 0 || layer.biases.rows == 0 || + layer.biases.buffer == NULL || layer.weights.rows == 0 || + layer.weights.cols == 0 || layer.weights.buffer == NULL; +} + +static void clearLayer(Layer *layer) { + if (layer != NULL) { + clearMatrix(&layer->weights); + clearMatrix(&layer->biases); + layer->activation = NULL; + } +} + +static void assignActivations(NeuralNetwork model) { + for (int i = 0; i < (int)model.numberOfLayers - 1; i++) { + model.layers[i].activation = relu; + } + + if (model.numberOfLayers > 0) + model.layers[model.numberOfLayers - 1].activation = softmax; +} + +NeuralNetwork loadModel(const char *path) { + NeuralNetwork model = {NULL, 0}; + FILE *file = fopen(path, "rb"); + + if (file != NULL) { + if (checkFileHeader(file)) { + unsigned int inputDimension = readDimension(file); + unsigned int outputDimension = readDimension(file); + + while (inputDimension > 0 && outputDimension > 0) { + Layer layer = readLayer(file, inputDimension, outputDimension); + Layer *layerBuffer = NULL; + + if (isEmptyLayer(layer)) { + clearLayer(&layer); + clearModel(&model); + break; } - } - return matrix; -} + layerBuffer = (Layer *)realloc( + model.layers, (model.numberOfLayers + 1) * sizeof(Layer)); -static Matrix forward(const NeuralNetwork model, Matrix inputBatch) -{ - Matrix result = inputBatch; - - if(result.buffer != NULL) - { - for(int i = 0; i < model.numberOfLayers; i++) - { - Matrix biasResult; - Matrix weightResult; - - weightResult = multiply(model.layers[i].weights, result); - clearMatrix(&result); - biasResult = add(model.layers[i].biases, weightResult); - clearMatrix(&weightResult); - - if(model.layers[i].activation != NULL) - model.layers[i].activation(&biasResult); - result = biasResult; + if (layerBuffer != NULL) + model.layers = layerBuffer; + else { + clearModel(&model); + break; } - } - return result; + model.layers[model.numberOfLayers] = layer; + model.numberOfLayers++; + + inputDimension = outputDimension; + outputDimension = readDimension(file); + } + } + fclose(file); + + assignActivations(model); + } + + return model; } -unsigned char *argmax(const Matrix matrix) -{ - unsigned char *maxIdx = NULL; +static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[], + unsigned int count) { + Matrix matrix = {0, 0, NULL}; // falsch herum - if(matrix.rows > 0 && matrix.cols > 0) - { - maxIdx = (unsigned char *)malloc(sizeof(unsigned char) * matrix.cols); + if (count > 0 && images != NULL) { + matrix = createMatrix(images[0].height * images[0].width, count); - if(maxIdx != NULL) - { - for(int colIdx = 0; colIdx < matrix.cols; colIdx++) - { - maxIdx[colIdx] = 0; - - for(int rowIdx = 1; rowIdx < matrix.rows; rowIdx++) - { - if(getMatrixAt(matrix, rowIdx, colIdx) > getMatrixAt(matrix, maxIdx[colIdx], colIdx)) - maxIdx[colIdx] = rowIdx; - } - } + if (matrix.buffer != NULL) { + for (int i = 0; i < count; i++) { + for (int j = 0; j < images[i].width * images[i].height; j++) { + setMatrixAt((MatrixType)images[i].buffer[j], matrix, j, i); } + } } + } - return maxIdx; + return matrix; } -unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[], unsigned int numberOfImages) -{ - Matrix inputBatch = imageBatchToMatrixOfImageVectors(images, numberOfImages); - Matrix outputBatch = forward(model, inputBatch); +static Matrix forward(const NeuralNetwork model, Matrix inputBatch) { + Matrix result = inputBatch; - unsigned char *result = argmax(outputBatch); - - clearMatrix(&outputBatch); - - return result; + if (result.buffer != NULL) { + for (int i = 0; i < model.numberOfLayers; i++) { + Matrix biasResult; + Matrix weightResult; + + weightResult = multiply(model.layers[i].weights, result); + clearMatrix(&result); + biasResult = add(model.layers[i].biases, weightResult); + clearMatrix(&weightResult); + + if (model.layers[i].activation != NULL) + model.layers[i].activation(&biasResult); + result = biasResult; + } + } + + return result; } -void clearModel(NeuralNetwork *model) -{ - if(model != NULL) - { - for(int i = 0; i < model->numberOfLayers; i++) - { - clearLayer(&model->layers[i]); +unsigned char *argmax(const Matrix matrix) { + unsigned char *maxIdx = NULL; + + if (matrix.rows > 0 && matrix.cols > 0) { + maxIdx = (unsigned char *)malloc(sizeof(unsigned char) * matrix.cols); + + if (maxIdx != NULL) { + for (int colIdx = 0; colIdx < matrix.cols; colIdx++) { + maxIdx[colIdx] = 0; + + for (int rowIdx = 1; rowIdx < matrix.rows; rowIdx++) { + if (getMatrixAt(matrix, rowIdx, colIdx) > + getMatrixAt(matrix, maxIdx[colIdx], colIdx)) + maxIdx[colIdx] = rowIdx; } - model->layers = NULL; - model->numberOfLayers = 0; + } } + } + + return maxIdx; +} + +unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[], + unsigned int numberOfImages) { + Matrix inputBatch = imageBatchToMatrixOfImageVectors(images, numberOfImages); + Matrix outputBatch = forward(model, inputBatch); + + unsigned char *result = argmax(outputBatch); + + clearMatrix(&outputBatch); + + return result; +} + +void clearModel(NeuralNetwork *model) { + if (model != NULL) { + for (int i = 0; i < model->numberOfLayers; i++) { + clearLayer(&model->layers[i]); + } + model->layers = NULL; + model->numberOfLayers = 0; + } } \ No newline at end of file diff --git a/neuralNetworkTests.c b/neuralNetworkTests.c index 21ab370..9d2ac42 100644 --- a/neuralNetworkTests.c +++ b/neuralNetworkTests.c @@ -1,242 +1,308 @@ +#include "neuralNetwork.h" +#include "unity.h" +#include #include #include #include -#include -#include "unity.h" -#include "neuralNetwork.h" +static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn) { + FILE *f = fopen(path, "wb"); + if (f == NULL) + return; -static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn) -{ - // TODO -} + /* 1) Header: exakt das String, ohne '\n' oder abschließendes '\0' */ + const char header[] = "__info2_neural_network_file_format__"; + fwrite(header, sizeof(char), strlen(header), f); -void test_loadModelReturnsCorrectNumberOfLayers(void) -{ - const char *path = "some__nn_test_file.info2"; - MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; - MatrixType buffer2[] = {1, 2, 3, 4, 5, 6}; - Matrix weights1 = {.buffer=buffer1, .rows=3, .cols=2}; - Matrix weights2 = {.buffer=buffer2, .rows=2, .cols=3}; - MatrixType buffer3[] = {1, 2, 3}; - MatrixType buffer4[] = {1, 2}; - Matrix biases1 = {.buffer=buffer3, .rows=3, .cols=1}; - Matrix biases2 = {.buffer=buffer4, .rows=2, .cols=1}; - Layer layers[] = {{.weights=weights1, .biases=biases1}, {.weights=weights2, .biases=biases2}}; + /* Wenn es keine Layer gibt, kein Dimensionspaar schreiben (loadModel + wird beim Lesen dann 0 zurückgeben). Aber wir können auch frühzeitig + mit einem 0-Int terminieren — beides ist in Ordnung. */ + if (nn.numberOfLayers == 0) { + /* optional: schreibe ein 0 als next outputDimension (nicht nötig) */ + int zero = 0; + fwrite(&zero, sizeof(int), 1, f); + fclose(f); + return; + } - NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=2}; - NeuralNetwork netUnderTest; + /* 2) Für die erste Layer schreiben wir inputDimension und outputDimension */ + /* inputDimension == weights.cols, outputDimension == weights.rows */ + int inputDim = (int)nn.layers[0].weights.cols; + int outputDim = (int)nn.layers[0].weights.rows; + fwrite(&inputDim, sizeof(int), 1, f); + fwrite(&outputDim, sizeof(int), 1, f); - prepareNeuralNetworkFile(path, expectedNet); + /* 3) Für jede Layer in Reihenfolge: Gewichte (output x input), Biases (output + x 1). Zwischen Layern wird nur die nächste outputDimension (int) + geschrieben. */ + for (int i = 0; i < nn.numberOfLayers; i++) { + Layer layer = nn.layers[i]; - netUnderTest = loadModel(path); - remove(path); + int wrows = (int)layer.weights.rows; + int wcols = (int)layer.weights.cols; + int wcount = wrows * wcols; + int bcount = + layer.biases.rows * layer.biases.cols; /* normalerweise rows * 1 */ - TEST_ASSERT_EQUAL_INT(expectedNet.numberOfLayers, netUnderTest.numberOfLayers); - clearModel(&netUnderTest); -} - -void test_loadModelReturnsCorrectWeightDimensions(void) -{ - const char *path = "some__nn_test_file.info2"; - MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; - Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; - MatrixType biasBuffer[] = {7, 8, 9}; - Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1}; - Layer layers[] = {{.weights=weights, .biases=biases}}; - - NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1}; - NeuralNetwork netUnderTest; - - prepareNeuralNetworkFile(path, expectedNet); - - netUnderTest = loadModel(path); - remove(path); - - TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, netUnderTest.layers[0].weights.rows); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, netUnderTest.layers[0].weights.cols); - clearModel(&netUnderTest); -} - -void test_loadModelReturnsCorrectBiasDimensions(void) -{ - const char *path = "some__nn_test_file.info2"; - MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; - Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; - MatrixType biasBuffer[] = {7, 8, 9}; - Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1}; - Layer layers[] = {{.weights=weights, .biases=biases}}; - - NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1}; - NeuralNetwork netUnderTest; - - prepareNeuralNetworkFile(path, expectedNet); - - netUnderTest = loadModel(path); - remove(path); - - TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.rows, netUnderTest.layers[0].biases.rows); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.cols, netUnderTest.layers[0].biases.cols); - clearModel(&netUnderTest); -} - -void test_loadModelReturnsCorrectWeights(void) -{ - const char *path = "some__nn_test_file.info2"; - MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; - Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; - MatrixType biasBuffer[] = {7, 8, 9}; - Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1}; - Layer layers[] = {{.weights=weights, .biases=biases}}; - - NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1}; - NeuralNetwork netUnderTest; - - prepareNeuralNetworkFile(path, expectedNet); - - netUnderTest = loadModel(path); - remove(path); - - TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, netUnderTest.layers[0].weights.rows); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, netUnderTest.layers[0].weights.cols); - int n = netUnderTest.layers[0].weights.rows * netUnderTest.layers[0].weights.cols; - TEST_ASSERT_EQUAL_INT_ARRAY(expectedNet.layers[0].weights.buffer, netUnderTest.layers[0].weights.buffer, n); - clearModel(&netUnderTest); -} - -void test_loadModelReturnsCorrectBiases(void) -{ - const char *path = "some__nn_test_file.info2"; - MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; - Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; - MatrixType biasBuffer[] = {7, 8, 9}; - Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1}; - Layer layers[] = {{.weights=weights, .biases=biases}}; - - NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1}; - NeuralNetwork netUnderTest; - - prepareNeuralNetworkFile(path, expectedNet); - - netUnderTest = loadModel(path); - remove(path); - - TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, netUnderTest.layers[0].weights.rows); - TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, netUnderTest.layers[0].weights.cols); - int n = netUnderTest.layers[0].biases.rows * netUnderTest.layers[0].biases.cols; - TEST_ASSERT_EQUAL_INT_ARRAY(expectedNet.layers[0].biases.buffer, netUnderTest.layers[0].biases.buffer, n); - clearModel(&netUnderTest); -} - -void test_loadModelFailsOnWrongFileTag(void) -{ - const char *path = "some_nn_test_file.info2"; - NeuralNetwork netUnderTest; - FILE *file = fopen(path, "wb"); - - if(file != NULL) - { - const char *fileTag = "info2_neural_network_file_format"; - - fwrite(fileTag, sizeof(char), strlen(fileTag), file); - - fclose(file); + /* Gewichte (MatrixType binär) */ + if (wcount > 0 && layer.weights.buffer != NULL) { + fwrite(layer.weights.buffer, sizeof(MatrixType), (size_t)wcount, f); } - netUnderTest = loadModel(path); - - remove(path); - - TEST_ASSERT_NULL(netUnderTest.layers); - TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers); -} - -void test_clearModelSetsMembersToNull(void) -{ - const char *path = "some__nn_test_file.info2"; - MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; - Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; - MatrixType biasBuffer[] = {7, 8, 9}; - Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1}; - Layer layers[] = {{.weights=weights, .biases=biases}}; - - NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1}; - NeuralNetwork netUnderTest; - - prepareNeuralNetworkFile(path, expectedNet); - - netUnderTest = loadModel(path); - remove(path); - - TEST_ASSERT_NOT_NULL(netUnderTest.layers); - TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); - clearModel(&netUnderTest); - TEST_ASSERT_NULL(netUnderTest.layers); - TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers); -} - -static void someActivation(Matrix *matrix) -{ - for(int i = 0; i < matrix->rows * matrix->cols; i++) - { - matrix->buffer[i] = fabs(matrix->buffer[i]); + /* Biases (MatrixType binär) */ + if (bcount > 0 && layer.biases.buffer != NULL) { + fwrite(layer.biases.buffer, sizeof(MatrixType), (size_t)bcount, f); } + + /* Für die nächste Layer: falls vorhanden, schreibe deren outputDimension */ + if (i + 1 < nn.numberOfLayers) { + int nextOutput = (int)nn.layers[i + 1].weights.rows; + fwrite(&nextOutput, sizeof(int), 1, f); + } else { + /* Letzte Layer: wir können das Ende signalisieren, indem wir ein 0 + schreiben. loadModel liest dann outputDimension = 0 und beendet die + Schleife. */ + int zero = 0; + fwrite(&zero, sizeof(int), 1, f); + } + } + + fclose(f); } -void test_predictReturnsCorrectLabels(void) -{ - const unsigned char expectedLabels[] = {4, 2}; - GrayScalePixelType imageBuffer1[] = {10, 30, 25, 17}; - GrayScalePixelType imageBuffer2[] = {20, 40, 10, 128}; - GrayScaleImage inputImages[] = {{.buffer=imageBuffer1, .width=2, .height=2}, {.buffer=imageBuffer2, .width=2, .height=2}}; - MatrixType weightsBuffer1[] = {1, -2, 3, -4, 5, -6, 7, -8}; - MatrixType weightsBuffer2[] = {-9, 10, 11, 12, 13, 14}; - MatrixType weightsBuffer3[] = {-15, 16, 17, 18, -19, 20, 21, 22, 23, -24, 25, 26, 27, -28, -29}; - Matrix weights1 = {.buffer=weightsBuffer1, .rows=2, .cols=4}; - Matrix weights2 = {.buffer=weightsBuffer2, .rows=3, .cols=2}; - Matrix weights3 = {.buffer=weightsBuffer3, .rows=5, .cols=3}; - MatrixType biasBuffer1[] = {200, 0}; - MatrixType biasBuffer2[] = {0, -100, 0}; - MatrixType biasBuffer3[] = {0, -1000, 0, 2000, 0}; - Matrix biases1 = {.buffer=biasBuffer1, .rows=2, .cols=1}; - Matrix biases2 = {.buffer=biasBuffer2, .rows=3, .cols=1}; - Matrix biases3 = {.buffer=biasBuffer3, .rows=5, .cols=1}; - Layer layers[] = {{.weights=weights1, .biases=biases1, .activation=someActivation}, \ - {.weights=weights2, .biases=biases2, .activation=someActivation}, \ - {.weights=weights3, .biases=biases3, .activation=someActivation}}; - NeuralNetwork netUnderTest = {.layers=layers, .numberOfLayers=3}; - unsigned char *predictedLabels = predict(netUnderTest, inputImages, 2); - TEST_ASSERT_NOT_NULL(predictedLabels); - int n = (int)(sizeof(expectedLabels) / sizeof(expectedLabels[0])); - TEST_ASSERT_EQUAL_UINT8_ARRAY(expectedLabels, predictedLabels, n); - free(predictedLabels); +void test_loadModelReturnsCorrectNumberOfLayers(void) { + const char *path = "some__nn_test_file.info2"; + MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; + MatrixType buffer2[] = {1, 2, 3, 4, 5, 6}; + Matrix weights1 = {.buffer = buffer1, .rows = 3, .cols = 2}; + Matrix weights2 = {.buffer = buffer2, .rows = 2, .cols = 3}; + MatrixType buffer3[] = {1, 2, 3}; + MatrixType buffer4[] = {1, 2}; + Matrix biases1 = {.buffer = buffer3, .rows = 3, .cols = 1}; + Matrix biases2 = {.buffer = buffer4, .rows = 2, .cols = 1}; + Layer layers[] = {{.weights = weights1, .biases = biases1}, + {.weights = weights2, .biases = biases2}}; + + NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 2}; + NeuralNetwork netUnderTest; + + prepareNeuralNetworkFile(path, expectedNet); + + netUnderTest = loadModel(path); + remove(path); + + TEST_ASSERT_EQUAL_INT(expectedNet.numberOfLayers, + netUnderTest.numberOfLayers); + clearModel(&netUnderTest); +} + +void test_loadModelReturnsCorrectWeightDimensions(void) { + const char *path = "some__nn_test_file.info2"; + MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; + Matrix weights = {.buffer = weightBuffer, .rows = 3, .cols = 2}; + MatrixType biasBuffer[] = {7, 8, 9}; + Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; + Layer layers[] = {{.weights = weights, .biases = biases}}; + + NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; + NeuralNetwork netUnderTest; + + prepareNeuralNetworkFile(path, expectedNet); + + netUnderTest = loadModel(path); + remove(path); + + TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, + netUnderTest.layers[0].weights.rows); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, + netUnderTest.layers[0].weights.cols); + clearModel(&netUnderTest); +} + +void test_loadModelReturnsCorrectBiasDimensions(void) { + const char *path = "some__nn_test_file.info2"; + MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; + Matrix weights = {.buffer = weightBuffer, .rows = 3, .cols = 2}; + MatrixType biasBuffer[] = {7, 8, 9}; + Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; + Layer layers[] = {{.weights = weights, .biases = biases}}; + + NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; + NeuralNetwork netUnderTest; + + prepareNeuralNetworkFile(path, expectedNet); + + netUnderTest = loadModel(path); + remove(path); + + TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.rows, + netUnderTest.layers[0].biases.rows); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.cols, + netUnderTest.layers[0].biases.cols); + clearModel(&netUnderTest); +} + +void test_loadModelReturnsCorrectWeights(void) { + const char *path = "some__nn_test_file.info2"; + MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; + Matrix weights = {.buffer = weightBuffer, .rows = 3, .cols = 2}; + MatrixType biasBuffer[] = {7, 8, 9}; + Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; + Layer layers[] = {{.weights = weights, .biases = biases}}; + + NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; + NeuralNetwork netUnderTest; + + prepareNeuralNetworkFile(path, expectedNet); + + netUnderTest = loadModel(path); + remove(path); + + TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, + netUnderTest.layers[0].weights.rows); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, + netUnderTest.layers[0].weights.cols); + int n = + netUnderTest.layers[0].weights.rows * netUnderTest.layers[0].weights.cols; + TEST_ASSERT_EQUAL_INT_ARRAY(expectedNet.layers[0].weights.buffer, + netUnderTest.layers[0].weights.buffer, n); + clearModel(&netUnderTest); +} + +void test_loadModelReturnsCorrectBiases(void) { + const char *path = "some__nn_test_file.info2"; + MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; + Matrix weights = {.buffer = weightBuffer, .rows = 3, .cols = 2}; + MatrixType biasBuffer[] = {7, 8, 9}; + Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; + Layer layers[] = {{.weights = weights, .biases = biases}}; + + NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; + NeuralNetwork netUnderTest; + + prepareNeuralNetworkFile(path, expectedNet); + + netUnderTest = loadModel(path); + remove(path); + + TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, + netUnderTest.layers[0].weights.rows); + TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, + netUnderTest.layers[0].weights.cols); + int n = + netUnderTest.layers[0].biases.rows * netUnderTest.layers[0].biases.cols; + TEST_ASSERT_EQUAL_INT_ARRAY(expectedNet.layers[0].biases.buffer, + netUnderTest.layers[0].biases.buffer, n); + clearModel(&netUnderTest); +} + +void test_loadModelFailsOnWrongFileTag(void) { + const char *path = "some_nn_test_file.info2"; + NeuralNetwork netUnderTest; + FILE *file = fopen(path, "wb"); + + if (file != NULL) { + const char *fileTag = "info2_neural_network_file_format"; + + fwrite(fileTag, sizeof(char), strlen(fileTag), file); + + fclose(file); + } + + netUnderTest = loadModel(path); + + remove(path); + + TEST_ASSERT_NULL(netUnderTest.layers); + TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers); +} + +void test_clearModelSetsMembersToNull(void) { + const char *path = "some__nn_test_file.info2"; + MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; + Matrix weights = {.buffer = weightBuffer, .rows = 3, .cols = 2}; + MatrixType biasBuffer[] = {7, 8, 9}; + Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; + Layer layers[] = {{.weights = weights, .biases = biases}}; + + NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; + NeuralNetwork netUnderTest; + + prepareNeuralNetworkFile(path, expectedNet); + + netUnderTest = loadModel(path); + remove(path); + + TEST_ASSERT_NOT_NULL(netUnderTest.layers); + TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); + clearModel(&netUnderTest); + TEST_ASSERT_NULL(netUnderTest.layers); + TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers); +} + +static void someActivation(Matrix *matrix) { + for (int i = 0; i < matrix->rows * matrix->cols; i++) { + matrix->buffer[i] = fabs(matrix->buffer[i]); + } +} + +void test_predictReturnsCorrectLabels(void) { + const unsigned char expectedLabels[] = {4, 2}; + GrayScalePixelType imageBuffer1[] = {10, 30, 25, 17}; + GrayScalePixelType imageBuffer2[] = {20, 40, 10, 128}; + GrayScaleImage inputImages[] = { + {.buffer = imageBuffer1, .width = 2, .height = 2}, + {.buffer = imageBuffer2, .width = 2, .height = 2}}; + MatrixType weightsBuffer1[] = {1, -2, 3, -4, 5, -6, 7, -8}; + MatrixType weightsBuffer2[] = {-9, 10, 11, 12, 13, 14}; + MatrixType weightsBuffer3[] = {-15, 16, 17, 18, -19, 20, 21, 22, + 23, -24, 25, 26, 27, -28, -29}; + Matrix weights1 = {.buffer = weightsBuffer1, .rows = 2, .cols = 4}; + Matrix weights2 = {.buffer = weightsBuffer2, .rows = 3, .cols = 2}; + Matrix weights3 = {.buffer = weightsBuffer3, .rows = 5, .cols = 3}; + MatrixType biasBuffer1[] = {200, 0}; + MatrixType biasBuffer2[] = {0, -100, 0}; + MatrixType biasBuffer3[] = {0, -1000, 0, 2000, 0}; + Matrix biases1 = {.buffer = biasBuffer1, .rows = 2, .cols = 1}; + Matrix biases2 = {.buffer = biasBuffer2, .rows = 3, .cols = 1}; + Matrix biases3 = {.buffer = biasBuffer3, .rows = 5, .cols = 1}; + Layer layers[] = { + {.weights = weights1, .biases = biases1, .activation = someActivation}, + {.weights = weights2, .biases = biases2, .activation = someActivation}, + {.weights = weights3, .biases = biases3, .activation = someActivation}}; + NeuralNetwork netUnderTest = {.layers = layers, .numberOfLayers = 3}; + unsigned char *predictedLabels = predict(netUnderTest, inputImages, 2); + TEST_ASSERT_NOT_NULL(predictedLabels); + int n = (int)(sizeof(expectedLabels) / sizeof(expectedLabels[0])); + TEST_ASSERT_EQUAL_UINT8_ARRAY(expectedLabels, predictedLabels, n); + free(predictedLabels); } void setUp(void) { - // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden + // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden } void tearDown(void) { - // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden + // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden } -int main() -{ - UNITY_BEGIN(); +int main() { + UNITY_BEGIN(); - printf("\n============================\nNeural network tests\n============================\n"); - RUN_TEST(test_loadModelReturnsCorrectNumberOfLayers); - RUN_TEST(test_loadModelReturnsCorrectWeightDimensions); - RUN_TEST(test_loadModelReturnsCorrectBiasDimensions); - RUN_TEST(test_loadModelReturnsCorrectWeights); - RUN_TEST(test_loadModelReturnsCorrectBiases); - RUN_TEST(test_loadModelFailsOnWrongFileTag); - RUN_TEST(test_clearModelSetsMembersToNull); - RUN_TEST(test_predictReturnsCorrectLabels); + printf("\n============================\nNeural network " + "tests\n============================\n"); + RUN_TEST(test_loadModelReturnsCorrectNumberOfLayers); + RUN_TEST(test_loadModelReturnsCorrectWeightDimensions); + RUN_TEST(test_loadModelReturnsCorrectBiasDimensions); + RUN_TEST(test_loadModelReturnsCorrectWeights); + RUN_TEST(test_loadModelReturnsCorrectBiases); + RUN_TEST(test_loadModelFailsOnWrongFileTag); + RUN_TEST(test_clearModelSetsMembersToNull); + RUN_TEST(test_predictReturnsCorrectLabels); - return UNITY_END(); + return UNITY_END(); } \ No newline at end of file From 7aa57191da9231916cf77d4bbd8f8e0d76f66a8a Mon Sep 17 00:00:00 2001 From: Kristin Date: Sun, 23 Nov 2025 17:16:18 +0100 Subject: [PATCH 4/6] neuralNetworkTests mit Kommentaren --- matrix.c | 32 ++------------------------------ neuralNetworkTests.c | 38 ++++++++++++++++++++++++++++++-------- 2 files changed, 32 insertions(+), 38 deletions(-) diff --git a/matrix.c b/matrix.c index 64d551c..4a2ec16 100644 --- a/matrix.c +++ b/matrix.c @@ -89,30 +89,6 @@ Matrix broadCastRows(const Matrix matrix, const unsigned int rows, } Matrix add(const Matrix matrix1, const Matrix matrix2) { - Matrix result; - const int cols1 = matrix1.cols; - const int rows1 = matrix1.rows; - const int cols2 = matrix2.cols; - const int rows2 = matrix2.rows; - const int colsEqu = (matrix1.cols == matrix2.cols) ? 1 : 0; - const int rowsEqu = (matrix1.rows == matrix2.rows) ? 1 : 0; - if(colsEqu && rowsEqu) - { - Matrix result = createMatrix(matrix1.rows, matrix1.cols); - for(int i = 0; i < rows1; i++) - { - for (int j = 0; j < cols1; j++) - { - int valueM1 = getMatrixAt(matrix1, i, j); - int valueM2 =getMatrixAt(matrix2, i, j); - int sum = valueM1 + valueM2; - setMatrixAt(sum, result,i,j); - } - } - -<<<<<<< HEAD - // Broadcasting nur bei Vektor und Matrix, Fehlermeldung bei zwei unpassenden - // Matrizen const unsigned int rows1 = matrix1.rows; const unsigned int rows2 = matrix2.rows; @@ -233,15 +209,11 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) { } else { - printf( - "Fehlermeldung"); // vielleicht Fehlermeldung ändern zu Programmabbruch + printf("Fehlermeldung"); // vielleicht Fehlermeldung ändern zu + // Programmabbruch Matrix error = {0, 0, NULL}; return error; } -======= - return result; - } ->>>>>>> 7f3c6d1d3f7d4ee08747df6a4999e1908f5dd56d } Matrix multiply(const Matrix matrix1, const Matrix matrix2) { diff --git a/neuralNetworkTests.c b/neuralNetworkTests.c index 9d2ac42..8b6c307 100644 --- a/neuralNetworkTests.c +++ b/neuralNetworkTests.c @@ -5,28 +5,50 @@ #include #include +/*typedef struct +{ + Matrix weights; + Matrix biases; + ActivationFunctionType activation; +} Layer; + +typedef struct +{ + Layer *layers; + unsigned int numberOfLayers; +} NeuralNetwork;*/ + +/*Layer: Ebene im neuronalen Netzwerk, besteht aus mehreren Neuronen +Input-Layer: Eingabedatei +Hidden-Layer: verarbeiten die Daten +Output-Layer: Ergebnis + + +Gewichte: bestimmen, wie stark ein Eingangssignal auf ein Neuron wirkt + +Dimension: Form der Matrizen für einen Layer*/ + +// speichert NeuralNetwork nn in binäre Datei->erzeugt Dateiformat static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn) { - FILE *f = fopen(path, "wb"); + FILE *f = fopen(path, "wb"); // Binärdatei zum Schreiben öffnen if (f == NULL) return; - /* 1) Header: exakt das String, ohne '\n' oder abschließendes '\0' */ + // Header ist Erkennungsstring am Anfang der Datei, loadmodel erkennt + // Dateiformat const char header[] = "__info2_neural_network_file_format__"; fwrite(header, sizeof(char), strlen(header), f); - /* Wenn es keine Layer gibt, kein Dimensionspaar schreiben (loadModel - wird beim Lesen dann 0 zurückgeben). Aber wir können auch frühzeitig - mit einem 0-Int terminieren — beides ist in Ordnung. */ + // Wenn es keine Layer gibt, 0 eintragen, LoadModel gibt 0 zurück if (nn.numberOfLayers == 0) { - /* optional: schreibe ein 0 als next outputDimension (nicht nötig) */ int zero = 0; fwrite(&zero, sizeof(int), 1, f); fclose(f); return; } - /* 2) Für die erste Layer schreiben wir inputDimension und outputDimension */ - /* inputDimension == weights.cols, outputDimension == weights.rows */ + // Layer 0, inputDimension: Anzahl Input-Neuronen, outputDimension: Anzahl + // Output-Neuronen int inputDim = (int)nn.layers[0].weights.cols; int outputDim = (int)nn.layers[0].weights.rows; fwrite(&inputDim, sizeof(int), 1, f); From 0f0f2f19c3bc297ddad9cb7375a03525f4be5645 Mon Sep 17 00:00:00 2001 From: Kristin Date: Tue, 25 Nov 2025 09:57:13 +0100 Subject: [PATCH 5/6] lauffaehige version, noch haesslich --- imageInput.c | 138 +++++++++++++++++++--- imageInputTests.c | 293 ++++++++++++++++++++++++++++------------------ matrix.c | 97 ++++++++++----- 3 files changed, 362 insertions(+), 166 deletions(-) diff --git a/imageInput.c b/imageInput.c index d31a7da..0015137 100644 --- a/imageInput.c +++ b/imageInput.c @@ -1,29 +1,131 @@ +#include "imageInput.h" #include #include #include -#include "imageInput.h" -#define BUFFER_SIZE 100 #define FILE_HEADER_STRING "__info2_image_file_format__" -// TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei -GrayScaleImage readImage() -{ - +/* ---------------------------------------------------------- + 1. Header prüfen + ---------------------------------------------------------- */ +static int readHeader(FILE *file) { + char header[sizeof(FILE_HEADER_STRING)]; + if (fread(header, 1, sizeof(FILE_HEADER_STRING) - 1, file) != + sizeof(FILE_HEADER_STRING) - 1) + return 0; + header[sizeof(FILE_HEADER_STRING) - 1] = '\0'; + return strcmp(header, FILE_HEADER_STRING) == 0; } -// TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen -GrayScaleImageSeries *readImages(const char *path) -{ - GrayScaleImageSeries *series = NULL; - FILE *file = fopen("mnist_test.info2","rb"); - char headOfFile; - series = malloc(); - return series; +/* ---------------------------------------------------------- + 2. Meta-Daten lesen (unsigned short) + ---------------------------------------------------------- */ +static int readMeta(FILE *file, unsigned short *count, unsigned short *width, + unsigned short *height) { + if (fread(count, sizeof(unsigned short), 1, file) != 1) + return 0; + if (fread(width, sizeof(unsigned short), 1, file) != 1) + return 0; + if (fread(height, sizeof(unsigned short), 1, file) != 1) + return 0; + return 1; } -// TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt -void clearSeries(GrayScaleImageSeries *series) -{ +/* ---------------------------------------------------------- + 3. Einzelbild lesen + ---------------------------------------------------------- */ +static int readSingleImage(FILE *file, GrayScaleImage *img, + unsigned short width, unsigned short height) { + img->width = width; + img->height = height; -} \ No newline at end of file + size_t numPixels = (size_t)width * (size_t)height; + img->buffer = malloc(numPixels); + if (!img->buffer) + return 0; + + if (fread(img->buffer, 1, numPixels, file) != numPixels) { + free(img->buffer); + img->buffer = NULL; + return 0; + } + return 1; +} + +/* ---------------------------------------------------------- + 4. Label lesen + ---------------------------------------------------------- */ +static int readLabel(FILE *file, unsigned char *label) { + return fread(label, 1, 1, file) == 1; +} + +/* ---------------------------------------------------------- + 5. Komplette Bildserie lesen + ---------------------------------------------------------- */ +GrayScaleImageSeries *readImages(const char *path) { + FILE *file = fopen(path, "rb"); + if (!file) + return NULL; + + if (!readHeader(file)) { + fclose(file); + return NULL; + } + + unsigned short count, width, height; + if (!readMeta(file, &count, &width, &height)) { + fclose(file); + return NULL; + } + + GrayScaleImageSeries *series = malloc(sizeof(GrayScaleImageSeries)); + if (!series) { + fclose(file); + return NULL; + } + + series->count = count; + series->images = malloc(count * sizeof(GrayScaleImage)); + series->labels = malloc(count * sizeof(unsigned char)); + if (!series->images || !series->labels) { + free(series->images); + free(series->labels); + free(series); + fclose(file); + return NULL; + } + + for (unsigned int i = 0; i < count; i++) { + if (!readSingleImage(file, &series->images[i], width, height) || + !readLabel(file, &series->labels[i])) { + // Aufräumen bei Fehler + for (unsigned int j = 0; j < i; j++) { + free(series->images[j].buffer); + } + free(series->images); + free(series->labels); + free(series); + fclose(file); + return NULL; + } + } + + fclose(file); + return series; +} + +/* ---------------------------------------------------------- + 6. Speicher komplett freigeben + ---------------------------------------------------------- */ +void clearSeries(GrayScaleImageSeries *series) { + if (!series) + return; + + for (unsigned int i = 0; i < series->count; i++) { + free(series->images[i].buffer); + } + + free(series->images); + free(series->labels); + free(series); +} diff --git a/imageInputTests.c b/imageInputTests.c index 03240ab..e498ec4 100644 --- a/imageInputTests.c +++ b/imageInputTests.c @@ -1,143 +1,204 @@ - -#include -#include -#include -#include "unity.h" #include "imageInput.h" +#include "unity.h" +#include +#include +#include +/* --------------------------------------------------------- + Hilfsfunktion: Testdatei vorbereiten + --------------------------------------------------------- */ +static void prepareImageFile(const char *path, unsigned int width, + unsigned int height, unsigned int numberOfImages, + unsigned char label) { + FILE *file = fopen(path, "wb"); + if (!file) + return; -static void prepareImageFile(const char *path, unsigned short int width, unsigned short int height, unsigned int short numberOfImages, unsigned char label) -{ - FILE *file = fopen(path, "wb"); + // Header + const char *fileTag = "__info2_image_file_format__"; + fwrite(fileTag, 1, strlen(fileTag), file); - if(file != NULL) - { - const char *fileTag = "__info2_image_file_format__"; - GrayScalePixelType *zeroBuffer = (GrayScalePixelType *)calloc(numberOfImages * width * height, sizeof(GrayScalePixelType)); + // Meta-Daten als unsigned short + unsigned short n = (unsigned short)numberOfImages; + unsigned short w = (unsigned short)width; + unsigned short h = (unsigned short)height; + fwrite(&n, sizeof(unsigned short), 1, file); + fwrite(&w, sizeof(unsigned short), 1, file); + fwrite(&h, sizeof(unsigned short), 1, file); - if(zeroBuffer != NULL) - { - fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file); - fwrite(&numberOfImages, sizeof(numberOfImages), 1, file); - fwrite(&width, sizeof(width), 1, file); - fwrite(&height, sizeof(height), 1, file); + // Pixelbuffer + GrayScalePixelType *buffer = + calloc(width * height, sizeof(GrayScalePixelType)); + if (!buffer) { + fclose(file); + return; + } + for (unsigned int i = 0; i < width * height; i++) + buffer[i] = (GrayScalePixelType)i; - for(int i = 0; i < numberOfImages; i++) - { - fwrite(zeroBuffer, sizeof(GrayScalePixelType), width * height, file); - fwrite(&label, sizeof(unsigned char), 1, file); - } + // Jedes Bild schreiben: Pixel + Label + for (unsigned int img = 0; img < numberOfImages; img++) { + fwrite(buffer, sizeof(GrayScalePixelType), width * height, file); + fwrite(&label, sizeof(unsigned char), 1, file); + } - free(zeroBuffer); - } - - fclose(file); - } + free(buffer); + fclose(file); } +/* --------------------------------------------------------- + Unit Tests + --------------------------------------------------------- */ -void test_readImagesReturnsCorrectNumberOfImages(void) -{ - GrayScaleImageSeries *series = NULL; - const unsigned short expectedNumberOfImages = 2; - const char *path = "testFile.info2"; - prepareImageFile(path, 8, 8, expectedNumberOfImages, 1); - series = readImages(path); - TEST_ASSERT_NOT_NULL(series); - TEST_ASSERT_EQUAL_UINT16(expectedNumberOfImages, series->count); - clearSeries(series); - remove(path); +void test_readImagesReturnsCorrectNumberOfImages(void) { + GrayScaleImageSeries *series = NULL; + const unsigned int expectedNumberOfImages = 2; + const char *path = "testFile.info2"; + prepareImageFile(path, 8, 8, expectedNumberOfImages, 1); + series = readImages(path); + TEST_ASSERT_NOT_NULL(series); + TEST_ASSERT_EQUAL_UINT(expectedNumberOfImages, series->count); + clearSeries(series); + remove(path); } -void test_readImagesReturnsCorrectImageWidth(void) -{ - GrayScaleImageSeries *series = NULL; - const unsigned short expectedWidth = 10; - const char *path = "testFile.info2"; - prepareImageFile(path, expectedWidth, 8, 2, 1); - series = readImages(path); - TEST_ASSERT_NOT_NULL(series); - TEST_ASSERT_NOT_NULL(series->images); - TEST_ASSERT_EQUAL_UINT16(2, series->count); - TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[0].width); - TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[1].width); - clearSeries(series); - remove(path); +void test_readImagesReturnsCorrectImageWidth(void) { + GrayScaleImageSeries *series = NULL; + const unsigned int expectedWidth = 10; + const char *path = "testFile.info2"; + prepareImageFile(path, expectedWidth, 8, 2, 1); + series = readImages(path); + TEST_ASSERT_NOT_NULL(series); + TEST_ASSERT_NOT_NULL(series->images); + TEST_ASSERT_EQUAL_UINT(2, series->count); + TEST_ASSERT_EQUAL_UINT(expectedWidth, series->images[0].width); + TEST_ASSERT_EQUAL_UINT(expectedWidth, series->images[1].width); + clearSeries(series); + remove(path); } -void test_readImagesReturnsCorrectImageHeight(void) -{ - GrayScaleImageSeries *series = NULL; - const unsigned short expectedHeight = 10; - const char *path = "testFile.info2"; - prepareImageFile(path, 8, expectedHeight, 2, 1); - series = readImages(path); - TEST_ASSERT_NOT_NULL(series); - TEST_ASSERT_NOT_NULL(series->images); - TEST_ASSERT_EQUAL_UINT16(2, series->count); - TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[0].height); - TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[1].height); - clearSeries(series); - remove(path); +void test_readImagesReturnsCorrectImageHeight(void) { + GrayScaleImageSeries *series = NULL; + const unsigned int expectedHeight = 10; + const char *path = "testFile.info2"; + prepareImageFile(path, 8, expectedHeight, 2, 1); + series = readImages(path); + TEST_ASSERT_NOT_NULL(series); + TEST_ASSERT_NOT_NULL(series->images); + TEST_ASSERT_EQUAL_UINT(2, series->count); + TEST_ASSERT_EQUAL_UINT(expectedHeight, series->images[0].height); + TEST_ASSERT_EQUAL_UINT(expectedHeight, series->images[1].height); + clearSeries(series); + remove(path); } -void test_readImagesReturnsCorrectLabels(void) -{ - const unsigned char expectedLabel = 15; +void test_readImagesReturnsCorrectLabels(void) { + const unsigned char expectedLabel = 15; - GrayScaleImageSeries *series = NULL; - const char *path = "testFile.info2"; - prepareImageFile(path, 8, 8, 2, expectedLabel); - series = readImages(path); - TEST_ASSERT_NOT_NULL(series); - TEST_ASSERT_NOT_NULL(series->labels); - TEST_ASSERT_EQUAL_UINT16(2, series->count); - for (int i = 0; i < 2; i++) { - TEST_ASSERT_EQUAL_UINT8(expectedLabel, series->labels[i]); - } - clearSeries(series); - remove(path); + GrayScaleImageSeries *series = NULL; + const char *path = "testFile.info2"; + prepareImageFile(path, 8, 8, 2, expectedLabel); + series = readImages(path); + TEST_ASSERT_NOT_NULL(series); + TEST_ASSERT_NOT_NULL(series->labels); + TEST_ASSERT_EQUAL_UINT(2, series->count); + for (int i = 0; i < 2; i++) { + TEST_ASSERT_EQUAL_UINT8(expectedLabel, series->labels[i]); + } + clearSeries(series); + remove(path); } -void test_readImagesReturnsNullOnNotExistingPath(void) -{ - const char *path = "testFile.txt"; - remove(path); +void test_readImagesReturnsNullOnNotExistingPath(void) { + const char *path = "testFile.txt"; + remove(path); + TEST_ASSERT_NULL(readImages(path)); +} + +void test_readImagesFailsOnWrongFileTag(void) { + const char *path = "testFile.info2"; + FILE *file = fopen(path, "w"); + if (file != NULL) { + fprintf(file, "some_tag "); + fclose(file); TEST_ASSERT_NULL(readImages(path)); + } + remove(path); } -void test_readImagesFailsOnWrongFileTag(void) -{ - const char *path = "testFile.info2"; - FILE *file = fopen(path, "w"); - if(file != NULL) - { - fprintf(file, "some_tag "); - fclose(file); - TEST_ASSERT_NULL(readImages(path)); - } - remove(path); +void test_read_GrayScale_Pixel(void) { + GrayScaleImageSeries *series = NULL; + const char *path = "testFile.info2"; + + prepareImageFile(path, 8, 8, 1, 1); + series = readImages(path); + + TEST_ASSERT_NOT_NULL(series); + TEST_ASSERT_NOT_NULL(series->images); + TEST_ASSERT_EQUAL_UINT(1, series->count); + + for (int i = 0; i < (8 * 8); i++) { + TEST_ASSERT_EQUAL_UINT8((GrayScalePixelType)i, series->images[0].buffer[i]); + } + + clearSeries(series); + remove(path); } -void setUp(void) { - // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden +/* --------------------------------------------------------- + Optional: Mehrere Bilder gleichzeitig testen + --------------------------------------------------------- */ + +void test_readImagesMultipleImagesContent(void) { + GrayScaleImageSeries *series = NULL; + const char *path = "testFile.info2"; + const unsigned int numberOfImages = 3; + const unsigned int width = 4; + const unsigned int height = 4; + const unsigned char label = 7; + + prepareImageFile(path, width, height, numberOfImages, label); + + series = readImages(path); + TEST_ASSERT_NOT_NULL(series); + TEST_ASSERT_NOT_NULL(series->images); + TEST_ASSERT_NOT_NULL(series->labels); + TEST_ASSERT_EQUAL_UINT(numberOfImages, series->count); + + for (unsigned int img = 0; img < numberOfImages; img++) { + for (unsigned int i = 0; i < width * height; i++) + TEST_ASSERT_EQUAL_UINT8((GrayScalePixelType)i, + series->images[img].buffer[i]); + TEST_ASSERT_EQUAL_UINT8(label, series->labels[img]); + } + + clearSeries(series); + remove(path); } -void tearDown(void) { - // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden +/* --------------------------------------------------------- + Setup / Teardown + --------------------------------------------------------- */ +void setUp(void) {} +void tearDown(void) {} + +/* --------------------------------------------------------- + main() + --------------------------------------------------------- */ +int main(void) { + UNITY_BEGIN(); + + printf("\n============================\nImage input " + "tests\n============================\n"); + + RUN_TEST(test_readImagesReturnsCorrectNumberOfImages); + RUN_TEST(test_readImagesReturnsCorrectImageWidth); + RUN_TEST(test_readImagesReturnsCorrectImageHeight); + RUN_TEST(test_readImagesReturnsCorrectLabels); + RUN_TEST(test_readImagesReturnsNullOnNotExistingPath); + RUN_TEST(test_readImagesFailsOnWrongFileTag); + RUN_TEST(test_read_GrayScale_Pixel); + RUN_TEST(test_readImagesMultipleImagesContent); + + return UNITY_END(); } - -int main() -{ - UNITY_BEGIN(); - - printf("\n============================\nImage input tests\n============================\n"); - RUN_TEST(test_readImagesReturnsCorrectNumberOfImages); - RUN_TEST(test_readImagesReturnsCorrectImageWidth); - RUN_TEST(test_readImagesReturnsCorrectImageHeight); - RUN_TEST(test_readImagesReturnsCorrectLabels); - RUN_TEST(test_readImagesReturnsNullOnNotExistingPath); - RUN_TEST(test_readImagesFailsOnWrongFileTag); - - return UNITY_END(); -} \ No newline at end of file diff --git a/matrix.c b/matrix.c index 4a2ec16..b20d718 100644 --- a/matrix.c +++ b/matrix.c @@ -10,31 +10,45 @@ MatrixType *buffer; //Zeiger auf Speicherbereich Reihen*Spalten } Matrix;*/ Matrix createMatrix(unsigned int rows, unsigned int cols) { - + Matrix matrix; Matrix errorMatrix = {0, 0, NULL}; if (rows == 0 || cols == 0) { return errorMatrix; } - MatrixType *buffer = - malloc(rows * cols * sizeof(MatrixType)); // Speicher reservieren, malloc - // liefert Zeiger auf Speicher - Matrix newMatrix = {rows, cols, buffer}; // neue Matrix nach struct - return newMatrix; + matrix.rows = rows; + matrix.cols = cols; + + matrix.buffer = malloc(rows * cols * sizeof(MatrixType)); + if (matrix.buffer == NULL) { + matrix.rows = 0; + matrix.cols = 0; + return matrix; + } + + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + matrix.buffer[i * matrix.cols + j] = UNDEFINED_MATRIX_VALUE; + } + } + return matrix; } void clearMatrix(Matrix *matrix) { - matrix->buffer = UNDEFINED_MATRIX_VALUE; - matrix->rows = UNDEFINED_MATRIX_VALUE; - matrix->cols = UNDEFINED_MATRIX_VALUE; - free((*matrix).buffer); // Speicher freigeben + + if (matrix->buffer != NULL) { + free((*matrix).buffer); + matrix->buffer = NULL; + } + matrix->rows = 0; + matrix->cols = 0; } void setMatrixAt(const MatrixType value, Matrix matrix, const unsigned int rowIdx, // Kopie der Matrix wird übergeben const unsigned int colIdx) { - if (rowIdx >= matrix.rows || - colIdx >= matrix.cols) { // Speichergröße nicht überschreiten + if (rowIdx >= matrix.rows || colIdx >= matrix.cols || + matrix.buffer == NULL) { // Speichergröße nicht überschreiten return; } @@ -45,9 +59,9 @@ void setMatrixAt(const MatrixType value, Matrix matrix, MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, // Kopie der Matrix wird übergeben unsigned int colIdx) { - if (rowIdx >= matrix.rows || - colIdx >= matrix.cols) { // Speichergröße nicht überschreiten - return 0; + if (rowIdx >= matrix.rows || colIdx >= matrix.cols || + matrix.buffer == NULL) { // Speichergröße nicht überschreiten + return UNDEFINED_MATRIX_VALUE; } MatrixType value = matrix.buffer[rowIdx * matrix.cols + colIdx]; @@ -103,6 +117,9 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) { { Matrix result = createMatrix(rows1, cols1); // Speicher reservieren + if (result.buffer == NULL) { + return (Matrix){0, 0, NULL}; + } for (int i = 0; i < (rows1 * cols1); i++) { // addieren @@ -120,16 +137,22 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) { if (cols1 == 1) { Matrix result = createMatrix(rows2, cols2); + if (result.buffer == NULL) { + return (Matrix){0, 0, NULL}; + } Matrix copy1 = broadCastCols(matrix1, rows2, cols2); - - for (int i = 0; i < (rows2 * cols2); i++) { // addieren - - result.buffer[i] = - (copy1.buffer[i] + - matrix2.buffer[i]); // buffer[i] ⇔ *(buffer + i) Adresse = - // Startadresse + (i * sizeof(MatrixType)) + if (!copy1.buffer) { + clearMatrix(&result); + return (Matrix){0, 0, NULL}; } + + for (unsigned int i = 0; i < rows2 * cols2; i++) { + result.buffer[i] = copy1.buffer[i] + matrix2.buffer[i]; + } + + /* freigeben, weil nicht mehr benötigt */ + clearMatrix(©1); return result; // add und return @@ -137,19 +160,22 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) { } else if (cols2 == 1) { Matrix result = createMatrix(rows1, cols1); + if (result.buffer == NULL) { + Matrix error = {0, 0, NULL}; + return error; + } + // Matrix2 hat nur eine Spalte -> horizontal broadcasten Matrix copy2 = broadCastCols(matrix2, rows1, cols1); - for (int i = 0; i < (rows1 * cols1); i++) { // addieren - - result.buffer[i] = - (matrix1.buffer[i] + - copy2.buffer[i]); // buffer[i] ⇔ *(buffer + i) Adresse = - // Startadresse + (i * sizeof(MatrixType)) + for (unsigned int i = 0; i < rows1 * cols1; i++) { + result.buffer[i] = matrix1.buffer[i] + copy2.buffer[i]; } - return result; - // add und return + // Optional: Speicher von copy2 freigeben + clearMatrix(©2); + + return result; } else { @@ -167,6 +193,9 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) { if (rows1 == 1) { Matrix result = createMatrix(rows2, cols2); + if (result.buffer == NULL) { + return (Matrix){0, 0, NULL}; + } Matrix copy1 = broadCastRows(matrix1, rows2, cols2); @@ -184,8 +213,12 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) { } else if (rows2 == 1) { Matrix result = createMatrix(rows1, cols1); + if (result.buffer == NULL) { + return (Matrix){0, 0, NULL}; + } + + Matrix copy2 = broadCastRows(matrix2, rows1, cols1); - Matrix copy2 = broadCastCols(matrix2, rows1, cols1); // add und return for (int i = 0; i < (rows1 * cols1); i++) { // addieren @@ -242,4 +275,4 @@ Matrix multiply(const Matrix matrix1, const Matrix matrix2) { Matrix errorMatrix = {0, 0, NULL}; return errorMatrix; } -} \ No newline at end of file +} From fd1bc886a7af147fc855909d2b52d58fde8228a7 Mon Sep 17 00:00:00 2001 From: Kristin Date: Tue, 25 Nov 2025 10:38:40 +0100 Subject: [PATCH 6/6] neu --- imageInput.c | 3 +++ matrix.c | 26 ++++++++++++++++---------- neuralNetworkTests.c | 29 +++++++++++++++-------------- 3 files changed, 34 insertions(+), 24 deletions(-) diff --git a/imageInput.c b/imageInput.c index 0015137..7f318ce 100644 --- a/imageInput.c +++ b/imageInput.c @@ -28,6 +28,7 @@ static int readMeta(FILE *file, unsigned short *count, unsigned short *width, return 0; if (fread(height, sizeof(unsigned short), 1, file) != 1) return 0; + return 1; } @@ -74,9 +75,11 @@ GrayScaleImageSeries *readImages(const char *path) { unsigned short count, width, height; if (!readMeta(file, &count, &width, &height)) { + fclose(file); return NULL; } + // printf("%d, %d, %d", count, width, height); GrayScaleImageSeries *series = malloc(sizeof(GrayScaleImageSeries)); if (!series) { diff --git a/matrix.c b/matrix.c index b20d718..bcbf07c 100644 --- a/matrix.c +++ b/matrix.c @@ -3,32 +3,38 @@ #include #include -// TODO Matrix-Funktionen implementieren /*typedef struct { unsigned int rows; //Zeilen unsigned int cols; //Spalten MatrixType *buffer; //Zeiger auf Speicherbereich Reihen*Spalten } Matrix;*/ + Matrix createMatrix(unsigned int rows, unsigned int cols) { - Matrix matrix; - Matrix errorMatrix = {0, 0, NULL}; - if (rows == 0 || cols == 0) { + + Matrix matrix; // neue Metrix Struktur erstellen + + Matrix errorMatrix = {0, 0, NULL}; // Fehlermatrix zum zurückgeben + + if (rows == 0 || cols == 0) { // fehlerhafte Parameter übergeben return errorMatrix; } - matrix.rows = rows; + + matrix.rows = rows; // nach dem Prüfen auf unmögliche Angaben kann die Matrix + // erstellt werden matrix.cols = cols; - matrix.buffer = malloc(rows * cols * sizeof(MatrixType)); - if (matrix.buffer == NULL) { + matrix.buffer = + malloc(rows * cols * sizeof(MatrixType)); // Speicher reservieren + if (matrix.buffer == NULL) { // Prüfen, ob Speicher reserviert werden konnte matrix.rows = 0; matrix.cols = 0; return matrix; } - for (int i = 0; i < rows; i++) { - for (int j = 0; j < cols; j++) { - matrix.buffer[i * matrix.cols + j] = UNDEFINED_MATRIX_VALUE; + for (int r = 0; r < rows; r++) { + for (int c = 0; c < cols; c++) { + matrix.buffer[r * matrix.cols + c] = UNDEFINED_MATRIX_VALUE; } } return matrix; diff --git a/neuralNetworkTests.c b/neuralNetworkTests.c index 8b6c307..c6a6ae7 100644 --- a/neuralNetworkTests.c +++ b/neuralNetworkTests.c @@ -30,20 +30,21 @@ Dimension: Form der Matrizen für einen Layer*/ // speichert NeuralNetwork nn in binäre Datei->erzeugt Dateiformat static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn) { - FILE *f = fopen(path, "wb"); // Binärdatei zum Schreiben öffnen - if (f == NULL) - return; + FILE *fptr = fopen(path, "wb"); // Binärdatei zum Schreiben öffnen + if (fptr == NULL) + return; // file konnte nicht geöffnet werden // Header ist Erkennungsstring am Anfang der Datei, loadmodel erkennt // Dateiformat - const char header[] = "__info2_neural_network_file_format__"; - fwrite(header, sizeof(char), strlen(header), f); + const char header[] = + "__info2_neural_network_file_format__"; // header vor jedem Layer + fwrite(header, sizeof(char), strlen(header), fptr); // Wenn es keine Layer gibt, 0 eintragen, LoadModel gibt 0 zurück if (nn.numberOfLayers == 0) { int zero = 0; - fwrite(&zero, sizeof(int), 1, f); - fclose(f); + fwrite(&zero, sizeof(int), 1, fptr); + fclose(fptr); return; } @@ -51,8 +52,8 @@ static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn) { // Output-Neuronen int inputDim = (int)nn.layers[0].weights.cols; int outputDim = (int)nn.layers[0].weights.rows; - fwrite(&inputDim, sizeof(int), 1, f); - fwrite(&outputDim, sizeof(int), 1, f); + fwrite(&inputDim, sizeof(int), 1, fptr); + fwrite(&outputDim, sizeof(int), 1, fptr); /* 3) Für jede Layer in Reihenfolge: Gewichte (output x input), Biases (output x 1). Zwischen Layern wird nur die nächste outputDimension (int) @@ -68,28 +69,28 @@ static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn) { /* Gewichte (MatrixType binär) */ if (wcount > 0 && layer.weights.buffer != NULL) { - fwrite(layer.weights.buffer, sizeof(MatrixType), (size_t)wcount, f); + fwrite(layer.weights.buffer, sizeof(MatrixType), (size_t)wcount, fptr); } /* Biases (MatrixType binär) */ if (bcount > 0 && layer.biases.buffer != NULL) { - fwrite(layer.biases.buffer, sizeof(MatrixType), (size_t)bcount, f); + fwrite(layer.biases.buffer, sizeof(MatrixType), (size_t)bcount, fptr); } /* Für die nächste Layer: falls vorhanden, schreibe deren outputDimension */ if (i + 1 < nn.numberOfLayers) { int nextOutput = (int)nn.layers[i + 1].weights.rows; - fwrite(&nextOutput, sizeof(int), 1, f); + fwrite(&nextOutput, sizeof(int), 1, fptr); } else { /* Letzte Layer: wir können das Ende signalisieren, indem wir ein 0 schreiben. loadModel liest dann outputDimension = 0 und beendet die Schleife. */ int zero = 0; - fwrite(&zero, sizeof(int), 1, f); + fwrite(&zero, sizeof(int), 1, fptr); } } - fclose(f); + fclose(fptr); } void test_loadModelReturnsCorrectNumberOfLayers(void) {