void denormalize_net(char *cfgfile, char *weightfile, char *outfile) { gpu_index = -1; network *net = load_network(cfgfile, weightfile, 0); int i; for (i = 0; i < net->n; ++i) { layer l = net->layers[i]; if ((l.type == DECONVOLUTIONAL || l.type == CONVOLUTIONAL) && l.batch_normalize) { denormalize_convolutional_layer(l); net->layers[i].batch_normalize=0; } if (l.type == CONNECTED && l.batch_normalize) { denormalize_connected_layer(l); net->layers[i].batch_normalize=0; } if (l.type == GRU && l.batch_normalize) { denormalize_connected_layer(*l.input_z_layer); denormalize_connected_layer(*l.input_r_layer); denormalize_connected_layer(*l.input_h_layer); denormalize_connected_layer(*l.state_z_layer); denormalize_connected_layer(*l.state_r_layer); denormalize_connected_layer(*l.state_h_layer); l.input_z_layer->batch_normalize = 0; l.input_r_layer->batch_normalize = 0; l.input_h_layer->batch_normalize = 0; l.state_z_layer->batch_normalize = 0; l.state_r_layer->batch_normalize = 0; l.state_h_layer->batch_normalize = 0; net->layers[i].batch_normalize=0; } } save_weights(net, outfile); free_network(net); }
void normalize_net(char *cfgfile, char *weightfile, char *outfile) { gpu_index = -1; network *net = load_network(cfgfile, weightfile, 0); int i; for(i = 0; i < net->n; ++i){ layer l = net->layers[i]; if(l.type == CONVOLUTIONAL && !l.batch_normalize){ net->layers[i] = normalize_layer(l, l.n); } if (l.type == CONNECTED && !l.batch_normalize) { net->layers[i] = normalize_layer(l, l.outputs); } if (l.type == GRU && l.batch_normalize) { *l.input_z_layer = normalize_layer(*l.input_z_layer, l.input_z_layer->outputs); *l.input_r_layer = normalize_layer(*l.input_r_layer, l.input_r_layer->outputs); *l.input_h_layer = normalize_layer(*l.input_h_layer, l.input_h_layer->outputs); *l.state_z_layer = normalize_layer(*l.state_z_layer, l.state_z_layer->outputs); *l.state_r_layer = normalize_layer(*l.state_r_layer, l.state_r_layer->outputs); *l.state_h_layer = normalize_layer(*l.state_h_layer, l.state_h_layer->outputs); net->layers[i].batch_normalize=1; } } save_weights(net, outfile); free_network(net); }
void statistics_net(char *cfgfile, char *weightfile) { gpu_index = -1; network *net = load_network(cfgfile, weightfile, 0); int i; for (i = 0; i < net->n; ++i) { layer l = net->layers[i]; if (l.type == CONNECTED && l.batch_normalize) { printf("Connected Layer %d\n", i); statistics_connected_layer(l); } if (l.type == GRU && l.batch_normalize) { printf("GRU Layer %d\n", i); printf("Input Z\n"); statistics_connected_layer(*l.input_z_layer); printf("Input R\n"); statistics_connected_layer(*l.input_r_layer); printf("Input H\n"); statistics_connected_layer(*l.input_h_layer); printf("State Z\n"); statistics_connected_layer(*l.state_z_layer); printf("State R\n"); statistics_connected_layer(*l.state_r_layer); printf("State H\n"); statistics_connected_layer(*l.state_h_layer); } printf("\n"); } free_network(net); }
void label_classifier(char *datacfg, char *filename, char *weightfile) { int i; network *net = load_network(filename, weightfile, 0); set_batch_network(net, 1); srand(time(0)); list *options = read_data_cfg(datacfg); char *label_list = option_find_str(options, "names", "data/labels.list"); char *test_list = option_find_str(options, "test", "data/train.list"); int classes = option_find_int(options, "classes", 2); char **labels = get_labels(label_list); list *plist = get_paths(test_list); char **paths = (char **)list_to_array(plist); int m = plist->size; free_list(plist); for(i = 0; i < m; ++i){ image im = load_image_color(paths[i], 0, 0); image resized = resize_min(im, net->w); image crop = crop_image(resized, (resized.w - net->w)/2, (resized.h - net->h)/2, net->w, net->h); float *pred = network_predict(net, crop.data); if(resized.data != im.data) free_image(resized); free_image(im); free_image(crop); int ind = max_index(pred, classes); printf("%s\n", labels[ind]); } }
void partial(char *cfgfile, char *weightfile, char *outfile, int max) { gpu_index = -1; network *net = load_network(cfgfile, weightfile, 1); save_weights_upto(net, outfile, max); free_network(net); }
void predict_regressor(char *cfgfile, char *weightfile, char *filename) { network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); clock_t time; char buff[256]; char *input = buff; while(1){ if(filename){ strncpy(input, filename, 256); }else{ printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if(!input) return; strtok(input, "\n"); } image im = load_image_color(input, 0, 0); image sized = letterbox_image(im, net->w, net->h); float *X = sized.data; time=clock(); float *predictions = network_predict(net, X); printf("Predicted: %f\n", predictions[0]); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); free_image(im); free_image(sized); if (filename) break; } free_network(net); }
void mkimg(char *cfgfile, char *weightfile, int h, int w, int num, char *prefix) { network *net = load_network(cfgfile, weightfile, 0); image *ims = get_weights(net->layers[0]); int n = net->layers[0].n; int z; for(z = 0; z < num; ++z){ image im = make_image(h, w, 3); fill_image(im, .5); int i; for(i = 0; i < 100; ++i){ image r = copy_image(ims[rand()%n]); rotate_image_cw(r, rand()%4); random_distort_image(r, 1, 1.5, 1.5); int dx = rand()%(w-r.w); int dy = rand()%(h-r.h); ghost_image(r, im, dx, dy); free_image(r); } char buff[256]; sprintf(buff, "%s/gen_%d", prefix, z); save_image(im, buff); free_image(im); } free_network(net); }
void validate_classifier_single(char *datacfg, char *filename, char *weightfile) { int i, j; network *net = load_network(filename, weightfile, 0); set_batch_network(net, 1); srand(time(0)); list *options = read_data_cfg(datacfg); char *label_list = option_find_str(options, "labels", "data/labels.list"); char *leaf_list = option_find_str(options, "leaves", 0); if(leaf_list) change_leaves(net->hierarchy, leaf_list); char *valid_list = option_find_str(options, "valid", "data/train.list"); int classes = option_find_int(options, "classes", 2); int topk = option_find_int(options, "top", 1); char **labels = get_labels(label_list); list *plist = get_paths(valid_list); char **paths = (char **)list_to_array(plist); int m = plist->size; free_list(plist); float avg_acc = 0; float avg_topk = 0; int *indexes = calloc(topk, sizeof(int)); for(i = 0; i < m; ++i){ int class = -1; char *path = paths[i]; for(j = 0; j < classes; ++j){ if(strstr(path, labels[j])){ class = j; break; } } image im = load_image_color(paths[i], 0, 0); image resized = resize_min(im, net->w); image crop = crop_image(resized, (resized.w - net->w)/2, (resized.h - net->h)/2, net->w, net->h); //show_image(im, "orig"); //show_image(crop, "cropped"); //cvWaitKey(0); float *pred = network_predict(net, crop.data); if(net->hierarchy) hierarchy_predictions(pred, net->outputs, net->hierarchy, 1, 1); if(resized.data != im.data) free_image(resized); free_image(im); free_image(crop); top_k(pred, classes, topk, indexes); if(indexes[0] == class) avg_acc += 1; for(j = 0; j < topk; ++j){ if(indexes[j] == class) avg_topk += 1; } printf("%d: top 1: %f, top %d: %f\n", i, avg_acc/(i+1), topk, avg_topk/(i+1)); } }
void inter_dcgan(char *cfgfile, char *weightfile) { network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); clock_t time; char buff[256]; char *input = buff; int i, imlayer = 0; for (i = 0; i < net->n; ++i) { if (net->layers[i].out_c == 3) { imlayer = i; printf("%d\n", i); break; } } image start = random_unit_vector_image(net->w, net->h, net->c); image end = random_unit_vector_image(net->w, net->h, net->c); image im = make_image(net->w, net->h, net->c); image orig = copy_image(start); int c = 0; int count = 0; int max_count = 15; while(1){ ++c; if(count == max_count){ count = 0; free_image(start); start = end; end = random_unit_vector_image(net->w, net->h, net->c); if(c > 300){ end = orig; } if(c>300 + max_count) return; } ++count; slerp(start.data, end.data, (float)count / max_count, im.w*im.h*im.c, im.data); float *X = im.data; time=clock(); network_predict(net, X); image out = get_network_image_layer(net, imlayer); //yuv_to_rgb(out); normalize_image(out); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); //char buff[256]; sprintf(buff, "out%05d", c); save_image(out, "out"); save_image(out, buff); show_image(out, "out", 0); } }
void test_char_rnn(char *cfgfile, char *weightfile, int num, char *seed, real_t temp, int rseed, char *token_file) { char **tokens = 0; if (token_file) { size_t n; tokens = read_tokens(token_file, &n); } srand(rseed); char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); network *net = load_network(cfgfile, weightfile, 0); int inputs = net->inputs; int i, j; for (i = 0; i < net->n; ++i) net->layers[i].temperature = temp; int c = 0; int len = strlen(seed); real_t *input = calloc(inputs, sizeof(real_t)); /* fill_cpu(inputs, 0, input, 1); for(i = 0; i < 10; ++i){ network_predict(net, input); } fill_cpu(inputs, 0, input, 1); */ for (i = 0; i < len - 1; ++i) { c = seed[i]; input[c] = 1; network_predict(net, input); input[c] = 0; print_symbol(c, tokens); } if (len) c = seed[len - 1]; print_symbol(c, tokens); for (i = 0; i < num; ++i) { input[c] = 1; real_t *out = network_predict(net, input); input[c] = 0; for (j = 32; j < 127; ++j) { //printf("%d %c %f\n",j, j, out[j]); } for (j = 0; j < inputs; ++j) { if (out[j] < .0001) out[j] = 0; } c = sample_array(out, inputs); print_symbol(c, tokens); } printf("\n"); }
void test_lsd(char *cfg, char *weights, char *filename, int gray) { network *net = load_network(cfg, weights, 0); set_batch_network(net, 1); srand(2222222); clock_t time; char buff[256]; char *input = buff; int i, imlayer = 0; for (i = 0; i < net->n; ++i) { if (net->layers[i].out_c == 3) { imlayer = i; printf("%d\n", i); break; } } while(1){ if(filename){ strncpy(input, filename, 256); }else{ printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if(!input) return; strtok(input, "\n"); } image im = load_image_color(input, 0, 0); image resized = resize_min(im, net->w); image crop = crop_image(resized, (resized.w - net->w)/2, (resized.h - net->h)/2, net->w, net->h); if(gray) grayscale_image_3c(crop); float *X = crop.data; time=clock(); network_predict(net, X); image out = get_network_image_layer(net, imlayer); //yuv_to_rgb(out); constrain_image(out); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); show_image(out, "out"); show_image(crop, "crop"); save_image(out, "out"); #ifdef OPENCV cvWaitKey(0); #endif free_image(im); free_image(resized); free_image(crop); if (filename) break; } }
int main ( int argc , char** argv ) { double start, end; // get cmdline args std::string input_file = argv[1]; std::string output_file = argv[2]; int num_steps = atoi( argv[3] ); // check for valid input file if ( !utils::fexists( input_file ) ) { printf( "Error: Input file does not exist.\n" ); return 1; } // initialize adjacency list vector hash printf( "Loading network edges from %s\n", input_file.c_str() ); start = omp_get_wtime(); load_network( input_file ); end = omp_get_wtime(); printf( "Time to read input file = %lf seconds\n", end - start ); // compute the normalized credit after numSteps printf("\nComputing the Credit Values for %d Rounds:\n", num_steps); CreditVec C( nodevec.size(), 1 ); // initialize credit at t=0 to 1 for each node CreditVec C_( nodevec.size(), 0 ); std::vector<CreditVec> updates( num_steps ); for (int i=0; i<num_steps; ++i) { printf("round %d = ", i+1); start = omp_get_wtime(); credit_update(C, C_); end = omp_get_wtime(); printf( "%f seconds\n", end - start ); // store credit update before overwriting timestep t updates[i] = C_; C = C_; // C(t+1) becomes C(t) for next iteration } // output credit value results after the final step printf( "\nOutputting Network and Random Walk Data to %s\n", output_file.c_str() ); write_output( output_file, updates ); // free heap memory for ( auto& node: nodevec ) { delete node; } return 0 ; }
void valid_tactic_rnn(char *cfgfile, char *weightfile, char *seed) { char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); network *net = load_network(cfgfile, weightfile, 0); int inputs = net->inputs; int count = 0; int words = 1; int c; int len = strlen(seed); real_t *input = calloc(inputs, sizeof(real_t)); int i; for (i = 0; i < len; ++i) { c = seed[i]; input[(int) c] = 1; network_predict(net, input); input[(int) c] = 0; } real_t sum = 0; c = getc(stdin); real_t log2 = log(2); int in = 0; while (c != EOF) { int next = getc(stdin); if (next == EOF) break; if (next < 0 || next >= 255) error("Out of range character"); input[c] = 1; real_t *out = network_predict(net, input); input[c] = 0; if (c == '.' && next == '\n') in = 0; if (!in) { if (c == '>' && next == '>') { in = 1; ++words; } c = next; continue; } ++count; sum += log(out[next]) / log2; c = next; printf("%d %d Perplexity: %4.4f Word Perplexity: %4.4f\n", count, words, pow(2, -sum / count), pow(2, -sum / words)); } }
void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename, int top) { network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); list *options = read_data_cfg(datacfg); char *name_list = option_find_str(options, "names", 0); if(!name_list) name_list = option_find_str(options, "labels", "data/labels.list"); if(top == 0) top = option_find_int(options, "top", 1); int i = 0; char **names = get_labels(name_list); clock_t time; int *indexes = calloc(top, sizeof(int)); char buff[256]; char *input = buff; while(1){ if(filename){ strncpy(input, filename, 256); }else{ printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if(!input) return; strtok(input, "\n"); } image im = load_image_color(input, 0, 0); image r = letterbox_image(im, net->w, net->h); //resize_network(net, r.w, r.h); //printf("%d %d\n", r.w, r.h); float *X = r.data; time=clock(); float *predictions = network_predict(net, X); if(net->hierarchy) hierarchy_predictions(predictions, net->outputs, net->hierarchy, 1, 1); top_k(predictions, net->outputs, top, indexes); fprintf(stderr, "%s: Predicted in %f seconds.\n", input, sec(clock()-time)); for(i = 0; i < top; ++i){ int index = indexes[i]; //if(net->hierarchy) printf("%d, %s: %f, parent: %s \n",index, names[index], predictions[index], (net->hierarchy->parent[index] >= 0) ? names[net->hierarchy->parent[index]] : "Root"); //else printf("%s: %f\n",names[index], predictions[index]); printf("%5.2f%%: %s\n", predictions[index]*100, names[index]); } if(r.data != im.data) free_image(r); free_image(im); if (filename) break; } }
void rgbgr_net(char *cfgfile, char *weightfile, char *outfile) { gpu_index = -1; network *net = load_network(cfgfile, weightfile, 0); int i; for(i = 0; i < net->n; ++i){ layer l = net->layers[i]; if(l.type == CONVOLUTIONAL){ rgbgr_weights(l); break; } } save_weights(net, outfile); free_network(net); }
void demo_regressor(char *datacfg, char *cfgfile, char *weightfile, int cam_index, const char *filename) { #ifdef OPENCV printf("Regressor Demo\n"); network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); list *options = read_data_cfg(datacfg); int classes = option_find_int(options, "classes", 1); char *name_list = option_find_str(options, "names", 0); char **names = get_labels(name_list); void * cap = open_video_stream(filename, cam_index, 0,0,0); if(!cap) error("Couldn't connect to webcam.\n"); float fps = 0; while(1){ struct timeval tval_before, tval_after, tval_result; gettimeofday(&tval_before, NULL); image in = get_image_from_stream(cap); image crop = center_crop_image(in, net->w, net->h); grayscale_image_3c(crop); float *predictions = network_predict(net, crop.data); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.0f\n",fps); int i; for(i = 0; i < classes; ++i){ printf("%s: %f\n", names[i], predictions[i]); } show_image(crop, "Regressor", 10); free_image(in); free_image(crop); gettimeofday(&tval_after, NULL); timersub(&tval_after, &tval_before, &tval_result); float curr = 1000000.f/((long int)tval_result.tv_usec); fps = .9*fps + .1*curr; } free_network(net); #endif }
void test_tactic_rnn_multi(char *cfgfile, char *weightfile, int num, real_t temp, int rseed, char *token_file) { char **tokens = 0; if (token_file) { size_t n; tokens = read_tokens(token_file, &n); } srand(rseed); char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); network *net = load_network(cfgfile, weightfile, 0); int inputs = net->inputs; int i, j; for (i = 0; i < net->n; ++i) net->layers[i].temperature = temp; int c = 0; real_t *input = calloc(inputs, sizeof(real_t)); real_t *out = 0; while (1) { reset_network_state(net, 0); while ((c = getc(stdin)) != EOF && c != 0) { input[c] = 1; out = network_predict(net, input); input[c] = 0; } for (i = 0; i < num; ++i) { for (j = 0; j < inputs; ++j) { if (out[j] < .0001) out[j] = 0; } int next = sample_array(out, inputs); if (c == '.' && next == '\n') break; c = next; print_symbol(c, tokens); input[c] = 1; out = network_predict(net, input); input[c] = 0; } printf("\n"); } }
void test_coco(char *cfgfile, char *weightfile, char *filename, float thresh) { image **alphabet = load_alphabet(); network *net = load_network(cfgfile, weightfile, 0); layer l = net->layers[net->n-1]; set_batch_network(net, 1); srand(2222222); float nms = .4; clock_t time; char buff[256]; char *input = buff; while(1){ if(filename){ strncpy(input, filename, 256); } else { printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if(!input) return; strtok(input, "\n"); } image im = load_image_color(input,0,0); image sized = resize_image(im, net->w, net->h); float *X = sized.data; time=clock(); network_predict(net, X); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); int nboxes = 0; detection *dets = get_network_boxes(net, 1, 1, thresh, 0, 0, 0, &nboxes); if (nms) do_nms_sort(dets, l.side*l.side*l.n, l.classes, nms); draw_detections(im, dets, l.side*l.side*l.n, thresh, coco_classes, alphabet, 80); save_image(im, "prediction"); show_image(im, "predictions"); free_detections(dets, nboxes); free_image(im); free_image(sized); #ifdef OPENCV cvWaitKey(0); cvDestroyAllWindows(); #endif if (filename) break; } }
void demo_art(char *cfgfile, char *weightfile, int cam_index) { #ifdef OPENCV network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); void * cap = open_video_stream(0, cam_index, 0,0,0); char *window = "ArtJudgementBot9000!!!"; if(!cap) error("Couldn't connect to webcam.\n"); int i; int idx[] = {37, 401, 434}; int n = sizeof(idx)/sizeof(idx[0]); while(1){ image in = get_image_from_stream(cap); image in_s = resize_image(in, net->w, net->h); float *p = network_predict(net, in_s.data); printf("\033[2J"); printf("\033[1;1H"); float score = 0; for(i = 0; i < n; ++i){ float s = p[idx[i]]; if (s > score) score = s; } score = score; printf("I APPRECIATE THIS ARTWORK: %10.7f%%\n", score*100); printf("["); int upper = 30; for(i = 0; i < upper; ++i){ printf("%c", ((i+.5) < score*upper) ? 219 : ' '); } printf("]\n"); show_image(in, window, 1); free_image(in_s); free_image(in); } #endif }
void print_weights(char *cfgfile, char *weightfile, int n) { gpu_index = -1; network *net = load_network(cfgfile, weightfile, 1); layer l = net->layers[n]; int i, j; //printf("["); for(i = 0; i < l.n; ++i){ //printf("["); for(j = 0; j < l.size*l.size*l.c; ++j){ //if(j > 0) printf(","); printf("%g ", l.weights[i*l.size*l.size*l.c + j]); } printf("\n"); //printf("]%s\n", (i == l.n-1)?"":","); } //printf("]"); }
void vec_char_rnn(char *cfgfile, char *weightfile, char *seed) { char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); network *net = load_network(cfgfile, weightfile, 0); int inputs = net->inputs; int c; int seed_len = strlen(seed); real_t *input = calloc(inputs, sizeof(real_t)); int i; char *line; while ((line = fgetl(stdin)) != 0) { reset_network_state(net, 0); for (i = 0; i < seed_len; ++i) { c = seed[i]; input[(int) c] = 1; network_predict(net, input); input[(int) c] = 0; } strip(line); int str_len = strlen(line); for (i = 0; i < str_len; ++i) { c = line[i]; input[(int) c] = 1; network_predict(net, input); input[(int) c] = 0; } c = ' '; input[(int) c] = 1; network_predict(net, input); input[(int) c] = 0; layer l = net->layers[0]; #ifdef GPU cuda_pull_array(l.output_gpu, l.output, l.outputs); #endif printf("%s", line); for (i = 0; i < l.outputs; ++i) { printf(",%g", l.output[i]); } printf("\n"); } }
void test_tag(char *cfgfile, char *weightfile, char *filename) { network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); int i = 0; char **names = get_labels("data/tags.txt"); clock_t time; int indexes[10]; char buff[256]; char *input = buff; int size = net->w; while (1) { if (filename) { strncpy(input, filename, 256); } else { printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if (!input) return; strtok(input, "\n"); } image im = load_image_color(input, 0, 0); image r = resize_min(im, size); resize_network(net, r.w, r.h); printf("%d %d\n", r.w, r.h); real_t *X = r.data; time = clock(); real_t *predictions = network_predict(net, X); top_predictions(net, 10, indexes); printf("%s: Predicted in %f seconds.\n", input, sec(clock() - time)); for (i = 0; i < 10; ++i) { int index = indexes[i]; printf("%.1f%%: %s\n", predictions[index] * 100, names[index]); } if (r.data != im.data) free_image(r); free_image(im); if (filename) break; } }
void demo_segmenter(char *datacfg, char *cfg, char *weights, int cam_index, const char *filename) { #ifdef OPENCV printf("Classifier Demo\n"); network *net = load_network(cfg, weights, 0); set_batch_network(net, 1); srand(2222222); void * cap = open_video_stream(filename, cam_index, 0,0,0); if(!cap) error("Couldn't connect to webcam.\n"); float fps = 0; while(1){ struct timeval tval_before, tval_after, tval_result; gettimeofday(&tval_before, NULL); image in = get_image_from_stream(cap); image in_s = letterbox_image(in, net->w, net->h); network_predict(net, in_s.data); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.0f\n",fps); image pred = get_network_image(net); image prmask = mask_to_rgb(pred); show_image(prmask, "Segmenter", 10); free_image(in_s); free_image(in); free_image(prmask); gettimeofday(&tval_after, NULL); timersub(&tval_after, &tval_before, &tval_result); float curr = 1000000.f/((long int)tval_result.tv_usec); fps = .9*fps + .1*curr; } free_network(net); #endif }
void test_dcgan(char *cfgfile, char *weightfile) { network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); clock_t time; char buff[256]; char *input = buff; int i, imlayer = 0; for (i = 0; i < net->n; ++i) { if (net->layers[i].out_c == 3) { imlayer = i; printf("%d\n", i); break; } } while(1){ image im = make_image(net->w, net->h, net->c); int i; for(i = 0; i < im.w*im.h*im.c; ++i){ im.data[i] = rand_normal(); } float *X = im.data; time=clock(); network_predict(net, X); image out = get_network_image_layer(net, imlayer); //yuv_to_rgb(out); normalize_image(out); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); show_image(out, "out"); save_image(out, "out"); #ifdef OPENCV cvWaitKey(0); #endif free_image(im); } }
void test_dcgan(char *cfgfile, char *weightfile) { network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); clock_t time; char buff[256]; char *input = buff; int imlayer = 0; imlayer = net->n-1; while(1){ image im = make_image(net->w, net->h, net->c); int i; for(i = 0; i < im.w*im.h*im.c; ++i){ im.data[i] = rand_normal(); } //float mag = mag_array(im.data, im.w*im.h*im.c); //scale_array(im.data, im.w*im.h*im.c, 1./mag); float *X = im.data; time=clock(); network_predict(net, X); image out = get_network_image_layer(net, imlayer); //yuv_to_rgb(out); normalize_image(out); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); save_image(out, "out"); show_image(out, "out", 0); free_image(im); } free_network(net); }
void validate_yolo(char *cfg, char *weights) { network *net = load_network(cfg, weights, 0); set_batch_network(net, 1); fprintf(stderr, "Learning Rate: %g, Momentum: %g, Decay: %g\n", net->learning_rate, net->momentum, net->decay); srand(time(0)); char *base = "results/comp4_det_test_"; //list *plist = get_paths("data/voc.2007.test"); list *plist = get_paths("/home/pjreddie/data/voc/2007_test.txt"); //list *plist = get_paths("data/voc.2012.test"); char **paths = (char **)list_to_array(plist); layer l = net->layers[net->n-1]; int classes = l.classes; int j; FILE **fps = calloc(classes, sizeof(FILE *)); for(j = 0; j < classes; ++j){ char buff[1024]; snprintf(buff, 1024, "%s%s.txt", base, voc_names[j]); fps[j] = fopen(buff, "w"); } int m = plist->size; int i=0; int t; float thresh = .001; int nms = 1; float iou_thresh = .5; int nthreads = 8; image *val = calloc(nthreads, sizeof(image)); image *val_resized = calloc(nthreads, sizeof(image)); image *buf = calloc(nthreads, sizeof(image)); image *buf_resized = calloc(nthreads, sizeof(image)); pthread_t *thr = calloc(nthreads, sizeof(pthread_t)); load_args args = {0}; args.w = net->w; args.h = net->h; args.type = IMAGE_DATA; for(t = 0; t < nthreads; ++t){ args.path = paths[i+t]; args.im = &buf[t]; args.resized = &buf_resized[t]; thr[t] = load_data_in_thread(args); } time_t start = time(0); for(i = nthreads; i < m+nthreads; i += nthreads){ fprintf(stderr, "%d\n", i); for(t = 0; t < nthreads && i+t-nthreads < m; ++t){ pthread_join(thr[t], 0); val[t] = buf[t]; val_resized[t] = buf_resized[t]; } for(t = 0; t < nthreads && i+t < m; ++t){ args.path = paths[i+t]; args.im = &buf[t]; args.resized = &buf_resized[t]; thr[t] = load_data_in_thread(args); } for(t = 0; t < nthreads && i+t-nthreads < m; ++t){ char *path = paths[i+t-nthreads]; char *id = basecfg(path); float *X = val_resized[t].data; network_predict(net, X); int w = val[t].w; int h = val[t].h; int nboxes = 0; detection *dets = get_network_boxes(net, w, h, thresh, 0, 0, 0, &nboxes); if (nms) do_nms_sort(dets, l.side*l.side*l.n, classes, iou_thresh); print_yolo_detections(fps, id, l.side*l.side*l.n, classes, w, h, dets); free_detections(dets, nboxes); free(id); free_image(val[t]); free_image(val_resized[t]); } } fprintf(stderr, "Total Detection Time: %f Seconds\n", (double)(time(0) - start)); free_network( net ); }
void train_yolo(char *cfgfile, char *weightfile) { char *train_images = "/data/voc/train.txt"; char *backup_directory = "/home/kunle12/backup/"; srand(time(0)); char *base = basecfg(cfgfile); printf("%s\n", base); float avg_loss = -1; network * net = load_network(cfgfile, weightfile, 0); printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net->learning_rate, net->momentum, net->decay); int imgs = net->batch*net->subdivisions; int i = *net->seen/imgs; data train, buffer; layer l = net->layers[net->n - 1]; int side = l.side; int classes = l.classes; float jitter = l.jitter; list *plist = get_paths(train_images); //int N = plist->size; char **paths = (char **)list_to_array(plist); load_args args = {0}; args.w = net->w; args.h = net->h; args.paths = paths; args.n = imgs; args.m = plist->size; args.classes = classes; args.jitter = jitter; args.num_boxes = side; args.d = &buffer; args.type = REGION_DATA; args.angle = net->angle; args.exposure = net->exposure; args.saturation = net->saturation; args.hue = net->hue; pthread_t load_thread = load_data_in_thread(args); clock_t time; //while(i*imgs < N*120){ while(get_current_batch(net) < net->max_batches){ i += 1; time=clock(); pthread_join(load_thread, 0); train = buffer; load_thread = load_data_in_thread(args); printf("Loaded: %lf seconds\n", sec(clock()-time)); time=clock(); float loss = train_network(net, train); if (avg_loss < 0) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; printf("%d: %f, %f avg, %f rate, %lf seconds, %d images\n", i, loss, avg_loss, get_current_rate(net), sec(clock()-time), i*imgs); if(i%1000==0 || (i < 1000 && i%100 == 0)){ char buff[256]; sprintf(buff, "%s/%s_%d.weights", backup_directory, base, i); save_weights(net, buff); } free_data(train); } char buff[256]; sprintf(buff, "%s/%s_final.weights", backup_directory, base); save_weights(net, buff); free_network( net ); }
void validate_yolo_recall(char *cfg, char *weights) { network *net = load_network(cfg, weights, 0); set_batch_network(net, 1); fprintf(stderr, "Learning Rate: %g, Momentum: %g, Decay: %g\n", net->learning_rate, net->momentum, net->decay); srand(time(0)); char *base = "results/comp4_det_test_"; list *plist = get_paths("data/voc.2007.test"); char **paths = (char **)list_to_array(plist); layer l = net->layers[net->n-1]; int classes = l.classes; int side = l.side; int j, k; FILE **fps = calloc(classes, sizeof(FILE *)); for(j = 0; j < classes; ++j){ char buff[1024]; snprintf(buff, 1024, "%s%s.txt", base, voc_names[j]); fps[j] = fopen(buff, "w"); } int m = plist->size; int i=0; float thresh = .001; float iou_thresh = .5; float nms = 0; int total = 0; int correct = 0; int proposals = 0; float avg_iou = 0; for(i = 0; i < m; ++i){ char *path = paths[i]; image orig = load_image_color(path, 0, 0); image sized = resize_image(orig, net->w, net->h); char *id = basecfg(path); network_predict(net, sized.data); int nboxes = 0; detection *dets = get_network_boxes(net, orig.w, orig.h, thresh, 0, 0, 1, &nboxes); if (nms) do_nms_obj(dets, side*side*l.n, 1, nms); char labelpath[4096]; find_replace(path, "images", "labels", labelpath); find_replace(labelpath, "JPEGImages", "labels", labelpath); find_replace(labelpath, ".jpg", ".txt", labelpath); find_replace(labelpath, ".JPEG", ".txt", labelpath); int num_labels = 0; box_label *truth = read_boxes(labelpath, &num_labels); for(k = 0; k < side*side*l.n; ++k){ if(dets[k].objectness > thresh){ ++proposals; } } for (j = 0; j < num_labels; ++j) { ++total; box t = {truth[j].x, truth[j].y, truth[j].w, truth[j].h}; float best_iou = 0; for(k = 0; k < side*side*l.n; ++k){ float iou = box_iou(dets[k].bbox, t); if(dets[k].objectness > thresh && iou > best_iou){ best_iou = iou; } } avg_iou += best_iou; if(best_iou > iou_thresh){ ++correct; } } fprintf(stderr, "%5d %5d %5d\tRPs/Img: %.2f\tIOU: %.2f%%\tRecall:%.2f%%\n", i, correct, total, (float)proposals/(i+1), avg_iou*100/total, 100.*correct/total); free_detections(dets, nboxes); free(id); free_image(orig); free_image(sized); } free_network( net ); }
network *load_network_p(char *cfg, char *weights, int clear) { network *net = calloc(1, sizeof(network)); *net = load_network(cfg, weights, clear); return net; }
void train_regressor(char *datacfg, char *cfgfile, char *weightfile, int *gpus, int ngpus, int clear) { int i; float avg_loss = -1; char *base = basecfg(cfgfile); printf("%s\n", base); printf("%d\n", ngpus); network **nets = calloc(ngpus, sizeof(network*)); srand(time(0)); int seed = rand(); for(i = 0; i < ngpus; ++i){ srand(seed); #ifdef GPU cuda_set_device(gpus[i]); #endif nets[i] = load_network(cfgfile, weightfile, clear); nets[i]->learning_rate *= ngpus; } srand(time(0)); network *net = nets[0]; int imgs = net->batch * net->subdivisions * ngpus; printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net->learning_rate, net->momentum, net->decay); list *options = read_data_cfg(datacfg); char *backup_directory = option_find_str(options, "backup", "/backup/"); char *train_list = option_find_str(options, "train", "data/train.list"); int classes = option_find_int(options, "classes", 1); list *plist = get_paths(train_list); char **paths = (char **)list_to_array(plist); printf("%d\n", plist->size); int N = plist->size; clock_t time; load_args args = {0}; args.w = net->w; args.h = net->h; args.threads = 32; args.classes = classes; args.min = net->min_ratio*net->w; args.max = net->max_ratio*net->w; args.angle = net->angle; args.aspect = net->aspect; args.exposure = net->exposure; args.saturation = net->saturation; args.hue = net->hue; args.size = net->w; args.paths = paths; args.n = imgs; args.m = N; args.type = REGRESSION_DATA; data train; data buffer; pthread_t load_thread; args.d = &buffer; load_thread = load_data(args); int epoch = (*net->seen)/N; while(get_current_batch(net) < net->max_batches || net->max_batches == 0){ time=clock(); pthread_join(load_thread, 0); train = buffer; load_thread = load_data(args); printf("Loaded: %lf seconds\n", sec(clock()-time)); time=clock(); float loss = 0; #ifdef GPU if(ngpus == 1){ loss = train_network(net, train); } else { loss = train_networks(nets, ngpus, train, 4); } #else loss = train_network(net, train); #endif if(avg_loss == -1) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; printf("%ld, %.3f: %f, %f avg, %f rate, %lf seconds, %ld images\n", get_current_batch(net), (float)(*net->seen)/N, loss, avg_loss, get_current_rate(net), sec(clock()-time), *net->seen); free_data(train); if(*net->seen/N > epoch){ epoch = *net->seen/N; char buff[256]; sprintf(buff, "%s/%s_%d.weights",backup_directory,base, epoch); save_weights(net, buff); } if(get_current_batch(net)%100 == 0){ char buff[256]; sprintf(buff, "%s/%s.backup",backup_directory,base); save_weights(net, buff); } } char buff[256]; sprintf(buff, "%s/%s.weights", backup_directory, base); save_weights(net, buff); for(i = 0; i < ngpus; ++i){ free_network(nets[i]); } free(nets); free_ptrs((void**)paths, plist->size); free_list(plist); free(base); }