def __init__(self, num_classes, loss=None, dropout_p=None, **kwargs): super(AsNet, self).__init__() resnet_ = resnet50(pretrained=True) self.num_parts = 3 self.loss = loss self.layer0 = nn.Sequential(resnet_.conv1, resnet_.bn1, resnet_.relu, resnet_.maxpool) self.layer1 = resnet_.layer1 self.layer2 = resnet_.layer2 self.pc1 = PC_Module(512) self.layer3 = resnet_.layer3 # self.pc2 = PC_Module(1024) layer4 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) layer4.load_state_dict(resnet_.layer4.state_dict()) self.layer4_trunk = nn.Sequential(copy.deepcopy(layer4)) self.layer4_branch = nn.Sequential(copy.deepcopy(layer4)) # self.layer4 = nn.Sequential(copy.deepcopy(layer4)) self.layer5_trunk = Bottleneck(2048, 512) # self.layer5_branch = Bottleneck(2048, 512) # self.attention_pc_branch = PC_Module(1024) # self.res_part1 = Bottleneck(2048, 512) # self.res_part2 = Bottleneck(2048, 512) self.global_avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.global_maxpool = nn.AdaptiveMaxPool2d((1, 1)) self.parts_pool = nn.AdaptiveAvgPool2d((self.num_parts, 1)) # self.dropout = nn.Dropout(p=0.5) self.bn_trunk = nn.BatchNorm2d(2048) #20191226_1 # self.bn_branch = nn.BatchNorm2d(2048) #20191226_1 # self.fc = nn.Linear(2048, 2048) # self.bn = nn.BatchNorm2d(2048) # self.dim_red = DimReduceLayer(2048, 256) # self.dim_red_trunk = DimReduceLayer(2048, 256) self.dim_red_branch = DimReduceLayer(2048, 256) # self.dim_red_branch = DimReduceLayer(1024, 256) # self.dim_red_branch = nn.ModuleList([DimReduceLayer(2048, 256) for _ in range(self.num_parts)]) # self.conv5 = DimReduceLayer(2048, 2048) # 20191221_3 # self.classifier_trunk = nn.Linear(256, num_classes) self.classifiers = nn.ModuleList( [nn.Linear(256, num_classes) for _ in range(self.num_parts)]) # self.classifiers = nn.ModuleList([nn.Linear(256, num_classes) for _ in range(self.num_parts+1)]) # self.classifiers = nn.ModuleList([nn.Linear(2048, num_classes) for _ in range(self.num_parts)]) self.classifier_trunk = nn.Linear(2048, num_classes) # self.classifier1 = nn.Linear(2048, num_classes) # 20191221_3 # self.classifier = nn.ModuleList([nn.Linear(256, num_classes) for _ in range(6)]) # 20191221_2 self._init_params()
def __init__(self, in_channels, out_channels=1024, aspect_ratios=[[1]], scales=[1], parent=None): super().__init__() self.num_classes = cfg.num_classes self.mask_dim = cfg.mask_dim self.num_priors = sum(len(x) for x in aspect_ratios) self.parent = [parent] # Don't include this in the state dict if cfg.mask_proto_prototypes_as_features: in_channels += self.mask_dim if parent is None: if cfg.extra_head_net is None: out_channels = in_channels else: self.upfeature, out_channels = make_net( in_channels, cfg.extra_head_net) if cfg.use_prediction_module: self.block = Bottleneck(out_channels, out_channels // 4) self.conv = nn.Conv2d(out_channels, out_channels, kernel_size=1, bias=True) self.bn = nn.BatchNorm2d(out_channels) self.bbox_layer = nn.Conv2d(out_channels, self.num_priors * 4, **cfg.head_layer_params) self.conf_layer = nn.Conv2d(out_channels, self.num_priors * self.num_classes, **cfg.head_layer_params) self.mask_layer = nn.Conv2d(out_channels, self.num_priors * self.mask_dim, **cfg.head_layer_params) if cfg.use_instance_coeff: self.inst_layer = nn.Conv2d( out_channels, self.num_priors * cfg.num_instance_coeffs, **cfg.head_layer_params) # What is this ugly lambda doing in the middle of all this clean prediction module code? def make_extra(num_layers): if num_layers == 0: return lambda x: x else: # Looks more complicated than it is. This just creates an array of num_layers alternating conv-relu return nn.Sequential(*sum([[ nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(inplace=True) ] for _ in range(num_layers)], [])) self.bbox_extra, self.conf_extra, self.mask_extra = [ make_extra(x) for x in cfg.extra_layers ] if cfg.mask_type == mask_type.lincomb and cfg.mask_proto_coeff_gate: self.gate_layer = nn.Conv2d(out_channels, self.num_priors * self.mask_dim, kernel_size=3, padding=1) self.aspect_ratios = aspect_ratios self.scales = scales self.priors = None self.last_conv_size = None
def __init__(self): super(MGN, self).__init__() num_classes = 1500 feats = 256 resnet = resnet50(pretrained=True) self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8)) self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8)) self.reduction = nn.Sequential(nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats), nn.ReLU()) self._init_reduction(self.reduction) self.fc_id_2048_0 = nn.Linear(feats, num_classes) self.fc_id_2048_1 = nn.Linear(feats, num_classes) self.fc_id_2048_2 = nn.Linear(feats, num_classes) self.fc_id_256_1_0 = nn.Linear(feats, num_classes) self.fc_id_256_1_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_0 = nn.Linear(feats, num_classes) self.fc_id_256_2_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_2 = nn.Linear(feats, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2) self.attention = CALayer(2048) self.attention2 = SpatialAttn() self.num = 1
def __init__(self, channels, h_ratio=0.33, w_ratio=1.): super(BatchFeatureErase_Basic, self).__init__() self.drop_batch_bottleneck = Bottleneck(channels, 512) self.drop_batch_drop = BatchDrop(h_ratio, w_ratio)
def __init__(self): super(MGN, self).__init__() resnet = resnet50(pretrained=True) # resnet50网络 self.backone = nn.Sequential( resnet.conv1, # 64*112*112 resnet.bn1, resnet.relu, resnet.maxpool, # 64*56*56 ) res_conv2 = nn.Sequential(*resnet.layer1[1:]) # 256*56*56 res_conv3 = nn.Sequential(*resnet.layer1[1:], *resnet.layer2) # 512*28*28 res_conv4 = nn.Sequential(*resnet.layer1[1:], *resnet.layer2, *resnet.layer3) # 1024*14*14 res_g_conv3 = resnet.layer2 # p0 512*28*28 res_g_conv4 = resnet.layer3 # p4 1024*14*14 res_g_conv5 = resnet.layer4 # p1 2048*7*7 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential(nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p0 = nn.Sequential(copy.deepcopy(res_conv2), copy.deepcopy(res_g_conv3), nn.Conv2d(512, 2048, 1, bias=False), nn.BatchNorm2d(2048), nn.ReLU()) self.p4 = nn.Sequential(copy.deepcopy(res_conv3), copy.deepcopy(res_g_conv4), nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048), nn.ReLU()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) pool2d = nn.MaxPool2d self.maxpool_zg_p4 = pool2d(kernel_size=(24, 8)) # part-4?????????????? self.maxpool_zg_p0 = pool2d(kernel_size=(48, 16)) # part-0 self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4)) # part-1 self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8)) # part-2 self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8)) # part-3 self.maxpool_zp2 = pool2d(kernel_size=(12, 8)) # part-2 可以划分为2个 self.maxpool_zp3 = pool2d(kernel_size=(8, 8)) # part-3 可以划分分3个 reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) # print("p1降维----》", self.reduction_0) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # p0,p4 self.reduction_p0 = copy.deepcopy(reduction) # print("p0降维----》", self.reduction_p0) self.reduction_p4 = copy.deepcopy(reduction) # fc softmax loss # self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_0 = nn.Linear(256, 751) self.fc_id_2048_1 = nn.Linear(256, 751) self.fc_id_2048_2 = nn.Linear(256, 751) # p0 p4 self.fc_id_2048_3 = nn.Linear(256, 751) # print("p0全连接------------->", self.fc_id_2048_3) self.fc_id_2048_4 = nn.Linear(256, 751) self.fc_id_256_1_0 = nn.Linear(256, 751) self.fc_id_256_1_1 = nn.Linear(256, 751) self.fc_id_256_2_0 = nn.Linear(256, 751) self.fc_id_256_2_1 = nn.Linear(256, 751) self.fc_id_256_2_2 = nn.Linear(256, 751) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) # p0 p4 self._init_fc(self.fc_id_2048_3) # print("debug2222222222") self._init_fc(self.fc_id_2048_4) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
class BFE(nn.Module): def __init__(self, num_classes, width_ratio=0.5, height_ratio=0.5): super(BFE, self).__init__() # resnet = resnet50() # resnet.load_state_dict(torch.load('./resnet50-19c8e357.pth')) # print("load ResNet50 parameters") print("load ResNeSt50 and ResNet50 parameters") model = resnet50() resnet = resnest50() model.load_state_dict(torch.load('../resnet50-19c8e357.pth')) resnet.load_state_dict(torch.load('../resnest50-528c19ca.pth')) self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, CAM_Module(256), resnet.layer2, CAM_Module(512), ) self.res_part_head = nn.Sequential(resnet.layer3, CAM_Module(1024)) self.res_part = nn.Sequential( Bottleneck(1024, 512, stride=1, downsample=nn.Sequential( nn.Conv2d(1024, 2048, kernel_size=1, stride=1, bias=False), nn.BatchNorm2d(2048), )), Bottleneck(2048, 512), Bottleneck(2048, 512), ) # self.res_part.load_state_dict(resnet.layer4.state_dict()) self.res_part.load_state_dict(model.layer4.state_dict()) self.c4 = CAM_Module(2048) self.part_pool = nn.AdaptiveMaxPool2d((1, 1)) # self.part_pool = nn.AdaptiveAvgPool2d((1, 1)) self.res_part2 = Bottleneck(2048, 512) self.batch_crop = BatchDrop(height_ratio, width_ratio) self.reduction = nn.Sequential(nn.Linear(2048, 1024, 1), nn.BatchNorm1d(1024), nn.ReLU()) self.reduction.apply(weights_init_kaiming) self.softmax = nn.Linear(1024, num_classes) self.softmax.apply(weights_init_kaiming) # Auxiliary branch ab_vector_size = 256 reduction = nn.Sequential(nn.Conv2d(2048, ab_vector_size, 1), nn.BatchNorm2d(ab_vector_size), nn.ReLU(inplace=True)) self.auxiliary_avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.auxiliary_softmax = nn.Linear(ab_vector_size, num_classes) self.auxiliary_softmax.apply(weights_init_kaiming) self.auxiliary_reduction = copy.deepcopy(reduction) self.auxiliary_reduction.apply(weights_init_kaiming) def forward(self, x): x = self.backbone(x) x = self.res_part_head(x) x = self.res_part(x) x = self.c4(x) predict = [] triplet_features = [] softmax_features = [] # auxiliary branch auxiliary = self.auxiliary_avgpool(x) auxiliary_triplet_feature = self.auxiliary_reduction( auxiliary).squeeze() auxiliary_softmax_class = self.auxiliary_softmax( auxiliary_triplet_feature) softmax_features.append(auxiliary_softmax_class) triplet_features.append(auxiliary_triplet_feature) predict.append(auxiliary_triplet_feature) # main branch x = self.res_part2(x) x = self.batch_crop(x) triplet_feature = self.part_pool(x).squeeze() feature = self.reduction(triplet_feature) softmax_feature = self.softmax(feature) triplet_features.append(feature) softmax_features.append(softmax_feature) predict.append(feature) if self.training: return triplet_features, softmax_features else: return torch.cat(predict, 1) def get_optim_policy(self): params = [ { 'params': self.backbone.parameters() }, { 'params': self.res_part_head.parameters() }, { 'params': self.res_part.parameters() }, { 'params': self.c4.parameters() }, { 'params': self.res_part2.parameters() }, { 'params': self.reduction.parameters() }, { 'params': self.softmax.parameters() }, { 'params': self.auxiliary_reduction.parameters() }, { 'params': self.auxiliary_softmax.parameters() }, ] return params
def __init__(self): super(Encoder, self).__init__() resnet = resnet50(pretrained=True) self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) # conv4_1 res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) #########identity-related######### self.p0_id = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p1_id = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p2_id = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.maxpool_zg_p0 = nn.MaxPool2d(kernel_size=(12, 4)) self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zp1 = nn.MaxPool2d(kernel_size=(12, 8)) self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(8, 8)) self.reduction_zg_p0_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_zg_p1_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z0_p1_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z1_p1_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_zg_p2_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z0_p2_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z1_p2_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z2_p2_id = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.fc_fg_p0_id = nn.Linear(opt.feat_id, int(opt.num_cls)) self.fc_fg_p1_id = nn.Linear(opt.feat_id, int(opt.num_cls)) self.fc_f0_p1_id = nn.Linear(opt.feat_id, int(opt.num_cls)) self.fc_f1_p1_id = nn.Linear(opt.feat_id, int(opt.num_cls)) self.fc_fg_p2_id = nn.Linear(opt.feat_id, int(opt.num_cls)) self.fc_f0_p2_id = nn.Linear(opt.feat_id, int(opt.num_cls)) self.fc_f1_p2_id = nn.Linear(opt.feat_id, int(opt.num_cls)) self.fc_f2_p2_id = nn.Linear(opt.feat_id, int(opt.num_cls)) #########cloth_related######### self.p0_cloth = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p1_cloth = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p2_cloth = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.reduction_zg_p0_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_zg_p1_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z0_p1_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z1_p1_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_zg_p2_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z0_p2_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z1_p2_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.reduction_z2_p2_cloth = nn.Sequential( nn.Conv2d(2048, opt.feat_id, 1, bias=False), nn.BatchNorm2d(opt.feat_id)) self.fc_cloth_g0 = nn.Linear(opt.feat_id, int(opt.num_cloths)) self.fc_cloth_g1 = nn.Linear(opt.feat_id, int(opt.num_cloths)) self.fc_cloth_g2 = nn.Linear(opt.feat_id, int(opt.num_cloths)) #########identity_unrelated######### self.p0_nid = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p1_nid = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p2_nid = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.avgpool_zg_p0 = nn.AvgPool2d(kernel_size=(12, 4)) self.avgpool_zg_p1 = nn.AvgPool2d(kernel_size=(24, 8)) self.avgpool_zp1 = nn.AvgPool2d(kernel_size=(12, 8)) self.avgpool_zg_p2 = nn.AvgPool2d(kernel_size=(24, 8)) self.avgpool_zp2 = nn.AvgPool2d(kernel_size=(8, 8)) self.fc_zg_p0_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_zg_p0_nid_lv = nn.Linear(2048, int(opt.feat_nid)) self.fc_zg_p1_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_zg_p1_nid_lv = nn.Linear(2048, int(opt.feat_nid)) self.fc_z0_p1_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_z0_p1_nid_lv = nn.Linear(2048, int(opt.feat_nid)) self.fc_z1_p1_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_z1_p1_nid_lv = nn.Linear(2048, int(opt.feat_nid)) self.fc_zg_p2_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_zg_p2_nid_lv = nn.Linear(2048, int(opt.feat_nid)) self.fc_z0_p2_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_z0_p2_nid_lv = nn.Linear(2048, int(opt.feat_nid)) self.fc_z1_p2_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_z1_p2_nid_lv = nn.Linear(2048, int(opt.feat_nid)) self.fc_z2_p2_nid_mu = nn.Linear(2048, int(opt.feat_nid)) self.fc_z2_p2_nid_lv = nn.Linear(2048, int(opt.feat_nid)) # self.fc_nid = nn.Linear(512, int(opt.num_cls) * 2) id_dict2 = self.get_modules(self.id_dict2()) for i in range(np.size(id_dict2)): init_weights(id_dict2[i])
def __init__(self, depth, pretrained=True, cut_at_pooling=False, num_features=0, norm=False, dropout=0, num_classes=0): super(ResNet, self).__init__() self.pretrained = pretrained self.depth = depth self.cut_at_pooling = cut_at_pooling self.has_embedding = num_features > 0 # Construct base (pretrained) resnet if depth not in ResNet.__factory: raise KeyError("Unsupported depth:", depth) resnet = ResNet.__factory[depth](pretrained=pretrained) resnet.layer4[0].conv2.stride = (1,1) resnet.layer4[0].downsample[0].stride = (1,1) self.base = nn.Sequential( resnet.conv1, resnet.bn1, resnet.maxpool, # no relu resnet.layer1, resnet.layer2, resnet.layer3) self.num_classes = num_classes out_planes = resnet.fc.in_features self.num_features = num_features self.dropout = dropout # 1st branch self.global_branch = resnet.layer4 self.gap = nn.AdaptiveAvgPool2d(1) if self.has_embedding: self.feat = nn.Linear(out_planes, num_features) init.kaiming_normal_(self.feat.weight, mode='fan_out') init.constant_(self.feat.bias, 0) self.feat_bn = nn.BatchNorm1d(self.num_features) else: self.num_features = out_planes self.feat_bn = nn.BatchNorm1d(self.num_features) self.feat_bn.bias.requires_grad_(False) if self.dropout > 0: self.drop = nn.Dropout(self.dropout) if self.num_classes > 0: self.classifier = nn.Linear(self.num_features, self.num_classes, bias=False) init.normal_(self.classifier.weight, std=0.001) init.constant_(self.feat_bn.weight, 1) init.constant_(self.feat_bn.bias, 0) # 2nd branch self.max_branch = nn.Sequential(deepcopy(resnet.layer4), Bottleneck(2048, 512)) self.max_branch[1].apply(weights_init_kaiming) self.gmp = nn.AdaptiveMaxPool2d(1) if self.has_embedding: self.feat_max = nn.Linear(out_planes, num_features) init.kaiming_normal_(self.feat_max.weight, mode='fan_out') init.constant_(self.feat_max.bias, 0) self.feat_bn_max = nn.BatchNorm1d(self.num_features) else: self.num_features = out_planes self.feat_bn_max = nn.BatchNorm1d(self.num_features) self.feat_bn_max.bias.requires_grad_(False) if self.dropout > 0: self.drop_max = nn.Dropout(self.dropout) if self.num_classes > 0: self.classifier_max = nn.Linear(self.num_features, self.num_classes, bias=False) init.normal_(self.classifier_max.weight, std=0.001) init.constant_(self.feat_bn_max.weight, 1) init.constant_(self.feat_bn_max.bias, 0) if not pretrained: self.reset_params()
def __init__(self, args): super(BIMGN, self).__init__() num_classes = args.num_classes num_attributes = args.num_attributes resnet = resnet50(pretrained=True) self.rgb_branch = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.ir_branch = copy.deepcopy(self.rgb_branch) if args.non_local == True: layers = [3, 4, 6, 3] non_layers = [0, 2, 3, 0] self.NL_1 = nn.ModuleList( [Non_local(256) for i in range(non_layers[0])]) self.NL_1_idx = sorted( [layers[0] - (i + 1) for i in range(non_layers[0])]) self.NL_2 = nn.ModuleList( [Non_local(512) for i in range(non_layers[1])]) self.NL_2_idx = sorted( [layers[1] - (i + 1) for i in range(non_layers[1])]) self.NL_3 = nn.ModuleList( [Non_local(1024) for i in range(non_layers[2])]) self.NL_3_idx = sorted( [layers[2] - (i + 1) for i in range(non_layers[2])]) self.NL_4 = nn.ModuleList( [Non_local(2048) for i in range(non_layers[3])]) self.NL_4_idx = sorted( [layers[3] - (i + 1) for i in range(non_layers[3])]) self.backbone = nn.Sequential( resnet.layer1, resnet.layer2[0], resnet.layer2[1], resnet.layer2[2], self.NL_2[0], resnet.layer2[3], self.NL_2[1], resnet.layer3[0], ) res_conv4 = nn.Sequential(resnet.layer3[1], resnet.layer3[2], resnet.layer3[3], self.NL_3[0], resnet.layer3[4], self.NL_3[1], resnet.layer3[5], self.NL_3[2]) else: self.backbone = nn.Sequential( resnet.layer1, resnet.layer2, resnet.layer3[0], ) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) if args.pool == 'max': pool2d = nn.MaxPool2d elif args.pool == 'avg': pool2d = nn.AvgPool2d else: raise Exception() self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8)) self.maxpool_zp2 = pool2d(kernel_size=(12, 8)) self.maxpool_zp3 = pool2d(kernel_size=(8, 8)) reduction = nn.Sequential(nn.Conv2d(2048, args.feats, 1, bias=False), nn.BatchNorm2d(args.feats), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_0 = nn.Linear(args.feats, num_classes) self.fc_id_2048_1 = nn.Linear(args.feats, num_classes) self.fc_id_2048_2 = nn.Linear(args.feats, num_classes) self.fc_attr_2048_0 = nn.Linear(args.feats, num_attributes) self.fc_attr_2048_1 = nn.Linear(args.feats, num_attributes) self.fc_attr_2048_2 = nn.Linear(args.feats, num_attributes) self.fc_id_256_1_0 = nn.Linear(args.feats, num_classes) self.fc_id_256_1_1 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_0 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_1 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_2 = nn.Linear(args.feats, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_attr_2048_0) self._init_fc(self.fc_attr_2048_1) self._init_fc(self.fc_attr_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
def __init__(self, num_classes = 751): super(MGN, self).__init__() # 使用resnet的的前面层作为基础特征特征提取结构,分支结构共享部分 resnet = resnet50(pretrained=True) self.backone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, # res_conv2 resnet.layer2, # res_conv3 resnet.layer3[0], # res_conv4_1 ) # MGN Network,The difference is that we employ no down-sampling operations in res_conv5_1 block. # res_conv4x res_conv4 = nn.Sequential(*resnet.layer3[1:]) # res_conv5 global res_g_conv5 = resnet.layer4 # res_conv5 part res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential(nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) # mgn part-1 global self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) # mgn part-2 self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # mgn part-3 self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # global max pooling self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8)) self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8)) # 每个分支中用于降维的1×1conv和用于identity prediction的全连接层不共享权重 # conv1 reduce reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # fc softmax loss self.fc_id_2048_0 = nn.Linear(256, num_classes) # 2048 self.fc_id_2048_1 = nn.Linear(256, num_classes) # 2048 self.fc_id_2048_2 = nn.Linear(256, num_classes) # 2048 self.fc_id_256_1_0 = nn.Linear(256, num_classes) self.fc_id_256_1_1 = nn.Linear(256, num_classes) self.fc_id_256_2_0 = nn.Linear(256, num_classes) self.fc_id_256_2_1 = nn.Linear(256, num_classes) self.fc_id_256_2_2 = nn.Linear(256, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
def __init__(self, in_channels, out_channels=1024, aspect_ratios=[[1]], scales=[1], parent=None, index=0): # 256, 256, [[1, 1/2, 2]], [24*2**0 , 24*2**(1/3) , 24*2**(2/3) ], parent, 0 # 256, 256, [[1, 1/2, 2]], [48*2**0 , 48*2**(1/3) , 48*2**(2/3) ], parent, 1 # 256, 256, [[1, 1/2, 2]], [96*2**0 , 96*2**(1/3) , 96*2**(2/3) ], parent, 2 # 256, 256, [[1, 1/2, 2]], [192*2**0, 192*2**(1/3), 192*2**(2/3)], parent, 3 # 256, 256, [[1, 1/2, 2]], [384*2**0, 384*2**(1/3), 384*2**(2/3)], parent, 4 # 2**0 = 0, 2**(1/3) = 1.26, 2**(2/3) = 1.587 # 좀 더 균일한 스케일을 뽑아낼 수 있도록 만든 장치로 보임. super().__init__() self.num_classes = cfg.num_classes # len(coco2017_dataset.class_names) + 1, self.mask_dim = cfg.mask_dim # Defined by Yolact #fpn -> 32 self.num_priors = sum(len(x) * len(scales) for x in aspect_ratios) # =9 self.parent = [parent] # Don't include this in the state dict self.index = index self.num_heads = cfg.num_heads # Defined by Yolact -> 5 #False if cfg.mask_proto_split_prototypes_by_head and cfg.mask_type == mask_type.lincomb: self.mask_dim = self.mask_dim // self.num_heads #False if cfg.mask_proto_prototypes_as_features: in_channels += self.mask_dim #처음 pred_layer는 None. if parent is None: if cfg.extra_head_net is None: out_channels = in_channels else: # 'extra_head_net': [(256, 3, {'padding': 1})], self.upfeature, out_channels = make_net( in_channels, cfg.extra_head_net) # 차원 수 변화없음. conv2d(f=3, p=1) # out_channels = 256. #False if cfg.use_prediction_module: self.block = Bottleneck(out_channels, out_channels // 4) self.conv = nn.Conv2d(out_channels, out_channels, kernel_size=1, bias=True) self.bn = nn.BatchNorm2d(out_channels) #cfg 'head_layer_params': {'kernel_size': 3, 'padding': 1}, self.bbox_layer = nn.Conv2d( out_channels, self.num_priors * 4, **cfg.head_layer_params) #out channel:(9*4) self.conf_layer = nn.Conv2d( out_channels, self.num_priors * self.num_classes, **cfg.head_layer_params) #out channel:(9*c) self.mask_layer = nn.Conv2d( out_channels, self.num_priors * self.mask_dim, **cfg.head_layer_params) #out channel:(9*32) - coefficient # False if cfg.use_mask_scoring: self.score_layer = nn.Conv2d(out_channels, self.num_priors, **cfg.head_layer_params) # False // 'num_instance_coeffs': 64, -> But, No used # bbox IoU가 아니라 coefficient로 loss함수를 내고 싶을 때 사용. if cfg.use_instance_coeff: self.inst_layer = nn.Conv2d( out_channels, self.num_priors * cfg.num_instance_coeffs, **cfg.head_layer_params) # What is this ugly lambda doing in the middle of all this clean prediction module code? def make_extra(num_layers): if num_layers == 0: return lambda x: x else: # Looks more complicated than it is. This just creates an array of num_layers alternating conv-relu return nn.Sequential(*sum([[ nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(inplace=True) ] for _ in range(num_layers)], [])) # # Add extra layers between the backbone and the network heads # # The order is (bbox, conf, mask) # 'extra_layers': (0, 0, 0), -> #cw 즉, default설정으로는 아무것도 바뀌지 않는다. self.bbox_extra, self.conf_extra, self.mask_extra = [ make_extra(x) for x in cfg.extra_layers ] if cfg.mask_type == mask_type.lincomb and cfg.mask_proto_coeff_gate: #cw True and False. self.gate_layer = nn.Conv2d(out_channels, self.num_priors * self.mask_dim, kernel_size=3, padding=1) self.aspect_ratios = aspect_ratios self.scales = scales self.priors = None self.last_conv_size = None self.last_img_size = None
def __init__(self, cfg, backbone_path=None): super().__init__() image_size = cfg.INPUT.IMAGE_SIZE self.output_channels = cfg.MODEL.BACKBONE.OUT_CHANNELS image_channels = cfg.MODEL.BACKBONE.INPUT_CHANNELS self.backbone = resnet50(pretrained=True) self.modules = [] self.bank1 = nn.Sequential( nn.Conv2d( in_channels=image_channels, out_channels=64, kernel_size=7, stride=2, padding=3 ), nn.BatchNorm2d(64), nn.ReLU(), self.backbone.layer1, self.backbone.layer2, self.backbone.layer3, nn.Conv2d( in_channels=self.output_channels[0], out_channels=self.output_channels[0], kernel_size=1, stride=1, padding=0 ) ) self.bank2 = nn.Sequential( Bottleneck( inplanes=1024, planes=128, stride=2, downsample=nn.Sequential( nn.Conv2d( in_channels=1024, out_channels=512, kernel_size=1, stride=2, padding=0, bias=False), nn.BatchNorm2d(512) ), groups=1, base_width=64, dilation=1, norm_layer=None ), Bottleneck( inplanes=512, planes=128, stride=1, downsample=None, groups=1, base_width=64, dilation=1, norm_layer=None ) ) #self.modules.append(self.bank1) #print(self.bank2) self.bank3 = nn.Sequential( Bottleneck( inplanes=512, planes=128, stride=2, downsample=nn.Sequential( nn.Conv2d( in_channels=512, out_channels=512, kernel_size=1, stride=2, padding=0, bias=False), nn.BatchNorm2d(512) ), groups=1, base_width=64, dilation=1, norm_layer=None ), Bottleneck( inplanes=512, planes=128, stride=1, downsample=None, groups=1, base_width=64, dilation=1, norm_layer=None ) ) #print(self.bank3) self.bank4 = nn.Sequential( Bottleneck( inplanes=512, planes=64, stride=2, downsample=nn.Sequential( nn.Conv2d( in_channels=512, out_channels=256, kernel_size=1, stride=2, padding=0, bias=False), nn.BatchNorm2d(256) ), groups=1, base_width=64, dilation=1, norm_layer=None ), Bottleneck( inplanes=256, planes=64, stride=1, downsample=None, groups=1, base_width=64, dilation=1, norm_layer=None ) ) #print(self.bank4) self.bank5 = nn.Sequential( Bottleneck( inplanes=256, planes=64, stride=2, downsample=nn.Sequential( nn.Conv2d( in_channels=256, out_channels=256, kernel_size=1, stride=2, padding=0, bias=False), nn.BatchNorm2d(256) ), groups=1, base_width=64, dilation=1, norm_layer=None ), Bottleneck( inplanes=256, planes=64, stride=1, downsample=None, groups=1, base_width=64, dilation=1, norm_layer=None ) ) #print(self.bank5) self.bank6 = nn.Sequential( Bottleneck( inplanes=256, planes=64, stride=2, downsample=nn.Sequential( nn.Conv2d( in_channels=256, out_channels=256, kernel_size=1, stride=2, padding=0, bias=False), nn.BatchNorm2d(256) ), groups=1, base_width=64, dilation=1, norm_layer=None ), Bottleneck( inplanes=256, planes=64, stride=1, downsample=None, groups=1, base_width=64, dilation=1, norm_layer=None ), nn.MaxPool2d(kernel_size=2,stride=2) ) #print(self.bank5) self.feature_extractor = nn.Sequential(*self.modules) print(self.feature_extractor)
def __init__(self, num_classes, last_stride, pool): super(MGN_Paper, self).__init__() self.model_name = 'MGN_Paper' self.download = models.resnet50(pretrained=True) self.base = resnet50(pretrained=True, last_stride=last_stride) self.backbone = nn.Sequential( self.base.conv1, self.base.bn1, self.base.relu, self.base.maxpool, self.base.layer1, self.base.layer2, self.base.layer3[0], ) res_conv4 = nn.Sequential(*self.base.layer3[1:]) res_g_conv5 = self.base.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(self.base.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) if pool == 'MAX': pool2d = nn.MaxPool2d elif pool == 'AVG': pool2d = nn.AvgPool2d else: raise Exception() self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8)) self.maxpool_zp2 = pool2d(kernel_size=(12, 8)) self.maxpool_zp3 = pool2d(kernel_size=(8, 8)) self.reduction = nn.Sequential( nn.Conv2d(2048, self.feats, 1, bias=False), nn.BatchNorm2d(self.feats_256), nn.ReLU()) self._init_reduction(self.reduction) # self.reduction.apply(_init_reduction) self.fc_id_2048_0 = nn.Linear(self.feats_2048, num_classes) self.fc_id_2048_1 = nn.Linear(self.feats_2048, num_classes) self.fc_id_2048_2 = nn.Linear(self.feats_2048, num_classes) self.fc_id_256_1_0 = nn.Linear(self.feats_256, num_classes) self.fc_id_256_1_1 = nn.Linear(self.feats_256, num_classes) self.fc_id_256_2_0 = nn.Linear(self.feats_256, num_classes) self.fc_id_256_2_1 = nn.Linear(self.feats_256, num_classes) self.fc_id_256_2_2 = nn.Linear(self.feats_256, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
def __init__(self, num_classes, args): super(MGN, self).__init__() self.args = args resnet = resnet50(pretrained=False) res_path = os.path.dirname( os.path.realpath(__file__)) + '/resnet50-19c8e357.pth' resnet.load_state_dict(torch.load(res_path)) # backbone self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, # res_conv2 resnet.layer2, # res_conv3 resnet.layer3[0] # res_conv4_1 ) # res_conv4x res_conv4 = nn.Sequential(*resnet.layer3[1:]) # res_conv5 global res_g_conv5 = resnet.layer4 # res_conv5 part res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) # mgn part-1 global self.p1 = nn.Sequential( copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5 if args.head_1part_stride == 2 else res_p_conv5)) # mgn part-2 self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # mgn part-3 self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # global max pooling self.maxpool_zg_p1 = nn.MaxPool2d( kernel_size=(12, 4) if args.head_1part_stride == 2 else (24, 8)) self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8)) add_part_2048 = nn.Sequential(nn.BatchNorm1d(2048), nn.ReLU()) self._init_add_part(add_part_2048) self.add_part_1 = copy.deepcopy(add_part_2048) self.add_part_2 = copy.deepcopy(add_part_2048) self.add_part_3 = copy.deepcopy(add_part_2048) reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # fc softmax loss self.fc_id_2048_0_tmp = nn.Linear(2048, 2048) self.fc_id_2048_1_tmp = nn.Linear(2048, 2048) self.fc_id_2048_2_tmp = nn.Linear(2048, 2048) self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_1 = nn.Linear(2048, num_classes) self.fc_id_2048_2 = nn.Linear(2048, num_classes) self.fc_id_256_1_0 = nn.Linear(256, num_classes) self.fc_id_256_1_1 = nn.Linear(256, num_classes) self.fc_id_256_2_0 = nn.Linear(256, num_classes) self.fc_id_256_2_1 = nn.Linear(256, num_classes) self.fc_id_256_2_2 = nn.Linear(256, num_classes) self._init_fc(self.fc_id_2048_0_tmp) self._init_fc(self.fc_id_2048_1_tmp) self._init_fc(self.fc_id_2048_2_tmp) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2) embedding = nn.Sequential(nn.Linear(256, 256)) self.embedding_1 = copy.deepcopy(embedding) self.embedding_2 = copy.deepcopy(embedding) self.embedding_3 = copy.deepcopy(embedding) self._init_embedding(self.embedding_1) self._init_embedding(self.embedding_2) self._init_embedding(self.embedding_3) if args.src_ps_lw > 0 or args.cd_ps_lw > 0: ps_head_cls = PartSegHead self.ps_head = ps_head_cls({ 'in_c': 2048, 'mid_c': 256, 'num_classes': 8 }) print('Model Structure:') print(self)
def __init__(self): super(MGN, self).__init__() num_classes = 751 feats = 256 resnet = resnet50(pretrained=True) self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, ) self.layer1 = resnet.layer1 self.layer2 = resnet.layer2 self.layer3 = resnet.layer3[0] self.avgpool1 = nn.AvgPool2d(kernel_size=(96, 32)) self.avgpool2 = nn.AvgPool2d(kernel_size=(48, 16)) self.avgpool3 = nn.AvgPool2d(kernel_size=(24, 8)) self.layer1_fc = nn.Sequential( nn.Linear(256, 256), nn.BatchNorm1d(256), nn.ReLU(inplace=True), nn.Dropout(p=0), nn.Linear(256, 256), ) self.layer2_fc = nn.Sequential( nn.Linear(512, 256), nn.BatchNorm1d(256), nn.ReLU(inplace=True), nn.Dropout(p=0), nn.Linear(256, 256), ) self.layer3_fc = nn.Sequential( nn.Linear(1024, 512), nn.BatchNorm1d(512), nn.ReLU(inplace=True), nn.Dropout(p=0), nn.Linear(512, 256), ) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8)) self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8)) self.reduction = nn.Sequential(nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats), nn.ReLU()) self._init_reduction(self.reduction) self.fc_id_2048_0 = nn.Linear(feats, num_classes) self.fc_id_2048_1 = nn.Linear(feats, num_classes) self.fc_id_2048_2 = nn.Linear(feats, num_classes) self.fc_id_256_1_0 = nn.Linear(feats, num_classes) self.fc_id_256_1_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_0 = nn.Linear(feats, num_classes) self.fc_id_256_2_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_2 = nn.Linear(feats, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2) self.fusion_conv = nn.Conv1d(3, 1, kernel_size=1, bias=False) self.attention = CALayer(2048) self.attention_pixel1 = PALayer(96, 32) self.attention_pixel2 = PALayer(48, 16) self.attention_pixel3 = PALayer(24, 8)
def __init__(self, args): super(MGN, self).__init__() num_classes = args.num_classes print num_classes resnet = resnet50(pretrained=True) self.backone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, ) self.layer2 = resnet.layer2 self.layer3_0 = resnet.layer3[0] self.layer3_1 = resnet.layer3[1:] self.layer4 = resnet.layer4 # Spatial Attention Part self.attention1 = AttentionLayer(256, 16) self.attention2 = AttentionLayer(512, 32) # self.attention3 = AttentionLayer(1024,64) res_conv4 = nn.Sequential(self.layer3_1) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) # mgn part-1 global self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) # mgn part-2 self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # mgn part-3 self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) if args.pool == 'max': pool2d = nn.MaxPool2d elif args.pool == 'avg': pool2d = nn.AvgPool2d else: raise Exception() # max pooling self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8)) self.maxpool_zp2 = pool2d(kernel_size=(12, 8)) self.maxpool_zp3 = pool2d(kernel_size=(8, 8)) # conv1 reduce reduction = nn.Sequential(nn.Conv2d(2048, args.feats, 1, bias=False), nn.BatchNorm2d(args.feats), nn.PReLU(256, 0.25)) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # fc softmax loss #self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_0 = nn.Linear(args.feats, num_classes) self.fc_id_2048_1 = nn.Linear(args.feats, num_classes) self.fc_id_2048_2 = nn.Linear(args.feats, num_classes) self.fc_id_256_1_0 = nn.Linear(args.feats, num_classes) self.fc_id_256_1_1 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_0 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_1 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_2 = nn.Linear(args.feats, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
def __init__(self, in_channels, out_channels): super(BottleneckRCU, self).__init__() self.block = Bottleneck(in_channels, out_channels)
def __init__(self, num_classes): super(MGN, self).__init__() resnet = resnet50(pretrained=True) # backbone self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, # res_conv2 resnet.layer2, # res_conv3 resnet.layer3[0], # res_conv4_1 ) # 3. Multiple Granularity Network 3.1. Network Architecture: The difference is that we employ no down-sampling # operations in res_conv5_1 block. # res_conv4x res_conv4 = nn.Sequential(*resnet.layer3[1:]) # res_conv5 global res_g_conv5 = resnet.layer4 # res_conv5 part res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) # mgn part-1 global self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) # mgn part-2 self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # mgn part-3 self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # global max pooling self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8)) self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8)) # Figure 3: Notice that the 1 × 1 convolutions for dimension reduction and fully connected layers for identity # prediction in each branch DO NOT share weights with each other. # 4. Experiment 4.1 Implementation: Notice that different branches in the network are all initialized with the # same pretrained weights of the corresponding layers after the res conv4 1 block. # conv1 reduce reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # fc softmax loss self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_1 = nn.Linear(2048, num_classes) self.fc_id_2048_2 = nn.Linear(2048, num_classes) self.fc_id_256_1_0 = nn.Linear(256, num_classes) self.fc_id_256_1_1 = nn.Linear(256, num_classes) self.fc_id_256_2_0 = nn.Linear(256, num_classes) self.fc_id_256_2_1 = nn.Linear(256, num_classes) self.fc_id_256_2_2 = nn.Linear(256, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
def __init__(self, num_classes, width_ratio=0.5, height_ratio=0.5): super(BFE, self).__init__() # resnet = resnet50() # resnet.load_state_dict(torch.load('./resnet50-19c8e357.pth')) # print("load ResNet50 parameters") print("load ResNeSt50 and ResNet50 parameters") model = resnet50() resnet = resnest50() model.load_state_dict(torch.load('../resnet50-19c8e357.pth')) resnet.load_state_dict(torch.load('../resnest50-528c19ca.pth')) self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, CAM_Module(256), resnet.layer2, CAM_Module(512), ) self.res_part_head = nn.Sequential(resnet.layer3, CAM_Module(1024)) self.res_part = nn.Sequential( Bottleneck(1024, 512, stride=1, downsample=nn.Sequential( nn.Conv2d(1024, 2048, kernel_size=1, stride=1, bias=False), nn.BatchNorm2d(2048), )), Bottleneck(2048, 512), Bottleneck(2048, 512), ) # self.res_part.load_state_dict(resnet.layer4.state_dict()) self.res_part.load_state_dict(model.layer4.state_dict()) self.c4 = CAM_Module(2048) self.part_pool = nn.AdaptiveMaxPool2d((1, 1)) # self.part_pool = nn.AdaptiveAvgPool2d((1, 1)) self.res_part2 = Bottleneck(2048, 512) self.batch_crop = BatchDrop(height_ratio, width_ratio) self.reduction = nn.Sequential(nn.Linear(2048, 1024, 1), nn.BatchNorm1d(1024), nn.ReLU()) self.reduction.apply(weights_init_kaiming) self.softmax = nn.Linear(1024, num_classes) self.softmax.apply(weights_init_kaiming) # Auxiliary branch ab_vector_size = 256 reduction = nn.Sequential(nn.Conv2d(2048, ab_vector_size, 1), nn.BatchNorm2d(ab_vector_size), nn.ReLU(inplace=True)) self.auxiliary_avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.auxiliary_softmax = nn.Linear(ab_vector_size, num_classes) self.auxiliary_softmax.apply(weights_init_kaiming) self.auxiliary_reduction = copy.deepcopy(reduction) self.auxiliary_reduction.apply(weights_init_kaiming)
def __init__(self, args): super(Base, self).__init__() num_classes = args.num_classes feats = args.feats resnet = resnet50(pretrained=True) # 定义主干网络 self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # 池化层 if args.pool == 'max': pool2d = nn.MaxPool2d elif args.pool == 'avg': pool2d = nn.AvgPool2d else: raise Exception() self.pool_zp = pool2d(kernel_size=(4, 8)) # 1x1卷积层,降维 reduction = nn.Sequential(nn.Conv2d(2048, args.feats, 1, bias=False), nn.BatchNorm2d(args.feats), nn.ReLU()) self._init_reduction(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) # 全连接层 self.fc_1 = nn.Linear(feats, num_classes) self.fc_2 = nn.Linear(feats, num_classes) self.fc_3 = nn.Linear(feats, num_classes) self.fc_4 = nn.Linear(feats, num_classes) self.fc_5 = nn.Linear(feats, num_classes) self.fc_6 = nn.Linear(feats, num_classes) self._init_fc(self.fc_1) self._init_fc(self.fc_2) self._init_fc(self.fc_3) self._init_fc(self.fc_4) self._init_fc(self.fc_5) self._init_fc(self.fc_6)
def __init__(self, args): super(LMBN_r, self).__init__() self.n_ch = 2 self.chs = 2048 // self.n_ch # resnet = resnet50_ibn_a(last_stride=1, pretrained=True) resnet = resnet50(pretrained=True) self.backone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) conv3 = nn.Sequential(*resnet.layer3[1:]) no_downsample_conv4 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) no_downsample_conv4.load_state_dict(resnet.layer4.state_dict()) self.global_branch = nn.Sequential(copy.deepcopy(conv3), copy.deepcopy(resnet.layer4)) self.partial_branch = nn.Sequential(copy.deepcopy(conv3), copy.deepcopy(no_downsample_conv4)) self.channel_branch = nn.Sequential(copy.deepcopy(conv3), copy.deepcopy(no_downsample_conv4)) self.global_pooling = nn.AdaptiveMaxPool2d((1, 1)) self.partial_pooling = nn.AdaptiveAvgPool2d((2, 1)) self.channel_pooling = nn.AdaptiveMaxPool2d((1, 1)) self.avg_pooling = nn.AdaptiveAvgPool2d((1, 1)) reduction = BNNeck3(2048, args.num_classes, args.feats, return_f=True) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_drop = copy.deepcopy(reduction) self.shared = nn.Sequential( nn.Conv2d(self.chs, args.feats, 1, bias=False), nn.BatchNorm2d(args.feats), nn.ReLU(True)) self.weights_init_kaiming(self.shared) self.reduction_ch_0 = BNNeck(args.feats, args.num_classes, return_f=True) self.reduction_ch_1 = BNNeck(args.feats, args.num_classes, return_f=True) # if args.drop_block: # print('Using batch random erasing block.') # self.batch_drop_block = BatchRandomErasing() self.batch_drop_block = BatchFeatureErase_Top(2048, Bottleneck) self.activation_map = args.activation_map
def __init__(self, num_classes): super(Spark_CN, self).__init__() resnet = resnet50(pretrained=True) #modify the first conv #resnet.conv1 = nn.Conv2d(4, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.CGBlock1 = ContextGuidedBlock(2048, 2048, dilation_rate=1, reduction=16, add=True) self.CGBlock2 = ContextGuidedBlock(2048, 2048, dilation_rate=2, reduction=16, add=True) self.CGBlock3 = ContextGuidedBlock(2048, 2048, dilation_rate=3, reduction=16, add=True) self.PB_g1 = PoolBlock(size=1) self.PB_g2 = PoolBlock(size=1) self.PB_g3 = PoolBlock(size=1) self.PB2 = PoolBlock(size=2) #self.PB3 = PoolBlock(size=3) self.p1_1 = ReductionFc(2048, 256, num_classes) # self.p2_1 = ReductionFc(2048, 256, num_classes) self.p2_2 = ReductionFc(2048, 256, num_classes) self.p2_3 = ReductionFc(2048, 256, num_classes) self.p2_4 = ReductionFc(2048, 256, num_classes) self.p2_g = ReductionFc(2048, 256, num_classes) # self.p3_1 = ReductionFc(638, 256, num_classes) self.p3_2 = ReductionFc(638, 256, num_classes) self.p3_3 = ReductionFc(638, 256, num_classes) self.p3_4 = ReductionFc(638, 256, num_classes) self.p3_g = ReductionFc(2048, 256, num_classes) #
def __init__(self, num_classes, pool='avg', feats=256): """ :param num_classes: 数据集的类别数目 :param pool: 使用什么池化方式 :param feats: 输出的特征维度 """ super(MGN, self).__init__() num_classes = num_classes resnet = resnet50(pretrained=True) self.backone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) if pool == 'max': pool2d = nn.MaxPool2d elif pool == 'avg': pool2d = nn.AvgPool2d else: raise Exception() self.maxpool_zg_p1 = pool2d(kernel_size=(8, 4)) self.maxpool_zg_p2 = pool2d(kernel_size=(16, 8)) self.maxpool_zg_p3 = pool2d(kernel_size=(16, 8)) self.maxpool_zp2 = pool2d(kernel_size=(8, 8)) self.maxpool_zp3 = pool2d(kernel_size=(5, 8)) reduction = nn.Sequential(nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_0 = nn.Linear(feats, num_classes) self.fc_id_2048_1 = nn.Linear(feats, num_classes) self.fc_id_2048_2 = nn.Linear(feats, num_classes) self.fc_id_256_1_0 = nn.Linear(feats, num_classes) self.fc_id_256_1_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_0 = nn.Linear(feats, num_classes) self.fc_id_256_2_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_2 = nn.Linear(feats, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
class BFE(nn.Module): def __init__(self, num_classes, width_ratio=0.5, height_ratio=0.5): super(BFE, self).__init__() resnet = resnet50(pretrained=True) self.backbone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, # res_conv2 resnet.layer2, # res_conv3 resnet.layer3, # res_conv4 ) self.res_part = nn.Sequential( Bottleneck(1024, 512, stride=1, downsample=nn.Sequential( nn.Conv2d(1024, 2048, kernel_size=1, stride=1, bias=False), nn.BatchNorm2d(2048), )), Bottleneck(2048, 512), Bottleneck(2048, 512), ) self.res_part.load_state_dict(resnet.layer4.state_dict()) reduction = nn.Sequential(nn.Conv2d(2048, 512, 1), nn.BatchNorm2d(512), nn.ReLU()) # global branch self.global_avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.global_softmax = nn.Linear(512, num_classes) self.global_softmax.apply(weights_init_kaiming) self.global_reduction = copy.deepcopy(reduction) self.global_reduction.apply(weights_init_kaiming) # part branch self.res_part2 = Bottleneck(2048, 512) self.part_maxpool = nn.AdaptiveMaxPool2d((1, 1)) self.batch_crop = BatchDrop(height_ratio, width_ratio) self.reduction = nn.Sequential(nn.Linear(2048, 1024, 1), nn.BatchNorm1d(1024), nn.ReLU()) self.reduction.apply(weights_init_kaiming) self.softmax = nn.Linear(1024, num_classes) self.softmax.apply(weights_init_kaiming) def forward(self, x): """ :param x: input image tensor of (N, C, H, W) :return: (prediction, triplet_losses, softmax_losses) """ x = self.backbone(x) x = self.res_part(x) predict = [] triplet_features = [] softmax_features = [] #global branch glob = self.global_avgpool(x) global_triplet_feature = self.global_reduction(glob).squeeze() global_softmax_class = self.global_softmax(global_triplet_feature) softmax_features.append(global_softmax_class) triplet_features.append(global_triplet_feature) predict.append(global_triplet_feature) #part branch x = self.res_part2(x) x = self.batch_crop(x) triplet_feature = self.part_maxpool(x).squeeze() feature = self.reduction(triplet_feature) softmax_feature = self.softmax(feature) triplet_features.append(feature) softmax_features.append(softmax_feature) predict.append(feature) if self.training: return triplet_features, softmax_features else: return torch.cat(predict, 1) def get_optim_policy(self): params = [ { 'params': self.backbone.parameters() }, { 'params': self.res_part.parameters() }, { 'params': self.global_reduction.parameters() }, { 'params': self.global_softmax.parameters() }, { 'params': self.res_part2.parameters() }, { 'params': self.reduction.parameters() }, { 'params': self.softmax.parameters() }, ] return params
def __init__(self, args): super(MGN, self).__init__() num_classes = args.num_classes resnet = resnet50(pretrained=True) self.backone1 = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, ) self.backone2 = nn.Sequential( resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) # CBAM self.inplanes_1 = 64 self.channel_attention = ChannelAttention(self.inplanes_1) self.spatial_attention = SpatialAttention() res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) if args.pool == 'max': pool2d = nn.MaxPool2d elif args.pool == 'avg': pool2d = nn.AvgPool2d else: raise Exception() self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8)) self.maxpool_zp2 = pool2d(kernel_size=(12, 8)) self.maxpool_zp3 = pool2d(kernel_size=(8, 8)) reduction = nn.Sequential(nn.Conv2d(2048, args.feats, 1, bias=False), nn.BatchNorm2d(args.feats), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_0 = nn.Linear(args.feats, num_classes) self.fc_id_2048_1 = nn.Linear(args.feats, num_classes) self.fc_id_2048_2 = nn.Linear(args.feats, num_classes) self.fc_id_256_1_0 = nn.Linear(args.feats, num_classes) self.fc_id_256_1_1 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_0 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_1 = nn.Linear(args.feats, num_classes) self.fc_id_256_2_2 = nn.Linear(args.feats, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
def __init__(self): super(MGN, self).__init__() num_classes = 739 num_feats = 256 resnet = resnet50(pretrained=True) self.backone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3[0], ) self.ha1 = HarmAttn(1024) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) #if args.pool == 'max': #pool2d = nn.MaxPool2d #elif args.pool == 'avg': pool2d = nn.AvgPool2d #else: # raise Exception() self.maxpool_zg_p1 = pool2d(kernel_size=(24, 8)) self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8)) self.maxpool_zp2 = pool2d(kernel_size=(12, 8)) self.maxpool_zp3 = pool2d(kernel_size=(8, 8)) reduction = nn.Sequential(nn.Conv2d(2048, num_feats, 1, bias=False), nn.BatchNorm2d(num_feats), nn.ReLU()) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) #self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_0 = nn.Linear(num_feats, num_classes) self.fc_id_2048_1 = nn.Linear(num_feats, num_classes) self.fc_id_2048_2 = nn.Linear(num_feats, num_classes) self.fc_id_256_1_0 = nn.Linear(num_feats, num_classes) self.fc_id_256_1_1 = nn.Linear(num_feats, num_classes) self.fc_id_256_2_0 = nn.Linear(num_feats, num_classes) self.fc_id_256_2_1 = nn.Linear(num_feats, num_classes) self.fc_id_256_2_2 = nn.Linear(num_feats, num_classes) self.fc_g = nn.Linear(num_feats * 8, num_classes) self.fc_id_2048_0_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self.fc_id_2048_1_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self.fc_id_2048_2_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self.fc_id_256_1_0_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self.fc_id_256_1_1_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self.fc_id_256_2_0_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self.fc_id_256_2_1_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self.fc_id_256_2_2_w = nn.Sequential(nn.Linear(num_feats, 1), nn.Sigmoid()) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2) self._init_fc(self.fc_g) """
def __init__(self, num_classes, width_ratio=0.5, height_ratio=0.5): super(BFE, self).__init__() resnet = resnet50(pretrained=True) resnet.fc = nn.Sequential() self.model = resnet self.model.layer4[0].downsample[0].stride = (1, 1) self.model.layer4[0].conv2.stride = (1, 1) # layer3 branch self.bottleneck1 = Bottleneck(1024, 256) self.PBN1 = PBN(1024, num_classes, do_reduction=True, num_reduction=256) # global branch self.PBN2 = PBN(2048, num_classes, do_reduction=True, num_reduction=256) # 到这来 # # part1 branch # self.bottleneck2 = Bottleneck(2048, 512) # self.PBN3 = PBN_modify(2048, num_classes, do_reduction=True, num_reduction=256) # # part2 branch # self.bottleneck3 = Bottleneck(2048, 512) # self.PBN4 = PBN_modify(2048, num_classes, do_reduction=True, num_reduction=256) # part1 branch self.bottleneck2 = Bottleneck(2048, 512) self.bt1 = Bottleneck(2048, 512) self.bt2 = Bottleneck(2048, 512) self.bt3 = Bottleneck(2048, 512) self.PBN_l1 = PBN(2048, num_classes, do_reduction=True, num_reduction=256) self.PBN_l2 = PBN(2048, num_classes, do_reduction=True, num_reduction=256) self.PBN_l3 = PBN(2048, num_classes, do_reduction=True, num_reduction=256) # part2 branch self.bottleneck3 = Bottleneck(2048, 512) self.bt4 = Bottleneck(2048, 512) self.bt5 = Bottleneck(2048, 512) self.bt6 = Bottleneck(2048, 512) self.PBN_l4 = PBN(2048, num_classes, do_reduction=True, num_reduction=256) self.PBN_l5 = PBN(2048, num_classes, do_reduction=True, num_reduction=256) self.PBN_l6 = PBN(2048, num_classes, do_reduction=True, num_reduction=256)
def __init__( self, in_channels, out_channels=1024, aspect_ratios=[[1]], scales=[1], parent=None, index=0, ): super().__init__() self.num_classes = cfg.num_classes self.mask_dim = cfg.mask_dim # Defined by Yolact self.num_priors = sum(len(x) for x in aspect_ratios) self.parent = [parent] # Don't include this in the state dict self.index = index self.num_heads = cfg.num_heads # Defined by Yolact if (cfg.mask_proto_split_prototypes_by_head and cfg.mask_type == mask_type.lincomb): self.mask_dim = self.mask_dim // self.num_heads if cfg.mask_proto_prototypes_as_features: in_channels += self.mask_dim if parent is None: if cfg.extra_head_net is None: out_channels = in_channels else: self.upfeature, out_channels = make_net( in_channels, cfg.extra_head_net) if cfg.use_prediction_module: self.block = Bottleneck(out_channels, out_channels // 4) self.conv = nn.Conv2d(out_channels, out_channels, kernel_size=1, bias=True) self.bn = nn.BatchNorm2d(out_channels) self.bbox_layer = nn.Conv2d(out_channels, self.num_priors * 4, **cfg.head_layer_params) self.conf_layer = nn.Conv2d(out_channels, self.num_priors * self.num_classes, **cfg.head_layer_params) self.mask_layer = nn.Conv2d(out_channels, self.num_priors * self.mask_dim, **cfg.head_layer_params) if cfg.use_mask_scoring: self.score_layer = nn.Conv2d(out_channels, self.num_priors, **cfg.head_layer_params) if cfg.use_instance_coeff: self.inst_layer = nn.Conv2d( out_channels, self.num_priors * cfg.num_instance_coeffs, **cfg.head_layer_params) def make_extra(num_layers): if num_layers == 0: return lambda x: x else: return nn.Sequential(*sum( [[ nn.Conv2d( out_channels, out_channels, kernel_size=3, padding=1, ), nn.ReLU(inplace=True), ] for _ in range(num_layers)], [], )) self.bbox_extra, self.conf_extra, self.mask_extra = [ make_extra(x) for x in cfg.extra_layers ] if (cfg.mask_type == mask_type.lincomb and cfg.mask_proto_coeff_gate): self.gate_layer = nn.Conv2d( out_channels, self.num_priors * self.mask_dim, kernel_size=3, padding=1, ) self.aspect_ratios = aspect_ratios self.scales = scales self.priors = None self.last_conv_size = None self.last_img_size = None
def __init__(self): super(MGN, self).__init__() #num_classes = 751 #num_classes = 4101 num_classes = opt.cls_num feats = 256 if opt.backbone == 'resnet50': resnet = resnet50(pretrained=True) elif opt.backbone == 'resnet101': resnet = resnet101(pretrained=True) self.backbone1 = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, ) self.backbone2 = resnet.layer2 self.backbone3 = resnet.layer3[0] res_conv4 = nn.Sequential(*resnet.layer3[1:]) #res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential(nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) self.attc0 = ATTC(in_channels=256, out_channels=512) self.atts0 = ATTS(in_channels=256, h=48, w=16) self.attc1 = ATTC(in_channels=1024, out_channels=2048) self.atts1 = ATTS(in_channels=1024, h=24, w=8) self.attc2 = ATTC(in_channels=1024, out_channels=2048) self.atts2 = ATTS(in_channels=1024, h=24, w=8) self.attc3 = ATTC(in_channels=1024, out_channels=2048) self.atts3 = ATTS(in_channels=1024, h=24, w=8) self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8)) self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8)) self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8)) self.reduction = nn.Sequential(nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats), nn.ReLU()) self._init_reduction(self.reduction) self.fc_id_2048_0 = nn.Linear(feats, num_classes) self.fc_id_2048_1 = nn.Linear(feats, num_classes) self.fc_id_2048_2 = nn.Linear(feats, num_classes) self.fc_id_256_1_0 = nn.Linear(feats, num_classes) self.fc_id_256_1_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_0 = nn.Linear(feats, num_classes) self.fc_id_256_2_1 = nn.Linear(feats, num_classes) self.fc_id_256_2_2 = nn.Linear(feats, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)
def __init__(self): super(MGN, self).__init__() num_classes = 751 resnet = resnet50(pretrained=False) self.backone = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, # res_conv2 resnet.layer2, # res_conv3 resnet.layer3[0], # res_conv4_1 ) res_conv4 = nn.Sequential(*resnet.layer3[1:]) res_g_conv5 = resnet.layer4 res_p_conv5 = nn.Sequential( Bottleneck(1024, 512, downsample=nn.Sequential( nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))), Bottleneck(2048, 512), Bottleneck(2048, 512)) res_p_conv5.load_state_dict(resnet.layer4.state_dict()) # mgn part-1 global self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5)) # mgn part-2 self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # mgn part-3 self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5)) # pooling self.maxpool_zg_p1 = nn.AvgPool2d(kernel_size=(12, 4)) self.maxpool_zg_p2 = nn.AvgPool2d(kernel_size=(24, 8)) self.maxpool_zg_p3 = nn.AvgPool2d(kernel_size=(24, 8)) self.maxpool_zp2 = nn.AvgPool2d(kernel_size=(12, 8)) self.maxpool_zp3 = nn.AvgPool2d(kernel_size=(8, 8)) # conv1 reduce reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False), nn.BatchNorm2d(256), nn.PReLU(256, 0.25)) self._init_reduction(reduction) self.reduction_0 = copy.deepcopy(reduction) self.reduction_1 = copy.deepcopy(reduction) self.reduction_2 = copy.deepcopy(reduction) self.reduction_3 = copy.deepcopy(reduction) self.reduction_4 = copy.deepcopy(reduction) self.reduction_5 = copy.deepcopy(reduction) self.reduction_6 = copy.deepcopy(reduction) self.reduction_7 = copy.deepcopy(reduction) # fc softmax loss # self.fc_id_2048_0 = nn.Linear(2048, num_classes) self.fc_id_2048_0 = nn.Linear(256, num_classes) self.fc_id_2048_1 = nn.Linear(256, num_classes) self.fc_id_2048_2 = nn.Linear(256, num_classes) self.fc_id_256_1_0 = nn.Linear(256, num_classes) self.fc_id_256_1_1 = nn.Linear(256, num_classes) self.fc_id_256_2_0 = nn.Linear(256, num_classes) self.fc_id_256_2_1 = nn.Linear(256, num_classes) self.fc_id_256_2_2 = nn.Linear(256, num_classes) self._init_fc(self.fc_id_2048_0) self._init_fc(self.fc_id_2048_1) self._init_fc(self.fc_id_2048_2) self._init_fc(self.fc_id_256_1_0) self._init_fc(self.fc_id_256_1_1) self._init_fc(self.fc_id_256_2_0) self._init_fc(self.fc_id_256_2_1) self._init_fc(self.fc_id_256_2_2)