基于PyTorch架构的简易神经网络模型

妖狐艹你老母 2023-06-06 12:24 1阅读 0赞

下面通过三个实例来看看如何使用已经掌握的知识，搭建出一个基于PyTorch架构的简易神经网络模型。

### 一、简易神经网络 ###

1.导入包

import torch
     
    batch_n = 100
    hidden_layer = 100
    input_data = 1000
    output_data = 10

我们先通过import torch 导入必要的包，然后定义4个整型变量，其中：batch\_n是在一个批次中输入数据的数量，值是100，这意味着我们在一个批次中输入100个数据，同时，每个数据包含的数据特征有input\_data个，因为input\_data的值是1000，所以每个数据的特征就是1000个，hidden\_layer用于定义经过隐藏层后保留的数据特征的个数，这里有100个，因为我们的模型只考虑一层隐藏层，所以在代码中仅仅定义了一个隐藏层的参数；output\_data是输出的数据，值是10，我们可以将输出的数据看作一个分类结果值得数量，个数10表示我们最后要得到10个分类结果值。

一个批次的数据从输入到输出的完整过程是：先输入100个具有1000个特征的数据，经过隐藏层后变成100个具有100个特征的数据，再经过输出层后输出100个具有10个分类结果值的数据，在得到输出结果之后计算损失并进行后向传播，这样一次模型的训练就完成了，然后训练这个流程就可以完成指定次数的训练，并达到优化模型参数的目的。

2.初始化权重

x = torch.randn(batch_n,input_data)
    y = torch.randn(batch_n,output_data)
     
    w1 = torch.randn(input_data,hidden_layer)
    w2 = torch.randn(hidden_layer,output_data)

在以上的代码中定义的从输入层到隐藏层，从隐藏层到输出层对应的权重参数，同在之前说到的过程中使用的参数维度是一致的，由于我们现在并没有好的权重参数的初始化方法，尽管这并不是一个好主意，可以看到，在代码中定义的输入层维度为（100,1000），输出层维度为（100,10），同时，从输入层到隐藏层的权重参数维度为（1000,100），从隐藏层到输出层的权重参数维度为（100,10），这里我们可能会好奇权重参数的维度是如何定义下来的，其实，只要我们把整个过程看作矩阵连续的乘法运算，九自然能够明白了，在代码中我们的真实值y也是通过随机的方式生成的，所以一开始在使用损失函数计算损失值时得到的结果会较大。

3. 定义训练次数和学习效率

在定义好输入，输出和权重参数值之后，就可以开始训练模型和优化权重参数了，在此之前，我们还需要明确训练的总次数和学习效率，代码如下：

epoch_n = 20
    learning_rate = 1e-6

由于接下来会使用梯度下降的方法来优化神经网络的参数，所以必须定义后向传播的次数和梯度下降使用的学习效率。在以上代码中使用了epoch\_n定义训练的次数，epoch\_n的值为20，所以我们需要通过循环的方式让程序进行20次训练，来完成对初始化权重参数的优化和调整。在优化的过程中使用的学习效率learning\_rate的值为1e-6，表示0.000001，接下来对模型进行正式训练并对参数进行优化。

4.梯度下降优化神经网络的参数

下面代码通过最外层的一个大循环来保证我们的模型可以进行20次训练，循环内的是神经网络模型具体的前向传播和后向传播代码。参数的优化和更新使用梯度：

for epoch in range(epoch_n):
        h1 = x.mm(w1)  # 100*1000
        h1 = h1.clamp(min=0)
        y_pred = h1.mm(w2)  # 100*10
        # print(y_pred)
     
        loss = (y_pred - y).pow(2).sum()
        print("Epoch:{} , Loss:{:.4f}".format(epoch, loss))
     
        gray_y_pred = 2 * (y_pred - y)
        gray_w2 = h1.t().mm(gray_y_pred)
     
        grad_h = gray_y_pred.clone()
        grad_h = grad_h.mm(w2.t())
        grad_h.clamp_(min=0)
        grad_w1 = x.t().mm(grad_h)
     
        w1 -= learning_rate * grad_w1
        w2 -= learning_rate * gray_w2

