def test_simple_conv2d(self): program = Program() with program_guard(program, startup_program=Program()): images = layers.data(name='pixel', shape=[3, 48, 48], dtype='int32') layers.conv2d(input=images, num_filters=3, filter_size=[4, 4]) print(str(program))
def test_simple_conv2d(self): program = Program() with program_guard(program, startup_program=Program()): images = layers.data(name='pixel', shape=[3, 48, 48], dtype='int32') layers.conv2d(input=images, num_filters=3, filter_size=[4, 4]) print(str(program))
def proto_net(x): x = P.conv2d(x, 256, filter_size=(3, 3), stride=1, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="proto_net.0.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="proto_net.0.bias")) x = P.relu(x) x = P.conv2d(x, 256, filter_size=(3, 3), stride=1, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="proto_net.2.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="proto_net.2.bias")) x = P.relu(x) x = P.conv2d(x, 256, filter_size=(3, 3), stride=1, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="proto_net.4.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="proto_net.4.bias")) x = P.relu(x) x = P.resize_bilinear(x, scale=float(2)) x = P.relu(x) x = P.conv2d(x, 256, filter_size=(3, 3), stride=1, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="proto_net.8.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="proto_net.8.bias")) x = P.relu(x) x = P.conv2d(x, 32, filter_size=(1, 1), stride=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="proto_net.10.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="proto_net.10.bias")) return x
def PredictionModule(x, num_priors, num_classes, mask_dim, shared_conv_w, shared_conv_b, shared_bbox_w, shared_bbox_b, shared_conf_w, shared_conf_b, shared_mask_w, shared_mask_b): ''' 改编自DSSD算法中的PredictionModule,改成了3x3卷积。3个分支分别预测bbox、conf、mask系数。 x / | \ bbox conf mask ''' x = P.conv2d(x, 256, filter_size=(3, 3), stride=1, padding=1, param_attr=shared_conv_w, bias_attr=shared_conv_b) x = P.relu(x) bbox_x = x conf_x = x mask_x = x bbox = P.conv2d(bbox_x, num_priors * 4, filter_size=(3, 3), stride=1, padding=1, param_attr=shared_bbox_w, bias_attr=shared_bbox_b) bbox = P.transpose(bbox, perm=[0, 2, 3, 1]) bbox = P.reshape(bbox, (P.shape(bbox)[0], -1, 4)) conf = P.conv2d(conf_x, num_priors * num_classes, filter_size=(3, 3), stride=1, padding=1, param_attr=shared_conf_w, bias_attr=shared_conf_b) conf = P.transpose(conf, perm=[0, 2, 3, 1]) conf = P.reshape(conf, (P.shape(conf)[0], -1, num_classes)) mask = P.conv2d(mask_x, num_priors * mask_dim, filter_size=(3, 3), stride=1, padding=1, param_attr=shared_mask_w, bias_attr=shared_mask_b) mask = P.transpose(mask, perm=[0, 2, 3, 1]) mask = P.reshape(mask, (P.shape(mask)[0], -1, mask_dim)) mask = P.tanh(mask) preds = {'loc': bbox, 'conf': conf, 'mask': mask} return preds
def conv2d(x, filters, filter_size, padding=1, bias=False): conv_out = layers.conv2d(input=x, padding=padding, num_filters=filters, filter_size=filter_size, bias_attr=bias) return conv_out
def func(self, place): shape = [2, 4, 3, 3] eps = 0.005 dtype = np.float32 if fluid.core.is_compiled_with_rocm( ) else np.float64 x = layers.data('x', shape, False, dtype) # condition of depthwise conv: # use_cudnn == False # groups == filters # num_filters % num_channels == 0 y = layers.conv2d(x, shape[1], 1, groups=shape[1], bias_attr=False, use_cudnn=False) x_arr = np.random.uniform(-1, 1, shape).astype(dtype) w = fluid.default_main_program().global_block().all_parameters() w_arr = [] for p in w: w_arr.append(np.random.uniform(-1, 1, p.shape).astype(dtype)) gradient_checker.double_grad_check([x] + w, y, x_init=[x_arr] + w_arr, place=place, eps=eps)
def conv2d_unit(x, filters, kernels, stride, padding, name, is_test, trainable): x = P.conv2d(input=x, num_filters=filters, filter_size=kernels, stride=stride, padding=padding, act=None, param_attr=ParamAttr(initializer=fluid.initializer.Normal( 0.0, 0.01), name=name + ".conv.weights", trainable=trainable), bias_attr=False) bn_name = name + ".bn" x = P.batch_norm( input=x, act=None, is_test=is_test, param_attr=ParamAttr(initializer=fluid.initializer.Constant(1.0), regularizer=L2Decay(0.), trainable=trainable, name=bn_name + '.scale'), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.), trainable=trainable, name=bn_name + '.offset'), moving_mean_name=bn_name + '.mean', moving_variance_name=bn_name + '.var') x = P.leaky_relu(x, alpha=0.1) return x
def conv_bn_layer(self, input, num_filters, filter_size, stride, padding, name=None): """Create conv+bn layer""" conv = FL.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=1, act=None, param_attr=ParamAttr(name=name + "_weights"), bias_attr=False, name=name + '.conv2d.output.1') bn_name = name + ".bn" return FL.batch_norm( input=conv, act=None, name=bn_name + '.output.1', 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', )
def func(self, place): shape = [2, 2, 3, 3] eps = 0.005 dtype = np.float32 if fluid.core.is_compiled_with_rocm( ) else np.float64 x = layers.data('x', shape, False, dtype) y = layers.conv2d(input=x, num_filters=2, filter_size=1, padding=[1, 0, 1, 0], bias_attr=False, use_cudnn=True, groups=1, data_format="NHWC") x_arr = np.random.uniform(-1, 1, shape).astype(dtype) w = fluid.default_main_program().global_block().all_parameters() w_arr = [] for p in w: w_arr.append(np.random.uniform(-1, 1, p.shape).astype(dtype)) gradient_checker.double_grad_check([x] + w, y, x_init=[x_arr] + w_arr, place=place, eps=eps)
def _DBL(input, num_filters, filter_size, padding=1, name=None): conv = pfl.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, padding=padding, name=(name + '_conv2d') if name else None) bn = pfl.batch_norm(input=conv, name=(name + '_conv2d') if name else None) act = pfl.leaky_relu(bn, name=(name + '_act') if name else None) return act
def Yolact(backbone_name, inputs, num_classes, mask_dim, num_priors_list, is_test, transform=None, input_size=550, use_fast_prep=False): if use_fast_prep: inputs = fast_preprocess_layer(inputs, input_size, transform.normalize, transform.subtract_means, transform.to_float) # 冻结层时(即trainable=False),bn的均值、标准差也还是会变化,只有设置is_test=True才保证不变 trainable = not is_test if backbone_name == 'darknet53': backbone_s8, backbone_s16, backbone_s32 = DarkNet53(inputs, is_test, trainable) elif backbone_name == 'resnet50': backbone_s8, backbone_s16, backbone_s32 = Resnet50(inputs, is_test, trainable, use_dcn=False) elif backbone_name == 'resnet101': backbone_s8, backbone_s16, backbone_s32 = Resnet101(inputs, is_test, trainable, use_dcn=False) elif backbone_name == 'resnet50dcn': backbone_s8, backbone_s16, backbone_s32 = Resnet50(inputs, is_test, trainable, use_dcn=True) s8, s16, s32, s64, s128 = FPN(backbone_s8, backbone_s16, backbone_s32) # 1.mask原型,默认有32个原型,即通道数是32 proto_x = s8 proto_out = proto_net(proto_x) proto_out = P.relu(proto_out) proto_out = P.transpose(proto_out, perm=[0, 2, 3, 1]) # 2.预测头。第一个PredictionModule里的4个卷积层的参数被后面的PredictionModule共享 shared_conv_w = ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="prediction_layers.0.upfeature.0.weight") shared_conv_b = ParamAttr(initializer=fluid.initializer.Constant(0.0), name="prediction_layers.0.upfeature.0.bias") shared_bbox_w = ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="prediction_layers.0.bbox_layer.weight") shared_bbox_b = ParamAttr(initializer=fluid.initializer.Constant(0.0), name="prediction_layers.0.bbox_layer.bias") shared_conf_w = ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="prediction_layers.0.conf_layer.weight") shared_conf_b = ParamAttr(initializer=fluid.initializer.Constant(0.0), name="prediction_layers.0.conf_layer.bias") shared_mask_w = ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="prediction_layers.0.mask_layer.weight") shared_mask_b = ParamAttr(initializer=fluid.initializer.Constant(0.0), name="prediction_layers.0.mask_layer.bias") pred_outs = {'loc': [], 'conf': [], 'mask': []} for i, tensor in enumerate([s8, s16, s32, s64, s128]): num_priors = num_priors_list[i] # 预测bbox、conf、mask preds = PredictionModule(tensor, num_priors, num_classes, mask_dim, shared_conv_w, shared_conv_b, shared_bbox_w, shared_bbox_b, shared_conf_w, shared_conf_b, shared_mask_w, shared_mask_b) for key, value in preds.items(): pred_outs[key].append(value) for key, value in pred_outs.items(): pred_outs[key] = P.concat(value, axis=1) pred_outs['proto'] = proto_out if is_test: # 预测状态 print('----test----') pred_outs['conf'] = P.softmax(pred_outs['conf']) else: # 训练状态 print('----train----') pred_outs['segm'] = P.conv2d(s8, num_classes-1, filter_size=(1, 1), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="semantic_seg_conv.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="semantic_seg_conv.bias")) return pred_outs
def forward(self, x): if self.f is not None: # expand kernel channels kernel = self.f.expand(x.size(1), -1, -1, -1) x = layers.conv2d(x, kernel, stride=self.stride, padding=int((self.f.shape[2] - 1) / 2), groups=x.shape[1]) return x else: return x
def __call__(self, input): return layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, dilation=dilation, groups=groups, param_attr=self.attr_holder.param_attr, bias_attr=self.attr_holder.bias_attr, use_cudnn=use_cudnn, act=act)
def maskiou_net(x, num_class): x = P.conv2d(x, 8, filter_size=(3, 3), stride=2, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="maskiou_net.0.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="maskiou_net.0.bias")) x = P.relu(x) x = P.conv2d(x, 16, filter_size=(3, 3), stride=2, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="maskiou_net.2.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="maskiou_net.2.bias")) x = P.relu(x) x = P.conv2d(x, 32, filter_size=(3, 3), stride=2, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="maskiou_net.4.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="maskiou_net.4.bias")) x = P.relu(x) x = P.conv2d(x, 64, filter_size=(3, 3), stride=2, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="maskiou_net.6.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="maskiou_net.6.bias")) x = P.relu(x) x = P.conv2d(x, 128, filter_size=(3, 3), stride=2, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="maskiou_net.8.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="maskiou_net.8.bias")) x = P.relu(x) x = P.conv2d(x, num_class, filter_size=(1, 1), stride=1, padding=0, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="maskiou_net.10.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="maskiou_net.10.bias")) x = P.relu(x) return x
def func(self, place): shape = [2, 3, 3, 3] eps = 0.005 dtype = np.float64 x = layers.data('x', shape, False, dtype) y = layers.conv2d(x, 2, 1, padding=1, bias_attr=False) x_arr = np.random.uniform(-1, 1, shape).astype(dtype) w = fluid.default_main_program().global_block().all_parameters() w_arr = [] for p in w: w_arr.append(np.random.uniform(-1, 1, p.shape).astype(dtype)) gradient_checker.double_grad_check( [x] + w, y, x_init=[x_arr] + w_arr, place=place, eps=eps)
def spatio_conv_layer(self, x, Ks, c_in, c_out, name): """Spatio convolution layer""" _, T, n, _ = x.shape if c_in > c_out: x_input = fl.conv2d(input=x, num_filters=c_out, filter_size=[1, 1], stride=[1, 1], padding="SAME", data_format="NHWC", param_attr=fluid.ParamAttr(name="%s_conv2d_1" % name)) elif c_in < c_out: # if the size of input channel is less than the output, # padding x to the same size of output channel. pad = fl.fill_constant_batch_size_like( input=x, shape=[-1, T, n, c_out - c_in], dtype="float32", value=0.0) x_input = fl.concat([x, pad], axis=3) else: x_input = x for i in range(Ks): # x_input shape: [B,T, num_nodes, c_out] x_input = fl.reshape(x_input, [-1, c_out]) x_input = self.message_passing(self.gw, x_input, name="%s_mp_%d" % (name, i), norm=self.gw.node_feat["norm"]) x_input = fl.fc(x_input, size=c_out, bias_attr=False, param_attr=fluid.ParamAttr(name="%s_gcn_fc_%d" % (name, i))) bias = fluid.layers.create_parameter(shape=[c_out], dtype='float32', is_bias=True, name='%s_gcn_bias_%d' % (name, i)) x_input = fluid.layers.elementwise_add(x_input, bias, act="relu") x_input = fl.reshape(x_input, [-1, T, n, c_out]) return x_input
def FPN(s8, s16, s32): # y1 y1 = P.conv2d(s32, 256, filter_size=(1, 1), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.lat_layers.0.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.lat_layers.0.bias")) # y2 h_m, w_m = P.shape(s16)[2], P.shape(s16)[3] x = P.image_resize(y1, out_shape=[h_m, w_m], resample="BILINEAR") y2 = P.conv2d(s16, 256, filter_size=(1, 1), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.lat_layers.1.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.lat_layers.1.bias")) y2 = P.elementwise_add(x, y2, act=None) # y3 h_s, w_s = P.shape(s8)[2], P.shape(s8)[3] x = P.image_resize(y2, out_shape=[h_s, w_s], resample="BILINEAR") y3 = P.conv2d(s8, 256, filter_size=(1, 1), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.lat_layers.2.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.lat_layers.2.bias")) y3 = P.elementwise_add(x, y3, act=None) # pred y1 = P.conv2d(y1, 256, filter_size=(3, 3), padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.pred_layers.0.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.pred_layers.0.bias")) y1 = P.relu(y1) y2 = P.conv2d(y2, 256, filter_size=(3, 3), padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.pred_layers.1.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.pred_layers.1.bias")) y2 = P.relu(y2) y3 = P.conv2d(y3, 256, filter_size=(3, 3), padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.pred_layers.2.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.pred_layers.2.bias")) y3 = P.relu(y3) # 再对y1下采样2次 s64 = P.conv2d(y1, 256, filter_size=(3, 3), stride=2, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.downsample_layers.0.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.downsample_layers.0.bias")) s128 = P.conv2d(s64, 256, filter_size=(3, 3), stride=2, padding=1, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="fpn.downsample_layers.1.weight"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="fpn.downsample_layers.1.bias")) return y3, y2, y1, s64, s128
def test_nvprof(self): if not fluid.core.is_compiled_with_cuda(): return epoc = 8 dshape = [4, 3, 28, 28] data = layers.data(name='data', shape=[3, 28, 28], dtype='float32') conv = layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1]) place = fluid.CUDAPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) output_file = 'cuda_profiler.txt' with profiler.cuda_profiler(output_file, 'csv') as nvprof: for i in range(epoc): input = np.random.random(dshape).astype('float32') exe.run(fluid.default_main_program(), feed={'data': input}) os.remove(output_file)
def test_nvprof(self): if not fluid.core.is_compiled_with_cuda(): return epoc = 8 dshape = [4, 3, 28, 28] data = layers.data(name='data', shape=[3, 28, 28], dtype='float32') conv = layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1]) place = fluid.CUDAPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) output_file = 'cuda_profiler.txt' with profiler.cuda_profiler(output_file, 'csv') as nvprof: for i in range(epoc): input = np.random.random(dshape).astype('float32') exe.run(fluid.default_main_program(), feed={'data': input}) os.remove(output_file)
def conv_layer(self, input, num_filters, filter_size, stride, padding, name=None): """Create conv layer""" conv = FL.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=1, act=None, param_attr=ParamAttr(name=name + "_weights"), bias_attr=False, name=name + '.conv2d.output.1') return conv
def fully_con_layer(self, x, n, channel, name): """Fully connected layer""" bt_init = fluid.initializer.ConstantInitializer(value=0.0) bt = fl.create_parameter( shape=[n, 1], dtype="float32", attr=fluid.ParamAttr(name="%s_bt" % name, trainable=True, initializer=bt_init), ) x_conv = fl.conv2d(input=x, num_filters=1, filter_size=[1, 1], stride=[1, 1], padding="SAME", data_format="NHWC", param_attr=fluid.ParamAttr(name="%s_conv2d" % name)) x_conv = x_conv + bt return x_conv
def net(self, inputs=None): if self.inputs is None: self.inputs = inputs or fluid.layers.data( name=self.name + "_z", shape=[self.z_dim], dtype='float32') act = 'relu' x = fc(self.inputs, 1024 * 4 * 4, act=act, name=self.name + "_fc_1") x = reshape(x, [-1, 1024, 4, 4], name=self.name + "_reshape") x = up_sampling_2(x, 512, name=self.name + "_512×8×8") x = up_sampling_2(x, 256, name=self.name + "_256×16×16") x = up_sampling_2(x, 128, name=self.name + "_128×32×32") x = up_sampling_2(x, 64, name=self.name + "_64×64×64") x = up_sampling_2(x, 32, name=self.name + "_32×128×128") out = conv2d(x, 3, 3, padding=1, act='tanh', name=self.name + "_conv2d_out") return out
def CNNCharEmbedding(input, vocab_size, cnn_dim, n_kernals, hidden_dim, dropout_rate, output_dropout, embed_dim): """ CNN generates character embedding. Structed as: - embed(x) len_word X hidden_dim - Dropout(x) - CNN(x) len_word X hidden_dim - activation(x) - pool hidden_dim - fc embed_dim - Dropout. Return: embedded Tensor shaped like [bsz, len_seq, embed_dim] """ # input.size [batch_size, len_sentence, len_word] bsz, len_seq, len_word = input.shape emb = fluid.embedding(input, size=[vocab_size, hidden_dim]) # emb.size [batch_size, len_sentence, len_word, hidden_dim] emb = layers.dropout(x=emb, dropout_prob=dropout_rate) emb = layers.reshape(x=emb, shape=(bsz * len_seq, 1, len_word, hidden_dim)) # emb.size [batch_size X len_sentence, 1, len_word, hidden_dim] emb = layers.conv2d(input=emb, num_filters=n_kernals, filter_size=(cnn_dim, hidden_dim), padding=(cnn_dim - 1, 0), act='relu') # emb.size [bsz X len_seq, n_kernals, len_word, 1] emb = layers.transpose(x=emb, perm=[0, 3, 2, 1]) # emb.size [bsz X len_seq, 1, len_word, n_kernals] emb = layers.pool2d(input=emb, pool_size=[len_word, 1], pool_type='max') # emb.size [bsz X len_seq, 1, 1, n_kernals] emb = layers.fc(input=emb, size=embed_dim, num_flatten_dims=-1, act='tanh') # emb.size [bsz X len_seq, 1, 1, embed_dim] emb = layers.reshape(x=emb, shape=(bsz, len_seq, embed_dim)) emb = layers.dropout(x=emb, dropout_prob=output_dropout) return emb
def net(self, inputs=None): if self.inputs is None: self.inputs = inputs or fluid.layers.data( name=self.name + "_image", shape=self.image_size, dtype='float32') x = conv2d(self.inputs, 32, 3, stride=2, padding=1, act='leaky_relu', name=self.name + "_conv2d_1") x = dropout(x, 0.25) x = down_sampling_2(x, 64, name=self.name + "_64×32*32") x = down_sampling_2(x, 128, name=self.name + "_128×16*16") x = down_sampling_2(x, 256, name=self.name + "_256×8*8") x = flatten(x, name=self.name + "_fc") x = fc(x, 1, act="sigmoid") return x
def conv_bn_layer(self, input, num_filters, filter_size, stride=1, groups=1, act=None, name=None): conv = layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=groups, act=None, param_attr=ParamAttr(name=name + "_weights"), bias_attr=False) bn_name = "bn_" + name return layers.batch_norm(input=conv, act=act, 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')
def net(self, inputs): print(inputs.shape) x = conv2d(inputs, 64, 3, padding=1, act='relu') x = conv2d(x, 64, 3, padding=1, act='relu') x = pool2d(x, 2, pool_stride=2) print(x.shape) x = conv2d(x, 128, 3, padding=1, act='relu') x = conv2d(x, 128, 3, padding=1, act='relu') x = pool2d(x, 2, pool_stride=2) print(x.shape) x = conv2d(x, 256, 3, padding=1, act='relu') x = conv2d(x, 256, 3, padding=1, act='relu') x = conv2d(x, 256, 3, padding=1, act='relu') x = pool2d(x, 2, pool_stride=2) print(x.shape) x = conv2d(x, 512, 3, padding=1, act='relu') x = conv2d(x, 512, 3, padding=1, act='relu') x = conv2d(x, 512, 3, padding=1, act='relu') x = pool2d(x, 2, pool_stride=2) print(x.shape) x = conv2d(x, 512, 3, padding=1, act='relu') x = conv2d(x, 512, 3, padding=1, act='relu') x = conv2d(x, 512, 3, padding=1, act='relu') x = pool2d(x, 2, pool_stride=2) print(x.shape) x = flatten(x) x = fc(x, 4096, act='relu') x = fc(x, 4096, act='relu') out = fc(x, self.class_num) print(out.shape) return out
def up_sampling_2(x, num_filters, name, act='relu'): x = pixel_shuffle(x, 2) x = conv2d(x, num_filters, 3, padding=1, name=name + "_conv2d_1") x = batch_norm(x, act=act, name=name + "_bn") return x
def YOLOv3(inputs, initial_filters, num_classes, is_test, trainable=True): i32 = initial_filters i64 = i32 * 2 i128 = i32 * 4 i256 = i32 * 8 i512 = i32 * 16 i1024 = i32 * 32 ''' darknet53部分,所有卷积层都没有偏移bias_attr=False ''' x = conv2d_unit(inputs, i32, (3, 3), stride=1, padding=1, name='conv01', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i64, (3, 3), stride=2, padding=1, name='conv02', is_test=is_test, trainable=trainable) x = stack_residual_block(x, i32, n=1, conv_start_idx=3, is_test=is_test, trainable=trainable) x = conv2d_unit(x, i128, (3, 3), stride=2, padding=1, name='conv05', is_test=is_test, trainable=trainable) x = stack_residual_block(x, i64, n=2, conv_start_idx=6, is_test=is_test, trainable=trainable) x = conv2d_unit(x, i256, (3, 3), stride=2, padding=1, name='conv10', is_test=is_test, trainable=trainable) act11 = stack_residual_block(x, i128, n=8, conv_start_idx=11, is_test=is_test, trainable=trainable) x = conv2d_unit(act11, i512, (3, 3), stride=2, padding=1, name='conv27', is_test=is_test, trainable=trainable) act19 = stack_residual_block(x, i256, n=8, conv_start_idx=28, is_test=is_test, trainable=trainable) x = conv2d_unit(act19, i1024, (3, 3), stride=2, padding=1, name='conv44', is_test=is_test, trainable=trainable) act23 = stack_residual_block(x, i512, n=4, conv_start_idx=45, is_test=is_test, trainable=trainable) ''' darknet53部分结束,余下部分不再有残差块stack_residual_block() ''' x = conv2d_unit(act23, i512, (1, 1), stride=1, padding=0, name='conv53', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i1024, (3, 3), stride=1, padding=1, name='conv54', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i512, (1, 1), stride=1, padding=0, name='conv55', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i1024, (3, 3), stride=1, padding=1, name='conv56', is_test=is_test, trainable=trainable) lkrelu57 = conv2d_unit(x, i512, (1, 1), stride=1, padding=0, name='conv57', is_test=is_test, trainable=trainable) x = conv2d_unit(lkrelu57, i1024, (3, 3), stride=1, padding=1, name='conv58', is_test=is_test, trainable=trainable) y1 = P.conv2d( x, 3 * (num_classes + 5), filter_size=(1, 1), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="conv59.conv.weights"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="conv59.conv.bias")) x = conv2d_unit(lkrelu57, i256, (1, 1), stride=1, padding=0, name='conv60', is_test=is_test, trainable=trainable) x = P.resize_nearest(x, scale=float(2)) x = P.concat([x, act19], axis=1) x = conv2d_unit(x, i256, (1, 1), stride=1, padding=0, name='conv61', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i512, (3, 3), stride=1, padding=1, name='conv62', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i256, (1, 1), stride=1, padding=0, name='conv63', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i512, (3, 3), stride=1, padding=1, name='conv64', is_test=is_test, trainable=trainable) lkrelu64 = conv2d_unit(x, i256, (1, 1), stride=1, padding=0, name='conv65', is_test=is_test, trainable=trainable) x = conv2d_unit(lkrelu64, i512, (3, 3), stride=1, padding=1, name='conv66', is_test=is_test, trainable=trainable) y2 = P.conv2d( x, 3 * (num_classes + 5), filter_size=(1, 1), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="conv67.conv.weights"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="conv67.conv.bias")) x = conv2d_unit(lkrelu64, i128, (1, 1), stride=1, padding=0, name='conv68', is_test=is_test, trainable=trainable) x = P.resize_nearest(x, scale=float(2)) x = P.concat([x, act11], axis=1) x = conv2d_unit(x, i128, (1, 1), stride=1, padding=0, name='conv69', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i256, (3, 3), stride=1, padding=1, name='conv70', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i128, (1, 1), stride=1, padding=0, name='conv71', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i256, (3, 3), stride=1, padding=1, name='conv72', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i128, (1, 1), stride=1, padding=0, name='conv73', is_test=is_test, trainable=trainable) x = conv2d_unit(x, i256, (3, 3), stride=1, padding=1, name='conv74', is_test=is_test, trainable=trainable) y3 = P.conv2d( x, 3 * (num_classes + 5), filter_size=(1, 1), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name="conv75.conv.weights"), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name="conv75.conv.bias")) # 相当于numpy的transpose(),交换下标 y1 = P.transpose(y1, perm=[0, 2, 3, 1]) y2 = P.transpose(y2, perm=[0, 2, 3, 1]) y3 = P.transpose(y3, perm=[0, 2, 3, 1]) return y1, y2, y3
def temporal_conv_layer(self, x, Kt, c_in, c_out, name, act_func='relu'): """Temporal convolution layer""" _, T, n, _ = x.shape if c_in > c_out: x_input = fl.conv2d(input=x, num_filters=c_out, filter_size=[1, 1], stride=[1, 1], padding="SAME", data_format="NHWC", param_attr=fluid.ParamAttr(name="%s_conv2d_1" % name)) elif c_in < c_out: # if the size of input channel is less than the output, # padding x to the same size of output channel. pad = fl.fill_constant_batch_size_like( input=x, shape=[-1, T, n, c_out - c_in], dtype="float32", value=0.0) x_input = fl.concat([x, pad], axis=3) else: x_input = x # x_input = x_input[:, Kt - 1:T, :, :] if act_func == 'GLU': # gated liner unit bt_init = fluid.initializer.ConstantInitializer(value=0.0) bt = fl.create_parameter( shape=[2 * c_out], dtype="float32", attr=fluid.ParamAttr(name="%s_bt" % name, trainable=True, initializer=bt_init), ) x_conv = fl.conv2d(input=x, num_filters=2 * c_out, filter_size=[Kt, 1], stride=[1, 1], padding="SAME", data_format="NHWC", param_attr=fluid.ParamAttr(name="%s_conv2d_wt" % name)) x_conv = x_conv + bt return (x_conv[:, :, :, 0:c_out] + x_input) * fl.sigmoid( x_conv[:, :, :, -c_out:]) else: bt_init = fluid.initializer.ConstantInitializer(value=0.0) bt = fl.create_parameter( shape=[c_out], dtype="float32", attr=fluid.ParamAttr(name="%s_bt" % name, trainable=True, initializer=bt_init), ) x_conv = fl.conv2d(input=x, num_filters=c_out, filter_size=[Kt, 1], stride=[1, 1], padding="SAME", data_format="NHWC", param_attr=fluid.ParamAttr(name="%s_conv2d_wt" % name)) x_conv = x_conv + bt if act_func == "linear": return x_conv elif act_func == "sigmoid": return fl.sigmoid(x_conv) elif act_func == "relu": return fl.relu(x_conv + x_input) else: raise ValueError( f'ERROR: activation function "{act_func}" is not defined.')
def __call__(self, lr): x = image_resize(lr, scale=self.scale) x = conv2d(x, 64, (9, 9), padding=4, act='relu', name='conv1_1') x = conv2d(x, 32, (1, 1), act='relu', name='conv2_1') x = conv2d(x, 3, (5, 5), padding=2, name='conv3_1') return x
# hyper-parameters batch_size = 128 num_classes = 10 epochs = 12 img_rows = 28 img_cols = 28 # define the model X = layers.data(name="img", shape=[-1, 1, 28, 28], dtype="float32") Y = layers.data(name="label", shape=[-1, 1], dtype="int64") h_conv = layers.conv2d(X, num_filters=32, filter_size=(3, 3), act="relu") h_conv = layers.conv2d(h_conv, num_filters=64, filter_size=(3, 3), act="relu") h_pool = layers.pool2d(h_conv, pool_size=(2, 2)) h_dropout = layers.dropout(h_pool, dropout_prob=0.25) h_flatten = layers.flatten(h_dropout) h_fc = layers.fc(h_flatten, size=128, act="relu", bias_attr=fluid.param_attr.ParamAttr(name="b_0")) h_dropout2 = layers.dropout(h_fc, dropout_prob=0.25) pred = layers.fc(h_dropout2, size=num_classes, act="softmax", bias_attr=fluid.param_attr.ParamAttr(name="b_1")) loss = layers.reduce_mean(layers.cross_entropy(input=pred, label=Y))
def down_sampling_2(x, num_filters, name, act='leaky_relu'): x = conv2d(x, num_filters, 3, stride=2, padding=1, name=name + "_conv2d") x = batch_norm(x, act=act, name=name + "_bn") x = dropout(x, 0.25, name=name + "_dropout") return x