buian100487/info2Praktikum-NeuronalesNetz
1
0
Fork 0
forked from freudenreichan/info2Praktikum-NeuronalesNetz
Code Pull Requests Activity

First commit

Browse Source
This commit is contained in:
Tubui 2025-11-04 14:43:24 +01:00
parent 96c6871ea3
commit c76b9bc927
5 changed files with 354 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
imageInput.c
View File

@ -3,20 +3,131 @@
#include <string.h>
#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
// --------------------------
// Hilfsfunktion: Prüft den Header der Datei
// --------------------------
static int checkFileHeader(FILE *file)
{
char buffer[100] = {0};
size_t headerLen = strlen(FILE_HEADER_STRING);
// TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen
// Lese Header aus Datei
if (fread(buffer, sizeof(char), headerLen, file) != headerLen)
return 0;
// Prüfe, ob Header korrekt ist
return strcmp(buffer, FILE_HEADER_STRING) == 0;
}
// --------------------------
// Hilfsfunktion: Liest ein einzelnes Bild
// --------------------------
static int readImage(FILE *file, GrayScaleImage *image, unsigned int width, unsigned int height)
{
image->width = width; // Breite setzen
image->height = height; // Höhe setzen
image->buffer = (GrayScalePixelType *)malloc(width * height * sizeof(GrayScalePixelType));
if (!image->buffer)
return 0; // Speicherfehler
// Lese Pixelwerte
if (fread(image->buffer, sizeof(GrayScalePixelType), width * height, file) != width * height)
{
free(image->buffer);
image->buffer = NULL;
return 0; // Lese Fehler
}
return 1; // Erfolg
}
// --------------------------
// Funktion: Liest eine Serie von Bildern aus einer Datei
// --------------------------
GrayScaleImageSeries *readImages(const char *path)
{
GrayScaleImageSeries *series = NULL;
FILE *file = fopen(path, "rb");
if (!file)
return NULL; // Datei existiert nicht
// Prüfe Header
if (!checkFileHeader(file))
{
fclose(file);
return NULL; // Falsches Format
}
// Lese Anzahl der Bilder und deren Dimensionen
unsigned int count = 0;
unsigned short width = 0, height = 0;
if (fread(&count, sizeof(unsigned int), 1, file) != 1 ||
fread(&width, sizeof(unsigned short), 1, file) != 1 ||
fread(&height, sizeof(unsigned short), 1, file) != 1)
{
fclose(file);
return NULL;
}
// Speicher für Serie allozieren
GrayScaleImageSeries *series = (GrayScaleImageSeries *)malloc(sizeof(GrayScaleImageSeries));
if (!series)
{
fclose(file);
return NULL;
}
series->count = count;
series->images = (GrayScaleImage *)calloc(count, sizeof(GrayScaleImage));
series->labels = (unsigned char *)calloc(count, sizeof(unsigned char));
if (!series->images || !series->labels)
{
clearSeries(series);
fclose(file);
return NULL;
}
// Lese jedes Bild und Label
for (unsigned int i = 0; i < count; i++)
{
if (!readImage(file, &series->images[i], width, height) ||
fread(&series->labels[i], sizeof(unsigned char), 1, file) != 1)
{
clearSeries(series);
fclose(file);
return NULL;
}
}
fclose(file);
return series;
}
// TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
// --------------------------
// Funktion: Gibt eine Bildserie vollständig frei
// --------------------------
void clearSeries(GrayScaleImageSeries *series)
{
if (!series)
return;
if (series->images)
{
for (unsigned int i = 0; i < series->count; i++)
{
free(series->images[i].buffer); // Speicher jedes Bildes freigeben
series->images[i].buffer = NULL;
series->images[i].width = 0;
series->images[i].height = 0;
}
free(series->images); // Array der Bilder freigeben
}
if (series->labels)
free(series->labels); // Labels freigeben
free(series); // Serie selbst freigeben
}

71
matrix.c
View File

