文章目录
这里关于迁移学习与微调的内容不再细说，有关概念可以参考：https://blog.csdn.net/weixin_44751294/article/details/116844391
1. 迁移学习
这里介绍迁移学习调用模型的我用过的方法，关键步骤是pretrained=True，使用预训练的参数。
1.1 使用list列表直接截取
这种方法直接使用了list截取了前面部分的网络结构，然后用Flatten()对数据进行处理，再添加最后一层全连接层来实现分类
trained_model = resnet18(pretrained=True)
model = nn.Sequential(*list(trained_model.children())[:-1], # torch.Size([32, 512, 1, 1])
Flatten(), # torch.Size([32, 512])
nn.Linear(512, 5) # torch.Size([32, 5])
)
其中，Flatten的代码如下：
# 打平操作
class Flatten(nn.Module):
def __init__(self):
super(Flatten, self).__init__()
def forward(self, x):
shape = torch.prod(torch.tensor(x.shape[1:])).item()
return x.view(-1, shape)
1.2 直接对结构进行修改
同样是使用迁移学习，这种方法不需要使用什么特别的函数，直接用自定义的全连接层替换原本resnet的全连接层即可，比较方便。
finetune_net = torchvision.models.resnet18(pretrained=True)
finetune_net.fc = nn.Linear(finetune_net.fc.in_features, 2)
直接打印模型print(finetune_net)，或者通过finetune_net.modules即可输出修改后的网络结构，如下图所示：
比如：
# 定义网络结构
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool1 = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.pool2 = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
self.initialize_weights()
# for m in self.modules():
# print(m)
def forward(self, x):
x = self.pool1(F.relu(self.conv1(x)))
x = self.pool2(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
# 定义权值初始化
def initialize_weights(self):
# 其中self.modules()展示网络的层结构
for m in self.modules():
# 对nn.Conv2d层进行处理
if isinstance(m, nn.Conv2d):
# 采用 torch.nn.init.xavier_normal 方法对该层的 weight 进行初始化
torch.nn.init.xavier_normal_(m.weight.data)
# 并判断是否存在偏置(bias)，若存在，将 bias 初始化为全 0
if m.bias is not None:
m.bias.data.zero_()
# 对BatchNorm2d层进行处理
elif isinstance(m, nn.BatchNorm2d):
# 对于BatchNorm2d，其是不需要bias的，所以对应的bias设置为0；其他设置为1，以下是两种设置方法，功能是一样的
# 方法1：
m.weight.data.fill_(1)
m.bias.data.zero_()
# 方法2：使用常数初始化
# nn.init.constant_(m.weight, 1)
# nn.init.constant_(m.bias, 0)
# 对Linear层进行处理
elif isinstance(m, nn.Linear):
# 正态分布初始化,使值服从正态分布 N(mean, std)
torch.nn.init.normal_(m.weight.data, 0, 0.01)
m.bias.data.zero_()
net = Net()
# self.modules()结果展示如下
net.modules
<bound method Module.modules of Net(
(conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)>
2. 微调
对于加载预训练的参数，我也使用过两种方法，这里记录一下。
在此之前，需要注意，新增加的全连接层的参数是随机的，所以需要对其进行初始化操作，这里使用Xavier均匀分布（avier 初始化方法中服从均匀分布 U(−a,a)）：
nn.init.xavier_uniform_(finetune_net.fc.weight)
输出：
Parameter containing:
tensor([[ 0.1061, -0.0440, 0.0247, ..., 0.0166, 0.0326, -0.0786],
[-0.0324, -0.0513, -0.0037, ..., -0.0276, -0.0958, 0.0679]],
requires_grad=True)
其他的初始化方法可以参考博文：pytorch中的权值初始化方法，这里不再做详细介绍。
2.1 冻结层
由于上诉例子，只是修改了最后的一层全连接层，对于该层之外的全部层可以冻结其参数，只训练最后的全连接层，做法如下。
# 冻结除最后一层外的全部参数
for name, param in finetune_net.named_parameters():
if name not in ["fc.weight", "fc.bias"]:
# print(name)
param.requires_grad=False # 关键一步，设置为False之后，优化器溜不会对参数进行更新
当param.requires_grad=False的时候，表示该参数没有梯度信息，也就是不会反向传播更新参数，也就是相当于冻结了，数值保持不变。
查看效果：
for name, param in finetune_net.named_parameters():
print(name)
print(param)
可以看见，除了最后的一层全脸曾的权值与偏置，其他的requires_grad=False，全部被冻结。
那么，现在可以把全部参数送入优化器，优化器也只会对全连接层的数据进行处理。
# 这个优化器只对最后一层的参数进行更新，可以加快训练速度
optimizer = torch.optim.SGD(finetune_net.fc.parameters(), lr=1e-2, momentum=0.9)
# 或者是这一条，个人感觉这两句的效果是一致的（如有错误恳请指出）
# optimizer = torch.optim.SGD(finetune_net.parameters(), lr=learning_rate, weight_decay=0.001)
print(optimizer)
输出：
SGD (
Parameter Group 0
dampening: 0
lr: 0.01
momentum: 0.9
nesterov: False
weight_decay: 0
)
2.2 分组设置参数组
由于这里我们只需要对最后一层修改后的全连接层进行训练，而对其他层不需要怎么训练，根据这种特性，可以分为两个参数组丢进优化器中。
learning_rate = 1e-3
# 获取除了最后一层全连接层的全部层参数, 因为这部分数据参数只需要微调
params_1x = [param for name, param in finetune_net.named_parameters()
if name not in ["fc.weight", "fc.bias"]]
# 设置了两个参数组
# 其中学习率是不同的，对于其他组的学习率会低点，全连接组的学习率会高点
trainer = torch.optim.SGD([{
'params': params_1x}, # 其他组
{
'params': finetune_net.fc.parameters(),'lr': learning_rate * 10}], # 全连接组
lr=learning_rate, weight_decay=0.001)
print(trainer)
输出：
# 这里也分别对应了两组参数
SGD (
Parameter Group 0
dampening: 0
lr: 0.001
momentum: 0
nesterov: False
weight_decay: 0.001
Parameter Group 1
dampening: 0
lr: 0.01
momentum: 0
nesterov: False
weight_decay: 0.001
)
- 这里进一步说明一下设置两组的意图：
在利用 pre-trained model 的参数做初始化之后，我们可能想让 fc 层更新相对快一些，而希望前面的权值更新小一些，这就可以通过为不同的层设置不同的学习率来达到此目的。为不同层设置不同的学习率，主要通过优化器对多个参数组进行设置不同的参数。所以，只需要将原始的参数组，划分成两个，甚至更多的参数组，然后分别进行设置学习率。这里将原始参数“切分”成 fc3 层参数和其余参数，为 fc3 层设置更大的学习率。
对参数分组进行训练同样也是一种方法，但是时间可能比冻结需要的时间要长点。
在这一节中涉及到了设置学习率的问题，在之后我会再对如何动态的调整学习率做一个笔记总结。之后再接触到其他方法再进行补充。
3. 优化器基类：Optimizer
对于参数组的设置，其实是优化器基类的一个参数，这里补充一下这方面的笔记。
当数据、模型和损失函数确定，任务的数学模型就已经确定，接着就要选择一个合适的优化器(Optimizer)对该模型进行优化。
PyTorch 中所有的优化器(如：optim.Adadelta、optim.SGD、optim.RMSprop 等)均是Optimizer 的子类，Optimizer 中定义了一些常用的方法，有 zero_grad()、step(closure)、state_dict()、load_state_dict(state_dict)和add_param_group(param_group)
1. param_groups
认识 Optimizer 的方法之前，需要了解一个概念，叫做参数组(param_groups)。在finetune，某层定制学习率，某层学习率置零操作中，都会设计参数组的概念，因此首先了解参数组的概念非常有必要。
optimizer 对参数的管理是基于组的概念，可以为每一组参数配置特定的lr,momentum,weight_decay 等等。
参数组在 optimizer 中表现为一个 list(self.param_groups)，其中每个元素是dict，表示一个参数及其相应配置，在 dict 中包含’params’、‘weight_decay’、‘lr’ 、'momentum’等字段。
import torch
import torch.optim as optim
w1 = torch.randn(2, 2)
w1.requires_grad = True
w2 = torch.randn(2, 2)
w2.requires_grad = True
w3 = torch.randn(2, 2)
w3.requires_grad = True
# 一个参数组
optimizer_1 = optim.SGD([w1, w3], lr=0.1)
print('len(optimizer.param_groups): ', len(optimizer_1.param_groups))
# print(optimizer_1.param_groups, '\n')
# 两个参数组
optimizer_2 = optim.SGD([{
'params': w1, 'lr': 0.1},
{
'params': w2, 'lr': 0.001}])
print('len(optimizer.param_groups): ', len(optimizer_2.param_groups))
# print(optimizer_2.param_groups)
len(optimizer.param_groups): 1
len(optimizer.param_groups): 2
# 一组参数
optimizer_1.param_groups
[{'params': [tensor([[-0.3037, 1.4797],
[ 0.5660, 0.0942]], requires_grad=True),
tensor([[0.0423, 0.2110],
[1.4629, 0.7293]], requires_grad=True)],
'lr': 0.1,
'momentum': 0,
'dampening': 0,
'weight_decay': 0,
'nesterov': False}]
# 两组参数
optimizer_2.param_groups
[{'params': [tensor([[-0.3037, 1.4797],
[ 0.5660, 0.0942]], requires_grad=True)],
'lr': 0.1,
'momentum': 0,
'dampening': 0,
'weight_decay': 0,
'nesterov': False},
{'params': [tensor([[ 0.5763, -0.2417],
[ 0.9620, -0.2617]], requires_grad=True)],
'lr': 0.001,
'momentum': 0,
'dampening': 0,
'weight_decay': 0,
'nesterov': False}]
2. zero_grad
功能：将梯度清零
w1 = torch.randn(2, 2)
w1.requires_grad = True
w2 = torch.randn(2, 2)
w2.requires_grad = True
optimizer = optim.SGD([w1, w2], lr=0.001, momentum=0.9)
optimizer.param_groups[0]['params'][0].grad = torch.randn(2, 2)
print('参数w1的梯度：')
print(optimizer.param_groups[0]['params'][0].grad, '\n') # 参数组，第一个参数(w1)的梯度
optimizer.zero_grad()
print('执行zero_grad()之后，参数w1的梯度：')
print(optimizer.param_groups[0]['params'][0].grad) # 参数组，第一个参数(w1)的梯度
参数w1的梯度：
tensor([[ 2.0855, -1.7181],
[ 1.4635, 0.1929]])
执行zero_grad()之后，参数w1的梯度：
tensor([[0., 0.],
[0., 0.]])
optimizer.param_groups
[{'params': [tensor([[ 0.7282, -1.6298],
[-0.8011, -0.4588]], requires_grad=True),
tensor([[-1.9988, -0.2675],
[ 0.4767, 0.2058]], requires_grad=True)],
'lr': 0.001,
'momentum': 0.9,
'dampening': 0,
'weight_decay': 0,
'nesterov': False}]
3. state_dict
功能：获取模型当前的参数，以一个有序字典形式返回。这个有序字典中，key 是各层参数名，value 就是参数。
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 1, 3)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(1 * 3 * 3, 2)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = x.view(-1, 1 * 3 * 3)
x = F.relu(self.fc1(x))
return x
net = Net()
# 获取网络当前参数
net_state_dict = net.state_dict()
net_state_dict
OrderedDict([('conv1.weight',
tensor([[[[ 0.1543, -0.1407, 0.0830],
[-0.1273, -0.1226, -0.0813],
[ 0.0063, 0.0947, 0.0870]],
[[-0.0373, -0.0405, -0.1581],
[-0.1434, -0.0394, -0.0907],
[ 0.1879, 0.0017, 0.1906]],
[[-0.0318, -0.1629, -0.0959],
[ 0.1870, 0.0410, -0.0414],
[ 0.1877, -0.0737, 0.0832]]]])),
('conv1.bias', tensor([0.0677])),
('fc1.weight',
tensor([[-0.0222, -0.0308, 0.3086, -0.0744, 0.1465, 0.2873, 0.1144, -0.1305,
0.1582],
[-0.1610, 0.2409, 0.0661, -0.1861, -0.2027, 0.1601, -0.2494, 0.1504,
0.1627]])),
('fc1.bias', tensor([-0.2310, 0.2416]))])
4. load_state_dict
功能：将 state_dict 中的参数加载到当前网络，常用于 finetune。
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 1, 3)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(1 * 3 * 3, 2)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = x.view(-1, 1 * 3 * 3)
x = F.relu(self.fc1(x))
return x
def zero_param(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
torch.nn.init.constant_(m.weight.data, 0)
if m.bias is not None:
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
torch.nn.init.constant_(m.weight.data, 0)
m.bias.data.zero_()
net = Net()
# 保存，并加载模型参数(仅保存模型参数)
torch.save(net.state_dict(), 'net_params.pkl') # 假设训练好了一个模型net
pretrained_dict = torch.load('net_params.pkl')
# 将net的参数全部置0，方便对比
net.zero_param()
net_state_dict = net.state_dict()
print('conv1层的权值为:\n', net_state_dict['conv1.weight'], '\n')
# 通过load_state_dict 加载参数
net.load_state_dict(pretrained_dict)
print('加载之后，conv1层的权值变为:\n', net_state_dict['conv1.weight'])
conv1层的权值为:
tensor([[[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]]])
加载之后，conv1层的权值变为:
tensor([[[[ 0.1342, 0.0739, 0.1349],
[-0.0289, -0.0936, 0.1227],
[-0.0100, -0.1250, -0.1766]],
[[ 0.1367, 0.0436, 0.1686],
[ 0.1190, -0.1689, -0.0090],
[-0.0925, 0.1353, -0.0834]],
[[ 0.1444, -0.1853, 0.0623],
[ 0.1150, 0.1841, 0.0029],
[ 0.1390, 0.1746, -0.0154]]]])
pretrained_dict
OrderedDict([('conv1.weight',
tensor([[[[ 0.1342, 0.0739, 0.1349],
[-0.0289, -0.0936, 0.1227],
[-0.0100, -0.1250, -0.1766]],
[[ 0.1367, 0.0436, 0.1686],
[ 0.1190, -0.1689, -0.0090],
[-0.0925, 0.1353, -0.0834]],
[[ 0.1444, -0.1853, 0.0623],
[ 0.1150, 0.1841, 0.0029],
[ 0.1390, 0.1746, -0.0154]]]])),
('conv1.bias', tensor([-0.0964])),
('fc1.weight',
tensor([[ 0.0834, 0.3215, -0.2080, 0.1315, 0.0505, -0.2244, 0.1805, 0.1946,
0.0444],
[-0.3096, 0.3098, 0.2564, -0.0232, 0.3014, 0.1928, 0.1730, 0.0521,
0.0925]])),
('fc1.bias', tensor([ 0.3252, -0.1319]))])
5. add_param_group
功能：给 optimizer 管理的参数组中增加一组参数，可为该组参数 定制 lr, momentum, weight_decay 等
w1 = torch.randn(2, 2)
w1.requires_grad = True
w2 = torch.randn(2, 2)
w2.requires_grad = True
w3 = torch.randn(2, 2)
w3.requires_grad = True
# 一个参数组
optimizer_1 = optim.SGD([w1, w2], lr=0.1)
optimizer_1.param_groups
[{'params': [tensor([[-0.5223, -0.5817],
[-3.5183, 1.2317]], requires_grad=True),
tensor([[ 0.5794, -1.6020],
[-0.5890, 1.3211]], requires_grad=True)],
'lr': 0.1,
'momentum': 0,
'dampening': 0,
'weight_decay': 0,
'nesterov': False}]
# 增加一组参数
optimizer_1.add_param_group({
'params': w3, 'lr': 0.001, 'momentum': 0.8})
optimizer_1.param_groups
[{'params': [tensor([[-0.5223, -0.5817],
[-3.5183, 1.2317]], requires_grad=True),
tensor([[ 0.5794, -1.6020],
[-0.5890, 1.3211]], requires_grad=True)],
'lr': 0.1,
'momentum': 0,
'dampening': 0,
'weight_decay': 0,
'nesterov': False},
{'params': [tensor([[0.6763, 1.1298],
[0.8228, 0.5904]], requires_grad=True)],
'lr': 0.001,
'momentum': 0.8,
'dampening': 0,
'weight_decay': 0,
'nesterov': False}]
具体的优化器使用方法之后再补充