def __init__(self, num_layers, mode='ir', opts=None): super(BackboneEncoderUsingLastLayerIntoWPlus, self).__init__() print('Using BackboneEncoderUsingLastLayerIntoWPlus') assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152' assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se' blocks = get_blocks(num_layers) if mode == 'ir': unit_module = bottleneck_IR elif mode == 'ir_se': unit_module = bottleneck_IR_SE self.input_layer = Sequential( Conv2D(opts.input_nc, 64, (3, 3), 1, 1, bias_attr=False), BatchNorm2D(64), PReLU(64)) self.output_layer_2 = Sequential(BatchNorm2D(512), paddle.nn.AdaptiveAvgPool2D((7, 7)), Flatten(), Linear(512 * 7 * 7, 512)) self.linear = EqualLinear(512, 512 * 18, lr_mul=1) modules = [] for block in blocks: for bottleneck in block: modules.append( unit_module(bottleneck.in_channel, bottleneck.depth, bottleneck.stride)) self.body = Sequential(*modules)
def __init__(self, in_channel, depth, stride): super(bottleneck_IR, self).__init__() if in_channel == depth: self.shortcut_layer = MaxPool2D(1, stride) else: self.shortcut_layer = Sequential( Conv2D(in_channel, depth, (1, 1), stride, bias_attr=False), BatchNorm2D(depth)) self.res_layer = Sequential( BatchNorm2D(in_channel), Conv2D(in_channel, depth, (3, 3), (1, 1), 1, bias_attr=False), PReLU(depth), Conv2D(depth, depth, (3, 3), stride, 1, bias_attr=False), BatchNorm2D(depth))
def __init__(self, num_channels, num_filters, stride, shortcut=True, name=None, data_format="NCHW"): super(BasicBlock, self).__init__() self.stride = stride bn_name = "bn_" + name[3:] + "_before" self._batch_norm = BatchNorm( num_channels, act=None, epsilon=1e-05, param_attr=ParamAttr(name=bn_name + "_scale"), bias_attr=ParamAttr(bn_name + "_offset"), moving_mean_name=bn_name + "_mean", moving_variance_name=bn_name + "_variance", data_layout=data_format) self.conv0 = ConvBNLayer( num_channels=num_channels, num_filters=num_filters, filter_size=3, stride=1, act=None, name=name + "_branch2a", data_format=data_format) self.prelu = PReLU(num_parameters=1, name=name + "_branch2a_prelu") self.conv1 = ConvBNLayer( num_channels=num_filters, num_filters=num_filters, filter_size=3, stride=stride, act=None, name=name + "_branch2b", data_format=data_format) if shortcut: self.short = ConvBNLayer( num_channels=num_channels, num_filters=num_filters, filter_size=1, stride=stride, act=None, name=name + "_branch1", data_format=data_format) self.shortcut = shortcut
def __init__(self, num_classes=10): super(ImperativeLenet, self).__init__() conv2d_w1_attr = fluid.ParamAttr(name="conv2d_w_1") conv2d_w2_attr = fluid.ParamAttr(name="conv2d_w_2") fc_w1_attr = fluid.ParamAttr(name="fc_w_1") fc_w2_attr = fluid.ParamAttr(name="fc_w_2") fc_w3_attr = fluid.ParamAttr(name="fc_w_3") conv2d_b2_attr = fluid.ParamAttr(name="conv2d_b_2") fc_b1_attr = fluid.ParamAttr(name="fc_b_1") fc_b2_attr = fluid.ParamAttr(name="fc_b_2") fc_b3_attr = fluid.ParamAttr(name="fc_b_3") self.features = Sequential( Conv2D(in_channels=1, out_channels=6, kernel_size=3, stride=1, padding=1, weight_attr=conv2d_w1_attr, bias_attr=False), BatchNorm2D(6), ReLU(), MaxPool2D(kernel_size=2, stride=2), Conv2D(in_channels=6, out_channels=16, kernel_size=5, stride=1, padding=0, weight_attr=conv2d_w2_attr, bias_attr=conv2d_b2_attr), BatchNorm2D(16), PReLU(), MaxPool2D(kernel_size=2, stride=2)) self.fc = Sequential( Linear(in_features=400, out_features=120, weight_attr=fc_w1_attr, bias_attr=fc_b1_attr), LeakyReLU(), Linear(in_features=120, out_features=84, weight_attr=fc_w2_attr, bias_attr=fc_b2_attr), Sigmoid(), Linear(in_features=84, out_features=num_classes, weight_attr=fc_w3_attr, bias_attr=fc_b3_attr), Softmax()) self.add = paddle.nn.quant.add() self.quant_stub = paddle.nn.quant.QuantStub()
def __init__(self, num_layers, mode='ir', opts=None): super(GradualStyleEncoder, self).__init__() assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152' assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se' blocks = get_blocks(num_layers) if mode == 'ir': unit_module = bottleneck_IR elif mode == 'ir_se': unit_module = bottleneck_IR_SE self.input_layer = Sequential( Conv2D(opts.input_nc, 64, (3, 3), 1, 1, bias_attr=False), BatchNorm2D(64), PReLU(64)) modules = [] for block in blocks: for bottleneck in block: modules.append( unit_module(bottleneck.in_channel, bottleneck.depth, bottleneck.stride)) self.body = Sequential(*modules) self.styles = nn.LayerList() self.style_count = 18 self.coarse_ind = 3 self.middle_ind = 7 for i in range(self.style_count): if i < self.coarse_ind: style = GradualStyleBlock(512, 512, 16) elif i < self.middle_ind: style = GradualStyleBlock(512, 512, 32) else: style = GradualStyleBlock(512, 512, 64) self.styles.append(style) self.latlayer1 = nn.Conv2D(256, 512, kernel_size=1, stride=1, padding=0) self.latlayer2 = nn.Conv2D(128, 512, kernel_size=1, stride=1, padding=0)
def __init__(self, in_c, out_c, kernel=(1, 1), stride=(1, 1), padding=(0, 0), groups=1): super(ConvBlock, self).__init__() self.conv = Conv2D(in_c, out_channels=out_c, kernel_size=kernel, groups=groups, stride=stride, padding=padding) self.bn = BatchNorm2D(out_c) self.prelu = PReLU(out_c)
def __init__(self, layers=50, num_features=512, fc_type='E', dropout=0.4, input_image_channel=3, input_image_width=112, input_image_height=112, data_format="NCHW"): super(FresResNet, self).__init__() self.layers = layers self.data_format = data_format self.input_image_channel = input_image_channel supported_layers = [50, 100] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format( supported_layers, layers) if layers == 50: units = [3, 4, 14, 3] elif layers == 100: units = [3, 13, 30, 3] num_channels = [64, 64, 128, 256] num_filters = [64, 128, 256, 512] self.conv = ConvBNLayer( num_channels=self.input_image_channel, num_filters=64, filter_size=3, stride=1, act=None, name="conv1", data_format=self.data_format) self.prelu = PReLU(num_parameters=1, name="prelu1") self.block_list = paddle.nn.LayerList() for block in range(len(units)): shortcut = True for i in range(units[block]): conv_name = "res" + str(block + 2) + chr(97 + i) basic_block = self.add_sublayer( conv_name, BasicBlock( num_channels=num_channels[block] if i == 0 else num_filters[block], num_filters=num_filters[block], stride=2 if shortcut else 1, shortcut=shortcut, name=conv_name, data_format=self.data_format)) self.block_list.append(basic_block) shortcut = False assert input_image_width % 16 == 0 assert input_image_height % 16 == 0 feat_w = input_image_width // 16 feat_h = input_image_height // 16 self.fc_channels = num_filters[-1] * feat_w * feat_h self.fc = FC(num_filters[-1], self.fc_channels, num_features, fc_type, dropout, name='fc')