void train_super(char *cfgfile, char *weightfile, int clear) { char *train_images = "/data/imagenet/imagenet1k.train.list"; char *backup_directory = "/home/pjreddie/backup/"; srand(time(0)); char *base = basecfg(cfgfile); printf("%s\n", base); float avg_loss = -1; network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } if(clear) *net.seen = 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; 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.scale = 4; args.paths = paths; args.n = imgs; args.m = plist->size; args.d = &buffer; args.type = SUPER_DATA; #ifdef __linux__ pthread_t load_thread = load_data_in_thread(args); #endif clock_t time; //while(i*imgs < N*120){ while(get_current_batch(net) < net.max_batches){ i += 1; time=clock(); #ifdef __linux__ pthread_join(load_thread, 0); #endif train = buffer; #ifdef __linux__ load_thread = load_data_in_thread(args); #endif 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){ char buff[256]; sprintf(buff, "%s/%s_%d.weights", backup_directory, base, i); save_weights(net, buff); } if(i%100==0){ char buff[256]; sprintf(buff, "%s/%s.backup", backup_directory, base); save_weights(net, buff); } free_data(train); } char buff[256]; sprintf(buff, "%s/%s_final.weights", backup_directory, base); save_weights(net, buff); }
void validate_coco_recall(char *cfgfile, char *weightfile) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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("/home/pjreddie/data/voc/test/2007_test.txt"); char **paths = (char **)list_to_array(plist); layer l = net.layers[net.n-1]; int classes = l.classes; int square = l.sqrt; 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, coco_classes[j]); fps[j] = fopen(buff, "w"); } box *boxes = calloc(side*side*l.n, sizeof(box)); float **probs = calloc(side*side*l.n, sizeof(float *)); for(j = 0; j < side*side*l.n; ++j) probs[j] = calloc(classes, sizeof(float *)); int m = plist->size; int i=0; float thresh = .001; int nms = 0; float iou_thresh = .5; float nms_thresh = .5; 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); float *predictions = network_predict(net, sized.data); convert_coco_detections(predictions, classes, l.n, square, side, 1, 1, thresh, probs, boxes, 1); if (nms) do_nms(boxes, probs, side*side*l.n, 1, nms_thresh); char *labelpath = find_replace(path, "images", "labels"); labelpath = find_replace(labelpath, "JPEGImages", "labels"); labelpath = find_replace(labelpath, ".jpg", ".txt"); labelpath = find_replace(labelpath, ".JPEG", ".txt"); int num_labels = 0; box_label *truth = read_boxes(labelpath, &num_labels); for(k = 0; k < side*side*l.n; ++k){ if(probs[k][0] > 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(boxes[k], t); if(probs[k][0] > 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(id); free_image(orig); free_image(sized); } }
void train_char_rnn(char *cfgfile, char *weightfile, char *filename, int clear, int tokenized) { srand(time(0)); unsigned char *text = 0; int *tokens = 0; size_t size; if(tokenized){ tokens = read_tokenized_data(filename, &size); } else { FILE *fp = fopen(filename, "rb"); fseek(fp, 0, SEEK_END); size = ftell(fp); fseek(fp, 0, SEEK_SET); text = calloc(size+1, sizeof(char)); fread(text, 1, size, fp); fclose(fp); } char *backup_directory = "/home/pjreddie/backup/"; char *base = basecfg(cfgfile); fprintf(stderr, "%s\n", base); float avg_loss = -1; network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } int inputs = get_network_input_size(net); fprintf(stderr, "Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay); int batch = net.batch; int steps = net.time_steps; if(clear) *net.seen = 0; int i = (*net.seen)/net.batch; int streams = batch/steps; size_t *offsets = calloc(streams, sizeof(size_t)); int j; for(j = 0; j < streams; ++j){ offsets[j] = rand_size_t()%size; } clock_t time; while(get_current_batch(net) < net.max_batches){ i += 1; time=clock(); float_pair p; if(tokenized){ p = get_rnn_token_data(tokens, offsets, inputs, size, streams, steps); }else{ p = get_rnn_data(text, offsets, inputs, size, streams, steps); } float loss = train_network_datum(net, p.x, p.y) / (batch); free(p.x); free(p.y); if (avg_loss < 0) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; int chars = get_current_batch(net)*batch; fprintf(stderr, "%d: %f, %f avg, %f rate, %lf seconds, %f epochs\n", i, loss, avg_loss, get_current_rate(net), sec(clock()-time), (float) chars/size); for(j = 0; j < streams; ++j){ //printf("%d\n", j); if(rand()%10 == 0){ //fprintf(stderr, "Reset\n"); offsets[j] = rand_size_t()%size; reset_rnn_state(net, j); } } if(i%1000==0){ char buff[256]; sprintf(buff, "%s/%s_%d.weights", backup_directory, base, i); save_weights(net, buff); } if(i%10==0){ char buff[256]; sprintf(buff, "%s/%s.backup", backup_directory, base); save_weights(net, buff); } } char buff[256]; sprintf(buff, "%s/%s_final.weights", backup_directory, base); save_weights(net, buff); }
void test_go(char *filename, char *weightfile, int multi) { network net = parse_network_cfg(filename); if(weightfile){ load_weights(&net, weightfile); } srand(time(0)); set_batch_network(&net, 1); float *board = calloc(19*19, sizeof(float)); float *move = calloc(19*19, sizeof(float)); int color = 1; while(1){ float *output = network_predict(net, board); fltcpy(move, output, 19 * 19); 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); fltadd(move, output, 19 * 19); 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; } int indexes[nind]; int row, col; top_k(move, 19*19, nind, indexes); print_board(board, color, indexes); for(i = 0; i < nind; ++i){ int index = indexes[i]; row = index / 19; col = index % 19; printf("%d: %c %d, %.2f%%\n", i+1, col + 'A' + 1*(col > 7 && noi), (inverted)?19 - row : row+1, move[index]*100); } if(color == 1) printf("\u25EF Enter move: "); else printf("\u25C9 Enter move: "); char c; char *line = fgetl(stdin); int picked = 1; int dnum = sscanf(line, "%d", &picked); int cnum = sscanf(line, "%c", &c); if (strlen(line) == 0 || dnum) { --picked; if (picked < nind){ int index = indexes[picked]; row = index / 19; col = index % 19; board[row*19 + col] = 1; } } else if (cnum){ if (c <= 'T' && c >= 'A'){ int num = sscanf(line, "%c %d", &c, &row); row = (inverted)?19 - row : row-1; col = c - 'A'; if (col > 7 && noi) col -= 1; if (num == 2) board[row*19 + col] = 1; } else if (c == 'p') { // Pass } else if(c=='b' || c == 'w'){ char g; int num = sscanf(line, "%c %c %d", &g, &c, &row); row = (inverted)?19 - row : row-1; col = c - 'A'; if (col > 7 && noi) col -= 1; if (num == 3) board[row*19 + col] = (g == 'b') ? color : -color; } else if(c == 'c'){ char g; int num = sscanf(line, "%c %c %d", &g, &c, &row); row = (inverted)?19 - row : row-1; col = c - 'A'; if (col > 7 && noi) col -= 1; if (num == 3) board[row*19 + col] = 0; } } free(line); update_board(board); flip_board(board); color = -color; } }
void validate_coco(char *cfgfile, char *weightfile) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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/"; list *plist = get_paths("data/coco_val_5k.list"); //list *plist = get_paths("/home/pjreddie/data/people-art/test.txt"); //list *plist = get_paths("/home/pjreddie/data/voc/test/2007_test.txt"); char **paths = (char **)list_to_array(plist); layer l = net.layers[net.n-1]; int classes = l.classes; int square = l.sqrt; int side = l.side; int j; char buff[1024]; snprintf(buff, 1024, "%s/coco_results.json", base); FILE *fp = fopen(buff, "w"); fprintf(fp, "[\n"); box *boxes = calloc(side*side*l.n, sizeof(box)); float **probs = calloc(side*side*l.n, sizeof(float *)); for(j = 0; j < side*side*l.n; ++j) probs[j] = calloc(classes, sizeof(float *)); int m = plist->size; int i=0; int t; float thresh = .01; 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]; int image_id = get_coco_image_id(path); float *X = val_resized[t].data; float *predictions = network_predict(net, X); int w = val[t].w; int h = val[t].h; convert_coco_detections(predictions, classes, l.n, square, side, w, h, thresh, probs, boxes, 0); if (nms) do_nms_sort(boxes, probs, side*side*l.n, classes, iou_thresh); print_cocos(fp, image_id, boxes, probs, side*side*l.n, classes, w, h); free_image(val[t]); free_image(val_resized[t]); } } fseek(fp, -2, SEEK_CUR); fprintf(fp, "\n]\n"); fclose(fp); fprintf(stderr, "Total Detection Time: %f Seconds\n", (double)(time(0) - start)); }
void engine_go(char *filename, char *weightfile, int multi) { network net = parse_network_cfg(filename); if(weightfile){ load_weights(&net, weightfile); } srand(time(0)); set_batch_network(&net, 1); float *board = calloc(19*19, sizeof(float)); char *one = calloc(91, sizeof(char)); char *two = calloc(91, sizeof(char)); int passed = 0; while(1){ char buff[256]; int id = 0; int has_id = (scanf("%d", &id) == 1); scanf("%s", buff); if (feof(stdin)) break; char ids[256]; sprintf(ids, "%d", id); //fprintf(stderr, "%s\n", buff); if (!has_id) ids[0] = 0; if (!strcmp(buff, "protocol_version")){ printf("=%s 2\n\n", ids); } else if (!strcmp(buff, "name")){ printf("=%s DarkGo\n\n", ids); } else if (!strcmp(buff, "version")){ printf("=%s 1.0\n\n", ids); } else if (!strcmp(buff, "known_command")){ char comm[256]; scanf("%s", comm); int known = (!strcmp(comm, "protocol_version") || !strcmp(comm, "name") || !strcmp(comm, "version") || !strcmp(comm, "known_command") || !strcmp(comm, "list_commands") || !strcmp(comm, "quit") || !strcmp(comm, "boardsize") || !strcmp(comm, "clear_board") || !strcmp(comm, "komi") || !strcmp(comm, "final_status_list") || !strcmp(comm, "play") || !strcmp(comm, "genmove")); if(known) printf("=%s true\n\n", ids); else printf("=%s false\n\n", ids); } else if (!strcmp(buff, "list_commands")){ printf("=%s protocol_version\nname\nversion\nknown_command\nlist_commands\nquit\nboardsize\nclear_board\nkomi\nplay\ngenmove\nfinal_status_list\n\n", ids); } else if (!strcmp(buff, "quit")){ break; } else if (!strcmp(buff, "boardsize")){ int boardsize = 0; scanf("%d", &boardsize); //fprintf(stderr, "%d\n", boardsize); if(boardsize != 19){ printf("?%s unacceptable size\n\n", ids); } else { printf("=%s \n\n", ids); } } else if (!strcmp(buff, "clear_board")){ passed = 0; memset(board, 0, 19*19*sizeof(float)); printf("=%s \n\n", ids); } else if (!strcmp(buff, "komi")){ float komi = 0; scanf("%f", &komi); printf("=%s \n\n", ids); } else if (!strcmp(buff, "play")){ char color[256]; scanf("%s ", color); char c; int r; int count = scanf("%c%d", &c, &r); int player = (color[0] == 'b' || color[0] == 'B') ? 1 : -1; if(c == 'p' && count < 2) { passed = 1; printf("=%s \n\n", ids); char *line = fgetl(stdin); free(line); fflush(stdout); fflush(stderr); continue; } else { passed = 0; } if(c >= 'A' && c <= 'Z') c = c - 'A'; if(c >= 'a' && c <= 'z') c = c - 'a'; if(c >= 8) --c; r = 19 - r; fprintf(stderr, "move: %d %d\n", r, c); char *swap = two; two = one; one = swap; move_go(board, player, r, c); board_to_string(one, board); printf("=%s \n\n", ids); print_board(board, 1, 0); } else if (!strcmp(buff, "genmove")){ char color[256]; scanf("%s", color); int player = (color[0] == 'b' || color[0] == 'B') ? 1 : -1; int index = generate_move(net, player, board, multi, .1, .7, two, 1); if(passed || index < 0){ printf("=%s pass\n\n", ids); passed = 0; } else { int row = index / 19; int col = index % 19; char *swap = two; two = one; one = swap; move_go(board, player, row, col); board_to_string(one, board); row = 19 - row; if (col >= 8) ++col; printf("=%s %c%d\n\n", ids, 'A' + col, row); print_board(board, 1, 0); } } else if (!strcmp(buff, "p")){ //print_board(board, 1, 0); } else if (!strcmp(buff, "final_status_list")){ char type[256]; scanf("%s", type); fprintf(stderr, "final_status\n"); char *line = fgetl(stdin); free(line); if(type[0] == 'd' || type[0] == 'D'){ FILE *f = fopen("game.txt", "w"); int i, j; int count = 2; fprintf(f, "boardsize 19\n"); fprintf(f, "clear_board\n"); for(j = 0; j < 19; ++j){ for(i = 0; i < 19; ++i){ if(board[j*19 + i] == 1) fprintf(f, "play black %c%d\n", 'A'+i+(i>=8), 19-j); if(board[j*19 + i] == -1) fprintf(f, "play white %c%d\n", 'A'+i+(i>=8), 19-j); if(board[j*19 + i]) ++count; } } fprintf(f, "final_status_list dead\n"); fclose(f); FILE *p = popen("./gnugo --mode gtp < game.txt", "r"); for(i = 0; i < count; ++i){ free(fgetl(p)); free(fgetl(p)); } char *l = 0; while((l = fgetl(p))){ printf("%s\n", l); free(l); } } else { printf("?%s unknown command\n\n", ids); } } else { char *line = fgetl(stdin); free(line); printf("?%s unknown command\n\n", ids); } fflush(stdout); fflush(stderr); } }
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] = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&nets[i], weightfile); } if(clear) *nets[i].seen = 0; 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"); 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.min = net.min_crop; args.max = net.max_crop; 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); free_network(net); free_ptrs((void**)paths, plist->size); free_list(plist); free(base); }
void demo_classifier(char *datacfg, char *cfgfile, char *weightfile, int cam_index, const char *filename) { #ifdef OPENCV printf("Classifier Demo\n"); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); list *options = read_data_cfg(datacfg); srand(2222222); CvCapture * cap; if(filename){ cap = cvCaptureFromFile(filename); }else{ cap = cvCaptureFromCAM(cam_index); } int top = option_find_int(options, "top", 1); char *name_list = option_find_str(options, "names", 0); char **names = get_labels(name_list); int *indexes = calloc(top, sizeof(int)); if(!cap) error("Couldn't connect to webcam.\n"); cvNamedWindow("Classifier", CV_WINDOW_NORMAL); cvResizeWindow("Classifier", 512, 512); float fps = 0; int i; while(1){ struct timeval tval_before, tval_after, tval_result; gettimeofday(&tval_before, NULL); image in = get_image_from_stream(cap); image in_s = resize_image(in, net.w, net.h); show_image(in, "Classifier"); float *predictions = network_predict(net, in_s.data); top_predictions(net, top, indexes); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.0f\n",fps); for(i = 0; i < top; ++i){ int index = indexes[i]; printf("%.1f%%: %s\n", predictions[index]*100, names[index]); } 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 demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, image *labels, int classes, int frame_skip) { //skip = frame_skip; int delay = frame_skip; demo_names = names; demo_labels = labels; demo_classes = classes; demo_thresh = thresh; printf("Demo\n"); net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); if(filename){ cap = cvCaptureFromFile(filename); }else{ cap = cvCaptureFromCAM(cam_index); } if(!cap) error("Couldn't connect to webcam.\n"); detection_layer l = net.layers[net.n-1]; int j; avg = (float *) calloc(l.outputs, sizeof(float)); for(j = 0; j < FRAMES; ++j) predictions[j] = (float *) calloc(l.outputs, sizeof(float)); for(j = 0; j < FRAMES; ++j) images[j] = make_image(1,1,3); boxes = (BOX *)calloc(l.side*l.side*l.n, sizeof(BOX)); probs = (float **)calloc(l.side*l.side*l.n, sizeof(float *)); for(j = 0; j < l.side*l.side*l.n; ++j) probs[j] = (float *)calloc(l.classes, sizeof(float *)); pthread_t fetch_thread; pthread_t detect_thread; fetch_in_thread(0); det = in; det_s = in_s; fetch_in_thread(0); detect_in_thread(0); disp = det; det = in; det_s = in_s; for(j = 0; j < FRAMES/2; ++j){ fetch_in_thread(0); detect_in_thread(0); disp = det; det = in; det_s = in_s; } int count = 0; cvNamedWindow("Demo", CV_WINDOW_NORMAL); cvMoveWindow("Demo", 0, 0); cvResizeWindow("Demo", 1352, 1013); double before = get_wall_time(); while(1){ ++count; if(1){ if(pthread_create(&fetch_thread, 0, fetch_in_thread, 0)) error("Thread creation failed"); if(pthread_create(&detect_thread, 0, detect_in_thread, 0)) error("Thread creation failed"); show_image(disp, "Demo"); int c = cvWaitKey(1); if (c == 10){ if(frame_skip == 0) frame_skip = 60; else if(frame_skip == 4) frame_skip = 0; else if(frame_skip == 60) frame_skip = 4; else frame_skip = 0; } pthread_join(fetch_thread, 0); pthread_join(detect_thread, 0); if(delay == 0){ free_image(disp); disp = det; } det = in; det_s = in_s; }else { fetch_in_thread(0); det = in; det_s = in_s; detect_in_thread(0); if(delay == 0) { free_image(disp); disp = det; } show_image(disp, "Demo"); cvWaitKey(1); } --delay; if(delay < 0){ delay = frame_skip; double after = get_wall_time(); float curr = 1./(after - before); fps = curr; before = after; } } }
void validate_classifier_multi(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); int scales[] = {192, 224, 288, 320, 352}; int nscales = sizeof(scales)/sizeof(scales[0]); 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; } } float *pred = calloc(classes, sizeof(float)); image im = load_image_color(paths[i], 0, 0); for(j = 0; j < nscales; ++j){ image r = resize_min(im, scales[j]); resize_network(&net, r.w, r.h); float *p = network_predict(net, r.data); fltadd(pred, p, classes); flip_image(r); p = network_predict(net, r.data); fltadd(pred, p, classes); free_image(r); } free_image(im); top_k(pred, classes, topk, indexes); free(pred); 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_classifier(char *datacfg, char *cfgfile, char *weightfile, int target_layer) { int curr = 0; network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } srand(time(0)); list *options = read_data_cfg(datacfg); char *test_list = option_find_str(options, "test", "data/test.list"); int classes = option_find_int(options, "classes", 2); list *plist = get_paths(test_list); char **paths = (char **)list_to_array(plist); int m = plist->size; free_list(plist); clock_t time; data val, buffer; load_args args = {0}; args.w = net.w; args.h = net.h; args.paths = paths; args.classes = classes; args.n = net.batch; args.m = 0; args.labels = 0; args.d = &buffer; args.type = OLD_CLASSIFICATION_DATA; pthread_t load_thread = load_data_in_thread(args); for(curr = net.batch; curr < m; curr += net.batch){ time=clock(); pthread_join(load_thread, 0); val = buffer; if(curr < m){ args.paths = paths + curr; if (curr + net.batch > m) args.n = m - curr; load_thread = load_data_in_thread(args); } fprintf(stderr, "Loaded: %d images in %lf seconds\n", val.X.rows, sec(clock()-time)); time=clock(); matrix pred = network_predict_data(net, val); int i, j; if (target_layer >= 0){ //layer l = net.layers[target_layer]; } for(i = 0; i < pred.rows; ++i){ printf("%s", paths[curr-net.batch+i]); for(j = 0; j < pred.cols; ++j){ printf("\t%g", pred.vals[i][j]); } printf("\n"); } free_matrix(pred); fprintf(stderr, "%lf seconds, %d images, %d total\n", sec(clock()-time), val.X.rows, curr); free_data(val); } }
void train_classifier(char *datacfg, char *cfgfile, char *weightfile) { data_seed = time(0); srand(time(0)); float avg_loss = -1; char *base = basecfg(cfgfile); printf("%s\n", base); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay); int imgs = 1024; list *options = read_data_cfg(datacfg); char *backup_directory = option_find_str(options, "backup", "/backup/"); char *label_list = option_find_str(options, "labels", "data/labels.list"); char *train_list = option_find_str(options, "train", "data/train.list"); int classes = option_find_int(options, "classes", 2); char **labels = get_labels(label_list); 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; pthread_t load_thread; data train; data buffer; load_args args = {0}; args.w = net.w; args.h = net.h; args.min = net.w; args.max = net.max_crop; args.size = net.w; args.paths = paths; args.classes = classes; args.n = imgs; args.m = N; args.labels = labels; args.d = &buffer; args.type = CLASSIFICATION_DATA; load_thread = load_data_in_thread(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_in_thread(args); printf("Loaded: %lf seconds\n", sec(clock()-time)); time=clock(); /* int u; for(u = 0; u < net.batch; ++u){ image im = float_to_image(net.w, net.h, 3, train.X.vals[u]); show_image(im, "loaded"); cvWaitKey(0); } */ float loss = train_network(net, train); if(avg_loss == -1) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; printf("%d, %.3f: %f, %f avg, %f rate, %lf seconds, %d 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(*net.seen%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); pthread_join(load_thread, 0); free_data(buffer); free_network(net); free_ptrs((void**)labels, classes); free_ptrs((void**)paths, plist->size); free_list(plist); free(base); }
void validate_classifier_10(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)); 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; } } int w = net.w; int h = net.h; int shift = 32; image im = load_image_color(paths[i], w+shift, h+shift); image images[10]; images[0] = crop_image(im, -shift, -shift, w, h); images[1] = crop_image(im, shift, -shift, w, h); images[2] = crop_image(im, 0, 0, w, h); images[3] = crop_image(im, -shift, shift, w, h); images[4] = crop_image(im, shift, shift, w, h); flip_image(im); images[5] = crop_image(im, -shift, -shift, w, h); images[6] = crop_image(im, shift, -shift, w, h); images[7] = crop_image(im, 0, 0, w, h); images[8] = crop_image(im, -shift, shift, w, h); images[9] = crop_image(im, shift, shift, w, h); float *pred = calloc(classes, sizeof(float)); for(j = 0; j < 10; ++j){ float *p = network_predict(net, images[j].data); fltadd(pred, p, classes); free_image(images[j]); } free_image(im); top_k(pred, classes, topk, indexes); free(pred); 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 validate_classifier(char *datacfg, char *filename, char *weightfile) { int i = 0; network net = parse_network_cfg(filename); 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); clock_t time; float avg_acc = 0; float avg_topk = 0; int splits = m/1000; int num = (i+1)*m/splits - i*m/splits; data val, buffer; load_args args = {0}; args.w = net.w; args.h = net.h; args.paths = paths; args.classes = classes; args.n = num; args.m = 0; args.labels = labels; args.d = &buffer; args.type = OLD_CLASSIFICATION_DATA; pthread_t load_thread = load_data_in_thread(args); for(i = 1; i <= splits; ++i){ time=clock(); pthread_join(load_thread, 0); val = buffer; num = (i+1)*m/splits - i*m/splits; char **part = paths+(i*m/splits); if(i != splits){ args.paths = part; load_thread = load_data_in_thread(args); } printf("Loaded: %d images in %lf seconds\n", val.X.rows, sec(clock()-time)); time=clock(); float *acc = network_accuracies(net, val, topk); avg_acc += acc[0]; avg_topk += acc[1]; printf("%d: top 1: %f, top %d: %f, %lf seconds, %d images\n", i, avg_acc/i, topk, avg_topk/i, sec(clock()-time), val.X.rows); free_data(val); } }
void test_detector(char *datacfg, char *cfgfile, char *weightfile, char *filename, float thresh) { list *options = read_data_cfg(datacfg); printf("\ndatacfg: %s\n", datacfg); char *name_list = option_find_str(options, "names", "data/names.list"); char **names = get_labels(name_list); //printf("names: %s", names); //int i; //for(i = 0; i < 80; ++i){ // printf("names i %i, %s\n", i, names[i]); //} 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, 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); 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); 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; } }
void validate_recall(char *cfgfile, char *weightfile) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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 *val_images = "/home/pjreddie/data/voc/test/2007_test.txt"; list *plist = get_paths(val_images); char **paths = (char **)list_to_array(plist); layer l = net.layers[net.n - 1]; int num_boxes = l.side; int num = l.n; int classes = l.classes; int j; box *boxes = calloc(num_boxes*num_boxes*num, sizeof(box)); float **probs = calloc(num_boxes*num_boxes*num, sizeof(float *)); for(j = 0; j < num_boxes*num_boxes*num; ++j) probs[j] = calloc(classes+1, sizeof(float *)); int N = plist->size; int i=0; int k; float iou_thresh = .5; float thresh = .1; int total = 0; int correct = 0; float avg_iou = 0; int nms = 1; int proposals = 0; int save = 1; for (i = 0; i < N; ++i) { char *path = paths[i]; image orig = load_image_color(path, 0, 0); image resized = resize_image(orig, net.w, net.h); float *X = resized.data; float *predictions = network_predict(net, X); get_boxes(predictions+1+classes, num, num_boxes, 5+classes, boxes); get_probs(predictions, num*num_boxes*num_boxes, classes, 5+classes, probs); if (nms) do_nms(boxes, probs, num*num_boxes*num_boxes, (classes>0) ? classes : 1, iou_thresh); char *labelpath = find_replace(path, "images", "labels"); labelpath = find_replace(labelpath, "JPEGImages", "labels"); labelpath = find_replace(labelpath, ".jpg", ".txt"); labelpath = find_replace(labelpath, ".JPEG", ".txt"); int num_labels = 0; box_label *truth = read_boxes(labelpath, &num_labels); for(k = 0; k < num_boxes*num_boxes*num; ++k){ if(probs[k][0] > thresh){ ++proposals; if(save){ char buff[256]; sprintf(buff, "/data/extracted/nms_preds/%d", proposals); int dx = (boxes[k].x - boxes[k].w/2) * orig.w; int dy = (boxes[k].y - boxes[k].h/2) * orig.h; int w = boxes[k].w * orig.w; int h = boxes[k].h * orig.h; image cropped = crop_image(orig, dx, dy, w, h); image sized = resize_image(cropped, 224, 224); #ifdef OPENCV save_image_jpg(sized, buff); #endif free_image(sized); free_image(cropped); sprintf(buff, "/data/extracted/nms_pred_boxes/%d.txt", proposals); char *im_id = basecfg(path); FILE *fp = fopen(buff, "w"); fprintf(fp, "%s %d %d %d %d\n", im_id, dx, dy, dx+w, dy+h); fclose(fp); free(im_id); } } } 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 < num_boxes*num_boxes*num; ++k){ float iou = box_iou(boxes[k], t); if(probs[k][0] > thresh && iou > best_iou){ best_iou = iou; } } avg_iou += best_iou; if(best_iou > iou_thresh){ ++correct; } } free(truth); free_image(orig); free_image(resized); 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); } }
void validate_yolo(char *cfgfile, char *weightfile) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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"); } 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(classes, sizeof(float *)); 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; get_detection_boxes(l, w, h, thresh, probs, boxes, 0); if (nms) do_nms_sort_v2(boxes, probs, l.side*l.side*l.n, classes, iou_thresh); print_yolo_detections(fps, id, boxes, probs, l.side*l.side*l.n, classes, w, h); free(id); free_image(val[t]); free_image(val_resized[t]); } } fprintf(stderr, "Total Detection Time: %f Seconds\n", (double)(time(0) - start)); }
void extract_boxes(char *cfgfile, char *weightfile) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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 *val_images = "/home/pjreddie/data/voc/test/train.txt"; list *plist = get_paths(val_images); char **paths = (char **)list_to_array(plist); layer l = net.layers[net.n - 1]; int num_boxes = l.side; int num = l.n; int classes = l.classes; int j; box *boxes = calloc(num_boxes*num_boxes*num, sizeof(box)); float **probs = calloc(num_boxes*num_boxes*num, sizeof(float *)); for(j = 0; j < num_boxes*num_boxes*num; ++j) probs[j] = calloc(classes+1, sizeof(float *)); int N = plist->size; int i=0; int k; int count = 0; float iou_thresh = .3; for (i = 0; i < N; ++i) { fprintf(stderr, "%5d %5d\n", i, count); char *path = paths[i]; image orig = load_image_color(path, 0, 0); image resized = resize_image(orig, net.w, net.h); float *X = resized.data; float *predictions = network_predict(net, X); get_boxes(predictions+1+classes, num, num_boxes, 5+classes, boxes); get_probs(predictions, num*num_boxes*num_boxes, classes, 5+classes, probs); char *labelpath = find_replace(path, "images", "labels"); labelpath = find_replace(labelpath, "JPEGImages", "labels"); labelpath = find_replace(labelpath, ".jpg", ".txt"); labelpath = find_replace(labelpath, ".JPEG", ".txt"); int num_labels = 0; box_label *truth = read_boxes(labelpath, &num_labels); FILE *label = stdin; for(k = 0; k < num_boxes*num_boxes*num; ++k){ int overlaps = 0; for (j = 0; j < num_labels; ++j) { box t = {truth[j].x, truth[j].y, truth[j].w, truth[j].h}; float iou = box_iou(boxes[k], t); if (iou > iou_thresh){ if (!overlaps) { char buff[256]; sprintf(buff, "/data/extracted/labels/%d.txt", count); label = fopen(buff, "w"); overlaps = 1; } fprintf(label, "%d %f\n", truth[j].id, iou); } } if (overlaps) { char buff[256]; sprintf(buff, "/data/extracted/imgs/%d", count++); int dx = (boxes[k].x - boxes[k].w/2) * orig.w; int dy = (boxes[k].y - boxes[k].h/2) * orig.h; int w = boxes[k].w * orig.w; int h = boxes[k].h * orig.h; image cropped = crop_image(orig, dx, dy, w, h); image sized = resize_image(cropped, 224, 224); #ifdef OPENCV save_image_jpg(sized, buff); #endif free_image(sized); free_image(cropped); fclose(label); } } free(truth); free_image(orig); free_image(resized); } }
void self_go(char *filename, char *weightfile, char *f2, char *w2, int multi) { network net = parse_network_cfg(filename); if(weightfile){ load_weights(&net, weightfile); } network net2 = net; if(f2){ net2 = parse_network_cfg(f2); if(w2){ load_weights(&net2, w2); } } srand(time(0)); char boards[300][93]; int count = 0; set_batch_network(&net, 1); set_batch_network(&net2, 1); float *board = calloc(19*19, sizeof(float)); char *one = calloc(91, sizeof(char)); char *two = calloc(91, sizeof(char)); int done = 0; int player = 1; int p1 = 0; int p2 = 0; int total = 0; while(1){ if (done || count >= 300){ float score = score_game(board); int i = (score > 0)? 0 : 1; if((score > 0) == (total%2==0)) ++p1; else ++p2; ++total; fprintf(stderr, "Total: %d, Player 1: %f, Player 2: %f\n", total, (float)p1/total, (float)p2/total); int j; for(; i < count; i += 2){ for(j = 0; j < 93; ++j){ printf("%c", boards[i][j]); } printf("\n"); } memset(board, 0, 19*19*sizeof(float)); player = 1; done = 0; count = 0; fflush(stdout); fflush(stderr); } //print_board(board, 1, 0); //sleep(1); network use = ((total%2==0) == (player==1)) ? net : net2; int index = generate_move(use, player, board, multi, .1, .7, two, 0); if(index < 0){ done = 1; continue; } int row = index / 19; int col = index % 19; char *swap = two; two = one; one = swap; if(player < 0) flip_board(board); boards[count][0] = row; boards[count][1] = col; board_to_string(boards[count] + 2, board); if(player < 0) flip_board(board); ++count; move_go(board, player, row, col); board_to_string(one, board); player = -player; } }
void validate_compare(char *filename, char *weightfile) { int i = 0; network net = parse_network_cfg(filename); if(weightfile){ load_weights(&net, weightfile); } srand(time(0)); list *plist = get_paths("data/compare.val.list"); //list *plist = get_paths("data/compare.val.old"); char **paths = (char **)list_to_array(plist); int N = plist->size/2; free_list(plist); clock_t time; int correct = 0; int total = 0; int splits = 10; int num = (i+1)*N/splits - i*N/splits; data val, buffer; load_args args = {0}; args.w = net.w; args.h = net.h; args.paths = paths; args.classes = 20; args.n = num; args.m = 0; args.d = &buffer; args.type = COMPARE_DATA; pthread_t load_thread = load_data_in_thread(args); for(i = 1; i <= splits; ++i){ time=clock(); pthread_join(load_thread, 0); val = buffer; num = (i+1)*N/splits - i*N/splits; char **part = paths+(i*N/splits); if(i != splits){ args.paths = part; load_thread = load_data_in_thread(args); } printf("Loaded: %d images in %lf seconds\n", val.X.rows, sec(clock()-time)); time=clock(); matrix pred = network_predict_data(net, val); int j,k; for(j = 0; j < val.y.rows; ++j){ for(k = 0; k < 20; ++k){ if(val.y.vals[j][k*2] != val.y.vals[j][k*2+1]){ ++total; if((val.y.vals[j][k*2] < val.y.vals[j][k*2+1]) == (pred.vals[j][k*2] < pred.vals[j][k*2+1])){ ++correct; } } } } free_matrix(pred); printf("%d: Acc: %f, %lf seconds, %d images\n", i, (float)correct/total, sec(clock()-time), val.X.rows); free_data(val); } }
void train_go(char *cfgfile, char *weightfile) { data_seed = time(0); srand(time(0)); float avg_loss = -1; char *base = basecfg(cfgfile); printf("%s\n", base); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay); char *backup_directory = "/home/pjreddie/backup/"; char buff[256]; sprintf(buff, "/home/pjreddie/go.train.%02d", rand()%10); data train = load_go(buff); int N = train.X.rows; int epoch = (*net.seen)/N; while(get_current_batch(net) < net.max_batches || net.max_batches == 0){ clock_t time=clock(); data batch = get_random_data(train, net.batch); int i; for(i = 0; i < batch.X.rows; ++i){ int flip = rand()%2; int rotate = rand()%4; image in = float_to_image(19, 19, 1, batch.X.vals[i]); image out = float_to_image(19, 19, 1, batch.y.vals[i]); //show_image_normalized(in, "in"); //show_image_normalized(out, "out"); if(flip){ flip_image(in); flip_image(out); } rotate_image_cw(in, rotate); rotate_image_cw(out, rotate); //show_image_normalized(in, "in2"); //show_image_normalized(out, "out2"); //cvWaitKey(0); } float loss = train_network(net, batch); free_data(batch); if(avg_loss == -1) avg_loss = loss; avg_loss = avg_loss*.95 + loss*.05; printf("%d, %.3f: %f, %f avg, %f rate, %lf seconds, %d images\n", get_current_batch(net), (float)(*net.seen)/N, loss, avg_loss, get_current_rate(net), sec(clock()-time), *net.seen); 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); free_data(train); sprintf(buff, "/home/pjreddie/go.train.%02d", epoch%10); train = load_go(buff); } if(get_current_batch(net)%100 == 0){ char buff[256]; sprintf(buff, "%s/%s.backup",backup_directory,base); save_weights(net, buff); } } sprintf(buff, "%s/%s.weights", backup_directory, base); save_weights(net, buff); free_network(net); free(base); free_data(train); }
void train_compare(char *cfgfile, char *weightfile) { srand(time(0)); float avg_loss = -1; char *base = basecfg(cfgfile); char *backup_directory = "/home/pjreddie/backup/"; printf("%s\n", base); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay); int imgs = 1024; list *plist = get_paths("data/compare.train.list"); char **paths = (char **)list_to_array(plist); int N = plist->size; printf("%d\n", N); clock_t time; pthread_t load_thread; data train; data buffer; load_args args = {0}; args.w = net.w; args.h = net.h; args.paths = paths; args.classes = 20; args.n = imgs; args.m = N; args.d = &buffer; args.type = COMPARE_DATA; load_thread = load_data_in_thread(args); int epoch = *net.seen/N; int i = 0; while(1){ ++i; 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 == -1) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; printf("%.3f: %f, %f avg, %lf seconds, %ld images\n", (float)*net.seen/N, loss, avg_loss, sec(clock()-time), *net.seen); free_data(train); if(i%100 == 0){ char buff[256]; sprintf(buff, "%s/%s_%d_minor_%d.weights",backup_directory,base, epoch, i); save_weights(net, buff); } if(*net.seen/N > epoch){ epoch = *net.seen/N; i = 0; char buff[256]; sprintf(buff, "%s/%s_%d.weights",backup_directory,base, epoch); save_weights(net, buff); if(epoch%22 == 0) net.learning_rate *= .1; } } pthread_join(load_thread, 0); free_data(buffer); free_network(net); free_ptrs((void**)paths, plist->size); free_list(plist); free(base); }
void train_imagenet(char *cfgfile, char *weightfile) { data_seed = time(0); srand(time(0)); float avg_loss = -1; char *base = basecfg(cfgfile); char *backup_directory = "/home/pjreddie/backup/"; printf("%s\n", base); network net = parse_network_cfg(cfgfile, 1); if(weightfile){ load_weights(&net, weightfile); } printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay); int imgs = 1024; char **labels = get_labels("data/inet.labels.list"); list *plist = get_paths("data/inet.train.list"); char **paths = (char **)list_to_array(plist); printf("%d\n", plist->size); int N = plist->size; clock_t time; pthread_t load_thread; data train; data buffer; load_args args = {0}; args.w = net.w; args.h = net.h; args.paths = paths; args.classes = 1000; args.n = imgs; args.m = N; args.labels = labels; args.d = &buffer; args.type = CLASSIFICATION_DATA; load_thread = load_data_in_thread(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_in_thread(args); printf("Loaded: %lf seconds\n", sec(clock()-time)); time=clock(); float loss = train_network(net, train); if(avg_loss == -1) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; printf("%d, %.3f: %f, %f avg, %f rate, %lf seconds, %d 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(*net.seen%1000 == 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); pthread_join(load_thread, 0); free_data(buffer); free_network(net); free_ptrs((void**)labels, 1000); free_ptrs((void**)paths, plist->size); free_list(plist); free(base); }
void train_detector(char *datacfg, char *cfgfile, char *weightfile, int *gpus, int ngpus, int clear) { list *options = read_data_cfg(datacfg); char *train_images = option_find_str(options, "train", "data/train.list"); char *backup_directory = option_find_str(options, "backup", "/backup/"); srand(time(0)); char *base = basecfg(cfgfile); printf("%s\n", base); float avg_loss = -1; network *nets = calloc(ngpus, sizeof(network)); srand(time(0)); int seed = rand(); int i; for(i = 0; i < ngpus; ++i){ srand(seed); #ifdef GPU cuda_set_device(gpus[i]); #endif nets[i] = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&nets[i], weightfile); } if(clear) *nets[i].seen = 0; 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); data train, buffer; layer l = net.layers[net.n - 1]; 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 = l.max_boxes; args.d = &buffer; args.type = DETECTION_DATA; args.threads = 8; args.angle = net.angle; args.exposure = net.exposure; args.saturation = net.saturation; args.hue = net.hue; pthread_t load_thread = load_data(args); clock_t time; int count = 0; //while(i*imgs < N*120){ while(get_current_batch(net) < net.max_batches){ if(l.random && count++%10 == 0){ printf("Resizing\n"); int dim = (rand() % 10 + 10) * 32; if (get_current_batch(net)+100 > net.max_batches) dim = 544; //int dim = (rand() % 4 + 16) * 32; printf("%d\n", dim); args.w = dim; args.h = dim; pthread_join(load_thread, 0); train = buffer; free_data(train); load_thread = load_data(args); for(i = 0; i < ngpus; ++i){ resize_network(nets + i, dim, dim); } net = nets[0]; } time=clock(); pthread_join(load_thread, 0); train = buffer; load_thread = load_data(args); /* int k; for(k = 0; k < l.max_boxes; ++k){ box b = float_to_box(train.y.vals[10] + 1 + k*5); if(!b.x) break; printf("loaded: %f %f %f %f\n", b.x, b.y, b.w, b.h); } image im = float_to_image(448, 448, 3, train.X.vals[10]); int k; for(k = 0; k < l.max_boxes; ++k){ box b = float_to_box(train.y.vals[10] + 1 + k*5); printf("%d %d %d %d\n", truth.x, truth.y, truth.w, truth.h); draw_bbox(im, b, 8, 1,0,0); } save_image(im, "truth11"); */ 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 < 0) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; i = get_current_batch(net); printf("%d: %f, %f avg, %f rate, %lf seconds, %d images\n", get_current_batch(net), loss, avg_loss, get_current_rate(net), sec(clock()-time), i*imgs); if(i%1000==0 || (i < 1000 && i%100 == 0)){ #ifdef GPU if(ngpus != 1) sync_nets(nets, ngpus, 0); #endif char buff[256]; sprintf(buff, "%s/%s_%d.weights", backup_directory, base, i); save_weights(net, buff); } free_data(train); } #ifdef GPU if(ngpus != 1) sync_nets(nets, ngpus, 0); #endif char buff[256]; sprintf(buff, "%s/%s_final.weights", backup_directory, base); save_weights(net, buff); }
void train_coco(char *cfgfile, char *weightfile) { //char *train_images = "/home/pjreddie/data/voc/test/train.txt"; //char *train_images = "/home/pjreddie/data/coco/train.txt"; char *train_images = "data/coco.trainval.txt"; char *backup_directory = "/home/pjreddie/backup/"; srand(time(0)); data_seed = time(0); char *base = basecfg(cfgfile); printf("%s\n", base); float avg_loss = -1; network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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; 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)); /* image im = float_to_image(net.w, net.h, 3, train.X.vals[113]); image copy = copy_image(im); draw_coco(copy, train.y.vals[113], 7, "truth"); cvWaitKey(0); free_image(copy); */ 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){ 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); }
void validate_detector(char *datacfg, char *cfgfile, char *weightfile) { int j; list *options = read_data_cfg(datacfg); char *valid_images = option_find_str(options, "valid", "data/train.list"); char *name_list = option_find_str(options, "names", "data/names.list"); char *prefix = option_find_str(options, "results", "results"); char **names = get_labels(name_list); char *mapf = option_find_str(options, "map", 0); int *map = 0; if (mapf) map = read_map(mapf); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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 = "comp4_det_test_"; list *plist = get_paths(valid_images); char **paths = (char **)list_to_array(plist); layer l = net.layers[net.n-1]; int classes = l.classes; char buff[1024]; char *type = option_find_str(options, "eval", "voc"); FILE *fp = 0; FILE **fps = 0; int coco = 0; int imagenet = 0; if(0==strcmp(type, "coco")){ snprintf(buff, 1024, "%s/coco_results.json", prefix); fp = fopen(buff, "w"); fprintf(fp, "[\n"); coco = 1; } else if(0==strcmp(type, "imagenet")){ snprintf(buff, 1024, "%s/imagenet-detection.txt", prefix); fp = fopen(buff, "w"); imagenet = 1; classes = 200; } else { fps = calloc(classes, sizeof(FILE *)); for(j = 0; j < classes; ++j){ snprintf(buff, 1024, "%s/%s%s.txt", prefix, base, names[j]); fps[j] = fopen(buff, "w"); } } 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(classes, sizeof(float *)); int m = plist->size; int i=0; int t; float thresh = .005; float nms = .45; int nthreads = 4; 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; get_region_boxes(l, w, h, thresh, probs, boxes, 0, map); if (nms) do_nms_sort(boxes, probs, l.w*l.h*l.n, classes, nms); if (coco){ print_cocos(fp, path, boxes, probs, l.w*l.h*l.n, classes, w, h); } else if (imagenet){ print_imagenet_detections(fp, i+t-nthreads+1, boxes, probs, l.w*l.h*l.n, classes, w, h); } else { print_detector_detections(fps, id, boxes, probs, l.w*l.h*l.n, classes, w, h); } free(id); free_image(val[t]); free_image(val_resized[t]); } } for(j = 0; j < classes; ++j){ if(fps) fclose(fps[j]); } if(coco){ fseek(fp, -2, SEEK_CUR); fprintf(fp, "\n]\n"); fclose(fp); } fprintf(stderr, "Total Detection Time: %f Seconds\n", (double)(time(0) - start)); }
void demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int delay, char *prefix, int avg_frames, float hier, int w, int h, int frames, int fullscreen) { demo_delay = delay; demo_frame = avg_frames; predictions = calloc(demo_frame, sizeof(float*)); image **alphabet = load_alphabet(); demo_names = names; demo_alphabet = alphabet; demo_classes = classes; demo_thresh = thresh; demo_hier = hier; printf("Demo\n"); net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); pthread_t detect_thread; pthread_t fetch_thread; srand(2222222); if(filename){ printf("video file: %s\n", filename); cap = cvCaptureFromFile(filename); }else{ cap = cvCaptureFromCAM(cam_index); if(w){ cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_WIDTH, w); } if(h){ cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_HEIGHT, h); } if(frames){ cvSetCaptureProperty(cap, CV_CAP_PROP_FPS, frames); } } if(!cap) error("Couldn't connect to webcam.\n"); layer l = net.layers[net.n-1]; demo_detections = l.n*l.w*l.h; int j; avg = (float *) calloc(l.outputs, sizeof(float)); last_avg = (float *) calloc(l.outputs, sizeof(float)); last_avg2 = (float *) calloc(l.outputs, sizeof(float)); for(j = 0; j < demo_frame; ++j) predictions[j] = (float *) calloc(l.outputs, sizeof(float)); boxes = (box *)calloc(l.w*l.h*l.n, sizeof(box)); probs = (float **)calloc(l.w*l.h*l.n, sizeof(float *)); for(j = 0; j < l.w*l.h*l.n; ++j) probs[j] = (float *)calloc(l.classes+1, sizeof(float)); buff[0] = get_image_from_stream(cap); buff[1] = copy_image(buff[0]); buff[2] = copy_image(buff[0]); buff_letter[0] = letterbox_image(buff[0], net.w, net.h); buff_letter[1] = letterbox_image(buff[0], net.w, net.h); buff_letter[2] = letterbox_image(buff[0], net.w, net.h); ipl = cvCreateImage(cvSize(buff[0].w,buff[0].h), IPL_DEPTH_8U, buff[0].c); int count = 0; if(!prefix){ cvNamedWindow("Demo", CV_WINDOW_NORMAL); if(fullscreen){ cvSetWindowProperty("Demo", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN); } else { cvMoveWindow("Demo", 0, 0); cvResizeWindow("Demo", 1352, 1013); } } demo_time = get_wall_time(); while(!demo_done){ buff_index = (buff_index + 1) %3; if(pthread_create(&fetch_thread, 0, fetch_in_thread, 0)) error("Thread creation failed"); if(pthread_create(&detect_thread, 0, detect_in_thread, 0)) error("Thread creation failed"); if(!prefix){ if(count % (demo_delay+1) == 0){ fps = 1./(get_wall_time() - demo_time); demo_time = get_wall_time(); float *swap = last_avg; last_avg = last_avg2; last_avg2 = swap; memcpy(last_avg, avg, l.outputs*sizeof(float)); } display_in_thread(0); }else{ char name[256]; sprintf(name, "%s_%08d", prefix, count); save_image(buff[(buff_index + 1)%3], name); } pthread_join(fetch_thread, 0); pthread_join(detect_thread, 0); ++count; } }
void validate_detector_recall(char *cfgfile, char *weightfile) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } 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)); 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 j, k; 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(classes, sizeof(float *)); int m = plist->size; int i=0; float thresh = .001; float iou_thresh = .5; float nms = .4; 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); get_region_boxes(l, 1, 1, thresh, probs, boxes, 1, 0); if (nms) do_nms(boxes, probs, l.w*l.h*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 < l.w*l.h*l.n; ++k){ if(probs[k][0] > 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 < l.w*l.h*l.n; ++k){ float iou = box_iou(boxes[k], t); if(probs[k][0] > 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(id); free_image(orig); free_image(sized); } }
int oe_11_main(int argc,char** argv) { arpa_lm_t arpa_lm,lm1,lm2; char header1[MAX_HEADER]; char header2[MAX_HEADER]; flag backoff_from_unk_inc,backoff_from_unk_exc,backoff_from_ccs_inc,backoff_from_ccs_exc; char *lmfile1,*lmfile2,*newlmfile, *wtfile; char *fb_list_filename,*ccs_filename; fb_info *fb1,*fb2,*fb; double w1,w2; if (pc_flagarg(&argc, argv,"-help") || argc == 1) { oe_05_help_message(); exit(1); } lmfile1 = rr_salloc(pc_stringarg(&argc, argv,"-lm1","")); if (0 == strcmp(lmfile1, "")) { fprintf(stderr, "ERROR: Please specify a first input file with -lm1.\n"); oe_05_help_message(); } lmfile2 = rr_salloc(pc_stringarg(&argc, argv,"-lm2","")); if (0 == strcmp(lmfile2, "")) { fprintf(stderr, "ERROR: Please specify a second input file with -lm2.\n"); oe_05_help_message(); } newlmfile = rr_salloc(pc_stringarg(&argc, argv,"-lm","")); if (0 == strcmp(newlmfile, "")) { fprintf(stderr, "ERROR: Please specify a destination file with -lm.\n"); oe_05_help_message(); } fb_list_filename = rr_salloc(pc_stringarg(&argc, argv,"-forced_backoff","")); wtfile= rr_salloc(pc_stringarg(&argc, argv,"-weight","")); if (0 == strcmp(wtfile, "")) { fprintf(stderr, "ERROR: Please specify a weights file with -weight.\n"); oe_05_help_message(); } ccs_filename= rr_salloc(pc_stringarg(&argc, argv,"-context","")); backoff_from_unk_inc = pc_flagarg(&argc,argv,"-backoff_from_unk_inc"); backoff_from_ccs_inc = pc_flagarg(&argc,argv,"-backoff_from_ccs_inc"); backoff_from_unk_exc = pc_flagarg(&argc,argv,"-backoff_from_unk_exc"); backoff_from_ccs_exc = pc_flagarg(&argc,argv,"-backoff_from_ccs_exc"); robust_load_arpa_lm(&lm1,lmfile1,header1,MAX_HEADER); robust_load_arpa_lm(&lm2,lmfile2,header2,MAX_HEADER); load_weights(&w1,&w2,wtfile); printf ("\ncombine lms\n"); combine_lm(&arpa_lm,&lm1,&lm2); printf ("\nloading context cues.\n"); load_context_cue(&arpa_lm,ccs_filename); load_context_cue(&lm1,ccs_filename); load_context_cue(&lm2,ccs_filename); fb=gen_fb_list(arpa_lm.vocab_ht, arpa_lm.vocab_size, arpa_lm.vocab, arpa_lm.context_cue, backoff_from_unk_inc, backoff_from_unk_exc, backoff_from_ccs_inc, backoff_from_ccs_exc, fb_list_filename); fb1=gen_fb_list(lm1.vocab_ht, lm1.vocab_size, lm1.vocab, lm1.context_cue, backoff_from_unk_inc, backoff_from_unk_exc, backoff_from_ccs_inc, backoff_from_ccs_exc, fb_list_filename); fb2=gen_fb_list(lm2.vocab_ht, lm2.vocab_size, lm2.vocab, lm2.context_cue, backoff_from_unk_inc, backoff_from_unk_exc, backoff_from_ccs_inc, backoff_from_ccs_exc, fb_list_filename); printf ("\nrecaculate oov probabilities.\n"); recalc_oov_prob(&arpa_lm,&lm1,&lm2); printf ("\ncheck probabilities\n"); check_prob(&arpa_lm,&lm1,&lm2,fb1,fb2,w1,w2); printf ("\ncalculate interpolated probabilities\n"); calc_interpolated_prob(&arpa_lm,&lm1,&lm2,fb1,fb2,w1,w2); printf ("\ncalculate backoff weights\n"); calc_backoff_weight(&arpa_lm,fb); printf ("\nwrite interpolated lm\n"); write_interpolated_lm(&arpa_lm,newlmfile,header1,header2,2); printf ("\nfinished\n"); return 0; }
void run_nightmare(int argc, char **argv) { srand(0); if(argc < 4){ fprintf(stderr, "usage: %s %s [cfg] [weights] [image] [layer] [options! (optional)]\n", argv[0], argv[1]); return; } char *cfg = argv[2]; char *weights = argv[3]; char *input = argv[4]; int max_layer = atoi(argv[5]); int range = find_int_arg(argc, argv, "-range", 1); int rounds = find_int_arg(argc, argv, "-rounds", 1); int iters = find_int_arg(argc, argv, "-iters", 10); int octaves = find_int_arg(argc, argv, "-octaves", 4); float zoom = find_float_arg(argc, argv, "-zoom", 1.); float rate = find_float_arg(argc, argv, "-rate", .04); float thresh = find_float_arg(argc, argv, "-thresh", 1.); float rotate = find_float_arg(argc, argv, "-rotate", 0); char *prefix = find_char_arg(argc, argv, "-prefix", 0); network net = parse_network_cfg(cfg); load_weights(&net, weights); char *cfgbase = basecfg(cfg); char *imbase = basecfg(input); set_batch_network(&net, 1); image im = load_image_color(input, 0, 0); if(0){ float scale = 1; if(im.w > 512 || im.h > 512){ if(im.w > im.h) scale = 512.0/im.w; else scale = 512.0/im.h; } image resized = resize_image(im, scale*im.w, scale*im.h); free_image(im); im = resized; } int e; int n; for(e = 0; e < rounds; ++e){ fprintf(stderr, "Iteration: "); fflush(stderr); for(n = 0; n < iters; ++n){ fprintf(stderr, "%d, ", n); fflush(stderr); int layer = max_layer + rand()%range - range/2; int octave = rand()%octaves; optimize_picture(&net, im, layer, 1/pow(1.33333333, octave), rate, thresh); } fprintf(stderr, "done\n"); if(0){ image g = grayscale_image(im); free_image(im); im = g; } char buff[256]; if (prefix){ sprintf(buff, "%s/%s_%s_%d_%06d",prefix, imbase, cfgbase, max_layer, e); }else{ sprintf(buff, "%s_%s_%d_%06d",imbase, cfgbase, max_layer, e); } printf("%d %s\n", e, buff); save_image(im, buff); //show_image(im, buff); //cvWaitKey(0); if(rotate){ image rot = rotate_image(im, rotate); free_image(im); im = rot; } image crop = crop_image(im, im.w * (1. - zoom)/2., im.h * (1.-zoom)/2., im.w*zoom, im.h*zoom); image resized = resize_image(crop, im.w, im.h); free_image(im); free_image(crop); im = resized; } }