@ -1,35 +1,92 @@
#include <stdlib.h>
#include <string.h>
#include "matrix.h"
#include <stdlib.h>
// TODO Matrix-Funktionen implementieren
// Matrix erstellen
Matrix createMatrix(unsigned int rows, unsigned int cols)
{
Matrix m;
if (rows == 0 || cols == 0) {
m.rows = 0;
m.cols = 0;
m.buffer = NULL;
return m;
}
m.rows = rows;
m.cols = cols;
m.buffer = (MatrixType*)calloc(rows * cols, sizeof(MatrixType));
if (!m.buffer) {
m.rows = 0;
m.cols = 0;
}
return m;
}
// Speicher freigeben
void clearMatrix(Matrix *matrix)
{
if (!matrix || !matrix->buffer) return;
free(matrix->buffer);
matrix->buffer = NULL;
matrix->rows = 0;
matrix->cols = 0;
}
// Wert setzen
void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
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 UNDEFINED_MATRIX_VALUE;
return matrix.buffer[rowIdx * matrix.cols + colIdx];
}
// Addition
Matrix add(const Matrix matrix1, const Matrix matrix2)
{
Matrix result;
if (matrix1.rows != matrix2.rows || matrix1.cols != matrix2.cols) {
result.rows = 0;
result.cols = 0;
result.buffer = NULL;
return result;
}
result = createMatrix(matrix1.rows, matrix1.cols);
for (unsigned int i = 0; i < matrix1.rows * matrix1.cols; i++)
result.buffer[i] = matrix1.buffer[i] + matrix2.buffer[i];
return result;
}
// Multiplikation
Matrix multiply(const Matrix matrix1, const Matrix matrix2)
{
Matrix result;
if (matrix1.cols != matrix2.rows) {
result.rows = 0;
result.cols = 0;
result.buffer = NULL;
return result;
}
result = createMatrix(matrix1.rows, matrix2.cols);
for (unsigned int i = 0; i < matrix1.rows; i++)
{
for (unsigned int j = 0; j < matrix2.cols; j++)
{
MatrixType sum = 0;
for (unsigned int k = 0; k < matrix1.cols; k++)
sum += matrix1.buffer[i * matrix1.cols + k] * matrix2.buffer[k * matrix2.cols + j];
result.buffer[i * result.cols + j] = sum;
}
}
return result;
}

9
matrix.h
View File

@ -5,9 +5,15 @@
typedef float MatrixType;
// TODO Matrixtyp definieren
// Struktur Matrix
typedef struct {
MatrixType *buffer; // pointer
unsigned int rows;
unsigned int cols;
} Matrix;
// Funktionen
Matrix createMatrix(unsigned int rows, unsigned int cols);
void clearMatrix(Matrix *matrix);
void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
@ -15,5 +21,4 @@ MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int co
Matrix add(const Matrix matrix1, const Matrix matrix2);
Matrix multiply(const Matrix matrix1, const Matrix matrix2);
#endif

331
neuralNetworkTests.c
View File

