李沐之神经网络基础

发布时间：2024年01月10日

1.模型构造

1.1层和块

1.2自定义块

1.模型构造

1.1层和块

import torch
from torch import nn
from torch.nn import functional as F
#定义了一些没有包括参数的函数

net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
#构造的单层神经网络，线性层,激活层，线性层

X = torch.rand(2, 20)
#生成一个随机的input,torch.rand是用于生成均匀随机分布张量的函数，从区间[0,1)的均匀分布中
#随机抽取一个随机数生成一个张量，其中2是批量大小，20是输入的维度。
net(X)

"""输出结果：
tensor([[ 0.0343,  0.0264,  0.2505, -0.0243,  0.0945,  0.0012, -0.0141,  0.0666,
         -0.0547, -0.0667],
        [ 0.0772, -0.0274,  0.2638, -0.0191,  0.0394, -0.0324,  0.0102,  0.0707,
         -0.1481, -0.1031]], grad_fn=<AddmmBackward0>)"""

1.2自定义块

#任何一个层和任何一个神经网络应该都是muodule的一个子类
class MLP(nn.Module):
#定义了一个MLP类继承nn.Module:
    def __init__(self):
    # 调用MLP的父类Module的构造函数来执行必要的初始化。
    # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
    #在init函数里面定义了需要的函数和参数，在运行类对象的时候可以自动传递参数给属性，
    #和运行方法
        super().__init__(self):
        #调用父类nn.Module成员方法，把所需要的内部参数给全部设好
        self.hidden=nn.Linear(20,256)
        self.out=nn.Linear(256,10)
        #定义两个全连接层
    #__init__函数包括了网络里面需要的全部的层


    # 定义模型的前向传播，即如何根据输入X返回所需的模型输出
    def forward(self,x):
        return self.out(F.relu(self.hidden()))
        #F里面实现了很多的常用的和函数，注意，这里我们使用ReLU的函数版本，
        #其在nn.functional模块中定义。

#实例化多层感知机的层，然后在每次调用前向传播函数时调用这些层。注意一些关键细节： 首先，
#我们定制的__init__函数通过super().__init__() 调用父类的__init__函数， 省去了重复编写
#模版代码的痛苦。 然后，我们实例化两个全连接层， 分别为self.hidden和self.out。 注意，
#除非我们实现一个新的运算符， 否则我们不必担心反向传播函数或参数初始化， 系统将自动生成这些。 

net=MLP()
net(X)
#这里可以直接调用net(x)而不是net.forward(x)的原因是nn.Module() 中包含了 __call__ 函数
"""输出结果：
tensor([[ 0.0669,  0.2202, -0.0912, -0.0064,  0.1474, -0.0577, -0.3006,  0.1256,
         -0.0280,  0.4040],
        [ 0.0545,  0.2591, -0.0297,  0.1141,  0.1887,  0.0094, -0.2686,  0.0732,
         -0.0135,  0.3865]], grad_fn=<AddmmBackward0>)"""

块的一个主要优点是它的多功能性。我们可以子类化块以创建层（如全连接层的类）、整个模型（如上面的MLP类）或具有中等复杂度的各种组件。我们在接下来的章节中充分利用了这种多功能性，比如在处理卷积神经网络时。

1.3顺序块

class MySequential(nn.Module)：
    def __init__(self,*args):
    #*表示接受不定长参数传递
        super().__init__()
        for idx,module in enumerate(args):
        #这里，module是Module子类的一个实例。我们把它保存在'Module'类的成员，
        #变量_modules中。_module的类型是OrderedDict

        #enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引
        #序列，同时列出数据和数据下标(把序号和内容打包在一起)，一般用在 for 循环当中。
        #idx是序号，module是内容（也就是层）
        self._modules[str(idx)]=module
        #enumerate返回的是一个枚举对象，把索引转换成字符串使之可以被顺序访问
        #写入字典中

    def forward(self,X):
        # OrderedDict保证了按照成员添加的顺序遍历它们
        for block in self._modiles.values():
            X=block(X)
        return X

net=MySequential(nn.Linear(20,256),nn.ReLU(),nn.Linear(256,10))
net(X)
"""结果输出：
tensor([[ 2.2759e-01, -4.7003e-02,  4.2846e-01, -1.2546e-01,  1.5296e-01,
          1.8972e-01,  9.7048e-02,  4.5479e-04, -3.7986e-02,  6.4842e-02],
        [ 2.7825e-01, -9.7517e-02,  4.8541e-01, -2.4519e-01, -8.4580e-02,
          2.8538e-01,  3.6861e-02,  2.9411e-02, -1.0612e-01,  1.2620e-01]],
       grad_fn=<AddmmBackward0>)
"""

