def __init__(self,
num_classes=3,
num_channels=3,
is_deconv=False,
decoder_kernel_size=4,
checkpoint='weights/resnet18_scale_fold0_best.pth.tar',
noise_multiplier=1.0):
super().__init__()
filters = [64 * 2, 128 * 2, 256 * 2]
self.noise_multiplier = noise_multiplier
resnet_student = load_model('resnet18', pretrained=True)
resnet_student = FineTuneModel(resnet_student, 'resnet34', 512)
resnet_student = torch.nn.DataParallel(resnet_student)
checkpoint = torch.load(checkpoint)
print('Model loaded from epoch {} checkpoint'.format(
checkpoint['epoch']))
resnet_student.load_state_dict(checkpoint['state_dict'])
resnet_student = resnet_student.module
self.mean = (0.485, 0.456, 0.406)
self.std = (0.229, 0.224, 0.225)
# self.reverse_mean = [-0.485, -0.456, -0.406]
# self.reverse_std = [1/0.229, 1/0.224, 1/0.225]
self.firstconv = resnet_student.features[0]
self.firstbn = resnet_student.features[1]
self.firstrelu = resnet_student.features[2]
self.firstmaxpool = resnet_student.features[3]
self.encoder1 = resnet_student.features[4]
self.encoder2 = resnet_student.features[5]
self.encoder3 = resnet_student.features[6]
self.final_avg = nn.AvgPool2d(7, stride=1)
self.classifier = resnet_student.classifier[0]
# Decoder
self.decoder3 = DecoderBlock(in_channels=filters[2],
n_filters=filters[1],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder2 = DecoderBlock(in_channels=filters[1],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder1 = DecoderBlock(in_channels=filters[0],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
# Final Classifier
self.finaldeconv1 = nn.ConvTranspose2d(filters[0], 32, 3, stride=2)
self.finalrelu1 = nonlinearity(inplace=True)
self.finalconv2 = nn.Conv2d(32, 32, 3)
self.finalrelu2 = nonlinearity(inplace=True)
self.finalconv3 = nn.Conv2d(32, num_classes, 2, padding=1)
def __init__(self,
num_classes,
num_channels=3,
is_deconv=False,
decoder_kernel_size=3,
pretrained=True):
super().__init__()
filters = [256, 512, 1024, 2048]
resnet = models.resnet152(pretrained=pretrained)
self.mean = (0.485, 0.456, 0.406)
self.std = (0.229, 0.224, 0.225)
# self.firstconv = resnet.conv1
# assert num_channels == 3, "num channels not used now. to use changle first conv layer to support num channels other then 3"
# try to use 8-channels as first input
if num_channels == 3:
self.firstconv = resnet.conv1
else:
self.firstconv = nn.Conv2d(num_channels,
64,
kernel_size=(7, 7),
stride=(2, 2),
padding=(3, 3))
self.firstbn = resnet.bn1
self.firstrelu = resnet.relu
self.firstmaxpool = resnet.maxpool
self.encoder1 = resnet.layer1
self.encoder2 = resnet.layer2
self.encoder3 = resnet.layer3
self.encoder4 = resnet.layer4
# Decoder
self.decoder4 = DecoderBlock(in_channels=filters[3],
n_filters=filters[2],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder3 = DecoderBlock(in_channels=filters[2],
n_filters=filters[1],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder2 = DecoderBlock(in_channels=filters[1],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder1 = DecoderBlock(in_channels=filters[0],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
# Final Classifier
self.finaldeconv1 = nn.ConvTranspose2d(filters[0], 32, 3, stride=2)
self.finalrelu1 = nonlinearity(inplace=True)
self.finalconv2 = nn.Conv2d(32, 32, 3)
self.finalrelu2 = nonlinearity(inplace=True)
self.finalconv3 = nn.Conv2d(32, num_classes, 2, padding=1)
def __init__(self,
num_classes,
num_channels=3,
is_deconv=False,
decoder_kernel_size=4,
pretrained=True):
super().__init__()
filters = [64, 128, 256, 512]
resnet = models.resnet18(pretrained=pretrained)
self.mean = (0.485, 0.456, 0.406)
self.std = (0.229, 0.224, 0.225)
if num_channels == 3:
self.firstconv = resnet.conv1
else:
self.firstconv = nn.Conv2d(num_channels,
64,
kernel_size=(7, 7),
stride=(2, 2),
padding=(3, 3))
self.firstbn = resnet.bn1
self.firstrelu = resnet.relu
self.firstmaxpool = resnet.maxpool
self.encoder1 = resnet.layer1
self.encoder2 = resnet.layer2
self.encoder3 = resnet.layer3
self.encoder4 = resnet.layer4
# Decoder
self.decoder4 = DecoderBlock(in_channels=filters[3],
n_filters=filters[2],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder3 = DecoderBlock(in_channels=filters[2],
n_filters=filters[1],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder2 = DecoderBlock(in_channels=filters[1],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder1 = DecoderBlock(in_channels=filters[0],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
# Final Classifier
self.finaldeconv1 = nn.ConvTranspose2d(filters[0], 32, 3, stride=2)
self.finalrelu1 = nonlinearity(inplace=True)
self.finalconv2 = nn.Conv2d(32, 32, 3)
self.finalrelu2 = nonlinearity(inplace=True)
self.finalconv3 = nn.Conv2d(32, num_classes, 2, padding=1)
def __init__(self,
num_classes,
num_channels=3,
is_deconv=False,
decoder_kernel_size=4,
pretrained=True):
super().__init__()
filters = [256, 512, 1024, 2048]
# only pretrained
resnet = resnext101_32x4d(num_classes=1000, pretrained='imagenet')
self.mean = (0.485, 0.456, 0.406)
self.std = (0.229, 0.224, 0.225)
self.stem = resnet.stem
self.encoder1 = resnet.layer1
self.encoder2 = resnet.layer2
self.encoder3 = resnet.layer3
self.encoder4 = resnet.layer4
# Decoder
self.decoder4 = DecoderBlock(in_channels=filters[3],
n_filters=filters[2],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder3 = DecoderBlock(in_channels=filters[2],
n_filters=filters[1],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder2 = DecoderBlock(in_channels=filters[1],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder1 = DecoderBlock(in_channels=filters[0],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
# Final Classifier
self.finaldeconv1 = nn.ConvTranspose2d(filters[0], 32, 3, stride=2)
self.finalrelu1 = nonlinearity(inplace=True)
self.finalconv2 = nn.Conv2d(32, 32, 3)
self.finalrelu2 = nonlinearity(inplace=True)
self.finalconv3 = nn.Conv2d(32, num_classes, 2, padding=1)
def __init__(self, num_filters=32, pretrained=True, num_classes=3):
"""
:param num_classes:
:param num_filters:
:param pretrained:
False - no pre-trained network is used
True - encoder is pre-trained with VGG11
"""
super().__init__()
self.pool = nn.MaxPool2d(2, 2)
self.encoder = models.vgg11(pretrained=pretrained).features
self.relu = self.encoder[1]
self.conv1 = self.encoder[0]
self.conv2 = self.encoder[3]
self.conv3s = self.encoder[6]
self.conv3 = self.encoder[8]
self.conv4s = self.encoder[11]
self.conv4 = self.encoder[13]
self.conv5s = self.encoder[16]
self.conv5 = self.encoder[18]
self.center = DecoderBlock(num_filters * 8 * 2, num_filters * 8 * 2,
num_filters * 8)
self.dec5 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2,
num_filters * 8)
self.dec4 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2,
num_filters * 4)
self.dec3 = DecoderBlock(num_filters * (8 + 4), num_filters * 4 * 2,
num_filters * 2)
self.dec2 = DecoderBlock(num_filters * (4 + 2), num_filters * 2 * 2,
num_filters)
self.dec1 = ConvRelu(num_filters * (2 + 1), num_filters)
self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
self.mean = (0.485, 0.456, 0.406)
self.std = (0.229, 0.224, 0.225)
def __init__(self,
num_classes,
num_channels=3,
is_deconv=False,
decoder_kernel_size=4,
pretrained=True):
super().__init__()
filters = [384, 768, 2112, 2208]
densenet = models.densenet161(pretrained=pretrained)
self.mean = (0.485, 0.456, 0.406)
self.std = (0.229, 0.224, 0.225)
if num_channels == 3:
self.firstconv = densenet.features.conv0
else:
self.firstconv = nn.Conv2d(num_channels,
64,
kernel_size=(7, 7),
stride=(2, 2),
padding=(3, 3))
self.stem = nn.Sequential(
self.firstconv,
densenet.features.norm0,
densenet.features.relu0,
densenet.features.pool0,
)
self.encoder1 = nn.Sequential(densenet.features.denseblock1)
self.encoder2 = nn.Sequential(densenet.features.transition1,
densenet.features.denseblock2)
self.encoder3 = nn.Sequential(densenet.features.transition2,
densenet.features.denseblock3)
self.encoder4 = nn.Sequential(densenet.features.transition3,
densenet.features.denseblock4)
# Decoder
self.decoder4 = DecoderBlock(in_channels=filters[3],
n_filters=filters[2],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder3 = DecoderBlock(in_channels=filters[2],
n_filters=filters[1],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder2 = DecoderBlock(in_channels=filters[1],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder1 = DecoderBlock(in_channels=filters[0],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
# Final Classifier
self.finaldeconv1 = nn.ConvTranspose2d(filters[0], 32, 3, stride=2)
self.finalrelu1 = nonlinearity(inplace=True)
self.finalconv2 = nn.Conv2d(32, 32, 3)
self.finalrelu2 = nonlinearity(inplace=True)
self.finalconv3 = nn.Conv2d(32, num_classes, 2, padding=1)