动手学深度学习PyTorch（五）：深度学习计算

1.模型构造

1.1 继承Module类来构造模型

Module类是nn模块里提供的一个模型构造类，是所有神经网络模块的基类，我们可以继承它来定义我们想要的模型。下面继承Module类构造本节开头提到的多层感知机。这里定义的MLP类重载了Module类的__init__函数和forward函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。

import torch
from torch import nn

class MLP(nn.Module):
    # 声明带有模型参数的层，这里声明了两个全连接层
    def __init__(self,**kwargs):
        # 调用MLP父类Module的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数
        # 参数，如“模型参数的访问、初始化和共享”一节将介绍的模型参数params
        super(MLP,self).__init__(**kwargs)
        self.hidden = nn.Linear(784,256) # 隐层层
        self.act = nn.ReLU()
        self.output = nn.Linear(256,10) # 输出层

    # 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出
    def forward(self,x):
        a = self.act(self.hidden(x))
        return self.output(a)

以上的MLP类中无须定义反向传播函数。系统将通过自动求梯度而自动生成反向传播所需的backward函数。

我们可以实例化MLP类得到模型变量net。下面的代码初始化net并传入输入数据X做一次前向计算。其中，net(X)会调用MLP继承自Module类的__call__函数，这个函数将调用MLP类定义的forward函数来完成前向计算。

X = torch.rand(2,784)
net = MLP()
print(net)
net(X)

1.2 Module的子类

Module类是一个通用的部件。事实上，PyTorch还实现了继承自Module的可以方便构建模型的类: 如Sequential、ModuleList和ModuleDict等等。

1.2.1 Sequential类

当模型的前向计算为简单串联各个层的计算时，Sequential类可以通过更加简单的方式定义模型。这正是Sequential类的目的：它可以接收一个子模块的有序字典（OrderedDict）或者一系列子模块作为参数来逐一添加Module的实例，而模型的前向计算就是将这些实例按添加的顺序逐一计算。

下面实现一个与Sequential类有相同功能的MySequential类：

class MySequential(nn.Module):
    from collections import OrderedDict
    def __init__(self,*args):
        super(MySequential,self).__init__()
        if len(args) == 1 and isinstance(args[0],OrderedDict): # 如果传入的是一个OrderedDict
            for key,module in args[0].items():
                self.add_module(key,module) # add_module方法会将module添加进self._modules(一个OrderedDict)
        else: # 传入的是一些Module
            for idx,module in enumerate(args):
                self.add_module(str(idx),module)

    def forward(self,input):
        # self._modules返回一个 OrderedDict，保证会按照成员添加时的顺序遍历成员
        for module in self._modules.values():
            input = module(input)
        return input    

我们用MySequential类来实现前面描述的MLP类，并使用随机初始化的模型做一次前向计算。

net = MySequential(
        nn.Linear(784,256),
        nn.ReLU(),
        nn.Linear(256,10),
        )
print(net)
net(X)

1.2.2 ModuleList类

ModuleList接收一个子模块的列表作为输入，然后也可以类似List那样进行append和extend操作:

net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10)) # # 类似List的append操作
print(net[-1])  # 类似List的索引访问
print(net)

>>> Linear(in_features=256, out_features=10, bias=True)
>>> ModuleList(
>>>  (0): Linear(in_features=784, out_features=256, bias=True)
>>>  (1): ReLU()
>>>  (2): Linear(in_features=256, out_features=10, bias=True)
>>>  )

既然Sequential和ModuleList都可以进行列表化构造网络，那二者区别是什么呢。ModuleList仅仅是一个储存各种模块的列表，这些模块之间没有联系也没有顺序（所以不用保证相邻层的输入输出维度匹配），而且没有实现forward功能需要自己实现;而Sequential内的模块需要按照顺序排列，要保证相邻层的输入输出大小相匹配，内部forward功能已经实现。

ModuleList的出现只是让网络定义前向传播时更加灵活。

1.2.3 ModuleDict类

ModuleDict接收一个子模块的字典作为输入, 然后也可以类似字典那样进行添加访问操作:

net = nn.ModuleDict({
    'linear': nn.Linear(784, 256),
    'act': nn.ReLU(),
})
net['output'] = nn.Linear(256, 10) # 添加
print(net['linear']) # 访问
print(net.output)
print(net)

和ModuleList一样，ModuleDict实例仅仅是存放了一些模块的字典，并没有定义forward函数需要自己定义。同样，ModuleDict也与Python的Dict有所不同，ModuleDict里的所有模块的参数会被自动添加到整个网络中。

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

