在本文中，将介绍深度学习计算的关键组件，即模型构建、参数访问与初始化、设计⾃定义层和块、将模型读写到磁盘，以及利⽤GPU实现显著的加速。

1 层和块

单输出的神经网络：多输入，单输出，有一组相关参数。更新这些参数可以优化某目标函数。
多输出的神经网络：多输入，多输出，有一组可调整参数。当使用softmax回归时，一个单层就是一个模型。
多层感知机就是这种架构，整个模型接受原始输入（特征），生成输出（预测），并包含一些参数（所有组成层的参数集合）。每个单独的层接受输入（由前一层提供），生成输出（到下一层的输入），并且具有一组可调参数，这些参数根据从下一层反向传播的信号进行更新。

1.1自定义神经网络块

块可以描述单个层、由多个层组成的组件或整个模型本身。
从编程的角度看，块由类表示。它的任何子类都必须定义：

1.一个将其输入转换为输出的前向传播函数，并且必须存储任何必需的参数，有些块没有参数。
2.为了计算梯度，块必须有反向传播函数。

每个块必须提供的基本功能：

1.将输入数据作为其前向传播函数的参数。
2.通过前向传播函数生成输出，注意输出的维数可能与输入的维数不一样。
3.计算其输出关于输入的梯度，可通过其反向传播函数进行访问。这是自动进行的。
4.存储和访问前向传播计算所需的参数。
5.根据需要初始化模型参数。

在下面的代码中，从零开始编写一个块。它包含一个多层感知机，其具有有256个隐藏单元的隐藏层和⼀个10维输出层。MLP类继承了表示块的类。块的实现只需要提供构造函数与前向传播函数。

import torch
from torch import nn
from torch.nn import functional as F


class MLP(nn.Module):
    # 用模型参数声明层。这里声明两个全连接层。
    def __init__(self):
        # 调用MLP的父类Module的构造函数来执行必要的初始化。
        # 这样，在类实例化时也可以指定其他函数参数。
        super().__init__()
        self.hidden = nn.Linear(20,256) # 隐藏层
        self.out = nn.Linear(256,10) # 输出层

    # 定义前向传播函数，即如何根据输入x返回所需的模型输出
    def forward(self,x):
        return self.out(F.relu(self.hidden(x)))

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

1.2顺序块

Sequential类的设计是为了把其他模块串起来。自定义的简化版MySequential类只需定义两个关键函数：

1.一种将块逐个追加到列表中的函数；
2.一种前向传播函数，用于将输入按追加块的顺序传递给块组成的“链条”。

代码如下：

class MySequential(nn.Module):
    def __init__(self,*args):
        super().__init__()
        for idx,module in enumerate(args):
            # 这⾥，module是Module⼦类的⼀个实例。我们把它保存在'Module'类的成员
            # 变量_modules中。_module的类型是OrderedDic
            self._modules[str(idx)] = module
            # _modules的主要优点是：
            # 在模块的参数初始化过程中，系统知道在_modules字典中查找需要初始化参数的⼦块

    def forward(self,X):
        # OrderedDict保证了按照成员添加到顺序遍历它们
        for block in self._modules.values():
            X = block(X)
        return X

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

1.3在前向传播中执行代码

有时我们可能希望合并既不是上⼀层的结果也不是可更新参数的项，我们称之为常数参数（constant parameter）。例如，⼀个计算函数 f(x, w) = c · w⊤x的层，其中x是输⼊，w是参数，c是某个在优化过程中没有更新的指定常量。
实现⼀个FixedHiddenMLP类：

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不计算梯度的随机权重参数。因此在训练期间保持不变。
        self.rand_weight = torch.rand((20,20),requires_grad=False)
        self.linear = nn.Linear(20,20)

    def forward(self,X):
        X = self.linear(X)
        # 使用创建的常量参数以及relu和mm函数
        X = F.relu(torch.mm(X,self.rand_weight)+1)
        # 复用全连接层。这相当于两个全连接层共享参数
        X = self.linear(X)
        # 控制流
        while X.abs().sum() > 1: # l1范数
            X /= 2
        return  X.sum()

net = FixedHiddenMLP()
print(net(X))

可以混合搭配各种组合块的⽅法。比如：

class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(20,64),nn.ReLU(),
                                 nn.Linear(64,32),nn.ReLU())
        self.linear = nn.Linear(32,16)

    def forward(self,X):
        return self.linear(self.net(X))

chimera = nn.Sequential(NestMLP(),nn.Linear(16,20),FixedHiddenMLP())
print(chimera(X))

2.参数管理

2.1 访问参数、用于调试、诊断和可视化

具有单隐藏层的多层感知机：

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)

检查第二个全连接层的参数：

