torch.nn.Parameter 参数相关的介绍和使用
Posted zyw2002
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了torch.nn.Parameter 参数相关的介绍和使用相关的知识,希望对你有一定的参考价值。
文章目录
torch.nn.Parameter
基本介绍
torch.nn.Parameter
是继承自torch.Tensor
的子类,其主要作用是作为nn.Module
中的可训练参数使用。它与torch.Tensor
的区别就是nn.Parameter
会自动被认为是module
的可训练参数,即加入到parameter()
这个迭代器中去。
具体格式如下:
torch.nn.parameter.Parameter(data=None, requires_grad=True)
其中 data
为待传入的 Tensor
,requires_grad
默认为 True。
事实上,torch.nn
中提供的模块中的参数均是 nn.Parameter
类,例如:
module = nn.Linear(3, 3)
type(module.weight)
# torch.nn.parameter.Parameter
type(module.bias)
# torch.nn.parameter.Parameter
参数构造
nn.Parameter
可以看作是一个类型转换函数,将一个不可训练的类型 Tensor
转换成可以训练的类型 parameter
,并将这个 parameter
绑定到这个module
里面nn.Parameter()
添加的参数会被添加到Parameters
列表中,会被送入优化器中随训练一起学习更新
此时调用 parameters()
方法会显示参数。读者可自行体会以下两端代码:
""" 代码片段一 """
class Net(nn.Module):
def __init__(self):
super().__init__()
self.weight = torch.randn(3, 3)
self.bias = torch.randn(3)
def forward(self, inputs):
pass
net = Net()
print(list(net.parameters()))
# []
""" 代码片段二 """
class Net(nn.Module):
def __init__(self):
super().__init__()
self.weight = **nn.Parameter**(torch.randn(3, 3)) # 将tensor转换成parameter类型
self.bias = **nn.Parameter**(torch.randn(3))
def forward(self, inputs):
pass
net = Net()
print(list(**net.parameters()**)) # 显示参数
# [Parameter containing:
# tensor([[-0.4584, 0.3815, -0.4522],
# [ 2.1236, 0.7928, -0.7095],
# [-1.4921, -0.5689, -0.2342]], requires_grad=True), Parameter containing:
# tensor([-0.6971, -0.7651, 0.7897], requires_grad=True)]
nn.Parameter
相当于把传入的数据包装成一个参数,如果要直接访问/使用其中的数据而非参数本身,可对 nn.Parameter
对象调用 data
属性:
a = torch.tensor([1, 2, 3]).to(torch.float32)
param = nn.Parameter(a)
print(param)
# Parameter containing:
# tensor([1., 2., 3.], requires_grad=True)
print(param.data)
# tensor([1., 2., 3.])
参数访问
nn.Module 中有 **state_dict()**
方法,该方法将以字典形式返回模块的所有状态,包括模块的参数和 persistent buffers
,字典的键就是对应的参数/缓冲区的名称。
由于所有模块都继承 nn.Module
,因此我们可以对任意的模块调用 state_dict()
方法以查看状态:
linear_layer = nn.Linear(2, 2)
print(linear_layer.state_dict())
# OrderedDict([('weight', tensor([[ 0.2602, -0.2318],
# [-0.5192, 0.0130]])), ('bias', tensor([0.5890, 0.2476]))])
print(linear_layer.state_dict().keys())
# odict_keys(['weight', 'bias'])
对于线性层,除了 state_dict()
之外,我们还可以对其直接调用相应的属性,如下:
linear_layer = nn.Linear(2, 1)
print(linear_layer.weight)
# Parameter containing:
# tensor([[-0.1990, 0.3394]], requires_grad=True)
print(linear_layer.bias)
# Parameter containing:
# tensor([0.2697], requires_grad=True)
需要注意的是以上返回的均为参数对象,如需使用其中的数据,可调用 data
属性。
参数初始化
使用内置初始化
对于下面的单隐层网络,我们想对其中的两个线性层应用内置初始化器
class Net(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.Sequential(
nn.Linear(3, 2),
nn.ReLU(),
nn.Linear(2, 3),
)
def forward(self, X):
return self.layers(X)
假设权重从 N(0,1)
中采样,偏置全部初始化为 0
,则初始化代码如下:
def init_normal(module):
# 需要判断子模块是否为nn.Linear类,因为激活函数没有参数
if type(module) == nn.Linear:
nn.init.normal_(module.weight, mean=0, std=1)
nn.init.zeros_(module.bias)
net = Net()
net.apply(init_normal)
for param in net.parameters():
print(param)
# Parameter containing:
# tensor([[-0.3560, 0.8078, -2.4084],
# [ 0.1700, -0.3217, -1.3320]], requires_grad=True)
# Parameter containing:
# tensor([0., 0.], requires_grad=True)
# Parameter containing:
# tensor([[-0.8025, -1.0695],
# [-1.7031, -0.3068],
# [-0.3499, 0.4263]], requires_grad=True)
# Parameter containing:
# tensor([0., 0., 0.], requires_grad=True)
对 net
调用 apply
方法则会递归地对其下所有的子模块应用 init_normal
函数。
自定义初始化
如果我们想要自定义初始化,例如使用以下的分布来初始化网络的权重:
def my_init(module):
if type(module) == nn.Linear:
nn.init.uniform_(module.weight, -10, 10)
mask = module.weight.data.abs() >= 5
module.weight.data *= mask
net = Net()
net.apply(my_init)
for param in net.parameters():
print(param)
# Parameter containing:
# tensor([[-0.0000, -5.9610, 8.0000],
# [-0.0000, -0.0000, 7.6041]], requires_grad=True)
# Parameter containing:
# tensor([ 0.4058, -0.2891], requires_grad=True)
# Parameter containing:
# tensor([[ 0.0000, -0.0000],
# [-6.9569, -9.5102],
# [-9.0270, -0.0000]], requires_grad=True)
# Parameter containing:
# tensor([ 0.2521, -0.1500, -0.1484], requires_grad=True)
参数绑定
对于一个三隐层网络:
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
nn.Linear(8, 8), nn.ReLU(),
nn.Linear(8, 8), nn.ReLU(),
nn.Linear(8, 1))
如果我们想让第二个隐层和第三个隐层共享参数,则可以这样做:
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
shared, nn.ReLU(),
shared, nn.ReLU(),
nn.Linear(8, 1))
参考
PyTorch学习笔记(六)–Sequential类、参数管理与GPU_Lareges的博客-CSDN博客_sequential类
Python的torch.nn.Parameter初始化方法_昊大侠的博客-CSDN博客_torch.nn.parameter初始化
了解 torch.nn.Parameter
【中文标题】了解 torch.nn.Parameter【英文标题】:Understanding torch.nn.Parameter 【发布时间】:2018-11-28 19:51:07 【问题描述】:我是 pytorch 的新手,我很难理解 torch.nn.Parameter()
的工作原理。
我已经阅读了https://pytorch.org/docs/stable/nn.html 中的文档,但可能对此知之甚少。
有人可以帮忙吗?
我正在处理的代码 sn-p:
def __init__(self, weight):
super(Net, self).__init__()
# initializes the weights of the convolutional layer to be the weights of the 4 defined filters
k_height, k_width = weight.shape[2:]
# assumes there are 4 grayscale filters
self.conv = nn.Conv2d(1, 4, kernel_size=(k_height, k_width), bias=False)
self.conv.weight = torch.nn.Parameter(weight)
【问题讨论】:
这个话题似乎很有趣,也许你想发布一段你想讨论的代码? 嘿 iGian,我已经发布了我正在处理的代码 sn-p。提前致谢。 【参考方案1】:我会为你分解它。您可能知道,张量是多维矩阵。参数的原始形式是张量,即多维矩阵。它是变量类的子类。
变量和参数之间的区别在于与模块关联时。当参数作为模型属性与模块关联时,它会自动添加到参数列表中,并且可以使用“参数”迭代器进行访问。
最初在 Torch 中,变量(例如可能是中间状态)也会在分配时作为模型的参数添加。后来发现了需要缓存变量而不是将它们添加到参数列表中的用例。
文档中提到的一种情况是 RNN,在这种情况下,您需要保存最后一个隐藏状态,这样您就不必一次又一次地传递它。需要缓存一个变量,而不是让它自动注册为模型的参数,这就是为什么我们有一种显式的方式将参数注册到我们的模型,即 nn.Parameter 类。
例如,运行以下代码 -
import torch
import torch.nn as nn
from torch.optim import Adam
class NN_Network(nn.Module):
def __init__(self,in_dim,hid,out_dim):
super(NN_Network, self).__init__()
self.linear1 = nn.Linear(in_dim,hid)
self.linear2 = nn.Linear(hid,out_dim)
self.linear1.weight = torch.nn.Parameter(torch.zeros(in_dim,hid))
self.linear1.bias = torch.nn.Parameter(torch.ones(hid))
self.linear2.weight = torch.nn.Parameter(torch.zeros(in_dim,hid))
self.linear2.bias = torch.nn.Parameter(torch.ones(hid))
def forward(self, input_array):
h = self.linear1(input_array)
y_pred = self.linear2(h)
return y_pred
in_d = 5
hidn = 2
out_d = 3
net = NN_Network(in_d, hidn, out_d)
现在,检查与此模型相关的参数列表 -
for param in net.parameters():
print(type(param.data), param.size())
""" Output
<class 'torch.FloatTensor'> torch.Size([5, 2])
<class 'torch.FloatTensor'> torch.Size([2])
<class 'torch.FloatTensor'> torch.Size([5, 2])
<class 'torch.FloatTensor'> torch.Size([2])
"""
或者试试,
list(net.parameters())
这可以很容易地提供给您的优化器 -
opt = Adam(net.parameters(), learning_rate=0.001)
另外,请注意Parameters默认设置了require_grad。
【讨论】:
很好的解释!谢谢~@Astha Sharma 感谢您的精彩解释。关于您提供的代码,我有一个快速的问题。如self.linear2
线性网络有(hid,out_dim)
作为它的输入和输出维度,那么它对应的参数self.linear2.weight
是如何像torch.zeros(in_dim,hid)
那样有维度(in_dim, hid)
的呢?谢谢
如果我可以通过require_grad=False
关闭梯度计算,那么拥有参数有什么意义?
@anurag Parameter
是告诉 Pytorch 某些参数是可学习的正确方法。 require_grad
是告诉 Pyotrch 是否要修改参数的标志。【参考方案2】:
最近的 PyTorch 版本只有张量,但变量的概念已被弃用。
Parameters 只是张量,仅限于定义它们的模块(在模块构造函数__init__
方法中)。
它们将出现在module.parameters()
中。
当您构建通过这些参数梯度下降来学习的自定义模块时,这会很方便。
任何对 PyTorch 张量正确的东西对参数都是正确的,因为它们是张量。
此外,如果一个模块进入 GPU,参数也会进入。如果一个模块被保存,参数也会被保存。
有一个类似于模型参数的概念,称为buffers。
这些在模块中被命名为张量,但这些张量并不是要通过梯度下降来学习,而是你可以认为它们就像变量一样。您将根据需要更新模块 forward() 中的命名缓冲区。
对于buffer来说,也确实会和模块一起去GPU,和模块一起保存。
【讨论】:
Parameter
s 只有有限在__init__()
中使用吗?
否,但最常见的是在 __init__
方法中定义它们。以上是关于torch.nn.Parameter 参数相关的介绍和使用的主要内容,如果未能解决你的问题,请参考以下文章
PyTorch里面的torch.nn.Parameter()
PyTorch中的torch.nn.Parameter() 详解
解决错误AttributeError: module ‘torch.nn.parameter‘ has no attribute ‘UninitializedParameter‘的方法
如何在 Keras 模型中实现一些可训练的参数,例如 Pytorch 中的 nn.Parameters()?
Pytorch中 类Parameter的解析,类内成员函数.parameters()的源码分析,参数集合的获取,参数的注册赋值源码分析