以上代码通过最外层的一个大循环来保证我们的模型可以进行20层训练，循环内的是神经网络模型具体的前向传播和后向传播代码，参数的优化和更新使用梯度下降来完成。在这个神经网络的前向传播中，通过两个连续的矩阵乘法计算出预测结果，在计算的过程中还对矩阵乘积的结果使用clamp方法进行裁剪，将小于零的值全部重新赋值于0，这就像加上了一个ReLU激活函数的功能。

前向传播得到的预测结果通过 y\_pred来表示，在得到了预测值后就可以使用预测值和真实值来计算误差值了。我们用loss来表示误差值，对误差值的计算使用了均方误差函数。之后的代码部分就是通过实现后向传播来对权重参数进行优化了，为了计算方便，我们的代码实现使用的是每个节点的链式求导结果，在通过计算之后，就能够得到每个权重参数对应的梯度分别是grad\_w1和grad\_w2。在得到参数的梯度值之后，按照之前定义好的学习速率对w1和w2的权重参数进行更新，在代码中每次训练时，我们都会对loss的值进行打印输出，以方便看到整个优化过程的效果，所以最后会有20个loss值被打印显示。

5.打印结果及分析

Epoch:0 , Loss:55005852.0000
    Epoch:1 , Loss:131827080.0000
    Epoch:2 , Loss:455499616.0000
    Epoch:3 , Loss:633762304.0000
    Epoch:4 , Loss:23963018.0000
    Epoch:5 , Loss:10820027.0000
    Epoch:6 , Loss:6080145.5000
    Epoch:7 , Loss:3903527.5000
    Epoch:8 , Loss:2783492.7500
    Epoch:9 , Loss:2160689.0000
    Epoch:10 , Loss:1788741.0000
    Epoch:11 , Loss:1549332.1250
    Epoch:12 , Loss:1383139.6250
    Epoch:13 , Loss:1259326.3750
    Epoch:14 , Loss:1161324.7500
    Epoch:15 , Loss:1080014.2500
    Epoch:16 , Loss:1010260.2500
    Epoch:17 , Loss:949190.7500
    Epoch:18 , Loss:894736.6875
    Epoch:19 , Loss:845573.3750
     
    Process finished with exit code 0

可以看出，loss值从之前的巨大误差逐渐缩减，这说明我们的模型经过二十次训练和权重参数优化之后，得到的预测的值和真实值之间的差距越来越小了。

### 二、自动梯度 ###

我们在上面基于PyTorch深度学习框架搭建了一个简易神经网络模型，并通过在代码中使用前向传播和后向传播实现了对这个模型的训练和对权重参数的额优化，不过该模型在结构上很简单，而且神经网络的代码也不复杂。我们在实践中搭建的网络模型都是层次更深的神经网络模型，即深度神经网络模型，结构会有所变化，代码也会更复杂。对于深度的神经网络模型的前向传播使用简单的代码就能实现，但是很难实现涉及该模型中后向传播梯度计算部分的代码，其中最苦难的就是对模型计算逻辑的梳理。

在PyTorch中提供了一种非常方便的方法，可以帮助我们实现对模型中后向传播梯度的自动计算，避免了“重复造轮子”，这就是接下来要学习的torch.autograd包，通过torch.autograd包，可以使模型参数自动计算在优化过程中需要用到的梯度值，在很大程度上帮助降低了实现后向传播代码的复杂度。

torch.autograd包的主要功能是完成神经网络后向传播中的链式求导，手动实现链式求导的代码会给我们造成很大的困扰，而torch.autograd包中丰富的类减少了这些不必要的麻烦。

实现自动梯度功能的过程大概分为以下几步：