@ -1,230 +1,219 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "unity.h"
#include "neuralNetwork.h"
#define FILE_HEADER_STRING "__info2_neural_network_file_format__"
// --------------------------
// Hilfsfunktion zum Erstellen einer Test-Datei für das Netzwerk
// --------------------------
static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
{
// TODO
FILE *file = fopen(path, "wb");
if(file == NULL) return;
// 1. Schreibe den Datei-Header
// Dieser Header wird beim Laden überprüft, um das Dateiformat sicherzustellen
fwrite(FILE_HEADER_STRING, sizeof(char), strlen(FILE_HEADER_STRING), file);
// 2. Schreibe alle Layer des Netzwerks
for(unsigned int i = 0; i < nn.numberOfLayers; i++)
{
Layer layer = nn.layers[i];
int inputDim = (int)layer.weights.cols;
int outputDim = (int)layer.weights.rows;
// Schreibe die Dimensionen des Layers
fwrite(&inputDim, sizeof(int), 1, file);
fwrite(&outputDim, sizeof(int), 1, file);
// Schreibe die Gewichtsmatrix (outputDim x inputDim)
fwrite(layer.weights.buffer, sizeof(MatrixType), outputDim * inputDim, file);
// Schreibe den Bias-Vektor (outputDim x 1)
fwrite(layer.biases.buffer, sizeof(MatrixType), outputDim, file);
}
// 3. Schreibe zwei Nullen, um das Ende der Layer anzuzeigen
int zero = 0;
fwrite(&zero, sizeof(int), 1, file); // inputDim = 0
fwrite(&zero, sizeof(int), 1, file); // outputDim = 0
fclose(file);
}
// --------------------------
// Test: Prüft, ob loadModel richtige Anzahl Layer lädt
// --------------------------
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}};
const char *path = "test_nn_file.info2";
MatrixType wBuf[] = {1,2,3,4,5,6};
MatrixType bBuf[] = {1,2,3};
Layer layers[] = {{.weights={wBuf,3,2}, .biases={bBuf,3,1}}};
NeuralNetwork nn = {layers,1};
NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=2};
NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, nn);
prepareNeuralNetworkFile(path, expectedNet);
netUnderTest = loadModel(path);
NeuralNetwork loaded = loadModel(path);
TEST_ASSERT_EQUAL_INT(1, loaded.numberOfLayers);
clearModel(&loaded);
remove(path);
TEST_ASSERT_EQUAL_INT(expectedNet.numberOfLayers, netUnderTest.numberOfLayers);
clearModel(&netUnderTest);
}
// --------------------------
// Test: Prüft Dimensionen der Gewichte
// --------------------------
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}};
const char *path = "test_nn_file.info2";
MatrixType wBuf[] = {1,2,3,4,5,6};
MatrixType bBuf[] = {1,2,3};
Layer layers[] = {{.weights={wBuf,3,2}, .biases={bBuf,3,1}}};
NeuralNetwork nn = {layers,1};
NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, nn);
prepareNeuralNetworkFile(path, expectedNet);
netUnderTest = loadModel(path);
NeuralNetwork loaded = loadModel(path);
TEST_ASSERT_EQUAL_INT(3, loaded.layers[0].weights.rows);
TEST_ASSERT_EQUAL_INT(2, loaded.layers[0].weights.cols);
clearModel(&loaded);
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);
}
// --------------------------
// Test: Prüft Dimensionen der Biases
// --------------------------
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}};
const char *path = "test_nn_file.info2";
MatrixType wBuf[] = {1,2,3,4,5,6};
MatrixType bBuf[] = {1,2,3};
Layer layers[] = {{.weights={wBuf,3,2}, .biases={bBuf,3,1}}};
NeuralNetwork nn = {layers,1};
NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, nn);
prepareNeuralNetworkFile(path, expectedNet);
netUnderTest = loadModel(path);
NeuralNetwork loaded = loadModel(path);
TEST_ASSERT_EQUAL_INT(3, loaded.layers[0].biases.rows);
TEST_ASSERT_EQUAL_INT(1, loaded.layers[0].biases.cols);
clearModel(&loaded);
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);
}
// --------------------------
// Test: Prüft, dass Gewichte korrekt geladen werden
// --------------------------
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}};
const char *path = "test_nn_file.info2";
MatrixType wBuf[] = {1,2,3,4,5,6};
MatrixType bBuf[] = {1,2,3};
Layer layers[] = {{.weights={wBuf,3,2}, .biases={bBuf,3,1}}};
NeuralNetwork nn = {layers,1};
NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, nn);
prepareNeuralNetworkFile(path, expectedNet);
netUnderTest = loadModel(path);
NeuralNetwork loaded = loadModel(path);
int n = loaded.layers[0].weights.rows * loaded.layers[0].weights.cols;
TEST_ASSERT_EQUAL_INT_ARRAY(wBuf, loaded.layers[0].weights.buffer, n);
clearModel(&loaded);
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);
}
// --------------------------
// Test: Prüft, dass Bias korrekt geladen werden
// --------------------------
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}};
const char *path = "test_nn_file.info2";
MatrixType wBuf[] = {1,2,3,4,5,6};
MatrixType bBuf[] = {1,2,3};
Layer layers[] = {{.weights={wBuf,3,2}, .biases={bBuf,3,1}}};
NeuralNetwork nn = {layers,1};
NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, nn);
prepareNeuralNetworkFile(path, expectedNet);
netUnderTest = loadModel(path);
NeuralNetwork loaded = loadModel(path);
int n = loaded.layers[0].biases.rows * loaded.layers[0].biases.cols;
TEST_ASSERT_EQUAL_INT_ARRAY(bBuf, loaded.layers[0].biases.buffer, n);
clearModel(&loaded);
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);
}
// --------------------------
// Test: predict Funktion
// --------------------------
void test_predictReturnsCorrectLabels(void)
{
GrayScalePixelType img1[] = {10,20,30,40};
GrayScalePixelType img2[] = {5,15,25,35};
GrayScaleImage images[] = {
{.buffer=img1, .width=2, .height=2},
{.buffer=img2, .width=2, .height=2}
};
// Dummy Network für test: ReLU-ähnlich
MatrixType w1[] = {1,0,0,1,1,0,0,1};
MatrixType b1[] = {0,0};
Layer layers[] = {{.weights={w1,2,4}, .biases={b1,2,1}, .activation=NULL}};
NeuralNetwork nn = {layers,1};
unsigned char *labels = predict(nn, images, 2);
TEST_ASSERT_NOT_NULL(labels);
free(labels);
}
// --------------------------
// Test: clearModel setzt Pointer auf NULL
// --------------------------
void test_clearModelSetsMembersToNull(void)
{
MatrixType wBuf[] = {1,2,3,4,5,6};
MatrixType bBuf[] = {1,2,3};
Layer layers[] = {{.weights={wBuf,3,2}, .biases={bBuf,3,1}}};
NeuralNetwork nn = {layers,1};
clearModel(&nn);
TEST_ASSERT_NULL(nn.layers);
TEST_ASSERT_EQUAL_INT(0, nn.numberOfLayers);
}
// --------------------------
// Test: Fehlerhafte Datei (Header falsch)
// --------------------------
void test_loadModelFailsOnWrongFileTag(void)
{
const char *path = "some_nn_test_file.info2";
NeuralNetwork netUnderTest;
const char *path = "wrong_nn_file.info2";
FILE *file = fopen(path, "wb");
if(file != NULL)
{
const char *fileTag = "info2_neural_network_file_format";
fwrite(fileTag, sizeof(char), strlen(fileTag), file);
const char *wrongTag = "wrong_header_string";
fwrite(wrongTag, sizeof(char), strlen(wrongTag), file);
fclose(file);
}
netUnderTest = loadModel(path);
NeuralNetwork nn = loadModel(path);
TEST_ASSERT_NULL(nn.layers);
TEST_ASSERT_EQUAL_INT(0, nn.numberOfLayers);
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}};
// --------------------------
// Unity Setup / Teardown
// --------------------------
void setUp(void) {}
void tearDown(void) {}
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
}
void tearDown(void) {
// Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
}
int main()
// --------------------------
// Hauptfunktion zum Ausführen der Tests
// --------------------------
int main(void)
{
UNITY_BEGIN();
@ -234,9 +223,9 @@ int main()
RUN_TEST(test_loadModelReturnsCorrectBiasDimensions);
RUN_TEST(test_loadModelReturnsCorrectWeights);
RUN_TEST(test_loadModelReturnsCorrectBiases);
RUN_TEST(test_loadModelFailsOnWrongFileTag);
RUN_TEST(test_clearModelSetsMembersToNull);
RUN_TEST(test_predictReturnsCorrectLabels);
RUN_TEST(test_clearModelSetsMembersToNull);
RUN_TEST(test_loadModelFailsOnWrongFileTag);
return UNITY_END();
}

BIN
test_nn_file.info2 Normal file
View File

Binary file not shown.