AI入门：神经网络实战----全连接神经网络

我就是我 2022-12-28 14:05 263阅读 0赞

MNIST数据集介绍  
MNIST数据集是0~9等十个数字的手写数字数据集，它有50000张训练图片，10000张测试图片。每一张图片都是28 \* 28像素的灰度图。这些图片都被预处理成一维的数组: 28 \* 28 = 784，每一个像素都是0~255之间的一个整数表示，每张图片都有对应的数字。这些图片和对应的数字分别被称之为x和label。这种有x和label一一对应关系的数据集称之为one-hot。  
编写针对MNIST数据集的神经网络相当于编写C、Python等语言中的Hello World程序，是基础的基础，所以我们要好好掌握它。  
数据集的读取  
MNIST数据集是程序化的内容，大家的写法基本都一样，没有什么需要理解和记忆的。需要注意的是在读取的时候已经进行数据的归一化处理了，这个归一化处理很重要。  
这里得到的train\_loader和test\_loader是生成器，它们把数据读取出来之后，经过一些预处理，然后保存在变量中，每次问它们要，生成器就会给出一批数据，直到所有数据都被读取完。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70]  
简单的神经网络的构建1：全连接神经网络  
本节使用两种方式构建神经网络，这里采用用户手动控制w和b参数的方式。  
在之前我们提起过：上一层网络中的神经元的数据是通过一个简单的一元一次方程处理之后，再经过激活函数，然后就传给下一层神经网络的神经元。使用的一元一次方程就是：y = x \* w + b。  
当然，这只是对于一个神经元的处理。事实上，我们的网络层中往往含有很多个神经元。这时，我们就需要使用二维的张量。  
对于MNIST数据集的输入，每张图片都是28 \* 28 = 784维度的，我们希望第一层的输出是256维的，所以我们需要这样定义第一层的w1和b1。其中w1和b1都是需要迭代优化的，所以它们都需要写上requires\_grad=True (默认值是False)。

![在这里插入图片描述][20201217161705435.png]

有了第一层之后，剩下几层就简单了，依样画葫芦就可了。从256 -> 256 -> 10输出。最后的10的意思是一共有十种可能。至此，我们需要的参数都已经定义好了，且已经完成初始化工作。

![在这里插入图片描述][20201217161722980.png]

下面是利用这些参数构建神经网络。我们的预测工作 (前向传播) 就在forward(x)函数中完成。其中x表示输入的数据。这里一次性输入64张图片，每张图片的维度都是784，所以x的size是64行，784列的矩阵，以后简写成 (64, 784)。

x是 (64, 784) 的矩阵，w1是 (784, 256) 的矩阵，用线性代数中的矩阵乘法进行运算，得到(64, 256) 的结果，这个结果正好与b1相加，得到 (64, 256) 的结果。激活函数不影响x的形状，所以第一层的输出就是(64, 256) 的矩阵。以此类推，第二层得到的是(64, 256) 的矩阵；第三层得到的是(64, 10) 的矩阵。  
这里有三点需要注意：  
① 矩阵运算的时候，矩阵的维度一定要衔接好，否则是无法计算的。另外矩阵的尺寸最好是2^n，这样的尺寸的矩阵在计算时速度更快。  
② 最后一层是不需要激活的，所以没有必要再用relu()  
③ 对于多分类的输出，需要softmax()，但这个操作已经被PyTorch自动执行了，所以我们没必要添加softmax()。如果添加，反而会导致结果不收敛。

![在这里插入图片描述][20201217161739594.png]

在构建完网络模型之后，我们还需要指定梯度下降时用的算法、学习率、使用的损失函数等。  
在这里，我们使用SGD算法 (随机梯度下降)，\[w1,b1,w2,b2,w3,b3\]指的是要优化的参数列表，lr是学习率，也就是我们之前说的步长。步长不要太大，一般选取0.01~0.1即可，步子迈得太大会不稳的，如果有必要，甚至可以每过一轮就减少一点学习率。这里使用的损失函数是交叉熵损失函数。

![在这里插入图片描述][20201217161753269.png]