print(net[2].state_dict())

输出结果：

OrderedDict([('weight', tensor([[ 0.3016, -0.1901, -0.1991, -0.1220, 0.1121, -0.1424, -0.3060, 0.
,→3400]])), ('bias', tensor([-0.0291]))])

有两个参数：该层的权重和偏置。访问第二个全连接层的偏置：

print(type(net[2].bias)) # 提取偏置
print(net[2].bias) # 返回参数类实例
print(net[2].bias.data) # 访问该参数的值

结果：

<class 'torch.nn.parameter.Parameter'>
Parameter containing:
tensor([-0.0291], requires_grad=True)
tensor([-0.0291])

参数是复合的对象，包含值、梯度和额外信息。这就是我们需要显式参数值的原因。除了值之外，我们还可以访问每个参数的梯度。在上⾯这个⽹络中，由于我们还没有调⽤反向传播，所以参数的梯度处于初始状态。

net[2].weight.grad == None # True

一次性访问所有参数：

print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])

('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))

另⼀种访问⽹络参数的⽅式：

net.state_dict()['2.bias'].data

从嵌套块收集参数：

def block1():
	return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
							nn.Linear(8, 4), nn.ReLU())

def block2():
	net = nn.Sequential()
		for i in range(4):
		# 在这⾥嵌套
		net.add_module(f'block {i}', block1())
	return net
rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
rgnet(X)
print(rgnet)

Sequential(
  (0): Sequential(
	(block 0): Sequential(
	(0): Linear(in_features=4, out_features=8, bias=True)
	(1): ReLU()
	(2): Linear(in_features=8, out_features=4, bias=True)
	(3): ReLU()
   )
	(block 1): Sequential(
	(0): Linear(in_features=4, out_features=8, bias=True)
	(1): ReLU()
	(2): Linear(in_features=8, out_features=4, bias=True)
	(3): ReLU()
   )
	(block 2): Sequential(
	(0): Linear(in_features=4, out_features=8, bias=True)
	(1): ReLU()
	(2): Linear(in_features=8, out_features=4, bias=True)
	(3): ReLU()
   )
	(block 3): Sequential(
	(0): Linear(in_features=4, out_features=8, bias=True)
	(1): ReLU()
	(2): Linear(in_features=8, out_features=4, bias=True)
	(3): ReLU()
	)
   )
	(1): Linear(in_features=4, out_features=1, bias=True)
)

访问第⼀个主要的块中、第⼆个⼦块的第⼀层的偏置项：

rgnet[0][1][0].bias.data

2.2 参数初始化

默认情况下，PyTorch会根据⼀个范围均匀地初始化权重和偏置矩阵，这个范围是根据输⼊和输出维度计算出的。PyTorch的nn.init模块提供了多种预置初始化⽅法。

2.2.1内置初始化：

将所有权重参数初始化为标准差为0.01的⾼斯随机变量，且将偏置参数设置为0：

def init_normal(m):
	if type(m) == nn.Linear:
		nn.init.normal_(m.weight,mean=0,std=0.01)
		nn.init.zeros_(m.bias)
net.apply(init_normal)
net[0].weight.data[0],net[0].bias.data[0]

还可以将所有参数初始化为给定的常数，⽐如初始化为1:

def init_constant(m):
	if type(m) == nn.Linear:
		nn.init.constant_(m.weight,1)
		nn.init.zeros_(m.bias)
net.apply(init_constant)
net[0].weight.data[0],net[0].bias.data[0]

还可以对某些块应⽤不同的初始化⽅法。比如，使⽤Xavier初始化⽅法初始化第⼀个神经⽹络
层，然后将第三个神经⽹络层初始化为常量值42：

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)

2.2.2 自定义初始化

例如，使用以下分布为任意权重参数w初始化：

def my_init(m):
	if type(m) == nn.Linear:
		print("Init",*[(name,param.shape) for name,param in m.named_parameters()][0])
		nn.init.uniform_(m.weight,-10,10)
		m.weight.data *= m.weight.data.abs() >= 5

net.apply(my_init)
net[0].weight[:2]

可以直接设置参数:

net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
net[0].weight.data[0]

2.3 在不同模型组件间共享参数

可以定义⼀个稠密层，然后使⽤它的参数来设置另⼀个层的参数:

# 需要给共享层一个名称，以便可以引用它的参数。
shared = nn.Linear(8,8)
net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),
					shared,nn.ReLU(),
					shared,nn.ReLU(),
					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]

这个例⼦表明第三个和第五个神经⽹络层的参数是绑定的。它们不仅值相等，⽽且由相同的张量表⽰。因此，如果我们改变其中⼀个参数，另⼀个参数也会改变。

