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)
