New data format

Makefile

@@ -1,5 +1,11 @@
 CC=gcc
-COMMON=-Wall `pkg-config --cflags opencv` -isystem /usr/local/Cellar/opencv/2.4.6.1/include/opencv -isystem /usr/local/Cellar/opencv/2.4.6.1/include
+COMMON=-Wall `pkg-config --cflags opencv`
+UNAME = $(shell uname)
+ifeq ($(UNAME), Darwin)
+COMMON += -isystem /usr/local/Cellar/opencv/2.4.6.1/include/opencv -isystem /usr/local/Cellar/opencv/2.4.6.1/include
+else
+COMMON += -march=native
+endif
 CFLAGS= $(COMMON) -O3 -ffast-math -flto
 #CFLAGS= $(COMMON) -O0 -g 
 LDFLAGS=`pkg-config --libs opencv` -lm

src/connected_layer.c

@@ -69,7 +69,6 @@ void update_connected_layer(connected_layer layer, double step, double momentum,
             int index = i*layer.inputs+j;
             layer.weight_momentum[index] = step*(layer.weight_updates[index] - decay*layer.weights[index]) + momentum*layer.weight_momentum[index];
             layer.weights[index] += layer.weight_momentum[index];
-            //layer.weights[index] = constrain(layer.weights[index], 100.);
         }
     }
     memset(layer.bias_updates, 0, layer.outputs*sizeof(double));

src/convolutional_layer.c

