pytorch 卷积神经网络笔记

忘是亡心i 2023-06-10 03:21 217阅读 0赞

[pytorch 神经网络基本笔记][pytorch]中描述了神经网络中计算逻辑是什么，下面的例子来自官方，可以运行在cpu上。今天开始了解卷积神经网络是什么。  
**1 卷积**  
[最容易理解的对卷积(convolution)的解释][convolution]，虽然没有他说的那么容易理解，不过可以清楚卷积的意义：加权叠加.[卷积神经网络之卷积计算、作用与思想][Link 1]这篇文章说的是将滤波器作为特征模板在图片上方匹配。那么数学意义是什么呢？  
从[深度学习实战教程(四)：卷积神经网络][Link 2]，我找到卷积的计算公式: 其中 w b w\_b wb为偏置bias， f f f为激活函数，计算过程是`feature_map=image*filter`，拿着这个filter在图片上扫描，得到feature\_map  
 a i , j = f ( ∑ m = 0 2 ∑ n = 0 2 w m , n ∗ x i + m , j + n + w b ) a\_\{i,j\}=f(\\sum\_\{m=0\}^2\\sum\_\{n=0\}^2w\_\{m,n\}\*x\_\{i+m,j+n\}+w\_b) ai,j=f(m=0∑2n=0∑2wm,n∗xi\+m,j\+n\+wb)  
从这个公式可以看出卷积是将图片与卷积核中逐行对应位置的乘积之和。这个矩阵的乘法是不一样的，矩阵是行乘以列，而这个里是行×行  
再看看[别怕，"卷积"其实很简单][Link 3]  
**2 定义网络**  
定义了一个二维卷积，[nn.Conv2d卷积][nn.Conv2d]从这个里面的说明，我知道了下面的语句，我定义了一个输入通道为3，输出通道为6，卷积核3×3的卷积层模型，通道也就是维度。RGB图像是3通道这个我可以理解，为什么要输出通道为6呢。

self.conv1 = nn.Conv2d(3, 6, 5)
    self.conv2 = nn.Conv2d(6, 16, 5)

在工程化，我们一般不会自己定义网络，都使用成熟的网络模型，毕竟别人是科学家，而我是搞工程应用的。有分工，定位要清晰。  
[详解CNN卷积神经网络][CNN]中描述常见的神经网络,M表示卷积、池化层的数量，而K则表示全连接层的数量，那么这个M、K怎么设定呢，他们靠什么调整出来的数量呢？

INPUT -> [[CONV -> RELU]*N -> POOL?]*M -> [FC -> RELU]*K -> FC

再看看[卷积神经网络的卷积核大小、个数，卷积层数如何确定呢？][Link 4]，这些跟学习率一样，都是超参，这里就要论经验的重要性了。  
**3 池化**  
[CNN学习笔记：池化层][CNN 1]，池化的目的很明确就是降采样，[吴恩达深度学习笔记(79)-池化层讲解（Pooling layers）][79_-_Pooling layers]中描述Max Pooing最大池化最为常用，那么它的算法是什么呢？[深度学习之卷积神经网络（六）][Link 5]中描述：MaxPooling就是去一定范围的最大值。  
**4 全连接**  
[CNN入门讲解-为什么要有最后一层全连接？][CNN_-]，全连接是一个分类器，卷积块为“特征提取器”而 NN 块为“决策分类器“，这个我觉得说明容易理解。  
[CNN 入门讲解：什么是全连接层（Fully Connected Layer）?][CNN _Fully Connected Layer]这篇文章只是将cnn的识别用图来描述而已，还是特征提取到决策分类的工程化流程。[浅谈线性多分类分类器（全连接层、SVM、Softmax classifier等）][SVM_Softmax classifier]，既然是分类那当是线性回归了。  
**4.1 Dropout**  
[pytorch之Dropout][pytorch_Dropout],Dropout用于了防止或减轻过拟合而使用的函数，它一般用在全连接层.  
[pytorch Dropout过拟合][pytorch Dropout],这篇文章中的代码，可以看到dropout作用的变化。  
[ Dropout为何能防止过拟合？][Dropout]dropout是指在深度学习网络的训练过程中，对于神经网络单元，按照一定的概率将其暂时从网络中丢弃。故在随机梯度下降过程中，每个mini-batch都是在训练不同的网络。  
虽然[pytorch 神经网络基本笔记][pytorch]中介绍了通过风险函数和正则化防止过拟合，这里有多了个dropout，这篇文章讲的很好，我总结一下数学公式参考[神经网络优化算法：Dropout、梯度消失/爆炸、Adam优化算法，一篇就够了！][Dropout_Adam]

**5 官方实例**

