济南经三路专业做网站北京网站seo设计
Pytorch 神经网络基础
1.模型构造
1》层和块
块可以描述单个层，由多个层组成的组件或者模型本身
块由类表示，类的任何子类都必须定义一个将其输入转换为输出的前向传播函数。为了计算梯度，块必须具有反向传播函数
自定义块：
顺序块：
import torch
from torch import nn#输入
X=torch.rand(2,20)#顺序块
class MySequential(nn.Module):def __init__(self,*args):#*args是收集参数，相当于把若干个参数打包成一个来传入super().__init__()#调用父类的__init__函数for idx, block in enumerate(args):#遍历传入的神经网络层，并将它们以字符串索引作为键存储在 MySequential 实例的 _modules 属性中self._modules[str(idx)] = block#在模型参数初始化过程中，系统直到在_modules字典中查找需要初始化参数的子块def forward(self,X):for block in self._modules.values():#遍历 _modules 中的每个神经网络层X = block(X)#将当前层的输出作为下一层输入return Xnet=MySequential(nn.Linear(20,256),nn.ReLU(),nn.Linear(256,10))
a=net(X)print(a)在前向传播函数中执行代码
当sequential函数过于简单没法满足需求，可以在init和forward函数里进行自定义运算，继承nn.Module比继承Sequential更灵活的定义参数，和进行前向运算
import torch
from torch import nn
from torch.nn import functional as FX=torch.rand(2,20)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)X = F.relu(torch.mm(X,self.rand_weight)+1)#将输入X与权重相乘X = self.linear(X)while X.abs().sum()>1:#取绝对值之和X /= 2#使用 while 循环，如果输出张量的绝对值之和大于 1，则将输出张量除以 2，直到满足条件为止。这个操作可以视为一种归一化或缩放操作，以控制输出的数值范围return X.sum()net = FixedHiddenMLP()
a = net(X)
print(a)嵌套使用Module 的子类
嵌套体现在两个方面:
NestMLP类内部的self.net和self.linear形成了一个嵌套的子模块结构。
chimera 模块通过组合 NestMLP、线性层和 FixedHiddenMLP,形成了一个嵌套的计算流程。
import torch
from torch import nn
from torch.nn import functional as FX=torch.rand(2,20)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)X = F.relu(torch.mm(X,self.rand_weight)+1)#将输入X与权重相乘X = self.linear(X)while X.abs().sum()>1:#取绝对值之和X /= 2#使用 while 循环，如果输出张量的绝对值之和大于 1，则将输出张量除以 2，直到满足条件为止。这个操作可以视为一种归一化或缩放操作，以控制输出的数值范围return X.sum()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())
chimera(X)2.参数管理
参数访问：
import torch
from torch import nn
from torch.nn import functional as Fnet = 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())#检查第二个全连接层即Linear（8,1）的参数
#OrderedDict([('weight', tensor([[ 0.2360, 0.1646, 0.0861, 0.0126, -0.0548, 0.1074, 0.0612, -0.1232]])), ('bias', tensor([-0.1082]))])访问目标参数
print(type(net[2].bias))#访问第二个全连接层的偏移的类型
print(net[2].bias)#访问第二个全连接层的偏移
print(net[2].bias.data)#访问第二个全连接层的偏移的数值
'''<class 'torch.nn.parameter.Parameter'>
Parameter containing:
tensor([0.3516], requires_grad=True)
tensor([0.3516])'''print(net[2].weight.grad == None)#访问参数梯度，由于还没有开始反向传播，因此参数的梯度处于初始状态
#True一次性访问所有参数
print(*[(name,param.shape)for name, param in net[0].named_parameters()])
#('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
print(*[(name,param.shape)for name, param in net.named_parameters()])
#('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))从嵌套块收集参数
import torch
from torch import nn
from torch.nn import functional as FX=torch.rand(2,4)def block1():return nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,4),nn.ReLU())def block2():net = nn.Sequential()#创建一个空的 nn.Sequential 容器,用于按顺序组合多个 block1 模块for i in range(4):#嵌套net.add_module(f'block{i}',block1())#将四个block1()组合起来，用add_module的好处是可以传一个字符串的名字return(net)rgnet = nn.Sequential(block2(),nn.Linear(4,1))
output = rgnet(X)
print(output)
print(rgnet)显示嵌套结构
Sequential((0): Sequential((block0): 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())(block1): 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())(block2): 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())(block3): 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)
)按照以上结构，可以分层访问特定参数
print(rgnet[0][1][0].bias.data)#表示第二个 block1 模块中的第一个子模块,即第一个线性层的偏置参数
#tensor([-0.1861, -0.0683, 0.3388, -0.4251, -0.3339, 0.2232, -0.1247, 0.0476])参数初始化：
内置初始化
def init_normal(m):if type(m) == nn.Linear:#检查传入的模块 m 的类型是否为全连接层nn.init.normal_(m.weight,mean=0,std=0.01)#权重参数初始化为均值为0,标准差为0.01的正态分布#或者初始化为1#nn.init.constant_(m.weight,1)nn.init.zeros_(m.bias)#偏置参数初始化为0net.apply(init_normal)#递归地遍历 net 的每个子模块,对于每个子模块,调用 init_normal 函数。
同样可以对不同的神经网络层使用不同的初始化方法：
net[0].apply()
net[2].apply()
自定义初始化
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 的元素设置为 0
net.apply(my_init)#将 my_init 函数应用于网络 net 的每个子模块
net[0].weight[:2]#[:2] 表示对权重参数进行切片操作,选取前两行可以直接设置参数
net[0].weight.data[:]+=1
net[0].weight.data[0,0] = 42
net[0].weight.data[0]参数绑定：
多个层间共享参数
shared = nn.Linear(8,8)
net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),shared,nn.ReLU(),shared,nn.ReLU(),nn.Linear())
#第二个层和第四个层是相同的3.自定义层
和自定义块相似，只需要继承层类并实现前向传播功能
不带参数的层：
import torch
from torch import nn
from torch.nn import functional as FX=torch.FloatTensor([1,2,3,4,5])
class CenteredLayer(nn.Module):def __init__(self):super().__init__()def forward(self,X):return X-X.mean()#输入减均值，将均值变为0layer = CenteredLayer()
a=layer(X)
print(a)
#tensor([-2., -1., 0., 1., 2.])#将自定义层作为组件合并到网络中
net = nn.Sequential(nn.Linear(8,128),CenteredLayer())带参数的层：
class MyLinear(nn.Module):def __init__(self,in_units,units):#in_units是输入，units是输出super().__init__()self.weight = nn.Parameter(torch.randn(in_units,units))# torch.randn 函数生成一个服从标准正态分布的随机张量,形状为(in_units, units)self.bias = nn.Parameter(torch.randn(units,))#生成一个服从标准正态分布的随机向量，形状为(units,)def forward(self,X):linear = torch.matmul(X,self.weight.data)+self.bias.data#使用 torch.matmul对输入 X 和权重参数 self.weight.data 进行矩阵乘法运算#.data 属性访问权重参数的原始数据return F.relu(linear)#将线性输出传递给 ReLU 激活函数 F.reludense = MyLinear(5,3)
print(dense.weight)
'''tensor([[ 0.1203, 1.2635, -0.7978],[-1.4768, 1.0113, -0.8263],[-0.1474, 0.9414, -1.6847],[-1.4617, 0.7734, -1.3046],[-0.7199, -0.7151, 0.8831]], requires_grad=True)'''4.读写文件
加载和保存张量：
对于单个张量，直接调用load和save函数分别读写
x=torch.arange(4)
torch.save(x,'x-file')
torch.load('x-file')
可以存储一个张量列表，把它们读回内存
x=torch.arange(4)
y= torch.zeros(4)
torch.save([x,y],'x-files')
x2,y2=torch.load('x-files')
print(x2,y2)#tensor([0, 1, 2, 3]) tensor([0., 0., 0., 0.])将x，y存入字典，写入读取
x=torch.arange(4)
y= torch.zeros(4)
mydict={'x':x,'y':y}torch.save(mydict,'mydict')
mydict2=torch.load('mydict')
print(mydict2)
#{'x': tensor([0, 1, 2, 3]), 'y': tensor([0., 0., 0., 0.])}加载和保存模型参数：
torch.save(net.state_dict(),'mil.params')
#为了恢复模型，先实例化原始模型，直接读取文件中存储的模型参数
clone=MLP()
clone.load_state_dict(torch.load('mlp.params'))
#开启评估模式clone.eval()