当参数绑定时，梯度会发⽣什么情况？答案是由于模型参数包含梯度，因此在反向传播期间第⼆个隐藏层（即第三个神经⽹络层）和第三个隐藏层（即第五个神经⽹络层）的梯度会加在⼀起。

3.延后初始化

到目前为止，我们定义了⽹络架构，但没有指定输⼊维度；添加层时没有指定前⼀层的输出维度；在初始化参数时，甚⾄没有⾜够的信息来确定模型应该包含多少参数。这⾥的诀窍是框架的延后初始化（defers initialization），即直到数据第⼀次通过模型传递时，框架才会动态地推断出每个层的⼤⼩。⼀旦我们知道输⼊维数是20，框架可以通过代⼊值20来识别第⼀层权重矩阵的形状。识别出第⼀层的形状后，框架处理第⼆层，依此类推，直到所有形状都已知为⽌。注意，在这种情况下，只有第⼀层需要延迟初始化，但是框架仍是按顺序初始化的。等到知道了所有的参数形状，框架就可以初始化参数。

4.自定义层

4.1 不带参数的层

下⾯的CenteredLayer类要从其输⼊中减去均值。要构建它，我们只需继承基础层类并实现前向传播功能。

import torch
import torch.nn.functional as F
from torch import nn

class CenteredLayer(nn.Module):
	def __init__(self):
		super().__init__()
	
	def forward(self,X):
		return X - X.mean()
layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))

tensor([-2., -1., 0., 1., 2.])

将层作为组件合并到更复杂的模型中:

net = nn.Sequential(nn.Linear(8,120),CenteredLayer())

检查均值是否为0:

Y = net(torch.rand(4, 8))
Y.mean()

因为存储精度的原因，会看到⼀个⾮常⼩的⾮零数。

tensor(-1.3970e-09, grad_fn=<MeanBackward0>)

4.2 带参数的层

实现⾃定义版本的全连接层。该层需要两个参数，⼀个⽤于表⽰权重，另⼀个⽤于表⽰偏置项。在此实现中，我们使⽤修正线性单元作为激活函数。该层需要输⼊参数：in_units和units，分别表⽰输⼊数和输出数。

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)

linear = MyLinear(5, 3)
linear.weight

Parameter containing:
tensor([[ 1.9094, -0.8244, -1.6846],
[ 0.6850, 0.8366, -1.3837],
[ 0.0289, 2.0976, 1.3855],
[-0.8574, -0.3557, -0.4109],
[ 2.2963, -1.3008, 1.2173]], requires_grad=True)

使用自定义层进行前向传播计算：

linear(torch.rand(2,5))

tensor([[0.0984, 0.5687, 2.8316],
[2.2558, 0.0000, 1.8880]])

还可以使⽤⾃定义层构建模型，就像使⽤内置的全连接层⼀样使⽤⾃定义层:

net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))

tensor([[7.5465],
[4.6817]])

5读写文件

5.1加载和保存张量

对于单个张量，可以直接调⽤load和save函数分别读写它们。这两个函数都要求提供⼀个名称，save要
求将要保存的变量作为输⼊。

import torch
from torch import nn
from torch.nn import functional as F

x = torch.arange(4)
torch.save(x,'x-file')

将存储在⽂件中的数据读回内存:

x2 = torch.load('x-file')
x2

可以存储⼀个张量列表，然后把它们读回内存:

y=torch.zeros(4)
torch.save([x,y],'x-files')
x2.y2 = torch.load('x-files')
(x2,y2)

甚⾄可以写⼊或读取从字符串映射到张量的字典。在读取或写⼊模型中的所有权重时，这很⽅便：

mydict = {'x':x,'y':y}
torch.save(mydict,'mydict')
mydict2 = torch.load('mydict')
mydict2

5.2加载和保存模型参数

深度学习框架提供了内置函数来保存和加载整个⽹络。这将保存模型的参数⽽不是保存整个模型。以3层的多层感知机为例：

class MLP(nn.Module):
	def __init__(self):
		super().__init__()
		self.hidden = nn.Linear(20, 256)
		self.output = nn.Linear(256, 10)
		
	def forward(self, x):
		return self.output(F.relu(self.hidden(x)))

net = MLP()
X = torch.randn(size=(2, 20))
Y = net(X)

将模型的参数存储在⼀个叫做“mlp.params”的⽂件中：

torch.save(net.state_dict(),'mlp.params')

恢复模型时，不需要随机初始化模型参数，⽽是直接读取⽂件中存储的参数：

clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval()

MLP(
(hidden): Linear(in_features=20, out_features=256, bias=True)
(output): Linear(in_features=256, out_features=10, bias=True)
)