@@ -143,26 +143,22 @@ void learn_convolutional_layer(convolutional_layer layer, double *input)
     for(i = 0; i < layer.n; ++i){
         kernel_update(in_image, layer.kernel_updates[i], layer.stride, i, out_delta, layer.edge);
         layer.bias_updates[i] += avg_image_layer(out_delta, i);
-        //printf("%30.20lf\n", layer.bias_updates[i]);
     }
 }
 
 void update_convolutional_layer(convolutional_layer layer, double step, double momentum, double decay)
 {
-    //step = .01;
     int i,j;
     for(i = 0; i < layer.n; ++i){
         layer.bias_momentum[i] = step*(layer.bias_updates[i]) 
                                 + momentum*layer.bias_momentum[i];
         layer.biases[i] += layer.bias_momentum[i];
-        //layer.biases[i] = constrain(layer.biases[i],1.);
         layer.bias_updates[i] = 0;
         int pixels = layer.kernels[i].h*layer.kernels[i].w*layer.kernels[i].c;
         for(j = 0; j < pixels; ++j){
             layer.kernel_momentum[i].data[j] = step*(layer.kernel_updates[i].data[j] - decay*layer.kernels[i].data[j]) 
                                                 + momentum*layer.kernel_momentum[i].data[j];
             layer.kernels[i].data[j] += layer.kernel_momentum[i].data[j];
-            //layer.kernels[i].data[j] = constrain(layer.kernels[i].data[j], 1.);
         }
         zero_image(layer.kernel_updates[i]);
     }
@@ -188,14 +184,6 @@ void visualize_convolutional_filters(convolutional_layer layer, char *window)
         int w_offset = i*(size+border);
         image k = layer.kernels[i];
         image copy = copy_image(k);
-        /*
-        printf("Kernel %d - Bias: %f, Channels:",i,layer.biases[i]);
-        for(j = 0; j < k.c; ++j){
-            double a = avg_image_layer(k, j);
-            printf("%f, ", a);
-        }
-        printf("\n");
-        */
         normalize_image(copy);
         for(j = 0; j < k.c; ++j){
             set_pixel(copy,0,0,j,layer.biases[i]);
@@ -227,7 +215,6 @@ void visualize_convolutional_layer(convolutional_layer layer)
 {
     int i;
     char buff[256];
-    //image vis = make_image(layer.n*layer.size, layer.size*layer.kernels[0].c, 3);
     for(i = 0; i < layer.n; ++i){
         image k = layer.kernels[i];
         sprintf(buff, "Kernel %d", i);

src/data.c

@@ -1,23 +1,12 @@
 #include "data.h"
 #include "list.h"
 #include "utils.h"
+#include "image.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-batch make_batch(int n, int k)
-{
-    batch b;
-    b.n = n;
-    if(k < 3) k = 1;
-    b.images = calloc(n, sizeof(image));
-    b.truth = calloc(n, sizeof(double *));
-    int i;
-    for(i =0 ; i < n; ++i) b.truth[i] = calloc(k, sizeof(double));
-    return b;
-}
-
 list *get_paths(char *filename)
 {
     char *path;
@@ -41,75 +30,145 @@ void fill_truth(char *path, char **labels, int k, double *truth)
     }
 }
 
-batch load_list(list *paths, char **labels, int k)
+data load_data_image_paths(char **paths, int n, char **labels, int k)
-{
-    char *path;
-    batch data = make_batch(paths->size, 2);
-    node *n = paths->front;
-    int i;
-    for(i = 0; i < data.n; ++i){
-        path = (char *)n->val;
-        data.images[i] = load_image(path);
-        fill_truth(path, labels, k, data.truth[i]);
-        n = n->next;
-    }
-    return data;
-}
-
-batch get_all_data(char *filename, char **labels, int k)
-{
-    list *paths = get_paths(filename);
-    batch b = load_list(paths, labels, k);
-    free_list_contents(paths);
-    free_list(paths);
-    return b;
-}
-
-void free_batch(batch b)
 {
     int i;
-    for(i = 0; i < b.n; ++i){
+    data d;
-        free_image(b.images[i]);
+    d.shallow = 0;
-        free(b.truth[i]);
+    d.X.rows = n;
+    d.X.vals = calloc(d.X.rows, sizeof(double*));
+    d.y = make_matrix(n, k);
+
+    for(i = 0; i < n; ++i){
+        image im = load_image(paths[i]);
+        d.X.vals[i] = im.data;
+        d.X.cols = im.h*im.w*im.c;
+        fill_truth(paths[i], labels, k, d.y.vals[i]);
     }
-    free(b.images);
+    return d;
-    free(b.truth);
 }
 
-batch get_batch(char *filename, int curr, int total, char **labels, int k)
+data load_data_image_pathfile(char *filename, char **labels, int k)
 {
     list *plist = get_paths(filename);
     char **paths = (char **)list_to_array(plist);
-    int i;
+    data d = load_data_image_paths(paths, plist->size, labels, k);
-    int start = curr*plist->size/total;
-    int end = (curr+1)*plist->size/total;
-    batch b = make_batch(end-start, 2);
-    for(i = start; i < end; ++i){
-        b.images[i-start] = load_image(paths[i]);
-        fill_truth(paths[i], labels, k, b.truth[i-start]);
-    }
     free_list_contents(plist);
     free_list(plist);
     free(paths);
-    return b;
+    return d;
 }
 
-batch random_batch(char *filename, int n, char **labels, int k)
+void free_data(data d)
+{
+    if(!d.shallow){
+        free_matrix(d.X);
+        free_matrix(d.y);
+    }else{
+        free(d.X.vals);
+        free(d.y.vals);
+    }
+}
+
+data load_data_image_pathfile_part(char *filename, int part, int total, char **labels, int k)
 {
     list *plist = get_paths(filename);
     char **paths = (char **)list_to_array(plist);
+    int start = part*plist->size/total;
+    int end = (part+1)*plist->size/total;
+    data d = load_data_image_paths(paths+start, end-start, labels, k);
+    free_list_contents(plist);
+    free_list(plist);
+    free(paths);
+    return d;
+}
+
+data load_data_image_pathfile_random(char *filename, int n, char **labels, int k)
+{
     int i;
-    batch b = make_batch(n, 2);
+    list *plist = get_paths(filename);
+    char **paths = (char **)list_to_array(plist);
+    char **random_paths = calloc(n, sizeof(char*));
     for(i = 0; i < n; ++i){
         int index = rand()%plist->size;
-        b.images[i] = load_image(paths[index]);
+        random_paths[i] = paths[index];
-        //scale_image(b.images[i], 1./255.);
-        z_normalize_image(b.images[i]);
-        fill_truth(paths[index], labels, k, b.truth[i]);
-        //print_image(b.images[i]);
     }
+    data d = load_data_image_paths(random_paths, n, labels, k);
     free_list_contents(plist);
     free_list(plist);
     free(paths);
-    return b;
+    free(random_paths);
+    return d;
 }
+
+data load_categorical_data_csv(char *filename, int target, int k)
+{
+    data d;
+    d.shallow = 0;
+    matrix X = csv_to_matrix(filename);
+    double *truth_1d = pop_column(&X, target);
+    double **truth = one_hot_encode(truth_1d, X.rows, k);
+    matrix y;
+    y.rows = X.rows;
+    y.cols = k;
+    y.vals = truth;
+    d.X = X;
+    d.y = y;
+    free(truth_1d);
+    return d;
+}
+
+void randomize_data(data d)
+{
+    int i;
+    for(i = d.X.rows-1; i > 0; --i){
+        int index = rand()%i;
+        double *swap = d.X.vals[index];
+        d.X.vals[index] = d.X.vals[i];
+        d.X.vals[i] = swap;
+
+        swap = d.y.vals[index];
+        d.y.vals[index] = d.y.vals[i];
+        d.y.vals[i] = swap;
+    }
+}
+
+void normalize_data_rows(data d)
+{
+    int i;
+    for(i = 0; i < d.X.rows; ++i){
+        normalize_array(d.X.vals[i], d.X.cols);
+    }
+}
+
+data *cv_split_data(data d, int part, int total)
+{
+    data *split = calloc(2, sizeof(data));
+    int i;
+    int start = part*d.X.rows/total;
+    int end = (part+1)*d.X.rows/total;
+    data train;
+    data test;
+    train.shallow = test.shallow = 1;
+
+    test.X.rows = test.y.rows = end-start;
+    train.X.rows = train.y.rows = d.X.rows - (end-start);
+    train.X.cols = test.X.cols = d.X.cols;
+    train.y.cols = test.y.cols = d.y.cols;
+    for(i = 0; i < start; ++i){
+        train.X.vals[i] = d.X.vals[i];
+        train.y.vals[i] = d.y.vals[i];
+    }
+    for(i = start; i < end; ++i){
+        test.X.vals[i-start] = d.X.vals[i];
+        test.y.vals[i-start] = d.y.vals[i];
+    }
+    for(i = end; i < d.X.rows; ++i){
+        train.X.vals[i-(start-end)] = d.X.vals[i];
+        train.y.vals[i-(start-end)] = d.y.vals[i];
+    }
+    split[0] = train;
+    split[1] = test;
+    return split;
+}
+

src/data.h

@@ -1,18 +1,24 @@
 #ifndef DATA_H
 #define DATA_H
 
-#include "image.h"
+#include "matrix.h"
 
 typedef struct{
-    int n;
+    matrix X;
-    image *images;
+    matrix y;
-    double **truth;
+    int shallow;
-} batch;
+} data;
 
-batch get_all_data(char *filename, char **labels, int k);
-batch random_batch(char *filename, int n, char **labels, int k);
-batch get_batch(char *filename, int curr, int total, char **labels, int k);
-void free_batch(batch b);
 
+data load_data_image_pathfile(char *filename, char **labels, int k);
+void free_data(data d);
+data load_data_image_pathfile(char *filename, char **labels, int k);
+data load_data_image_pathfile_part(char *filename, int part, int total, 
+                                                char **labels, int k);
+data load_data_image_pathfile_random(char *filename, int n, char **labels, int k);
+data load_categorical_data_csv(char *filename, int target, int k);
+void normalize_data_rows(data d);
+void randomize_data(data d);
+data *cv_split_data(data d, int part, int total);
 
 #endif

src/matrix.c

@@ -13,6 +13,17 @@ void free_matrix(matrix m)
     free(m.vals);
 }
 
+void matrix_add_matrix(matrix from, matrix to)
+{
+    assert(from.rows == to.rows && from.cols == to.cols);
+    int i,j;
+    for(i = 0; i < from.rows; ++i){
+        for(j = 0; j < from.cols; ++j){
+            to.vals[i][j] += from.vals[i][j];
+        }
+    }
+}
+
 matrix make_matrix(int rows, int cols)
 {
     matrix m;

src/network.c

@@ -15,6 +15,8 @@ network make_network(int n)
     net.n = n;
     net.layers = calloc(net.n, sizeof(void *));
     net.types = calloc(net.n, sizeof(LAYER_TYPE));
+    net.outputs = 0;
+    net.output = 0;
     return net;
 }
 
@@ -45,13 +47,13 @@ void forward_network(network net, double *input)
     }
 }
 
