blame | history | patch | commit | commitdiff | ignore whitespace
Joseph Redmon
2014-12-11 79fffcce3ce495bd415dc1284224c915d7194d4c 
 src/cnn.c


@@ -8,6 +8,8 @@


#include "matrix.h"


#include "utils.h"


#include "mini_blas.h"


#include "matrix.h"


#include "server.h"




#include <time.h>


#include <stdlib.h>


@@ -36,6 +38,7 @@




void test_convolutional_layer()


{


/*


    int i;


    image dog = load_image("data/dog.jpg",224,224);


    network net = parse_network_cfg("cfg/convolutional.cfg");


@@ -72,6 +75,7 @@




    float *gpu_del = calloc(del_size, sizeof(float));


    memcpy(gpu_del, get_network_delta_layer(net, 0), del_size*sizeof(float));


    */




    /*


       start = clock();


@@ -97,6 +101,7 @@


     */


}




/*


void test_col2im()


{


    float col[] =  {1,2,1,2,


@@ -116,13 +121,12 @@


    int ksize = 3;


    int stride = 1;


    int pad = 0;


    col2im_gpu(col, batch,


            channels,  height,  width,


            ksize,  stride, pad, im);


    //col2im_gpu(col, batch,


    //        channels,  height,  width,


    //        ksize,  stride, pad, im);


    int i;


    for(i = 0; i < 16; ++i)printf("%f,", im[i]);


    printf("\n");


    /*


       float data_im[] = {


       1,2,3,4,


       5,6,7,8,


@@ -134,8 +138,8 @@


       ksize,   stride,  pad, data_col) ;


       for(i = 0; i < 18; ++i)printf("%f,", data_col[i]);


       printf("\n");


     */


}


*/




#endif




@@ -158,7 +162,7 @@


    int i;


    clock_t start = clock(), end;


    for(i = 0; i < 1000; ++i){


        im2col_cpu(dog.data,1, dog.c,  dog.h,  dog.w,  size,  stride, 0, matrix);


        //im2col_cpu(dog.data,1, dog.c,  dog.h,  dog.w,  size,  stride, 0, matrix);


        gemm(0,0,n,mw,mh,1,filters,mh,matrix,mw,1,edge.data,mw);


    }


    end = clock();


@@ -175,6 +179,7 @@




void verify_convolutional_layer()


{


/*


    srand(0);


    int i;


    int n = 1;


@@ -225,6 +230,7 @@


    printf("%f %f\n", avg_image_layer(mj1,0), avg_image_layer(mj2,0));


    show_image(mj1, "forward jacobian");


    show_image(mj2, "backward jacobian");


    */


}




void test_load()


@@ -305,6 +311,44 @@


    }


}




void draw_detection(image im, float *box, int side)


{


    int j;


    int r, c;


    float amount[5];


    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 smallest = amount[0];


    for(j = 1; j < 5; ++j) if(amount[j] < smallest) smallest = amount[j];




    for(r = 0; r < side; ++r){


        for(c = 0; c < side; ++c){


            j = (r*side + c) * 5;


            printf("Prob: %f\n", box[j]);


            if(box[j] >= smallest){


                int d = im.w/side;


                int y = r*d+box[j+1]*d;


                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);


                draw_box(im, x-w/2, y-h/2, x+w/2, y+h/2);


            }


        }


    }


    show_image(im, "box");


    cvWaitKey(0);


}






void train_detection_net()


{


    float avg_loss = 1;


@@ -313,6 +357,7 @@


    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);


    int imgs = 1000/net.batch+1;


    srand(time(0));


    //srand(23410);


    int i = 0;


    list *plist = get_paths("/home/pjreddie/data/imagenet/horse.txt");


    char **paths = (char **)list_to_array(plist);