???? __init__函数将每个模块逐个添加到有序字典_modules中。_modules的主要优点是：在模块的参数初始化过程中，系统知道在_modules字典中查找需要初始化参数的子块。当MySequential的前向传播函数被调用时，每个添加的块都按照它们被添加的顺序执行。现在可以使用我们的MySequential类重新实现多层感知机。

1.4在前向传播函数中执行代码

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不计算梯度的随机权重参数。因此其在训练期间保持不变
        self.rand_weight=torch.rand((20,20),requires_grad=False)
        #形状是20*20
        self.linear=nn.Linear(20,20)
        #nn.Linear其中第一个维度是batch_size，第二个维度是输入特征的数量。输出是
        #一个二维张量，其中第一个维度是batch_size，第二个维度是输出特征的数量。

        def forward(self,X):
            X=self.linear(X)
            #使用创建的常量参数以及relu和mm函数
            X=F.relu(torch.mm(X,self.rand_weight)+1)
            # 复用全连接层。这相当于两个全连接层共享参数
            X=self.linear(X)
            # 控制流
            while X.abs().sum()>1:
            #当绝对值求和大于1（l1范数）就一直除以2
                X/=2
            return X.sum
            #返回的是标量

net = FixedHiddenMLP()
net(X)
"""结果输出：
tensor(-0.2160, grad_fn=<SumBackward0>)"""


#混合搭配各种组合块的方法
class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net=nn.Sequential(nn.Linear(20,64),nn.ReLU(),nn.Linear(),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)
"""结果输出：
tensor(0.2183, grad_fn=<SumBackward0>)
"""

2.参数管理

2.1参数访问

#首先关注具有单隐藏层的多层感知机
import torch
from torch import nn

net=nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))
#nn.Linear(4,8)表示输入为4，输出为8
X=torch.rand(size=(2,4))
#X的形状是（2*4），表示有2个样本

net(X)
"""结果输出：
tensor([[-0.0619],
        [-0.0489]], grad_fn=<AddmmBackward0>)"""


"""参数访问"""
print(net[2].state_dict())
#net[2]拿到的是最后一个线性层，权重是一个状态state，因为权重可以被改变
"""结果输出：
OrderedDict([('weight', tensor([[-0.0427, -0.2939, -0.1894,  0.0220, -0.1709, -0.1522, -0.0334, -0.2263]])),
 ('bias', tensor([0.0887]))])
"""
#8个权重，1个偏置.输出的结果告诉我们一些重要的事情： 首先，这个全连接层包含两个参数，
#分别是该层的权重和偏置。 两者都存储为单精度浮点数（float32）。 注意，参数名称允许唯
#一标识每个参数，即使在包含数百个层的网络中也是如此。

"""目标参数"""
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)
"""结果输出：
<class 'torch.nn.parameter.Parameter'>
Parameter containing:
tensor([-0.0291], requires_grad=True)
tensor([-0.0291])"""
#参数是复合的对象，包含值、梯度和额外信息。 这就是我们需要显式参数值的原因。 除了值之外，
#我们还可以访问每个参数的梯度。

net[2].weight.grad==None
"""结果输出：
True"""
#在上面这个网络中，由于我们还没有调用反向传播(没有计算loss，W，B没有更新，所以没有反向计算)，
#所以参数的梯度处于初始状态。

"""一次性访问所有参数"""
#当我们需要对所有参数执行操作时，逐个访问它们可能会很麻烦。 当我们处理更复杂的块
#（例如，嵌套块）时，情况可能会变得特别复杂， 因为我们需要递归整个树来提取每个子块的参数。 
#下面，我们将通过演示来比较访问第一个全连接层的参数和访问所有层。
print(*[(name,param.shape) for name,param in net[0].named_parameters()])
print(*[(name,param.shape) for name,param in net.named_parameters()])
"""结果输出：
('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8]))
 '2.bias', torch.Size([1]))"""
#理解一下为什么是[8,4]因为这是权重X要和权重进行矩阵乘法，而

#另一种访问网络参数的方式
net.state_dict()['2.bias'].data
"""结果输出：
tensor([-0.0291])"""

"""从嵌套块收集参数"""
def block1():
    return nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(),nn.ReLU())

def block2():
    net=nn.Sequential()
    for i in range(4):
        #在这里嵌套
        net.add_module(f'block{i}',block1())
        #这里add和sequential的区别就是add可以传入一个字符串表示层数，功能是一样的
        #所以block2会嵌套4个block1
    return net

rgnet=nn.Sequential(block2(),nn.Linear(4,1))
rgnet(X)
"""结果输出：
tensor([[-0.3078],
        [-0.3078]], grad_fn=<AddmmBackward0>)"""
