def __init__(self, name_scope, cfg, mode='train'): super(suffixnet, self).__init__() self.cfg = cfg self.mode = mode self.mask_out = fluid.dygraph.Conv2DTranspose( num_channels=2048, num_filters=self.cfg.dim_reduced, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name='conv5_mask_b', learning_rate=2., regularizer=L2Decay(0.))) self.mask_fcn_logits = fluid.dygraph.Conv2D( num_channels=self.cfg.dim_reduced, num_filters=self.cfg.class_num, filter_size=1, act='sigmoid' if self.mode != 'train' else None, param_attr=ParamAttr(name='mask_fcn_logits_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name='mask_fcn_logits_b', learning_rate=2., regularizer=L2Decay(0.0)))
def _mask_conv_head(self, roi_feat, num_convs): for i in range(num_convs): layer_name = "mask_inter_feat_" + str(i + 1) fan = self.num_chan_reduced * 3 * 3 roi_feat = fluid.layers.conv2d( input=roi_feat, num_filters=self.num_chan_reduced, filter_size=3, padding=1 * self.dilation, act='relu', stride=1, dilation=self.dilation, name=layer_name, param_attr=ParamAttr(name=layer_name + '_w', initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name=layer_name + '_b', learning_rate=2., regularizer=L2Decay(0.))) fan = roi_feat.shape[1] * 2 * 2 feat = fluid.layers.conv2d_transpose( input=roi_feat, num_filters=self.num_chan_reduced, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w', initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name='conv5_mask_b', learning_rate=2., regularizer=L2Decay(0.))) return feat
def SuffixNet(self, conv5): mask_out = fluid.layers.conv2d_transpose( input=conv5, num_filters=cfg.dim_reduced, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name='conv5_mask_b', learning_rate=2., regularizer=L2Decay(0.))) act_func = None if self.mode != 'train': act_func = 'sigmoid' mask_fcn_logits = fluid.layers.conv2d( input=mask_out, num_filters=cfg.class_num, filter_size=1, act=act_func, param_attr=ParamAttr(name='mask_fcn_logits_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name="mask_fcn_logits_b", learning_rate=2., regularizer=L2Decay(0.))) if self.mode != 'train': mask_fcn_logits = fluid.layers.lod_reset(mask_fcn_logits, self.pred_result) return mask_fcn_logits
def conv_layer(input, num_filters, filter_size, stride=1, groups=1, act=None): conv = fluid.layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=groups, act=act, bias_attr=ParamAttr(initializer=MSRA()), param_attr=ParamAttr(initializer=MSRA())) return conv
def get_output(self, roi_feat, res_feat=None, return_logits=True, return_feat=False, wb_scalar=1.0, name=''): class_num = self.num_classes if res_feat is not None: res_feat = fluid.layers.conv2d(res_feat, roi_feat.shape[1], 1, name='res_net' + name) roi_feat = fluid.layers.sum([roi_feat, res_feat]) # configure the conv number for FPN if necessary head_feat = self._mask_conv_head(roi_feat, self.num_convs, self.norm_type, wb_scalar, name) if return_logits: fan0 = roi_feat.shape[1] * 2 * 2 up_head_feat = fluid.layers.conv2d_transpose( input=head_feat, num_filters=self.conv_dim, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w' + name, initializer=MSRA(uniform=False, fan_in=fan0)), bias_attr=ParamAttr(name='conv5_mask_b' + name, learning_rate=wb_scalar * self.lr_ratio, regularizer=L2Decay(0.))) fan = class_num mask_logits = fluid.layers.conv2d( input=up_head_feat, num_filters=class_num, filter_size=1, act=None, param_attr=ParamAttr(name='mask_fcn_logits_w' + name, initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name="mask_fcn_logits_b" + name, learning_rate=wb_scalar * self.lr_ratio, regularizer=L2Decay(0.))) if return_feat: return mask_logits, head_feat else: return mask_logits if return_feat: return head_feat
def conv_layer(input, num_filters, filter_size, stride=1, groups=1, act=None): conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=groups, act=None, #为了试swish loss暂时换的 bias_attr=ParamAttr(initializer=MSRA()), param_attr=ParamAttr(initializer=MSRA())) # conv = fluid.layers.swish(conv, beta=1.0) conv = fluid.layers.leaky_relu(conv, alpha=0.05) return conv
def _mask_conv_head(self, roi_feat, num_convs, norm_type): if norm_type == 'gn': for i in range(num_convs): layer_name = "mask_inter_feat_" + str(i + 1) fan = self.conv_dim * 3 * 3 initializer = MSRA(uniform=False, fan_in=fan) roi_feat = ConvNorm(roi_feat, self.conv_dim, 3, act='relu', dilation=self.dilation, initializer=initializer, norm_type=self.norm_type, name=layer_name, norm_name=layer_name) else: for i in range(num_convs): layer_name = "mask_inter_feat_" + str(i + 1) fan = self.conv_dim * 3 * 3 initializer = MSRA(uniform=False, fan_in=fan) roi_feat = fluid.layers.conv2d( input=roi_feat, num_filters=self.conv_dim, filter_size=3, padding=1 * self.dilation, act='relu', stride=1, dilation=self.dilation, name=layer_name, param_attr=ParamAttr(name=layer_name + '_w', initializer=initializer), bias_attr=ParamAttr(name=layer_name + '_b', learning_rate=2., regularizer=L2Decay(0.))) fan = roi_feat.shape[1] * 2 * 2 feat = fluid.layers.conv2d_transpose( input=roi_feat, num_filters=self.conv_dim, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w', initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name='conv5_mask_b', learning_rate=2., regularizer=L2Decay(0.))) # print(feat) return feat
def conv_bn_layer(self, input, filter_size, num_filters, stride, padding, channels=None, num_groups=1, use_cudnn=True, if_act=True): conv = fluid.layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, act=None, use_cudnn=use_cudnn, param_attr=ParamAttr(initializer=MSRA()), bias_attr=False) bn = fluid.layers.batch_norm(input=conv) if if_act: return fluid.layers.relu6(bn) else: return bn
def _conv_bn_layer(self, input, filter_size, num_filters, stride=1, padding=1, num_groups=1, if_act=True, name=None): conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=num_groups, act=None, param_attr=ParamAttr(initializer=MSRA(), name=name + '_weights'), bias_attr=False) bn_name = name + '_bn' bn = fluid.layers.batch_norm( input=conv, param_attr=ParamAttr( name=bn_name + "_scale", initializer=fluid.initializer.Constant(1.0)), bias_attr=ParamAttr( name=bn_name + "_offset", initializer=fluid.initializer.Constant(0.0)), moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance') if if_act: bn = fluid.layers.relu(bn) return bn
def conv_bn_layer(self, input, filter_size, num_filters, stride=1, padding=1, num_groups=1, if_act=True, name=None): conv = fluid.layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=num_groups, act=None, param_attr=ParamAttr(initializer=MSRA(), name=name + '_weights'), bias_attr=False) bn_name = name + '_bn' bn = self._bn(input=conv, bn_name=bn_name) if if_act: bn = fluid.layers.relu(bn) return bn
def conv_bn_layer(self, input, filter_size, num_filters, stride, padding, num_groups=1, use_cudnn=True, if_act=True, name=None): conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, act=None, use_cudnn=use_cudnn, param_attr=ParamAttr(initializer=MSRA(),name=name+'_weights'), bias_attr=False) out = int((input.shape[2] - 1)/float(stride) + 1) bn_name = name + '_bn' if if_act: return fluid.layers.batch_norm(input=conv, act='relu', param_attr = ParamAttr(name=bn_name+"_scale"), bias_attr=ParamAttr(name=bn_name+"_offset"), moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance') else: return fluid.layers.batch_norm(input=conv, param_attr = ParamAttr(name=bn_name+"_scale"), bias_attr=ParamAttr(name=bn_name+"_offset"), moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance')
def __init__(self, num_channels, filter_size, num_filters, stride, padding, channels=None, num_groups=1, act='relu', use_cudnn=True, name=None): super(ConvBNLayer, self).__init__() self._conv = Conv2D(num_channels=num_channels, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, act=None, use_cudnn=use_cudnn, param_attr=ParamAttr(initializer=MSRA(), name=self.full_name() + "_weights"), bias_attr=False) self._batch_norm = BatchNorm( num_filters, act=act, param_attr=ParamAttr(name=self.full_name() + "_bn" + "_scale"), bias_attr=ParamAttr(name=self.full_name() + "_bn" + "_offset"), moving_mean_name=self.full_name() + "_bn" + '_mean', moving_variance_name=self.full_name() + "_bn" + '_variance')
def __call__(self, roi_feat, wb_scalar=1.0, name=''): conv = roi_feat fan = self.conv_dim * 3 * 3 initializer = MSRA(uniform=False, fan_in=fan) for i in range(self.num_conv): name = 'bbox_head_conv' + str(i) conv = ConvNorm(conv, self.conv_dim, 3, act='relu', initializer=initializer, norm_type=self.norm_type, freeze_norm=self.freeze_norm, lr_scale=wb_scalar, name=name, norm_name=name) fan = conv.shape[1] * conv.shape[2] * conv.shape[3] head_heat = fluid.layers.fc( input=conv, size=self.mlp_dim, act='relu', name='fc6' + name, param_attr=ParamAttr(name='fc6%s_w' % name, initializer=Xavier(fan_out=fan), learning_rate=wb_scalar), bias_attr=ParamAttr(name='fc6%s_b' % name, regularizer=L2Decay(0.), learning_rate=wb_scalar * 2)) return head_heat
def highResolutionNet(input, num_classes): channels_2 = cfg.MODEL.HRNET.STAGE2.NUM_CHANNELS channels_3 = cfg.MODEL.HRNET.STAGE3.NUM_CHANNELS channels_4 = cfg.MODEL.HRNET.STAGE4.NUM_CHANNELS num_modules_2 = cfg.MODEL.HRNET.STAGE2.NUM_MODULES num_modules_3 = cfg.MODEL.HRNET.STAGE3.NUM_MODULES num_modules_4 = cfg.MODEL.HRNET.STAGE4.NUM_MODULES x = conv_bn_layer(input=input, filter_size=3, num_filters=64, stride=2, if_act=True, name='layer1_1') x = conv_bn_layer(input=x, filter_size=3, num_filters=64, stride=2, if_act=True, name='layer1_2') la1 = layer1(x, name='layer2') tr1 = transition_layer([la1], [256], channels_2, name='tr1') st2 = stage(tr1, num_modules_2, channels_2, name='st2') tr2 = transition_layer(st2, channels_2, channels_3, name='tr2') st3 = stage(tr2, num_modules_3, channels_3, name='st3') tr3 = transition_layer(st3, channels_3, channels_4, name='tr3') st4 = stage(tr3, num_modules_4, channels_4, name='st4') # upsample shape = st4[0].shape height, width = shape[-2], shape[-1] st4[1] = fluid.layers.resize_bilinear(st4[1], out_shape=[height, width]) st4[2] = fluid.layers.resize_bilinear(st4[2], out_shape=[height, width]) st4[3] = fluid.layers.resize_bilinear(st4[3], out_shape=[height, width]) out = fluid.layers.concat(st4, axis=1) last_channels = sum(channels_4) out = conv_bn_layer(input=out, filter_size=1, num_filters=last_channels, stride=1, if_act=True, name='conv-2') out = fluid.layers.conv2d(input=out, num_filters=num_classes, filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr(initializer=MSRA(), name='conv-1_weights'), bias_attr=False) out = fluid.layers.resize_bilinear(out, input.shape[2:]) return out
def conv_bn_layer(self, x, num_filters, filters_size, stride=1, groups=1, act=None, name=None): x = fluid.layers.conv2d(input=x, num_filters=num_filters, filter_size=filters_size, stride=stride, padding=(filters_size - 1) // 2, groups=groups, act=None, param_attr=ParamAttr(initializer=MSRA(), name=name + "_weight"), bias_attr=False) x = fluid.layers.batch_norm( input=x, act=act, param_attr=ParamAttr(name=name + "_scale", regularizer=L2DecayRegularizer( regularization_coeff=self.bn_decay)), bias_attr=ParamAttr(name=name + "_offset", regularizer=L2DecayRegularizer( regularization_coeff=self.bn_decay)), moving_mean_name=name + "_mean", moving_variance_name=name + "_variance") return x
def conv_bn_layer(self, input, filter_size, num_filters, stride, padding, channels=None, num_groups=1, act='relu', use_cudnn=True, name=None): conv = fluid.layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, act=None, use_cudnn=use_cudnn, param_attr=ParamAttr(initializer=MSRA(), name=name + "_weights"), bias_attr=False) bn_name = name + "_bn" return fluid.layers.batch_norm( input=conv, act=act, param_attr=ParamAttr(name=bn_name + "_scale"), bias_attr=ParamAttr(name=bn_name + "_offset"), moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance')
def build_net(self, inputs): if self.use_dice_loss or self.use_bce_loss: self.num_classes = 1 image = inputs['image'] st4 = self.backbone(image) # upsample shape = fluid.layers.shape(st4[0])[-2:] st4[1] = fluid.layers.resize_bilinear(st4[1], out_shape=shape) st4[2] = fluid.layers.resize_bilinear(st4[2], out_shape=shape) st4[3] = fluid.layers.resize_bilinear(st4[3], out_shape=shape) out = fluid.layers.concat(st4, axis=1) last_channels = sum(self.backbone.channels[str( self.backbone.width)][-1]) out = self._conv_bn_layer(input=out, filter_size=1, num_filters=last_channels, stride=1, if_act=True, name='conv-2') out = fluid.layers.conv2d(input=out, num_filters=self.num_classes, filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr(initializer=MSRA(), name='conv-1_weights'), bias_attr=False) input_shape = fluid.layers.shape(image)[-2:] logit = fluid.layers.resize_bilinear(out, input_shape) if self.num_classes == 1: out = sigmoid_to_softmax(logit) out = fluid.layers.transpose(out, [0, 2, 3, 1]) else: out = fluid.layers.transpose(logit, [0, 2, 3, 1]) pred = fluid.layers.argmax(out, axis=3) pred = fluid.layers.unsqueeze(pred, axes=[3]) if self.mode == 'train': label = inputs['label'] mask = label != self.ignore_index return self._get_loss(logit, label, mask) elif self.mode == 'eval': label = inputs['label'] mask = label != self.ignore_index loss = self._get_loss(logit, label, mask) return loss, pred, label, mask else: if self.num_classes == 1: logit = sigmoid_to_softmax(logit) else: logit = fluid.layers.softmax(logit, axis=1) return pred, logit
def _mask_conv_head(self, roi_feat, num_convs, norm_type, wb_scalar=1.0, name=''): if norm_type == 'gn': for i in range(num_convs): layer_name = "mask_inter_feat_" + str(i + 1) if not self.share_mask_conv: layer_name += name fan = self.conv_dim * 3 * 3 initializer = MSRA(uniform=False, fan_in=fan) roi_feat = ConvNorm(roi_feat, self.conv_dim, 3, act='relu', dilation=self.dilation, initializer=initializer, norm_type=self.norm_type, name=layer_name, norm_name=layer_name) else: for i in range(num_convs): layer_name = "mask_inter_feat_" + str(i + 1) if not self.share_mask_conv: layer_name += name fan = self.conv_dim * 3 * 3 initializer = MSRA(uniform=False, fan_in=fan) roi_feat = fluid.layers.conv2d( input=roi_feat, num_filters=self.conv_dim, filter_size=3, padding=1 * self.dilation, act='relu', stride=1, dilation=self.dilation, name=layer_name, param_attr=ParamAttr(name=layer_name + '_w', initializer=initializer), bias_attr=ParamAttr(name=layer_name + '_b', learning_rate=wb_scalar * self.lr_ratio, regularizer=L2Decay(0.))) return roi_feat
def conv_bn(self, input, filter_size, num_filters, stride, padding, num_groups=1, act='relu', use_cudnn=True): parameter_attr = ParamAttr(learning_rate=0.1, initializer=MSRA()) conv = fluid.layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, use_cudnn=use_cudnn, param_attr=parameter_attr, bias_attr=False) return fluid.layers.batch_norm(input=conv, act=act)
def net(self, input, class_dim=1000, scale=1.0): 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), ] input = self.conv_bn_layer( input, num_filters=int(32 * scale), filter_size=3, stride=2, padding=1, if_act=True) in_c = int(32 * scale) for layer_setting in bottleneck_params_list: t, c, n, s = layer_setting input = self.invresi_blocks( input=input, in_c=in_c, t=t, c=int(c * scale), n=n, s=s, ) in_c = int(c * scale) input = self.conv_bn_layer( input=input, num_filters=int(1280 * scale) if scale > 1.0 else 1280, filter_size=1, stride=1, padding=0, if_act=True) input = fluid.layers.pool2d( input=input, pool_size=7, pool_stride=1, pool_type='avg', global_pooling=True) output = fluid.layers.fc(input=input, size=class_dim, act='softmax', param_attr=ParamAttr(initializer=MSRA())) return output
def conv_bn_layer(input, num_filters, filter_size, stride=1, groups=1, act=None, bn=True, bias_attr=False): conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=groups, act=None, bias_attr=bias_attr, param_attr=ParamAttr(initializer=MSRA())) if bn == True: conv = fluid.layers.batch_norm(input=conv, act=act) return conv
def base_layer(ipt, name: str, filter_num: int, filter_size: int = 3, act=None, size_cut: bool = False, same_padding: bool = True, depthwise_sc: bool = True): """ 基础卷积+BN处理函数 :param ipt: 输入张量数据 :param name: 该层命名 :param filter_num: 卷积核数量 :param filter_size: 卷积核尺寸 :param groups: 卷积分组数 :param act: 卷积层激活函数 :param size_cut: 是否剪裁尺寸 :param same_padding: 是否保持输入输出尺寸 :param depthwise_sc: 是否深度可分离卷积,若为是则忽略卷积核数量这个参数 :return: 处理后张量 """ parameter_attr = ParamAttr(learning_rate=0.01, initializer=MSRA()) stride = filter_size - 1 if size_cut else 1 padding = (filter_size - 1) // 2 if same_padding else 0 tmp = fluid.layers.conv2d( input=ipt, num_filters=ipt.shape[-3] if depthwise_sc else filter_num, filter_size=filter_size, stride=stride, padding=padding, bias_attr=False, name="base_conv_" + name, param_attr=parameter_attr) if depthwise_sc: tmp = fluid.layers.conv2d( input=tmp, num_filters=filter_num, filter_size=1, stride=1, padding=0, bias_attr=False, name="base_conv_dpsc_" + name, param_attr=parameter_attr) tmp = fluid.layers.batch_norm( input=tmp, act=act, name="base_bn_" + name) return tmp
def net(self, input, class_dim=1000): scale = self.scale stage_repeats = [4, 8, 4] if scale == 0.25: stage_out_channels = [-1, 24, 24, 48, 96, 512] elif scale == 0.33: stage_out_channels = [-1, 24, 32, 64, 128, 512] elif scale == 0.5: stage_out_channels = [-1, 24, 48, 96, 192, 1024] elif scale == 1.0: stage_out_channels = [-1, 24, 116, 232, 464, 1024] elif scale == 1.5: stage_out_channels = [-1, 24, 176, 352, 704, 1024] elif scale == 2.0: stage_out_channels = [-1, 24, 224, 488, 976, 2048] else: raise ValueError( """{} groups is not supported for 1x1 Grouped Convolutions""".format(num_groups)) #conv1 input_channel = stage_out_channels[1] conv1 = self.conv_bn_layer(input=input, filter_size=3, num_filters=input_channel, padding=1, stride=2,name='stage1_conv') pool1 = fluid.layers.pool2d(input=conv1, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') conv = pool1 # bottleneck sequences for idxstage in range(len(stage_repeats)): numrepeat = stage_repeats[idxstage] output_channel = stage_out_channels[idxstage+2] for i in range(numrepeat): if i == 0: conv = self.inverted_residual_unit(input=conv, num_filters=output_channel, stride=2, benchmodel=2,name=str(idxstage+2)+'_'+str(i+1)) else: conv = self.inverted_residual_unit(input=conv, num_filters=output_channel, stride=1, benchmodel=1,name=str(idxstage+2)+'_'+str(i+1)) conv_last = self.conv_bn_layer(input=conv, filter_size=1, num_filters=stage_out_channels[-1], padding=0, stride=1, name='conv5') pool_last = fluid.layers.pool2d(input=conv_last, pool_size=7, pool_stride=1, pool_padding=0, pool_type='avg') output = fluid.layers.fc(input=pool_last, size=class_dim, param_attr=ParamAttr(initializer=MSRA(),name='fc6_weights'), bias_attr=ParamAttr(name='fc6_offset')) return output
def _get_output(self, roi_feat): class_num = self.num_classes # configure the conv number for FPN if necessary head_feat = self._mask_conv_head(roi_feat, self.num_convs) fan = class_num mask_logits = fluid.layers.conv2d( input=head_feat, num_filters=class_num, filter_size=1, act=None, param_attr=ParamAttr(name='mask_fcn_logits_w', initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name="mask_fcn_logits_b", learning_rate=2., regularizer=L2Decay(0.))) return mask_logits
def conv_bn_layer(self, input, filter_size, num_filters, stride, padding, num_groups=1, if_act=True, name=None, use_cudnn=True): conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, act=None, use_cudnn=use_cudnn, param_attr=ParamAttr( name=name + '_weights', initializer=MSRA()), bias_attr=False) bn_name = name + '_bn' bn = fluid.layers.batch_norm( input=conv, param_attr=ParamAttr(name=bn_name + "_scale"), bias_attr=ParamAttr(name=bn_name + "_offset"), moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance') if if_act: return fluid.layers.prelu( bn, mode='channel', param_attr=ParamAttr( name=name + '_prelu', regularizer=fluid.regularizer.L2Decay(0.0))) else: return bn
def _high_resolution_net(self, input, num_classes): x = self._conv_bn_layer( input=input, filter_size=3, num_filters=self.stage1_num_channels[0], stride=2, if_act=True, name='layer1_1') x = self._conv_bn_layer( input=x, filter_size=3, num_filters=self.stage1_num_channels[0], stride=2, if_act=True, name='layer1_2') la1 = self._layer1( x, self.stage1_num_modules, self.stage1_num_blocks, self.stage1_num_channels, name='layer2') tr1 = self._transition_layer([la1], self.stage1_num_channels, self.stage2_num_channels, name='tr1') st2 = self._stage( tr1, self.stage2_num_modules, self.stage2_num_blocks, self.stage2_num_channels, name='st2') tr2 = self._transition_layer( st2, self.stage2_num_channels, self.stage3_num_channels, name='tr2') st3 = self._stage( tr2, self.stage3_num_modules, self.stage3_num_blocks, self.stage3_num_channels, name='st3') tr3 = self._transition_layer( st3, self.stage3_num_channels, self.stage4_num_channels, name='tr3') st4 = self._stage( tr3, self.stage4_num_modules, self.stage4_num_blocks, self.stage4_num_channels, name='st4') # upsample shape = fluid.layers.shape(st4[0])[-2:] st4[1] = fluid.layers.resize_bilinear(st4[1], out_shape=shape) st4[2] = fluid.layers.resize_bilinear(st4[2], out_shape=shape) st4[3] = fluid.layers.resize_bilinear(st4[3], out_shape=shape) out = fluid.layers.concat(st4, axis=1) last_channels = sum(self.stage4_num_channels) out = self._conv_bn_layer( input=out, filter_size=1, num_filters=last_channels, stride=1, if_act=True, name='conv-2') out = fluid.layers.conv2d( input=out, num_filters=num_classes, filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr(initializer=MSRA(), name='conv-1_weights'), bias_attr=False) input_shape = fluid.layers.shape(input)[-2:] out = fluid.layers.resize_bilinear(out, input_shape) return out
def __call__(self, input): scale = self.scale stage_repeats = [4, 8, 4] if scale == 0.25: stage_out_channels = [-1, 24, 24, 48, 96, 512] elif scale == 0.33: stage_out_channels = [-1, 24, 32, 64, 128, 512] elif scale == 0.5: stage_out_channels = [-1, 24, 48, 96, 192, 1024] elif scale == 1.0: stage_out_channels = [-1, 24, 116, 232, 464, 1024] elif scale == 1.5: stage_out_channels = [-1, 24, 176, 352, 704, 1024] elif scale == 2.0: stage_out_channels = [-1, 24, 224, 488, 976, 2048] else: raise NotImplementedError("This scale size:[" + str(scale) + "] is not implemented!") #conv1 input_channel = stage_out_channels[1] conv1 = self.conv_bn_layer(input=input, filter_size=3, num_filters=input_channel, padding=1, stride=2, name='stage1_conv') pool1 = fluid.layers.pool2d(input=conv1, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') conv = pool1 # bottleneck sequences for idxstage in range(len(stage_repeats)): numrepeat = stage_repeats[idxstage] output_channel = stage_out_channels[idxstage + 2] for i in range(numrepeat): if i == 0: conv = self.inverted_residual_unit( input=conv, num_filters=output_channel, stride=2, benchmodel=2, name=str(idxstage + 2) + '_' + str(i + 1)) else: conv = self.inverted_residual_unit( input=conv, num_filters=output_channel, stride=1, benchmodel=1, name=str(idxstage + 2) + '_' + str(i + 1)) output = self.conv_bn_layer(input=conv, filter_size=1, num_filters=stage_out_channels[-1], padding=0, stride=1, name='conv5') if self.num_classes is not None: output = fluid.layers.pool2d(input=output, pool_size=7, pool_stride=1, pool_padding=0, pool_type='avg') output = fluid.layers.fc(input=output, size=self.num_classes, param_attr=ParamAttr(initializer=MSRA(), name='fc6_weights'), bias_attr=ParamAttr(name='fc6_offset')) return output
def net(self, input, class_dim=1000, scale=1.0): # conv1: 112x112 input = self.conv_bn_layer(input, filter_size=3, channels=3, num_filters=int(32 * scale), stride=2, padding=1, name="conv1") # 56x56 input = self.depthwise_separable(input, num_filters1=32, num_filters2=64, num_groups=32, stride=1, scale=scale, name="conv2_1") input = self.depthwise_separable(input, num_filters1=64, num_filters2=128, num_groups=64, stride=2, scale=scale, name="conv2_2") # 28x28 input = self.depthwise_separable(input, num_filters1=128, num_filters2=128, num_groups=128, stride=1, scale=scale, name="conv3_1") input = self.depthwise_separable(input, num_filters1=128, num_filters2=256, num_groups=128, stride=2, scale=scale, name="conv3_2") # 14x14 input = self.depthwise_separable(input, num_filters1=256, num_filters2=256, num_groups=256, stride=1, scale=scale, name="conv4_1") input = self.depthwise_separable(input, num_filters1=256, num_filters2=512, num_groups=256, stride=2, scale=scale, name="conv4_2") # 14x14 for i in range(5): input = self.depthwise_separable(input, num_filters1=512, num_filters2=512, num_groups=512, stride=1, scale=scale, name="conv5" + "_" + str(i + 1)) # 7x7 input = self.depthwise_separable(input, num_filters1=512, num_filters2=1024, num_groups=512, stride=2, scale=scale, name="conv5_6") input = self.depthwise_separable(input, num_filters1=1024, num_filters2=1024, num_groups=1024, stride=1, scale=scale, name="conv6") input = fluid.layers.pool2d(input=input, pool_size=0, pool_stride=1, pool_type='avg', global_pooling=True) output = fluid.layers.fc(input=input, size=class_dim, param_attr=ParamAttr(initializer=MSRA(), name="fc7_weights"), bias_attr=ParamAttr(name="fc7_offset")) return output
def net(self, input, label=None): x = self.conv_bn_layer( input, filter_size=3, num_filters=64, stride=2, padding=1, num_groups=1, if_act=True, name='conv3x3') x = self.conv_bn_layer( x, filter_size=3, num_filters=64, stride=1, padding=1, num_groups=64, if_act=True, name='dw_conv3x3') in_c = 64 cnt = 0 for _exp, out_c, times, _stride in self.Slimfacenet_bottleneck_setting: for i in range(times): stride = _stride if i == 0 else 1 filter_size, exp, se = self.table[self.arch[cnt]] se = False if se == 0 else True x = self.residual_unit( x, num_in_filter=in_c, num_out_filter=out_c, stride=stride, filter_size=filter_size, expansion_factor=exp, use_se=se, name='residual_unit' + str(cnt + 1)) cnt += 1 in_c = out_c out_c = 512 x = self.conv_bn_layer( x, filter_size=1, num_filters=out_c, stride=1, padding=0, num_groups=1, if_act=True, name='conv1x1') x = self.conv_bn_layer( x, filter_size=(7, 6), num_filters=out_c, stride=1, padding=0, num_groups=out_c, if_act=False, name='global_dw_conv7x7') x = fluid.layers.conv2d( x, num_filters=128, filter_size=1, stride=1, padding=0, groups=1, act=None, use_cudnn=True, param_attr=ParamAttr( name='linear_conv1x1_weights', initializer=MSRA(), regularizer=fluid.regularizer.L2Decay(4e-4)), bias_attr=False) bn_name = 'linear_conv1x1_bn' x = fluid.layers.batch_norm( x, param_attr=ParamAttr(name=bn_name + "_scale"), bias_attr=ParamAttr(name=bn_name + "_offset"), moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance') x = fluid.layers.reshape(x, shape=[x.shape[0], x.shape[1]]) if self.extract_feature: return x out = self.arc_margin_product( x, label, self.class_dim, s=32.0, m=0.50, mode=2) softmax = fluid.layers.softmax(input=out) cost = fluid.layers.cross_entropy(input=softmax, label=label) loss = fluid.layers.mean(x=cost) acc = fluid.layers.accuracy(input=out, label=label, k=1) return loss, acc
def __init__(self, n_layer, hidden_size=768, name="encoder", search_layer=True, use_fixed_gumbel=False, gumbel_alphas=None): super(EncoderLayer, self).__init__() self._n_layer = n_layer self._hidden_size = hidden_size self._n_channel = 256 self._steps = 3 self._n_ops = len(ConvBN_PRIMITIVES) self.use_fixed_gumbel = use_fixed_gumbel self.stem = fluid.dygraph.Sequential( Conv2D(num_channels=1, num_filters=self._n_channel, filter_size=[3, self._hidden_size], padding=[1, 0], param_attr=fluid.ParamAttr(initializer=MSRA()), bias_attr=False), BatchNorm(num_channels=self._n_channel, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(value=1)), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(value=0)))) cells = [] for i in range(n_layer): cell = Cell(steps=self._steps, n_channel=self._n_channel, name="%s/layer_%d" % (name, i)) cells.append(cell) self._cells = fluid.dygraph.LayerList(cells) k = sum(1 for i in range(self._steps) for n in range(2 + i)) num_ops = self._n_ops self.alphas = fluid.layers.create_parameter( shape=[k, num_ops], dtype="float32", default_initializer=NormalInitializer(loc=0.0, scale=1e-3)) # self.k = fluid.layers.create_parameter( # shape=[1, self._n_layer], # dtype="float32", # default_initializer=NormalInitializer( # loc=0.0, scale=1e-3)) self.pool2d_avg = Pool2D(pool_type='avg', global_pooling=True) self.bns = [] self.outs = [] for i in range(self._n_layer): bn = BatchNorm(num_channels=self._n_channel, param_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(value=1), trainable=False), bias_attr=fluid.ParamAttr( initializer=fluid.initializer.Constant(value=0), trainable=False)) self.bns.append(bn) out = Linear(self._n_channel, 3, param_attr=ParamAttr(initializer=MSRA()), bias_attr=ParamAttr(initializer=MSRA())) self.outs.append(out) self.use_fixed_gumbel = use_fixed_gumbel self.gumbel_alphas = gumbel_softmax(self.alphas) if gumbel_alphas is not None: self.gumbel_alphas = np.array(gumbel_alphas).reshape( self.alphas.shape) else: self.gumbel_alphas = gumbel_softmax(self.alphas) self.gumbel_alphas.stop_gradient = True print("gumbel_alphas: {}".format(self.gumbel_alphas))