def detect(self, im, conf_thresh=0.7): im_resized = cv2.resize(im, self.__shape) im_rgb = cv2.cvtColor(im_resized, cv2.COLOR_BGR2RGB) im_torch = torch.from_numpy(im_rgb.transpose( 2, 0, 1)).float().div(255.0).unsqueeze(0) im_torch = im_torch.to(torch.device("cuda")) output = self.__net(im_torch) boxes = get_all_boxes(output, self.__shape, conf_thresh, self.__net.num_classes, use_cuda=True)[0] boxes = nms(boxes, self.__nms_thresh) result = [] w = im.shape[1] h = im.shape[0] for i in range(len(boxes)): box = boxes[i] x1 = int(round((box[0] - box[2] / 2.0) * w)) y1 = int(round((box[1] - box[3] / 2.0) * h)) x2 = int(round((box[0] + box[2] / 2.0) * w)) y2 = int(round((box[1] + box[3] / 2.0) * h)) x1 = 0 if x1 < 0 else x1 y1 = 0 if y1 < 0 else y1 x2 = w - 1 if x2 >= w else x2 y2 = h - 1 if y2 >= h else y2 result.append([x1, y1, x2, y2]) return result
def test(): def truths_length(truths): for i in range(50): if truths[i][1] == 0: return i return 50 model.eval() num_classes = model.num_classes total = 0.0 proposals = 0.0 correct = 0.0 device = torch.device("cuda" if use_cuda else "cpu") if model.net_name() == 'region': # region_layer shape = (0, 0) else: shape = (model.width, model.height) for data, target, org_w, org_h in test_loader: print("======") data = data.to(device) output = model(data) all_boxes = get_all_boxes(output, shape, conf_thresh, num_classes, use_cuda=use_cuda) for k in range(len(all_boxes)): boxes = all_boxes[k] correct_yolo_boxes(boxes, org_w[k], org_h[k], model.width, model.height) boxes = np.array(nms(boxes, nms_thresh)) truths = target[k].view(-1, 5) num_gts = truths_length(truths) total = total + num_gts num_pred = len(boxes) if num_pred == 0: continue proposals += int((boxes[:, 4] > conf_thresh).sum()) for i in range(num_gts): gt_boxes = torch.FloatTensor([ truths[i][1], truths[i][2], truths[i][3], truths[i][4], 1.0, 1.0, truths[i][0] ]) gt_boxes = gt_boxes.repeat(num_pred, 1).t() pred_boxes = torch.FloatTensor(boxes).t() best_iou, best_j = torch.max( multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False), 0) # pred_boxes and gt_boxes are transposed for torch.max if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[ 6][0]: correct += 1 precision = 1.0 * correct / (proposals + eps) recall = 1.0 * correct / (total + eps) fscore = 2.0 * precision * recall / (precision + recall + eps) logging("correct: %d, precision: %f, recall: %f, fscore: %f" % (correct, precision, recall, fscore))
def test(): def truths_length(truths): for i in range(50): if truths[i][1] == 0: return i return 50 model.eval() num_classes = model.num_classes print("num", num_classes) total = 0.0 proposals = 0.0 correct = 0.0 device = torch.device("cuda" if use_cuda else "cpu") for _, (data, target) in enumerate(test_loader): data = data.to(device) output = model(data) all_boxes = get_all_boxes(output, conf_thresh, num_classes) for k in range(data.size(0)): boxes = all_boxes[k] boxes = np.array(nms(boxes, nms_thresh)) truths = target[k].view(-1, 5) num_gts = truths_length(truths) total = total + num_gts num_pred = len(boxes) if num_pred == 0: continue proposals += int((boxes[:, 4] > conf_thresh).sum()) for i in range(num_gts): gt_boxes = torch.FloatTensor([ truths[i][1], truths[i][2], truths[i][3], truths[i][4], 1.0, 1.0, truths[i][0] ]) gt_boxes = gt_boxes.repeat(num_pred, 1).t() pred_boxes = torch.FloatTensor(boxes).t() best_iou, best_j = torch.max( multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False), 0) # pred_boxes and gt_boxes are transposed for torch.max if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[ 6][0]: correct += 1 precision = 1.0 * correct / (proposals + eps) recall = 1.0 * correct / (total + eps) fscore = 2.0 * precision * recall / (precision + recall + eps) logging("precision: %f, recall: %f, fscore: %f" % (precision, recall, fscore))
def eval_list(cfgfile, namefile, weightfile, testfile): m = Darknet(cfgfile) m.load_weights(weightfile) use_cuda = 1 if use_cuda: m.cuda() class_names = load_class_names(namefile) file_list = [] with open(testfile, "r") as fin: for f in fin: file_list.append(f.strip()) for imgfile in file_list: img = Image.open(imgfile).convert('RGB') sized = img.resize((m.width, m.height)) filename = os.path.basename(imgfile) filename = os.path.splitext(filename)[0] #print(filename, img.width, img.height, sized_width, sized_height) if m.width * m.height > 1024 * 2560: print('omit %s' % filename) continue if False: boxes = do_detect(m, sized, conf_thresh, nms_thresh, use_cuda) else: m.eval() sized = image2torch(sized).cuda(); #output = m(Variable(sized, volatile=True)).data output = m(sized) #boxes = get_region_boxes(output, conf_thresh, m.num_classes, m.anchors, m.num_anchors, 0, 1)[0] boxes = get_all_boxes(output, conf_thresh, m.num_classes)[0] boxes = np.array(nms(boxes, nms_thresh)) if False: savename = get_det_image_name(imgfile) print('img: save to %s' % savename) plot_boxes(img, boxes, savename, class_names) if False: savename = get_det_result_name(imgfile) print('det: save to %s' % savename) save_boxes(imgfile, img, boxes, savename)
def test(val_loader, conf_thresh, nms_thresh, iou_thresh, out_path, batch_size): def truths_length(truths): for i in range(50): if truths[i][1] == 0: return i return 50 model.eval() num_classes = model.num_classes device = torch.device("cuda" if use_cuda else "cpu") if model.net_name() == 'region': # region_layer shape = (0, 0) else: shape = (model.width, model.height) map = [] for i, (imgpath, data, target, org_w, org_h) in enumerate(val_loader): print('Computing boxes for batch', i, 'of size', batch_size, '. Number computed is:', i * batch_size) data = data.to(device) output = model(data) all_boxes, det_confs = get_all_boxes(output, shape, conf_thresh, num_classes, use_cuda=use_cuda, output_confidence=True) for k in range(len(all_boxes)): boxes = np.array(all_boxes[k]) boxes = boxes[boxes[:, 4] > conf_thresh] boxes = nms(boxes, nms_thresh) boxes = np.stack(boxes) boxes_true = target.cpu().numpy().reshape(-1, 5) assert len(boxes_true) % 50 == 0, 'max_boxes in image.py "fill_truth_detection" is different from 50 with ' \ 'shape {}'.format(boxes_true.shape) boxes_true = boxes_true[50*k:50*(k+1)] boxes_true = boxes_true[boxes_true.max(1) > 0, 1:5] out_boxes = np.array([imgpath[k], boxes_true, boxes], dtype=object) np.save(out_path + str(i*len(imgpath) + k), out_boxes) boxes_pred = boxes[:, :4].copy() scores = boxes[:, 4].copy() boxes_pred = boxes_pred[scores > 0.03] scores = scores[scores > 0.03] map.append(map_iou(boxes_true, boxes_pred, scores)) if len(scores) > 0 else None map = np.array(map).mean() print('Validation output saved at ' + out_path) print('The mAP IoU is: {}'.format(map))
def inference(model, test_loader,**kwargs): assert kwargs['device'] != None, 'Device error' device = kwargs['device'] print(device) model.to(device) for w in FLAGS.weights: model.load_weights(w) logging('evaluating ... %s' % (w)) def truths_length(truths): for i in range(50): if truths[i][1] == 0: return i return 50 model.eval() num_classes = model.num_classes total = 0.0 proposals = 0.0 correct = 0.0 if model.net_name() == 'region': # region_layer shape=(0,0) else: shape=(model.width, model.height) print(len(test_loader)) ''' for data, target, org_w, org_h in test_loader: data = data.to(device) output = model(data) all_boxes = get_all_boxes(output, shape, conf_thresh, num_classes, use_cuda=False if device == "cpu" else True) for k in range(len(all_boxes)): boxes = all_boxes[k] correct_yolo_boxes(boxes, org_w[k], org_h[k], model.width, model.height) boxes = np.array(nms(boxes, nms_thresh)) truths = target[k].view(-1, 5) num_gts = truths_length(truths) total = total + num_gts num_pred = len(boxes) if num_pred == 0: continue proposals += int((boxes[:,4]>conf_thresh).sum()) for i in range(num_gts): gt_boxes = torch.FloatTensor([truths[i][1], truths[i][2], truths[i][3], truths[i][4], 1.0, 1.0, truths[i][0]]) gt_boxes = gt_boxes.repeat(num_pred,1).t() pred_boxes = torch.FloatTensor(boxes).t() best_iou, best_j = torch.max(multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False),0) # pred_boxes and gt_boxes are transposed for torch.max if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[6][0]: correct += 1 #print('fps: ', len(data)/(time.time()-t0)) ''' for idx in range(len(test_loader)): data[idx] = data[idx].to(device) output = model(data[idx]) all_boxes = get_all_boxes(output, shape, conf_thresh, num_classes, use_cuda=False if device == "cpu" else True) for k in range(len(all_boxes)): boxes = all_boxes[k] correct_yolo_boxes(boxes, org_w[idx][k], org_h[idx][k], model.width, model.height) boxes = np.array(nms(boxes, nms_thresh)) truths = target[idx][k].view(-1, 5) num_gts = truths_length(truths) total = total + num_gts num_pred = len(boxes) if num_pred == 0: continue proposals += int((boxes[:,4]>conf_thresh).sum()) for i in range(num_gts): gt_boxes = torch.FloatTensor([truths[i][1], truths[i][2], truths[i][3], truths[i][4], 1.0, 1.0, truths[i][0]]) gt_boxes = gt_boxes.repeat(num_pred,1).t() pred_boxes = torch.FloatTensor(boxes).t() best_iou, best_j = torch.max(multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False),0) # pred_boxes and gt_boxes are transposed for torch.max if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[6][0]: correct += 1 precision = 1.0*correct/(proposals+eps) recall = 1.0*correct/(total+eps) fscore = 2.0*precision*recall/(precision+recall+eps) #logging("correct: %d, precision: %f, recall: %f, fscore: %f" % (correct, precision, recall, fscore)) return fscore
def valid(datacfg, cfgfile, weightfile, outfile): options = read_data_cfg(datacfg) valid_images = options['valid'] name_list = options['names'] prefix = 'results' names = load_class_names(name_list) with open(valid_images) as fp: tmp_files = fp.readlines() valid_files = [item.rstrip() for item in tmp_files] m = Darknet(cfgfile) m.print_network() m.load_weights(weightfile) m.cuda() m.eval() valid_dataset = dataset.listDataset(valid_images, shape=(m.width, m.height), shuffle=False, transform=transforms.Compose([ transforms.ToTensor(), ])) valid_batchsize = 2 assert (valid_batchsize > 1) kwargs = {'num_workers': 4, 'pin_memory': True} valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=valid_batchsize, shuffle=False, **kwargs) fps = [0] * m.num_classes if not os.path.exists('results'): os.mkdir('results') for i in range(m.num_classes): buf = '%s/%s%s.txt' % (prefix, outfile, names[i]) fps[i] = open(buf, 'w') lineId = -1 conf_thresh = 0.005 nms_thresh = 0.45 if m.net_name() == 'region': # region_layer shape = (0, 0) else: shape = (m.width, m.height) for _, (data, target, org_w, org_h) in enumerate(valid_loader): data = data.cuda() output = m(data) batch_boxes = get_all_boxes(output, shape, conf_thresh, m.num_classes, only_objectness=0, validation=True) for i in range(len(batch_boxes)): lineId += 1 fileId = os.path.basename(valid_files[lineId]).split('.')[0] #width, height = get_image_size(valid_files[lineId]) width, height = float(org_w[i]), float(org_h[i]) print(valid_files[lineId]) boxes = batch_boxes[i] correct_yolo_boxes(boxes, width, height, m.width, m.height) boxes = nms(boxes, nms_thresh) for box in boxes: x1 = (box[0] - box[2] / 2.0) * width y1 = (box[1] - box[3] / 2.0) * height x2 = (box[0] + box[2] / 2.0) * width y2 = (box[1] + box[3] / 2.0) * height det_conf = box[4] for j in range((len(box) - 5) // 2): cls_conf = box[5 + 2 * j] cls_id = int(box[6 + 2 * j]) prob = det_conf * cls_conf fps[cls_id].write('%s %f %f %f %f %f\n' % (fileId, prob, x1, y1, x2, y2)) for i in range(m.num_classes): fps[i].close()
def valid_NB(datafile, cfgfile, weightfile, epoch, prefix='result'): model = Darknet(cfgfile) options = read_data_file(datafile) data_root = options['valid'] class_root = options['names'] names = read_class_names(class_root) device = 'cuda' if torch.cuda.is_available() else 'cpu' with open(data_root, 'r') as f: lines = f.readlines() valid_files = [item.strip() for item in lines] model.load_weights(weightfile) model = model.to(device) model.eval() NB_model = joblib.load('NB models/epoch_{}.pkl'.format(int(epoch))) data = YoloDataset(data_root, shape=(model.width, model.height), transform=transforms.Compose([transforms.ToTensor()]), train=False) batch_size = 2 kwargs = {'num_workers': 4, 'pin_memory': True} data_loader = DataLoader(data, batch_size=batch_size, shuffle=False, **kwargs) fs = [None] * model.num_classes if not os.path.exists(prefix): os.makedirs(prefix) for i in range(model.num_classes): filename = prefix + '/' + str(names[i]) + '.txt' fs[i] = open(filename, 'w') net_shape = (model.width, model.height) conf_thresh = 0.005 nms_thresh = 0.45 fileIndex = 0 for index, (imgs, labels, org_w, org_h) in enumerate(data_loader): imgs = imgs.to(device) output = model(imgs) batch_boxes = get_all_boxes(output, net_shape, conf_thresh, model.num_classes, device, validation=True) for i in range(len(batch_boxes)): fileId = os.path.basename(valid_files[fileIndex]).split('.')[ 0] # gei naive image name without suffix w, h = float(org_w[i]), float(org_h[i]) # print(valid_files[fileIndex], '{}/{}'.format(fileIndex+1, len(data_loader) * batch_size)) fileIndex += 1 boxes = batch_boxes[i] correct_yolo_boxes(boxes, w, h, model.width, model.height) boxes = auto_thresh_nms(boxes, NB_model) for box in boxes: x1 = (box[0] - box[2] / 2.0) * w y1 = (box[1] - box[3] / 2.0) * h x2 = (box[0] + box[2] / 2.0) * w y2 = (box[1] + box[3] / 2.0) * h # 包含物体的概率,乘以每一类的概率 det_conf = box[4] for j in range((len(box) - 5) // 2): cls_conf = box[5 + 2 * j] cls_id = int(box[5 + 2 * j + 1]) prob = det_conf * cls_conf fs[cls_id].write('{:s} {:f} {:f} {:f} {:f} {:f}\n'.format( fileId, prob, x1, y1, x2, y2)) for i in range(len(fs)): fs[i].close()
def detect(model, img, conf_thresh, nms_thresh, use_cuda): img = image2torch(img) img = img.to(torch.device('cuda' if use_cuda else 'cpu')) out_boxes = model(img) boxes = get_all_boxes(out_boxes, conf_thresh, model.num_classes, use_cuda=use_cuda)[0] return nms(boxes, nms_thresh)
def test(): def truths_length(truths): for i in range(50): if truths[i][1] == 0: return i return 50 conf_thresh = FLAGS.FB_thresh print("Conf_thresh%.2f" % conf_thresh) model.eval() num_classes = model.num_classes total = 0.0 proposals = 0.0 correct = 0.0 total_c = np.zeros((num_classes)) proposals_c = np.zeros((num_classes)) correct_c = np.zeros((num_classes)) device = torch.device("cuda" if use_cuda else "cpu") count_iter = 0.0 if model.net_name() == 'region': # region_layer shape = (0, 0) else: shape = (model.width, model.height) for data, target, org_w, org_h in test_loader: data = data.to(device) output = model(data) all_boxes = get_all_boxes(output, shape, conf_thresh, num_classes, use_cuda=use_cuda) for k in range(len(all_boxes)): boxes = all_boxes[k] correct_yolo_boxes(boxes, org_w[k], org_h[k], model.width, model.height) boxes = np.array(nms(boxes, nms_thresh)) truths = target[k].view(-1, 5) num_gts = truths_length(truths) total_c[range(num_classes)] += np.histogram( truths[:, 0], range(num_classes + 1))[0] total = total + num_gts num_pred = len(boxes) if num_pred == 0: continue Fg_mask = boxes[:, 4] > conf_thresh proposals += int(Fg_mask.sum()) [numberofdata, _] = np.histogram(boxes[Fg_mask, 6], range(num_classes + 1)) proposals_c[range(num_classes)] += numberofdata for i in range(num_gts): gt_boxes = torch.FloatTensor([ truths[i][1], truths[i][2], truths[i][3], truths[i][4], 1.0, 1.0, truths[i][0] ]) gt_boxes = gt_boxes.repeat(num_pred, 1).t() pred_boxes = torch.FloatTensor(boxes).t() best_iou, best_j = torch.max( multi_bbox_ious(gt_boxes, pred_boxes, x1y1x2y2=False), 0) # pred_boxes and gt_boxes are transposed for torch.max if best_iou > iou_thresh and pred_boxes[6][best_j] == gt_boxes[ 6][0]: correct += 1 correct_c[int(gt_boxes[6][0])] += 1 precision = 1.0 * correct / (proposals + eps) recall = 1.0 * correct / (total + eps) fscore = 2.0 * precision * recall / (precision + recall + eps) logging("Total correct: %d, precision: %f, recall: %f, fscore: %f" % (correct, precision, recall, fscore)) print("%d", len(namelist)) print("%d,%d,%d" % (len(correct_c), len(total_c), len(proposals_c))) for i in range(num_classes): precision = 1.0 * correct_c[i] / (proposals_c[i] + eps) recall = 1.0 * correct_c[i] / (total_c[i] + eps) fscore = 2.0 * precision * recall / (precision + recall + eps) logging("%s\t correct: %d, precision: %f, recall: %f, fscore: %f" % (namelist[i], correct_c[i], precision, recall, fscore))
def valid(datacfg, cfgfile, weightfile, save_path, use_cuda = False, size = 416): options = read_data_cfg(datacfg) valid_images = options['valid'] name_list = options['names'] if os.path.exists(save_path) == False: os.mkdir(save_path) prefix = save_path names = load_class_names(name_list) with open(valid_images) as fp: tmp_files = fp.readlines() valid_files = [item.rstrip() for item in tmp_files] m = Darknet(cfgfile) m.load_weights(weightfile) num_classes = len(names) if use_cuda: m.cuda() m.eval() valid_dataset = MyDataset(valid_images, shape=(size, size), is_train = False, transform=transforms.Compose([ transforms.ToTensor(), ])) valid_batchsize = 10 assert(valid_batchsize > 1) if use_cuda: kwargs = {'num_workers': 4, 'pin_memory': True} else: kwargs = {} valid_loader = torch.utils.data.DataLoader( valid_dataset, batch_size=valid_batchsize, shuffle=False, **kwargs) fps = [0]*num_classes if not os.path.exists('results'): os.mkdir('results') for i in range(num_classes): buf = '%s/%s.txt' % (prefix, names[i]) fps[i] = open(buf, 'w') lineId = -1 conf_thresh = 0.01 nms_thresh = 0.5 for batch_id, (data, target) in enumerate(valid_loader): if use_cuda: data = data.cuda() print('start processing batch{}'.format(batch_id)) start1 = time.time() output = m(data) batch_boxes = get_all_boxes(output, conf_thresh, num_classes, only_objectness=0, validation=True, use_cuda = use_cuda) for i in range(data.size(0)): lineId = lineId + 1 fileId = os.path.basename(valid_files[lineId]).split('.')[0] width, height = get_image_size(valid_files[lineId]) boxes = batch_boxes[i] if boxes.numel() == 0: continue for cls_id in range(num_classes): cls_ind = (boxes[:, 6] == cls_id) cls_boxes = nms(boxes[cls_ind],nms_thresh) if cls_boxes.numel == 0: continue for box in cls_boxes: x1 = (box[0] - box[2]/2.0) * width y1 = (box[1] - box[3]/2.0) * height x2 = (box[0] + box[2]/2.0) * width y2 = (box[1] + box[3]/2.0) * height fps[cls_id].write('%s %f %f %f %f %f\n' %(fileId, box[4] * box[5], x1, y1, x2, y2)) end1 = time.time() print('average time {}s'.format((end1 - start1) / len(data))) del data,target for i in range(num_classes): fps[i].close()