@@ -321,8 +366,12 @@


    while(1){


        i += 1;


        time=clock();


        data train = load_data_detection_random(imgs*net.batch, paths, plist->size, 256, 256, 8, 8, 256);


        //translate_data_rows(train, -144);


        data train = load_data_detection_jitter_random(imgs*net.batch, 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);


        */




        normalize_data_rows(train);


        printf("Loaded: %lf seconds\n", sec(clock()-time));


        time=clock();


@@ -331,36 +380,81 @@


        avg_loss = avg_loss*.9 + loss*.1;


        printf("%d: %f, %f avg, %lf seconds, %d images\n", i, loss, avg_loss, sec(clock()-time), i*imgs*net.batch);


#endif


        free_data(train);


        if(i%10==0){


            char buff[256];


            sprintf(buff, "/home/pjreddie/imagenet_backup/imagenet_%d.cfg", i);


            sprintf(buff, "/home/pjreddie/imagenet_backup/detnet_%d.cfg", i);


            save_network(net, buff);


        }


        free_data(train);


    }


}






void train_imagenet()


void train_imagenet_distributed(char *address)


{


    float avg_loss = 1;


    //network net = parse_network_cfg("/home/pjreddie/imagenet_backup/alexnet_1270.cfg");


    network net = parse_network_cfg("cfg/trained_alexnet.cfg");


    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);


    int imgs = 1000/net.batch+1;


    srand(time(0));


    network net = parse_network_cfg("cfg/net.cfg");


    set_learning_network(&net, 0, 1, 0);


    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);


    int imgs = 1;


    int i = 0;


    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);


    printf("%d\n", plist->size);


    clock_t time;


    data train, buffer;


    pthread_t load_thread = load_data_random_thread(imgs*net.batch, paths, plist->size, labels, 1000, 224, 224, &buffer);


    while(1){


        i += 1;




        time=clock();


        client_update(net, address);


        printf("Updated: %lf seconds\n", sec(clock()-time));




        time=clock();


        pthread_join(load_thread, 0);


        train = buffer;


        normalize_data_rows(train);


        load_thread = load_data_random_thread(imgs*net.batch, paths, plist->size, labels, 1000, 224, 224, &buffer);


        printf("Loaded: %lf seconds\n", sec(clock()-time));


        time=clock();




#ifdef GPU


        float loss = train_network_data_gpu(net, train, imgs);


        avg_loss = avg_loss*.9 + loss*.1;


        printf("%d: %f, %f avg, %lf seconds, %d images\n", i, loss, avg_loss, sec(clock()-time), i*imgs*net.batch);


#endif


        free_data(train);


    }


}




void train_imagenet()


{


    float avg_loss = 1;


    //network net = parse_network_cfg("/home/pjreddie/imagenet_backup/alexnet_1270.cfg");


    srand(time(0));


    network net = parse_network_cfg("cfg/net.cfg");


    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);


    int imgs = 1000/net.batch+1;


    //imgs=1;


    int i = 0;


    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);


    printf("%d\n", plist->size);


    clock_t time;


    pthread_t load_thread;


    data train;


    data buffer;


    load_thread = load_data_random_thread(imgs*net.batch, paths, plist->size, labels, 1000, 224, 224, &buffer);


    while(1){


        i += 1;


        time=clock();


        data train = load_data_random(imgs*net.batch, paths, plist->size, labels, 1000, 256, 256);


        //translate_data_rows(train, -144);


        pthread_join(load_thread, 0);


        train = buffer;


        normalize_data_rows(train);


        load_thread = load_data_random_thread(imgs*net.batch, paths, plist->size, labels, 1000, 224, 224, &buffer);


        printf("Loaded: %lf seconds\n", sec(clock()-time));


        time=clock();


#ifdef GPU


@@ -371,7 +465,7 @@


        free_data(train);


        if(i%10==0){


            char buff[256];


            sprintf(buff, "/home/pjreddie/imagenet_backup/imagenet_%d.cfg", i);


            sprintf(buff, "/home/pjreddie/imagenet_backup/alexnet_%d.cfg", i);


            save_network(net, buff);


        }


    }


