print('Using config:') pprint.pprint(cfg) # np.random.seed(cfg.RNG_SEED) # train set imdb_name = DATASET + "_train_supervised" imdb, roidb, ratio_list, ratio_index = combined_roidb(imdb_name) train_size = len(roidb) print('{:d} roidb entries'.format(train_size)) output_dir = os.path.join(args.save_dir, args.net, DATASET, 'all') os.makedirs(output_dir, exist_ok=True) dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, imdb.num_classes, training=True) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, num_workers=args.num_workers, pin_memory=False) # initilize the tensor holder here. im_data = torch.FloatTensor(1) im_info = torch.FloatTensor(1) num_boxes = torch.LongTensor(1) gt_boxes = torch.FloatTensor(1) # ship to cuda
def loop(): args = parse_args() print('Called with args:') print(args) if torch.cuda.is_available() and not args.cuda: print("WARNING: You have a CUDA device, so you should probably run with --cuda") if args.dataset == "pascal_voc": args.imdb_name = "voc_2007_test" args.imdbval_name = "voc_2007_test" args.set_cfgs = ['ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'] elif args.dataset == "pascal_voc_0712": args.imdb_name = "voc_2007_trainval+voc_2012_trainval" args.imdbval_name = "voc_2007_test" args.set_cfgs = ['ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'] elif args.dataset == "coco": args.imdb_name = "coco_2014_train+coco_2014_valminusminival" args.imdbval_name = "coco_2014_minival" args.set_cfgs = ['ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'] elif args.dataset == "imagenet": args.imdb_name = "imagenet_train" args.imdbval_name = "imagenet_val" args.set_cfgs = ['ANCHOR_SCALES', '[8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'] elif args.dataset == "vg": args.imdb_name = "vg_150-50-50_minitrain" args.imdbval_name = "vg_150-50-50_minival" args.set_cfgs = ['ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]'] args.cfg_file = "cfgs/{}.yml".format(args.net) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) print('Using config:') pprint.pprint(cfg) np.random.seed(cfg.RNG_SEED) cfg.TRAIN.USE_FLIPPED = False imdb, roidb, ratio_list, ratio_index = combined_roidb(args.imdbval_name, False) imdb.competition_mode(on=True) print('{:d} roidb entries'.format(len(roidb))) # initilize the network here. if args.net == 'vgg16': fpn = vgg16(imdb.classes, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res101': fpn = resnet(imdb.classes, 101, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res50': fpn = resnet(imdb.classes, 50, pretrained=True, class_agnostic=args.class_agnostic) elif args.net == 'res152': fpn = resnet(imdb.classes, 152, pretrained=True, class_agnostic=args.class_agnostic) else: print("network is not defined") pdb.set_trace() fpn.create_architecture() print('load model successfully!') im_data = torch.FloatTensor(1) im_info = torch.FloatTensor(1) num_boxes = torch.LongTensor(1) gt_boxes = torch.FloatTensor(1) # ship to cuda if args.cuda: im_data = im_data.cuda() im_info = im_info.cuda() num_boxes = num_boxes.cuda() gt_boxes = gt_boxes.cuda() # make variable im_data = Variable(im_data) im_info = Variable(im_info) num_boxes = Variable(num_boxes) gt_boxes = Variable(gt_boxes) if args.cuda: cfg.CUDA = True if args.cuda: fpn.cuda() start = time.time() max_per_image = 100 vis =True #args.vis if vis: thresh = 0.0 else: thresh = 0.0 save_name = 'faster_rcnn_10' num_images = len(imdb.image_index) all_boxes = [[[] for _ in range(num_images)] for _ in range(imdb.num_classes)] output_dir = get_output_dir(imdb, save_name) for h in range(200): dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \ imdb.num_classes, training=False, normalize=False) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=0, pin_memory=True) data_iter = iter(dataloader) _t = {'im_detect': time.time(), 'misc': time.time()} det_file = os.path.join(output_dir, 'detections.pkl') input_dir = args.load_dir + "/" + args.net + "/" + args.dataset if not os.path.exists(input_dir): raise Exception('There is no input directory for loading network from ' + input_dir) load_name = os.path.join(input_dir, 'fpn_{}_{}_{}.pth'.format(args.checksession, args.checkepoch, args.checkpoint)) print("load checkpoint %s" % (load_name)) checkpoint = torch.load(load_name) fpn.load_state_dict(checkpoint['model']) if 'pooling_mode' in checkpoint.keys(): cfg.POOLING_MODE = checkpoint['pooling_mode'] fpn.eval() empty_array = np.transpose(np.array([[], [], [], [], []]), (1, 0)) for i in range(num_images): data = data_iter.next() im_data.data.resize_(data[0].size()).copy_(data[0]) im_info.data.resize_(data[1].size()).copy_(data[1]) gt_boxes.data.resize_(data[2].size()).copy_(data[2]) num_boxes.data.resize_(data[3].size()).copy_(data[3]) det_tic = time.time() rois, cls_prob, bbox_pred, \ _, _, _, _, _ = fpn(im_data, im_info, gt_boxes, num_boxes) scores = cls_prob.data # 1*300*10 boxes = rois.data[:, :, 1:5] # 1*300*4 if cfg.TEST.BBOX_REG: # Apply bounding-box regression deltas box_deltas = bbox_pred.data # 1*300*40 if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED: # Optionally normalize targets by a precomputed mean and stdev if args.class_agnostic: box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \ + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda() box_deltas = box_deltas.view(1, -1, 4) else: box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \ + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda() box_deltas = box_deltas.view(1, -1, 4 * len(imdb.classes)) pred_boxes = bbox_transform_inv(boxes, box_deltas, 1) pred_boxes = clip_boxes(pred_boxes, im_info.data, 1) else: # Simply repeat the boxes, once for each class pred_boxes = boxes pred_boxes /= data[1][0][2].cuda() scores = scores.squeeze() pred_boxes = pred_boxes.squeeze() det_toc = time.time() detect_time = det_toc - det_tic misc_tic = time.time() if vis: im = cv2.imread(imdb.image_path_at(i)) im2show = np.copy(im) for j in range(1, imdb.num_classes): inds = torch.nonzero(scores[:, j] > thresh).view(-1) # if there is det if inds.numel() > 0: cls_scores = scores[:, j][inds] _, order = torch.sort(cls_scores, 0, True) if args.class_agnostic: cls_boxes = pred_boxes[inds, :] else: cls_boxes = pred_boxes[inds][:, j * 4:(j + 1) * 4] cls_dets = torch.cat((cls_boxes, cls_scores.unsqueeze(1)), 1) # cls_dets = torch.cat((cls_boxes, cls_scores), 1) cls_dets = cls_dets[order] keep = nms(cls_dets, cfg.TEST.NMS,~args.cuda) cls_dets = cls_dets[keep.view(-1).long()] if vis: im2show = vis_detections(im2show, imdb.classes[j], cls_dets.cpu().numpy(), 0.3) all_boxes[j][i] = cls_dets.cpu().numpy() else: all_boxes[j][i] = empty_array # Limit to max_per_image detections *over all classes* if max_per_image > 0: image_scores = np.hstack([all_boxes[j][i][:, -1] for j in range(1, imdb.num_classes)]) if len(image_scores) > max_per_image: image_thresh = np.sort(image_scores)[-max_per_image] for j in range(1, imdb.num_classes): keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0] all_boxes[j][i] = all_boxes[j][i][keep, :] misc_toc = time.time() nms_time = misc_toc - misc_tic sys.stdout.write('im_detect: {:d}/{:d} {:.3f}s {:.3f}s \r' \ .format(i + 1, num_images, detect_time, nms_time)) sys.stdout.flush() if vis: cv2.imwrite('images/result%d_%d.png' %(args.checkepoch,i), im2show) #pdb.set_trace() # cv2.imshow('test', im2show) # cv2.waitKey(0) del data del pred_boxes del scores torch.cuda.empty_cache() with open(det_file, 'wb') as f: cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL) print('Evaluating detections') aps, clss = imdb.evaluate_detections(all_boxes, output_dir) #print(aps) with open("result.txt", 'a+') as f: # print(args.checkepoch) lp="" cc=0 for b in clss: if cc!=len(clss)-1: lp=lp+"'"+str(b) + ":" + str(aps[cc])+"'," else: lp = lp + "'" + str(b) + ":" + str(aps[cc])+"'" cc=cc+1 sp = "["+lp+ "] ls:" + str(args.checksession) + "_" + str(args.checkepoch) # print(sp) f.write(sp + "\n") end = time.time() print("test time: %0.4fs" % (end - start)) args.checkepoch = args.checkepoch + 1 del data_iter del dataset del dataloader torch.cuda.empty_cache() #torch.empty_cache() gc.collect()
args.cfg_file = "cfgs/{}_{}.yml".format(args.net, args.dataset) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) cfg.USE_GPU_NMS = args.cuda cfg.CUDA = args.cuda print('Using config:') pprint.pprint(cfg) roidb_path = args.roidb_dir + "/" + args.dataset + "/" + args.imdbval_name roidb = get_roidb(roidb_path) dataset = roibatchLoader(roidb, phase='test') dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False) num_videos = len(dataset) args.num_videos = num_videos print('{:d} roidb entries'.format(num_videos)) model_dir = args.load_dir + "/" + args.net + "/" + args.dataset if not os.path.exists(model_dir): raise Exception( 'There is no input directory for loading network from ' + model_dir) output_dir = args.output_dir + "/" + args.net + "/" + args.dataset
print('{:d} roidb entries'.format(train_size)) output_dir = os.path.join(args.save_dir, args.arch, args.net, args.dataset) if not os.path.exists(output_dir): os.makedirs(output_dir) if args.use_det: vid_sampler_batch = sampler(vid_train_size, args.batch_size) det_sampler_batch = sampler_det(det_train_size, args.batch_size) #print(vid_sampler_batch) #print(det_sampler_batch) #input() # Build VID and DET datasets vid_dataset = roibatchLoader(vid_roidb,vid_ratio_list, vid_ratio_index, args.batch_size, vid_imdb.num_classes, training=True) det_dataset = roibatchLoader(det_roidb,det_ratio_list, det_ratio_index, args.batch_size, det_imdb.num_classes, training=True) vid_dataloader = torch.utils.data.DataLoader(vid_dataset, batch_size=args.batch_size, sampler=vid_sampler_batch, num_workers=args.num_workers, drop_last=True) det_dataloader = torch.utils.data.DataLoader(det_dataset, batch_size=args.batch_size, sampler=det_sampler_batch, num_workers=args.num_workers, drop_last=True) else: sampler_batch = sampler(train_size, args.batch_size)
max_per_image = 100 vis = args.vis if vis: thresh = 0.05 else: thresh = 0.0 save_name = 'faster_rcnn_10' num_images = len(imdb.image_index) all_boxes = [[[] for _ in range(num_images)] for _ in range(imdb.num_classes)] output_dir = get_output_dir(imdb, save_name) dataset = roibatchLoader(roidb, ratio_list, ratio_index, 1, \ imdb.num_classes, training=False, normalize = False) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=0, pin_memory=True) data_iter = iter(dataloader) _t = {'im_detect': time.time(), 'misc': time.time()} det_file = os.path.join(output_dir, 'detections.pkl') fasterRCNN.eval() empty_array = np.transpose(np.array([[],[],[],[],[]]), (1,0)) for i in range(num_images): data = next(data_iter) with torch.no_grad():
"WARNING: You have a CUDA device, so you should probably run with --cuda" ) # train set cfg.USE_GPU_NMS = args.cuda # create dataloader imdb, roidb, ratio_list, ratio_index, query = combined_roidb( args.imdb_name, True) train_size = len(roidb) print('{:d} roidb entries'.format(len(roidb))) sampler_batch = sampler(train_size, args.batch_size) dataset = roibatchLoader(roidb, ratio_list, ratio_index, query, args.batch_size, imdb._classes, training=True) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, sampler=sampler_batch, num_workers=args.num_workers, collate_fn=collate_tensors) # create output directory output_dir = args.save_dir if not os.path.exists(output_dir): os.makedirs(output_dir) # initilize the tensor holder here.
train_size = len(roidb) print('{:d} roidb entries'.format(len(roidb))) start_datetime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) output_dir = "./logs/" + args.dataset + "/" + args.backbone + "_IB/" + str( start_datetime) + "/" if not os.path.exists(output_dir): os.makedirs(output_dir) sampler_batch = sampler(train_size, args.batch_size) dataset = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, imdb.num_classes, training=True, trans=args.trans_img) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, sampler=sampler_batch, num_workers=args.num_workers) # initilize the tensor holder here. im_data = torch.FloatTensor(1) im_info = torch.FloatTensor(1) num_boxes = torch.LongTensor(1) gt_boxes = torch.FloatTensor(1)
cfg_from_list(args.set_cfgs) print('Using config:') pprint.pprint(cfg) logging.info(cfg) np.random.seed(cfg.RNG_SEED) # train set # -- Note: Use validation set and disable the flipped to enable faster loading. cfg.TRAIN.USE_FLIPPED = True cfg.USE_GPU_NMS = args.cuda imdb_train, roidb_train, ratio_list_train, ratio_index_train = combined_roidb(args.imdb_name,cfg.TRAIN.USE_FLIPPED) train_size = len(roidb_train) _print('Train: {:d} roidb entries'.format(len(roidb_train)), logging) train_dataset = roibatchLoader(roidb_train, ratio_list_train, ratio_index_train, args.batch_size, \ imdb_train.num_classes, training=True) sampler_batch = sampler(train_size, args.batch_size) train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, sampler=sampler_batch, num_workers=args.num_workers) ### test set cfg.TRAIN.USE_FLIPPED = False imdb_test, roidb_test, ratio_list_test, ratio_index_test = combined_roidb(args.imdbval_name,cfg.TRAIN.USE_FLIPPED, False) print('Test:{:d} roidb entries'.format(len(roidb_test))) output_dir = args.save_dir + "/" + args.net + "/" + args.dataset if not os.path.exists(output_dir): os.mkdir(output_dir) # initilize the tensor holder here. im_data = torch.FloatTensor(1)
def evaluation(name, net=None, vis=False, cuda=True, class_agnostic=False): cfg.TRAIN.USE_FLIPPED = False imdb, roidb, ratio_list, ratio_index = combined_roidb(name, False) imdb.competition_mode(on=True) print('{:d} roidb entries'.format(len(roidb))) if not net: input_dir = args.load_dir + "/" + args.net + "/" + args.dataset # input_dir = 'weight' if not os.path.exists(input_dir): raise Exception( 'There is no input directory for loading network from ' + input_dir) # load_name = os.path.join(input_dir, # 'faster_rcnn_{}_{}_{}.pth'.format(args.checksession, args.checkepoch, args.checkpoint)) load_name = os.path.join( input_dir, 'faster_rcnn_{}_best.pth'.format(cfg['POOLING_MODE'])) # initilize the network here. if args.net == 'vgg16': fasterRCNN = vgg16(imdb.classes, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res101': fasterRCNN = resnet(imdb.classes, 101, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res50': fasterRCNN = resnet(imdb.classes, 50, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res152': fasterRCNN = resnet(imdb.classes, 152, pretrained=False, class_agnostic=args.class_agnostic) else: print("network is not defined") pdb.set_trace() fasterRCNN.create_architecture() print("load checkpoint %s" % (load_name)) checkpoint = torch.load(load_name) fasterRCNN.load_state_dict(checkpoint['model']) if 'pooling_mode' in checkpoint.keys(): cfg.POOLING_MODE = checkpoint['pooling_mode'] print('load model successfully!') else: fasterRCNN = net # initilize the tensor holder here. im_data = torch.FloatTensor(1) im_info = torch.FloatTensor(1) num_boxes = torch.LongTensor(1) gt_boxes = torch.FloatTensor(1) # ship to cuda if cuda: im_data = im_data.cuda() im_info = im_info.cuda() num_boxes = num_boxes.cuda() gt_boxes = gt_boxes.cuda() # make variable im_data = Variable(im_data) im_info = Variable(im_info) num_boxes = Variable(num_boxes) gt_boxes = Variable(gt_boxes) if cuda: cfg.CUDA = True if cuda: fasterRCNN.cuda() start = time.time() max_per_image = 100 # vis = args.vis if vis: thresh = 0.05 else: thresh = 0.0 save_name = 'faster_rcnn_10' num_images = len(imdb.image_index) all_boxes = [[[] for _ in range(num_images)] for _ in range(imdb.num_classes)] output_dir = get_output_dir(imdb, save_name) dataset = roibatchLoader(roidb, ratio_list, ratio_index, 1, \ imdb.num_classes, training=False, normalize=False) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=0, pin_memory=True) data_iter = iter(dataloader) _t = {'im_detect': time.time(), 'misc': time.time()} det_file = os.path.join(output_dir, 'detections.pkl') fasterRCNN.eval() empty_array = np.transpose(np.array([[], [], [], [], []]), (1, 0)) for i in range(num_images): data = next(data_iter) with torch.no_grad(): im_data.resize_(data[0].size()).copy_(data[0]) im_info.resize_(data[1].size()).copy_(data[1]) gt_boxes.resize_(data[2].size()).copy_(data[2]) num_boxes.resize_(data[3].size()).copy_(data[3]) det_tic = time.time() rois, cls_prob, bbox_pred, \ rpn_loss_cls, rpn_loss_box, \ RCNN_loss_cls, RCNN_loss_bbox, \ rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes) scores = cls_prob.data boxes = rois.data[:, :, 1:5] if cfg.TEST.BBOX_REG: # Apply bounding-box regression deltas box_deltas = bbox_pred.data if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED: # Optionally normalize targets by a precomputed mean and stdev if class_agnostic: box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \ + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda() box_deltas = box_deltas.view(1, -1, 4) else: box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \ + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda() box_deltas = box_deltas.view(1, -1, 4 * len(imdb.classes)) pred_boxes = bbox_transform_inv(boxes, box_deltas, 1) pred_boxes = clip_boxes(pred_boxes, im_info.data, 1) else: # Simply repeat the boxes, once for each class pred_boxes = np.tile(boxes, (1, scores.shape[1])) pred_boxes /= data[1][0][2].item() scores = scores.squeeze() pred_boxes = pred_boxes.squeeze() det_toc = time.time() detect_time = det_toc - det_tic misc_tic = time.time() if vis: im = cv2.imread(imdb.image_path_at(i)) im2show = np.copy(im) for j in range(1, imdb.num_classes): inds = torch.nonzero(scores[:, j] > thresh).view(-1) # if there is det if inds.numel() > 0: cls_scores = scores[:, j][inds] _, order = torch.sort(cls_scores, 0, True) if class_agnostic: cls_boxes = pred_boxes[inds, :] else: cls_boxes = pred_boxes[inds][:, j * 4:(j + 1) * 4] cls_dets = torch.cat((cls_boxes, cls_scores.unsqueeze(1)), 1) # cls_dets = torch.cat((cls_boxes, cls_scores), 1) cls_dets = cls_dets[order] keep = nms(cls_boxes[order, :], cls_scores[order], cfg.TEST.NMS) cls_dets = cls_dets[keep.view(-1).long()] if vis: im2show = vis_detections(im2show, imdb.classes[j], cls_dets.cpu().numpy(), 0.3) all_boxes[j][i] = cls_dets.cpu().numpy() else: all_boxes[j][i] = empty_array # Limit to max_per_image detections *over all classes* if max_per_image > 0: image_scores = np.hstack( [all_boxes[j][i][:, -1] for j in range(1, imdb.num_classes)]) if len(image_scores) > max_per_image: image_thresh = np.sort(image_scores)[-max_per_image] for j in range(1, imdb.num_classes): keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0] all_boxes[j][i] = all_boxes[j][i][keep, :] misc_toc = time.time() nms_time = misc_toc - misc_tic sys.stdout.write('im_detect: {:d}/{:d} {:.3f}s {:.3f}s \r' \ .format(i + 1, num_images, detect_time, nms_time)) sys.stdout.flush() if vis: cv2.imwrite('result.png', im2show) pdb.set_trace() # cv2.imshow('test', im2show) # cv2.waitKey(0) with open(det_file, 'wb') as f: pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL) print('Evaluating detections') map = imdb.evaluate_detections(all_boxes, output_dir) # print(map) end = time.time() print("test time: %0.4fs" % (end - start)) return map
def test(args, model=None): if torch.cuda.is_available() and not args.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) # Load dataset imdb_vu, roidb_vu, ratio_list_vu, ratio_index_vu, query_vu = combined_roidb( args.imdbval_name, False) imdb_vu.competition_mode(on=True) dataset_vu = roibatchLoader(roidb_vu, ratio_list_vu, ratio_index_vu, query_vu, 1, imdb_vu._classes, training=False) # initilize the network here. if not model: if args.net == 'vgg16': fasterRCNN = vgg16(imdb_vu.classes, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res101': fasterRCNN = resnet(imdb_vu.classes, 101, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res50': fasterRCNN = resnet(imdb_vu.classes, 50, pretrained=False, class_agnostic=args.class_agnostic) elif args.net == 'res152': fasterRCNN = resnet(imdb_vu.classes, 152, pretrained=False, class_agnostic=args.class_agnostic) else: print("network is not defined") fasterRCNN.create_architecture() # Load checkpoint print("load checkpoint %s" % (args.weights)) checkpoint = torch.load(args.weights) fasterRCNN.load_state_dict(checkpoint['model']) if 'pooling_mode' in checkpoint.keys(): cfg.POOLING_MODE = checkpoint['pooling_mode'] print('load model successfully!') else: # evaluate constructed model fasterRCNN = model # initialize the tensor holder here. im_data = torch.FloatTensor(1) query = torch.FloatTensor(1) im_info = torch.FloatTensor(1) catgory = torch.LongTensor(1) gt_boxes = torch.FloatTensor(1) # ship to cuda if args.cuda: cfg.CUDA = True fasterRCNN.cuda() im_data = im_data.cuda() query = query.cuda() im_info = im_info.cuda() catgory = catgory.cuda() gt_boxes = gt_boxes.cuda() # record time start = time.time() # visiualization vis = args.vis if hasattr(args, 'vis') else None if vis: thresh = 0.05 else: thresh = 0.0 max_per_image = 100 fasterRCNN.eval() dataset_vu.query_position = 0 test_scales = cfg.TEST.SCALES multiscale_iterators = [] for i_scale, test_scale in enumerate(test_scales): cur_dataloader_vu = torch.utils.data.DataLoader(dataset_vu, batch_size=1, shuffle=False, num_workers=0, pin_memory=True) cur_data_iter_vu = iter(cur_dataloader_vu) multiscale_iterators.append(cur_data_iter_vu) # total quantity of testing images, each images include multiple detect class num_images_vu = len(imdb_vu.image_index) num_detect = len(ratio_index_vu[0]) all_boxes = [[[] for _ in range(num_images_vu)] for _ in range(imdb_vu.num_classes)] _t = {'im_detect': time.time(), 'misc': time.time()} for i, index in enumerate(ratio_index_vu[0]): det_tic = time.time() multiscale_boxes = [] multiscale_scores = [] for i_scale, (data_iter_vu, test_scale) in enumerate( zip(multiscale_iterators, test_scales)): # need to rewrite cfg.TRAIN.SCALES - very hacky! BACKUP_TRAIN_SCALES = cfg.TRAIN.SCALES cfg.TRAIN.SCALES = [test_scale] data = next(data_iter_vu) cfg.TRAIN.SCALES = BACKUP_TRAIN_SCALES with torch.no_grad(): im_data.resize_(data[0].size()).copy_(data[0]) query.resize_(data[1].size()).copy_(data[1]) im_info.resize_(data[2].size()).copy_(data[2]) gt_boxes.resize_(data[3].size()).copy_(data[3]) catgory.data.resize_(data[4].size()).copy_(data[4]) # Run Testing if not hasattr(args, "class_image_augmentation" ) or not args.class_image_augmentation: queries = [query] elif args.class_image_augmentation.lower() == "rotation90": queries = [query] for _ in range(3): queries.append(queries[-1].rot90(1, [2, 3])) else: raise RuntimeError( "Unknown class_image_augmentation: {}".format( args.class_image_augmentation)) for q in queries: rois, cls_prob, bbox_pred, \ rpn_loss_cls, rpn_loss_box, \ RCNN_loss_cls, _, RCNN_loss_bbox, \ rois_label, weight = fasterRCNN(im_data, q, im_info, gt_boxes, catgory) scores = cls_prob.data boxes = rois.data[:, :, 1:5] # Apply bounding-box regression if cfg.TEST.BBOX_REG: # Apply bounding-box regression deltas box_deltas = bbox_pred.data if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED: # Optionally normalize targets by a precomputed mean and stdev if args.class_agnostic: box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \ + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda() box_deltas = box_deltas.view(1, -1, 4) else: box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \ + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda() box_deltas = box_deltas.view( 1, -1, 4 * len(imdb_vu.classes)) pred_boxes = bbox_transform_inv(boxes, box_deltas, 1) pred_boxes = clip_boxes(pred_boxes, im_info.data, 1) else: # Simply repeat the boxes, once for each class pred_boxes = np.tile(boxes, (1, scores.shape[1])) # Resize to original ratio pred_boxes /= data[2][0][2].item() # Remove batch_size dimension scores = scores.squeeze() pred_boxes = pred_boxes.squeeze() multiscale_scores.append(scores) multiscale_boxes.append(pred_boxes) scores = torch.cat(multiscale_scores, dim=0) pred_boxes = torch.cat(multiscale_boxes, dim=0) # Record time det_toc = time.time() detect_time = det_toc - det_tic misc_tic = time.time() # Post processing inds = torch.nonzero(scores > thresh).view(-1) if inds.numel() > 0: # remove useless indices cls_scores = scores[inds] cls_boxes = pred_boxes[inds, :] cls_dets = torch.cat((cls_boxes, cls_scores.unsqueeze(1)), 1) # rearrange order _, order = torch.sort(cls_scores, 0, True) cls_dets = cls_dets[order] # NMS keep = nms(cls_boxes[order, :], cls_scores[order], cfg.TEST.NMS) cls_dets = cls_dets[keep.view(-1).long()] all_boxes[catgory][index] = cls_dets.cpu().numpy() # Limit to max_per_image detections *over all classes* if max_per_image > 0: try: image_scores = all_boxes[catgory][index][:, -1] if len(image_scores) > max_per_image: image_thresh = np.sort(image_scores)[-max_per_image] keep = np.where( all_boxes[catgory][index][:, -1] >= image_thresh)[0] all_boxes[catgory][index] = all_boxes[catgory][index][ keep, :] except: pass misc_toc = time.time() nms_time = misc_toc - misc_tic sys.stdout.write('im_detect: {:d}/{:d} {:.3f}s {:.3f}s \r' \ .format(i + 1, num_detect, detect_time, nms_time)) sys.stdout.flush() # save test image if vis and i % 1 == 0: im2show = cv2.imread( dataset_vu._roidb[dataset_vu.ratio_index[i]]['image']) im2show = vis_detections(im2show, 'shot', cls_dets.cpu().numpy(), 0.3) o_query = data[1][0].permute(1, 2, 0).contiguous().cpu().numpy() o_query *= [0.229, 0.224, 0.225] o_query += [0.485, 0.456, 0.406] o_query *= 255 o_query = o_query[:, :, ::-1] (h, w, c) = im2show.shape o_query = cv2.resize(o_query, (h, h), interpolation=cv2.INTER_LINEAR) im2show = np.concatenate((im2show, o_query), axis=1) vis_path = "./test_img" if not os.path.isdir(vis_path): os.makedirs(vis_path) cv2.imwrite(os.path.join(vis_path, "%d_d.png" % (i)), im2show) print('Evaluating detections') mAP = imdb_vu.evaluate_detections(all_boxes, None) end = time.time() print("test time: %0.4fs" % (end - start)) return mAP
from lib.roi_data_layer.roibatchLoader import roibatchLoader if __name__ == '__main__': batch_size = 12 imdb_name = "coco_2014_train+coco_2014_valminusminival" imdbval_name = "coco_2014_minival" set_cfgs = [ 'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '50' ] imdb, roidb, ratio_list, ratio_index = combined_roidb(imdb_name) train_size = len(roidb) print('{:d} roidb entries'.format(len(roidb))) sampler_batch = sampler(train_size, batch_size) dataset = roibatchLoader(roidb, ratio_list, ratio_index, batch_size, \ imdb.num_classes, training=True) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, sampler=sampler_batch, num_workers=1) data = next(data_iter) print(data)
num_boxes = Variable(num_boxes) gt_boxes = Variable(gt_boxes) start = time.time() max_per_image = 100 # IoU threshold for nms thresh = args.nms_threshold save_name = 'faster_rcnn_' + args.backbone num_images = len(imdb.image_index) all_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(imdb.num_classes)] output_dir = get_output_dir(imdb, save_name) dataset = roibatchLoader(roidb, ratio_list, ratio_index, 1, imdb.num_classes, training=False, normalize=False, trans=args.trans_img) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=0, pin_memory=True) data_iter = iter(dataloader) _t = {'im_detect': time.time(), 'misc': time.time()} det_file = os.path.join(output_dir, 'detections.pkl') fasterRCNN.eval() empty_array = np.transpose(np.array([[], [], [], [], []]), (1, 0)) with torch.no_grad(): for i in range(num_images):
max_per_image = 100 vis = args.vis if vis: thresh = 0.05 else: thresh = 0.0 save_name = 'faster_rcnn_10' num_images = len(roidb) all_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(num_classes)] # output_dir = get_output_dir(imdb, save_name) dataset = roibatchLoader(roidb, args.batch_size, \ num_classes, training=False, normalize=False) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=0, pin_memory=True) data_iter = iter(dataloader) _t = {'im_detect': time.time(), 'misc': time.time()} # det_file = os.path.join(output_dir, 'detections.pkl') fasterRCNN.eval() empty_array = np.transpose(np.array([[], [], [], [], []]), (1, 0)) det_file = 'det_{}_{}_{}.pickle'.format(args.dataset, args.net, test_image_tag) det_path = os.path.join(args.det_path, det_file)
if val_img_size % args.batch_size: choose_size = np.array(np.arange(val_img_size)) shuffle(choose_size) size = args.batch_size - val_img_size % args.batch_size for i in np.arange(size): val_roidb.append(roidb_temp['val_roidb'][choose_size[i]]) train_size = len(roidb) val_size = len(val_roidb) print('{:d} roidb entries'.format(train_size)) print('{:d} val_roidb entries'.format(val_size)) output_dir = args.save_dir + "/" + args.net + "/" + args.dataset if not os.path.exists(output_dir): os.makedirs(output_dir) dataset = roibatchLoader(roidb, args.batch_size, num_class, training=True) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers) val_dataset = roibatchLoader(val_roidb, args.batch_size, num_class, training=False) val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers) # initilize the tensor holder here.
# train set roidb_path = roidb_dir + "/" + dataset + "/" + imdb_name roidb = get_roidb( roidb_path ) # roidb是(13712,)大小的列表,每个元素形如{'frames': array([[ 0, 0, 768, 1]]), 'fg_name': '/home/tx/Dataset/tx/THUMOS14/val/video_validation_0000934', 'flipped': False, 'durations': array([30.]), 'bg_name': '/home/tx/Dataset/tx/THUMOS14/val/video_validation_0000934', 'max_classes': array([18.]), 'gt_classes': array([18.]), 'wins': array([[235., 265.]]), 'max_overlaps': array([1.])} print('{:d} roidb entries'.format(len(roidb))) model_dir = save_dir + "/" + net + "/" + dataset if not os.path.exists(model_dir): os.makedirs(model_dir) output_dir = output_dir + "/" + net + "/" + dataset if not os.path.exists(output_dir): os.makedirs(output_dir) # sampler_batch = sampler(train_size, args.batch_size) dataset = roibatchLoader( roidb ) #return data, gt_windows_padding, num_gt (data形状:[batch_size, 3, 512, 112, 112], gt_windows_padding形状:20行3列, num_gt = 1) dataloader = torch.utils.data.DataLoader(dataset, batch_size=bs, num_workers=nw, shuffle=True) # initilize the network here. tdcnn_demo = c3d_tdcnn(pretrained=True) tdcnn_demo.create_architecture() # 初始化特征提取网络 print( tdcnn_demo ) # 加载了activitynet预训练网络参数的c3d网络?(再次查看:rpn+特征提取网络?)包括_RPN、RCNN_base、RCNN_top、RCNN_cls_score、RCNN_twin_pred等网络 params = []