神经网络（一）：神经网络入门

文章目录

• 一、神经网络
• • 1.1神经元结构
  • 1.2单层神经网络：单层感知机
  • 1.3两层神经网络：多层感知机
  • 1.4多层神经网络
• 二、全连接神经网络
• • 2.1基本结构
  • 2.2激活函数、前向传播、反向传播、损失函数
  • • 2.2.1激活函数的意义
    • 2.2.2前向传播
    • 2.2.3损失函数、反向传播
    • 2.2.4梯度下降法
  • 2.3模型训练流程
  • 2.4全连接神经网络的Pytorch实现

---

一、神经网络

1.1神经元结构

生物神经元结构如下：

• 树突：一个神经元往往有多个树突，用于接收传如的信息。
• 轴突与轴突末梢：一个神经元只有一个轴突，但却有多个轴突末梢用于给其他多个神经元传递信息。轴突末梢跟其他神经元的树突产生连接，从而传递信号。

生物神经元彼此之间相互连接，不断传递信息而构成生物神经网络。

神经元结构则是模仿生物神经元提出的一种数学模型，其包含输入、输出与计算功能。其中，输入可类比神经元树突，树突可类比神经元的轴突末梢，计算则可类比为细胞核。经典的神经元模型如下：

其中包含三个输入 a 1 、 a 2 、 a 3 a_1、a_2、a_3 a1、a2、a3，每个输入分别对应一个权值，分别为 w 1 、 w 2 、 w 3 w_1、w_2、w_3 w1、w2、w3。将输入与权值相乘并求和（加权求和）后，再经过Sgn函数计算即可得到输出Z。而神经网络训练算法的目的在于，让权重的值调整到最佳，使得输出结果Z的值最接近真实值。

一般地，将sum与Sgn函数合并到一个圆圈里，代表神经元的内部计算，便于画出更加复杂的网络结构。并且，一个神经元可引出多个代表输出的有向箭头（具有相同的值），作为下一神经元的输入值并参与运算：

神经元模型的意义可以理解为：我们有一个数据，称之为样本。样本有四个属性，其中三个属性已知，一个属性未知，神经网络需要做的就是通过三个已知属性预测未知属性。具体办法就是使用神经元的公式进行计算。三个已知属性的值是 a 1 、 a 2 、 a 3 a_1、a_2、a_3 a1、a2、a3，未知属性的值是z。并且，已知的属性往往称之为特征，未知的属性往往称之为目标。假设特征与目标之间确实是线性关系，并且我们已经得到表示这个关系的权值 w 1 、 w 2 、 w 3 w_1、w_2、w_3 w1、w2、w3。那么，就可以通过神经元模型预测新样本的目标。

1.2单层神经网络：单层感知机

单层神经网络是由两层神经元（输入层、输出层）组成的神经网络，也被称之为感知机模型。其结构如下：

在感知机中有输入层、输出层两个层次：

• 输入层：只负责传输数据，不做计算。
• 输出层：需要对前面一层的输入进行计算，并将结果输出。

其中， w i , j w_{i,j} wi,j表示前一层第 j j j个神经元输入到后一层第 i i i神经元时，前一层神经元的输出对应的权值。观察 z 1 、 z 2 z_1、z_2 z1、z2公式，实际可看作是一对线性代数方程组，因此可以用矩阵乘法来表示。系数矩阵 w w w是两行三列矩阵：
[ w 1 , 1 w 1 , 2 w 1 , 3 w 2 , 1 w 2 , 2 w 2 , 3 ] (3) \left[ \begin{matrix} w_{1,1} & w_{1,2} & w_{1,3} \\ w_{2,1} & w_{2,2} & w_{2,3} \\ \end{matrix} \right] \tag{3} [w1,1w2,1w1,2w2,2w1,3w2,3](3)

同理，输入的是由 a 1 、 a 2 、 a 3 a_1、a_2、a_3 a1、a2、a3组成的列向量：
[ a 1 a 2 a 3 ] (3) \left[ \begin{matrix} a_1 \\ a_2 \\ a_3 \end{matrix} \right] \tag{3} a1a2a3 (3)

用g()表示输入加权和后经过的激活函数，则有：
z = g ( w ∗ a ) z=g(w*a) z=g(w∗a)

1.3两层神经网络：多层感知机

两层神经网络在单层神经网络的基础上增加了一个中间层（隐藏层），此时，隐藏层和输出层都是计算层。中间层结构如下：

