some fixes, some other experiments

Joseph Redmon

2014-12-22 4ab366a805a7678642539465d68ef906b4599aeb

some fixes, some other experiments

 Makefile

@@ -27,7 +27,7 @@
endif
endif
CFLAGS= $(COMMON) $(OPTS)
CFLAGS= $(COMMON) -O0 -g
#CFLAGS= $(COMMON) -O0 -g
LDFLAGS+=`pkg-config --libs opencv` -lm -pthread
VPATH=./src/
EXEC=cnn

 src/axpy.cl

@@ -13,7 +13,7 @@
__kernel void mask(int n, __global float *x, __global float *mask, int mod)
{
    int i = get_global_id(0);
    x[i] = (mask[(i/mod)*mod] || i%mod == 0) ? x[i] : 0;
    x[i] = (i%mod && !mask[(i/mod)*mod]) ? 0 : x[i];
}

__kernel void copy(int N, __global float *X, int OFFX, int INCX, __global float *Y, int OFFY, int INCY)

 src/cnn.c

@@ -31,21 +31,23 @@
    save_network(net, "cfg/trained_imagenet_smaller.cfg");
}

#define AMNT 3
void draw_detection(image im, float *box, int side)
{
    int j;
    int r, c;
    float amount[5] = {0,0,0,0,0};
    float amount[AMNT] = {0};
    for(r = 0; r < side*side; ++r){
        for(j = 0; j < 5; ++j){
            if(box[r*5] > amount[j]) {
                amount[j] = box[r*5];
                break;
        float val = box[r*5];
        for(j = 0; j < AMNT; ++j){
            if(val > amount[j]) {
                float swap = val;
                val = amount[j];
                amount[j] = swap;
            }
        }
    }
    float smallest = amount[0];
    for(j = 1; j < 5; ++j) if(amount[j] < smallest) smallest = amount[j];
    float smallest = amount[AMNT-1];

    for(r = 0; r < side; ++r){
        for(c = 0; c < side; ++c){
@@ -57,9 +59,9 @@
                int x = c*d+box[j+2]*d;
                int h = box[j+3]*256;
                int w = box[j+4]*256;
                printf("%f %f %f %f\n", box[j+1], box[j+2], box[j+3], box[j+4]);
                printf("%d %d %d %d\n", x, y, w, h);
                printf("%d %d %d %d\n", x-w/2, y-h/2, x+w/2, y+h/2);
                //printf("%f %f %f %f\n", box[j+1], box[j+2], box[j+3], box[j+4]);
                //printf("%d %d %d %d\n", x, y, w, h);
                //printf("%d %d %d %d\n", x-w/2, y-h/2, x+w/2, y+h/2);
                draw_box(im, x-w/2, y-h/2, x+w/2, y+h/2);
            }
        }
@@ -87,9 +89,11 @@
        i += 1;
        time=clock();
        data train = load_data_detection_jitter_random(imgs, paths, plist->size, 256, 256, 7, 7, 256);
        /*
        image im = float_to_image(224, 224, 3, train.X.vals[0]);
        draw_detection(im, train.y.vals[0], 7);
        //data train = load_data_detection_random(imgs, paths, plist->size, 224, 224, 7, 7, 256);

/*
        image im = float_to_image(224, 224, 3, train.X.vals[923]);
        draw_detection(im, train.y.vals[923], 7);
        */

        normalize_data_rows(train);
@@ -151,10 +155,10 @@
    //network net = parse_network_cfg("/home/pjreddie/imagenet_backup/alexnet_1270.cfg");
    srand(time(0));
    network net = parse_network_cfg(cfgfile);
    set_learning_network(&net, net.learning_rate, .5, .0005);
    set_learning_network(&net, net.learning_rate/10., .5, .0005);
    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);
    int imgs = 1024;
    int i = 23030;
    int i = 44700;
    char **labels = get_labels("/home/pjreddie/data/imagenet/cls.labels.list");
    list *plist = get_paths("/data/imagenet/cls.train.list");
    char **paths = (char **)list_to_array(plist);
@@ -385,8 +389,8 @@
    data test = load_categorical_data_csv("data/mnist/mnist_test.csv",0,10);
    network net = parse_network_cfg(cfgfile);
    int count = 0;
    int iters = 60000/net.batch + 1;
    while(++count <= 10){
    int iters = 6000/net.batch + 1;
    while(++count <= 100){
        clock_t start = clock(), end;
        normalize_data_rows(train);
        normalize_data_rows(test);

 src/connected_layer.c

@@ -24,15 +24,21 @@
    layer->delta = calloc(batch*outputs, sizeof(float*));

    layer->weight_updates = calloc(inputs*outputs, sizeof(float));
    layer->bias_updates = calloc(outputs, sizeof(float));

    layer->weight_prev = calloc(inputs*outputs, sizeof(float));
    layer->bias_prev = calloc(outputs, sizeof(float));

    layer->weights = calloc(inputs*outputs, sizeof(float));
    layer->biases = calloc(outputs, sizeof(float));


    float scale = 1./sqrt(inputs);
    //scale = .01;
    for(i = 0; i < inputs*outputs; ++i){
        layer->weights[i] = scale*rand_normal();
    }

    layer->bias_updates = calloc(outputs, sizeof(float));
    layer->biases = calloc(outputs, sizeof(float));
    for(i = 0; i < outputs; ++i){
        layer->biases[i] = scale;
    }
@@ -52,6 +58,32 @@
    return layer;
}

void secret_update_connected_layer(connected_layer *layer)
{
    int n = layer->outputs*layer->inputs;
    float dot = dot_cpu(n, layer->weight_updates, 1, layer->weight_prev, 1);
    float mag = sqrt(dot_cpu(n, layer->weight_updates, 1, layer->weight_updates, 1))
                * sqrt(dot_cpu(n, layer->weight_prev, 1, layer->weight_prev, 1));
    float cos = dot/mag;
    if(cos > .3) layer->learning_rate *= 1.1;
    else if (cos < -.3) layer-> learning_rate /= 1.1;

    scal_cpu(n, layer->momentum, layer->weight_prev, 1);
    axpy_cpu(n, 1, layer->weight_updates, 1, layer->weight_prev, 1);
    scal_cpu(n, 0, layer->weight_updates, 1);

    scal_cpu(layer->outputs, layer->momentum, layer->bias_prev, 1);
    axpy_cpu(layer->outputs, 1, layer->bias_updates, 1, layer->bias_prev, 1);
    scal_cpu(layer->outputs, 0, layer->bias_updates, 1);

    //printf("rate:   %f\n", layer->learning_rate);

    axpy_cpu(layer->outputs, layer->learning_rate, layer->bias_prev, 1, layer->biases, 1);

    axpy_cpu(layer->inputs*layer->outputs, -layer->decay, layer->weights, 1, layer->weight_prev, 1);
    axpy_cpu(layer->inputs*layer->outputs, layer->learning_rate, layer->weight_prev, 1, layer->weights, 1);
}

void update_connected_layer(connected_layer layer)
{
    axpy_cpu(layer.outputs, layer.learning_rate, layer.bias_updates, 1, layer.biases, 1);

 src/connected_layer.h

@@ -18,8 +18,8 @@
    float *weight_updates;
    float *bias_updates;

    float *weight_adapt;
    float *bias_adapt;
    float *weight_prev;
    float *bias_prev;

    float *output;
    float *delta;
@@ -38,6 +38,7 @@

} connected_layer;

void secret_update_connected_layer(connected_layer *layer);
connected_layer *make_connected_layer(int batch, int inputs, int outputs, ACTIVATION activation, float learning_rate, float momentum, float decay);

void forward_connected_layer(connected_layer layer, float *input);

 src/data.c

@@ -81,6 +81,18 @@
    return X;
}

char **get_random_paths(char **paths, int n, int m)
{
    char **random_paths = calloc(n, sizeof(char*));
    int i;
    for(i = 0; i < n; ++i){
        int index = rand()%m;
        random_paths[i] = paths[index];
        if(i == 0) printf("%s\n", paths[index]);
    }
    return random_paths;
}

matrix load_labels_paths(char **paths, int n, char **labels, int k)
{
    matrix y = make_matrix(n, k);
@@ -138,13 +150,8 @@

data load_data_detection_jitter_random(int n, char **paths, int m, int h, int w, int nh, int nw, float scale)
{
    char **random_paths = calloc(n, sizeof(char*));
    char **random_paths = get_random_paths(paths, n, m);
    int i;
    for(i = 0; i < n; ++i){
        int index = rand()%m;
        random_paths[i] = paths[index];
        if(i == 0) printf("%s\n", paths[index]);
    }
    data d;
    d.shallow = 0;
    d.X = load_image_paths(random_paths, n, h, w);
@@ -154,10 +161,11 @@
        int dx = rand()%32;
        int dy = rand()%32;
        fill_truth_detection(random_paths[i], d.y.vals[i], 224, 224, nh, nw, scale, dx, dy);

        image a = float_to_image(h, w, 3, d.X.vals[i]);
        jitter_image(a,224,224,dy,dx);
    }
    d.X.cols = 224*224*3;
   // print_matrix(d.y);
    free(random_paths);
    return d;
}
@@ -165,13 +173,7 @@

data load_data_detection_random(int n, char **paths, int m, int h, int w, int nh, int nw, float scale)
{
    char **random_paths = calloc(n, sizeof(char*));
    int i;
    for(i = 0; i < n; ++i){
        int index = rand()%m;
        random_paths[i] = paths[index];
        if(i == 0) printf("%s\n", paths[index]);
    }
    char **random_paths = get_random_paths(paths, n, m);
    data d;
    d.shallow = 0;
    d.X = load_image_paths(random_paths, n, h, w);
@@ -180,18 +182,6 @@
    return d;
}

char **get_random_paths(char **paths, int n, int m)
{
    char **random_paths = calloc(n, sizeof(char*));
    int i;
    for(i = 0; i < n; ++i){
        int index = rand()%m;
        random_paths[i] = paths[index];
        if(i == 0) printf("%s\n", paths[index]);
    }
    return random_paths;
}

data load_data(char **paths, int n, int m, char **labels, int k, int h, int w)
{
    if(m) paths = get_random_paths(paths, n, m);

 src/dropout_layer.c

@@ -80,6 +80,7 @@

void backward_dropout_layer_gpu(dropout_layer layer, cl_mem delta)
{
    if(!delta) return;
    int size = layer.inputs*layer.batch;

    cl_kernel kernel = get_dropout_kernel();

 src/image.c

@@ -39,6 +39,7 @@
            for(j = 0; j < w; ++j){
                int src = j + dw + (i+dh)*a.w + k*a.w*a.h;
                int dst = j + i*w + k*w*h;
                //printf("%d %d\n", src, dst);
                a.data[dst] = a.data[src];
            }
        }

 src/network.c

@@ -103,7 +103,8 @@
        }
        else if(net.types[i] == CONNECTED){
            connected_layer layer = *(connected_layer *)net.layers[i];
            update_connected_layer(layer);
            secret_update_connected_layer((connected_layer *)net.layers[i]);
            //update_connected_layer(layer);
        }
    }
}

 src/network_gpu.c

@@ -195,6 +195,7 @@
    }
    else if(net.types[i] == CONNECTED){
        connected_layer layer = *(connected_layer *)net.layers[i];
        cl_read_array(layer.output_cl, layer.output, layer.outputs*layer.batch);
        return layer.output;
    }
    else if(net.types[i] == MAXPOOL){