def __init__(self, input_channels, output_channels, filter_size, stride, padding, stdv, groups=1, act=None, name=None): super(ConvPoolLayer, self).__init__() self.relu = ReLU() if act == "relu" else None self._conv = Conv2D( in_channels=input_channels, out_channels=output_channels, kernel_size=filter_size, stride=stride, padding=padding, groups=groups, weight_attr=ParamAttr( name=name + "_weights", initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr( name=name + "_offset", initializer=Uniform(-stdv, stdv))) self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
def __init__(self, class_num=1000): super(AlexNetDY, self).__init__() stdv = 1.0 / math.sqrt(3 * 11 * 11) self._conv1 = ConvPoolLayer( 3, 64, 11, 4, 2, stdv, act="relu", name="conv1") stdv = 1.0 / math.sqrt(64 * 5 * 5) self._conv2 = ConvPoolLayer( 64, 192, 5, 1, 2, stdv, act="relu", name="conv2") stdv = 1.0 / math.sqrt(192 * 3 * 3) self._conv3 = Conv2D( 192, 384, 3, stride=1, padding=1, weight_attr=ParamAttr( name="conv3_weights", initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr( name="conv3_offset", initializer=Uniform(-stdv, stdv))) stdv = 1.0 / math.sqrt(384 * 3 * 3) self._conv4 = Conv2D( 384, 256, 3, stride=1, padding=1, weight_attr=ParamAttr( name="conv4_weights", initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr( name="conv4_offset", initializer=Uniform(-stdv, stdv))) stdv = 1.0 / math.sqrt(256 * 3 * 3) self._conv5 = ConvPoolLayer( 256, 256, 3, 1, 1, stdv, act="relu", name="conv5") stdv = 1.0 / math.sqrt(256 * 6 * 6) self._drop1 = Dropout(p=0.5, mode="downscale_in_infer") self._fc6 = Linear( in_features=256 * 6 * 6, out_features=4096, weight_attr=ParamAttr( name="fc6_weights", initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr( name="fc6_offset", initializer=Uniform(-stdv, stdv))) self._drop2 = Dropout(p=0.5, mode="downscale_in_infer") self._fc7 = Linear( in_features=4096, out_features=4096, weight_attr=ParamAttr( name="fc7_weights", initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr( name="fc7_offset", initializer=Uniform(-stdv, stdv))) self._fc8 = Linear( in_features=4096, out_features=class_num, weight_attr=ParamAttr( name="fc8_weights", initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr( name="fc8_offset", initializer=Uniform(-stdv, stdv)))
def __init__(self, num_channels, num_filters, reduction_ratio, name=None, data_format="NCHW"): super(SELayer, self).__init__() self.data_format = data_format self.pool2d_gap = AdaptiveAvgPool2D(1, data_format=self.data_format) 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, weight_attr=ParamAttr( initializer=Uniform(-stdv, stdv), name=name + "_sqz_weights"), bias_attr=ParamAttr(name=name + '_sqz_offset')) self.relu = nn.ReLU() stdv = 1.0 / math.sqrt(med_ch * 1.0) self.excitation = Linear( med_ch, num_filters, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv), name=name + "_exc_weights"), bias_attr=ParamAttr(name=name + '_exc_offset')) self.sigmoid = nn.Sigmoid()
def __init__(self, num_classes=1000): super(AlexNet, self).__init__() self.num_classes = num_classes stdv = 1.0 / math.sqrt(3 * 11 * 11) self._conv1 = ConvPoolLayer(3, 64, 11, 4, 2, stdv, act="relu") stdv = 1.0 / math.sqrt(64 * 5 * 5) self._conv2 = ConvPoolLayer(64, 192, 5, 1, 2, stdv, act="relu") stdv = 1.0 / math.sqrt(192 * 3 * 3) self._conv3 = Conv2D( 192, 384, 3, stride=1, padding=1, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) stdv = 1.0 / math.sqrt(384 * 3 * 3) self._conv4 = Conv2D( 384, 256, 3, stride=1, padding=1, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) stdv = 1.0 / math.sqrt(256 * 3 * 3) self._conv5 = ConvPoolLayer(256, 256, 3, 1, 1, stdv, act="relu") if self.num_classes > 0: stdv = 1.0 / math.sqrt(256 * 6 * 6) self._drop1 = Dropout(p=0.5, mode="downscale_in_infer") self._fc6 = Linear( in_features=256 * 6 * 6, out_features=4096, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) self._drop2 = Dropout(p=0.5, mode="downscale_in_infer") self._fc7 = Linear( in_features=4096, out_features=4096, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) self._fc8 = Linear( in_features=4096, out_features=num_classes, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
def __init__(self, class_dim=1000): super(InceptionV4DY, self).__init__() self._inception_stem = InceptionStem() self._inceptionA_1 = InceptionA(name="1") self._inceptionA_2 = InceptionA(name="2") self._inceptionA_3 = InceptionA(name="3") self._inceptionA_4 = InceptionA(name="4") self._reductionA = ReductionA() self._inceptionB_1 = InceptionB(name="1") self._inceptionB_2 = InceptionB(name="2") self._inceptionB_3 = InceptionB(name="3") self._inceptionB_4 = InceptionB(name="4") self._inceptionB_5 = InceptionB(name="5") self._inceptionB_6 = InceptionB(name="6") self._inceptionB_7 = InceptionB(name="7") self._reductionB = ReductionB() self._inceptionC_1 = InceptionC(name="1") self._inceptionC_2 = InceptionC(name="2") self._inceptionC_3 = InceptionC(name="3") self.avg_pool = AdaptiveAvgPool2D(1) self._drop = Dropout(p=0.2, mode="downscale_in_infer") stdv = 1.0 / math.sqrt(1536 * 1.0) self.out = Linear( 1536, class_dim, weight_attr=ParamAttr( initializer=Uniform(-stdv, stdv), name="final_fc_weights"), bias_attr=ParamAttr(name="final_fc_offset"))
def __init__(self, ch_in, ch_out, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=False): super(ConvLayer, self).__init__() bias_attr = False fan_in = ch_in * kernel_size**2 bound = 1 / math.sqrt(fan_in) param_attr = paddle.ParamAttr(initializer=Uniform(-bound, bound)) if bias: bias_attr = paddle.ParamAttr(initializer=Constant(0.)) self.conv = nn.Conv2D(in_channels=ch_in, out_channels=ch_out, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, weight_attr=param_attr, bias_attr=bias_attr)
def __init__(self, depth=50, cardinality=32, num_classes=1000, with_pool=True): super(ResNeXt, self).__init__() self.depth = depth self.cardinality = cardinality self.num_classes = num_classes self.with_pool = with_pool supported_depth = [50, 101, 152] assert depth in supported_depth, \ "supported layers are {} but input layer is {}".format( supported_depth, depth) supported_cardinality = [32, 64] assert cardinality in supported_cardinality, \ "supported cardinality is {} but input cardinality is {}" \ .format(supported_cardinality, cardinality) layer_cfg = {50: [3, 4, 6, 3], 101: [3, 4, 23, 3], 152: [3, 8, 36, 3]} layers = layer_cfg[depth] num_channels = [64, 256, 512, 1024] num_filters = [128, 256, 512, 1024 ] if cardinality == 32 else [256, 512, 1024, 2048] self.conv = ConvBNLayer(num_channels=3, num_filters=64, filter_size=7, stride=2, act='relu') self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1) self.block_list = [] for block in range(len(layers)): shortcut = False for i in range(layers[block]): bottleneck_block = self.add_sublayer( 'bb_%d_%d' % (block, i), BottleneckBlock(num_channels=num_channels[block] if i == 0 else num_filters[block] * int(64 // self.cardinality), num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, cardinality=self.cardinality, shortcut=shortcut)) self.block_list.append(bottleneck_block) shortcut = True if with_pool: self.pool2d_avg = AdaptiveAvgPool2D(1) if num_classes > 0: self.pool2d_avg_channels = num_channels[-1] * 2 stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0) self.out = Linear( self.pool2d_avg_channels, num_classes, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
def __init__(self, num_channels, reduction_ratio=4, name=None): super(SEBlock, self).__init__() self.pool2d_gap = nn.AdaptiveAvgPool2D(1) self._num_channels = num_channels stdv = 1.0 / math.sqrt(num_channels * 1.0) med_ch = num_channels // reduction_ratio self.squeeze = nn.Linear( num_channels, med_ch, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv), name=name + "_1_weights"), bias_attr=ParamAttr(name=name + "_1_offset")) stdv = 1.0 / math.sqrt(med_ch * 1.0) self.excitation = nn.Linear( med_ch, num_channels, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv), name=name + "_2_weights"), bias_attr=ParamAttr(name=name + "_2_offset"))
def __init__(self, ch, reduction_ratio=16): super(SELayer, self).__init__() self.pool = nn.AdaptiveAvgPool2D(1) stdv = 1.0 / math.sqrt(ch) c_ = ch // reduction_ratio self.squeeze = nn.Linear( ch, c_, weight_attr=paddle.ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=True) stdv = 1.0 / math.sqrt(c_) self.extract = nn.Linear( c_, ch, weight_attr=paddle.ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=True)
def __init__(self, ch_ins, ch_out, up_strides, dcn_v2=True): super(IDAUp, self).__init__() for i in range(1, len(ch_ins)): ch_in = ch_ins[i] up_s = int(up_strides[i]) fan_in = ch_in * 3 * 3 stdv = 1. / math.sqrt(fan_in) proj = nn.Sequential( ConvNormLayer(ch_in, ch_out, filter_size=3, stride=1, use_dcn=dcn_v2, bias_on=dcn_v2, norm_decay=None, dcn_lr_scale=1., dcn_regularizer=None, initializer=Uniform(-stdv, stdv)), nn.ReLU()) node = nn.Sequential( ConvNormLayer(ch_out, ch_out, filter_size=3, stride=1, use_dcn=dcn_v2, bias_on=dcn_v2, norm_decay=None, dcn_lr_scale=1., dcn_regularizer=None, initializer=Uniform(-stdv, stdv)), nn.ReLU()) kernel_size = up_s * 2 fan_in = ch_out * kernel_size * kernel_size stdv = 1. / math.sqrt(fan_in) up = nn.Conv2DTranspose( ch_out, ch_out, kernel_size=up_s * 2, stride=up_s, padding=up_s // 2, groups=ch_out, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=False) fill_up_weights(up) setattr(self, 'proj_' + str(i), proj) setattr(self, 'up_' + str(i), up) setattr(self, 'node_' + str(i), node)
def __init__(self, num_channels, num_filters, reduction_ratio, name=None): super(SELayer, self).__init__() self.pool2d_gap = AdaptiveAvgPool2D(1) 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, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) stdv = 1.0 / math.sqrt(med_ch * 1.0) self.excitation = Linear( med_ch, num_filters, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
def __init__(self, num_channels, lr_mult, reduction_ratio=4, name=None): super(SEBlock, self).__init__() self.pool2d_gap = AdaptiveAvgPool2D(1) self._num_channels = num_channels stdv = 1.0 / math.sqrt(num_channels * 1.0) med_ch = num_channels // reduction_ratio self.squeeze = Linear(num_channels, med_ch, weight_attr=ParamAttr(learning_rate=lr_mult, initializer=Uniform( -stdv, stdv)), bias_attr=ParamAttr(learning_rate=lr_mult)) stdv = 1.0 / math.sqrt(med_ch * 1.0) self.excitation = Linear(med_ch, num_channels, weight_attr=ParamAttr(learning_rate=lr_mult, initializer=Uniform( -stdv, stdv)), bias_attr=ParamAttr(learning_rate=lr_mult))
def __init__(self, num_classes=1000, with_pool=True): super().__init__() self.num_classes = num_classes self.with_pool = with_pool self.layers_config = { "inception_a": [[192, 256, 288], [32, 64, 64]], "inception_b": [288], "inception_c": [[768, 768, 768, 768], [128, 160, 160, 192]], "inception_d": [768], "inception_e": [1280, 2048] } inception_a_list = self.layers_config["inception_a"] inception_c_list = self.layers_config["inception_c"] inception_b_list = self.layers_config["inception_b"] inception_d_list = self.layers_config["inception_d"] inception_e_list = self.layers_config["inception_e"] self.inception_stem = InceptionStem() self.inception_block_list = nn.LayerList() for i in range(len(inception_a_list[0])): inception_a = InceptionA(inception_a_list[0][i], inception_a_list[1][i]) self.inception_block_list.append(inception_a) for i in range(len(inception_b_list)): inception_b = InceptionB(inception_b_list[i]) self.inception_block_list.append(inception_b) for i in range(len(inception_c_list[0])): inception_c = InceptionC(inception_c_list[0][i], inception_c_list[1][i]) self.inception_block_list.append(inception_c) for i in range(len(inception_d_list)): inception_d = InceptionD(inception_d_list[i]) self.inception_block_list.append(inception_d) for i in range(len(inception_e_list)): inception_e = InceptionE(inception_e_list[i]) self.inception_block_list.append(inception_e) if with_pool: self.avg_pool = AdaptiveAvgPool2D(1) if num_classes > 0: self.dropout = Dropout(p=0.2, mode="downscale_in_infer") stdv = 1.0 / math.sqrt(2048 * 1.0) self.fc = Linear( 2048, num_classes, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr())
def __init__(self, class_dim: int = 1000, load_checkpoint: str = None): super(ResNeXt50_32x4d, self).__init__() self.layers = 50 self.cardinality = 32 depth = [3, 4, 6, 3] num_channels = [64, 256, 512, 1024] num_filters = [128, 256, 512, 1024] self.conv = ConvBNLayer(num_channels=3, num_filters=64, filter_size=7, stride=2, act='relu', name="res_conv1") self.pool2d_max = MaxPool2d(kernel_size=3, stride=2, padding=1) self.block_list = [] for block in range(len(depth)): shortcut = False for i in range(depth[block]): conv_name = "res" + str(block + 2) + chr(97 + i) bottleneck_block = self.add_sublayer( 'bb_%d_%d' % (block, i), BottleneckBlock( num_channels=num_channels[block] if i == 0 else num_filters[block] * int(64 // self.cardinality), num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, cardinality=self.cardinality, shortcut=shortcut, name=conv_name)) self.block_list.append(bottleneck_block) shortcut = True self.pool2d_avg = AdaptiveAvgPool2d(1) self.pool2d_avg_channels = num_channels[-1] * 2 stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0) self.out = Linear( self.pool2d_avg_channels, class_dim, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv), name="fc_weights"), bias_attr=ParamAttr(name="fc_offset")) if load_checkpoint is not None: model_dict = paddle.load(load_checkpoint)[0] self.set_dict(model_dict) print("load custom checkpoint success") else: checkpoint = os.path.join(self.directory, 'resnext50_32x4d_imagenet.pdparams') if not os.path.exists(checkpoint): os.system( 'wget https://paddlehub.bj.bcebos.com/dygraph/image_classification/resnext50_32x4d_imagenet.pdparams -O ' + checkpoint) model_dict = paddle.load(checkpoint)[0] self.set_dict(model_dict) print("load pretrained checkpoint success")
def __init__(self, num_channels, num_filters, reduction_ratio): super().__init__() self.avg_pool = nn.AdaptiveAvgPool2D(1) self._num_channels = num_channels med_ch = int(num_channels / reduction_ratio) stdv = 1.0 / math.sqrt(num_channels * 1.0) self.fc_squeeze = nn.Linear( num_channels, med_ch, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) self.relu = nn.ReLU() stdv = 1.0 / math.sqrt(med_ch * 1.0) self.fc_excitation = nn.Linear( med_ch, num_filters, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) self.sigmoid = nn.Sigmoid()
def __init__(self, config, stages_pattern, class_num=1000, return_patterns=None, return_stages=None): super().__init__() self.inception_a_list = config["inception_a"] self.inception_c_list = config["inception_c"] self.inception_b_list = config["inception_b"] self.inception_d_list = config["inception_d"] self.inception_e_list = config["inception_e"] self.inception_stem = InceptionStem() self.inception_block_list = nn.LayerList() for i in range(len(self.inception_a_list[0])): inception_a = InceptionA(self.inception_a_list[0][i], self.inception_a_list[1][i]) self.inception_block_list.append(inception_a) for i in range(len(self.inception_b_list)): inception_b = InceptionB(self.inception_b_list[i]) self.inception_block_list.append(inception_b) for i in range(len(self.inception_c_list[0])): inception_c = InceptionC(self.inception_c_list[0][i], self.inception_c_list[1][i]) self.inception_block_list.append(inception_c) for i in range(len(self.inception_d_list)): inception_d = InceptionD(self.inception_d_list[i]) self.inception_block_list.append(inception_d) for i in range(len(self.inception_e_list)): inception_e = InceptionE(self.inception_e_list[i]) self.inception_block_list.append(inception_e) self.avg_pool = AdaptiveAvgPool2D(1) self.dropout = Dropout(p=0.2, mode="downscale_in_infer") stdv = 1.0 / math.sqrt(2048 * 1.0) self.fc = Linear( 2048, class_num, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr()) super().init_res(stages_pattern, return_patterns=return_patterns, return_stages=return_stages)
def __init__(self, class_dim: int): super(ExitFlow, self).__init__() name = "exit_flow" self._conv_0 = ExitFlowBottleneckBlock(728, 728, 1024, name=name + "_1") self._conv_1 = SeparableConv(1024, 1536, stride=1, name=name + "_2") self._conv_2 = SeparableConv(1536, 2048, stride=1, name=name + "_3") self._pool = AdaptiveAvgPool2d(1) stdv = 1.0 / math.sqrt(2048 * 1.0) self._out = Linear( 2048, class_dim, weight_attr=ParamAttr(name="fc_weights", initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr(name="fc_offset"))
def __init__(self, class_dim: int = 1000, load_checkpoint: str = None): super(InceptionV4, self).__init__() self._inception_stem = InceptionStem() self._inceptionA_1 = InceptionA(name="1") self._inceptionA_2 = InceptionA(name="2") self._inceptionA_3 = InceptionA(name="3") self._inceptionA_4 = InceptionA(name="4") self._reductionA = ReductionA() self._inceptionB_1 = InceptionB(name="1") self._inceptionB_2 = InceptionB(name="2") self._inceptionB_3 = InceptionB(name="3") self._inceptionB_4 = InceptionB(name="4") self._inceptionB_5 = InceptionB(name="5") self._inceptionB_6 = InceptionB(name="6") self._inceptionB_7 = InceptionB(name="7") self._reductionB = ReductionB() self._inceptionC_1 = InceptionC(name="1") self._inceptionC_2 = InceptionC(name="2") self._inceptionC_3 = InceptionC(name="3") self.avg_pool = AdaptiveAvgPool2d(1) self._drop = Dropout(p=0.2, mode="downscale_in_infer") stdv = 1.0 / math.sqrt(1536 * 1.0) self.out = Linear( 1536, class_dim, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv), name="final_fc_weights"), bias_attr=ParamAttr(name="final_fc_offset")) if load_checkpoint is not None: model_dict = paddle.load(load_checkpoint)[0] self.set_dict(model_dict) print("load custom checkpoint success") else: checkpoint = os.path.join(self.directory, 'inceptionv4_imagenet.pdparams') if not os.path.exists(checkpoint): os.system( 'wget https://paddlehub.bj.bcebos.com/dygraph/image_classification/inceptionv4_imagenet.pdparams -O' + checkpoint) model_dict = paddle.load(checkpoint)[0] self.set_dict(model_dict) print("load pretrained checkpoint success")
def __init__(self, ch_in, ch_out, norm_type='bn'): super(Upsample, self).__init__() fan_in = ch_in * 3 * 3 stdv = 1. / math.sqrt(fan_in) self.dcn = DeformableConvV2( ch_in, ch_out, kernel_size=3, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)), bias_attr=ParamAttr(initializer=Constant(0), regularizer=L2Decay(0.), learning_rate=2.), lr_scale=2., regularizer=L2Decay(0.)) self.bn = batch_norm(ch_out, norm_type=norm_type, initializer=Constant(1.))
def __init__(self, class_dim=1000): super(InceptionV3, self).__init__() self.inception_a_list = [[192, 256, 288], [32, 64, 64]] self.inception_c_list = [[768, 768, 768, 768], [128, 160, 160, 192]] self.inception_stem = InceptionStem() self.inception_block_list = [] for i in range(len(self.inception_a_list[0])): inception_a = self.add_sublayer( "inception_a_" + str(i + 1), InceptionA(self.inception_a_list[0][i], self.inception_a_list[1][i], name=str(i + 1))) self.inception_block_list.append(inception_a) inception_b = self.add_sublayer("nception_b_1", InceptionB(288, name="1")) self.inception_block_list.append(inception_b) for i in range(len(self.inception_c_list[0])): inception_c = self.add_sublayer( "inception_c_" + str(i + 1), InceptionC(self.inception_c_list[0][i], self.inception_c_list[1][i], name=str(i + 1))) self.inception_block_list.append(inception_c) inception_d = self.add_sublayer("inception_d_1", InceptionD(768, name="1")) self.inception_block_list.append(inception_d) inception_e = self.add_sublayer("inception_e_1", InceptionE(1280, name="1")) self.inception_block_list.append(inception_e) inception_e = self.add_sublayer("inception_e_2", InceptionE(2048, name="2")) self.inception_block_list.append(inception_e) self.gap = AdaptiveAvgPool2D(1) self.drop = Dropout(p=0.2, mode="downscale_in_infer") stdv = 1.0 / math.sqrt(2048 * 1.0) self.out = Linear(2048, class_dim, weight_attr=ParamAttr(initializer=Uniform( -stdv, stdv), name="fc_weights"), bias_attr=ParamAttr(name="fc_offset"))
def __init__(self, in_channels, ch_head=256, ch_emb=128, num_classes=1, num_identities_dict={0: 14455}): super(FairMOTEmbeddingHead, self).__init__() assert num_classes >= 1 self.num_classes = num_classes self.ch_emb = ch_emb self.num_identities_dict = num_identities_dict self.reid = nn.Sequential( ConvLayer( in_channels, ch_head, kernel_size=3, padding=1, bias=True), nn.ReLU(), ConvLayer( ch_head, ch_emb, kernel_size=1, stride=1, padding=0, bias=True)) param_attr = paddle.ParamAttr(initializer=KaimingUniform()) bound = 1 / math.sqrt(ch_emb) bias_attr = paddle.ParamAttr(initializer=Uniform(-bound, bound)) self.reid_loss = nn.CrossEntropyLoss(ignore_index=-1, reduction='sum') if num_classes == 1: nID = self.num_identities_dict[0] # single class self.classifier = nn.Linear( ch_emb, nID, weight_attr=param_attr, bias_attr=bias_attr) # When num_identities(nID) is 1, emb_scale is set as 1 self.emb_scale = math.sqrt(2) * math.log(nID - 1) if nID > 1 else 1 else: self.classifiers = dict() self.emb_scale_dict = dict() for cls_id, nID in self.num_identities_dict.items(): self.classifiers[str(cls_id)] = nn.Linear( ch_emb, nID, weight_attr=param_attr, bias_attr=bias_attr) # When num_identities(nID) is 1, emb_scale is set as 1 self.emb_scale_dict[str(cls_id)] = math.sqrt(2) * math.log( nID - 1) if nID > 1 else 1
def __init__(self, in_channels, ch_head=256, ch_emb=128, num_identifiers=14455): super(FairMOTEmbeddingHead, self).__init__() self.reid = nn.Sequential( ConvLayer( in_channels, ch_head, kernel_size=3, padding=1, bias=True), nn.ReLU(), ConvLayer( ch_head, ch_emb, kernel_size=1, stride=1, padding=0, bias=True)) param_attr = paddle.ParamAttr(initializer=KaimingUniform()) bound = 1 / math.sqrt(ch_emb) bias_attr = paddle.ParamAttr(initializer=Uniform(-bound, bound)) self.classifier = nn.Linear( ch_emb, num_identifiers, weight_attr=param_attr, bias_attr=bias_attr) self.reid_loss = nn.CrossEntropyLoss(ignore_index=-1, reduction='sum') # When num_identifiers is 1, emb_scale is set as 1 self.emb_scale = math.sqrt(2) * math.log( num_identifiers - 1) if num_identifiers > 1 else 1
def __init__(self, layers=50, class_dim=1000, lr_mult_list=[1.0, 1.0, 1.0, 1.0, 1.0]): super(ResNet_vd, self).__init__() self.layers = layers supported_layers = [18, 34, 50, 101, 152, 200] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format( supported_layers, layers) self.lr_mult_list = lr_mult_list assert isinstance( self.lr_mult_list, (list, tuple )), "lr_mult_list should be in (list, tuple) but got {}".format( type(self.lr_mult_list)) assert len( self.lr_mult_list ) == 5, "lr_mult_list length should should be 5 but got {}".format( len(self.lr_mult_list)) if layers == 18: depth = [2, 2, 2, 2] elif layers == 34 or layers == 50: depth = [3, 4, 6, 3] elif layers == 101: depth = [3, 4, 23, 3] elif layers == 152: depth = [3, 8, 36, 3] elif layers == 200: depth = [3, 12, 48, 3] num_channels = [64, 256, 512, 1024 ] if layers >= 50 else [64, 64, 128, 256] num_filters = [64, 128, 256, 512] self.conv1_1 = ConvBNLayer(num_channels=3, num_filters=32, filter_size=3, stride=2, act='relu', lr_mult=self.lr_mult_list[0], name="conv1_1") self.conv1_2 = ConvBNLayer(num_channels=32, num_filters=32, filter_size=3, stride=1, act='relu', lr_mult=self.lr_mult_list[0], name="conv1_2") self.conv1_3 = ConvBNLayer(num_channels=32, num_filters=64, filter_size=3, stride=1, act='relu', lr_mult=self.lr_mult_list[0], name="conv1_3") self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1) self.block_list = [] if layers >= 50: for block in range(len(depth)): shortcut = False for i in range(depth[block]): if layers in [101, 152, 200] and block == 2: if i == 0: conv_name = "res" + str(block + 2) + "a" else: conv_name = "res" + str(block + 2) + "b" + str(i) else: conv_name = "res" + str(block + 2) + chr(97 + i) 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, if_first=block == i == 0, lr_mult=self.lr_mult_list[block + 1], name=conv_name)) self.block_list.append(bottleneck_block) shortcut = True else: for block in range(len(depth)): shortcut = False for i in range(depth[block]): conv_name = "res" + str(block + 2) + chr(97 + i) basic_block = self.add_sublayer( 'bb_%d_%d' % (block, i), BasicBlock(num_channels=num_channels[block] if i == 0 else num_filters[block], num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, shortcut=shortcut, if_first=block == i == 0, name=conv_name, lr_mult=self.lr_mult_list[block + 1])) self.block_list.append(basic_block) shortcut = True self.pool2d_avg = AdaptiveAvgPool2D(1) self.pool2d_avg_channels = num_channels[-1] * 2 stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0) self.out = Linear(self.pool2d_avg_channels, class_dim, weight_attr=ParamAttr(initializer=Uniform( -stdv, stdv), name="fc_0.w_0"), bias_attr=ParamAttr(name="fc_0.b_0"))
def __init__(self, layers=50, class_dim=1000, input_image_channel=3, data_format="NCHW"): super(ResNet, self).__init__() self.layers = layers self.data_format = data_format self.input_image_channel = input_image_channel supported_layers = [18, 34, 50, 101, 152] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format( supported_layers, layers) if layers == 18: depth = [2, 2, 2, 2] elif layers == 34 or 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 ] if layers >= 50 else [64, 64, 128, 256] num_filters = [64, 128, 256, 512] self.conv = ConvBNLayer(num_channels=self.input_image_channel, num_filters=64, filter_size=7, stride=2, act="relu", name="conv1", data_format=self.data_format) self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1, data_format=self.data_format) self.block_list = [] if layers >= 50: for block in range(len(depth)): shortcut = False for i in range(depth[block]): if layers in [101, 152] and block == 2: if i == 0: conv_name = "res" + str(block + 2) + "a" else: conv_name = "res" + str(block + 2) + "b" + str(i) else: conv_name = "res" + str(block + 2) + chr(97 + i) bottleneck_block = self.add_sublayer( conv_name, 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, name=conv_name, data_format=self.data_format)) self.block_list.append(bottleneck_block) shortcut = True else: for block in range(len(depth)): shortcut = False for i in range(depth[block]): conv_name = "res" + str(block + 2) + chr(97 + i) basic_block = self.add_sublayer( conv_name, BasicBlock(num_channels=num_channels[block] if i == 0 else num_filters[block], num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, shortcut=shortcut, name=conv_name, data_format=self.data_format)) self.block_list.append(basic_block) shortcut = True self.pool2d_avg = AdaptiveAvgPool2D(1, data_format=self.data_format) self.pool2d_avg_channels = num_channels[-1] * 2 stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0) self.out = Linear(self.pool2d_avg_channels, class_dim, weight_attr=ParamAttr(initializer=Uniform( -stdv, stdv), name="fc_0.w_0"), bias_attr=ParamAttr(name="fc_0.b_0"))
def __init__(self, scale, class_num=1000): super(GhostNet, self).__init__() self.cfgs = [ # k, t, c, SE, s [3, 16, 16, 0, 1], [3, 48, 24, 0, 2], [3, 72, 24, 0, 1], [5, 72, 40, 1, 2], [5, 120, 40, 1, 1], [3, 240, 80, 0, 2], [3, 200, 80, 0, 1], [3, 184, 80, 0, 1], [3, 184, 80, 0, 1], [3, 480, 112, 1, 1], [3, 672, 112, 1, 1], [5, 672, 160, 1, 2], [5, 960, 160, 0, 1], [5, 960, 160, 1, 1], [5, 960, 160, 0, 1], [5, 960, 160, 1, 1] ] self.scale = scale output_channels = int(self._make_divisible(16 * self.scale, 4)) self.conv1 = ConvBNLayer(in_channels=3, out_channels=output_channels, kernel_size=3, stride=2, groups=1, act="relu", name="conv1") # build inverted residual blocks idx = 0 self.ghost_bottleneck_list = [] for k, exp_size, c, use_se, s in self.cfgs: in_channels = output_channels output_channels = int(self._make_divisible(c * self.scale, 4)) hidden_dim = int(self._make_divisible(exp_size * self.scale, 4)) ghost_bottleneck = self.add_sublayer( name="_ghostbottleneck_" + str(idx), sublayer=GhostBottleneck(in_channels=in_channels, hidden_dim=hidden_dim, output_channels=output_channels, kernel_size=k, stride=s, use_se=use_se, name="_ghostbottleneck_" + str(idx))) self.ghost_bottleneck_list.append(ghost_bottleneck) idx += 1 # build last several layers in_channels = output_channels output_channels = int(self._make_divisible(exp_size * self.scale, 4)) self.conv_last = ConvBNLayer(in_channels=in_channels, out_channels=output_channels, kernel_size=1, stride=1, groups=1, act="relu", name="conv_last") self.pool2d_gap = AdaptiveAvgPool2D(1) in_channels = output_channels self._fc0_output_channels = 1280 self.fc_0 = ConvBNLayer(in_channels=in_channels, out_channels=self._fc0_output_channels, kernel_size=1, stride=1, act="relu", name="fc_0") self.dropout = nn.Dropout(p=0.2) stdv = 1.0 / math.sqrt(self._fc0_output_channels * 1.0) self.fc_1 = Linear(self._fc0_output_channels, class_num, weight_attr=ParamAttr(name="fc_1_weights", initializer=Uniform( -stdv, stdv)), bias_attr=ParamAttr(name="fc_1_offset"))
def __init__(self, layers=50, class_num=1000, cardinality=32, input_image_channel=3, data_format="NCHW"): super(ResNeXt, self).__init__() self.layers = layers self.cardinality = cardinality self.reduction_ratio = 16 self.data_format = data_format self.input_image_channel = input_image_channel supported_layers = [50, 101, 152] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format( supported_layers, layers) supported_cardinality = [32, 64] assert cardinality in supported_cardinality, \ "supported cardinality is {} but input cardinality is {}" \ .format(supported_cardinality, cardinality) 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 = [128, 256, 512, 1024 ] if cardinality == 32 else [256, 512, 1024, 2048] if layers < 152: self.conv = ConvBNLayer(num_channels=self.input_image_channel, num_filters=64, filter_size=7, stride=2, act='relu', name="conv1", data_format=self.data_format) else: self.conv1_1 = ConvBNLayer(num_channels=self.input_image_channel, num_filters=64, filter_size=3, stride=2, act='relu', name="conv1", data_format=self.data_format) self.conv1_2 = ConvBNLayer(num_channels=64, num_filters=64, filter_size=3, stride=1, act='relu', name="conv2", data_format=self.data_format) self.conv1_3 = ConvBNLayer(num_channels=64, num_filters=128, filter_size=3, stride=1, act='relu', name="conv3", data_format=self.data_format) self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1, data_format=self.data_format) self.block_list = [] n = 1 if layers == 50 or layers == 101 else 3 for block in range(len(depth)): n += 1 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] * int(64 // self.cardinality), num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, cardinality=self.cardinality, reduction_ratio=self.reduction_ratio, shortcut=shortcut, if_first=block == 0, name=str(n) + '_' + str(i + 1), data_format=self.data_format)) self.block_list.append(bottleneck_block) shortcut = True self.pool2d_avg = AdaptiveAvgPool2D(1, data_format=self.data_format) self.pool2d_avg_channels = num_channels[-1] * 2 stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0) self.out = Linear(self.pool2d_avg_channels, class_num, weight_attr=ParamAttr(initializer=Uniform( -stdv, stdv), name="fc6_weights"), bias_attr=ParamAttr(name="fc6_offset"))
def __init__(self, layers=68, class_dim=1000): super(DPN, self).__init__() self._class_dim = class_dim args = self.get_net_args(layers) bws = args['bw'] inc_sec = args['inc_sec'] rs = args['r'] k_r = args['k_r'] k_sec = args['k_sec'] G = args['G'] init_num_filter = args['init_num_filter'] init_filter_size = args['init_filter_size'] init_padding = args['init_padding'] self.k_sec = k_sec self.conv1_x_1_func = ConvBNLayer(num_channels=3, num_filters=init_num_filter, filter_size=init_filter_size, stride=2, pad=init_padding, act='relu', name="conv1") self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1) num_channel_dpn = init_num_filter self.dpn_func_list = [] #conv2 - conv5 match_list, num = [], 0 for gc in range(4): bw = bws[gc] inc = inc_sec[gc] R = (k_r * bw) // rs[gc] if gc == 0: _type1 = 'proj' _type2 = 'normal' match = 1 else: _type1 = 'down' _type2 = 'normal' match = match + k_sec[gc - 1] match_list.append(match) self.dpn_func_list.append( self.add_sublayer( "dpn{}".format(match), DualPathFactory(num_channels=num_channel_dpn, num_1x1_a=R, num_3x3_b=R, num_1x1_c=bw, inc=inc, G=G, _type=_type1, name="dpn" + str(match)))) num_channel_dpn = [bw, 3 * inc] for i_ly in range(2, k_sec[gc] + 1): num += 1 if num in match_list: num += 1 self.dpn_func_list.append( self.add_sublayer( "dpn{}".format(num), DualPathFactory(num_channels=num_channel_dpn, num_1x1_a=R, num_3x3_b=R, num_1x1_c=bw, inc=inc, G=G, _type=_type2, name="dpn" + str(num)))) num_channel_dpn = [ num_channel_dpn[0], num_channel_dpn[1] + inc ] out_channel = sum(num_channel_dpn) self.conv5_x_x_bn = BatchNorm( num_channels=sum(num_channel_dpn), act="relu", param_attr=ParamAttr(name='final_concat_bn_scale'), bias_attr=ParamAttr('final_concat_bn_offset'), moving_mean_name='final_concat_bn_mean', moving_variance_name='final_concat_bn_variance') self.pool2d_avg = AdaptiveAvgPool2D(1) stdv = 0.01 self.out = Linear(out_channel, class_dim, weight_attr=ParamAttr(initializer=Uniform( -stdv, stdv), name="fc_weights"), bias_attr=ParamAttr(name="fc_offset"))
def __init__(self, layers=50, scales=4, width=26, class_dim=1000): super(Res2Net_vd, self).__init__() self.layers = layers self.scales = scales self.width = width basic_width = self.width * self.scales supported_layers = [50, 101, 152, 200] 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] elif layers == 200: depth = [3, 12, 48, 3] num_channels = [64, 256, 512, 1024] num_channels2 = [256, 512, 1024, 2048] num_filters = [basic_width * t for t in [1, 2, 4, 8]] self.conv1_1 = ConvBNLayer(num_channels=3, num_filters=32, filter_size=3, stride=2, act='relu', name="conv1_1") self.conv1_2 = ConvBNLayer(num_channels=32, num_filters=32, filter_size=3, stride=1, act='relu', name="conv1_2") self.conv1_3 = ConvBNLayer(num_channels=32, num_filters=64, filter_size=3, stride=1, act='relu', name="conv1_3") self.pool2d_max = MaxPool2D(kernel_size=3, stride=2, padding=1) self.block_list = [] for block in range(len(depth)): shortcut = False for i in range(depth[block]): if layers in [101, 152, 200] and block == 2: if i == 0: conv_name = "res" + str(block + 2) + "a" else: conv_name = "res" + str(block + 2) + "b" + str(i) else: conv_name = "res" + str(block + 2) + chr(97 + i) bottleneck_block = self.add_sublayer( 'bb_%d_%d' % (block, i), BottleneckBlock(num_channels1=num_channels[block] if i == 0 else num_channels2[block], num_channels2=num_channels2[block], num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, scales=scales, shortcut=shortcut, if_first=block == i == 0, name=conv_name)) self.block_list.append(bottleneck_block) shortcut = True self.pool2d_avg = AdaptiveAvgPool2D(1) self.pool2d_avg_channels = num_channels[-1] * 2 stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0) self.out = Linear(self.pool2d_avg_channels, class_dim, weight_attr=ParamAttr(initializer=Uniform( -stdv, stdv), name="fc_weights"), bias_attr=ParamAttr(name="fc_offset"))
def __init__(self, width=18, has_se=False, class_num=1000, return_patterns=None): super().__init__() self.width = width self.has_se = has_se self._class_num = class_num channels_2 = [self.width, self.width * 2] channels_3 = [self.width, self.width * 2, self.width * 4] channels_4 = [ self.width, self.width * 2, self.width * 4, self.width * 8 ] self.conv_layer1_1 = ConvBNLayer(num_channels=3, num_filters=64, filter_size=3, stride=2, act="relu") self.conv_layer1_2 = ConvBNLayer(num_channels=64, num_filters=64, filter_size=3, stride=2, act="relu") self.layer1 = nn.Sequential(*[ BottleneckBlock(num_channels=64 if i == 0 else 256, num_filters=64, has_se=has_se, stride=1, downsample=True if i == 0 else False) for i in range(4) ]) self.conv_tr1_1 = ConvBNLayer(num_channels=256, num_filters=width, filter_size=3) self.conv_tr1_2 = ConvBNLayer(num_channels=256, num_filters=width * 2, filter_size=3, stride=2) self.st2 = Stage(num_modules=1, num_filters=channels_2, has_se=self.has_se) self.conv_tr2 = ConvBNLayer(num_channels=width * 2, num_filters=width * 4, filter_size=3, stride=2) self.st3 = Stage(num_modules=4, num_filters=channels_3, has_se=self.has_se) self.conv_tr3 = ConvBNLayer(num_channels=width * 4, num_filters=width * 8, filter_size=3, stride=2) self.st4 = Stage(num_modules=3, num_filters=channels_4, has_se=self.has_se) # classification num_filters_list = [32, 64, 128, 256] self.last_cls = LastClsOut(num_channel_list=channels_4, has_se=self.has_se, num_filters_list=num_filters_list) last_num_filters = [256, 512, 1024] self.cls_head_conv_list = nn.LayerList() for idx in range(3): self.cls_head_conv_list.append( ConvBNLayer(num_channels=num_filters_list[idx] * 4, num_filters=last_num_filters[idx], filter_size=3, stride=2)) self.conv_last = ConvBNLayer(num_channels=1024, num_filters=2048, filter_size=1, stride=1) self.avg_pool = nn.AdaptiveAvgPool2D(1) stdv = 1.0 / math.sqrt(2048 * 1.0) self.fc = nn.Linear( 2048, class_num, weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv))) if return_patterns is not None: self.update_res(return_patterns) self.register_forward_post_hook(self._return_dict_hook)
def xavier(channels, filter_size, name): stdv = (3.0 / (filter_size**2 * channels))**0.5 param_attr = ParamAttr(initializer=Uniform(-stdv, stdv), name=name + "_weights") return param_attr