def main(): chainer.config.train = False parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model') parser.add_argument('image') parser.add_argument('--label_names', help='The path to the file with label names') args = parser.parse_args() with open(args.label_names, 'r') as f: label_names = f.read().splitlines() model = SSD300(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) model.nms_thresh = 0.45 model.score_thresh = 0.3 bboxes, labels, scores = model.predict([img]) print((bboxes, labels, scores)) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=label_names) plot.show()
def main(): chainer.config.train = False parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model') parser.add_argument('image') parser.add_argument( '--label_names', help='The path to the yaml file with label names') args = parser.parse_args() with open(args.label_names, 'r') as f: label_names = tuple(yaml.load(f)) model = SSD300( n_fg_class=len(label_names), pretrained_model=args.pretrained_model) # Change the threshold for showing labels #model.score_thresh=0.55 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] nb_containers = sum([1 for l in label if label_names[int(l)] == 'container']) a = vis_bbox( img, bbox, label, score, label_names=label_names) a.annotate("Number of containers = {}".format(nb_containers), xytext=(0,0), xy=(0,0)) plot.show()
def __init__(self): super(SSDObjectDetector, self).__init__() self.gpu = rospy.get_param("~gpu", -1) self.classifier_name = rospy.get_param("~classifier_name", rospy.get_name()) self.cv_bridge = CvBridge() # load model self.label_names = self.load_label_names() rospy.loginfo("Loaded %d labels" % len(self.label_names)) # model_path: name of pretrained model or path to model file model_path = rospy.get_param("~model_path", None) self.model = SSD300(n_fg_class=len(self.label_names), pretrained_model=model_path) if self.gpu >= 0: self.model.to_gpu(self.gpu) rospy.loginfo("Loaded model: %s" % model_path) # dynamic reconfigure self.srv = Server(Config, self.config_callback) # advertise self.pub_rects = self.advertise("~output/rect", RectArray, queue_size=1) self.pub_class = self.advertise("~output/class", ClassificationResult, queue_size=1) self.pub_image = self.advertise("~output/image", Image, queue_size=1)
def model_fn(model_dir): """ This function is called by the Chainer container during hosting when running on SageMaker with values populated by the hosting environment. Here, we load the pre-trained model's weights. `voc_bbox_label_names` contains label names, and `SSD300` defines the network architecture. We pass in the number of labels and the path to the model for `SSD300` to load. Args: model_dir (str): path to the directory containing the saved model artifacts Returns: a loaded Chainer model For more on `model_fn` and `save`, please visit the sagemaker-python-sdk repository: https://github.com/aws/sagemaker-python-sdk For more on the Chainer container, please visit the sagemaker-chainer-containers repository: https://github.com/aws/sagemaker-chainer-containers """ # Loads a pretrained SSD model. chainer.config.train = False path = os.path.join(model_dir, 'ssd_model.npz') model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model=path) return model
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(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model', default='voc0712') parser.add_argument('image') args = parser.parse_args() if args.model == 'ssd300': model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'ssd512': model = SSD512(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() 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_bbox_label_names) plt.show()
def setUp(self): if self.insize == 300: self.link = SSD300(n_fg_class=self.n_fg_class) self.n_bbox = 8732 elif self.insize == 512: self.link = SSD512(n_fg_class=self.n_fg_class) self.n_bbox = 24564
def annotate(args, path_in, path_out): chainer.config.train = False with open("model/label_names_coco_container.yml", 'r') as f: label_names = tuple(yaml.load(f)) model = SSD300( n_fg_class=len(label_names), pretrained_model=args.model) # Change the threshold for showing labels # model.score_thresh=0.4 # model.nms_thres = args.threshold count = 1 numfiles = len([f for f in os.listdir(path_in) if ".jpg" in f]) for file in [f for f in os.listdir(path_in) if ".jpg" in f]: img = utils.read_image(path_in+file, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] nb_containers = sum([1 for l in label if label_names[int(l)] == 'container']) a = vis_bbox( img, bbox, label, score, label_names=label_names) a.annotate("Number of containers = {}".format(nb_containers), xytext=(0, 0), xy=(0, 0)) plot.axis('off') plot.savefig(path_out + "frame{}.png".format(str(count).zfill(5)), bbox_inches='tight') plot.close() if count % 10 == 0: print("Progress: %0.2f%%" % (count / numfiles * 100,), flush=True) count += 1
def main(): args = argparser() if not os.path.isdir(args.output_dir): os.makedirs(args.output_dir) else: print('output dir is exist.') exit() print('loading labels...') bbox_label_names = load_bbox_label_names() print(bbox_label_names) print('----') print('loading model...') chainer.config.train = False if args.model == 'ssd300': model = SSD300(n_fg_class=len(bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'ssd512': model = SSD512(n_fg_class=len(bbox_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() print('loading images...') jpg_list = glob.glob(os.path.join(args.image_dir, '*.jpg')) for i, jpg_name in enumerate(jpg_list): print('{}/{} {}'.format(i + 1, len(jpg_list), jpg_name)) # object detection img = utils.read_image(jpg_name, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] str_label = [bbox_label_names[n] for n in label] # create_output_dir and name filename = os.path.split(jpg_name)[1] output_dir = os.path.split(jpg_name)[0].replace( args.image_dir, args.output_dir) if not os.path.isdir(output_dir): os.makedirs(output_dir) output_name = os.path.join(output_dir, (os.path.splitext(filename)[0] + '.xml')) # output xml if args.no_copy: full_name = os.path.abspath(jpg_name) else: output_jpg_name = os.path.join(output_dir, filename) full_name = os.path.abspath(output_jpg_name) shutil.copyfile(jpg_name, output_jpg_name) img_size = IMAGE_SIZE(img.shape[1], img.shape[2], img.shape[0]) create_pascalVOC(full_name, img_size, str_label, bbox, output_name)
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 __init__(self, model="ssd300", gpu=-1, pretrained_model="voc0712"): if model == "ssd300": self.model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model=pretrained_model) elif model == "ssd512": self.model = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model=pretrained_model) if gpu >= 0: chainer.cuda.get_device_from_id(gpu).use() self.model.to_gpu()
def __init__(self, trained_model, gpu=-1): try: self.model = SSD300( n_fg_class=len(LABEL_NAMES), pretrained_model=trained_model) if gpu >= 0: chainer.cuda.get_device_from_id(gpu).use() self.model.to_gpu() except: print('Could not load model')
def __init__(self, model_file_path=None, score_thresh=0.4): if model_file_path is None: data_directory = rospy.get_param('~data_directory') model_file_path = os.path.join(data_directory, _ssd300_coco_file_path) n_fg_class = len(coco_bbox_label_names) self.model = SSD300(n_fg_class=n_fg_class, pretrained_model=model_file_path) self.model.use_preset('evaluate') self.model.score_thresh = score_thresh
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 runRCNN(): startTime = time.time() #print(startTime) # Read an RGB image and return it in CHW format. img = read_image('sample7.jpg') model = SSD300(pretrained_model='voc0712') model1 = SSD512(pretrained_model='voc0712') bboxes, labels, scores = model1.predict([img]) vis_bbox(img, bboxes[0], labels[0], scores[0], label_names=voc_bbox_label_names) print(time.time() - startTime)
def callback(): label_name = ("tops", "bottoms") model = SSD300(n_fg_class=len(label_name), pretrained_model='via_model') # get request body as text stream = request.files["imageFile"].stream # return make_response(jsonify({'result': stream})) img = np.asarray(bytearray(stream.read()), dtype=np.uint8) img = cv2.imdecode(img, 1) clum = {} bboxes, labels, scores = model.predict([img.transpose(2, 0, 1)]) for bbox, label in zip(bboxes[0], labels[0]): label_index = label_name[label] clum[label_index] = [int(item) for item in bbox] return json.dumps(clum)
def __init__(self): self.bridge = CvBridge() print("モデル読み込み中...") self.model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model="voc0712") print("読み込み完了") self.imagesub = rospy.Subscriber(params.image_topic, Image, self.imageCB) self.image_pub = rospy.Publisher(params.result_topic, Image) self.stock_img = np.zeros((300, 300, 3), np.uint8) if params.gpu > 0: chainer.cuda.get_device_from_id(params.gpu).use() model.to_gpu()
def main(): args = arg() chainer.config.train = False model = SSD300( n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model ) if args.gpu >= 0: model.to_gpu(args.gpu) chainer.cuda.get_device(args.gpu).use() ws = WeightServer(host=args.host, port=args.port, model=model) ws.run()
def setup_model(param, model_type="ssd512", gpu=-1): if model_type == 'ssd300': model = SSD300(n_fg_class=len(MOT16Dataset.class_map), pretrained_model='imagenet') elif model_type == 'ssd512': model = SSD512(n_fg_class=len(MOT16Dataset.class_map), pretrained_model='imagenet') model.use_preset('evaluate') if gpu >= 0: chainer.cuda.get_device_from_id(gpu).use() model.to_gpu() serializers.load_hdf5(param, model) return model
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained', default='./models/model_iter_12000.npz') args = parser.parse_args() label_names = pose_bbox_label_names BboxDataset = PoseBboxDataset if args.model == 'ssd300': model = SSD300(n_fg_class=len(label_names), pretrained_model=args.pretrained) elif args.model == 'ssd512': model = SSD512(n_fg_class=len(label_names), pretrained_model=args.pretrained) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() for i in range(0, 10): dataset = BboxDataset(split='test') ori_img, ori_bbox, ori_label = dataset[i] pred_bbox, pred_labels, pred_scores = model.predict([ori_img]) fig = plt.figure(figsize=(20, 10), dpi=80) fig.suptitle("Original vs Prediction Annotations", fontsize=32) ax1 = fig.add_subplot(1, 2, 1) ax1.set_xlabel("Original", fontsize=24) ax2 = fig.add_subplot(1, 2, 2) ax2.set_xlabel("Prediction", fontsize=24) vis_bbox(ori_img, ori_bbox, ori_label, label_names=label_names, ax=ax1) vis_bbox(ori_img, pred_bbox[0], pred_labels[0], pred_scores[0], label_names=label_names, ax=ax2) plt.tight_layout() plt.savefig('visualization/compare-{}.png'.format(i))
def item_detection(img_file): """ Recieve a image file for detection. Return detected data to create 'Item' model :param img_file: :return: bbox, name, score """ chainer.config.train = False # Define the detection model model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model='voc0712') img = utils.read_image(img_file, color=True) bboxes, labels, scores = model.predict([img]) bbox, name, score = bboxes[0], labels[0], scores[0] return name, score
def runSSD(): aimage = 'sample7.jpg' amodel = 'ssd300' apretrained_model = 'voc0712' agpu = -1 if amodel == 'ssd300': model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model=apretrained_model) elif amodel == 'ssd512': model = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model=apretrained_model) if agpu >= 0: chainer.cuda.get_device_from_id(agpu).use() model.to_gpu() img = utils.read_image(aimage, 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_bbox_label_names)
def demo(args): chainer.config.train = False with open(args.label_names, 'r') as f: label_names = tuple(yaml.load(f)) model = SSD300(n_fg_class=len(label_names), pretrained_model=args.pretrained_model) # Change the threshold for showing labels #model.score_thresh=0.4 model.nms_thres = args.threshold bbox = np.full(4, np.nan) label = np.full(1, np.nan).astype(int) score = np.full(1, np.nan) img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) for i, l in enumerate(labels[0]): if label_names[l] in ['container', 'truck', 'ship']: bbox = np.vstack([bbox, bboxes[0][i]]) label = np.append(label, int(labels[0][i])) score = np.append(score, scores[0][i]) #bbox, label, score = bboxes[0], labels[0], scores[0] bbox = np.array(pd.DataFrame(bbox).dropna()) label = np.asarray([h for h in label if not h == -2147483648]) score = np.asarray([h for h in score if not np.isnan(h)]) nb_containers = sum( [1 for l in label if label_names[int(l)] == 'container']) a = vis_bbox(img, bbox, label, score, label_names=label_names) a.annotate("Number of containers = {}".format(nb_containers), xytext=(0, 0), xy=(0, 0), color='green', fontsize=14) plot.axis('off') plot.savefig("./temp_result/result.png", bbox_inches='tight', interpolation="nearest") print("finished")
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--batchsize', type=int, default=32) parser.add_argument('--test-batchsize', type=int, default=16) parser.add_argument('--iteration', type=int, default=120000) parser.add_argument('--step', type=int, nargs='*', default=[80000, 100000]) parser.add_argument('--out', default='result') parser.add_argument('--resume') args = parser.parse_args() comm = chainermn.create_communicator() device = comm.intra_rank if args.model == 'ssd300': model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet') elif args.model == 'ssd512': model = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet') model.use_preset('evaluate') train_chain = MultiboxTrainChain(model) chainer.cuda.get_device_from_id(device).use() model.to_gpu() train = TransformDataset( ConcatenatedDataset(VOCBboxDataset(year='2007', split='trainval'), VOCBboxDataset(year='2012', split='trainval')), ('img', 'mb_loc', 'mb_label'), Transform(model.coder, model.insize, model.mean)) if comm.rank == 0: indices = np.arange(len(train)) else: indices = None indices = chainermn.scatter_dataset(indices, comm, shuffle=True) train = train.slice[indices] # http://chainermn.readthedocs.io/en/latest/tutorial/tips_faqs.html#using-multiprocessiterator if hasattr(multiprocessing, 'set_start_method'): multiprocessing.set_start_method('forkserver') train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize // comm.size, n_processes=2) if comm.rank == 0: test = VOCBboxDataset(year='2007', split='test', use_difficult=True, return_difficult=True) test_iter = chainer.iterators.SerialIterator(test, args.test_batchsize, repeat=False, shuffle=False) # initial lr is set to 1e-3 by ExponentialShift optimizer = chainermn.create_multi_node_optimizer( chainer.optimizers.MomentumSGD(), comm) optimizer.setup(train_chain) for param in train_chain.params(): if param.name == 'b': param.update_rule.add_hook(GradientScaling(2)) else: param.update_rule.add_hook(WeightDecay(0.0005)) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=device) trainer = training.Trainer(updater, (args.iteration, 'iteration'), args.out) trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3), trigger=triggers.ManualScheduleTrigger( args.step, 'iteration')) if comm.rank == 0: trainer.extend(DetectionVOCEvaluator(test_iter, model, use_07_metric=True, label_names=voc_bbox_label_names), trigger=triggers.ManualScheduleTrigger( args.step + [args.iteration], 'iteration')) log_interval = 10, 'iteration' trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc', 'main/loss/conf', 'validation/main/map' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.extend(extensions.snapshot(), trigger=triggers.ManualScheduleTrigger( args.step + [args.iteration], 'iteration')) trainer.extend(extensions.snapshot_object( model, 'model_iter_{.updater.iteration}'), trigger=(args.iteration, 'iteration')) if args.resume: serializers.load_npz(args.resume, trainer) trainer.run()
import cv2 import sys from chainercv.links import SSD300 from chainercv.visualizations import vis_bbox from chainercv.datasets import voc_bbox_label_names model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model="voc0712") cap = cv2.VideoCapture(0) if cap.isOpened() is False: print("can not open camera") sys.exit() def crop_human(img, bbox): # bbox = [int(i) for i in bbox*10] croped_img = img[bbox[0]:bbox[2], bbox[1]:bbox[3], :] return croped_img def main(): while True: # VideoCaptureから1フレーム読み込む ret, frame = cap.read() print(frame.shape) resized_frame = cv2.resize( frame, (int(frame.shape[1] * 0.1), int(frame.shape[0] * 0.1))) bboxes, labels, scores = model.predict( [resized_frame.transpose(2, 0, 1)]) bbox = [int(i) for i in bboxes[0][0] * 10] if bbox[2] - bbox[0] > bbox[3] - bbox[1] * 2.5:
def handler(context): dataset_alias = context.datasets trainval_2007_dataset_id = dataset_alias['trainval2007'] trainval_2012_dataset_id = dataset_alias['trainval2012'] test_2007_dataset_id = dataset_alias['test2007'] trainval_2007_dataset = list( load_dataset_from_api(trainval_2007_dataset_id)) trainval_2012_dataset = list( load_dataset_from_api(trainval_2012_dataset_id)) test_2007_dataset = list(load_dataset_from_api(test_2007_dataset_id)) if network_model == 'ssd300': model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet') elif network_model == 'ssd512': model = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet') model.use_preset('evaluate') train_chain = MultiboxTrainChain(model) if USE_GPU >= 0: chainer.cuda.get_device_from_id(USE_GPU).use() model.to_gpu() trainval_2007 = DetectionDatasetFromAPI(trainval_2007_dataset) trainval_2012 = DetectionDatasetFromAPI(trainval_2012_dataset) test_2007 = DetectionDatasetFromAPI(test_2007_dataset, use_difficult=True, return_difficult=True) train = TransformDataset(ConcatenatedDataset(trainval_2007, trainval_2012), Transform(model.coder, model.insize, model.mean)) train_iter = chainer.iterators.SerialIterator(train, BATCHSIZE) test_iter = chainer.iterators.SerialIterator(test_2007, BATCHSIZE, repeat=False, shuffle=False) # initial lr is set to 1e-3 by ExponentialShift optimizer = chainer.optimizers.MomentumSGD() optimizer.setup(train_chain) for param in train_chain.params(): if param.name == 'b': param.update_rule.add_hook(GradientScaling(2)) else: param.update_rule.add_hook(WeightDecay(0.0005)) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=USE_GPU) trainer = training.Trainer(updater, (nb_iterations, 'iteration'), out=ABEJA_TRAINING_RESULT_DIR) trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3), trigger=triggers.ManualScheduleTrigger([80000, 100000], 'iteration')) trainer.extend(DetectionVOCEvaluator(test_iter, model, use_07_metric=True, label_names=voc_bbox_label_names), trigger=(10000, 'iteration')) log_interval = 100, 'iteration' trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.observe_lr(), trigger=log_interval) print_entries = [ 'iteration', 'main/loss', 'main/loss/loc', 'main/loss/conf', 'validation/main/map' ] report_entries = [ 'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc', 'main/loss/conf', 'validation/main/map' ] trainer.extend(Statistics(report_entries, nb_iterations, obs_key='iteration'), trigger=log_interval) trainer.extend(Tensorboard(report_entries, out_dir=log_path)) trainer.extend(extensions.PrintReport(print_entries), trigger=log_interval) trainer.extend(extensions.snapshot_object( model, 'model_iter_{.updater.iteration}'), trigger=(nb_iterations, 'iteration')) trainer.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--batchsize', type=int, default=32) 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 if args.model == 'ssd300': model = SSD300(n_fg_class=len(epic_kitchens_bbox_category_names), pretrained_model='imagenet') elif args.model == 'ssd512': model = SSD512(n_fg_class=len(epic_kitchens_bbox_category_names), pretrained_model='imagenet') model.use_preset('evaluate') train_chain = MultiboxTrainChain(model) 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', 'mb_loc', 'mb_label'), Transform(model.coder, model.insize, model.mean)) indices = chainermn.scatter_dataset(indices, comm, shuffle=True) train = train.slice[indices] # http://chainermn.readthedocs.io/en/latest/tutorial/tips_faqs.html#using-multiprocessiterator if hasattr(multiprocessing, 'set_start_method'): multiprocessing.set_start_method('forkserver') train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize, n_processes=2) optimizer = chainermn.create_multi_node_optimizer( chainer.optimizers.MomentumSGD(), comm) optimizer.setup(train_chain) for param in train_chain.params(): if param.name == 'b': param.update_rule.add_hook(GradientScaling(2)) else: param.update_rule.add_hook(WeightDecay(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([ 'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc', 'main/loss/conf' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=1)) trainer.extend(extensions.snapshot_object( model, '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('--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--batchsize', type=int, default=32) parser.add_argument('--iteration', type=int, default=120000) parser.add_argument('--step', type=int, nargs='*', default=[80000, 100000]) parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--out', default='result') parser.add_argument('--resume') args = parser.parse_args() if args.model == 'ssd300': model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet') elif args.model == 'ssd512': model = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model='imagenet') model.use_preset('evaluate') train_chain = MultiboxTrainChain(model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() train = TransformDataset( ConcatenatedDataset(VOCBboxDataset(year='2007', split='trainval'), VOCBboxDataset(year='2012', split='trainval')), Transform(model.coder, model.insize, model.mean)) train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize) test = VOCBboxDataset(year='2007', split='test', use_difficult=True, return_difficult=True) test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) # initial lr is set to 1e-3 by ExponentialShift optimizer = chainer.optimizers.MomentumSGD() optimizer.setup(train_chain) for param in train_chain.params(): if param.name == 'b': param.update_rule.add_hook(GradientScaling(2)) else: param.update_rule.add_hook(WeightDecay(0.0005)) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.iteration, 'iteration'), args.out) trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3), trigger=triggers.ManualScheduleTrigger( args.step, 'iteration')) trainer.extend(DetectionVOCEvaluator(test_iter, model, use_07_metric=True, label_names=voc_bbox_label_names), trigger=triggers.ManualScheduleTrigger( args.step + [args.iteration], 'iteration')) log_interval = 10, 'iteration' trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc', 'main/loss/conf', 'validation/main/map' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.extend(extensions.snapshot(), trigger=triggers.ManualScheduleTrigger( args.step + [args.iteration], 'iteration')) trainer.extend(extensions.snapshot_object( model, 'model_iter_{.updater.iteration}'), trigger=(args.iteration, 'iteration')) if args.resume: serializers.load_npz(args.resume, trainer) trainer.run()
bccd_labels = ('rbc', 'wbc', 'platelets') class MultiboxTrainChain(chainer.Chain): def __init__(self, model, alpha=1, k=3): super(MultiboxTrainChain, self).__init__() with self.init_scope(): self.model = model self.alpha = alpha self.k = k def forward(self, imgs, gt_mb_locs, gt_mb_labels): mb_locs, mb_confs = self.model(imgs) loc_loss, conf_loss = multibox_loss(mb_locs, mb_confs, gt_mb_locs, gt_mb_labels, self.k) loss = loc_loss * self.alpha + conf_loss chainer.reporter.report( { 'loss': loss, 'loss/loc': loc_loss, 'loss/conf': conf_loss }, self) return loss model = SSD300(n_fg_class=len(bccd_labels), pretrained_model='imagenet') train_chain = MultiboxTrainChain(model)