2 模型参数的访问、初始化和共享

在3.3节（线性回归的简洁实现）中，我们通过init模块来初始化模型的参数。我们也介绍了访问模型参数的简单方法。本节将深入讲解如何访问和初始化模型参数，以及如何在多个层之间共享同一份模型参数。
我们先定义一个与上一节中相同的含单隐藏层的多层感知机。我们依然使用默认方式初始化它的参数，并做一次前向计算。与之前不同的是，在这里我们从nn中导入了init模块，它包含了多种模型初始化方法。

  1. import torch
  2. from torch import nn
  3. from torch.nn import init
  5. net = nn.Sequential(nn.Linear(4, 3), nn.ReLU(), nn.Linear(3, 1))  # pytorch已进行默认初始化
  7. print(net)
  8. X = torch.rand(2, 4)
  9. Y = net(X).sum()
  10. 输出：
  11. Sequential(
  12.   (0): Linear(in_features=4, out_features=3, bias=True)
  13.   (1): ReLU()
  14.   (2): Linear(in_features=3, out_features=1, bias=True)
  15. )

2.1 访问模型参数

回忆一下上一节中提到的Sequential类与Module类的继承关系。对于Sequential实例中含模型参数的层，我们可以通过Module类的parameters()或者named_parameters方法来访问所有参数（以迭代器的形式返回），后者除了返回参数Tensor外还会返回其名字。下面，访问多层感知机net的所有参数：

  1. print(type(net.named_parameters()))
  2. for name, param in net.named_parameters():
  3.     print(name, param.size())
  4. 输出：
  5. <class 'generator'>
  6. 0.weight torch.Size([3, 4])
  7. 0.bias torch.Size([3])
  8. 2.weight torch.Size([1, 3])
  9. 2.bias torch.Size([1])

可见返回的名字自动加上了层数的索引作为前缀。 我们再来访问net中单层的参数。对于使用Sequential类构造的神经网络，我们可以通过方括号[]来访问网络的任一层。索引0表示隐藏层为Sequential实例最先添加的层。

  1. for name, param in net[0].named_parameters():
  2.     print(name, param.size(), type(param))
  3. 输出：
  4. weight torch.Size([3, 4]) <class 'torch.nn.parameter.Parameter'>
  5. bias torch.Size([3]) <class 'torch.nn.parameter.Parameter'>

因为这里是单层的所以没有了层数索引的前缀。另外返回的param的类型为torch.nn.parameter.Parameter，其实这是Tensor的子类，和Tensor不同的是如果一个Tensor是Parameter，那么它会自动被添加到模型的参数列表里，来看下面这个例子。

  1. class MyModel(nn.Module):
  2.     def __init__(self, **kwargs):
  3.         super(MyModel, self).__init__(**kwargs)
  4.         self.weight1 = nn.Parameter(torch.rand(20, 20))
  5.         self.weight2 = torch.rand(20, 20)
  6.     def forward(self, x):
  7.         pass
  9. n = MyModel()
  10. for name, param in n.named_parameters():
  11.     print(name)
  12. 输出:
  13. weight1

上面的代码中weight1在参数列表中但是weight2却没在参数列表中。
因为Parameter是Tensor，即Tensor拥有的属性它都有，比如可以根据data来访问参数数值，用grad来访问参数梯度。

  1. weight_0 = list(net[0].parameters())[0]
  2. print(weight_0.data)
  3. print(weight_0.grad) # 反向传播前梯度为None
  4. Y.backward()
  5. print(weight_0.grad)
  6. 输出：
  7. tensor([[ 0.2719, -0.0898, -0.2462,  0.0655],
  8.         [-0.4669, -0.2703,  0.3230,  0.2067],
  9.         [-0.2708,  0.1171, -0.0995,  0.3913]])
  10. None
  11. tensor([[-0.2281, -0.0653, -0.1646, -0.2569],
  12.         [-0.1916, -0.0549, -0.1382, -0.2158],
  13.         [ 0.0000,  0.0000,  0.0000,  0.0000]])

2.2 初始化模型参数