-void update_network(network net, double step)
+void update_network(network net, double step, double momentum, double decay)
 {
     int i;
     for(i = 0; i < net.n; ++i){
         if(net.types[i] == CONVOLUTIONAL){
             convolutional_layer layer = *(convolutional_layer *)net.layers[i];
-            update_convolutional_layer(layer, step, 0.9, .01);
+            update_convolutional_layer(layer, step, momentum, decay);
         }
         else if(net.types[i] == MAXPOOL){
             //maxpool_layer layer = *(maxpool_layer *)net.layers[i];
@@ -61,7 +63,7 @@ void update_network(network net, double step)
         }
         else if(net.types[i] == CONNECTED){
             connected_layer layer = *(connected_layer *)net.layers[i];
-            update_connected_layer(layer, step, .9, 0);
+            update_connected_layer(layer, step, momentum, decay);
         }
     }
 }
@@ -111,8 +113,26 @@ double *get_network_delta(network net)
     return get_network_delta_layer(net, net.n-1);
 }
 
-void learn_network(network net, double *input)
+void calculate_error_network(network net, double *truth)
 {
+    double *delta = get_network_delta(net);
+    double *out = get_network_output(net);
+    int i, k = get_network_output_size(net);
+    for(i = 0; i < k; ++i){
+        delta[i] = truth[i] - out[i];
+    }
+}
+
+int get_predicted_class_network(network net)
+{
+    double *out = get_network_output(net);
+    int k = get_network_output_size(net);
+    return max_index(out, k);
+}
+
+void backward_network(network net, double *input, double *truth)
+{
+    calculate_error_network(net, truth);
     int i;
     double *prev_input;
     double *prev_delta;
@@ -145,40 +165,43 @@ void learn_network(network net, double *input)
     }
 }
 
