github
/
darknet
mirror of https://github.com/AlexeyAB/darknet.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Draw top5 accuracy on the Loss-chart for training Classifier

Browse Source
pull/4477/head
AlexeyAB 6 years ago
parent fc663f6efe
commit 6c28da5def
3 changed files with 80 additions and 30 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 80
      src/classifier.c
  2. 25
      src/detector.c
  3. 5
      src/image.c

80
src/classifier.c
Unescape View File

@ -23,13 +23,15 @@
image get_image_from_stream(CvCapture *cap); image get_image_from_stream(CvCapture *cap);
image get_image_from_stream_cpp(CvCapture *cap); image get_image_from_stream_cpp(CvCapture *cap);
#include "http_stream.h" #include "http_stream.h"
IplImage* draw_train_chart(float max_img_loss, int max_batches, int number_of_lines, int img_size, int dont_show); IplImage* draw_train_chart(float max_img_loss, int max_batches, int number_of_lines, int img_size, int dont_show);
void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches, void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches,
float precision, int draw_precision, int dont_show, int mjpeg_port); float precision, int draw_precision, char *accuracy_name, int dont_show, int mjpeg_port);
#endif #endif
float validate_classifier_single(char *datacfg, char *filename, char *weightfile, network *existing_net, int topk_custom);
float *get_regression_values(char **labels, int n) float *get_regression_values(char **labels, int n)
{ {
float *v = calloc(n, sizeof(float)); float *v = calloc(n, sizeof(float));
@ -42,7 +44,7 @@ float *get_regression_values(char **labels, int n)
return v; return v;
} }
void train_classifier(char *datacfg, char *cfgfile, char *weightfile, int *gpus, int ngpus, int clear, int dont_show, int mjpeg_port) void train_classifier(char *datacfg, char *cfgfile, char *weightfile, int *gpus, int ngpus, int clear, int dont_show, int mjpeg_port, int calc_topk)
{ {
int i; int i;
@ -83,7 +85,7 @@ void train_classifier(char *datacfg, char *cfgfile, char *weightfile, int *gpus,
list *plist = get_paths(train_list); list *plist = get_paths(train_list);
char **paths = (char **)list_to_array(plist); char **paths = (char **)list_to_array(plist);
printf("%d\n", plist->size); printf("%d\n", plist->size);
int N = plist->size; int train_images_num = plist->size;
clock_t time; clock_t time;
load_args args = {0}; load_args args = {0};
@ -105,14 +107,14 @@ void train_classifier(char *datacfg, char *cfgfile, char *weightfile, int *gpus,
args.paths = paths; args.paths = paths;
args.classes = classes; args.classes = classes;
args.n = imgs; args.n = imgs;
args.m = N; args.m = train_images_num;
args.labels = labels; args.labels = labels;
args.type = CLASSIFICATION_DATA; args.type = CLASSIFICATION_DATA;
#ifdef OPENCV #ifdef OPENCV
//args.threads = 3; //args.threads = 3;
IplImage* img = NULL; IplImage* img = NULL;
float max_img_loss = 5; float max_img_loss = 10;
int number_of_lines = 100; int number_of_lines = 100;
int img_size = 1000; int img_size = 1000;
img = draw_train_chart(max_img_loss, net.max_batches, number_of_lines, img_size, dont_show); img = draw_train_chart(max_img_loss, net.max_batches, number_of_lines, img_size, dont_show);
@ -126,6 +128,8 @@ void train_classifier(char *datacfg, char *cfgfile, char *weightfile, int *gpus,
int iter_save = get_current_batch(net); int iter_save = get_current_batch(net);
int iter_save_last = get_current_batch(net); int iter_save_last = get_current_batch(net);
int iter_topk = get_current_batch(net);
float topk = 0;
while(get_current_batch(net) < net.max_batches || net.max_batches == 0){ while(get_current_batch(net) < net.max_batches || net.max_batches == 0){
time=clock(); time=clock();
@ -152,9 +156,32 @@ void train_classifier(char *datacfg, char *cfgfile, char *weightfile, int *gpus,
i = get_current_batch(net); i = get_current_batch(net);
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); int calc_topk_for_each = iter_topk + 4 * train_images_num / (net.batch * net.subdivisions); // calculate TOPk for each 4 Epochs
calc_topk_for_each = fmax(calc_topk_for_each, net.burn_in);
calc_topk_for_each = fmax(calc_topk_for_each, 1000);
if (i % 10 == 0) {
if (calc_topk) {
fprintf(stderr, "\n (next TOP5 calculation at %d iterations) ", calc_topk_for_each);
if (topk > 0) fprintf(stderr, " Last accuracy TOP5 = %2.2f %% \n", topk * 100);
}
if (net.cudnn_half) {
if (i < net.burn_in * 3) fprintf(stderr, " Tensor Cores are disabled until the first %d iterations are reached.\n", 3 * net.burn_in);
else fprintf(stderr, " Tensor Cores are used.\n");
}
}
int draw_precision = 0;
if (calc_topk && (i >= calc_topk_for_each || i == net.max_batches)) {
iter_topk = i;
topk = validate_classifier_single(datacfg, cfgfile, weightfile, &net, 5); // calc TOP5
printf("\n accuracy TOP5 = %f \n", topk);
draw_precision = 1;
}
printf("%d, %.3f: %f, %f avg, %f rate, %lf seconds, %d images\n", get_current_batch(net), (float)(*net.seen)/ train_images_num, loss, avg_loss, get_current_rate(net), sec(clock()-time), *net.seen);
#ifdef OPENCV #ifdef OPENCV
draw_train_loss(img, img_size, avg_loss, max_img_loss, i, net.max_batches, -1, 0, dont_show, mjpeg_port); draw_train_loss(img, img_size, avg_loss, max_img_loss, i, net.max_batches, topk, draw_precision, "top5", dont_show, mjpeg_port);
#endif // OPENCV #endif // OPENCV
if (i >= (iter_save + 1000)) { if (i >= (iter_save + 1000)) {
@ -512,14 +539,25 @@ void validate_classifier_full(char *datacfg, char *filename, char *weightfile)
} }
void validate_classifier_single(char *datacfg, char *filename, char *weightfile) float validate_classifier_single(char *datacfg, char *filename, char *weightfile, network *existing_net, int topk_custom)
{ {
int i, j; int i, j;
network net = parse_network_cfg(filename); network net;
if(weightfile){ int old_batch = -1;
load_weights(&net, weightfile); if (existing_net) {
net = *existing_net; // for validation during training
old_batch = net.batch;
set_batch_network(&net, 1);
}
else {
net = parse_network_cfg_custom(filename, 1, 0);
if (weightfile) {
load_weights(&net, weightfile);
}
//set_batch_network(&net, 1);
fuse_conv_batchnorm(net);
calculate_binary_weights(net);
} }
set_batch_network(&net, 1);
srand(time(0)); srand(time(0));
list *options = read_data_cfg(datacfg); list *options = read_data_cfg(datacfg);
@ -530,7 +568,9 @@ void validate_classifier_single(char *datacfg, char *filename, char *weightfile)
char *valid_list = option_find_str(options, "valid", "data/train.list"); char *valid_list = option_find_str(options, "valid", "data/train.list");
int classes = option_find_int(options, "classes", 2); int classes = option_find_int(options, "classes", 2);
int topk = option_find_int(options, "top", 1); int topk = option_find_int(options, "top", 1);
if (topk_custom > 0) topk = topk_custom; // for validation during training
if (topk > classes) topk = classes; if (topk > classes) topk = classes;
printf(" TOP calculation...\n");
char **labels = get_labels(label_list); char **labels = get_labels(label_list);
list *plist = get_paths(valid_list); list *plist = get_paths(valid_list);
@ -571,8 +611,15 @@ void validate_classifier_single(char *datacfg, char *filename, char *weightfile)
if(indexes[j] == class_id) avg_topk += 1; if(indexes[j] == class_id) avg_topk += 1;
} }
printf("%d: top 1: %f, top %d: %f\n", i, avg_acc/(i+1), topk, avg_topk/(i+1)); if (existing_net) printf("\r");
else printf("\n");
printf("%d: top 1: %f, top %d: %f", i, avg_acc/(i+1), topk, avg_topk/(i+1));
}
if (existing_net) {
set_batch_network(&net, old_batch);
} }
float topk_result = avg_topk / i;
return topk_result;
} }
void validate_classifier_multi(char *datacfg, char *filename, char *weightfile) void validate_classifier_multi(char *datacfg, char *filename, char *weightfile)
@ -1198,6 +1245,7 @@ void run_classifier(int argc, char **argv)
} }
int mjpeg_port = find_int_arg(argc, argv, "-mjpeg_port", -1); int mjpeg_port = find_int_arg(argc, argv, "-mjpeg_port", -1);
int calc_topk = find_int_arg(argc, argv, "-topk", -1);
char *gpu_list = find_char_arg(argc, argv, "-gpus", 0); char *gpu_list = find_char_arg(argc, argv, "-gpus", 0);
int *gpus = 0; int *gpus = 0;
int gpu = 0; int gpu = 0;
@ -1233,13 +1281,13 @@ void run_classifier(int argc, char **argv)
int layer = layer_s ? atoi(layer_s) : -1; int layer = layer_s ? atoi(layer_s) : -1;
if(0==strcmp(argv[2], "predict")) predict_classifier(data, cfg, weights, filename, top); if(0==strcmp(argv[2], "predict")) predict_classifier(data, cfg, weights, filename, top);
else if(0==strcmp(argv[2], "try")) try_classifier(data, cfg, weights, filename, atoi(layer_s)); else if(0==strcmp(argv[2], "try")) try_classifier(data, cfg, weights, filename, atoi(layer_s));
else if(0==strcmp(argv[2], "train")) train_classifier(data, cfg, weights, gpus, ngpus, clear, dont_show, mjpeg_port); else if(0==strcmp(argv[2], "train")) train_classifier(data, cfg, weights, gpus, ngpus, clear, dont_show, mjpeg_port, calc_topk);
else if(0==strcmp(argv[2], "demo")) demo_classifier(data, cfg, weights, cam_index, filename); else if(0==strcmp(argv[2], "demo")) demo_classifier(data, cfg, weights, cam_index, filename);
else if(0==strcmp(argv[2], "gun")) gun_classifier(data, cfg, weights, cam_index, filename); else if(0==strcmp(argv[2], "gun")) gun_classifier(data, cfg, weights, cam_index, filename);
else if(0==strcmp(argv[2], "threat")) threat_classifier(data, cfg, weights, cam_index, filename); else if(0==strcmp(argv[2], "threat")) threat_classifier(data, cfg, weights, cam_index, filename);
else if(0==strcmp(argv[2], "test")) test_classifier(data, cfg, weights, layer); else if(0==strcmp(argv[2], "test")) test_classifier(data, cfg, weights, layer);
else if(0==strcmp(argv[2], "label")) label_classifier(data, cfg, weights); else if(0==strcmp(argv[2], "label")) label_classifier(data, cfg, weights);
else if(0==strcmp(argv[2], "valid")) validate_classifier_single(data, cfg, weights); else if(0==strcmp(argv[2], "valid")) validate_classifier_single(data, cfg, weights, NULL, -1);
else if(0==strcmp(argv[2], "validmulti")) validate_classifier_multi(data, cfg, weights); else if(0==strcmp(argv[2], "validmulti")) validate_classifier_multi(data, cfg, weights);
else if(0==strcmp(argv[2], "valid10")) validate_classifier_10(data, cfg, weights); else if(0==strcmp(argv[2], "valid10")) validate_classifier_10(data, cfg, weights);
else if(0==strcmp(argv[2], "validcrop")) validate_classifier_crop(data, cfg, weights); else if(0==strcmp(argv[2], "validcrop")) validate_classifier_crop(data, cfg, weights);

25
src/detector.c
Unescape View File

@ -25,10 +25,10 @@
#pragma comment(lib, "opencv_imgproc" OPENCV_VERSION ".lib") #pragma comment(lib, "opencv_imgproc" OPENCV_VERSION ".lib")
#pragma comment(lib, "opencv_highgui" OPENCV_VERSION ".lib") #pragma comment(lib, "opencv_highgui" OPENCV_VERSION ".lib")
#endif #endif
IplImage* draw_train_chart(float max_img_loss, int max_batches, int number_of_lines, int img_size, int dont_show); IplImage* draw_train_chart(float max_img_loss, int max_batches, int number_of_lines, int img_size, int dont_show);
void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches, void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches,
float precision, int draw_precision, int dont_show, int mjpeg_port); float precision, int draw_precision, char *accuracy_name, int dont_show, int mjpeg_port);
#define CV_RGB(r, g, b) cvScalar( (b), (g), (r), 0 ) #define CV_RGB(r, g, b) cvScalar( (b), (g), (r), 0 )
#endif // OPENCV #endif // OPENCV
@ -244,20 +244,23 @@ void train_detector(char *datacfg, char *cfgfile, char *weightfile, int *gpus, i
avg_loss = avg_loss*.9 + loss*.1; avg_loss = avg_loss*.9 + loss*.1;
i = get_current_batch(net); i = get_current_batch(net);
if (mean_average_precision > 0) {
printf("\n Last accuracy mAP@0.5 = %2.2f %% ", mean_average_precision*100); int calc_map_for_each = iter_map + 4 * train_images_num / (net.batch * net.subdivisions); // calculate mAP for each 4 Epochs
calc_map_for_each = fmax(calc_map_for_each, net.burn_in);
calc_map_for_each = fmax(calc_map_for_each, 1000);
if (calc_map) {
printf("\n (next mAP calculation at %d iterations) ", calc_map_for_each);
if (mean_average_precision > 0) printf("\n Last accuracy mAP@0.5 = %2.2f %% ", mean_average_precision * 100);
} }
int calc_map_for_each = 4 * train_images_num / (net.batch * net.subdivisions); // calculate mAP for each 4 Epochs
if (calc_map) printf("\n (next mAP calculation at %d iterations) ", (iter_map + calc_map_for_each));
if (net.cudnn_half) { if (net.cudnn_half) {
if (i < net.burn_in * 3) printf("\n Tensor Cores are disabled until the first %d iterations are reached.", 3 * net.burn_in); if (i < net.burn_in * 3) fprintf(stderr, "\n Tensor Cores are disabled until the first %d iterations are reached.", 3 * net.burn_in);
else printf("\n Tensor Cores are used."); else fprintf(stderr, "\n Tensor Cores are used.");
} }
printf("\n %d: %f, %f avg loss, %f rate, %lf seconds, %d images\n", get_current_batch(net), loss, avg_loss, get_current_rate(net), (what_time_is_it_now() - time), i*imgs); printf("\n %d: %f, %f avg loss, %f rate, %lf seconds, %d images\n", get_current_batch(net), loss, avg_loss, get_current_rate(net), (what_time_is_it_now() - time), i*imgs);
int draw_precision = 0; int draw_precision = 0;
if (calc_map && (i >= (iter_map + calc_map_for_each) || i == net.max_batches) && i >= net.burn_in && i >= 1000) { if (calc_map && (i >= calc_map_for_each || i == net.max_batches)) {
if (l.random) { if (l.random) {
printf("Resizing to initial size: %d x %d \n", init_w, init_h); printf("Resizing to initial size: %d x %d \n", init_w, init_h);
args.w = init_w; args.w = init_w;
@ -281,7 +284,7 @@ void train_detector(char *datacfg, char *cfgfile, char *weightfile, int *gpus, i
draw_precision = 1; draw_precision = 1;
} }
#ifdef OPENCV #ifdef OPENCV
draw_train_loss(img, img_size, avg_loss, max_img_loss, i, net.max_batches, mean_average_precision, draw_precision, dont_show, mjpeg_port); draw_train_loss(img, img_size, avg_loss, max_img_loss, i, net.max_batches, mean_average_precision, draw_precision, "mAP%", dont_show, mjpeg_port);
#endif // OPENCV #endif // OPENCV
//if (i % 1000 == 0 || (i < 1000 && i % 100 == 0)) { //if (i % 1000 == 0 || (i < 1000 && i % 100 == 0)) {
@ -975,7 +978,7 @@ float validate_detector_map(char *datacfg, char *cfgfile, char *weightfile, floa
thresh_calc_avg_iou, tp_for_thresh, fp_for_thresh, unique_truth_count - tp_for_thresh, avg_iou * 100); thresh_calc_avg_iou, tp_for_thresh, fp_for_thresh, unique_truth_count - tp_for_thresh, avg_iou * 100);
mean_average_precision = mean_average_precision / classes; mean_average_precision = mean_average_precision / classes;
printf("\n IoU threshold = %2.2f %% \n", iou_thresh * 100); printf("\n IoU threshold = %2.0f %% \n", iou_thresh * 100);
printf(" mean average precision (mAP@%0.2f) = %f, or %2.2f %% \n", iou_thresh, mean_average_precision, mean_average_precision * 100); printf(" mean average precision (mAP@%0.2f) = %f, or %2.2f %% \n", iou_thresh, mean_average_precision, mean_average_precision * 100);

5
src/image.c
Unescape View File

@ -762,7 +762,7 @@ IplImage* draw_train_chart(float max_img_loss, int max_batches, int number_of_li
} }
void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches, void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches,
float precision, int draw_precision, int dont_show, int mjpeg_port) float precision, int draw_precision, char *accuracy_name, int dont_show, int mjpeg_port)
{ {
int img_offset = 50; int img_offset = 50;
int draw_size = img_size - img_offset; int draw_size = img_size - img_offset;
@ -780,7 +780,7 @@ void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_
static float old_precision = 0; static float old_precision = 0;
static int iteration_old = 0; static int iteration_old = 0;
static int text_iteration_old = 0; static int text_iteration_old = 0;
if(iteration_old == 0) cvPutText(img, "mAP%", cvPoint(0, 12), &font, CV_RGB(255, 0, 0)); if(iteration_old == 0) cvPutText(img, accuracy_name, cvPoint(0, 12), &font, CV_RGB(255, 0, 0));
cvLine(img, cvLine(img,
cvPoint(img_offset + draw_size * (float)iteration_old / max_batches, draw_size * (1 - old_precision)), cvPoint(img_offset + draw_size * (float)iteration_old / max_batches, draw_size * (1 - old_precision)),
@ -815,7 +815,6 @@ void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_
k = cvWaitKey(20); k = cvWaitKey(20);
} }
if (k == 's' || current_batch == (max_batches - 1) || current_batch % 100 == 0) { if (k == 's' || current_batch == (max_batches - 1) || current_batch % 100 == 0) {
//cvSaveImage("chart.jpg", img, 0);
save_cv_png(img, "chart.png"); save_cv_png(img, "chart.png");
cvPutText(img, "- Saved", cvPoint(250, img_size - 10), &font, CV_RGB(255, 0, 0)); cvPutText(img, "- Saved", cvPoint(250, img_size - 10), &font, CV_RGB(255, 0, 0));
} }

Write Preview
Loading…
Cancel
Save