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