2.1 访问模型参数

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

print(type(net.named_parameters()))
for name, param in net.named_parameters():
    print(name, param.size())

通过方括号[]来访问网络的任一层。索引0表示隐藏层为Sequential实例最先添加的层。

for name, param in net[0].named_parameters():
    print(name, param.size(), type(param))

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

class MyModel(nn.Module):
    def __init__(self, **kwargs):
        super(MyModel, self).__init__(**kwargs)
        self.weight1 = nn.Parameter(torch.rand(20, 20))
        self.weight2 = torch.rand(20, 20)
    def forward(self, x):
        pass
    
n = MyModel()
for name, param in n.named_parameters():
    print(name)

>>> weight1

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

2.2 初始化模型参数

PyTorch的init模块里提供了多种预设的初始化方法。在下面的例子中，我们将权重参数初始化成均值为0、标准差为0.01的正态分布随机数，并依然将偏差参数清零。

for name, param in net.named_parameters():
    if 'weight' in name:
        init.normal_(param, mean=0, std=0.01)
        print(name, param.data)

下面使用常数来初始化权重参数。

for name, param in net.named_parameters():
    if 'bias' in name:
        init.constant_(param, val=0)
        print(name, param.data)

2.3 自定义初始化方法

有时候我们需要的初始化方法并没有在init模块中提供。这时，可以实现一个初始化方法，从而能够像使用其他初始化方法那样使用它：

def init_weight_(tensor):
   with torch.no_grad():
       tensor.uniform_(-10, 10)
       tensor *= (tensor.abs() >= 5).float()

for name, param in net.named_parameters():
   if 'weight' in name:
       init_weight_(param)
       print(name, param.data)

2.4 共享模型参数

在有些情况下，我们希望在多个层之间共享模型参数。此外，如果我们传入Sequential的模块是同一个Module实例的话参数也是共享的，下面来看一个例子:

linear = nn.Linear(1, 1, bias=False)
net = nn.Sequential(linear, linear) 
print(net)
for name, param in net.named_parameters():
    init.constant_(param, val=3)
    print(name, param.data)

3.自定义层

3.1 不含模型参数的自定义层

下面的CenteredLayer类通过继承Module类自定义了一个将输入减掉均值后输出的层，并将层的计算定义在了forward函数里。这个层里不含模型参数。

import torch
from torch import nn

class CenteredLayer(nn.Module):
    def __init__(self, **kwargs):
        super(CenteredLayer, self).__init__(**kwargs)
    def forward(self, x):
        return x - x.mean()

3.2 含模型参数的自定义层

我们还可以自定义含模型参数的自定义层。其中的模型参数可以通过训练学出。除了直接定义成Parameter类外，还可以使用ParameterList和ParameterDict分别定义参数的列表和字典。
ParameterList接收一个Parameter实例的列表作为输入然后得到一个参数列表，使用的时候可以用索引来访问某个参数，另外也可以使用append和extend在列表后面新增参数。

class MyDense(nn.Module):
    def __init__(self):
        super(MyDense, self).__init__()
        self.params = nn.ParameterList([nn.Parameter(torch.randn(4, 4)) for i in range(3)])
        self.params.append(nn.Parameter(torch.randn(4, 1)))

    def forward(self, x):
        for i in range(len(self.params)):
            x = torch.mm(x, self.params[i])
        return x
net = MyDense()
print(net)
>>> MyDense(
>>>   (params): ParameterList(
>>>       (0): Parameter containing: [torch.FloatTensor of size 4x4]
>>>       (1): Parameter containing: [torch.FloatTensor of size 4x4]
>>>       (2): Parameter containing: [torch.FloatTensor of size 4x4]
>>>       (3): Parameter containing: [torch.FloatTensor of size 4x1]
>>>   )
>>> )

而ParameterDict接收一个Parameter实例的字典作为输入然后得到一个参数字典，然后可以按照字典的规则使用了。例如使用update()新增参数，使用keys()返回所有键值，使用items()返回所有键值对等等。

class MyDictDense(nn.Module):
    def __init__(self):
        super(MyDictDense, self).__init__()
        self.params = nn.ParameterDict({
                'linear1': nn.Parameter(torch.randn(4, 4)),
                'linear2': nn.Parameter(torch.randn(4, 1))
        })
        self.params.update({'linear3': nn.Parameter(torch.randn(4, 2))}) # 新增

    def forward(self, x, choice='linear1'):
        return torch.mm(x, self.params[choice])

net = MyDictDense()
print(net)

