test

image.c

@@ -90,7 +90,6 @@ Image** import_images(char* image_file_string, char* label_file_string, int* _nu
     fread(word_buffer, 4, 1, label_file);
     big_endian_to_c_uint(word_buffer, &label_count, buffer_size);
 
-
     //Read description of file
     fread(word_buffer, 4, 1, image_file);
     big_endian_to_c_uint(word_buffer, &magic_number_images, buffer_size);

main.c

@@ -6,14 +6,22 @@
 int main() {
     Image** images = import_images("../data/train-images.idx3-ubyte", "../data/train-labels.idx1-ubyte", NULL, 60000);
 //    img_visualize(images[0]);
+//    img_visualize(images[1]);
 
-    Neural_Network* nn = new_network(28*28, 32, 3, 10, 0.01);
+//    matrix_print(images[0]->pixel_values);
-    randomize_network(nn, 10);
+//    matrix_print(images[1]->pixel_values);
+
+    Neural_Network* nn = new_network(28*28, 32, 2, 10, 0.1);
+    randomize_network(nn, 1);
     //    save_network(nn);
     //    Neural_Network* nn = load_network("../networks/test1.txt");
 
-    batch_train(nn, images, 20000, 16);
+//    batch_train(nn, images, 20000, 20);
 
-    printf("%lf\n", measure_network_accuracy(nn, images, 10000));
+    for (int i = 0; i < 1000; ++i) {
+        train_network(nn, images[i], images[i]->label);
+    }
+
+    printf("%lf\n", measure_network_accuracy(nn, images, 10));
 
 }

neuronal_network.c

@@ -117,11 +117,20 @@ 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++) {
         Matrix* prediction = predict_image(network, images[i]);
-        if (matrix_argmax(prediction) == images[i]->label) {
+
+        matrix_print(prediction);
+        printf("Label: %c\n", images[i]->label);
+
+        int guess = matrix_argmax(prediction);
+        int answer = (unsigned char) images[i]->label;
+
+        if (guess == answer) {
             num_correct++;
         }
+
         matrix_free(prediction);
     }
     return ((double) num_correct) / amount;
@@ -160,43 +169,47 @@ Matrix* predict(Neural_Network* network, Matrix* image_data) {
     return output[network->hidden_amount];
 }
 
-void batch_train(Neural_Network* network, Image** images, int amount, int batch_size) {
+//void batch_train(Neural_Network* network, Image** images, int amount, int batch_size) {
+//
+//    for (int i = 0; i < amount; ++i) {
+//
+//        if(amount % 1000 == 0) {
+//            printf("1k pics!\n");
+//        }
+//
+//        Matrix* batch_weights[network->hidden_amount + 1];
+//
+//        for (int j = 0; j < batch_size; ++j) {
+//            Matrix** delta_weights = train_network(network, images[i], images[i]->label);
+//
+//            for (int k = 0; k < network->hidden_amount + 1; k++) {
+//                if(j == 0) {
+//                    batch_weights[k] = delta_weights[k];
+//                    continue;
+//                }
+//
+//                Matrix* temp_result = add(batch_weights[k], delta_weights[k]);
+//
+//                matrix_free(batch_weights[k]);
+//                matrix_free(delta_weights[k]);
+//
+//                batch_weights[k] = temp_result;
+//            }
+//
+//            free(delta_weights);
+//        }
+//
+//        for (int j = 0; j < network->hidden_amount + 1; ++j) {
+//            Matrix* average_delta_weight = scale(batch_weights[j], (1.0 / batch_size));
+//            apply_weights(network, average_delta_weight, j);
+//
+//            matrix_free(average_delta_weight);
+//            matrix_free(batch_weights[j]);
+//        }
+//    }
+//}
 
-    for (int i = 0; i < amount; ++i) {
+void train_network(Neural_Network* network, Image *image, int label) {
-
-        Matrix* batch_weights[network->hidden_amount + 1];
-
-        for (int j = 0; j < batch_size; ++j) {
-            Matrix** delta_weights = train_network(network, images[i], images[i]->label);
-
-            for (int k = 0; k < network->hidden_amount + 1; k++) {
-                if(j == 0) {
-                    batch_weights[k] = delta_weights[k];
-                    continue;
-                }
-
-                Matrix* temp_result = add(batch_weights[k], delta_weights[k]);
-
-                matrix_free(batch_weights[k]);
-                matrix_free(delta_weights[k]);
-
-                batch_weights[k] = temp_result;
-            }
-
-            free(delta_weights);
-        }
-
-        for (int j = 0; j < network->hidden_amount + 1; ++j) {
-            Matrix* average_delta_weight = scale(batch_weights[j], (1.0 / batch_size));
-            apply_weights(network, average_delta_weight, j);
-
-            matrix_free(average_delta_weight);
-            matrix_free(batch_weights[j]);
-        }
-    }
-}
-
-Matrix ** train_network(Neural_Network* network, Image *image, int label) {
 
     Matrix* image_data = matrix_flatten(image->pixel_values, 0);
     Matrix* input = matrix_add_bias(image_data);
@@ -258,9 +271,9 @@ Matrix ** train_network(Neural_Network* network, Image *image, int label) {
         matrix_free(output[i]);
     }
 
-//    for (int i = 0; i < network->hidden_amount + 1; ++i) {
+    for (int i = 0; i < network->hidden_amount + 1; ++i) {
-//        matrix_free(delta_weights[i]);
+        matrix_free(delta_weights[i]);
-//    }
+    }
 
     matrix_free(sigmoid_prime);
     matrix_free(wanted_output);
@@ -268,7 +281,7 @@ Matrix ** train_network(Neural_Network* network, Image *image, int label) {
     matrix_free(delta);
     matrix_free(previous_delta);
 
-    return delta_weights;
+//    return delta_weights;
 }
 
 Matrix* calculate_delta_hidden(Matrix* next_layer_delta, Matrix* weights, Matrix* current_layer_output) {

neuronal_network.h

@@ -30,4 +30,4 @@ void batch_train(Neural_Network* network, Image** images, int amount, int batch_
 double measure_network_accuracy(Neural_Network* network, Image** images, int amount);
 Matrix* predict_image(Neural_Network* network, Image* image);
 
-Matrix ** train_network(Neural_Network* network, Image *image, int label);
+void train_network(Neural_Network* network, Image *image, int label);