@@ -392,20 +486,23 @@




    clock_t time;


    float avg_acc = 0;


    float avg_top5 = 0;


    int splits = 50;




    for(i = 0; i < splits; ++i){


        time=clock();


        char **part = paths+(i*m/splits);


        int num = (i+1)*m/splits - i*m/splits;


        data val = load_data(part, num, labels, 1000, 256, 256);


        data val = load_data(part, num, labels, 1000, 224, 224);




        normalize_data_rows(val);


        printf("Loaded: %d images in %lf seconds\n", val.X.rows, sec(clock()-time));


        time=clock();


#ifdef GPU


        float acc = network_accuracy_gpu(net, val);


        avg_acc += acc;


        printf("%d: %f, %f avg, %lf seconds, %d images\n", i, acc, avg_acc/(i+1), sec(clock()-time), val.X.rows);


        float *acc = network_accuracies_gpu(net, val);


        avg_acc += acc[0];


        avg_top5 += acc[1];


        printf("%d: top1: %f, top5: %f, %lf seconds, %d images\n", i, avg_acc/(i+1), avg_top5/(i+1), sec(clock()-time), val.X.rows);


#endif


        free_data(val);


    }


@@ -413,27 +510,57 @@




void test_detection()


{


    network net = parse_network_cfg("cfg/detnet_test.cfg");


    //imgs=1;


    network net = parse_network_cfg("cfg/detnet.test");


    srand(2222222);


    int i = 0;


    clock_t time;


    char filename[256];


    int indexes[10];


    while(1){


        fgets(filename, 256, stdin);


        image im = load_image_color(filename, 256, 256);


        strtok(filename, "\n");


        image im = load_image_color(filename, 224, 224);


        z_normalize_image(im);


        printf("%d %d %d\n", im.h, im.w, im.c);


        float *X = im.data;


        time=clock();


        float *predictions = network_predict(net, X);


        top_predictions(net, 10, indexes);


        printf("%s: Predicted in %f seconds.\n", filename, sec(clock()-time));


        draw_detection(im, predictions, 7);


        free_image(im);


    }


}




void test_init(char *cfgfile)


{


    network net = parse_network_cfg(cfgfile);


    set_batch_network(&net, 1);


    srand(2222222);


    int i = 0;


    char *filename = "data/test.jpg";




    image im = load_image_color(filename, 224, 224);


    z_normalize_image(im);


    float *X = im.data;


    forward_network(net, X, 0, 1);


    for(i = 0; i < net.n; ++i){


        if(net.types[i] == CONVOLUTIONAL){


            convolutional_layer layer = *(convolutional_layer *)net.layers[i];


            image output = get_convolutional_image(layer);


            int size = output.h*output.w*output.c;


            float v = variance_array(layer.output, size);


            float m = mean_array(layer.output, size);


            printf("%d: Convolutional, mean: %f, variance %f\n", i, m, v);


        }


        else if(net.types[i] == CONNECTED){


            connected_layer layer = *(connected_layer *)net.layers[i];


            int size = layer.outputs;


            float v = variance_array(layer.output, size);


            float m = mean_array(layer.output, size);


            printf("%d: Connected, mean: %f, variance %f\n", i, m, v);


        }


    }


    free_image(im);


}




void test_imagenet()


{


    network net = parse_network_cfg("cfg/imagenet_test.cfg");


@@ -446,6 +573,7 @@


    int indexes[10];


    while(1){


        fgets(filename, 256, stdin);


        strtok(filename, "\n");


        image im = load_image_color(filename, 256, 256);


        z_normalize_image(im);


        printf("%d %d %d\n", im.h, im.w, im.c);


@@ -540,14 +668,14 @@




}




void test_nist()


void test_nist(char *path)


{


    srand(222222);


    network net = parse_network_cfg("cfg/nist_final.cfg");


    network net = parse_network_cfg(path);


    data test = load_categorical_data_csv("data/mnist/mnist_test.csv",0,10);


    translate_data_rows(test, -144);


    normalize_data_rows(test);


    clock_t start = clock(), end;


    float test_acc = network_accuracy_multi(net, test,16);


    float test_acc = network_accuracy_gpu(net, test);


    end = clock();


    printf("Accuracy: %f, Time: %lf seconds\n", test_acc,(float)(end-start)/CLOCKS_PER_SEC);


}


@@ -558,19 +686,43 @@


    network net = parse_network_cfg("cfg/nist.cfg");


    data train = load_categorical_data_csv("data/mnist/mnist_train.csv", 0, 10);


    data test = load_categorical_data_csv("data/mnist/mnist_test.csv",0,10);


    translate_data_rows(train, -144);


    translate_data_rows(test, -144);


    normalize_data_rows(train);


    normalize_data_rows(test);


    int count = 0;


    int iters = 50000/net.batch;


    int iters = 60000/net.batch + 1;


    //iters = 6000/net.batch + 1;


    while(++count <= 2000){


        clock_t start = clock(), end;


        float loss = train_network_sgd(net, train, iters);


        float loss = train_network_sgd_gpu(net, train, iters);


        end = clock();


        float test_acc = network_accuracy(net, test);


        float test_acc = 0;


        if(count%1 == 0) test_acc = network_accuracy_gpu(net, test);


        printf("%d: Loss: %f, Test Acc: %f, Time: %lf seconds\n", count, loss, test_acc,(float)(end-start)/CLOCKS_PER_SEC);


    }


}