#2*1是因为X是行数为2的矩阵，也就是有2个样本，而1是因为定义的最后linear层的输出特征为1。

print(rgnet)
"""结果输出：
Sequential(
  (0): Sequential(
    (block 0): 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()
    )
    (block 1): 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()
    )
    (block 2): 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()
    )
    (block 3): 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)
)"""


rgnet[0][1][0].bias.data
"""结果输出：
tensor([-0.2539,  0.4913,  0.3029, -0.4799,  0.2022,  0.3146,  0.0601,  0.3757])"""

首先关注具有单隐藏层的多层感知机：

2.2参数初始化

"""内置初始化"""
#首先调用内置的初始化器。 下面的代码将所有权重参数初始化为标准差为0.01的高斯随机变量， 
#且将偏置参数设置为0。
def init_normal(m)
    #m就是一个module
    if type(m)==nn.Linear:
    #如果是全连接层，也就是线性层
        nn.init.normal_(m.weight,mean=0,std=0.01)
        #均值维0，标准差0.01的初始化，下划线接在后面表示是一个替换函数，不是会返回一个值，
        #而是直接把weight给替换掉
        nn.init.zeros_(m.bias)

net.apply(init_normal)
#apply就是调用net里面的所有module，挨个传入初始化模组,就是遍历一遍
net[0].weight.data[0],net[0].bias.data[0]
"""结果输出：
(tensor([-0.0128, -0.0141,  0.0062,  0.0028]), tensor(0.))"""

#将所有参数初始化为给定的常数，比如初始化为1。
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]
"""结果输出：
(tensor([1., 1., 1., 1.]), tensor(0.))"""


"""对某些块应用不同的初始化方法"""
#使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42。
def init_xavier(m):
    if type(m)==nn.Linear:
        nn.init.xavier_uniform_(m.weight)
        #为了数值稳定使每层的方差都相同，nn.init.xavier_uniform_采取的是均匀分布而不是正态分布

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)
"""结果输出：
tensor([ 0.5236,  0.0516, -0.3236,  0.3794])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])
"""


"""自定义初始化"""
#使用以下的分布为任意权重参数𝑤定义初始化方法：
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)
        #张量将具有从 U ( ? a , a )采样的值中生成值
        m.weight.data*=m.weight.data.abs()>=5
        #=m.weight.data的绝对值是不是大于等于5，如果是的话就保留，不是的话就重置为0

net.apply(my_init)
net[0].weight[:2]
"""结果输出：
Init weight torch.Size([8, 4])
Init weight torch.Size([1, 8])

tensor([[5.4079, 9.3334, 5.0616, 8.3095],
        [0.0000, 7.2788, -0.0000, -0.0000]], grad_fn=<SliceBackward0>)
"""

#我们始终可以直接设置参数
net[0].weight.data[:]+=1
net[0].weight.data[0,0]=42
net[0].weight.data[0]
"""结果输出：
tensor([42.0000, 10.3334,  6.0616,  9.3095])"""


"""参数绑定"""
#我们希望在多个层间共享参数：我们可以定义一个稠密层，然后使用它的参数来设置另一个层的参数。
# 我们需要给共享层一个名称，以便可以引用它的参数
shared=nn.Linear(8,8)
net=nn.Sequential(nn.Linear(4,8),nn.ReLU(),shared,nn.ReLU(),shared,nn.ReLU(),nn.Linear(8,1))
#理论上第2，3层都是一样的

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])
"""结果输出：
[ True  True  True  True  True  True  True  True]
[ True  True  True  True  True  True  True  True]
"""
#这个例子表明第二层和第三层的参数是绑定的。 它们不仅值相等，而且由相同的张量表示。 
#因此，如果我们改变其中一个参数，另一个参数也会改变。 这里有一个问题：当参数绑定时，
#梯度会发生什么情况？ 答案是由于模型参数包含梯度， 因此在反向传播期间第二个隐藏层和
#第三个隐藏层的梯度会加在一起。

3.自定义层

3.1不带参数的层

#构造一个没有任何参数的自定义层
import torch
import tprch.nn.functional as F
from torch import nn

#下面的CenteredLayer类要从其输入中减去均值。 要构建它，我们只需继承基础层类并实现前向传播功能。
class CenteredLayer(nn.module):
    def __init__(self):
        super().__init__()

    def forward(self,X):
        return X-X.mean()

#向该层提供一些数据，验证它是否能按预期工作。
layer=CentetedLayer()
layer(torch.FloatTensor([1,2,3,4,5]))
"""结果输出：
tensor([-2., -1.,  0.,  1.,  2.])
"""
#由此可见每个数都减去了均值，因此整个向量的大小应该接近0

