def eval_coco(self, val_dataset): index2category = json.load(open("coco_index2category.json")) logging.info('Start Evaling') coco_result = [] coco_img_ids = set([]) for step, samples in enumerate(val_dataset): images, labels = samples['image'], samples['label'] image_size = images.size(2) image_paths, origin_sizes = samples['image_path'], samples['origin_size'] with torch.no_grad(): outputs = self.net(images) #output = self.yolo_loss(outputs) output_list = [] for i in range(3): output_list.append(self.yolo_loss[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, self.config.num_classes, conf_thres=0.001, nms_thres=0.45) for idx, detections in enumerate(batch_detections): image_id = int(os.path.basename(image_paths[idx])[-16:-4]) coco_img_ids.add(image_id) if detections is not None: origin_size = eval(origin_sizes[idx]) detections = detections.cpu().numpy() dim_diff = np.abs(origin_size[0] - origin_size[1]) pad1, pad2 = dim_diff // 2, dim_diff - dim_diff // 2 pad = ((pad1, pad2), (0, 0), (0, 0)) if origin_size[1] <= origin_size[0] else ((0, 0), (pad1, pad2), (0, 0)) scale = origin_size[0] if origin_size[1] <= origin_size[0] else origin_size[1] for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: x1 = x1 / self.config.image_size * scale x2 = x2 / self.config.image_size * scale y1 = y1 / self.config.image_size * scale y2 = y2 / self.config.image_size * scale x1 -= pad[1][0] y1 -= pad[0][0] x2 -= pad[1][0] y2 -= pad[0][0] w = x2 - x1 h = y2 - y1 coco_result.append({ "image_id":image_id, "category_id":index2category[str(int(cls_pred.item()))], "bbox":(float(x1), float(y1), float(w), float(h)), "score":float(conf), }) logging.info("Now have finished [%.3d/%.3d]"%(step, len(val_dataset))) save_path = "coco_results.json" with open(save_path, "w") as f: json.dump(coco_result, f, sort_keys=True, indent=4, separators=(',', ':')) logging.info('Save result in {}'.format(save_path)) logging.info('Using COCO APi to evaluate') cocoGt = COCO(self.config.annotation) cocoDt = cocoGt.loadRes(save_path) cocoEval = COCOeval(cocoGt, cocoDt, "bbox") cocoEval.params.imgIds = list(coco_img_ids) cocoEval.evaluate() cocoEval.accumulate() cocoEval.summarize()
def validate(net): n_gt = 0 correct = 0 for step, samples in enumerate(dataloader): images, labels, image_paths = samples["image"], samples[ "label"], samples["img_path"] labels = labels.cuda() with torch.no_grad(): time1 = datetime.datetime.now() outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) output = non_max_suppression(output, 1, conf_thres=0.5) if ((datetime.datetime.now() - time1).seconds > 5): logging.info('Batch %d time is too long ' % (step)) n_gt = 1 break # print("time2", (datetime.datetime.now() - time1).seconds*1000+(datetime.datetime.now() - time1).microseconds//1000) # calculate for sample_i in range(labels.size(0)): # Get labels for sample where width is not zero (dummies) target_sample = labels[sample_i, labels[sample_i, :, 3] != 0] for obj_cls, tx, ty, tw, th in target_sample: # Get rescaled gt coordinates tx1, tx2 = config["img_w"] * ( tx - tw / 2), config["img_w"] * (tx + tw / 2) ty1, ty2 = config["img_h"] * ( ty - th / 2), config["img_h"] * (ty + th / 2) n_gt += 1 box_gt = torch.cat([ coord.unsqueeze(0) for coord in [tx1, ty1, tx2, ty2] ]).view(1, -1) sample_pred = output[sample_i] if sample_pred is not None: # Iterate through predictions where the class predicted is same as gt for x1, y1, x2, y2, conf, obj_conf, obj_pred in sample_pred[ sample_pred[:, 6] == obj_cls]: box_pred = torch.cat([ coord.unsqueeze(0) for coord in [x1, y1, x2, y2] ]).view(1, -1) iou = bbox_iou(box_pred, box_gt) if iou >= config["iou_thres"]: correct += 1 break if n_gt: logging.info('Batch [%d/%d] mAP: %.5f' % (step, len(dataloader), float(correct / n_gt))) logging.info('Mean Average Precision: %.5f' % float(correct / n_gt))
def inference(self, image, classes, colors): image_origin = image image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image = cv2.resize(image, (self.config.image_size, self.config.image_size), interpolation=cv2.INTER_LINEAR) image = np.expand_dims(image, 0) image = image.astype(np.float32) image /= 255 image = np.transpose(image, (0, 3, 1, 2)) image = image.astype(np.float32) image = torch.from_numpy(image) start_time = time.time() if torch.cuda.is_available(): image = image.cuda() with torch.no_grad(): outputs = self.net(image) output_list = [] for i in range(3): output_list.append(self.yolo_loss[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, self.config.num_classes, conf_thres=0.5, nms_thres=0.4) spand_time = float(time.time() - start_time) detection = batch_detections[0] if detection is not None: origin_size = image_origin.shape[:2] detection = detection.cpu().numpy() for x1, y1, x2, y2, conf, cls_conf, cls_pred in detection: x1 = int(x1 / self.config.image_size * origin_size[1]) x2 = int(x2 / self.config.image_size * origin_size[1]) y1 = int(y1 / self.config.image_size * origin_size[0]) y2 = int(y2 / self.config.image_size * origin_size[0]) color = colors[int(cls_pred)] image_origin = cv2.rectangle(image_origin, (x1, y1), (x2, y2), color, 3) image_origin = cv2.rectangle(image_origin, (x1, y1), (x2, y1 + 20), color, thickness=-1) caption = "{}:{:.2f}".format(classes[int(cls_pred)], cls_conf) image_origin = cv2.putText(image_origin, caption, (x1, y1 + 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2) return image_origin, spand_time
def detect(config): is_training = False # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: logging.warning("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLoss(config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # Load tested img imgfile = config["img_path"] img = Image.open(imgfile).convert('RGB') resized = img.resize((config["img_w"], config["img_h"])) input = image2torch(resized) input = input.to(torch.device("cuda")) start = time.time() outputs = net(input) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) output = non_max_suppression(output, config["yolo"]["classes"], conf_thres=0.5, nms_thres=0.4) finish = time.time() print('%s: Predicted in %f seconds.' % (imgfile, (finish - start))) namefile = config["classname_path"] class_names = load_class_names(namefile) plot_boxes(img, output, 'predictions.jpg', class_names)
def ref(config): """ :param config: :return: """ # File name img_fn = '/home/yz/cde/ProposalYOLO/feature/ref/img-ref-attn.txt' ftr_fn = '/home/yz/cde/ProposalYOLO/feature/ref/ftr-ref-attn.txt' img_strm = open(img_fn, 'a') ftr_strm = open(ftr_fn, 'a') # Load and initialize network is_training = False # net = ProposalModel(config, is_training=is_training) net = ProposalAttention(config, is_training=is_training) net.train(is_training) ROIdelegator = RoIPooling(pooled_height=1, pooled_width=1, spatial_scale=1.0 / 32) # Forward hook layer = net.targeted_layer() features = list() def hook_feature(module, input, output): features.append(output[0]) features.append(output[1]) features.append(output[2]) layer.register_forward_hook(hook_feature) ftr_strm.write('%d\n' % (net.backbone.layers_out_filters[-1])) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format( config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( ProposalLoss(config["yolo"]["anchors"][i], (config["img_w"], config["img_h"]))) # Prepare images path images_path = [ y for x in os.walk(config["ref_path"]) for y in glob.glob(os.path.join(x[0], "*.jpg")) ] images_path.sort() print 'Num. of images: ', len(images_path) if len(images_path) == 0: raise Exception("no image found in {}".format(config["ref_path"])) # Start inference if config["pca"]: pca = pickle.load(open(config["mapping_fn"], 'rb')) batch_size = config["batch_size"] for step in range(0, len(images_path), batch_size): # preprocess images = [] images_origin = [] features = [] name = "" for path in images_path[step * batch_size:(step + 1) * batch_size]: logging.info("processing: {}".format(path)) image = cv2.imread(path, cv2.IMREAD_COLOR) name = path.split('/')[-1][:-4] if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output) # ROI Pooling if batch_detections[0] is None: continue rois = batch_detections[0].data.cpu().numpy()[:, :-1] image_index = np.zeros((rois.shape[0], 1)) rois = np.rint(np.concatenate((image_index, rois), axis=1)) rois = torch.Tensor(rois).cuda() feature_map = features[2] output = ROIdelegator(feature_map, rois) output = output.view(output.size(0), output.size(1) * output.size(2) * output.size(3)) output = output.data.cpu().numpy() # Output cnt = output.shape[0] assert cnt == rois.shape[0] dim = output.shape[1] if config["pca"]: output = pca.transform(output) output = normalize(output, norm='l2', axis=1) ori_h, ori_w = images_origin[0].shape[:2] pre_h, pre_w = config["img_h"], config["img_w"] for i in xrange(cnt): x1 = torch.clamp(rois[i][1].data, min=0, max=pre_w) / pre_w * ori_w y1 = torch.clamp(rois[i][2].data, min=0, max=pre_h) / pre_h * ori_h x2 = torch.clamp(rois[i][3].data, min=0, max=pre_w) / pre_w * ori_w y2 = torch.clamp(rois[i][4].data, min=0, max=pre_h) / pre_h * ori_h img_strm.write('%s-%04d %d %d %d %d\n' % (name, i + 1, x1, y1, x2, y2)) for j in xrange(dim): if j < dim - 1: ftr_strm.write('%f ' % output[i][j]) else: ftr_strm.write('%f\n' % output[i][j]) """
def pca(config): """ :param config: :return: """ # Load and initialize network is_training = False # net = ProposalModel(config, is_training=is_training) net = ProposalAttention(config, is_training=is_training) net.train(is_training) ROIdelegator = RoIPooling(pooled_height=1, pooled_width=1, spatial_scale=1.0 / 32) # Forward hook layer = net.targeted_layer() features = list() def hook_feature(module, input, output): features.append(output[0]) features.append(output[1]) features.append(output[2]) layer.register_forward_hook(hook_feature) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format( config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( ProposalLoss(config["yolo"]["anchors"][i], (config["img_w"], config["img_h"]))) # Prepare images path images_path = [ y for x in os.walk(config["pca_path"]) for y in glob.glob(os.path.join(x[0], "*.jpg")) ] images_path.sort() print 'Num. of images: ', len(images_path) if len(images_path) == 0: raise Exception("no image found in {}".format(config["ref_path"])) # Start inference batch_size = config["batch_size"] feats = list() for step in range(0, len(images_path), batch_size): # preprocess images = [] images_origin = [] features = [] name = "" for path in images_path[step * batch_size:(step + 1) * batch_size]: logging.info("processing: {}".format(path)) image = cv2.imread(path, cv2.IMREAD_COLOR) name = path.split('/')[-1][:-4] if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output) # ROI Pooling if batch_detections[0] is None: continue rois = batch_detections[0].data.cpu().numpy()[:, :-1] image_index = np.zeros((rois.shape[0], 1)) rois = np.rint(np.concatenate((image_index, rois), axis=1)) rois = torch.Tensor(rois).cuda() feature_map = features[2] output = ROIdelegator(feature_map, rois) output = output.view(output.size(0), output.size(1) * output.size(2) * output.size(3)) output = output.data.cpu().numpy() # output = normalize(output, norm='l2', axis=1) # print output.shape # Output feats.append(output) feats = np.concatenate(tuple(feats), axis=0) print 'Learning pca with dim:', feats.shape # PCA feats = normalize(feats, norm='l2', axis=1) pca = PCA(feats.shape[1], whiten=True) pca.fit(feats) pickle.dump(pca, open(config["mapping_fn"], 'wb'))
def test(config): is_training = False anchors = [int(x) for x in config["yolo"]["anchors"].split(",")] anchors = [[[anchors[i], anchors[i + 1]], [anchors[i + 2], anchors[i + 3]], [anchors[i + 4], anchors[i + 5]]] for i in range(0, len(anchors), 6)] anchors.reverse() config["yolo"]["anchors"] = [] for i in range(3): config["yolo"]["anchors"].append(anchors[i]) # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format(config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append(YOLOLayer(config["batch_size"],i,config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # prepare images path images_name = os.listdir(config["images_path"]) images_path = [os.path.join(config["images_path"], name) for name in images_name] if len(images_path) == 0: raise Exception("no image found in {}".format(config["images_path"])) cap = cv2.VideoCapture(0) # cap = cv2.VideoCapture("./007.avi") img_i = 0 start = time.time() while cap.isOpened(): ret, frame = cap.read() if not ret: break img_i += 1 # preprocess images = [] images_origin = [] image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference with torch.no_grad(): time1=datetime.datetime.now() outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) print("time1",(datetime.datetime.now()-time1).microseconds) batch_detections = non_max_suppression(output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"]) print("time2", (datetime.datetime.now() - time1).microseconds) # write result images. Draw bounding boxes and labels of detections classes = open(config["classes_names_path"], "r").read().split("\n")[:-1] if not os.path.isdir("./output/"): os.makedirs("./output/") for idx, detections in enumerate(batch_detections): img_show = images_origin[idx] img_show = cv2.cvtColor(img_show, cv2.COLOR_RGB2BGR) if detections is not None: unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) boxes=[] for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: # Rescale coordinates to original dimensions ori_h, ori_w = images_origin[idx].shape[:2] pre_h, pre_w = config["img_h"], config["img_w"] box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w # Create a Rectangle patch box = BoundBox(x1, y1, x1 + box_w, y1 + box_h, cls_conf.item(), int(cls_pred)) boxes.append(box) img_show = draw_boxes(img_show, boxes, labels) # image_show = cv2.rectangle(images_origin[idx], (x1, y1), (x1 + box_w, y1 + box_h), (0, 255, 0), 1) cv2.imshow('1', img_show) cv2.waitKey(1) logging.info("Save all results to ./output/")
def detect_image(name, response, config, net, yolo_losses, classes, complex_yolo_416, pid): start_time = time.time() images_path = [os.path.join(config["images_path"], name)] if len(images_path) == 0: raise Exception("no image with name {} found in {}".format(name, config["images_path"])) # Start inference batch_size = config["batch_size"] for step in range(0, len(images_path), batch_size): images = [] images_origin = [] for path in images_path[step * batch_size: (step + 1) * batch_size]: logging.info("processing: {}".format(path)) image = cv2.imread(path, cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images) lock.acquire() # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"], nms_thres=0.45) lock.release() # write result images. Draw bounding boxes and labels of detections if not os.path.isdir("./output/"): os.makedirs("./output/") for idx, detections in enumerate(batch_detections): plt.figure() fig, ax = plt.subplots(1) ax.imshow(images_origin[idx]) if detections is not None: unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) bbox_colors = random.sample(colors, n_cls_preds) for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: color = bbox_colors[int(np.where(unique_labels == int(cls_pred))[0])] # Rescale coordinates to original dimensions ori_h, ori_w = images_origin[idx].shape[:2] pre_h, pre_w = config["img_h"], config["img_w"] box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w # Create a Rectangle patch bbox = patches.Rectangle((x1, y1), box_w, box_h, linewidth=2, edgecolor=color, facecolor='none') # Add the bbox to the plot ax.add_patch(bbox) # Add label plt.text(x1, y1, s=classes[int(cls_pred)], color='white', verticalalignment='top', bbox={'color': color, 'pad': 0}) # Save generated image with detections plt.axis('off') plt.gca().xaxis.set_major_locator(NullLocator()) plt.gca().yaxis.set_major_locator(NullLocator()) plt.savefig('output/{}'.format(name), bbox_inches='tight', pad_inches=0.0) plt.close() computation_time = time.time() - start_time cpu = psutil.cpu_percent() / 100 complex_yolo_416.append(computation_time * cpu * 2.8) print("\tyolo3 + {} finished in {}s, system response in {} s, cpu in {} cycles (10^9)" .format(round(cpu, 3), round(computation_time, 4) , round(np.average(response), 4) , round(np.average(complex_yolo_416), 3))) # logging.info("Save all results to ./output/") return computation_time, cpu * 100, complex_yolo_416
def eval_voc(self, val_dataset): logging.info('Start Evaling') def voc_ap(rec, prec, use_07_metric=False): """ ap = voc_ap(rec, prec, [use_07_metric]) Compute VOC AP given precision and recall. If use_07_metric is true, uses the VOC 07 11 point method (default:False). """ _rec = np.arange(0., 1.1, 0.1) _prec = [] if use_07_metric: # 11 point metric ap = 0. for t in np.arange(0., 1.1, 0.1): if np.sum(rec >= t) == 0: p = 0 else: p = np.max(prec[rec >= t]) _prec.append(p) ap = ap + p / 11. else: # correct AP calculation # first append sentinel values at the end mrec = np.concatenate(([0.], rec, [1.])) mpre = np.concatenate(([0.], prec, [0.])) # compute the precision envelope for i in range(mpre.size - 1, 0, -1): mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) # to calculate area under PR curve, look for points # where X axis (recall) changes value i = np.where(mrec[1:] != mrec[:-1])[0] # and sum (\Delta recall) * prec ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) return ap def parse_rec(imagename): filename = imagename.replace('jpg', 'xml') tree = ET.parse(filename) objects = [] for obj in tree.findall('object'): obj_struct = {} obj_struct['pose'] = obj.fine('pose').text() obj_struct['truncated'] = int(obj.find('truncated').text) obj_struct['difficult'] = int(obj.find('difficult').text) bbox = obj.find('bndbox') obj_struct['bbox'] = [ int(bbox.find('xmin').text), int(bbox.find('ymin').text), int(bbox.find('xmax').text), int(bbox.find('ymax').text) ] objects.append(obj_struct) return objects for step, samples in enumerate(val_dataset): images, labels = samples['image'], samples['label'] image_paths, origin_sizes = samples['image_path'], samples[ 'origin_size'] with torch.no_grad(): outputs = self.net(images) output_list = [] for i in range(3): output_list.append(self.yolo_loss[i](outputs[i], labels)) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, self.config.num_classes, conf_thres=0.01, nms_thres=0.4) for idx, detections in enumerate(batch_detections): image_id = int(os.path.basename(image_paths[idx])[:6]) if detections is not None: origin_size = eval(origin_sizes[idx]) detections = detections.cpu().numpy() for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: x1 = x1 / self.config.image_size * origin_size[0] x2 = x2 / self.config.image_size * origin_size[0] y1 = y1 / self.config.image_size * origin_size[1] y2 = y2 / self.config.image_size * origin_size[1]
def test(config): """ :param config: :return: """ is_training = False # Load and initialize network # net = ProposalModel(config, is_training=is_training) net = ProposalAttention(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format( config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( ProposalLoss(config["yolo"]["anchors"][i], (config["img_w"], config["img_h"]))) # prepare images path images_name = os.listdir(config["images_path"]) # shuffle(images_name) # images_name = images_name[:40] images_name.sort() images_path = [ os.path.join(config["images_path"], name) for name in images_name ] if len(images_path) == 0: raise Exception("no image found in {}".format(config["images_path"])) # Start inference batch_size = config["batch_size"] for step in range(0, len(images_path), batch_size): # preprocess images = [] images_origin = [] for path in images_path[step * batch_size:(step + 1) * batch_size]: logging.info("processing: {}".format(path)) name = path.split('/')[-1][:-4] image = cv2.imread(path, cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) # print output.size() batch_detections = non_max_suppression(output) # write result images. Draw bounding boxes and labels of detections if not os.path.isdir("./output/"): os.makedirs("./output/") for idx, detections in enumerate(batch_detections): plt.figure() fig, ax = plt.subplots(1) ax.imshow(images_origin[idx]) if detections is not None: for x1, y1, x2, y2, conf in detections: bbox_colors = random.sample(colors, len(batch_detections)) color = bbox_colors[idx] # Rescale coordinates to original dimensions ori_h, ori_w = images_origin[idx].shape[:2] pre_h, pre_w = config["img_h"], config["img_w"] if x1 < 0: x1 = 1 if x2 > pre_w: x2 = pre_w - 1 if y1 < 0: y1 = 1 if y2 > pre_h: y2 = pre_h - 1 box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w # Create a Rectangle patch bbox = patches.Rectangle((x1, y1), box_w, box_h, linewidth=2, edgecolor=color, facecolor='none') # Add the bbox to the plot ax.add_patch(bbox) ax.text(x1, y1, '{:.2f}'.format(conf), bbox=dict(facecolor=color, alpha=0.9), fontsize=8, color='white') else: print 'Nothing detected.' # Save generated image with detections plt.axis('off') plt.gca().xaxis.set_major_locator(NullLocator()) plt.gca().yaxis.set_major_locator(NullLocator()) plt.savefig('output/{}-attn.png'.format(name), bbox_inches='tight', pad_inches=0.0) plt.close() logging.info("Save all results to ./output/")
def evaluate(config): is_training = False # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: logging.warning("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLoss(config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # DataLoader dataloader = torch.utils.data.DataLoader(COCODataset( config["val_path"], (config["img_w"], config["img_h"]), is_training=False), batch_size=config["batch_size"], shuffle=False, num_workers=16, pin_memory=False) # Start the eval loop logging.info("Start eval.") n_gt = 0 correct = 0 for step, samples in enumerate(dataloader): images, labels = samples["image"], samples["label"] labels = labels.cuda() with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) output = non_max_suppression(output, 80, conf_thres=0.2) # calculate for sample_i in range(labels.size(0)): # Get labels for sample where width is not zero (dummies) target_sample = labels[sample_i, labels[sample_i, :, 3] != 0] for obj_cls, tx, ty, tw, th in target_sample: # Get rescaled gt coordinates tx1, tx2 = config["img_w"] * ( tx - tw / 2), config["img_w"] * (tx + tw / 2) ty1, ty2 = config["img_h"] * ( ty - th / 2), config["img_h"] * (ty + th / 2) n_gt += 1 box_gt = torch.cat([ coord.unsqueeze(0) for coord in [tx1, ty1, tx2, ty2] ]).view(1, -1) sample_pred = output[sample_i] if sample_pred is not None: # Iterate through predictions where the class predicted is same as gt for x1, y1, x2, y2, conf, obj_conf, obj_pred in sample_pred[ sample_pred[:, 6] == obj_cls]: box_pred = torch.cat([ coord.unsqueeze(0) for coord in [x1, y1, x2, y2] ]).view(1, -1) iou = bbox_iou(box_pred, box_gt) if iou >= config["iou_thres"]: correct += 1 break if n_gt: logging.info('Batch [%d/%d] mAP: %.5f' % (step, len(dataloader), float(correct / n_gt))) logging.info('Mean Average Precision: %.5f' % float(correct / n_gt))
def evaluate(config): is_training = False # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("Load checkpoint: {}".format(config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: logging.warning("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLoss(config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # DataLoader. dataloader = torch.utils.data.DataLoader(COCODataset( config["val_path"], (config["img_w"], config["img_h"]), is_training=False), batch_size=config["batch_size"], shuffle=False, num_workers=8, pin_memory=False) # Coco Prepare. index2category = json.load(open("coco_index2category.json")) # Start the eval loop logging.info("Start eval.") coco_results = [] coco_img_ids = set([]) APs = [] for step, samples in enumerate(dataloader): images, labels = samples["image"], samples["label"] image_paths, origin_sizes = samples["image_path"], samples[ "origin_size"] with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, config["yolo"]["classes"], conf_thres=0.0001, nms_thres=0.45) for idx, detections in enumerate(batch_detections): correct = [] annotations = labels[idx, labels[idx, :, 3] != 0] image_id = int(os.path.basename(image_paths[idx])[-16:-4]) coco_img_ids.add(image_id) if detections is None: if annotations.size(0) != 0: APs.append(0) continue detections = detections[np.argsort(-detections[:, 4])] origin_size = eval(origin_sizes[idx]) detections = detections.cpu().numpy() # =========================================================================================================================== # The amount of padding that was added pad_x = max(origin_size[1] - origin_size[0], 0) * (config["img_w"] / max(origin_size)) pad_y = max(origin_size[0] - origin_size[1], 0) * (config["img_w"] / max(origin_size)) # Image height and width after padding is removed unpad_h = config["img_w"] - pad_y unpad_w = config["img_w"] - pad_x # =========================================================================================================================== if annotations.size(0) == 0: correct.extend([0 for _ in range(len(detections))]) else: target_boxes = torch.FloatTensor(annotations[:, 1:].shape) target_boxes[:, 0] = (annotations[:, 1] - annotations[:, 3] / 2) target_boxes[:, 1] = (annotations[:, 2] - annotations[:, 4] / 2) target_boxes[:, 2] = (annotations[:, 1] + annotations[:, 3] / 2) target_boxes[:, 3] = (annotations[:, 2] + annotations[:, 4] / 2) target_boxes *= config["img_w"] detected = [] for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: pred_bbox = (x1, y1, x2, y2) #x1 = x1 / config["img_w"] * origin_size[0] #x2 = x2 / config["img_w"] * origin_size[0] #y1 = y1 / config["img_h"] * origin_size[1] #y2 = y2 / config["img_h"] * origin_size[1] #w = x2 - x1 #h = y2 - y1 h = ((y2 - y1) / unpad_h) * origin_size[1] w = ((x2 - x1) / unpad_w) * origin_size[0] y1 = ((y1 - pad_y // 2) / unpad_h) * origin_size[1] x1 = ((x1 - pad_x // 2) / unpad_w) * origin_size[0] coco_results.append({ "image_id": image_id, "category_id": index2category[str(int(cls_pred.item()))], "bbox": (float(x1), float(y1), float(w), float(h)), "score": float(conf), }) pred_bbox = torch.FloatTensor(pred_bbox).view(1, -1) # Compute iou with target boxes iou = bbox_iou(pred_bbox, target_boxes) # Extract index of largest overlap best_i = np.argmax(iou) # If overlap exceeds threshold and classification is correct mark as correct if iou[best_i] > config[ 'iou_thres'] and cls_pred == annotations[ best_i, 0] and best_i not in detected: correct.append(1) detected.append(best_i) else: correct.append(0) true_positives = np.array(correct) false_positives = 1 - true_positives # Compute cumulative false positives and true positives false_positives = np.cumsum(false_positives) true_positives = np.cumsum(true_positives) # Compute recall and precision at all ranks recall = true_positives / annotations.size(0) if annotations.size( 0) else true_positives precision = true_positives / np.maximum( true_positives + false_positives, np.finfo(np.float64).eps) # Compute average precision AP = compute_ap(recall, precision) APs.append(AP) print("+ Sample [%d/%d] AP: %.4f (%.4f)" % (len(APs), 5000, AP, np.mean(APs))) logging.info("Now {}/{}".format(step, len(dataloader))) print("Mean Average Precision: %.4f" % np.mean(APs)) save_results_path = "coco_results.json" with open(save_results_path, "w") as f: json.dump(coco_results, f, sort_keys=True, indent=4, separators=(',', ':')) logging.info("Save coco format results to {}".format(save_results_path)) # COCO api logging.info("Using coco-evaluate tools to evaluate.") cocoGt = COCO(config["annotation_path"]) cocoDt = cocoGt.loadRes(save_results_path) cocoEval = COCOeval(cocoGt, cocoDt, "bbox") cocoEval.params.imgIds = list(coco_img_ids) # real imgIds cocoEval.evaluate() cocoEval.accumulate() cocoEval.summarize()
def evaluate(config): # checkpoint_paths = {'58': r'\\192.168.25.58\Team-CV\checkpoints\torch_yolov3'} checkpoint_paths = {'39': r'F:\Team-CV\checkpoints\shuffle_v2/'} # checkpoint_paths = {'68': r'E:\github\YOLOv3_PyTorch\evaluate\weights'} post_weights = {k: 0 for k in checkpoint_paths.keys()} weight_index = {k: 0 for k in checkpoint_paths.keys()} time_inter = 10 dataloader = torch.utils.data.DataLoader(COCODataset( config["train_path"], (config["img_w"], config["img_h"]), is_training=False, is_scene=True), batch_size=config["batch_size"], shuffle=False, num_workers=0, pin_memory=False, drop_last=True) # DataLoader net, yolo_losses = build_yolov3(config) while 1: for key, checkpoint_path in checkpoint_paths.items(): os.makedirs(checkpoint_path + '/result', exist_ok=True) checkpoint_weights = os.listdir(checkpoint_path) checkpoint_result = os.listdir(checkpoint_path + '/result') checkpoint_result = [ cweight.split("_")[2][:-4] for cweight in checkpoint_result if cweight.endswith('ini') ] checkpoint_weights = [ cweight for cweight in checkpoint_weights if cweight.endswith('weights') ] if weight_index[key] >= len(checkpoint_weights): print('weight_index[key]', weight_index[key], len(checkpoint_weights)) time.sleep(time_inter) continue if post_weights[key] == checkpoint_weights[weight_index[key]]: print('post_weights[key]', post_weights[key]) time.sleep(time_inter) continue post_weights[key] = checkpoint_weights[weight_index[key]] if post_weights[key].endswith("_.weights"): #检查权重是否保存完 print("post_weights[key].split('_')", post_weights[key].split('_')) time.sleep(time_inter) continue if checkpoint_weights[weight_index[key]].split( "_")[1][:-8] in checkpoint_result: print('weight_index[key] +', weight_index[key]) weight_index[key] += 1 time.sleep(time_inter // 20) continue weight_index[key] += 1 try: if config["pretrain_snapshot"]: # Restore pretrain model state_dict = torch.load(config["pretrain_snapshot"]) logging.info("loading model from %s" % config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: state_dict = torch.load( os.path.join(checkpoint_path, post_weights[key])) logging.info( "loading model from %s" % os.path.join(checkpoint_path, post_weights[key])) net.load_state_dict(state_dict) except Exception as E: print(E) time.sleep(time_inter) continue logging.info("Start eval.") # Start the eval loop n_gt = 0 correct = 0 imagepath_list = [] for step, samples in enumerate(dataloader): images, labels, image_paths = samples["image"], samples[ "label"], samples["img_path"] labels = labels.cuda() with torch.no_grad(): time1 = datetime.datetime.now() outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) output = non_max_suppression(output, 1, conf_thres=0.5) if ((datetime.datetime.now() - time1).seconds > 5): logging.info('Batch %d time is too long ' % (step)) n_gt = 1 break print( "time2", (datetime.datetime.now() - time1).seconds * 1000 + (datetime.datetime.now() - time1).microseconds // 1000) # calculate for sample_i in range(labels.size(0)): # Get labels for sample where width is not zero (dummies) target_sample = labels[sample_i, labels[sample_i, :, 3] != 0] for obj_cls, tx, ty, tw, th in target_sample: # Get rescaled gt coordinates tx1, tx2 = config["img_w"] * ( tx - tw / 2), config["img_w"] * (tx + tw / 2) ty1, ty2 = config["img_h"] * ( ty - th / 2), config["img_h"] * (ty + th / 2) n_gt += 1 box_gt = torch.cat([ coord.unsqueeze(0) for coord in [tx1, ty1, tx2, ty2] ]).view(1, -1) sample_pred = output[sample_i] if sample_pred is not None: # Iterate through predictions where the class predicted is same as gt for x1, y1, x2, y2, conf, obj_conf, obj_pred in sample_pred[ sample_pred[:, 6] == obj_cls.cuda()]: box_pred = torch.cat([ coord.unsqueeze(0) for coord in [x1, y1, x2, y2] ]).view(1, -1) iou = bbox_iou(box_pred, box_gt) if iou >= config["iou_thres"]: correct += 1 break else: if image_paths[ sample_i] not in imagepath_list: imagepath_list.append( image_paths[sample_i]) else: if image_paths[sample_i] not in imagepath_list: imagepath_list.append( image_paths[sample_i]) if n_gt: logging.info('Batch [%d/%d] err_count:%d mAP: %.5f' % (step, len(dataloader), len(imagepath_list), float(correct / n_gt))) logging.info('Mean Average Precision: %.5f' % float(correct / n_gt)) Mean_Average = float(correct / n_gt) ini_name = os.path.join( checkpoint_path + '/result/', '%.4f_%s.ini' % ((float(post_weights[key].split("_")[0]) + float(correct / n_gt)) / 2, post_weights[key].replace(".weights", ""))) write_ini(ini_name, Mean_Average, imagepath_list) break
def test(config): is_training = False anchors = [int(x) for x in config["yolo"]["anchors"].split(",")] anchors = [[[anchors[i], anchors[i + 1]], [anchors[i + 2], anchors[i + 3]], [anchors[i + 4], anchors[i + 5]]] for i in range(0, len(anchors), 6)] anchors.reverse() config["yolo"]["anchors"] = [] for i in range(3): config["yolo"]["anchors"].append(anchors[i]) # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format( config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLayer(config["batch_size"], i, config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # prepare images path images_name = os.listdir(config["images_path"]) images_path = [ os.path.join(config["images_path"], name) for name in images_name ] if len(images_path) == 0: raise Exception("no image found in {}".format(config["images_path"])) # Start inference batch_size = config["batch_size"] for step in range(0, len(images_path), batch_size): # preprocess images = [] images_origin = [] for path in images_path[step * batch_size:(step + 1) * batch_size]: logging.info("processing: {}".format(path)) image = cv2.imread(path, cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression( output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"]) # write result images. Draw bounding boxes and labels of detections classes = open(config["classes_names_path"], "r").read().split("\n")[:-1] for idx, detections in enumerate(batch_detections): if detections is not None: unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) boxes = [] for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: # Rescale coordinates to original dimensions ori_h, ori_w = images_origin[idx].shape[:2] pre_h, pre_w = config["img_h"], config["img_w"] box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w # Create a Rectangle patch box = BoundBox(x1, y1, x1 + box_w, y1 + box_h, cls_conf.item(), int(cls_pred), classes[int(cls_pred)]) boxes.append(box) # Save generated image with detections img_show = draw_boxes(images_origin[idx], boxes, labels, 0.5) img_show = cv2.resize(img_show, (img_show.shape[1], img_show.shape[0]), interpolation=cv2.INTER_CUBIC) # outVideo.write(img_show) cv2.imshow("ai", img_show) cv2.waitKey() logging.info("Save all results to ./output/")
def test(model, conf_thres=0.001, nms_thres=0.5): device = "cuda:0" classes = ['person'] if model is None: pass else: device = model.device # get model device data_parameters = read_yaml(model.data_yaml) classes = data_parameters['classes'] batch_size = model.batch_size # Dataset data_parameters[ "data_path"] = '/home/lingc1/data/sports-training-data/player_detection/validate_dataset_5k_half_size' data_set = Yolov3Data(data_parameters, None, index_file='val_test') dataloader = DataLoader(data_set, batch_size, shuffle=False, num_workers=0, collate_fn=data_set.collate_fn) print(('%20s' + '%10s' * 6) % ('Class', 'Images', 'Targets', 'P', 'R', 'mAP', 'F1')) loss, p_80, r_80, f1_80, mp_80, mr_80, map_80, mf1_80 = 0., 0., 0., 0., 0., 0., 0., 0. seen = 0 images_num = 0 output_results = "" class_recs = {} nc = len(classes) names = classes det_lines = [] imagenames = [] npos_cls = {} for i in range(nc): npos_cls[i] = 0 class_recs[i] = {} for i, (imgs, targets) in enumerate(dataloader): imgs = imgs.to(device) targets = targets.to(device) target_number = len(targets) preds = model.inference(imgs, None) output = non_max_suppression(preds, conf_thres=conf_thres, nms_thres=nms_thres) true_targets = targets[torch.sum(targets[:, 1:6], 1) != 0] # Statistics per image # remove the targets that fills 0 for data distribution. true_targets = targets[torch.sum(targets[:, 1:6], 1) != 0] # npos += len(true_targets) for si, pred in enumerate(output): images_num += 1 if pred is not None and len(pred) > 0: # Rescale boxes from 416 to true image size # pred[:, :4] = scale_coords(imgs.shape[2:], pred[:, :4], im0_shape).round() for *xyxy, conf, cls_conf, cls in pred: x = int(xyxy[0]) y = int(xyxy[1]) w = int((xyxy[2] - xyxy[0]).round()) h = int((xyxy[3] - xyxy[1]).round()) output_line = "{:s},{:d},{:d},{:d},{:d},{:f}\n".format( Path(str(si)).name, x, y, w, h, conf) det_lines.append(output_line) output_results = output_results + output_line labels = true_targets[true_targets[:, 0] == si, 1:] nl = len(labels) tcls = labels[:, 4].tolist() if nl else [] # target class seen += 1 imagename = os.path.splitext(Path(str(si)).name)[0] imagenames.append(imagename) if nl: unique_classes = np.unique(tcls).astype('int32') # detected = [] for cls in unique_classes: cls_idx = np.where(tcls == cls)[0] tcls_tensor = labels[:, 4] tcls_tensor = tcls_tensor[cls_idx] npos_cls[cls] += len(tcls_tensor) # target boxes tbox = xywh2xyxy(labels[:, 0:4]) tbox = tbox[cls_idx] tbox[:, [0, 2]] *= imgs.shape[3] tbox[:, [1, 3]] *= imgs.shape[2] bbox = np.array(tbox.cpu().numpy().round(), dtype=int) det = [False] * len(tcls_tensor) difficult = np.array(det) class_recs[cls][imagename] = { 'bbox': bbox, 'difficult': difficult, 'det': det } p_80, r_80, ap_80, f1_80 = [], [], [], [] p_50, r_50, ap_50, f1_50 = [], [], [], [] ap_80_iou = 0.8 ap_50_iou = 0.5 class_recs_80 = copy.deepcopy(class_recs) class_recs_50 = copy.deepcopy(class_recs) for cls in range(nc): rec_cls, prec_cls, ap_cls = voc_eval(det_lines, npos_cls[cls], imagenames, class_recs_80[cls], ovthresh=ap_80_iou, use_07_metric=True) f1_cls = 2 * prec_cls[-1] * rec_cls[-1] / (prec_cls[-1] + rec_cls[-1] + 1e-16) p_80.append(prec_cls[-1]) r_80.append(rec_cls[-1]) ap_80.append(ap_cls) f1_80.append(f1_cls) print("AP 80") print("person ap is: %.6f" % (ap_cls * 100)) print("recall is %.6f" % (rec_cls[-1] * 100)) print("precision is %.6f" % (prec_cls[-1] * 100)) rec_cls, prec_cls, ap_cls = voc_eval(det_lines, npos_cls[cls], imagenames, class_recs_50[cls], ovthresh=ap_50_iou, use_07_metric=True) f1_cls = 2 * prec_cls[-1] * rec_cls[-1] / (prec_cls[-1] + rec_cls[-1] + 1e-16) p_50.append(prec_cls[-1]) r_50.append(rec_cls[-1]) ap_50.append(ap_cls) f1_50.append(f1_cls) print("AP 50") print("person ap is: %.6f" % (ap_cls * 100)) print("recall is %.6f" % (rec_cls[-1] * 100)) print("precision is %.6f" % (prec_cls[-1] * 100)) mp_80, mr_80, map_80, mf1_80 = np.mean(p_80) * 100, np.mean( r_80) * 100, np.mean(ap_80) * 100, np.mean(f1_80) * 100 mp_50, mr_50, map_50, mf1_50 = np.mean(p_50) * 100, np.mean( r_50) * 100, np.mean(ap_50) * 100, np.mean(f1_50) * 100 # Print results all_target_sum = 0 for _, cls_npos in npos_cls.items(): all_target_sum += cls_npos pf = '%20s' + '%10.6g' * 6 # print format # print(pf % ('all', seen, nt.sum(), mp, mr, map, mf1), end='\n\n') print(pf % ('all', seen, all_target_sum, mp_80, mr_80, map_80, mf1_80), end='\n\n') print(pf % ('all', seen, all_target_sum, mp_50, mr_50, map_50, mf1_50), end='\n\n') # Print results per class # if nc > 1: # for i, c in enumerate(ap_class): # print(pf % (names[c], seen, npos_cls[c], p[i], r[i], ap[i], f1[i])) if nc > 1: for i in range(nc): print(pf % (names[i], seen, npos_cls[i], p_80[i], r_80[i], ap_80[i], f1_80[i])) print(pf % (names[i], seen, npos_cls[i], p_50[i], r_50[i], ap_50[i], f1_50[i])) # Return results maps = np.zeros(nc) # for i, c in enumerate(ap_class): # maps[c] = ap[i] for i in range(nc): maps[i] = ap_80[i] return (mp_80, mr_80, map_80, mf1_80, loss / len(dataloader), mp_50, mr_50, map_50, mf1_50), maps
def eval(config): """ :param config: :return: """ is_training = False # Load and initialize network # net = ProposalModel(config, is_training=is_training) net = ProposalAttention(config, is_training=is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) # YOLO loss with 3 scales val_losses = [] for i in range(3): val_losses.append( ProposalLoss(config["yolo"]["anchors"][i], (config["img_w"], config["img_h"]))) # DataLoader val_loader = torch.utils.data.DataLoader( COCOvalDataset(config["val_path"], (config["img_w"], config["img_h"])), batch_size=16, # set batch size by 1 shuffle=False, num_workers=2, pin_memory=False) """ VALIDATION """ total = 0.0 proposal = 0.0 correct = 0.0 net.eval() img_cnt = 0 recall_cnt = 0.0 for step, samples in enumerate(val_loader): images, labels = samples["image"], samples["label"] with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(val_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output) # one image at a time !!! for label_i in range(labels.size(0)): total_avg = 0 correct_avg = 0 # calculate total targets = labels[label_i] for tx, ty, tw, th in targets: if tw > 0: total += 1 total_avg += 1 else: continue # calculate proposal if batch_detections[label_i] is None: continue img_cnt += 1 predictions = batch_detections[label_i] proposal += predictions.size(0) # calculate correct for tx, ty, tw, th in targets: x1, x2 = config["img_w"] * (tx - tw / 2.0), config["img_w"] * ( tx + tw / 2.0) y1, y2 = config["img_h"] * (ty - th / 2.0), config["img_h"] * ( ty + th / 2.0) box_gt = [x1, y1, x2, y2, 1.0] box_gt = torch.from_numpy(np.array(box_gt)).float().cuda() best_iou = 0.0 for pred_i in range(predictions.size(0)): iou = bbox_iou(predictions[pred_i].unsqueeze(0), box_gt.unsqueeze(0)) iou = iou.item() best_iou = max(iou, best_iou) if best_iou >= 0.5: correct += 1 correct_avg += 1 recall_cnt += float(correct_avg / float(total_avg)) if (step + 1) % 100 == 0: print 'Total: %d\tProposal: %d\tCorrect: %d\tPrecision: %.4f\tRecall: %.4f' % ( total, proposal, correct, correct / (proposal + 1e-6), correct / (total + 1e-6)) precision = correct / (proposal + 1e-6) recall = correct / (total + 1e-6) fscore = (2.0 * precision * recall) / (precision + recall + 1e-6) print("Precision: %.4f\tRecall: %.4f\tFscore: %.4f" % (precision, recall, fscore)) print("Avg Recall: %.4f" % (recall_cnt / float(img_cnt + 1e-6)))
def test(config): is_training = False # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format( config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLayer(config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # prepare images path images_name = os.listdir(config["images_path"]) images_path = [ os.path.join(config["images_path"], name) for name in images_name ] if len(images_path) == 0: raise Exception("no image found in {}".format(config["images_path"])) # Start testing FPS of different batch size for batch_size in range(1, 10): # preprocess images = [] for path in images_path[:batch_size]: image = cv2.imread(path, cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) for i in range(batch_size - len(images)): images.append(images[0]) # fill len to batch_sze images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference in 30 times and calculate average inference_times = [] for i in range(30): start_time = time.time() with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression( output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"]) torch.cuda.synchronize() # wait all done. end_time = time.time() inference_times.append(end_time - start_time) inference_time = sum(inference_times) / len( inference_times) / batch_size fps = 1.0 / inference_time logging.info( "Batch_Size: {}, Inference_Time: {:.5f} s/image, FPS: {}".format( batch_size, inference_time, fps))
def test(config): is_training = False anchors = [int(x) for x in config["yolo"]["anchors"].split(",")] anchors = [[[anchors[i], anchors[i + 1]], [anchors[i + 2], anchors[i + 3]], [anchors[i + 4], anchors[i + 5]]] for i in range(0, len(anchors), 6)] anchors.reverse() config["yolo"]["anchors"] = [] for i in range(3): config["yolo"]["anchors"].append(anchors[i]) net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() ini_files = [ inifile for inifile in os.listdir( os.path.join(config['test_weights'], 'result')) if inifile.endswith('.ini') ] accuracy_s = [(inifile[:-4]).split('_')[-1] for inifile in ini_files] accuracy_ints = list(map(float, accuracy_s)) max_index = accuracy_ints.index(max(accuracy_ints)) # for kkk,ini_file in enumerate(ini_files): ini_list_config = configparser.ConfigParser() config_file_path = os.path.join(config['test_weights'], 'result', ini_files[max_index]) Bi_picpath = os.path.join(config['test_weights'], 'result', ini_files[max_index]).replace('.ini', '') os.makedirs(Bi_picpath, exist_ok=True) ini_list_config.read(config_file_path) ini_session = ini_list_config.sections() accuracy = ini_list_config.items(ini_session[0]) err_jpgfiles = ini_list_config.items(ini_session[1]) weight_file = os.path.join( config['test_weights'], '%s.weights' % ini_files[max_index].split('_')[0]) if weight_file: # Restore pretrain model logging.info("load checkpoint from {}".format(weight_file)) state_dict = torch.load(weight_file) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLayer(config["batch_size"], i, config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # images_name = os.listdir(config["images_path"]) # prepare images path # images_path = [os.path.join(config["images_path"], name) for name in images_name] # if len(images_path) == 0: # raise Exception("no image found in {}".format(config["images_path"])) # batch_size = config["batch_size"]# Start inference # for step in range(0, len(images_path), batch_size): for _jpg_images in err_jpgfiles: images = [] # preprocess images_origin = [] jpg_path = str(_jpg_images[1]) logging.info("processing: {}".format(jpg_path)) bbox_list = read_gt_boxes(jpg_path) image = cv2.imread(jpg_path, cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(jpg_path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() with torch.no_grad(): # inference outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression( output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"]) classes = open(config["classes_names_path"], "r").read().split("\n")[:-1] for idx, detections in enumerate(batch_detections): image_show = images_origin[idx] if detections is not None: unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: ori_h, ori_w = images_origin[ idx].shape[: 2] # Rescale coordinates to original dimensions pre_h, pre_w = config["img_h"], config["img_w"] box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w image_show = cv2.rectangle(images_origin[idx], (x1, y1), (x1 + box_w, y1 + box_h), (0, 255, 0), 2) for (x1, x2, y1, y2) in bbox_list: [x1, x2, y1, y2] = map(int, [x1, x2, y1, y2]) cv2.rectangle(image_show, (x1, y1), (x2, y2), (255, 0, 0), 2) pic_name = (jpg_path.split('/')[-1]).split('.')[0] image_show = cv2.cvtColor(image_show, cv2.COLOR_RGB2BGR) cv2.imwrite( os.path.join(Bi_picpath, '%s.jpg' % os.path.basename(pic_name)), image_show)
def evaluate(config): is_training = False # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: logging.warning("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append(YOLOLoss(config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # DataLoader dataloader = torch.utils.data.DataLoader(dataset=COCODataset(config["val_path"], config["img_w"]), batch_size=config["batch_size"], shuffle=True, num_workers=1, pin_memory=False) # Start the eval loop logging.info("Start eval.") n_gt = 0 correct = 0 logging.info('%s' % str(dataloader)) gt_histro={} pred_histro = {} correct_histro = {} for i in range(config["yolo"]["classes"]): gt_histro[i] = 1 pred_histro[i] = 1 correct_histro[i] = 0 # images 是一个batch里的全部图片,labels是一个batch里面的全部标签 for step, (images, labels) in enumerate(dataloader): labels = labels.cuda() with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) # 把三个尺度上的预测结果在第1维度(第0维度是batch里的照片,第1维度是一张照片里面的各个预测框,第2维度是各个预测数值)上拼接起来 batch_output = torch.cat(output_list, dim=1) logging.info('%s' % str(batch_output.shape)) # 进行NMS抑制 batch_output = non_max_suppression(prediction=batch_output, num_classes=config["yolo"]["classes"], conf_thres=config["conf_thresh"], nms_thres=config["nms_thresh"]) # calculate for sample_index_in_batch in range(labels.size(0)): # fetched img sample in tensor( C(RxGxB) x H x W ), transform to cv2 format in H x W x C(BxGxR) sample_image = images[sample_index_in_batch].numpy() sample_image = np.transpose(sample_image, (1, 2, 0)) sample_image = cv2.cvtColor(sample_image, cv2.COLOR_RGB2BGR) logging.debug("fetched img %d size %s" % (sample_index_in_batch, sample_image.shape)) # Get labels for sample where width is not zero (dummies)(init all labels to zeros in array) target_sample = labels[sample_index_in_batch, labels[sample_index_in_batch, :, 3] != 0] # get prediction for this sample sample_pred = batch_output[sample_index_in_batch] if sample_pred is not None: for x1, y1, x2, y2, conf, obj_conf, obj_pred in sample_pred: # for each prediction box # logging.info("%d" % obj_cls) box_pred = torch.cat([coord.unsqueeze(0) for coord in [x1, y1, x2, y2]]).view(1, -1) sample_image = draw_prediction(sample_image,conf, obj_conf, int(obj_pred), (x1, y1, x2, y2), config) # 每一个ground truth的 分类编号obj_cls、相对中心x、相对中心y、相对宽w、相对高h for obj_cls, tx, ty, tw, th in target_sample: # Get rescaled gt coordinates # 转化为输入像素尺寸的 左上角像素tx1 ty1,右下角像素tx2 ty2 tx1, tx2 = config["img_w"] * (tx - tw / 2), config["img_w"] * (tx + tw / 2) ty1, ty2 = config["img_h"] * (ty - th / 2), config["img_h"] * (ty + th / 2) # 计算ground truth数量,用于统计信息 n_gt += 1 gt_histro[int(obj_cls)] += 1 # 转化为 shape(1,4)的tensor,用来计算IoU box_gt = torch.cat([coord.unsqueeze(0) for coord in [tx1, ty1, tx2, ty2]]).view(1, -1) # logging.info('%s' % str(box_gt.shape)) sample_pred = batch_output[sample_index_in_batch] if sample_pred is not None: # Iterate through predictions where the class predicted is same as gt # 对于每一个ground truth,遍历预测结果 for x1, y1, x2, y2, conf, obj_conf, obj_pred in sample_pred[sample_pred[:, 6] == obj_cls]: # 如果当前预测分类 == 当前真实分类 #logging.info("%d" % obj_cls) box_pred = torch.cat([coord.unsqueeze(0) for coord in [x1, y1, x2, y2]]).view(1, -1) pred_histro[int(obj_pred)] += 1 iou = bbox_iou(box_pred, box_gt) if iou >= config["iou_thresh"]: correct += 1 correct_histro[int(obj_pred)] += 1 break if n_gt: types = config["types"] reverse_types = {} # 建立一个反向的types for key in types.keys(): reverse_types[types[key]] = key logging.info('Batch [%d/%d] mAP: %.5f' % (step, len(dataloader), float(correct / n_gt))) logging.info('mAP Histro:%s' % str([ reverse_types[i] +':'+ str(int(100 * correct_histro[i] / gt_histro[i])) for i in range(config["yolo"]["classes"] ) ])) logging.info('Recall His:%s' % str([ reverse_types[i] +':'+ str(int(100 * correct_histro[i] / pred_histro[i])) for i in range(config["yolo"]["classes"]) ])) logging.info('Mean Average Precision: %.5f' % float(correct / n_gt))
def test(config,int_dir='result'): is_training = False anchors = [int(x) for x in config["yolo"]["anchors"].split(",")] anchors = [[[anchors[i], anchors[i + 1]], [anchors[i + 2], anchors[i + 3]], [anchors[i + 4], anchors[i + 5]]] for i in range(0, len(anchors), 6)] anchors.reverse() config["yolo"]["anchors"] = [] for i in range(3): config["yolo"]["anchors"].append(anchors[i]) net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() ini_files = os.listdir(os.path.join(config['test_weights'], int_dir)) for kkk,ini_file in enumerate(ini_files): ini_list_config = configparser.ConfigParser() config_file_path = os.path.join(config['test_weights'], int_dir,ini_files[-kkk-1]) ini_list_config.read(config_file_path) ini_session = ini_list_config.sections() # accuracy = ini_list_config.items(ini_session[0]) err_jpgfiles = ini_list_config.items(ini_session[1]) aaa = glob.glob(os.path.join(config['test_weights'],'*_%s.weights'%ini_files[-kkk-1].split('_')[-1].split('.')[0])) weight_file = aaa[0]#os.path.join(config['test_weights'],'%s.weights'%ini_files[-kkk-1].split('_')[0]) if weight_file: # Restore pretrain model logging.info("load checkpoint from {}".format(weight_file)) state_dict = torch.load(weight_file) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") yolo_losses = [] for i in range(3): yolo_losses.append(YOLOLayer(1, i, config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) for index, _jpg_images in enumerate(err_jpgfiles): images = []# preprocess images_origin = [] jpg_path = str(_jpg_images[1]) print(str(index+1),jpg_path) bbox_list = read_gt_boxes(jpg_path) image = cv2.imread(jpg_path, cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(jpg_path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]),interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() with torch.no_grad():# inference outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"]) classes = open(config["classes_names_path"], "r").read().split("\n")[:-1] if not os.path.isdir("./output/"): os.makedirs("./output/") for idx, detections in enumerate(batch_detections): image_show=images_origin[idx] if detections is not None: unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: ori_h, ori_w = images_origin[idx].shape[:2]# Rescale coordinates to original dimensions pre_h, pre_w = config["img_h"], config["img_w"] box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w #绿色代表预测,红色代表标注 image_show = cv2.rectangle(images_origin[idx], (x1, y1), (x1 + box_w, y1 + box_h), (0, 255, 0),2) for (x1, x2, y1, y2) in bbox_list: [x1, x2, y1, y2] = map(int, [x1, x2, y1, y2]) cv2.rectangle(image_show, (x1, y1), (x2, y2), (0, 0, 255), 2) cv2.imshow('1', image_show) cv2.waitKey()
def test(config): is_training = False anchors = [int(x) for x in config["yolo"]["anchors"].split(",")] anchors = [[[anchors[i], anchors[i + 1]], [anchors[i + 2], anchors[i + 3]], [anchors[i + 4], anchors[i + 5]]] for i in range(0, len(anchors), 6)] anchors.reverse() config["yolo"]["anchors"] = [] for i in range(3): config["yolo"]["anchors"].append(anchors[i]) # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format(config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append(YOLOLayer(config["batch_size"],i,config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # prepare images path images_path = os.listdir(config["images_path"]) images_path = [file for file in images_path if file.endswith('.jpg')] # images_path = [os.path.join(config["images_path"], name) for name in images_name] if len(images_path) == 0: raise Exception("no image found in {}".format(config["images_path"])) # Start inference batch_size = config["batch_size"] bgimage = cv2.imread(os.path.join(config["images_path"], images_path[0]), cv2.IMREAD_COLOR) bgimage = cv2.cvtColor(bgimage, cv2.COLOR_BGR2GRAY) for step in range(0, len(images_path)-1, batch_size): # preprocess images = [] images_origin = [] for path in images_path[step*batch_size: (step+1)*batch_size]: if not path.endswith(".jpg") and (not path.endswith(".png")) and not path.endswith(".JPEG"): continue image = cv2.imread(os.path.join(config["images_path"], path), cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"]) # write result images. Draw bounding boxes and labels of detections classes = open(config["classes_names_path"], "r").read().split("\n")[:-1] for idx, detections in enumerate(batch_detections): image_show =images_origin[idx] if detections is not None: anno = savexml.GEN_Annotations(path + '.jpg') anno.set_size(1280, 720, 3) unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) bbox_list = [] for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: # Rescale coordinates to original dimensions ori_h, ori_w = images_origin[idx].shape[:2] pre_h, pre_w = config["img_h"], config["img_w"] box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w # Create a Rectangle patch bbox_list.append((x1, y1,box_w,box_h)) image_show = cv2.rectangle(images_origin[idx], (x1, y1), (x1 + box_w, y1 + box_h), (0, 0, 255), 1) boundbox = bg_judge(images_origin[idx],bgimage,bbox_list) print('boundbox',boundbox,bbox_list) for (x,y,w,h) in boundbox: image_show = cv2.rectangle(image_show, (x, y), (x + w, y + h), (0, 255, 0), 1) # anno.add_pic_attr("mouse", int(x1.cpu().data), int(y1.cpu().data), int(box_w.cpu().data) , int(box_h.cpu().data) ,"0") # # xml_path = os.path.join(config["images_path"], path).replace('rec_pic',r'detect_pic1\Annotations').replace('jpg','xml') # anno.savefile(xml_path) # cv2.imwrite(os.path.join(config["images_path"], path).replace('rec_pic',r'detect_pic1\rec_pic'),images_origin[idx]) cv2.imshow('1', image_show) cv2.waitKey(1) logging.info("Save all results to ./output/")
def vis(config): """ :param config: :return: """ is_training = False # Load and initialize network # net = ProposalModel(config, is_training=is_training) net = ProposalAttention(config, is_training=is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) # YOLO loss with 3 scales val_losses = [] for i in range(3): val_losses.append( ProposalLoss(config["yolo"]["anchors"][i], (config["img_w"], config["img_h"]))) # DataLoader val_loader = torch.utils.data.DataLoader(COCOvalDataset( config["val_path"], (config["img_w"], config["img_h"])), batch_size=4, shuffle=False, num_workers=2, pin_memory=False) sample = None step_d = 1 step_i = 1 cnt = 3 for i, sample in enumerate(val_loader): if i == cnt: break # Detection images, labels = sample["image"], sample["label"] with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(val_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output) for idx, detections in enumerate(batch_detections): plt.figure() fig, ax = plt.subplots(1) ax.imshow(np.transpose(images[idx].numpy(), (1, 2, 0))) if detections is not None: for x1, y1, x2, y2, conf in detections: bbox_colors = random.sample(colors, len(batch_detections)) color = bbox_colors[idx] pre_h, pre_w = config["img_h"], config["img_w"] if x1 < 0: x1 = 0 if x2 > pre_w: x2 = pre_w if y1 < 0: y1 = 0 if y2 > pre_h: y2 = pre_h box_h = (y2 - y1) box_w = (x2 - x1) # Create a Rectangle patch bbox = patches.Rectangle((x1, y1), box_w, box_h, linewidth=2, edgecolor=color, facecolor='none') # Add the bbox to the plot ax.add_patch(bbox) # ax.text(x1, y1, '{:.2f}'.format(conf), bbox=dict(facecolor=color, alpha=0.9), fontsize=8, color='white') else: print 'Nothing detected.' # Save generated image with detections plt.axis('off') plt.gca().xaxis.set_major_locator(NullLocator()) plt.gca().yaxis.set_major_locator(NullLocator()) plt.savefig('vis10/img{}_detect.jpg'.format(step_d), bbox_inches='tight', pad_inches=0.0) plt.close() step_d += 1 # Ground-truth for i, (image, label) in enumerate(zip(sample['image'], sample['label'])): plt.figure() fig, ax = plt.subplots(1) ax.imshow(np.transpose(image.numpy(), (1, 2, 0))) for l in label: if l.sum() == 0: continue x1 = int((l[0] - l[2] / 2) * config["img_w"]) y1 = int((l[1] - l[3] / 2) * config["img_h"]) x2 = int((l[0] + l[2] / 2) * config["img_w"]) y2 = int((l[1] + l[3] / 2) * config["img_h"]) box_h = (y2 - y1) box_w = (x2 - x1) bbox = patches.Rectangle((x1, y1), box_w, box_h, linewidth=2, edgecolor='blue', facecolor='none') ax.add_patch(bbox) # cv2.rectangle(image, (x1, y1), (x2, y2), (0, 0, 255)) plt.axis('off') plt.gca().xaxis.set_major_locator(NullLocator()) plt.gca().yaxis.set_major_locator(NullLocator()) plt.savefig('vis10/img{}_input.jpg'.format(step_i), bbox_inches='tight', pad_inches=0.0) plt.close() step_i += 1
def eval_voc(self, val_dataset, classes, iou_thresh=0.5): logging.info('Start Evaling') results = {} def voc_ap(rec, prec, use_07_metric=False): """ ap = voc_ap(rec, prec, [use_07_metric]) Compute VOC AP given precision and recall. If use_07_metric is true, uses the VOC 07 11 point method (default:False). """ _rec = np.arange(0., 1.1, 0.1) _prec = [] if use_07_metric: # 11 point metric ap = 0. for t in np.arange(0., 1.1, 0.1): if np.sum(rec >= t) == 0: p = 0 else: p = np.max(prec[rec >= t]) _prec.append(p) ap = ap + p / 11. else: # correct AP calculation # first append sentinel values at the end mrec = np.concatenate(([0.], rec, [1.])) mpre = np.concatenate(([0.], prec, [0.])) # compute the precision envelope for i in range(mpre.size - 1, 0, -1): mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) # to calculate area under PR curve, look for points # where X axis (recall) changes value i = np.where(mrec[1:] != mrec[:-1])[0] # and sum (\Delta recall) * prec ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) return ap def caculate_ap(correct, conf, pred_cls, total, classes): correct, conf, pred_cls = np.array(correct), np.array( conf), np.array(pred_cls) index = np.argsort(-conf) correct, conf, pred_cls = correct[index], conf[index], pred_cls[ index] ap = [] AP = {} for i, c in enumerate(classes): k = pred_cls == i n_gt = total[c] n_p = sum(k) if n_gt == 0 and n_p == 0: continue elif n_p == 0 or n_gt == 0: ap.append(0) AP[c] = 0 else: fpc = np.cumsum(1 - correct[k]) tpc = np.cumsum(correct[k]) rec = tpc / n_gt prec = tpc / (tpc + fpc) _ap = voc_ap(rec, prec) ap.append(_ap) AP[c] = _ap mAP = np.array(ap).mean() return mAP, AP def parse_rec(imagename, classes): filename = imagename.replace('jpg', 'xml') tree = ET.parse(filename) objects = [] for obj in tree.findall('object'): difficult = obj.find('difficult').text cls = obj.find('name').text if cls not in classes or int(difficult) == 1: continue cls_id = classes.index(cls) xmlbox = obj.find('bndbox') obj = [ float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text), cls_id ] objects.append(obj) return np.asarray(objects) total = {} for cls in classes: total[cls] = 0 correct = [] conf_list = [] pred_list = [] for step, samples in enumerate(val_dataset): images, labels = samples['image'], samples['label'] image_paths, origin_sizes = samples['image_path'], samples[ 'origin_size'] logging.info("Now have finished [%.3d/%.3d]" % (step, len(val_dataset))) with torch.no_grad(): outputs = self.net(images) output_list = [] for i in range(3): output_list.append(self.yolo_loss[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, self.config.num_classes, conf_thres=0.001, nms_thres=0.4) for idx, detections in enumerate(batch_detections): image_path = image_paths[idx] label = labels[idx] for t in range(label.size(0)): if label[t, :].sum() == 0: label = label[:t, :] break label_cls = np.array(label[:, 0]) for cls_id in label_cls: total[classes[int(cls_id)]] += 1 if detections is None: if label.size(0) != 0: label_cls = np.unique(label_cls) for cls_id in label_cls: correct.append(0) conf_list.append(1) pred_list.append(int(cls_id)) continue if label.size(0) == 0: for *pred_box, conf, cls_conf, cls_pred in detections: correct.append(0) conf_list.append(conf) pred_list.append(int(cls_pred)) else: detections = detections[np.argsort(-detections[:, 4])] detected = [] for *pred_box, conf, cls_conf, cls_pred in detections: pred_box = torch.FloatTensor(pred_box).view(1, -1) pred_box[:, 2:] = pred_box[:, 2:] - pred_box[:, :2] pred_box[:, :2] = pred_box[:, :2] + pred_box[:, 2:] / 2 pred_box = pred_box / self.config.image_size ious = bbox_iou(pred_box, label[:, 1:]) best_i = np.argmax(ious) if ious[best_i] > iou_thresh and int(cls_pred) == int( label[best_i, 0]) and best_i not in detected: correct.append(1) detected.append(best_i) else: correct.append(0) pred_list.append(int(cls_pred)) conf_list.append(float(conf)) results['correct'] = correct results['conf'] = conf_list results['pred_cls'] = pred_list results['total'] = total with open('results.json', 'w') as f: json.dump(results, f) logging.info('Having saved to results.json') logging.info('Begin calculating....') with open('results.json', 'r') as result_file: results = json.load(result_file) mAP, AP_class = caculate_ap(correct=results['correct'], conf=results['conf'], pred_cls=results['pred_cls'], total=results['total'], classes=classes) logging.info('mAP(IoU=0.5):{:.1f}'.format(mAP * 100))
def evaluate(config): is_training = False # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("Load checkpoint: {}".format(config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: logging.warning("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLoss(config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # DataLoader. dataloader = torch.utils.data.DataLoader(COCODataset( config["val_path"], (config["img_w"], config["img_h"]), is_training=False), batch_size=config["batch_size"], shuffle=False, num_workers=8, pin_memory=False) # Coco Prepare. index2category = json.load(open("coco_index2category.json")) # Start the eval loop logging.info("Start eval.") coco_results = [] coco_img_ids = set([]) for step, samples in enumerate(dataloader): images, labels = samples["image"], samples["label"] image_paths, origin_sizes = samples["image_path"], samples[ "origin_size"] with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(output, config["yolo"]["classes"], conf_thres=0.01, nms_thres=0.45) for idx, detections in enumerate(batch_detections): image_id = int(os.path.basename(image_paths[idx])[-16:-4]) coco_img_ids.add(image_id) if detections is not None: origin_size = eval(origin_sizes[idx]) detections = detections.cpu().numpy() for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: x1 = x1 / config["img_w"] * origin_size[0] x2 = x2 / config["img_w"] * origin_size[0] y1 = y1 / config["img_h"] * origin_size[1] y2 = y2 / config["img_h"] * origin_size[1] w = x2 - x1 h = y2 - y1 coco_results.append({ "image_id": image_id, "category_id": index2category[str(int(cls_pred.item()))], "bbox": (float(x1), float(y1), float(w), float(h)), "score": float(conf), }) logging.info("Now {}/{}".format(step, len(dataloader))) save_results_path = "coco_results.json" with open(save_results_path, "w") as f: json.dump(coco_results, f, sort_keys=True, indent=4, separators=(',', ':')) logging.info("Save coco format results to {}".format(save_results_path)) # COCO api logging.info("Using coco-evaluate tools to evaluate.") cocoGt = COCO(config["annotation_path"]) cocoDt = cocoGt.loadRes(save_results_path) cocoEval = COCOeval(cocoGt, cocoDt, "bbox") cocoEval.params.imgIds = list(coco_img_ids) # real imgIds cocoEval.evaluate() cocoEval.accumulate() cocoEval.summarize()
def test(config): is_training = False # Load and initialize network net = ModelMain(config, is_training=is_training) net.train(is_training) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if config["pretrain_snapshot"]: logging.info("load checkpoint from {}".format( config["pretrain_snapshot"])) state_dict = torch.load(config["pretrain_snapshot"]) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append( YOLOLoss(config["yolo"]["anchors"][i], config["yolo"]["classes"], (config["img_w"], config["img_h"]))) # prepare images path images_name = os.listdir(config["images_path"]) images_path = [ os.path.join(config["images_path"], name) for name in images_name ] if len(images_path) == 0: raise Exception("no image found in {}".format(config["images_path"])) # Start inference batch_size = config["batch_size"] for step in range(0, len(images_path), batch_size): # preprocess images = [] images_origin = [] for path in images_path[step * batch_size:(step + 1) * batch_size]: logging.info("processing: {}".format(path)) image = cv2.imread(path, cv2.IMREAD_COLOR) if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # keep for save result image = cv2.resize(image, (config["img_w"], config["img_h"]), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) images = np.asarray(images) images = torch.from_numpy(images).cuda() # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression( output, config["yolo"]["classes"], conf_thres=config["confidence_threshold"]) # write result images. Draw bounding boxes and labels of detections classes = open(config["classes_names_path"], "r").read().split("\n")[:-1] if not os.path.isdir("./output/"): os.makedirs("./output/") for idx, detections in enumerate(batch_detections): plt.figure() fig, ax = plt.subplots(1) ax.imshow(images_origin[idx]) if detections is not None: unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) bbox_colors = random.sample(colors, n_cls_preds) for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: color = bbox_colors[int( np.where(unique_labels == int(cls_pred))[0])] # Rescale coordinates to original dimensions ori_h, ori_w = images_origin[idx].shape[:2] pre_h, pre_w = config["img_h"], config["img_w"] box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w # Create a Rectangle patch bbox = patches.Rectangle((x1, y1), box_w, box_h, linewidth=2, edgecolor=color, facecolor='none') # Add the bbox to the plot ax.add_patch(bbox) # Add label plt.text(x1, y1, s=classes[int(cls_pred)], color='white', verticalalignment='top', bbox={ 'color': color, 'pad': 0 }) # Save generated image with detections plt.axis('off') plt.gca().xaxis.set_major_locator(NullLocator()) plt.gca().yaxis.set_major_locator(NullLocator()) plt.savefig('output/{}_{}.jpg'.format(step, idx), bbox_inches='tight', pad_inches=0.0) plt.close() logging.info("Save all results to ./output/")
def test(): is_traning = False # 不训练,测试 # Load and initialize network net = ModelMain(is_training=is_traning) net.train(is_traning) # Set data parallel net = nn.DataParallel(net) net = net.cuda() # Restore pretrain model if trained_model_dir: logging.info("load checkpoint from {}".format(trained_model_dir)) state_dict = torch.load(trained_model_dir) net.load_state_dict(state_dict) else: raise Exception("missing pretrain_snapshot!!!") # YOLO loss with 3 scales yolo_losses = [] for i in range(3): yolo_losses.append(YOLOLoss(anchors[i], yolo_class_num, (img_h, img_w))) # prepare the images path images_name = os.listdir("./images/") images_path = [os.path.join("./images/", name) for name in images_name] print('images_name:', images_name) print('images_path:', len(images_path), images_path) if len(images_path) == 0: raise Exception("no image found in {}".format("./images/")) # Start inference batch_size = 16 for step in range(0, len(images_path), batch_size): # range(0, 4, 16) step = 0, 4, 8, 12 logging.info('Batch_size:{}'.format(batch_size)) # preprocess images = [] # 输入网络图片组 images_origin = [] # 原始图片组 for path in images_path[step * batch_size:(step + 1) * batch_size]: logging.info("processing: {}".format(path)) image = cv2.imread(path, cv2.IMREAD_COLOR) # cv2.imshow('Image', image) # cv2.waitKey(0) logging.info(" √ Successfully Processed! √") if image is None: logging.error("read path error: {}. skip it.".format(path)) continue image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) images_origin.append(image) # 预处理完毕,加入原始图片组 # 进一步将图片处理为网络可以接受的数据类型(resize、归一化等) image = cv2.resize(image, (img_h, img_w), interpolation=cv2.INTER_LINEAR) image = image.astype(np.float32) image /= 255.0 image = np.transpose(image, (2, 0, 1)) image = image.astype(np.float32) images.append(image) # 归一化完毕,加入输入网络图片组 images = np.asarray(images) images = torch.from_numpy(images).cuda() logging.info("\nImages Convert to Tensor of CUDA Done!") # inference with torch.no_grad(): outputs = net(images) output_list = [] for i in range(3): output_list.append(yolo_losses[i](outputs[i])) output = torch.cat(output_list, 1) batch_detections = non_max_suppression(prediction=output, num_classes=yolo_class_num, conf_thres=0.5) logging.info("\nNet Detection Done!\n") # write result images: Draw BBox classes = open(classes_name_path, 'r').read().split("\n")[:-1] # 读取coco.names if not os.path.isdir("./output/"): os.makedirs("./output/") for idx, detections in enumerate(batch_detections): plt.figure() fig, ax = plt.subplots(1) ax.imshow(images_origin[idx]) if detections is not None: unique_labels = detections[:, -1].cpu().unique() n_cls_preds = len(unique_labels) bbox_colors = random.sample(colors, n_cls_preds) # print('Final Detections: ', detections) for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: color = bbox_colors[int( np.where(unique_labels == int(cls_pred))[0])] # Rescale coordinates to original dimensions ori_h, ori_w = images_origin[idx].shape[:2] pre_h, pre_w = img_h, img_w # 416, 416 box_h = ((y2 - y1) / pre_h) * ori_h box_w = ((x2 - x1) / pre_w) * ori_w y1 = (y1 / pre_h) * ori_h x1 = (x1 / pre_w) * ori_w # Create a Rectangle patch bbox = patches.Rectangle((x1, y1), box_w, box_h, linewidth=2, edgecolor=color, facecolor='none') # Add the bbox to the plot ax.add_patch(bbox) # Add label plt.text(x1, y1, s=classes[int(cls_pred)], color='white', verticalalignment='top', bbox={ 'color': color, 'pad': 0 }) # Save generated image with detections plt.axis('off') plt.gca().xaxis.set_major_locator(NullLocator()) plt.gca().yaxis.set_major_locator(NullLocator()) plt.savefig('output/{}_{}.jpg'.format(step, idx), bbox_inches='tight', pad_inches=0.0) plt.close() logging.info("All the Test Process Succeed! Enjoy it!")