-void train_network_batch(network net, batch b)
+int train_network_datum(network net, double *x, double *y, double step, double momentum, double decay)
 {
-    int i,j;
+        forward_network(net, x);
-    int k = get_network_output_size(net);
+        int class = get_predicted_class_network(net);
+        backward_network(net, x, y);
+        update_network(net, step, momentum, decay);
+        return (y[class]?1:0);
+}
+
+double train_network_sgd(network net, data d, double step, double momentum,double decay)
+{
+    int i;
     int correct = 0;
-    for(i = 0; i < b.n; ++i){
+    for(i = 0; i < d.X.rows; ++i){
-        show_image(b.images[i], "Input");
+        int index = rand()%d.X.rows;
-        forward_network(net, b.images[i].data);
+        correct += train_network_datum(net, d.X.vals[index], d.y.vals[index], step, momentum, decay);
-        image o = get_network_image(net);
+        if((i+1)%10 == 0){
-        if(o.h) show_image_collapsed(o, "Output");
+            printf("%d: %f\n", (i+1), (double)correct/(i+1));
-        double *output = get_network_output(net);
-        double *delta = get_network_delta(net);
-        int max_k = 0;
-        double max = 0;
-        for(j = 0; j < k; ++j){
-            delta[j] = b.truth[i][j]-output[j];
-            if(output[j] > max) {
-                max = output[j];
-                max_k = j;
-            }
         }
-        if(b.truth[i][max_k]) ++correct;
+    }
-        printf("%f\n", (double)correct/(i+1));
+    return (double)correct/d.X.rows;
-        learn_network(net, b.images[i].data);
+}
-        update_network(net, .001);
+
+void train_network(network net, data d, double step, double momentum, double decay)
+{
+    int i;
+    int correct = 0;
+    for(i = 0; i < d.X.rows; ++i){
+        correct += train_network_datum(net, d.X.vals[i], d.y.vals[i], step, momentum, decay);
         if(i%100 == 0){
             visualize_network(net);
-            cvWaitKey(100);
+            cvWaitKey(10);
         }
     }
     visualize_network(net);
-    print_network(net);
     cvWaitKey(100);
-    printf("Accuracy: %f\n", (double)correct/b.n);
+    printf("Accuracy: %f\n", (double)correct/d.X.rows);
 }
 
 int get_network_output_size_layer(network net, int i)
@@ -250,7 +273,7 @@ void print_network(network net)
 {
     int i,j;
     for(i = 0; i < net.n; ++i){
-        double *output;
+        double *output = 0;
         int n = 0;
         if(net.types[i] == CONVOLUTIONAL){
             convolutional_layer layer = *(convolutional_layer *)net.layers[i];
@@ -283,3 +306,17 @@ void print_network(network net)
         fprintf(stderr, "\n");
     }
 }
+double network_accuracy(network net, data d)
+{
+    int i;
+    int correct = 0;
+    int k = get_network_output_size(net);
+    for(i = 0; i < d.X.rows; ++i){
+        forward_network(net, d.X.vals[i]);
+        double *out = get_network_output(net);
+        int guess = max_index(out, k);
+        if(d.y.vals[i][guess]) ++correct;
+    }
+    return (double)correct/d.X.rows;
+}
+

src/network.h

@@ -16,13 +16,17 @@ typedef struct {
     int n;
     void **layers;
     LAYER_TYPE *types;
+    int outputs;
+    double *output;
 } network;
 
 network make_network(int n);
 void forward_network(network net, double *input);
-void learn_network(network net, double *input);
+void backward_network(network net, double *input, double *truth);
-void update_network(network net, double step);
+void update_network(network net, double step, double momentum, double decay);
-void train_network_batch(network net, batch b);
+double train_network_sgd(network net, data d, double step, double momentum,double decay);
+void train_network(network net, data d, double step, double momentum, double decay);
+double network_accuracy(network net, data d);
 double *get_network_output(network net);
 double *get_network_output_layer(network net, int i);
 double *get_network_delta_layer(network net, int i);
@@ -31,6 +35,7 @@ int get_network_output_size_layer(network net, int i);
 int get_network_output_size(network net);
 image get_network_image(network net);
 image get_network_image_layer(network net, int i);
+int get_predicted_class_network(network net);
 void print_network(network net);
 void visualize_network(network net);
 

src/parser.c

@@ -107,6 +107,8 @@ network parse_network_cfg(char *filename)
         ++count;
         n = n->next;
     }   
+    net.outputs = get_network_output_size(net);
+    net.output = get_network_output(net);
     return net;
 }
 

src/tests.c

@@ -166,19 +166,16 @@ void test_parser()
         avgerr = .99 * avgerr + .01 * err;
         if(count % 1000000 == 0) printf("%f %f :%f AVG %f \n", truth, out[0], err, avgerr);
         delta[0] = truth - out[0];
-        learn_network(net, input);
+        backward_network(net, input, &truth);
-        update_network(net, .001);
+        update_network(net, .001,0,0);
     }
 }
 
 void test_data()
 {
     char *labels[] = {"cat","dog"};
-    batch train = random_batch("train_paths.txt", 101,labels, 2);
+    data train = load_data_image_pathfile_random("train_paths.txt", 101,labels, 2);
-    show_image(train.images[0], "Test Data Loading");
+    free_data(train);
-    show_image(train.images[100], "Test Data Loading");
-    show_image(train.images[10], "Test Data Loading");
-    free_batch(train);
 }
 
 void test_full()
