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_move(network net, float *board, float *move, int multi) { float *output = network_predict(net, board); copy_cpu(19*19, output, 1, move, 1); int i; if(multi){ image bim = float_to_image(19, 19, 1, board); for(i = 1; i < 8; ++i){ rotate_image_cw(bim, i); if(i >= 4) flip_image(bim); float *output = network_predict(net, board); image oim = float_to_image(19, 19, 1, output); if(i >= 4) flip_image(oim); rotate_image_cw(oim, -i); axpy_cpu(19*19, 1, output, 1, move, 1); if(i >= 4) flip_image(bim); rotate_image_cw(bim, -i); } scal_cpu(19*19, 1./8., move, 1); } for(i = 0; i < 19*19; ++i){ if(board[i]) move[i] = 0; } }
void test_char_rnn(char *cfgfile, char *weightfile, int num, char *seed, float 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 = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } int inputs = get_network_input_size(net); int i, j; for(i = 0; i < net.n; ++i) net.layers[i].temperature = temp; int c = 0; int len = strlen(seed); float *input = calloc(inputs, sizeof(float)); /* 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; float *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 valid_tactic_rnn(char *cfgfile, char *weightfile, char *seed) { char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } int inputs = get_network_input_size(net); int count = 0; int words = 1; int c; int len = strlen(seed); float *input = calloc(inputs, sizeof(float)); int i; for(i = 0; i < len; ++i){ c = seed[i]; input[(int)c] = 1; network_predict(net, input); input[(int)c] = 0; } float sum = 0; c = getc(stdin); float 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; float *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 vec_char_rnn(char *cfgfile, char *weightfile, char *seed) { char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } int inputs = get_network_input_size(net); int c; int seed_len = strlen(seed); float *input = calloc(inputs, sizeof(float)); int i; char *line; while((line=fgetl(stdin)) != 0){ reset_rnn_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 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_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); } }
/* * do prediction *@param[in]: yoloctx, context *@param[in]: filename, input picture *@param[in]: thresh, threshold for probability x confidence level *@param[out]: predictions, store detected objects */ void yoloPredict(context_param_yolo_t *yoloctx, char *filename, float thresh, yoloPredictions *predictions) { printf("YOLO predict\n"); int nwidth = yoloctx->_nwidth; int nheight = yoloctx->_nheight; int side = yoloctx->_grid.grids; int classes = yoloctx->_grid.classes; int bbs = yoloctx->_grid.bbs; int sqrt = yoloctx->_sqrt; float nms = yoloctx->_nms; image im = load_image_color(filename, 0, 0); image sized = resize_image(im, nwidth, nheight); resetData(yoloctx); float *x = sized.data; float *fpredictions = network_predict(yoloctx->_net, x); float **probs = yoloctx->_grid.probs; box *boxes = yoloctx->_grid.boxes; convertDetections(fpredictions, classes, bbs, sqrt, side, 1, 1, thresh, probs, boxes, 0); if (nms) do_nms_sort(boxes, probs, side*side*bbs, classes, nms); convertResults(im.w, im.h, side*side*bbs, thresh, boxes, probs, class_names, 20, predictions); //free(predictions); free_image(sized); free_image(im); }
void yolo_net_predict(network *pNet, char *imgfilename, char * resfile, float thresh){ detection_layer l = pNet->layers[pNet->n-1]; 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 *)); image im = load_image_color(imgfilename,0,0); image resized = resize_image(im, pNet->w, pNet->h); float *X = resized.data; time=clock(); float *predictions = network_predict(*pNet, X); free_image(im); printf("%s: Predicted in %f seconds.\n", imgfilename, sec(clock()-time)); FILE *ofp = fopen(resfile, "w"); if (ofp == NULL) {fprintf(stderr, "Can't open output file %s!\n",resfile); exit(1);} //convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, demo_thresh, probs, boxes, 0); convert_print_yolo_detections(ofp, 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); fclose(ofp); }
std::vector< classification > ofxDarknet::classify( ofPixels & pix, int count ) { int *indexes = ( int* ) calloc( count, sizeof( int ) ); ofPixels pix2( pix ); if (pix2.getImageType() != OF_IMAGE_COLOR) { pix2.setImageType(OF_IMAGE_COLOR); } if( pix2.getWidth() != net.w && pix2.getHeight() != net.h ) { pix2.resize( net.w, net.h ); } image im = convert( pix2 ); float *predictions = network_predict( net, im.data1 ); top_k( predictions, net.outputs, count, indexes ); std::vector< classification > classifications; for( int i = 0; i < count; ++i ) { int index = indexes[ i ]; classification c; c.label = labelsAvailable ? names[ index ] : ofToString(index); c.probability = predictions[ index ]; classifications.push_back( c ); } free_image( im ); free(indexes); return classifications; }
void test_cgm(char *cfgfile, char *weightfile, char *session) { char *base = basecfg(cfgfile); printf("%s\n", base); network net = parse_network_cfg(cfgfile); load_weights(&net, weightfile); freopen("out.txt", "w", stdout); int input_len = net.w; int stride = net.w/4; int i,j,k; data train; train.shallow = 0; train.X = make_matrix(128, net.w*net.h*net.c); train.y = make_matrix(128, 1); float cbuf[4096*16]; int cidx = 0; int cnt = 0; int cntstride = 0; int freq[16] = {0}; FILE *fp = fopen(session, "rb"); if(!fp) file_error(session); while (!feof(fp)) { unsigned short bytes[11]; fread(bytes, 2, 11, fp); float fbytes[2]; fread(fbytes, 4, 2, fp); // put into circular buffer for (j=0;j<10;j++) cbuf[cidx+(j<<12)] = (float)(bytes[j])/65536.f; cidx = (1+cidx)&4095; cnt++; cntstride++; if (fbytes[0]>54 && cnt>input_len && cntstride>stride) { cntstride = 0; train.y.vals[0][0] = (fbytes[0]-50)/200.0; for (k=0;k<net.w;k++) for (j=0;j<10;j++) { train.X.vals[0][(j*net.w)+k] = cbuf[(j<<12)+(((cidx-1-net.w+k)+4096)&4095)]; } float *p = network_predict(net, train.X.vals[0]); // fprintf(stderr, "%f, %f\n", train.y.vals[0][0], p[0]); p[0] = (p[0]*200.0)+50.0; fprintf(stdout, "%f, %f\n", fbytes[0], p[0]); fprintf(stderr, "%f, %f\n", fbytes[0], p[0]); } } fclose(fp); free_network(net); free_data(train); }
void valid_char_rnn(char *cfgfile, char *weightfile) { char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } int inputs = get_network_input_size(net); int count = 0; int c; float *input = calloc(inputs, sizeof(float)); float sum = 0; c = getc(stdin); float log2 = log(2); while(c != EOF){ int next = getc(stdin); if(next == EOF) break; ++count; input[c] = 1; float *out = network_predict(net, input); input[c] = 0; sum += log(out[next])/log2; c = next; } printf("Perplexity: %f\n", pow(2, -sum/count)); }
void *detect_in_thread(void *ptr) { float nms = .4; layer l = net.layers[net.n-1]; float *X = det_s.data; float *prediction = network_predict(net, X); memcpy(predictions[demo_index], prediction, l.outputs*sizeof(float)); mean_arrays(predictions, FRAMES, l.outputs, avg); l.output = avg; free_image(det_s); if(l.type == DETECTION){ get_detection_boxes(l, 1, 1, demo_thresh, probs, boxes, 0); } else if (l.type == REGION){ get_region_boxes(l, 1, 1, demo_thresh, probs, boxes, 0, 0, demo_hier_thresh); } else { error("Last layer must produce detections\n"); } if (nms > 0) do_nms(boxes, probs, l.w*l.h*l.n, l.classes, nms); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.1f\n",fps); printf("Objects:\n\n"); images[demo_index] = det; det = images[(demo_index + FRAMES/2 + 1)%FRAMES]; demo_index = (demo_index + 1)%FRAMES; draw_detections(det, l.w*l.h*l.n, demo_thresh, boxes, probs, demo_names, demo_alphabet, demo_classes); return 0; }
void *detect_in_thread(void *ptr) { float nms = .4; detection_layer l = net.layers[net.n-1]; float *X = det_s.data; float *prediction = network_predict(net, X); memcpy(predictions[demo_index], prediction, l.outputs*sizeof(float)); mean_arrays(predictions, FRAMES, l.outputs, avg); free_image(det_s); convert_detections(avg, l.classes, l.n, l.sqrt, l.side, 1, 1, demo_thresh, probs, boxes, 0); if (nms > 0) do_nms(boxes, probs, l.side*l.side*l.n, l.classes, nms); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.1f\n",fps); printf("Objects:\n\n"); images[demo_index] = det; det = images[(demo_index + FRAMES/2 + 1)%FRAMES]; demo_index = (demo_index + 1)%FRAMES; draw_detections(det, l.side*l.side*l.n, demo_thresh, boxes, probs, demo_names, demo_labels, demo_classes); return 0; }
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 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 Darknet::yoloImage(const QString &filename, float thresh) { const Mat ori = OpenCV::loadImage(getAbs(filename), -1); Mat img; cv::resize(ori, img, cv::Size(priv->net.w, priv->net.h)); image im = toDarkImage(img); //image im = load_image_color((char *)qPrintable(getAbs(filename)), 0, 0); //image sized = resize_image(im, priv->net.w, priv->net.h); //float *X = sized.data; float *X = im.data; float *predictions = network_predict(priv->net, X); float nms=.5; const detection_layer l = priv->l; convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, thresh, priv->probs, priv->boxes, 0); if (nms) do_nms_sort(priv->boxes, priv->probs, l.side*l.side*l.n, l.classes, nms); draw_detections(im, l.side*l.side*l.n, thresh, priv->boxes, priv->probs, voc_names, 0, 20); show_image(im, "predictions"); save_image(im, "predictions"); //show_image(sized, "resized"); free_image(im); //free_image(sized); }
void *detect_in_thread(void *ptr) { running = 1; float nms = .4; layer l = net.layers[net.n-1]; float *X = buff_letter[(buff_index+2)%3].data; float *prediction = network_predict(net, X); memcpy(predictions[demo_index], prediction, l.outputs*sizeof(float)); mean_arrays(predictions, demo_frame, l.outputs, avg); l.output = last_avg2; if(demo_delay == 0) l.output = avg; if(l.type == DETECTION){ get_detection_boxes(l, 1, 1, demo_thresh, probs, boxes, 0); } else if (l.type == REGION){ get_region_boxes(l, buff[0].w, buff[0].h, net.w, net.h, demo_thresh, probs, boxes, 0, 0, demo_hier, 1); } else { error("Last layer must produce detections\n"); } if (nms > 0) do_nms_obj(boxes, probs, l.w*l.h*l.n, l.classes, nms); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.1f\n",fps); printf("Objects:\n\n"); image display = buff[(buff_index+2) % 3]; draw_detections(display, demo_detections, demo_thresh, boxes, probs, demo_names, demo_alphabet, demo_classes); demo_index = (demo_index + 1)%demo_frame; running = 0; return 0; }
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"); } }
std::string ofxDarknet::rnn(int num, std::string seed, float temp ) { int inputs = get_network_input_size( net ); for( int i = 0; i < net.n; ++i ) { net.layers[ i ].temperature = temp; } int c = 0; int len = seed.length(); float *input = ( float* ) calloc( inputs, sizeof( float ) ); std::string sampled_text; for( int i = 0; i < len - 1; ++i ) { c = seed[ i ]; input[ c ] = 1; network_predict( net, input ); input[ c ] = 0; char _c = c; sampled_text += _c; } if( len ) c = seed[ len - 1 ]; char _c = c; sampled_text += _c; for( int i = 0; i < num; ++i ) { input[ c ] = 1; float *out = network_predict( net, input ); input[ c ] = 0; for( int j = 0; j < inputs; ++j ) { if( out[ j ] < .0001 ) out[ j ] = 0; } c = sample_array( out, inputs ); char _c = c; sampled_text += _c; } delete input; return sampled_text; }
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 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 test_tactic_rnn(char *cfgfile, char *weightfile, int num, float 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 = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } int inputs = get_network_input_size(net); int i, j; for(i = 0; i < net.n; ++i) net.layers[i].temperature = temp; int c = 0; float *input = calloc(inputs, sizeof(float)); float *out = 0; while((c = getc(stdin)) != EOF){ 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 valid_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 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); while (c != EOF) { int next = getc(stdin); if (next == EOF) break; if (next < 0 || next >= 255) error("Out of range character"); ++count; if (next == ' ' || next == '\n' || next == '\t') ++words; input[c] = 1; real_t *out = network_predict(net, input); input[c] = 0; sum += log(out[next]) / log2; c = next; printf("%d BPC: %4.4f Perplexity: %4.4f Word Perplexity: %4.4f\n", count, -sum / count, pow(2, -sum / count), pow(2, -sum / words)); } }
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; } }