main.c

@@ -2,28 +2,122 @@
 
 #include "image.h"
 #include "neuronal_network.h"
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "util.h"
 
-int main() {
+void parsingErrorPrintHelp(){
-    Image** images = import_images("../data/train-images.idx3-ubyte", "../data/train-labels.idx1-ubyte", NULL, 60000);
+    printf("Syntax: c_net [train | detect]\n");
-//    img_visualize(images[0]);
+    printf("commands:\n");
-//    img_visualize(images[1]);
+    printf("train\t train the network\n");
+    printf("predict\t load a pgm image and predict_demo the number\n");
+    exit(1);
+}
 
-//    matrix_print(images[0]->pixel_values);
+void parsingErrorTrain(){
-//    matrix_print(images[1]->pixel_values);
+    printf("invalid syntax\n");
+    printf("Syntax: c_net train [path_to_train-images.idx3-ubyte] [path_to_train-labels.idx1-ubyte] [hidden_layer_count] [neurons_per_layer] [epochs] [learning_rate] [path_to_save_network]\n");
+    exit(1);
+}
 
-    Neural_Network* nn = new_network(28*28, 40, 5, 10, 0.08);
+void parsingErrorDetect(){
-    randomize_network(nn, 1);
+    printf("invalid syntax\n");
-//        Neural_Network* nn = load_network("../networks/newest_network.txt");
+    printf("Syntax: c_net predict_demo [path_to_network] [image_file]");
-//    printf("Done loading!\n");
+}
 
-//    batch_train(nn, images, 20000, 20);
+void predict_demo(int argc, char** arguments){
+    if(argc != 2) parsingErrorDetect();
+    char * network_file = arguments[0];
+    char * image_file = arguments[1];
 
-    for (int i = 0; i < 30000; ++i) {
+    Neural_Network * nn = load_network(network_file);
-        train_network(nn, images[i], images[i]->label);
+    Image * image = load_pgm_image(image_file);
+    Matrix * result = predict_image(nn, image);
+    int predicted = matrix_argmax(result);
+    printf("prediction result %d\n", predicted);
+    matrix_print(result);
+    matrix_free(result);
+}
+
+void train(int argc, char** arguments) {
+    if (argc != 7) parsingErrorTrain();
+    char *image_file = arguments[0];
+    char *label_file = arguments[1];
+    int hidden_count = (int) strtol(arguments[2], NULL, 10);
+    int neurons_per_layer = (int) strtol(arguments[3], NULL, 10);
+    int epochs = (int) strtol(arguments[4], NULL, 10);
+    if (errno != 0) {
+        printf("hidden_count, neurons_per_layer or epochs could not be parsed!\n");
+        exit(1);
     }
+    double learning_rate = strtod(arguments[5], NULL);
+    if (errno != 0) {
+        printf("learning_rate could not be parsed!\n");
+        exit(1);
+    }
+    char *save_path = arguments[6];
+    int imported = 0;
+    Image **images = import_images(image_file, label_file, &imported, 50000);
 
-    save_network(nn);
+//    for(int i = 0; i < imported; i++){
+//        matrix_save(images[i]->pixel_values, "images.txt");
+//    }
+//    exit(1);
 
-    printf("%lf\n", measure_network_accuracy(nn, images, 10000));
+    Neural_Network *nn = new_network(28 * 28, neurons_per_layer, hidden_count, 10, learning_rate);
+    randomize_network(nn, 1);
+    printf("training_network\n");
+    for(int epoch = 1; epoch <= epochs; epoch++){
+        printf("epoch %d\n", epoch);
+        for (int i = 0; i < imported; i++) {
+            if (i % 1000 == 0) {
+                updateBar(i * 100 / imported);
+            }
+            train_network(nn, images[i], images[i]->label);
+        }
+        updateBar(100);
+        printf("\n");
+        printf("accuracy %lf\n", measure_network_accuracy(nn, images, 10000));
+    }
+    printf("done training!\n");
+    save_network(nn, save_path);
+}
+
+int main(int argc, char** argv) {
+//    Image** images = import_images("../data/train-images.idx3-ubyte", "../data/train-labels.idx1-ubyte", NULL, 60000);
+////    img_visualize(images[0]);
+////    img_visualize(images[1]);
+//
+////    matrix_print(images[0]->pixel_values);
+////    matrix_print(images[1]->pixel_values);
+//
+//    Neural_Network* nn = new_network(28*28, 40, 5, 10, 0.08);
+//    randomize_network(nn, 1);
+////        Neural_Network* nn = load_network("../networks/newest_network.txt");
+////    printf("Done loading!\n");
+//
+////    batch_train(nn, images, 20000, 20);
+//
+//    for (int i = 0; i < 30000; ++i) {
+//        train_network(nn, images[i], images[i]->label);
+//    }
+//
+//    save_network(nn);
+//
+//    printf("%lf\n", measure_network_accuracy(nn, images, 10000));
+    if(argc < 2){
+        parsingErrorPrintHelp();
+        exit(1);
+    }
+    if(strcmp(argv[1], "train") == 0){
+        train(argc-2, argv+2);
+        return 0;
+    }
+    if(strcmp(argv[1], "predict") == 0){
+        predict_demo(argc - 2, argv + 2);
+        return 0;
+    }
+    parsingErrorPrintHelp();
 
 }

neuronal_network.c

@@ -2,6 +2,7 @@
 #include "neuronal_network.h"
 #include <stdio.h>
 #include <math.h>
+#include "util.h"
 
 double sigmoid(double input);
 Matrix* predict(Neural_Network* network, Matrix* image_data);
@@ -45,9 +46,7 @@ void free_network(Neural_Network* network){
     free(network);
 }
 
-void save_network(Neural_Network* network) {
+void save_network(Neural_Network* network, char * file_name) {
-
-    char* file_name = "../networks/newest_network.txt";
 
     // create file
     FILE* save_file = fopen(file_name, "w");
@@ -117,7 +116,9 @@ void print_network(Neural_Network* network) {
 double measure_network_accuracy(Neural_Network* network, Image** images, int amount) {
     int num_correct = 0;
 
-    for (int i = 0; i < amount; i++) {
+    printf("evaluating network\n");
+    for (int i = 50001; i < amount; i++) {
+        updateBar(i*100/amount);
         Matrix* prediction = predict_image(network, images[i]);
 
         int guess = matrix_argmax(prediction);
@@ -129,6 +130,7 @@ double measure_network_accuracy(Neural_Network* network, Image** images, int amo
 
         matrix_free(prediction);
     }
+    updateBar(100);
     return ((double) num_correct) / amount;
 }
 

neuronal_network.h

@@ -21,7 +21,7 @@ Neural_Network* new_network(int input_size, int hidden_size, int hidden_amount,
 void randomize_network(Neural_Network* network, int scope);
 void free_network(Neural_Network* network);
 
-void save_network(Neural_Network* network);
+void save_network(Neural_Network* network, char * file_name);
 Neural_Network* load_network(char* file);
 
 void print_network(Neural_Network* network);