@@ -188,110 +185,37 @@ void test_full()
     int i = 0;
     char *labels[] = {"cat","dog"};
     while(i++ < 1000 || 1){
-        batch train = random_batch("train_paths.txt", 1000, labels, 2);
+        data train = load_data_image_pathfile_random("train_paths.txt", 1000, labels, 2);
-        train_network_batch(net, train);
+        train_network(net, train, .0005, 0, 0);
-        free_batch(train);
+        free_data(train);
         printf("Round %d\n", i);
     }
 }
 
-double error_network(network net, matrix m, double **truth)
-{
-    int i;
-    int correct = 0;
-    int k = get_network_output_size(net);
-    for(i = 0; i < m.rows; ++i){
-        forward_network(net, m.vals[i]);
-        double *out = get_network_output(net);
-        int guess = max_index(out, k);
-        if(truth[i][guess]) ++correct;
-    }
-    return (double)correct/m.rows;
-}
-
-double **one_hot(double *a, int n, int k)
-{
-    int i;
-    double **t = calloc(n, sizeof(double*));
-    for(i = 0; i < n; ++i){
-        t[i] = calloc(k, sizeof(double));
-        int index = (int)a[i];
-        t[i][index] = 1;
-    }
-    return t;
-}
-
 void test_nist()
 {
-    srand(999999);
+    srand(444444);
     network net = parse_network_cfg("nist.cfg");
-    matrix m = csv_to_matrix("mnist/mnist_train.csv");
+    data train = load_categorical_data_csv("mnist/mnist_train.csv", 0, 10);
-    matrix test = csv_to_matrix("mnist/mnist_test.csv");
+    data test = load_categorical_data_csv("mnist/mnist_test.csv",0,10);
-    double *truth_1d = pop_column(&m, 0);
+    normalize_data_rows(train);
-    double **truth = one_hot(truth_1d, m.rows, 10);
+    normalize_data_rows(test);
-    double *test_truth_1d = pop_column(&test, 0);
+    randomize_data(train);
-    double **test_truth = one_hot(test_truth_1d, test.rows, 10);
-    int i,j;
-    clock_t start = clock(), end;
-    for(i = 0; i < test.rows; ++i){
-        normalize_array(test.vals[i], 28*28);
-        //scale_array(m.vals[i], 28*28, 1./255.);
-        //translate_array(m.vals[i], 28*28, -.1);
-    }
-    for(i = 0; i < m.rows; ++i){
-        normalize_array(m.vals[i], 28*28);
-        //scale_array(m.vals[i], 28*28, 1./255.);
-        //translate_array(m.vals[i], 28*28, -.1);
-    }
     int count = 0;
     double lr = .0005;
-    while(++count <= 300){
+    while(++count <= 1){
-        //lr *= .99;
+        double acc = train_network_sgd(net, train, lr, .9, .001);
-        int index = 0;
+        printf("Training Accuracy: %lf", acc);
-        int correct = 0;
+        lr /= 2; 
-        int number = 1000;
-        for(i = 0; i < number; ++i){
-            index = rand()%m.rows;
-            forward_network(net, m.vals[index]);
-            double *out = get_network_output(net);
-            double *delta = get_network_delta(net);
-            int max_i = 0;
-            double max = out[0];
-            for(j = 0; j < 10; ++j){
-                delta[j] = truth[index][j]-out[j];
-                if(out[j] > max){
-                    max = out[j];
-                    max_i = j;
-                }
-            }
-            if(truth[index][max_i]) ++correct;
-            learn_network(net, m.vals[index]);
-            update_network(net, lr);
-        }
-        print_network(net);
-        image input = double_to_image(28,28,1, m.vals[index]);
-        //show_image(input, "Input");
-        image o = get_network_image(net);
-        //show_image_collapsed(o, "Output");
-        visualize_network(net);
-        cvWaitKey(10);
-        //double test_acc = error_network(net, m, truth);
-        fprintf(stderr, "\n%5d: %f %f\n\n",count, (double)correct/number, lr);
-        if(count % 10 == 0 && 0){
-            double train_acc = error_network(net, m, truth);
-            fprintf(stderr, "\nTRAIN: %f\n", train_acc);
-            double test_acc = error_network(net, test, test_truth);
-            fprintf(stderr, "TEST: %f\n\n", test_acc);
-            printf("%d, %f, %f\n", count, train_acc, test_acc);
-        }
-        if(count % (m.rows/number) == 0) lr /= 2; 
     }
-            double train_acc = error_network(net, m, truth);
+    /*
-            fprintf(stderr, "\nTRAIN: %f\n", train_acc);
+    double train_acc = network_accuracy(net, train);
-            double test_acc = error_network(net, test, test_truth);
+    fprintf(stderr, "\nTRAIN: %f\n", train_acc);
-            fprintf(stderr, "TEST: %f\n\n", test_acc);
+    double test_acc = network_accuracy(net, test);
-            printf("%d, %f, %f\n", count, train_acc, test_acc);
+    fprintf(stderr, "TEST: %f\n\n", test_acc);
-    end = clock();
+    printf("%d, %f, %f\n", count, train_acc, test_acc);
+    */
+    //end = clock();
     //printf("Neural Net Learning: %lf seconds\n", (double)(end-start)/CLOCKS_PER_SEC);
 }
 
@@ -315,9 +239,9 @@ void test_random_classify()
 {
     network net = parse_network_cfg("connected.cfg");
     matrix m = csv_to_matrix("train.csv");
-    matrix ho = hold_out_matrix(&m, 2500);
+    //matrix ho = hold_out_matrix(&m, 2500);
     double *truth = pop_column(&m, 0);
-    double *ho_truth = pop_column(&ho, 0);
+    //double *ho_truth = pop_column(&ho, 0);
     int i;
     clock_t start = clock(), end;
     int count = 0;
@@ -333,8 +257,8 @@ void test_random_classify()
             delta[0] = truth[index] - out[0];
             // printf("%f\n", delta[0]);
             //printf("%f %f\n", truth[index], out[0]);
-            learn_network(net, m.vals[index]);
+            //backward_network(net, m.vals[index], );
-            update_network(net, .00001);
+            update_network(net, .00001, 0,0);
         }
         //double test_acc = error_network(net, m, truth);
         //double valid_acc = error_network(net, ho, ho_truth);
@@ -356,33 +280,19 @@ void test_random_classify()
     printf("Neural Net Learning: %lf seconds\n", (double)(end-start)/CLOCKS_PER_SEC);
 }
 
