def __init__(self, in_channels, num_classes):
super(InceptionAux, self).__init__()
self.conv0 = BasicConv2d(in_channels, 128, kernel_size=1)
self.conv1 = BasicConv2d(128, 768, kernel_size=5)
self.conv1.stddev = 0.01
self.fc = nn.Linear(768, num_classes)
self.fc.stddev = 0.001
def __init__(self, num_classes=1000, transform_input=False, in_channels=3):
super(Inception3XS, self).__init__()
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(in_channels,
32,
kernel_size=3,
stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.fc = nn.Linear(288, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
import scipy.stats as stats
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.numel()))
values = values.view(m.weight.size())
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def __init__(self):
super(Inception3, self).__init__()
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
# if aux_logits:
# self.AuxLogits = InceptionAux(768, num_classes)
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
import scipy.stats as stats
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.data.numel()))
values = values.view(m.weight.data.size())
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, config, anchors, num_cls, transform_input=False):
nn.Module.__init__(self)
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
# aux_logits
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
self.conv = nn.Conv2d(2048, model.output_channels(len(anchors), num_cls), 1)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.data.numel()))
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, num_classes=NLABEL, aux_logits=False, transform_input=False):
super(Inception3, self).__init__()
self.aux_logits = aux_logits
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(4, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
if aux_logits:
self.AuxLogits = InceptionAux(768, num_classes)
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
self.fc = nn.Linear(2048, num_classes)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
import scipy.stats as stats
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.numel()))
values = values.view(m.weight.size())
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def __init__(self, in_channels):
super(InceptionBlock, self).__init__()
self.branch3x3 = BasicConv2d(in_channels, 384, kernel_size=3, stride=2)
self.branch3x3dbl_1 = BasicConv2d(in_channels, 64, kernel_size=1)
self.branch3x3dbl_2 = BasicConv2d(64, 96, kernel_size=3, padding=1)
self.branch3x3dbl_3 = BasicConv2d(96, 96, kernel_size=3, stride=2)
self.maxpool = torch.nn.MaxPool2d(kernel_size=3, stride=2, return_indices=True)
def __init__(self,
num_classes=1000,
aux_logits=True,
transform_input=False,
in_channels=3):
super().__init__()
self.aux_logits = aux_logits
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(in_channels,
32,
kernel_size=3,
stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
if aux_logits:
self.AuxLogits = InceptionAux(288, num_classes)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
self.Vessel_Preconv = nn.Conv2d(1, 768, 1, bias=False)
self.VesselMultiplier = nn.Conv2d(in_channels=1,
out_channels=768,
kernel_size=1,
bias=False)
self.VesselMultiplier.weight.data.copy_(torch.ones((768, 1, 1, 1)))
self.VesselMultiplier.weight.requires_grad = False
self.Vessel = BasicConv3d(768,
768,
kernel_size=(2, 3, 3),
padding=(0, 1, 1))
self.fc = nn.Linear(768, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
import scipy.stats as stats
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.numel()))
values = values.view(m.weight.size())
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
m = self.Vessel_Preconv
values = torch.ones(m.weight.numel())
values = values.view(m.weight.size())
m.weight.data.copy_(values)
for p in m.parameters():
p.requires_grad = False
def get_model(args):
if args.model_name == 'inception':
if args.pre_trained_checkpoint is not None:
model = models.inception_v3(pretrained=False, transform_input=False)
model.fc = nn.Linear(2048, args.n_outputs)
model.AuxLogits = InceptionAux(768, args.n_outputs)
model.aux_logits = False
new_conv = BasicConv2d(1, 32, kernel_size=3, stride=2)
model.Conv2d_1a_3x3 = new_conv
sd = torch.load(args.pre_trained_checkpoint)['model']
model.load_state_dict(sd)
else:
model = models.inception_v3(pretrained=True, transform_input=False)
model.fc = nn.Linear(2048, args.n_outputs)
model.AuxLogits = InceptionAux(768, args.n_outputs)
model.aux_logits = False
new_conv = BasicConv2d(1, 32, kernel_size=3, stride=2)
first_layer_sd = model.Conv2d_1a_3x3.state_dict()
first_layer_sd['conv.weight'] = first_layer_sd['conv.weight'].mean(dim=1, keepdim=True)
new_conv.load_state_dict(first_layer_sd)
model.Conv2d_1a_3x3 = new_conv
elif args.model_name == 'resnet':
if args.pre_trained_checkpoint is not None:
model = models.resnet50(pretrained=False)
model.fc = nn.Linear(in_features=2048, out_features=args.n_outputs, bias=True)
new_conv = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
model.conv1 = new_conv
sd = torch.load(args.pre_trained_checkpoint)['model']
model.load_state_dict(sd)
else:
model = models.resnet50(pretrained=True)
model.fc = nn.Linear(in_features=2048, out_features=args.n_outputs, bias=True)
new_conv = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
first_layer_sd = model.conv1.state_dict()
first_layer_sd['weight'] = first_layer_sd['weight'].mean(dim=1, keepdim=True)
new_conv.load_state_dict(first_layer_sd)
model.conv1 = new_conv
elif args.model_name == 'resnext':
if args.pre_trained_checkpoint is not None:
model = models.resnext50_32x4d(pretrained=False)
model.fc = nn.Linear(in_features=2048, out_features=args.n_outputs, bias=True)
new_conv = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
model.conv1 = new_conv
sd = torch.load(args.pre_trained_checkpoint)['model']
model.load_state_dict(sd)
else:
model = models.resnext50_32x4d(pretrained=True)
model.fc = nn.Linear(in_features=2048, out_features=args.n_outputs, bias=True)
new_conv = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
first_layer_sd = model.conv1.state_dict()
first_layer_sd['weight'] = first_layer_sd['weight'].mean(dim=1, keepdim=True)
new_conv.load_state_dict(first_layer_sd)
model.conv1 = new_conv
return model
def __init__(self, in_channels=2048):
super(SpatialConvolution, self).__init__()
self.branch1x1 = BasicConv2d(in_channels, 1024, kernel_size=1)
self.branch9x9_1 = BasicConv2d(in_channels, 512, kernel_size=1)
self.branch9x9_2a = BasicConv2d(512,
512,
kernel_size=(1, 9),
padding=(0, 4))
self.branch9x9_2b = BasicConv2d(512,
512,
kernel_size=(9, 1),
padding=(4, 0))
def __init__(self,
config_channels,
anchors,
num_cls,
transform_input=False):
nn.Module.__init__(self)
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
# aux_logits
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
self.conv = nn.Conv2d(2048,
model.output_channels(len(anchors), num_cls), 1)
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
stddev = m.stddev if hasattr(m, 'stddev') else 0.1
X = stats.truncnorm(-2, 2, scale=stddev)
values = torch.Tensor(X.rvs(m.weight.data.numel()))
m.weight.data.copy_(values)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
if config_channels.config.getboolean('model', 'pretrained'):
url = _model.model_urls['inception_v3_google']
logging.info('use pretrained model: ' + url)
state_dict = self.state_dict()
for key, value in torch.utils.model_zoo.load_url(url).items():
if key in state_dict:
state_dict[key] = value
self.load_state_dict(state_dict)
def __init__(self, pre=True):
super().__init__()
self.encoder = pretrainedmodels.__dict__['inceptionv4'](num_classes=1000, pretrained='imagenet')
conv1 = BasicConv2d(4, 32, kernel_size=3, stride=2)
if pre:
w = self.encoder.features[0].conv.weight
conv1.conv.weight = nn.Parameter(torch.cat((w, 0.5 * (w[:, :1, :, :] + w[:, 2:, :, :])), dim=1))
self.encoder.features[0].conv = conv1
self.last_linear = nn.Linear(1536, num_class())
pass
def __init__(self, pre=True):
super().__init__()
self.encoder = torchvision.models.inception_v3(pretrained=pre)
conv1 = BasicConv2d(4, 32, kernel_size=3, stride=2)
if pre:
w = self.encoder.Conv2d_1a_3x3.conv.weight
conv1.conv.weight = nn.Parameter(torch.cat((w, 0.5 * (w[:, :1, :, :] + w[:, 2:, :, :])), dim=1))
self.encoder.Conv2d_1a_3x3 = conv1
self.encoder.AuxLogits = InceptionAux(768, num_class())
self.encoder.fc = nn.Linear(2048, num_class())
def __init__(self, in_channels=2048, spatial_kernel=9):
super(SpatialConvolution_v1, self).__init__()
out_channels1 = in_channels // 2
out_channels2 = in_channels // 4
self.branch1x1 = BasicConv2d(in_channels, out_channels1, kernel_size=1)
self.branchNxN_1 = BasicConv2d(in_channels,
out_channels2,
kernel_size=1)
spatial_padding = spatial_kernel // 2
self.branchNxN_2a = BasicConv2d(out_channels2,
out_channels2,
kernel_size=(1, spatial_kernel),
padding=(0, spatial_padding))
self.branchNxN_2b = BasicConv2d(out_channels2,
out_channels2,
kernel_size=(spatial_kernel, 1),
padding=(spatial_padding, 0))
def __init__(self, num_classes=80, aux_logits=True, transform_input=False, apply_avgpool=False):
super(Inception3, self).__init__()
self.aux_logits = aux_logits
self.transform_input = transform_input
self.apply_avgpool = apply_avgpool
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
if aux_logits:
self.AuxLogits = InceptionAux(768, num_classes)
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
def get_model(args):
if args.model_name == 'inception':
if args.pre_trained_checkpoint is not None:
model = models.inception_v3(pretrained=False,
transform_input=False)
model.fc = nn.Linear(2048, args.n_outputs)
model.AuxLogits = InceptionAux(768, args.n_outputs)
model.aux_logits = False
new_conv = BasicConv2d(1, 32, kernel_size=3, stride=2)
model.Conv2d_1a_3x3 = new_conv
sd = torch.load(args.pre_trained_checkpoint)['model']
model.load_state_dict(sd)
else:
print('Missing model.')
return model
def __init__(self, in_channels, pretrained=False, version='inception_v3'):
super(Inception_BB, self).__init__()
version = version.strip()
if version == 'inception_v3':
inception = models.inception_v3(pretrained, init_weights=True)
else:
raise NotImplementedError(
'version {} is not supported as of now'.format(version))
inception.Conv2d_1a_3x3 = BasicConv2d(in_channels,
32,
kernel_size=3,
stride=2)
return_layers = {'Mixed_7c': 'out'}
self.backbone = IntermediateLayerGetter(inception, return_layers)
self.out_channels = 2048
def __init__(self,
num_classes,
M=32,
net='inception_mixed_6e',
pretrained=False):
super(WSDAN, self).__init__()
self.num_classes = num_classes
self.M = M
self.net = net
# Network Initialization
if 'inception' in net:
model = inception_v3(pretrained=pretrained)
if net == 'inception_mixed_6e':
try:
self.features = self._get_features_mixed_6e(model)
except:
traceback.print_exc()
self.num_features = 768
elif net == 'inception_mixed_7c':
self.features = self._get_features_mixed_7c(model)
self.num_features = 2048
else:
raise ValueError('Unsupported net: %s' % net)
elif 'vgg' in net:
self.features = getattr(vgg,
net)(pretrained=pretrained).get_features()
self.num_features = 512
elif 'resnet' in net:
self.features = getattr(resnet,
net)(pretrained=pretrained).get_features()
self.num_features = 512 * self.features[-1][-1].expansion
else:
raise ValueError('Unsupported net: %s' % net)
# Attention Maps
self.attentions = BasicConv2d(self.num_features, self.M, kernel_size=1)
# Bilinear Attention Pooling
self.bap = BAP(pool='GAP')
# Classification Layer
self.fc = nn.Linear(self.M * self.num_features,
self.num_classes,
bias=False)
def get_model(model_name='resnext101_32x16d_wsl', n_classes=6, raw=False):
model = None
if model_name.startswith('eff'):
model = EfficientNet.from_pretrained(model_name)
last_output_size=2048
if model_name.endswith('b1') or model_name.endswith('b0'):
last_output_size = 1280
if raw:
raise Exception('Checkout for other effnet types the channel size out last output')
elif model_name.endswith('b2'):
if raw:
model._conv_stem = Conv2d(1, 32, kernel_size=3, stride=2, bias=False)
# torch.nn.init.xavier_normal_(model._conv_stem.weight)
last_output_size = 1408
elif model_name.endswith('b4'):
if raw:
model._conv_stem = Conv2d(1, 48, kernel_size=3, stride=2, bias=False, padding=(0,1))
# torch.nn.init.xavier_normal_(model._conv_stem.weight)
last_output_size = 1792
else:
raise Exception('Checkout for other effnet types the channel size out last output')
model._fc = torch.nn.Linear(last_output_size, n_classes)
elif model_name.startswith('resnext101_32x') and model_name.endswith('wsl'):
model = torch.hub.load('facebookresearch/WSL-Images', model_name)
if raw:
model.conv1 = torch.nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
model.fc = torch.nn.Linear(2048, n_classes)
elif model_name == 'inceptionv3':
model = inceptionv3()
model.last_linear = torch.nn.Linear(2048, n_classes)
if raw:
model.Conv2d_1a_3x3 = BasicConv2d(1, 32, kernel_size=3, stride=2)
if model is None:
raise Exception('failed to instantiate model: '+ model_name)
return model
def inception_v3(num_classes,
freeze_feature_extractor=False,
use_pretrained=True,
num_channels=3):
"""Wrapper for Inception v3 architecture
Input: 229x229
WARNING: expects (299,299) sized images and has auxiliary output. See
InceptionV3 class in `opensoundscape.torch.models.cnn` for use.
Args:
num_classes:
number of output nodes for the final layer
freeze_feature_extractor:
if False (default), entire network will have gradients and can train
if True, feature block is frozen and only final layer is trained
use_pretrained:
if True, uses pre-trained ImageNet features from
Pytorch's model zoo.
num_channels:
specify channels in input sample, eg [channels h,w] sample shape
"""
model_ft = models.inception_v3(pretrained=use_pretrained)
if freeze_feature_extractor:
freeze_params(model_ft)
# Handle the auxilary net
num_ftrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
# Handle the primary net
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
if num_channels != 3:
from torchvision.models.inception import BasicConv2d
model_ft.Conv2d_1a_3x3 = BasicConv2d(num_channels,
32,
kernel_size=3,
stride=2)
return model_ft
def load_trained_inception_v3(fname):
"""Load trained inception_v3 from path to its state dictionary.
"""
model = inception_v3(pretrained=False, num_classes=2)
model.Conv2d_1a_3x3 = BasicConv2d(1, 32, kernel_size=3, stride=2)
return _load_model_from_state_dict(model, fname)
def __init__(self,
use_bottleneck=True,
bottleneck_dim=256,
new_cls=False,
class_num=1000,
aux_logits=True,
transform_input=False):
super(Inception3Fc, self).__init__()
model_inception = inception_v3(pretrained=True)
self.aux_logits = aux_logits
self.transform_input = transform_input
self.Conv2d_1a_3x3 = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.Conv2d_2a_3x3 = BasicConv2d(32, 32, kernel_size=3)
self.Conv2d_2b_3x3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
self.Conv2d_3b_1x1 = BasicConv2d(64, 80, kernel_size=1)
self.Conv2d_4a_3x3 = BasicConv2d(80, 192, kernel_size=3)
self.Mixed_5b = InceptionA(192, pool_features=32)
self.Mixed_5c = InceptionA(256, pool_features=64)
self.Mixed_5d = InceptionA(288, pool_features=64)
self.Mixed_6a = InceptionB(288)
self.Mixed_6b = InceptionC(768, channels_7x7=128)
self.Mixed_6c = InceptionC(768, channels_7x7=160)
self.Mixed_6d = InceptionC(768, channels_7x7=160)
self.Mixed_6e = InceptionC(768, channels_7x7=192)
if aux_logits:
self.AuxLogits = InceptionAux(768, class_num)
self.Mixed_7a = InceptionD(768)
self.Mixed_7b = InceptionE(1280)
self.Mixed_7c = InceptionE(2048)
self.fc = nn.Linear(2048, class_num)
# self.avgpool = model_xception.avgpool
self.feature_layers = nn.Sequential(
self.Conv2d_1a_3x3,
self.Conv2d_2a_3x3,
self.Conv2d_2b_3x3,
self.Conv2d_3b_1x1,
self.Conv2d_4a_3x3,
self.Mixed_5b,
self.Mixed_5c,
self.Mixed_5d,
self.Mixed_6a,
self.Mixed_6b,
self.Mixed_6c,
self.Mixed_6d,
self.Mixed_6e,
self.Mixed_7a,
self.Mixed_7b,
self.Mixed_7c,
)
####################
self.use_bottleneck = use_bottleneck
self.new_cls = new_cls
# print("classes inside network",new_cls)
if new_cls:
if self.use_bottleneck:
print(bottleneck_dim)
self.bottleneck = nn.Linear(model_inception.fc.in_features,
bottleneck_dim)
self.fc = nn.Linear(bottleneck_dim, class_num)
self.bottleneck.apply(init_weights)
self.fc.apply(init_weights)
self.__in_features = bottleneck_dim
else:
self.fc = nn.Linear(model_inception.fc.in_features, class_num)
self.fc.apply(init_weights)
self.__in_features = model_inception.fc.in_features
else:
self.fc = model_inception.fc
self.__in_features = model_inception.fc.in_features