我们在3.15节（数值稳定性和模型初始化）中提到了PyTorch中nn.Module的模块参数都采取了较为合理的初始化策略（不同类型的layer具体采样的哪一种初始化方法的可参考源代码）。但我们经常需要使用其他方法来初始化权重。PyTorch的init模块里提供了多种预设的初始化方法。在下面的例子中，我们将权重参数初始化成均值为0、标准差为0.01的正态分布随机数，并依然将偏差参数清零。

  1. for name, param in net.named_parameters():
  2.     if 'weight' in name:
  3.         init.normal_(param, mean=0, std=0.01)
  4.         print(name, param.data)
  5. 输出：
  6. 0.weight tensor([[ 0.0030,  0.0094,  0.0070, -0.0010],
  7.         [ 0.0001,  0.0039,  0.0105, -0.0126],
  8.         [ 0.0105, -0.0135, -0.0047, -0.0006]])
  9. 2.weight tensor([[-0.0074,  0.0051,  0.0066]])
  10. 下面使用常数来初始化权重参数。
  11. for name, param in net.named_parameters():
  12.     if 'bias' in name:
  13.         init.constant_(param, val=0)
  14.         print(name, param.data)
  16. 0.bias tensor([0., 0., 0.])
  17. 2.bias tensor([0.])

2.3 自定义初始化方法

有时候我们需要的初始化方法并没有在init模块中提供。这时，可以实现一个初始化方法，从而能够像使用其他初始化方法那样使用它。在这之前我们先来看看PyTorch是怎么实现这些初始化方法的，例如torch.nn.init.normal_：

  1. def normal_(tensor, mean=0, std=1):
  2.     with torch.no_grad():
  3.         return tensor.normal_(mean, std)

可以看到这就是一个inplace改变Tensor值的函数，而且这个过程是不记录梯度的。 类似的我们来实现一个自定义的初始化方法。在下面的例子里，我们令权重有一半概率初始化为0，有另一半概率初始化为$[-10,-5]$和$[5,10]$两个区间里均匀分布的随机数。

  1. def init_weight_(tensor):
  2.     with torch.no_grad():
  3.         tensor.uniform_(-10, 10)
  4.         tensor *= (tensor.abs() >= 5).float()
  6. for name, param in net.named_parameters():
  7.     if 'weight' in name:
  8.         init_weight_(param)
  9.         print(name, param.data)
  10. 输出：
  11. 0.weight tensor([[ 7.0403,  0.0000, -9.4569,  7.0111],
  12.         [-0.0000, -0.0000,  0.0000,  0.0000],
  13.         [ 9.8063, -0.0000,  0.0000, -9.7993]])
  14. 2.weight tensor([[-5.8198,  7.7558, -5.0293]])

此外，参考2.3.2节，我们还可以通过改变这些参数的data来改写模型参数值同时不会影响梯度:

  1. for name, param in net.named_parameters():
  2.     if 'bias' in name:
  3.         param.data += 1
  4.         print(name, param.data)
  5. 输出：
  6. 0.bias tensor([1., 1., 1.])
  7. 2.bias tensor([1.])

通过 torch.nn.init 模块中的init

  1. class LinearNet(nn.Module):
  2.     def __init__(self,num_inputs,num_outputs):
  3.         super(LinearNet,self).__init__()
  4.         self.linear = nn.Linear(num_inputs,num_outputs)
  5.     def forward(self,x):
  6.         y = self.linear(x.view(x.shape[0],-1))
  7.         return y
  8. init.normal_(net.linear.weight ,mean = 0, std = 0.01)
  9. init.constant_(net.linear.bias,val = 0)

通过自定义参数初始化

  1. num_inputs ,num_outputs ,num_hiddens = 784,10,256
  2. W1 = torch.tensor(np.random.normal(0, 0.01, (num_inputs,num_hiddens)), dtype=torch.float)
  3. b1 = torch.zeros(num_hiddens, dtype=torch.float)
  4. W2 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens,num_outputs)), dtype=torch.float)
  5. b2 = torch.zeros(num_outputs, dtype=torch.float)
  6. params = [W1, b1, W2, b2]
  7. for param in params:
  8.     param.requires_grad_(requires_grad=True)
  10. def net(X):
  11.     X = X.view((-1,num_inputs))
  12.     H = relu(torch.matmul(X,W1)+b1)
  13.     return torch.matmul(H,W2)+b2