def __init__(self, features, config, **kwargs):
super().__init__(**kwargs)
self.feature_layers = [4, 5, 6, 7]
self.feature_dims = [64, 128, 256, 512]
self.features = features
with self.name_scope():
# self.backbone = vision.resnet50_v1()
self.add_layers('reduce_dim', conv_bn_relu(64, 1),
conv_bn_relu(64, 1), conv_bn_relu(64, 1),
conv_bn_relu(64, 1))
self.add_layers(
'deconv',
nn.Conv2DTranspose(
64,
4,
strides=2,
padding=1,
weight_initializer=mx.initializer.MSRAPrelu(slope=0.1)),
nn.Conv2DTranspose(
64,
4,
strides=2,
padding=1,
weight_initializer=mx.initializer.MSRAPrelu(slope=0.1)),
nn.Conv2DTranspose(
64,
4,
strides=2,
padding=1,
weight_initializer=mx.initializer.MSRAPrelu(slope=0.1)))
self.add_layers('pred', self._prediction_head(),
self._prediction_head(), self._prediction_head(),
self._prediction_head())
self.flow = nn.HybridSequential(prefix='flow')
self.flow.add(
nn.Conv2D(64,
7,
padding=3,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.LeakyReLU(0.1))
self.flow.add(
nn.Conv2D(64,
7,
padding=3,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.LeakyReLU(0.1))
self.flow.add(
nn.Conv2D(64,
7,
padding=3,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.LeakyReLU(0.1))
def __init__(self, features, config, **kwargs):
super().__init__(**kwargs)
self.feature_layers = [4, 5, 6, 7]
self.feature_dims = [64, 128, 256, 512]
self.features = features
self.dilation = get_param(config, 'network.dilation', 1)
with self.name_scope():
# self.backbone = vision.resnet50_v1()
self.reduce_dim = nn.HybridSequential()
self.reduce_dim.add(nn.Conv2D(64, 1))
self.reduce_dim.add(nn.BatchNorm())
self.reduce_dim.add(nn.Activation('relu'))
self.reduce_dim_2 = nn.HybridSequential()
self.reduce_dim_2.add(nn.Conv2D(64, 1))
self.reduce_dim_2.add(nn.BatchNorm())
self.upsampler = Upsample(64, 2)
self.flow = nn.HybridSequential(prefix='flow')
self.flow.add(
nn.Conv2D(64,
7,
padding=3 * self.dilation,
dilation=self.dilation,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.LeakyReLU(0.1))
self.flow.add(
nn.Conv2D(32,
7,
padding=3 * self.dilation,
dilation=self.dilation,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.LeakyReLU(0.1))
self.flow.add(
nn.Conv2D(16,
7,
padding=3 * self.dilation,
dilation=self.dilation,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.LeakyReLU(0.1))
self.flow.add(
nn.Conv2D(2,
7,
padding=3 * self.dilation,
dilation=self.dilation,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
def _conv2d_bn(filter,
kernel,
dilation,
padding,
stride,
num_sync_bn_devices=-1):
"""A common conv-bn-leakyrelu cell"""
cell = nn.HybridSequential(prefix='')
cell.add(
nn.Conv2D(filter,
kernel_size=kernel,
dilation=dilation,
strides=stride,
padding=padding,
weight_initializer=Xavier(rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros'))
if num_sync_bn_devices < 1:
cell.add(nn.BatchNorm(epsilon=1e-5, momentum=0.9))
else:
cell.add(
gluon.contrib.nn.SyncBatchNorm(epsilon=1e-5,
momentum=0.9,
num_devices=num_sync_bn_devices))
cell.add(nn.Activation('relu'))
return cell
def __init__(self, bert_out_dim, params=None):
super(CoAttention, self).__init__(bert_out_dim)
with self.name_scope():
self.w4c = gluon.nn.Dense(units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False)
self.w4q = gluon.nn.Dense(units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False)
self.w4mlu = self.params.get('linear_kernel',
shape=(1, 1, int(bert_out_dim)),
init=mx.init.Xavier())
self.bias = self.params.get('coattention_bias',
shape=(1, ),
init=mx.init.Zero())
def __init__(self, batchSize):
self.net = SSDv1()
self.net.initialize(init=Xavier(), ctx=self.ctx)
self.batchSize = batchSize
self.trainIter = image.ImageDetIter(batch_size=self.batchSize, data_shape=(3, 300, 300),
path_imgrec='utils/TrainY.rec', path_imgidx='utils/TrainY.idx',)
self.trainer = gluon.Trainer(self.net.collect_params(), 'sgd', {'learning_rate': 0.1, 'wd': 5e-4})
def __init__(self, **kwargs):
super(CoAttention, self).__init__(**kwargs)
with self.name_scope():
self.w4c = gluon.nn.Dense(units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False)
self.w4q = gluon.nn.Dense(units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False)
self.w4mlu = self.params.get('linear_kernel',
shape=(1, 1,
opt.emb_encoder_conv_channels),
init=mx.init.Xavier())
self.bias = self.params.get('coattention_bias',
shape=(1, ),
init=mx.init.Zero())
def __init__(self, **kwargs):
super(CoAttention, self).__init__(**kwargs)
with self.name_scope():
self.w4c = gluon.nn.Dense(
units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False
)
self.w4q = gluon.nn.Dense(
units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False
)
self.w4mlu = self.params.get(
'linear_kernel', shape=(1, 1, EMB_ENCODER_CONV_CHANNELS), init=mx.init.Xavier())
self.bias = self.params.get(
'coattention_bias', shape=(1,), init=mx.init.Zero())
def __init__(self, freeze=False, batch_norm=False, **kwargs):
super(E2FAR, self).__init__(**kwargs)
with self.name_scope():
self.layers = [2, 2, 3, 3]
self.filters = [64, 128, 256, 512]
self.hidden_units = [4096, 1024]
self.backbone = self._make_features([2, 2, 3, 3],
[64, 128, 256, 512],
batch_norm)
self.extra_backbone = self._make_features([3], [512], batch_norm)
self.conv6 = gluon.nn.Conv2D(512,
kernel_size=5,
strides=2,
padding=1,
weight_initializer=Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros')
self.conv7 = gluon.nn.Conv2D(512,
kernel_size=1,
weight_initializer=Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros')
self.conv8 = gluon.nn.Conv2D(512,
kernel_size=1,
weight_initializer=Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros')
self.shape_regressor = self._make_prediction(out_dim=199)
self.exp_regressor = self._make_prediction(out_dim=29)
if freeze:
for _, w in self.backbone.collect_params().items():
w.grad_req = 'null'
for _, w in self.extra_backbone.collect_params().items():
w.grad_req = 'null'
def _conv2d(filter, kernel, dilation, padding, stride):
"""A common conv-bn-leakyrelu cell"""
cell = nn.HybridSequential(prefix='')
cell.add(nn.Conv2D(filter, kernel_size=kernel, dilation=dilation,
strides=stride, padding=padding,
weight_initializer=Xavier(rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros'))
cell.add(nn.Activation('relu'))
return cell
def __init__(self, channels, **kwargs):
super().__init__(**kwargs)
with self.name_scope():
self.deconv = nn.Conv2DTranspose(channels,
4,
strides=2,
padding=1,
weight_initializer=Xavier(
rnd_type='gaussian',
magnitude=2))
self.reduce_dim = nn.Conv2D(channels,
1,
use_bias=False,
weight_initializer=Xavier(
rnd_type='gaussian', magnitude=2))
self.conv = nn.Conv2D(channels,
3,
padding=1,
weight_initializer=Xavier(
rnd_type='gaussian', magnitude=2))
def init_model(self, is_train=True):
"""
Initialized the model
:param is_train:
:return:
"""
if self.args.pretrained_mode == 0 and os.path.exists(
self.args.model_path):
# load imagenet pretrained model
print('load pretrained model from %s...' % self.args.model_path)
self.inference.init_imagenet_params(self.args.model_path, self.ctx)
elif self.args.pretrained_mode == 1 and os.path.exists(
self.args.model_path):
# load webface pretrained model
print('load pretrained model from %s...' % self.args.model_path)
self.inference.init_convs_params(self.args.model_path, self.ctx)
elif self.args.pretrained_mode == 2 and os.path.exists(
self.args.model_path):
print('load pretrained model from %s...' % self.args.model_path)
self.inference.load_parameters(self.args.model_path,
ctx=self.ctx,
allow_missing=True)
self.inference.init_extra_params(self.ctx)
elif self.args.pretrained_mode == 3 and os.path.exists(
self.args.model_path):
print('load pretrained model from %s...' % self.args.model_path)
self.inference.load_parameters(self.args.model_path, ctx=self.ctx)
model_name, cur_epoch, cur_iter = (os.path.splitext(
os.path.basename(self.args.model_path))[0]).split('-')
self.args.start_epoch = int(cur_epoch)
self.cur_iter = int(cur_iter)
self.cur_epoch = int(cur_epoch)
elif self.args.model_path.endswith('.params') or not is_train:
# load from the path
print('load model from the %s...' % self.args.model_path)
# self.inference.load_parameters(self.args.model_path, ctx=self.ctx, ignore_extra=True)
self.inference.load_parameters(self.args.model_path,
ctx=self.ctx,
ignore_extra=True)
elif self.args.start_epoch > 0:
# load from the previous checkpoint
model_path = os.path.join(
self.args.ckpt_dir,
'%s-epoch-%d.params' % (self.args.arch, self.args.start_epoch))
print('load the model for the epoch [%d] from %s...' %
(self.args.start_epoch, model_path))
self.inference.load_parameters(model_path, self.ctx)
else:
# random initialize
print('initialize the model using Xavier initializer...')
self.inference.initialize(Xavier(rnd_type='gaussian',
factor_type='out',
magnitude=2),
ctx=self.ctx)
def _make_features(self, layers, filters, batch_norm, step):
featurizer = nn.HybridSequential(prefix='')
count = 0
for i, num in enumerate(layers):
for _ in range(num):
if count not in step_spec[step]:
conv_layer = nn.QConv2D(filters[i],
kernel_size=3,
padding=1,
weight_initializer=Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros',
bits=1,
apply_scaling=True)
featurizer.add(conv_layer)
featurizer.add(nn.Dropout(rate=0.25))
featurizer.add(nn.Activation('relu'))
else:
conv_layer = nn.Conv2D(filters[i],
kernel_size=3,
padding=1,
weight_initializer=Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros')
featurizer.add(conv_layer)
featurizer.add(nn.Dropout(rate=0.25))
featurizer.add(nn.Activation('relu'))
count += 1
if batch_norm:
featurizer.add(nn.BatchNorm())
featurizer.add(nn.MaxPool2D(strides=2))
return featurizer
def get_base_net(self):
"""
获取base net，默认是mobilenet v2
:return: base net，基础网络
"""
base_net = get_model('mobilenet1.0', pretrained=True)
with base_net.name_scope():
base_net.output = Dense(units=self.n_class) # 全连接层
base_net.output.initialize(Xavier(), ctx=self.ctx) # 初始化
base_net.collect_params().reset_ctx(self.ctx)
base_net.hybridize()
return base_net
def __init__(self, layers, filters, batch_norm=False, **kwargs):
super(VGGAtrousBase, self).__init__(**kwargs)
assert len(layers) == len(filters)
self.init = {
'weight_initializer':
Xavier(rnd_type='gaussian', factor_type='out', magnitude=2),
'bias_initializer':
'zeros'
}
with self.name_scope():
# we use pre-trained weights from caffe, initial scale must change
init_scale = mx.nd.array([0.229, 0.224, 0.225]).reshape(
(1, 3, 1, 1)) * 255
self.init_scale = self.params.get_constant('init_scale',
init_scale)
self.stages = nn.HybridSequential()
for l, f in zip(layers, filters):
stage = nn.HybridSequential(prefix='')
with stage.name_scope():
for _ in range(l):
stage.add(
nn.Conv2D(f, kernel_size=3, padding=1,
**self.init))
if batch_norm:
stage.add(nn.BatchNorm())
stage.add(nn.Activation('relu'))
self.stages.add(stage)
# self.stages have [stage1, stage2, stage3, stage4, stage5] now
# the stride are [1 , 2 , 4 , 8 , 16] before max pool.
# use dilated convolution instead of dense layers
stage = nn.HybridSequential(prefix='dilated_')
with stage.name_scope():
stage.add(
nn.Conv2D(1024,
kernel_size=3,
padding=6,
dilation=6,
**self.init))
if batch_norm:
stage.add(nn.BatchNorm())
stage.add(nn.Activation('relu'))
stage.add(nn.Conv2D(1024, kernel_size=1, **self.init))
if batch_norm:
stage.add(nn.BatchNorm())
stage.add(nn.Activation('relu'))
self.stages.add(stage)
# self.stages ==>[stage1, ..., stage5, stage6(the dense layers in vgg)].
# the stride of stage6 is 32.
# normalize layer for 4-th and 5-th stage
self.norm4 = Normalize(filters[3], 10)
self.norm5 = Normalize(filters[4], 8)
def __init__(self, features, **kwargs):
super().__init__(**kwargs)
self.feature_layers = [4, 5, 6, 7]
self.feature_dims = [64, 128, 256, 512]
self.features = features
with self.name_scope():
# self.backbone = vision.resnet50_v1()
self.reduce_dim = nn.Conv2D(1024, 1, use_bias=False)
self.flow = nn.HybridSequential(prefix='flow')
self.flow.add(
nn.Conv2D(1024,
3,
padding=1,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.Activation('relu'))
self.flow.add(
nn.Conv2D(1024,
3,
padding=1,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.Activation('relu'))
self.flow.add(
nn.Conv2D(512,
3,
padding=1,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
self.flow.add(nn.Activation('relu'))
self.upbranch4 = TopDownBranch(self.feature_dims[2])
self.upbranch3 = TopDownBranch(self.feature_dims[1])
self.upbranch2 = TopDownBranch(self.feature_dims[0])
self.output5 = nn.Conv2D(2, 3, padding=1)
self.output4 = nn.Conv2D(2, 3, padding=1)
self.output3 = nn.Conv2D(2, 3, padding=1)
self.output2 = nn.Conv2D(2, 3, padding=1)
def get_base_net(ctx):
"""
获取base net，默认是mobilenet v2
:param ctx: 运行环境，cpu or gpu，默认cpu
:return: base net，基础网络
"""
base_net = get_model('mobilenet1.0', pretrained=True)
with base_net.name_scope():
base_net.output = Dense(units=27) # 全连接层
base_net.output.initialize(Xavier(), ctx=ctx) # 初始化
base_net.collect_params().reset_ctx(ctx)
base_net.hybridize()
return base_net
def __init__(self, bert_out_dim, concat_out=True, params=None):
super(CoAttention, self).__init__("co_attention")
self.concat_out = concat_out
with self.name_scope():
self.w4c = gluon.nn.Dense(units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False)
self.w4q = gluon.nn.Dense(units=1,
flatten=False,
weight_initializer=Xavier(),
use_bias=False)
self.w4mlu = self.params.get('linear_kernel',
shape=(1, 1, bert_out_dim),
init=mx.init.Xavier())
self.bias = self.params.get('coattention_bias',
shape=(1, ),
init=mx.init.Zero())
if not self.concat_out:
self.out_weight = self.params.get('weight_of_output',
shape=(1, 4),
init=mx.init.Xavier())
def __init__(self, num_heads, **kwargs):
super(SelfAttention, self).__init__(**kwargs)
with self.name_scope():
self.attention = MultiHeadAttentionCell(
num_heads=num_heads,
base_cell=DotProductAttentionCell(scaled=True,
dropout=opt.layers_dropout,
use_bias=False),
query_units=opt.emb_encoder_conv_channels,
key_units=opt.emb_encoder_conv_channels,
value_units=opt.emb_encoder_conv_channels,
use_bias=False,
weight_initializer=Xavier())
def train(params, loader, model=None):
epoch = params.get('epoch', 10)
verbose = params.get("verbose", True)
batch_size = params.get("batch_size", 32)
if model is None:
class_name = params["class_name"]
layer_num = params.get("layer_num", 5)
class_num = params.get("class_num", 3)
s = params.get("s", 4)
b = params.get("b", 2)
yolo = Yolo(layer_num, class_num, s=s, b=b, class_name=class_name)
yolo.initialize(init=Xavier(magnitude=0.02))
else:
print("model load finish")
layer_num = model.layer_num
class_num = model.class_num
s = model.s
b = model.b
yolo = model
if verbose:
print("train params: \n\tepoch:%d \n\tlayer_num:%d \n\tclass_num:%d \n\ts:%d \n\tb:%d" % \
(epoch, layer_num, class_num, s, b))
ngd = optimizer.SGD(momentum=0.7, learning_rate=0.005)
trainer = gluon.Trainer(yolo.collect_params(), ngd)
for ep in range(epoch):
loader.reset()
mean_loss = 0
t1 = time()
for i, batch in enumerate(loader):
x = batch.data[0]
y = batch.label[0].reshape((-1, 5))
y = translate_y(y, yolo.s, yolo.b, yolo.class_num)
y = nd.array(y)
with autograd.record():
loss_func = TotalLoss(s=s, c=class_num, b=b)
ypre = yolo(x) # (32,output_dim)
loss = nd.mean(loss_func(ypre, y))
mean_loss += loss.asscalar()
loss.backward()
trainer.step(batch_size)
t2 = time()
if verbose:
print("epoch:%d/%d loss:%.5f time:%4f" %
(ep + 1, epoch, mean_loss / 32, t2 - t1),
flush=True)
print()
return yolo
def _make_features(self, layers, filters, batch_norm):
featurizer = nn.HybridSequential(prefix='')
for i, num in enumerate(layers):
for _ in range(num):
featurizer.add(nn.Conv2D(filters[i], kernel_size=3, padding=1,
weight_initializer=Xavier(rnd_type='gaussian',
factor_type='out',
magnitude=2),
bias_initializer='zeros'))
if batch_norm:
featurizer.add(nn.BatchNorm())
featurizer.add(nn.Activation('relu'))
featurizer.add(nn.MaxPool2D(strides=2))
return featurizer
def __init__(self):
super(Matting_Decoder,self).__init__()
self.trans = nn.HybridSequential(prefix='')
self.trans.add(nn.Conv2D(channels=512,kernel_size=1))
self.trans.add(nn.BatchNorm())
channels = [512,256,128,64,64]
self.dec_layers = []
for i,c in enumerate(channels):
block = nn.HybridSequential(prefix='decove_{0}'.format(6-i))
block.add(nn.Conv2D(channels=c,kernel_size=5,padding=2,
weight_initializer=Xavier(rnd_type='gaussian', factor_type='out', magnitude=2),
bias_initializer='zeros'))
block.add(nn.BatchNorm())
block.add(nn.Activation('relu'))
self.dec_layers.append(block)
self.alpha_block = nn.HybridSequential()
self.alpha_block.add(nn.Conv2D(channels=1,kernel_size=5,padding=2,
weight_initializer=Xavier(rnd_type='gaussian', factor_type='out', magnitude=2),
bias_initializer='zeros'))
self.alpha_block.add(nn.BatchNorm())
self.alpha_block.add(nn.Activation('relu'))
def __init__(self, kernel_size, num_filters, conv_layers, num_heads,
total_layers, sub_layer_idx, **kwargs):
super(OneEncoderBlock, self).__init__(**kwargs)
self.position_encoder = PositionEncoder()
self.convs = gluon.nn.HybridSequential()
with self.convs.name_scope():
for _ in range(conv_layers):
one_conv_module = gluon.nn.HybridSequential()
with one_conv_module.name_scope():
one_conv_module.add(gluon.nn.LayerNorm(epsilon=1e-06))
one_conv_module.add(gluon.nn.Dropout(opt.layers_dropout))
one_conv_module.add(
DepthwiseConv(kernel_size=kernel_size,
num_filters=num_filters,
input_channels=num_filters))
one_conv_module.add(
StochasticDropoutLayer(
dropout=(sub_layer_idx / total_layers) *
(1 - opt.p_l)))
sub_layer_idx += 1
self.convs.add(one_conv_module)
with self.name_scope():
self.dropout = gluon.nn.Dropout(opt.layers_dropout)
self.attention = SelfAttention(num_heads=num_heads)
self.attention_dropout = StochasticDropoutLayer(
(sub_layer_idx / total_layers) * (1 - opt.p_l))
sub_layer_idx += 1
self.attention_layer_norm = gluon.nn.LayerNorm(epsilon=1e-06)
self.positionwise_ffn = gluon.nn.HybridSequential()
with self.positionwise_ffn.name_scope():
self.positionwise_ffn.add(gluon.nn.LayerNorm(epsilon=1e-06))
self.positionwise_ffn.add(
gluon.nn.Dropout(rate=opt.layers_dropout))
self.positionwise_ffn.add(
gluon.nn.Dense(units=opt.emb_encoder_conv_channels,
activation='relu',
use_bias=True,
weight_initializer=MSRAPrelu(),
flatten=False))
self.positionwise_ffn.add(
gluon.nn.Dense(units=opt.emb_encoder_conv_channels,
use_bias=True,
weight_initializer=Xavier(),
flatten=False))
self.positionwise_ffn.add(
StochasticDropoutLayer(dropout=(sub_layer_idx / total_layers) *
(1 - opt.p_l)))
def _init_weight(self, name, arr):
if name in self._kwargs.keys():
init_params = self._kwargs[name]
for (k, v) in init_params.items():
if k.lower() == "normal":
random.normal(0, v, out=arr)
elif k.lower() == "uniform":
random.uniform(-v, v, out=arr)
elif k.lower() == "orthogonal":
raise NotImplementedError("Not support at the moment")
elif k.lower() == "xavier":
xa = Xavier(v[0], v[1], v[2])
xa(name, arr)
else:
raise NotImplementedError("Not support")
def __init__(self,spec,stage):
super(Encoder_Decoder,self).__init__()
self.stage = stage
self.encoder = Matting_Encoder(spec=spec)
self.decoder = Matting_Decoder()
self.refine = nn.HybridSequential(prefix='refine')
channels = [64,64,64,1]
with self.refine.name_scope():
for i,c in enumerate(channels):
self.refine.add(nn.Conv2D(channels=64,kernel_size=3,
weight_initializer=Xavier(),
bias_initializer='zeros'))
self.refine.add(nn.BatchNorm())
self.refine.add(nn.Activation('relu'))
def __init__(self, num_heads, **kwargs):
super(SelfAttention, self).__init__(**kwargs)
with self.name_scope():
self.attention = MultiHeadAttentionCell(
num_heads=num_heads,
base_cell=DotProductAttentionCell(
scaled=True,
dropout=0.1,
use_bias=False
),
query_units=EMB_ENCODER_CONV_CHANNELS,
key_units=EMB_ENCODER_CONV_CHANNELS,
value_units=EMB_ENCODER_CONV_CHANNELS,
use_bias=False,
weight_initializer=Xavier()
)
def __init__(self, features, config, **kwargs):
super().__init__(**kwargs)
self.scale = get_param(config, 'network.scale')
with self.name_scope():
self.flow = nn.HybridSequential(prefix='flow')
act_param = get_param(config, 'network.activation', dict())
act_func = self._builder(lambda: nn.Activation('relu'),
**act_param)
weight_init_param = get_param(config, 'network.weight_init',
dict())
weight_init_func = self._builder(
lambda: Xavier(rnd_type='gaussian', magnitude=2),
**weight_init_param)
self.flow.add(
nn.Conv2D(32,
7,
padding=3,
weight_initializer=weight_init_func()))
self.flow.add(act_func())
self.flow.add(
nn.Conv2D(64,
7,
padding=3,
weight_initializer=weight_init_func()))
self.flow.add(act_func())
self.flow.add(
nn.Conv2D(32,
7,
padding=3,
weight_initializer=weight_init_func()))
self.flow.add(act_func())
self.flow.add(
nn.Conv2D(16,
7,
padding=3,
weight_initializer=weight_init_func()))
self.flow.add(act_func())
self.flow.add(
nn.Conv2D(2,
7,
padding=3,
weight_initializer=weight_init_func()))
def train2(params, loader: BaseDataLoader, model=None):
epoch = params.get('epoch', 10)
verbose = params.get("verbose", True)
batch_size = params.get("batch_size", 32)
if model is None:
layer_num = params.get("layer_num", 5)
class_num = params.get("class_num", 3)
s = params.get("s", 4)
b = params.get("b", 2)
yolo = Yolo(layer_num, class_num, s=s, b=b)
yolo.initialize(init=Xavier(magnitude=0.02))
else:
print("model load finish")
layer_num = model.layer_num
class_num = model.class_num
s = model.s
b = model.b
yolo = model
if verbose:
print("train params: \n\tepoch:%d \n\tlayer_num:%d \n\tclass_num:%d \n\ts:%d \n\tb:%d" % \
(epoch, layer_num, class_num, s, b))
ngd = optimizer.SGD(momentum=0.7, learning_rate=0.0025)
trainer = gluon.Trainer(yolo.collect_params(), ngd)
for ep in range(epoch):
loss = 0
all_batch = int(loader.data_number() / batch_size)
t1 = time()
for _ in range(all_batch):
x, y = loader.next_batch(batch_size)
with autograd.record():
loss_func = TotalLoss(s=s, c=class_num, b=b)
ypre = yolo(x) # (32,output_dim)
loss = nd.mean(loss_func(ypre, y))
loss.backward()
trainer.step(batch_size)
t2 = time()
if verbose:
print("epoch:%d/%d loss:%.5f time:%4f" %
(ep + 1, epoch, loss.asscalar(), t2 - t1),
flush=True)
return yolo
def __init__(self, in_channels, out_channels, kernel_size, strides,
padding, use_bias, use_bn, bn_use_global_stats, **kwargs):
super(VGGConv, self).__init__(**kwargs)
self.use_bn = use_bn
with self.name_scope():
self.conv = nn.Conv2D(channels=out_channels,
kernel_size=kernel_size,
strides=strides,
padding=padding,
use_bias=use_bias,
weight_initializer=Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=2),
in_channels=in_channels)
if self.use_bn:
self.bn = nn.BatchNorm(in_channels=out_channels,
use_global_stats=bn_use_global_stats)
self.activ = nn.Activation('relu')
def __init__(self, layers, filters, batch_norm=False, **kwargs):
super(VGGBase, self).__init__(**kwargs)
assert len(layers) == len(filters)
self.init = {
'weight_initializer':
Xavier(rnd_type='gaussian', factor_type='out', magnitude=2),
'bias_initializer':
'zeros'
}
self.layers = layers
self.batch_norm = batch_norm
with self.name_scope():
self.stages = nn.HybridSequential()
for l, f in zip(layers, filters):
stage = nn.HybridSequential(prefix='')
with stage.name_scope():
for _ in range(l):
stage.add(
nn.Conv2D(f, kernel_size=3, padding=1,
**self.init))
if batch_norm:
stage.add(nn.BatchNorm())
stage.add(nn.Activation('relu'))
self.stages.add(stage)
# use convolution instead of dense layers
stage = nn.HybridSequential(prefix='fc_')
with stage.name_scope():
stage.add(
nn.Conv2D(1024, kernel_size=3, padding=1,
**self.init)) # fc6
if batch_norm:
stage.add(nn.BatchNorm())
stage.add(nn.Activation('relu'))
stage.add(nn.Conv2D(1024, kernel_size=1, **self.init)) # fc7
if batch_norm:
stage.add(nn.BatchNorm())
stage.add(nn.Activation('relu'))
self.stages.add(stage)
def __init__(self, features, config, **kwargs):
super().__init__(**kwargs)
self.feature_layers = [4, 5, 6, 7]
self.feature_dims = [64, 128, 256, 512]
self.features = features
config = Reader(config)
with self.name_scope():
# self.backbone = vision.resnet50_v1()
self.reduce_dim = nn.HybridSequential()
self.reduce_dim.add(nn.Conv2D(64, 1))
self.reduce_dim.add(nn.BatchNorm())
self.reduce_dim.add(nn.Activation('relu'))
channels = config.network.flow.channels.get([64, 32, 16, 2])
self.flow = nn.HybridSequential(prefix='flow')
for i, c in enumerate(channels):
if i != 0:
self.flow.add(nn.LeakyReLU(0.1))
self.flow.add(
nn.Conv2D(c,
7,
padding=3,
weight_initializer=Xavier(rnd_type='gaussian',
magnitude=2)))
