def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, groups=1): super(ConvBNReLU, self).__init__() padding = (kernel_size - 1) // 2 if groups == 1: conv = layers.Conv2d(in_channels, out_channels, kernel_size, stride, pad_mode='pad', padding=padding) else: conv = layers.Conv2d(in_channels, in_channels, kernel_size, stride, pad_mode='pad', padding=padding, group=in_channels) self.features = layers.SequentialLayer( [conv, layers.BatchNorm2d(out_channels), layers.ReLU6()])
def __init__(self, class_num=1000, growth_rate=12, block_config=(6, 12, 24, 16), bn_size=4, theta=0.5, bc=False): super(DenseNet, self).__init__() num_init_feature = 2 * growth_rate if bc: self.features = layers.SequentialLayer([ _conv3x3(3, num_init_feature, 1), _bn(num_init_feature), ReLU() ]) else: self.features = layers.SequentialLayer([ _conv7x7(3, num_init_feature, 2), _bn(num_init_feature), ReLU(), MaxPool2d(kernel_size=2, stride=2, pad_mode='same', data_format='NCHW') ]) num_feature = num_init_feature for i, num_layers in enumerate(block_config): self.features.append( _DenseBlock(num_layers, num_feature, bn_size, growth_rate)) num_feature = num_feature + growth_rate * num_layers if i != len(block_config) - 1: self.features.append( _Transition(num_feature, int(num_feature * theta))) num_feature = int(num_feature * theta) self.norm = _bn(num_feature) self.relu = ReLU() # self.features.append([_bn(num_feature),ReLU()]) self.mean = ReduceMean(keep_dims=True) self.flatten = layers.Flatten() self.end_point = _fc(num_feature, class_num)
def __init__(self, in_planes=3, ngf=64, n_layers=9, alpha=0.2, norm_mode='batch', dropout=True, pad_mode="CONSTANT"): super(ResNetGenerator, self).__init__() self.conv_in = ConvNormReLU(in_planes, ngf, 7, 1, alpha=alpha, norm_mode=norm_mode, pad_mode=pad_mode) self.down_1 = ConvNormReLU(ngf, ngf * 2, 3, 2, alpha, norm_mode) self.down_2 = ConvNormReLU(ngf * 2, ngf * 4, 3, 2, alpha, norm_mode) layer_list = [ ResidualBlock( ngf * 4, norm_mode, dropout=dropout, pad_mode=pad_mode) ] * n_layers self.residuals = layers.SequentialLayer(layer_list) self.up_2 = ConvTransposeNormReLU(ngf * 4, ngf * 2, 3, 2, alpha, norm_mode) self.up_1 = ConvTransposeNormReLU(ngf * 2, ngf, 3, 2, alpha, norm_mode) if pad_mode == "CONSTANT": self.conv_out = layers.Conv2d(ngf, 3, kernel_size=7, stride=1, pad_mode='pad', padding=3) else: pad = layers.Pad(paddings=((0, 0), (0, 0), (3, 3), (3, 3)), mode=pad_mode) conv = layers.Conv2d(ngf, 3, kernel_size=7, stride=1, pad_mode='pad') self.conv_out = layers.SequentialLayer([pad, conv]) self.activate = Tanh()
def __init__(self, in_channels, out_channels): super(_Transition, self).__init__() self.layer = layers.SequentialLayer([ _bn(in_channels), layers.ReLU(), _conv1x1(in_channels, out_channels), AvgPool2d(kernel_size=2, stride=2, pad_mode='same', data_format='NCHW') ])
def __init__(self, in_channels, growth_rate, bn_size): super(_DenseLayer, self).__init__() self.layer = layers.SequentialLayer([ _bn(in_channels), layers.ReLU(), _conv1x1(in_channels, bn_size * growth_rate), _bn(bn_size * growth_rate), layers.ReLU(), _conv3x3(bn_size * growth_rate, growth_rate), ]) self.ops = Concat(axis=1)
def test_sequential(): context.set_context(mode=context.GRAPH_MODE, device_target="CPU") net = layers.SequentialLayer([ layers.Conv2d(1, 6, 5, pad_mode='valid', weight_init="ones"), layers.ReLU(), layers.MaxPool2d(kernel_size=2, stride=2) ]) model = Model(net) model.compile() z = model.predict(ts.ones((1, 1, 32, 32))) print(z.asnumpy())
def __init__(self, input_channel=1280, class_num=1000, use_activation=False): super(MobileNetV2Head, self).__init__() # mobilenet head self.head = layers.SequentialLayer( ([GlobalAvgPooling(), layers.Dense(input_channel, class_num)])) self.use_activation = use_activation self.activation = Softmax() self._initialize_weights()
def __init__(self, features, class_num=1000): super(VGG, self).__init__() self.features = features self.flatten = layers.Flatten() self.classifier = layers.SequentialLayer([ layers.Dense(512 * 7 * 7, 4096), layers.ReLU(), layers.Dropout(), layers.Dense(4096, 4096), layers.ReLU(), layers.Dropout(), layers.Dense(4096, class_num), ])
def make_layers(cfg, batch_norm=False): Layers = [] in_channels = 3 for v in cfg: if v == 'M': Layers += [layers.MaxPool2d(kernel_size=2, stride=2)] else: conv2d = _conv3x3(in_channels, v) if batch_norm: Layers += [conv2d, layers.BatchNorm2d(v), layers.ReLU()] else: Layers += [conv2d, layers.ReLU()] in_channels = v return layers.SequentialLayer(Layers)
def __init__(self, in_planes=3, ndf=64, n_layers=3, alpha=0.2, norm_mode='batch'): super(Discriminator, self).__init__() kernel_size = 4 layer_list = [ layers.Conv2d(in_planes, ndf, kernel_size, 2, pad_mode='pad', padding=1), layers.LeakyReLU(alpha) ] nf_mult = ndf for i in range(1, n_layers): nf_mult_prev = nf_mult nf_mult = min(2**i, 8) * ndf layer_list.append( ConvNormReLU(nf_mult_prev, nf_mult, kernel_size, 2, alpha, norm_mode, padding=1)) nf_mult_prev = nf_mult nf_mult = min(2**n_layers, 8) * ndf layer_list.append( ConvNormReLU(nf_mult_prev, nf_mult, kernel_size, 1, alpha, norm_mode, padding=1)) layer_list.append( layers.Conv2d(nf_mult, 1, kernel_size, 1, pad_mode='pad', padding=1)) self.features = layers.SequentialLayer(layer_list)
def __init__(self, in_planes, out_planes, kernel_size=4, stride=2, alpha=0.2, norm_mode='batch', pad_mode='CONSTANT', use_relu=True, padding=None): super(ConvTransposeNormReLU, self).__init__() conv = layers.Conv2dTranspose(in_planes, out_planes, kernel_size, stride=stride, pad_mode='same') norm = layers.BatchNorm2d(out_planes) if norm_mode == 'instance': # Use BatchNorm2d with batchsize=1, affine=False, training=True instead of InstanceNorm2d norm = layers.BatchNorm2d(out_planes, affine=False) has_bias = (norm_mode == 'instance') if padding is None: padding = (kernel_size - 1) // 2 if pad_mode == 'CONSTANT': conv = layers.Conv2dTranspose(in_planes, out_planes, kernel_size, stride, pad_mode='same', has_bias=has_bias) layer_list = [conv, norm] else: paddings = ((0, 0), (0, 0), (padding, padding), (padding, padding)) pad = layers.Pad(paddings=paddings, mode=pad_mode) conv = layers.Conv2dTranspose(in_planes, out_planes, kernel_size, stride, pad_mode='pad', has_bias=has_bias) layer_list = [pad, conv, norm] if use_relu: relu = layers.ReLU() if alpha > 0: relu = layers.LeakyReLU(alpha) layer_list.append(relu) self.features = layers.SequentialLayer(layer_list)
def __init__(self, outer_nc, inner_nc, in_planes=None, dropout=False, submodule=None, outermost=False, innermost=False, alpha=0.2, norm_mode='batch'): super(UnetSkipConnectionBlock, self).__init__() downnorm = layers.BatchNorm2d(inner_nc) upnorm = layers.BatchNorm2d(outer_nc) use_bias = False if norm_mode == 'instance': downnorm = layers.BatchNorm2d(inner_nc, affine=False) upnorm = layers.BatchNorm2d(outer_nc, affine=False) use_bias = True if in_planes is None: in_planes = outer_nc downconv = layers.Conv2d(in_planes, inner_nc, kernel_size=4, stride=2, padding=1, has_bias=use_bias, pad_mode='pad') downrelu = layers.LeakyReLU(alpha) uprelu = layers.ReLU() if outermost: upconv = layers.Conv2dTranspose(inner_nc * 2, outer_nc, kernel_size=4, stride=2, padding=1, pad_mode='pad') down = [downconv] up = [uprelu, upconv, layers.Tanh()] model = down + [submodule] + up elif innermost: upconv = layers.Conv2dTranspose(inner_nc, outer_nc, kernel_size=4, stride=2, padding=1, has_bias=use_bias, pad_mode='pad') down = [downrelu, downconv] up = [uprelu, upconv, upnorm] model = down + up else: upconv = layers.Conv2dTranspose(inner_nc * 2, outer_nc, kernel_size=4, stride=2, padding=1, has_bias=use_bias, pad_mode='pad') down = [downrelu, downconv, downnorm] up = [uprelu, upconv, upnorm] model = down + [submodule] + up if dropout: model.append(layers.Dropout(0.5)) self.model = layers.SequentialLayer(model) self.skip_connections = not outermost self.concat = Concat(axis=1)
def __init__(self, in_channel, out_channel, stride=1): super(ResidualBlock, self).__init__() channel = out_channel // self.expansion self.conv1 = _conv1x1(in_channel, channel, stride=1) self.bn1 = _bn(channel) self.conv2 = _conv3x3(channel, channel, stride=stride) self.bn2 = _bn(channel) self.conv3 = _conv1x1(channel, out_channel, stride=1) self.bn3 = _bn_last(out_channel) self.relu = layers.ReLU() self.down_sample = False self.down_sample_layer = None if stride != 1 or in_channel != out_channel: self.down_sample = True if self.down_sample: self.down_sample_layer = layers.SequentialLayer( [_conv1x1(in_channel, out_channel, stride), _bn(out_channel)])
def __init__(self, width_mult=1., round_nearest=8, input_channel=32, last_channel=1280): super(MobileNetV2Backbone, self).__init__() # setting of inverted residual blocks self.cfgs = [ # t, c, n, s [1, 16, 1, 1], [6, 24, 2, 2], [6, 32, 3, 2], [6, 64, 4, 2], [6, 96, 3, 1], [6, 160, 3, 2], [6, 320, 1, 1], ] # building first layer input_channel = _make_divisible(input_channel * width_mult, round_nearest) self.last_channel = _make_divisible( last_channel * max(1.0, width_mult), round_nearest) backbone_layers = [ConvBNReLU(3, input_channel, stride=2)] # building inverted residual blocks for t, c, n, s in self.cfgs: output_channel = _make_divisible(c * width_mult, round_nearest) for i in range(n): stride = s if i == 0 else 1 backbone_layers.append( InvertedResidual(input_channel, output_channel, stride, expand_ratio=t)) input_channel = output_channel # building last several layers backbone_layers.append( ConvBNReLU(input_channel, self.last_channel, kernel_size=1)) self.backbone = layers.SequentialLayer(backbone_layers) self._initialize_weights()
def _make_layer(self, block, layer_num, in_channel, out_channel, stride): """ Make stage network of ResNet. Args: block (layers.Layer): Resnet block. layer_num (int): Layer number. in_channel (int): Input channel. out_channel (int): Output channel. stride (int): Stride size for the first convolutional layer. Returns: SequentialLayer, the output layer. Examples: >>> _make_layer(ResidualBlock, 3, 128, 256, 2) """ layer = layers.SequentialLayer([block(in_channel, out_channel, stride=stride)]) for _ in range(1, layer_num): resnet_block = block(out_channel, out_channel, stride=1) layer.append(resnet_block) return layer
def __init__(self, inp, oup, stride, expand_ratio): super(InvertedResidual, self).__init__() assert stride in [1, 2] hidden_dim = int(round(inp * expand_ratio)) self.use_res_connect = stride == 1 and inp == oup residual_layers = [] if expand_ratio != 1: residual_layers.append(ConvBNReLU(inp, hidden_dim, kernel_size=1)) residual_layers.extend([ ConvBNReLU(hidden_dim, hidden_dim, stride=stride, groups=hidden_dim), layers.Conv2d(hidden_dim, oup, kernel_size=1, stride=1, has_bias=False), layers.BatchNorm2d(oup), ]) self.conv = layers.SequentialLayer(residual_layers)