void train_nist_distributed(char *address)


{


    srand(time(0));


    network net = parse_network_cfg("cfg/nist.client");


    data train = load_categorical_data_csv("data/mnist/mnist_train.csv", 0, 10);


    //data test = load_categorical_data_csv("data/mnist/mnist_test.csv",0,10);


    normalize_data_rows(train);


    //normalize_data_rows(test);


    int count = 0;


    int iters = 50000/net.batch;


    iters = 1000/net.batch + 1;


    while(++count <= 2000){


        clock_t start = clock(), end;


        float loss = train_network_sgd_gpu(net, train, iters);


        client_update(net, address);


        end = clock();


        //float test_acc = network_accuracy_gpu(net, test);


        //float test_acc = 0;


        printf("%d: Loss: %f, Time: %lf seconds\n", count, loss, (float)(end-start)/CLOCKS_PER_SEC);


    }


}




void test_ensemble()


{


    int i;


@@ -597,14 +749,14 @@


            lr /= 2; 


        }


        matrix partial = network_predict_data(net, test);


        float acc = matrix_accuracy(test.y, partial);


        float acc = matrix_topk_accuracy(test.y, partial,1);


        printf("Model Accuracy: %lf\n", acc);


        matrix_add_matrix(partial, prediction);


        acc = matrix_accuracy(test.y, prediction);


        acc = matrix_topk_accuracy(test.y, prediction,1);


        printf("Current Ensemble Accuracy: %lf\n", acc);


        free_matrix(partial);


    }


    float acc = matrix_accuracy(test.y, prediction);


    float acc = matrix_topk_accuracy(test.y, prediction,1);


    printf("Full Ensemble Accuracy: %lf\n", acc);


}




@@ -660,25 +812,27 @@


    printf("%d, %d, %d\n", train.X.rows, split[0].X.rows, split[1].X.rows);


}




void test_im2row()


{


    int h = 20;


    int w = 20;


    int c = 3;


    int stride = 1;


    int size = 11;


    image test = make_random_image(h,w,c);


    int mc = 1;


    int mw = ((h-size)/stride+1)*((w-size)/stride+1);


    int mh = (size*size*c);


    int msize = mc*mw*mh;


    float *matrix = calloc(msize, sizeof(float));


    int i;


    for(i = 0; i < 1000; ++i){


        im2col_cpu(test.data,1,  c,  h,  w,  size,  stride, 0, matrix);


        //image render = float_to_image(mh, mw, mc, matrix);


    }


/*


   void test_im2row()


   {


   int h = 20;


   int w = 20;


   int c = 3;


   int stride = 1;


   int size = 11;


   image test = make_random_image(h,w,c);


   int mc = 1;


   int mw = ((h-size)/stride+1)*((w-size)/stride+1);


   int mh = (size*size*c);


   int msize = mc*mw*mh;


   float *matrix = calloc(msize, sizeof(float));


   int i;


   for(i = 0; i < 1000; ++i){


//im2col_cpu(test.data,1,  c,  h,  w,  size,  stride, 0, matrix);


//image render = float_to_image(mh, mw, mc, matrix);


}


}


 */




void flip_network()


{


@@ -731,6 +885,76 @@


#endif


}




void test_correct_alexnet()


{


    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);


    printf("%d\n", plist->size);


    clock_t time;


    int count = 0;




    srand(222222);


    network net = parse_network_cfg("cfg/alexnet.test");


    printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);


    int imgs = 1000/net.batch+1;


    imgs = 1;




    while(++count <= 5){


        time=clock();


        data train = load_data_random(imgs*net.batch, paths, plist->size, labels, 1000, 256, 256);


        //translate_data_rows(train, -144);


        normalize_data_rows(train);


        printf("Loaded: %lf seconds\n", sec(clock()-time));


        time=clock();


        float loss = train_network_data_cpu(net, train, imgs);


        printf("%d: %f, %lf seconds, %d images\n", count, loss, sec(clock()-time), imgs*net.batch);


        free_data(train);


    }