由于两个实例具有相同的模型参数，在输⼊相同的X时，两个实例的计算结果应该相同。验证一下：

Y_clone = clone(X)
Y_clone == Y

tensor([[True, True, True, True, True, True, True, True, True, True],
[True, True, True, True, True, True, True, True, True, True]])

6.GPU

在PyTorch中，每个数组都有⼀个设备（device），通常将其称为环境（context）。默认情况下，所有变量和相关的计算都分配给CPU。有时环境可能是GPU。

6.1计算设备

可以指定⽤于存储和计算的设备，如CPU和GPU。默认情况下，张量是在内存中创建的，然后使⽤CPU计
算它。在PyTorch中，CPU和GPU可以⽤torch.device(‘cpu’) 和torch.device(‘cuda’)表⽰。应该注意的是，cpu设备意味着所有物理CPU和内存，这意味着PyTorch的计算将使⽤所有CPU核⼼。然⽽，gpu设备只代表⼀个卡和相应的显存。如果有多个GPU，则使⽤torch.device(f’cuda:{i}') 来表⽰第i块GPU（i从0开始）。另外，cuda:0和cuda是等价的。

import torch
from torch import nn
torch.device('cpu'), torch.device('cuda'), torch.device('cuda:1')

(device(type='cpu'), device(type='cuda'), device(type='cuda', index=1))

查询可用gpu的数量：

torch.cuda,device_count()

定义两个函数，可以在不存在所需所有GPU的情况下运行代码：

def try_gpu(i=0): #@save
	"""如果存在，则返回gpu(i)，否则返回cpu()"""
	if torch.cuda.device_count() >= i + 1:
		return torch.device(f'cuda:{i}')
	return torch.device('cpu')

def try_all_gpus(): #@save
	"""返回所有可⽤的GPU，如果没有GPU，则返回[cpu(),]"""
	devices = [torch.device(f'cuda:{i}')
		for i in range(torch.cuda.device_count())]
	return devices if devices else [torch.device('cpu')]
try_gpu(), try_gpu(10), try_all_gpus()

(device(type='cuda', index=0),
device(type='cpu'),
[device(type='cuda', index=0), device(type='cuda', index=1)])

6.2张量与GPU

可以查询张量所在的设备。默认情况下，张量是在CPU上创建的。

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

device(type='cpu')

⽆论何时我们要对多个项进⾏操作，它们都必须在同⼀个设备上。

有⼏种⽅法可以在GPU上存储张量。在第⼀个gpu上创建张量变量X：

X = torch.ones(2, 3, device=try_gpu())
X

假设⾄少有两个GPU，下⾯的代码将在第⼆个GPU上创建⼀个随机张量：

Y = torch.rand(2, 3, device=try_gpu(1))
Y

tensor([[0.3821, 0.5270, 0.4919],
[0.9391, 0.0660, 0.6468]], device='cuda:1')

如果要计算X + Y，需要决定在哪⾥执⾏这个操作。例如，在下图中，可以将X传输到第⼆个GPU并在那⾥执⾏操作。不要简单地X加上Y，因为这会导致异常，运⾏时引擎不知道该怎么做：它在同⼀设备上找不到数据会导致失败。由于Y位于第⼆个GPU上，所以需要将X移到那⾥，然后才能执⾏相加运算。

Z = X.cuda(1)
print(X)
print(Z)

tensor([[1., 1., 1.],
[1., 1., 1.]], device='cuda:0')
tensor([[1., 1., 1.],
[1., 1., 1.]], device='cuda:1'

现在数据在同⼀个GPU上（Z和Y都在），可以将它们相加。

print(Y + Z)

tensor([[1.3821, 1.5270, 1.4919],
[1.9391, 1.0660, 1.6468]], device='cuda:1'

6.3 神经网络与GPU

神经⽹络模型也可以指定设备。下⾯的代码将模型参数放在GPU上。

net = nn.Sequential(nn.Linear(3, 1))
net = net.to(device=try_gpu())

当输⼊为GPU上的张量时，模型将在同⼀GPU上计算结果。

net(X)

tensor([[-0.0605],
[-0.0605]], device='cuda:0', grad_fn=<AddmmBackward0>)

确认模型参数是否存储在同⼀个GPU上：

net[0].weight.data.device

device(type='cuda', index=0)

总之，只要所有的数据和参数都在同⼀个设备上，我们就可以有效地学习模型。

注意：不经意地移动数据可能会显著降低性能。
⼀个典型的错误如下：计算GPU上每个⼩批量的损失，并在命令⾏中将其报告给⽤⼾（或将其记录在NumPy ndarray中）时，将触发全局解释器锁，从⽽使所有GPU阻塞。最好是为GPU内部的⽇志分配内存，并且只移动较⼤的⽇志。