一.参数访问
我们以多层感知机为例
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())结果：
就是把参数名称和参数的值都列出来了
1.1提取参数
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)
bias代表偏置
想只提取数值就用.data
net.state_dict()['2.bias'].data
也可以指定名字来去提取参数
1.2一次性提取全部参数
print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])
我们发现这个提取的时候也可以指定第几层
上面的是无*的，下面是有*的
解包操作：解包（unpacking）是指将一个可迭代对象（如列表、元组、字典等）中的元素赋值给多个变量的过程
* 迭代器解包操作，也称之为序列拆分操作符
** 字典解包操作，也称之为映射拆分操作。作为关键字参数传递给函数。
使用 *和 ** 的解包的好处是能节省代码量，使得代码看起来更优雅
在字典中*
只会返回key
**会返回value
1.3嵌套快提取参数
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)
第一大块就是block2（），我们访问第一大快第一小块第一层的偏置值
二.参数初始化
2.1内置初始化
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]就像我们之前学的normal一样
可以体会一下
然后是指定参数
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]此时weight就为1了
当然我们也可以不同的神经层应用不同的初始化
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)第一层用的xavier初始化，第三层用的指定w
2.2自定义初始化
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)#均匀分布-10到10之间
m.weight.data *= m.weight.data.abs() >= 5#把绝对值小于5的都归零
net.apply(my_init)
net[0].weight[:2]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])由于模型参数包含梯度，因此在反向传播期间第二个隐藏层 （即第三个神经网络层）和第三个隐藏层（即第五个神经网络层）的梯度会加在一起。
主要包括
自定义层，读写文件和GPU
三.自定义层
不含参数
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]))
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())
Y = net(torch.rand(4, 8))
Y.mean()含参数
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
linear(torch.rand(2, 5))
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))含参数的在init初始化的时候用Parameter
在PyTorch中，nn.Parameter 是一个特殊的类，用于封装Tensor，以便将其注册为模块（Module）的参数。当一个Tensor被封装为 nn.Parameter 后，它会自动被添加到模块的参数列表中（即，模块的 .parameters() 方法会返回这个Tensor），这样PyTorch的自动求导系统（Autograd）和优化器（Optimizer）就可以跟踪并更新这个Tensor的值了
四.读写文件
为什么要保存？
我们希望保存训练的模型， 以备将来在各种环境中使用（比如在部署中进行预测）。 此外，当运行一个耗时较长的训练过程时， 最佳的做法是定期保存中间结果， 以确保在服务器电源被不小心断掉时，我们不会损失几天的计算结果。 因此，现在是时候学习如何加载和存储权重向量和整个模型了
加载和保存张量
用到的主要函数
torch.save 是 PyTorch 中的一个函数，用于保存模型或张量（Tensor）到磁盘上。这个函数非常灵活，可以保存几乎任何 Python 对象，但最常用于保存 PyTorch 的模型、张量、字典等。保存的对象可以随后通过 torch.load 函数加载回来
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单个元素，列表和字典都可以用sava读取到磁盘中，load再回到内存中
加载和保存模型参数
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)
torch.save(net.state_dict(), 'mlp.params')
clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval()
Y_clone = clone(X)
Y_clone == Y我们会发现用state_dict来展示全部信息
torch.load只是把数据加载了，而load_state_dict是按照字典的模式去读取到模型里
五.GPU
GPU存储张量
X = torch.ones(2, 3, device=try_gpu())
然后就是在第二个gpu上进行创建张量
Y = torch.rand(2, 3, device=try_gpu(1))
这个时候x与y不在同一个GPU里面
所以实现x+y时先复制到同一个gpu里面
Z = X.cuda(1)
然后再Z+Y
net = nn.Sequential(nn.Linear(3, 1))
net = net.to(device=try_gpu())
net[0].weight.data.device上面的代码就是指定参数存放在gpu里面
标签：weight,nn,torch,学习,init,计算,深度,net,data From： https://blog.csdn.net/Q268191051011/article/details/140747527