def init_tile_modules():
self.avgpool_tile = nn.AdaptiveAvgPool2d((1, 1))
self.maxpool_tile = nn.AdaptiveMaxPool2d((1, 1))
self.fc_tile = nn.Sequential(
nn.Flatten(),
nn.Linear(self.lastconv_output_channels, num_classes))
def rn18_l4_1a_maxpool_nc_1k():
model = rn18_l4_1a_nc_1k_scratch()
model.classifier = nn.Sequential(nn.AdaptiveMaxPool2d((1, 1)),
nn.Flatten())
return model
def __init__(self, config):
super(SiameseNetwork, self).__init__()
self.config = config
if self.config.use_resnet:
self.pretrained_model = get_pretrained_model(False, pretrain_kind='vggface2', model_name='resnet50')
else:
self.pretrained_model = get_pretrained_model(False, pretrain_kind='vggface2', model_name='senet50')
if self.config.use_bilinear:
self.bi_conv = nn.Conv2d(2048, 512, 1)
self.bi_bn = nn.BatchNorm2d(512)
self.bi_rule = nn.ReLU(0.1)
self.bilinear = nn.Bilinear(512, 512, 1024)
if self.config.use_spatial_attention:
self.conv_sw1 = nn.Conv2d(512, 50, 1)
self.sw1_bn = nn.BatchNorm2d(50)
self.sw1_activation = nn.ReLU()
self.conv_sw2 = nn.Conv2d(50, 1, 1)
self.sw2_activation = nn.Softplus()
if self.config.use_se:
self.selayer = SELayer(512)
self.ll1 = nn.Linear(1024, 50)
self.relu = nn.ReLU()
self.sigmod = nn.Sigmoid()
self.dropout1 = nn.Dropout(self.config.drop_out_rate)
self.dropout2 = nn.Dropout(self.config.drop_out_rate)
self.ll2 = nn.Linear(50, 1)
else:
if self.config.use_spatial_attention:
self.conv_sw1 = nn.Conv2d(2048, 50, 1)
self.sw1_bn = nn.BatchNorm2d(50)
self.sw1_activation = nn.ReLU()
self.conv_sw2 = nn.Conv2d(50, 1, 1)
self.sw2_activation = nn.Softplus()
if self.config.use_se:
self.selayer = SELayer(2048)
self.ll1 = nn.Linear(4096, 100)
# self.ll3 = nn.Linear(512, 64)
self.relu = nn.ReLU()
self.sigmod = nn.Sigmoid()
self.dropout = nn.Dropout(self.config.drop_out_rate)
if config.loss == 'binary':
self.ll2 = nn.Linear(100, 1)
elif config.loss == 'a-softmax':
self.ll2 = CusAngleLinear(100, 2, m=config.a_softmax_m)
elif config.loss == 'am-softmax':
self.ll2 = Am_softmax(100, 2)
elif config.loss == 'arcface':
self.ll2 = Arcface(100, 2)
if self.config.pooling_method == 'avg':
self.pool = nn.AdaptiveAvgPool2d(1)
elif self.config.pooling_method == 'max':
self.pool = nn.AdaptiveMaxPool2d(1)
elif self.config.pooling_method == 'rmac':
self.pool = rmac
elif self.config.pooling_method == 'gem':
self.pool = gem
self.maxpool = nn.AdaptiveMaxPool2d(1)
if self.config.use_stack:
self.reduce_conv1 = nn.Conv2d(4096, 4096, 3)
self.reduce_conv2 = nn.Conv2d(4096, 4096, 3)
self.reduce_conv3 = nn.Conv2d(4096, 4096, 3)
def __init__(self):
super(node_att, self).__init__()
self.maxpool = nn.AdaptiveMaxPool2d(1)
def __init__(self, num_classes, last_stride, data_set, width_ratio=1.0, height_ratio=0.33):
super(Baseline, self).__init__()
self.mix_conv = nn.Sequential(nn.Conv2d(2048, 1024, kernel_size=1, stride=1, bias=False))
self.preact = SEResnet('resnet101')
self.pose_se = SELayer(1024)
self.global_se = SELayer(1024)
self.layer_lis = [[3, 4, 6, 3], [3, 4, 23, 3]]
self.base = ResNet(self.layer_lis[1], last_stride)
self.data = data_set
res = models.resnet101(pretrained=True)
model_dict = self.base.state_dict()
res_pretrained_dict = res.state_dict()
res_pretrained_dict = {k: v for k, v in res_pretrained_dict.items() if k in model_dict}
model_dict.update(res_pretrained_dict)
self.base.load_state_dict(model_dict)
self.layer4 = 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.layer4.load_state_dict(res.layer4.state_dict())
self.bfe_layer4 = 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.bfe_layer4.load_state_dict(res.layer4.state_dict())
self.batch_erase = BatchDrop(height_ratio, width_ratio)
self.bfe_gap = nn.AdaptiveAvgPool2d(1)
self.pose_gap = nn.AdaptiveMaxPool2d(1)
self.lead_gap = nn.AdaptiveMaxPool2d(1)
self.lead_avg_gap = nn.AdaptiveAvgPool2d(1)
self.num_classes = num_classes
self.bottleneck = nn.BatchNorm1d(self.in_planes)
self.bottleneck.bias.requires_grad_(False)
self.classifier = nn.Linear(self.in_planes, self.num_classes, bias=False)
self.lead_bottleneck = nn.BatchNorm1d(2048)
self.lead_bottleneck.bias.requires_grad_(False)
self.lead_classifier = nn.Linear(2048, self.num_classes, bias=False)
self.part1_bottleneck = nn.BatchNorm1d(self.in_planes)
self.part1_bottleneck.bias.requires_grad_(False)
self.part1_classifier = nn.Linear(self.in_planes, self.num_classes, bias=False)
self.bottleneck.apply(weights_init_kaiming)
self.classifier.apply(weights_init_classifier)
self.lead_bottleneck.apply(weights_init_kaiming)
self.lead_classifier.apply(weights_init_classifier)
self.mix_conv.apply(weights_init_kaiming)
self.part1_bottleneck.apply(weights_init_kaiming)
self.part1_classifier.apply(weights_init_classifier)
def __init__(self, size=None):
super().__init__()
self._size = size or (1, 1)
self.ap = nn.AdaptiveAvgPool2d(self._size)
self.mp = nn.AdaptiveMaxPool2d(self._size)
def __init__(self, sz: Optional[int] = None):
"Output will be 2*sz or 2 if sz is None"
super().__init__()
self.output_size = sz or 1
self.ap = nn.AdaptiveAvgPool2d(self.output_size)
self.mp = nn.AdaptiveMaxPool2d(self.output_size)
def __init__(self, model, feature_size, classes_num):
super(PMGI_V3_Extend, self).__init__()
self.features = model
self.maxpool = nn.AdaptiveMaxPool2d((1, 1))
self.num_ftrs = 2048 * 1 * 1
self.elu = nn.ELU(inplace=True)
self.classifier_concat = nn.Sequential(
nn.BatchNorm1d(1024 * 3),
nn.Linear(1024 * 3, feature_size),
nn.BatchNorm1d(feature_size),
nn.ELU(inplace=True),
nn.Linear(feature_size, classes_num),
)
self.conv_block1 = nn.Sequential(
BasicConv(self.num_ftrs // 4,
feature_size,
kernel_size=1,
stride=1,
padding=0,
relu=True),
BasicConv(feature_size,
self.num_ftrs // 2,
kernel_size=3,
stride=1,
padding=1,
relu=True))
self.classifier1 = nn.Sequential(
nn.BatchNorm1d(self.num_ftrs // 2),
nn.Linear(self.num_ftrs // 2, feature_size),
nn.BatchNorm1d(feature_size),
nn.ELU(inplace=True),
nn.Linear(feature_size, classes_num),
)
self.conv_block2 = nn.Sequential(
BasicConv(self.num_ftrs // 2,
feature_size,
kernel_size=1,
stride=1,
padding=0,
relu=True),
BasicConv(feature_size,
self.num_ftrs // 2,
kernel_size=3,
stride=1,
padding=1,
relu=True))
self.classifier2 = nn.Sequential(
nn.BatchNorm1d(self.num_ftrs // 2),
nn.Linear(self.num_ftrs // 2, feature_size),
nn.BatchNorm1d(feature_size),
nn.ELU(inplace=True),
nn.Linear(feature_size, classes_num),
)
self.conv_block3 = nn.Sequential(
BasicConv(self.num_ftrs,
feature_size,
kernel_size=1,
stride=1,
padding=0,
relu=True),
BasicConv(feature_size,
self.num_ftrs // 2,
kernel_size=3,
stride=1,
padding=1,
relu=True))
self.classifier3 = nn.Sequential(
nn.BatchNorm1d(self.num_ftrs // 2),
nn.Linear(self.num_ftrs // 2, feature_size),
nn.BatchNorm1d(feature_size),
nn.ELU(inplace=True),
nn.Linear(feature_size, classes_num),
)
self.map1 = nn.Linear((self.num_ftrs // 2) * 3, feature_size)
self.map2 = nn.Linear(feature_size, (self.num_ftrs // 2))
self.fc = nn.Linear((self.num_ftrs // 2) * 3, classes_num)
self.drop = nn.Dropout(p=0.5)
self.sigmoid = nn.Sigmoid()
def __init__(self,
num_classes,
basename,
last_stride,
with_ibn,
gcb,
stage_with_gcb,
with_abd,
feats=256,
**kwargs):
super(MGN, self).__init__()
if basename == 'resnet50':
self.base = ResNet.from_name('resnet50', last_stride, with_ibn,
gcb, stage_with_gcb, with_abd)
elif basename == 'resnet101':
self.base = ResNet.from_name('resnet101', last_stride, with_ibn,
gcb, stage_with_gcb, with_abd)
elif basename == 'resnext101':
self.base = resnext101_ibn_a(4, 32, last_stride, with_abd,
**kwargs)
else:
raise Exception("Unknown base ", basename)
#resnet = resnet50(pretrained=True)
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.res_p_conv5 = res_p_conv5
# deepcopy，不共享权重
self.p1 = nn.Sequential(res_conv4, 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.p1 = nn.Sequential(res_conv4, res_g_conv5)
#self.p2 = nn.Sequential(res_conv4,res_p_conv5)
#self.p3 = nn.Sequential(res_conv4, res_p_conv5)
# p1, p2, p3 size: bs x 2048 x 16 x 8
self.maxpool_zg_p1 = nn.AdaptiveMaxPool2d(
(1, 1)) #nn.MaxPool2d(kernel_size=(12, 4))
self.maxpool_zg_p2 = nn.AdaptiveMaxPool2d(
(1, 1)) #nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zg_p3 = nn.AdaptiveMaxPool2d(
(1, 1)) #nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zp2 = nn.AdaptiveMaxPool2d(
(2, 1)) #nn.MaxPool2d(kernel_size=(12, 8))
self.maxpool_zp3 = nn.AdaptiveMaxPool2d(
(3, 1)) #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)
if self.training:
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)
def get(config=None):
name = config.model.name
classes = config.classes
pred_type = config.model.params.pred_type
tune_type = config.model.params.tune_type
adjusted_classes = classes
if pred_type == 'REG':
adjusted_classes = 1
elif pred_type == 'MIX':
adjusted_classes = classes + 1
# ===========================================================================
# Model list
# ===========================================================================
if name == 'densenet161':
model = models.densenet161(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.classifier.in_features
model.classifier = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'densenet201':
model = models.densenet201(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.classifier.in_features
model.classifier = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'resnet50':
model = models.resnet50(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
# model.avgpool = GeM()
model.avgpool = nn.AdaptiveMaxPool2d(1)
num_ftrs = model.fc.in_features
model.fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'resnet101':
model = models.resnet101(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.fc.in_features
model.fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'resnet152':
model = models.resnet152(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.fc.in_features
model.fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'resnext50_32x4d':
model = models.resnext50_32x4d(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.fc.in_features
model.fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'resnext101_32x8d':
model = models.resnext101_32x8d(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.fc.in_features
model.fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'wide_resnet50_2':
model = models.wide_resnet50_2(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.fc.in_features
model.fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'wide_resnet101_2':
model = models.wide_resnet101_2(pretrained=True)
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.fc.in_features
model.fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'efficientnet-b0':
model = EfficientNet.from_pretrained('efficientnet-b0')
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model._fc.in_features
model._fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'efficientnet-b1':
model = EfficientNet.from_pretrained('efficientnet-b1')
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
model._avg_pooling = nn.AdaptiveMaxPool2d(1)
num_ftrs = model._fc.in_features
model._fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'efficientnet-b5':
model = EfficientNet.from_pretrained('efficientnet-b5')
if tune_type == 'FE':
for param in model.parameters():
param.requires_grad = False
num_ftrs = model._fc.in_features
model._fc = get_default_fc(num_ftrs, adjusted_classes,
config.model.params)
elif name == 'pann-cnn14-attn':
model = Pann_Cnn14_Attn(pretrained=True)
model.att_block = AttBlock(2048,
adjusted_classes,
activation='sigmoid')
else:
raise Exception("model not in list!")
print("[ Model : {} ]".format(name))
print("↳ [ Prediction type : {} ]".format(pred_type))
print("↳ [ Adjusted classes : {} ]".format(adjusted_classes))
if config.mode != "PRD":
print("↳ [ Tuning type : {} ]".format(tune_type))
return model
if init_type == 'pretrained':
model = models.resnet18(pretrained=True)
for param in model.parameters():
param.requires_grad = False
elif init_type == 'random': # with frozen conv. weights
model = models.resnet18(pretrained=False)
for param in model.parameters():
param.requires_grad = False
elif init_type == 'stratch':
model = models.resnet18(pretrained=False)
model.maxpool.kernel_size = 2
model.avgpool = nn.AdaptiveMaxPool2d(
1) # changing average pooling with max pooling
model.fc = nn.Linear(512, 2,
bias=True) # changing the number of classes as 2
elif arch_name == 'bagnet33':
import bagnets.pytorch
if init_type == 'pretrained':
model = bagnets.pytorch.bagnet33(pretrained=True)
for param in model.parameters():
param.requires_grad = False
elif init_type == 'random': # with frozen conv. weights
model = bagnets.pytorch.bagnet33(pretrained=False)
for param in model.parameters():
def __init__(self, sz=None):
super().__init__()
sz = sz or (1, 1)
self.ap = nn.AdaptiveAvgPool2d(sz)
self.mp = nn.AdaptiveMaxPool2d(sz)
def __init__(self,
cfg=None,
load_path=None,
depth=101,
vec_dim=128,
max_pool=False,
clf1_num=None,
clf2_num=None,
adv_eta=None):
super(ResNetbasedNet, self).__init__()
self.load = True if load_path is not None else False
self.clf1 = True if clf1_num is not None else False
self.clf2 = True if clf2_num is not None else False
self.adv_eta = Variable(
torch.tensor(adv_eta).type(torch.float),
requires_grad=False) if adv_eta is not None else None
if cfg is not None:
model = build_resnet_backbone(
cfg, ShapeSpec(channels=len(cfg.MODEL.PIXEL_MEAN)))
pretrained_model = torch.load(cfg.MODEL.WEIGHTS)
cur_state = model.state_dict()
mapped_dict = {}
for name, param in pretrained_model.items():
if name == 'model':
for p in param:
if p.replace('backbone.bottom_up.', '') in cur_state:
mapped_dict[p.replace('backbone.bottom_up.',
'')] = param[p]
model.load_state_dict(mapped_dict)
self.backbone = nn.Sequential(*list(model.children()))
else:
model = torch.hub.load('pytorch/vision:v0.6.0',
'resnet{}'.format(depth),
pretrained=not self.load)
self.backbone = nn.Sequential(*list(model.children())[:-2])
self.max_pool = nn.AdaptiveMaxPool2d(
(1, 1)) if max_pool else nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(2048, vec_dim)
if self.clf1:
self.clf1_layer = nn.Sequential(nn.Linear(vec_dim, vec_dim),
nn.BatchNorm1d(vec_dim), nn.ReLU(),
nn.Linear(vec_dim, clf1_num))
if self.clf2:
self.clf2_layer = nn.Sequential(nn.Linear(vec_dim, vec_dim),
nn.BatchNorm1d(vec_dim), nn.ReLU(),
nn.Linear(vec_dim, clf2_num))
if self.load:
load_model = torch.load(load_path)
mapped_dict = {
'backbone': (self.backbone, {}),
'fc': (self.fc, {})
}
if self.clf1:
mapped_dict['clf1_layer'] = (self.clf1_layer, {})
if self.clf2:
# print(self.clf2_layer.state_dict())
mapped_dict['clf2_layer'] = (self.clf2_layer, {})
for name, param in load_model.items():
if name.split('.')[0] in mapped_dict.keys():
mapped_dict[name.split('.')[0]][1]['.'.join(
name.split('.')[1:])] = param
for layers in mapped_dict.keys():
mapped_dict[layers][0].load_state_dict(mapped_dict[layers][1])
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.global_pool = nn.AdaptiveMaxPool2d((1, 1))
def __init__(
self,
train_features: int,
num_classes: int = 1,
zero_init_residual: bool = False,
groups: int = 1,
width_per_group: int = 64,
replace_stride_with_dilation: Optional[List[bool]] = None,
) -> None:
super(EKEResnet, self).__init__()
self.name = f'ResNet_{train_features}'
self.norm_layer = nn.BatchNorm2d
self.inplanes = 32
self.dilation = 1
if replace_stride_with_dilation is None:
# each element in the tuple indicates if we should replace
# the 2x2 stride with a dilated convolution instead
replace_stride_with_dilation = [False, False, False]
if len(replace_stride_with_dilation) != 3:
raise ValueError("replace_stride_with_dilation should be None "
"or a 3-element tuple, got {}"
.format(replace_stride_with_dilation))
self.groups = groups
self.base_width = width_per_group
self.train_features = train_features
self.transBlock1 = TransBlock(train_features, X_train_shape_1*2)
self.transBlock2 = TransBlock(X_train_shape_1*2,
2*2**next_pow2(11))
num_in_filters = 2**next_pow2(11)*2
self.transBlock3 = TransBlock(num_in_filters,
2*2**next_pow2(11))
block = BasicBlock
self.layer1 = self._make_layer(Bottleneck, 16, 1)
self.maxpool = nn.AdaptiveMaxPool2d((4, 4))
self.layer2 = self._make_layer(Bottleneck, 32, 1)
self.layer3 = self._make_layer(Bottleneck, 32, 1)
self.fc1 = nn.Linear(256*4*2, 32)
self.fc2 = nn.Linear(32, 8)
self.fc3 = nn.Linear(8, 1)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out',
nonlinearity='relu')
elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
# Zero-initialize the last BN in each residual branch,
# so that the residual branch starts with zeros,
# and each residual block behaves like an identity.
# This improves the model by 0.2~0.3% according
# to https://arxiv.org/abs/1706.02677
if zero_init_residual:
for m in self.modules():
if isinstance(m, Bottleneck):
nn.init.constant_(m.bn3.weight, 0) # type: ignore[arg-type] #noqa
elif isinstance(m, BasicBlock):
nn.init.constant_(m.bn2.weight, 0) # type: ignore[arg-type] #noqa
def __init__(self, num_classes, last_stride, model_path, neck, neck_feat,
model_name, pretrain_choice, num_stripes, gcb, rpp, dropout,
cam, sum, arc):
super(NEW_PCBBaseline, self).__init__()
self.num_stripes = num_stripes
self.gcb = gcb
self.rpp = rpp
self.dropout = dropout
self.hidden_dim = 256
self.cam = cam
self.sum = sum
self.arc = arc
if model_name == 'resnet18':
self.in_planes = 512
self.base = ResNet(last_stride=last_stride,
block=BasicBlock,
layers=[2, 2, 2, 2])
elif model_name == 'resnet34':
self.in_planes = 512
self.base = ResNet(last_stride=last_stride,
block=BasicBlock,
layers=[3, 4, 6, 3])
elif model_name == 'resnet50':
self.base = ResNet(last_stride=last_stride,
block=Bottleneck,
layers=[3, 4, 6, 3])
elif model_name == 'resnet101':
self.base = ResNet(last_stride=last_stride,
block=Bottleneck,
layers=[3, 4, 23, 3])
elif model_name == 'resnet152':
self.base = ResNet(last_stride=last_stride,
block=Bottleneck,
layers=[3, 8, 36, 3])
elif model_name == 'se_resnet50':
self.base = SENet(block=SEResNetBottleneck,
layers=[3, 4, 6, 3],
groups=1,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnet101':
self.base = SENet(block=SEResNetBottleneck,
layers=[3, 4, 23, 3],
groups=1,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnet152':
self.base = SENet(block=SEResNetBottleneck,
layers=[3, 8, 36, 3],
groups=1,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnext50':
self.base = SENet(block=SEResNeXtBottleneck,
layers=[3, 4, 6, 3],
groups=32,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnext101':
self.base = SENet(block=SEResNeXtBottleneck,
layers=[3, 4, 23, 3],
groups=32,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'senet154':
self.base = SENet(block=SEBottleneck,
layers=[3, 8, 36, 3],
groups=64,
reduction=16,
dropout_p=0.2,
last_stride=last_stride)
elif model_name == 'resnet50_ibn_a':
self.base = resnet50_ibn_a(last_stride, self.gcb, self.cam)
elif model_name == 'resnet101_ibn_a':
self.base = resnet101_ibn_a(last_stride, self.gcb)
elif model_name == 'se_resnet101_ibn_a':
self.base = se_resnet101_ibn_a(last_stride)
if pretrain_choice == 'imagenet':
if not os.path.exists(model_path):
assert "No The Pretrained Model"
self.base.load_param(model_path)
print('Loading pretrained ImageNet model......')
self.gap_avg = nn.AdaptiveAvgPool2d(1)
self.gap_max = nn.AdaptiveMaxPool2d(1)
self.num_classes = num_classes
self.neck = neck
self.neck_feat = neck_feat
self.base.layer4[0].conv2 = nn.Conv2d(512,
512,
kernel_size=3,
bias=False,
stride=1,
padding=1)
self.base.layer4[0].downsample = nn.Sequential(
nn.Conv2d(1024, 2048, kernel_size=1, stride=1, bias=False),
nn.BatchNorm2d(2048))
if self.sum:
print("Building Attention Branch")
self.atten_pam = PAM_Module(256)
self.atten_cam = CAM_Module(256)
sum_conv = nn.Sequential(nn.Dropout2d(0.1, False),
nn.Conv2d(256, 256, kernel_size=1))
sum_conv.apply(weights_init_kaiming)
self.sum_conv = sum_conv
# Add new layers
if self.rpp:
self.local_avgpool = RPP()
else:
self.local_avgpool_avg = nn.AdaptiveAvgPool2d((6, 1))
self.local_avgpool_max = nn.AdaptiveMaxPool2d((6, 1))
if self.dropout:
self.dropout_layer = nn.Dropout(p=0.5)
if self.arc:
self.arcface = ArcCos(self.in_planes,
self.num_classes,
s=30.0,
m=0.50)
self.l1_conv_list = nn.ModuleList()
self.l2_conv_list = nn.ModuleList()
self.l3_conv_list = nn.ModuleList()
self.l4_conv_list = nn.ModuleList()
self.l5_conv_list = nn.ModuleList()
for _ in range(6):
local_conv = nn.Sequential(
nn.Conv1d(2048, self.hidden_dim, kernel_size=1),
nn.BatchNorm2d(self.hidden_dim), nn.ReLU(inplace=True))
local_conv.apply(weights_init_kaiming)
self.l1_conv_list.append(local_conv)
for _ in range(2):
local_2_conv = nn.Sequential(
nn.Conv1d(2048 * 5, 256, kernel_size=1), nn.BatchNorm2d(256),
nn.ReLU(inplace=True))
local_2_conv.apply(weights_init_kaiming)
self.l2_conv_list.append(local_2_conv)
for _ in range(3):
local_3_conv = nn.Sequential(
nn.Conv1d(2048 * 4, 256, kernel_size=1), nn.BatchNorm2d(256),
nn.ReLU(inplace=True))
local_3_conv.apply(weights_init_kaiming)
self.l3_conv_list.append(local_3_conv)
for _ in range(4):
local_4_conv = nn.Sequential(
nn.Conv1d(2048 * 3, 256, kernel_size=1), nn.BatchNorm2d(256),
nn.ReLU(inplace=True))
local_4_conv.apply(weights_init_kaiming)
self.l4_conv_list.append(local_4_conv)
for _ in range(5):
local_5_conv = nn.Sequential(
nn.Conv1d(2048 * 2, 256, kernel_size=1), nn.BatchNorm2d(256),
nn.ReLU(inplace=True))
local_5_conv.apply(weights_init_kaiming)
self.l5_conv_list.append(local_5_conv)
# Classifier for each stripe
self.fc_1_list = nn.ModuleList()
self.fc_2_list = nn.ModuleList()
self.fc_3_list = nn.ModuleList()
self.fc_4_list = nn.ModuleList()
self.fc_5_list = nn.ModuleList()
if self.neck == 'no':
# For Global
self.classifier = nn.Linear(self.in_planes, self.num_classes)
self.classifier.apply(weights_init_classifier) # new add by luo
# For Part
for _ in range(self.num_stripes):
fc = nn.Linear(self.hidden_dim, self.num_classes)
fc.apply(weights_init_classifier)
self.fc_1_list.append(fc)
elif self.neck == 'bnneck':
self.bottleneck_1_list = nn.ModuleList()
self.bottleneck_2_list = nn.ModuleList()
self.bottleneck_3_list = nn.ModuleList()
self.bottleneck_4_list = nn.ModuleList()
self.bottleneck_5_list = nn.ModuleList()
# For Global
self.bottleneck = nn.BatchNorm1d(self.in_planes)
self.bottleneck.bias.requires_grad_(False) # no shift
self.bottleneck.apply(weights_init_kaiming)
self.classifier = nn.Linear(self.in_planes,
self.num_classes,
bias=False)
self.classifier.apply(weights_init_classifier)
for _ in range(6):
fc = nn.Linear(self.hidden_dim, self.num_classes, bias=False)
fc.apply(weights_init_classifier)
self.fc_1_list.append(fc)
bottleneck = nn.BatchNorm1d(self.hidden_dim)
bottleneck.bias.requires_grad_(False) # no shift
bottleneck.apply(weights_init_kaiming)
self.bottleneck_1_list.append(bottleneck)
for _ in range(2):
fc_2 = nn.Linear(self.hidden_dim, self.num_classes, bias=False)
fc_2.apply(weights_init_classifier)
self.fc_2_list.append(fc_2)
bottleneck_2 = nn.BatchNorm1d(self.hidden_dim)
bottleneck_2.bias.requires_grad_(False) # no shift
bottleneck_2.apply(weights_init_kaiming)
self.bottleneck_2_list.append(bottleneck_2)
for _ in range(3):
fc_3 = nn.Linear(self.hidden_dim, self.num_classes, bias=False)
fc_3.apply(weights_init_classifier)
self.fc_3_list.append(fc_3)
bottleneck_3 = nn.BatchNorm1d(self.hidden_dim)
bottleneck_3.bias.requires_grad_(False) # no shift
bottleneck_3.apply(weights_init_kaiming)
self.bottleneck_3_list.append(bottleneck_3)
for _ in range(4):
fc_4 = nn.Linear(self.hidden_dim, self.num_classes, bias=False)
fc_4.apply(weights_init_classifier)
self.fc_4_list.append(fc_4)
bottleneck_4 = nn.BatchNorm1d(self.hidden_dim)
bottleneck_4.bias.requires_grad_(False) # no shift
bottleneck_4.apply(weights_init_kaiming)
self.bottleneck_4_list.append(bottleneck_4)
for _ in range(5):
fc_5 = nn.Linear(self.hidden_dim, self.num_classes, bias=False)
fc_5.apply(weights_init_classifier)
self.fc_5_list.append(fc_5)
bottleneck_5 = nn.BatchNorm1d(self.hidden_dim)
bottleneck_5.bias.requires_grad_(False) # no shift
bottleneck_5.apply(weights_init_kaiming)
self.bottleneck_5_list.append(bottleneck_5)
initcache = join(
opt.dataPath, 'centroids',
opt.arch + '_' + whole_test_set.dataset + '_' +
str(opt.num_clusters) + '_desc_cen.hdf5')
if not exists(initcache):
raise FileNotFoundError(
'Could not find clusters, please run with --mode=cluster before proceeding'
)
with h5py.File(initcache, mode='r') as h5:
clsts = h5.get("centroids")[...]
traindescs = h5.get("descriptors")[...]
net_vlad.init_params(clsts, traindescs)
del clsts, traindescs
model.add_module('pool', net_vlad)
elif opt.pooling.lower() == 'max':
global_pool = nn.AdaptiveMaxPool2d((1, 1))
model.add_module(
'pool', nn.Sequential(
*[global_pool, Flatten(), L2Norm()]))
elif opt.pooling.lower() == 'avg':
global_pool = nn.AdaptiveAvgPool2d((1, 1))
model.add_module(
'pool', nn.Sequential(
*[global_pool, Flatten(), L2Norm()]))
else:
raise ValueError('Unknown pooling type: ' + opt.pooling)
isParallel = False
if opt.nGPU > 1 and torch.cuda.device_count() > 1:
model.encoder = nn.DataParallel(model.encoder)
if opt.mode.lower() != 'cluster':
def init_tile_modules():
self.avgpool_tile = nn.AdaptiveAvgPool2d((1, 1))
self.maxpool_tile = nn.AdaptiveMaxPool2d((1, 1))
self.fc_tile = nn.Sequential(
nn.Flatten(), nn.Linear(512 * block.expansion, num_classes))
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, sz=None):
"Output will be 2*sz or 2 if sz is None"
super(AdaptiveConcatPool2d, self).__init__()
self.output_size = sz or 1
self.ap = nn.AdaptiveAvgPool2d(self.output_size)
self.mp = nn.AdaptiveMaxPool2d(self.output_size)
def __init__(self, size=(1, 1)):
super().__init__()
self.ap = nn.AdaptiveAvgPool2d(size)
self.mp = nn.AdaptiveMaxPool2d(size)
def __init__(self):
super(LayerTest, self).__init__()
self.pool = nn.AdaptiveMaxPool2d((1, 1))
def __init__(self, output_size=1):
super(GlobalAvgMaxPool2D, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(output_size=output_size)
self.max_pool = nn.AdaptiveMaxPool2d(output_size=output_size)
self.conv = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
avgout = torch.mean(x, dim=1, keepdim=True)
maxout, _ = torch.max(x, dim=1, keepdim=True)
x = torch.cat([avgout, maxout], dim=1)
x = self.conv(x)
return self.sigmoid(x)
class CBAM(nn.Module):
def __init__(self, inchannel):
super(CBAM, self).__init__()
self.ca = ChannelAttention(inchannel)
self.sp = SpatialAttention()
def forward(self, x):
x = self.ca(x) * x
x = self.sp(x) * x
return x
if __name__ == '__main__':
#net =BasicBlock(inplanes=3,planes=3)
a = torch.randn((1, 64, 224, 224))
avg_pool = nn.AdaptiveAvgPool2d(1)
max_pool = nn.AdaptiveMaxPool2d(1)
net = SpatialAttention()
print(net(a).shape)
def __init__(self):
# pyramidal pooling of sizes 1, 3, 6
self.pool1 = nn.AdaptiveMaxPool2d(1)
self.pool3 = nn.AdaptiveMaxPool2d(3)
self.pool6 = nn.AdaptiveMaxPool2d(6)
self.lst = [self.pool1, self.pool3, self.pool6]
def __init__(self, dims, FC_dims):
assert (dims[-1] == FC_dims[0])
super(PointPairNet, self).__init__()
self.L = nn.Sequential(*get_MLP_layers(dims, False))
self.Pool = nn.AdaptiveMaxPool2d((1, 1))
self.F = nn.Sequential(*get_MLP_layers(FC_dims, False))
strides=2))
else:
blk.append(Residual(num_channels, num_channels))
return blk
class Flatten(nn.Module):
def forward(self, input):
return input.view(input.size(0), -1)
b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))
net = nn.Sequential(b1, b2, b3, b4, b5, nn.AdaptiveMaxPool2d((1, 1)),
Flatten(), nn.Linear(512, 10))
lr, num_epochs, batch_size, device = 0.05, 5, 256, d2l.try_gpu()
def init_weights(m):
if type(m) == nn.Linear or type(m) == nn.Conv2d:
torch.nn.init.xavier_uniform_(m.weight)
net.apply(init_weights)
criterion = nn.CrossEntropyLoss()
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch5(net, train_iter, test_iter, criterion, num_epochs, batch_size,
device, lr)
def __init__(self, dims, doLastRelu=False):
layers = [
PointwiseMLP(dims, doLastRelu=doLastRelu), #BxNxK
GlobalPool(nn.AdaptiveMaxPool2d((1, dims[-1]))), #BxK
]
super(PointNetGlobalMax, self).__init__(*layers)
def test_module_dmas(self):
# Check for unknown module that it returns 0 and throws a warning
self.assertEqual(modules.module_dmas(MyModule(), None, None), 0)
self.assertWarns(UserWarning, modules.module_dmas, MyModule(), None,
None)
# Common unit tests
# Linear
self.assertEqual(
modules.module_dmas(nn.Linear(8, 4), torch.zeros((1, 8)),
torch.zeros((1, 4))), 4 * (8 + 1) + 8 + 4)
# Activation
self.assertEqual(
modules.module_dmas(nn.Identity(), torch.zeros((1, 8)),
torch.zeros((1, 8))), 8)
self.assertEqual(
modules.module_dmas(nn.Flatten(), torch.zeros((1, 8)),
torch.zeros((1, 8))), 16)
self.assertEqual(
modules.module_dmas(nn.ReLU(), torch.zeros((1, 8)),
torch.zeros((1, 8))), 8 * 2)
self.assertEqual(
modules.module_dmas(nn.ReLU(inplace=True), torch.zeros((1, 8)),
None), 8)
self.assertEqual(
modules.module_dmas(nn.ELU(), torch.zeros((1, 8)),
torch.zeros((1, 8))), 17)
self.assertEqual(
modules.module_dmas(nn.Sigmoid(), torch.zeros((1, 8)),
torch.zeros((1, 8))), 16)
self.assertEqual(
modules.module_dmas(nn.Tanh(), torch.zeros((1, 8)),
torch.zeros((1, 8))), 24)
# Conv
input_t = torch.rand((1, 3, 32, 32))
mod = nn.Conv2d(3, 8, 3)
self.assertEqual(modules.module_dmas(mod, input_t, mod(input_t)),
201824)
# ConvTranspose
mod = nn.ConvTranspose2d(3, 8, 3)
self.assertEqual(modules.module_dmas(mod, input_t, mod(input_t)),
259178)
# BN
self.assertEqual(
modules.module_dmas(nn.BatchNorm1d(8), torch.zeros((1, 8, 4)),
torch.zeros((1, 8, 4))),
32 + 17 + 1 + 16 + 17 + 32)
# Pooling
self.assertEqual(
modules.module_dmas(nn.MaxPool2d((2, 2)), torch.zeros(
(1, 8, 4, 4)), torch.zeros((1, 8, 2, 2))), 4 * 32 + 32)
self.assertEqual(
modules.module_dmas(nn.AdaptiveMaxPool2d((2, 2)),
torch.zeros((1, 8, 4, 4)),
torch.zeros((1, 8, 2, 2))), 4 * 32 + 32)
# Integer output size support
self.assertEqual(
modules.module_dmas(nn.MaxPool2d(2), torch.zeros((1, 8, 4, 4)),
torch.zeros((1, 8, 2, 2))), 4 * 32 + 32)
self.assertEqual(
modules.module_dmas(nn.AdaptiveMaxPool2d(2),
torch.zeros((1, 8, 4, 4)),
torch.zeros((1, 8, 2, 2))), 4 * 32 + 32)
# Dropout
self.assertEqual(
modules.module_dmas(nn.Dropout(), torch.zeros((1, 8)),
torch.zeros((1, 8))), 17)
def __init__(self,
in_channel,
out_channel,
kernel_size=3,
r_factor=64,
layer=3,
pos_injection=2,
is_encoding=1,
pos_rfactor=8,
pooling='mean',
dropout_prob=0.0,
pos_noise=0.0):
super(HANet_Conv, self).__init__()
self.pooling = pooling
self.pos_injection = pos_injection
self.layer = layer
self.dropout_prob = dropout_prob
self.sigmoid = nn.Sigmoid()
if r_factor > 0:
mid_1_channel = math.ceil(in_channel / r_factor)
elif r_factor < 0:
r_factor = r_factor * -1
mid_1_channel = in_channel * r_factor
if self.dropout_prob > 0:
self.dropout = nn.Dropout2d(self.dropout_prob)
self.attention_first = nn.Sequential(
nn.Conv1d(in_channels=in_channel,
out_channels=mid_1_channel,
kernel_size=1,
stride=1,
padding=0,
bias=False), Norm2d(mid_1_channel),
nn.ReLU(inplace=True))
if layer == 2:
self.attention_second = nn.Sequential(
nn.Conv1d(in_channels=mid_1_channel,
out_channels=out_channel,
kernel_size=kernel_size,
stride=1,
padding=kernel_size // 2,
bias=True))
elif layer == 3:
mid_2_channel = (mid_1_channel * 2)
self.attention_second = nn.Sequential(
nn.Conv1d(in_channels=mid_1_channel,
out_channels=mid_2_channel,
kernel_size=3,
stride=1,
padding=1,
bias=True), Norm2d(mid_2_channel),
nn.ReLU(inplace=True))
self.attention_third = nn.Sequential(
nn.Conv1d(in_channels=mid_2_channel,
out_channels=out_channel,
kernel_size=kernel_size,
stride=1,
padding=kernel_size // 2,
bias=True))
if self.pooling == 'mean':
#print("##### average pooling")
self.rowpool = nn.AdaptiveAvgPool2d((128 // pos_rfactor, 1))
else:
#print("##### max pooling")
self.rowpool = nn.AdaptiveMaxPool2d((128 // pos_rfactor, 1))
if pos_rfactor > 0:
if is_encoding == 0:
if self.pos_injection == 1:
self.pos_emb1d_1st = PosEmbedding1D(pos_rfactor,
dim=in_channel,
pos_noise=pos_noise)
elif self.pos_injection == 2:
self.pos_emb1d_2nd = PosEmbedding1D(pos_rfactor,
dim=mid_1_channel,
pos_noise=pos_noise)
elif is_encoding == 1:
if self.pos_injection == 1:
self.pos_emb1d_1st = PosEncoding1D(pos_rfactor,
dim=in_channel,
pos_noise=pos_noise)
elif self.pos_injection == 2:
self.pos_emb1d_2nd = PosEncoding1D(pos_rfactor,
dim=mid_1_channel,
pos_noise=pos_noise)
else:
print("Not supported position encoding")
exit()
