def __init__(self, num_classes=1000): super(MobileNetV3_Large, self).__init__() self.conv1 = Conv2D(3, 16, filter_size=3, stride=2, padding=1) self.bn1 = BatchNorm(16) self.hs1 = hswish() self.bneck = fluid.dygraph.Sequential( Block(3, 16, 16, 16, relu(), None, 1), Block(3, 16, 64, 24, relu(), None, 2), Block(3, 24, 72, 24, relu(), None, 1), Block(5, 24, 72, 40, relu(), SeModule(40), 2), Block(5, 40, 120, 40, relu(), SeModule(40), 1), Block(5, 40, 120, 40, relu(), SeModule(40), 1), Block(3, 40, 240, 80, hswish(), None, 2), Block(3, 80, 200, 80, hswish(), None, 1), Block(3, 80, 184, 80, hswish(), None, 1), Block(3, 80, 184, 80, hswish(), None, 1), Block(3, 80, 480, 112, hswish(), SeModule(112), 1), Block(3, 112, 672, 112, hswish(), SeModule(112), 1), Block(5, 112, 672, 160, hswish(), SeModule(160), 1), Block(5, 160, 672, 160, hswish(), SeModule(160), 2), Block(5, 160, 960, 160, hswish(), SeModule(160), 1), ) self.conv2 = Conv2D(160, 960, filter_size=1, stride=1, padding=0) self.bn2 = BatchNorm(960) self.hs2 = hswish() self.linear3 = Linear(960, 1280) self.bn3 = BatchNorm(1280) self.hs3 = hswish() self.linear4 = Linear(1280, num_classes,act='softmax')
def __init__(self, dict_dim, emb_dim=128, hid_dim=128, fc_hid_dim=96, class_dim=2, channels=1, win_size=(3, 128)): super(CNN, self).__init__() self.dict_dim = dict_dim self.emb_dim = emb_dim self.hid_dim = hid_dim self.fc_hid_dim = fc_hid_dim self.class_dim = class_dim self.channels = channels self.win_size = win_size self.embedding = Embedding(size=[self.dict_dim + 1, self.emb_dim], dtype='float64', is_sparse=False, padding_idx=0) self._conv2d = Conv2D(num_channels=self.channels, num_filters=self.hid_dim, filter_size=win_size, padding=[1, 0], use_cudnn=True, act=None, dtype="float64") self._fc_1 = Linear(input_dim=self.hid_dim, output_dim=self.fc_hid_dim, dtype="float64") self._fc_2 = Linear(input_dim=self.fc_hid_dim, output_dim=self.class_dim, act="softmax", dtype="float64")
def __init__(self, num_classes=1000): super(MobileNetV3_Small, self).__init__() self.conv1 = Conv2D(3, 16, filter_size=3, stride=2, padding=1) self.bn1 = BatchNorm(16) self.hs1 = hswish() self.bneck = fluid.dygraph.Sequential( Block(3, 16, 16, 16, relu(), SeModule(16), 2), Block(3, 16, 72, 24, relu(), None, 2), Block(3, 24, 88, 24, relu(), None, 1), Block(5, 24, 96, 40, hswish(), SeModule(40), 2), Block(5, 40, 240, 40, hswish(), SeModule(40), 1), Block(5, 40, 240, 40, hswish(), SeModule(40), 1), Block(5, 40, 120, 48, hswish(), SeModule(48), 1), Block(5, 48, 144, 48, hswish(), SeModule(48), 1), Block(5, 48, 288, 96, hswish(), SeModule(96), 2), Block(5, 96, 576, 96, hswish(), SeModule(96), 1), Block(5, 96, 576, 96, hswish(), SeModule(96), 1), ) self.conv2 = Conv2D(96, 576, filter_size=1, stride=1, padding=0) self.bn2 = BatchNorm(576) self.hs2 = hswish() self.linear3 = Linear(576, 1280) self.bn3 = BatchNorm(1280) self.hs3 = hswish() self.linear4 = Linear(1280, num_classes,act='softmax')
def __init__(self): super(DNN, self).__init__() self.name = 'DNN_1024_512_256_dygraph' self.embeddings = [ Embedding( size=[cfg.sparse_feature_dim, cfg.embedding_size], dtype='float32', padding_idx=0, param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(cfg.embedding_size))))) for _ in range(26) ] feature_size = 13 + 26 * cfg.embedding_size self.block_1 = Linear( feature_size, 1024, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1))) self.block_2_1 = Linear( 1024, 1024, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1))) self.block_2_2 = Linear( 1024, 512, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1))) self.block_2_3 = Linear( 512, 256, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1))) self.block_3 = Linear( 256, 2, act='softmax', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1)))
def __init__(self, num_channels, num_filters, reduction_ratio, name=None): super(SELayer, self).__init__() self.pool2d_gap = Pool2D(pool_type='avg', global_pooling=True) self._num_channels = num_channels med_ch = int(num_channels / reduction_ratio) stdv = 1.0 / math.sqrt(num_channels * 1.0) self.squeeze = Linear(num_channels, med_ch, act="relu", param_attr=ParamAttr( initializer=fluid.initializer.Uniform( -stdv, stdv), name=name + "_sqz_weights"), bias_attr=ParamAttr(name=name + '_sqz_offset')) stdv = 1.0 / math.sqrt(med_ch * 1.0) self.excitation = Linear( med_ch, num_filters, act="sigmoid", param_attr=ParamAttr(initializer=fluid.initializer.Uniform( -stdv, stdv), name=name + "_exc_weights"), bias_attr=ParamAttr(name=name + '_exc_offset'))
def __init__(self, dict_dim, batch_size, seq_len): super(BiGRU, 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', param_attr=fluid.ParamAttr(learning_rate=30), is_sparse=False) h_0 = np.zeros((self.batch_size, self.hid_dim), dtype="float32") h_0 = to_variable(h_0) self._fc1 = Linear(input_dim=self.hid_dim, output_dim=self.hid_dim * 3) self._fc2 = Linear(input_dim=self.hid_dim * 2, 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._gru_forward = DynamicGRU(size=self.hid_dim, h_0=h_0, is_reverse=False) self._gru_backward = DynamicGRU(size=self.hid_dim, h_0=h_0, is_reverse=True)
def __init__(self, dict_dim, batch_size, seq_len): super(CNN, 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.channels = 1 self.win_size = [3, self.hid_dim] 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._simple_conv_pool_1 = SimpleConvPool( self.channels, self.hid_dim, self.win_size, batch_size=self.batch_size) self._fc1 = Linear( input_dim=self.hid_dim * self.seq_len, output_dim=self.fc_hid_dim, act="softmax") self._fc_prediction = Linear( input_dim=self.fc_hid_dim, output_dim=self.class_dim, act="softmax")
def __init__(self, name_scope): super(MNIST, self).__init__(name_scope) #两个隐含层 self.fc1 = Linear(input_dim=784, output_dim=10, act='sigmoid') self.fc2 = Linear(input_dim=10, output_dim=10, act='sigmoid') #输出层,不用激活函数 self.fc3 = Linear(input_dim=10, output_dim=1, act=None)
def __init__(self, name, cfg, mode='train'): super(AttentionCluster, self).__init__() self.name = name self.cfg = cfg self.mode = mode self.is_training = (mode == 'train') self.get_config() self.fc1 = Linear( input_dim=36864, output_dim=1024, act='tanh', param_attr=ParamAttr( name="fc1.weights", initializer=fluid.initializer.MSRA(uniform=False)), bias_attr=ParamAttr(name="fc1.bias", initializer=fluid.initializer.MSRA())) self.fc2 = Linear( input_dim=1024, output_dim=4096, act='tanh', param_attr=ParamAttr( name="fc2.weights", initializer=fluid.initializer.MSRA(uniform=False)), bias_attr=ParamAttr(name="fc2.bias", initializer=fluid.initializer.MSRA()))
def __init__(self, dict_dim, batch_size, seq_len): super(BiGRU, 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', param_attr=fluid.ParamAttr(learning_rate=30), is_sparse=False) h_0 = np.zeros((self.batch_size, self.hid_dim), dtype="float32") h_0 = to_variable(h_0) self._fc1 = Linear(input_dim=self.hid_dim, output_dim=self.hid_dim * 3) self._fc2 = Linear(input_dim=self.hid_dim * 2, 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 = BiGRUEncoder(grnn_hidden_dim=self.hid_dim, input_dim=self.hid_dim * 3, h_0=h_0, init_bound=0.1, is_bidirection=True)
def __init__(self, dict_dim, batch_size, seq_len): super(CNN, 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.channels = 1 self.win_size = [3, self.hid_dim] self.batch_size = batch_size self.seq_len = seq_len self._encoder = CNNEncoder(dict_size=self.dict_dim + 1, emb_dim=self.emb_dim, seq_len=self.seq_len, filter_size=self.win_size, num_filters=self.hid_dim, hidden_dim=self.hid_dim, padding_idx=None, act='tanh') self._fc1 = Linear(input_dim=self.hid_dim * self.seq_len, output_dim=self.fc_hid_dim, act="softmax") self._fc_prediction = Linear(input_dim=self.fc_hid_dim, output_dim=self.class_dim, act="softmax")
def __init__(self): super(SimpleFCNet, self).__init__() param_attr = fluid.ParamAttr(initializer=fluid.initializer.Constant( value=0.8)) bias_attr = fluid.ParamAttr(initializer=fluid.initializer.Constant( value=0.5)) self._fcs = [] in_channel = IMAGE_SIZE for hidden_size in [10, 20, 30]: self._fcs.append( Linear( in_channel, hidden_size, act='tanh', param_attr=param_attr, bias_attr=bias_attr)) in_channel = hidden_size self._fcs.append( Linear( in_channel, CLASS_NUM, act='softmax', param_attr=param_attr, bias_attr=bias_attr))
def __init__(self): super(SimpleNetUnusedParam, self).__init__() self.net_a = Linear(input_dim=10, output_dim=20) self.net_b = Linear(input_dim=20, output_dim=5) self.net_c = Linear(input_dim=5, output_dim=10) self.net_d = Linear(input_dim=20, output_dim=10)
def __init__(self): super(DNNPlus, self).__init__() self.name = 'DNNPlus_' + str(cfg.embedding_size) + '_' + str( cfg.dnn_hidden_dims[0]) self.init_value_ = 0.1 self.embedding_w = Embedding( size=[cfg.num_feat + 1, 1], dtype='float32', padding_idx=0, param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_), regularizer=fluid.regularizer.L1DecayRegularizer(cfg.reg))) self.embedding = Embedding( size=[cfg.num_feat + 1, cfg.embedding_size], dtype='float32', padding_idx=0, param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_ / math.sqrt(float(cfg.embedding_size))))) self.first_order_act = fluid.layers.sigmoid sizes = [cfg.num_field * cfg.embedding_size ] + cfg.deepfm_layer_sizes + [1] acts = ['relu' for _ in range(len(cfg.deepfm_layer_sizes))] + [None] w_scales = [ self.init_value_ / math.sqrt(float(10)) for _ in range(len(cfg.deepfm_layer_sizes)) ] + [self.init_value_] self.second_order_fc = Linear( cfg.deepfm_layer_sizes[0], 1, act='sigmoid', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=w_scales[0])), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_))) self.add_sublayer('secong_order', self.second_order_fc) self.linears = [] for i in range(len(cfg.deepfm_layer_sizes) + 1): linear = Linear( sizes[i], sizes[i + 1], act=acts[i], param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=w_scales[i])), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_))) self.add_sublayer('linear_%d' % i, linear) self.linears.append(linear)
def __init__(self): super(MNIST, self).__init__() # 定义两层全连接隐含层,输出维度是10,激活函数为sigmoid self.fc1 = Linear(input_dim=784, output_dim=10, act='sigmoid') # 隐含层节点为10,可根据任务调整 self.fc2 = Linear(input_dim=10, output_dim=10, act='sigmoid') # 定义一层全连接输出层,输出维度是1,不使用激活函数 self.fc3 = Linear(input_dim=10, output_dim=1, act=None)
def __init__(self, decoder_size): super(SimpleAttention, self).__init__() self.fc_1 = Linear(decoder_size, decoder_size, act=None, bias_attr=False) self.fc_2 = Linear(decoder_size, 1, act=None, bias_attr=False)
def __init__(self): super(MLP, self).__init__() SIZE = 10 self._fc1 = Linear(784, 200, act="relu") self._fc2 = Linear(200, 200, act="relu") self._fc3 = Linear(200, 200, act="relu") self._fc4 = Linear(200, 10, act="softmax") self._fc5 = Linear(200, 10, act="softmax")
def __init__(self, num_classes=8): super(Model, self).__init__() self.fc1 = Linear(input_dim=10, output_dim=32, act='relu') # 输入层和隐藏层的连接,隐藏层使用Sigmoid作为激活函数 self.fc2 = Linear(input_dim=32, output_dim=16, act='relu') # 第一个隐藏层和第二个隐藏层之间的连接 self.fc3 = Linear(input_dim=16, output_dim=num_classes, act='sigmoid') # 隐藏层和输出层的连接,输出层不使用激活函数
def __init__(self, name_scope, num_classes=1): super(VAE_Linear, self).__init__(name_scope) # 创建卷积和池化层块,每个卷积层使用Sigmoid激活函数,后面跟着一个2x2的池化 self.fc1 = Linear(784, 400) self.fc21 = Linear(400, 20) self.fc22 = Linear(400, 20) self.fc3 = Linear(20, 400) self.fc4 = Linear(400, 784)
def __init__(self, num_classes=10, classifier_activation='softmax'): super(LeNet, self).__init__() self.num_classes = num_classes self.features = Sequential(Conv2D(1, 6, 3, stride=1, padding=1), Pool2D(2, 'max', 2), Conv2D(6, 16, 5, stride=1, padding=0), Pool2D(2, 'max', 2)) if num_classes > 0: self.fc = Sequential(Linear(400, 120), Linear(120, 84), Linear(84, 10, act=classifier_activation))
def __init__(self, num_classes=10): super(AlexNet, self).__init__() # AlexNet与LeNet一样也会同时使用卷积和池化层提取图像特征 # 与LeNet不同的是激活函数换成了‘relu’ # 这里将conv1中的输入通道数设置成1,输入为(样本数m,1,28,28) self.conv1 = Conv2D(num_channels=1, num_filters=10, filter_size=11, stride=1, padding=3, act='relu') # 输出为(m,10,24,24) self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') # 输出为(m,10,12,12) self.conv2 = Conv2D(num_channels=10, num_filters=100, filter_size=5, stride=1, padding=2, act='relu') # (m,100,12,12) self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') # (m,100,6,6) self.conv3 = Conv2D(num_channels=100, num_filters=200, filter_size=3, stride=1, padding=0, act='relu') # (m,200,4,4) self.conv4 = Conv2D(num_channels=200, num_filters=200, filter_size=3, stride=1, padding=1, act='relu') # (m,200,4,4) self.conv5 = Conv2D(num_channels=200, num_filters=100, filter_size=3, stride=1, padding=1, act='relu') # (m,100,4,4) self.pool5 = Pool2D(pool_size=2, pool_stride=2, pool_type='max') # 相当于无效 # (m,100,2,2) self.fc1 = Linear(input_dim=400, output_dim=64, act='relu') self.drop_ratio1 = 0.5 self.fc2 = Linear(input_dim=64, output_dim=64, act='relu') self.drop_ratio2 = 0.5 self.fc3 = Linear(input_dim=64, output_dim=num_classes)
def __init__(self, args): super(Relation_module, self).__init__() self.args = args if 'imagenet' in self.args.dataset or 'cub' in self.args.dataset: linear_dim = 3*3*self.args.num_filters else: linear_dim = self.args.num_filters inp_channels = self.args.num_filters*2 if self.args.backbone=='Conv4' else self.args.resnet12_num_filters[-1]*2 padding = 1 if self.args.dataset=='omniglot' else 0 self.conv0 = Conv_block(num_channels=inp_channels, num_filters=64, padding=padding, pooltype=self.args.pooling_type, args=args) self.conv1 = Conv_block(num_channels=64, num_filters=64, padding=padding, pooltype=self.args.pooling_type, args=args) self.fc0 = Linear(linear_dim, 8) self.fc1 = Linear(8, 1)
def __init__(self): super(DRNN, self).__init__() self.name = 'DRNN_' + str(cfg.drnn_hidden_dim) + '_' + str( cfg.drnn_hidden_layer) self.embeddings = [ Embedding( size=[cfg.sparse_feature_dim, cfg.embedding_size], dtype='float32', padding_idx=0, param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(cfg.embedding_size))))) for _ in range(26) ] feature_size = 13 + 26 * cfg.embedding_size self.block_1 = Linear( feature_size, cfg.drnn_hidden_dim, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1))) self.block_2 = Linear( cfg.drnn_hidden_dim, cfg.drnn_hidden_dim, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1))) self.block_3 = Linear( cfg.drnn_hidden_dim, 2, act='softmax', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1 / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=0.1)))
def __init__(self, num_class=10): super(LeNet, self).__init__() # 创建卷积和池化层块,每个卷积层sigmoid激活函数,后面加一个2x2的池化 self.conv1 = Conv2D(num_channels=1, num_filters=6, filter_size=5, act='sigmoid') self.pool1 = Pool2D(pool_size=2, pool_type='max', pool_stride=2, pool_padding=0) self.conv2 = Conv2D(num_channels=6, num_filters=16, filter_size=5, act='sigmoid') self.pool2 = Pool2D(pool_size=2, pool_type='max', pool_stride=2, pool_padding=0) # 创建第3个卷积层,此卷积层不含有池化层 self.conv3 = Conv2D(num_channels=16, num_filters=120, filter_size=5, act='sigmoid') # 创建全连接层,卷积层的输出数据格式是[N,C,H,W],在输入全连接层的时候,会自动将数据拉平 # 也就是对每个样本,自动将其转化为长度为K的向量,K=C×H×W ,一个mini-batch的数据维度变成了N×K的二维向量 self.fc1 = Linear(input_dim=120, output_dim=64, act='sigmoid') self.fc2 = Linear(input_dim=64, output_dim=num_classes, act='softmax')
def __init__(self, decoder_size, num_classes): super(GRUDecoderWithAttention, self).__init__() self.simple_attention = SimpleAttention(decoder_size) self.fc_1_layer = Linear( Config.encoder_size * 2, decoder_size * 3, bias_attr=False) self.fc_2_layer = Linear( decoder_size, decoder_size * 3, bias_attr=False) self.gru_unit = GRUUnit( size=decoder_size * 3, param_attr=None, bias_attr=None) self.out_layer = Linear( decoder_size, num_classes + 2, bias_attr=None, act='softmax') self.decoder_size = decoder_size
def __init__(self): super(DRNN, self).__init__() self.name = 'DRNN_' + str(cfg.embedding_size) + '_' + str( cfg.drnn_hidden_dim) + '_' + str(cfg.drnn_hidden_layer) self.init_value_ = 0.1 self.embedding = Embedding( size=[cfg.num_feat + 1, cfg.embedding_size], dtype='float32', padding_idx=0, param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_ / math.sqrt(float(cfg.embedding_size))))) self.hidden_1 = Linear( cfg.num_field * cfg.embedding_size, cfg.drnn_hidden_dim, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_ / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_))) self.add_sublayer('hidden_1', self.hidden_1) self.hidden_2 = Linear( cfg.drnn_hidden_dim, cfg.drnn_hidden_dim, act='relu', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_ / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_))) self.add_sublayer('hidden_2', self.hidden_2) self.hidden_3 = Linear( cfg.drnn_hidden_dim, 1, act='sigmoid', param_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_ / math.sqrt(float(10)))), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.TruncatedNormalInitializer( loc=0.0, scale=self.init_value_))) self.add_sublayer('hidden_3', self.hidden_3)
def __init__(self, num_classes=1000): super(AlexNet, self).__init__() # AlexNet与LeNet一样使用卷积层与池化层提取图像特征 # 不同的是AlexNet激活函数换成了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_type='max', pool_stride=2) 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_type='max', pool_stride=2) 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_type='max', pool_stride=2) self.fc1 = Linear(input_dim=12544, output_dim=4096, act='relu') self.drop_ratio1 = 0.5 # AlexNet的一个改进就是引入了dropout # 在全连接之后使用dropout抑制过拟合 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, 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 ) print( "weight", self.fc_1_layer.weight.shape ) 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): 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, layers=50, class_dim=1000): """ layers, 网络层数,可以是50, 101或者152 class_dim,分类标签的类别数 """ super(ResNet, self).__init__() self.layers = layers supported_layers = [50, 101, 152] assert layers in supported_layers, 'supported layers are {} but input layer is {}'.format( supported_layers, layers) if layers == 50: # ResNet50包含多个模块,其中第2到第5个模块分别包含3、4、6、3个残差块 depth = [3, 4, 6, 3] elif layers == 101: # ResNet101包含多个模块,其中第2到第5个模块分别包含3、4、23、3个残差块 depth = [3, 4, 23, 3] elif layers == 152: # ResNet152包含多个模块,其中第2到第5个模块分别包含3、8、36、3个残差块 depth = [3, 8, 36, 3] # 残差块中使用到的卷积的输出通道数 num_filters = [64, 128, 256, 512] # ResNet的第一个模块,包含1个7x7卷积,后面跟着1个最大池化层 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') # ResNet的第二到第五个残差块c2、c3、c4、c5(BottleNeckBlock也就是残差块) 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, # c3、c4、c5将会在第一个残差块使用stride=2;其余所有残差块stride=1 shortcut=shortcut)) num_channels = bottleneck_block._num_channels_out self.bottleneck_block_list.append(bottleneck_block) shortcut = True # 在c5的输出特征图上使用全局池化 self.pool2d_avg = Pool2D(pool_size=7, pool_type='avg', global_pooling=True) # stdv用来作为全连接层随机初始化参数的方差 stdv = 1.0 / math.sqrt(2048 * 1.0) # 创建全连接层,输出大小为类别数目 self.out = Linear( input_dim=2048, output_dim=class_dim, param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.Uniform(-stdv, stdv)))