cleaned up data parsing a lot. probably nothing broken?

Joseph Redmon

2014-11-21 e36182cd8c5dd5c6d0aa1f77cf5cdca87e8bb1f0

 src/data.c

@@ -1,5 +1,4 @@
#include "data.h"
#include "list.h"
#include "utils.h"
#include "image.h"

@@ -11,6 +10,7 @@
{
    char *path;
    FILE *file = fopen(filename, "r");
    if(!file) file_error(filename);
    list *lines = make_list();
    while((path=fgetl(file))){
        list_insert(lines, path);
@@ -19,6 +19,30 @@
    return lines;
}

void fill_truth_detection(char *path, float *truth, int height, int width, int num_height, int num_width, float scale)
{
    int box_height = height/num_height;
    int box_width = width/num_width;
    char *labelpath = find_replace(path, "imgs", "det");
    labelpath = find_replace(labelpath, ".JPEG", ".txt");
    FILE *file = fopen(labelpath, "r");
    int x, y, h, w;
    while(fscanf(file, "%d %d %d %d", &x, &y, &w, &h) == 4){
        int i = x/box_width;
        int j = y/box_height;
        float dh = (float)(x%box_width)/box_height;
        float dw = (float)(y%box_width)/box_width;
        float sh = h/scale;
        float sw = w/scale;
        int index = (i+j*num_width)*5;
        truth[index++] = 1;
        truth[index++] = dh;
        truth[index++] = dw;
        truth[index++] = sh;
        truth[index++] = sw;
    }
}

void fill_truth(char *path, char **labels, int k, float *truth)
{
    int i;
@@ -30,35 +54,66 @@
    }
}

data load_data_image_paths(char **paths, int n, char **labels, int k)
matrix load_image_paths(char **paths, int n, int h, int w)
{
    int i;
    data d;
    d.shallow = 0;
    d.X.rows = n;
    d.X.vals = calloc(d.X.rows, sizeof(float*));
    d.y = make_matrix(n, k);
    matrix X;
    X.rows = n;
    X.vals = calloc(X.rows, sizeof(float*));
    X.cols = 0;

    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]);
        image im = load_image_color(paths[i], h, w);
        X.vals[i] = im.data;
        X.cols = im.h*im.w*im.c;
    }
    return d;
    return X;
}

data load_data_image_pathfile(char *filename, char **labels, int k)
matrix load_labels_paths(char **paths, int n, char **labels, int k)
{
    matrix y = make_matrix(n, k);
    int i;
    for(i = 0; i < n; ++i){
        fill_truth(paths[i], labels, k, y.vals[i]);
    }
    return y;
}

matrix load_labels_detection(char **paths, int n, int height, int width, int num_height, int num_width, float scale)
{
    int k = num_height*num_width*5;
    matrix y = make_matrix(n, k);
    int i;
    for(i = 0; i < n; ++i){
        fill_truth_detection(paths[i], y.vals[i], height, width, num_height, num_width, scale);
    }
    return y;
}

data load_data_image_pathfile(char *filename, char **labels, int k, int h, int w)
{
    list *plist = get_paths(filename);
    char **paths = (char **)list_to_array(plist);
    data d = load_data_image_paths(paths, plist->size, labels, k);
    int n = plist->size;
    data d;
    d.shallow = 0;
    d.X = load_image_paths(paths, n, h, w);
    d.y = load_labels_paths(paths, n, labels, k);
    free_list_contents(plist);
    free_list(plist);
    free(paths);
    return d;
}

char **get_labels(char *filename)
{
    list *plist = get_paths(filename);
    char **labels = (char **)list_to_array(plist);
    free_list(plist);
    return labels;
}

void free_data(data d)
{
    if(!d.shallow){
@@ -70,33 +125,42 @@
    }
}

data load_data_image_pathfile_part(char *filename, int part, int total, char **labels, int k)
data load_data_detection_random(int n, char **paths, int m, char **labels, int h, int w, int nh, int nw, float scale)
{
    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);
    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]);
    }
    data d;
    d.shallow = 0;
    d.X = load_image_paths(random_paths, n, h, w);
    d.y = load_labels_detection(random_paths, n, h, w, nh, nw, scale);
    free(random_paths);
    return d;
}

