def __init__(self, num_classes=10): super(SqueezeNet, self).__init__() self.features = nn.SequentialCell([ nn.Conv2d(3, 96, kernel_size=7, stride=2, pad_mode='valid', has_bias=True), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2), Fire(96, 16, 64, 64), Fire(128, 16, 64, 64), Fire(128, 32, 128, 128), nn.MaxPool2d(kernel_size=3, stride=2), Fire(256, 32, 128, 128), Fire(256, 48, 192, 192), Fire(384, 48, 192, 192), Fire(384, 64, 256, 256), nn.MaxPool2d(kernel_size=3, stride=2), Fire(512, 64, 256, 256), ]) # Final convolution is initialized differently from the rest self.final_conv = nn.Conv2d(512, num_classes, kernel_size=1, has_bias=True) self.dropout = nn.Dropout(keep_prob=0.5) self.relu = nn.ReLU() self.mean = P.ReduceMean(keep_dims=True) self.flatten = nn.Flatten() self.custom_init_weight()
def __init__(self, num_classes=10, is_training=True): super(InceptionV3, self).__init__() self.is_training = is_training self.Conv2d_1a = BasicConv2d(3, 32, kernel_size=3, stride=2, pad_mode='valid') self.Conv2d_2a = BasicConv2d(32, 32, kernel_size=3, stride=1, pad_mode='valid') self.Conv2d_2b = BasicConv2d(32, 64, kernel_size=3, stride=1) self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2) self.Conv2d_3b = BasicConv2d(64, 80, kernel_size=1) self.Conv2d_4a = BasicConv2d(80, 192, kernel_size=3, pad_mode='valid') self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2) self.Mixed_5b = Inception_A(192, pool_features=32) self.Mixed_5c = Inception_A(256, pool_features=64) self.Mixed_5d = Inception_A(288, pool_features=64) self.Mixed_6a = Inception_B(288) self.Mixed_6b = Inception_C(768, channels_7x7=128) self.Mixed_6c = Inception_C(768, channels_7x7=160) self.Mixed_6d = Inception_C(768, channels_7x7=160) self.Mixed_6e = Inception_C(768, channels_7x7=192) self.Mixed_7a = Inception_D(768) self.Mixed_7b = Inception_E(1280) self.Mixed_7c = Inception_E(2048) if is_training: self.aux_logits = AuxLogits(768, num_classes) self.logits = Logits(num_classes, dropout_keep_prob=0.5)
def __init__(self, backbone_shape, backbone, out_channel): super(YOLOv4, self).__init__() self.out_channel = out_channel self.backbone = backbone self.conv1 = _conv_bn_leakyrelu(1024, 512, ksize=1) self.conv2 = _conv_bn_leakyrelu(512, 1024, ksize=3) self.conv3 = _conv_bn_leakyrelu(1024, 512, ksize=1) self.maxpool1 = nn.MaxPool2d(kernel_size=5, stride=1, pad_mode='same') self.maxpool2 = nn.MaxPool2d(kernel_size=9, stride=1, pad_mode='same') self.maxpool3 = nn.MaxPool2d(kernel_size=13, stride=1, pad_mode='same') self.conv4 = _conv_bn_leakyrelu(2048, 512, ksize=1) self.conv5 = _conv_bn_leakyrelu(512, 1024, ksize=3) self.conv6 = _conv_bn_leakyrelu(1024, 512, ksize=1) self.conv7 = _conv_bn_leakyrelu(512, 256, ksize=1) self.conv8 = _conv_bn_leakyrelu(512, 256, ksize=1) self.backblock0 = YoloBlock(backbone_shape[-2], out_chls=backbone_shape[-3], out_channels=out_channel) self.conv9 = _conv_bn_leakyrelu(256, 128, ksize=1) self.conv10 = _conv_bn_leakyrelu(256, 128, ksize=1) self.conv11 = _conv_bn_leakyrelu(128, 256, ksize=3, stride=2) self.conv12 = _conv_bn_leakyrelu(256, 512, ksize=3, stride=2) self.backblock1 = YoloBlock(backbone_shape[-3], out_chls=backbone_shape[-4], out_channels=out_channel) self.backblock2 = YoloBlock(backbone_shape[-2], out_chls=backbone_shape[-3], out_channels=out_channel) self.backblock3 = YoloBlock(backbone_shape[-1], out_chls=backbone_shape[-2], out_channels=out_channel) self.concat = P.Concat(axis=1)
def __init__(self, num_classes, include_top=True): super(GoogleNet, self).__init__() self.conv1 = Conv2dBlock(3, 64, kernel_size=7, stride=2, padding=0) self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="same") self.conv2 = Conv2dBlock(64, 64, kernel_size=1) self.conv3 = Conv2dBlock(64, 192, kernel_size=3, padding=0) self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="same") self.block3a = Inception(192, 64, 96, 128, 16, 32, 32) self.block3b = Inception(256, 128, 128, 192, 32, 96, 64) self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="same") self.block4a = Inception(480, 192, 96, 208, 16, 48, 64) self.block4b = Inception(512, 160, 112, 224, 24, 64, 64) self.block4c = Inception(512, 128, 128, 256, 24, 64, 64) self.block4d = Inception(512, 112, 144, 288, 32, 64, 64) self.block4e = Inception(528, 256, 160, 320, 32, 128, 128) self.maxpool4 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode="same") self.block5a = Inception(832, 256, 160, 320, 32, 128, 128) self.block5b = Inception(832, 384, 192, 384, 48, 128, 128) self.dropout = nn.Dropout(keep_prob=0.8) self.include_top = include_top if self.include_top: self.mean = P.ReduceMean(keep_dims=True) self.flatten = nn.Flatten() self.classifier = nn.Dense(1024, num_classes, weight_init=weight_variable(), bias_init=weight_variable())
def __init__(self, stem_filters, num_filters=42): super(CellStem0, self).__init__() self.num_filters = num_filters self.stem_filters = stem_filters self.conv_1x1 = nn.SequentialCell([ nn.ReLU(), nn.Conv2d(in_channels=self.stem_filters, out_channels=self.num_filters, kernel_size=1, stride=1, pad_mode='pad', has_bias=False), nn.BatchNorm2d(num_features=self.num_filters, eps=0.001, momentum=0.9, affine=True) ]) self.comb_iter_0_left = BranchSeparables(self.num_filters, self.num_filters, 5, 2, 2) self.comb_iter_0_right = BranchSeparablesStem(self.stem_filters, self.num_filters, 7, 2, 3, bias=False) self.comb_iter_1_left = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same') self.comb_iter_1_right = BranchSeparablesStem(self.stem_filters, self.num_filters, 7, 2, 3, bias=False) self.comb_iter_2_left = nn.AvgPool2d(kernel_size=3, stride=2, pad_mode='same') self.comb_iter_2_right = BranchSeparablesStem(self.stem_filters, self.num_filters, 5, 2, 2, bias=False) self.comb_iter_3_right = nn.AvgPool2d(kernel_size=3, stride=1, pad_mode='same') self.comb_iter_4_left = BranchSeparables(self.num_filters, self.num_filters, 3, 1, 1, bias=False) self.comb_iter_4_right = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')
def __init__(self, in_classes, kernel_size, padding, maxpool, has_bias): super(MusicTaggerCNN, self).__init__() self.in_classes = in_classes self.kernel_size = kernel_size self.maxpool = maxpool self.padding = padding self.has_bias = has_bias # build model self.conv1 = nn.Conv2d(self.in_classes[0], self.in_classes[1], self.kernel_size[0]) self.conv2 = nn.Conv2d(self.in_classes[1], self.in_classes[2], self.kernel_size[1]) self.conv3 = nn.Conv2d(self.in_classes[2], self.in_classes[3], self.kernel_size[2]) self.conv4 = nn.Conv2d(self.in_classes[3], self.in_classes[4], self.kernel_size[3]) self.bn1 = nn.BatchNorm2d(self.in_classes[1]) self.bn2 = nn.BatchNorm2d(self.in_classes[2]) self.bn3 = nn.BatchNorm2d(self.in_classes[3]) self.bn4 = nn.BatchNorm2d(self.in_classes[4]) self.pool1 = nn.MaxPool2d(maxpool[0], maxpool[0]) self.pool2 = nn.MaxPool2d(maxpool[1], maxpool[1]) self.pool3 = nn.MaxPool2d(maxpool[2], maxpool[2]) self.pool4 = nn.MaxPool2d(maxpool[3], maxpool[3]) self.poolreduce = P.ReduceMax(keep_dims=False) self.Act = nn.ReLU() self.flatten = nn.Flatten() self.dense = nn.Dense(2048, 50, activation='sigmoid') self.sigmoid = nn.Sigmoid()
def __init__(self, is_training=True): super(VGG, self).__init__() self.conv1 = Conv(3, 64, use_bn=True) self.conv2 = Conv(64, 128, use_bn=True) self.conv3 = Conv(128, 256, use_bn=True) self.conv4 = Conv(256, 256, use_bn=True) self.conv5 = Conv(256, 512, use_bn=True) self.conv6 = Conv(512, 512, use_bn=True) self.conv7 = Conv(512, 512, kernel_size=2, pad_mode='valid', use_bn=True) self.maxpool2d1 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='same') self.maxpool2d2 = nn.MaxPool2d(kernel_size=(2, 1), stride=(2, 1), pad_mode='same') self.bn1 = _bn(512)
def __init__(self): super(VGG16, self).__init__() self.b1 = _make_layer([3, 64, 64]) self.b2 = _make_layer([64, 128, 128]) self.b3 = _make_layer([128, 256, 256, 256]) self.b4 = _make_layer([256, 512, 512, 512]) self.b5 = _make_layer([512, 512, 512, 512]) self.m1 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='SAME') self.m2 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='SAME') self.m3 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='SAME') self.m4 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='SAME') self.m5 = nn.MaxPool2d(kernel_size=3, stride=1, pad_mode='SAME')
def __init__(self, num_classes=10, cut_layer=None): super().__init__() self.cut_layer = cut_layer self.conv1 = nn.Conv2d(1, 6, 5, pad_mode='valid') self.relu1 = nn.ReLU() self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid') self.relu2 = nn.ReLU() self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2) self.flatten = nn.Flatten() self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02)) self.relu3 = nn.ReLU() self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02)) self.relu4 = nn.ReLU() self.fc3 = nn.Dense(84, num_classes, weight_init=Normal(0.02)) # Preparing named layers so that the model can be split and straddle # across the client and the server self.layers = [] self.layerdict = collections.OrderedDict() self.layerdict['conv1'] = self.conv1 self.layerdict['relu1'] = self.relu1 self.layerdict['pool1'] = self.pool1 self.layerdict['conv2'] = self.conv2 self.layerdict['relu2'] = self.relu2 self.layerdict['pool2'] = self.pool2 self.layerdict['flatten'] = self.flatten self.layerdict['fc1'] = self.fc1 self.layerdict['relu3'] = self.relu3 self.layerdict['fc2'] = self.fc2 self.layerdict['relu4'] = self.relu4 self.layerdict['fc3'] = self.fc3 self.layers.append('conv1') self.layers.append('relu1') self.layers.append('pool1') self.layers.append('conv2') self.layers.append('relu2') self.layers.append('pool2') self.layers.append('flatten') self.layers.append('fc1') self.layers.append('relu3') self.layers.append('fc2') self.layers.append('relu4') self.layers.append('fc3')
def __init__(self, num_classes=10, channel=1, phase='train', include_top=True): super().__init__() self.conv1 = conv(channel, 12, 11, stride=2, pad_mode="same", has_bias=True) self.conv2 = conv(12, 20, 3, pad_mode="same", has_bias=True) self.relu = P.ReLU() self.max_pool2d = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='valid') self.include_top = include_top if self.include_top: dropout_ratio = 0.65 if phase == 'test': dropout_ratio = 1.0 self.flatten = nn.Flatten() self.fc1 = fc_with_initialize(20 * 3 * 3, 1024) self.fc2 = fc_with_initialize(1024, 1024) self.fc3 = fc_with_initialize(1024, num_classes) self.dropout = nn.Dropout(dropout_ratio)
def __init__(self, block, layer_nums, in_channels, out_channels, strides, num_classes): super(resnet, self).__init__() if not len(layer_nums) == len(in_channels) == len(out_channels) == 4: raise ValueError( "the length of layer_num, in_channels, out_channels list must be 4!" ) self.conv1 = ConvBNReLU(3, 64, kernel_size=7, stride=2) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="same") self.layer1 = self._make_layer(block, layer_nums[0], in_channel=in_channels[0], out_channel=out_channels[0], stride=strides[0]) self.layer2 = self._make_layer(block, layer_nums[1], in_channel=in_channels[1], out_channel=out_channels[1], stride=strides[1]) self.layer3 = self._make_layer(block, layer_nums[2], in_channel=in_channels[2], out_channel=out_channels[2], stride=strides[2]) self.layer4 = self._make_layer(block, layer_nums[3], in_channel=in_channels[3], out_channel=out_channels[3], stride=strides[3])
def _make_layer(base, args, 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: weight = 'ones' if args.initialize_mode == "XavierUniform": weight_shape = (v, in_channels, 3, 3) weight = initializer('XavierUniform', shape=weight_shape, dtype=mstype.float32).to_tensor() conv2d = nn.Conv2d(in_channels=in_channels, out_channels=v, kernel_size=3, padding=args.padding, pad_mode=args.pad_mode, has_bias=args.has_bias, weight_init=weight) if batch_norm: layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU()] else: layers += [conv2d, nn.ReLU()] in_channels = v return nn.SequentialCell(layers)
def __init__(self, in_channels, has_bias=False): super(Inception_D, self).__init__() self.concat = P.Concat(axis=1) self.branch0 = nn.SequentialCell([ BasicConv2d(in_channels, 192, kernel_size=1, has_bias=has_bias), BasicConv2d(192, 320, kernel_size=3, stride=2, pad_mode='valid', has_bias=has_bias) ]) self.branch1 = nn.SequentialCell([ BasicConv2d(in_channels, 192, kernel_size=1, has_bias=has_bias), BasicConv2d(192, 192, kernel_size=(1, 7), has_bias=has_bias), # check BasicConv2d(192, 192, kernel_size=(7, 1), has_bias=has_bias), BasicConv2d(192, 192, kernel_size=3, stride=2, pad_mode='valid', has_bias=has_bias) ]) self.branch_pool = nn.MaxPool2d(kernel_size=3, stride=2)
def __init__(self): super(BasicCell, self).__init__() self.conv3x3_1 = _conv3x3(128, 128) self.bn3x3_1 = _bn(128) self.conv3x3_2 = _conv3x3(128, 128) self.bn3x3_2 = _bn(128) self.conv3x3_3 = _conv3x3(128, 128) self.bn3x3_3 = _bn(128) self.mp = nn.MaxPool2d(kernel_size=3, stride=1, pad_mode="same") self.proj1 = _conv1x1(128, 64) self.bn1 = _bn(64) self.proj2 = _conv1x1(128, 64) self.bn2 = _bn(64) self.proj3 = _conv1x1(128, 64) self.bn3 = _bn(64) self.proj4 = _conv1x1(128, 64) self.bn4 = _bn(64) self.proj5 = _conv1x1(128, 64) self.bn5 = _bn(64) self.proj6 = _conv1x1(128, 64) self.bn6 = _bn(64) self.relu = P.ReLU() self.concat = ops.Concat(axis=1)
def __init__(self, block, num_classes=100, batch_size=32): """init""" super(ResNet, self).__init__() self.batch_size = batch_size self.num_classes = num_classes self.conv1 = conv7x7(3, 64, stride=2, padding=0) self.bn1 = bn_with_initialize(64) self.relu = ops.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="same") self.layer1 = MakeLayer0(block, in_channels=64, out_channels=256, stride=1) self.layer2 = MakeLayer1(block, in_channels=256, out_channels=512, stride=2) self.layer3 = MakeLayer2(block, in_channels=512, out_channels=1024, stride=2) self.layer4 = MakeLayer3(block, in_channels=1024, out_channels=2048, stride=2) self.pool = ops.ReduceMean(keep_dims=True) self.squeeze = ops.Squeeze(axis=(2, 3)) self.fc = fc_with_initialize(512 * block.expansion, num_classes)
def __init__(self, in_channels, out_channels, stride=1, momentum=0.9): super(ResidualBlock, self).__init__() out_chls = out_channels // self.expansion self.conv1 = _conv1x1(in_channels, out_chls, stride=1) self.bn1 = _fused_bn(out_chls, momentum=momentum) self.conv2 = _conv3x3(out_chls, out_chls, stride=stride) self.bn2 = _fused_bn(out_chls, momentum=momentum) self.conv3 = _conv1x1(out_chls, out_channels, stride=1) self.bn3 = _fused_bn(out_channels, momentum=momentum) self.relu = P.ReLU() self.downsample = (in_channels != out_channels) self.stride = stride if self.downsample: self.conv_down_sample = _conv1x1(in_channels, out_channels, stride=stride) self.bn_down_sample = _fused_bn(out_channels, momentum=momentum) elif self.stride != 1: self.maxpool_down = nn.MaxPool2d(kernel_size=1, stride=2, pad_mode='same') self.add = P.Add()
def __init__(self, include_last_bn_relu=True): super(PAVNet, self).__init__() self.conv1_1 = ops._conv_bn_crelu(3, 32, 2, 7) self.pool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same') self.conv2_1 = ops._mCReLU(64, [48, 48, 128], 1, False) self.conv2_2 = ops._mCReLU(128, [48, 48, 128], 1, True) self.conv2_3 = ops._mCReLU(128, [48, 48, 128], 1, True) self.conv3_1 = ops._mCReLU(128, [96, 96, 256], 2, True) self.conv3_2 = ops._mCReLU(256, [96, 96, 256], 1, True) self.conv3_3 = ops._mCReLU(256, [96, 96, 256], 1, True) self.conv3_4 = ops._mCReLU(256, [96, 96, 256], 1, True) self.conv4_1 = ops._inception(256, '128 96-256 48-96-96 256 512', 2, True) self.conv4_2 = ops._inception(512, '128 96-256 48-96-96 512', 1, True) self.conv4_3 = ops._inception(512, '128 96-256 48-96-96 512', 1, True) self.conv4_4 = ops._inception(512, '128 96-256 48-96-96 512', 1, True) self.conv5_1 = ops._inception(512, '128 192-384 64-128-128 256 768', 2, True) self.conv5_2 = ops._inception(768, '128 192-384 64-128-128 768', 1, True) self.conv5_3 = ops._inception(768, '128 192-384 64-128-128 768', 1, True) self.conv5_4 = ops._inception(768, '128 192-384 64-128-128 768', 1, True) self.include_last_bn_relu = include_last_bn_relu if include_last_bn_relu: self.last_bn = nn.BatchNorm2d(num_features=768) self.last_scale = ops._scale(768) self.last_relu = nn.ReLU()
def __init__(self, in_channel, n_class=2, feature_scale=2, use_deconv=True, use_bn=True): super(UNet, self).__init__() self.in_channel = in_channel self.n_class = n_class self.feature_scale = feature_scale self.use_deconv = use_deconv self.use_bn = use_bn filters = [64, 128, 256, 512, 1024] filters = [int(x / self.feature_scale) for x in filters] # Down Sample self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode="same") self.conv0 = UnetConv2d(self.in_channel, filters[0], self.use_bn) self.conv1 = UnetConv2d(filters[0], filters[1], self.use_bn) self.conv2 = UnetConv2d(filters[1], filters[2], self.use_bn) self.conv3 = UnetConv2d(filters[2], filters[3], self.use_bn) self.conv4 = UnetConv2d(filters[3], filters[4], self.use_bn) # Up Sample self.up_concat1 = UnetUp(filters[1], filters[0], self.use_deconv, 2) self.up_concat2 = UnetUp(filters[2], filters[1], self.use_deconv, 2) self.up_concat3 = UnetUp(filters[3], filters[2], self.use_deconv, 2) self.up_concat4 = UnetUp(filters[4], filters[3], self.use_deconv, 2) # Finale Convolution self.final = nn.Conv2d(filters[0], n_class, 1)
def test_maxpool2d_error_padding(): """ test_maxpool2d_error_padding """ kernel_size = 3.5 stride = 3 padding = 1 with pytest.raises(ValueError): nn.MaxPool2d(kernel_size, stride, padding=padding)
def __init__(self, num_classes=10): super(SqueezeNet_Residual, self).__init__() self.conv1 = nn.Conv2d(3, 96, kernel_size=7, stride=2, pad_mode='valid', has_bias=True) self.fire2 = Fire(96, 16, 64, 64) self.fire3 = Fire(128, 16, 64, 64) self.fire4 = Fire(128, 32, 128, 128) self.fire5 = Fire(256, 32, 128, 128) self.fire6 = Fire(256, 48, 192, 192) self.fire7 = Fire(384, 48, 192, 192) self.fire8 = Fire(384, 64, 256, 256) self.fire9 = Fire(512, 64, 256, 256) # Final convolution is initialized differently from the rest self.conv10 = nn.Conv2d(512, num_classes, kernel_size=1, has_bias=True) self.relu = nn.ReLU() self.max_pool2d = nn.MaxPool2d(kernel_size=3, stride=2) self.add = P.TensorAdd() self.dropout = nn.Dropout(keep_prob=0.5) self.mean = P.ReduceMean(keep_dims=True) self.flatten = nn.Flatten() self.custom_init_weight()
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, block, num_classes=100): super(ResNet9, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2) self.layer1 = self.MakeLayer(block, 1, in_channels=64, out_channels=256, stride=1) self.layer2 = self.MakeLayer(block, 1, in_channels=256, out_channels=512, stride=2) self.layer3 = self.MakeLayer(block, 1, in_channels=512, out_channels=1024, stride=2) self.layer4 = self.MakeLayer(block, 1, in_channels=1024, out_channels=2048, stride=2) self.avgpool = nn.AvgPool2d(7, 1) self.flatten = nn.Flatten() self.fc = nn.Dense(512 * block.expansion, num_classes)
def __init__(self, in_str): super(LeNet5, self).__init__() a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 = in_str.strip( ).split() a1 = int(a1) a2 = int(a2) a3 = int(a3) a4 = int(a4) a5 = int(a5) a6 = int(a6) a7 = int(a7) a8 = int(a8) a9 = int(a9) a10 = int(a10) a11 = int(a11) a12 = int(a12) a13 = int(a13) a14 = int(a14) a15 = int(a15) self.conv1 = nn.Conv2d(a1, a2, a3, pad_mode="valid") self.conv2 = nn.Conv2d(a4, a5, a6, pad_mode="valid") self.fc1 = nn.Dense(a7 * a8 * a9, a10) self.fc2 = nn.Dense(a11, a12) self.fc3 = nn.Dense(a13, a14) self.relu = nn.ReLU() self.max_pool2d = nn.MaxPool2d(kernel_size=a15) self.flatten = nn.Flatten()
def __init__(self, block, layer_nums, in_channels, out_channels, strides, num_classes, use_se=False): super(ResNet, self).__init__() if not len(layer_nums) == len(in_channels) == len(out_channels) == 4: raise ValueError( "the length of layer_num, in_channels, out_channels list must be 4!" ) self.use_se = use_se self.se_block = False if self.use_se: self.se_block = True if self.use_se: self.conv1_0 = _conv3x3(3, 32, stride=2, use_se=self.use_se) self.bn1_0 = _bn(32) self.conv1_1 = _conv3x3(32, 32, stride=1, use_se=self.use_se) self.bn1_1 = _bn(32) self.conv1_2 = _conv3x3(32, 64, stride=1, use_se=self.use_se) else: self.conv1 = _conv7x7(3, 64, stride=2) self.bn1 = _bn(64) self.relu = P.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="same") self.layer1 = self._make_layer(block, layer_nums[0], in_channel=in_channels[0], out_channel=out_channels[0], stride=strides[0], use_se=self.use_se) self.layer2 = self._make_layer(block, layer_nums[1], in_channel=in_channels[1], out_channel=out_channels[1], stride=strides[1], use_se=self.use_se) self.layer3 = self._make_layer(block, layer_nums[2], in_channel=in_channels[2], out_channel=out_channels[2], stride=strides[2], use_se=self.use_se, se_block=self.se_block) self.layer4 = self._make_layer(block, layer_nums[3], in_channel=in_channels[3], out_channel=out_channels[3], stride=strides[3], use_se=self.use_se, se_block=self.se_block) self.mean = P.ReduceMean(keep_dims=True) self.flatten = nn.Flatten() self.end_point = _fc(out_channels[3], num_classes, use_se=self.use_se)
def __init__(self, block, layer_num, num_classes=100, batch_size=32): super(ResNet, self).__init__() self.batch_size = batch_size self.num_classes = num_classes self.conv1 = conv7x7(3, 64, stride=2, padding=0) self.bn1 = bn_with_initialize(64) self.relu = P.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="SAME") self.layer1 = MakeLayer0(block, layer_num[0], in_channels=64, out_channels=256, stride=1) self.layer2 = MakeLayer1(block, layer_num[1], in_channels=256, out_channels=512, stride=2) self.layer3 = MakeLayer2(block, layer_num[2], in_channels=512, out_channels=1024, stride=2) self.layer4 = MakeLayer3(block, layer_num[3], in_channels=1024, out_channels=2048, stride=2) self.pool = P.ReduceMean(keep_dims=True) self.fc = fc_with_initialize(512 * block.expansion, num_classes) self.flatten = nn.Flatten()
def __init__(self): super(LeNet, self).__init__() self.relu = P.ReLU() self.batch_size = 32 self.conv1 = nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=0, has_bias=False, pad_mode='valid') self.conv2 = nn.Conv2d(6, 16, kernel_size=5, stride=1, padding=0, has_bias=False, pad_mode='valid') self.pool = nn.MaxPool2d(kernel_size=2, stride=2) self.reshape = P.Reshape() self.fc1 = nn.Dense(400, 120) self.fc1.matmul.add_prim_attr("primitive_target", "CPU") self.fc1.bias_add.add_prim_attr("primitive_target", "CPU") self.fc2 = nn.Dense(120, 84) self.fc2.matmul.add_prim_attr("primitive_target", "CPU") self.fc2.bias_add.add_prim_attr("primitive_target", "CPU") self.fc3 = nn.Dense(84, 10) self.fc3.matmul.add_prim_attr("primitive_target", "CPU") self.fc3.bias_add.add_prim_attr("primitive_target", "CPU")
def __init__(self, num_class=10, channel=1): super(LeNet5, self).__init__() self.num_class = num_class self.conv1 = nn.Conv2dBnFoldQuant(channel, 6, 5, pad_mode='valid', per_channel=True, quant_delay=900) self.conv2 = nn.Conv2dBnFoldQuant(6, 16, 5, pad_mode='valid', per_channel=True, quant_delay=900) self.fc1 = nn.DenseQuant(16 * 5 * 5, 120, per_channel=True, quant_delay=900) self.fc2 = nn.DenseQuant(120, 84, per_channel=True, quant_delay=900) self.fc3 = nn.DenseQuant(84, self.num_class, per_channel=True, quant_delay=900) self.relu = nn.ActQuant(nn.ReLU(), per_channel=False, quant_delay=900) self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2) self.flatten = nn.Flatten()
def __init__(self, in_channels, out_channels): super().__init__() self.maxpool_conv = nn.SequentialCell([ nn.MaxPool2d(kernel_size=2, stride=2), DoubleConv(in_channels, out_channels) ])
def __init__(self): super(LeNet, self).__init__() self.relu = P.ReLU() self.batch_size = 1 weight1 = Tensor(np.ones([6, 3, 5, 5]).astype(np.float32) * 0.01) weight2 = Tensor(np.ones([16, 6, 5, 5]).astype(np.float32) * 0.01) self.conv1 = nn.Conv2d(3, 6, (5, 5), weight_init=weight1, stride=1, padding=0, pad_mode='valid') self.conv2 = nn.Conv2d(6, 16, (5, 5), weight_init=weight2, pad_mode='valid', stride=1, padding=0) self.pool = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode="valid") self.reshape = P.Reshape() self.reshape1 = P.Reshape() self.fc1 = Dense(400, 120) self.fc2 = Dense(120, 84) self.fc3 = Dense(84, 10)
def __init__(self): super(LeNet, self).__init__() self.relu = P.ReLU() self.batch_size = 32 self.conv1 = nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=0, has_bias=False, pad_mode='valid') self.conv2 = nn.Conv2d(6, 16, kernel_size=5, stride=1, padding=0, has_bias=False, pad_mode='valid') self.pool = nn.MaxPool2d(kernel_size=2, stride=2) self.pool.recompute() self.reshape = P.Reshape() self.fc1 = nn.Dense(400, 120) self.fc2 = nn.Dense(120, 84) self.fc3 = nn.Dense(84, 10)