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 decode_captcha(char *cfgfile, char *weightfile) { setbuf(stdout, NULL); srand(time(0)); network net = parse_network_cfg(cfgfile); set_batch_network(&net, 1); if(weightfile){ load_weights(&net, weightfile); } char filename[256]; while(1){ printf("Enter filename: "); fgets(filename, 256, stdin); strtok(filename, "\n"); image im = load_image_color(filename, 300, 57); scale_image(im, 1./255.); float *X = im.data; float *predictions = network_predict(net, X); image out = float_to_image(300, 57, 1, predictions); show_image(out, "decoded"); #ifdef OPENCV cvWaitKey(0); #endif free_image(im); } }
void test_cifar_multi(char *filename, char *weightfile) { network net = parse_network_cfg(filename); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(time(0)); float avg_acc = 0; data test = load_cifar10_data("data/cifar/cifar-10-batches-bin/test_batch.bin"); int i; for(i = 0; i < test.X.rows; ++i){ image im = float_to_image(32, 32, 3, test.X.vals[i]); float pred[10] = {0}; float *p = network_predict(net, im.data); axpy_cpu(10, 1, p, 1, pred, 1); flip_image(im); p = network_predict(net, im.data); axpy_cpu(10, 1, p, 1, pred, 1); int index = max_index(pred, 10); int class = max_index(test.y.vals[i], 10); if(index == class) avg_acc += 1; free_image(im); printf("%4d: %.2f%%\n", i, 100.*avg_acc/(i+1)); } }
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 valid_go(char *cfgfile, char *weightfile, int multi) { srand(time(0)); char *base = basecfg(cfgfile); printf("%s\n", base); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay); float *board = calloc(19*19, sizeof(float)); float *move = calloc(19*19, sizeof(float)); moves m = load_go_moves("/home/pjreddie/backup/go.test"); int N = m.n; int i; int correct = 0; for(i = 0; i <N; ++i){ char *b = m.data[i]; int row = b[0]; int col = b[1]; int truth = col + 19*row; string_to_board(b+2, board); predict_move(net, board, move, multi); int index = max_index(move, 19*19); if(index == truth) ++correct; printf("%d Accuracy %f\n", i, (float) correct/(i+1)); } }
void test_dice(char *cfgfile, char *weightfile, char *filename) { network * net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(net, weightfile); } set_batch_network(net, 1); srand(2222222); int i = 0; char **names = dice_labels; char buff[256]; char *input = buff; int indexes[6]; 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, net->w, net->h); float *X = im.data; float *predictions = network_predict(net, X); top_predictions(net, 6, indexes); for(i = 0; i < 6; ++i){ int index = indexes[i]; printf("%s: %f\n", names[index], predictions[index]); } free_image(im); if (filename) break; } }
void test_captcha(char *cfgfile, char *weightfile) { setbuf(stdout, NULL); srand(time(0)); //char *base = basecfg(cfgfile); //printf("%s\n", base); network net = parse_network_cfg(cfgfile); set_batch_network(&net, 1); if(weightfile){ load_weights(&net, weightfile); } char filename[256]; while(1){ //printf("Enter filename: "); fgets(filename, 256, stdin); strtok(filename, "\n"); image im = load_image_color(filename, 200, 60); translate_image(im, -128); scale_image(im, 1/128.); float *X = im.data; float *predictions = network_predict(net, X); print_letters(predictions, 10); free_image(im); } }
/* * @param[in]: ctx */ void createYoloNetwork(context_param_yolo_t *yoloctx, char* cfgfile, char* weightfile) { printf("Create YOLO network\n"); network net = parse_network_cfg(cfgfile); if (weightfile) { load_weights(&net, weightfile); } set_batch_network(&net, 1); detection_layer l = net.layers[net.n - 1]; yoloGrid grid; grid.grids = l.side; grid.bbs = l.n; grid.classes = l.classes; box *boxes = malloc(l.side * l.side * l.n * sizeof(box)); float **probs = malloc(l.side * l.side * l.n * sizeof(float *)); for (int j = 0; j < l.side * l.side * l.n; j++) { probs[j] = malloc(l.classes*sizeof(float *)); } yoloctx->_net = net; yoloctx->_grid = grid; yoloctx->_grid.boxes = boxes; yoloctx->_grid.probs = probs; yoloctx->_nwidth = net.w; yoloctx->_nheight = net.h; yoloctx->_sqrt = l.sqrt; yoloctx->_nms = .5f; // non maximal suppression }
void validate_classifier_full(char *datacfg, char *filename, char *weightfile) { int i, j; network net = parse_network_cfg(filename); set_batch_network(&net, 1); if(weightfile){ load_weights(&net, weightfile); } srand(time(0)); list *options = read_data_cfg(datacfg); char *label_list = option_find_str(options, "labels", "data/labels.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)); int size = net.w; 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, size); resize_network(&net, resized.w, resized.h); //show_image(im, "orig"); //show_image(crop, "cropped"); //cvWaitKey(0); float *pred = network_predict(net, resized.data); if(net.hierarchy) hierarchy_predictions(pred, net.outputs, net.hierarchy, 1, 1); free_image(im); free_image(resized); 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 test_detector(char *datacfg, char *cfgfile, char *weightfile, char *filename, float thresh, float hier_thresh) { int show_flag = 1; list *options = read_data_cfg(datacfg); char *name_list = option_find_str(options, "names", "data/names.list"); char **names = get_labels(name_list); image **alphabet = load_alphabet(); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); clock_t time; char buff[256]; char *input = buff; int j; float nms=.4; 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); layer l = net.layers[net.n-1]; box *boxes = calloc(l.w*l.h*l.n, sizeof(box)); float **probs = calloc(l.w*l.h*l.n, sizeof(float *)); for(j = 0; j < l.w*l.h*l.n; ++j) probs[j] = calloc(l.classes + 1, sizeof(float *)); float *X = sized.data; time=clock(); network_predict(net, X); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); get_region_boxes(l, 1, 1, thresh, probs, boxes, 0, 0, hier_thresh); if (l.softmax_tree && nms) do_nms_obj(boxes, probs, l.w*l.h*l.n, l.classes, nms); else if (nms) do_nms_sort(boxes, probs, l.w*l.h*l.n, l.classes, nms); draw_detections(im, l.w*l.h*l.n, thresh, boxes, probs, names, alphabet, l.classes, show_flag); save_image(im, "predictions"); show_image(im, "predictions"); free_image(im); free_image(sized); free(boxes); free_ptrs((void **)probs, l.w*l.h*l.n); #ifdef OPENCV cvWaitKey(0); cvDestroyAllWindows(); #endif if (filename) break; } }
float *network_predict_image(network *net, image im) { image imr = letterbox_image(im, net->w, net->h); set_batch_network(net, 1); float *p = network_predict(*net, imr.data); free_image(imr); return p; }
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_lsd(char *cfgfile, char *weightfile, char *filename) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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); //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; } }
void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename, int top) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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 demo_regressor(char *datacfg, char *cfgfile, char *weightfile, int cam_index, const char *filename) { #ifdef OPENCV printf("Regressor Demo\n"); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); CvCapture * cap; if(filename){ cap = cvCaptureFromFile(filename); }else{ cap = cvCaptureFromCAM(cam_index); } if(!cap) error("Couldn't connect to webcam.\n"); cvNamedWindow("Regressor", CV_WINDOW_NORMAL); cvResizeWindow("Regressor", 512, 512); 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); show_image(in, "Regressor"); float *predictions = network_predict(net, in_s.data); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.0f\n",fps); printf("People: %f\n", predictions[0]); free_image(in_s); free_image(in); cvWaitKey(10); 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; } #endif }
void test_yolo(char *cfgfile, char *weightfile, char *filename, float thresh) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } detection_layer l = net.layers[net.n-1]; set_batch_network(&net, 1); srand(2222222); clock_t time; char buff[256]; char *input = buff; int j; float nms=.5; box *boxes = calloc(l.side*l.side*l.n, sizeof(box)); float **probs = calloc(l.side*l.side*l.n, sizeof(float *)); for(j = 0; j < l.side*l.side*l.n; ++j) probs[j] = calloc(l.classes, sizeof(float *)); 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(); float *predictions = network_predict(net, X); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, thresh, probs, boxes, 0); if (nms) do_nms_sort(boxes, probs, l.side*l.side*l.n, l.classes, nms); //draw_detections(im, l.side*l.side*l.n, thresh, boxes, probs, voc_names, voc_labels, 20); draw_detections(im, l.side*l.side*l.n, thresh, boxes, probs, voc_names, 0, 20); show_image(im, "predictions"); save_image(im, "predictions"); show_image(sized, "resized"); free_image(im); free_image(sized); #ifdef OPENCV cvWaitKey(0); cvDestroyAllWindows(); #endif if (filename) break; } }
void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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"); int 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; 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); float *X = r.data; time=clock(); float *predictions = network_predict(net, X); top_predictions(net, top, indexes); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); for(i = 0; i < top; ++i){ int index = indexes[i]; printf("%s: %f\n", names[index], predictions[index]); } if(r.data != im.data) free_image(r); free_image(im); if (filename) break; } }
int Darknet::loadNetwork(const QString &cfg, const QString &weights) { priv->net = parse_network_cfg((char *)qPrintable(getAbs(cfg))); load_weights(&priv->net, (char *)qPrintable(getAbs(weights))); set_batch_network(&priv->net, 1); priv->l = priv->net.layers[priv->net.n-1]; priv->boxes = (box *)calloc(priv->l.side*priv->l.side*priv->l.n, sizeof(box)); priv->probs = (float **)calloc(priv->l.side*priv->l.side*priv->l.n, sizeof(float *)); for(int j = 0; j < priv->l.side * priv->l.side * priv->l.n; ++j) priv->probs[j] = (float *)calloc(priv->l.classes, sizeof(float *)); return 0; }
void ofxDarknet::init( std::string cfgfile, std::string weightfile, std::string nameslist ) { if (nameslist != "") { labelsAvailable = true; } net = parse_network_cfg( cfgfile.c_str() ); load_weights( &net, weightfile.c_str() ); set_batch_network( &net, 1 ); if (!nameslist.empty()){ names = get_labels( (char *) nameslist.c_str() ); } // load layer names int numLayerTypes = 24; int * counts = new int[ numLayerTypes ]; for (int i=0; i<numLayerTypes; i++) {counts[i] = 0;} for (int i=0; i<net.n; i++) { LAYER_TYPE type = net.layers[i].type; string layerName = "Unknown"; if (type == CONVOLUTIONAL) layerName = "Conv"; else if (type == DECONVOLUTIONAL) layerName = "Deconv"; else if (type == CONNECTED) layerName = "FC"; else if (type == MAXPOOL) layerName = "MaxPool"; else if (type == SOFTMAX) layerName = "Softmax"; else if (type == DETECTION) layerName = "Detect"; else if (type == DROPOUT) layerName = "Dropout"; else if (type == CROP) layerName = "Crop"; else if (type == ROUTE) layerName = "Route"; else if (type == COST) layerName = "Cost"; else if (type == NORMALIZATION) layerName = "Normalize"; else if (type == AVGPOOL) layerName = "AvgPool"; else if (type == LOCAL) layerName = "Local"; else if (type == SHORTCUT) layerName = "Shortcut"; else if (type == ACTIVE) layerName = "Active"; else if (type == RNN) layerName = "RNN"; else if (type == GRU) layerName = "GRU"; else if (type == CRNN) layerName = "CRNN"; else if (type == BATCHNORM) layerName = "Batchnorm"; else if (type == NETWORK) layerName = "Network"; else if (type == XNOR) layerName = "XNOR"; else if (type == REGION) layerName = "Region"; else if (type == REORG) layerName = "Reorg"; else if (type == BLANK) layerName = "Blank"; layerNames.push_back(layerName+" "+ofToString(counts[type])); counts[type] += 1; } delete counts; loaded = true; }
int darknet_load_network(struct darknet_helper *dnet, const char *cfg, const char *weights) { dnet->priv->net = parse_network_cfg((char *)cfg); load_weights(&dnet->priv->net, (char *)weights); set_batch_network(&dnet->priv->net, 1); detection_layer l = dnet->priv->net.layers[dnet->priv->net.n-1]; dnet->priv->boxes = (box *)calloc(l.side*l.side*l.n, sizeof(box)); dnet->priv->probs = (float **)calloc(l.side*l.side*l.n, sizeof(float *)); int j; for(j = 0; j < l.side * l.side * l.n; ++j) dnet->priv->probs[j] = (float *)calloc(l.classes, sizeof(float *)); return 0; }
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_writing(char *cfgfile, char *weightfile, char *filename) { network * net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(net, weightfile); } 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); resize_network(net, im.w, im.h); printf("%d %d %d\n", im.h, im.w, im.c); float *X = im.data; time=clock(); network_predict(net, X); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); image pred = get_network_image(net); image upsampled = resize_image(pred, im.w, im.h); image thresh = threshold_image(upsampled, .5); pred = thresh; show_image(pred, "prediction"); show_image(im, "orig"); #ifdef OPENCV cvWaitKey(0); cvDestroyAllWindows(); #endif free_image(upsampled); free_image(thresh); free_image(im); if (filename) break; } }
void test_mnist_multi(char *filename, char *weightfile) { network net = parse_network_cfg(filename); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(time(0)); float avg_acc = 0; data test; test = load_mnist_data("data/mnist/t10k-images.idx3-ubyte", "data/mnist/t10k-labels.idx1-ubyte", 10000); int i; for(i = 0; i < test.X.rows; ++i){ image im = float_to_image(28, 28, 1, test.X.vals[i]); float pred[10] = {0}; float *p = network_predict(net, im.data); axpy_cpu(10, 1, p, 1, pred, 1); // flip_image(im); image im1 = rotate_image(im, -2.0*3.1415926/180.0); image im2 = rotate_image(im, 2.0*3.1415926/180.0); image im3 = rotate_image(im, -3.0*3.1415926/180.0); image im4 = rotate_image(im, 3.0*3.1415926/180.0); p = network_predict(net, im1.data); axpy_cpu(10, 1, p, 1, pred, 1); p = network_predict(net, im2.data); axpy_cpu(10, 1, p, 1, pred, 1); p = network_predict(net, im3.data); axpy_cpu(10, 1, p, 1, pred, 1); p = network_predict(net, im4.data); axpy_cpu(10, 1, p, 1, pred, 1); int index = max_index(pred, 10); int class = max_index(test.y.vals[i], 10); if(index == class) avg_acc += 1; free_image(im); free_image(im1); free_image(im2); free_image(im3); free_image(im4); printf("%4d: %.2f%%\n", i, 100.*avg_acc/(i+1)); } printf("%4d: %.2f%%\n", i, 100.*avg_acc/(i+1)); }
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 test_tag(char *cfgfile, char *weightfile, char *filename) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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); float *X = r.data; time=clock(); float *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 speed(char *cfgfile, int tics) { if (tics == 0) tics = 1000; network *net = parse_network_cfg(cfgfile); set_batch_network(net, 1); int i; double time=what_time_is_it_now(); image im = make_image(net->w, net->h, net->c*net->batch); for(i = 0; i < tics; ++i){ network_predict(net, im.data); } double t = what_time_is_it_now() - time; long ops = numops(net); printf("\n%d evals, %f Seconds\n", tics, t); printf("Floating Point Operations: %.2f Bn\n", (float)ops/1000000000.); printf("FLOPS: %.2f Bn\n", (float)ops/1000000000.*tics/t); printf("Speed: %f sec/eval\n", t/tics); printf("Speed: %f Hz\n", tics/t); }
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 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 valid_captcha(char *cfgfile, char *weightfile, char *filename) { char **labels = get_labels("/data/captcha/reimgs.labels.list"); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } list *plist = get_paths("/data/captcha/reimgs.fg.list"); char **paths = (char **)list_to_array(plist); int N = plist->size; int outputs = net.outputs; set_batch_network(&net, 1); srand(2222222); int i, j; for(i = 0; i < N; ++i){ if (i%100 == 0) fprintf(stderr, "%d\n", i); image im = load_image_color(paths[i], net.w, net.h); float *X = im.data; float *predictions = network_predict(net, X); //printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); int truth = -1; for(j = 0; j < 13; ++j){ if (strstr(paths[i], labels[j])) truth = j; } if (truth == -1){ fprintf(stderr, "bad: %s\n", paths[i]); return; } printf("%d, ", truth); for(j = 0; j < outputs; ++j){ if (j != 0) printf(", "); printf("%f", predictions[j]); } printf("\n"); fflush(stdout); free_image(im); if (filename) break; } }