kp

Reviewed-on: kachelto100370/info2Praktikum-NeuronalesNetz#1

.gitignore

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

.vscode/c_cpp_properties.json

@@ -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

@@ -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

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

README.md

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

imageInput.c

@@ -7,16 +7,23 @@
 #define FILE_HEADER_STRING "__info2_image_file_format__"
 
 // TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei
+GrayScaleImage readImage()
+{
+
+}
 
 // TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen
 GrayScaleImageSeries *readImages(const char *path)
 {
     GrayScaleImageSeries *series = NULL;
-    
+    FILE *file = fopen("mnist_test.info2","rb");
+    char headOfFile;
+    series = malloc();
     return series;
 }
 
 // TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
 void clearSeries(GrayScaleImageSeries *series)
 {
+
 }

matrix.c

@@ -1,35 +1,206 @@
+#include "matrix.h"
 #include <stdlib.h>
 #include <string.h>
-#include "matrix.h"
-
 // TODO Matrix-Funktionen implementieren
+/*typedef struct {
+    unsigned int rows;  //Zeilen
+    unsigned int cols; //Spalten
+    MatrixType *buffer; //Zeiger auf Speicherbereich Reihen*Spalten
+} Matrix;*/
+Matrix createMatrix(unsigned int rows, unsigned int cols) {
+  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) {
+  matrix->buffer = UNDEFINED_MATRIX_VALUE;
+  matrix->rows = UNDEFINED_MATRIX_VALUE;
+  matrix->cols = UNDEFINED_MATRIX_VALUE;
+  free((*matrix).buffer); // Speicher freigeben
+}
+void setMatrixAt(const MatrixType value, Matrix matrix,
+                 const unsigned int rowIdx, // Kopie der Matrix wird übergeben
+                 const unsigned int colIdx) {
 
-Matrix createMatrix(unsigned int rows, unsigned int cols)
-{
+  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) { // Speichergröße nicht überschreiten
+    return 0;
+  }
+
+  MatrixType value = matrix.buffer[rowIdx * matrix.cols + 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) {
 
-void clearMatrix(Matrix *matrix)
-{
+  // Ergebnismatrix
+  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;
 }
-
-void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
-{
-    
-}
-
-MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
-{
-    
-}
-
-Matrix add(const Matrix matrix1, const Matrix matrix2)
-{
-    
-}
-
-Matrix multiply(const Matrix matrix1, const Matrix matrix2)
-{
-    
+Matrix multiply(const Matrix matrix1, const Matrix matrix2) { 
+  //Spalten1 müssen gleich zeilen2 sein! dann multiplizieren
+  if (matrix1.cols == matrix2.rows){
+    Matrix multMatrix = createMatrix(matrix1.rows,matrix2.cols);
+    //durch neue matrix iterieren
+    for (int r=0; r< matrix1.rows; r++){
+      for (int c=0; c< matrix2.cols; c++){
+        MatrixType sum = 0.0;
+        //skalarprodukte berechnen, k damit die ganze zeile mal die ganze spalte genommen wird quasi
+        for (int k=0; k< matrix1.cols; k++){
+          //sum+= matrix1.buffer[r*matrix1.cols+k]*matrix2.buffer[k*matrix2.cols+c];
+          sum += getMatrixAt(matrix1, r, k)*getMatrixAt(matrix2, k, c);
+        }
+        //Ergebnisse in neue matrix speichern
+        setMatrixAt(sum, multMatrix, r, c);
+      }
+    }
+    return multMatrix;
+  }
+  //sonst fehler, kein multiply möglich
+  else{
+    Matrix errorMatrix = {0, 0, NULL};
+    return errorMatrix;
+  }
 }

matrix.h

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

neuralN_readFiles

@@ -0,0 +1,29 @@
+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()

neuralNetwork.c

@@ -1,35 +1,29 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <math.h>
-#include <string.h>
 #include "neuralNetwork.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #define BUFFER_SIZE 100
 #define FILE_HEADER_STRING "__info2_neural_network_file_format__"
 
-static void softmax(Matrix *matrix)
-{
-    if(matrix->cols > 0)
-    {
+static void softmax(Matrix *matrix) {
+  if (matrix->cols > 0) {
     double *colSums = (double *)calloc(matrix->cols, sizeof(double));
 
-        if(colSums != NULL)
-        {
-            for(int colIdx = 0; colIdx < matrix->cols; colIdx++)
-            {
-                for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++)
-                {
+    if (colSums != NULL) {
+      for (int colIdx = 0; colIdx < matrix->cols; colIdx++) {
+        for (int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) {
           MatrixType expValue = exp(getMatrixAt(*matrix, rowIdx, colIdx));
           setMatrixAt(expValue, *matrix, rowIdx, colIdx);
           colSums[colIdx] += expValue;
         }
       }
 
-            for(int colIdx = 0; colIdx < matrix->cols; colIdx++)
-            {
-                for(int rowIdx = 0; rowIdx < matrix->rows; rowIdx++)
-                {
-                    MatrixType normalizedValue = getMatrixAt(*matrix, rowIdx, colIdx) / colSums[colIdx];
+      for (int colIdx = 0; colIdx < matrix->cols; colIdx++) {
+        for (int rowIdx = 0; rowIdx < matrix->rows; rowIdx++) {
+          MatrixType normalizedValue =
+              getMatrixAt(*matrix, rowIdx, colIdx) / colSums[colIdx];
           setMatrixAt(normalizedValue, *matrix, rowIdx, colIdx);
         }
       }
@@ -38,54 +32,49 @@ static void softmax(Matrix *matrix)
   }
 }
 
-static void relu(Matrix *matrix)
-{
-    for(int i = 0; i < matrix->rows * matrix->cols; i++)
-    {
+static void relu(Matrix *matrix) {
+  for (int i = 0; i < matrix->rows * matrix->cols; i++) {
     matrix->buffer[i] = matrix->buffer[i] >= 0 ? matrix->buffer[i] : 0;
   }
 }
 
-static int checkFileHeader(FILE *file)
-{
+static int checkFileHeader(FILE *file) {
   int isValid = 0;
   int fileHeaderLen = strlen(FILE_HEADER_STRING);
   char buffer[BUFFER_SIZE] = {0};
 
-    if(BUFFER_SIZE-1 < fileHeaderLen)
-        fileHeaderLen = BUFFER_SIZE-1;
+  if (BUFFER_SIZE - 1 < fileHeaderLen)
+    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;
 
   return isValid;
 }
 
-static unsigned int readDimension(FILE *file)
-{
+static unsigned int readDimension(FILE *file) {
   int dimension = 0;
 
-    if(fread(&dimension, sizeof(int), 1, file) != 1)
+  if (fread(&dimension, sizeof(int), 1, file) != 1)
     dimension = 0;
 
   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);
 
-    if(matrix.buffer != NULL)
-    {
-        if(fread(matrix.buffer, sizeof(MatrixType), rows*cols, file) != rows*cols)
+  if (matrix.buffer != NULL) {
+    if (fread(matrix.buffer, sizeof(MatrixType), rows * cols, file) !=
+        rows * cols)
       clearMatrix(&matrix);
   }
 
   return matrix;
 }
 
-static Layer readLayer(FILE *file, unsigned int inputDimension, unsigned int outputDimension)
-{
+static Layer readLayer(FILE *file, unsigned int inputDimension,
+                       unsigned int outputDimension) {
   Layer layer;
   layer.weights = readMatrix(file, outputDimension, inputDimension);
   layer.biases = readMatrix(file, outputDimension, 1);
@@ -93,62 +82,54 @@ static Layer readLayer(FILE *file, unsigned int inputDimension, unsigned int out
   return layer;
 }
 
-static int isEmptyLayer(const Layer layer)
-{
-    return layer.biases.cols == 0 || layer.biases.rows == 0 || layer.biases.buffer == NULL || layer.weights.rows == 0 || layer.weights.cols == 0 || layer.weights.buffer == NULL;
+static int isEmptyLayer(const Layer layer) {
+  return layer.biases.cols == 0 || layer.biases.rows == 0 ||
+         layer.biases.buffer == NULL || layer.weights.rows == 0 ||
+         layer.weights.cols == 0 || layer.weights.buffer == NULL;
 }
 
-static void clearLayer(Layer *layer)
-{
-    if(layer != NULL)
-    {
+static void clearLayer(Layer *layer) {
+  if (layer != NULL) {
     clearMatrix(&layer->weights);
     clearMatrix(&layer->biases);
     layer->activation = NULL;
   }
 }
 
-static void assignActivations(NeuralNetwork model)
-{
-    for(int i = 0; i < (int)model.numberOfLayers-1; i++)
-    {
+static void assignActivations(NeuralNetwork model) {
+  for (int i = 0; i < (int)model.numberOfLayers - 1; i++) {
     model.layers[i].activation = relu;
   }
 
-    if(model.numberOfLayers > 0)
-        model.layers[model.numberOfLayers-1].activation = softmax;
+  if (model.numberOfLayers > 0)
+    model.layers[model.numberOfLayers - 1].activation = softmax;
 }
 
-NeuralNetwork loadModel(const char *path)
-{
+NeuralNetwork loadModel(const char *path) {
   NeuralNetwork model = {NULL, 0};
   FILE *file = fopen(path, "rb");
 
-    if(file != NULL)
-    {
-        if(checkFileHeader(file))
-        {
+  if (file != NULL) {
+    if (checkFileHeader(file)) {
       unsigned int inputDimension = readDimension(file);
       unsigned int outputDimension = readDimension(file);
 
-            while(inputDimension > 0 && outputDimension > 0)
-            {
+      while (inputDimension > 0 && outputDimension > 0) {
         Layer layer = readLayer(file, inputDimension, outputDimension);
         Layer *layerBuffer = NULL;
 
-                if(isEmptyLayer(layer))
-                {
+        if (isEmptyLayer(layer)) {
           clearLayer(&layer);
           clearModel(&model);
           break;
         }
 
-                layerBuffer = (Layer *)realloc(model.layers, (model.numberOfLayers + 1) * sizeof(Layer));
+        layerBuffer = (Layer *)realloc(
+            model.layers, (model.numberOfLayers + 1) * sizeof(Layer));
 
-                if(layerBuffer != NULL)
+        if (layerBuffer != NULL)
           model.layers = layerBuffer;
-                else
-                {
+        else {
           clearModel(&model);
           break;
         }
@@ -168,20 +149,16 @@ NeuralNetwork loadModel(const char *path)
   return model;
 }
 
-static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[], unsigned int count)
-{
-    Matrix matrix = {NULL, 0, 0};
+static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[],
+                                               unsigned int count) {
+  Matrix matrix = {0, 0, NULL};
 
-    if(count > 0 && images != NULL)
-    {
+  if (count > 0 && images != NULL) {
     matrix = createMatrix(images[0].height * images[0].width, count);
 
-        if(matrix.buffer != NULL)
-        {
-            for(int i = 0; i < count; i++)
-            {
-                for(int j = 0; j < images[i].width * images[i].height; j++)
-                {
+    if (matrix.buffer != NULL) {
+      for (int i = 0; i < count; i++) {
+        for (int j = 0; j < images[i].width * images[i].height; j++) {
           setMatrixAt((MatrixType)images[i].buffer[j], matrix, j, i);
         }
       }
@@ -191,14 +168,11 @@ static Matrix imageBatchToMatrixOfImageVectors(const GrayScaleImage images[], un
   return matrix;
 }
 
-static Matrix forward(const NeuralNetwork model, Matrix inputBatch)
-{
+static Matrix forward(const NeuralNetwork model, Matrix inputBatch) {
   Matrix result = inputBatch;
 
-    if(result.buffer != NULL)
-    {
-        for(int i = 0; i < model.numberOfLayers; i++)
-        {
+  if (result.buffer != NULL) {
+    for (int i = 0; i < model.numberOfLayers; i++) {
       Matrix biasResult;
       Matrix weightResult;
 
@@ -207,7 +181,7 @@ static Matrix forward(const NeuralNetwork model, Matrix inputBatch)
       biasResult = add(model.layers[i].biases, weightResult);
       clearMatrix(&weightResult);
 
-            if(model.layers[i].activation != NULL)
+      if (model.layers[i].activation != NULL)
         model.layers[i].activation(&biasResult);
       result = biasResult;
     }
@@ -216,23 +190,19 @@ static Matrix forward(const NeuralNetwork model, Matrix inputBatch)
   return result;
 }
 
-unsigned char *argmax(const Matrix matrix)
-{
+unsigned char *argmax(const Matrix matrix) {
   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);
 
-        if(maxIdx != NULL)
-        {
-            for(int colIdx = 0; colIdx < matrix.cols; colIdx++)
-            {
+    if (maxIdx != NULL) {
+      for (int colIdx = 0; colIdx < matrix.cols; colIdx++) {
         maxIdx[colIdx] = 0;
 
-                for(int rowIdx = 1; rowIdx < matrix.rows; rowIdx++)
-                {
-                    if(getMatrixAt(matrix, rowIdx, colIdx) > getMatrixAt(matrix, maxIdx[colIdx], colIdx))
+        for (int rowIdx = 1; rowIdx < matrix.rows; rowIdx++) {
+          if (getMatrixAt(matrix, rowIdx, colIdx) >
+              getMatrixAt(matrix, maxIdx[colIdx], colIdx))
             maxIdx[colIdx] = rowIdx;
         }
       }
@@ -242,8 +212,8 @@ unsigned char *argmax(const Matrix matrix)
   return maxIdx;
 }
 
-unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[], unsigned int numberOfImages)
-{
+unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[],
+                       unsigned int numberOfImages) {
   Matrix inputBatch = imageBatchToMatrixOfImageVectors(images, numberOfImages);
   Matrix outputBatch = forward(model, inputBatch);
 
@@ -254,12 +224,9 @@ unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[],
   return result;
 }
 
-void clearModel(NeuralNetwork *model)
-{
-    if(model != NULL)
-    {
-        for(int i = 0; i < model->numberOfLayers; i++)
-        {
+void clearModel(NeuralNetwork *model) {
+  if (model != NULL) {
+    for (int i = 0; i < model->numberOfLayers; i++) {
       clearLayer(&model->layers[i]);
     }
     model->layers = NULL;