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()