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)
