def __init__(self,
in_channels,
out_channels,
bn_use_global_stats,
reduction=16,
**kwargs):
super(PreSEAttBlock, self).__init__(**kwargs)
mid_cannels = out_channels // reduction
with self.name_scope():
self.bn = nn.BatchNorm(in_channels=in_channels,
use_global_stats=bn_use_global_stats)
self.relu = nn.Activation("relu")
self.conv1 = conv1x1(in_channels=in_channels,
out_channels=mid_cannels,
use_bias=True)
self.conv2 = conv1x1(in_channels=mid_cannels,
out_channels=out_channels,
use_bias=True)
self.sigmoid = nn.Activation("sigmoid")
def __init__(self, num_category, **kwargs):
super(Net1, self).__init__(**kwargs)
with self.name_scope():
# layers created in name_scope will inherit name space
# from parent layer.
self.bn = nn.BatchNorm()
self.dropout = nn.Dropout(0.3)
self.fc1 = nn.Dense(4096, activation="relu")
self.fc2 = nn.Dense(num_category)
self.image_lstm = gluon.rnn.LSTM(hidden_size=1024, num_layers=5)
'''
self.lstm_cell = [gluon.rnn.LSTMCell(hidden_size=100) for i in range(5)]
self.h = [nd.random.uniform(shape=(15, 100)) for i in range(5)]
self.c = [nd.random.uniform(shape=(15, 100)) for i in range(5)]
'''
self.question_lstm = gluon.rnn.LSTM(hidden_size=100, num_layers=12)
self.image_fc = nn.Dense(1024, activation="relu")
self.question_fc = nn.Dense(1024, activation="relu")
self.ctx = gb.try_gpu()
def __init__(self,
in_channels,
out_channels,
kernel_size,
padding,
bn_use_global_stats,
**kwargs):
super(DarkConv, self).__init__(**kwargs)
with self.name_scope():
self.conv = nn.Conv2D(
channels=out_channels,
kernel_size=kernel_size,
padding=padding,
use_bias=False,
in_channels=in_channels)
self.bn = nn.BatchNorm(
in_channels=out_channels,
use_global_stats=bn_use_global_stats)
# self.bn = nn.BatchNorm(in_channels=out_channels, momentum=0.01)
self.activ = nn.LeakyReLU(alpha=0.1)
def __init__(self, class_num,ctx):
super(FCNx8, self).__init__()
self.desc = "fcnx8"
with self.name_scope():
self.encode = EncodeNet_gluoncv(ctx)
self.decode = nn.Sequential(prefix="decode")
self.decode.add(
nn.Conv2D(channels=512,kernel_size=3,padding=1,strides=1),
nn.BatchNorm(),
nn.Activation("relu"),
nn.Dropout(0.1),
nn.Conv2D(channels=class_num,kernel_size=1,padding=0,strides=1)
)
for layer in self.decode:
if isinstance(layer,nn.Conv2D):
layer.initialize(init=mx.init.Xavier(), ctx=ctx)
else:
layer.initialize(ctx=ctx)
self.decode.collect_params().setattr('lr_mult',10)
self.upscale = 8
def _add_conv(out,
channels=1,
kernel=1,
stride=1,
pad=0,
num_group=1,
active=True,
batchnorm=True):
out.add(SamePadding(kernel, stride, dilation=(1, 1)))
out.add(
nn.Conv2D(channels,
kernel,
stride,
pad,
groups=num_group,
use_bias=False))
if batchnorm:
out.add(nn.BatchNorm(scale=True, momentum=0.99, epsilon=1e-3))
if active:
out.add(nn.Swish())
def __init__(self,
kernel_size,
channels_out,
channels_in=0,
strides=1,
with_bn=True,
**kwargs):
super(convolution, self).__init__(**kwargs)
paddings = (kernel_size -
1) // 2 # determine paddings to keep resolution unchanged
with self.name_scope():
self.conv = nn.Conv2D(
channels_out,
kernel_size,
strides,
paddings,
in_channels=channels_in,
use_bias=not with_bn) # infer input shape if not specified
self.bn = nn.BatchNorm(
in_channels=channels_out) if with_bn else nn.Sequential()
def __init__(self, num_classes, **kwargs):
super(ResNet, self).__init__(**kwargs)
with self.name_scope():
b1 = nn.Conv2D(16, kernel_size=3, strides=1, padding=1)
b2 = nn.Sequential()
for _ in range(8):
b2.add(Residual(16))
b3 = nn.Sequential()
b3.add(Residual(32, same_shape=False))
for _ in range(7):
b3.add(Residual(32))
b4 = nn.Sequential()
b4.add(Residual(64, same_shape=False))
for _ in range(7):
b4.add(Residual(64))
b5 = nn.Sequential()
b5.add(nn.BatchNorm(), nn.Activation(activation="relu"),
nn.AvgPool2D(pool_size=8), nn.Dense(num_classes))
self.net = nn.Sequential()
self.net.add(b1, b2, b3, b4, b5)
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 resnet18(num_classes):
net = nn.HybridSequential()
net.add(nn.Conv2D(64, kernel_size=3, strides=1, padding=1),
nn.BatchNorm(), nn.Activation('relu'))
def resnet_block(num_channels, num_residuals, first_block=False):
blk = nn.HybridSequential()
for i in range(num_residuals):
if i == 0 and not first_block:
blk.add(Residual(num_channels, use_1x1conv=True, strides=2))
else:
blk.add(Residual(num_channels))
return blk
net.add(resnet_block(64, 2, first_block=True),
resnet_block(128, 2),
resnet_block(256, 2),
resnet_block(512, 2))
net.add(nn.GlobalAvgPool2D(), nn.Dense(num_classes))
return net
def get_spatial_temporal_conv(in_filters, out_filter, stride, use_bias=False):
blk = nn.Sequential()
i = 3 * in_filters * out_filter * 3 * 3
i /= in_filters * 3 * 3 + 3 * out_filter
middle_filters = int(i)
#print("Number of middle filters: {0}".format(middle_filters))
blk.add(
nn.Conv3D(channels=middle_filters,
kernel_size=(1, 3, 3),
strides=(1, stride[0], stride[1]),
padding=(0, 1, 1),
use_bias=use_bias), nn.BatchNorm(),
nn.Activation(activation='relu'),
nn.Conv3D(channels=out_filter,
kernel_size=(3, 1, 1),
strides=(stride[0], 1, 1),
padding=(1, 0, 0),
use_bias=use_bias))
return blk
def __init__(self, block, layers, channels, classes=10, **kwargs):
super(CIFARResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.Conv2D(channels[0], 3, 1, 1, use_bias=False))
self.features.add(nn.BatchNorm())
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(
self._make_layer(block,
num_layer,
channels[i + 1],
stride,
i + 1,
in_channels=channels[i]))
self.features.add(nn.GlobalAvgPool2D())
self.output = nn.Dense(classes, in_units=channels[-1])
def __init__(self,
channels,
stride,
downsample=False,
in_channels=0,
init=True,
**kwargs):
super(BasicBlockV2, self).__init__(**kwargs)
self.channels = channels
self.stride = stride
self.in_channels = in_channels
self.bn = nn.BatchNorm()
self.body = nn.HybridSequential(prefix='')
self.downsample = None
if downsample:
self.downsample = nn.HybridSequential(prefix='')
if init:
self._init()
def __init__(self, num_dilation, **kwargs):
super(MultiLayerDilation, self).__init__(**kwargs)
self.conv1 = nn.Conv2D(channels=512, kernel_size=3, dilation=num_dilation, padding=num_dilation)
self.conv2 = nn.Conv2D(channels=512, kernel_size=3, dilation=num_dilation, padding=num_dilation)
self.conv3 = nn.Conv2D(channels=512, kernel_size=3, dilation=num_dilation, padding=num_dilation)
self.conv4 = nn.Conv2D(channels=256, kernel_size=3, dilation=num_dilation, padding=num_dilation)
self.conv5 = nn.Conv2D(channels=128, kernel_size=3, dilation=num_dilation, padding=num_dilation)
self.conv6 = nn.Conv2D(channels=64, kernel_size=3, dilation=num_dilation, padding=num_dilation)
self.bn1 = nn.BatchNorm()
self.bn2 = nn.BatchNorm()
self.bn3 = nn.BatchNorm()
self.bn4 = nn.BatchNorm()
self.bn5 = nn.BatchNorm()
self.bn6 = nn.BatchNorm()
def conv(channels,
k_size=4,
stride=2,
pad=1,
bn=True,
drop_out=True,
p=0.2,
ReLU=True,
sequential=True):
layers = []
if ReLU:
layers += [
nn.Conv2D(channels=channels,
strides=stride,
kernel_size=k_size,
padding=pad,
activation='relu',
use_bias=False)
]
else:
layers += [
nn.Conv2D(channels=channels,
strides=stride,
kernel_size=k_size,
padding=pad,
use_bias=False)
]
if bn:
layers += [nn.BatchNorm()]
if drop_out:
layers += [nn.Dropout(p)]
if sequential:
out = nn.HybridSequential()
for layer in layers:
out.add(layer)
return out
else:
return layers
def __init__(self, k, scale,
activation='relu',
normalization='batch'):
super(Discriminator, self).__init__()
self.alpha = 0
self.scale=scale
self.activation = activation
self.normalization = normalization
i=0
self.network = dict()
name = f'fromrgb_growth'
self.network[name] = nn.HybridSequential(prefix=name)
with self.network[name].name_scope():
self.network[name].add(nn.Conv2D(nf(scale), 3, 1, 1, use_bias=True))
self.network[name].add(nn.LeakyReLU(0.2))
name = f'fromrgb_main'
self.network[name] = nn.HybridSequential(prefix=name)
with self.network[name].name_scope():
self.network[name].add(nn.Conv2D(nf(scale-1), 3, 1, 1, use_bias=True))
self.network[name].add(nn.LeakyReLU(0.2))
for i in range(scale, 1, -1):
name = f'growth_{i}'
self.network[name] = nn.HybridSequential(prefix=name)
with self.network[name].name_scope():
self.network[name].add(nn.Conv2D(nf(i-1), 3, 1, 1, use_bias=False))
if 'batch' in normalization: self.network[name].add(nn.BatchNorm())
self.network[name].add(nn.LeakyReLU(0.2))
self.network[name].add(nn.MaxPool2D())
self.network['downscale'] = nn.HybridSequential()
self.network['downscale'].add(nn.MaxPool2D())
self.network['result'] = nn.HybridSequential()
self.network['result'].add(nn.Conv2D(1000, 1, 1, 0, use_bias=True))
self.network['result'].add(nn.Conv2D(1, 1, 1, 0, use_bias=True))
def __init__(self, growthRate, depth, reduction, nClasses, bottleneck):
super(DenseNet, self).__init__()
nDenseBlocks = (depth - 4) // 3
if bottleneck:
nDenseBlocks //= 2
nChannels = 2 * growthRate
with self.name_scope():
self.conv1 = nn.Conv2D(nChannels,
kernel_size=3,
padding=1,
use_bias=False,
weight_initializer=init.Normal(
math.sqrt(2. / nChannels)))
self.dense1 = self._make_dense(growthRate, nDenseBlocks,
bottleneck)
nChannels += nDenseBlocks * growthRate
nOutChannels = int(math.floor(nChannels * reduction))
with self.name_scope():
self.trans1 = Transition(nOutChannels)
nChannels = nOutChannels
with self.name_scope():
self.dense2 = self._make_dense(growthRate, nDenseBlocks,
bottleneck)
nChannels += nDenseBlocks * growthRate
nOutChannels = int(math.floor(nChannels * reduction))
with self.name_scope():
self.trans2 = Transition(nOutChannels)
nChannels = nOutChannels
with self.name_scope():
self.dense3 = self._make_dense(growthRate, nDenseBlocks,
bottleneck)
nChannels += nDenseBlocks * growthRate
with self.name_scope():
self.bn1 = nn.BatchNorm()
self.fc = nn.Dense(nClasses)
def __init__(self, **kwargs):
super(colorize_net, self).__init__(**kwargs)
with self.name_scope():
self.bn0 = nn.BatchNorm()
self.conv0 = nn.Conv2D(256, 1, activation='relu')
self.bn1 = nn.BatchNorm()
self.conv1 = nn.Conv2D(128, 3, padding=1, activation='relu')
self.bn2 = nn.BatchNorm()
self.conv2 = nn.Conv2D(64, 3, padding=1, activation='relu')
self.bn3 = nn.BatchNorm()
self.conv3 = nn.Conv2D(64, 3, padding=1, activation='relu')
self.bn4 = nn.BatchNorm()
self.conv4 = nn.Conv2D(32, 3, padding=1, activation='relu')
self.bn5 = nn.BatchNorm()
self.conv5 = nn.Conv2D(2, 3, padding=1, activation='sigmoid')
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 down_sample_blk(num_filters):
'''
nn.MaxPool2D(2) halves the height and width of the input.
Pass the output from down_sample_blk to cls_predictor,
the 3x3 conv in cls_predictor actually covers a 10x10 area in
the input of down_sample_blk.
E.g.
x x x required input for a 3x3 conv in cls_predictor
y y y y y y before MaxPool2D(2)
z z z z z z z z required input for a 3x3 conv in down_sample_blk
0 1 2 3 4 5 6 7 8 9 required input for a 3x3 conv in down_sample_blk
'''
blk = nn.HybridSequential()
for _ in range(2):
blk.add(nn.Conv2D(channels=num_filters, kernel_size=3, padding=1),
nn.BatchNorm(in_channels=num_filters), nn.Activation('relu'))
blk.add(nn.MaxPool2D(2))
blk.hybridize()
return blk
def conv_act_layer(in_channels,
prefix,
num,
kernel_size,
padding,
stride=1,
use_bn=False):
'''
prefix = 'conv'+ str(layer num)+'_'
'''
net = nn.HybridSequential()
net.add(
nn.Conv2D(channels=in_channels,
kernel_size=kernel_size,
strides=stride,
padding=padding,
prefix='{}{}_'.format(prefix, num)))
if use_bn:
net.add(nn.BatchNorm(prefix='{}{}_'.format(prefix, num)))
net.add(nn.Activation('relu', prefix='{}relu_{}_'.format(prefix, num)))
return net
def __init__(self, block, layers, channels, classes=1000, thumbnail=False, **kwargs):
super(ResNetV1, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if thumbnail:
self.features.add(_conv3x3x3(channels[0], 1, 3))
else:
self.features.add(nn.Conv3D(channels[0], 3, 1, 1, use_bias=False,
in_channels=1)) ## hu :in_channels=3-->1
self.features.add(nn.BatchNorm())
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool3D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1],
stride, i+1, in_channels=channels[i]))
self.features.add(nn.GlobalAvgPool3D())
self.output = nn.Dense(classes, in_units=channels[-1])
def __init__(self,
in_channels,
out_channels,
kernel_size,
strides=1,
padding=0,
groups=1,
bn_use_global_stats=False,
**kwargs):
super(ConvBlock, self).__init__(**kwargs)
with self.name_scope():
self.conv = nn.Conv2D(channels=out_channels,
kernel_size=kernel_size,
strides=strides,
padding=padding,
groups=groups,
use_bias=False,
in_channels=in_channels)
self.bn = nn.BatchNorm(in_channels=out_channels,
use_global_stats=bn_use_global_stats)
self.activ = nn.Activation('relu')
def resnet18(num_classes):
"""A slightly modified ResNet-18 model"""
def resnet_block(num_channels, num_residuals, first_block=False):
blk = nn.Sequential()
for i in range(num_residuals):
if i == 0 and not first_block:
blk.add(d2l.Residual(num_channels, use_1x1conv=True,
strides=2))
else:
blk.add(d2l.Residual(num_channels))
return blk
net = nn.Sequential()
# This model uses a smaller convolution kernel, stride, and padding and
# removes the maximum pooling layer
net.add(nn.Conv2D(64, kernel_size=3, strides=1, padding=1), nn.BatchNorm(),
nn.Activation('relu'))
net.add(resnet_block(64, 2, first_block=True), resnet_block(128, 2),
resnet_block(256, 2), resnet_block(512, 2))
net.add(nn.GlobalAvgPool2D(), nn.Dense(num_classes))
return net
def __init__(self, channels, **kwargs):
super(FeatureFusionMoudle, self).__init__(**kwargs)
self.block = nn.HybridSequential()
with self.block.name_scope():
self.block.add(
nn.Conv2D(in_channels=channels,
channels=channels,
kernel_size=3,
strides=1,
padding=1))
self.block.add(nn.BatchNorm())
self.block.add(nn.Activation('relu'))
self.pool = nn.GlobalAvgPool2D()
self.conv1 = nn.Conv2D(in_channels=channels,
channels=channels,
kernel_size=1,
strides=1)
self.conv2 = nn.Conv2D(in_channels=channels,
channels=channels,
kernel_size=1,
strides=1)
def __init__(self):
super(SRGenerator, self).__init__()
self.conv1 = nn.Conv2D(64,
kernel_size=3,
strides=1,
padding=1,
activation='relu')
self.res_block = nn.HybridSequential()
with self.name_scope():
for i in range(16):
self.res_block.add(ResnetBlock())
self.res_block.add(
nn.Conv2D(64,
kernel_size=3,
strides=1,
padding=1,
use_bias=False), nn.BatchNorm())
self.subpix_block1 = SubpixelBlock()
self.subpix_block2 = SubpixelBlock()
self.conv4 = nn.Conv2D(3, kernel_size=1, strides=1, activation='tanh')
def __init__(self, opt):
super(RNNText, self).__init__()
with self.name_scope():
if opt.model == 'lstm':
self.rnn = rnn.LSTM(opt.num_hidden,
opt.num_layers,
bidirectional=opt.bidirectional,
dropout=opt.drop)
elif opt.model == 'gru':
self.rnn = rnn.GRU(opt.num_hidden,
opt.num_layers,
bidirectional=opt.bidirectional,
dropout=opt.drop)
elif opt.model == 'rnn':
self.rnn = rnn.RNN(opt.num_hidden,
opt.num_layers,
dropout=opt.drop)
else:
raise NotImplementedError
self.fc = nn.Dense(opt.num_hidden * 2)
self.bn = nn.BatchNorm()
def __init__(self, channels=64, r=4):
super(ResGlobLocaforGlobLocaChaFuse, self).__init__()
inter_channels = int(channels // r)
with self.name_scope():
self.local_att = nn.HybridSequential(prefix='local_att')
self.local_att.add(nn.Conv2D(inter_channels, kernel_size=1, strides=1, padding=0))
self.local_att.add(nn.BatchNorm())
self.local_att.add(nn.Activation('relu'))
self.local_att.add(nn.Conv2D(channels, kernel_size=1, strides=1, padding=0))
self.local_att.add(nn.BatchNorm())
self.global_att = nn.HybridSequential(prefix='global_att')
self.global_att.add(nn.GlobalAvgPool2D())
self.global_att.add(nn.Conv2D(inter_channels, kernel_size=1, strides=1, padding=0))
self.global_att.add(nn.BatchNorm())
self.global_att.add(nn.Activation('relu'))
self.global_att.add(nn.Conv2D(channels, kernel_size=1, strides=1, padding=0))
self.global_att.add(nn.BatchNorm())
self.local_att2 = nn.HybridSequential(prefix='local_att2')
self.local_att2.add(nn.Conv2D(inter_channels, kernel_size=1, strides=1, padding=0))
self.local_att2.add(nn.BatchNorm())
self.local_att2.add(nn.Activation('relu'))
self.local_att2.add(nn.Conv2D(channels, kernel_size=1, strides=1, padding=0))
self.local_att2.add(nn.BatchNorm())
self.global_att2 = nn.HybridSequential(prefix='global_att2')
self.global_att2.add(nn.GlobalAvgPool2D())
self.global_att2.add(nn.Conv2D(inter_channels, kernel_size=1, strides=1, padding=0))
self.global_att2.add(nn.BatchNorm())
self.global_att2.add(nn.Activation('relu'))
self.global_att2.add(nn.Conv2D(channels, kernel_size=1, strides=1, padding=0))
self.global_att2.add(nn.BatchNorm())
self.sig1 = nn.Activation('sigmoid')
self.sig2 = nn.Activation('sigmoid')
def __init__(self,
in_channels,
out_channels,
kernel_size,
strides,
padding,
activate=True,
**kwargs):
super(DartsConv, self).__init__(**kwargs)
self.activate = activate
with self.name_scope():
if self.activate:
self.activ = nn.Activation("relu")
self.conv = nn.Conv2D(channels=out_channels,
kernel_size=kernel_size,
strides=strides,
padding=padding,
use_bias=False,
in_channels=in_channels)
self.bn = nn.BatchNorm(in_channels=out_channels)
def change_scale(self, ctx):
self.scale += 1
self.network[f'fromrgb_main'] = self.network[f'fromrgb_growth']
name = f'fromrgb_growth'
self.network[name] = nn.HybridSequential(prefix=name)
with self.network[name].name_scope():
self.network[name].add(nn.Conv2D(nf(self.scale), 3, 1, 1, use_bias=True))
self.network[name].add(nn.LeakyReLU(0.2))
name = f'growth_{self.scale}'
self.network[name] = nn.HybridSequential()
with self.network[name].name_scope():
self.network[name].add(nn.Conv2D(nf(self.scale-1), 3, 1, 1, use_bias=False))
if 'batch' in self.normalization: self.network[name].add(nn.BatchNorm())
self.network[name].add(nn.LeakyReLU(0.2))
self.network[name].add(nn.MaxPool2D())
self.network[f'fromrgb_growth'].collect_params().initialize(mx.init.Xavier(magnitude=2.24), ctx=ctx)
self.network[f'growth_{self.scale}'].collect_params().initialize(mx.init.Xavier(magnitude=2.24), ctx=ctx)
def _add_conv(out,
channels=1,
kernel=1,
stride=1,
pad=0,
num_group=1,
active=True,
lite=False):
out.add(
nn.Conv2D(channels,
kernel,
stride,
pad,
groups=num_group,
use_bias=False))
out.add(nn.BatchNorm(scale=True, momentum=0.99, epsilon=1e-3))
if active:
if lite:
out.add(ReLU6())
else:
out.add(nn.Swish())