>>> MyDictDense(
>>>   (params): ParameterDict(
>>>       (linear1): Parameter containing: [torch.FloatTensor of size 4x4]
>>>       (linear2): Parameter containing: [torch.FloatTensor of size 4x1]
>>>       (linear3): Parameter containing: [torch.FloatTensor of size 4x2]
>>>   )
>>> )

4.读取和存储

在实际中，我们有时需要把训练好的模型部署到很多不同的设备。在这种情况下，我们可以把内存中训练好的模型参数存储在硬盘上供后续读取使用。

4.1 读写Tensor

我们可以直接使用save函数和load函数分别存储和读取Tensor。save使用Python的pickle实用程序将对象进行序列化，然后将序列化的对象保存到disk，使用save可以保存各种对象,包括模型、张量和字典等。而load使用pickle unpickle工具将pickle的对象文件反序列化为内存。

下面的例子创建了Tensor变量x，并将其存在文件名同为x.pt的文件里。

import torch
from torch import nn

x = torch.ones(3)
torch.save(x,'x.pt')

然后我们将数据从存储的文件读回内存。

x2 = torch.load('x.pt')

4.2 读写模型

4.2.1 state_dict

在PyTorch中，Module的可学习参数(即权重和偏差)，模块模型包含在参数中(通过model.parameters()访问)。state_dict是一个从参数名映射到参数Tesnor的字典对象。

class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.hidden = nn.Linear(3, 2)
        self.act = nn.ReLU()
        self.output = nn.Linear(2, 1)

    def forward(self, x):
        a = self.act(self.hidden(x))
        return self.output(a)

net = MLP()
net.state_dict()

>>> OrderedDict([('hidden.weight', tensor([[ 0.2448,  0.1856, -0.5678],
>>>                       [ 0.2030, -0.2073, -0.0104]])),
>>>              ('hidden.bias', tensor([-0.3117, -0.4232])),
>>>              ('output.weight', tensor([[-0.4556,  0.4084]])),
>>>              ('output.bias', tensor([-0.3573]))])

只有具有可学习参数的层(卷积层、线性层等)才有state_dict中的条目。优化器(optim)也有一个state_dict，其中包含关于优化器状态以及所使用的超参数的信息。

optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
optimizer.state_dict()
>>> {'param_groups': [{'dampening': 0,
>>>    'lr': 0.001,
>>>    'momentum': 0.9,
>>>    'nesterov': False,
>>>    'params': [4736167728, 4736166648, 4736167368, 4736165352],
>>>    'weight_decay': 0}],
>>>  'state': {}}

4.2.2 保存和加载模型

PyTorch中保存和加载训练模型有两种常见的方法:
1）仅保存和加载模型参数(state_dict)；
2）保存和加载整个模型。

## 1. 保存和加载state_dict(推荐方式)
### 保存：
torch.save(model.state_dict(), PATH) # 推荐的文件后缀名是pt或pth
### 加载：
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH))
## 2. 保存和加载整个模型
### 保存：
torch.save(model, PATH)
### 加载：
model = torch.load(PATH)

5.GPU计算

5.1 Tensor的GPU计算

使用.cuda()可以将CPU上的Tensor转换（复制）到GPU上。如果有多块GPU，我们用.cuda(i)来表示第i块GPU及相应的显存（从0开始）且cuda(0)和cuda()等价。

x = torch.tensor([1,2,3])
x
x = x.cuda(0)
x

>>> tensor([1, 2, 3])
>>> tensor([1, 2, 3], device='cuda:0')

我们可以直接在创建的时候就指定设备。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

x = torch.tensor([1, 2, 3], device=device)
# or
x = torch.tensor([1, 2, 3]).to(device)
x
>>> tensor([1, 2, 3], device='cuda:0')

如果对在GPU上的数据进行运算，那么结果还是存放在GPU上。

y = x**2
y
>>> tensor([1, 4, 9], device='cuda:0')

需要注意的是，存储在不同位置中的数据是不可以直接进行计算的。即存放在CPU上的数据不可以直接与存放在GPU上的数据进行运算，位于不同GPU上的数据也是不能直接进行计算的。

5.2 模型的GPU计算

同Tensor类似，PyTorch模型也可以通过.cuda转换到GPU上。我们可以通过检查模型的参数的device属性来查看存放模型的设备。

net = nn.Linear(3, 1)
list(net.parameters())[0].device
net.cuda()
list(net.parameters())[0].device
>>> device(type='cpu')
>>> device(type='cuda', index=0)

同样需要保证模型输入的Tensor和模型都在同一设备上，否则会报错。