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

Compare commits

base: kachelto100370:main
Branches Tags
kachelto100370:main
kachelto100370:Krisp2
kachelto100370:RMax
kachelto100370:KTobi2
freudenreichan:main
..
compare: freudenreichan:main
Branches Tags
freudenreichan:main
kachelto100370:main
kachelto100370:Krisp2
kachelto100370:RMax
kachelto100370:KTobi2

No commits in common. "main" and "main" have entirely different histories.
main ... main

13 changed files with 597 additions and 1145 deletions
Show Stats Expand all files Collapse all files

3
.gitignore vendored
View File

@ -2,6 +2,3 @@ mnist
runTests runTests
*.o *.o
*.exe *.exe
.vscode/c_cpp_properties.json
.vscode/launch.json
.vscode/settings.json

18
.vscode/c_cpp_properties.json vendored
View File

@ -1,18 +0,0 @@
{
"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
}

24
.vscode/launch.json vendored
View File

@ -1,24 +0,0 @@
{
"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
}
]
}
]
}

59
.vscode/settings.json vendored
View File

@ -1,59 +0,0 @@
{
"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
}

2
README.md
View File

@ -1,2 +0,0 @@
# Projekt 2 für Informatik 2 Praktikum

132
imageInput.c
View File

@ -1,134 +1,22 @@
#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__"
/* ---------------------------------------------------------- // TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei
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
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) {
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;
}
/* ----------------------------------------------------------
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;
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;
}
// 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);
} }

171
imageInputTests.c
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,79 +119,25 @@ void test_readImagesFailsOnWrongFileTag(void) {
remove(path); remove(path);
} }
void test_read_GrayScale_Pixel(void) { void setUp(void) {
GrayScaleImageSeries *series = NULL; // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
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 tearDown(void) {
Optional: Mehrere Bilder gleichzeitig testen // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
--------------------------------------------------------- */
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);
} }
/* --------------------------------------------------------- int main()
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();
} }

211
matrix.c
View File

@ -1,208 +1,35 @@
#include "matrix.h"
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "matrix.h"
/*typedef struct { // TODO Matrix-Funktionen implementieren
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 createMatrix(unsigned int rows, unsigned int cols)
if (cols == 0 || rows == 0) { {
Matrix errorMatrix = {0, 0, NULL};
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;
}
void clearMatrix(Matrix *matrix) {
if (matrix->buffer != NULL) {
free((*matrix).buffer);
matrix->buffer = NULL;
}
matrix->rows = 0;
matrix->cols = 0;
} }
void setMatrixAt(const MatrixType value, Matrix matrix, void clearMatrix(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
} }
MatrixType getMatrixAt(const Matrix matrix,
unsigned int rowIdx, // Kopie der Matrix wird übergeben
unsigned int colIdx) {
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]; void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
return value;
} }
Matrix broadcastingCols(const Matrix matrix, const unsigned int cols) {
Matrix copy1 = createMatrix(matrix.rows, cols);
for (int r = 0; r < matrix.rows; r++) {
MatrixType valueMatrix1 = getMatrixAt(matrix, r, 0);
for (int c = 0; c < cols; c++) {
setMatrixAt(valueMatrix1, copy1, r, c);
}
}
return copy1;
}
Matrix broadcastingRows(const Matrix matrix, const unsigned int rows) {
Matrix copy1 = createMatrix(rows, matrix.cols);
for (int c = 0; c < matrix.cols; c++) {
MatrixType valueMatrix1 = getMatrixAt(matrix, 0, c);
for (int r = 0; r < rows; r++) {
setMatrixAt(valueMatrix1, copy1, r, c);
}
}
return copy1;
}
Matrix add(const Matrix matrix1, const Matrix matrix2) {
// Ergebnismatrix MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
Matrix result; {
const int cols1 = matrix1.cols;
const int rows1 = matrix1.rows;
const int cols2 = matrix2.cols;
const int rows2 = matrix2.rows;
const int rowsEqual = (matrix1.rows == matrix2.rows) ? 1 : 0;
const int colsEqual = (matrix1.cols == matrix2.cols) ? 1 : 0;
// Broadcasting nur bei Vektor und Matrix, Fehlermeldung bei zwei unpassender
// Matrix
if (rowsEqual == 1 && colsEqual == 1) {
Matrix result = createMatrix(matrix1.rows, matrix1.cols);
if (result.buffer == NULL) {
return (Matrix){0, 0, NULL};
}
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);
}
}
return result;
} else if (rowsEqual == 1 && (cols1 == 1 || cols2 == 1)) {
if (cols1 == 1) { // broadcasting von vektor 1 zu matrix 1, add
Matrix newMatrix = broadcastingCols(matrix1, cols2);
// add
Matrix result = createMatrix(newMatrix.rows, newMatrix.cols);
if (result.buffer == NULL) {
return (Matrix){0, 0, NULL};
}
for (int i = 0; i < rows1; i++) {
for (int j = 0; j < cols2; j++) {
int valueM1 = getMatrixAt(newMatrix, i, j);
int valueM2 = getMatrixAt(matrix2, i, j);
int sum = valueM1 + valueM2;
setMatrixAt(sum, result, i, j);
}
}
return result;
} else {
Matrix newMatrix2 = broadcastingCols(matrix2, cols1);
// add
Matrix result = createMatrix(newMatrix2.rows, newMatrix2.cols);
if (result.buffer == NULL) {
return (Matrix){0, 0, NULL};
}
for (int i = 0; i < rows1; i++) {
for (int j = 0; j < cols1; j++) {
int valueM1 = getMatrixAt(matrix1, i, j);
int valueM2 = getMatrixAt(newMatrix2, i, j);
int sum = valueM1 + valueM2;
setMatrixAt(sum, result, i, j);
}
}
return result;
}
}
else if ((rows1 == 1 || rows2 == 1) && colsEqual == 1) {
if (rows1 == 1) {
Matrix newMatrix = broadcastingRows(matrix1, rows2);
// add
Matrix result = createMatrix(newMatrix.rows, newMatrix.cols);
if (result.buffer == NULL) {
return (Matrix){0, 0, NULL};
}
for (int i = 0; i < rows2; i++) {
for (int j = 0; j < cols1; j++) {
int valueM1 = getMatrixAt(newMatrix, i, j);
int valueM2 = getMatrixAt(matrix2, i, j);
int sum = valueM1 + valueM2;
setMatrixAt(sum, result, i, j);
}
}
return result;
} else {
Matrix newMatrix2 = broadcastingRows(matrix2, rows1);
// add
Matrix result = createMatrix(newMatrix2.rows, newMatrix2.cols);
if (result.buffer == NULL) {
return (Matrix){0, 0, NULL};
}
for (int i = 0; i < rows1; i++) {
for (int j = 0; j < cols1; j++) {
int valueM1 = getMatrixAt(matrix1, i, j);
int valueM2 = getMatrixAt(newMatrix2, i, j);
int sum = valueM1 + valueM2;
setMatrixAt(sum, result, i, j);
}
}
return result;
}
} else {
// kein add möglich
Matrix errorMatrix = {0, 0, NULL};
return errorMatrix;
}
return result;
} }
Matrix multiply(const Matrix matrix1, const Matrix matrix2) {
// Spalten1 müssen gleich zeilen2 sein! dann multiplizieren Matrix add(const Matrix matrix1, const Matrix matrix2)
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++) { Matrix multiply(const Matrix matrix1, const Matrix matrix2)
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;
}
} }

17
matrix.h
View File

@ -6,25 +6,14 @@
typedef float MatrixType; typedef float MatrixType;
// TODO Matrixtyp definieren // TODO Matrixtyp definieren
typedef struct {
unsigned int rows;
unsigned int cols;
MatrixType *buffer;
} Matrix;
Matrix createMatrix(unsigned int rows, unsigned int cols); Matrix createMatrix(unsigned int rows, unsigned int cols);
void clearMatrix(Matrix *matrix); void clearMatrix(Matrix *matrix);
void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
unsigned int colIdx); MatrixType getMatrixAt(const 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 add(const Matrix matrix1, const Matrix matrix2);
Matrix multiply(const Matrix matrix1, const Matrix matrix2); Matrix multiply(const Matrix matrix1, const Matrix matrix2);
#endif #endif

29
neuralN_readFiles
View File

@ -1,29 +0,0 @@
Inhalte: Dynamische Speicherverwaltung, Strukturen, Dateien lesen.
Ziel: Die Bilder aus mnist_test.info 2 auslesen
Struktur für einlesen des Strings am Anfang der Datei:
int AnzahlBilder
int breiteBilder
int LaengeBilder
Struktur für Bilder:
unsinged int array Breite * Höhe
unsigned int Klasse (Label 0 - 9)
Speicher für Bilder dynamisch allokieren
GrayScaleImageSeries:
datei einlesen
header String aus der Datei lesen
mit header String den benötigten Speicher freigeben
in den Speicher die Datei einschreiben (mit Hilfsfunktion)
Hilfsfunktion (saveFile)
gehe zum Anfang des Strings
speicher alles der Reihe nach ein
clearSeries:
pointer der be malloc kommt nehemen
free()

169
neuralNetwork.c
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,49 +38,54 @@ 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};
if (BUFFER_SIZE - 1 < fileHeaderLen) if(BUFFER_SIZE-1 < fileHeaderLen)
fileHeaderLen = BUFFER_SIZE - 1; fileHeaderLen = BUFFER_SIZE-1;
if (fread(buffer, sizeof(char), fileHeaderLen, file) == fileHeaderLen) if(fread(buffer, sizeof(char), fileHeaderLen, file) == fileHeaderLen)
isValid = strcmp(buffer, FILE_HEADER_STRING) == 0; isValid = strcmp(buffer, FILE_HEADER_STRING) == 0;
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)
dimension = 0; dimension = 0;
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,54 +93,62 @@ 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;
} }
if (model.numberOfLayers > 0) if(model.numberOfLayers > 0)
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;
@ -181,7 +207,7 @@ static Matrix forward(const NeuralNetwork model, Matrix inputBatch) {
biasResult = add(model.layers[i].biases, weightResult); biasResult = add(model.layers[i].biases, weightResult);
clearMatrix(&weightResult); clearMatrix(&weightResult);
if (model.layers[i].activation != NULL) if(model.layers[i].activation != NULL)
model.layers[i].activation(&biasResult); model.layers[i].activation(&biasResult);
result = biasResult; result = biasResult;
} }
@ -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;

253
neuralNetworkTests.c
View File

@ -1,112 +1,30 @@
#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
{
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 *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 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, fptr);
fclose(fptr);
return;
}
// 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, 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];
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 */
/* Gewichte (MatrixType binär) */
if (wcount > 0 && layer.weights.buffer != NULL) {
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, 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, 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, fptr);
}
}
fclose(fptr);
} }
void test_loadModelReturnsCorrectNumberOfLayers(void) { 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};
Matrix weights1 = {.buffer = buffer1, .rows = 3, .cols = 2}; Matrix weights1 = {.buffer=buffer1, .rows=3, .cols=2};
Matrix weights2 = {.buffer = buffer2, .rows = 2, .cols = 3}; Matrix weights2 = {.buffer=buffer2, .rows=2, .cols=3};
MatrixType buffer3[] = {1, 2, 3}; MatrixType buffer3[] = {1, 2, 3};
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;
prepareNeuralNetworkFile(path, expectedNet); prepareNeuralNetworkFile(path, expectedNet);
@ -114,20 +32,20 @@ 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};
MatrixType biasBuffer[] = {7, 8, 9}; MatrixType biasBuffer[] = {7, 8, 9};
Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1};
Layer layers[] = {{.weights = weights, .biases = biases}}; Layer layers[] = {{.weights=weights, .biases=biases}};
NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest; NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, expectedNet); prepareNeuralNetworkFile(path, expectedNet);
@ -136,22 +54,21 @@ 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};
MatrixType biasBuffer[] = {7, 8, 9}; MatrixType biasBuffer[] = {7, 8, 9};
Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1};
Layer layers[] = {{.weights = weights, .biases = biases}}; Layer layers[] = {{.weights=weights, .biases=biases}};
NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest; NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, expectedNet); prepareNeuralNetworkFile(path, expectedNet);
@ -160,22 +77,21 @@ 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};
MatrixType biasBuffer[] = {7, 8, 9}; MatrixType biasBuffer[] = {7, 8, 9};
Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1};
Layer layers[] = {{.weights = weights, .biases = biases}}; Layer layers[] = {{.weights=weights, .biases=biases}};
NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest; NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, expectedNet); prepareNeuralNetworkFile(path, expectedNet);
@ -184,26 +100,23 @@ 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};
MatrixType biasBuffer[] = {7, 8, 9}; MatrixType biasBuffer[] = {7, 8, 9};
Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1};
Layer layers[] = {{.weights = weights, .biases = biases}}; Layer layers[] = {{.weights=weights, .biases=biases}};
NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest; NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, expectedNet); prepareNeuralNetworkFile(path, expectedNet);
@ -212,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);
@ -244,15 +155,16 @@ 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};
MatrixType biasBuffer[] = {7, 8, 9}; MatrixType biasBuffer[] = {7, 8, 9};
Matrix biases = {.buffer = biasBuffer, .rows = 3, .cols = 1}; Matrix biases = {.buffer=biasBuffer, .rows=3, .cols=1};
Layer layers[] = {{.weights = weights, .biases = biases}}; Layer layers[] = {{.weights=weights, .biases=biases}};
NeuralNetwork expectedNet = {.layers = layers, .numberOfLayers = 1}; NeuralNetwork expectedNet = {.layers=layers, .numberOfLayers=1};
NeuralNetwork netUnderTest; NeuralNetwork netUnderTest;
prepareNeuralNetworkFile(path, expectedNet); prepareNeuralNetworkFile(path, expectedNet);
@ -267,37 +179,36 @@ 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};
MatrixType biasBuffer1[] = {200, 0}; MatrixType biasBuffer1[] = {200, 0};
MatrixType biasBuffer2[] = {0, -100, 0}; MatrixType biasBuffer2[] = {0, -100, 0};
MatrixType biasBuffer3[] = {0, -1000, 0, 2000, 0}; MatrixType biasBuffer3[] = {0, -1000, 0, 2000, 0};
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);
TEST_ASSERT_NOT_NULL(predictedLabels); TEST_ASSERT_NOT_NULL(predictedLabels);
int n = (int)(sizeof(expectedLabels) / sizeof(expectedLabels[0])); int n = (int)(sizeof(expectedLabels) / sizeof(expectedLabels[0]));
@ -313,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);