def __init__(self, pretrained=False): super().__init__() self.pool = nn.MaxPool2d(3, 2, 1) if pretrained: encoder = se_resnext50_32x4d(pretrained='imagenet') else: encoder = se_resnext50_32x4d(pretrained=None) self.conv1 = Sequential( nn.Conv2d(3, 64, 3, stride=1, padding=1, bias=False), ) self.conv2 = encoder.layer1 self.conv3 = encoder.layer2 self.conv4 = encoder.layer3 self.conv5 = encoder.layer4 self.center = nn.Sequential( ConvRelu(2048, 1024), ConvRelu(1024, 512), ) self.dec5 = DecoderBlockSCSE(2560, 1024, 256) self.dec4 = DecoderBlockSCSE(1280, 128, 128) self.dec3 = DecoderBlockSCSE(640, 64, 64) self.dec2 = DecoderBlockSCSE(320, 32, 32) self.dec1 = ConvRelu(96, 64) self.final_do = nn.Dropout2d(p=0.25) self.logit = nn.Sequential( nn.Conv2d(64, 32, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(32, 1, kernel_size=1, padding=0), )
def __init__(self, out_channels=7, pretrained=True, nodes=(32, 32), dropout=0, enhance_diag=True, aux_pred=True): super(rx50_gcn_3head_4channel, self).__init__() # same with res_fdcs_v5 self.aux_pred = aux_pred self.node_size = nodes self.num_cluster = out_channels if pretrained: resnet = se_resnext50_32x4d() else: resnet = se_resnext50_32x4d(pretrained=None) print('NOTE: No pretraining') self.layer0, self.layer1, self.layer2, self.layer3, = \ resnet.layer0, resnet.layer1, resnet.layer2, resnet.layer3 self.conv0 = torch.nn.Conv2d(4, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) for child in self.layer0.children(): for param in child.parameters(): par = param break break self.conv0.parameters = torch.cat([par[:, 0, :, :].unsqueeze(1), par], 1) self.layer0 = torch.nn.Sequential(self.conv0, *list(self.layer0)[1:4]) self.graph_layers1 = GCN_Layer(1024, 128, bnorm=True, activation=nn.ReLU(True), dropout=dropout) self.graph_layers2 = GCN_Layer(128, out_channels, bnorm=False, activation=None) self.scg = SCG_block(in_ch=1024, hidden_ch=out_channels, node_size=nodes, add_diag=enhance_diag, dropout=dropout) weight_xavier_init(self.graph_layers1, self.graph_layers2, self.scg)
def __init__(self, hparams, vocab_size=len(char_field.vocab)): super().__init__() self.hparams = hparams self.feature_extractor = nn.Sequential(*list( pretrainedmodels.se_resnext50_32x4d().children() )[:-3]) # feature extractor not including last se block and fc layers self.ext = list( pretrainedmodels.se_resnext50_32x4d().children() )[-3] # last se block of feature extractor self.fc = nn.Linear( self.feature_extractor[-1][-1].se_module.fc2.out_channels, hparams.d_model ) self.fc_ext = nn.Linear( self.ext[-1].se_module.fc2.out_channels, hparams.d_model ) self.pe1 = PositionalEncoding(hparams.d_model, hparams.dropout) self.pe1_ext = PositionalEncoding(hparams.d_model, hparams.dropout) self.emb = nn.Embedding(vocab_size, hparams.d_model) self.pe2 = PositionalEncoding(hparams.d_model, hparams.dropout) self.transf = nn.Transformer( hparams.d_model, hparams.nhead, num_encoder_layers=hparams.num_encoder_layers, num_decoder_layers=hparams.num_decoder_layers, dim_feedforward=hparams.dim_ff ) self.transf_ext = nn.Transformer( hparams.d_model, hparams.nhead, num_encoder_layers=hparams.num_encoder_layers, num_decoder_layers=hparams.num_decoder_layers, dim_feedforward=hparams.dim_ff ) self.fc_out = nn.Linear(2 * hparams.d_model, vocab_size) self.loss = L.SoftCrossEntropyLoss(ignore_index=char_field.vocab.stoi[char_field.pad_token]) for p in self.transf.parameters(): if p.dim() > 1: nn.init.xavier_uniform_(p) for p in self.transf_ext.parameters(): if p.dim() > 1: nn.init.xavier_uniform_(p)
def __init__(self, num_classes=1, num_filters=32, pretrained=True, is_deconv=False): super().__init__() self.num_classes = num_classes self.pool = nn.MaxPool2d(2, 2) if pretrained: self.encoder = se_resnext50_32x4d(num_classes=1000, pretrained='imagenet') else: self.encoder = se_resnext50_32x4d(num_classes=1000, pretrained=None) self.conv1 = self.encoder.layer0 self.conv2 = self.encoder.layer1 self.conv3 = self.encoder.layer2 self.conv4 = self.encoder.layer3 self.conv5 = self.encoder.layer4 self.center = DecoderBlock(2048, num_filters * 8, num_filters * 8, is_deconv=is_deconv) self.dec5 = DecoderBlock(2048 + num_filters * 8, num_filters * 8, num_filters * 8, is_deconv=is_deconv) self.dec4 = DecoderBlock(1024 + num_filters * 8, num_filters * 8, num_filters * 8, is_deconv=is_deconv) self.dec3 = DecoderBlock(512 + num_filters * 8, num_filters * 2, num_filters * 2, is_deconv=is_deconv) self.dec2 = DecoderBlock(256 + num_filters * 2, num_filters * 2, num_filters, is_deconv=is_deconv) self.dec1 = DecoderBlock(64 + num_filters, num_filters, num_filters, is_deconv=is_deconv) self.dec0 = ConvRelu(num_filters, num_filters) self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def __init__(self, num_classes): super().__init__() self.se_resnext50_32x4d = pm.se_resnext50_32x4d() self.max_pool = torch.nn.MaxPool2d(7, stride=1) self.linear1 = torch.nn.Linear(2048, 768) self.last_linear = torch.nn.Linear(768, num_classes) self.batch_norm1 = torch.nn.BatchNorm1d(768)
def __init__(self, encoder_depth, num_classes, num_filters=32, dropout_2d=0.2, pretrained=False, is_deconv=False): super().__init__() self.num_classes = num_classes self.dropout_2d = dropout_2d self.encoder = pretrainedmodels.se_resnext50_32x4d() #torchvision.models.resnet152(pretrained=pretrained) bottom_channel_nr = 512*4 self.relu = nn.ReLU(inplace=True) self.pool = nn.MaxPool2d(2, 2) #self.input_adjust = nn.Sequential(self.encoder.layer0, self.pool) self.input_adjust = self.encoder.layer0 self.conv1 = self.encoder.layer1 self.conv2 = self.encoder.layer2 self.conv3 = self.encoder.layer3 self.conv4 = self.encoder.layer4 self.center = DecoderCenter(bottom_channel_nr, num_filters * 8 *2, num_filters * 8, False) self.dec5 = DecoderBlockV2(bottom_channel_nr + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec4 = DecoderBlockV2(bottom_channel_nr // 2 + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec3 = DecoderBlockV2(bottom_channel_nr // 4 + num_filters * 8, num_filters * 4 * 2, num_filters * 2, is_deconv) self.dec2 = DecoderBlockV2(bottom_channel_nr // 8 + num_filters * 2, num_filters * 2 * 2, num_filters * 2 * 2, is_deconv) self.dec1 = DecoderBlockV2(num_filters * 2 * 2, num_filters * 2 * 2, num_filters, is_deconv) self.dec0 = ConvRelu(num_filters, num_filters) self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def make_backend_se_resnext50_32x4d(pretrained=True, use_maxblurpool=False, remove_last_stride=False, n_channel=1): model = pretrainedmodels.se_resnext50_32x4d( pretrained='imagenet' if pretrained else None) if use_maxblurpool: model.layer0[3] = MaxBlurPool2d(3, True) print('Use: MaxBlurPool2d') if remove_last_stride: model.layer4[0].conv2.stride = (1, 1) model.layer4[0].downsample[0].stride = (1, 1) print('Removed: last stride') if n_channel == 1: weight = model.layer0[0].weight conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) conv1.weight = nn.Parameter(torch.mean(weight, dim=1, keepdim=True)) layer0 = nn.Sequential(conv1, model.layer0[1], model.layer0[2], model.layer0[3]) model.layer0 = layer0 print('Converted: 1ch') del model.avg_pool del model.dropout del model.last_linear return model
def __init__(self, model, num_classes): super().__init__() self.norm = nn.BatchNorm2d(6) if model.type.startswith('efficientnet'): self.model = efficientnet_pytorch.EfficientNet.from_pretrained( model.type) # self.model._conv_stem = efficientnet_pytorch.utils.Conv2dDynamicSamePadding( # 6, 32, kernel_size=3, stride=2, bias=False) self.model._conv_stem = nn.Conv2d(6, 32, kernel_size=3, stride=2, padding=1, bias=False) self.model._fc = nn.Linear(self.model._fc.in_features, num_classes) elif model.type == 'seresnext50': self.model = pretrainedmodels.se_resnext50_32x4d( pretrained='imagenet') self.model.layer0.conv1 = nn.Conv2d(6, 64, kernel_size=7, stride=2, padding=3, bias=False) self.model.avg_pool = nn.AdaptiveAvgPool2d(1) self.model.last_linear = nn.Linear( self.model.last_linear.in_features, num_classes) else: raise AssertionError('invalid model {}'.format(model))
def __init__(self, encoder_depth, num_classes, num_filters=32, dropout_2d=0.2, pretrained=False, is_deconv=False): super().__init__() self.num_classes = num_classes self.dropout_2d = dropout_2d self.encoder = pretrainedmodels.se_resnext50_32x4d() #torchvision.models.resnet152(pretrained=pretrained) self.pool = nn.MaxPool2d(2, 2) bottom_channel_nr = 512*4 self.input_adjust = nn.Sequential(self.encoder.layer0.conv1, self.encoder.layer0.bn1, self.encoder.layer0.relu1) self.conv1 = self.encoder.layer1 self.conv2 = self.encoder.layer2 self.conv3 = self.encoder.layer3 self.conv4 = self.encoder.layer4 self.dec4 = DecoderBlockV2(bottom_channel_nr, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec3 = DecoderBlockV2(bottom_channel_nr // 2 + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec2 = DecoderBlockV2(bottom_channel_nr // 4 + num_filters * 8, num_filters * 4 * 2, num_filters * 2, is_deconv) self.dec1 = DecoderBlockV2(bottom_channel_nr // 8 + num_filters * 2, num_filters * 2 * 2, num_filters * 2 * 2, is_deconv) self.final = nn.Conv2d(num_filters * 2 * 2, num_classes, kernel_size=1) self._mask_out = nn.Sequential(nn.Conv2d(704, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(64, 2, kernel_size=1, stride=1, padding=0))
def __init__( self, encoder_depth, num_classes, num_filters=32, dropout_2d=0.2, pretrained=False, is_deconv=False, ): super().__init__() self.num_classes = num_classes self.dropout_2d = dropout_2d self.encoder = ( pretrainedmodels.se_resnext50_32x4d() ) # torchvision.models.resnet152(pretrained=pretrained) bottom_channel_nr = 512 * 4 self.relu = nn.ReLU(inplace=True) self.pool = nn.MaxPool2d(2, 2) # self.input_adjust = nn.Sequential(self.encoder.layer0, self.pool) self.input_adjust = self.encoder.layer0 self.conv1 = self.encoder.layer1 self.conv2 = self.encoder.layer2 self.conv3 = self.encoder.layer3 self.conv4 = self.encoder.layer4 self.center = DecoderCenter(bottom_channel_nr, num_filters * 8 * 2, num_filters * 8, False) self.dec5 = DecoderBlockV2( bottom_channel_nr + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv, ) self.dec4 = DecoderBlockV2( bottom_channel_nr // 2 + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv, ) self.dec3 = DecoderBlockV2( bottom_channel_nr // 4 + num_filters * 8, num_filters * 4 * 2, num_filters * 2, is_deconv, ) self.dec2 = DecoderBlockV2( bottom_channel_nr // 8 + num_filters * 2, num_filters * 2 * 2, num_filters * 2 * 2, is_deconv, ) self.dec1 = DecoderBlockV2(num_filters * 2 * 2, num_filters * 2 * 2, num_filters, is_deconv) self.dec0 = ConvRelu(num_filters, num_filters) self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def __init__(self, slug, num_filters=256, pretrained=True, bifpn=False): """Creates an `FPN` instance for feature extraction. Args: slug: model slug e.g. 'r18', 'r101' for ResNet num_filters: the number of filters in each output pyramid level pretrained: use ImageNet pre-trained backbone feature extractor num_input_channels: number fo input channels """ self.slug = slug super().__init__() if not pretrained: print("Caution, not loading pretrained weights.") if slug == 'resnet18': self.resnet = models.resnet18(pretrained=pretrained) num_bottleneck_filters = 512 elif slug == 'resnet34': self.resnet = models.resnet34(pretrained=pretrained) num_bottleneck_filters = 512 elif slug == 'resnet50': self.resnet = models.resnet50(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'resnet101': self.resnet = models.resnet101(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'resnet152': self.resnet = models.resnet152(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'rx50': self.resnet = models.resnext50_32x4d(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'rx101': self.resnet = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x8d_wsl') num_bottleneck_filters = 2048 elif slug == "rx102": self.resnet = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') num_bottleneck_filters = 2048 elif slug == "seresnext": self.resnet = pretrainedmodels.se_resnext50_32x4d(pretrained="imagenet") num_bottleneck_filters = 2048 else: assert False, "Bad slug: %s" % slug # Access resnet directly in forward pass; do not store refs here due to # https://github.com/pytorch/pytorch/issues/8392 self.bifpn = bifpn if bifpn: self.BiFPN = BiFPN(num_filters) self.lateral4 = Conv1x1(num_bottleneck_filters, num_filters) self.lateral3 = Conv1x1(num_bottleneck_filters // 2, num_filters) self.lateral2 = Conv1x1(num_bottleneck_filters // 4, num_filters) self.lateral1 = Conv1x1(num_bottleneck_filters // 8, num_filters) self.smooth4 = Conv3x3(num_filters, num_filters) self.smooth3 = Conv3x3(num_filters, num_filters) self.smooth2 = Conv3x3(num_filters, num_filters) self.smooth1 = Conv3x3(num_filters, num_filters)
def __init__(self, classes=2): super(Seresnext, self).__init__() model = se_resnext50_32x4d() firstLayer = list(model.children())[0] firstLayer[0] = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) modules = list(firstLayer) + list(model.children())[1:-1] self.features = nn.Sequential(*modules) self.classifier = nn.Conv2d(2048, classes, kernel_size=1, stride=1)
def classification_model_resnext50_combine_last(**kwargs): base_model = pretrainedmodels.se_resnext50_32x4d() return ClassificationModelResnetCombineLast(base_model, base_model_features=2048, nb_features=6, base_model_l1_outputs=64, combine_conv_features=512, **kwargs)
def __init__( self, encoder_depth, num_classes, num_filters=32, dropout_2d=0.2, pretrained=False, is_deconv=False, ): super().__init__() self.num_classes = num_classes self.dropout_2d = dropout_2d self.encoder = ( pretrainedmodels.se_resnext50_32x4d() ) # torchvision.models.resnet152(pretrained=pretrained) self.pool = nn.MaxPool2d(2, 2) bottom_channel_nr = 512 * 4 self.input_adjust = nn.Sequential( self.encoder.layer0.conv1, self.encoder.layer0.bn1, self.encoder.layer0.relu1, ) self.conv1 = self.encoder.layer1 self.conv2 = self.encoder.layer2 self.conv3 = self.encoder.layer3 self.conv4 = self.encoder.layer4 self.dec4 = DecoderBlockV2(bottom_channel_nr, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec3 = DecoderBlockV2( bottom_channel_nr // 2 + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv, ) self.dec2 = DecoderBlockV2( bottom_channel_nr // 4 + num_filters * 8, num_filters * 4 * 2, num_filters * 2, is_deconv, ) self.dec1 = DecoderBlockV2( bottom_channel_nr // 8 + num_filters * 2, num_filters * 2 * 2, num_filters * 2 * 2, is_deconv, ) self.final = nn.Conv2d(num_filters * 2 * 2, num_classes, kernel_size=1) self._mask_out = nn.Sequential( nn.Conv2d(704, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(64, 2, kernel_size=1, stride=1, padding=0), )
def __init__(self, num_classes=1, pretrained=False): """ Args: num_classes: Number of output classes. num_filters: """ super().__init__() self.pool = nn.AvgPool2d(2, 2) if pretrained: encoder = se_resnext50_32x4d(pretrained='imagenet') else: encoder = se_resnext50_32x4d(pretrained=None) self.conv1 = Sequential( OrderedDict([('conv1', nn.Conv2d(3, 64, 3, padding=1, bias=False))])) self.conv2 = encoder.layer1 self.conv3 = encoder.layer2 self.conv4 = encoder.layer3 self.conv5 = encoder.layer4 self.center = nn.Sequential( ConvRelu(2048, 1024), ConvRelu(1024, 512), ) self.dec5 = DecoderBlockSCSE(2560, 256, 256) self.dec4 = DecoderBlockSCSE(1280, 128, 128) self.dec3 = DecoderBlockSCSE(640, 64, 64) self.dec2 = DecoderBlockSCSE(320, 32, 32) self.dec1 = ConvRelu(96, 64) self.final_do = nn.Dropout(p=0.25) self.final = nn.Conv2d(64, num_classes, kernel_size=1) self.logit = nn.Sequential( nn.Conv2d(544, 32, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(32, 1, kernel_size=1, padding=0), ) self.fusion = nn.Sequential( nn.Conv2d(2592, 32, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(32, 1, kernel_size=1, padding=0), ) self.fc = nn.Linear(2048, 1)
def body(pretrained = True): model = pretrainedmodels.se_resnext50_32x4d().to(device) w1 = model.state_dict()[next(iter(model.state_dict()))] model.layer0.conv1=torch.nn.Conv2d(4,64,(7,7),(2,2),(3,3)) model.state_dict()[next(iter(model.state_dict()))][:,:3,:,:]=w1 model.state_dict()[next(iter(model.state_dict()))][:,3,:,:]=0 return model
def __init__(self): super().__init__() self.base_model = pretrainedmodels.se_resnext50_32x4d() self.base_model.layer0[0] = nn.Conv2d(1, 64, 3, stride=2, padding=1, bias=False)
def __init__(self, bottleneck_size=256): super().__init__() self.se_resnext50_32x4d = pm.se_resnext50_32x4d() self.se_resnext50_32x4d.dropout = nn.Dropout(0.5) self.se_resnext50_32x4d.last_linear = nn.Linear(512 * SEResNeXtBottleneck.expansion, bottleneck_size) self.bn512 = nn.BatchNorm1d(bottleneck_size) model_settings = pm.pretrained_settings['se_resnext50_32x4d']['imagenet'] _, self.input_height, self.input_width = model_settings['input_size']
def se_resnext(num_classes, pretrained): model = se_resnext50_32x4d(num_classes=1000, pretrained=pretrained) num_ftrs = model.last_linear.in_features model.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) model.last_linear = nn.Sequential( nn.Linear(num_ftrs, num_classes, bias=True)) return model
def create_net(name, pretrained=True): if name == 'se_resnext50_32x4d': return pm.se_resnext50_32x4d() elif name == 'se_resnext101_32x4d': return pm.se_resnext101_32x4d() elif name == 'resnext101_32x8d_wsl': return torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x8d_wsl') else: raise Exception('name ' + str(name) + ' is not supported')
def __init__(self, hparams): super(Net, self).__init__() self.hparams = hparams self.submodule = pretrainedmodels.se_resnext50_32x4d( num_classes=1000, pretrained='imagenet' ) in_features = self.submodule.last_linear.in_features # Change last_linear to Identity() to preserve memory self.submodule.last_linear = Identity() self.head = Head(in_features, NUM_CATEGORIES, NUM_GENERA, NUM_FAMILIES)
def _get_convnet(self, backbone, pretrained): if backbone == 'resnet34': convnet = nn.Sequential( *list(models.resnet34(pretrained=pretrained).children())[:-1]) shape = (512, 4 * 5) add_bn = True elif backbone == 'resnet50': convnet = nn.Sequential( *list(models.resnet50(pretrained=pretrained).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'resnet101': convnet = nn.Sequential( *list(models.resnet101(pretrained=pretrained).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'resnet152': convnet = nn.Sequential( *list(models.resnet152(pretrained=pretrained).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'densenet121': convnet = nn.Sequential( models.densenet121(pretrained=pretrained).features, nn.ReLU(inplace=True), nn.AvgPool2d(7, stride=1)) shape = (1024, 4 * 5) add_bn = False elif backbone == 'densenet201': convnet = nn.Sequential( models.densenet201(pretrained=pretrained).features, nn.ReLU(inplace=True), nn.AvgPool2d(7, stride=1)) shape = (1920, 4 * 5) add_bn = False elif backbone == 'se_resnext_50': pretrain = 'imagenet' if pretrained else None convnet = nn.Sequential(*list( se_resnext50_32x4d(num_classes=1000, pretrained=pretrain).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'se_resnext_101': pretrain = 'imagenet' if pretrained else None convnet = nn.Sequential(*list( se_resnext101_32x4d(num_classes=1000, pretrained=pretrain).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'sphere_net': convnet = PlainNet() shape = (512, 16 * 16) add_bn = False else: raise ValueError("Backbone [%s] not recognized." % backbone) return convnet, shape, add_bn
def __init__(self, encoder_depth, num_classes=1, num_filters=32, dropout_2d=0.4, pretrained=True, is_deconv=True): super(UNetResNetAttention, self).__init__() self.num_classes = num_classes self.dropout_2d = dropout_2d self.pool = nn.MaxPool2d(2, 2) self.resnet = pretrainedmodels.se_resnext50_32x4d() bottom_channel_nr = 2048 conv1 = nn.Conv2d(3, 64, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), bias=False) conv1.weight = self.resnet.layer0.conv1.weight ''' self.encoder1 = nn.Sequential(conv1, self.resnet.layer0.bn1, self.resnet.layer0.relu1 ,self.pool ) ''' self.encoder1 = EncoderBlock( nn.Sequential(conv1, self.resnet.layer0.bn1, self.resnet.layer0.relu1,self.pool), num_filters*2 ) self.encoder2 = EncoderBlock(self.resnet.layer1, bottom_channel_nr//8) self.encoder3 = EncoderBlock(self.resnet.layer2, bottom_channel_nr//4) self.encoder4 = EncoderBlock(self.resnet.layer3, bottom_channel_nr//2) self.encoder5 = EncoderBlock(self.resnet.layer4, bottom_channel_nr) center_block = nn.Sequential( ConvBn2d(bottom_channel_nr, bottom_channel_nr, kernel_size=3, padding=1), nn.ReLU(inplace=True), ConvBn2d(bottom_channel_nr, bottom_channel_nr//2, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2) ) self.center = EncoderBlock(center_block, bottom_channel_nr//2) self.decoder5 = DecoderBlock(bottom_channel_nr + bottom_channel_nr // 2, num_filters * 16, 64) self.decoder4 = DecoderBlock(64 + bottom_channel_nr // 2, num_filters * 8, 64) self.decoder3 = DecoderBlock(64 + bottom_channel_nr // 4, num_filters * 4, 64) self.decoder2 = DecoderBlock(64 + bottom_channel_nr // 8, num_filters * 2, 64) self.decoder1 = DecoderBlock(64, num_filters, 64) self.final = nn.Conv2d(64, 2, kernel_size=1) self.logit = nn.Sequential( nn.Conv2d(64, 64, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(64, 2, kernel_size=1, padding=0) )
def se_resnext50_32x4d(): """ From: https://github.com/Cadene/pretrained-models.pytorch From: https://github.com/hujie-frank/SENet Residual networks with grouped convolutional layers and squeeze & excitation blocks ResNext: https://arxiv.org/pdf/1611.05431.pdf Squeeze and Excitation: https://arxiv.org/abs/1709.01507 Params 27M, GFLOPs 4.25, Top-1 acc 79.076, Top-5 acc 94.434 """ return pretrainedmodels.se_resnext50_32x4d(num_classes=1000, pretrained="imagenet")
def __init__(self, encoder_depth, num_classes=1, num_filters=32, dropout_2d=0.4, pretrained=True, is_deconv=True): super(UNetResNetAttention, self).__init__() self.num_classes = num_classes self.dropout_2d = dropout_2d self.resnet = pretrainedmodels.se_resnext50_32x4d() bottom_channel_nr = 2048 self.encoder1 = EncoderBlock( nn.Sequential(self.resnet.layer0.conv1, self.resnet.layer0.bn1, self.resnet.layer0.relu1), num_filters * 2) self.encoder2 = EncoderBlock(self.resnet.layer1, bottom_channel_nr // 8) self.encoder3 = EncoderBlock(self.resnet.layer2, bottom_channel_nr // 4) self.encoder4 = EncoderBlock(self.resnet.layer3, bottom_channel_nr // 2) self.encoder5 = EncoderBlock(self.resnet.layer4, bottom_channel_nr) center_block = nn.Sequential( ConvBn2d(bottom_channel_nr, bottom_channel_nr, kernel_size=3, padding=1), nn.ReLU(inplace=True), ConvBn2d(bottom_channel_nr, bottom_channel_nr // 2, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2)) self.center = EncoderBlock(center_block, bottom_channel_nr // 2) self.decoder5 = DecoderBlock( bottom_channel_nr + bottom_channel_nr // 2, num_filters * 16, 64) self.decoder4 = DecoderBlock(64 + bottom_channel_nr // 2, num_filters * 8, 64) self.decoder3 = DecoderBlock(64 + bottom_channel_nr // 4, num_filters * 4, 64) self.decoder2 = DecoderBlock(64 + bottom_channel_nr // 8, num_filters * 2, 64) self.decoder1 = DecoderBlock(64, num_filters, 64) self.final = nn.Conv2d(64, 2, kernel_size=1) self.logit = nn.Sequential( nn.Conv2d(320, 64, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(64, 2, kernel_size=1, padding=0))
def __init__(self, encoder_settings, num_classes=4, pre=False, **kwargs): super(UneXt50SE, self).__init__() self.n_classes = num_classes m = pretrainedmodels.se_resnext50_32x4d( pretrained='imagenet' if pre else None) # conv = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) # w = (m.layer0.conv1.weight.sum(1)).unsqueeze(1) # conv.weight = nn.Parameter(w) # self.enc0 = nn.Sequential(conv, m.layer0.bn1, nn.ReLU(inplace=True)) self.enc0 = nn.Sequential(m.layer0.conv1, m.layer0.bn1, nn.ReLU(inplace=True)) self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True) self.enc1 = m.layer1 # 256 self.enc2 = m.layer2 # 512 self.enc3 = m.layer3 # 1024 self.enc4 = m.layer4 # 2048 self.middle_conv = ASPPI(2048, 1024) self.dec4 = UnetBlockI(1024, 1024, 512) self.dec3 = UnetBlockI(512, 512, 256) self.dec2 = UnetBlockI(256, 256, 128) self.dec1 = UnetBlockI(128, 64, 64) self.hc = HyperColumnI([1024, 512, 256, 128], [32] * 4) self.drop = nn.Dropout2d(0.2) self.final_conv = conv_layer(64 + 32 * 4, self.n_classes + 1, ks=1, norm_type=None, use_activ=False) self.logit = nn.Sequential( nn.Dropout2d(0.5), nn.Conv2d(5120 * 2, 64, kernel_size=1), nn.ReLU(inplace=True), GBnorm_2d(64), nn.Conv2d(64, self.n_classes, kernel_size=1)) to_Mish(self.dec4), to_Mish(self.dec3), to_Mish(self.dec2), to_Mish( self.dec1) to_Mish(self.final_conv), to_Mish(self.middle_conv) apply_init(self.middle_conv, nn.init.kaiming_normal_) apply_init(self.dec4, nn.init.kaiming_normal_) apply_init(self.dec3, nn.init.kaiming_normal_) apply_init(self.dec2, nn.init.kaiming_normal_) apply_init(self.dec1, nn.init.kaiming_normal_) apply_init(self.final_conv, nn.init.kaiming_normal_) apply_init(self.hc, nn.init.kaiming_normal_)
def __init__(self, senet_version='se_resnext50_32x4d', input_size=128, num_classes=340, pretrained='imagenet', dropout=0.): super().__init__() if senet_version == 'se_resnext50_32x4d': self.model = se_resnext50_32x4d(pretrained=pretrained) elif senet_version == 'se_resnext101_32x4d': self.model = se_resnext101_32x4d(pretrained=pretrained) self.features = self.model.features self.relu = nn.ReLU() self.avg_pool = nn.AvgPool2d(input_size // 32, stride=1, padding=0) self.dropout = nn.Dropout(p=dropout) self.last_linear = nn.Linear(2048, num_classes)
def __init__(self, num_classes): super(ArcSEResnext50, self).__init__() self.feature_extr = pm.se_resnext50_32x4d() self.pool = torch.nn.AdaptiveAvgPool2d((1, 1)) self.metric = ArcMarginProduct(in_features=2048, out_features=num_classes) weights = torch.zeros(64, 6, 7, 7, dtype=torch.float32) weights[:, 0, :, :] = self.feature_extr.layer0.conv1.weight[:, 0, :, :] weights[:, 1, :, :] = self.feature_extr.layer0.conv1.weight[:, 0, :, :] weights[:, 2, :, :] = self.feature_extr.layer0.conv1.weight[:, 1, :, :] weights[:, 3, :, :] = self.feature_extr.layer0.conv1.weight[:, 1, :, :] weights[:, 4, :, :] = self.feature_extr.layer0.conv1.weight[:, 2, :, :] weights[:, 5, :, :] = self.feature_extr.layer0.conv1.weight[:, 2, :, :] self.feature_extr.layer0.conv1 = nn.Conv2d(6, 64, (7, 7), (2, 2), (3, 3), bias=False) self.feature_extr.layer0.conv1.weight = torch.nn.Parameter(weights)
def _get_serresnext(self): encoder = se_resnext50_32x4d( num_classes=1000, pretrained='imagenet' if self.pretrained else None) bottom_channel_nr = 2048 conv1 = nn.Sequential(encoder.layer0, SCSEBlock(self.num_filters * 2)) conv2 = nn.Sequential(encoder.layer1, SCSEBlock(self.num_filters * 8)) conv3 = nn.Sequential(encoder.layer2, SCSEBlock(self.num_filters * 16)) conv4 = nn.Sequential(encoder.layer3, SCSEBlock(self.num_filters * 32)) conv5 = nn.Sequential(encoder.layer4, SCSEBlock(self.num_filters * 64)) return { 'conv1': conv1, 'conv2': conv2, 'conv3': conv3, 'conv4': conv4, 'conv5': conv5, 'bottom_channel_nr': bottom_channel_nr }
def __init__(self, num_classes=6, dropout_p=0.1): super(SEResNeXt50, self).__init__() backbone = se_resnext50_32x4d(num_classes=1000, pretrained='imagenet') self.layer0 = backbone.layer0 self.layer1 = backbone.layer1 self.layer2 = backbone.layer2 self.layer3 = backbone.layer3 self.layer4 = backbone.layer4 self.aspp = ASPP(inplanes=2048, output_stride=16, dropout=None) # self.spp = SPP(input_channels=256) # self.spp = SPP(input_channels=2048) self.concat_pool = AdaptiveConcatPool2d() self.dropout = nn.Dropout(dropout_p) if dropout_p is not None else None self.fc1 = nn.Linear(512, 256) # self.fc1 = nn.Linear(2048 * 4, 256) self.fc2 = nn.Linear(256, num_classes) self.relu = nn.ReLU() self.activation = nn.Sigmoid()
def get_model(name): if name == 'effb3': model = EfficientNet.from_pretrained('efficientnet-b3') model._fc = torch.nn.Linear(1536, 2) return model if name == 'effb1': model = EfficientNet.from_pretrained('efficientnet-b1') model._fc = torch.nn.Linear(1280, 2) return model if name == 'dnet161': model = pm.densenet161() model.last_linear = torch.nn.Linear(2048, 2) return model if name == 'effb0': model = EfficientNet.from_pretrained('efficientnet-b0') model._fc = torch.nn.Linear(1280, 2) return model if name == 'dnet121': model = pm.densenet121(pretrained='imagenet') model.last_linear = torch.nn.Linear(1024, 2) return model if name == 'se_resnext50_32x4d': model = pm.se_resnext50_32x4d() model.last_linear = torch.nn.Linear(2048, 2) return model if name == 'effb7': model = EfficientNet.from_pretrained('efficientnet-b7') model._fc = torch.nn.Linear(2048, 2) return model raise Exception('model {} is not supported'.format(name))
def __init__(self, encoder_settings, num_classes=4, seql=64, pre=True, **kwargs): super(UneXt50SE_c, self).__init__() self.n_classes = num_classes m = pretrainedmodels.se_resnext50_32x4d( pretrained='imagenet' if pre else None) self.enc0 = nn.Sequential(m.layer0.conv1, m.layer0.bn1, nn.ReLU(inplace=True)) self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True) self.enc1 = m.layer1 # 256 self.enc2 = m.layer2 # 512 self.enc3 = m.layer3 # 1024 self.enc4 = m.layer4 # 2048 self.middle_conv = ASPPI(2048, 1024) self.logit = nn.Sequential( nn.Dropout2d(0.5), nn.Conv2d(5120 * 2, 64, kernel_size=1), nn.ReLU(inplace=True), GBnorm_2d(64), nn.Conv2d(64, self.n_classes, kernel_size=1)) self.drop = nn.Dropout2d(0.2) self.final_conv_c = conv_layer(1024, self.n_classes + 1, ks=3, norm_type=None, use_activ=False) to_Mish(self.final_conv_c), to_Mish(self.middle_conv) apply_init(self.final_conv_c, nn.init.kaiming_normal_)
def select_network(network, num_classes=1000): if network == 'resnet18': backbone = models.resnet18(pretrained=True) model = Resnet18(backbone, num_classes=num_classes) return model # metric_fc = ArcMarginProduct(512, Num_classes, s=30, m=0.5, easy_margin=False) elif network == 'resnet50': backbone = models.resnet50(pretrained=True) model = Resnet50(backbone, num_classes=num_classes) return model elif network == 'se_resnext50_32x4d': backbone = pretrainedmodels.se_resnext50_32x4d(pretrained='imagenet') model = Se_resnext50_32x4d(backbone, num_classes=num_classes) return model elif network == 'resnest50': model = resnest50(pretrained=True, num_classes=num_classes) # model = resnest50(num_classes=num_classes) return model elif network == 'resnest101': model = resnest101(pretrained=True, num_classes=num_classes) # model = resnest101(num_classes=num_classes) return model elif network == 'efficientb0': model = EfficientNet.from_pretrained('efficientnet-b0', num_classes=num_classes) return model elif network == 'efficientb5': model = EfficientNet.from_pretrained('efficientnet-b5', num_classes=num_classes) return model