-void test_random_preprocess()
+void test_split()
 {
-    FILE *file = fopen("train.csv", "w");
+    data train = load_categorical_data_csv("mnist/mnist_train.csv", 0, 10);
-    char *labels[] = {"cat","dog"};
+    data *split = cv_split_data(train, 0, 13);
-    int i,j,k;
+    printf("%d, %d, %d\n", train.X.rows, split[0].X.rows, split[1].X.rows);
-    srand(0);
-    network net = parse_network_cfg("convolutional.cfg");
-    for(i = 0; i < 100; ++i){
-        printf("%d\n", i);
-        batch part = get_batch("train_paths.txt", i, 100, labels, 2);
-        for(j = 0; j < part.n; ++j){
-            forward_network(net, part.images[j].data);
-            double *out = get_network_output(net);
-            fprintf(file, "%f", part.truth[j][0]);
-            for(k = 0; k < get_network_output_size(net); ++k){
-                fprintf(file, ",%f", out[k]);
-            }
-            fprintf(file, "\n");
-        }
-        free_batch(part);
-    }
 }
 
+
 int main()
 {
     //test_kernel_update();
-    test_nist();
+    test_split();
+   // test_nist();
     //test_full();
     //test_random_preprocess();
     //test_random_classify();

src/utils.c

@@ -216,3 +216,16 @@ double rand_normal()
     for(i = 0; i < 12; ++i) sum += (double)rand()/RAND_MAX;
     return sum-6.;
 }
+
+double **one_hot_encode(double *a, int n, int k)
+{
+    int i;
+    double **t = calloc(n, sizeof(double*));
+    for(i = 0; i < n; ++i){
+        t[i] = calloc(k, sizeof(double));
+        int index = (int)a[i];
+        t[i][index] = 1;
+    }
+    return t;
+}
+

src/utils.h

@@ -22,5 +22,6 @@ double constrain(double a, double max);
 double rand_normal();
 double mean_array(double *a, int n);
 double variance_array(double *a, int n);
+double **one_hot_encode(double *a, int n, int k);
 #endif