#ifdef GPU


    count = 0;


    srand(222222);


    net = parse_network_cfg("cfg/alexnet.test");


    while(++count <= 5){


        time=clock();


        data train = load_data_random(imgs*net.batch, paths, plist->size, labels, 1000, 256, 256);


        //translate_data_rows(train, -144);


        normalize_data_rows(train);


        printf("Loaded: %lf seconds\n", sec(clock()-time));


        time=clock();


        float loss = train_network_data_gpu(net, train, imgs);


        printf("%d: %f, %lf seconds, %d images\n", count, loss, sec(clock()-time), imgs*net.batch);


        free_data(train);


    }


#endif


}




void run_server()


{


    srand(time(0));


    network net = parse_network_cfg("cfg/net.cfg");


    set_batch_network(&net, 1);


    server_update(net);


}


void test_client()


{


    network net = parse_network_cfg("cfg/alexnet.client");


    clock_t time=clock();


    client_update(net, "localhost");


    printf("1\n");


    client_update(net, "localhost");


    printf("2\n");


    client_update(net, "localhost");


    printf("3\n");


    printf("Transfered: %lf seconds\n", sec(clock()-time));


}




int find_int_arg(int argc, char* argv[], char *arg)


{


    int i;


    for(i = 0; i < argc-1; ++i) if(0==strcmp(argv[i], arg)) return atoi(argv[i+1]);


    return 0;


}




int main(int argc, char *argv[])


{


@@ -738,95 +962,108 @@


        fprintf(stderr, "usage: %s <function>\n", argv[0]);


        return 0;


    }


    int index = find_int_arg(argc, argv, "-i");


#ifdef GPU


    cl_setup(index);


#endif


    if(0==strcmp(argv[1], "train")) train_imagenet();


    else if(0==strcmp(argv[1], "detection")) train_detection_net();


    else if(0==strcmp(argv[1], "asirra")) train_asirra();


    else if(0==strcmp(argv[1], "nist")) train_nist();


    else if(0==strcmp(argv[1], "test_correct")) test_gpu_net();


    else if(0==strcmp(argv[1], "test_correct")) test_correct_alexnet();


    else if(0==strcmp(argv[1], "test")) test_imagenet();


    else if(0==strcmp(argv[1], "visualize")) test_visualize(argv[2]);


    else if(0==strcmp(argv[1], "valid")) validate_imagenet(argv[2]);


    else if(0==strcmp(argv[1], "server")) run_server();


    else if(0==strcmp(argv[1], "detect")) test_detection();


#ifdef GPU


    else if(0==strcmp(argv[1], "test_gpu")) test_gpu_blas();


#endif


    else if(argc < 3){


        fprintf(stderr, "usage: %s <function>\n", argv[0]);


        return 0;


    }


    else if(0==strcmp(argv[1], "client")) train_imagenet_distributed(argv[2]);


    else if(0==strcmp(argv[1], "init")) test_init(argv[2]);


    else if(0==strcmp(argv[1], "visualize")) test_visualize(argv[2]);


    else if(0==strcmp(argv[1], "valid")) validate_imagenet(argv[2]);


    else if(0==strcmp(argv[1], "testnist")) test_nist(argv[2]);


    fprintf(stderr, "Success!\n");


    return 0;


}




