class Detection(object): def __init__(self, gpu_id=0, weight_path=None, video_path=None, output_dir=None, ): self.__num_class = cfg.VOC_DATA["NUM"] self.__conf_threshold = cfg.VAL["CONF_THRESH"] self.__nms_threshold = cfg.VAL["NMS_THRESH"] self.__device = gpu.select_device(gpu_id) self.__multi_scale_val = cfg.VAL["MULTI_SCALE_VAL"] self.__flip_val = cfg.VAL["FLIP_VAL"] self.__classes = cfg.VOC_DATA["CLASSES"] self.__video_path = video_path self.__output_dir = output_dir self.__model = Build_Model().to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, showatt=False) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def Video_detection(self): import cv2 vid = cv2.VideoCapture(self.__video_path) if not vid.isOpened(): raise IOError("Couldn't open webcam or video") video_FourCC = int(vid.get(cv2.CAP_PROP_FOURCC)) video_fps = vid.get(cv2.CAP_PROP_FPS) video_size = (int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)), int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))) isOutput = True if self.__output_dir != "" else False if isOutput: print("!!! TYPE:", type(self.__output_dir), type(video_FourCC), type(video_fps), type(video_size)) out = cv2.VideoWriter(self.__output_dir, video_FourCC, video_fps, video_size) accum_time = 0 curr_fps = 0 fps = "FPS: ??" prev_time = timer() while True: return_value, frame = vid.read() bboxes_prd = self.__evalter.get_bbox(frame) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=frame, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) curr_time = timer() exec_time = curr_time - prev_time prev_time = curr_time accum_time = accum_time + exec_time curr_fps = curr_fps + 1 if accum_time > 1: accum_time = accum_time - 1 fps = "FPS: " + str(curr_fps) curr_fps = 0 cv2.putText(frame, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.50, color=(255, 0, 0), thickness=2) cv2.namedWindow("result", cv2.WINDOW_NORMAL) cv2.imshow("result", frame) if isOutput: out.write(frame) if cv2.waitKey(1) & 0xFF == ord('q'): break
class Tester(object): def __init__(self, weight_path=None, gpu_id=0, img_size=544, visiual=None, eval=False): self.img_size = img_size self.__num_class = cfg.DATA["NUM"] self.__conf_threshold = cfg.TEST["CONF_THRESH"] self.__nms_threshold = cfg.TEST["NMS_THRESH"] self.__device = gpu.select_device(gpu_id) self.__multi_scale_test = cfg.TEST["MULTI_SCALE_TEST"] self.__flip_test = cfg.TEST["FLIP_TEST"] self.__visiual = './test_img/' self.__eval = eval self.__classes = cfg.DATA["CLASSES"] self.__model = Yolov3().to(self.__device) # self.__load_model_weights(weight_path) self.__load_model_weights('./weight/best.pt') self.__evalter = Evaluator(self.__model, visiual=False) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) # print(chkpt) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def test(self): if self.__visiual: imgs = os.listdir(self.__visiual) for v in imgs: path = os.path.join(self.__visiual, v) print("test images : {}".format(path)) img = cv2.imread(path) assert img is not None bboxes_prd = self.__evalter.get_bbox(img) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) path = os.path.join(cfg.PROJECT_PATH, "data/{}".format(v)) cv2.imwrite(path, img) print("saved images : {}".format(path)) if self.__eval: mAP = 0 print('*' * 20 + "Validate" + '*' * 20) with torch.no_grad(): APs = Evaluator(self.__model).APs_voc(self.__multi_scale_test, self.__flip_test) for i in APs: print("{} --> mAP : {}".format(i, APs[i])) mAP += APs[i] mAP = mAP / self.__num_class print('mAP:%g' % (mAP))
def video_detection(self): vid = cv2.VideoCapture(self.video_path) if not vid.isOpened(): raise IOError("Couldn't open webcam or video") video_FourCC = int(vid.get(cv2.CAP_PROP_FOURCC)) video_fps = vid.get(cv2.CAP_PROP_FPS) video_size = ( int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)), int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)), ) isOutput = True if self.output_dir != "" else False if isOutput: print( "!!! TYPE:", type(self.output_dir), type(video_FourCC), type(video_fps), type(video_size), ) out = cv2.VideoWriter(self.output_dir, video_FourCC, video_fps, video_size) accum_time = 0 curr_fps = 0 fps = "FPS: ??" prev_time = timer() while True: return_value, frame = vid.read() evaluator_imgs = Evaluator(self.__model, self.__classes, self.__num_classes, visual=False) bboxes_prd = evaluator_imgs.get_bbox(frame) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=frame, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) curr_time = timer() exec_time = curr_time - prev_time prev_time = curr_time accum_time = accum_time + exec_time curr_fps = curr_fps + 1 if accum_time > 1: accum_time = accum_time - 1 fps = "FPS: " + str(curr_fps) curr_fps = 0 cv2.putText(frame, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.50, color=(255, 0, 0), thickness=2) cv2.namedWindow("result", cv2.WINDOW_NORMAL) cv2.imshow("result", frame) if isOutput: out.write(frame) if cv2.waitKey(1) & 0xFF == ord("q"): break
class Evaluation(object): def __init__( self, gpu_id=0, weight_path=None, visiual=None, eval=False, ): # self.__num_class = cfg.VOC_DATA["NUM"] self.__num_class = cfg.Customer_DATA["NUM"] self.__conf_threshold = cfg.VAL["CONF_THRESH"] self.__nms_threshold = cfg.VAL["NMS_THRESH"] self.__device = gpu.select_device(gpu_id) self.__multi_scale_val = cfg.VAL["MULTI_SCALE_VAL"] self.__flip_val = cfg.VAL["FLIP_VAL"] self.__visiual = visiual self.__eval = eval # self.__classes = cfg.VOC_DATA["CLASSES"] self.__classes = cfg.Customer_DATA["CLASSES"] self.__model = Build_Model().to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, showatt=False) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def val(self): global logger if self.__eval: logger.info("***********Start Evaluation****************") start = time.time() mAP = 0 with torch.no_grad(): APs, inference_time = Evaluator(self.__model, showatt=False).APs_voc( self.__multi_scale_val, self.__flip_val) for i in APs: logger.info("{} --> mAP : {}".format(i, APs[i])) mAP += APs[i] mAP = mAP / self.__num_class logger.info("mAP:{}".format(mAP)) logger.info("inference time: {:.2f} ms".format(inference_time)) end = time.time() logger.info(" ===val cost time:{:.4f}s".format(end - start)) def detection(self): global logger if not self.__visiual: return # imgs = os.listdir(self.__visiual) # logger.info("***********Start Detection****************") # for v in imgs: # path = os.path.join(self.__visiual, v) for files in os.walk(self.__visiual): # print(files) for tp_f in files[2]: path = files[0] + '/' + tp_f _, file_type = os.path.splitext(path) if file_type != '.jpg': #json continue logger.info("val images : {}".format(path)) img = cv2.imread(path) assert img is not None v = path.split('/')[-1] bboxes_prd = self.__evalter.get_bbox(img) #, v if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes( image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes, ) path = os.path.join(cfg.PROJECT_PATH, "detection_result/{}".format(v)) cv2.imwrite(path, img) logger.info("saved images : {}".format(path))
class Evaluation(object): def __init__(self, gpu_id=0, weight_path=None, visiual=None, eval=False, mode=None): self.__num_class = cfg.VOC_DATA["NUM"] self.__conf_threshold = cfg.VAL["CONF_THRESH"] self.__nms_threshold = cfg.VAL["NMS_THRESH"] self.__device = gpu.select_device(gpu_id) self.__showatt = cfg.TRAIN["showatt"] self.__visiual = visiual self.__mode = mode self.__classes = cfg.VOC_DATA["CLASSES"] self.__model = Build_Model(showatt=self.__showatt).to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, showatt=self.__showatt) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) # self.__model.load_state_dict(chkpt["model"]) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def val(self): global logger logger.info("***********Start Evaluation****************") start = time.time() mAP = 0 with torch.no_grad(): APs, inference_time = Evaluator(self.__model, showatt=False).APs_voc() for i in APs: logger.info("{} --> mAP : {}".format(i, APs[i])) mAP += APs[i] mAP = mAP / self.__num_class logger.info("mAP:{}".format(mAP)) logger.info("inference time: {:.2f} ms".format(inference_time)) end = time.time() logger.info(" ===val cost time:{:.4f}s".format(end - start)) def detection(self): global logger if self.__visiual: imgs = os.listdir(self.__visiual) logger.info("***********Start Detection****************") for v in imgs: path = os.path.join(self.__visiual, v) logger.info("val images : {}".format(path)) img = cv2.imread(path) assert img is not None bboxes_prd = self.__evalter.get_bbox(img, v, mode=self.__mode) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes( image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes, ) path = os.path.join(cfg.PROJECT_PATH, "detection_result/{}".format(v)) cv2.imwrite(path, img) logger.info("saved images : {}".format(path))
class Evaluation(object): def __init__(self, gpu_id = 0, weight_path=None, img_size=544, visiual=None, heatmap=False ): self.img_size = img_size self.__num_class = cfg.COCO_DATA["NUM"] self.__conf_threshold = cfg.VAL["CONF_THRESH"] self.__nms_threshold = cfg.VAL["NMS_THRESH"] self.__device = gpu.select_device(gpu_id) self.__multi_scale_val = cfg.VAL["MULTI_SCALE_VAL"] self.__flip_val = cfg.VAL["FLIP_VAL"] self.__visiual = visiual self.__eval = eval self.__classes = cfg.COCO_DATA["CLASSES"] self.__model = Build_Model().to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, showatt=heatmap) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def reset(self): path1 = os.path.join(cfg.DETECTION_PATH, "detection_result/") path2 = os.path.join(cfg.DETECTION_PATH, "ShowAtt/") for i in os.listdir(path1): path_file = os.path.join(path1, i) if os.path.isfile(path_file): os.remove(path_file) else: for f in os.listdir(path_file): path_file2 = os.path.join(path_file, f) if os.path.isfile(path_file2): os.remove(path_file2) for i in os.listdir(path2): path_file = os.path.join(path2, i) if os.path.isfile(path_file): os.remove(path_file) else: for f in os.listdir(path_file): path_file2 = os.path.join(path_file, f) if os.path.isfile(path_file2): os.remove(path_file2) def study(self): # Parameter study y = [] for i in [0.08, 0.07, 0.06]: t = time.time() evaluator = COCOAPIEvaluator(model_type='YOLOv3', data_dir=cfg.DATA_PATH, img_size=cfg.VAL["TEST_IMG_SIZE"], confthre=i, nmsthre=cfg.VAL["NMS_THRESH"]) _, r = evaluator.evaluate(self.__model) y.append(str(i) +str(' ') + str(r) +str(' ')+ str(time.time() - t,)) np.savetxt('study.txt', y, fmt='%s') # y = np.loadtxt('study.txt') def val(self): global writer, logger logger.info("***********Start Evaluation****************") start = time.time() evaluator = COCOAPIEvaluator(model_type='YOLOv4', data_dir=cfg.DATA_PATH, img_size=cfg.VAL["TEST_IMG_SIZE"], confthre=cfg.VAL["CONF_THRESH"], nmsthre=cfg.VAL["NMS_THRESH"]) ap50_95, ap50 = evaluator.evaluate(self.__model) logger.info('ap50_95:{}|ap50:{}'.format(ap50_95, ap50)) end = time.time() logger.info(" ===val cost time:{:.4f}s".format(end - start)) def Inference(self): global writer, logger # clear cache self.reset() logger.info("***********Start Inference****************") imgs = os.listdir(self.__visiual) logger.info("images path: {}".format(self.__visiual)) path = os.path.join(cfg.DETECTION_PATH, "detection_result") logger.info("saved images at: {}".format(path)) inference_times = [] for v in imgs: start_time = time.time() path = os.path.join(self.__visiual, v) img = cv2.imread(path) assert img is not None bboxes_prd = self.__evalter.get_bbox(img, v) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) path = os.path.join(cfg.DETECTION_PATH, "detection_result/{}".format(v)) cv2.imwrite(path, img) end_time = time.time() inference_times.append(end_time - start_time) inference_time = sum(inference_times) / len(inference_times) fps = 1.0 / inference_time logging.info("Inference_Time: {:.5f} s/image, FPS: {}".format(inference_time,fps))
class Evaluation(object): def __init__(self, gpu_id='0', weight_path=None, img_size=544, visiual=None, eval=False, epoch=None): self.img_size = img_size self.__num_class = cfg.DATA["NUM"] self.__conf_threshold = cfg.VAL["CONF_THRESH"] self.__nms_threshold = cfg.VAL["NMS_THRESH"] # self.__device = select_device('0', batch_size=cfg.VAL["BATCH_SIZE"]) self.__device = gpu.select_device(gpu_id) self.__multi_scale_val = cfg.VAL["MULTI_SCALE_VAL"] self.__flip_val = cfg.VAL["FLIP_VAL"] self.__visiual = visiual self.__eval = eval self.__classes = cfg.DATA["CLASSES"] self.__model = Build_Model().to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, epoch, showatt=False) self.epoch = epoch def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def val(self): global writer, logger if self.__eval: logger.info("***********Start Evaluation****************") start = time.time() mAP = 0 with torch.no_grad(): _, _, APs = Evaluator(self.__model, self.epoch, showatt=False).APs_voc( self.__multi_scale_val, self.__flip_val) for i in APs: logger.info("{} --> mAP : {}".format(i, APs[i])) mAP += APs[i] mAP = mAP / self.__num_class logger.info('mAP:{}'.format(mAP)) writer.add_scalar('mAP', mAP, self.epoch) end = time.time() logger.info(" ===val cost time:{:.4f}s".format(end - start)) def detection(self): global writer, logger if self.__visiual: imgs = os.listdir(self.__visiual) logger.info("***********Start Detection****************") start = time.clock() for v in imgs: path = os.path.join(self.__visiual, v) logger.info("val images : {}".format(path)) img = cv2.imread(path) assert img is not None bboxes_prd = self.__evalter.get_bbox(img, v) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) path = os.path.join(cfg.PROJECT_PATH, "detection_result/{}".format(v)) cv2.imwrite(path, img) logger.info("saved images : {}".format(path)) end = time.clock() times = end - start FPS = len(imgs) / times logger.info('FPS:{}'.format(FPS)) logger.info(" ===detection cost time:{:.4f}s".format(times))
class Detection(object): def __init__( self, label_path, weight_path=None, output_dir=None, ): self.__label_path = os.path.join("/data", label_path) self.get_first_10_imgs() self.__num_class = cfg.DATASET.NUM # these should be set still self.__conf_threshold = 0.25 self.__nms_threshold = 0.5 ####################################### self.__device = gpu.select_device() self.__classes = cfg.DATASET.CLASSES self.__output_dir = output_dir self.__model = Build_Model().to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, showatt=False) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def detect_demo(self): import cv2 accum_time = 0 for image_path in tqdm(self.__file_dict.keys()): # print(self.__file_dict[image_path]) frame = cv2.imread(image_path) # prev_time = timer() bboxes_prd = self.__evalter.get_bbox(frame) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=frame, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) visualize_boxes_and_labels_on_image_array( image=frame, boxes=self.__file_dict[image_path][:, :4], classes=self.__file_dict[image_path][:, 4], scores=None, line_thickness=10, category_index=self.__classes) cv2.imwrite( os.path.join(self.__output_dir, os.path.basename(image_path)), frame) print("FPS: {:.04f}".format(1000 * len(self.__file_dict.keys()) / self.__evalter.inference_time)) def get_first_10_imgs(self): fh = open(self.__label_path) image_paths = {} #################################### # for random select #################################### # random.seed(1) # lines = random.choices(fh.readlines(),k=10) # for line in lines: # line = line.rstrip().split() # if len(line)>1: # image_paths[os.path.join("/data",line[0])] = np.array([list(map(int,i.split(","))) for i in line[1:]]) # else: # break #################################### # for on demand plot #################################### lines = fh.readlines() imgs = [ "images/0021023.png", "images/0020485.png", "images/0021042.png", "images/0021630.png", "images/0021729.png", "images/0021781.png" ] for line in lines: line = line.rstrip().split() if line[0] in imgs: image_paths[os.path.join("/data", line[0])] = np.array( [list(map(int, i.split(","))) for i in line[1:]]) ##################################### self.__file_dict = image_paths
class Detection(object): def __init__(self, label_path, weight_path=None, output_dir=None, ): self.__label_path = os.path.join("/data",label_path) self.get_first_10_imgs() self.__num_class = cfg.DATASET.NUM self.__conf_threshold = cfg.VAL.CONF_THRESH self.__nms_threshold = cfg.VAL.NMS_THRESH self.__device = gpu.select_device() self.__classes = cfg.DATASET.CLASSES # self.__video_path = video_path self.__output_dir = output_dir self.__model = Build_Model().to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, showatt=False) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt) print("loading weight file is done") del chkpt def detect_demo(self): import cv2 accum_time = 0 for image_path in self.__file_list: frame = cv2.imread(image_path) # prev_time = timer() bboxes_prd = self.__evalter.get_bbox(frame) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=frame, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) # curr_time = timer() # accum_time += curr_time - prev_time cv2.imwrite(os.path.join(self.__output_dir,os.path.basename(image_path)),frame) print("FPS: {:.04f}".format(len(self.__file_list)/self.__evalter.inference_time)) def get_first_10_imgs(self): fh = open(self.__label_path) image_paths = [] for line in fh.readlines(): line = line.rstrip().split() if len(image_paths) < 100: if len(line) > 1: image_paths.append(os.path.join("/data",line[0])) else: break print(image_paths) self.__file_list = image_paths
class Tester(object): def __init__(self, weight_path=None, gpu_id=0, visiual=None, eval=False): self.img_size = cfg.TEST["TEST_IMG_SIZE"] self.__num_class = cfg.DATA["NUM"] self.__conf_threshold = cfg.TEST["CONF_THRESH"] self.__nms_threshold = cfg.TEST["NMS_THRESH"] self.__device = gpu.select_device(gpu_id, force_cpu=False) self.__multi_scale_test = cfg.TEST["MULTI_SCALE_TEST"] self.__flip_test = cfg.TEST["FLIP_TEST"] self.__classes = cfg.DATA["CLASSES"] self.__visiual = visiual self.__eval = eval self.__model = NPMMRDet().to(self.__device) # Single GPU net_model = NPMMRDet() if torch.cuda.device_count() >1: ## Multi GPUs print("Let's use", torch.cuda.device_count(), "GPUs!") net_model = torch.nn.DataParallel(net_model) ## Multi GPUs self.__model = net_model.to(self.__device) elif torch.cuda.device_count() ==1: self.__model = net_model.to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, visiual=False) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt) #['model'] #print("loading weight file is done") del chkpt def test(self): global logger logger.info("***********Start Evaluation****************") if self.__visiual: imgs = os.listdir(self.__visiual) for v in imgs: path = os.path.join(self.__visiual, v) #print("test images : {}".format(path)) img = cv2.imread(path) assert img is not None bboxes_prd = self.__evalter.get_bbox(img) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) path = os.path.join(cfg.PROJECT_PATH, "prediction/imgs_all/{}".format(v)) cv2.imwrite(path, img) #print("saved images : {}".format(path)) mAP = 0 if self.__eval and cfg.TEST["EVAL_TYPE"] == 'VOC': with torch.no_grad(): start = time.time() APs, inference_time = Evaluator(self.__model).APs_voc(self.__multi_scale_test, self.__flip_test) for i in APs: print("{} --> AP : {}".format(i, APs[i])) mAP += APs[i] mAP = mAP / self.__num_class logger.info('mAP:{}'.format(mAP)) logger.info("inference time: {:.2f} ms".format(inference_time)) writer.add_scalar('test/VOCmAP', mAP) end = time.time() logger.info("Test cost time:{:.4f}s".format(end - start)) #print('mAP:%g' % (mAP)) #print("inference time : {:.2f} ms".format(inference_time)) elif self.__eval and cfg.TEST["EVAL_TYPE"] == 'COCO': with torch.no_grad(): start = time.time() evaluator = COCOEvaluator(data_dir=cfg.DATA_PATH, img_size=cfg.TEST["TEST_IMG_SIZE"], confthre=cfg.TEST["CONF_THRESH"], nmsthre=cfg.TEST["NMS_THRESH"]) ap50_95, ap50, inference_time = evaluator.evaluate(self.__model) logger.info('ap50_95:{} | ap50:{}'.format(ap50_95, ap50)) logger.info("inference time: {:.2f} ms".format(inference_time)) writer.add_scalar('test/COCOAP50', ap50) writer.add_scalar('test/COCOAP50_95', ap50_95) end = time.time() logger.info("Test cost time:{:.4f}s".format(end - start)) elif self.__eval and cfg.TEST["EVAL_TYPE"] == 'BOTH': with torch.no_grad(): start = time.time() APs, inference_time = Evaluator(self.__model).APs_voc(self.__multi_scale_test, self.__flip_test) for i in APs: print("{} --> mAP : {}".format(i, APs[i])) mAP += APs[i] mAP = mAP / self.__num_class logger.info('mAP:{}'.format(mAP)) logger.info("inference time: {:.2f} ms".format(inference_time)) writer.add_scalar('test/VOCmAP', mAP) end = time.time() logger.info("Test cost time:{:.4f}s".format(end - start)) start = time.time() evaluator = COCOEvaluator(data_dir=cfg.DATA_PATH, img_size=cfg.TEST["TEST_IMG_SIZE"], confthre=cfg.TEST["CONF_THRESH"], nmsthre=cfg.TEST["NMS_THRESH"]) ap50_95, ap50, inference_time = evaluator.evaluate(self.__model) logger.info('ap50_95:{} | ap50:{}'.format(ap50_95, ap50)) logger.info("inference time: {:.2f} ms".format(inference_time)) writer.add_scalar('test/COCOAP50', ap50) writer.add_scalar('test/COCOAP50_95', ap50_95) end = time.time() logger.info("Test cost time:{:.4f}s".format(end - start))
class Tester(object): def __init__(self, cfg_path=None, weight_path=None, gpu_id=0, img_size=544, visiual=None, eval=False ): self.img_size = img_size self.__num_class = pms.DATA["NUM"] self.__conf_threshold = pms.TEST["CONF_THRESH"] self.__nms_threshold = pms.TEST["NMS_THRESH"] self.__device = gpu.select_device(gpu_id) self.__visiual = visiual self.__eval = eval self.__classes = pms.DATA["CLASSES"] self.__model = Darknet(cfg_path=cfg_path, img_size=img_size).to(self.__device) self.__load_model_weights(weight_path) self.__evalter = Evaluator(self.__model, visiual=False) def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model.load_state_dict(chkpt['model']) print("loading weight file is done") del chkpt def test(self): if self.__visiual: imgs = os.listdir(self.__visiual) for v in imgs: path = os.path.join(self.__visiual, v) print("test images : {}".format(path)) img = cv2.imread(path) assert img is not None bboxes_prd = self.__evalter.get_bbox(img) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) path = os.path.join(pms.PROJECT_PATH, "data/{}".format(v)) cv2.imwrite(path, img) print("saved images : {}".format(path)) if self.__eval: mAP = 0 print('*' * 20 + "Validate" + '*' * 20) with torch.no_grad(): result = self.__evalter.APs_voc() for i in result: print(i, result[i]) mAP += result[i] mAP = mAP / self.__num_class print('mAP:%g' % (mAP))
def test(self): if self.mode not in ["+voc", "+coco", None]: print("===== " * 4 + "visualizing " + self.mode + " =====" * 4) # 创建新的visual目录 visual_result_path = os.path.join(cfg.PROJECT_PATH, "data", "visual") if os.path.exists(visual_result_path): shutil.rmtree(visual_result_path) os.mkdir(visual_result_path) imgs = os.listdir(self.mode) for v in tqdm(imgs): path = os.path.join(self.mode, v) # print("test images: {}".format(path)) img = cv2.imread(path) assert img is not None evaluator_imgs = Evaluator(self.__model, self.__classes, self.__num_classes, visual=False) bboxes_prd = evaluator_imgs.get_bbox(img) if bboxes_prd.shape[0] != 0: boxes = bboxes_prd[..., :4] class_inds = bboxes_prd[..., 5].astype(np.int32) scores = bboxes_prd[..., 4] visualize_boxes(image=img, boxes=boxes, labels=class_inds, probs=scores, class_labels=self.__classes) path = os.path.join(visual_result_path, v) cv2.imwrite(path, img) # print("saved images: {}".format(path)) elif self.mode == "+voc": print("===== " * 4 + "evaluating " + self.mode + " =====" * 4) evaluator_voc = Evaluator(self.__model, self.__classes, self.__num_classes, visual=True) APs = evaluator_voc.APs_voc( multi_scale_test=self.__multi_scale_test, flip_test=self.__flip_test) APsum = 0 for i in APs: print("{:16}: {}".format(i, APs[i])) APsum += APs[i] mAP = APsum / self.__num_classes print("mAP: {}".format(mAP)) else: print("===== " * 4 + "evaluating " + self.mode + " =====" * 4) evaluator_coco = Evaluator(self.__model, self.__classes, self.__num_classes, visual=True) APs = evaluator_coco.APs_coco()
class Evaluation(object): def __init__( self, gpu_id=0, model1_path=None, model2_path=None, data_dir=None, # result_dir=None, mnist=False, ): self.__num_class = cfg.Customer_DATA["NUM"] self.__conf_threshold = cfg.VAL["CONF_THRESH"] self.__nms_threshold = cfg.VAL["NMS_THRESH"] self.__device = gpu.select_device(gpu_id) self.__multi_scale_val = cfg.VAL["MULTI_SCALE_VAL"] self.__flip_val = cfg.VAL["FLIP_VAL"] self.__data_dir = data_dir print(self.__data_dir) self.__classes = cfg.Customer_DATA["CLASSES"] self.__mnist = mnist self.__model1 = Build_Model().to(self.__device) if mnist: self.__model2 = torch.load(model2_path).double().cuda() else: self.__model2 = torch.load(model2_path).cuda() self.__load_model_weights(model1_path) self.__evalter = Evaluator(self.__model1, showatt=False) # self.__result_dir = result_dir def __load_model_weights(self, weight_path): print("loading weight file from : {}".format(weight_path)) weight = os.path.join(weight_path) chkpt = torch.load(weight, map_location=self.__device) self.__model1.load_state_dict(chkpt) # print("loading weight file is done") del chkpt def detection(self): if os.path.isdir(self.__data_dir): imgs = os.listdir(self.__data_dir) print("***********Start Detection****************") for v in imgs: path = self.__data_dir + "/" + v print("val images : {}".format(path)) img = cv2.imread(path) assert img is not None bboxes_prd = self.__evalter.get_bbox(img, v) points, max_l = get_points(img, bboxes_prd=bboxes_prd, model=self.__model2, mnist=self.__mnist) if points is None: return # print(points) matrix_calculator = calculator(self.__classes) matrix_calculator.get_from_points(points, max_l) print(matrix_calculator()) else: raise NotImplementedError("The data directory is not exist!")