def __init__(self): super(MNIST, self).__init__() self._simple_img_conv_pool_1 = SimpleImgConvPool(1, 20, 5, 2, 2, act="relu") self._simple_img_conv_pool_2 = SimpleImgConvPool(20, 50, 5, 2, 2, act="relu") self.pool_2_shape = 50 * 4 * 4 SIZE = 10 scale = (2.0 / (self.pool_2_shape**2 * SIZE))**0.5 self._fc = Linear(self.pool_2_shape, 10, param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.NormalInitializer( loc=0.0, scale=scale)), act="softmax")
def __init__(self): super(GoogLeNet,self).__init__() # 1 self.conv1 = Conv2D(num_channels=3,num_filters=64,filter_size=7,padding=3,act='relu') self.pool1 = Pool2D(pool_size=3,pool_stride=2,pool_padding=1,pool_type='max') # 2 self.conv2_1 = Conv2D(num_channels=64,num_filters=64,filter_size=1,act='relu') self.conv2_2 = Conv2D(num_channels=64,num_filters=192,filter_size=3,padding=1,act='relu') self.pool2 = Pool2D(pool_size=3,pool_stride=2,pool_padding=1,pool_type='max') # 3 self.block3_1 = Inception(192, 64, (96, 128), (16, 32), 32) self.block3_2 = Inception(256, 128, (128, 192), (32, 96), 64) self.pool3 = Pool2D(pool_size=3, pool_stride=2,pool_padding=1, pool_type='max') # 4 self.block4_1 = Inception(480, 192, (96, 208), (16, 48), 64) self.block4_2 = Inception(512, 160, (112, 224), (24, 64), 64) self.block4_3 = Inception(512, 128, (128, 256), (24, 64), 64) self.block4_4 = Inception(512, 112, (144, 288), (32, 64), 64) self.block4_5 = Inception(528, 256, (160, 320), (32, 128), 128) self.pool4 = Pool2D(pool_size=3, pool_stride=2,pool_padding=1, pool_type='max') # 5 self.block5_1 = Inception(832,256,(160,320),(32,128),128) self.block5_2 = Inception(832,384,(192,384),(48,128),128) self.pool5 = Pool2D(pool_stride=1,global_pooling=True,pool_type='avg') self.fc = Linear(input_dim=1024,output_dim=1,act=None)
def __init__(self, bottleneck_params, in_channels=3, class_dim=1024): super(Xception, self).__init__() self.convbn1 = ConvBN(in_channels, 32, 3, 2, act='relu') self.convbn2 = ConvBN(32, 64, 3, 1, act='relu') in_channel = 64 self.entry_flow, in_channel = self.block_flow( block_num=bottleneck_params['entry_flow'][0], strides=bottleneck_params['entry_flow'][1], chns=bottleneck_params['entry_flow'][2], in_channel=in_channel) self.middle_flow, in_channel = self.block_flow( block_num=bottleneck_params['middle_flow'][0], strides=bottleneck_params['middle_flow'][1], chns=bottleneck_params['middle_flow'][2], in_channel=in_channel) self.exit_flow, in_channel = self.exit_block_flow( block_num=bottleneck_params['exit_flow'][0], strides=bottleneck_params['exit_flow'][1], chns=bottleneck_params['exit_flow'][2], in_channel=in_channel) self.pool = Pool2D(pool_size=7, pool_type='avg', global_pooling=True) self.feature_dim = 2048 import math stdv = 1.0 / math.sqrt(2048 * 1.0) self.linear = Linear(self.feature_dim, class_dim, act='softmax', param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)))
def __init__(self, scale=1.0, num_classes=1000, with_pool=True, classifier_activation='softmax'): super(MobileNetV2, self).__init__() self.scale = scale self.num_classes = num_classes self.with_pool = with_pool bottleneck_params_list = [ (1, 16, 1, 1), (6, 24, 2, 2), (6, 32, 3, 2), (6, 64, 4, 2), (6, 96, 3, 1), (6, 160, 3, 2), (6, 320, 1, 1), ] self._conv1 = ConvBNLayer( num_channels=3, num_filters=int(32 * scale), filter_size=3, stride=2, padding=1) self._invl = [] i = 1 in_c = int(32 * scale) for layer_setting in bottleneck_params_list: t, c, n, s = layer_setting i += 1 tmp = self.add_sublayer( sublayer=InvresiBlocks( in_c=in_c, t=t, c=int(c * scale), n=n, s=s), name='conv' + str(i)) self._invl.append(tmp) in_c = int(c * scale) self._out_c = int(1280 * scale) if scale > 1.0 else 1280 self._conv9 = ConvBNLayer( num_channels=in_c, num_filters=self._out_c, filter_size=1, stride=1, padding=0) if with_pool: self._pool2d_avg = Pool2D(pool_type='avg', global_pooling=True) if num_classes > 0: tmp_param = ParamAttr(name=self.full_name() + "fc10_weights") self._fc = Linear( self._out_c, num_classes, act=classifier_activation, param_attr=tmp_param, bias_attr=ParamAttr(name="fc10_offset"))
def __init__(self, num_classes=1): super(AlexNet, self).__init__() # AlexNet与LeNet一样也会同时使用卷积和池化层提取图像特征 # 与LeNet不同的是激活函数换成了‘relu’ 作用:通过加权的输入进行非线性组合产生非线性决策边界 self.conv1 = Conv2D(num_channels=3, num_filters=96, filter_size=11, stride=4, padding=5, act='relu') self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') #输出神经元个数 self.conv2 = Conv2D(num_channels=96, num_filters=256, filter_size=5, stride=1, padding=2, act='relu') self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.conv3 = Conv2D(num_channels=256, num_filters=384, filter_size=3, stride=1, padding=1, act='relu') self.conv4 = Conv2D(num_channels=384, num_filters=384, filter_size=3, stride=1, padding=1, act='relu') self.conv5 = Conv2D(num_channels=384, num_filters=256, filter_size=3, stride=1, padding=1, act='relu') self.pool5 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.fc1 = Linear(input_dim=12544, output_dim=4096, act='relu') # 7*7*256 self.drop_ratio1 = 0.5 self.fc2 = Linear(input_dim=4096, output_dim=4096, act='relu') self.drop_ratio2 = 0.5 self.fc3 = Linear(input_dim=4096, output_dim=num_classes)
def __init__(self, num_channels, reduction_ratio): super(SqueezeExcitation, self).__init__() self._num_channels = num_channels self._pool = Pool2D(pool_size=0, pool_type='avg', global_pooling=True) self._squeeze = Linear( num_channels, num_channels // reduction_ratio, param_attr=fluid.ParamAttr(initializer=fluid.initializer.Constant( value=0.05)), act='relu') self._excitation = Linear( num_channels // reduction_ratio, num_channels, param_attr=fluid.ParamAttr(initializer=fluid.initializer.Constant( value=0.05)), act='sigmoid')
def __init__(self, conv_arch=((2, 64), (2, 128), (3, 256), (3, 512), (3, 512)), num_classes=1000): super(VGG, self).__init__() self.vgg_blocks = [] iter_id = 0 # 添加vgg_block # 这里一共5个vgg_block,每个block里面的卷积层数目和输出通道数由conv_arch指定 in_channels = [3, 64, 128, 256, 512, 512] for (num_convs, num_channels) in conv_arch: block = self.add_sublayer('block'+str(iter_id), vgg_block(num_convs, in_channels=in_channels[iter_id], out_channels=num_channels)) self.vgg_blocks.append(block) iter_id += 1 self.fc1 = Linear(input_dim=512*7*7, output_dim=4096, act='relu') self.drop_ratio1 = 0.5 self.fc2 = Linear(input_dim=4096, output_dim=4096, act='relu') self.drop_ratio2 = 0.5 self.fc3 = Linear(input_dim=4096, output_dim=num_classes, act='softmax')
def __init__(self, name_scope, config, mode): super(TSM_ResNet, self).__init__(name_scope) self.layers = config.MODEL.num_layers self.seg_num = config.MODEL.seg_num self.class_dim = config.MODEL.num_classes self.reshape_list = [ config.MODEL.seglen * 3, config[mode.upper()]['target_size'], config[mode.upper()]['target_size'] ] if self.layers == 50: depth = [3, 4, 6, 3] else: raise NotImplementedError num_filters = [64, 128, 256, 512] self.conv = ConvBNLayer(num_channels=3, num_filters=64, filter_size=7, stride=2, act='relu') self.pool2d_max = Pool2D(pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') self.bottleneck_block_list = [] num_channels = 64 for block in range(len(depth)): shortcut = False for i in range(depth[block]): bottleneck_block = self.add_sublayer( 'bb_%d_%d' % (block, i), BottleneckBlock(num_channels=num_channels, num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, shortcut=shortcut, seg_num=self.seg_num)) num_channels = int(bottleneck_block._num_channels_out) self.bottleneck_block_list.append(bottleneck_block) shortcut = True self.pool2d_avg = Pool2D(pool_size=7, pool_type='avg', global_pooling=True) import math stdv = 1.0 / math.sqrt(2048 * 1.0) self.out = Linear( 2048, self.class_dim, act="softmax", param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)), bias_attr=fluid.param_attr.ParamAttr( learning_rate=2.0, regularizer=fluid.regularizer.L2Decay(0.)))
def __init__(self, layers=50, class_dim=100): super(ResNet, self).__init__() self.layers = layers supported_layers = [34, 50, 101, 152] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format(supported_layers, layers) if layers == 50: depth = [3, 4, 6, 3] elif layers == 101: depth = [3, 4, 23, 3] elif layers == 152: depth = [3, 8, 36, 3] num_channels = [64, 256, 512, 1024] num_filters = [64, 128, 256, 512] self.conv = ConvBNLayer( num_channels=3, num_filters=64, filter_size=7, stride=1, #stride=2, test w.o downsample act='relu') self.pool2d_max = Pool2D(pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') self.bottleneck_block_list = [] for block in range(len(depth)): shortcut = False for i in range(depth[block]): bottleneck_block = self.add_sublayer( 'bb_%d_%d' % (block, i), BottleneckBlock(num_channels=num_channels[block] if i == 0 else num_filters[block] * 4, num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, shortcut=shortcut)) self.bottleneck_block_list.append(bottleneck_block) shortcut = True self.pool2d_avg = Pool2D(pool_size=7, pool_type='avg', global_pooling=True) self.pool2d_avg_output = num_filters[len(num_filters) - 1] * 4 * 1 * 1 import math stdv = 1.0 / math.sqrt(2048 * 1.0) self.out = Linear( self.pool2d_avg_output, class_dim, act='softmax', param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)))
def __init__(self, rnn_hidden_size=Config.encoder_size, is_test=False, use_cudnn=True): super(EncoderNet, self).__init__() self.rnn_hidden_size = rnn_hidden_size para_attr = fluid.ParamAttr( initializer=fluid.initializer.Normal(0.0, 0.02)) bias_attr = fluid.ParamAttr(initializer=fluid.initializer.Normal( 0.0, 0.02), learning_rate=2.0) if fluid.framework.in_dygraph_mode(): h_0 = np.zeros((Config.batch_size, rnn_hidden_size), dtype="float32") h_0 = to_variable(h_0) else: h_0 = fluid.layers.fill_constant( shape=[Config.batch_size, rnn_hidden_size], dtype='float32', value=0) self.ocr_convs = OCRConv(is_test=is_test, use_cudnn=use_cudnn) self.fc_1_layer = Linear(768, rnn_hidden_size * 3, param_attr=para_attr, bias_attr=False) self.fc_2_layer = Linear(768, rnn_hidden_size * 3, param_attr=para_attr, bias_attr=False) self.gru_forward_layer = DynamicGRU(size=rnn_hidden_size, h_0=h_0, param_attr=para_attr, bias_attr=bias_attr, candidate_activation='relu') self.gru_backward_layer = DynamicGRU(size=rnn_hidden_size, h_0=h_0, param_attr=para_attr, bias_attr=bias_attr, candidate_activation='relu', is_reverse=True) self.encoded_proj_fc = Linear(rnn_hidden_size * 2, Config.decoder_size, bias_attr=False)
def __init__(self, class_dim=1000, scale=1.0): super(MobileNetV2, self).__init__() self.scale = scale self.class_dim = class_dim bottleneck_params_list = [ (1, 16, 1, 1), (6, 24, 2, 2), (6, 32, 3, 2), (6, 64, 4, 2), (6, 96, 3, 1), (6, 160, 3, 2), (6, 320, 1, 1), ] #1. conv1 self._conv1 = ConvBNLayer(num_channels=3, num_filters=int(32 * scale), filter_size=3, stride=2, act=None, padding=1) #2. bottleneck sequences self._invl = [] i = 1 in_c = int(32 * scale) for layer_setting in bottleneck_params_list: t, c, n, s = layer_setting i += 1 tmp = self.add_sublayer(sublayer=InvresiBlocks(in_c=in_c, t=t, c=int(c * scale), n=n, s=s), name='conv' + str(i)) self._invl.append(tmp) in_c = int(c * scale) #3. last_conv self._out_c = int(1280 * scale) if scale > 1.0 else 1280 self._conv9 = ConvBNLayer(num_channels=in_c, num_filters=self._out_c, filter_size=1, stride=1, act=None, padding=0) #4. pool self._pool2d_avg = Pool2D(pool_type='avg', global_pooling=True) #5. fc tmp_param = ParamAttr(name=self.full_name() + "fc10_weights") self._fc = Linear(self._out_c, class_dim, param_attr=tmp_param, bias_attr=ParamAttr(name="fc10_offset"))
def __init__(self, dict_dim, batch_size, seq_len): super(BOW, self).__init__() self.dict_dim = dict_dim self.emb_dim = 128 self.hid_dim = 128 self.fc_hid_dim = 96 self.class_dim = 2 self.batch_size = batch_size self.seq_len = seq_len self.embedding = Embedding( size=[self.dict_dim + 1, self.emb_dim], dtype='float32', is_sparse=False) self._fc1 = Linear(input_dim = self.hid_dim, output_dim=self.hid_dim, act="tanh") self._fc2 = Linear(input_dim = self.hid_dim, output_dim=self.fc_hid_dim, act="tanh") self._fc_prediction = Linear(input_dim = self.fc_hid_dim, output_dim = self.class_dim, act="softmax")
def __init__(self, nc, ndf=64, n_layers=3, stride=2, get_intern_feat=False, adaptive_layers=1): super(AdaptiveDiscriminator, self).__init__() self.get_intern_feat = get_intern_feat self.n_layers = n_layers self.adaptive_layers = adaptive_layers self.nc = nc self.ndf = ndf self.sw = cfg.FINESIZE // 8 self.sh = int(self.sw / cfg.ASPECTRATIO) self.ch = self.sh * self.sw nf = ndf fc_0 = self.add_sublayer('fc_0', Linear(self.ch, nc * 4**2)) encoder_0 = self.add_sublayer( 'encoder_0', Conv4x4(nc, nf, stride=2, act='leaky_relu')) self.fcs = [fc_0] self.encoders = [encoder_0] for n in range(1, self.adaptive_layers): nf_prev = nf nf = min(nf * 2, 512) fc = self.add_sublayer('fc_%d' % n, Linear(self.ch, nf_prev * 4**2)) encoder = self.add_sublayer( 'encoder_' % n, Conv4x4(nf_prev, nf, stride=2, act='leaky_relu')) self.fcs.append(fc) self.encoders.append(encoder) self.determined_convs = [] for n in range(self.add_parameter, self.n_layers + 1): nf_prev = nf nf = min(nf * 2, 512) conv = self.add_sublayer('conv_%d' % n, Conv4x4BNReLU(nf_prev, nf, stride=stride)) self.determined_convs.append(conv)
def __init__(self, num_classes=10, classifier_activation='softmax'): 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_b1_attr = fluid.ParamAttr(name="conv2d_b_1") 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(num_channels=1, num_filters=6, filter_size=3, stride=1, padding=1, param_attr=conv2d_w1_attr, bias_attr=conv2d_b1_attr), Pool2D(pool_size=2, pool_type='max', pool_stride=2), Conv2D(num_channels=6, num_filters=16, filter_size=5, stride=1, padding=0, param_attr=conv2d_w2_attr, bias_attr=conv2d_b2_attr), Pool2D(pool_size=2, pool_type='max', pool_stride=2)) self.fc = Sequential( Linear(input_dim=400, output_dim=120, param_attr=fc_w1_attr, bias_attr=fc_b1_attr), Linear(input_dim=120, output_dim=84, param_attr=fc_w2_attr, bias_attr=fc_b2_attr), Linear(input_dim=84, output_dim=num_classes, act=classifier_activation, param_attr=fc_w3_attr, bias_attr=fc_b3_attr))
def __init__(self, conv_arch=((2, 64), (2, 128), (3, 256), (3, 512), (3, 512))): super(VGG, self).__init__() self.vgg_blocks = [] iter_id = 0 in_channels = [3, 64, 128, 256, 512, 512] for (num_convs, num_channels) in conv_arch: block = self.add_sublayer( 'block_' + str(iter_id), vgg_block(num_convs, in_channels=in_channels[iter_id], out_channels=num_channels)) self.vgg_blocks.append(block) iter_id += 1 self.fc1 = Linear(input_dim=512 * 7 * 7, output_dim=4096, act='relu') self.drop1_ratio = 0.5 self.fc2 = Linear(input_dim=4096, output_dim=4096, act='relu') self.drop2_ratio = 0.5 self.fc3 = Linear(input_dim=4096, output_dim=1)
def __init__(self, num_classes=1): super(LeNet, self).__init__() self.conv1 = Conv2D(num_channels=1, num_filters=6, filter_size=5, act='sigmoid') self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.conv2 = Conv2D(num_channels=6, num_filters=16, filter_size=5, act='sigmoid') self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.conv3 = Conv2D(num_channels=16, num_filters=120, filter_size=4, act='sigmoid') self.fc1 = Linear(input_dim=120, output_dim=64, act='sigmoid') self.fc2 = Linear(input_dim=64, output_dim=num_classes)
def __init__(self, vocab_size): super(LogisticModel, self).__init__() self.logit = Linear( input_dim=4096, output_dim=vocab_size, act=None, param_attr=fluid.ParamAttr( initializer=fluid.initializer.MSRAInitializer(uniform=False)), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.MSRAInitializer(uniform=False)))
def __init__(self, input_dim, channels, sn=False, epsilon=1e-5): super(AdaIN, self).__init__() self.channels = channels self.epsilon = epsilon self.input_dim = input_dim self.norm = Nop_InstanceNorm(self.input_dim) self.fc = Linear(64, self.input_dim * 2, param_attr=weight_initializer, act=None)
def __init__(self): super(SimpleNet, self).__init__() self.net_a = paddle.nn.Sequential( paddle.nn.Linear(10, 20), paddle.nn.Linear(20, 20), paddle.nn.Linear(20, 5)) self.net_b = paddle.nn.Sequential( paddle.nn.Linear(10, 20), paddle.nn.Linear(20, 20), paddle.nn.Linear(20, 5)) self.net_unused = Linear(10, 20) self.step = 0
def __init__(self, encoder_size, decoder_size, num_classes): super(GRUDecoderWithAttention, self).__init__() self.simple_attention = SimpleAttention(decoder_size) self.fc_1_layer = Linear(input_dim=encoder_size * 2, output_dim=decoder_size * 3, bias_attr=False) self.fc_2_layer = Linear(input_dim=decoder_size, output_dim=decoder_size * 3, bias_attr=False) self.gru_unit = GRUUnit(size=decoder_size * 3, param_attr=None, bias_attr=None) self.out_layer = Linear(input_dim=decoder_size, output_dim=num_classes + 2, bias_attr=None, act='softmax') self.decoder_size = decoder_size
def __init__(self, num_channels, reduction_ratio): super(SqueezeExcitation, self).__init__() self._num_channels = num_channels self._pool = Pool2D(pool_size=0, pool_type='avg', global_pooling=True) stdv = 1.0 / math.sqrt(num_channels * 1.0) self._fc = Linear( num_channels, num_channels // reduction_ratio, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)), act='relu') stdv = 1.0 / math.sqrt(num_channels / 16.0 * 1.0) self._excitation = Linear( num_channels // reduction_ratio, num_channels, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)), act='sigmoid')
def __init__(self, name_scope, num_classes=1): super(LeNet, self).__init__(name_scope) self.conv1 = Conv2D(num_channels=1, num_filters=6, filter_size=5, act='relu') self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.conv2 = Conv2D(num_channels=6, num_filters=16, filter_size=5, act='relu') self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') # self.conv3 = Conv2D(num_channels=16, num_filters=120, filter_size=4, act='relu') # 创建全连接层,第一个全连接层的输出神经元个数为64, 第二个全连接层输出神经元个数为分裂标签的类别数 self.fc1 = Linear(input_dim=16 * 5 * 5, output_dim=120, act='relu') self.fc2 = Linear(input_dim=120, output_dim=84, act='relu') self.fc3 = Linear(input_dim=84, output_dim=num_classes)
def __init__(self, num_classes=1): super(AlexNet, self).__init__() self.conv1 = Conv2D(num_channels=3, num_filters=96, filter_size=11, stride=4, padding=5, act='relu') self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.conv2 = Conv2D(num_channels=96, num_filters=256, filter_size=5, stride=1, padding=2, act='relu') self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.conv3 = Conv2D(num_channels=256, num_filters=384, filter_size=3, stride=1, padding=1, act='relu') self.conv4 = Conv2D(num_channels=384, num_filters=384, filter_size=3, stride=1, padding=1, act='relu') self.conv5 = Conv2D(num_channels=384, num_filters=256, filter_size=3, stride=1, padding=1, act='relu') self.pool5 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.fc1 = Linear(input_dim=12544, output_dim=4096, act='relu') self.drop_ratio1 = 0.5 self.fc2 = Linear(input_dim=4096, output_dim=4096, act='relu') self.drop_ratio2 = 0.5 self.fc3 = Linear(input_dim=4096, output_dim=num_classes)
def __init__(self, depth=50, num_classes=1000): super(ResNet, self).__init__() layer_config = { 50: [3, 4, 6, 3], 101: [3, 4, 23, 3], 152: [3, 8, 36, 3], } assert depth in layer_config.keys(), \ "supported depth are {} but input layer is {}".format( layer_config.keys(), depth) layers = layer_config[depth] num_in = [64, 256, 512, 1024] num_out = [64, 128, 256, 512] self.conv = ConvBNLayer(num_channels=3, num_filters=64, filter_size=7, stride=2, act='relu') self.pool = Pool2D(pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') self.layers = [] for idx, num_blocks in enumerate(layers): blocks = [] shortcut = False for b in range(num_blocks): block = BottleneckBlock( num_channels=num_in[idx] if b == 0 else num_out[idx] * 4, num_filters=num_out[idx], stride=2 if b == 0 and idx != 0 else 1, shortcut=shortcut) blocks.append(block) shortcut = True layer = self.add_sublayer("layer_{}".format(idx), Sequential(*blocks)) self.layers.append(layer) self.global_pool = Pool2D(pool_size=7, pool_type='avg', global_pooling=True) stdv = 1.0 / math.sqrt(2048 * 1.0) self.fc_input_dim = num_out[-1] * 4 * 1 * 1 self.fc = Linear( self.fc_input_dim, num_classes, act='softmax', param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)))
def __init__(self, c_in, num_classes, layers, method, steps=4, multiplier=4, stem_multiplier=3): super(Network, self).__init__() self._c_in = c_in self._num_classes = num_classes self._layers = layers self._steps = steps self._multiplier = multiplier self._primitives = PRIMITIVES self._method = method c_cur = stem_multiplier * c_in self.stem = fluid.dygraph.Sequential( Conv2D(num_channels=3, num_filters=c_cur, filter_size=3, padding=1, param_attr=fluid.ParamAttr(initializer=MSRAInitializer()), bias_attr=False), BatchNorm(num_channels=c_cur, param_attr=fluid.ParamAttr( initializer=ConstantInitializer(value=1)), bias_attr=fluid.ParamAttr( initializer=ConstantInitializer(value=0)))) c_prev_prev, c_prev, c_cur = c_cur, c_cur, c_in cells = [] reduction_prev = False for i in range(layers): if i in [layers // 3, 2 * layers // 3]: c_cur *= 2 reduction = True else: reduction = False cell = Cell(steps, multiplier, c_prev_prev, c_prev, c_cur, reduction, reduction_prev, method) reduction_prev = reduction cells.append(cell) c_prev_prev, c_prev = c_prev, multiplier * c_cur self.cells = fluid.dygraph.LayerList(cells) self.global_pooling = Pool2D(pool_type='avg', global_pooling=True) self.classifier = Linear( input_dim=c_prev, output_dim=num_classes, param_attr=ParamAttr(initializer=MSRAInitializer()), bias_attr=ParamAttr(initializer=MSRAInitializer())) self._initialize_alphas()
def __init__(self): super(OCRAttention, self).__init__() self.encoder_net = EncoderNet() self.fc = Linear(Config.encoder_size, Config.decoder_size, bias_attr=False, act='relu') self.embedding = Embedding( [Config.num_classes + 2, Config.word_vector_dim], dtype='float32') self.gru_decoder_with_attention = GRUDecoderWithAttention( Config.decoder_size, Config.num_classes)
def forward(self, inputs): inputs = paddle.fluid.data(input) inputs = paddle.reshape(inputs, (-1, 784)) zeros = paddle.tensor.zeros(shape=[1, 2], dtype="float32", force_cpu=False) inputs = Linear(700, 400) outputs = self.fc(inputs) return outputs
def __init__(self, dict_dim, seq_len): super(GRU, self).__init__() self.dict_dim = dict_dim self.emb_dim = 128 self.hid_dim = 128 self.fc_hid_dim = 96 self.class_dim = 3 self.seq_len = seq_len self._fc1 = Linear(input_dim=self.hid_dim, output_dim=self.fc_hid_dim, act="tanh") self._fc_prediction = Linear(input_dim=self.fc_hid_dim, output_dim=self.class_dim, act="softmax") self._encoder = GRUEncoder(dict_size=self.dict_dim + 1, emb_dim=self.emb_dim, gru_dim=self.hid_dim, hidden_dim=self.hid_dim, padding_idx=None, seq_len=self.seq_len)
def __init__(self, input_dim, grnn_hidden_dim, init_bound, h_0=None): super(BiGRU, self).__init__() self.pre_gru = Linear( input_dim=input_dim, output_dim=grnn_hidden_dim * 3, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Uniform(low=-init_bound, high=init_bound), regularizer=fluid.regularizer.L2DecayRegularizer( regularization_coeff=1e-4))) #, #num_flatten_dims=2) self.gru = DynamicGRU( size=grnn_hidden_dim, h_0=h_0, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Uniform(low=-init_bound, high=init_bound), regularizer=fluid.regularizer.L2DecayRegularizer( regularization_coeff=1e-4))) self.pre_gru_r = Linear( input_dim=input_dim, output_dim=grnn_hidden_dim * 3, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Uniform(low=-init_bound, high=init_bound), regularizer=fluid.regularizer.L2DecayRegularizer( regularization_coeff=1e-4))) #, #num_flatten_dims=2) self.gru_r = DynamicGRU( size=grnn_hidden_dim, is_reverse=True, h_0=h_0, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Uniform(low=-init_bound, high=init_bound), regularizer=fluid.regularizer.L2DecayRegularizer( regularization_coeff=1e-4)))
def __init__(self, features, num_classes=1000): super(VGG, self).__init__() self.features = features self.avgpool = Pool2D(pool_size=7, pool_stride=1, pool_type='avg') import math stdv = 1.0 / math.sqrt(2048 * 1.0) self.classifier = Linear( 512, num_classes, act='softmax', param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)))