输出层的结果由隐藏层两个神经元的输入经过加权求和、激活函数计算后才可得到，此时即引入了第二个参数矩阵 w ( 2 ) w^{(2)} w(2)：

同样也可使用矩阵运算来概括整个网络的运算流程：
z = g ( 2 ) ( a ( 2 ) ∗ w ( 2 ) ) a 1 ( 2 ) = g 1 ( 1 ) ( a ( 1 ) ∗ w 1 ( 1 ) ) a 2 ( 2 ) = g 2 ( 1 ) ( a ( 1 ) ∗ w 2 ( 1 ) ) z=g^{(2)}(a^{(2)}*w^{(2)})\\ a_1^{(2)}=g^{(1)}_1(a^{(1)}*w^{(1)}_1)\\ a_2^{(2)}=g^{(1)}_2(a^{(1)}*w^{(1)}_2) z=g(2)(a(2)∗w(2))a1(2)=g1(1)(a(1)∗w1(1))a2(2)=g2(1)(a(1)∗w2(1))

需要说明的是，上文对神经网络的结构图的讨论中都没有提到偏置节点（bias unit）。事实上，这些节点是默认存在的，其本质是存储值永远为一个常量的单元。在神经网络的每个层次中，除了输出层以外，都会含有这样一个偏置单元，在引入偏置值后，神经元基本模型变为：

数学表达式：

同样的，将偏置值加入到两层神经网络当中得到：

1.4多层神经网络

在两层神经网络的输出层后面，继续添加层次，使得原来的输出层变成隐藏层，新加的层次成为新的输出层，从而构建多层神经网络。简单的多层神经网络如下：

输出z的推导公式为：
z = g ( 3 ) ( a ( 3 ) ∗ w ( 3 ) ) a ( 3 ) = g ( 2 ) ( a ( 2 ) ∗ w ( 2 ) ) a ( 2 ) = g ( 1 ) ( a ( 1 ) ∗ w ( 1 ) ) z=g^{(3)}(a^{(3)}*w^{(3)})\\ a^{(3)}=g^{(2)}(a^{(2)}*w^{(2)})\\ a^{(2)}=g^{(1)}(a^{(1)}*w^{(1)}) z=g(3)(a(3)∗w(3))a(3)=g(2)(a(2)∗w(2))a(2)=g(1)(a(1)∗w(1))

从图中可以看出，参数矩阵 w ( 1 ) 、 w ( 2 ) 、 w ( 3 ) w^{(1)}、w^{(2)}、w^{(3)} w(1)、w(2)、w(3)分别有6、4、6个参数，即整个神经网络共有16个参数：

假设我们将中间层的节点数做一下调整。第一个中间层改为3个单元，第二个中间层改为4个单元。经过调整以后，整个网络的参数变成了33个：

二、全连接神经网络

2.1基本结构

全连接神经网络是指第 N 层的每个神经元和第 N-1 层的所有神经元相连，即第 N-1 层神经元的输出就是第 N 层神经元的输入。整体结构由三部分组成：

• 输入层：输入的数据，即向量（矩阵）组 x 1 、 x 2 、 x 3 x_1、x_2、x_3 x1、x2、x3，可以是图片、矩阵等。
• 隐藏层：对输入数据进行特征提取，对于不同的输入神经单元设置不同的权重与偏置，从而影响神经单元对输入信息敏感程度，可以形成输出结果的偏向）。
• 输出层：输出的结果，即 y 1 、 y 2 、 y 3 y_1、y_2、y_3 y1、y2、y3，可以是分类结果等。

通过输入层激活信号，再通过隐藏层提取特征，不同隐藏层神经单元对应不同输入层的神经单元，其权重和自身偏置均可能不同。由隐藏层将信号

经计算再传递到输出层，最后由输出层输出信号。例如，识别一个4x3的图像，下例中采用了12 神经元来对应 4x3 个像素点进行输入，在隐藏层中使用另外三个神经单元进行特征提取，最后输出层再使用两个神经节点标记识别结果是 0 或 1（分别表示黑与白）：

