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 _make_deconv_layer(self, num_layers, num_filters, num_kernels): assert num_layers == len(num_filters), \ 'ERROR: num_deconv_layers is different len(num_deconv_filters)' assert num_layers == len(num_kernels), \ 'ERROR: num_deconv_layers is different len(num_deconv_filters)' layers = OrderedDict() for i in range(num_layers): kernel, padding, _ = \ self._get_deconv_cfg(num_kernels[i]) planes = num_filters[i] layers['deconv_{}'.format(i)] = nn.SequentialCell( OrderedDict([ ('deconv', nn.Conv2dTranspose( in_channels=self.inplanes, out_channels=planes, kernel_size=kernel, stride=2, pad_mode='pad', padding=padding, has_bias=self.deconv_with_bias, weight_init=Normal(0.001), )), ('bn', nn.BatchNorm2d(planes, momentum=BN_MOMENTUM)), ('relu', nn.ReLU()), ])) self.inplanes = planes return nn.SequentialCell(layers)
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 = nn.Conv2dTranspose(in_planes, out_planes, kernel_size, stride=stride, pad_mode='same') norm = nn.BatchNorm2d(out_planes) if norm_mode == 'instance': # Use BatchNorm2d with batchsize=1, affine=False, training=True instead of InstanceNorm2d norm = nn.BatchNorm2d(out_planes, affine=False) has_bias = (norm_mode == 'instance') if padding is None: padding = (kernel_size - 1) // 2 if pad_mode == 'CONSTANT': conv = nn.Conv2dTranspose(in_planes, out_planes, kernel_size, stride, pad_mode='same', has_bias=has_bias) layers = [conv, norm] else: paddings = ((0, 0), (0, 0), (padding, padding), (padding, padding)) pad = nn.Pad(paddings=paddings, mode=pad_mode) conv = nn.Conv2dTranspose(in_planes, out_planes, kernel_size, stride, pad_mode='pad', has_bias=has_bias) layers = [pad, conv, norm] if use_relu: relu = nn.ReLU() if alpha > 0: relu = nn.LeakyReLU(alpha) layers.append(relu) self.features = nn.SequentialCell(layers)
def __init__(self, in_channels, out_channels, bilinear=True): super().__init__() self.concat = F.Concat(axis=1) self.factor = 104.0 / 136.0 self.center_crop = CentralCrop(central_fraction=self.factor) self.conv = DoubleConv(in_channels, out_channels, in_channels // 2) self.up = nn.Conv2dTranspose(in_channels, in_channels // 2, kernel_size=2, stride=2) self.relu = nn.ReLU()
def __init__(self, in_channel, out_channel, use_deconv, n_concat=2): super(UnetUp, self).__init__() self.conv = UnetConv2d(in_channel + (n_concat - 2) * out_channel, out_channel, False) self.concat = P.Concat(axis=1) self.use_deconv = use_deconv if use_deconv: self.up_conv = nn.Conv2dTranspose(in_channel, out_channel, kernel_size=2, stride=2, pad_mode="same") else: self.up_conv = nn.Conv2d(in_channel, out_channel, 1)
def _convTanspose(in_channels, out_channels, kernel_size=1, stride=1, padding=0, pad_mode='pad'): """ConvTranspose wrapper.""" shape = (out_channels, in_channels, kernel_size, kernel_size) weights = initializer("XavierUniform", shape=shape, dtype=mstype.float32) shape_bias = (out_channels,) bias = Tensor(np.array(np.zeros(shape_bias)).astype(np.float32)) return nn.Conv2dTranspose(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, pad_mode=pad_mode, weight_init=weights, has_bias=True, bias_init=bias)
def __init__(self): super(FaceQABackbone, self).__init__() self.shape = P.Shape() self.reshape = P.Reshape() self.cast = P.Cast() self.conv0 = conv3x3(3, 64, stride=2, padding=1) self.bn0 = bn_with_initialize(64) self.relu0 = P.ReLU() self.conv1 = conv3x3(64, 64, stride=2, padding=1) self.bn1 = bn_with_initialize(64) self.relu1 = P.ReLU() self.backbone = nn.SequentialCell([Block1(), Block2()]) # branch euler self.euler_conv = conv3x3(128, 128, stride=2, padding=1) self.euler_bn = bn_with_initialize(128) self.euler_relu = P.ReLU() self.euler_fc1 = fc_with_initialize(128 * 6 * 6, 256) self.euler_relu1 = P.ReLU() self.euler_fc2 = fc_with_initialize(256, 128) self.euler_relu2 = P.ReLU() self.euler_fc3 = fc_with_initialize(128, 3) # branch heatmap self.kps_deconv = nn.Conv2dTranspose(128, 5, 4, stride=2, pad_mode='pad', group=1, dilation=1, padding=1, has_bias=False) self.kps_up = nn.Conv2dTranspose(5, 5, 4, stride=2, pad_mode='pad', group=1, dilation=1, padding=1, has_bias=False)
def convTranspose2x2( in_channels, out_channels, has_bias=False): # Davinci devices only support 'groups=1' return nn.Conv2dTranspose(in_channels, out_channels, kernel_size=2, stride=2, has_bias=has_bias, weight_init='normal', bias_init='zeros')
def _convTanspose(in_channels, out_channels, kernel_size=1, stride=1, padding=0, pad_mode='pad', gain=1): """ConvTranspose wrapper.""" shape = (out_channels, in_channels, kernel_size, kernel_size) # xavier_normal fan_in = in_channels * kernel_size * kernel_size fan_out = out_channels * kernel_size * kernel_size std = gain * (2 / (fan_in + fan_out)) ** 0.5 weights = Tensor(np.random.normal(loc=0.0, scale=std, size=shape).astype(np.float32)) shape_bias = (out_channels,) bias = Tensor(np.array(np.zeros(shape_bias)).astype(np.float32)) return nn.Conv2dTranspose(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, pad_mode=pad_mode, weight_init=weights, has_bias=True, bias_init=bias)
def __init__(self, cin, cout, kernel_size, stride=1, pad_mode="same", padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros'): super(NetConv2dTranspose, self).__init__() self.conv = nn.Conv2dTranspose(cin, cout, kernel_size, stride, pad_mode, padding, dilation, group, has_bias, weight_init, bias_init)
def __init__(self, n_class): super().__init__() self.n_class = n_class self.conv1 = nn.SequentialCell( nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(64), nn.ReLU(), nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(64), nn.ReLU()) self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv2 = nn.SequentialCell( nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(128), nn.ReLU(), nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(128), nn.ReLU()) self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv3 = nn.SequentialCell( nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(256), nn.ReLU(), nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(256), nn.ReLU(), nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(256), nn.ReLU()) self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv4 = nn.SequentialCell( nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(512), nn.ReLU(), nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(512), nn.ReLU(), nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(512), nn.ReLU()) self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv5 = nn.SequentialCell( nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(512), nn.ReLU(), nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(512), nn.ReLU(), nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, weight_init='xavier_uniform'), nn.BatchNorm2d(512), nn.ReLU()) self.pool5 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv6 = nn.SequentialCell( nn.Conv2d(in_channels=512, out_channels=4096, kernel_size=7, weight_init='xavier_uniform'), nn.BatchNorm2d(4096), nn.ReLU(), ) self.conv7 = nn.SequentialCell( nn.Conv2d(in_channels=4096, out_channels=4096, kernel_size=1, weight_init='xavier_uniform'), nn.BatchNorm2d(4096), nn.ReLU(), ) self.score_fr = nn.Conv2d(in_channels=4096, out_channels=self.n_class, kernel_size=1, weight_init='xavier_uniform') self.upscore2 = nn.Conv2dTranspose(in_channels=self.n_class, out_channels=self.n_class, kernel_size=4, stride=2, weight_init='xavier_uniform') self.score_pool4 = nn.Conv2d(in_channels=512, out_channels=self.n_class, kernel_size=1, weight_init='xavier_uniform') self.upscore_pool4 = nn.Conv2dTranspose(in_channels=self.n_class, out_channels=self.n_class, kernel_size=4, stride=2, weight_init='xavier_uniform') self.score_pool3 = nn.Conv2d(in_channels=256, out_channels=self.n_class, kernel_size=1, weight_init='xavier_uniform') self.upscore8 = nn.Conv2dTranspose(in_channels=self.n_class, out_channels=self.n_class, kernel_size=16, stride=8, weight_init='xavier_uniform') self.shape = P.Shape() self.cast = P.Cast()
def __init__(self, num_classes, num_anchors_list, args): layer_index = { # backbone '0_conv_batch_relu': [3, 16], '1_conv_batch_relu': [16, 32], '2_conv_batch_relu': [32, 64], '3_conv_batch_relu': [64, 64], '4_conv_batch_relu': [64, 64], '5_conv_batch_relu': [64, 128], '6_conv_batch': [128, 64], '7_conv_batch': [64, 64], '8_conv_batch_relu': [64, 128], '9_conv_batch': [128, 64], '10_conv_batch': [64, 64], '11_conv_batch_relu': [64, 128], '12_conv_batch': [128, 128], '13_conv_batch_relu': [128, 256], '14_conv_batch': [256, 144], '15_conv_batch': [144, 128], '16_conv_batch_relu': [128, 256], '17_conv_batch': [256, 128], '18_conv_batch': [128, 128], '19_conv_batch_relu': [128, 256], '20_conv_batch': [256, 144], '21_conv_batch': [144, 256], '22_conv_batch_relu': [256, 512], '23_conv_batch': [512, 256], '24_conv_batch': [256, 256], '25_conv_batch_relu': [256, 512], '26_conv_batch': [512, 256], '27_conv_batch': [256, 256], '28_conv_batch_relu': [256, 512], '30_deconv_up': [512, 64], '31_conv_batch': [320, 160], '32_conv_batch_relu': [160, 96], '33_conv_batch_relu': [96, 96], '34_conv_batch_relu': [96, 96], '35_conv_batch': [96, 80], '36_conv_batch_relu': [80, 128], '37_conv_batch': [128, 96], '38_conv_batch': [96, 128], '39_conv_batch_relu': [128, 256], '41_deconv_up': [256, 64], '42_conv_batch_relu': [192, 64], '43_conv_batch_relu': [64, 64], '44_conv_batch_relu': [64, 64], '45_conv_batch_relu': [64, 64], '46_conv_batch_relu': [64, 96], '47_conv_batch': [96, 64], '48_conv_batch_relu': [64, 128], # head '29_conv': [512], '40_conv': [256], '49_conv': [128] } super(HwYolov3, self).__init__() layer0 = [ (layer_index['0_conv_batch_relu'][0], layer_index['0_conv_batch_relu'][1], 3, 2), (layer_index['1_conv_batch_relu'][0], layer_index['1_conv_batch_relu'][1], 3, 2), (layer_index['2_conv_batch_relu'][0], layer_index['2_conv_batch_relu'][1], 3, 2), (layer_index['3_conv_batch_relu'][0], layer_index['3_conv_batch_relu'][1], 3, 1), (layer_index['4_conv_batch_relu'][0], layer_index['4_conv_batch_relu'][1], 3, 1), ] layer1 = [ (layer_index['5_conv_batch_relu'][0], layer_index['5_conv_batch_relu'][1], 3, 2), (layer_index['6_conv_batch'][0], layer_index['6_conv_batch'][1], 1, 1, 0), (layer_index['7_conv_batch'][0], layer_index['7_conv_batch'][1], 3, 1, 1), (layer_index['8_conv_batch_relu'][0], layer_index['8_conv_batch_relu'][1], 1, 1), (layer_index['9_conv_batch'][0], layer_index['9_conv_batch'][1], 1, 1, 0), (layer_index['10_conv_batch'][0], layer_index['10_conv_batch'][1], 3, 1, 1), (layer_index['11_conv_batch_relu'][0], layer_index['11_conv_batch_relu'][1], 1, 1), ] layer2 = [ (layer_index['12_conv_batch'][0], layer_index['12_conv_batch'][1], 3, 2, 1), (layer_index['13_conv_batch_relu'][0], layer_index['13_conv_batch_relu'][1], 1, 1), (layer_index['14_conv_batch'][0], layer_index['14_conv_batch'][1], 1, 1, 0), (layer_index['15_conv_batch'][0], layer_index['15_conv_batch'][1], 3, 1, 1), (layer_index['16_conv_batch_relu'][0], layer_index['16_conv_batch_relu'][1], 1, 1), (layer_index['17_conv_batch'][0], layer_index['17_conv_batch'][1], 1, 1, 0), (layer_index['18_conv_batch'][0], layer_index['18_conv_batch'][1], 3, 1, 1), (layer_index['19_conv_batch_relu'][0], layer_index['19_conv_batch_relu'][1], 1, 1), ] layer3 = [ (layer_index['20_conv_batch'][0], layer_index['20_conv_batch'][1], 1, 1, 0), (layer_index['21_conv_batch'][0], layer_index['21_conv_batch'][1], 3, 2, 1), (layer_index['22_conv_batch_relu'][0], layer_index['22_conv_batch_relu'][1], 1, 1), (layer_index['23_conv_batch'][0], layer_index['23_conv_batch'][1], 1, 1, 0), (layer_index['24_conv_batch'][0], layer_index['24_conv_batch'][1], 3, 1, 1), (layer_index['25_conv_batch_relu'][0], layer_index['25_conv_batch_relu'][1], 1, 1), (layer_index['26_conv_batch'][0], layer_index['26_conv_batch'][1], 1, 1, 0), (layer_index['27_conv_batch'][0], layer_index['27_conv_batch'][1], 3, 1, 1), (layer_index['28_conv_batch_relu'][0], layer_index['28_conv_batch_relu'][1], 1, 1), ] layer4 = [ (layer_index['30_deconv_up'][0], layer_index['30_deconv_up'][1], 4, 2, 1), ] layer5 = [ (layer_index['31_conv_batch'][0], layer_index['31_conv_batch'][1], 1, 1, 0), (layer_index['32_conv_batch_relu'][0], layer_index['32_conv_batch_relu'][1], 3, 1), (layer_index['33_conv_batch_relu'][0], layer_index['33_conv_batch_relu'][1], 3, 1), (layer_index['34_conv_batch_relu'][0], layer_index['34_conv_batch_relu'][1], 3, 1), (layer_index['35_conv_batch'][0], layer_index['35_conv_batch'][1], 1, 1, 0), (layer_index['36_conv_batch_relu'][0], layer_index['36_conv_batch_relu'][1], 3, 1), (layer_index['37_conv_batch'][0], layer_index['37_conv_batch'][1], 1, 1, 0), (layer_index['38_conv_batch'][0], layer_index['38_conv_batch'][1], 3, 1, 1), (layer_index['39_conv_batch_relu'][0], layer_index['39_conv_batch_relu'][1], 1, 1), ] layer6 = [ (layer_index['41_deconv_up'][0], layer_index['41_deconv_up'][1], 4, 2, 1), ] layer7 = [ (layer_index['42_conv_batch_relu'][0], layer_index['42_conv_batch_relu'][1], 1, 1), (layer_index['43_conv_batch_relu'][0], layer_index['43_conv_batch_relu'][1], 3, 1), (layer_index['44_conv_batch_relu'][0], layer_index['44_conv_batch_relu'][1], 3, 1), (layer_index['45_conv_batch_relu'][0], layer_index['45_conv_batch_relu'][1], 3, 1), (layer_index['46_conv_batch_relu'][0], layer_index['46_conv_batch_relu'][1], 3, 1), (layer_index['47_conv_batch'][0], layer_index['47_conv_batch'][1], 3, 1, 1), (layer_index['48_conv_batch_relu'][0], layer_index['48_conv_batch_relu'][1], 1, 1), ] self.layer0 = MakeYoloLayer(layer0) self.layer1 = MakeYoloLayer(layer1) self.layer2 = MakeYoloLayer(layer2) self.layer3 = MakeYoloLayer(layer3) self.layer4 = nn.Conv2dTranspose(layer4[0][0], layer4[0][1], layer4[0][2], layer4[0][3], pad_mode='pad', padding=layer4[0][4], has_bias=True) self.args = args self.concat = P.Concat(1) self.layer5 = MakeYoloLayer(layer5) self.layer6 = nn.Conv2dTranspose(layer6[0][0], layer6[0][1], layer6[0][2], layer6[0][3], pad_mode='pad', padding=layer6[0][4], has_bias=True) self.layer7 = MakeYoloLayer(layer7) self.head1_conv = nn.Conv2d(layer_index['29_conv'][0], num_anchors_list[0] * (4 + 1 + num_classes), 1, 1, has_bias=True) self.head2_conv = nn.Conv2d(layer_index['40_conv'][0], num_anchors_list[1] * (4 + 1 + num_classes), 1, 1, has_bias=True) self.head3_conv = nn.Conv2d(layer_index['49_conv'][0], num_anchors_list[2] * (4 + 1 + num_classes), 1, 1, has_bias=True) self.relu = nn.ReLU()
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 = nn.BatchNorm2d(inner_nc) upnorm = nn.BatchNorm2d(outer_nc) use_bias = False if norm_mode == 'instance': downnorm = nn.BatchNorm2d(inner_nc, affine=False) upnorm = nn.BatchNorm2d(outer_nc, affine=False) use_bias = True if in_planes is None: in_planes = outer_nc downconv = nn.Conv2d(in_planes, inner_nc, kernel_size=4, stride=2, padding=1, has_bias=use_bias, pad_mode='pad') downrelu = nn.LeakyReLU(alpha) uprelu = nn.ReLU() if outermost: upconv = nn.Conv2dTranspose(inner_nc * 2, outer_nc, kernel_size=4, stride=2, padding=1, pad_mode='pad') down = [downconv] up = [uprelu, upconv, nn.Tanh()] model = down + [submodule] + up elif innermost: upconv = nn.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 = nn.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(nn.Dropout(0.5)) self.model = nn.SequentialCell(model) self.skip_connections = not outermost self.concat = ops.Concat(axis=1)