def __init__(self, classes=None, weights_file=False): super(Yolov2, self).__init__() if classes: self.num_classes = len(classes) darknet19 = Darknet19() if weights_file: print('load pretrained weight from {}'.format(weights_file)) darknet19.load_weights(weights_file) print('pretrained weight loaded!') # darknet backbone self.conv1 = nn.Sequential(darknet19.layer0, darknet19.layer1, darknet19.layer2, darknet19.layer3, darknet19.layer4) self.conv2 = darknet19.layer5 # detection layers self.conv3 = nn.Sequential( conv_bn_leaky(1024, 1024, kernel_size=3, return_module=True), conv_bn_leaky(1024, 1024, kernel_size=3, return_module=True)) self.downsampler = conv_bn_leaky(512, 64, kernel_size=1, return_module=True) self.conv4 = nn.Sequential( conv_bn_leaky(1280, 1024, kernel_size=3, return_module=True), nn.Conv2d(1024, (5 + self.num_classes) * self.num_anchors, kernel_size=1)) self.reorg = ReorgLayer()
def main(): trained_model = cfg.trained_model thresh = 0.5 image_dir = '/home/cory/cedl/vid/videos/vid04' net = Darknet19() net_utils.load_net(trained_model, net) net.eval() net.cuda() print('load model successfully') print(net) image_extensions = ['.jpg', '.JPG', '.png', '.PNG'] image_abs_paths = sorted([ os.path.join(image_dir, name) for name in os.listdir(image_dir) if name[-4:] in image_extensions ]) t_det = Timer() t_total = Timer() for i, image_path in enumerate(image_abs_paths): t_total.tic() image, im_data = preprocess(image_path) im_data = net_utils.np_to_variable(im_data, is_cuda=True, volatile=True).permute(0, 3, 1, 2) t_det.tic() bbox_pred, iou_pred, prob_pred = net.forward(im_data) det_time = t_det.toc() # to numpy bbox_pred = bbox_pred.data.cpu().numpy() iou_pred = iou_pred.data.cpu().numpy() prob_pred = prob_pred.data.cpu().numpy() # print bbox_pred.shape, iou_pred.shape, prob_pred.shape bboxes, scores, cls_inds = yolo_utils.postprocess( bbox_pred, iou_pred, prob_pred, image.shape, cfg, thresh) im2show = yolo_utils.draw_detection(image, bboxes, scores, cls_inds, cfg) if im2show.shape[0] > 1100: im2show = cv2.resize(im2show, (int( 1000. * float(im2show.shape[1]) / im2show.shape[0]), 1000)) cv2.imshow('test', im2show) total_time = t_total.toc() format_str = 'frame: %d, (detection: %.1f fps, %.1f ms) (total: %.1f fps, %.1f ms)' print(format_str % (i, 1. / det_time, det_time * 1000, 1. / total_time, total_time * 1000)) t_det.clear() t_total.clear() key = cv2.waitKey(1) if key == ord('q'): break
def __init__(self, channel=None, weights_file=False): super(HalfMirror, self).__init__() if channel: self.num_channel = channel darknet = Darknet19() seblock = SELayer(self.num_channel) self.conv0 = darknet.layer0 self.max_1 = nn.MaxPool2d(kernel_size=2, stride=2, return_indices=False) self.conv2 = darknet.layer1 self.max_3 = nn.MaxPool2d(kernel_size=2, stride=2, return_indices=False) self.conv4_6 = darknet.layer2 self.max_7 = nn.MaxPool2d(kernel_size=2, stride=2, return_indices=False) ############################################################### darknet19 = de_Darknet19() # self.deconv = nn.Sequential(darknet19.layer1,darknet19.layer2,darknet19.layer3,) # self.reconstruct = nn.Sequential(darknet19.layer4) #self.unpool_7 = nn.MaxUnpool2d(2, stride=2) self.channel_select = seblock self.deconv4_6 = darknet19.layer2 #self.unpool_3 = nn.MaxUnpool2d(2, stride=2) self.deconv2 = darknet19.layer3 #self.unpool_1 = nn.MaxUnpool2d(2, stride=2) self.deconv0 = darknet19.layer4
def __init__(self): self.n_boxes = 5 self.n_classes = 20 super(YOLO_v2, self).__init__() darknet = Darknet19(pretrained=True).features self.feature = darknet self.layer1 = nn.Sequential( nn.Conv2d(in_channels=1024, out_channels=1024, kernel_size=(3, 3), padding=1), nn.BatchNorm2d(1024), nn.LeakyReLU(negative_slope=0.1)) self.layer2 = nn.Sequential( nn.Conv2d(in_channels=1024, out_channels=1024, kernel_size=(3, 3), padding=1), nn.BatchNorm2d(1024), nn.LeakyReLU(negative_slope=0.1)) self.layer3 = nn.Sequential( nn.Conv2d(in_channels=1024, out_channels=1024, kernel_size=(3, 3), padding=1), nn.BatchNorm2d(1024), nn.LeakyReLU(negative_slope=0.1)) self.layer4 = nn.Sequential( nn.Conv2d(in_channels=1024, out_channels=(self.n_boxes * (5 + self.n_classes)), kernel_size=(3, 3), padding=1))
def __init__(self, modelpath): self.thresh = 0.5 self.label = ('car', 'truck', 'trailer', 'oil') self.net = Darknet19() net_utils.load_net(modelpath, self.net) self.net.cuda() self.net.eval() print('Yolo init Success')
def __init__(self, args): super(YOLOv2, self).__init__() ### YOLOv2 Config from VOC self.ANCHORS = ANCHORS self.BOX = len(ANCHORS) // 2 self.LABELS = LABELS self.CLASS = len(LABELS) self.IMAGE_H = IMAGE_H self.IMAGE_W = IMAGE_W self.GRID_H = GRID_H self.GRID_W = GRID_W self.LAMBDA_OBJECT = LAMBDA_OBJECT self.LAMBDA_NO_OBJECT = LAMBDA_NO_OBJECT self.LAMBDA_COORD = LAMBDA_COORD self.LAMBDA_CLASS = LAMBDA_CLASS self.OBJ_THRESHOLD = OBJ_THRESHOLD self.NMS_THRESHOLD = NMS_THRESHOLD ### training config self.BATCH_SIZE = int(args.batch_size) self.DARKNET19_WEIGHTS = args.darknet19_weights ### create YOLO network components # helper self.best_anchor_finder = BestAnchorFinder(self.ANCHORS) self.darknet19 = Darknet19() # take some blocks from darknet 19 self.conv1 = nn.Sequential(self.darknet19.layer0, self.darknet19.layer1, self.darknet19.layer2, self.darknet19.layer3, self.darknet19.layer4) self.conv2 = self.darknet19.layer5 # detection layers self.conv3 = nn.Sequential( conv_bn_leaky(1024, 1024, kernel_size=3, return_module=True), conv_bn_leaky(1024, 1024, kernel_size=3, return_module=True)) self.downsampler = conv_bn_leaky(512, 64, kernel_size=1, return_module=True) self.conv4 = nn.Sequential( conv_bn_leaky(1280, 1024, kernel_size=3, return_module=True), nn.Conv2d(1024, (5 + self.CLASS) * self.BOX, kernel_size=1)) # reorg self.reorg = ReorgLayer() return
def __init__(self, thresh=0.1, width=600, height=480): self.center = (width / 2, height / 2) self.camera = cv2.VideoCapture(0) self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, width) self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height) self.max_area = width * height trained_model = cfg.trained_model self.thresh = thresh self.net = Darknet19() net_utils.load_net(trained_model, self.net) self.net.cuda() self.net.eval()
def test_voc_ap(model): print(model) imdb = VOCDataset(imdb_name, cfg.DATA_DIR, cfg.batch_size, yolo_utils.preprocess_test, processes=4, shuffle=False, dst_size=cfg.inp_size) net = Darknet19() net_utils.load_net(model, net) net.cuda() net.eval() mAP = test_net(net, imdb, max_per_image, thresh, vis) imdb.close() return mAP
def main(): opt = parse_args() use_cuda, num_gpus = cuda_mode(opt) with open('config.yml', 'r') as f: config = yaml.load(f) class_names = config['class_names'] data_dir = opt.data_dir anno_dir = os.path.join(data_dir, 'annotations_cache') test_file_path = os.path.join(anno_dir, '2007_test.txt') with open(test_file_path, 'r') as f: tmp_files = f.readlines() test_files = [item.rstrip() for item in tmp_files] model = Darknet19() model.load_trained_model(torch.load(opt.trained_model)) if use_cuda: model.cuda() model.eval() init_width = 416 init_height = 416 test_dataset = dataset.listDataset(test_file_path, shape=(init_width, init_height), shuffle=False, transform=transforms.Compose( [transforms.ToTensor()])) test_bs = opt.bs assert test_bs > 1 kwargs = {'num_workers': 4, 'pin_memory': True} test_loader = DataLoader(test_dataset, batch_size=test_bs, shuffle=False, **kwargs) results = test(model, test_loader, test_files, config) evaluate(results, data_dir, class_names)
im_data = np.expand_dims( yolo_utils.preprocess_test((image, None, cfg.inp_size))[0], 0) return image, im_data, fname # hyper-parameters # npz_fname = 'models/yolo-voc.weights.npz' # h5_fname = 'models/yolo-voc.weights.h5' trained_model = cfg.trained_model # trained_model = os.path.join(cfg.train_output_dir, 'darknet19_voc07trainval_exp3_158.h5') thresh = 0.1 #im_path = 'demo' dir_path = 'demo' # --- net = Darknet19() #load model net_utils.load_net(trained_model, net) #load weights # net.load_from_npz(npz_fname) # net_utils.save_net(h5_fname, net) net.cuda() #use GPU net.eval() print('load model succ...') t_det = Timer() t_total = Timer() # im_fnames = ['person.jpg'] for n, par in enumerate(sorted(os.listdir(dir_path))): print "hahahaha" im_path = os.path.join(dir_path, par) #im_fnames = sorted((fname for fname in os.listdir(im_path) if os.path.splitext(fname)[-1] == '.JPG'))#shuffle data im_fnames = sorted(fname for fname in os.listdir(im_path)
def main(): shutil.rmtree('output', ignore_errors=True) shutil.copytree('output_template', 'output') shutil.rmtree('kitti_det_output', ignore_errors=True) os.makedirs('kitti_det_output') trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_new_2/kitti_new_2_100.h5' thresh = 0.5 use_kitti = True image_dir = '/home/cory/KITTI_Dataset/data_object_image_2/training/image_2' net = Darknet19() net_utils.load_net(trained_model, net) net.eval() net.cuda() print('load model successfully') # print(net) def str_index(filename): if use_kitti: return filename begin_pos = filename.rfind('_') + 1 end_pos = filename.rfind('.') str_v = filename[begin_pos:end_pos] return int(str_v) image_extensions = ['.jpg', '.JPG', '.png', '.PNG'] img_files = open( '/home/cory/yolo2-pytorch/train_data/kitti/kitti_val_images.txt') image_abs_paths = img_files.readlines() image_abs_paths = [f.strip() for f in image_abs_paths] '''image_abs_paths = sorted([os.path.join(image_dir, name) for name in os.listdir(image_dir) if name[-4:] in image_extensions], key=str_index)''' key_frame_path = '' detection_period = 5 use_flow = False kitti_filename = 'yolo_flow_kitti_det.txt' try: os.remove(kitti_filename) except OSError: pass t_det = Timer() t_total = Timer() for i, image_path in enumerate(image_abs_paths): t_total.tic() image, im_data = preprocess(image_path) im_data = net_utils.np_to_variable(im_data, is_cuda=True, volatile=True).permute(0, 3, 1, 2) layer_of_flow = 'conv4' t_det.tic() bbox_pred, iou_pred, prob_pred = net.forward(im_data) det_time = t_det.toc() # to numpy bbox_pred = bbox_pred.data.cpu().numpy() iou_pred = iou_pred.data.cpu().numpy() prob_pred = prob_pred.data.cpu().numpy() # print bbox_pred.shape, iou_pred.shape, prob_pred.shape bboxes, scores, cls_inds = yolo_utils.postprocess( bbox_pred, iou_pred, prob_pred, image.shape, cfg, thresh) det_obj = detection_objects(bboxes, scores, cls_inds) save_as_kitti_format(i, det_obj, kitti_filename, src_label='kitti') vis_enable = False if vis_enable: im2show = yolo_utils.draw_detection(image, bboxes, scores, cls_inds, cfg) cv2.imshow('detection', im2show) cv2.imwrite('output/detection/{:04d}.jpg'.format(i), im2show) total_time = t_total.toc() format_str = 'frame: %d, (detection: %.1f fps, %.1f ms) (total: %.1f fps, %.1f ms)' print(format_str % (i, 1. / det_time, det_time * 1000, 1. / total_time, total_time * 1000)) t_det.clear() t_total.clear() if vis_enable: key = cv2.waitKey(0) if key == ord('q'): break
def main(): opt = parse_args() use_cuda, num_gpus = cuda_mode(opt) with open('config.yml', 'r') as f: config = yaml.load(f) data_dir = opt.data_dir anno_dir = os.path.join(data_dir, 'annotations_cache') train_list = '2012_train.txt' test_list = '2007_test.txt' train_list_path = os.path.join(anno_dir, train_list) test_list_path = os.path.join(anno_dir, test_list) num_workers = config['train_num_workers'] batch_size = opt.bs lr = opt.lr momentum = config['momentum'] decay = config['decay'] # Training parameters max_epochs = opt.epochs seed = int(time.time()) save_interval = 10 # epochs save_dir = opt.out_dir print('Trained models will be save to', os.path.abspath(save_dir)) if not os.path.exists(save_dir): os.makedirs(save_dir) torch.manual_seed(seed) pre_model = opt.pre_model model = Darknet19(pre_model) init_width = 416 init_height = 416 kwargs = {'num_workers': num_workers, 'pin_memory': True} \ if use_cuda else {} test_loader = DataLoader(dataset.listDataset( test_list_path, shape=(init_width, init_height), shuffle=False, transform=transforms.Compose([transforms.ToTensor()]), train=False), batch_size=batch_size, shuffle=False, **kwargs) if use_cuda: if num_gpus > 1: model = torch.nn.DataParallel(model).cuda() else: model = model.cuda() params_dict = dict(model.named_parameters()) params = [] for key, value in params_dict.items(): if key.find('.bn') >= 0 or key.find('.bias') >= 0: params += [{'params': [value], 'weight_decay': 0.}] else: params += [{'params': [value], 'weight_decay': decay * batch_size}] optimizer = optim.SGD(model.parameters(), lr=lr/batch_size, momentum=momentum, dampening=0, weight_decay=decay*batch_size) pro_bs = 0 for epoch in range(max_epochs): train_loader = DataLoader(dataset.listDataset( train_list_path, shape=(init_width, init_height), shuffle=True, transform=transforms.Compose([transforms.ToTensor()]), train=True, seen=0, batch_size=batch_size, num_workers=num_workers), batch_size=batch_size, shuffle=False, **kwargs) pro_bs = train(model, epoch, train_loader, optimizer, opt, config, pro_bs, save_dir, save_interval) test(model, test_loader, config)
def __init__(self): self.img_uploader = util.FTP_Uploader() self.face = util.Face_Detect() # =================================检索列表=============================== #年龄列表' self.ageLists = {} fp_ages = open(AgeInfoDir, 'r') for ages_lists in fp_ages: age_num, age_lists = ages_lists[:-1].split(':') self.ageLists[age_num.encode('utf-8')] = age_lists fp_ages.close() #类别列表 self.classLists = {} fp_classes = open(ClassInfoDir, 'r') for classes_lists in fp_classes: class_num, class_lists = classes_lists[:-1].split(':') #print class_num self.classLists[class_num.encode('utf-8')] = class_lists fp_classes.close() #print self.classLists #款式列表 self.versionLists = {} fp_versions = open(VerInfoDir, 'r') for versions_lists in fp_versions: print versions_lists version_num, version_lists = versions_lists[:-1].split(':') self.versionLists[version_num.encode('utf-8')] = version_lists fp_versions.close() # 风格列表 self.styleLists = {} fp_styles = open(StyInfoDir, 'r') for styles_lists in fp_styles: style_num, style_lists = styles_lists[:-1].split(':') self.styleLists[style_num.encode('utf-8')] = style_lists fp_styles.close() # 价钱列表 self.princeLists = {} fp_princes = open(PrinceInfoDir, 'r') for princes_lists in fp_princes: prince_num, prince_value = princes_lists[:-1].split('\t') self.princeLists[prince_num.encode('utf-8')] = prince_value fp_princes.close() #print self.princeLists self.bboxes = [] self.scores = [] self.cls_inds = [] self.cls_res = [] self.cls_score = [] self.cls_res_top5 = [] self.cls_score_top5 = [] #Init for resnet with open(ClassPath, 'r') as file: num_classes = [] for eachline in file: numclass = eachline.split('\t')[-1][:-1] num_classes.append(numclass) self.num_classes = num_classes model_res = getmodel(restore=1) torch.nn.DataParallel(model_res).cuda() self.model_res = model_res self.trained_model = cfg.trained_model #Init for yolov2 # trained_model = os.path.join(cfg.train_output_dir, 'darknet19_voc07trainval_exp3_158.h5') self.thresh = 0.5 self.im_path = 'demo' # --- net = Darknet19() # load model net_utils.load_net(self.trained_model, net) # load weights # net.load_from_npz(npz_fname) # net_utils.save_net(h5_fname, net) net.cuda() # use GPU net.eval() self.net = net print('load model succ...')
def main(): shutil.rmtree('output', ignore_errors=True) shutil.copytree('output_template', 'output') # trained_model = cfg.trained_model # trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_new_2/kitti_new_2_60.h5' trained_model = '/home/cory/yolo2-pytorch/models/training/voc0712_obj_scale/voc0712_obj_scale_1.h5' # trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_det_new_2/kitti_det_new_2_40.h5' # trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_det_new_2/kitti_det_new_2_10.h5' thresh = 0.5 use_kitti = True image_dir = '/home/cory/KITTI_Dataset/data_tracking_image_2/training/image_02/0013' # car = 1 5 # pedestrian = 13 17 net = Darknet19() net_utils.load_net(trained_model, net) net.eval() net.cuda() print('load model successfully') # print(net) def str_index(filename): if use_kitti: return filename begin_pos = filename.rfind('_') + 1 end_pos = filename.rfind('.') str_v = filename[begin_pos: end_pos] return int(str_v) image_extensions = ['.jpg', '.JPG', '.png', '.PNG'] image_abs_paths = sorted([os.path.join(image_dir, name) for name in os.listdir(image_dir) if name[-4:] in image_extensions], key=str_index) key_frame_path = '' detection_period = 5 use_flow = False kitti_filename = 'yolo_flow_kitti_det.txt' try: os.remove(kitti_filename) except OSError: pass t_det = Timer() t_total = Timer() for i, image_path in enumerate(image_abs_paths): t_total.tic() image, im_data = preprocess(image_path) im_data = net_utils.np_to_variable(im_data, is_cuda=True, volatile=True).permute(0, 3, 1, 2) layer_of_flow = 'conv4' # key frame if i % detection_period == 0 and use_flow: key_frame_path = image_path # conv5 feature map feature = net.get_feature_map(im_data=im_data, layer=layer_of_flow) feature = feature.data.cpu().numpy() feature_map_all = plot_feature_map(feature, resize_ratio=1) # cv2.imshow('feature_map', feature_map_all) cv2.imwrite('output/feature_map/{:04d}.jpg'.format(i), feature_map_all * 255) t_det.tic() if use_flow: t1 = time.time() conv5_shifted_gpu = detect_by_flow(i, feature, image, image_path, key_frame_path) t2 = time.time() print('detect_by_flow', t2 - t1) bbox_pred, iou_pred, prob_pred = net.feed_feature(Variable(conv5_shifted_gpu), layer=layer_of_flow) else: bbox_pred, iou_pred, prob_pred = net.forward(im_data) det_time = t_det.toc() # to numpy bbox_pred = bbox_pred.data.cpu().numpy() iou_pred = iou_pred.data.cpu().numpy() prob_pred = prob_pred.data.cpu().numpy() # print bbox_pred.shape, iou_pred.shape, prob_pred.shape bboxes, scores, cls_inds = yolo_utils.postprocess(bbox_pred, iou_pred, prob_pred, image.shape, cfg, thresh) det_obj = detection_objects(bboxes, scores, cls_inds) save_as_kitti_format(i, det_obj, kitti_filename, src_label='kitti') im2show = yolo_utils.draw_detection(image, bboxes, scores, cls_inds, cfg) cv2.imshow('detection', im2show) cv2.imwrite('output/detection/{:04d}.jpg'.format(i), im2show) total_time = t_total.toc() format_str = 'frame: %d, (detection: %.1f fps, %.1f ms) (total: %.1f fps, %.1f ms)' print(format_str % ( i, 1. / det_time, det_time * 1000, 1. / total_time, total_time * 1000)) t_det.clear() t_total.clear() key = cv2.waitKey(1) if key == ord('q'): break
# Use LMDB custom dataset or VOC-style if cfg.lmdb: dataset = dset(cfg.target_file, cfg.root_dir, cfg.multi_scale_inp_size) # , cfg.transforms) dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch, shuffle=True, num_workers=args.workers) else: image_data = torchvision.datasets.ImageFolder(args.path) data_loader = torch.utils.data.DataLoader(image_data, batch_size=args.batch, shuffle=True, num_workers=args.workers, multiscale=cfg.multi_scale_inp_size) # replace 4 with the number of classes in your custom dataset classes = 20 if args.transfer else cfg.num_classes # create the network net = Darknet(classes) # Load weights # Loads pretrained yolo VOC weights if args.transfer: net.load_from_npz(cfg.pretrained_model, num_conv=18) exp_name = str(int(time.time())) # For tensorboard consistency on reloads start_epoch = 0 j = 0 lr = cfg.init_learning_rate # Loads from a latest saved checkpoint in case training takes place over multiple days. else: path_t = cfg.trained_model() if os.path.exists(path_t):
im2show.shape[0]), 1000)) # noqa 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') imdb.evaluate_detections(all_boxes, output_dir) if __name__ == '__main__': # data loader imdb = VOCDataset(imdb_name, cfg.DATA_DIR, cfg.batch_size, yolo_utils.preprocess_test, processes=1, shuffle=False, dst_size=cfg.multi_scale_inp_size) net = Darknet19(training=False) net_utils.load_net(trained_model, net) net.cuda() net.eval() test_net(net, imdb, max_per_image, thresh, vis) imdb.close()
def main(): root_dir = '/home/cory/project/yolo2-pytorch' output_dir = root_dir + '/output' output_template_dir = root_dir + '/output_template' kitti_filename = root_dir + '/yolo_flow_kitti_det.txt' shutil.rmtree(output_dir, ignore_errors=True) shutil.copytree(output_template_dir, output_dir) # trained_model = cfg.trained_model # trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_new_2/kitti_new_2_100.h5' # trained_model = '/home/cory/project/yolo2-pytorch/models/training/kitti_baseline_v3/kitti_baseline_v3_80.h5' trained_model = '/home/cory/project/yolo2-pytorch/models/training/kitti_new_2_flow_center_ft/kitti_new_2_flow_center_ft_50.h5' # trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_new_2_flow_ft/kitti_new_2_flow_ft_2.h5' # trained_model = '/home/cory/yolo2-pytorch/models/training/voc0712_obj_scale/voc0712_obj_scale_1.h5' # trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_det_new_2/kitti_det_new_2_40.h5' # trained_model = '/home/cory/yolo2-pytorch/models/training/kitti_det_new_2/kitti_det_new_2_10.h5' thresh = 0.5 # car = 1 5 # pedestrian = 13 17 net = Darknet19() net_utils.load_net(trained_model, net) net.eval() net.cuda() print('load model successfully') # print(net) img_files = open( '/home/cory/project/yolo2-pytorch/train_data/kitti/kitti_val_images.txt' ) # img_files = open('/home/cory/project/yolo2-pytorch/train_data/kitti/0001_images.txt') # img_files = open('/home/cory/yolo2-pytorch/train_data/ImageNetVID_test.txt') # img_files = open('/home/cory/yolo2-pytorch/train_data/vid04_images.txt') image_abs_paths = img_files.readlines() image_abs_paths = [f.strip() for f in image_abs_paths] image_abs_paths = image_abs_paths[500:] key_frame_path = '' detection_period = 1 use_flow = False layer_of_flow = 'conv4' try: os.remove(kitti_filename) except OSError: pass t_det = Timer() t_total = Timer() for i, image_path in enumerate(image_abs_paths): t_total.tic() t0 = time.time() image, im_data = preprocess(image_path) im_data = net_utils.np_to_variable(im_data, is_cuda=True, volatile=True).permute(0, 3, 1, 2) t1 = time.time() print('t1', t1 - t0) # key frame if use_flow and i % detection_period == 0: key_frame_path = image_path # conv5 feature map feature = net.get_feature_map(im_data=im_data, layer=layer_of_flow) feature = feature.data.cpu().numpy() feature_map_all = plot_feature_map(feature, resize_ratio=1) # cv2.imshow('feature_map', feature_map_all) cv2.imwrite(output_dir + '/feature_map/{:04d}.jpg'.format(i), feature_map_all * 255) t_det.tic() if use_flow: conv5_shifted_gpu = detect_by_flow(i, feature, image, image_path, key_frame_path, output_dir) bbox_pred, iou_pred, prob_pred = net.feed_feature( Variable(conv5_shifted_gpu), layer=layer_of_flow) else: bbox_pred, iou_pred, prob_pred = net.forward(im_data) det_time = t_det.toc() t2 = time.time() print('t2', t2 - t1) # to numpy bbox_pred = bbox_pred.data.cpu().numpy() iou_pred = iou_pred.data.cpu().numpy() prob_pred = prob_pred.data.cpu().numpy() t3 = time.time() print('t3', t3 - t2) # print bbox_pred.shape, iou_pred.shape, prob_pred.shape bboxes, scores, cls_inds = yolo_utils.postprocess( bbox_pred, iou_pred, prob_pred, image.shape, cfg, thresh) t4 = time.time() print('t4', t4 - t3) det_obj = detection_objects(bboxes, scores, cls_inds) save_as_kitti_format(i, det_obj, kitti_filename, src_label='kitti') im2show = yolo_utils.draw_detection(image, bboxes, scores, cls_inds, cfg) cv2.imshow('detection', im2show) cv2.imwrite(output_dir + '/detection/{:04d}.jpg'.format(i), im2show) total_time = t_total.toc() format_str = 'frame: %d, (detection: %.1f fps, %.1f ms) (total: %.1f fps, %.1f ms)' print(format_str % (i, 1. / det_time, det_time * 1000, 1. / total_time, total_time * 1000)) t5 = time.time() print('t5', t5 - t4) t_det.clear() t_total.clear() key = cv2.waitKey(1) if key == ord('q'): break
im_data = np.expand_dims( yolo_utils.preprocess_test((image, None, cfg.inp_size))[0], 0) return image, im_data # hyper-parameters # npz_fname = 'models/yolo-voc.weights.npz' # h5_fname = 'models/yolo-voc.weights.h5' trained_model = cfg.trained_model # trained_model = os.path.join( # cfg.train_output_dir, 'darknet19_voc07trainval_exp3_158.h5') thresh = 0.5 im_path = 'demo' # --- net = Darknet19() net_utils.load_net(trained_model, net) # net.load_from_npz(npz_fname) # net_utils.save_net(h5_fname, net) net.cuda() net.eval() print('load model succ...') t_det = Timer() t_total = Timer() im_fnames = sorted((fname for fname in os.listdir(im_path) if os.path.splitext(fname)[-1] == '.jpg')) im_fnames = (os.path.join(im_path, fname) for fname in im_fnames) pool = Pool(processes=1)
def extractObjects(self, video_path): import os import cv2 import torch import numpy as np from torch.multiprocessing import Pool from darknet import Darknet19 import utils.yolo as yolo_utils import utils.network as net_utils from utils.timer import Timer import cfgs.config as cfg def preprocess(fname): # return fname image = cv2.imread(fname) im_data = np.expand_dims( yolo_utils.preprocess_test((image, None, cfg.inp_size))[0], 0) return image, im_data # hyper-parameters # npz_fname = 'models/yolo-voc.weights.npz' # h5_fname = 'models/yolo-voc.weights.h5' trained_model = cfg.trained_model # trained_model = os.path.join(cfg.train_output_dir, 'darknet19_voc07trainval_exp3_158.h5') thresh = 0.5 im_path = video_path # --- net = Darknet19() net_utils.load_net(trained_model, net) # net.load_from_npz(npz_fname) # net_utils.save_net(h5_fname, net) net.cuda() net.eval() print('load model succ...') t_det = Timer() t_total = Timer() # im_fnames = ['person.jpg'] im_fnames = sorted([ fname for fname in sorted(os.listdir(im_path)) if os.path.splitext(fname)[-1] == '.jpg' ]) im_fnames = (os.path.join(im_path, fname) for fname in im_fnames) objectDetect = [] for i, (image) in enumerate(im_fnames): t_total.tic() im_data = preprocess(image) image = im_data[0] im_data = im_data[1] im_data = net_utils.np_to_variable(im_data, is_cuda=True, volatile=True).permute( 0, 3, 1, 2) t_det.tic() bbox_pred, iou_pred, prob_pred = net(im_data) det_time = t_det.toc() # to numpy bbox_pred = bbox_pred.data.cpu().numpy() iou_pred = iou_pred.data.cpu().numpy() prob_pred = prob_pred.data.cpu().numpy() # print bbox_pred.shape, iou_pred.shape, prob_pred.shape bboxes, scores, cls_inds = yolo_utils.postprocess( bbox_pred, iou_pred, prob_pred, image.shape, cfg, thresh) objectDetect.append(','.join( set([cfg.label_names[i] for i in cls_inds]))) return objectDetect