目的：前两节讲的是关于数据的处理，这一小节讲神经网络模型的搭建
1.自定义Net类（搭建的神经网络模型）
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)
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):
for m in self.modules():
if isinstance(m, nn.Conv2d):
torch.nn.init.xavier_normal_(m.weight.data)
if m.bias is not None:
m.bias.data.zero_()
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
torch.nn.init.normal_(m.weight.data, 0, 0.01)
m.bias.data.zero_()
神经网络搭建步骤：
①在初始化函数中定义“组件”。（就是神经网络中每一层,例如卷积层、池化层、全连接层）
②在forward()函数中将“组件”拼起来，组成一个神经网络。
③权重初始化
self.modules()能依次返回神经网络的各层，然后根据每层所属的不同类型，例如是卷积层还是池化层，定义不同的初始化方式。
2.模型Finetune
什么是Finetune？
用一个已经训练过的模型的权值参数作为我们模型的初始化参数，更宽泛地称之为迁移学习。
Finetune基本步骤
1.获得一个训练好的模型A并提取模型A中的权值参数
2.将提取出来的权值参数放到新模型B中
与基本步骤对应的代码：
1.保存模型A的参数。net1是实例化的对象表示模型A
torch.save(net1.state_dict(),'net1_params.pkl')
2.加载模型A的参数：
pretrained_dict=torch.load('net_params.pkl')
3.获取模型B的参数字典net2_state_dict,net2是实例化的对象表示模型B：
net2_state_dict=net2.state_dict()
模型A中有的参数模型B可能不需要，因此要剔除pretrained_dict中多余的参数：
pretrained_dict_l = {k: v for k, v in pretrained_dict.items() if k in net2_state_dict}
用剔除后的参数字典对新模型的参数字典更新：
net2_state_dict.updata(pretrained_dict_l)
将更新后的参数字典放到模型B中：
net2.load_state_dict(net2_state_dict)
3.不同层设置不同的学习率
# ================================= #
# 按需设置学习率
# ================================= #
# 将fc3层的参数从原始网络参数中剔除
ignored_params = list(map(id, net.fc3.parameters()))
base_params = filter(lambda p: id(p) not in ignored_params, net.parameters())
# 为fc3层设置需要的学习率
optimizer = optim.SGD([
{'params': base_params},
{'params': net.fc3.parameters(), 'lr': lr_init*10}], lr_init, momentum=0.9, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss() # 选择损失函数
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1) # 设置学习率下降策略第一行代码：
map(function,iterable)第一个参数是一个函数，第二个参数是一个序列，将序列中的每个元素通过函数计算得到一个新序列并输出。
id()用于获取对象的内存地址，因此map(id, net.fc3.parameters()返回的是fc3层所有参数的内存地址，也就是ignored_params
第二行代码：
理解filter()函数：参考
filter(function,iterable)我们可以直接for循环来依次输出filter对象中的每个元素，但是这个迭代器只能执一次，如果想多次重复使用filter函数的结果，可以使用list将这个迭代器转换为列表。
第一个参数为返回True或者False的函数，第二个参数是一个列表。将列表中的每个元素依次送入函数，将函数返回值为0的输入元素过滤掉，得到输出列表。
function: lambda p: id(p) not in ignored_params
iterable: net.parameters()
不是fc3层权重的，返回True，因此过滤后得到的是除了fc3层权重之外的所有权重