// return classification error and the normalized difference between predicted and true sentiment std::pair<double, double> do_predict(const struct problem *test_prob, struct model* model_) { double acc = 0; double clse=0; int total = 0; double *prob_estimates=NULL; int *labels=NULL; int nr_class=get_nr_class(model_); if(flag_predict_probability) { if(!check_probability_model(model_)) { fprintf(stderr, "probability output is only supported for logistic regression\n"); exit(1); } labels=(int *) malloc(nr_class*sizeof(int)); get_labels(model_,labels); prob_estimates = (double *) malloc(nr_class*sizeof(double)); } int l = test_prob->l; int i = 0; for(i=0; i<l; i++) { int predict_label = 0; int target_label=test_prob->y[i]; feature_node *xi = test_prob->x[i]; if(flag_predict_probability) { int j; predict_label = predict_probability(model_,xi,prob_estimates); double predict_score=0; for(j=0;j<model_->nr_class;j++) predict_score+=prob_estimates[j]*labels[j]; //double acc_max= fabs(target_label-3)+2; //acc+=(acc_max-sqrt((predict_score - target_label)*(predict_score - target_label)))/acc_max; acc += (predict_score - target_label) * (predict_score - target_label); if (predict_label!=target_label) clse++; } else { predict_label = predict(model_,xi); //double acc_max= fabs(target_label-3)+2; //acc+=(acc_max-sqrt((predict_label - target_label)*(predict_label - target_label)))/acc_max; acc += (predict_label - target_label) * (predict_label - target_label); if (predict_label!=target_label) clse++; } ++total; } if(flag_predict_probability) { free(prob_estimates); free(labels); } //printf("Error = %g%% (%d/%d)\n",(double) (total-correct)/total*100,total-correct,total); return std::make_pair(clse/total,acc/total) ; }
static PyObject *PyHdbscan_run(PyHdbscan *self, PyObject *args){ /// TODO: check for errors PyObject *dataset; double *dset = NULL; if (! PyArg_ParseTuple(args, "O", &dataset)){ return NULL; } if (dataset) { Py_INCREF(dataset); self->rows = PyList_Size(dataset); PyObject* row = PyList_GetItem(dataset, 0); self->cols = PyList_Size(row); dset = PyList_toArray(dataset, NULL, self->rows, self->cols); self->labels = PyList_New(0); Py_INCREF(self->labels); Py_XDECREF(dataset); if(!scan){ return NULL; } } else { return NULL; } int err = hdbscan_run(scan, dset, self->rows, self->cols, TRUE); get_labels(self, scan->clusterLabels); free(dset); return Py_BuildValue("i", err); }
void do_predict(FILE *input, FILE *output) { std::vector<double> pred_values; //store decision values std::vector<double> true_values; //store true values int total = 0; int nr_class = get_nr_class(model_); int * labels = Malloc(int, nr_class); get_labels(model_, labels); double * prob_estimates = NULL; int j, n; int nr_feature = get_nr_feature(model_); if(model_->bias >=0) n = nr_feature+1; else n = nr_feature; // not yet support multiclass assert(nr_class==2); //print out header... if(output_option ==2) { prob_estimates = Malloc(double, nr_class); fprintf(output,"labels"); for(j=0;j<nr_class;j++) fprintf(output," %d",labels[j]); fprintf(output,"\n"); }
bool edit_interface_rep::complete_try () { tree st= subtree (et, path_up (tp)); if (is_compound (st)) return false; string s= st->label, ss; int end= last_item (tp); array<string> a; if (inside (LABEL) || inside (REFERENCE) || inside (PAGEREF)) { if (end != N(s)) return false; ss= copy (s); tree t= get_labels (); int i, n= N(t); for (i=0; i<n; i++) if (is_atomic (t[i]) && starts (t[i]->label, s)) a << string (t[i]->label (N(s), N(t[i]->label))); } else { if ((end==0) || (!is_iso_alpha (s[end-1])) || ((end!=N(s)) && is_iso_alpha (s[end]))) return false; int start= end-1; while ((start>0) && is_iso_alpha (s[start-1])) start--; ss= s (start, end); a= find_completions (drd, et, ss); } if (N(a) == 0) return false; complete_start (ss, a); return true; }
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 validate_imagenet(char *filename, char *weightfile) { int i = 0; network net = parse_network_cfg(filename, 1); if(weightfile){ load_weights(&net, weightfile); } srand(time(0)); char **labels = get_labels("data/inet.labels.list"); //list *plist = get_paths("data/inet.suppress.list"); list *plist = get_paths("data/inet.val.list"); char **paths = (char **)list_to_array(plist); int m = plist->size; free_list(plist); clock_t time; float avg_acc = 0; float avg_top5 = 0; int splits = 50; 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 = 1000; args.n = num; args.m = 0; args.labels = labels; args.d = &buffer; args.type = 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, 5); avg_acc += acc[0]; avg_top5 += acc[1]; printf("%d: top1: %f, top5: %f, %lf seconds, %d images\n", i, avg_acc/i, avg_top5/i, sec(clock()-time), val.X.rows); free_data(val); } }
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; } }
void train_cifar_distill(char *cfgfile, char *weightfile) { 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/"; int classes = 10; int N = 50000; char **labels = get_labels("data/cifar/labels.txt"); int epoch = (*net.seen)/N; data train = load_all_cifar10(); matrix soft = csv_to_matrix("results/ensemble.csv"); float weight = .9; scale_matrix(soft, weight); scale_matrix(train.y, 1. - weight); matrix_add_matrix(soft, train.y); while(get_current_batch(net) < net.max_batches || net.max_batches == 0){ clock_t time=clock(); float loss = train_network_sgd(net, train, 1); 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); } 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**)labels, classes); free(base); free_data(train); }
void train_imagenet(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); //net.seen=0; int imgs = 1024; int i = net.seen/imgs; char **labels = get_labels("data/inet.labels.list"); list *plist = get_paths("/data/imagenet/cls.train.list"); char **paths = (char **)list_to_array(plist); printf("%d\n", plist->size); clock_t time; pthread_t load_thread; data train; data buffer; load_thread = load_data_thread(paths, imgs, plist->size, labels, 1000, 256, 256, &buffer); while(1){ ++i; time=clock(); pthread_join(load_thread, 0); train = buffer; /* image im = float_to_image(256, 256, 3, train.X.vals[114]); show_image(im, "training"); cvWaitKey(0); */ load_thread = load_data_thread(paths, imgs, plist->size, labels, 1000, 256, 256, &buffer); printf("Loaded: %lf seconds\n", sec(clock()-time)); time=clock(); float loss = train_network(net, train); net.seen += imgs; if(avg_loss == -1) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; printf("%d: %f, %f avg, %lf seconds, %d images\n", i, loss, avg_loss, sec(clock()-time), net.seen); free_data(train); if((i % 20000) == 0) net.learning_rate *= .1; //if(i%100 == 0 && net.learning_rate > .00001) net.learning_rate *= .97; if(i%1000==0){ char buff[256]; sprintf(buff, "/home/pjreddie/imagenet_backup/%s_%d.weights",base, i); save_weights(net, buff); } } }
void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename, int top) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); list *options = read_data_cfg(datacfg); char *name_list = option_find_str(options, "names", 0); if(!name_list) name_list = option_find_str(options, "labels", "data/labels.list"); if(top == 0) top = option_find_int(options, "top", 1); int i = 0; char **names = get_labels(name_list); clock_t time; int *indexes = calloc(top, sizeof(int)); char buff[256]; char *input = buff; while(1){ if(filename){ strncpy(input, filename, 256); }else{ printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if(!input) return; strtok(input, "\n"); } image im = load_image_color(input, 0, 0); image r = letterbox_image(im, net.w, net.h); //resize_network(&net, r.w, r.h); //printf("%d %d\n", r.w, r.h); float *X = r.data; time=clock(); float *predictions = network_predict(net, X); if(net.hierarchy) hierarchy_predictions(predictions, net.outputs, net.hierarchy, 1, 1); top_k(predictions, net.outputs, top, indexes); fprintf(stderr, "%s: Predicted in %f seconds.\n", input, sec(clock()-time)); for(i = 0; i < top; ++i){ int index = indexes[i]; //if(net.hierarchy) printf("%d, %s: %f, parent: %s \n",index, names[index], predictions[index], (net.hierarchy->parent[index] >= 0) ? names[net.hierarchy->parent[index]] : "Root"); //else printf("%s: %f\n",names[index], predictions[index]); printf("%5.2f%%: %s\n", predictions[index]*100, names[index]); } if(r.data != im.data) free_image(r); free_image(im); if (filename) break; } }
void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); list *options = read_data_cfg(datacfg); char *name_list = option_find_str(options, "names", 0); if(!name_list) name_list = option_find_str(options, "labels", "data/labels.list"); int top = option_find_int(options, "top", 1); int i = 0; char **names = get_labels(name_list); clock_t time; int *indexes = calloc(top, sizeof(int)); char buff[256]; char *input = buff; int size = net.w; while(1){ if(filename){ strncpy(input, filename, 256); }else{ printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if(!input) return; strtok(input, "\n"); } image im = load_image_color(input, 0, 0); image r = resize_min(im, size); resize_network(&net, r.w, r.h); printf("%d %d\n", r.w, r.h); float *X = r.data; time=clock(); float *predictions = network_predict(net, X); top_predictions(net, top, indexes); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); for(i = 0; i < top; ++i){ int index = indexes[i]; printf("%s: %f\n", names[index], predictions[index]); } if(r.data != im.data) free_image(r); free_image(im); if (filename) break; } }
void boogie_proof::pp_proof(std::ostream& out) { vector<step> steps; ptr_vector<proof> rules; rules.push_back(m_proof); steps.push_back(step()); obj_map<proof, unsigned> index; index.insert(m_proof, 0); for (unsigned j = 0; j < rules.size(); ++j) { proof* p = rules[j]; proof_ref_vector premises(m); expr_ref conclusion(m); svector<std::pair<unsigned, unsigned> > positions; vector<expr_ref_vector> substs; expr* tmp; steps[j].m_fact = m.get_fact(p); m.is_implies(steps[j].m_fact, tmp, steps[j].m_fact); get_subst(p, steps[j].m_subst); get_labels(p, steps[j].m_labels); if (m.is_hyper_resolve(p, premises, conclusion, positions, substs)) { for (unsigned i = 1; i < premises.size(); ++i) { proof* premise = premises[i].get(); unsigned position = 0; if (!index.find(premise, position)) { position = rules.size(); rules.push_back(premise); steps.push_back(step()); index.insert(premise, position); } steps[j].m_refs.push_back(position); } get_rule_name(premises[0].get(), steps[j].m_rule_name); } } for (unsigned j = steps.size(); j > 0; ) { --j; step &s = steps[j]; // TBD // s.m_labels; // set references, compensate for reverse ordering. for (unsigned i = 0; i < s.m_refs.size(); ++i) { s.m_refs[i] = rules.size()-1-s.m_refs[i]; } } steps.reverse(); pp_steps(out, steps); }
void run_detector(int argc, char **argv) { char *prefix = find_char_arg(argc, argv, "-prefix", 0); float thresh = find_float_arg(argc, argv, "-thresh", .24); int cam_index = find_int_arg(argc, argv, "-c", 0); int frame_skip = find_int_arg(argc, argv, "-s", 0); if(argc < 4){ fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]); return; } char *gpu_list = find_char_arg(argc, argv, "-gpus", 0); int *gpus = 0; int gpu = 0; int ngpus = 0; if(gpu_list){ printf("%s\n", gpu_list); int len = strlen(gpu_list); ngpus = 1; int i; for(i = 0; i < len; ++i){ if (gpu_list[i] == ',') ++ngpus; } gpus = calloc(ngpus, sizeof(int)); for(i = 0; i < ngpus; ++i){ gpus[i] = atoi(gpu_list); gpu_list = strchr(gpu_list, ',')+1; } } else { gpu = gpu_index; gpus = &gpu; ngpus = 1; } int clear = find_arg(argc, argv, "-clear"); char *datacfg = argv[3]; char *cfg = argv[4]; char *weights = (argc > 5) ? argv[5] : 0; char *filename = (argc > 6) ? argv[6]: 0; if(0==strcmp(argv[2], "test")) test_detector(datacfg, cfg, weights, filename, thresh); else if(0==strcmp(argv[2], "train")) train_detector(datacfg, cfg, weights, gpus, ngpus, clear); else if(0==strcmp(argv[2], "valid")) validate_detector(datacfg, cfg, weights); else if(0==strcmp(argv[2], "recall")) validate_detector_recall(cfg, weights); else if(0==strcmp(argv[2], "demo")) { list *options = read_data_cfg(datacfg); int classes = option_find_int(options, "classes", 20); char *name_list = option_find_str(options, "names", "data/names.list"); char **names = get_labels(name_list); demo(cfg, weights, thresh, cam_index, filename, names, classes, frame_skip, prefix); } }
void ofxDarknet::init( std::string cfgfile, std::string weightfile, std::string nameslist ) { if (nameslist != "") { labelsAvailable = true; } net = parse_network_cfg( cfgfile.c_str() ); load_weights( &net, weightfile.c_str() ); set_batch_network( &net, 1 ); if (!nameslist.empty()){ names = get_labels( (char *) nameslist.c_str() ); } // load layer names int numLayerTypes = 24; int * counts = new int[ numLayerTypes ]; for (int i=0; i<numLayerTypes; i++) {counts[i] = 0;} for (int i=0; i<net.n; i++) { LAYER_TYPE type = net.layers[i].type; string layerName = "Unknown"; if (type == CONVOLUTIONAL) layerName = "Conv"; else if (type == DECONVOLUTIONAL) layerName = "Deconv"; else if (type == CONNECTED) layerName = "FC"; else if (type == MAXPOOL) layerName = "MaxPool"; else if (type == SOFTMAX) layerName = "Softmax"; else if (type == DETECTION) layerName = "Detect"; else if (type == DROPOUT) layerName = "Dropout"; else if (type == CROP) layerName = "Crop"; else if (type == ROUTE) layerName = "Route"; else if (type == COST) layerName = "Cost"; else if (type == NORMALIZATION) layerName = "Normalize"; else if (type == AVGPOOL) layerName = "AvgPool"; else if (type == LOCAL) layerName = "Local"; else if (type == SHORTCUT) layerName = "Shortcut"; else if (type == ACTIVE) layerName = "Active"; else if (type == RNN) layerName = "RNN"; else if (type == GRU) layerName = "GRU"; else if (type == CRNN) layerName = "CRNN"; else if (type == BATCHNORM) layerName = "Batchnorm"; else if (type == NETWORK) layerName = "Network"; else if (type == XNOR) layerName = "XNOR"; else if (type == REGION) layerName = "Region"; else if (type == REORG) layerName = "Reorg"; else if (type == BLANK) layerName = "Blank"; layerNames.push_back(layerName+" "+ofToString(counts[type])); counts[type] += 1; } delete counts; loaded = true; }
int test_get_labels() { const char *test_name = "test_get_labels"; struct rooted_tree tree = tree_7(); /* ((A:1,:1.0)f:2.0,(C:1,(D:1,E:1):2)h:3)i; */ struct llist *labels = get_labels(&tree); struct list_elem *el = labels->head; if (strcmp("A", (char *) el->data) != 0) { printf ("%s: expected label 'A', got '%s'.\n", test_name, (char *) el->data); return 1; } el = el->next; if (strcmp("f", (char *) el->data) != 0) { printf ("%s: expected label 'f', got '%s'.\n", test_name, (char *) el->data); return 1; } el = el->next; if (strcmp("C", (char *) el->data) != 0) { printf ("%s: expected label 'C', got '%s'.\n", test_name, (char *) el->data); return 1; } el = el->next; if (strcmp("D", (char *) el->data) != 0) { printf ("%s: expected label 'D', got '%s'.\n", test_name, (char *) el->data); return 1; } el = el->next; if (strcmp("E", (char *) el->data) != 0) { printf ("%s: expected label 'E', got '%s'.\n", test_name, (char *) el->data); return 1; } el = el->next; if (strcmp("h", (char *) el->data) != 0) { printf ("%s: expected label 'h', got '%s'.\n", test_name, (char *) el->data); return 1; } el = el->next; if (strcmp("i", (char *) el->data) != 0) { printf ("%s: expected label 'i', got '%s'.\n", test_name, (char *) el->data); return 1; } el = el->next; if (NULL != el) { printf ("%s: expected end of list.\n", test_name); return 1; } printf ("%s: ok.\n", test_name); return 0; }
void demo_regressor(char *datacfg, char *cfgfile, char *weightfile, int cam_index, const char *filename) { #ifdef OPENCV printf("Regressor Demo\n"); network *net = load_network(cfgfile, weightfile, 0); set_batch_network(net, 1); srand(2222222); list *options = read_data_cfg(datacfg); int classes = option_find_int(options, "classes", 1); char *name_list = option_find_str(options, "names", 0); char **names = get_labels(name_list); void * cap = open_video_stream(filename, cam_index, 0,0,0); if(!cap) error("Couldn't connect to webcam.\n"); float fps = 0; while(1){ struct timeval tval_before, tval_after, tval_result; gettimeofday(&tval_before, NULL); image in = get_image_from_stream(cap); image crop = center_crop_image(in, net->w, net->h); grayscale_image_3c(crop); float *predictions = network_predict(net, crop.data); printf("\033[2J"); printf("\033[1;1H"); printf("\nFPS:%.0f\n",fps); int i; for(i = 0; i < classes; ++i){ printf("%s: %f\n", names[i], predictions[i]); } show_image(crop, "Regressor", 10); free_image(in); free_image(crop); gettimeofday(&tval_after, NULL); timersub(&tval_after, &tval_before, &tval_result); float curr = 1000000.f/((long int)tval_result.tv_usec); fps = .9*fps + .1*curr; } free_network(net); #endif }
metadata get_metadata(char *file) { metadata m = {0}; list *options = read_data_cfg(file); char *name_list = option_find_str(options, "names", 0); if(!name_list) name_list = option_find_str(options, "labels", 0); if(!name_list) { fprintf(stderr, "No names or labels found\n"); } else { m.names = get_labels(name_list); } m.classes = option_find_int(options, "classes", 2); free_list(options); return m; }
static PyObject *PyHdbscan_rerun(PyHdbscan *self, PyObject *args){ Py_XDECREF(self->labels); if (!PyArg_ParseTuple(args, "i", &self->minPoints)) return NULL; if(self->minPoints < 3){ return NULL; } int err = hdbscan_rerun(scan, self->minPoints); self->labels = PyList_New(0); Py_INCREF(self->labels); get_labels(self, scan->clusterLabels); return Py_BuildValue("i", err); }
void test_tag(char *cfgfile, char *weightfile, char *filename) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); int i = 0; char **names = get_labels("data/tags.txt"); clock_t time; int indexes[10]; char buff[256]; char *input = buff; int size = net.w; while(1){ if(filename){ strncpy(input, filename, 256); }else{ printf("Enter Image Path: "); fflush(stdout); input = fgets(input, 256, stdin); if(!input) return; strtok(input, "\n"); } image im = load_image_color(input, 0, 0); image r = resize_min(im, size); resize_network(&net, r.w, r.h); printf("%d %d\n", r.w, r.h); float *X = r.data; time=clock(); float *predictions = network_predict(net, X); top_predictions(net, 10, indexes); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); for(i = 0; i < 10; ++i){ int index = indexes[i]; printf("%.1f%%: %s\n", predictions[index]*100, names[index]); } if(r.data != im.data) free_image(r); free_image(im); if (filename) break; } }
void validate_imagenet(char *filename, char *weightfile) { int i = 0; network net = parse_network_cfg(filename); if(weightfile){ load_weights(&net, weightfile); } srand(time(0)); char **labels = get_labels("data/inet.labels.list"); list *plist = get_paths("data/inet.val.list"); char **paths = (char **)list_to_array(plist); int m = plist->size; free_list(plist); clock_t time; float avg_acc = 0; float avg_top5 = 0; int splits = 50; int num = (i+1)*m/splits - i*m/splits; data val, buffer; pthread_t load_thread = load_data_thread(paths, num, 0, labels, 1000, 256, 256, &buffer); 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) load_thread = load_data_thread(part, num, 0, labels, 1000, 256, 256, &buffer); printf("Loaded: %d images in %lf seconds\n", val.X.rows, sec(clock()-time)); time=clock(); float *acc = network_accuracies(net, val); avg_acc += acc[0]; avg_top5 += acc[1]; printf("%d: top1: %f, top5: %f, %lf seconds, %d images\n", i, avg_acc/i, avg_top5/i, sec(clock()-time), val.X.rows); free_data(val); } }
void valid_captcha(char *cfgfile, char *weightfile, char *filename) { char **labels = get_labels("/data/captcha/reimgs.labels.list"); network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } list *plist = get_paths("/data/captcha/reimgs.fg.list"); char **paths = (char **)list_to_array(plist); int N = plist->size; int outputs = net.outputs; set_batch_network(&net, 1); srand(2222222); int i, j; for(i = 0; i < N; ++i){ if (i%100 == 0) fprintf(stderr, "%d\n", i); image im = load_image_color(paths[i], net.w, net.h); float *X = im.data; float *predictions = network_predict(net, X); //printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); int truth = -1; for(j = 0; j < 13; ++j){ if (strstr(paths[i], labels[j])) truth = j; } if (truth == -1){ fprintf(stderr, "bad: %s\n", paths[i]); return; } printf("%d, ", truth); for(j = 0; j < outputs; ++j){ if (j != 0) printf(", "); printf("%f", predictions[j]); } printf("\n"); fflush(stdout); free_image(im); if (filename) break; } }
void test_captcha(char *cfgfile, char *weightfile, char *filename) { network net = parse_network_cfg(cfgfile); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); int i = 0; char **names = get_labels("/data/captcha/reimgs.labels.list"); char buff[256]; char *input = buff; int indexes[26]; 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, 26, indexes); //printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); for(i = 0; i < 26; ++i){ int index = indexes[i]; if(i != 0) printf(", "); printf("%s %f", names[index], predictions[index]); } printf("\n"); fflush(stdout); free_image(im); if (filename) break; } }
void test_imagenet(char *cfgfile, char *weightfile, char *filename) { network net = parse_network_cfg(cfgfile, 1); if(weightfile){ load_weights(&net, weightfile); } set_batch_network(&net, 1); srand(2222222); int i = 0; char **names = get_labels("data/shortnames.txt"); clock_t time; int indexes[10]; 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, 256, 256); float *X = im.data; time=clock(); float *predictions = network_predict(net, X); top_predictions(net, 10, indexes); printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time)); for(i = 0; i < 10; ++i){ int index = indexes[i]; printf("%s: %f\n", names[index], predictions[index]); } free_image(im); if (filename) break; } }
void do_predict(FILE *input, FILE *output) { int correct = 0; int total = 0; double error = 0; double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0; int nr_class=get_nr_class(model_); double *prob_estimates=NULL; int j, n; int nr_feature=get_nr_feature(model_); if(model_->bias>=0) n=nr_feature+1; else n=nr_feature; if(flag_predict_probability) { int *labels; if(!check_probability_model(model_)) { fprintf(stderr, "probability output is only supported for logistic regression\n"); exit(1); } labels=(int *) malloc(nr_class*sizeof(int)); get_labels(model_,labels); prob_estimates = (double *) malloc(nr_class*sizeof(double)); fprintf(output,"labels"); for(j=0;j<nr_class;j++) fprintf(output," %d",labels[j]); fprintf(output,"\n"); free(labels); } max_line_len = 1024; line = (char *)malloc(max_line_len*sizeof(char)); while(readline(input) != NULL) { int i = 0; double target_label, predict_label; char *idx, *val, *label, *endptr; int inst_max_index = 0; // strtol gives 0 if wrong format label = strtok(line," \t\n"); if(label == NULL) // empty line exit_input_error(total+1); target_label = strtod(label,&endptr); if(endptr == label || *endptr != '\0') exit_input_error(total+1); while(1) { if(i>=max_nr_attr-2) // need one more for index = -1 { max_nr_attr *= 2; x = (struct feature_node *) realloc(x,max_nr_attr*sizeof(struct feature_node)); } idx = strtok(NULL,":"); val = strtok(NULL," \t"); if(val == NULL) break; errno = 0; x[i].index = (int) strtol(idx,&endptr,10); if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index) exit_input_error(total+1); else inst_max_index = x[i].index; errno = 0; x[i].value = strtod(val,&endptr); if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr))) exit_input_error(total+1); // feature indices larger than those in training are not used if(x[i].index <= nr_feature) ++i; } if(model_->bias>=0) { x[i].index = n; x[i].value = model_->bias; i++; } x[i].index = -1; if(model_->normal){ double length = 0; for(int kk = 0; x[kk].index != -1; kk++) length += x[kk].value * x[kk].value; length = sqrt(length); for(int kk = 0; x[kk].index != -1; kk++) x[kk].value /= length; } if(flag_predict_probability) { int j; predict_label = predict_probability(model_,x,prob_estimates); fprintf(output,"%g",predict_label); for(j=0;j<model_->nr_class;j++) fprintf(output," %g",prob_estimates[j]); fprintf(output,"\n"); } else { predict_label = predict(model_,x); fprintf(output,"%g\n",predict_label); } if(predict_label == target_label) ++correct; error += (predict_label-target_label)*(predict_label-target_label); sump += predict_label; sumt += target_label; sumpp += predict_label*predict_label; sumtt += target_label*target_label; sumpt += predict_label*target_label; ++total; } if(model_->param.solver_type==L2R_L2LOSS_SVR || model_->param.solver_type==L2R_L1LOSS_SVR_DUAL || model_->param.solver_type==L2R_L2LOSS_SVR_DUAL) { info("Mean squared error = %g (regression)\n",error/total); info("Squared correlation coefficient = %g (regression)\n", ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/ ((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt)) ); } else info("Accuracy = %g%% (%d/%d)\n",(double) correct/total*100,correct,total); if(flag_predict_probability) free(prob_estimates); }
void do_predict(FILE *input, FILE *output, struct model* model_) { int correct = 0; int total = 0; int nr_class=get_nr_class(model_); double *prob_estimates=NULL; int j, n; int nr_feature=get_nr_feature(model_); if(model_->bias>=0) n=nr_feature+1; else n=nr_feature; if(flag_predict_probability) { int *labels; if(!check_probability_model(model_)) { fprintf(stderr, "probability output is only supported for logistic regression\n"); exit(1); } labels=(int *) malloc(nr_class*sizeof(int)); get_labels(model_,labels); prob_estimates = (double *) malloc(nr_class*sizeof(double)); fprintf(output,"labels"); for(j=0;j<nr_class;j++) fprintf(output," %d",labels[j]); fprintf(output,"\n"); free(labels); } max_line_len = 1024; line = (char *)malloc(max_line_len*sizeof(char)); while(readline(input) != NULL) { int i = 0; int target_label, predict_label; char *idx, *val, *label, *endptr; int inst_max_index = 0; // strtol gives 0 if wrong format label = strtok(line," \t"); target_label = (int) strtol(label,&endptr,10); if(endptr == label) exit_input_error(total+1); while(1) { if(i>=max_nr_attr-2) // need one more for index = -1 { max_nr_attr *= 2; x = (struct feature_node *) realloc(x,max_nr_attr*sizeof(struct feature_node)); } idx = strtok(NULL,":"); val = strtok(NULL," \t"); if(val == NULL) break; errno = 0; x[i].index = (int) strtol(idx,&endptr,10); if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index) exit_input_error(total+1); else inst_max_index = x[i].index; errno = 0; x[i].value = strtod(val,&endptr); if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr))) exit_input_error(total+1); // feature indices larger than those in training are not used if(x[i].index <= nr_feature) ++i; } if(model_->bias>=0) { x[i].index = n; x[i].value = model_->bias; i++; } x[i].index = -1; if(flag_predict_probability) { int j; predict_label = predict_probability(model_,x,prob_estimates); fprintf(output,"%d",predict_label); for(j=0;j<model_->nr_class;j++) fprintf(output," %g",prob_estimates[j]); fprintf(output,"\n"); } else { predict_label = predict(model_,x); fprintf(output,"%d\n",predict_label); } if(predict_label == target_label) ++correct; ++total; } printf("Accuracy = %g%% (%d/%d)\n",(double) correct/total*100,correct,total); if(flag_predict_probability) free(prob_estimates); }
void validate_detector(char *datacfg, char *cfgfile, char *weightfile, char *outfile) { 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)); 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")){ if(!outfile) outfile = "coco_results"; snprintf(buff, 1024, "%s/%s.json", prefix, outfile); fp = fopen(buff, "w"); fprintf(fp, "[\n"); coco = 1; } else if(0==strcmp(type, "imagenet")){ if(!outfile) outfile = "imagenet-detection"; snprintf(buff, 1024, "%s/%s.txt", prefix, outfile); fp = fopen(buff, "w"); imagenet = 1; classes = 200; } else { if(!outfile) outfile = "comp4_det_test_"; fps = calloc(classes, sizeof(FILE *)); for(j = 0; j < classes; ++j){ snprintf(buff, 1024, "%s/%s%s.txt", prefix, outfile, 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, .5); 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 *predictModelWholeGenome(void *arg) { thread_data_t *data = (thread_data_t *) arg; printf("data->trainedModel is %s\n", data->trainedModel); printf("data->coverageFileList is %s\n", data->coverageFileList); printf("data->trainFile %s\n", data->trainFile); printf("data->paramFile %s\n", data->paramFile); printf("data->chr is %d\n", data->chr); char *trainedModel = data->trainedModel; char *coverageFileList = data->coverageFileList; // char *trainFile = data->trainFile; char *paramFile = data->paramFile; int chr = data->chr; // utility var int i,j,k; // trainedModel struct model *mymodel; if( (mymodel = load_model(trainedModel)) == 0) { printf("cannot load model from file %s\n", trainedModel); return EXIT_SUCCESS; } // coverageFileList int totalCoverageFiles; FILE *coverageFileListFp = NULL; if( (coverageFileListFp = fopen(coverageFileList, "r") ) == NULL) { printf("Cannot open file %s\n", coverageFileList); return EXIT_SUCCESS; } char **coverageFiles = (char **)calloc(MAX_BAM_FILES,sizeof(char *)); for(i = 0; i < MAX_BAM_FILES; i++) { coverageFiles[i] = (char *)calloc(MAX_DIR_LEN, sizeof(char)); } i = 0; while (!feof(coverageFileListFp)) { if (i >= MAX_BAM_FILES) { printf("Error: the number of input coverages files exceeds the limit %d\n", i); return EXIT_SUCCESS; } if( ( fscanf(coverageFileListFp, "%s\n", coverageFiles[i]) ) != 1) { printf("Error: reading %dth from %s\n", i, coverageFileList); return EXIT_SUCCESS; } i++; } totalCoverageFiles = i; fclose(coverageFileListFp); // open coverage Files FILE *coverageFps[totalCoverageFiles]; for(i = 0; i < totalCoverageFiles; i++) { if( (coverageFps[i] = fopen(coverageFiles[i], "rb")) == NULL ) { printf("Error opening coverage file %s\n", coverageFiles[i]); return EXIT_SUCCESS; } } // paramFile struct extractFeatureParam *param = (struct extractFeatureParam *)calloc(1, sizeof(struct extractFeatureParam)); parseParam(paramFile, param); // predict model: by default: predict probability int nr_class = get_nr_class(mymodel); double *prob_estimates = (double *)calloc(nr_class, sizeof(double)); // predResult for storing results int totalBins = 0; int cumBins[NUM_SEQ]; for (i = 0; i < NUM_SEQ; i++) { totalBins += (int)(chrlen[i] / param->resolution) + 1; cumBins[i] = totalBins; } // allocate memory for result based on thread data chr // as we are using one thread for each chr float *predResult = (float *)calloc( (int)(chrlen[chr] / param->resolution) + 1, sizeof(float)); // read in feature for each bin and do prediction for(j = 0; j < (int)(chrlen[chr] / param->resolution) + 1; j++) { if(j % 100000 == 0) { printf("Predicting chr%d:%dth bin\n", chr,j); fflush(stdout); } int max_nr_feature = 100; struct feature_node *myX = (struct feature_node *)calloc(max_nr_feature, sizeof(struct feature_node)); int idx = 0; for(k = 0; k < totalCoverageFiles; k++) { float *buffer = (float *)calloc( param->windowSize/param->resolution,sizeof(float)); int offset = j; offset += -(int)((float)(param->windowSize / 2) / (float)param->resolution + 0.5); if(offset < 0 || offset + (int)((float)(param->windowSize) / (float)param->resolution + 0.5) > (int)(chrlen[i] / param->resolution) + 1) { // printf("offset is %d\n", offset); free(buffer); continue; } if(chr != 0) offset += cumBins[chr-1]; // printf("offset is %d\n", offset); fseek(coverageFps[k], offset*sizeof(float), SEEK_SET); fread(buffer, sizeof(float), param->windowSize/param->resolution, coverageFps[k]); int l; // printf("buffer[%d] is:",l); for(l = 0; l < param->windowSize/param->resolution; l++) { // if(j == 289540) printf("%f,",buffer[l]); if(buffer[l] != 0) { myX[idx].index = k*(param->windowSize/param->resolution) + l + 1; myX[idx].value = buffer[l]; idx++; } if(idx >= max_nr_feature -2) { // feature_node is not long enough max_nr_feature *= 2; myX = (struct feature_node *)realloc(myX, max_nr_feature*sizeof(struct feature_node)); } } free(buffer); } // end of loop through coverageFiles // printf("\n"); myX[idx].index = -1; // a flag for end of features if(idx == 0) { // printf("idx is %d\n",idx); predResult[j] = 0.0; free(myX); continue; } // printf("nr_feature is %d\n", idx); predict_probability(mymodel, myX, prob_estimates); // printf("num of feature is %d\n", get_nr_feature(mymodel)); // printf("num of class is %d\n", get_nr_class(mymodel)); int *mylabel = (int *)calloc(10, sizeof(int)); // added, in order to get the correct label get_labels(mymodel, mylabel); if(mylabel[0] == 1) { predResult[j] = prob_estimates[0]; } else { predResult[j] = prob_estimates[1]; } free(myX); free(mylabel); } for(i = 0; i < totalCoverageFiles; i++) { fclose(coverageFps[i]); } // free pointers for(i = 0; i < MAX_BAM_FILES; i++) { free(coverageFiles[i]); } free(coverageFiles); free(param); free(prob_estimates); // give address of pointer to this function, so that the function can free the pointer. free_and_destroy_model(&mymodel); pthread_exit((void *) predResult); }
void train_captcha(char *cfgfile, char *weightfile) { 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; int i = *net.seen/imgs; int solved = 1; list *plist; char **labels = get_labels("/data/captcha/reimgs.labels.list"); if (solved){ plist = get_paths("/data/captcha/reimgs.solved.list"); }else{ plist = get_paths("/data/captcha/reimgs.raw.list"); } char **paths = (char **)list_to_array(plist); printf("%d\n", plist->size); clock_t time; #if defined __linux__ || defined __APPLE__ || defined PTHREAD_WINDOWS pthread_t load_thread; #else #endif data train; data buffer; load_args args = {0}; args.w = net.w; args.h = net.h; args.paths = paths; args.classes = 26; args.n = imgs; args.m = plist->size; args.labels = labels; args.d = &buffer; args.type = CLASSIFICATION_DATA; #if defined __linux__ || defined __APPLE__ || defined PTHREAD_WINDOWS load_thread = load_data_in_thread(args); #endif while(1){ ++i; time=clock(); #if defined __linux__ || defined __APPLE__ || defined PTHREAD_WINDOWS pthread_join(load_thread, 0); #endif train = buffer; fix_data_captcha(train, solved); /* image im = float_to_image(256, 256, 3, train.X.vals[114]); show_image(im, "training"); cvWaitKey(0); */ #if defined __linux__ || defined __APPLE__ || defined PTHREAD_WINDOWS 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 == -1) avg_loss = loss; avg_loss = avg_loss*.9 + loss*.1; printf("%d: %f, %f avg, %lf seconds, %d images\n", i, loss, avg_loss, sec(clock()-time), *net.seen); free_data(train); if(i%100==0){ char buff[256]; sprintf(buff, "/home/pjreddie/imagenet_backup/%s_%d.weights",base, i); save_weights(net, buff); } } }
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); }