#将层作为组件合并到更复杂的模型中。
net=nn.Sequential(nn.Linear(8,128),CenteredLayer())
#作为额外的健全性检查，我们可以在向该网络发送随机数据后，检查均值是否为0。 由于我们处理的
#是浮点数，因为存储精度的原因，我们仍然可能会看到一个非常小的非零数。
Y=net(torch.rand(4,8))
Y.mean()
"""结果输出：
tensor(7.4506e-09, grad_fn=<MeanBackward0>)
"""

3.2带参数的层

#实现自定义版本的全连接层。 回想一下，该层需要两个参数，一个用于表示权重，另一个用于表示
#偏置项。 在此实现中，我们使用修正线性单元作为激活函数。 该层需要输入参数：in_units和units，
#分别表示输入数和输出数。
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)

#实例化MyLinear类并访问其模型参数。
linear=MyLinear(5,3)
linear.weight
"""结果输出：
Parameter containing:
tensor([[ 0.1775, -1.4539,  0.3972],
        [-0.1339,  0.5273,  1.3041],
        [-0.3327, -0.2337, -0.6334],
        [ 1.2076, -0.3937,  0.6851],
        [-0.4716,  0.0894, -0.9195]], requires_grad=True)"""


#使用自定义层直接执行前向传播计算。
linear(torch.rand(2,5))
"""结果输出：
tensor([[0., 0., 0.],
        [0., 0., 0.]])"""

#使用自定义层构建模型，就像使用内置的全连接层一样使用自定义层。
net=nn.Sequential(MyLinear(64,8),MyLinear(8,1))
net(torch.rand(2,64))
"""结果输出：
tensor([[0.],
        [0.]])
"""

4.读写文件

4.1加载和保存张量

import torch 
from torch import nn
from torch.nn import functional as F

#对于单个张量，我们可以直接调用load和save函数分别读写它们。 这两个函数都要求我们提供
#一个名称，save要求将要保存的变量作为输入。
x=torch.arange(4)
torch.save(x,'x-file')

x2=torch.load("x-file")
x2
"""结果输出：
tensor([0, 1, 2, 3])"""


#可以存储一个张量列表，然后把它们读回内存。
y=torch.zeros(4)
torch.save([x,y],'x-files')
x2,y2=torch.load('x-files')
(x2,y2)
"""结果输出：
(tensor([0, 1, 2, 3]), tensor([0., 0., 0., 0.]))"""

#甚至可以写入或读取从字符串映射到张量的字典。 当我们要读取或写入模型中的所有权重时，这很方便。
mydict={'x':x,'y':y}
torch.save(mydict,'mydict')
mydict2=torch.load('mydict')
mydict2
"""结果输出：
{'x': tensor([0, 1, 2, 3]), 'y': tensor([0., 0., 0., 0.])}"""

4.2加载和保存模型参数


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)

#将模型的参数存储在一个叫做“mlp.params”的文件中
torch.save(net.state_dict(),'mlp.params')

#为了恢复模型，我们实例化了原始多层感知机模型的一个备份。 这里我们不需要随机初始化
#模型参数，而是直接读取文件中存储的参数。
clone=MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval()
# train模式（net.train())和eval模式（net.eval())。一般的神经网络中，这两种模式是一样的，只有当模型中存在dropout和batchnorm的时候才有区别。
"""结果输出：
MLP(
  (hidden): Linear(in_features=20, out_features=256, bias=True)
  (output): Linear(in_features=256, out_features=10, bias=True)
)"""


#由于两个实例具有相同的模型参数，在输入相同的X时， 两个实例的计算结果应该相同。
Y_clone=clone(X)
Y_clone==Y
"""结果输出：tensor([[True, True, True, True, True, True, True, True, True, True],
        [True, True, True, True, True, True, True, True, True, True]])
"""

总结：

save和load函数可用于张量对象的文件读写。
我们可以通过参数字典保存和加载网络的全部参数。
保存架构必须在代码中完成，而不是在参数中完成。

参考：

https://www.cnblogs.com/jack-nie-23/p/16506630.html

python中枚举类的理解_python枚举类-CSDN博客

pytorch学习笔记：nn.Module类方法中部分方法详解_class net(nn.module)-CSDN博客

一、nn.Module() 【PyTorch读懂源码】 - 知乎
 【torch.nn.init】初始化参数方法解读_nn.init.uniform_-CSDN博客

torch 中 nn.init.xavier_uniform_ 方法-CSDN博客

https://www.cnblogs.com/lusiqi/p/17177639.html
nn.Parameter()-CSDN博客

[Pytorch系列-30]：神经网络基础 - torch.nn库五大基本功能：nn.Parameter、nn.Linear、nn.functioinal、nn.Module、nn.Sequentia-CSDN博客

文章来源:https://blog.csdn.net/m0_51133942/article/details/135442125
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！