（1）通过输入的Tensor数据类型的变量在神经网络的前向传播过程中生成一张计算图

（2）根据这个计算图和输出结果准确计算出每个参数需要更新的梯度

（3）通过完成后向传播完成对参数梯度的更新

在实践中完成自动梯度需要用到torch.autograd包中的Variable类对我们定义的Tensor数据类型变量进行封装，在封装后，计算图中的各个节点就是一个variable 对象，这样才能应用自动梯度的功能。autograd package是PyTorch中所有神经网络的核心。先了解一些基本知识，然后开始训练第一个神经网络。autograd package提供了Tensors上所有运算的自动求导功能。它是一个按运行定义（define-by-run）的框架，这意味着反向传播是依据代码运行情况而定义的，并且每一个单次迭代都可能不相同。

autograd.Variable 是这个package的中心类。它打包了一个Tensor，并且支持几乎所有运算。一旦你完成了你的计算，可以调用.backward()，所有梯度就可以自动计算。  
　　你可以使用.data属性来访问原始tensor。相对于变量的梯度值可以被积累到.grad中。  
　　这里还有一个类对于自动梯度的执行是很重要的：Function（函数）  
　　变量和函数是相互关联的，并且建立一个非循环图。每一个变量有一个.grad\_fn属性，它可以引用一个创建了变量的函数（除了那些用户创建的变量——他们的grad\_fn是空的）。  
　　如果想要计算导数，可以调用Variable上的.backward()。如果变量是标量（只有一个元素），你不需要为backward()确定任何参数。但是，如果它有多个元素，你需要确定grad\_output参数（这是一个具有匹配形状的tensor）。

如果已经按照如上的方式完成了相关操作，则在选中了计算图中的某个节点时，这个节点必定是一个Variable对象，用X表示我们选中的节点，那么X.data代表Tensor数据类型 的变量，X.grad也是一个Variable对象，不过他代表的是X的梯度，在想访问梯度值的时候需要X.grad.data

下面通过一个自动梯度的实例来看看如何使用torch.autograd.Variable类和torch.autograd包，我们同样搭建一个二层结构的神经网络模型，这有利于我们之前搭建的简易神经网络模型的训练和优化过程进行对比，重新实现。

1.导入包

import torch
    from torch.autograd import Variable
     
    # 批量输入的数据量
    batch_n = 100
    # 通过隐藏层后输出的特征数
    hidden_layer = 100
    # 输入数据的特征个数
    input_data = 1000
    # 最后输出的分类结果数
    output_data = 10

其中：batch\_n是在一个批次中输入数据的数量，值是100，这意味着我们在一个批次中输入100个数据，同时，每个数据包含的数据特征有input\_data个，因为input\_data的值是1000，所以每个数据的特征就是1000个，hidden\_layer用于定义经过隐藏层后保留的数据特征的个数，这里有100个，因为我们的模型只考虑一层隐藏层，所以在代码中仅仅定义了一个隐藏层的参数；output\_data是输出的数据，值是10，我们可以将输出的数据看作一个分类结果值得数量，个数10表示我们最后要得到10个分类结果值。

2.初始化权重

x = Variable(torch.randn(batch_n , input_data) , requires_grad = False)
    y = Variable(torch.randn(batch_n , output_data) , requires_grad = False)
     
    w1 = Variable(torch.randn(input_data,hidden_layer),requires_grad = True)
    w2 = Variable(torch.randn(hidden_layer,output_data),requires_grad = True)

“Variable(torch.randn(batch\_n, input\_data), requires\_grad = False)”这段代码就是之前讲到的用 Variable类对 Tensor数据类型变量进行封装的操作。在以上代码中还使用了一个requires\_grad参数，这个参数的赋值类型是布尔型，如果requires\_grad的值是False，那么表示该变量在进行自动梯度计算的过程中不会保留梯度值。我们将输入的数据x和输出的数据y的requires\_grad参数均设置为False，这是因为这两个变量并不是我们的模型需要优化的参数，而两个权重w1和w2的requires\_grad参数的值为True

