- 多层感知机的简洁实现pytorch-多层感知机,最简单的深度学习模型,将非线性激活函数引入到模型中。_羞儿的博客-CSDN博客中含单隐藏层的多层感知机的实现方法。首先构造
Sequential
实例,然后依次添加两个全连接层。其中第一层的输出大小为256,即隐藏层单元个数是256;第二层的输出大小为10,即输出层单元个数是10。我们在上一章的其他节中也使用了Sequential
类构造模型。这里我们介绍另外一种基于Module
类的模型构造方法:它让模型构造更加灵活。
继承Module
类来构造模型
-
Module
类是nn
模块里提供的一个模型构造类,是所有神经网络模块的基类,可以继承它来定义我们想要的模型。下面继承Module
类构造本节开头提到的多层感知机。这里定义的MLP
类重载了Module
类的__init__
函数和forward
函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。MLP
类中无须定义反向传播函数。系统将通过自动求梯度而自动生成反向传播所需的backward
函数。 -
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
类得到模型变量net
。下面的代码初始化net
并传入输入数据X
做一次前向计算。其中,net(X)
会调用MLP
继承自Module
类的__call__
函数,这个函数将调用MLP
类定义的forward
函数来完成前向计算。 -
x = torch.rand(2, 784) net = MLP() print(net) net(X)ag-0-1gqj7fqh9ag-1-1gqj7fqh9
-
MLP( (hidden): Linear(in_features=784, out_features=256, bias=True) (act): ReLU() (output): Linear(in_features=256, out_features=10, bias=True) ) tensor([[ 0.0569, 0.0350, -0.0277, -0.0978, 0.0526, -0.1721, 0.1613, 0.0384, 0.0745, -0.1180], [ 0.1452, 0.0046, 0.0880, -0.0355, -0.0086, -0.0448, 0.2466, 0.0487, 0.0475, -0.0972]], grad_fn=<AddmmBackward0>)
-
注意,这里并没有将
Module
类命名为Layer
(层)或者Model
(模型)之类的名字,这是因为该类是一个可供自由组建的部件。它的子类既可以是一个层(如PyTorch提供的Linear
类),又可以是一个模型(如这里定义的MLP
类),或者是模型的一个部分。
Module
的子类
-
Module
类是一个通用的部件。事实上,PyTorch还实现了继承自
Module的可以方便构建模型的类: 如
Sequential、
ModuleList和
ModuleDict`等等。 -
Sequential
类-
当模型的前向计算为简单串联各个层的计算时,
Sequential
类可以通过更加简单的方式定义模型。这正是Sequential
类的目的:它可以接收一个子模块的有序字典(OrderedDict)或者一系列子模块作为参数来逐一添加Module
的实例,而模型的前向计算就是将这些实例按添加的顺序逐一计算。 -
实现一个与
Sequential
类有相同功能的MySequential
类。这或许可以帮助读者更加清晰地理解Sequential
类的工作机制。用MySequential
类来实现前面描述的MLP
类,并使用随机初始化的模型做一次前向计算。 -
MySequential( (0): Linear(in_features=784, out_features=256, bias=True) (1): ReLU() (2): Linear(in_features=256, out_features=10, bias=True) ) tensor([[ 0.0266, 0.0073, 0.1667, -0.0249, -0.0646, 0.0612, 0.0847, 0.0460, 0.3148, 0.0031], [ 0.0881, 0.0829, 0.1487, 0.0068, -0.1228, -0.1077, 0.0487, -0.0836, 0.1567, -0.1193]], grad_fn=<AddmmBackward0>)
-
-
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) net(torch.zeros(1, 784)) # 会报NotImplementedError
-
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) ) NotImplementedError: Module [ModuleList] is missing the required "forward" function
-
既然
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)]) def forward(self, x): # ModuleList can act as an iterable, or be indexed using ints for i, l in enumerate(self.linears): x = self.linears[i // 2](x) + l(x) return x
-
另外,
ModuleList
不同于一般的Python的list
,加入到ModuleList
里面的所有模块的参数会被自动添加到整个网络中,下面看一个例子对比一下。 -
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)
-
net1: torch.Size([10, 10]) torch.Size([10]) net2:
-
-
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) # net(torch.zeros(1, 784)) # 会报NotImplementedError
-
Linear(in_features=784, out_features=256, bias=True) Linear(in_features=256, out_features=10, bias=True) ModuleDict( (linear): Linear(in_features=784, out_features=256, bias=True) (act): ReLU() (output): Linear(in_features=256, out_features=10, bias=True) )
-
和
ModuleList
一样,ModuleDict
实例仅仅是存放了一些模块的字典,并没有定义forward
函数需要自己定义。同样,ModuleDict
也与Python的Dict
有所不同,ModuleDict
里的所有模块的参数会被自动添加到整个网络中。
-
构造复杂的模型
-
虽然上面介绍的这些类可以使模型构造更加简单,且不需要定义
forward
函数,但直接继承Module
类可以极大地拓展模型构造的灵活性。下面我们构造一个稍微复杂点的网络FancyMLP
。在这个网络中,我们通过get_constant
函数创建训练中不被迭代的参数,即常数参数。在前向计算中,除了使用创建的常数参数外,我们还使用Tensor
的函数和Python的控制流,并多次调用相同的层。在这个FancyMLP
模型中,我们使用了常数权重rand_weight
(注意它不是可训练模型参数)、做了矩阵乘法操作(torch.mm
)并重复使用了相同的Linear
层。下面我们来测试该模型的前向计算。 -
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 /= 2 if x.norm().item() < 0.8: x *= 10 return x.sum() X = torch.rand(2, 20) net = FancyMLP() print(net) net(X)
-
FancyMLP( (linear): Linear(in_features=20, out_features=20, bias=True) ) tensor(-13.7453, 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)
-
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(-8.4966, grad_fn=<SumBackward0>)
-
可以通过继承
Module
类来构造模型。Sequential
、ModuleList
、ModuleDict
类都继承自Module
类。与Sequential
不同,ModuleList
和ModuleDict
并没有定义一个完整的网络,它们只是将不同的模块存放在一起,需要自己定义forward
函数。虽然Sequential
等类可以使模型构造更加简单,但直接继承Module
类可以极大地拓展模型构造的灵活性。
模型参数的访问、初始化和共享
-
通过
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()
-
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())
-
<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
实例最先添加的层。-
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() print(X,Y) print(type(net.named_parameters())) for name, param in net.named_parameters(): print(name, param.size()) for name, param in net[0].named_parameters(): print(name, param.size(), type(param))
-
Sequential( (0): Linear(in_features=4, out_features=3, bias=True) (1): ReLU() (2): Linear(in_features=3, out_features=1, bias=True) ) tensor([[0.3863, 0.5931, 0.4958, 0.5612], [0.6388, 0.5556, 0.0613, 0.0673]]) tensor(0.0355, grad_fn=<SumBackward0>) <class 'generator'> 0.weight torch.Size([3, 4]) 0.bias torch.Size([3]) 2.weight torch.Size([1, 3]) 2.bias torch.Size([1]) 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
,那么它会自动被添加到模型的参数列表里,来看下面这个例子。-
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
来访问参数梯度。 -
weight_0 = list(net[0].parameters())[0] print(weight_0.data) print(weight_0.grad) # 反向传播前梯度为None Y.backward() print(weight_0.grad)
-
tensor([[ 0.1633, 0.4935, -0.2096, 0.3643], [-0.3411, -0.4858, -0.0935, -0.4009], [ 0.0155, 0.2264, 0.2721, 0.3809]]) None tensor([[-0.5175, -0.5799, -0.2812, -0.3173], [ 0.0000, 0.0000, 0.0000, 0.0000], [-0.2534, -0.2840, -0.1377, -0.1554]])
-
初始化模型参数
-
PyTorch中
nn.Module
的模块参数都采取了较为合理的初始化策略(不同类型的layer具体采样的哪一种初始化方法的可参考源代码)。但我们经常需要使用其他方法来初始化权重。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)
-
0.weight tensor([[ 0.0024, 0.0115, 0.0088, 0.0098], [-0.0160, -0.0014, 0.0021, 0.0019], [ 0.0031, 0.0009, 0.0060, -0.0080]]) 2.weight tensor([[ 0.0137, -0.0166, -0.0243]])
-
自定义初始化方法
-
有时候我们需要的初始化方法并没有在
init
模块中提供。这时,可以实现一个初始化方法,从而能够像使用其他初始化方法那样使用它。在这之前我们先来看看PyTorch是怎么实现这些初始化方法的,例如torch.nn.init.normal_
:可以看到这就是一个inplace改变Tensor
值的函数,而且这个过程是不记录梯度的。类似的我们来实现一个自定义的初始化方法。在下面的例子里,我们令权重有一半概率初始化为0,有另一半概率初始化为[-10,-5]和[5,10]两个区间里均匀分布的随机数。 -
def normal_(tensor, mean=0, std=1): with torch.no_grad(): return tensor.normal_(mean, std) 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)
-
0.weight tensor([[-0.0000, -9.1898, 6.7726, -0.0000], [ 0.0000, -0.0000, -7.7626, 0.0000], [ 6.0222, 9.4339, -8.2883, -0.0000]]) 2.weight tensor([[0., 0., -0.]])
-
还可以通过改变这些参数的
data
来改写模型参数值同时不会影响梯度: -
for name, param in net.named_parameters(): if 'bias' in name: param.data += 1 print(name, param.data)
-
0.bias tensor([0.7341, 1.0775, 1.1191]) 2.bias tensor([1.2091])
共享模型参数
-
在有些情况下,我们希望在多个层之间共享模型参数。如何共享模型参数:
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) print(id(net[0]) == id(net[1])) print(id(net[0].weight) == id(net[1].weight)) x = torch.ones(1, 1) y = net(x).sum() print(y) y.backward() print(net[0].weight.grad) # 单次梯度是3,两次所以就是6
-
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.]]) True True tensor(9., grad_fn=<SumBackward0>) tensor([[6.]])
自定义层
-
深度学习的一个魅力在于神经网络中各式各样的层,例如全连接层和后面章节中将要介绍的卷积层、池化层与循环层。虽然PyTorch提供了大量常用的层,但有时候我们依然希望自定义层。本节将介绍如何使用
Module
来自定义层,从而可以被重复调用。 -
不含模型参数的自定义层
- 先介绍如何定义一个不含模型参数的自定义层。模型构造中介绍的使用
Module
类构造模型类似。下面的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))
-
tensor([-2., -1., 0., 1., 2.])
- 也可以用它来构造更复杂的模型。下面打印自定义层各个输出的均值。因为均值是浮点数,所以它的值是一个很接近0的数。
-
y = net(torch.rand(4, 8)) y.mean().item()
-
-3.259629011154175e-09
-
- 先介绍如何定义一个不含模型参数的自定义层。模型构造中介绍的使用
-
含模型参数的自定义层
-
还可以自定义含模型参数的自定义层。其中的模型参数可以通过训练学出。模型参数的访问、初始化和共享中介绍了
Parameter
类其实是Tensor
的子类,如果一个Tensor
是Parameter
,那么它会自动被添加到模型的参数列表里。所以在自定义含模型参数的层时,应该将参数定义成Parameter
,那样直接定义成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.float32 of size 4x4] (1): Parameter containing: [torch.float32 of size 4x4] (2): Parameter containing: [torch.float32 of size 4x4] (3): Parameter containing: [torch.float32 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) x = torch.ones(1, 4) # 这样就可以根据传入的键值来进行不同的前向传播: print(net(x, 'linear1')) print(net(x, 'linear2')) print(net(x, 'linear3'))
-
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] ) ) tensor([[ 0.0328, 2.9246, 1.9687, -0.0347]], grad_fn=<MmBackward0>) tensor([[-1.4231]], grad_fn=<MmBackward0>) tensor([[ 2.0699, -0.0636]], grad_fn=<MmBackward0>)
-
-
也可以使用自定义层构造模型。它和PyTorch的其他层在使用上很类似。
-
net = nn.Sequential( MyDictDense(), CenteredLayer(), ) print(net) print(net(x))
-
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): CenteredLayer() ) tensor([[-0.9821, 2.2057, 1.5066, -2.7302]], grad_fn=<SubBackward0>)
-
-
可以通过
Module
类自定义神经网络中的层,从而可以被重复调用。
读取和存储
-
到目前为止,介绍了如何处理数据以及如何构建、训练和测试深度学习模型。然而在实际中,有时需要把训练好的模型部署到很多不同的设备。在这种情况下,可以把内存中训练好的模型参数存储在硬盘上供后续读取使用。
-
读写
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) # 还可以存储一个`Tensor`列表并读回内存。 y = torch.zeros(4) torch.save([x, y], 'xy.pt') xy_list = torch.load('xy.pt') print(xy_list) # 存储并读取一个从字符串映射到`Tensor`的字典。 torch.save({'x': x, 'y': y}, 'xy_dict.pt') xy = torch.load('xy_dict.pt') print(xy)
-
tensor([1., 1., 1.]) [tensor([1., 1., 1.]), tensor([0., 0., 0., 0.])] {'x': tensor([1., 1., 1.]), 'y': tensor([0., 0., 0., 0.])}
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SKoP2sZg-1677897286625)(C:\Users\23105\AppData\Roaming\marktext\images\2023-03-04-10-20-35-image.png)]
- 可以直接使用
读写模型
-
在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.3441, 0.5054, 0.5027], [ 0.4022, -0.0523, 0.2171]])), ('hidden.bias', tensor([0.0867, 0.5426])), ('output.weight', tensor([[ 0.5839, -0.6612]])), ('output.bias', tensor([0.2582]))])
-
-
注意,只有具有可学习参数的层(卷积层、线性层等)才有
state_dict
中的条目。优化器(optim
)也有一个state_dict
,其中包含关于优化器状态以及所使用的超参数的信息。-
optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9) optimizer.state_dict()
-
{'state': {}, 'param_groups': [{'lr': 0.001, 'momentum': 0.9, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'maximize': False, 'foreach': None, 'differentiable': False, 'params': [0, 1, 2, 3]}]}
-
保存和加载模型加载预训练模型,模型微调,在自己的数据集上快速出效果_羞儿的博客-CSDN博客
-
PyTorch中保存和加载训练模型有两种常见的方法:
-
仅保存和加载模型参数(
state_dict
); -
保存和加载整个模型。
-
-
保存和加载
state_dict
(推荐方式)-
# 保存 torch.save(model.state_dict(), PATH) # 推荐的文件后缀名是pt或pth # 加载 model = TheModelClass(*args, **kwargs) model.load_state_dict(torch.load(PATH))
-
-
保存和加载整个模型
-
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
-
tensor([[True], [True]])
-
-
因为这
net
和net2
都有同样的模型参数,那么对同一个输入X
的计算结果将会是一样的。上面的输出也验证了这一点。此外,还有一些其他使用场景,例如GPU与CPU之间的模型保存与读取、使用多块GPU的模型的存储等等,使用的时候可以参考官方文档。 -
通过
save
函数和load
函数可以很方便地读写Tensor
。通过save
函数和load_state_dict
函数可以很方便地读写模型的参数。
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
-
tensor([[True], [True]])
-
-
因为这
net
和net2
都有同样的模型参数,那么对同一个输入X
的计算结果将会是一样的。上面的输出也验证了这一点。此外,还有一些其他使用场景,例如GPU与CPU之间的模型保存与读取、使用多块GPU的模型的存储等等,使用的时候可以参考官方文档。 -
通过
save
函数和load
函数可以很方便地读写Tensor
。通过save
函数和load_state_dict
函数可以很方便地读写模型的参数。