pyTorch入门3
参考了《pyTorch实战》《动手学深度学习（pyTorch版）》
1. 层（Layer）和块（Module）
神经网络是由许多层组成的，而在大型的神经网络中，许多层又构成了比层大一些的组件——块。
如果熟悉C或C++的话，可以把层看做是基本数据类型，把块看作是结构体Struct，例如之前介绍的nn.Sequential就可以看作是一种特殊的块。
1.1 自定义块
下面来实现一个多层感知机的块，要定义一个块，一般需要继承自torch.nn.Module，同时实现两个函数，分别是
__init__(self)-
forward(self, X)前向传播函数
注意：当调用前向传播时，不要直接使用
forward()函数，而是应该实例化块后，像使用函数一样使用该变量，进而获得前向传播的效果，此时，pyTorch会调用nn.Module的__call__()函数，进而在其中调用forward()，从而实现前向传播。
import torch
from torch import nn
from torch.nn import functional as F
class MLP(nn.Module):
# 用模型参数声明层。这里，我们声明两个全连接的层
def __init__(self):
# 调用MLP的父类Module的构造函数来执行必要的初始化。
# 这样，在类实例化时也可以指定其他函数参数，例如模型参数params
super().__init__()
self.hidden = nn.Linear(20, 256) # 隐藏层
self.out = nn.Linear(256, 10) # 输出层
# 定义模型的前向传播，即如何根据输入X返回所需的模型输出
def forward(self, X):
# 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
return self.out(F.relu(self.hidden(X)))
X = torch.rand(2, 20)
net = MLP()
print(net(X))
print(net.forward(X)) # 不要这样做，否则会导致很多钩子函数无法调用
tensor([[ 0.0758, 0.2157, 0.0882, -0.3040, 0.2303, 0.0867, -0.1976, -0.0529,
-0.0375, 0.0187],
[-0.1651, 0.1769, -0.0810, -0.2636, 0.1494, 0.1209, -0.1045, 0.0484,
-0.0541, 0.1236]], grad_fn=<AddmmBackward0>)
tensor([[ 0.0758, 0.2157, 0.0882, -0.3040, 0.2303, 0.0867, -0.1976, -0.0529,
-0.0375, 0.0187],
[-0.1651, 0.1769, -0.0810, -0.2636, 0.1494, 0.1209, -0.1045, 0.0484,
-0.0541, 0.1236]], grad_fn=<AddmmBackward0>)
1.2 自定义顺序块
下面的代码实现了一个自己定义的顺序块，在其中的__init__()函数中，我们使用_modules属性（_module的数据类型是OrderedDict，因此在forward()函数中，需要使用values()来进行遍历）来保存每个加入到该顺序块中的子块。之所以这样做，我的理解是为后续能够找到每层的参数提供一个标准化的变量，进而实现模型参数的递归遍历。
class MySequential(nn.Module):
def __init__(self, *args):
super().__init__()
for idx, module in enumerate(args):
# 这里，module是Module子类的一个实例。我们把它保存在'Module'类的成员
# 变量_modules中。_module的类型是OrderedDict
self._modules[str(idx)] = module
def forward(self, X):
# OrderedDict保证了按照成员添加的顺序遍历它们
for block in self._modules.values():
X = block(X)
return X
2 模型参数
2.1 参数的查看
在查看模型的参数上，主要由三个函数，分别是：
-
model.state_dict()：返回一个OrderedDict对象，一般用于模型的保存 -
model.parameters()：返回一个生成器（generator，即用yield返回），只包含了层的权重，一般用于优化器的初始化 -
model.named_parameters()：返回一个生成器，其中包含了层的名称以及层的权重
import torch
from torch import nn
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)
tensor([[0.3910],
[0.3429]], grad_fn=<AddmmBackward0>)
net[0].state_dict()
OrderedDict([('weight',
tensor([[-0.2085, 0.0465, 0.3837, -0.0263],
[ 0.2905, 0.1418, -0.1686, 0.3553],
[-0.3393, -0.0554, -0.1383, -0.0337],
[ 0.0722, -0.2049, -0.4940, -0.4341],
[-0.1917, 0.3491, -0.2002, -0.4147],
[-0.1582, 0.4971, -0.4866, 0.4300],
[-0.2066, 0.2952, -0.0132, 0.3540],
[ 0.1061, -0.2398, -0.3574, 0.2755]])),
('bias',
tensor([-0.4946, -0.3924, -0.3753, 0.1968, -0.3885, -0.3502, 0.2036, -0.0082]))])
print(net.parameters())
print(net.named_parameters())
<generator object Module.parameters at 0x00000152F0664740>
<generator object Module.named_parameters at 0x00000152F0664740>
print(*[param.shape for param in net.parameters()])
torch.Size([8, 4]) torch.Size([8]) torch.Size([1, 8]) torch.Size([1])
print(*[(name, param.shape) for name, param in net.named_parameters()])
('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))
要获得特定的层的参数，可以通过层的名称进行索引，索引的方式有如下几种：
print(f"第2层的权重——类的形式:{net[2].weight}")
print(f"第2层的偏置——类的形式:{net[2].bias}")
print(f"第2层的偏置——数据的形式:{net[2].bias.data}")
print(f"第2层的梯度:{net[2].bias.grad}")
print(f"第2层的权重——数据的形式:{net.state_dict()['2.weight']}")
第2层的权重——类的形式:Parameter containing:
tensor([[-0.0497, -0.2259, -0.0557, -0.0915, -0.3122, -0.0528, 0.2824, 0.2857]],
requires_grad=True)
第2层的偏置——类的形式:Parameter containing:
tensor([0.2492], requires_grad=True)
第2层的偏置——数据的形式:tensor([0.2492])
第2层的梯度:None
第2层的权重——数据的形式:tensor([[-0.0497, -0.2259, -0.0557, -0.0915, -0.3122, -0.0528, 0.2824, 0.2857]])
2.2 模型权重初始化
常用的初始化方法包括X吴恩达的视频中关于这一部分的理论部分讲得更加浅显一些
深度之眼这一部分(《权值初始化》)
常用的模型初始化方法包括：
- Xavier初始化
- Kaiming初始化
2.2.1 pyTorch中的初始化
torch中的初始化主要使用torch.nn.init模块，其中内置了多种初始化方法：
-
init.normal_(weight, mean, std)初始化为正态分布 -
init.zeros_(bias)初始化为全0 -
init.xavier_normal_(weight)xavier初始化，用一个正态分布生成值，填充输入的张量或变量 -
init.xavier_uniform_(weight)xavier初始化，用一个均匀分布生成值，填充输入的张量或变量 -
init.uniform_()初始化为均匀分布 -
init.constant_(weight, val)以val值填充变量weight -
init.kaiming_normal_(weight)xavier初始化，用一个正态分布生成值，填充输入的张量或变量 -
init.kaiming_uniform_(weight)Kaiming初始化，用一个均匀分布生成值，填充输入的张量或变量
def init_normal(m):
if type(m) == nn.Linear:
nn.init.normal_(m.weight, mean=0, std=.01)
nn.init.zeros_(m.bias)
net.apply(init_normal)
print(net[0].weight.data[0])
print(net[0].bias.data[0])
tensor([ 0.0079, -0.0053, -0.0052, -0.0114])
tensor(0.)
还可以对特定的块或者层进行初始化：
def init_xavier(m):
if type(m) == nn.Linear:
nn.init.xavier_uniform_(m.weight)
def init_42(m):
if type(m) == nn.Linear:
nn.init.constant_(m.weight, 42)
net[0].apply(init_xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)
tensor([ 0.0540, -0.2176, 0.1471, 0.4690])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])
2.2.2 参数绑定
如果需要在多个层间共享参数，可以定义一个稠密层，然后用这个稠密层的参数来设置另一个层的参数：
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4,8),
nn.ReLU(),
shared,
nn.ReLU(),
shared,
nn.ReLU(),
shared,
nn.Linear(8, 1))
net(X)
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0,0] = 100
print(net[2].weight.data[0] == net[4].weight.data[0])
tensor([True, True, True, True, True, True, True, True])
tensor([True, True, True, True, True, True, True, True])
2.3 自定义层中的参数
class MyLinear(nn.Module):
def __init__(self, in_units, units):
super().__init__()
self.weight = nn.Parameter(torch.randn(in_units, units))
self.bias = nn.Parameter(torch.randn(units,))
def forward(self, X):
linear = torch.matmul(X, self.weight.data) + self.bias.data
return F.relu(linear)