至此，我们就完成了神经网络的搭建。这个神经网络中的参数都是我们手动指定的。这种方式一般只用来构建很小的神经网络。为了更快，更方便的搭建神经网络，我们更常用第二种方式。  
简单的神经网络的构建2：全连接神经网络  
用类的方式构建神经网络需要继承PyTorch提供的nn.Module类，并在\_\_init\_\_()中调用父类的构造函数。  
用这种方式时，需要优化的参数都隐藏在layer1 ~ layer3中。需要注意的是，需要优化的层前面都要用self指定，且都要放在\_\_init\_\_()中。forward()函数只负责预测 (前向传播)。

![在这里插入图片描述][20201217161810998.png]

与方式1最大的区别就是方式2需要实例化一个对象model，model.parameters()可以自动获得需要优化的参数，也就是隐藏在layer1 ~ layer3中的参数。

![在这里插入图片描述][20201217161822712.png]

这种类的方法的好处是模型搭建更加简单，参数收集更容易，且比较完整。所以我们最常用第二种方式。下面我们就使用这个模型进行训练和预测。  
神经网络的训练和结果  
这一段我们就对模型进行训练。epochs是要训练的次数，我们假设移动需要训练5轮，也就是每一张测试图片都将被读取5次。  
我们从train\_loader中读取每一个批次的index，以及数据和标签。我们的数据的尺寸是(64, 1, 28, 28)，其中64是每一个批次读取的图片数量，1是图片的通道数 (灰度图的通道数是1，彩色图的通道数为3)，剩余两个28是宽和高。这个数据我们需要将其转化成(64, 784)就需要使用reshape(batch\_size, 784)，也可以写成reshape(-1, 784)。写成-1时，PyTorch将自动计算batch\_size。数据变形之后就可以用于model.forward()了，并得到预测值(logits)。用criterion(logits, target)计算预测值与真实值之间的差距 (loss)。  
在得到损失值loss之后就可以进行反向传播求导了，但前提是要把所有参数的梯度清零。求导结束之后进行一次优化，也就是进行类似 w = w - lr \* w.grad这样的操作。这样就完成了一轮训练。我们可以每个100个批次显示一下训练结果。这里有用的主要是loss.item()，显示的是损失值变化。理想的损失值是不规则的慢慢下降的一个过程。

![在这里插入图片描述][20201217161839169.png]

在训练完一个epoch之后，我们需要对当前的神经网络进行一次测试。测试需要知道的是损失值和准确率。  
测试过程与训练过程一样，也是一次预测的过程。区别是需要统计criterion函数计算得到的损失值，以及把正确结果统计出来。值得注意的是logits.data.max(1)不要换成logits.data.argmax(1)。因为两个函数一个得到的是最大值，另一个得到的是最大值的index。不过因为这里的值与index正好相等，所以这两个函数在这个例子中的运行结果是一样的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70 1]

最终，经过5轮训练之后，我们的模型在测试集的准确率达到95%，平均每个元素的损失值为0.0027。  
总结  
这一节我们介绍了MNIST数据集，并用PyTorch对其进行读取。在构建神经网络时，我们首先用手动生成参数的方式创建了一个784 -> 256 -> 256 -> 10的全连接神经网络，然后再用类的方式创建相同结构的神经网络，并对比这两种方式的优缺点。最后对第二种方式进行训练和测试，达到了90+%的准确率。至此，我们就从0开始创建了一个简单的神经网络，并对其进行训练和测试，完成了AI的入门。

