def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model') parser.add_argument('--dataset', choices=('voc', ), default='voc') parser.add_argument('image') args = parser.parse_args() if args.dataset == 'voc': if args.pretrained_model is None: args.pretrained_model = 'voc07' label_names = voc_bbox_label_names model = FasterRCNNVGG16(n_fg_class=len(label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=label_names) plt.show()
def test_pretrained(self): kwargs = { 'n_fg_class': self.n_fg_class, 'pretrained_model': self.pretrained_model, } if self.pretrained_model == 'voc0712': valid = self.n_fg_class in {None, 20} elif self.pretrained_model == 'imagenet': valid = self.n_fg_class is not None if valid: FasterRCNNVGG16(**kwargs) else: with self.assertRaises(ValueError): FasterRCNNVGG16(**kwargs)
def main(): dataset = VOCBboxDataset(year='2007', split='test') models = [ ('Faster R-CNN', FasterRCNNVGG16(pretrained_model='voc07')), ('SSD300', SSD300(pretrained_model='voc0712')), ('SSD512', SSD512(pretrained_model='voc0712')), ] indices = [29, 301, 189, 229] fig = plt.figure(figsize=(30, 30)) for i, idx in enumerate(indices): for j, (name, model) in enumerate(models): img, _, _ = dataset[idx] bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] ax = fig.add_subplot( len(indices), len(models), i * len(models) + j + 1) vis_bbox( img, bbox, label, score, label_names=voc_bbox_label_names, ax=ax ) # Set MatplotLib parameters ax.set_aspect('equal') if i == 0: font = FontProperties() font.set_family('serif') ax.set_title(name, fontsize=35, y=1.03, fontproperties=font) plt.axis('off') plt.tight_layout() plt.show()
def main(): chainer.config.train = False parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model', default=TRAINED_MODEL_DEFAULT) parser.add_argument('image') args = parser.parse_args() if args.pretrained_model == TRAINED_MODEL_DEFAULT and \ not os.path.exists(TRAINED_MODEL_DEFAULT): download_model.download_model(MODEL_URL, TRAINED_MODEL_DEFAULT) model = FasterRCNNVGG16(n_fg_class=1, pretrained_model=args.pretrained_model) if args.gpu >= 0: model.to_gpu(args.gpu) chainer.cuda.get_device(args.gpu).use() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=('face', )) plot.show()
def setUp(self): proposal_creator_params = { 'n_train_post_nms': self.n_train_post_nms, 'n_test_post_nms': self.n_test_post_nms } self.link = FasterRCNNVGG16( self.n_fg_class, pretrained_model=None, proposal_creator_params=proposal_creator_params)
def get_detector(det_type, model_args): if det_type == 'ssd300': model = SSD300(**model_args) elif det_type == 'ssd512': model = SSD512(**model_args) elif det_type == 'faster': model = FasterRCNNVGG16(**model_args) else: raise NotImplementedError return model
def main(): parser = argparse.ArgumentParser() parser.add_argument('--pretrained_model', default=TRAINED_MODEL_DEFAULT) parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--batchsize', type=int, default=32) args = parser.parse_args() if args.pretrained_model == TRAINED_MODEL_DEFAULT and \ not os.path.exists(TRAINED_MODEL_DEFAULT): download_model.download_model(MODEL_URL, TRAINED_MODEL_DEFAULT) model = FasterRCNNVGG16(n_fg_class=1, pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() model.use_preset('evaluate') #dataset = VOCDetectionDataset( # year='2007', split='test', use_difficult=True, return_difficult=True) dataset = WIDERFACEDataset(WIDER_VAL_DIR, WIDER_VAL_ANNOTATION_MAT, use_difficult=True, return_difficult=True) iterator = iterators.SerialIterator(dataset, args.batchsize, repeat=False, shuffle=False) imgs, pred_values, gt_values = apply_prediction_to_iterator( model.predict, iterator, hook=ProgressHook(len(dataset))) # delete unused iterator explicitly del imgs pred_bboxes, pred_labels, pred_scores = pred_values gt_bboxes, gt_labels, gt_difficults = gt_values ap = eval_detection_voc_ap(pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels, gt_difficults, use_07_metric=True) map_ = np.nanmean(ap) print() print('mAP: {:f}'.format(map_)) for l, name in enumerate(('face', )): if ap[l]: print('{:s}: {:f}'.format(name, ap[l])) else: print('{:s}: -'.format(name))
def set_model(self, n_class=2): """モデルのセット Args: n_class (int, optional): 認識する物体クラスの数. Defaults to 2. """ faster_rcnn = FasterRCNNVGG16(n_fg_class=n_class, pretrained_model="imagenet") faster_rcnn.use_preset("evaluate") model = FasterRCNNTrainChain(faster_rcnn) self.model = model self.logger.info("set FasterRCNNVGG16, pretrained=imagenet")
def main(): chainer.config.train = False parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model', default=TRAINED_MODEL_DEFAULT) parser.add_argument('image') args = parser.parse_args() if args.pretrained_model == TRAINED_MODEL_DEFAULT and \ not os.path.exists(TRAINED_MODEL_DEFAULT): download_model.download_model(MODEL_URL, TRAINED_MODEL_DEFAULT) try: model = FasterRCNNVGG16(n_fg_class=1, pretrained_model=args.pretrained_model) # Workaround for the newer version of chainercv (maybe v0.7.0 and higher) except KeyError: if args.pretrained_model == TRAINED_MODEL_DEFAULT and \ not os.path.exists(TRAINED_MODEL_NEW): download_model.download_model(MODEL_URL_NEW, TRAINED_MODEL_NEW) model = FasterRCNNVGG16(n_fg_class=1, pretrained_model=TRAINED_MODEL_NEW) else: model = FasterRCNNVGG16(n_fg_class=1, pretrained_model=TRAINED_MODEL_NEW) if args.gpu >= 0: model.to_gpu(args.gpu) chainer.cuda.get_device(args.gpu).use() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] # vis_bbox(img, bbox, label, score, label_names=('face',)) vis_bbox(img, bbox) print(bbox) plot.show()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model', default='voc07') parser.add_argument('--output-dir', '-o', default='output_img') parser.add_argument( '--images', '-i', default= '/home/takagi.kazunari/projects/datasets/SUNRGBD_2DBB_fixed/test/image' ) args = parser.parse_args() dataset = SUNRGBDDataset( "/home/takagi.kazunari/projects/datasets/SUNRGBD_2DBB_fixed") sunrgbd_bbox_label_names = dataset.get_dataset_label() model = FasterRCNNVGG16(n_fg_class=len(sunrgbd_bbox_label_names), pretrained_model=args.pretrained_model) if args.pretrained_model == 'voc07': model = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() f_names = glob.glob(osp.join(args.images, "*")) for f_name in tqdm(f_names): img = utils.read_image(osp.join(args.images, f_name), color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] out_f_name = f_name.split("/")[-1] vis_bbox(img, bbox, label, score, label_names=sunrgbd_bbox_label_names) plt.savefig(osp.join(args.output_dir, "res_" + out_f_name))
def __init__(self, gpu, model, nms_thresh= 0.45, score_thresh=0.6): self.gpu = gpu if model == 'yolo_v2_tiny': self.model = YOLOv2Tiny( n_fg_class=len(voc_bbox_label_names), pretrained_model='voc0712') elif model == 'yolo_v3': self.model = YOLOv3( n_fg_class=len(voc_bbox_label_names), pretrained_model='voc0712') elif model == 'ssd300': self.model = SSD300( n_fg_class=len(voc_bbox_label_names), pretrained_model='voc0712') elif model == 'ssd512': self.model = SSD512( n_fg_class=len(voc_bbox_label_names), pretrained_model='voc0712') elif model == 'fasterrcnnvgg16': self.model = FasterRCNNVGG16( n_fg_class=len(coco_bbox_label_names), pretrained_model='voc0712') elif model == 'fasterrcnnfpnresnet50': self.model = FasterRCNNFPNResNet50( n_fg_class=len(coco_bbox_label_names), pretrained_model='coco') elif model == 'fasterrcnnfpnresnet101': self.model = FasterRCNNFPNResNet101( n_fg_class=len(coco_bbox_label_names), pretrained_model='coco') else: self.model = YOLOv2( n_fg_class=len(voc_bbox_label_names), pretrained_model='voc0712') #self.model.nms_thresh = nms_thresh #self.model.score_thresh = score_thresh if self.gpu >= 0: chainer.cuda.get_device_from_id(self.gpu).use() self.model.to_gpu()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('faster_rcnn', 'ssd300', 'ssd512'), default='ssd300') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--batchsize', type=int, default=32) args = parser.parse_args() if args.model == 'faster_rcnn': model = FasterRCNNVGG16(pretrained_model='voc07') elif args.model == 'ssd300': model = SSD300(pretrained_model='voc0712') elif args.model == 'ssd512': model = SSD512(pretrained_model='voc0712') if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() model.use_preset('evaluate') dataset = VOCDetectionDataset(year='2007', split='test', use_difficult=True, return_difficult=True) iterator = iterators.SerialIterator(dataset, args.batchsize, repeat=False, shuffle=False) pred_bboxes, pred_labels, pred_scores, gt_values = \ apply_detection_link(model, iterator, hook=ProgressHook(len(dataset))) gt_bboxes, gt_labels, gt_difficults = gt_values eval_ = eval_detection_voc(pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels, gt_difficults, use_07_metric=True) print() print('mAP: {:f}'.format(eval_['map'])) for l, name in enumerate(voc_detection_label_names): if l in eval_: print('{:s}: {:f}'.format(name, eval_[l]['ap'])) else: print('{:s}: -'.format(name))
def setUp(self): faster_rcnn = FasterRCNNVGG16( n_fg_class=self.n_fg_class, pretrained_model=False) self.link = FasterRCNNTrainChain(faster_rcnn) self.n_bbox = 3 self.bboxes = chainer.Variable( generate_random_bbox(self.n_bbox, (600, 800), 16, 350)[np.newaxis]) _labels = np.random.randint( 0, self.n_fg_class, size=(1, self.n_bbox)).astype(np.int32) self.labels = chainer.Variable(_labels) _imgs = np.random.uniform( low=-122.5, high=122.5, size=(1, 3, 600, 800)).astype(np.float32) self.imgs = chainer.Variable(_imgs) self.scale = chainer.Variable(np.array(1.))
def load_model(self, model_file, n_class=2): """Detectorモデルをロードする Args: model_file (str): モデルファイルパス n_class (int, optional): 認識物体の数. Defaults to 2. """ _ = util.check_file(model_file) model = FasterRCNNVGG16(n_fg_class=n_class, pretrained_model=model_file) if self.gpu >= 0: chainer.cuda.get_device_from_id(self.gpu).use() model.to_gpu() self.logger.info(f"use GPU: {self.gpu}") self.model = model self.model_file = model_file
def get_faster_rcnn(n): frc = FasterRCNNVGG16(n_fg_class=20) model = FasterRCNNTrainChain(frc) batchsize = 1 # only 1 is supported K = 10 x = np.random.uniform(size=(batchsize, 3, n * 512, 512)).astype('f') x = chainer.as_variable(x) bbox = np.random.uniform(size=(batchsize, K, 4)).astype('f') bbox = chainer.as_variable(bbox) labels = np.random.randint(size=(batchsize, K), low=0, high=20)\ .astype(np.int32) labels = chainer.as_variable(labels) scale = np.ones((batchsize, )).astype('f') scale = chainer.as_variable(scale) return [x, bbox, labels, scale], model
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model', default='voc07') parser.add_argument('image') args = parser.parse_args() model = FasterRCNNVGG16(n_fg_class=len(voc_detection_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: model.to_gpu(args.gpu) chainer.cuda.get_device(args.gpu).use() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=voc_detection_label_names) plot.show()
def main(): parser = argparse.ArgumentParser( description='ChainerCV training example: Faster R-CNN') parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--lr', '-l', type=float, default=1e-3) parser.add_argument('--out', '-o', default='result', help='Output directory') parser.add_argument('--seed', '-s', type=int, default=0) parser.add_argument('--step_size', '-ss', type=int, default=50000) parser.add_argument('--iteration', '-i', type=int, default=70000) args = parser.parse_args() np.random.seed(args.seed) train_data = VOCDetectionDataset(split='trainval', year='2007') test_data = VOCDetectionDataset(split='test', year='2007', use_difficult=True, return_difficult=True) faster_rcnn = FasterRCNNVGG16(n_fg_class=len(voc_detection_label_names), pretrained_model='imagenet') faster_rcnn.use_preset('evaluate') model = FasterRCNNTrainChain(faster_rcnn) if args.gpu >= 0: model.to_gpu(args.gpu) chainer.cuda.get_device(args.gpu).use() optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) def transform(in_data): img, bbox, label = in_data _, H, W = img.shape img = faster_rcnn.prepare(img) _, o_H, o_W = img.shape scale = o_H / H bbox = transforms.resize_bbox(bbox, (H, W), (o_H, o_W)) # horizontally flip img, params = transforms.random_flip(img, x_random=True, return_param=True) bbox = transforms.flip_bbox(bbox, (o_H, o_W), x_flip=params['x_flip']) return img, bbox, label, scale train_data = TransformDataset(train_data, transform) train_iter = chainer.iterators.MultiprocessIterator(train_data, batch_size=1, n_processes=None, shared_mem=100000000) test_iter = chainer.iterators.SerialIterator(test_data, batch_size=1, repeat=False, shuffle=False) updater = chainer.training.updater.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.iteration, 'iteration'), out=args.out) trainer.extend(extensions.snapshot_object(model.faster_rcnn, 'snapshot_model.npz'), trigger=(args.iteration, 'iteration')) trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=(args.step_size, 'iteration')) log_interval = 20, 'iteration' plot_interval = 3000, 'iteration' print_interval = 20, 'iteration' trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss', 'main/rpn_cls_loss', 'validation/main/map', ]), trigger=print_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) if extensions.PlotReport.available(): trainer.extend(extensions.PlotReport(['main/loss'], file_name='loss.png', trigger=plot_interval), trigger=plot_interval) trainer.extend( DetectionVOCEvaluator(test_iter, model.faster_rcnn, use_07_metric=True, label_names=voc_detection_label_names), trigger=ManualScheduleTrigger([args.step_size, args.iteration], 'iteration'), invoke_before_training=False) trainer.extend(extensions.dump_graph('main/loss')) trainer.run()
path = '' path2 = '' while not os.path.exists(path): print("Please type text FilePath") path = input(">>") while not os.path.exists(path2): print("Please type Output FilePath \n Default is C:\\DriveRecorder\\test") path2 = input(">>") if path2 == '': path2 = r'C:\DriveRecorder\test' break model = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names), pretrained_model="voc07") chainer.cuda.get_device_from_id(0).use() print("Runing on GPU") model.to_gpu() print('Initialize Complete') while True: f = open(path) before = f.read() f.close() while True: f = open(path) after = f.read() f.close() if before != after:
def main(): bbox_label_names = ('loop') n_itrs = 70000 n_step = 50000 np.random.seed(0) train_data = DefectDetectionDataset(split='train') test_data = DefectDetectionDataset(split='test') proposal_params = {'min_size': 8} faster_rcnn = FasterRCNNVGG16(n_fg_class=1, pretrained_model='imagenet', ratios=[0.5, 1, 2], anchor_scales=[1, 4, 8, 16], min_size=512, max_size=1024, proposal_creator_params=proposal_params) faster_rcnn.use_preset('evaluate') model = FasterRCNNTrainChain(faster_rcnn) chainer.cuda.get_device_from_id(0).use() model.to_gpu() optimizer = chainer.optimizers.MomentumSGD(lr=1e-3, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) train_data = TransformDataset(train_data, Transform(faster_rcnn)) train_iter = chainer.iterators.MultiprocessIterator( train_data, batch_size=1, n_processes=None, shared_mem=100000000) test_iter = chainer.iterators.SerialIterator( test_data, batch_size=1, repeat=False, shuffle=False) updater = chainer.training.updater.StandardUpdater( train_iter, optimizer, device=0) trainer = training.Trainer( updater, (n_itrs, 'iteration'), out='result') trainer.extend( extensions.snapshot_object(model.faster_rcnn, 'snapshot_model_{.updater.iteration}.npz'), trigger=(n_itrs/5, 'iteration')) trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=(n_step, 'iteration')) log_interval = 50, 'iteration' plot_interval = 100, 'iteration' print_interval = 20, 'iteration' trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.PrintReport( ['iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss', 'main/rpn_cls_loss', 'validation/main/map', ]), trigger=print_interval) trainer.extend(extensions.ProgressBar(update_interval=5)) if extensions.PlotReport.available(): trainer.extend( extensions.PlotReport( ['main/loss'], file_name='loss.png', trigger=plot_interval ), trigger=plot_interval ) trainer.extend( DetectionVOCEvaluator( test_iter, model.faster_rcnn, use_07_metric=True, label_names=bbox_label_names), trigger=ManualScheduleTrigger( [100, 500, 1000, 5000, 10000, 20000, 40000, 60000, n_step, n_itrs], 'iteration')) trainer.extend(extensions.dump_graph('main/loss')) trainer.run()
root = '../data/3Types/Data3TypesYminXminYmaxXmax' #print(os.listdir(root)) dataset_test = MultiDefectDetectionDataset(data_dir=root, split='validation2') bbox_label_names = ('111', 'dot','100') # DataSet Statistics print('total number of training images: ', len(dataset)) print('total number of test images: ', len(dataset_test)) print('type of defects: ', bbox_label_names) # predict figures using new methods use_gpu = False#True proposal_params = {'min_size': 8,'nms_thresh': 0.5} model = FasterRCNNVGG16(n_fg_class=3, pretrained_model='../BestWeight.npz', ratios=[ 0.5, 1, 1.5, 2, 2.5, 4,8,16],anchor_scales=[1, 4, 8, 16], min_size=1024, max_size=1024,proposal_creator_params=proposal_params) if use_gpu: chainer.cuda.get_device_from_id(0).use() model.to_gpu() bbox_label_names = ('111loop', 'dot', '100loop') thetaList = [0.001,0.005,0.01,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6] IoUList = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9] for iou_i in IoUList: os.mkdir(str(iou_i)) Plist = [] Rlist = []
def eval(self): pred_bboxes,pred_labels,pred_scores,gt_bboxes,gt_labels = [],[],[],[],[] if self.loadfrom: pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels = self.backuper.load( self.loadfrom) print("The lists have been loaded with {} objects.".format( len(pred_bboxes))) else: if self.model == 'faster_rcnn': if self.pretrained_model: model = FasterRCNNVGG16( n_fg_class=20, pretrained_model=self.pretrained_model) else: model = FasterRCNNVGG16(pretrained_model='voc07') elif self.model == 'ssd300': if self.pretrained_model: model = SSD300(n_fg_class=20, pretrained_model=self.pretrained_model) else: model = SSD300(pretrained_model='voc0712') elif self.model == 'ssd512': if self.pretrained_model: model = SSD512(n_fg_class=20, pretrained_model=self.pretrained_model) else: model = SSD512(pretrained_model='voc0712') if self.gpu >= 0: chainer.cuda.get_device_from_id(self.gpu).use() model.to_gpu() model.use_preset('evaluate') # dataset = VOCBboxDataset( # year='2007', split='test', use_difficult=True, return_difficult=True) dataset = PTI01BboxDataset(limit=self.limit, imagespath=self.imagespath, labelspath=self.labelspath) iterator = iterators.SerialIterator(dataset, self.batchsize, repeat=False, shuffle=False) imgs, pred_values, gt_values = apply_prediction_to_iterator( model.predict, iterator, hook=ProgressHook(len(dataset))) # delete unused iterator explicitly del imgs pred_bboxes, pred_labels, pred_scores = pred_values gt_bboxes, gt_labels = gt_values pred_bboxes = list(pred_bboxes) pred_labels = list(pred_labels) pred_scores = list(pred_scores) gt_bboxes = list(gt_bboxes) gt_labels = list(gt_labels) self.backuper.save( self.model, 'pti01', len(dataset), (pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels)) if (len(gt_bboxes) == 0): print('Warning: gt_bboxes is empty') gt_bboxes, gt_label = [], [] # print('{} {} {} {} {}'.format(len(pred_bboxes),len(pred_labels),len(pred_scores),len(gt_bboxes),len(gt_labels))) metrics = PTI01Metrics( (pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels), model=self.model, metric=self.metric, database_name='PTI01', limit=self.limit, plottings=self.plot) metrics.calc()
def main(): parser = argparse.ArgumentParser( description='ChainerCV training example: Faster R-CNN') parser.add_argument( '--dataset_path', '-path', type=str, default="/home/takagi.kazunari/projects/datasets/SUNRGBD_2DBB_fixed") parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--lr', '-l', type=float, default=1e-3) parser.add_argument('--out', '-o', default='sunrgbd_result', help='Output directory') parser.add_argument('--seed', '-s', type=int, default=0) parser.add_argument('--step_size', '-ss', type=int, default=50000) parser.add_argument('--iteration', '-i', type=int, default=70000) args = parser.parse_args() np.random.seed(args.seed) train_data = SUNRGBDDataset(args.dataset_path, mode="train") test_data = SUNRGBDDataset(args.dataset_path, mode="test") sunrgbd_bbox_label_names = train_data.get_dataset_label() faster_rcnn = FasterRCNNVGG16(n_fg_class=len(sunrgbd_bbox_label_names), pretrained_model='imagenet') faster_rcnn.use_preset('evaluate') model = FasterRCNNTrainChain(faster_rcnn) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005)) train_data = TransformDataset(train_data, Transform(faster_rcnn)) train_iter = chainer.iterators.MultiprocessIterator(train_data, batch_size=1, n_processes=None, shared_mem=100000000) test_iter = chainer.iterators.SerialIterator(test_data, batch_size=1, repeat=False, shuffle=False) updater = chainer.training.updaters.StandardUpdater(train_iter, optimizer, device=args.gpu) now_time = str(datetime.datetime.today()).replace(" ", "_") save_dir = osp.join(args.out, now_time) trainer = training.Trainer(updater, (args.iteration, 'iteration'), out=save_dir) #save_iteration = [i for i in range(100, args.iteration, args.step_size)] weight_save_interval = 5000, 'iteration' evaluation_interval = 10000, 'iteration' trainer.extend(extensions.snapshot_object( model.faster_rcnn, 'sunrgbd_model_{.updater.iteration}.npz'), trigger=weight_save_interval) trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=(args.step_size, 'iteration')) log_interval = 20, 'iteration' plot_interval = 10, 'iteration' print_interval = 20, 'iteration' trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss', 'main/rpn_cls_loss', 'validation/main/map', ]), trigger=print_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) if extensions.PlotReport.available(): trainer.extend(extensions.PlotReport(['main/loss'], file_name='loss.png', trigger=plot_interval), trigger=plot_interval) #do_evaluation_iteration = [i for i in range(0, args.iteration, 500)] trainer.extend(DetectionVOCEvaluator(test_iter, model.faster_rcnn, use_07_metric=True, label_names=sunrgbd_bbox_label_names), trigger=evaluation_interval) trainer.extend(extensions.dump_graph('main/loss')) trainer.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('faster_rcnn', 'ssd300', 'ssd512', 'yolo_v3'), default='ssd300') parser.add_argument('--pretrained_model') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--batchsize', type=int, default=32) args = parser.parse_args() if args.model == 'faster_rcnn': if args.pretrained_model: model = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) else: model = FasterRCNNVGG16(pretrained_model='voc07') elif args.model == 'ssd300': if args.pretrained_model: model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) else: model = SSD300(pretrained_model='voc0712') elif args.model == 'ssd512': if args.pretrained_model: model = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) else: model = SSD512(pretrained_model='voc0712') elif args.model == 'yolo_v3': if args.pretrained_model: model = YOLOv3(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) else: model = YOLOv3(pretrained_model='voc0712') if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() model.use_preset('evaluate') dataset = VOCBboxDataset(year='2007', split='test', use_difficult=True, return_difficult=True) iterator = iterators.SerialIterator(dataset, args.batchsize, repeat=False, shuffle=False) in_values, out_values, rest_values = apply_to_iterator(model.predict, iterator, hook=ProgressHook( len(dataset))) # delete unused iterators explicitly del in_values pred_bboxes, pred_labels, pred_scores = out_values gt_bboxes, gt_labels, gt_difficults = rest_values result = eval_detection_voc(pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels, gt_difficults, use_07_metric=True) print() print('mAP: {:f}'.format(result['map'])) for l, name in enumerate(voc_bbox_label_names): if result['ap'][l]: print('{:s}: {:f}'.format(name, result['ap'][l])) else: print('{:s}: -'.format(name))
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batchsize', type=int, default=1) parser.add_argument('--lr', type=float, default=1e-3) parser.add_argument('--out', default='result') parser.add_argument('--resume') args = parser.parse_args() comm = chainermn.create_communicator() device = comm.intra_rank faster_rcnn = FasterRCNNVGG16( n_fg_class=len(epic_kitchens_bbox_label_names), pretrained_model='imagenet') faster_rcnn.use_preset('evaluate') model = FasterRCNNTrainChain(faster_rcnn) chainer.cuda.get_device_from_id(device).use() model.to_gpu() train = EpicKitchensBboxDataset(year='2018', split='train') if comm.rank == 0: indices = np.arange(len(train)) else: indices = None train = TransformDataset(train, ('img', 'bbox', 'label', 'scale'), Transform(faster_rcnn)) indices = chainermn.scatter_dataset(indices, comm, shuffle=True) train = train.slice[indices] train_iter = chainer.iterators.SerialIterator(train, batch_size=args.batchsize) optimizer = chainermn.create_multi_node_optimizer( chainer.optimizers.MomentumSGD(), comm) optimizer.setup(model) optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005)) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=device) trainer = training.Trainer(updater, (18, 'epoch'), args.out) trainer.extend(extensions.ExponentialShift('lr', 0.1, init=args.lr), trigger=triggers.ManualScheduleTrigger([12, 15], 'epoch')) if comm.rank == 0: log_interval = 10, 'iteration' trainer.extend( extensions.LogReport(log_name='log.json', trigger=log_interval)) trainer.extend(extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss', 'main/rpn_cls_loss' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=1)) trainer.extend(extensions.snapshot_object( model.faster_rcnn, 'model_iter_{.updater.iteration}.npz'), trigger=(1, 'epoch')) if args.resume: serializers.load_npz(args.resume, trainer) trainer.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--no-display', action='store_true') parser.add_argument('--model', choices=('ssd300', 'ssd512', 'faster-rcnn-vgg16'), default='faster-rcnn-vgg16') parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--pretrained_model', choices=('voc0712', 'voc07'), default='voc0712') parser.add_argument('--year', '-y', choices=('2015', '2016', '2017'), default='2015') parser.add_argument('--sequence-map', '-s', default=None) args = parser.parse_args() if args.sequence_map is None: if args.year == '2015': seqmap_name = 'c2-test' elif args.year == '2016': seqmap_name = 'c5-test' elif args.year == '2017': seqmap_name = 'c9-test' map_name, split = seqmap_name.split('-') if split == 'test': split = 'val' sequences = get_sequences(split, map_name) if args.model == 'ssd300': detector = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'ssd512': detector = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'faster-rcnn-vgg16': detector = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) detector.use_preset('evaluate') detector.score_thresh = 0.5 if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() detector.to_gpu() sort_label_names = ['person'] if not args.no_display: plt.ion() fig = plt.figure() for seq in sequences: if args.no_display: ax = fig.add_subplot(111, aspect='equal') dataset = MOTDataset(year=args.year, split=split, sequence=seq) model = SORTMultiObjectTracking(detector, voc_bbox_label_names, sort_label_names) print('Sequence: {}'.format(seq)) cycle_times = [] for i in range(len(dataset)): img, _, _ = dataset[i] start_time = time.time() bboxes, labels, scores, inst_ids = model.predict([img]) cycle_time = time.time() - start_time cycle_times.append(cycle_time) if args.no_display: bbox = bboxes[0] inst_id = inst_ids[0] label = labels[0] score = scores[0] vis_tracking_bbox(img, bbox, inst_id, label, score, label_names=voc_bbox_label_names, ax=ax) fig.canvas.flush_events() plt.draw() ax.cla() cycle_times = np.array(cycle_times) print('total time: {}'.format(np.sum(cycle_times))) print('average time: {}'.format(np.average(cycle_times)))
def main(): parser = argparse.ArgumentParser() parser.add_argument('--pretrained-model', default='imagenet') parser.add_argument('--batch-size', type=int, default=1) parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--no-display', action='store_true') parser.add_argument('--shuffle', action='store_true') parser.add_argument('--save-path', type=str, default=None) parser.add_argument('--split', choices=('train', 'val'), default='val') parser.add_argument('--skip', action='store_true') parser.add_argument('--score-thresh', type=float, default=0.6) args = parser.parse_args() model = FasterRCNNVGG16(n_fg_class=len(epic_kitchens_bbox_label_names), pretrained_model=args.pretrained_model) model.score_thresh = args.score_thresh if args.gpu >= 0: cuda.get_device_from_id(args.gpu).use() model.to_gpu() dataset = EpicKitchensBboxDataset(split=args.split) dataset_iter = chainer.iterators.SerialIterator(dataset, args.batch_size, shuffle=args.shuffle, repeat=False) dataset_iter.reset() if dataset_iter._order is None: indices = dataset.ids else: indices = dataset_iter._order for batch_data in dataset_iter: imgs = [] for data in batch_data: img, _, _ = data imgs.append(img) bboxes, labels, scores = model.predict(imgs) base_index = dataset_iter.current_position - args.batch_size for b_i in range(args.batch_size): img = imgs[b_i] bbox, label, score = bboxes[b_i], labels[b_i], scores[b_i] if args.skip: if len(bbox) == 0: print('skip {}.jpg'.format(indices[base_index + b_i])) continue vis_bbox(img, bbox, label, score, label_names=epic_kitchens_bbox_label_names) if args.save_path is not None: save_path = os.path.join(thisdir, args.save_path) if not os.path.exists(save_path): os.makedirs(save_path) plt.savefig( os.path.join( save_path, '{}.png'.format(dataset.ids[base_index + b_i].replace( '/', '_')))) if not args.no_display: plt.show()
from chainercv.extensions import DetectionVOCEvaluator from chainercv.links import FasterRCNNVGG16 from chainercv.links.model.faster_rcnn import FasterRCNNTrainChain from chainercv import transforms from wider_face_dataset import WIDERFACEDataset # dataset paths WIDER_TRAIN_DIR = 'WIDER_train' WIDER_TRAIN_ANNOTATION_MAT = 'wider_face_split/wider_face_train.mat' WIDER_VAL_DIR = 'WIDER_val' WIDER_VAL_ANNOTATION_MAT = 'wider_face_split/wider_face_val.mat' BLACKLIST_FILE = 'blacklist.txt' faster_rcnn = FasterRCNNVGG16(n_fg_class=1, pretrained_model='imagenet') #min_size=600, max_size=1000,) def transform(in_data): img, bbox, label = in_data _, H, W = img.shape img = faster_rcnn.prepare(img) _, o_H, o_W = img.shape scale = o_H / H bbox = transforms.resize_bbox(bbox, (H, W), (o_H, o_W)) # horizontally flip img, params = transforms.random_flip( img, x_random=True, return_param=True) bbox = transforms.flip_bbox( bbox, (o_H, o_W), x_flip=params['x_flip'])
def main(): parser = argparse.ArgumentParser( description='ChainerCV training example: Faster R-CNN') parser.add_argument('--dataset', choices=('voc07', 'voc0712'), help='The dataset to use: VOC07, VOC07+12', default='voc07') parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--lr', '-l', type=float, default=1e-3) parser.add_argument('--out', '-o', default='result', help='Output directory') parser.add_argument('--seed', '-s', type=int, default=0) parser.add_argument('--step_size', '-ss', type=int, default=50000) parser.add_argument('--iteration', '-i', type=int, default=70000) args = parser.parse_args() np.random.seed(args.seed) if args.dataset == 'voc07': train_data = VOCBboxDataset(split='trainval', year='2007') elif args.dataset == 'voc0712': train_data = ConcatenatedDataset( VOCBboxDataset(year='2007', split='trainval'), VOCBboxDataset(year='2012', split='trainval')) test_data = VOCBboxDataset(split='test', year='2007', use_difficult=True, return_difficult=True) faster_rcnn = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet') faster_rcnn.use_preset('evaluate') model = FasterRCNNTrainChain(faster_rcnn) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005)) train_data = TransformDataset(train_data, Transform(faster_rcnn)) train_iter = chainer.iterators.MultiprocessIterator(train_data, batch_size=1, n_processes=None, shared_mem=100000000) test_iter = chainer.iterators.SerialIterator(test_data, batch_size=1, repeat=False, shuffle=False) updater = chainer.training.updaters.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.iteration, 'iteration'), out=args.out) trainer.extend(extensions.snapshot_object(model.faster_rcnn, 'snapshot_model.npz'), trigger=(args.iteration, 'iteration')) trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=(args.step_size, 'iteration')) log_interval = 20, 'iteration' plot_interval = 3000, 'iteration' print_interval = 20, 'iteration' trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss', 'main/rpn_cls_loss', 'validation/main/map', ]), trigger=print_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) if extensions.PlotReport.available(): trainer.extend(extensions.PlotReport(['main/loss'], file_name='loss.png', trigger=plot_interval), trigger=plot_interval) trainer.extend(DetectionVOCEvaluator(test_iter, model.faster_rcnn, use_07_metric=True, label_names=voc_bbox_label_names), trigger=ManualScheduleTrigger( [args.step_size, args.iteration], 'iteration')) trainer.extend(extensions.dump_graph('main/loss')) trainer.run()
def calc_features(img_dirs, feature_names): """ calculates all features given by feature_names :param img_dirs: a list of image paths :type img_dirs: list :param feature_names: a list containing all feature names :type feature_names: list :return: dict (img_dir, features) features is also a dict (feature_name, feature vector) :rtype: dict """ features = {} dir_haarfeatures = os.path.join(os.getcwd(), 'res', 'haarcascades') face_frontal_cascade = cv2.CascadeClassifier(os.path.join(dir_haarfeatures, 'haarcascade_frontalface_default.xml')) face_profile_cascade = cv2.CascadeClassifier(os.path.join(dir_haarfeatures, 'haarcascade_profileface.xml')) model = FasterRCNNVGG16(pretrained_model='voc07') for img_dir in img_dirs: print 'calc features for: ' + img_dir img = read_img(img_dir) features[img_dir] = dict() #init features dict for each image for name in feature_names: if TU_feature_file_exists(img_dir, name): continue if name == Features.Face_count or name == Features.Rot_distance or name == Features.Face_bb: face_count, rot_distance, face_bb = face_detection(img, face_frontal_cascade, face_profile_cascade) feature_files.save_features(img_dir, Features.Face_count, face_count) feature_files.save_features(img_dir, Features.Rot_distance, rot_distance) feature_files.save_features(img_dir, Features.Face_bb, face_bb) features[img_dir][Features.Face_count] = face_count features[img_dir][Features.Rot_distance] = rot_distance features[img_dir][Features.Face_bb] = face_bb elif name == Features.Face_bb_full_img: feature = _face_bb_full_img_calculator(img, face_frontal_cascade, face_profile_cascade) feature_files.save_features(img_dir, Features.Face_bb_full_img, feature) features[img_dir][Features.Face_bb_full_img] = feature elif name == Features.Face_bb_quarter_imgs: feature = _face_bb_quarter_imgs_calculator(img, face_frontal_cascade, face_profile_cascade) feature_files.save_features(img_dir, Features.Face_bb_quarter_imgs, feature) features[img_dir][Features.Face_bb_quarter_imgs] = feature elif name == Features.Face_bb_eighth_imgs: feature = _face_bb_eighth_imgs_calculator(img, face_frontal_cascade, face_profile_cascade) feature_files.save_features(img_dir, Features.Face_bb_eighth_imgs, feature) features[img_dir][Features.Face_bb_eighth_imgs] = feature elif name == Features.Tilted_edges: feature = _img_tilted_calculator(img) feature_files.save_features(img_dir, Features.Tilted_edges, feature) features[img_dir][Features.Tilted_edges] = feature elif name == Features.Edge_hist_v0: feature = _edge_hist_dir_calculator(img, False, False) feature_files.save_features(img_dir, Features.Edge_hist_v0, feature) features[img_dir][Features.Edge_hist_v0] = feature elif name == Features.Edge_hist_v1: feature = _edge_hist_dir_calculator(img, True, True) feature_files.save_features(img_dir, Features.Edge_hist_v1, feature) features[img_dir][Features.Edge_hist_v1] = feature elif name == Features.Edge_hist_v2: feature = _edge_hist_dir_calculator(img, True, False) feature_files.save_features(img_dir, Features.Edge_hist_v2, feature) features[img_dir][Features.Edge_hist_v2] = feature elif name == Features.Symmetry: feature = _symmetry_calculator(img, model) feature_files.save_features(img_dir, Features.Symmetry, feature) features[img_dir][Features.Symmetry] = feature # precalculated features elif name == Features.Hsv_hist: feature = load_precalc_feature(img_dir, Features.Hsv_hist) feature_files.save_features(img_dir, Features.Hsv_hist, feature) features[img_dir][Features.Hsv_hist] = feature elif name == Features.DenseSIFT_L0: feature = load_precalc_feature(img_dir, Features.DenseSIFT_L0) feature_files.save_features(img_dir, Features.DenseSIFT_L0, feature) features[img_dir][Features.DenseSIFT_L0] = feature elif name == Features.DenseSIFT_L1: feature = load_precalc_feature(img_dir, Features.DenseSIFT_L1) feature_files.save_features(img_dir, Features.DenseSIFT_L1, feature) features[img_dir][Features.DenseSIFT_L1] = feature elif name == Features.DenseSIFT_L2: feature = load_precalc_feature(img_dir, Features.DenseSIFT_L2) feature_files.save_features(img_dir, Features.DenseSIFT_L2, feature) features[img_dir][Features.DenseSIFT_L2] = feature elif name == Features.Hog_L0: feature = load_precalc_feature(img_dir, Features.Hog_L0) feature_files.save_features(img_dir, Features.Hog_L0, feature) features[img_dir][Features.Hog_L0] = feature elif name == Features.Hog_L1: feature = load_precalc_feature(img_dir, Features.Hog_L1) feature_files.save_features(img_dir, Features.Hog_L1, feature) features[img_dir][Features.Hog_L1] = feature elif name == Features.Hog_L2: feature = load_precalc_feature(img_dir, Features.Hog_L2) feature_files.save_features(img_dir, Features.Hog_L2, feature) features[img_dir][Features.Hog_L2] = feature elif name == Features.Lbp_L0: feature = load_precalc_feature(img_dir, Features.Lbp_L0) feature_files.save_features(img_dir, Features.Lbp_L0, feature) features[img_dir][Features.Lbp_L0] = feature elif name == Features.Lbp_L1: feature = load_precalc_feature(img_dir, Features.Lbp_L1) feature_files.save_features(img_dir, Features.Lbp_L1, feature) features[img_dir][Features.Lbp_L1] = feature elif name == Features.Lbp_L2: feature = load_precalc_feature(img_dir, Features.Lbp_L2) feature_files.save_features(img_dir, Features.Lbp_L2, feature) features[img_dir][Features.Lbp_L2] = feature elif name == Features.Gist: feature = load_precalc_feature(img_dir, Features.Gist) feature_files.save_features(img_dir, Features.Gist, feature) features[img_dir][Features.Gist] = feature elif name == Features.CNN_fc7: feature = load_precalc_feature(img_dir, Features.CNN_fc7) feature_files.save_features(img_dir, Features.CNN_fc7, feature) features[img_dir][Features.CNN_fc7] = feature elif name == Features.CNN_prob: feature = load_precalc_feature(img_dir, Features.CNN_prob) feature_files.save_features(img_dir, Features.CNN_prob, feature) features[img_dir][Features.CNN_prob] = feature else: raise NotImplementedError return features
import download_model WIDER_VAL_DIR = '/Volumes/D../image pocess/WIDER_test' WIDER_VAL_ANNOTATION_MAT = '/Users/YEH/Downloads/chainercv-fasterrcnn-widerface-master/wider_face_split/wider_face_val.mat' # trained model MODELFILE = 'result/snapshot_model.npz' mat = scipy.io.loadmat(WIDER_VAL_ANNOTATION_MAT) #dict_keys(['pose_label_list', 'event_list', 'file_list', '__header__', '__version__', 'invalid_label_list', 'illumination_label_list', '__globals__', 'occlusion_label_list', 'face_bbx_list', 'blur_label_list', 'expression_label_list']) if not os.path.exists(MODELFILE): download_model.download_model('http://nixeneko.2-d.jp/hatenablog/20170724_facedetection_model/snapshot_model.npz', MODELFILE) model = FasterRCNNVGG16( n_fg_class=1, pretrained_model=MODELFILE) parser = argparse.ArgumentParser( description='view detection test on validation dataset') parser.add_argument('--gpu', '-g', type=int, default=-1) args = parser.parse_args() if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu(args.gpu) for i in range(len(mat['event_list'])): event = mat['event_list'][i,0][0] for j in range(len(mat['file_list'][i,0])): file = mat['file_list'][i,0][j,0][0]