# 1. 将数据加载到numpy数组里，然后将数组专程torch.*Tensor
    # 1.1 对于图片，有Pillow，OpenCV等包可以使用
    # 1.2 对于音频,有scipy和librosa等包可以使用
    # 1.3 对于文本，不管是原生的python还是基于cpython的文本，可以使用NLTK和SpaSy
    # 2 计算机视觉包torchvision，其中包含了针对Imagenet,CIFAR10，MINIST等数据集的数据加载器data loaders
    #   还有对图片数据变形的操作，即torchvision.datasets,torch.utils.data.Dataloader
    import time
    import torch
    import torchvision
    import torchvision.transforms as transforms
    import matplotlib.pyplot as plt
    import numpy as np
    # 定义卷积神经网络
    import torch.nn as nn
    import torch.nn.functional as F
    # 定义损失函数和优化器
    import torch.optim as optim
    
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)
    
    testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)
    
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    # 定义卷积网络
    class Net(nn.Module):
        def __init__(self):
            super(Net,self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 5)
            self.pool = nn.MaxPool2d(2, 2)
            self.conv2 = nn.Conv2d(6, 16, 5)
            # 全连接层，16*5*5个节点连接到120个节点上
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            # 全连接层，将120个节点将120个节点连接到84个节点上
            self.fc2 = nn.Linear(120, 84)
            # 全连接层，将84个节点连接到10个节点上
            self.fc3 = nn.Linear(84, 10)
        def forward(self, x):
            x = self.pool(F.relu(self.conv1(x)))
            x = self.pool(F.relu(self.conv2(x)))
            x = x.view(-1, 16 * 5 * 5)
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    # 随机获取训练图片
    dataiter = iter(trainloader)
    images, labels = dataiter.next()
    FMT='%Y-%m-%d %H:%M:%S'
    net = Net()
    # 交叉熵损失
    criterion = nn.CrossEntropyLoss()
    # 随机梯度下降SGD
    # （使用标准动量优化算法momentum）
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    print('训练开始时间:%s' % time.strftime(FMT,time.localtime(time.time())))
    for epoch in range(2):  # loop over the dataset multiple times
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data
            # zero the parameter gradients
            # 将梯度置为0,也就是把loss关于weight的导数变成0
            optimizer.zero_grad()
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            # print statistics
            running_loss += loss.item()
            if i % 2000 == 1999:    # print every 2000 mini-batches
                print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    print('训练结束时间:%s' % time.strftime(FMT,time.localtime(time.time())))
    print('Finished Training')
    print('总体预测开始时间:%s' % time.strftime(FMT,time.localtime(time.time())))
    correct = 0
    total = 0
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('总体预测结束时间:%s' % time.strftime(FMT,time.localtime(time.time())))
    print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))
    
    print('每类预测开始时间:%s' % time.strftime(FMT,time.localtime(time.time())))
    class_correct = list(0. for i in range(10))
    class_total = list(0. for i in range(10))
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, predicted = torch.max(outputs, 1)
            c = (predicted == labels).squeeze()
            for i in range(4):
                label = labels[i]
                class_correct[label] += c[i].item()
                class_total[label] += 1
    
    
    for i in range(10):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))
    print('每类预测结束时间:%s' % time.strftime(FMT,time.localtime(time.time())))
    
    Files already downloaded and verified
    Files already downloaded and verified
    训练开始时间:2019-10-22 11:32:03
    [1,  2000] loss: 2.199
    [1,  4000] loss: 1.863
    [1,  6000] loss: 1.665
    [1,  8000] loss: 1.589
    [1, 10000] loss: 1.533
    [1, 12000] loss: 1.493
    [2,  2000] loss: 1.405
    [2,  4000] loss: 1.365
    [2,  6000] loss: 1.354
    [2,  8000] loss: 1.346
    [2, 10000] loss: 1.303
    [2, 12000] loss: 1.294
    训练结束时间:2019-10-22 11:33:49
    Finished Training
    总体预测开始时间:2019-10-22 11:33:49
    总体预测结束时间:2019-10-22 11:33:53
    Accuracy of the network on the 10000 test images: 53 %
    每类预测开始时间:2019-10-22 11:33:53
    Accuracy of plane : 53 %
    Accuracy of   car : 81 %
    Accuracy of  bird :  8 %
    Accuracy of   cat : 30 %
    Accuracy of  deer : 60 %
    Accuracy of   dog : 32 %
    Accuracy of  frog : 65 %
    Accuracy of horse : 75 %
    Accuracy of  ship : 66 %
    Accuracy of truck : 55 %
    每类预测结束时间:2019-10-22 11:33:57

[pytorch]: https://blog.csdn.net/warrah/article/details/102680712
[convolution]: https://www.cnblogs.com/alexanderkun/p/8149059.html
[Link 1]: https://www.cnblogs.com/shine-lee/p/9932226.html
[Link 2]: https://cuijiahua.com/blog/2018/12/dl-10.html
[Link 3]: https://blog.csdn.net/qq_39521554/article/details/79083864
[nn.Conv2d]: https://blog.csdn.net/qq_26369907/article/details/88366147
[CNN]: https://blog.csdn.net/liangchunjiang/article/details/79030681
[Link 4]: https://yq.aliyun.com/articles/610509
[CNN 1]: https://www.cnblogs.com/MrSaver/p/10356695.html
[79_-_Pooling layers]: https://www.jianshu.com/p/b742c8c92b26
[Link 5]: https://www.jianshu.com/p/3b114d47739a
[CNN_-]: https://baijiahao.baidu.com/s?id=1590121601889191549&wfr=spider&for=pc
[CNN _Fully Connected Layer]: http://www.pianshen.com/article/5815352418/
[SVM_Softmax classifier]: https://blog.csdn.net/Trasper1/article/details/82216305
[pytorch_Dropout]: https://www.jianshu.com/p/636be9f8f046
[pytorch Dropout]: https://www.jianshu.com/p/57f4ed660923
[Dropout]: https://blog.csdn.net/dQCFKyQDXYm3F8rB0/article/details/81976571
[Dropout_Adam]: https://www.cnblogs.com/mantch/p/11379289.html