def train_net(image_set, year, root_path, devkit_path, pretrained, epoch,
prefix, ctx, begin_epoch, end_epoch, frequent, kv_store, work_load_list=None):
"""
wrapper for solver
:param image_set: image set to train on
:param year: year of image set
:param root_path: 'data' folder
:param devkit_path: 'VOCdevkit' folder
:param pretrained: prefix of pretrained model
:param epoch: epoch of pretrained model
:param prefix: prefix of new model
:param ctx: context to train in
:param begin_epoch: begin epoch number
:param end_epoch: end epoch number
:param frequent: frequency to print
:return: None
"""
# set up logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# load training data
voc, roidb, means, stds = load_train_roidb(image_set, year, root_path, devkit_path, flip=True)
train_data = ROIIter(roidb, ctx=ctx, batch_size=config.TRAIN.BATCH_IMAGES, shuffle=True, mode='train', work_load_list=work_load_list)
# load pretrained
args, auxs = load_param(pretrained, epoch, convert=True, ctx=ctx[0])
del args['fc8_bias']
del args['fc8_weight']
# load symbol
sym = get_symbol_vgg()
# initialize params
arg_shape, _, _ = sym.infer_shape(data=(1, 3, 224, 224), rois=(1, 5))
arg_shape_dict = dict(zip(sym.list_arguments(), arg_shape))
args['cls_score_weight'] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict['cls_score_weight'], ctx=ctx[0])
args['cls_score_bias'] = mx.nd.zeros(shape=arg_shape_dict['cls_score_bias'], ctx=ctx[0])
args['bbox_pred_weight'] = mx.random.normal(mean=0, stdvar=0.001, shape=arg_shape_dict['bbox_pred_weight'], ctx=ctx[0])
args['bbox_pred_bias'] = mx.nd.zeros(shape=arg_shape_dict['bbox_pred_bias'], ctx=ctx[0])
# train
solver = Solver(prefix, sym, ctx, begin_epoch, end_epoch, kv_store, args, auxs, momentum=0.9, wd=0.0005,
learning_rate=0.001, lr_scheduler=mx.lr_scheduler.FactorScheduler(30000, 0.1), max_data_shape=[('data', (1, 3, 1000, 1000))])
solver.fit(train_data, frequent=frequent)
# edit params and save
for epoch in range(begin_epoch + 1, end_epoch + 1):
arg_params, aux_params = load_checkpoint(prefix, epoch)
arg_params['bbox_pred_weight'] = (arg_params['bbox_pred_weight'].T * mx.nd.array(stds, ctx=ctx[0])).T
arg_params['bbox_pred_bias'] = arg_params['bbox_pred_bias'] * mx.nd.array(stds, ctx=ctx[0]) + \
mx.nd.array(means, ctx=ctx[0])
save_checkpoint(prefix, epoch, arg_params, aux_params)
def train_net(image_set, year, root_path, devkit_path, pretrained, epoch,
prefix, ctx, begin_epoch, end_epoch, frequent, kv_store, work_load_list=None, resume=False):
# set up logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# load symbol
sym = get_vgg_rpn()
feat_sym = get_vgg_rpn().get_internals()['rpn_cls_score_output']
# setup multi-gpu
config.TRAIN.BATCH_IMAGES *= len(ctx)
config.TRAIN.BATCH_SIZE *= len(ctx)
# load training data
voc, roidb = load_gt_roidb(image_set, year, root_path, devkit_path, flip=True)
train_data = AnchorLoader(feat_sym, roidb, batch_size=config.TRAIN.BATCH_SIZE, shuffle=True, mode='train',
ctx=ctx, work_load_list=work_load_list)
# infer max shape
max_data_shape = [('data', (1, 3, 1000, 1000))]
max_data_shape_dict = {k: v for k, v in max_data_shape}
_, feat_shape, _ = feat_sym.infer_shape(**max_data_shape_dict)
from rcnn.minibatch import assign_anchor
import numpy as np
label = assign_anchor(feat_shape[0], np.zeros((0, 5)), [[1000, 1000, 1.0]])
max_label_shape = [('label', label['label'].shape),
('bbox_target', label['bbox_target'].shape),
('bbox_inside_weight', label['bbox_inside_weight'].shape),
('bbox_outside_weight', label['bbox_outside_weight'].shape)]
print 'providing maximum shape', max_data_shape, max_label_shape
# load pretrained
args, auxs = load_param(pretrained, epoch, convert=True)
# initialize params
if not resume:
arg_shape, _, _ = sym.infer_shape(data=(1, 3, 224, 224))
arg_shape_dict = dict(zip(sym.list_arguments(), arg_shape))
args['rpn_conv_3x3_weight'] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict['rpn_conv_3x3_weight'])
args['rpn_conv_3x3_bias'] = mx.nd.zeros(shape=arg_shape_dict['rpn_conv_3x3_bias'])
args['rpn_cls_score_weight'] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict['rpn_cls_score_weight'])
args['rpn_cls_score_bias'] = mx.nd.zeros(shape=arg_shape_dict['rpn_cls_score_bias'])
args['rpn_bbox_pred_weight'] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict['rpn_bbox_pred_weight'])
args['rpn_bbox_pred_bias'] = mx.nd.zeros(shape=arg_shape_dict['rpn_bbox_pred_bias'])
# train
solver = Solver(prefix, sym, ctx, begin_epoch, end_epoch, kv_store, args, auxs, momentum=0.9, wd=0.0005,
learning_rate=1e-3, lr_scheduler=mx.lr_scheduler.FactorScheduler(60000, 0.1),
mutable_data_shape=True, max_data_shape=max_data_shape, max_label_shape=max_label_shape)
solver.fit(train_data, frequent=frequent)
def train_net(image_set, year, root_path, devkit_path, pretrained, epoch,
prefix, ctx, begin_epoch, end_epoch, frequent, kv_store, work_load_list=None, resume=False):
# set up logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# load symbol
sym = get_vgg_rcnn()
# setup multi-gpu
config.TRAIN.BATCH_IMAGES *= len(ctx)
config.TRAIN.BATCH_SIZE *= len(ctx)
# load training data
voc, roidb, means, stds = load_rpn_roidb(image_set, year, root_path, devkit_path, flip=True)
train_data = ROIIter(roidb, batch_size=config.TRAIN.BATCH_IMAGES, shuffle=True, mode='train',
ctx=ctx, work_load_list=work_load_list)
# infer max shape
max_data_shape = [('data', (1, 3, 1000, 1000))]
# load pretrained
args, auxs = load_param(pretrained, epoch, convert=True)
# initialize params
if not resume:
input_shapes = {k: v for k, v in train_data.provide_data + train_data.provide_label}
arg_shape, _, _ = sym.infer_shape(**input_shapes)
arg_shape_dict = dict(zip(sym.list_arguments(), arg_shape))
args['cls_score_weight'] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict['cls_score_weight'])
args['cls_score_bias'] = mx.nd.zeros(shape=arg_shape_dict['cls_score_bias'])
args['bbox_pred_weight'] = mx.random.normal(mean=0, stdvar=0.001, shape=arg_shape_dict['bbox_pred_weight'])
args['bbox_pred_bias'] = mx.nd.zeros(shape=arg_shape_dict['bbox_pred_bias'])
# train
solver = Solver(prefix, sym, ctx, begin_epoch, end_epoch, kv_store, args, auxs, momentum=0.9, wd=0.0005,
learning_rate=1e-3, lr_scheduler=mx.lr_scheduler.FactorScheduler(30000, 0.1),
mutable_data_shape=True, max_data_shape=max_data_shape)
solver.fit(train_data, frequent=frequent)
# edit params and save
for epoch in range(begin_epoch + 1, end_epoch + 1):
arg_params, aux_params = load_checkpoint(prefix, epoch)
arg_params['bbox_pred_weight'] = (arg_params['bbox_pred_weight'].T * mx.nd.array(stds)).T
arg_params['bbox_pred_bias'] = arg_params['bbox_pred_bias'] * mx.nd.array(stds) + \
mx.nd.array(means)
save_checkpoint(prefix, epoch, arg_params, aux_params)
def train_net(image_set, year, root_path, devkit_path, pretrained, epoch,
prefix, ctx, begin_epoch, end_epoch, frequent):
"""
wrapper for solver
:param image_set: image set to train on
:param year: year of image set
:param root_path: 'data' folder
:param devkit_path: 'VOCdevkit' folder
:param pretrained: prefix of pretrained model
:param epoch: epoch of pretrained model
:param prefix: prefix of new model
:param ctx: context to train in
:param begin_epoch: begin epoch number
:param end_epoch: end epoch number
:param frequent: frequency to print
:return: None
"""
# set up logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# load training data
voc, roidb, means, stds = load_train_roidb(image_set,
year,
root_path,
devkit_path,
flip=True)
train_data = ROIIter(roidb,
batch_size=config.TRAIN.BATCH_IMAGES,
shuffle=True,
mode='train')
# load pretrained
args, auxs = load_param(pretrained, epoch, convert=True, ctx=ctx)
del args['fc8_bias']
del args['fc8_weight']
# load symbol
sym = get_symbol_vgg()
# initialize params
arg_shape, _, _ = sym.infer_shape(data=(1, 3, 224, 224), rois=(1, 5))
arg_shape_dict = dict(zip(sym.list_arguments(), arg_shape))
args['cls_score_weight'] = mx.random.normal(
mean=0, stdvar=0.01, shape=arg_shape_dict['cls_score_weight'], ctx=ctx)
args['cls_score_bias'] = mx.nd.zeros(
shape=arg_shape_dict['cls_score_bias'], ctx=ctx)
args['bbox_pred_weight'] = mx.random.normal(
mean=0,
stdvar=0.001,
shape=arg_shape_dict['bbox_pred_weight'],
ctx=ctx)
args['bbox_pred_bias'] = mx.nd.zeros(
shape=arg_shape_dict['bbox_pred_bias'], ctx=ctx)
# train
solver = Solver(prefix,
sym,
ctx,
begin_epoch,
end_epoch,
args,
auxs,
momentum=0.9,
wd=0.0005,
learning_rate=0.001,
lr_scheduler=mx.lr_scheduler.FactorScheduler(30000, 0.1))
solver.fit(train_data, frequent=frequent)
# edit params and save
for epoch in range(begin_epoch + 1, end_epoch + 1):
arg_params, aux_params = load_checkpoint(prefix, epoch)
arg_params['bbox_pred_weight'] = (arg_params['bbox_pred_weight'].T *
mx.nd.array(stds, ctx=ctx)).T
arg_params['bbox_pred_bias'] = arg_params['bbox_pred_bias'] * mx.nd.array(stds, ctx=ctx) + \
mx.nd.array(means, ctx=ctx)
save_checkpoint(prefix, epoch, arg_params, aux_params)
def train_rpn(
image_set,
year,
root_path,
devkit_path,
pretrained,
epoch,
prefix,
ctx,
begin_epoch,
end_epoch,
frequent,
kv_store,
work_load_list=None,
):
# load symbol
sym = get_vgg_rpn()
feat_sym = get_vgg_rpn().get_internals()["rpn_cls_score_output"]
# setup multi-gpu
config.TRAIN.BATCH_IMAGES *= len(ctx)
config.TRAIN.BATCH_SIZE *= len(ctx)
# load training data
voc, roidb = load_gt_roidb(image_set, year, root_path, devkit_path, flip=True)
train_data = AnchorLoader(
feat_sym,
roidb,
batch_size=config.TRAIN.BATCH_SIZE,
shuffle=True,
mode="train",
ctx=ctx,
work_load_list=work_load_list,
)
# infer max shape
max_data_shape = [("data", (1, 3, 1000, 1000))]
max_data_shape_dict = {k: v for k, v in max_data_shape}
_, feat_shape, _ = feat_sym.infer_shape(**max_data_shape_dict)
from rcnn.minibatch import assign_anchor
import numpy as np
label = assign_anchor(feat_shape[0], np.zeros((0, 5)), [[1000, 1000, 1.0]])
max_label_shape = [
("label", label["label"].shape),
("bbox_target", label["bbox_target"].shape),
("bbox_inside_weight", label["bbox_inside_weight"].shape),
("bbox_outside_weight", label["bbox_outside_weight"].shape),
]
print "providing maximum shape", max_data_shape, max_label_shape
# load pretrained
args, auxs = load_param(pretrained, epoch, convert=True)
# initialize params
arg_shape, _, _ = sym.infer_shape(data=(1, 3, 224, 224))
arg_shape_dict = dict(zip(sym.list_arguments(), arg_shape))
args["rpn_conv_3x3_weight"] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict["rpn_conv_3x3_weight"])
args["rpn_conv_3x3_bias"] = mx.nd.zeros(shape=arg_shape_dict["rpn_conv_3x3_bias"])
args["rpn_cls_score_weight"] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict["rpn_cls_score_weight"])
args["rpn_cls_score_bias"] = mx.nd.zeros(shape=arg_shape_dict["rpn_cls_score_bias"])
args["rpn_bbox_pred_weight"] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict["rpn_bbox_pred_weight"])
args["rpn_bbox_pred_bias"] = mx.nd.zeros(shape=arg_shape_dict["rpn_bbox_pred_bias"])
# train
solver = Solver(
prefix,
sym,
ctx,
begin_epoch,
end_epoch,
kv_store,
args,
auxs,
momentum=0.9,
wd=0.0005,
learning_rate=1e-3,
lr_scheduler=mx.lr_scheduler.FactorScheduler(60000, 0.1),
mutable_data_shape=True,
max_data_shape=max_data_shape,
max_label_shape=max_label_shape,
)
solver.fit(train_data, frequent=frequent)
def train_rcnn(
image_set,
year,
root_path,
devkit_path,
pretrained,
epoch,
prefix,
ctx,
begin_epoch,
end_epoch,
frequent,
kv_store,
work_load_list=None,
):
# load symbol
sym = get_vgg_rcnn()
# setup multi-gpu
config.TRAIN.BATCH_IMAGES *= len(ctx)
config.TRAIN.BATCH_SIZE *= len(ctx)
# load training data
voc, roidb, means, stds = load_rpn_roidb(image_set, year, root_path, devkit_path, flip=True)
train_data = ROIIter(
roidb, batch_size=config.TRAIN.BATCH_IMAGES, shuffle=True, mode="train", ctx=ctx, work_load_list=work_load_list
)
# infer max shape
max_data_shape = [("data", (1, 3, 1000, 1000))]
# load pretrained
args, auxs = load_param(pretrained, epoch, convert=True)
# initialize params
arg_shape, _, _ = sym.infer_shape(data=(1, 3, 224, 224), rois=(1, 5))
arg_shape_dict = dict(zip(sym.list_arguments(), arg_shape))
args["cls_score_weight"] = mx.random.normal(mean=0, stdvar=0.01, shape=arg_shape_dict["cls_score_weight"])
args["cls_score_bias"] = mx.nd.zeros(shape=arg_shape_dict["cls_score_bias"])
args["bbox_pred_weight"] = mx.random.normal(mean=0, stdvar=0.001, shape=arg_shape_dict["bbox_pred_weight"])
args["bbox_pred_bias"] = mx.nd.zeros(shape=arg_shape_dict["bbox_pred_bias"])
# train
solver = Solver(
prefix,
sym,
ctx,
begin_epoch,
end_epoch,
kv_store,
args,
auxs,
momentum=0.9,
wd=0.0005,
learning_rate=1e-3,
lr_scheduler=mx.lr_scheduler.FactorScheduler(30000, 0.1),
mutable_data_shape=True,
max_data_shape=max_data_shape,
)
solver.fit(train_data, frequent=frequent)
# edit params and save
for epoch in range(begin_epoch + 1, end_epoch + 1):
arg_params, aux_params = load_checkpoint(prefix, epoch)
arg_params["bbox_pred_weight"] = (arg_params["bbox_pred_weight"].T * mx.nd.array(stds)).T
arg_params["bbox_pred_bias"] = arg_params["bbox_pred_bias"] * mx.nd.array(stds) + mx.nd.array(means)
save_checkpoint(prefix, epoch, arg_params, aux_params)
