def __init__(self, cin, cout, stride=1, dilation=1): super(BasicBlock, self).__init__() self.conv_bn_act = nn.Conv2dBnAct(cin, cout, kernel_size=3, stride=stride, pad_mode='pad', padding=dilation, has_bias=False, dilation=dilation, has_bn=True, momentum=BN_MOMENTUM, activation='relu', after_fake=False) self.conv_bn = nn.Conv2dBnAct(cout, cout, kernel_size=3, stride=1, pad_mode='same', has_bias=False, dilation=dilation, has_bn=True, momentum=BN_MOMENTUM, activation=None) self.relu = ops.ReLU()
def __init__(self, cin, cout, up_f=2, enable_dcn=False): super(IDAUp, self).__init__() self.enable_dcn = enable_dcn if enable_dcn: self.proj = DeformConv(cin, cout) self.node = DeformConv(cout, cout) else: self.proj = nn.Conv2dBnAct(cin, cout, kernel_size=1, stride=1, pad_mode='same', has_bias=False, has_bn=True, momentum=BN_MOMENTUM, activation='relu', after_fake=False) self.node = nn.Conv2dBnAct(2 * cout, cout, kernel_size=3, stride=1, pad_mode='same', has_bias=False, has_bn=True, momentum=BN_MOMENTUM, activation='relu', after_fake=False) self.up = nn.Conv2dTranspose(cout, cout, up_f * 2, stride=up_f, pad_mode='pad', padding=up_f // 2) self.concat = ops.Concat(axis=1)
def __init__(self, num_class=10, channel=1): super(LeNet5, self).__init__() self.type = "fusion" self.num_class = num_class # change `nn.Conv2d` to `nn.Conv2dBnAct` self.conv1 = nn.Conv2dBnAct(channel, 6, 5, pad_mode='valid', has_bn=True, activation='relu') self.conv2 = nn.Conv2dBnAct(6, 16, 5, pad_mode='valid', has_bn=True, activation='relu') # change `nn.Dense` to `nn.DenseBnAct` self.fc1 = nn.DenseBnAct(16 * 5 * 5, 120, activation='relu') self.fc2 = nn.DenseBnAct(120, 84, activation='relu') self.fc3 = nn.DenseBnAct(84, self.num_class) self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2) self.flatten = nn.Flatten()
def __init__(self, inp, oup, stride, expend_ratio): super(InvertedResidual, self).__init__() self.stride = stride assert stride in [1, 2] hidden_dim = int(inp * expend_ratio) self.use_res_connect = self.stride == 1 and inp == oup if expend_ratio == 1: self.conv = nn.SequentialCell([ nn.Conv2dBnAct(hidden_dim, hidden_dim, 3, stride, group=hidden_dim, batchnorm=True, activation='relu6'), nn.Conv2dBnAct(hidden_dim, oup, 1, 1, batchnorm=True) ]) else: self.conv = nn.SequentialCell([ nn.Conv2dBnAct(inp, hidden_dim, 1, 1, batchnorm=True, activation='relu6'), nn.Conv2dBnAct(hidden_dim, hidden_dim, 3, stride, group=hidden_dim, batchnorm=True, activation='relu6'), nn.Conv2dBnAct(hidden_dim, oup, 1, 1, batchnorm=True) ]) self.add = P.TensorAdd()
def __init__(self, in_channel, out_channel, stride=1): super(ResidualBlock, self).__init__() channel = out_channel // self.expansion self.conv1 = ConvBNReLU(in_channel, channel, kernel_size=1, stride=1) self.conv2 = ConvBNReLU(channel, channel, kernel_size=3, stride=stride) self.conv3 = nn.Conv2dBnAct(channel, out_channel, kernel_size=1, stride=1, pad_mode='same', padding=0, has_bn=True, activation='relu') self.down_sample = False if stride != 1 or in_channel != out_channel: self.down_sample = True self.down_sample_layer = None if self.down_sample: self.down_sample_layer = nn.Conv2dBnAct(in_channel, out_channel, kernel_size=1, stride=stride, pad_mode='same', padding=0, has_bn=True, activation='relu') self.add = P.TensorAdd() self.relu = P.ReLU()
def __init__(self, num_class=10): super(LeNet5, self).__init__() self.num_class = num_class self.conv1 = nn.Conv2dBnAct(1, 6, kernel_size=5, has_bn=True, activation='relu', pad_mode="valid") self.conv2 = nn.Conv2dBnAct(6, 16, kernel_size=5, activation='relu', pad_mode="valid") self.fc1 = nn.DenseBnAct(16 * 5 * 5, 120, activation='relu') self.fc2 = nn.DenseBnAct(120, 84, activation='relu') self.fc3 = nn.DenseBnAct(84, self.num_class) self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2) self.flatten = nn.Flatten()
def __init__(self, nclass, activation='prelu', drop_out=.1, phase='train'): super(EPRNet, self).__init__() self.phase = phase self.shape = P.Shape() self.stem = nn.Conv2dBnAct(3, 16, 3, 2, 'pad', 1, weight_init='xavier_uniform', has_bn=True, activation=activation) self.layer1 = nn.SequentialCell([ _EPRModule(16, 32, atrous_rates=(1, 2, 4), activation=activation), _EPRModule(32, 32, atrous_rates=(1, 2, 4), activation=activation, down_sample=True) ]) self.layer2 = nn.SequentialCell([ _EPRModule(32, 64, atrous_rates=(3, 6, 9), activation=activation), _EPRModule(64, 64, atrous_rates=(3, 6, 9), activation=activation), _EPRModule(64, 64, atrous_rates=(3, 6, 9), activation=activation), _EPRModule(64, 64, atrous_rates=(3, 6, 9), activation=activation, down_sample=True) ]) self.layer3 = nn.SequentialCell([ _EPRModule(64, 128, atrous_rates=(7, 13, 19), activation=activation), _EPRModule(128, 128, atrous_rates=(13, 25, 37), activation=activation) ]) self.stern_conv1 = nn.Conv2dBnAct(128, 128, 3, 1, 'pad', 1, weight_init='xavier_uniform', has_bn=True, activation=activation) self.stern_drop = nn.Dropout(drop_out) if drop_out else None self.stern_conv2 = nn.Conv2d(128, nclass, 1, weight_init='xavier_uniform')
def __init__(self, in_channels, out_channles, atrous_rates, activation='prelu'): super(_MPUnit, self).__init__() self.mpu0 = nn.Conv2dBnAct(in_channels, out_channles, 1, weight_init='xavier_uniform', has_bn=True, activation=activation) self.mpu1 = nn.Conv2dBnAct(in_channels, out_channles, 3, 1, 'pad', padding=atrous_rates[0], dilation=atrous_rates[0], group=in_channels, weight_init='xavier_uniform', has_bn=True, activation=activation) self.mpu2 = nn.Conv2dBnAct(in_channels, out_channles, 3, 1, 'pad', padding=atrous_rates[1], dilation=atrous_rates[1], group=in_channels, weight_init='xavier_uniform', has_bn=True, activation=activation) self.mpu3 = nn.Conv2dBnAct(in_channels, out_channles, 3, 1, 'pad', padding=atrous_rates[2], dilation=atrous_rates[2], group=in_channels, weight_init='xavier_uniform', has_bn=True, activation=activation) self.proj = nn.Conv2dBnAct(4 * out_channles, out_channles, 1, weight_init='xavier_uniform', has_bn=True, activation=activation) self.concat = P.Concat(axis=1)
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 layers = [] if expand_ratio != 1: layers.append(ConvBNReLU(inp, hidden_dim, kernel_size=1)) layers.extend([ # dw ConvBNReLU(hidden_dim, hidden_dim, stride=stride, groups=hidden_dim), # pw-linear nn.Conv2dBnAct(hidden_dim, oup, kernel_size=1, stride=1, pad_mode='pad', padding=0, group=1, has_bn=True) ]) self.conv = nn.SequentialCell(layers) self.add = P.TensorAdd()
def __init__(self, in_channels, out_channels, atrous_rates, activation='prelu', down_sample=False): super(_EPRModule, self).__init__() stride = 2 if down_sample else 1 self.pyramid = _MPUnit(in_channels, out_channels, atrous_rates, activation) self.compact = nn.Conv2dBnAct(out_channels, out_channels, 3, stride, 'pad', 1, weight_init='xavier_uniform', has_bn=True, activation=activation) if (out_channels != in_channels) or down_sample: self.skip = nn.Conv2d(in_channels, out_channels, 1, stride=stride, weight_init='xavier_uniform') self.skip_bn = nn.BatchNorm2d(out_channels) else: self.skip = None self.act = nn.ReLU() self.add = P.Add()
def _conv_bn(in_channel, out_channel, ksize, stride=1): """Get a conv2d batchnorm and relu layer.""" return nn.SequentialCell([ nn.Conv2dBnAct(in_channel, out_channel, kernel_size=ksize, stride=stride, batchnorm=True) ])
def __init__(self, levels, channels, block=BasicBlock, residual_root=False): super(DLA34, self).__init__() self.channels = channels self.base_layer = nn.Conv2dBnAct(3, channels[0], kernel_size=7, stride=1, pad_mode='same', has_bias=False, has_bn=True, momentum=BN_MOMENTUM, activation='relu', after_fake=False) self.level0 = self._make_conv_level(channels[0], channels[0], levels[0]) self.level1 = self._make_conv_level(channels[0], channels[1], levels[1], stride=2) self.level2 = Tree(levels[2], block, channels[1], channels[2], 2, level_root=False, root_residual=residual_root) self.level3 = Tree(levels[3], block, channels[2], channels[3], 2, level_root=True, root_residual=residual_root) self.level4 = Tree(levels[4], block, channels[3], channels[4], 2, level_root=True, root_residual=residual_root) self.level5 = Tree(levels[5], block, channels[4], channels[5], 2, level_root=True, root_residual=residual_root) self.dla_fn = [ self.level0, self.level1, self.level2, self.level3, self.level4, self.level5 ]
def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1): super(ConvBNReLU, self).__init__() padding = (kernel_size - 1) // 2 self.conv = nn.Conv2dBnAct(in_planes, out_planes, kernel_size, stride=stride, pad_mode='pad', padding=padding, group=groups, has_bn=True, activation='relu')
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.Conv2dBnAct(out_chls_2, out_channels, kernel_size=1, stride=1, has_bias=True, has_bn=False, activation=None, after_fake=False)
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.Conv2dBnAct(in_channels, out_channels, kernel_size, stride=stride, pad_mode=pad_mode, padding=padding, dilation=dilation, has_bn=True, momentum=0.9, activation='relu')
def _make_conv_level(self, cin, cout, convs, stride=1, dilation=1): modules = [] for i in range(convs): modules.append( nn.Conv2dBnAct(cin, cout, kernel_size=3, stride=stride if i == 0 else 1, pad_mode='pad', padding=dilation, has_bias=False, dilation=dilation, has_bn=True, momentum=BN_MOMENTUM, activation='relu', after_fake=False)) cin = cout return nn.SequentialCell(modules)
def _conv_bn_relu(in_channel, out_channel, ksize, stride=1, padding=0, dilation=1, alpha=0.1, momentum=0.9, eps=1e-5, pad_mode="same"): """Get a conv2d batchnorm and relu layer""" return nn.Conv2dBnAct(in_channel, out_channel, ksize, stride=stride, pad_mode=pad_mode, padding=padding, dilation=dilation, has_bn=True, momentum=momentum, eps=eps, activation='leakyrelu', alpha=alpha)
def __init__(self, in_channels, out_channels, kernel_size, stride=1, pad_mode='valid', padding=0, has_bias=False, weight_init="XavierUniform", bias_init='zeros'): super(Conv2d, self).__init__() self.conv = nn.Conv2dBnAct(in_channels, out_channels, kernel_size, stride=stride, pad_mode=pad_mode, padding=padding, weight_init=weight_init, bias_init=bias_init, has_bias=has_bias, has_bn=True, activation="relu")
def __init__(self, levels, block, in_channels, out_channels, stride=1, level_root=False, root_dim=0, root_kernel_size=1, dilation=1, root_residual=False): super(Tree, self).__init__() self.levels = levels if root_dim == 0: root_dim = 2 * out_channels if level_root: root_dim += in_channels if self.levels == 1: self.tree1 = block(in_channels, out_channels, stride, dilation=dilation) self.tree2 = block(out_channels, out_channels, 1, dilation=dilation) else: self.tree1 = Tree(levels - 1, block, in_channels, out_channels, stride, root_dim=0, root_kernel_size=root_kernel_size, dilation=dilation, root_residual=root_residual) self.tree2 = Tree(levels - 1, block, out_channels, out_channels, root_dim=root_dim + out_channels, root_kernel_size=root_kernel_size, dilation=dilation, root_residual=root_residual) self.root = Root(root_dim, out_channels, root_kernel_size, root_residual) self.level_root = level_root self.root_dim = root_dim self.downsample = None self.project = None if stride > 1: self.downsample = nn.MaxPool2d(stride, stride=stride) if in_channels != out_channels: self.project = nn.Conv2dBnAct(in_channels, out_channels, kernel_size=1, stride=1, pad_mode='same', has_bias=False, has_bn=True, momentum=BN_MOMENTUM, activation=None, after_fake=False)