kachelto100370/info2Praktikum-NeuronalesNetz
2
0
Fork 0
forked from freudenreichan/info2Praktikum-NeuronalesNetz
Code Pull Requests Activity

Compare commits

base: kachelto100370/info2Praktikum-NeuronalesNetz:Krisp2
Branches Tags
kachelto100370/info2Praktikum-NeuronalesNetz:main kachelto100370/info2Praktikum-NeuronalesNetz:Krisp2 kachelto100370/info2Praktikum-NeuronalesNetz:RMax kachelto100370/info2Praktikum-NeuronalesNetz:KTobi2 freudenreichan/info2Praktikum-NeuronalesNetz:main
..
compare: kachelto100370/info2Praktikum-NeuronalesNetz:4a1b6cbb409cec8cc068534ad2db11a6f1395e6a
Branches Tags
kachelto100370/info2Praktikum-NeuronalesNetz:Krisp2 kachelto100370/info2Praktikum-NeuronalesNetz:RMax kachelto100370/info2Praktikum-NeuronalesNetz:KTobi2 kachelto100370/info2Praktikum-NeuronalesNetz:main freudenreichan/info2Praktikum-NeuronalesNetz:main
1 Commits
Krisp2 .. 4a1b6cbb40
Author SHA1 Message Date
Max-R 4a1b6cbb40 Fehler 0 Matrix bei add abfangen 2025-11-25 10:13:01 +01:00
13 changed files with 791 additions and 941 deletions
Expand all files Collapse all files
.gitignore
-6
View File
@@ -2,9 +2,3 @@ mnist
runTests runTests
*.o *.o
*.exe *.exe
.vscode/settings.json
.vscode/launch.json
.vscode/settings.json
.vscode/settings.json
runImageInputTests
testFile.info2
.vscode/c_cpp_properties.json
Vendored
+18
View File
@@ -0,0 +1,18 @@
{
"configurations": [
{
"name": "windows-gcc-x64",
"includePath": [
"${workspaceFolder}/**"
],
"compilerPath": "C:/ProgramData/mingw64/mingw64/bin/gcc.exe",
"cStandard": "${default}",
"cppStandard": "${default}",
"intelliSenseMode": "windows-gcc-x64",
"compilerArgs": [
""
]
}
],
"version": 4
}
.vscode/launch.json
Vendored
+24
View File
@@ -0,0 +1,24 @@
{
"version": "0.2.0",
"configurations": [
{
"name": "C/C++ Runner: Debug Session",
"type": "cppdbg",
"request": "launch",
"args": [],
"stopAtEntry": false,
"externalConsole": true,
"cwd": "c:/Users/Max-R/I2Pr/repoKachelto/I2-Pr_neuronalesNetz/info2Praktikum-NeuronalesNetz",
"program": "c:/Users/Max-R/I2Pr/repoKachelto/I2-Pr_neuronalesNetz/info2Praktikum-NeuronalesNetz/build/Debug/outDebug",
"MIMode": "gdb",
"miDebuggerPath": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
}
]
}
.vscode/settings.json
Vendored
+57 -1
View File
@@ -1,3 +1,59 @@
{ {
"makefile.configureOnOpen": false "C_Cpp_Runner.cCompilerPath": "gcc",
"C_Cpp_Runner.cppCompilerPath": "g++",
"C_Cpp_Runner.debuggerPath": "gdb",
"C_Cpp_Runner.cStandard": "",
"C_Cpp_Runner.cppStandard": "",
"C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/VR_NR/Community/VC/Auxiliary/Build/vcvarsall.bat",
"C_Cpp_Runner.useMsvc": false,
"C_Cpp_Runner.warnings": [
"-Wall",
"-Wextra",
"-Wpedantic",
"-Wshadow",
"-Wformat=2",
"-Wcast-align",
"-Wconversion",
"-Wsign-conversion",
"-Wnull-dereference"
],
"C_Cpp_Runner.msvcWarnings": [
"/W4",
"/permissive-",
"/w14242",
"/w14287",
"/w14296",
"/w14311",
"/w14826",
"/w44062",
"/w44242",
"/w14905",
"/w14906",
"/w14263",
"/w44265",
"/w14928"
],
"C_Cpp_Runner.enableWarnings": true,
"C_Cpp_Runner.warningsAsError": false,
"C_Cpp_Runner.compilerArgs": [],
"C_Cpp_Runner.linkerArgs": [],
"C_Cpp_Runner.includePaths": [],
"C_Cpp_Runner.includeSearch": [
"*",
"**/*"
],
"C_Cpp_Runner.excludeSearch": [
"**/build",
"**/build/**",
"**/.*",
"**/.*/**",
"**/.vscode",
"**/.vscode/**"
],
"C_Cpp_Runner.useAddressSanitizer": false,
"C_Cpp_Runner.useUndefinedSanitizer": false,
"C_Cpp_Runner.useLeakSanitizer": false,
"C_Cpp_Runner.showCompilationTime": false,
"C_Cpp_Runner.useLinkTimeOptimization": false,
"C_Cpp_Runner.msvcSecureNoWarnings": false
} }
imageInput.c
+16 -123
View File
@@ -1,136 +1,29 @@
#include "imageInput.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "imageInput.h"
#define BUFFER_SIZE 100
#define FILE_HEADER_STRING "__info2_image_file_format__" #define FILE_HEADER_STRING "__info2_image_file_format__"
// define BUFFER 100
// 10x10 pixel
/* ---------------------------------------------------------- // TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei
1. Header prüfen GrayScaleImage readImage()
---------------------------------------------------------- */ {
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
2. Meta-Daten lesen (unsigned short) GrayScaleImageSeries *readImages(const char *path)
---------------------------------------------------------- */ {
static int readMeta(FILE *file, unsigned short *count, unsigned short *width, GrayScaleImageSeries *series = NULL;
unsigned short *height) { FILE *file = fopen("mnist_test.info2","rb");
if (fread(count, sizeof(unsigned short), 1, file) != 1) char headOfFile;
return 0; series = malloc();
if (fread(width, sizeof(unsigned short), 1, file) != 1)
return 0;
if (fread(height, sizeof(unsigned short), 1, file) != 1)
return 0;
return 1;
}
/* ----------------------------------------------------------
3. Einzelbild lesen
---------------------------------------------------------- */
static int readSingleImage(FILE *file, GrayScaleImage *img,
unsigned short width, unsigned short height) {
img->width = width;
img->height = height;
size_t numPixels = (size_t)width * (size_t)height; // anzahl an pixeln
img->buffer = malloc(numPixels);
if (!img->buffer)
return 0;
if (fread(img->buffer, 1, numPixels, file) != numPixels) {
free(img->buffer);
img->buffer = NULL; // fehler bei ungültiger eingabe
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;
}
// printf("%d, %d, %d", count, width, height);
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; return series;
} }
/* ---------------------------------------------------------- // TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
6. Speicher komplett freigeben void clearSeries(GrayScaleImageSeries *series)
---------------------------------------------------------- */ {
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);
} }
imageInputTests.c
+56 -123
View File
@@ -1,98 +1,88 @@
#include "imageInput.h"
#include "unity.h"
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h>
#include <string.h> #include <string.h>
#include "unity.h"
#include "imageInput.h"
/* ---------------------------------------------------------
Hilfsfunktion: Testdatei vorbereiten static void prepareImageFile(const char *path, unsigned short int width, unsigned short int height, unsigned int short numberOfImages, unsigned char label)
--------------------------------------------------------- */ {
static void prepareImageFile(const char *path, unsigned int width,
unsigned int height, unsigned int numberOfImages,
unsigned char label) {
FILE *file = fopen(path, "wb"); FILE *file = fopen(path, "wb");
if (!file)
return;
// Header if(file != NULL)
{
const char *fileTag = "__info2_image_file_format__"; const char *fileTag = "__info2_image_file_format__";
fwrite(fileTag, 1, strlen(fileTag), file); GrayScalePixelType *zeroBuffer = (GrayScalePixelType *)calloc(numberOfImages * width * height, sizeof(GrayScalePixelType));
// Meta-Daten als unsigned short if(zeroBuffer != NULL)
unsigned short n = (unsigned short)numberOfImages; {
unsigned short w = (unsigned short)width; fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
unsigned short h = (unsigned short)height; fwrite(&numberOfImages, sizeof(numberOfImages), 1, file);
fwrite(&n, sizeof(unsigned short), 1, file); fwrite(&width, sizeof(width), 1, file);
fwrite(&w, sizeof(unsigned short), 1, file); fwrite(&height, sizeof(height), 1, file);
fwrite(&h, sizeof(unsigned short), 1, file);
// Pixelbuffer for(int i = 0; i < numberOfImages; i++)
GrayScalePixelType *buffer = {
calloc(width * height, sizeof(GrayScalePixelType)); fwrite(zeroBuffer, sizeof(GrayScalePixelType), width * height, file);
if (!buffer) {
fclose(file);
return;
}
for (unsigned int i = 0; i < width * height; i++)
buffer[i] = (GrayScalePixelType)i;
// 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); fwrite(&label, sizeof(unsigned char), 1, file);
} }
free(buffer); free(zeroBuffer);
fclose(file);
} }
/* --------------------------------------------------------- fclose(file);
Unit Tests }
--------------------------------------------------------- */ }
void test_readImagesReturnsCorrectNumberOfImages(void) {
void test_readImagesReturnsCorrectNumberOfImages(void)
{
GrayScaleImageSeries *series = NULL; GrayScaleImageSeries *series = NULL;
const unsigned int expectedNumberOfImages = 2; const unsigned short expectedNumberOfImages = 2;
const char *path = "testFile.info2"; const char *path = "testFile.info2";
prepareImageFile(path, 8, 8, expectedNumberOfImages, 1); prepareImageFile(path, 8, 8, expectedNumberOfImages, 1);
series = readImages(path); series = readImages(path);
TEST_ASSERT_NOT_NULL(series); TEST_ASSERT_NOT_NULL(series);
TEST_ASSERT_EQUAL_UINT(expectedNumberOfImages, series->count); TEST_ASSERT_EQUAL_UINT16(expectedNumberOfImages, series->count);
clearSeries(series); clearSeries(series);
remove(path); remove(path);
} }
void test_readImagesReturnsCorrectImageWidth(void) { void test_readImagesReturnsCorrectImageWidth(void)
{
GrayScaleImageSeries *series = NULL; GrayScaleImageSeries *series = NULL;
const unsigned int expectedWidth = 10; const unsigned short expectedWidth = 10;
const char *path = "testFile.info2"; const char *path = "testFile.info2";
prepareImageFile(path, expectedWidth, 8, 2, 1); prepareImageFile(path, expectedWidth, 8, 2, 1);
series = readImages(path); series = readImages(path);
TEST_ASSERT_NOT_NULL(series); TEST_ASSERT_NOT_NULL(series);
TEST_ASSERT_NOT_NULL(series->images); TEST_ASSERT_NOT_NULL(series->images);
TEST_ASSERT_EQUAL_UINT(2, series->count); TEST_ASSERT_EQUAL_UINT16(2, series->count);
TEST_ASSERT_EQUAL_UINT(expectedWidth, series->images[0].width); TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[0].width);
TEST_ASSERT_EQUAL_UINT(expectedWidth, series->images[1].width); TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[1].width);
clearSeries(series); clearSeries(series);
remove(path); remove(path);
} }
void test_readImagesReturnsCorrectImageHeight(void) { void test_readImagesReturnsCorrectImageHeight(void)
{
GrayScaleImageSeries *series = NULL; GrayScaleImageSeries *series = NULL;
const unsigned int expectedHeight = 10; const unsigned short expectedHeight = 10;
const char *path = "testFile.info2"; const char *path = "testFile.info2";
prepareImageFile(path, 8, expectedHeight, 2, 1); prepareImageFile(path, 8, expectedHeight, 2, 1);
series = readImages(path); series = readImages(path);
TEST_ASSERT_NOT_NULL(series); TEST_ASSERT_NOT_NULL(series);
TEST_ASSERT_NOT_NULL(series->images); TEST_ASSERT_NOT_NULL(series->images);
TEST_ASSERT_EQUAL_UINT(2, series->count); TEST_ASSERT_EQUAL_UINT16(2, series->count);
TEST_ASSERT_EQUAL_UINT(expectedHeight, series->images[0].height); TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[0].height);
TEST_ASSERT_EQUAL_UINT(expectedHeight, series->images[1].height); TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[1].height);
clearSeries(series); clearSeries(series);
remove(path); remove(path);
} }
void test_readImagesReturnsCorrectLabels(void) { void test_readImagesReturnsCorrectLabels(void)
{
const unsigned char expectedLabel = 15; const unsigned char expectedLabel = 15;
GrayScaleImageSeries *series = NULL; GrayScaleImageSeries *series = NULL;
@@ -101,7 +91,7 @@ void test_readImagesReturnsCorrectLabels(void) {
series = readImages(path); series = readImages(path);
TEST_ASSERT_NOT_NULL(series); TEST_ASSERT_NOT_NULL(series);
TEST_ASSERT_NOT_NULL(series->labels); TEST_ASSERT_NOT_NULL(series->labels);
TEST_ASSERT_EQUAL_UINT(2, series->count); TEST_ASSERT_EQUAL_UINT16(2, series->count);
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
TEST_ASSERT_EQUAL_UINT8(expectedLabel, series->labels[i]); TEST_ASSERT_EQUAL_UINT8(expectedLabel, series->labels[i]);
} }
@@ -109,16 +99,19 @@ void test_readImagesReturnsCorrectLabels(void) {
remove(path); remove(path);
} }
void test_readImagesReturnsNullOnNotExistingPath(void) { void test_readImagesReturnsNullOnNotExistingPath(void)
{
const char *path = "testFile.txt"; const char *path = "testFile.txt";
remove(path); remove(path);
TEST_ASSERT_NULL(readImages(path)); TEST_ASSERT_NULL(readImages(path));
} }
void test_readImagesFailsOnWrongFileTag(void) { void test_readImagesFailsOnWrongFileTag(void)
{
const char *path = "testFile.info2"; const char *path = "testFile.info2";
FILE *file = fopen(path, "w"); FILE *file = fopen(path, "w");
if (file != NULL) { if(file != NULL)
{
fprintf(file, "some_tag "); fprintf(file, "some_tag ");
fclose(file); fclose(file);
TEST_ASSERT_NULL(readImages(path)); TEST_ASSERT_NULL(readImages(path));
@@ -126,85 +119,25 @@ void test_readImagesFailsOnWrongFileTag(void) {
remove(path); remove(path);
} }
// Test void setUp(void) {
// Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
void test_read_GrayScale_Pixel(
void) { // testet das einlesen eines graustufenbildes von readImages()
GrayScaleImageSeries *series = NULL; // enthält später das Bild
const char *path = "testFile.info2";
prepareImageFile(path, 8, 8, 1,
1); // Höhe x Breite in Pixel, Anzahl Bilder und Kategorie
series = readImages(path);
TEST_ASSERT_NOT_NULL(series); // Speicher reservieren
TEST_ASSERT_NOT_NULL(series->images); // Inhalt ist da
TEST_ASSERT_EQUAL_UINT(1, series->count); // Anzahl der Bilder stimmt
for (int i = 0; i < (8 * 8); i++) {
TEST_ASSERT_EQUAL_UINT8(
(GrayScalePixelType)i,
series->images[0].buffer[i]); // alle Pixelwerte prüfen
} }
clearSeries(series); void tearDown(void) {
remove(path); // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
} }
/* --------------------------------------------------------- int main()
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);
}
/* ---------------------------------------------------------
Setup / Teardown
--------------------------------------------------------- */
void setUp(void) {}
void tearDown(void) {}
/* ---------------------------------------------------------
main()
--------------------------------------------------------- */
int main(void) {
UNITY_BEGIN(); UNITY_BEGIN();
printf("\n============================\nImage input " printf("\n============================\nImage input tests\n============================\n");
"tests\n============================\n");
RUN_TEST(test_readImagesReturnsCorrectNumberOfImages); RUN_TEST(test_readImagesReturnsCorrectNumberOfImages);
RUN_TEST(test_readImagesReturnsCorrectImageWidth); RUN_TEST(test_readImagesReturnsCorrectImageWidth);
RUN_TEST(test_readImagesReturnsCorrectImageHeight); RUN_TEST(test_readImagesReturnsCorrectImageHeight);
RUN_TEST(test_readImagesReturnsCorrectLabels); RUN_TEST(test_readImagesReturnsCorrectLabels);
RUN_TEST(test_readImagesReturnsNullOnNotExistingPath); RUN_TEST(test_readImagesReturnsNullOnNotExistingPath);
RUN_TEST(test_readImagesFailsOnWrongFileTag); RUN_TEST(test_readImagesFailsOnWrongFileTag);
RUN_TEST(test_read_GrayScale_Pixel);
RUN_TEST(test_readImagesMultipleImagesContent);
return UNITY_END(); return UNITY_END();
} }
windows/macos-arm64/libmnist_complete.a → macos-arm64/libmnist_complete.a
View File
windows/macos-arm64/libraylib.a → macos-arm64/libraylib.a
View File
makefile
+2 -2
View File
@@ -59,8 +59,8 @@ imageInputTests: imageInput.o imageInputTests.c $(unityfolder)/unity.c
# -------------------------- # --------------------------
clean: clean:
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
rm -f *.o mnist runMatrixTests runNeuralNetworkTests runImageInputTests
else
del /f *.o *.exe del /f *.o *.exe
else
rm -f *.o mnist runMatrixTests runNeuralNetworkTests runImageInputTests
endif endif
matrix.c
+30 -36
View File
@@ -1,15 +1,13 @@
#include "matrix.h" #include "matrix.h"
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
// TODO Matrix-Funktionen implementieren
/*typedef struct { /*typedef struct {
unsigned int rows; //Zeilen unsigned int rows; //Zeilen
unsigned int cols; //Spalten unsigned int cols; //Spalten
MatrixType *buffer; //Zeiger auf Speicherbereich Reihen*Spalten MatrixType *buffer; //Zeiger auf Speicherbereich Reihen*Spalten
} Matrix;*/ } Matrix;*/
Matrix createMatrix(unsigned int rows, unsigned int cols) {
Matrix createMatrix(const unsigned int rows, const unsigned int cols) {
if (cols == 0 || rows == 0){ if (cols == 0 || rows == 0){
Matrix errorMatrix = {0, 0, NULL}; Matrix errorMatrix = {0, 0, NULL};
return errorMatrix; return errorMatrix;
@@ -21,15 +19,11 @@ Matrix createMatrix(const unsigned int rows, const unsigned int cols) {
return newMatrix; return newMatrix;
} }
void clearMatrix(Matrix *matrix) { void clearMatrix(Matrix *matrix) {
matrix->buffer = UNDEFINED_MATRIX_VALUE;
if (matrix->buffer != NULL) { matrix->rows = UNDEFINED_MATRIX_VALUE;
free((*matrix).buffer); matrix->cols = UNDEFINED_MATRIX_VALUE;
matrix->buffer = NULL; free((*matrix).buffer); // Speicher freigeben
} }
matrix->rows = 0;
matrix->cols = 0;
}
void setMatrixAt(const MatrixType value, Matrix matrix, void setMatrixAt(const MatrixType value, Matrix matrix,
const unsigned int rowIdx, // Kopie der Matrix wird übergeben const unsigned int rowIdx, // Kopie der Matrix wird übergeben
const unsigned int colIdx) { const unsigned int colIdx) {
@@ -42,20 +36,19 @@ void setMatrixAt(const MatrixType value, Matrix matrix,
// rowIdx * matrix.cols -> Beginn der Zeile colIdx ->Spalte // rowIdx * matrix.cols -> Beginn der Zeile colIdx ->Spalte
// innerhalb der Zeile // innerhalb der Zeile
} }
MatrixType MatrixType getMatrixAt(const Matrix matrix,
getMatrixAt(const Matrix matrix, unsigned int rowIdx, // Kopie der Matrix wird übergeben
const unsigned int rowIdx, // Kopie der Matrix wird übergeben unsigned int colIdx) {
const unsigned int colIdx) { if (rowIdx >= matrix.rows ||
if (rowIdx >= matrix.rows || colIdx >= matrix.cols || colIdx >= matrix.cols) { // Speichergröße nicht überschreiten
matrix.buffer == NULL) { // Speichergröße nicht überschreiten return 0;
return UNDEFINED_MATRIX_VALUE;
} }
MatrixType value = matrix.buffer[rowIdx * matrix.cols + colIdx]; MatrixType value = matrix.buffer[rowIdx * matrix.cols + colIdx];
return value; return value;
} }
Matrix broadCastCols(const Matrix matrix, const unsigned int cols) { Matrix broadcastingCols(const Matrix matrix, const unsigned int cols){
Matrix copy1 = createMatrix(matrix.rows, cols); Matrix copy1 = createMatrix(matrix.rows, cols);
for (int r= 0; r < matrix.rows; r++){ for (int r= 0; r < matrix.rows; r++){
MatrixType valueMatrix1 = getMatrixAt(matrix, r, 0); MatrixType valueMatrix1 = getMatrixAt(matrix, r, 0);
@@ -65,7 +58,7 @@ Matrix broadCastCols(const Matrix matrix, const unsigned int cols) {
} }
return copy1; return copy1;
} }
Matrix broadCastRows(const Matrix matrix, const unsigned int rows) { Matrix broadcastingRows(const Matrix matrix, const unsigned int rows){
Matrix copy1 = createMatrix(rows, matrix.cols); Matrix copy1 = createMatrix(rows, matrix.cols);
for (int c= 0; c < matrix.cols; c++){ for (int c= 0; c < matrix.cols; c++){
MatrixType valueMatrix1 = getMatrixAt(matrix, 0, c); MatrixType valueMatrix1 = getMatrixAt(matrix, 0, c);
@@ -74,6 +67,7 @@ Matrix broadCastRows(const Matrix matrix, const unsigned int rows) {
} }
} }
return copy1; return copy1;
} }
Matrix add(const Matrix matrix1, const Matrix matrix2) { Matrix add(const Matrix matrix1, const Matrix matrix2) {
@@ -84,6 +78,7 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) {
const int cols2 = matrix2.cols; const int cols2 = matrix2.cols;
const int rows2 = matrix2.rows; const int rows2 = matrix2.rows;
const int rowsEqual = (matrix1.rows==matrix2.rows) ? 1: 0; const int rowsEqual = (matrix1.rows==matrix2.rows) ? 1: 0;
const int colsEqual = (matrix1.cols==matrix2.cols) ? 1: 0; const int colsEqual = (matrix1.cols==matrix2.cols) ? 1: 0;
@@ -103,9 +98,10 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) {
} }
} }
return result; return result;
} else if (rowsEqual == 1 && (cols1 == 1 || cols2 == 1)) { }
else if (rowsEqual ==1 && (cols1 ==1 || cols2 ==1)){
if (cols1==1){ //broadcasting von vektor 1 zu matrix 1, add if (cols1==1){ //broadcasting von vektor 1 zu matrix 1, add
Matrix newMatrix = broadCastCols(matrix1, cols2); Matrix newMatrix = broadcastingCols(matrix1, cols2);
//add //add
Matrix result = createMatrix(newMatrix.rows, newMatrix.cols); Matrix result = createMatrix(newMatrix.rows, newMatrix.cols);
if (result.buffer == NULL){ if (result.buffer == NULL){
@@ -119,10 +115,10 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) {
setMatrixAt(sum, result, i, j); setMatrixAt(sum, result, i, j);
} }
} }
clearMatrix(&newMatrix);
return result; return result;
} else { }
Matrix newMatrix2 = broadCastCols(matrix2, cols1); else{
Matrix newMatrix2 = broadcastingCols(matrix2, cols1);
//add //add
Matrix result = createMatrix(newMatrix2.rows, newMatrix2.cols); Matrix result = createMatrix(newMatrix2.rows, newMatrix2.cols);
if (result.buffer == NULL){ if (result.buffer == NULL){
@@ -136,14 +132,13 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) {
setMatrixAt(sum, result, i, j); setMatrixAt(sum, result, i, j);
} }
} }
return result; return result;
} }
} }
else if ((rows1 ==1 || rows2 ==1) && colsEqual == 1){ else if ((rows1 ==1 || rows2 ==1) && colsEqual == 1){
if (rows1==1){ if (rows1==1){
Matrix newMatrix = broadCastRows(matrix1, rows2); Matrix newMatrix = broadcastingRows(matrix1, rows2);
//add //add
Matrix result = createMatrix(newMatrix.rows, newMatrix.cols); Matrix result = createMatrix(newMatrix.rows, newMatrix.cols);
if (result.buffer == NULL){ if (result.buffer == NULL){
@@ -158,8 +153,9 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) {
} }
} }
return result; return result;
} else { }
Matrix newMatrix2 = broadCastRows(matrix2, rows1); else{
Matrix newMatrix2 = broadcastingRows(matrix2, rows1);
//add //add
Matrix result = createMatrix(newMatrix2.rows, newMatrix2.cols); Matrix result = createMatrix(newMatrix2.rows, newMatrix2.cols);
if (result.buffer == NULL){ if (result.buffer == NULL){
@@ -173,10 +169,10 @@ Matrix add(const Matrix matrix1, const Matrix matrix2) {
setMatrixAt(sum, result, i, j); setMatrixAt(sum, result, i, j);
} }
} }
clearMatrix(&newMatrix2);
return result; return result;
} }
} else { }
else {
// kein add möglich // kein add möglich
Matrix errorMatrix = {0, 0, NULL}; Matrix errorMatrix = {0, 0, NULL};
return errorMatrix; return errorMatrix;
@@ -191,11 +187,9 @@ Matrix multiply(const Matrix matrix1, const Matrix matrix2) {
for (int r=0; r< matrix1.rows; r++){ for (int r=0; r< matrix1.rows; r++){
for (int c=0; c< matrix2.cols; c++){ for (int c=0; c< matrix2.cols; c++){
MatrixType sum = 0.0; MatrixType sum = 0.0;
// skalarprodukte berechnen, k damit die ganze zeile mal die ganze //skalarprodukte berechnen, k damit die ganze zeile mal die ganze spalte genommen wird quasi
// spalte genommen wird quasi
for (int k=0; k< matrix1.cols; k++){ for (int k=0; k< matrix1.cols; k++){
// sum+= //sum+= matrix1.buffer[r*matrix1.cols+k]*matrix2.buffer[k*matrix2.cols+c];
// matrix1.buffer[r*matrix1.cols+k]*matrix2.buffer[k*matrix2.cols+c];
sum += getMatrixAt(matrix1, r, k)*getMatrixAt(matrix2, k, c); sum += getMatrixAt(matrix1, r, k)*getMatrixAt(matrix2, k, c);
} }
//Ergebnisse in neue matrix speichern //Ergebnisse in neue matrix speichern
matrix.h
+5 -8
View File
@@ -13,15 +13,12 @@ typedef struct {
} Matrix; } Matrix;
Matrix createMatrix(const unsigned int rows, const unsigned int cols); Matrix createMatrix(unsigned int rows, unsigned int cols);
void clearMatrix(Matrix *matrix); void clearMatrix(Matrix *matrix);
void setMatrixAt(const MatrixType value, Matrix matrix, void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx,
const unsigned int rowIdx, const unsigned int colIdx); unsigned int colIdx);
MatrixType getMatrixAt(const Matrix matrix, const unsigned int rowIdx, MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx,
const unsigned int colIdx); unsigned int colIdx);
Matrix broadCastCols(const Matrix matrix, const unsigned int cols);
Matrix broadCastRows(const Matrix matrix, const unsigned int rows);
Matrix add(const Matrix matrix1, const Matrix matrix2); Matrix add(const Matrix matrix1, const Matrix matrix2);
Matrix multiply(const Matrix matrix1, const Matrix matrix2); Matrix multiply(const Matrix matrix1, const Matrix matrix2);
neuralNetwork.c
+93 -60
View File
@@ -1,29 +1,35 @@
#include "neuralNetwork.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h> #include <string.h>
#include "neuralNetwork.h"
#define BUFFER_SIZE 100 #define BUFFER_SIZE 100
#define FILE_HEADER_STRING "__info2_neural_network_file_format__" #define FILE_HEADER_STRING "__info2_neural_network_file_format__"
static void softmax(Matrix *matrix) { static void softmax(Matrix *matrix)
if (matrix->cols > 0) { {
if(matrix->cols > 0)
{
double *colSums = (double *)calloc(matrix->cols, sizeof(double)); double *colSums = (double *)calloc(matrix->cols, sizeof(double));
if (colSums != NULL) { if(colSums != NULL)
for (int colIdx = 0; colIdx < matrix->cols; colIdx++) { {
for (int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) { for(int colIdx = 0; colIdx < matrix->cols; colIdx++)
{
for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++)
{
MatrixType expValue = exp(getMatrixAt(*matrix, rowIdx, colIdx)); MatrixType expValue = exp(getMatrixAt(*matrix, rowIdx, colIdx));
setMatrixAt(expValue, *matrix, rowIdx, colIdx); setMatrixAt(expValue, *matrix, rowIdx, colIdx);
colSums[colIdx] += expValue; colSums[colIdx] += expValue;
} }
} }
for (int colIdx = 0; colIdx < matrix->cols; colIdx++) { for(int colIdx = 0; colIdx < matrix->cols; colIdx++)
for (int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) { {
MatrixType normalizedValue = for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++)
getMatrixAt(*matrix, rowIdx, colIdx) / colSums[colIdx]; {
MatrixType normalizedValue = getMatrixAt(*matrix, rowIdx, colIdx) / colSums[colIdx];
setMatrixAt(normalizedValue, *matrix, rowIdx, colIdx); setMatrixAt(normalizedValue, *matrix, rowIdx, colIdx);
} }
} }
@@ -32,13 +38,16 @@ static void softmax(Matrix *matrix) {
} }
} }
static void relu(Matrix *matrix) { static void relu(Matrix *matrix)
for (int i = 0; i < matrix->rows * matrix->cols; i++) { {
for(int i = 0; i < matrix->rows * matrix->cols; i++)
{
matrix->buffer[i] = matrix->buffer[i] >= 0 ? matrix->buffer[i] : 0; matrix->buffer[i] = matrix->buffer[i] >= 0 ? matrix->buffer[i] : 0;
} }
} }
static int checkFileHeader(FILE *file) { static int checkFileHeader(FILE *file)
{
int isValid = 0; int isValid = 0;
int fileHeaderLen = strlen(FILE_HEADER_STRING); int fileHeaderLen = strlen(FILE_HEADER_STRING);
char buffer[BUFFER_SIZE] = {0}; char buffer[BUFFER_SIZE] = {0};
@@ -52,7 +61,8 @@ static int checkFileHeader(FILE *file) {
return isValid; return isValid;
} }
static unsigned int readDimension(FILE *file) { static unsigned int readDimension(FILE *file)
{
int dimension = 0; int dimension = 0;
if(fread(&dimension, sizeof(int), 1, file) != 1) if(fread(&dimension, sizeof(int), 1, file) != 1)
@@ -61,20 +71,21 @@ static unsigned int readDimension(FILE *file) {
return dimension; return dimension;
} }
static Matrix readMatrix(FILE *file, unsigned int rows, unsigned int cols) { static Matrix readMatrix(FILE *file, unsigned int rows, unsigned int cols)
{
Matrix matrix = createMatrix(rows, cols); Matrix matrix = createMatrix(rows, cols);
if (matrix.buffer != NULL) { if(matrix.buffer != NULL)
if (fread(matrix.buffer, sizeof(MatrixType), rows * cols, file) != {
rows * cols) if(fread(matrix.buffer, sizeof(MatrixType), rows*cols, file) != rows*cols)
clearMatrix(&matrix); clearMatrix(&matrix);
} }
return matrix; return matrix;
} }
static Layer readLayer(FILE *file, unsigned int inputDimension, static Layer readLayer(FILE *file, unsigned int inputDimension, unsigned int outputDimension)
unsigned int outputDimension) { {
Layer layer; Layer layer;
layer.weights = readMatrix(file, outputDimension, inputDimension); layer.weights = readMatrix(file, outputDimension, inputDimension);
layer.biases = readMatrix(file, outputDimension, 1); layer.biases = readMatrix(file, outputDimension, 1);
@@ -82,22 +93,25 @@ static Layer readLayer(FILE *file, unsigned int inputDimension,
return layer; return layer;
} }
static int isEmptyLayer(const Layer layer) { static int isEmptyLayer(const Layer layer)
return layer.biases.cols == 0 || layer.biases.rows == 0 || {
layer.biases.buffer == NULL || layer.weights.rows == 0 || 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;
layer.weights.cols == 0 || layer.weights.buffer == NULL;
} }
static void clearLayer(Layer *layer) { static void clearLayer(Layer *layer)
if (layer != NULL) { {
if(layer != NULL)
{
clearMatrix(&layer->weights); clearMatrix(&layer->weights);
clearMatrix(&layer->biases); clearMatrix(&layer->biases);
layer->activation = NULL; layer->activation = NULL;
} }
} }
static void assignActivations(NeuralNetwork model) { static void assignActivations(NeuralNetwork model)
for (int i = 0; i < (int)model.numberOfLayers - 1; i++) { {
for(int i = 0; i < (int)model.numberOfLayers-1; i++)
{
model.layers[i].activation = relu; model.layers[i].activation = relu;
} }
@@ -105,31 +119,36 @@ static void assignActivations(NeuralNetwork model) {
model.layers[model.numberOfLayers-1].activation = softmax; model.layers[model.numberOfLayers-1].activation = softmax;
} }
NeuralNetwork loadModel(const char *path) { NeuralNetwork loadModel(const char *path)
{
NeuralNetwork model = {NULL, 0}; NeuralNetwork model = {NULL, 0};
FILE *file = fopen(path, "rb"); FILE *file = fopen(path, "rb");
if (file != NULL) { if(file != NULL)
if (checkFileHeader(file)) { {
if(checkFileHeader(file))
{
unsigned int inputDimension = readDimension(file); unsigned int inputDimension = readDimension(file);
unsigned int outputDimension = readDimension(file); unsigned int outputDimension = readDimension(file);
while (inputDimension > 0 && outputDimension > 0) { while(inputDimension > 0 && outputDimension > 0)
{
Layer layer = readLayer(file, inputDimension, outputDimension); Layer layer = readLayer(file, inputDimension, outputDimension);
Layer *layerBuffer = NULL; Layer *layerBuffer = NULL;
if (isEmptyLayer(layer)) { if(isEmptyLayer(layer))
{
clearLayer(&layer); clearLayer(&layer);
clearModel(&model); clearModel(&model);
break; break;
} }
layerBuffer = (Layer *)realloc( layerBuffer = (Layer *)realloc(model.layers, (model.numberOfLayers + 1) * sizeof(Layer));
model.layers, (model.numberOfLayers + 1) * sizeof(Layer));
if(layerBuffer != NULL) if(layerBuffer != NULL)
model.layers = layerBuffer; model.layers = layerBuffer;
else { else
{
clearModel(&model); clearModel(&model);
break; break;
} }
@@ -149,16 +168,20 @@ NeuralNetwork loadModel(const char *path) {
return model; return model;
} }
static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[], static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[], unsigned int count)
unsigned int count) { {
Matrix matrix = {0, 0, NULL}; // falsch herum Matrix matrix = {NULL, 0, 0};
if (count > 0 && images != NULL) { if(count > 0 && images != NULL)
{
matrix = createMatrix(images[0].height * images[0].width, count); matrix = createMatrix(images[0].height * images[0].width, count);
if (matrix.buffer != NULL) { if(matrix.buffer != NULL)
for (int i = 0; i < count; i++) { {
for (int j = 0; j < images[i].width * images[i].height; j++) { 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); setMatrixAt((MatrixType)images[i].buffer[j], matrix, j, i);
} }
} }
@@ -168,11 +191,14 @@ static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[],
return matrix; return matrix;
} }
static Matrix forward(const NeuralNetwork model, Matrix inputBatch) { static Matrix forward(const NeuralNetwork model, Matrix inputBatch)
{
Matrix result = inputBatch; Matrix result = inputBatch;
if (result.buffer != NULL) { if(result.buffer != NULL)
for (int i = 0; i < model.numberOfLayers; i++) { {
for(int i = 0; i < model.numberOfLayers; i++)
{
Matrix biasResult; Matrix biasResult;
Matrix weightResult; Matrix weightResult;
@@ -190,19 +216,23 @@ static Matrix forward(const NeuralNetwork model, Matrix inputBatch) {
return result; return result;
} }
unsigned char *argmax(const Matrix matrix) { unsigned char *argmax(const Matrix matrix)
{
unsigned char *maxIdx = NULL; unsigned char *maxIdx = NULL;
if (matrix.rows > 0 && matrix.cols > 0) { if(matrix.rows > 0 && matrix.cols > 0)
{
maxIdx = (unsigned char *)malloc(sizeof(unsigned char) * matrix.cols); maxIdx = (unsigned char *)malloc(sizeof(unsigned char) * matrix.cols);
if (maxIdx != NULL) { if(maxIdx != NULL)
for (int colIdx = 0; colIdx < matrix.cols; colIdx++) { {
for(int colIdx = 0; colIdx < matrix.cols; colIdx++)
{
maxIdx[colIdx] = 0; maxIdx[colIdx] = 0;
for (int rowIdx = 1; rowIdx < matrix.rows; rowIdx++) { for(int rowIdx = 1; rowIdx < matrix.rows; rowIdx++)
if (getMatrixAt(matrix, rowIdx, colIdx) > {
getMatrixAt(matrix, maxIdx[colIdx], colIdx)) if(getMatrixAt(matrix, rowIdx, colIdx) > getMatrixAt(matrix, maxIdx[colIdx], colIdx))
maxIdx[colIdx] = rowIdx; maxIdx[colIdx] = rowIdx;
} }
} }
@@ -212,8 +242,8 @@ unsigned char *argmax(const Matrix matrix) {
return maxIdx; return maxIdx;
} }
unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[], unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[], unsigned int numberOfImages)
unsigned int numberOfImages) { {
Matrix inputBatch = imageBatchToMatrixOfImageVectors(images, numberOfImages); Matrix inputBatch = imageBatchToMatrixOfImageVectors(images, numberOfImages);
Matrix outputBatch = forward(model, inputBatch); Matrix outputBatch = forward(model, inputBatch);
@@ -224,9 +254,12 @@ unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[],
return result; return result;
} }
void clearModel(NeuralNetwork *model) { void clearModel(NeuralNetwork *model)
if (model != NULL) { {
for (int i = 0; i < model->numberOfLayers; i++) { if(model != NULL)
{
for(int i = 0; i < model->numberOfLayers; i++)
{
clearLayer(&model->layers[i]); clearLayer(&model->layers[i]);
} }
model->layers = NULL; model->layers = NULL;
neuralNetworkTests.c
+49 -141
View File
@@ -1,102 +1,18 @@
#include "neuralNetwork.h"
#include "unity.h"
#include <math.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <math.h>
#include "unity.h"
#include "neuralNetwork.h"
/*typedef struct
static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
{ {
Matrix weights; // TODO
Matrix biases; }
ActivationFunctionType activation;
} Layer;
typedef struct void test_loadModelReturnsCorrectNumberOfLayers(void)
{ {
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*/
/* Gewichtsmatrix der Layer:
*/
// speichert NeuralNetwork nn in binäre Datei->später kann es wieder geöffnet
// werden
static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn) {
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__"; // header string
fwrite(header, sizeof(char), strlen(header),
fptr); // der header wird am Anfang der Datei platziert
// Wenn es keine Layer gibt, 0 eintragen, LoadModel erkennt, dass Datei leer
// ist
if (nn.numberOfLayers == 0) {
int zero = 0;
fwrite(&zero, sizeof(int), 1, fptr);
fclose(fptr);
return;
}
// Layer 0, inputDimension: Anzahl Input-Neuronen, outputDimension: Anzahl
// Output-Neuronen wird in Datei eingefügt
int inputDim = (int)nn.layers[0].weights.cols;
int outputDim = (int)nn.layers[0].weights.rows;
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)
geschrieben. */
for (int i = 0; i < nn.numberOfLayers; i++) {
Layer layer = nn.layers[i]; // kürzer, durch alle layer iterieren
int wrows = (int)layer.weights.rows;
int wcols = (int)layer.weights.cols;
int wcount = wrows * wcols; // Anzahl Gewichtseinträge
int bcount =
layer.biases.rows * layer.biases.cols; // Anzahl der Bias-Einträge
/* Gewichte */
if (wcount > 0 && layer.weights.buffer != NULL) {
fwrite(layer.weights.buffer, sizeof(MatrixType), (size_t)wcount, fptr);
} // Gewichte werden als Matrix gespeichert
/* Biases */
if (bcount > 0 && layer.biases.buffer != NULL) {
fwrite(layer.biases.buffer, sizeof(MatrixType), (size_t)bcount, fptr);
} // Biases werden als Vektor gespeichert
/* outputDimensionen der nächsten Layer */
if (i + 1 < nn.numberOfLayers) {
int nextOutput = (int)nn.layers[i + 1].weights.rows;
fwrite(&nextOutput, sizeof(int), 1, fptr);
} else {
// loadModel erkennt 0 als Ende der Datei
int zero = 0;
fwrite(&zero, sizeof(int), 1, fptr);
}
}
fclose(fptr); // Datei schließen
}
void test_loadModelReturnsCorrectNumberOfLayers(void) {
const char *path = "some__nn_test_file.info2"; const char *path = "some__nn_test_file.info2";
MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
MatrixType buffer2[] = {1, 2, 3, 4, 5, 6}; MatrixType buffer2[] = {1, 2, 3, 4, 5, 6};
@@ -106,8 +22,7 @@ void test_loadModelReturnsCorrectNumberOfLayers(void) {
MatrixType buffer4[] = {1, 2}; MatrixType buffer4[] = {1, 2};
Matrix biases1 = {.buffer=buffer3, .rows=3, .cols=1}; Matrix biases1 = {.buffer=buffer3, .rows=3, .cols=1};
Matrix biases2 = {.buffer=buffer4, .rows=2, .cols=1}; Matrix biases2 = {.buffer=buffer4, .rows=2, .cols=1};
Layer layers[] = {{.weights = weights1, .biases = biases1}, Layer layers[] = {{.weights=weights1, .biases=biases1}, {.weights=weights2, .biases=biases2}};
{.weights = weights2, .biases = biases2}};
NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=2}; NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=2};
NeuralNetwork netUnderTest; NeuralNetwork netUnderTest;
@@ -117,12 +32,12 @@ void test_loadModelReturnsCorrectNumberOfLayers(void) {
netUnderTest = loadModel(path); netUnderTest = loadModel(path);
remove(path); remove(path);
TEST_ASSERT_EQUAL_INT(expectedNet.numberOfLayers, TEST_ASSERT_EQUAL_INT(expectedNet.numberOfLayers, netUnderTest.numberOfLayers);
netUnderTest.numberOfLayers);
clearModel(&netUnderTest); clearModel(&netUnderTest);
} }
void test_loadModelReturnsCorrectWeightDimensions(void) { void test_loadModelReturnsCorrectWeightDimensions(void)
{
const char *path = "some__nn_test_file.info2"; const char *path = "some__nn_test_file.info2";
MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6};
Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2};
@@ -139,14 +54,13 @@ void test_loadModelReturnsCorrectWeightDimensions(void) {
remove(path); remove(path);
TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, netUnderTest.layers[0].weights.rows);
netUnderTest.layers[0].weights.rows); TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, netUnderTest.layers[0].weights.cols);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols,
netUnderTest.layers[0].weights.cols);
clearModel(&netUnderTest); clearModel(&netUnderTest);
} }
void test_loadModelReturnsCorrectBiasDimensions(void) { void test_loadModelReturnsCorrectBiasDimensions(void)
{
const char *path = "some__nn_test_file.info2"; const char *path = "some__nn_test_file.info2";
MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6};
Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2};
@@ -163,14 +77,13 @@ void test_loadModelReturnsCorrectBiasDimensions(void) {
remove(path); remove(path);
TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.rows, TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.rows, netUnderTest.layers[0].biases.rows);
netUnderTest.layers[0].biases.rows); TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.cols, netUnderTest.layers[0].biases.cols);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].biases.cols,
netUnderTest.layers[0].biases.cols);
clearModel(&netUnderTest); clearModel(&netUnderTest);
} }
void test_loadModelReturnsCorrectWeights(void) { void test_loadModelReturnsCorrectWeights(void)
{
const char *path = "some__nn_test_file.info2"; const char *path = "some__nn_test_file.info2";
MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6};
Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2};
@@ -187,18 +100,15 @@ void test_loadModelReturnsCorrectWeights(void) {
remove(path); remove(path);
TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, netUnderTest.layers[0].weights.rows);
netUnderTest.layers[0].weights.rows); TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, netUnderTest.layers[0].weights.cols);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, int n = netUnderTest.layers[0].weights.rows * netUnderTest.layers[0].weights.cols;
netUnderTest.layers[0].weights.cols); TEST_ASSERT_EQUAL_INT_ARRAY(expectedNet.layers[0].weights.buffer, netUnderTest.layers[0].weights.buffer, n);
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); clearModel(&netUnderTest);
} }
void test_loadModelReturnsCorrectBiases(void) { void test_loadModelReturnsCorrectBiases(void)
{
const char *path = "some__nn_test_file.info2"; const char *path = "some__nn_test_file.info2";
MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6};
Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2};
@@ -215,23 +125,21 @@ void test_loadModelReturnsCorrectBiases(void) {
remove(path); remove(path);
TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0); TEST_ASSERT_TRUE(netUnderTest.numberOfLayers > 0);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.rows, netUnderTest.layers[0].weights.rows);
netUnderTest.layers[0].weights.rows); TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, netUnderTest.layers[0].weights.cols);
TEST_ASSERT_EQUAL_INT(expectedNet.layers[0].weights.cols, int n = netUnderTest.layers[0].biases.rows * netUnderTest.layers[0].biases.cols;
netUnderTest.layers[0].weights.cols); TEST_ASSERT_EQUAL_INT_ARRAY(expectedNet.layers[0].biases.buffer, netUnderTest.layers[0].biases.buffer, n);
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); clearModel(&netUnderTest);
} }
void test_loadModelFailsOnWrongFileTag(void) { void test_loadModelFailsOnWrongFileTag(void)
{
const char *path = "some_nn_test_file.info2"; const char *path = "some_nn_test_file.info2";
NeuralNetwork netUnderTest; NeuralNetwork netUnderTest;
FILE *file = fopen(path, "wb"); FILE *file = fopen(path, "wb");
if (file != NULL) { if(file != NULL)
{
const char *fileTag = "info2_neural_network_file_format"; const char *fileTag = "info2_neural_network_file_format";
fwrite(fileTag, sizeof(char), strlen(fileTag), file); fwrite(fileTag, sizeof(char), strlen(fileTag), file);
@@ -247,7 +155,8 @@ void test_loadModelFailsOnWrongFileTag(void) {
TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers); TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers);
} }
void test_clearModelSetsMembersToNull(void) { void test_clearModelSetsMembersToNull(void)
{
const char *path = "some__nn_test_file.info2"; const char *path = "some__nn_test_file.info2";
MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6}; MatrixType weightBuffer[] = {1, 2, 3, 4, 5, 6};
Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2}; Matrix weights = {.buffer=weightBuffer, .rows=3, .cols=2};
@@ -270,23 +179,23 @@ void test_clearModelSetsMembersToNull(void) {
TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers); TEST_ASSERT_EQUAL_INT(0, netUnderTest.numberOfLayers);
} }
static void someActivation(Matrix *matrix) { static void someActivation(Matrix *matrix)
for (int i = 0; i < matrix->rows * matrix->cols; i++) { {
for(int i = 0; i < matrix->rows * matrix->cols; i++)
{
matrix->buffer[i] = fabs(matrix->buffer[i]); matrix->buffer[i] = fabs(matrix->buffer[i]);
} }
} }
void test_predictReturnsCorrectLabels(void) { void test_predictReturnsCorrectLabels(void)
{
const unsigned char expectedLabels[] = {4, 2}; const unsigned char expectedLabels[] = {4, 2};
GrayScalePixelType imageBuffer1[] = {10, 30, 25, 17}; GrayScalePixelType imageBuffer1[] = {10, 30, 25, 17};
GrayScalePixelType imageBuffer2[] = {20, 40, 10, 128}; GrayScalePixelType imageBuffer2[] = {20, 40, 10, 128};
GrayScaleImage inputImages[] = { GrayScaleImage inputImages[] = {{.buffer=imageBuffer1, .width=2, .height=2}, {.buffer=imageBuffer2, .width=2, .height=2}};
{.buffer = imageBuffer1, .width = 2, .height = 2},
{.buffer = imageBuffer2, .width = 2, .height = 2}};
MatrixType weightsBuffer1[] = {1, -2, 3, -4, 5, -6, 7, -8}; MatrixType weightsBuffer1[] = {1, -2, 3, -4, 5, -6, 7, -8};
MatrixType weightsBuffer2[] = {-9, 10, 11, 12, 13, 14}; MatrixType weightsBuffer2[] = {-9, 10, 11, 12, 13, 14};
MatrixType weightsBuffer3[] = {-15, 16, 17, 18, -19, 20, 21, 22, MatrixType weightsBuffer3[] = {-15, 16, 17, 18, -19, 20, 21, 22, 23, -24, 25, 26, 27, -28, -29};
23, -24, 25, 26, 27, -28, -29};
Matrix weights1 = {.buffer=weightsBuffer1, .rows=2, .cols=4}; Matrix weights1 = {.buffer=weightsBuffer1, .rows=2, .cols=4};
Matrix weights2 = {.buffer=weightsBuffer2, .rows=3, .cols=2}; Matrix weights2 = {.buffer=weightsBuffer2, .rows=3, .cols=2};
Matrix weights3 = {.buffer=weightsBuffer3, .rows=5, .cols=3}; Matrix weights3 = {.buffer=weightsBuffer3, .rows=5, .cols=3};
@@ -296,9 +205,8 @@ void test_predictReturnsCorrectLabels(void) {
Matrix biases1 = {.buffer=biasBuffer1, .rows=2, .cols=1}; Matrix biases1 = {.buffer=biasBuffer1, .rows=2, .cols=1};
Matrix biases2 = {.buffer=biasBuffer2, .rows=3, .cols=1}; Matrix biases2 = {.buffer=biasBuffer2, .rows=3, .cols=1};
Matrix biases3 = {.buffer=biasBuffer3, .rows=5, .cols=1}; Matrix biases3 = {.buffer=biasBuffer3, .rows=5, .cols=1};
Layer layers[] = { Layer layers[] = {{.weights=weights1, .biases=biases1, .activation=someActivation}, \
{.weights = weights1, .biases = biases1, .activation = someActivation}, {.weights=weights2, .biases=biases2, .activation=someActivation}, \
{.weights = weights2, .biases = biases2, .activation = someActivation},
{.weights=weights3, .biases=biases3, .activation=someActivation}}; {.weights=weights3, .biases=biases3, .activation=someActivation}};
NeuralNetwork netUnderTest = {.layers=layers, .numberOfLayers=3}; NeuralNetwork netUnderTest = {.layers=layers, .numberOfLayers=3};
unsigned char *predictedLabels = predict(netUnderTest, inputImages, 2); unsigned char *predictedLabels = predict(netUnderTest, inputImages, 2);
@@ -316,11 +224,11 @@ void tearDown(void) {
// Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
} }
int main() { int main()
{
UNITY_BEGIN(); UNITY_BEGIN();
printf("\n============================\nNeural network " printf("\n============================\nNeural network tests\n============================\n");
"tests\n============================\n");
RUN_TEST(test_loadModelReturnsCorrectNumberOfLayers); RUN_TEST(test_loadModelReturnsCorrectNumberOfLayers);
RUN_TEST(test_loadModelReturnsCorrectWeightDimensions); RUN_TEST(test_loadModelReturnsCorrectWeightDimensions);
RUN_TEST(test_loadModelReturnsCorrectBiasDimensions); RUN_TEST(test_loadModelReturnsCorrectBiasDimensions);