data load_data_image_pathfile_random(char *filename, int n, char **labels, int k)
data load_data(char **paths, int n, char **labels, int k, int h, int w)
{
    int i;
    list *plist = get_paths(filename);
    char **paths = (char **)list_to_array(plist);
    data d;
    d.shallow = 0;
    d.X = load_image_paths(paths, n, h, w);
    d.y = load_labels_paths(paths, n, labels, k);
    return d;
}

data load_data_random(int n, char **paths, int m, char **labels, int k, int h, int w)
{
    char **random_paths = calloc(n, sizeof(char*));
    int i;
    for(i = 0; i < n; ++i){
        int index = rand()%plist->size;
        int index = rand()%m;
        random_paths[i] = paths[index];
        if(i == 0) printf("%s\n", paths[index]);
    }
    data d = load_data_image_paths(random_paths, n, labels, k);
    free_list_contents(plist);
    free_list(plist);
    free(paths);
    data d = load_data(random_paths, n, labels, k, h, w);
    free(random_paths);
    return d;
}
@@ -118,6 +182,88 @@
    return d;
}

data load_cifar10_data(char *filename)
{
    data d;
    d.shallow = 0;
    long i,j;
    matrix X = make_matrix(10000, 3072);
    matrix y = make_matrix(10000, 10);
    d.X = X;
    d.y = y;

    FILE *fp = fopen(filename, "rb");
    if(!fp) file_error(filename);
    for(i = 0; i < 10000; ++i){
        unsigned char bytes[3073];
        fread(bytes, 1, 3073, fp);
        int class = bytes[0];
        y.vals[i][class] = 1;
        for(j = 0; j < X.cols; ++j){
            X.vals[i][j] = (double)bytes[j+1];
        }
    }
   translate_data_rows(d, -144);
   scale_data_rows(d, 1./128);
   //normalize_data_rows(d);
    fclose(fp);
    return d;
}

void get_random_batch(data d, int n, float *X, float *y)
{
    int j;
    for(j = 0; j < n; ++j){
        int index = rand()%d.X.rows;
        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));
        memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));
    }
}

void get_next_batch(data d, int n, int offset, float *X, float *y)
{
    int j;
    for(j = 0; j < n; ++j){
        int index = offset + j;
        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));
        memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));
    }
}


data load_all_cifar10()
{
    data d;
    d.shallow = 0;
    int i,j,b;
    matrix X = make_matrix(50000, 3072);
    matrix y = make_matrix(50000, 10);
    d.X = X;
    d.y = y;


    for(b = 0; b < 5; ++b){
        char buff[256];
        sprintf(buff, "data/cifar10/data_batch_%d.bin", b+1);
        FILE *fp = fopen(buff, "rb");
        if(!fp) file_error(buff);
        for(i = 0; i < 10000; ++i){
            unsigned char bytes[3073];
            fread(bytes, 1, 3073, fp);
            int class = bytes[0];
            y.vals[i+b*10000][class] = 1;
            for(j = 0; j < X.cols; ++j){
                X.vals[i+b*10000][j] = (double)bytes[j+1];
            }
        }
        fclose(fp);
    }
    //normalize_data_rows(d);
    translate_data_rows(d, -144);
    scale_data_rows(d, 1./128);
    return d;
}

void randomize_data(data d)
{
    int i;
@@ -133,6 +279,22 @@
    }
}

void scale_data_rows(data d, float s)
{
    int i;
    for(i = 0; i < d.X.rows; ++i){
        scale_array(d.X.vals[i], d.X.cols, s);
    }
}

void translate_data_rows(data d, float s)
{
    int i;
    for(i = 0; i < d.X.rows; ++i){
        translate_array(d.X.vals[i], d.X.cols, s);
    }
}

void normalize_data_rows(data d)
{
    int i;