• 对于输入层，十二个神经单元对应 4 * 3 像素值（0或1），如果该像素是白的，则对应神经元兴奋（对应1），否则静息（对应0）。
• 对于输出层的两个节点，如果识别结果偏向0，那么第一个节点兴奋度会高于第二个节点，反之识别结果偏向1。
• 对于隐藏层，每一个节点会对输入层的兴奋有不同的接收权重，从而更加偏向于某种识别模式。例如，隐藏层第一个神经单元对应下图模式A，也就是对应输入层 4、7号神经单元接收权重比较高，对其他神经单元接受权重比较低，如果超过了神经单元自身的偏置（阈值）则会引发隐藏层的兴奋，向输出层传递兴奋信息，隐藏层其他神经单元同理。

事实上，神经网络模型的意义就在于找到最为合适的参数w、b，使得预测结果与真实情况最为接近。

2.2激活函数、前向传播、反向传播、损失函数

2.2.1激活函数的意义

由上文可知，每一层的参数运算均可表示为矩阵运算：
a [ 1 ] = w [ 1 ] ∗ x + b [ 1 ] a^{[1]}=w^{[1]}*x+b^{[1]} a[1]=w[1]∗x+b[1]

• a [ 1 ] a^{[1]} a[1]：上一层神经元输出值的与系数矩阵、偏置的加权和，是本层神经元的输出值。
• b [ 1 ] b^{[1]} b[1]`：系数矩阵。
• x x x：上一层神经元的输出值。
• b [ 1 ] b^{[1]} b[1]：偏置。

若直接将 a [ 1 ] a^{[1]} a[1]作为下一隐藏层的输入，并继续只进行线性运算（仅含有加法、数量乘法运算），即 a [ 2 ] = w [ 2 ] ∗ a [ 1 ] + b [ 2 ] a^{[2]}=w^{[2]}*a^{[1]}+b^{[2]} a[2]=w[2]∗a[1]+b[2]，则会出现"无效的隐藏层"。数学推导如下：

可见，此时 a [ 2 ] a^{[2]} a[2] 相当于是一组新参数 w ′ 、 b ′ w^{'}、b^{'} w′、b′与输入向量 x x x运算得到，则原先的 a [ 1 ] a^{[1]} a[1]隐藏层退化，神经网络仍只含有一层隐藏层（多层线性操作等价于一层线性操作，多层神经网络退化为最简单的单层神经网络模型）。

事实上，真实世界有些原始数据本身就是线性不可分的，必须要对原始空间进行一定的非线性操作，此时就必须使用非线性的激活函数参与运算来为神经网络引入非线性性，否则多层神经网络就没有意义。

除此之外，激活函数有助于将神经元输出的值限制在我们要求的某个限制内。 因为激活函数的输入是 W ∗ x + b W * x + b W∗x+b，如果不限制在某个值上，则此值的变动范围会非常大，此时可使用激活函数将输出值限定在一个范围（常用0~1），来表示神经元的兴奋程度（0表静默，1表活跃）。

2.2.2前向传播

前向传播，是指将数据特征作为输入，输入到隐藏层，将数据特征和对应的权重相乘同时再和偏置进行求和，将计算的结果通过激活函数进行激活，激活函数输出值作为下一层神经网络层的输入再和对应的权重相乘同时和对应的偏置求和，再将计算的结果通过激活函数进行激活，不断重复上述的过程直到神经网络的输出层，最终得到神经网络的输出值。

简单来说，输入数据输入到神经网络并通过隐藏层进行运算，最后输出结果的过程，就是神经网络的前向传播。一个简单的神经网络：

隐藏层两个神经元的计算：

输出层神经元的计算：

其中， w 11 、 w 13 、 b 1 、 w 12 、 w 14 、 b 2 、 w 21 、 w 22 、 b 3 w_{11}、w_{13}、b_1、w_{12}、w_{14}、b_2、w_{21}、w_{22}、b_3 w11、w13、b1、w12、w14、b2、w21、w22、b3是模型中所包含的权重和偏置，而训练模型的目的在于，找到一种方法可以求出准确的 w w w和 b b b，使得前向传播计算出来的预测值 y y y无限接近于真实值。

2.2.3损失函数、反向传播

【损失函数】

在模型确定后（本质是确定了一组参数），就希望训练结果接近于真实值，此时可设置损失函数来计算前向传播的输出值和真实的label值之间的损失误差，来对模型性能进行评估。目前常见的损失函数有均方误差、交叉熵误差。对于不同类型的问题，如：

• 回归问题：输出的是物体的值，如预测当前温度等，是对真实值的一种逼近预测，输出值是连续的。
• 分类问题：输出的是物体所属的类别，输出值是离散的。

对于不同类型的问题就有着不同的常用损失函数。

【反向传播】

事实上，模型训练的流程为，将数据输入模型并通过前向传播得到输出数据，利用损失函数计算输出数据与真实数据之间的误差，并利用反向传播更新参数（这一过程需使用梯度）使损失函数变低（神经网络的输出和真实值更加逼近），最后不断重复这一过程，直到损失函数接近于0。

但是实际项目中，由于数据中存在噪声，因此损失值在参数不断的更新下会不断接近0，但是不可能等于0，所以我们往常将模型的训练轮次和损失值变化画图显示出来，如果损失值在一定的轮次后趋于平缓不再下降，那么就认为模型的训练已经收敛了。例如：

2.2.4梯度下降法

梯度下降法是最为常见的反向传播更新参数的算法，具体步骤为：

• 1.计算损失：使用损失函数计算预测值与真实值之间的误差。例如，使用均方误差（MSE）或交叉熵损失。
• 2.误差反向传播：从输出层开始，计算损失相对于每个参数的梯度。通过链式法则，将梯度逐层传递回输入层。
• 3.参数更新：使用优化算法（如梯度下降）更新每个参数，使损失最小化。参数更新公式如下：

其中， W o l d W_{old} Wold是更新前的权重， W n e w W_{new} Wnew是更新后的权重， η η η是学习率， ∂ l ∂ w \frac{\partial l}{\partial w} ∂w∂l是损失函数相对于权重的梯度。

【梯度下降法原理】

梯度下降法正是基于此思想，只是从追求不同方向上最陡的山体梯度，变为追求如何修改参数可使损失函数值下降最快。反之，就是梯度上升法。需要注意的是，梯度下降法只是一种局部搜索优化算法，即它无法保证得到全局最优解。因此，有时需要运用其他优化算法来搜索全局最优解。

1.一元函数 ：模型仅有一个参数

函数 J ( w ) J(w) J(w)即为损失函数，横坐标 w w w表示模型参数，问题转化为如何求出函数极小值处参数 w w w的值。
思路 ：在当前位置求偏导，即梯度，负梯度不断增大接近零的方向（ w w w的变化方向），就是不断逼近函数极小值的方向。有时得到的是函数最小值的局部最优解，如果损失函数是凸函数，梯度下降法得到的解就是全局最优解。

一元函数的梯度（导数）公式：

假设损失函数为 J ( θ ) J(θ) J(θ)，其中 θ θ θ是模型参数，从一个初始点 θ 0 θ_0 θ0开始迭代，每次迭代更新 θ θ θ的值，直至损失函数值下降到一定程度，或者达到固定次数的迭代次数。每次迭代的更新公式：

其中， α α α是学习率，控制每一步迭代的步长。学习率太小会导致收敛速度慢，而学习率太大会导致算法发散。因此，学习率是梯度下降法中需要调整的一个超参数。

注意，超参数是指算法运行之前手动设置的参数，用于控制模型的行为和性能。这些超参数的选择会影响到模型的训练速度、收敛性、容量和泛化能力等方面，常见的超参数如学习率、迭代次数、正则化参数、隐藏层的神经元数量等。

2. 多元函数 ：模型含多个参数

对于不同参数 θ i θ_i θi，其梯度定义为：

其中，函数 J ( θ ) J(θ) J(θ)即为损失函数，此时每次迭代的更新公式为：

直至损失函数值下降到一定程度，或者达到固定次数的迭代次数时，算法终止。

【梯度下降法案例】

初始误差（使用均方误差函数） ： J ( x 1 ) = ( 2 − 1.731 ) 2 / 2 J(x_1)=(2-1.731)^2/2 J(x1)=(2−1.731)2/2

完成一轮更新后，损失函数的值更加逼近0，代表预测结果更加接近真实情况。

2.3模型训练流程

在完成上文的学习后，可大致梳理出模型训练的大致流程：

• 1.以 N N N份的输入数据 X X X及其对应的结果 Y Y Y（同样为 N N N）份来搭建模型，常见模型如卷积神经网络。
• 2.开始训练，并设置模型训练的超参数，如学习率、训练轮次等。
  • 2.1输入数据集 X X X，前向传播得到训练结果 Y ′ Y' Y′。
  • 2.2根据真实结果 Y Y Y计算损失函数 J ( Θ ) J(Θ) J(Θ)，其中，训练结果 Y ′ Y' Y′是关于参数集合 Θ Θ Θ的函数。
  • 2.3利用梯度下降法进行反向传播，更新参数值，并重新进行预测。
  • 2.4重复上述过程直到满足终止条件，从而得到模型。
• 3.利用模型对测试集进行测试，满足条件即可正常使用，否则调整超参数、模型类别等，重新训练模型。

2.4全连接神经网络的Pytorch实现

【1.导入相关包】

#1.导入相关包
import torch
import torch.nn as nn
import copy
import time
from torchsummary import summary
import torch
from torch import nn
from torchvision.datasets import FashionMNIST
from torchvision import transforms
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import math
import torch.utils.data as Data

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

【2.加载FashionMNIST数据集】

#2.加载FashionMNIST数据集
##定义数据预处理操作
transform = transforms.Compose([
    transforms.ToTensor(),  #将PIL图像或NumPy ndarray 转换为FloatTensor，并在[0.,1.]范围内缩放图像的像素值。
    transforms.Normalize((0.5,), (0.5,))  #对张量图像进行标准化,给出的均值(mean)和标准差(std)应用于所有三个通道。这里均值和标准差设置为0.5，意味着[0,1]的输入将被标准化到[-1,1]。对于灰度图（如MNIST），只需要给出一个通道的均值和标准差。
])
##加载训练集、测试集
train_data = FashionMNIST(root="./", train=True, transform=transform, download=True)
test_data = FashionMNIST(root="./", train=False, transform=transform, download=True)
##构建训练集、测试集加载器
train_loader = Data.DataLoader(dataset=train_data, batch_size=64, shuffle=True)
test_loader = Data.DataLoader(dataset=test_data, batch_size=64, shuffle=False)
##可视化训练数据
def show_img(train_loader,batch_size):
    for step, (x, y) in enumerate(train_loader):
        if step > 0:  # 恒成立
            break
    batch_x = x.squeeze().numpy()
    batch_y = y.numpy()
    class_label = train_data.classes
    # 可视化
    fig = plt.figure(figsize=(int(math.sqrt(batch_size)), int(math.sqrt(batch_size))))
    for i in range(batch_size):
        ax = fig.add_subplot(int(math.sqrt(batch_size)), int(math.sqrt(batch_size)), i + 1, xticks=[], yticks=[])
        ax.imshow(batch_x[i], cmap=plt.cm.binary)
        ax.set_title(class_label[batch_y[i]])
show_img(train_loader,64)

【3.建立全连接神经网络模型】

#3.建立全连接神经网络模型
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        #784=28*28
        self.fc1 = nn.Linear(784, 128) 
        self.fc2 = nn.Linear(128, 128)  
        #预测结果为10个类别之一
        self.output = nn.Linear(128, 10) 
    #定义前向传播过程
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.output(x)
        return x
model=SimpleNN().to(device)
print(summary(model,input_size=(784,)))

【4.训练模型】

#4.训练模型
##使用Adam优化器，设置学习率为0.001，model.parameters()将模型中所有需要被训练的参数传入优化器中
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
##使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()
##设置训练轮次
epoch = 100
def train_model(model, train_loader, optimizer, criterion, epoch, device):
    for e in range(epoch):
        start_time=time.time()
        for images, labels in train_loader:
            images = images.to(device)
            labels = labels.to(device)
            images = images.view(-1, 28*28)  
            #梯度清除
            optimizer.zero_grad()
            #前向传播模型预测结果
            output = model(images)
            #计算预测结果与实际值的损失函数值
            loss = criterion(output, labels)
            #反向传播，计算所有模型参数关于损失函数的梯度
            loss.backward()
            #更新参数
            optimizer.step()
        end_time=time.time()
        print("轮次{} 用时 : {}".format(e+1, end_time-start_time))
train_model(model, train_loader, optimizer, criterion, epoch, device)

【5.测试模型】

#5.测试模型
def evaluate_model(model, test_loader, device):
    model.eval()
    total_correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            images = images.view(-1, 28*28).to(device)
            output = model(images)
            _, predicted = torch.max(output.data, 1)
            total += labels.size(0)
            total_correct += (predicted == labels.to(device)).sum().item()
    print(f'Accuracy: {100 * total_correct / total:.2f}%')
evaluate_model(model, test_loader, device)

【6.查看模型结构】

#6.查看模型结构
torch.save(model,'./SimpleNN.pth')
import netron

modelData = './SimpleNN.pth'  # 定义模型数据保存的路径
netron.start(modelData)  # 输出网络结构