3.定义训练次数和学习效率

在定义好输入，输出和权重参数值之后，就可以开始训练模型和优化权重参数了，在此之前，我们还需要明确训练的总次数和学习效率，代码如下：

epoch_n = 20
    learning_rate = 1e-6

和之前一样，在以上代码中使用了epoch\_n定义训练的次数，epoch\_n的值为20，所以我们需要通过循环的方式让程序进行20次训练，来完成对初始化权重参数的优化和调整。在优化的过程中使用的学习效率learning\_rate的值为1e-6，表示0.000001，接下来对模型进行正式训练并对参数进行优化。

4.新的模型训练和参数优化

for epoch in range(epoch_n):
     
        y_pred = x.mm(w1).clamp(min= 0 ).mm(w2)
        loss = (y_pred - y).pow(2).sum()
        print("Epoch:{} , Loss:{:.4f}".format(epoch, loss.data))
     
        loss.backward()
        w1.data -= learning_rate * w1.grad.data
        w2.data -= learning_rate * w2.grad.data
     
        w1.grad.data.zero_()
        w2.grad.data.zero_()

和之前的代码相比，当前的代码更简洁了，之前代码中的后向传播计算部分变成了新代码中的 loss.backward()，这个函数的功能在于让模型根据计算图自动计算每个节点的梯度值并根据需求进行保留，有了这一步，我们的权重参数 w1.data和 w2.data就可以直接使用在自动梯度过程中求得的梯度值w1.data.grad和w2.data.grad，并结合学习速率来对现有的参数进行更新、优化了。在代码的最后还要将本次计算得到的各个参数节点的梯度值通过grad.data.zero\_()全部置零，如果不置零，则计算的梯度值会被一直累加，这样就会影响到后续的计算。同样，在整个模型的训练和优化过程中，每个循环都加入了打印loss值的操作，所以最后会得到20个loss值的打印输出。

5.打印结果及分析

Epoch:0 , Loss:51193236.0000
    Epoch:1 , Loss:118550784.0000
    Epoch:2 , Loss:451814400.0000
    Epoch:3 , Loss:715576704.0000
    Epoch:4 , Loss:21757992.0000
    Epoch:5 , Loss:11608872.0000
    Epoch:6 , Loss:7414747.5000
    Epoch:7 , Loss:5172238.5000
    Epoch:8 , Loss:3814624.2500
    Epoch:9 , Loss:2930500.2500
    Epoch:10 , Loss:2325424.0000
    Epoch:11 , Loss:1895581.7500
    Epoch:12 , Loss:1581226.2500
    Epoch:13 , Loss:1345434.7500
    Epoch:14 , Loss:1164679.7500
    Epoch:15 , Loss:1023319.6875
    Epoch:16 , Loss:910640.1875
    Epoch:17 , Loss:819365.0625
    Epoch:18 , Loss:743999.4375
    Epoch:19 , Loss:680776.3750
     
    Process finished with exit code 0

可以看出，对参数的优化在顺利进行，因为loss值也越来越低。

### 三、自定义传播函数 ###

其实除了可以采用自动梯度方法，我们还可以通过构建一个继承了torch.nn.Module的新类，来完成对前向传播函数和后向传播函数的重写。在这个新类中，我们使用forward作为前向传播函数的关键字，使用backward作为后向传播函数的关键字。下面介绍如何使用自定义传播函数的方法，来调整之前具备自动梯度功能的简易神经网络模型。整个代码的开始部分如下：

和之前的代码一样，在代码的开始部分同样是导入必要的包、类，并定义需要用到的4 个变量。下面看看新的代码部分是如何定义我们的前向传播 forward 函数和后向传播backward函数的：

