def test_deeplab(ctx):
test_data = get_data("val", DATA_DIR, LIST_DIR, len(ctx))
ctx = [mx.gpu(int(i)) for i in args.gpu.split(',')]
sym_instance = eval(symbol_str)()
# infer shape
val_provide_data = [[("data", (1, 3, tile_height, tile_width))]]
val_provide_label = [[("softmax_label", (1, 1, tile_height, tile_width))]]
data_shape_dict = {
'data': (1, 3, tile_height, tile_width),
'softmax_label': (1, 1, tile_height, tile_width)
}
eval_sym = sym_instance.get_symbol(NUM_CLASSES, is_train=False)
sym_instance.infer_shape(data_shape_dict)
arg_params, aux_params = load_init_param(args.load, process=True)
sym_instance.check_parameter_shapes(arg_params,
aux_params,
data_shape_dict,
is_train=False)
data_names = ['data']
label_names = ['softmax_label']
# create predictor
predictor = Predictor(eval_sym,
data_names,
label_names,
context=ctx,
provide_data=val_provide_data,
provide_label=val_provide_label,
arg_params=arg_params,
aux_params=aux_params)
if args.vis:
from mxnetgo.myutils.fs import mkdir_p
vis_dir = os.path.join(logger.get_logger_dir(), "vis")
mkdir_p(vis_dir)
stats = MIoUStatistics(NUM_CLASSES)
test_data.reset_state()
nbatch = 0
for data, label in tqdm(test_data.get_data()):
output_all = predict_scaler(data,
predictor,
scales=[0.9, 1.0, 1.1],
classes=NUM_CLASSES,
tile_size=(tile_height, tile_width),
is_densecrf=False,
nbatch=nbatch,
val_provide_data=val_provide_data,
val_provide_label=val_provide_label)
output_all = np.argmax(output_all, axis=0)
label = np.squeeze(label)
if args.vis:
cv2.imwrite(os.path.join(vis_dir, "{}.jpg".format(nbatch)),
visualize_label(output_all))
stats.feed(output_all, label) # very time-consuming
nbatch += 1
logger.info("mIoU: {}, meanAcc: {}, acc: {} ".format(
stats.mIoU, stats.mean_accuracy, stats.accuracy))
def load_init_param(model_name, convert=False, ctx=None, process=False):
"""
wrapper for load checkpoint
:param prefix: Prefix of model name.
:param epoch: Epoch number of model we would like to load.
:param convert: reference model should be converted to GPU NDArray first
:param ctx: if convert then ctx must be designated.
:param process: model should drop any test
:return: (arg_params, aux_params)
"""
save_dict = mx.nd.load(model_name + ".params")
arg_params, aux_params = load_checkpoint(save_dict)
if convert:
if ctx is None:
ctx = mx.cpu()
arg_params = convert_context(arg_params, ctx)
aux_params = convert_context(aux_params, ctx)
if process:
tests = [k for k in arg_params.keys() if '_test' in k]
for test in tests:
arg_params[test.replace('_test', '')] = arg_params.pop(test)
logger.info("arg_params to restore from dict: {}".format(','.join(
sorted(arg_params.keys()))))
logger.info("aux_params to restore from dict: {}".format(','.join(
sorted(aux_params.keys()))))
return arg_params, aux_params
def check_parameter_shapes(self,
arg_params,
aux_params,
data_shape_dict,
is_train=True):
if is_train:
data = []
for k in self.sym.list_arguments():
data.append([
k,
str(self.arg_shape_dict[k]),
self.sym.get_internals()[k].list_attr()["lr_mult"] if
self.sym.get_internals()[k].list_attr().has_key("lr_mult")
else "default"
])
table = tabulate(data, headers=['name', 'shape', 'lr_mult'])
logger.info(colored("Arg Parameters: \n", 'cyan') + table)
aux_data = []
for k in self.sym.list_auxiliary_states():
aux_data.append([k, str(self.aux_shape_dict[k])])
aux_table = tabulate(aux_data, headers=['name', 'shape'])
logger.info(
colored("Auxiliary Parameters: \n", 'cyan') + aux_table)
""" # temporarily removed by dongzhuoyao
def init_weights(self, arg_params, aux_params):
origin_arg_params = arg_params.copy()
origin_aux_params = aux_params.copy()
arg_params['fc6_weight'] = mx.random.normal(
0, 0.01, shape=self.arg_shape_dict['fc6_weight'])
arg_params['fc6_bias'] = mx.nd.zeros(
shape=self.arg_shape_dict['fc6_bias'])
arg_params['score_weight'] = mx.random.normal(
0, 0.01, shape=self.arg_shape_dict['score_weight'])
arg_params['score_bias'] = mx.nd.zeros(
shape=self.arg_shape_dict['score_bias'])
arg_params['upsampling_weight'] = mx.nd.zeros(
shape=self.arg_shape_dict['upsampling_weight'])
init = mx.init.Initializer()
init._init_bilinear('upsample_weight', arg_params['upsampling_weight'])
delta_arg_params = list(
set(arg_params.keys()) - set(origin_arg_params.keys()))
delta_aux_params = list(
set(aux_params.keys()) - set(origin_aux_params.keys()))
logger.info("arg_params initialize manually: {}".format(','.join(
sorted(delta_arg_params))))
logger.info("aux_params initialize manually: {}".format(','.join(
sorted(delta_aux_params))))
def check_parameter_shapes(self, arg_params, aux_params, data_shape_dict, is_train=True):
if is_train:
data = []
for k in self.sym.list_arguments():
data.append([k, str(self.arg_shape_dict[k]), self.sym.get_internals()[k].list_attr()["lr_mult"] if self.sym.get_internals()[k].list_attr().has_key("lr_mult") else "default"])
table = tabulate(data, headers=['name', 'shape', 'lr_mult'])
logger.info(colored("Arg Parameters: \n", 'cyan') + table)
aux_data = []
for k in self.sym.list_auxiliary_states():
aux_data.append([k, str(self.aux_shape_dict[k])])
aux_table = tabulate(aux_data, headers=['name', 'shape'])
logger.info(colored("Auxiliary Parameters: \n", 'cyan') + aux_table)
for k in self.sym.list_arguments():
if k in data_shape_dict or (False if is_train else 'label' in k):
continue
assert k in arg_params, '{} not initialized'.format(k)
assert arg_params[k].shape == self.arg_shape_dict[k], \
"shape inconsistent for '{}' inferred {} provided {}".format(k, str(self.arg_shape_dict[k]), str(
arg_params[k].shape))
for k in self.sym.list_auxiliary_states():
assert k in aux_params, '{} not initialized'.format(k)
assert aux_params[k].shape == self.aux_shape_dict[k], \
"shape inconsistent for '{}' inferred {} provided {}".format(k, str(self.aux_shape_dict[k]), str(
aux_params[k].shape))
def __init__(self, show_interval, class_num):
super(FCNLogLossMetric, self).__init__('FCNLogLoss')
self.show_interval = show_interval
logger.info(
"start training, loss show interval = {}".format(show_interval))
self.sum_metric = 0
self.num_inst = 0
self.class_num = class_num
def test_deeplab():
logger.auto_set_dir()
ctx = [mx.gpu(int(i)) for i in config.gpus.split(',')]
logger.info('testing config:{}\n'.format(pprint.pformat(config)))
sym_instance = eval(config.symbol)()
# infer shape
val_provide_data = [[("data", (1L, 3L, config.TEST.tile_height,
config.TEST.tile_width))]]
def train_net(args, ctx):
logger.auto_set_dir()
from symbols.gluon_deeplabv2 import resnet101_deeplab_new
input_batch_size = args.batch_size * len(ctx)
sym_instance = resnet101_deeplab_new()
sym = sym_instance.get_symbol(NUM_CLASSES, is_train=True)
eval_sym_instance = resnet101_deeplab_new()
eval_sym = eval_sym_instance.get_symbol(NUM_CLASSES, is_train=False)
train_data = get_data("train_aug", DATA_DIR, LIST_DIR, len(ctx))
eval_data = get_data("val", DATA_DIR, LIST_DIR, len(ctx))
# infer shape
data_shape_dict = {'data':(args.batch_size, 3, args.crop_size[0],args.crop_size[1])
,'label':(args.batch_size, 1, args.crop_size[0],args.crop_size[1])}
sym_instance.infer_shape(data_shape_dict)
# load and initialize params
begin_epoch = 1
mod = MutableModule(sym, data_names=['data'], label_names=['label'],context=ctx, fixed_param_prefix=fixed_param_prefix)
# metric
fcn_loss_metric = metric.FCNLogLossMetric(args.frequent,PascalVOC12.class_num())
eval_metrics = mx.metric.CompositeEvalMetric()
eval_metrics.add(fcn_loss_metric)
batch_end_callbacks = [callback.Speedometer(input_batch_size, frequent=args.frequent)]
epoch_end_callbacks = \
[mx.callback.module_checkpoint(mod, os.path.join(logger.get_logger_dir(),"mxnetgo"), period=1, save_optimizer_states=True),
]
lr_scheduler = StepScheduler(train_data.size()*EPOCH_SCALE,lr_step_list)
# optimizer
optimizer_params = {'momentum': 0.9,
'wd': 0.0005,
'learning_rate': 2.5e-4,
'lr_scheduler': lr_scheduler,
'rescale_grad': 1.0,
'clip_gradient': None}
logger.info("epoch scale = {}".format(EPOCH_SCALE))
mod.fit(train_data=train_data, args = args, eval_sym=eval_sym, eval_sym_instance=eval_sym_instance, eval_data=eval_data, eval_metric=eval_metrics, epoch_end_callback=epoch_end_callbacks,
batch_end_callback=batch_end_callbacks, kvstore=kvstore,
optimizer='sgd', optimizer_params=optimizer_params,
arg_params=None, aux_params=None, begin_epoch=begin_epoch, num_epoch=end_epoch,epoch_scale=EPOCH_SCALE, validation_on_last=validation_on_last)
def init_weights(self, arg_params, aux_params):
origin_arg_params = arg_params.copy()
origin_aux_params = aux_params.copy()
#m = np.array([104, 116, 122])
#const_arr = np.resize(m, (1,3,1,1)) # NCHW
#logger.warn("constant_color initialized in symbol")
#arg_params['constant_color'] = mx.nd.array(const_arr, dtype='float32').broadcast_to(self.arg_shape_dict['constant_color'])
arg_params['fc6_weight'] = mx.random.normal(0, 0.01, shape=self.arg_shape_dict['fc6_weight'])
arg_params['fc6_bias'] = mx.nd.zeros(shape=self.arg_shape_dict['fc6_bias'])
arg_params['score_weight'] = mx.random.normal(0, 0.01, shape=self.arg_shape_dict['score_weight'])
arg_params['score_bias'] = mx.nd.zeros(shape=self.arg_shape_dict['score_bias'])
arg_params['upsampling_weight'] = mx.nd.zeros(shape=self.arg_shape_dict['upsampling_weight'])
init = mx.init.Initializer()
init._init_bilinear('upsample_weight', arg_params['upsampling_weight'])
delta_arg_params = list(set(arg_params.keys()) - set(origin_arg_params.keys()))
delta_aux_params = list(set(aux_params.keys()) - set(origin_aux_params.keys()))
logger.info("arg_params initialize manually: {}".format(','.join(sorted(delta_arg_params))))
logger.info("aux_params initialize manually: {}".format(','.join(sorted(delta_aux_params))))
def train_net(args, ctx):
logger.auto_set_dir()
sym_instance = resnet101_deeplab_new()
sym = sym_instance.get_symbol(NUM_CLASSES, is_train=True, use_global_stats=False)
eval_sym_instance = resnet101_deeplab_new()
eval_sym = eval_sym_instance.get_symbol(NUM_CLASSES, is_train=False, use_global_stats=True)
# setup multi-gpu
gpu_nums = len(ctx)
input_batch_size = args.batch_size * gpu_nums
train_data = get_data("train", DATA_DIR, LIST_DIR, len(ctx))
test_data = get_data("val", DATA_DIR, LIST_DIR, len(ctx))
# infer shape
data_shape_dict = {'data':(args.batch_size, 3, args.crop_size[0],args.crop_size[1])
,'label':(args.batch_size, 1, args.crop_size[0],args.crop_size[1])}
pprint.pprint(data_shape_dict)
sym_instance.infer_shape(data_shape_dict)
# load and initialize params
epoch_string = args.load.rsplit("-",2)[1]
begin_epoch = 1
if not args.scratch:
begin_epoch = int(epoch_string)
logger.info('continue training from {}'.format(begin_epoch))
arg_params, aux_params = load_init_param(args.load, convert=True)
else:
logger.info(args.load)
arg_params, aux_params = load_init_param(args.load, convert=True)
sym_instance.init_weights(arg_params, aux_params)
# check parameter shapes
sym_instance.check_parameter_shapes(arg_params, aux_params, data_shape_dict)
data_names = ['data']
label_names = ['label']
mod = MutableModule(sym, data_names=data_names, label_names=label_names,context=ctx, fixed_param_prefix=fixed_param_prefix)
# decide training params
# metric
fcn_loss_metric = metric.FCNLogLossMetric(args.frequent,Camvid.class_num())
eval_metrics = mx.metric.CompositeEvalMetric()
for child_metric in [fcn_loss_metric]:
eval_metrics.add(child_metric)
# callback
batch_end_callbacks = [callback.Speedometer(input_batch_size, frequent=args.frequent)]
#batch_end_callbacks = [mx.callback.ProgressBar(total=train_data.size/train_data.batch_size)]
epoch_end_callbacks = \
[mx.callback.module_checkpoint(mod, os.path.join(logger.get_logger_dir(),"mxnetgo"), period=1, save_optimizer_states=True),
]
lr_scheduler = StepScheduler(train_data.size()*EPOCH_SCALE,lr_step_list)
# optimizer
optimizer_params = {'momentum': 0.9,
'wd': 0.0005,
'learning_rate': 2.5e-4,
'lr_scheduler': lr_scheduler,
'rescale_grad': 1.0,
'clip_gradient': None}
logger.info("epoch scale = {}".format(EPOCH_SCALE))
mod.fit(train_data=train_data, args = args,eval_sym=eval_sym, eval_sym_instance=eval_sym_instance, eval_data=test_data, eval_metric=eval_metrics, epoch_end_callback=epoch_end_callbacks,
batch_end_callback=batch_end_callbacks, kvstore=kvstore,
optimizer='sgd', optimizer_params=optimizer_params,
arg_params=arg_params, aux_params=aux_params, begin_epoch=begin_epoch, num_epoch=end_epoch,epoch_scale=EPOCH_SCALE, validation_on_last=validation_on_last)
def train_net(args, ctx):
logger.auto_set_dir()
# load symbol
shutil.copy2(os.path.join(curr_path, 'symbols', symbol_str + '.py'), logger.get_logger_dir())#copy file to logger dir for debug convenience
sym_instance = eval(symbol_str)()
sym = sym_instance.get_symbol(NUM_CLASSES, is_train=True)
#digraph = mx.viz.plot_network(sym, save_format='pdf')
#digraph.render()
# setup multi-gpu
gpu_nums = len(ctx)
input_batch_size = args.batch_size * gpu_nums
train_data = get_data("train", DATA_DIR, LIST_DIR, len(ctx))
test_data = get_data("val", DATA_DIR, LIST_DIR, len(ctx))
eval_sym_instance = eval(symbol_str)()
# infer max shape
max_scale = [args.crop_size]
max_data_shape = [('data', (args.batch_size, 3, max([v[0] for v in max_scale]), max([v[1] for v in max_scale])))]
max_label_shape = [('label', (args.batch_size, 1, max([v[0] for v in max_scale]), max([v[1] for v in max_scale])))]
# infer shape
data_shape_dict = {'data':(args.batch_size, 3, args.crop_size[0],args.crop_size[1])
,'label':(args.batch_size, 1, args.crop_size[0],args.crop_size[1])}
pprint.pprint(data_shape_dict)
sym_instance.infer_shape(data_shape_dict)
# load and initialize params
epoch_string = args.load.rsplit("-",2)[1]
begin_epoch = 0
if not args.scratch:
begin_epoch = int(epoch_string)
logger.info('continue training from {}'.format(begin_epoch))
arg_params, aux_params = load_init_param(args.load, convert=True)
else:
logger.info(args.load)
arg_params, aux_params = load_init_param(args.load, convert=True)
sym_instance.init_weights(arg_params, aux_params)
# check parameter shapes
sym_instance.check_parameter_shapes(arg_params, aux_params, data_shape_dict)
data_names = ['data']
label_names = ['label']
mod = MutableModule(sym, data_names=data_names, label_names=label_names,context=ctx, max_data_shapes=[max_data_shape for _ in xrange(gpu_nums)],
max_label_shapes=[max_label_shape for _ in xrange(gpu_nums)], fixed_param_prefix=fixed_param_prefix)
# decide training params
# metric
fcn_loss_metric = metric.FCNLogLossMetric(args.frequent)
eval_metrics = mx.metric.CompositeEvalMetric()
# rpn_eval_metric, rpn_cls_metric, rpn_bbox_metric, eval_metric, cls_metric, bbox_metric
for child_metric in [fcn_loss_metric]:
eval_metrics.add(child_metric)
# callback
batch_end_callbacks = [callback.Speedometer(input_batch_size, frequent=args.frequent)]
#batch_end_callbacks = [mx.callback.ProgressBar(total=train_data.size/train_data.batch_size)]
epoch_end_callbacks = \
[mx.callback.module_checkpoint(mod, os.path.join(logger.get_logger_dir(),"mxnetgo"), period=1, save_optimizer_states=True),
]
lr_scheduler = StepScheduler(train_data.size()*EPOCH_SCALE,lr_step_list)
# optimizer
optimizer_params = {'momentum': 0.9,
'wd': 0.0005,
'learning_rate': 2.5e-4,
'lr_scheduler': lr_scheduler,
'rescale_grad': 1.0,
'clip_gradient': None}
logger.info("epoch scale = {}".format(EPOCH_SCALE))
mod.fit(train_data=train_data, args = args, eval_sym_instance=eval_sym_instance, eval_data=test_data, eval_metric=eval_metrics, epoch_end_callback=epoch_end_callbacks,
batch_end_callback=batch_end_callbacks, kvstore=kvstore,
optimizer='sgd', optimizer_params=optimizer_params,
arg_params=arg_params, aux_params=aux_params, begin_epoch=begin_epoch, num_epoch=end_epoch,epoch_scale=EPOCH_SCALE, validation_on_last=end_epoch)
def get_symbol(self, num_class, is_train,use_global_stats, units=[3, 4, 23, 3], num_stage=4, filter_list=[64, 256, 512, 1024, 2048],b_lr_mult=2.0,w_lr_mult=1.0, bottle_neck=True, bn_mom=0.9, workspace=512, memonger=False):
"""Return ResNet symbol of cifar10 and imagenet
Parameters
----------
units : list
Number of units in each stage
num_stage : int
Number of stage
filter_list : list
Channel size of each stage
num_class : int
Ouput size of symbol
dataset : str
Dataset type, only cifar10 and imagenet supports
workspace : int
Workspace used in convolution operator
"""
num_unit = len(units)
self.is_train = is_train
self.use_global_stats = use_global_stats
if self.is_train:
logger.info("is_train: {}".format(self.is_train))
logger.info("use_global_stats: {}".format(self.use_global_stats))
assert(num_unit == num_stage)
data = mx.sym.Variable(name='data')
#constant_color = mx.sym.Variable('constant_color')
#constant_color = mx.sym.BlockGrad(constant_color)
#data = data - constant_color
if self.is_train:
seg_cls_gt = mx.symbol.Variable(name='label')
data = mx.sym.BatchNorm(data=data, fix_gamma=True, use_global_stats=self.use_global_stats, eps=2e-5, momentum=bn_mom, name='bn_data')
## body for imagenet, note that cifar is another different body
body = mx.sym.Convolution(data=data, num_filter=filter_list[0], kernel=(7, 7), stride=(2,2), pad=(3, 3),
no_bias=True, name="conv0", workspace=workspace)
body = mx.sym.BatchNorm(data=body, fix_gamma=False, use_global_stats=self.use_global_stats,eps=2e-5, momentum=bn_mom, name='bn0')
body = mx.sym.Activation(data=body, act_type='relu', name='relu0')
body = mx.symbol.Pooling(data=body, kernel=(3, 3), stride=(2,2), pad=(1,1), pool_type='max')
dilation = [1,1,2,4]
for i in range(num_stage):
body = self.residual_unit(body, filter_list[i+1], (1 if i==0 or i==3 else 2, 1 if i==0 or i==3 else 2), False,
dilation=1,name='stage%d_unit%d' % (i + 1, 1), bottle_neck=bottle_neck,
workspace=workspace, memonger=memonger)
for j in range(units[i]-1):
body = self.residual_unit(body, filter_list[i+1], (1,1), True, dilation=dilation[i], name='stage%d_unit%d' % (i + 1, j + 2),
bottle_neck=bottle_neck, workspace=workspace, memonger=memonger)
bn1 = mx.sym.BatchNorm(data=body, fix_gamma=False, use_global_stats=self.use_global_stats, eps=2e-5, momentum=bn_mom, name='bn1')
relu1 = mx.sym.Activation(data=bn1, act_type='relu', name='relu1')
#end of resnet
fc6_bias = mx.symbol.Variable('fc6_bias', lr_mult=b_lr_mult)
fc6_weight = mx.symbol.Variable('fc6_weight', lr_mult=w_lr_mult)
fc6 = mx.symbol.Convolution(data=relu1, kernel=(1, 1), pad=(0, 0), num_filter=1024, name="fc6",
bias=fc6_bias, weight=fc6_weight, workspace=workspace)
relu_fc6 = mx.sym.Activation(data=fc6, act_type='relu', name='relu_fc6')
score_bias = mx.symbol.Variable('score_bias', lr_mult=b_lr_mult)
score_weight = mx.symbol.Variable('score_weight', lr_mult=w_lr_mult)
score = mx.symbol.Convolution(data=relu_fc6, kernel=(1, 1), pad=(0, 0),dilate=(6,6), num_filter=num_class, name="score",
bias=score_bias, weight=score_weight, workspace=workspace)
upsamle_scale = 16 # upsample 4X
croped_score = mx.symbol.Deconvolution(
data=score, num_filter=num_class, kernel=(upsamle_scale * 2, upsamle_scale * 2),
stride=(upsamle_scale, upsamle_scale), num_group=num_class, no_bias=True,
name='upsampling', attr={'lr_mult': '0.0'}, workspace=workspace)
# magic Cropping
croped_score = mx.symbol.Crop(*[croped_score, data], offset=(8, 8), name='croped_score')
if is_train:
softmax = mx.symbol.SoftmaxOutput(data=croped_score, label=seg_cls_gt, normalization='valid',
multi_output=True,
use_ignore=True, ignore_label=255, name="softmax")
else:
softmax = mx.symbol.SoftmaxOutput(data=croped_score, normalization='valid', multi_output=True,
use_ignore=True,
ignore_label=255, name="softmax")
self.sym = softmax
return softmax
def get_symbol(self, class_num, is_train, pretrained=True):
self.is_train = is_train
self.use_global_stats = not is_train
if self.is_train:
logger.info("is_train: {}".format(self.is_train))
logger.info("use_global_stats: {}".format(self.use_global_stats))
data = mx.sym.Variable(name='data')
if self.is_train:
seg_cls_gt = mx.symbol.Variable(name='label')
resnet = gluon.model_zoo.vision.resnet101_v1(pretrained=pretrained)
net = nn.HybridSequential()
for layer in resnet.features[:6]:
net.add(layer)
with net.name_scope():
net.add(Bottleneck(1024, strides=2, in_channels=512))
for _ in range(23):
net.add(
DilatedBottleneck(channels=1024,
strides=1,
dilation=2,
in_channels=1024))
net.add(
nn.Conv2D(channels=2048, kernel_size=1, strides=1, padding=0))
for _ in range(3):
net.add(
DilatedBottleneck(channels=2048,
strides=1,
dilation=4,
in_channels=2048))
net.add(ASPP())
upsampling = nn.Conv2DTranspose(
channels=class_num,
kernel_size=32,
strides=16,
padding=8,
weight_initializer=mx.init.Bilinear(),
use_bias=False)
upsampling.collect_params().setattr("lr_mult", 0.0)
net.add(upsampling)
net.add(nn.BatchNorm())
data = mx.sym.var('data')
out = net(data)
croped_score = mx.symbol.Crop(*[out, data],
offset=(4, 4),
name='croped_score')
if is_train:
softmax = mx.symbol.SoftmaxOutput(data=croped_score,
label=seg_cls_gt,
normalization='valid',
multi_output=True,
use_ignore=True,
ignore_label=255,
name="softmax")
else:
softmax = mx.symbol.SoftmaxOutput(data=croped_score,
normalization='valid',
multi_output=True,
use_ignore=True,
ignore_label=255,
name="softmax")
self.sym = softmax
return softmax
def proceed_validation(ctx):
#logger.auto_set_dir()
test_data = get_data("val", DATA_DIR, LIST_DIR, len(ctx))
ctx = [mx.gpu(int(i)) for i in args.gpu.split(',')]
sym_instance = resnet101_deeplab_new()
# infer shape
val_provide_data = [[("data", (1, 3, tile_height, tile_width))]]
val_provide_label = [[("softmax_label", (1, 1, tile_height, tile_width))]]
data_shape_dict = {
'data': (1, 3, tile_height, tile_width),
'softmax_label': (1, 1, tile_height, tile_width)
}
eval_sym = sym_instance.get_symbol(NUM_CLASSES,
is_train=False,
use_global_stats=True)
sym_instance.infer_shape(data_shape_dict)
arg_params, aux_params = load_init_param(args.load, process=True)
sym_instance.check_parameter_shapes(arg_params,
aux_params,
data_shape_dict,
is_train=False)
data_names = ['data']
label_names = ['softmax_label']
# create predictor
predictor = Predictor(eval_sym,
data_names,
label_names,
context=ctx,
provide_data=val_provide_data,
provide_label=val_provide_label,
arg_params=arg_params,
aux_params=aux_params)
if args.vis:
from mxnetgo.myutils.fs import mkdir_p
vis_dir = os.path.join("fuck_vis")
mkdir_p(vis_dir)
stats = MIoUStatistics(NUM_CLASSES)
test_data.reset_state()
nbatch = 0
for data, label in tqdm(test_data.get_data()):
output_all = predict_scaler(data,
predictor,
scales=[0.5, 0.75, 1.0, 1.25, 1.5],
classes=NUM_CLASSES,
tile_size=(tile_height, tile_width),
is_densecrf=False,
nbatch=nbatch,
val_provide_data=val_provide_data,
val_provide_label=val_provide_label)
output_all = np.argmax(output_all, axis=0)
label = np.squeeze(label)
if args.vis:
m = np.array([104, 116, 122])
const_arr = np.resize(m, (1, 1, 3)) # NCHW
origin_img = data[0] + const_arr
cv2.imwrite(
os.path.join(vis_dir, "{}.jpg".format(nbatch)),
np.concatenate((
origin_img,
visualize_label(label),
np.dstack((label, label, label)),
visualize_label(output_all),
),
axis=1))
stats.feed(output_all, label) # very time-consuming
nbatch += 1
logger.info("mIoU: {}, meanAcc: {}, acc: {} ".format(
stats.mIoU, stats.mean_accuracy, stats.accuracy))
label_names = ['softmax_label']
# create predictor
predictor = Predictor(eval_sym,
data_names,
label_names,
context=ctx,
provide_data=val_provide_data,
provide_label=val_provide_label,
arg_params=arg_params,
aux_params=aux_params)
if args.vis:
from mxnetgo.myutils.fs import mkdir_p
vis_dir = os.path.join(logger.get_logger_dir(), "vis")
logger.info(" vis_dir: {}".format(vis_dir))
mkdir_p(vis_dir)
# load demo data
image_names = [
'frankfurt_000001_073088_leftImg8bit.png',
'lindau_000024_000019_leftImg8bit.png'
]
im = cv2.imread('demo/' + image_names[0],
cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
im = im[None, :, :, :].astype('float32') # extend one dimension
output_all = predict_scaler(im,
predictor,
scales=[1.0],
classes=config.dataset.NUM_CLASSES,
tile_size=(config.TEST.tile_height,
def resnext(self,
units,
num_stages,
filter_list,
num_classes,
is_train,
use_global_stats,
num_group,
bottle_neck=True,
b_lr_mult=2.0,
w_lr_mult=1.0,
bn_mom=0.9,
workspace=256,
memonger=False):
if is_train:
logger.info("is_train: {}".format(is_train))
logger.info("use_global_stats: {}".format(use_global_stats))
num_unit = len(units)
assert (num_unit == num_stages)
if is_train:
seg_cls_gt = mx.symbol.Variable(name='label')
data = mx.sym.Variable(name='data')
data = mx.sym.identity(data=data, name='id')
data = mx.sym.BatchNorm(data=data,
use_global_stats=use_global_stats,
fix_gamma=True,
eps=2e-5,
momentum=bn_mom,
name='bn_data')
# often expected to be 224 such as imagenet
body = mx.sym.Convolution(data=data,
num_filter=filter_list[0],
kernel=(7, 7),
stride=(2, 2),
pad=(3, 3),
no_bias=True,
name="conv0",
workspace=workspace)
body = mx.sym.BatchNorm(data=body,
use_global_stats=use_global_stats,
fix_gamma=False,
eps=2e-5,
momentum=bn_mom,
name='bn0')
body = mx.sym.Activation(data=body, act_type='relu', name='relu0')
body = mx.sym.Pooling(data=body,
kernel=(3, 3),
stride=(2, 2),
pad=(1, 1),
pool_type='max')
dilation = [1, 1, 2, 4]
for i in range(num_stages):
body = self.residual_unit(
body,
filter_list[i + 1],
(1 if i == 0 or i == 3 else 2, 1 if i == 0 or i == 3 else 2),
False,
use_global_stats=use_global_stats,
dilation=1,
name='stage%d_unit%d' % (i + 1, 1),
bottle_neck=bottle_neck,
num_group=num_group,
bn_mom=bn_mom,
workspace=workspace,
memonger=memonger)
for j in range(units[i] - 1):
body = self.residual_unit(body,
filter_list[i + 1], (1, 1),
True,
dilation=dilation[i],
name='stage%d_unit%d' %
(i + 1, j + 2),
use_global_stats=use_global_stats,
bottle_neck=bottle_neck,
num_group=num_group,
bn_mom=bn_mom,
workspace=workspace,
memonger=memonger)
fc6_bias = mx.symbol.Variable('fc6_bias', lr_mult=b_lr_mult)
fc6_weight = mx.symbol.Variable('fc6_weight', lr_mult=w_lr_mult)
fc6 = mx.symbol.Convolution(data=body,
kernel=(1, 1),
pad=(0, 0),
num_filter=1024,
name="fc6",
bias=fc6_bias,
weight=fc6_weight,
workspace=workspace)
relu_fc6 = mx.sym.Activation(data=fc6,
act_type='relu',
name='relu_fc6')
score_bias = mx.symbol.Variable('score_bias', lr_mult=b_lr_mult)
score_weight = mx.symbol.Variable('score_weight', lr_mult=w_lr_mult)
score = mx.symbol.Convolution(data=relu_fc6,
kernel=(1, 1),
dilate=(6, 6),
pad=(0, 0),
num_filter=num_classes,
name="score",
bias=score_bias,
weight=score_weight,
workspace=workspace)
upsamle_scale = 16 # upsample 4X
croped_score = mx.symbol.Deconvolution(data=score,
num_filter=num_classes,
kernel=(upsamle_scale * 2,
upsamle_scale * 2),
stride=(upsamle_scale,
upsamle_scale),
num_group=num_classes,
no_bias=True,
name='upsampling',
attr={'lr_mult': '0.0'},
workspace=workspace)
# magic Cropping
croped_score = mx.symbol.Crop(*[croped_score, data],
offset=(8, 8),
name='croped_score')
if is_train:
softmax = mx.symbol.SoftmaxOutput(data=croped_score,
label=seg_cls_gt,
normalization='valid',
multi_output=True,
use_ignore=True,
ignore_label=255,
name="softmax")
else:
softmax = mx.symbol.SoftmaxOutput(data=croped_score,
normalization='valid',
multi_output=True,
use_ignore=True,
ignore_label=255,
name="softmax")
self.sym = softmax
return softmax