/*


void visualize_imagenet_topk(char *filename)


{


    int i,j,k,l;


    int topk = 10;


    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*));


    float **score = calloc(num, sizeof(float *));


    for(i = 0; i < num; ++i){


        vizs[i] = calloc(topk, sizeof(image));


        for(j = 0; j < topk; ++j) vizs[i][j] = make_image(h,w,3);


        score[i] = calloc(topk, sizeof(float));


    }


   void visualize_imagenet_topk(char *filename)


   {


   int i,j,k,l;


   int topk = 10;


   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*));


   float **score = calloc(num, sizeof(float *));


   for(i = 0; i < num; ++i){


   vizs[i] = calloc(topk, sizeof(image));


   for(j = 0; j < topk; ++j) vizs[i][j] = make_image(h,w,3);


   score[i] = calloc(topk, sizeof(float));


   }




    int count = 0;


    while(n){


        ++count;


        char *image_path = (char *)n->val;


        image im = load_image(image_path, 0, 0);


        n = n->next;


        if(im.h < 200 || im.w < 200) continue;


        printf("Processing %dx%d image\n", im.h, im.w);


        resize_network(net, im.h, im.w, im.c);


        //scale_image(im, 1./255);


        translate_image(im, -144);


        forward_network(net, im.data, 0, 0);


        image out = get_network_image(net);


   int count = 0;


   while(n){


   ++count;


   char *image_path = (char *)n->val;


   image im = load_image(image_path, 0, 0);


   n = n->next;


   if(im.h < 200 || im.w < 200) continue;


   printf("Processing %dx%d image\n", im.h, im.w);


   resize_network(net, im.h, im.w, im.c);


//scale_image(im, 1./255);


translate_image(im, -144);


forward_network(net, im.data, 0, 0);


image out = get_network_image(net);




        int dh = (im.h - h)/(out.h-1);


        int dw = (im.w - w)/(out.w-1);


        //printf("%d %d\n", dh, dw);


        for(k = 0; k < out.c; ++k){


            float topv = 0;


            int topi = -1;


            int topj = -1;


            for(i = 0; i < out.h; ++i){


                for(j = 0; j < out.w; ++j){


                    float val = get_pixel(out, i, j, k);


                    if(val > topv){


                        topv = val;


                        topi = i;


                        topj = j;


                    }


                }


            }


            if(topv){


                image sub = get_sub_image(im, dh*topi, dw*topj, h, w);


                for(l = 0; l < topk; ++l){


                    if(topv > score[k][l]){


                        float swap = score[k][l];


                        score[k][l] = topv;


                        topv = swap;


int dh = (im.h - h)/(out.h-1);


int dw = (im.w - w)/(out.w-1);


//printf("%d %d\n", dh, dw);


for(k = 0; k < out.c; ++k){


float topv = 0;


int topi = -1;


int topj = -1;


for(i = 0; i < out.h; ++i){


for(j = 0; j < out.w; ++j){


float val = get_pixel(out, i, j, k);


if(val > topv){


topv = val;


topi = i;


topj = j;


}


}


}


if(topv){


image sub = get_sub_image(im, dh*topi, dw*topj, h, w);


for(l = 0; l < topk; ++l){


if(topv > score[k][l]){


float swap = score[k][l];


score[k][l] = topv;


topv = swap;




                        image swapi = vizs[k][l];


                        vizs[k][l] = sub;


                        sub = swapi;


                    }


                }


                free_image(sub);


            }


        }


        free_image(im);


        if(count%50 == 0){


            image grid = grid_images(vizs, num, topk);


            //show_image(grid, "IMAGENET Visualization");


            save_image(grid, "IMAGENET Grid Single Nonorm");


            free_image(grid);


        }


    }


    //cvWaitKey(0);


image swapi = vizs[k][l];


vizs[k][l] = sub;


sub = swapi;


}


}


free_image(sub);


}


}


free_image(im);


if(count%50 == 0){


image grid = grid_images(vizs, num, topk);


//show_image(grid, "IMAGENET Visualization");


save_image(grid, "IMAGENET Grid Single Nonorm");


free_image(grid);


}


}


//cvWaitKey(0);


}




void visualize_imagenet_features(char *filename)