import torch
    import torch.optim as optim
    from torch.nn import functional as F
    import torch.nn as nn
    import torchvision
    from torch.nn import Module
    
    #三个超参数
    learning_rate = 0.01 #学习率
    epochs = 5           #总的训练次数
    batch_size = 64      #每个批次的样本数量
    
    train_loader = torch.utils.data.DataLoader(torchvision.datasets.MNIST('datasets/mnist_data',
                    train=True,
                    download=True,
                    transform=torchvision.transforms.Compose([
                    torchvision.transforms.ToTensor(),                       # 数据类型转化
                    torchvision.transforms.Normalize((0.1307, ), (0.3081, )) # 数据归一化处理
        ])), batch_size=batch_size,shuffle=True)
    
    test_loader = torch.utils.data.DataLoader(torchvision.datasets.MNIST('datasets/mnist_data/',
                    train=False,
                    download=True,
                    transform=torchvision.transforms.Compose([
                    torchvision.transforms.ToTensor(),
                    torchvision.transforms.Normalize((0.1307, ), (0.3081, ))
        ])),batch_size=batch_size,shuffle=False)
    
    
    class Model(Module):
        def __init__(self):
            super(Model, self).__init__()
            self.layer1 = nn.Linear(784, 256) #输入784维度，输出256维度
            self.layer2 = nn.Linear(256, 256) #输入256维度，输出256维度
            self.layer3 = nn.Linear(256, 10)  #输入256维度，输出10维度
    
        def forward(self, x):
            x = F.relu(self.layer1(x)) #relu激活函数
            x = F.relu(self.layer2(x))
            x = self.layer3(x) #第三层没有激活函数
            
            #默认最后会加一个softmax函数，所以不需要手动添加softmax函数了
            return x
    
    model = Model()
    
    #定义优化器，用SGD，优化w和b，使用lr
    optimizer = optim.SGD(model.parameters(), lr = learning_rate)
    
    #查文档发现，CrossEntropyLoss()中已经包含Softmax()函数，所以此处无需重复使用，否则会导致算法不收敛
    criteon = nn.CrossEntropyLoss() #用交叉熵损失函数作为损失函数
    
    for epoch in range(epochs):
        for batch_idx,(data,target) in enumerate(train_loader):
            #print(data.shape)
            data = data.reshape(-1, 28 * 28)#n个数据，每个数据的维度维28*28，不需要写通道数
            #print(data.shape)
            logits = model.forward(data) #前向传播得到的(预测)结果
            loss = criteon(logits, target) #交叉熵损失函数：计算预测结果与真实结果之间的损失值
            optimizer.zero_grad() #梯度清零
            
            #计算损失是forward函数后面一层，要从最后一层开始反向传播。所以是从loss开始反向传播，也就是计算导数
            #导数的值可能与自变量的值相关。所以要用具体的损失值开始反向计算。
            loss.backward() 
            optimizer.step() #进行一次优化，也就是进行类似 w = w - lr * w.grad这样的操作
            
            if batch_idx % 100 == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch, batch_idx * len(data), len(train_loader.dataset),
                           100. * batch_idx / len(train_loader), loss.item()))
        
        #完成一个epoch的训练之后，对测试集进行测试
        test_loss = 0
        correct = 0
        for data, target in test_loader:
            data = data.reshape(-1, 28 * 28)#n个数据，每个数据的维度维28*28
            logits = model.forward(data)
            
            test_loss += criteon(logits, target).item() #.item()的意思是就是获得tensor的内容，是数值
            pred = logits.data.max(1)[1]  #从维度为1方向获取预测结果的最大值。这样获得的pred的形状是(64)
            #注意，不要是用argmax(1)，因为max(1)得到的是最大值，而argmax(1)得到的是最大值的index。但是在这个例子里两者的结果是相同的。
            #pred = logits.data.argmax(1)
            
            #把预测值与真实值进行比较，如果相等则返回True，不等则返回False。这个一维的张量用.sum()方法进行统计
            #True作为1看待，False作为0看待。这样就可以得到总的预测正确的元素个数
            correct += pred.eq(target.data).sum() 
    
        #最后统计每个元素的损失值、总的正确率等数据
        test_loss /= len(test_loader.dataset)
        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))
    print("完成")

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70]: /images/20221120/8e829cc561b84aa5be9c950839293771.png
[20201217161705435.png]: /images/20221120/ac5b0fbc8e574eb4a4f67cbd4811207d.png
[20201217161722980.png]: /images/20221120/3b3965b3d48e43718cb9085bb508a89d.png
[20201217161739594.png]: /images/20221120/884a729de7b94e0d863f8ec3344c3ba0.png
[20201217161753269.png]: /images/20221120/2893caea34974993b21eab275bc56c36.png
[20201217161810998.png]: /images/20221120/a6e72bfbb89f424a865168f890d4ce3a.png
[20201217161822712.png]: /images/20221120/d4f7741c2b1a43ae85f7cacd470cfcf4.png
[20201217161839169.png]: /images/20221120/c99877580d084af9a7952c1dca0598d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdlaWwwMDc_size_16_color_FFFFFF_t_70 1]: /images/20221120/dfe77f212e244330ad39c76b78b82795.png