Attempt at visualizing ImageNet Features

Joseph Redmon

2014-04-11 cc06817efa24f20811ef6b32143c6700a91c5f2a

 src/tests.c

@@ -77,7 +77,7 @@
    int size = 3;
    float eps = .00000001;
    image test = make_random_image(5,5, 1);
    convolutional_layer layer = *make_convolutional_layer(test.h,test.w,test.c, n, size, stride, RELU);
    convolutional_layer layer = *make_convolutional_layer(1,test.h,test.w,test.c, n, size, stride, RELU);
    image out = get_convolutional_image(layer);
    float **jacobian = calloc(test.h*test.w*test.c, sizeof(float));
    
@@ -188,70 +188,151 @@
    free_data(train);
}

void test_full()
void train_full()
{
    network net = parse_network_cfg("full.cfg");
    network net = parse_network_cfg("cfg/imagenet.cfg");
    srand(2222222);
    int i = 800;
    int i = 0;
    char *labels[] = {"cat","dog"};
    float lr = .00001;
    float momentum = .9;
    float decay = 0.01;
    while(i++ < 1000 || 1){
        visualize_network(net);
        cvWaitKey(100);
        data train = load_data_image_pathfile_random("train_paths.txt", 1000, labels, 2, 256, 256);
        image im = float_to_image(256, 256, 3,train.X.vals[0]);
        show_image(im, "input");
        cvWaitKey(100);
    while(1){
        i += 1000;
        data train = load_data_image_pathfile_random("images/assira/train.list", 1000, labels, 2, 256, 256);
        //image im = float_to_image(256, 256, 3,train.X.vals[0]);
        //visualize_network(net);
        //cvWaitKey(100);
        //show_image(im, "input");
        //cvWaitKey(100);
        //scale_data_rows(train, 1./255.);
        normalize_data_rows(train);
        clock_t start = clock(), end;
        float loss = train_network_sgd(net, train, 100, lr, momentum, decay);
        float loss = train_network_sgd(net, train, 1000, lr, momentum, decay);
        end = clock();
        printf("%d: %f, Time: %lf seconds, LR: %f, Momentum: %f, Decay: %f\n", i, loss, (float)(end-start)/CLOCKS_PER_SEC, lr, momentum, decay);
        free_data(train);
        if(i%100==0){
        if(i%10000==0){
            char buff[256];
            sprintf(buff, "backup_%d.cfg", i);
            //save_network(net, buff);
            sprintf(buff, "cfg/assira_backup_%d.cfg", i);
            save_network(net, buff);
        }
        //lr *= .99;
    }
}

void test_visualize()
{
    network net = parse_network_cfg("cfg/imagenet.cfg");
    srand(2222222);
    visualize_network(net);
    cvWaitKey(0);
}
void test_full()
{
    network net = parse_network_cfg("cfg/backup_1300.cfg");
    srand(2222222);
    int i,j;
    int total = 100;
    char *labels[] = {"cat","dog"};
    FILE *fp = fopen("preds.txt","w");
    for(i = 0; i < total; ++i){
        visualize_network(net);
        cvWaitKey(100);
        data test = load_data_image_pathfile_part("images/assira/test.list", i, total, labels, 2, 256, 256);
        image im = float_to_image(256, 256, 3,test.X.vals[0]);
        show_image(im, "input");
        cvWaitKey(100);
        normalize_data_rows(test);
        for(j = 0; j < test.X.rows; ++j){
            float *x = test.X.vals[j];
            forward_network(net, x);
            int class = get_predicted_class_network(net);
            fprintf(fp, "%d\n", class);
        }
        free_data(test);
    }
    fclose(fp);
}

void test_cifar10()
{
    data test = load_cifar10_data("images/cifar10/test_batch.bin");
    scale_data_rows(test, 1./255);
    network net = parse_network_cfg("cfg/cifar10.cfg");
    int count = 0;
    float lr = .000005;
    float momentum = .99;
    float decay = 0.001;
    decay = 0;
    int batch = 10000;
    while(++count <= 10000){
        char buff[256];
        sprintf(buff, "images/cifar10/data_batch_%d.bin", rand()%5+1);
        data train = load_cifar10_data(buff);
        scale_data_rows(train, 1./255);
        train_network_sgd(net, train, batch, lr, momentum, decay);
        //printf("%5f %5f\n",(double)count*batch/train.X.rows, loss);

        float test_acc = network_accuracy(net, test);
        printf("%5f %5f\n",(double)count*batch/train.X.rows/5, 1-test_acc);
        free_data(train);
    }

}

void test_vince()
{
    network net = parse_network_cfg("cfg/vince.cfg");
    data train = load_categorical_data_csv("images/vince.txt", 144, 2);
    normalize_data_rows(train);

    int count = 0;
    float lr = .00005;
    float momentum = .9;
    float decay = 0.0001;
    decay = 0;
    int batch = 10000;
    while(++count <= 10000){
        float loss = train_network_sgd(net, train, batch, lr, momentum, decay);
        printf("%5f %5f\n",(double)count*batch/train.X.rows, loss);
    }
}

void test_nist()
{
    srand(444444);
    srand(888888);
    network net = parse_network_cfg("nist.cfg");
    network net = parse_network_cfg("cfg/nist_basic.cfg");
    data train = load_categorical_data_csv("mnist/mnist_train.csv", 0, 10);
    data test = load_categorical_data_csv("mnist/mnist_test.csv",0,10);
    normalize_data_rows(train);
    normalize_data_rows(test);
    //randomize_data(train);
    int count = 0;
    float lr = .0005;
    float lr = .00005;
    float momentum = .9;
    float decay = 0.001;
    clock_t start = clock(), end;
    while(++count <= 100){
        //visualize_network(net);
        float loss = train_network_sgd(net, train, 1000, lr, momentum, decay);
        printf("%5d Training Loss: %lf, Params: %f %f %f, ",count*100, loss, lr, momentum, decay);
        end = clock();
        printf("Time: %lf seconds\n", (float)(end-start)/CLOCKS_PER_SEC);
        start=end;
        //cvWaitKey(100);
        //lr /= 2; 
        if(count%5 == 0){
            float train_acc = network_accuracy(net, train);
            fprintf(stderr, "\nTRAIN: %f\n", train_acc);
            float test_acc = network_accuracy(net, test);
            fprintf(stderr, "TEST: %f\n\n", test_acc);
            printf("%d, %f, %f\n", count, train_acc, test_acc);
            //lr *= .5;
    float decay = 0.0001;
    decay = 0;
    //clock_t start = clock(), end;
    int batch = 10000;
    while(++count <= 10000){
        float loss = train_network_sgd(net, train, batch, lr, momentum, decay);
        printf("%5f %5f\n",(double)count*batch/train.X.rows, loss);
        //printf("%5d Training Loss: %lf, Params: %f %f %f, ",count*1000, loss, lr, momentum, decay);
        //end = clock();
        //printf("Time: %lf seconds\n", (float)(end-start)/CLOCKS_PER_SEC);
        //start=end;
        /*
           if(count%5 == 0){
           float train_acc = network_accuracy(net, train);
           fprintf(stderr, "\nTRAIN: %f\n", train_acc);
           float test_acc = network_accuracy(net, test);
           fprintf(stderr, "TEST: %f\n\n", test_acc);
           printf("%d, %f, %f\n", count, train_acc, test_acc);
        //lr *= .5;
        }
         */
    }
}

@@ -400,6 +481,7 @@
{
    x = x-1+3;
    x = x-1+3;
    x = x-1+3;
    x = (x-1)*2+1;
    x = x-1+5;
    x = (x-1)*2+1;
@@ -411,100 +493,87 @@
{
    int h = voc_size(outh);
    int w = voc_size(outw);
    fprintf(stderr, "%d %d\n", h, w);

    IplImage *sized = cvCreateImage(cvSize(w,h), src->depth, src->nChannels);
    cvResize(src, sized, CV_INTER_LINEAR);
    image im = ipl_to_image(sized);
    reset_network_size(net, im.h, im.w, im.c);
    resize_network(net, im.h, im.w, im.c);
    forward_network(net, im.data);
    image out = get_network_image_layer(net, 5);
    //printf("%d %d\n%d %d\n", outh, out.h, outw, out.w);
    image out = get_network_image_layer(net, 6);
    free_image(im);
    cvReleaseImage(&sized);
    return copy_image(out);
}

void features_VOC(int part, int total)
void features_VOC_image_size(char *image_path, int h, int w)
{
    int i,j, count = 0;
    network net = parse_network_cfg("cfg/voc_features.cfg");
    char *path_file = "images/VOC2012/all_paths.txt";
    char *out_dir = "voc_features/";
    list *paths = get_paths(path_file);
    node *n = paths->front;
    int size = paths->size;
    for(count = 0; count < part*size/total; ++count) n = n->next;
    while(n && count++ < (part+1)*size/total){
        char *path = (char *)n->val;
        char buff[1024];
        sprintf(buff, "%s%s.txt",out_dir, path);
        printf("%s\n", path);
        FILE *fp = fopen(buff, "w");
        if(fp == 0) file_error(buff);
    int j;
    network net = parse_network_cfg("cfg/voc_imagenet.cfg");
    fprintf(stderr, "%s\n", image_path);

        IplImage* src = 0;
        if( (src = cvLoadImage(path,-1)) == 0 )
        {
            printf("Cannot load file image %s\n", path);
            exit(0);
        }
        int w = src->width;
        int h = src->height;
        int sbin = 8;
        int interval = 10;
        double scale = pow(2., 1./interval);
        int m = (w<h)?w:h;
        int max_scale = 1+floor((double)log((double)m/(5.*sbin))/log(scale));
        image *ims = calloc(max_scale+interval, sizeof(image));
    IplImage* src = 0;
    if( (src = cvLoadImage(image_path,-1)) == 0 ) file_error(image_path);
    image out = features_output_size(net, src, h, w);
    for(j = 0; j < out.c*out.h*out.w; ++j){
        if(j != 0) printf(",");
        printf("%g", out.data[j]);
    }
    printf("\n");
    free_image(out);
    cvReleaseImage(&src);
}

        for(i = 0; i < interval; ++i){
            double factor = 1./pow(scale, i);
            double ih =  round(h*factor);
            double iw =  round(w*factor);
            int ex_h = round(ih/4.) - 2;
            int ex_w = round(iw/4.) - 2;
            ims[i] = features_output_size(net, src, ex_h, ex_w);
void visualize_imagenet_features(char *filename)
{
    int i,j,k;
    network net = parse_network_cfg("cfg/voc_imagenet.cfg");
    list *plist = get_paths(filename);
    node *n = plist->front;
    int h = voc_size(1), w = voc_size(1);
    int num = get_network_image(net).c;
    image *vizs = calloc(num, sizeof(image));
    for(i = 0; i < num; ++i) vizs[i] = make_image(h, w, 3);
    while(n){
        char *image_path = (char *)n->val;
        image im = load_image(image_path, 0, 0);
        printf("Processing %dx%d image\n", im.h, im.w);
        resize_network(net, im.h, im.w, im.c);
        forward_network(net, im.data);
        image out = get_network_image(net);

            ih =  round(h*factor);
            iw =  round(w*factor);
            ex_h = round(ih/8.) - 2;
            ex_w = round(iw/8.) - 2;
            ims[i+interval] = features_output_size(net, src, ex_h, ex_w);
            for(j = i+interval; j < max_scale; j += interval){
                factor /= 2.;
                ih =  round(h*factor);
                iw =  round(w*factor);
                ex_h = round(ih/8.) - 2;
                ex_w = round(iw/8.) - 2;
                ims[j+interval] = features_output_size(net, src, ex_h, ex_w);
        int dh = (im.h - h)/h;
        int dw = (im.w - w)/w;
        for(i = 0; i < out.h; ++i){
            for(j = 0; j < out.w; ++j){
                image sub = get_sub_image(im, dh*i, dw*j, h, w);
                for(k = 0; k < out.c; ++k){
                    float val = get_pixel(out, i, j, k);
                    //printf("%f, ", val);
                    image sub_c = copy_image(sub);
                    scale_image(sub_c, val);
                    add_into_image(sub_c, vizs[k], 0, 0);
                    free_image(sub_c);
                }
                free_image(sub);
            }
        }
        for(i = 0; i < max_scale+interval; ++i){
            image out = ims[i];
            //printf("%d, %d\n", out.h, out.w);
            fprintf(fp, "%d, %d, %d\n",out.c, out.h, out.w);
            for(j = 0; j < out.c*out.h*out.w; ++j){
                if(j != 0)fprintf(fp, ",");
                fprintf(fp, "%g", out.data[j]);
            }
            fprintf(fp, "\n");
            free_image(out);
        }
        free(ims);
        fclose(fp);
        cvReleaseImage(&src);
        //printf("\n");
        show_images(vizs, 10, "IMAGENET Visualization");
        cvWaitKey(1000);
        n = n->next;
    }
    cvWaitKey(0);
}

void features_VOC_image(char *image_file, char *image_dir, char *out_dir)
{
    int i,j;
    network net = parse_network_cfg("cfg/voc_features.cfg");
    network net = parse_network_cfg("cfg/voc_imagenet.cfg");
    char image_path[1024];
    sprintf(image_path, "%s%s",image_dir, image_file);
    sprintf(image_path, "%s/%s",image_dir, image_file);
    char out_path[1024];
    sprintf(out_path, "%s%s.txt",out_dir, image_file);
    sprintf(out_path, "%s/%s.txt",out_dir, image_file);
    printf("%s\n", image_file);
    FILE *fp = fopen(out_path, "w");
    if(fp == 0) file_error(out_path);
@@ -514,10 +583,11 @@
    int w = src->width;
    int h = src->height;
    int sbin = 8;
    int interval = 10;
    int interval = 4;
    double scale = pow(2., 1./interval);
    int m = (w<h)?w:h;
    int max_scale = 1+floor((double)log((double)m/(5.*sbin))/log(scale));
    if(max_scale < interval) error("max_scale must be >= interval");
    image *ims = calloc(max_scale+interval, sizeof(image));

    for(i = 0; i < interval; ++i){
@@ -557,20 +627,74 @@
    cvReleaseImage(&src);
}

void test_distribution()
{
    IplImage* img = 0;
    if( (img = cvLoadImage("im_small.jpg",-1)) == 0 ) file_error("im_small.jpg");
    network net = parse_network_cfg("cfg/voc_features.cfg");
    int h = img->height/8-2;
    int w = img->width/8-2;
    image out = features_output_size(net, img, h, w);
    int c = out.c;
    out.c = 1;
    show_image(out, "output");
    out.c = c;
    image input = ipl_to_image(img);
    show_image(input, "input");
    CvScalar s;
    int i,j;
    image affects = make_image(input.h, input.w, 1);
    int count = 0;
    for(i = 0; i<img->height; i += 1){
        for(j = 0; j < img->width; j += 1){
            IplImage *copy = cvCloneImage(img);
            s=cvGet2D(copy,i,j); // get the (i,j) pixel value
            printf("%d/%d\n", count++, img->height*img->width);
            s.val[0]=0;
            s.val[1]=0;
            s.val[2]=0;
            cvSet2D(copy,i,j,s); // set the (i,j) pixel value
            image mod = features_output_size(net, copy, h, w);
            image dist = image_distance(out, mod);
            show_image(affects, "affects");
            cvWaitKey(1);
            cvReleaseImage(&copy);
            //affects.data[i*affects.w + j] += dist.data[3*dist.w+5];
            affects.data[i*affects.w + j] += dist.data[1*dist.w+1];
            free_image(mod);
            free_image(dist);
        }
    }
    show_image(affects, "Origins");
    cvWaitKey(0);
    cvWaitKey(0);
}


int main(int argc, char *argv[])
{
    //train_full();
    //test_distribution();
    //feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);

    //test_blas();
    //test_visualize();
    //test_gpu_blas();
    //test_blas();
    //test_convolve_matrix();
    //    test_im2row();
    //test_split();
    //test_ensemble();
    //test_nist();
    //test_cifar10();
    //test_vince();
    //test_full();
    //train_VOC();
    features_VOC_image(argv[1], argv[2], argv[3]);
    printf("Success!\n");
    //features_VOC_image(argv[1], argv[2], argv[3]);
    //features_VOC_image_size(argv[1], atoi(argv[2]), atoi(argv[3]));
    //visualize_imagenet_features("data/assira/train.list");
    visualize_imagenet_features("data/VOC2011.list");
    fprintf(stderr, "Success!\n");
    //test_random_preprocess();
    //test_random_classify();
    //test_parser();