def load_inception(self, model_path):
"""加载Inception预训练模型;
Inception model没有features;
目前本函数不可用;"""
model = models.Inception3()
model.load_state_dict(torch.load(model_path))
return model
def test_inception_model_conv_below_conv(self):
""" Test winnowing inception model conv below conv """
model = models.Inception3()
model.eval()
input_shape = [1, 3, 299, 299]
input_channels_to_prune = [1, 3, 5, 7, 9, 15, 32, 45]
list_of_modules_to_winnow = [(model.Mixed_5b.branch3x3dbl_2.conv,
input_channels_to_prune)]
print(model.Mixed_5b.branch3x3dbl_1.conv.out_channels)
new_model, _ = winnow_model(model,
input_shape,
list_of_modules_to_winnow,
reshape=True,
in_place=False,
verbose=True)
self.assertEqual(new_model.Mixed_5b.branch3x3dbl_1.conv.out_channels,
56)
self.assertEqual(
list(new_model.Mixed_5b.branch3x3dbl_1.conv.weight.shape),
[56, 192, 1, 1])
del model
del new_model
def test_inception_model_conv_below_avgpool(self):
""" Test winnowing inception model with conv below avgpool """
model = models.Inception3()
model.eval()
input_shape = [1, 3, 299, 299]
input_channels_to_prune = [1, 3, 5, 7, 9, 15, 32, 45]
list_of_modules_to_winnow = [(model.Mixed_5b.branch_pool.conv,
input_channels_to_prune)]
print(model.Mixed_5b.branch_pool.conv)
print(model.Mixed_5b.branch_pool.conv.out_channels,
model.Mixed_5b.branch_pool.conv.in_channels)
# Call the Winnow API.
new_model, _ = winnow_model(model,
input_shape,
list_of_modules_to_winnow,
reshape=True,
in_place=False,
verbose=True)
self.assertEqual(new_model.Mixed_5b.branch_pool.conv[1].out_channels,
32)
self.assertEqual(
list(new_model.Mixed_5b.branch_pool.conv[1].weight.shape),
[32, 184, 1, 1])
del model
del new_model
def test_inception_model_conv_below_split(self):
""" Test winnowing inception model with conv below split """
model = models.Inception3()
model.eval()
input_shape = [1, 3, 299, 299]
input_channels_to_prune = [1, 3, 5, 7, 9, 15, 32, 45]
list_of_modules_to_winnow = [(model.Mixed_5b.branch3x3dbl_1.conv,
input_channels_to_prune)]
print(model.Mixed_5b.branch3x3dbl_1.conv.out_channels)
# Call the Winnow API.
new_model, _ = winnow_model(model,
input_shape,
list_of_modules_to_winnow,
reshape=True,
in_place=False,
verbose=True)
del model
del new_model
model = models.Inception3()
model.eval()
input_shape = [1, 3, 299, 299]
input_channels_to_prune = [1, 3, 5, 7, 9, 15, 32, 45]
list_of_modules_to_winnow = [(model.Mixed_5b.branch1x1.conv,
input_channels_to_prune)]
print(model.Mixed_5b.branch3x3dbl_1.conv.out_channels)
# Call the Winnow API.
new_model, _ = winnow_model(model,
input_shape,
list_of_modules_to_winnow,
reshape=True,
in_place=False,
verbose=True)
del model
del new_model
self.assertEqual(0, 0)
def test_inceptionv3_eval(self):
# replacement for models.inception_v3(pretrained=True) that does not download weights
kwargs = {}
kwargs['transform_input'] = True
kwargs['aux_logits'] = True
kwargs['init_weights'] = False
model = models.Inception3(**kwargs)
model.aux_logits = False
model.AuxLogits = None
m = torch.jit.script(model.eval())
self.checkModule(m, "inception_v3", torch.rand(1, 3, 299, 299))
def test_inception_v3_eval():
# replacement for models.inception_v3(pretrained=True) that does not download weights
kwargs = {}
kwargs['transform_input'] = True
kwargs['aux_logits'] = True
kwargs['init_weights'] = False
name = "inception_v3"
model = models.Inception3(**kwargs)
model.aux_logits = False
model.AuxLogits = None
model = model.eval()
x = torch.rand(1, 3, 299, 299)
_check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
def test_inception_v3_eval():
kwargs = {}
kwargs["transform_input"] = True
kwargs["aux_logits"] = True
kwargs["init_weights"] = False
name = "inception_v3"
model = models.Inception3(**kwargs)
model.aux_logits = False
model.AuxLogits = None
model = model.eval()
x = torch.rand(1, 3, 299, 299)
_check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None))
_check_input_backprop(model, x)
def __init__(self, k):
super(LFGAAGoogleNet, self).__init__()
self.k = k
inception_v3 = th_models.Inception3(aux_logits=False, transform_input=False)
state_dict = model_zoo.load_url(model_urls['inception_v3_google'])
state_dict_rm_aux = {k: v for k, v in state_dict.items() if 'AuxLogits' not in k}
inception_v3.load_state_dict(state_dict_rm_aux)
layers = list(inception_v3.children())[:-1]
layers.insert(3, torch.nn.MaxPool2d(3, 2))
layers.insert(6, torch.nn.MaxPool2d(3, 2))
layers.append(torch.nn.AvgPool2d(8))
self.layers_1 = torch.nn.Sequential(*layers[:3]) # 64 x 147 x 147
self.layers_2 = torch.nn.Sequential(*layers[3:6]) # 192 x 71 x 71
self.layers_3 = torch.nn.Sequential(*layers[6:10]) # 288 x 35 x 35
self.layers_4 = torch.nn.Sequential(*layers[10:15]) # 768 x 17 x 17
self.tail_layers = torch.nn.Sequential(*layers[15:])
self.extract_1 = torch.nn.Sequential(
torch.nn.MaxPool2d(kernel_size=8, stride=8, padding=-2),
torch.nn.Conv2d(64, self.k, kernel_size=1, stride=1)
)
self.extract_2 = torch.nn.Sequential(
torch.nn.MaxPool2d(kernel_size=4, stride=4),
torch.nn.Conv2d(192, self.k, kernel_size=1, stride=1)
)
self.extract_3 = torch.nn.Sequential(
torch.nn.MaxPool2d(kernel_size=2, stride=2),
torch.nn.Conv2d(288, self.k, kernel_size=1, stride=1)
)
self.extract_4 = torch.nn.Sequential(
torch.nn.Conv2d(768, self.k, kernel_size=1, stride=1)
)
self.fc1 = torch.nn.Linear(289, 1, bias=True)
self.fc2 = torch.nn.Linear(289, 1, bias=True)
self.fc3 = torch.nn.Linear(289, 1, bias=True)
self.fc4 = torch.nn.Linear(289, 1, bias=True)
self.fc5 = torch.nn.Linear(2048, 2 * k, bias=True)
self.bn1 = torch.nn.BatchNorm1d(k)
self.bn2 = torch.nn.BatchNorm1d(k)
weight_init(self.fc1,
self.fc2,
self.fc3,
self.fc4,
self.fc5)
def __init__(self, num_classes, aux_logits=True, transform_input=False,
pretrained=None, optimizer_name="Adam",
learning_rate=1e-3, loss_name="NLLLoss", metrics=None,
use_cuda=False, **kwargs):
""" Class initilization.
Parameters
----------
num_classes: int
number of classification classes.
aux_logits: bool, default False
auxiliary classifier for the training.
transform_input: bool, default False
normalize the data.
pretrained: str, default None
update the weights of the model using this state information.
optimizer_name: str, default 'Adam'
the name of the optimizer: see 'torch.optim' for a description
of available optimizer.
learning_rate: float, default 1e-3
the optimizer learning rate.
loss_name: str, default 'NLLLoss'
the name of the loss: see 'torch.nn' for a description
of available loss.
metrics: list of str
a list of extra metrics that will be computed.
use_cuda: bool, default False
wether to use GPU or CPU.
kwargs: dict
specify directly a custom 'optimizer' or 'loss'. Can also be used
to set specific optimizer parameters.
"""
self.model = models.Inception3(
num_classes=num_classes,
aux_logits=aux_logits,
transform_input=transform_input)
super().__init__(
optimizer_name=optimizer_name,
learning_rate=learning_rate,
loss_name=loss_name,
metrics=metrics,
use_cuda=use_cuda,
pretrained=pretrained,
**kwargs)
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True):
model_ft = None
input_size = 0
if model_name == "inception":
""" Inception V3
"""
model_ft = models.Inception3()
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
model_ft.aux_logits = False
return model_ft, input_size
def __init__(self, model_name, use_gpu=False):
self.model_name = model_name
self.x = process_img('./pandas.jpg')
self.use_gpu = use_gpu
if self.model_name in 'inception':
self.model_name = 'inception'
self.path = "./model_weight/inception_v3/inception_v3_google-1a9a5a14.pth"
model = models.Inception3(aux_logits=False,
transform_input=False,
init_weights=False)
model.eval()
self.model = model
self.depth = 2
elif self.model_name in 'alexnet':
self.model_name = 'alexnet'
self.path = "./model_weight/alexnet/alexnet-owt-4df8aa71.pth"
model = models.alexnet(False)
model.eval()
self.model = model
self.depth = -1
elif self.model_name in 'resnet':
self.model_name = 'resnet'
self.path = './model_weight/resnet/resnet18-f37072fd.pth'
model = models.resnet18(False)
model.eval()
self.model = model
self.depth = 2
else:
print("Wrong model name")
if self.use_gpu:
self.model = self.model.to(0)
# self.x = self.x.cuda()
self.x = self.x.to(0)
def _get_untrained_model(model_name, num_classes):
"""
Primarily, this method exists to return an untrained / vanilla version of a specified (pretrained) model.
This is on best-attempt basis only and may be out of sync with actual model definitions. The code is manually maintained.
:param model_name: Lower-case model names are pretrained by convention.
:param num_classes: Number of classes to initialize the vanilla model with.
:return: default model for the model_name with custom number of classes
"""
if model_name.startswith('bninception'):
return classification.BNInception(num_classes=num_classes)
elif model_name.startswith('densenet'):
return torch_models.DenseNet(num_classes=num_classes)
elif model_name.startswith('dpn'):
return classification.DPN(num_classes=num_classes)
elif model_name.startswith('inceptionresnetv2'):
return classification.InceptionResNetV2(num_classes=num_classes)
elif model_name.startswith('inception_v3'):
return torch_models.Inception3(num_classes=num_classes)
elif model_name.startswith('inceptionv4'):
return classification.InceptionV4(num_classes=num_classes)
elif model_name.startswith('nasnetalarge'):
return classification.NASNetALarge(num_classes=num_classes)
elif model_name.startswith('nasnetamobile'):
return classification.NASNetAMobile(num_classes=num_classes)
elif model_name.startswith('pnasnet5large'):
return classification.PNASNet5Large(num_classes=num_classes)
elif model_name.startswith('polynet'):
return classification.PolyNet(num_classes=num_classes)
elif model_name.startswith('pyresnet'):
return classification.PyResNet(num_classes=num_classes)
elif model_name.startswith('resnet'):
return torch_models.ResNet(num_classes=num_classes)
elif model_name.startswith('resnext101_32x4d'):
return classification.ResNeXt101_32x4d(num_classes=num_classes)
elif model_name.startswith('resnext101_64x4d'):
return classification.ResNeXt101_64x4d(num_classes=num_classes)
elif model_name.startswith('se_inception'):
return classification.SEInception3(num_classes=num_classes)
elif model_name.startswith('se_resnext50_32x4d'):
return classification.se_resnext50_32x4d(num_classes=num_classes,
pretrained=None)
elif model_name.startswith('se_resnext101_32x4d'):
return classification.se_resnext101_32x4d(num_classes=num_classes,
pretrained=None)
elif model_name.startswith('senet154'):
return classification.senet154(num_classes=num_classes,
pretrained=None)
elif model_name.startswith('se_resnet50'):
return classification.se_resnet50(num_classes=num_classes,
pretrained=None)
elif model_name.startswith('se_resnet101'):
return classification.se_resnet101(num_classes=num_classes,
pretrained=None)
elif model_name.startswith('se_resnet152'):
return classification.se_resnet152(num_classes=num_classes,
pretrained=None)
elif model_name.startswith('squeezenet1_0'):
return torch_models.squeezenet1_0(num_classes=num_classes,
pretrained=False)
elif model_name.startswith('squeezenet1_1'):
return torch_models.squeezenet1_1(num_classes=num_classes,
pretrained=False)
elif model_name.startswith('xception'):
return classification.Xception(num_classes=num_classes)
else:
raise ValueError(
'No vanilla model found for model name: {}'.format(model_name))
print('Testing complete in {:.1f}m {:.4f}s'.format(time_elapsed // 60,
time_elapsed % 60))
print('-' * 10)
print('Number of parameters in the model %d ' % (get_num_params(model)))
return mean_test_loss # , mean_test_loss, std_test_acc
# ### Inception network model
# #### Pretrained Inception model
# In[14]:
model = models.Inception3()
fc = nn.Linear(in_features=2048, out_features=2)
model.fc = fc
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
optimizer.scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min')
# In[15]:
get_num_params(model)
# In[16]:
testing = test_model(model, test_loader)
def forward(self, x):
x = models.Inception3(1, False)
x = self.sigmoid(x)
return x
def __init__(self,
num_classes=3,
num_level=2,
pool_type='max_pool',
use_spp=False):
super(InceptionV3, self).__init__()
self.inception = models.Inception3(num_classes=3, aux_logits=False)
del self.inception.fc
# print(self.inception._modules.keys())
# print(self.inception)
origin_dicts = torch.load(
'pth/inception_v3_google-1a9a5a14.pth') # 预训练模型中inception_v3网络的参数
model_dicts = self.inception.state_dict() # 自定义的去掉后面几层的网络的参数列表
pretrained_dicts = {
k: v
for k, v in origin_dicts.items() if k in model_dicts
} # 预训练模型参数在自定义模型中有的参数列表
model_dicts.update(pretrained_dicts) # 更新自定义的模型参数
self.inception.load_state_dict(model_dicts)
self.inception_1 = models.Inception3(num_classes=3, aux_logits=False)
del self.inception_1.fc
self.inception_1.Conv2d_1a_3x3.conv = nn.Conv2d(1,
32,
kernel_size=(3, 3),
stride=(2, 2),
bias=False)
model_dicts = self.inception_1.state_dict() # 自定义的去掉后面几层的网络的参数列表
pretrained_dicts = {
k: v
for k, v in origin_dicts.items() if k in model_dicts
} # 预训练模型参数在自定义模型中有的参数列表
layer1 = pretrained_dicts['Conv2d_1a_3x3.conv.weight']
new = torch.zeros(32, 1, 3, 3)
for i, output_channel in enumerate(layer1):
new[i] = 0.299 * output_channel[0] + 0.587 * output_channel[
1] + 0.114 * output_channel[2]
pretrained_dicts['Conv2d_1a_3x3.conv.weight'] = new
model_dicts.update(pretrained_dicts) # 更新自定义的模型参数
self.inception_1.load_state_dict(model_dicts)
self.conv1_fusion = nn.Conv2d(6144,
256,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(256)
self.relu1_fusion = nn.ReLU(inplace=True)
self.conv2_fusion = nn.Conv2d(256,
128,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(128)
self.relu2_fusion = nn.ReLU(inplace=True)
self.downsample = nn.Sequential(
nn.Conv2d(6144,
128,
kernel_size=1,
stride=1,
padding=0,
bias=False),
nn.BatchNorm2d(128),
)
self.conv_fusion = nn.Sequential(
nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0, bias=False),
nn.ReLU(inplace=True),
)
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(64 * 2 * 2, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
self.use_spp = use_spp
if use_spp:
self.num_level = num_level
self.pool_type = pool_type
self.num_grid = self._cal_num_grids(num_level)
self.spp_layer = SpatialPyramidPooling2d(num_level)
self.classifier_spp = nn.Sequential(
nn.Dropout(),
nn.Linear(64 * self.num_grid, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
