深度学习计算
模型构造
让我们回顾一下在3.10节（多层感知机的简洁实现）中含单隐藏层的多层感知机的实现方法。我们首先构造 Sequential实例，然后依次添加两个全连接层。其中第一层的输出大小为256，即隐藏层单元个数是256；第二层的输出大小为10，即输出层单元个数是10。我们在上一章的其他节中也使用了 Sequential类构造模型。这里我们介绍另外一种基于 Module类的模型构造方法：它让模型构造更加灵活。
继承Moudle类来构造模型
Module类是 nn模块里提供的一个模型构造类，是所有神经网络模块的基类，我们可以继承它来定义我们想要的模型。下面继承 Module类构造本节开头提到的多层感知机。这里定义的 MLP类重载了 Module类的 __init__函数和 forward函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。
import torch
from torch import nn
class MLP(nn.Module): # 定义MLP类，并继承自nn.Module
# 声明带有模型参数的层，这里声明了两个全连接层
def __init__(self, **kwargs): # 构造函数，它接收一个特殊的参数self（表示类的实例自身），以及可能的其他关键字参数kwargs（用于接收任意数量的关键字参数）
super(MLP, self).__init__(**kwargs) # 调用父类构造函数，MLP表示当前类的名称，self表示当前类的实例
self.hidden = nn.Linear(784, 256) # 隐藏层
self.act = nn.ReLU()
self.output = nn.Linear(256, 10) # 输出层
# 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出
def forward(self, x): # 它接收两个参数，self表示类的实例自身，x表示输入数据
a = self.act(self.hidden(x)) # 首先将输入x传递给隐藏层self.hidden进行线性变换，然后将变换后的结果传递给激活函数self.act进行非线性转换，最后将转换后的结果赋值给变量a
return self.output(a) # 将变量a作为输入传递给输出层self.output进行线性变换，并将结果返回作为模型的输出
'''
我们可以实例化MLP类得到模型变量net。下面的代码初始化net并传入输入数据X做一次前向计算。其中，net(X)会调用MLP继承自Module类的__call__函数，这个函数将调用MLP类定义的forward函数来完成前向计算
'''
X = torch.rand(2, 784)
net = MLP()
print(net) # 打印net形状
print(net(X))
Module的子类
我们刚刚提到，Module类是一个通用的部件。事实上，PyTorch还实现了继承自 Module的可以方便构建模型的类: 如 Sequential、ModuleList和 ModuleDict等等
Sequential类
当模型的前向计算为简单串联各个层的计算时，Sequential类可以通过更加简单的方式定义模型。这正是 Sequential类的目的：它可以接收一个子模块的有序字典（OrderedDict）或者一系列子模块作为参数来逐一添加 Module的实例，而模型的前向计算就是将这些实例按添加的顺序逐一计算。
下面我们实现一个与 Sequential类有相同功能的 MySequential类
from collections import OrderedDict
import torch
from torch import nn
class MySequential(nn.Module):
def __init__(self, *args):
super(MySequential, self).__init__() # 调用父类nn.Module的构造函数
if len(args) == 1 and isinstance(args[0], OrderedDict): # 判断如果传入的参数只有一个，并且是OrderedDict类型
for key, module in args[0].items(): # 遍历args[0]中的每个元素，其中args[0]表示传入的OrderedDict参数
self.add_module(key, module) # add_module方法会将module添加进self._modules(一个OrderedDict)
else: # 传入的是一些Module
for idx, module in enumerate(args): # 遍历args中的每个模块，idx表示模块的索引
self.add_module(str(idx), module)
def forward(self, input):
# self._modules返回一个 OrderedDict，保证会按照成员添加时的顺序遍历成员
for module in self._modules.values(): # 遍历self._modules中的每个模块
input = module(input) # 将输入数据input传递给当前模块module进行前向计算，并将计算结果赋值给input，作为下一层模块的输入
return input # 返回最终的模型输出
'''我们用MySequential类来实现前面描述的MLP类，并使用随机初始化的模型做一次前向计算。'''
net = MySequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 10),
)
print(net)
X = torch.rand(2, 784)
print(net(X)) # 在nn.Module的子类中，定义了forward函数后，可以通过直接调用实例对象来执行前向计算。这是因为在nn.Module中，__call__方法被实现为调用forward函数。
ModuleList类
ModuleList接收一个子模块的列表作为输入，然后也可以类似List那样进行append和extend操作:
from collections import OrderedDict
import torch
from torch import nn
net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10)) # 类似List的append操作，将一个新的线性层nn.Linear(256, 10)添加到net列表的末尾
print(net[-1]) # 类似List的索引访问，通过负索引访问net列表中的最后一个模块，即输出层nn.Linear(256, 10)
print(net) # 显示模型的结构信息
# net(torch.zeros(1, 784)) # 会报NotImplementedError
#output：
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功能需要自己实现，所以上面执行 net(torch.zeros(1, 784))会报 NotImplementedError；而 Sequential内的模块需要按照顺序排列，要保证相邻层的输入输出大小相匹配，内部 forward功能已经实现
ModuleList的出现只是让网络定义前向传播时更加灵活，见下面官网的例子：
class MyModule(nn.Module):
def __init__(self): # 构造函数
super(MyModule, self).__init__() # 调用父类构造函数
self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)]) # 创建了一个nn.ModuleList对象self.linears，其中包含了10个线性层nn.Linear(10, 10)。通过列表推导式，在循环中创建了这些线性层
def forward(self, x):
# ModuleList can act as an iterable, or be indexed using ints
for i, l in enumerate(self.linears): # ：使用enumerate函数遍历self.linears中的线性层。i表示迭代的索引，l表示当前的线性层
x = self.linears[i // 2](x) + l(x) # 将输入数据 x 分别传递给 self.linears[i // 2] 和 l 两个线性层进行前向计算，并将它们的结果相加
return x
另外，ModuleList不同于一般的Python的 list，加入到 ModuleList里面的所有模块的参数会被自动添加到整个网络中，下面看一个例子对比一下
from torch import nn
class Module_ModuleList(nn.Module):
def __init__(self):
super(Module_ModuleList, self).__init__()
self.linears = nn.ModuleList([nn.Linear(10, 10)])
class Module_List(nn.Module):
def __init__(self):
super(Module_List, self).__init__()
self.linears = [nn.Linear(10, 10)]
net1 = Module_ModuleList()
net2 = Module_List()
print("net1:")
for p in net1.parameters():
print(p.size())
print("net2:")
for p in net2.parameters():
print(p)
'''
普通列表没有提供模型追踪和管理的功能。因此，当调用 parameters() 方法时，无法直接访问到 self.linears 中线性层的参数。
在模型的前向计算中，需要手动编写代码来遍历和调用列表中的线性层
'''
#output
net1:
torch.Size([10, 10])
torch.Size([10])
net2:
ModuleDict类
ModuleDict接收一个子模块的字典作为输入, 然后也可以类似字典那样进行添加访问操作:
from torch import nn
net = nn.ModuleDict({
'linear': nn.Linear(784, 256),
'act': nn.ReLU(),
})
net['output'] = nn.Linear(256, 10) # 在net中添加一个键值对，键为'output'，值为一个线性层nn.Linear(256, 10)。这样就向net中添加了一个新的模块。
print(net['linear']) # 访问
print(net.output)
print(net)
# net(torch.zeros(1, 784)) 由于ModuleDict并没有实现前向传播函数，所以会报NotImplementedError错误。
#output
Linear(in_features=784, out_features=256, bias=True)
Linear(in_features=256, out_features=10, bias=True)
ModuleDict(
(act): ReLU()
(linear): Linear(in_features=784, out_features=256, bias=True)
(output): Linear(in_features=256, out_features=10, bias=True)
)
和 ModuleList一样，ModuleDict实例仅仅是存放了一些模块的字典，并没有定义 forward函数需要自己定义。同样，ModuleDict也与Python的 Dict有所不同，ModuleDict里的所有模块的参数会被自动添加到整个网络中
构造复杂的模型
虽然上面介绍的这些类可以使模型构造更加简单，且不需要定义 forward函数，但直接继承 Module类可以极大地拓展模型构造的灵活性。下面我们构造一个稍微复杂点的网络 FancyMLP。在这个网络中，我们通过 get_constant函数创建训练中不被迭代的参数，即常数参数。在前向计算中，除了使用创建的常数参数外，我们还使用 Tensor的函数和Python的控制流，并多次调用相同的层。
import torch
from torch import nn
class FancyMLP(nn.Module):
def __init__(self, **kwargs):
super(FancyMLP, self).__init__(**kwargs)
self.rand_weight = torch.rand((20, 20), requires_grad=False) # 不可训练参数（常数参数）
self.linear = nn.Linear(20, 20) # 创建了一个线性层
def forward(self, x):
x = self.linear(x)
# 使用创建的常数参数，以及nn.functional中的relu函数和mm函数
x = nn.functional.relu(torch.mm(x, self.rand_weight.data) + 1)
# 复用全连接层。等价于两个全连接层共享参数
x = self.linear(x)
# 控制流，这里我们需要调用item函数来返回标量进行比较
while x.norm().item() > 1: # 对输入x进行了归一化操作，确保其L2范数不超过1,助于限制输入的范围，使其适应模型的要求，同时保持输入数据的合理范围，有助于提高模型的稳定性和性能
x /= 2
if x.norm().item() < 0.8:
x *= 10
return x.sum()
X = torch.rand(2, 20)
net = FancyMLP()
print(net)
net(X)
#output
FancyMLP(
(linear): Linear(in_features=20, out_features=20, bias=True)
)
tensor(0.8432, grad_fn=<SumBackward0>)
因为 FancyMLP和 Sequential类都是 Module类的子类，所以我们可以嵌套调用它们
class NestMLP(nn.Module):
def __init__(self, **kwargs):
super(NestMLP, self).__init__(**kwargs)
self.net = nn.Sequential(nn.Linear(40, 30), nn.ReLU())
def forward(self, x):
return self.net(x)
net = nn.Sequential(NestMLP(), nn.Linear(30, 20), FancyMLP())
X = torch.rand(2, 40)
print(net)
net(X)
#output
Sequential(
(0): NestMLP(
(net): Sequential(
(0): Linear(in_features=40, out_features=30, bias=True)
(1): ReLU()
)
)
(1): Linear(in_features=30, out_features=20, bias=True)
(2): FancyMLP(
(linear): Linear(in_features=20, out_features=20, bias=True)
)
)
tensor(14.4908, grad_fn=<SumBackward0>)
模型参数的访问，初始化和共享
在3.3节（线性回归的简洁实现）中，我们通过 init模块来初始化模型的参数。我们也介绍了访问模型参数的简单方法。本节将深入讲解如何访问和初始化模型参数，以及如何在多个层之间共享同一份模型参数。
我们先定义一个与上一节中相同的含单隐藏层的多层感知机。我们依然使用默认方式初始化它的参数，并做一次前向计算。与之前不同的是，在这里我们从 nn中导入了 init模块，它包含了多种模型初始化方法。
import torch
from torch import nn
from torch.nn import init
net = nn.Sequential(nn.Linear(4, 3), nn.ReLU(), nn.Linear(3, 1)) # pytorch已进行默认初始化
print(net)
X = torch.rand(2, 4)
Y = net(X).sum()
#output
Sequential(
(0): Linear(in_features=4, out_features=3, bias=True)
(1): ReLU()
(2): Linear(in_features=3, out_features=1, bias=True)
)
访问模型参数
回忆一下上一节中提到的 Sequential类与 Module类的继承关系。对于 Sequential实例中含模型参数的层，我们可以通过 Module类的 parameters()或者 named_parameters方法来访问所有参数（以迭代器的形式返回），后者除了返回参数 Tensor外还会返回其名字。下面，访问多层感知机 net的所有参数：
print(type(net.named_parameters()))
for name, param in net.named_parameters():
print(name, param.size())
#output
<class 'generator'>
0.weight torch.Size([3, 4])
0.bias torch.Size([3])
2.weight torch.Size([1, 3])
2.bias torch.Size([1])
可见返回的名字自动加上了层数的索引作为前缀。 我们再来访问 net中单层的参数。对于使用 Sequential类构造的神经网络，我们可以通过方括号 []来访问网络的任一层。索引0表示隐藏层为 Sequential实例最先添加的层。
for name, param in net[0].named_parameters():
print(name, param.size(), type(param))
#output
weight torch.Size([3, 4]) <class 'torch.nn.parameter.Parameter'>
bias torch.Size([3]) <class 'torch.nn.parameter.Parameter'>
因为这里是单层的所以没有了层数索引的前缀。另外返回的 param的类型为 torch.nn.parameter.Parameter，其实这是 Tensor的子类，和 Tensor不同的是如果一个 Tensor是 Parameter，那么它会自动被添加到模型的参数列表里，来看下面这个例子。
import torch
from torch import nn
from torch.nn import init
class MyModel(nn.Module):
def __init__(self, **kwargs):
super(MyModel, self).__init__(**kwargs)
self.weight1 = nn.Parameter(torch.rand(20, 20)) # 通过nn.Parameter将其标记为需要优化的参数。它的初始值为形状为(20, 20)的随机张量
self.weight2 = torch.rand(20, 20)
def forward(self, x):
pass
n = MyModel()
for name, param in n.named_parameters():
print(name)
#output
weight1
上面的代码中 weight1在参数列表中但是 weight2却没在参数列表中。
因为 Parameter是 Tensor，即 Tensor拥有的属性它都有，比如可以根据 data来访问参数数值，用 grad来访问参数梯度。
weight_0 = list(net[0].parameters())[0]
print(weight_0.data)
print(weight_0.grad) # 反向传播前梯度为None
Y.backward()
print(weight_0.grad)
#output
tensor([[ 0.2719, -0.0898, -0.2462, 0.0655],
[-0.4669, -0.2703, 0.3230, 0.2067],
[-0.2708, 0.1171, -0.0995, 0.3913]])
None
tensor([[-0.2281, -0.0653, -0.1646, -0.2569],
[-0.1916, -0.0549, -0.1382, -0.2158],
[ 0.0000, 0.0000, 0.0000, 0.0000]])
初始化模型参数
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)
#output
0.weight tensor([[ 0.0030, 0.0094, 0.0070, -0.0010],
[ 0.0001, 0.0039, 0.0105, -0.0126],
[ 0.0105, -0.0135, -0.0047, -0.0006]])
2.weight tensor([[-0.0074, 0.0051, 0.0066]])
下面使用常数来初始化权重参数
for name, param in net.named_parameters():
if 'bias' in name:
init.constant_(param, val=0)
print(name, param.data)
自定义初始化方法
有时候我们需要的初始化方法并没有在 init模块中提供。这时，可以实现一个初始化方法，从而能够像使用其他初始化方法那样使用它。在这之前我们先来看看PyTorch是怎么实现这些初始化方法的，例如 torch.nn.init.normal_
def normal_(tensor, mean=0, std=1):
with torch.no_grad():
return tensor.normal_(mean, std)
可以看到这就是一个inplace改变 Tensor值的函数，而且这个过程是不记录梯度的。 类似的我们来实现一个自定义的初始化方法。在下面的例子里，我们令权重有一半概率初始化为0，有另一半概率初始化为[−10**,−5**][−10,−5][−10,−5**]和**[5,10][5,10][5,10]两个区间里均匀分布的随机数。
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)
此外，我们还可以通过改变这些参数的 data来改写模型参数值同时不会影响梯度
for name, param in net.named_parameters():
if 'bias' in name:
param.data += 1
print(name, param.data)
#output
0.bias tensor([1.2821, 1.1869, 1.0025])
2.bias tensor([1.0862])
共享模型参数
在有些情况下，我们希望在多个层之间共享模型参数。4.1.3节提到了如何共享模型参数: Module类的 forward函数里多次调用同一个层。此外，如果我们传入 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)
#output
Sequential(
(0): Linear(in_features=1, out_features=1, bias=False)
(1): Linear(in_features=1, out_features=1, bias=False)
)
0.weight tensor([[3.]])
在内存中，这两个线性层其实一个对象:
print(id(net[0]) == id(net[1]))
print(id(net[0].weight) == id(net[1].weight))
#output
True
True
因为模型参数里包含了梯度，所以在反向传播计算时，这些共享的参数的梯度是累加的:
x = torch.ones(1, 1)
y = net(x).sum()
print(y)
y.backward()
print(net[0].weight.grad) # 单次梯度是3，两次所以就是6
#output
tensor(9., grad_fn=<SumBackward0>)
tensor([[6.]])
自定义层
不含模型参数的自定义层
下面的 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()
'''我们可以实例化这个层，然后做前向计算'''
layer = CenteredLayer()
layer(torch.tensor([1, 2, 3, 4, 5], dtype=torch.float))
'''我们也可以用它来构造更复杂的模型'''
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())
'''下面打印自定义层各个输出的均值。因为均值是浮点数，所以它的值是一个很接近0的数'''
y = net(torch.rand(4, 8))
y.mean().item()
#output:7.450580596923828e-09
含模型参数的自定义层
我们还可以自定义含模型参数的自定义层。其中的模型参数可以通过训练学出。
在4.2节（模型参数的访问、初始化和共享）中介绍了 Parameter类其实是 Tensor的子类，如果一个 Tensor是 Parameter，那么它会自动被添加到模型的参数列表里。所以在自定义含模型参数的层时，我们应该将参数定义成 Parameter，除了像4.2.1节那样直接定义成 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)
#output
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)
#output
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]
)
)
'''这样就可以根据传入的键值来进行不同的前向传播'''
x = torch.ones(1, 4)
print(net(x, 'linear1'))
print(net(x, 'linear2'))
print(net(x, 'linear3'))
#output
tensor([[1.5082, 1.5574, 2.1651, 1.2409]], grad_fn=<MmBackward>)
tensor([[-0.8783]], grad_fn=<MmBackward>)
tensor([[ 2.2193, -1.6539]], grad_fn=<MmBackward>)
'''我们也可以使用自定义层构造模型。它和PyTorch的其他层在使用上很类似'''
net = nn.Sequential(
MyDictDense(),
MyListDense(),
)
print(net)
print(net(x))
#output
Sequential(
(0): 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]
)
)
(1): MyListDense(
(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]
)
)
)
tensor([[-101.2394]], grad_fn=<MmBackward>)
读取和存储
到目前为止，我们介绍了如何处理数据以及如何构建、训练和测试深度学习模型。然而在实际中，我们有时需要把训练好的模型部署到很多不同的设备。在这种情况下，我们可以把内存中训练好的模型参数存储在硬盘上供后续读取使用
读写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')
print(x2)
#output：tensor([1., 1., 1.])
'''我们还可以存储一个Tensor列表并读回内存。'''
y = torch.zeros(4)
torch.save([x, y], 'xy.pt')
xy_list = torch.load('xy.pt')
print(xy_list)
#output: [tensor([1., 1., 1.]), tensor([0., 0., 0., 0.])]
'''存储并读取一个从字符串映射到Tensor的字典'''
torch.save({'x': x, 'y': y}, 'xy_dict.pt')
xy = torch.load('xy_dict.pt')
print(xy)
#output: {'x': tensor([1., 1., 1.]), 'y': tensor([0., 0., 0., 0.])}
读写模型
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()
print(net.state_dict())
#output:
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)
print(optimizer.state_dict())
#output:
{'param_groups': [{'dampening': 0,
'lr': 0.001,
'momentum': 0.9,
'nesterov': False,
'params': [4736167728, 4736166648, 4736167368, 4736165352],
'weight_decay': 0}],
'state': {}}
保存和加载模型
PyTorch中保存和加载训练模型有两种常见的方法:
- 仅保存和加载模型参数(
state_dict)； - 保存和加载整个模型。
保存和加载state_dict(推荐)
'''保存'''
torch.save(model.state_dict(), filename) # 推荐的文件后缀名是pt或pth
'''加载'''
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(filename))
保存和加载整个模型
torch.save(model, PATH) #保存
model = torch.load(PATH) #加载
我们采用推荐的方法一来实验一下
X = torch.randn(2, 3)
Y = net(X)
PATH = "./net.pt"
torch.save(net.state_dict(), PATH)
net2 = MLP()
net2.load_state_dict(torch.load(PATH))
Y2 = net2(X)
Y2 == Y
#output
tensor([[1],
[1]], dtype=torch.uint8)
因为这 net和 net2都有同样的模型参数，那么对同一个输入 X的计算结果将会是一样的。上面的输出也验证了这一点
GPU计算（但是我没有CUDA😣）
计算设备
torch.cuda.is_available()查看GPU是否可用
torch.cuda.device_count()查看GPU数量
torch.cuda.current_device()查看当前GPU名字
Tensor的GPU计算
默认情况下，Tensor会被存在内存上。因此，之前我们每次打印 Tensor的时候看不到GPU相关标识
使用 .cuda()可以将CPU上的 Tensor转换（复制）到GPU上。如果有多块GPU，我们用 .cuda(i)来表示第 i 块GPU及相应的显存（i 从0开始）且 cuda(0)和 cuda()等价。
x = x.cuda(0)
print(x)
#output:tensor([1, 2, 3], device='cuda:0')
'''我们可以通过Tensor的device属性来查看该Tensor所在的设备'''
x.device
#output:device(type='cuda', index=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)
#output:tensor([1, 2, 3], device='cuda:0')
如果对在GPU上的数据进行运算，那么结果还是存放在GPU上
y = x**2
print(y)
#output:tensor([1, 4, 9], device='cuda:0')
需要注意的是，存储在不同位置中的数据是不可以直接进行计算的。即存放在CPU上的数据不可以直接与存放在GPU上的数据进行运算，位于不同GPU上的数据也是不能直接进行计算的
模型的GPU计算
同 Tensor类似，PyTorch模型也可以通过 .cuda转换到GPU上。我们可以通过检查模型的参数的 device属性来查看存放模型的设备
net = nn.Linear(3, 1)
list(net.parameters())[0].device
#output：device(type='cpu')
'''可见模型在CPU上，将其转换到GPU上:'''
net.cuda()
list(net.parameters())[0].device
#output: device(type='cuda', index=0)
总之，PyTorch要求计算的所有输入数据都在内存或同一块显卡的显存上。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
