def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1): super(ConvBNReLU, self).__init__() padding = 0 conv = nn.Conv2d(in_planes, out_planes, kernel_size, stride, pad_mode='same', padding=padding) layers = [conv, _bn(out_planes), nn.ReLU()] self.features = nn.SequentialCell(layers)
def ms_conv2x2(in_channels, out_channels, stride=1, padding=0, pad_mode='same', has_bias=False): """Get a conv2d layer with 2x2 kernel size.""" init_value = weight_variable((out_channels, in_channels, 1, 1)) return nn.Conv2d(in_channels, out_channels, kernel_size=2, stride=stride, padding=padding, pad_mode=pad_mode, weight_init=init_value, has_bias=has_bias)
def _conv1x1(in_channel, out_channel, stride=1, use_se=False): if use_se: weight = _conv_variance_scaling_initializer(in_channel, out_channel, kernel_size=1) else: weight_shape = (out_channel, in_channel, 1, 1) weight = Tensor( kaiming_normal(weight_shape, mode="fan_out", nonlinearity='relu')) return nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, padding=0, pad_mode='same', weight_init=weight)
def __init__(self, cin, cout, kernel_size, stride=1, pad_mode="valid", padding=0, dilation=1, group=1, has_bias=True, weight_init='normal', bias_init='zeros'): super(Net, self).__init__() self.conv = nn.Conv2d(cin, cout, kernel_size, stride, pad_mode, padding, dilation, group, has_bias, weight_init, bias_init)
def conv_block(in_channels, out_channels, kernel_size, stride, dilation=1): """Get a conv2d batchnorm and relu layer""" pad_mode = 'same' padding = 0 return nn.SequentialCell([ nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, pad_mode=pad_mode), nn.BatchNorm2d(out_channels, momentum=0.1), nn.ReLU() ])
def __init__(self, in_str): a, b, c, d, e, f, g, h = in_str.strip().split() a = int(a) b = int(b) c = int(b) d = int(b) e = int(b) f = int(b) g = int(b) h = int(b) super(Net, self).__init__() self.conv = nn.Conv2d(a, b, c, pad_mode="valid") self.bn = nn.BatchNorm2d(d) self.relu = nn.ReLU() self.flatten = nn.Flatten() self.fc = nn.Dense(e * f * g, h)
def conv(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode='pad', has_bias=True): """weight initial for conv layer""" weight = weight_variable() return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, weight_init=weight, has_bias=has_bias, pad_mode=pad_mode)
def __init__(self, in_planes, out_planes, kernel_size, stride, padding, groups, norm_layer): weight_shape = (out_planes, in_planes, kernel_size, kernel_size) kaiming_weight, _ = Init_KaimingUniform(weight_shape, a=math.sqrt(5)) super(ConvBN, self).__init__( nn.Conv2d(in_planes, out_planes, kernel_size, stride, pad_mode='pad', padding=padding, group=groups, has_bias=False, weight_init=kaiming_weight), norm_layer(out_planes), )
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1, padding=0, pad_mode="same"): super(Conv2dBlock, self).__init__() self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, pad_mode=pad_mode, weight_init=weight_variable()) self.bn = nn.BatchNorm2d(out_channels, eps=0.001) self.relu = nn.ReLU()
def __init__(self, upsample_scales, mode="nearest", freq_axis_kernel_size=1, cin_pad=0, cin_channels=80): super(UpsampleNetwork, self).__init__() self.expand_op = P.ExpandDims() self.squeeze_op = P.Squeeze(1) up_layers = [] total_scale = np.prod(upsample_scales) self.indent = cin_pad * total_scale for scale in upsample_scales: freq_axis_padding = (freq_axis_kernel_size - 1) // 2 k_size = (freq_axis_kernel_size, scale * 2 + 1) padding = (freq_axis_padding, freq_axis_padding, scale, scale) stretch = Resize(scale, 1, mode) conv = nn.Conv2d(1, 1, kernel_size=k_size, has_bias=False, pad_mode='pad', padding=padding) up_layers.append(stretch) up_layers.append(conv) self.up_layers = nn.CellList(up_layers)
def __init__(self, cin, cout, kernel_size, stride=1, pad_mode='pad', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros'): super(Net, self).__init__() Tensor(np.ones([6, 3, 3, 3]).astype(np.float32) * 0.01) self.conv = nn.Conv2d(cin, cout, kernel_size, stride, pad_mode, padding, dilation, group, has_bias, weight_init, bias_init)
def __init__(self, in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros', has_bn=False, momentum=0.997, eps=1e-5, activation=None, alpha=0.2, after_fake=True): super(Conv2dBnAct, self).__init__() self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, pad_mode=pad_mode, padding=padding, dilation=dilation, group=group, has_bias=has_bias, weight_init=weight_init, bias_init=bias_init) self.has_bn = Validator.check_bool(has_bn, "has_bn") self.has_act = activation is not None self.after_fake = Validator.check_bool(after_fake, "after_fake") if has_bn: self.batchnorm = BatchNorm2d(out_channels, eps, momentum) if activation == "leakyrelu": self.activation = LeakyReLU(alpha) else: self.activation = get_activation(activation) if isinstance( activation, str) else activation if activation is not None and not isinstance( self.activation, (Cell, Primitive)): raise TypeError( "The activation must be str or Cell or Primitive," " but got {}.".format(activation))
def conv3x3(in_channels, out_channels, stride=1, groups=1, dilation=1, pad_mode="pad", padding=1): """3x3 convolution with padding""" return nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, pad_mode=pad_mode, group=groups, has_bias=False, dilation=dilation, padding=padding)
def _conv(in_channels, out_channels, kernel_size=3, stride=1, padding=0, pad_mode='pad'): """Conv2D wrapper.""" shape = (out_channels, in_channels, kernel_size, kernel_size) weights = weight_init_ones(shape) return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, pad_mode=pad_mode, weight_init=weights, has_bias=False)
def __init__(self, in_channels, out_channels, kernel_size, stride, padding): super(Conv2dBatch, self).__init__() # Parameters self.in_channels = in_channels self.out_channels = out_channels self.kernel_size = kernel_size self.stride = stride self.padding = padding self.conv = nn.Conv2d(self.in_channels, self.out_channels, self.kernel_size, self.stride, has_bias=False, pad_mode='pad', padding=self.padding) self.bn = nn.BatchNorm2d(self.out_channels, momentum=0.9, eps=1e-5)
def conv_bn_relu(in_channel, out_channel, kernel_size, stride, depthwise, activation='relu6'): output = [] output.append( nn.Conv2d(in_channel, out_channel, kernel_size, stride, pad_mode="same", group=1 if not depthwise else in_channel)) output.append(nn.BatchNorm2d(out_channel)) if activation: output.append(nn.get_activation(activation)) return nn.SequentialCell(output)
def __init__(self, cin, cout): super(Net, self).__init__() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="same") self.conv = nn.Conv2d(cin, cin, kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same") self.bn = nn.BatchNorm2d(cin, momentum=0.1, eps=0.0001) self.add = P.TensorAdd() self.relu = P.ReLU() self.mean = P.ReduceMean(keep_dims=True) self.reshape = P.Reshape() self.dense = nn.Dense(cin, cout)
def __init__(self, num_classes=10): super(ConvNet, self).__init__() self.conv1 = nn.Conv2d(3, ConvNet.output_ch, kernel_size=7, stride=2, pad_mode='pad', padding=3) self.bn1 = nn.BatchNorm2d(ConvNet.output_ch) self.relu = nn.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='pad', padding=1) self.flatten = nn.Flatten() self.fc = nn.Dense( int(ConvNet.image_h * ConvNet.image_w * ConvNet.output_ch / (4 * 4)), num_classes)
def __init__(self, in_channel, out_channel, kernel_size, stride=1, pad_mode='same', padding=0): super(BasicConv2d, self).__init__() self.conv = nn.Conv2d(in_channel, out_channel, kernel_size=kernel_size, stride=stride, pad_mode=pad_mode, padding=padding, weight_init=XavierUniform(), has_bias=True) self.bn = nn.BatchNorm2d(out_channel, eps=0.001, momentum=0.9997) self.relu = nn.ReLU()
def __init__(self, in_channel, out_channel, kernel_size=3, stride=1, use_bn=False, pad_mode='same'): super(Conv, self).__init__() self.conv = nn.Conv2d(in_channel, out_channel, kernel_size=kernel_size, stride=stride, padding=0, pad_mode=pad_mode, weight_init=TruncatedNormal(0.02)) self.bn = _bn(out_channel) self.Relu = nn.ReLU() self.use_bn = use_bn
def __init__(self, inchannels=512, num_anchors=3): super(LandmarkHead, self).__init__() weight_shape = (num_anchors * 10, inchannels, 1, 1) kaiming_weight, kaiming_bias = Init_KaimingUniform(weight_shape, a=math.sqrt(5), has_bias=True) self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 10, kernel_size=(1, 1), stride=1, padding=0, has_bias=True, weight_init=kaiming_weight, bias_init=kaiming_bias) self.permute = P.Transpose() self.reshape = P.Reshape()
def __init__(self, cin, cout, kernel_size, stride=1, pad_mode='pad', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros', strategy=None): super(NetConv, self).__init__() self.conv = nn.Conv2d(cin, cout, kernel_size, stride, pad_mode, padding, dilation, group, has_bias, weight_init, bias_init) self.conv.conv2d.shard(strategy)
def __init__(self, weight, in_channel, out_channel, kernel_size, stride=1, padding=0, has_bias=False, bias=None): super(Net, self).__init__() self.conv = nn.Conv2d(in_channels=in_channel, out_channels=out_channel, kernel_size=kernel_size, stride=stride, padding=padding, has_bias=has_bias, weight_init=weight, bias_init=bias)
def __init__(self, in_channels, out_chls, out_channels): super(YoloBlock, self).__init__() out_chls_2 = out_chls * 2 self.conv0 = _conv_bn_relu(in_channels, out_chls, ksize=1) self.conv1 = _conv_bn_relu(out_chls, out_chls_2, ksize=3) self.conv2 = _conv_bn_relu(out_chls_2, out_chls, ksize=1) self.conv3 = _conv_bn_relu(out_chls, out_chls_2, ksize=3) self.conv4 = _conv_bn_relu(out_chls_2, out_chls, ksize=1) self.conv5 = _conv_bn_relu(out_chls, out_chls_2, ksize=3) self.conv6 = nn.Conv2d(out_chls_2, out_channels, kernel_size=1, stride=1, has_bias=True)
def conv_bn_relu(in_channel, out_channel, use_bn=True, kernel_size=3, stride=1, pad_mode="same", activation='relu'): output = [] output.append( nn.Conv2d(in_channel, out_channel, kernel_size, stride, pad_mode=pad_mode)) if use_bn: output.append(nn.BatchNorm2d(out_channel)) if activation: output.append(nn.get_activation(activation)) return nn.SequentialCell(output)
def conv4x4(in_channels, out_channels, stride=1, groups=1, dilation=1, pad_mode="pad", padding=1, bias=True): """4x4 convolution with padding""" return nn.Conv2d(in_channels, out_channels, kernel_size=4, stride=stride, pad_mode=pad_mode, group=groups, has_bias=bias, dilation=dilation, padding=padding)
def _make_layer(base, batch_norm): """Make stage network of VGG.""" layers = [] in_channels = 3 for v in base: if v == 'M': layers += [nn.MaxPool2d(kernel_size=2, stride=2)] else: conv2d = nn.Conv2d(in_channels=in_channels, out_channels=v, kernel_size=3, padding=1, pad_mode='pad') if batch_norm: layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU()] else: layers += [conv2d, nn.ReLU()] in_channels = v return nn.SequentialCell(layers)
def _last_conv2d(in_channel, out_channel, kernel_size=3, stride=1, pad_mod='same', pad=0): in_channels = in_channel out_channels = in_channel depthwise_conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, pad_mode='same', padding=pad, group=in_channels) conv = _conv2d(in_channel, out_channel, kernel_size=1) return nn.SequentialCell( [depthwise_conv, _bn(in_channel), nn.ReLU6(), conv])
def _last_conv2d(in_channel, out_channel, kernel_size=3, stride=1, pad_mod='same', pad=0): depthwise_conv = nn.Conv2d(in_channel, in_channel, kernel_size, stride, pad_mode='same', padding=pad, has_bias=False, group=in_channel, weight_init='ones') conv = _conv2d(in_channel, out_channel, kernel_size=1) return nn.SequentialCell( [depthwise_conv, _bn(in_channel), nn.ReLU6(), conv])
def __init__(self, block, num_classes=100): super(ResNet50, self).__init__() weight_conv = Tensor(np.ones([64, 3, 7, 7]).astype(np.float32) * 0.01) self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, weight_init=weight_conv) self.bn1 = bn_with_initialize(64) self.relu = nn.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = MakeLayer3(block, in_channels=64, out_channels=256, stride=1) self.layer2 = MakeLayer4(block, in_channels=256, out_channels=512, stride=2) self.layer3 = MakeLayer6(block, in_channels=512, out_channels=1024, stride=2) self.layer4 = MakeLayer3(block, in_channels=1024, out_channels=2048, stride=2) self.avgpool = nn.AvgPool2d(7, 1) self.flatten = nn.Flatten() weight_fc = Tensor( np.ones([num_classes, 512 * block.expansion]).astype(np.float32) * 0.01) bias_fc = Tensor(np.ones([num_classes]).astype(np.float32) * 0.01) self.fc = nn.Dense(512 * block.expansion, num_classes, weight_init=weight_fc, bias_init=bias_fc)