class Model(torch.nn.Module):
        def __init__(self):
            super(Model,self).__init__()
         
        def forward(self,input,w1,w2):
            x = torch.mm(input,w1)
            x = torch.clamp(x,min=0)
            x = torch.mm(x,w2)
            return x
         
        def backward(self):
            pass

以上代码展示了一个比较常用的Python类的构造方式：首先通过class Model(torch.nn.Module)完成了类继承的操作，之后分别是类的初始化，以及forward函数和backward函数。forward函数实现了模型的前向传播中的矩阵运算，backward实现了模型的后向传播中的自动梯度计算，后向传播如果没有特别的需求，则在一般情况下不用进行调整。在定义好类之后，我们就可以对其进行调用了，代码如下：

model = Model()

这一系列操作相当于完成了对简易神经网络的搭建，然后就只剩下对模型进行训练和对参数进行优化的部分了，代码如下：

#_*_coding:utf-8_*_
    import torch
    from torch.autograd import Variable
     
    # 批量输入的数据量
    batch_n = 100
    # 通过隐藏层后输出的特征数
    hidden_layer = 100
    # 输入数据的特征个数
    input_data = 1000
    # 最后输出的分类结果数
    output_data = 10
     
    x = Variable(torch.randn(batch_n , input_data) , requires_grad = False)
    y = Variable(torch.randn(batch_n , output_data) , requires_grad = False)
     
    w1 = Variable(torch.randn(input_data,hidden_layer),requires_grad = True)
    w2 = Variable(torch.randn(hidden_layer,output_data),requires_grad = True)
     
    # 训练次数设置为20
    epoch_n = 20
    # 将学习效率设置为0.000001
    learning_rate = 1e-6
     
    for epoch in range(epoch_n):
     
        y_pred = x.mm(w1).clamp(min= 0 ).mm(w2)
        loss = (y_pred - y).pow(2).sum()
        print("Epoch:{} , Loss:{:.4f}".format(epoch, loss.data))
     
        loss.backward()
        w1.data -= learning_rate * w1.grad.data
        w2.data -= learning_rate * w2.grad.data
     
        w1.grad.data.zero_()
        w2.grad.data.zero_()

这里，变量的赋值、训练次数和学习速率的定义，以及模型训练和参数优化使用的代码，和在 6.2.1节中使用的代码没有太大的差异，不同的是，我们的模型通过“y\_pred =model(x, w1, w2)”来完成对模型预测值的输出，并且整个训练部分的代码被简化了。在20次训练后，20个loss值的打印输出如下:

Epoch:0 , Loss:39938204.0000
    Epoch:1 , Loss:49318664.0000
    Epoch:2 , Loss:147433040.0000
    Epoch:3 , Loss:447003584.0000
    Epoch:4 , Loss:418029088.0000
    Epoch:5 , Loss:4521120.5000
    Epoch:6 , Loss:3043527.5000
    Epoch:7 , Loss:2294490.0000
    Epoch:8 , Loss:1862741.6250
    Epoch:9 , Loss:1583754.6250
    Epoch:10 , Loss:1384331.2500
    Epoch:11 , Loss:1230558.5000
    Epoch:12 , Loss:1105670.1250
    Epoch:13 , Loss:1000757.3750
    Epoch:14 , Loss:910758.0625
    Epoch:15 , Loss:832631.0625
    Epoch:16 , Loss:764006.6250
    Epoch:17 , Loss:703198.6875
    Epoch:18 , Loss:649156.8125
    Epoch:19 , Loss:600928.8750
     
    Process finished with exit code 0

本文基于Pytorch运用了三种方法搭建了简单的神经网络，其中后两种分别采用了自由梯度、自定义传播函数的方法，有助于初学者更好的理解神经网络的搭建过程。

参考文章：[https://www.cnblogs.com/wj-1314/p/9830950.html][https_www.cnblogs.com_wj-1314_p_9830950.html]

[https_www.cnblogs.com_wj-1314_p_9830950.html]: https://www.cnblogs.com/wj-1314/p/9830950.html