def write_voc_results_file(all_boxes, test_imgid_list, det_save_dir): ''' :param all_boxes: is a list. each item reprensent the detections of a img. the detections is a array. shape is [-1, 7]. [category, score, x, y, w, h, theta] Note that: if none detections in this img. that the detetions is : [] :param test_imgid_list: :param det_save_path: :return: ''' for cls, cls_id in NAME_LABEL_MAP.items(): if cls == 'back_ground': continue print("Writing {} VOC resutls file".format(cls)) tools.mkdir(det_save_dir) det_save_path = os.path.join(det_save_dir, "det_" + cls + ".txt") with open(det_save_path, 'wt') as f: for index, img_name in enumerate(test_imgid_list): this_img_detections = all_boxes[index] this_cls_detections = this_img_detections[ this_img_detections[:, 0] == cls_id] if this_cls_detections.shape[0] == 0: continue # this cls has none detections in this img for a_det in this_cls_detections: f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f} {:.1f}\n'. format(img_name, a_det[1], a_det[2], a_det[3], a_det[4], a_det[5], a_det[6]) ) # that is [img_name, score, x, y, w, h, theta]
def do_python_eval(test_imgid_list, test_annotation_path): AP_list = [] #import matplotlib.pyplot as plt #import matplotlib.colors as colors #color_list = colors.cnames.keys()[::6] for cls, index in NAME_LABEL_MAP.items(): if cls == 'back_ground': continue recall, precision, AP = voc_eval(detpath=os.path.join( cfgs.EVALUATE_DIR, cfgs.VERSION), test_imgid_list=test_imgid_list, cls_name=cls, annopath=test_annotation_path) AP_list += [AP] pl.plot(recall, precision, lw=2, label='{} (AP = {:.4f})' ''.format(cls, AP)) print(10 * "__") pl.xlabel('Recall') pl.ylabel('Precision') pl.grid(True) pl.ylim([0.0, 1.05]) pl.xlim([0.0, 1.0]) pl.title('Precision-Recall') pl.legend(loc="lower left") pl.show() pl.savefig(cfgs.VERSION + '_eval.jpg') print("hello") print("mAP is : {}".format(np.mean(AP_list)))
def do_python_eval(test_imgid_list, test_annotation_path): import matplotlib.colors as colors import matplotlib.pyplot as plt AP_list = [] for cls, index in NAME_LABEL_MAP.items(): if cls == 'back_ground': continue recall, precision, AP = voc_eval(detpath=cfgs.EVALUATE_R_DIR, test_imgid_list=test_imgid_list, cls_name=cls, annopath=test_annotation_path) AP_list += [AP] print("cls : {}|| Recall: {} || Precison: {}|| AP: {}".format( cls, recall[-1], precision[-1], AP)) # print("{}_ap: {}".format(cls, AP)) # print("{}_recall: {}".format(cls, recall[-1])) # print("{}_precision: {}".format(cls, precision[-1])) c = colors.cnames.keys() c_dark = list(filter(lambda x: x.startswith('dark'), c)) c = ['red', 'orange'] plt.axis([0, 1.2, 0, 1]) plt.plot(recall, precision, color=c_dark[index], label=cls) plt.legend(loc='upper right') plt.xlabel('R') plt.ylabel('P') plt.savefig('./PR_R.png') print("mAP is : {}".format(np.mean(AP_list)))
def do_python_eval(test_imgid_list, test_annotation_path): AP_list = [] # import matplotlib.pyplot as plt # import matplotlib.colors as colors # color_list = colors.cnames.keys()[::6] for cls, index in NAME_LABEL_MAP.items(): if cls == 'back_ground': continue recall, precision, AP = voc_eval(detpath=os.path.join( cfgs.EVALUATE_DIR, cfgs.VERSION), test_imgid_list=test_imgid_list, cls_name=cls, annopath=test_annotation_path, ovthresh=cfgs.EVAL_THRESHOLD, use_07_metric=cfgs.USE_07_METRIC) AP_list += [AP] print("cls : {}|| Recall: {} || Precison: {}|| AP: {}".format( cls, recall[-1], precision[-1], AP)) # plt.plot(recall, precision, label=cls, color=color_list[index]) # plt.legend(loc='upper right') print(10 * "__") # plt.show() # plt.savefig(cfgs.VERSION+'.jpg') print("mAP is : {}".format(np.mean(AP_list)))
def do_python_eval(test_imgid_list, test_annotation_path, iou_thresh=0.5): import matplotlib.colors as colors import matplotlib.pyplot as plt AP_list = [] recall_all = 0 precision_all = 0 cls_to_avg = 0 gt_cls_num_all = 0 tp_all = 0 fp_all = 0 for cls, index in NAME_LABEL_MAP.items(): if cls == 'back_ground': continue recall, precision, AP, gt_cls_num, tp, fp = voc_eval( detpath=cfgs.INFERENCE_SAVE_PATH, test_imgid_list=test_imgid_list, cls_name=cls, annopath=test_annotation_path, ovthresh=iou_thresh) # print('cls:', cls, 'gt num:', gt_cls_num) if np.isnan(AP): continue if AP == 0: #recall.size == 0 or precision.size == 0: if gt_cls_num == 0: continue else: recall, precision, tp, fp = [0], [0], [0], [0] AP_list += [AP] recall_all += recall[-1] precision_all += precision[-1] cls_to_avg += 1 gt_cls_num_all += gt_cls_num tp_all += tp[-1] fp_all += fp[-1] print( "cls : {}|| num : {}|| Recall: {} || Precison: {}|| AP: {}".format( cls, gt_cls_num, recall[-1], precision[-1], AP)) c = colors.cnames.keys() c_dark = list(filter(lambda x: x.startswith('dark'), c)) c = ['red', 'orange'] plt.axis([0, 1.2, 0.5, 1]) plt.plot(recall[::500], precision[::500], color=c_dark[index], label=cls) # print(recall, precision) plt.legend(loc='upper right') plt.xlabel('R') plt.ylabel('P') plt.savefig('./PR_R.png') print("avg recall is {}".format(recall_all / cls_to_avg)) print("avg precision is {}".format(precision_all / cls_to_avg)) print("avg false alarm is {}".format(fp_all / (tp_all + fp_all))) print("mAP is : {}".format(np.mean(AP_list)))
def _write_voc_results_file(all_boxes, test_imgid_list, det_save_path): for cls, cls_ind in NAME_LABEL_MAP.items(): if cls == 'back_ground': continue print('Writing {} VOC results file'.format(cls)) with open(det_save_path, 'wt') as f: for im_ind, index in enumerate(test_imgid_list): dets = all_boxes[cls_ind][im_ind] if dets == []: continue # the VOCdevkit expects 1-based indices for k in range(dets.shape[0]): f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'.format( index, dets[k, -1], dets[k, 0] + 1, dets[k, 1] + 1, dets[k, 2] + 1, dets[k, 3] + 1))
def do_python_eval(test_imgid_list, test_annotation_path): import matplotlib.colors as colors import matplotlib.pyplot as plt mAP_dict = {} mPrecision_dict = {} mRecall_dict = {} for cls, index in NAME_LABEL_MAP.items(): print(cls) if cls == 'back_ground': continue recall, precision, AP = voc_eval(detpath=cfgs.EVALUATE_H_DIR, test_imgid_list=test_imgid_list, cls_name=cls, annopath=test_annotation_path) Precision_cls = np.mean(precision) Recall_cls = np.mean(recall) print("{}_AP: {}".format(cls, AP)) print("{}_mRecall: {}".format(cls, Recall_cls)) print("{}_mPrecision: {}".format(cls, Precision_cls)) mAP_dict[cls] = AP mPrecision_dict[cls] = Precision_cls mRecall_dict[cls] = Recall_cls c = colors.cnames.keys() c_dark = list(filter(lambda x: x.startswith('dark'), c)) c = ['blue', 'green'] plt.axis([0, 1.2, 0, 1]) plt.plot(recall, precision, color=c_dark[index], label=cls) plt.legend(loc='upper right') plt.xlabel('Recall') plt.ylabel('Precision') plt.savefig('./PR_H.png') print(mAP_dict, mRecall_dict, mPrecision_dict) total_mAP = np.mean(get_values_from_dict(mAP_dict)) total_mRecall = np.mean(get_values_from_dict(mRecall_dict)) total_mPrecision = np.mean(get_values_from_dict(mPrecision_dict)) print("mAP_H is : {}".format(total_mAP)) print("mRecall_H is : {}".format(total_mRecall)) print("mPrecision_H is : {}".format(total_mPrecision)) # print(mAP, recall, precision) return total_mAP, total_mRecall, total_mPrecision, mAP_dict, mRecall_dict, mPrecision_dict
def do_python_eval(test_imgid_list, test_annotation_path): # import matplotlib.colors as colors # import matplotlib.pyplot as plt AP_list = [] for cls, index in NAME_LABEL_MAP.items(): if cls == 'back_ground': continue recall, precision, AP = voc_eval(detpath=cfgs.EVALUATE_R_DIR, test_imgid_list=test_imgid_list, cls_name=cls, annopath=test_annotation_path, use_07_metric=cfgs.USE_07_METRIC, ovthresh=cfgs.EVAL_THRESHOLD) AP_list += [AP] print("cls : {}|| Recall: {} || Precison: {}|| AP: {}".format( cls, recall[-1], precision[-1], AP)) # print("{}_ap: {}".format(cls, AP)) # print("{}_recall: {}".format(cls, recall[-1])) # print("{}_precision: {}".format(cls, precision[-1])) r = np.array(recall) p = np.array(precision) F1 = 2 * r * p / (r + p) max_ind = np.argmax(F1) print('F1:{} P:{} R:{}'.format(F1[max_ind], p[max_ind], r[max_ind])) # c = colors.cnames.keys() # c_dark = list(filter(lambda x: x.startswith('dark'), c)) # c = ['red', 'orange'] # plt.axis([0, 1.2, 0, 1]) # plt.plot(recall, precision, color=c_dark[index], label=cls) # plt.legend(loc='upper right') # plt.xlabel('R') # plt.ylabel('P') # plt.savefig('./PR_R.png') print("mAP is : {}".format(np.mean(AP_list)))
def inference(det_net, file_paths, des_folder, h_len, w_len, h_overlap, w_overlap, save_res=False): if save_res: assert cfgs.SHOW_SCORE_THRSHOLD >= 0.5, \ 'please set score threshold (example: SHOW_SCORE_THRSHOLD = 0.5) in cfgs.py' else: assert cfgs.SHOW_SCORE_THRSHOLD < 0.005, \ 'please set score threshold (example: SHOW_SCORE_THRSHOLD = 0.00) in cfgs.py' tmp_file = './tmp_%s.txt' % cfgs.VERSION # 1. preprocess img img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3]) img_batch = tf.cast(img_plac, tf.float32) if cfgs.NET_NAME in ['resnet101_v1d', 'resnet50_v1d']: img_batch = (img_batch / 255 - tf.constant( cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) else: img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN) img_batch = tf.expand_dims(img_batch, axis=0) img_batch = short_side_resize_for_inference_data( img_tensor=img_batch, target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN[0], is_resize=False) det_boxes_h, det_scores_h, det_category_h = det_net.build_whole_detection_network( input_img_batch=img_batch, gtboxes_batch=None) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) restorer, restore_ckpt = det_net.get_restorer() config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: sess.run(init_op) if not restorer is None: restorer.restore(sess, restore_ckpt) print('restore model') if not os.path.exists(tmp_file): fw = open(tmp_file, 'w') fw.close() fr = open(tmp_file, 'r') pass_img = fr.readlines() fr.close() for count, img_path in enumerate(file_paths): fw = open(tmp_file, 'a+') if img_path + '\n' in pass_img: continue start = timer() img = cv2.imread(img_path) box_res = [] label_res = [] score_res = [] imgH = img.shape[0] imgW = img.shape[1] ori_H = imgH ori_W = imgW # print(" ori_h, ori_w: ", imgH, imgW) if imgH < h_len: temp = np.zeros([h_len, imgW, 3], np.float32) temp[0:imgH, :, :] = img img = temp imgH = h_len if imgW < w_len: temp = np.zeros([imgH, w_len, 3], np.float32) temp[:, 0:imgW, :] = img img = temp imgW = w_len for hh in range(0, imgH, h_len - h_overlap): if imgH - hh - 1 < h_len: hh_ = imgH - h_len else: hh_ = hh for ww in range(0, imgW, w_len - w_overlap): if imgW - ww - 1 < w_len: ww_ = imgW - w_len else: ww_ = ww src_img = img[hh_:(hh_ + h_len), ww_:(ww_ + w_len), :] for short_size in cfgs.IMG_SHORT_SIDE_LEN: max_len = 1200 if h_len < w_len: new_h, new_w = short_size, min( int(short_size * float(w_len) / h_len), max_len) else: new_h, new_w = min( int(short_size * float(h_len) / w_len), max_len), short_size img_resize = cv2.resize(src_img, (new_h, new_w)) det_boxes_h_, det_scores_h_, det_category_h_ = \ sess.run( [det_boxes_h, det_scores_h, det_category_h], feed_dict={img_plac: img_resize[:, :, ::-1]} ) valid = det_scores_h_ > 1e-4 det_boxes_h_ = det_boxes_h_[valid] det_scores_h_ = det_scores_h_[valid] det_category_h_ = det_category_h_[valid] det_boxes_h_[:, 0] = det_boxes_h_[:, 0] * w_len / new_w det_boxes_h_[:, 1] = det_boxes_h_[:, 1] * h_len / new_h det_boxes_h_[:, 2] = det_boxes_h_[:, 2] * w_len / new_w det_boxes_h_[:, 3] = det_boxes_h_[:, 3] * h_len / new_h if len(det_boxes_h_) > 0: for ii in range(len(det_boxes_h_)): box = det_boxes_h_[ii] box[0] = box[0] + ww_ box[1] = box[1] + hh_ box[2] = box[2] + ww_ box[3] = box[3] + hh_ box_res.append(box) label_res.append(det_category_h_[ii]) score_res.append(det_scores_h_[ii]) box_res = np.array(box_res) label_res = np.array(label_res) score_res = np.array(score_res) box_res_, label_res_, score_res_ = [], [], [] # h_threshold = {'roundabout': 0.35, 'tennis-court': 0.35, 'swimming-pool': 0.4, 'storage-tank': 0.3, # 'soccer-ball-field': 0.3, 'small-vehicle': 0.4, 'ship': 0.35, 'plane': 0.35, # 'large-vehicle': 0.4, 'helicopter': 0.4, 'harbor': 0.3, 'ground-track-field': 0.4, # 'bridge': 0.3, 'basketball-court': 0.4, 'baseball-diamond': 0.3} h_threshold = { 'turntable': 0.5, 'tennis-court': 0.5, 'swimming-pool': 0.5, 'storage-tank': 0.5, 'soccer-ball-field': 0.5, 'small-vehicle': 0.5, 'ship': 0.5, 'plane': 0.5, 'large-vehicle': 0.5, 'helicopter': 0.5, 'harbor': 0.5, 'ground-track-field': 0.5, 'bridge': 0.5, 'basketball-court': 0.5, 'baseball-diamond': 0.5, 'container-crane': 0.5 } for sub_class in range(1, cfgs.CLASS_NUM + 1): index = np.where(label_res == sub_class)[0] if len(index) == 0: continue tmp_boxes_h = box_res[index] tmp_label_h = label_res[index] tmp_score_h = score_res[index] tmp_boxes_h = np.array(tmp_boxes_h) tmp = np.zeros( [tmp_boxes_h.shape[0], tmp_boxes_h.shape[1] + 1]) tmp[:, 0:-1] = tmp_boxes_h tmp[:, -1] = np.array(tmp_score_h) # inx = nms.py_cpu_nms(dets=np.array(tmp, np.float32), # thresh=h_threshold[LABEL_NAME_MAP[sub_class]], # max_output_size=500) inx = nms(np.array(tmp, np.float32), h_threshold[LABEl_NAME_MAP[sub_class]]) inx = inx[:500] # max_outpus is 500 box_res_.extend(np.array(tmp_boxes_h)[inx]) score_res_.extend(np.array(tmp_score_h)[inx]) label_res_.extend(np.array(tmp_label_h)[inx]) time_elapsed = timer() - start if save_res: scores = np.array(score_res_) labels = np.array(label_res_) boxes = np.array(box_res_) valid_show = scores > cfgs.SHOW_SCORE_THRSHOLD scores = scores[valid_show] boxes = boxes[valid_show] labels = labels[valid_show] det_detections_h = draw_box_in_img.draw_boxes_with_label_and_scores( np.array(img, np.float32), boxes=boxes, labels=labels, scores=scores, in_graph=False) det_detections_h = det_detections_h[:ori_H, :ori_W] save_dir = os.path.join(des_folder, cfgs.VERSION) tools.mkdir(save_dir) cv2.imwrite( save_dir + '/' + img_path.split('/')[-1].split('.')[0] + '_h_s%d_t%f.jpg' % (h_len, cfgs.FAST_RCNN_NMS_IOU_THRESHOLD), det_detections_h) view_bar( '{} cost {}s'.format( img_path.split('/')[-1].split('.')[0], time_elapsed), count + 1, len(file_paths)) else: # eval txt CLASS_DOTA = NAME_LABEL_MAP.keys() # Task2 write_handle_h = {} txt_dir_h = os.path.join('txt_output', cfgs.VERSION + '_h') tools.mkdir(txt_dir_h) for sub_class in CLASS_DOTA: if sub_class == 'back_ground': continue write_handle_h[sub_class] = open( os.path.join(txt_dir_h, 'Task2_%s.txt' % sub_class), 'a+') for i, hbox in enumerate(box_res_): command = '%s %.3f %.1f %.1f %.1f %.1f\n' % ( img_path.split('/')[-1].split('.')[0], score_res_[i], hbox[0], hbox[1], hbox[2], hbox[3]) write_handle_h[LABEl_NAME_MAP[label_res_[i]]].write( command) for sub_class in CLASS_DOTA: if sub_class == 'back_ground': continue write_handle_h[sub_class].close() view_bar( '{} cost {}s'.format( img_path.split('/')[-1].split('.')[0], time_elapsed), count + 1, len(file_paths)) fw.write('{}\n'.format(img_path)) fw.close() os.remove(tmp_file)
def eval_with_plac(img_dir, det_net, num_imgs, image_ext, draw_imgs, test_annotation_path): # 1. preprocess img img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3]) # is RGB. not GBR img_batch = tf.cast(img_plac, tf.float32) img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN) img_batch = short_side_resize_for_inference_data( img_tensor=img_batch, target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN, is_resize=False) det_boxes_h, det_scores_h, det_category_h, \ det_boxes_r, det_scores_r, det_category_r = det_net.build_whole_detection_network( input_img_batch=img_batch, gtboxes_h_batch=None, gtboxes_r_batch=None) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) global_step_tensor = slim.get_or_create_global_step() eval_result = [] last_checkpoint_name = None while True: restorer, restore_ckpt = det_net.get_restorer() #saver = tf.train.Saver(max_to_keep=10) start_time = time.time() model_path = os.path.splitext(os.path.basename(restore_ckpt))[0] if model_path == None: print("Wait for available checkpoint") elif last_checkpoint_name == model_path: print( "Already evaluated checkpoint {}, we will try evaluation in {} seconds" .format(model_path, EVAL_INTERVAL)) #continue else: print('Last ckpt was {}, new ckpt is {}'.format( last_checkpoint_name, model_path)) last_checkpoint_name = model_path config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: sess.run(init_op) sess.run(global_step_tensor.initializer) if not restorer is None: restorer.restore(sess, restore_ckpt) print('restore model', restore_ckpt) global_stepnp = tf.train.global_step(sess, global_step_tensor) print('#########################', global_stepnp) all_boxes_h = [] all_boxes_r = [] imgs = os.listdir(img_dir) imgs_len = len(imgs) none_detected_image = [] for i, a_img_name in enumerate(imgs[:]): a_img_name = a_img_name.split(image_ext)[0] image_name = a_img_name + image_ext print('\n', a_img_name) raw_img = cv2.imread( os.path.join(img_dir, a_img_name + image_ext)) raw_h, raw_w = raw_img.shape[0], raw_img.shape[1] start = time.time() resized_img, det_boxes_h_, det_scores_h_, det_category_h_, \ det_boxes_r_, det_scores_r_, det_category_r_ = \ sess.run( [img_batch, det_boxes_h, det_scores_h, det_category_h, det_boxes_r, det_scores_r, det_category_r], feed_dict={img_plac: raw_img} ) end = time.time() print("det category H : ", det_category_h_) print("det category R : ", det_category_r_) # print("{} cost time : {} ".format(img_name, (end - start))) if draw_imgs: det_detections_h = draw_box_in_img.draw_box_cv( np.squeeze(resized_img, 0), boxes=det_boxes_h_, labels=det_category_h_, scores=det_scores_h_) det_detections_r = draw_box_in_img.draw_rotate_box_cv( np.squeeze(resized_img, 0), boxes=det_boxes_r_, labels=det_category_r_, scores=det_scores_r_) save_dir = os.path.join(cfgs.TEST_SAVE_PATH, cfgs.VERSION) tools.mkdir(save_dir) cv2.imwrite(save_dir + '/' + a_img_name + '_h.jpg', det_detections_h[:, :, ::-1]) cv2.imwrite(save_dir + '/' + a_img_name + '_r.jpg', det_detections_r[:, :, ::-1]) xmin, ymin, xmax, ymax = det_boxes_h_[:, 0], det_boxes_h_[:, 1], \ det_boxes_h_[:, 2], det_boxes_h_[:, 3] if det_boxes_r_.shape[0] != 0: #print('### Has box ###') resized_h, resized_w = resized_img.shape[ 1], resized_img.shape[2] det_boxes_r_ = forward_convert(det_boxes_r_, False) det_boxes_r_[:, 0::2] *= (raw_w / resized_w) det_boxes_r_[:, 1::2] *= (raw_h / resized_h) det_boxes_r_ = back_forward_convert( det_boxes_r_, False) x_c, y_c, w, h, theta = det_boxes_r_[:, 0], det_boxes_r_[:, 1], det_boxes_r_[:, 2], \ det_boxes_r_[:, 3], det_boxes_r_[:, 4] xmin = xmin * raw_w / resized_w xmax = xmax * raw_w / resized_w ymin = ymin * raw_h / resized_h ymax = ymax * raw_h / resized_h boxes_h = np.transpose( np.stack([xmin, ymin, xmax, ymax])) boxes_r = np.transpose( np.stack([x_c, y_c, w, h, theta])) dets_h = np.hstack((det_category_h_.reshape(-1, 1), det_scores_h_.reshape(-1, 1), boxes_h)) dets_r = np.hstack((det_category_r_.reshape(-1, 1), det_scores_r_.reshape(-1, 1), boxes_r)) all_boxes_h.append(dets_h) all_boxes_r.append(dets_r) else: imgs.remove(image_name) none_detected_image.append(image_name) print('No detected') tools.view_bar( '{} image cost {}s'.format(a_img_name, (end - start)), i + 1, imgs_len) fw1 = open(cfgs.VERSION + '_detections_h.pkl', 'wb') fw2 = open(cfgs.VERSION + '_detections_r.pkl', 'wb') pickle.dump(all_boxes_h, fw1) pickle.dump(all_boxes_r, fw2) # with open(cfgs.VERSION + '_detections_h.pkl', 'rb') as f1: # all_boxes_h = pickle.load(f1, encoding='unicode') # print(10 * "###") # print(len(all_boxes_h)) # # with open(cfgs.VERSION + '_detections_r.pkl', 'rb') as f2: # all_boxes_r = pickle.load(f2, encoding='unicode') # # print(len(all_boxes_r)) # imgs = os.listdir(img_dir) real_test_imgname_list = [i.split(image_ext)[0] for i in imgs] print(10 * "**") print('horizon eval:') # print(len(all_boxes_h), len(all_boxes_r)) # print(len(real_test_imgname_list)) mAP_h, recall_h, precision_h, total_mAP_h, total_recall_h, total_precision_h = voc_eval.voc_evaluate_detections( all_boxes=all_boxes_h, test_imgid_list=real_test_imgname_list, test_annotation_path=test_annotation_path) print('mAP_h: ', mAP_h) print('mRecall_h:', recall_h) print('mPrecision_h:', precision_h) print('total_mAP_h: ', total_mAP_h) print('total_recall_h_list:', total_recall_h) print('total_precision_h_list:', total_precision_h) print(10 * "**") print('rotation eval:') mAP_r, recall_r, precision_r, total_mAP_r, total_recall_r, total_precision_r = voc_eval_r.voc_evaluate_detections( all_boxes=all_boxes_r, test_imgid_list=real_test_imgname_list, test_annotation_path=test_annotation_path) f1score_h_check = (1 + 1**2) * precision_h * recall_h / ( 1**2 * precision_h + recall_h) f1score_h = calc_fscore(precision_h, recall_h, 1) f1score_r_check = (1 + 1**2) * precision_r * recall_r / ( 1**2 * precision_r + recall_r) f1score_r = calc_fscore(precision_r, recall_r, 1) print(10 * '##') print('mAP_r:', mAP_r) print('mRecall_r:', recall_r) print('mPrecision_r:', precision_r) print('total_mAP_r_list: ', total_mAP_r) print('total_recall_r_list:', total_recall_r) print('total_precision_r_list:', total_precision_r) print('f1score_r:', f1score_r) summary_path = os.path.join(cfgs.SUMMARY_PATH, cfgs.VERSION + '/eval_0') tools.mkdir(summary_path) summary_writer = tf.summary.FileWriter(summary_path, graph=sess.graph) mAP_h_summ = tf.Summary() mAP_h_summ.value.add(tag='EVAL_Global/mAP_h', simple_value=mAP_h) summary_writer.add_summary(mAP_h_summ, global_stepnp) mAP_r_summ = tf.Summary() mAP_r_summ.value.add(tag='EVAL_Global/mAP_r', simple_value=mAP_r) summary_writer.add_summary(mAP_r_summ, global_stepnp) mRecall_h_summ = tf.Summary() mRecall_h_summ.value.add(tag='EVAL_Global/Recall_h', simple_value=recall_h) summary_writer.add_summary(mRecall_h_summ, global_stepnp) mRecall_r_summ = tf.Summary() mRecall_r_summ.value.add(tag='EVAL_Global/Recall_r', simple_value=recall_r) summary_writer.add_summary(mRecall_r_summ, global_stepnp) mPrecision_h_summ = tf.Summary() mPrecision_h_summ.value.add(tag='EVAL_Global/Precision_h', simple_value=precision_h) summary_writer.add_summary(mPrecision_h_summ, global_stepnp) mPrecision_r_summ = tf.Summary() mPrecision_r_summ.value.add(tag='EVAL_Global/Precision_r', simple_value=precision_r) summary_writer.add_summary(mPrecision_r_summ, global_stepnp) mF1Score_h_summ = tf.Summary() mF1Score_h_summ.value.add(tag='EVAL_Global/F1Score_h', simple_value=f1score_h) summary_writer.add_summary(mF1Score_h_summ, global_stepnp) mF1Score_r_summ = tf.Summary() mF1Score_r_summ.value.add(tag='EVAL_Global/F1Score_r', simple_value=f1score_r) summary_writer.add_summary(mF1Score_r_summ, global_stepnp) mAP_h_class_dict = {} mAP_r_class_dict = {} recall_h_class_dict = {} recall_r_class_dict = {} precision_h_class_dict = {} precision_r_class_dict = {} f1score_h_class_dict = {} f1score_r_class_dict = {} label_list = list(NAME_LABEL_MAP.keys()) label_list.remove('back_ground') for cls in label_list: mAP_h_class_dict["cls_%s_mAP_h_summ" % cls] = tf.Summary() mAP_r_class_dict["cls_%s_mAP_r_summ" % cls] = tf.Summary() recall_h_class_dict["cls_%s_recall_h_summ" % cls] = tf.Summary() recall_r_class_dict["cls_%s_recall_r_summ" % cls] = tf.Summary() precision_h_class_dict["cls_%s_precision_h_summ" % cls] = tf.Summary() precision_r_class_dict["cls_%s_precision_r_summ" % cls] = tf.Summary() f1score_h_class_dict["cls_%s_f1score_h_summ" % cls] = tf.Summary() f1score_r_class_dict["cls_%s_f1score_r_summ" % cls] = tf.Summary() for cls in label_list: mAP_h_class_dict["cls_%s_mAP_h_summ" % cls].value.add( tag='EVAL_Class_mAP/{}_mAP_h'.format(cls), simple_value=total_mAP_h[cls]) mAP_r_class_dict["cls_%s_mAP_r_summ" % cls].value.add( tag='EVAL_Class_mAP/{}_mAP_r'.format(cls), simple_value=total_mAP_r[cls]) recall_h_class_dict[ "cls_%s_recall_h_summ" % cls].value.add( tag='EVAL_Class_recall/{}_recall_h'.format(cls), simple_value=total_recall_h[cls]) recall_r_class_dict[ "cls_%s_recall_r_summ" % cls].value.add( tag='EVAL_Class_recall/{}_recall_r'.format(cls), simple_value=total_recall_r[cls]) precision_h_class_dict[ "cls_%s_precision_h_summ" % cls].value.add( tag='EVAL_Class_precision/{}_precision_h'.format( cls), simple_value=total_precision_h[cls]) precision_r_class_dict[ "cls_%s_precision_r_summ" % cls].value.add( tag='EVAL_Class_precision/{}_precision_r'.format( cls), simple_value=total_precision_r[cls]) f1score_h_cls = calc_fscore(total_precision_h[cls], total_recall_h[cls], 1) f1score_r_cls = calc_fscore(total_precision_r[cls], total_recall_r[cls], 1) f1score_h_class_dict[ "cls_%s_f1score_h_summ" % cls].value.add( tag='EVAL_Class_f1score/{}_f1score_h'.format(cls), simple_value=f1score_h_cls) f1score_r_class_dict[ "cls_%s_f1score_r_summ" % cls].value.add( tag='EVAL_Class_f1score/{}_f1score_r'.format(cls), simple_value=f1score_r_cls) for cls in label_list: summary_writer.add_summary( mAP_h_class_dict["cls_%s_mAP_h_summ" % cls], global_stepnp) summary_writer.add_summary( mAP_r_class_dict["cls_%s_mAP_r_summ" % cls], global_stepnp) summary_writer.add_summary( recall_h_class_dict["cls_%s_recall_h_summ" % cls], global_stepnp) summary_writer.add_summary( recall_r_class_dict["cls_%s_recall_r_summ" % cls], global_stepnp) summary_writer.add_summary( precision_h_class_dict["cls_%s_precision_h_summ" % cls], global_stepnp) summary_writer.add_summary( precision_r_class_dict["cls_%s_precision_r_summ" % cls], global_stepnp) summary_writer.add_summary( f1score_h_class_dict["cls_%s_f1score_h_summ" % cls], global_stepnp) summary_writer.add_summary( f1score_r_class_dict["cls_%s_f1score_r_summ" % cls], global_stepnp) summary_writer.flush() if not os.path.exists(save_dir): os.makedirs(save_dir) save_ckpt = os.path.join(save_dir, 'voc_' + str(global_stepnp) + 'model.ckpt') #saver.save(sess, save_ckpt) print(' weights had been saved') time_to_next_eval = start_time + EVAL_INTERVAL - time.time() if time_to_next_eval > 0: time.sleep(time_to_next_eval)