Pytorch预训练模型以及修改

import torchvision.models as models

resnet18 = models.resnet18(pretrained=False) #pretrained参数默认是False,为了代码清晰，最好还是加上参数赋值.
print resnet18 #打印网络结构
resnet18.load_state_dict(torch.load(path_params.pkl)) #其中，path_params.pkl为预训练模型参数的保存路径。

print resnet18 #打印的还是网络结构

# 注意: cnn = resnet18.load_state_dict(torch.load( path_params.pkl )) #是错误的，这样cnn将是nonetype

pre_dict = resnet18.state_dict() #按键值对将模型参数加载到pre_dict

print for k, v in pre_dict.items(): # 打印模型参数

for k, v in pre_dict.items():
　　print k  #打印模型每层命名

# model是自己定义好的新网络模型，将pretrained_dict和model_dict中命名一致的层加入

# pretrained_dict（包括参数)。

pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} 

# coding=UTF-8 
import torchvision.models as models 
#调用模型 
model = models.resnet50(pretrained=True) 
#提取fc层中固定的参数 
fc_features = model.fc.in_features 
#修改类别为9 
model.fc = nn.Linear(fc_features, 9)

torch.save(model_object, 'model.pkl')  # 保存整个神经网络的结构和模型参数 

model = torch.load('model.pkl') # 重载并初始化新的神经网络对象。 

torch.save(model_object.state_dict(), 'params.pkl')  # 只保存神经网络的模型参数

#首先自己新定义一个网络
class CNN(nn.Module):
　　def __init__(self, block, layers, num_classes=9): 
    #自己新定义的CNN与继承的ResNet网络结构大体相同，即除了新增层，其他层的层名与ResNet的相同。
　
　　　self.inplanes = 64 
　　　　super(ResNet, self).__init__() #继承ResNet网络结构
　　　　self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) 
　　　　self.bn1 = nn.BatchNorm2d(64) 
　　　　self.relu = nn.ReLU(inplace=True) 
　　　　self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) 
　　　　self.layer1 = self._make_layer(block, 64, layers[0]) 
　　　　self.layer2 = self._make_layer(block, 128, layers[1], stride=2) 
　　　　self.layer3 = self._make_layer(block, 256, layers[2], stride=2) 
　　　　self.layer4 = self._make_layer(block, 512, layers[3], stride=2) 
　　　　self.avgpool = nn.AvgPool2d(7, stride=1)
　　　
     　#新增一个反卷积层 
　　　　self.convtranspose1 = nn.ConvTranspose2d(2048, 2048, kernel_size=3, stride=1, padding=1, output_padding=0, groups=1, bias=False, dilation=1) 
　　　
     　#新增一个最大池化层 
　　　　self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1) 
　　　　
       #将原来的fc层改成fclass层 
　　　　self.fclass = nn.Linear(2048, num_classes) #原来的fc层：self.fc = nn.Linear(512 * block.expansion, num_classes)
　　　　for m in self.modules(): #
　　　　　　if isinstance(m, nn.Conv2d): 
　　　　　　　　n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels #
　　　　　　　　m.weight.data.normal_(0, math.sqrt(2. / n)) 
　　　　　　elif isinstance(m, nn.BatchNorm2d): 
　　　　　　　　m.weight.data.fill_(1) 
　　　　　　　　m.bias.data.zero_() 
　　def _make_layer(self, block, planes, blocks, stride=1): 
　　　　downsample = None 
　　　　if stride != 1 or self.inplanes != planes * block.expansion: 
　　　　　　downsample = nn.Sequential( 
　　　　　　nn.Conv2d(self.inplanes, planes * block.expansion, 
　　　　　　　　　　kernel_size=1, stride=stride, bias=False), 
　　　　　　　　　　nn.BatchNorm2d(planes * block.expansion), 
　　　　　　　　　　　　) 
　　　　layers = [ ] 
　　　　layers.append(block(self.inplanes, planes, stride, downsample)) 
　　　　self.inplanes = planes * block.expansion 
　　　　for i in range(1, blocks): 
　　　　　　layers.append(block(self.inplanes, planes)) 
　　　　return nn.Sequential(*layers) 
　　def forward(self, x): 
　　　　x = self.conv1(x) 
　　　　x = self.bn1(x) 
　　　　x = self.relu(x) 
　　　　x = self.maxpool(x) 
　　　　x = self.layer1(x) 
　　　　x = self.layer2(x) 
　　　　x = self.layer3(x) 
　　　　x = self.layer4(x) 
　　　　x = self.avgpool(x) 
　　　　#3个新加层的forward 
　　　　x = x.view(x.size(0), -1) 
       
       #因为接下来的self.convtranspose1层的输入通道是2048
　　　　x = self.convtranspose1(x) 
　　　　x = self.maxpool2(x) 
　　　　x = x.view(x.size(0), -1)  
       
       #因为接下来的self.fclass层的输入通道是2048 
　　　　x = self.fclass(x) 
　　　　return x
#加载model 
resnet50 = models.resnet50(pretrained=True) 
cnn = CNN(Bottleneck, [3, 4, 6, 3]) #创建一个自己新定义的网络对象cnn。

model_dict = cnn.state_dict()  #自己新定义网络的参数

pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} #只能对层名一致的层进行“层名：参数”键值对赋值。
# 更新现有的model_dict
model_dict.update(pretrained_dict)
# 加载我们真正需要的模型参数state_dict
cnn.load_state_dict(model_dict) # cnn.load_state_dict()方法对cnn初始化，其一个重要参数strict，默认为True，表示预训练模型（model_dict）的层和自己定义的网络结构（cnn）的层严格对应相等（比如层名和维度）。
print(cnn)

count = 0
para_optim = []
for k in model.children():
　　count += 1
　　if count > 6:   # 6 should be changed properly
　　　　for param in k.parameters():
　　　　　　para_optim.append(param)
　　else:
　　　　for param in k.parameters():
　　　　　　param.requires_grad = False
optimizer = optim.RMSprop(para_optim, lr)#只对特定的层的参数进行优化更新，即选择特定的层进行finetune。
到此我们实现了PyTorch中使用预训练的模型初始化网络的一部分参数。

for param in model.parameters():
 　　param.requires_grad = False

 list ( nn.Sequential(nn.Linear(10, 20), nn.ReLU()).modules() )
 Out[9]:
 [Sequential (
 (0): Linear (10 -> 20)
 (1): ReLU ()
 ), Linear (10 -> 20), ReLU ()]
 In [10]: list( nn.Sequential(nn.Linear(10, 20), nn.ReLU()) .children() )
 Out[10]: [Linear (10 -> 20), ReLU ()]

 model_urls = {
 'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
 'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
 'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
 'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
 'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
 'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
 'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
 'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth'  }

import torch
 import torch.nn as nn
 import torchvision.models as models
vgg16 = models.vgg16(pretrained=False)
#打印出预训练模型的参数
 vgg16.load_state_dict(torch.load('vgg16-397923af.pth'))
 print('vgg16:\n', vgg16) 
modified_features = nn.Sequential(*list(vgg16.features.children())[:-1])
 # to relu5_3
 print('modified_features:\n', modified_features )#打印修改后的模型参数