卷积神经网络CNN入门【pytorch学习】

朴灿烈づ我的快乐病毒、 2022-04-17 00:04 358阅读 0赞

## 简述 ##

在学习GANs的时候遇到一篇论文DCGANs，说是其中用到了卷积神经网络。  
所以，就抽空学习一下，结果，真没想到有那么多的坑。

### 文章目录 ###

*   *  简述
     *  数据配置
     *   *  配套的代码段
     *  参数设置
     *  训练集批处理构建
     *  测试集
     *  构建CNN框架
     *  训练
     *  测试结果
     *  全部代码
     *  参考

## 数据配置 ##

第一步配置数据的时候就贼坑了。。。

*  看下面的这一篇文章就可以解决，就是手动下载之后，放在一个目录下，之后，再修改源码中指定的位置，之后再运行，代码会从本地下载（其实就是转移位置），但是由于它同时也会生成两个c文件。所以，**不推荐直接手动的建目录之类的操作**。
 *  [pytorch下载mnist超时解决方案][pytorch_mnist]

### 配套的代码段 ###

import torch
    import torch.nn as nn
    import torchvision
    import torch.utils.data as Data
    
    DOWNLOAD_MNIST = True  # 已经下载好的话，会自动跳过的
    
    # Mnist 手写数字
    train_data = torchvision.datasets.MNIST(
        root='./mnist/',  # 保存或者提取位置
        train=True,  # this is training data
        transform=torchvision.transforms.ToTensor(),  # 转换 PIL.Image or numpy.ndarray 成
        # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
        download=DOWNLOAD_MNIST,  # 没下载就下载, 下载了就不用再下了
    )
    
    test_data = torchvision.datasets.MNIST(
        root='./mnist/',
        train=False
    )

## 参数设置 ##

*  这里只测试一次的原因其实是，训练集有60000个。虽然之后使用批处理的方式，但是我们`BATCH_SIZE`设置为了50，所以，也有1200次的训练了。所以，只用一次就好了。
 *  `BATCH_SIZE` 就是每一次训练的那个块中的数据数量
 *  `LR`学习率

这些参数在建立GANs的时候也用到了。

# Hyper Parameters
    EPOCH = 1  # 训练整批数据多少次, 为了节约时间, 我们只训练一次
    BATCH_SIZE = 50
    LR = 0.001  # 学习率

## 训练集批处理构建 ##

# 训练集丢BATCH_SIZE个, 图片大小为28*28
    train_loader = Data.DataLoader(
        dataset=train_data,
        batch_size=BATCH_SIZE,
        shuffle=True  # 是否打乱顺序
    )

## 测试集 ##

其实这里调用出来是没有什么用，但是任然放出来了，主要是为了跟学习的一份代码中保持一致性。找bug的时候，这样很方便。

**但是这里有一个重点（对于新手）**

*  `torch.unsqueeze()`函数，给数组加上一个维度。dim=1表示在添加的这个维度是再哪？
 *  比如`dim=1`时候
 *  `（10，20）`变成了`（10，1，20）`

# test_data为 [10000, 28, 28]这样的一个数组，这里就只截取一段就好了
    test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)
    test_y = test_data.test_labels

## 构建CNN框架 ##

*  `nn.Module`非常常见的自定义类，所有模型的基类
 *  第一个网络是：先是一个卷积，再是一个ReLU激活函数，最后再来个最大池化

如果真的是新手的话，会发下这里贼多知识点。

*  [先看懂什么是卷积][Link 1]
 *  [再搞定padding，stride这些参数什么意思][padding_stride]
 *  **池化：** 这个反而是最简单的。就是给一个矩形（小一点的），然后通过一定的移动方式，在这个区间上找最大值。然后不重复的这样遍历完所有的像素点。得到的一张新图（新的张量）
 *  **所以，我在注释的地方表示的是到这里的时候这个数据的shape**
 *  通过`.view(shape(0),-1)` 这样的方式，将数据展开为一个一维向量。之后，再通过一个线性函数，转成10个线性函数的结果来。（**表示对应10个数字的概率（其实可能是负数的，但是会逐渐的改善，大致上能拟合出结果来）**）

class CNN(nn.Module):
        def __init__(self):
            super(CNN, self).__init__()
            self.layer1 = nn.Sequential(
                # (1, 28, 28)
                nn.Conv2d(
                    in_channels=1,
                    out_channels=16,
                    kernel_size=5,  # 卷积filter, 移动块长
                    stride=1,  # filter的每次移动步长
                    padding=2,
                    groups=1
                ),
                # (16, 28, 38)
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)
                # (16, 14, 14)
            )
            self.layer2 = nn.Sequential(
    
                nn.Conv2d(
                    in_channels=16,
                    out_channels=32,
                    kernel_size=5,
                    stride=1,
                    padding=2
                ),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)
            )
            self.layer3 = nn.Linear(32 * 7 * 7, 10)
    
        def forward(self, x):
            # print(x.shape)
            x = self.layer1(x)
            # print(x.shape)
            x = self.layer2(x)
            # print(x.shape)
            x = x.view(x.size(0), -1)
            # print(x.shape)
            x = self.layer3(x)
            # print(x.shape)
            return x

## 训练 ##

*  这里的遍历，其实是会把所有的训练集数据都训练过一遍为止。
 *  损失函数调用的是交叉熵。[https://blog.csdn.net/zziahgf/article/details/80196376][https_blog.csdn.net_zziahgf_article_details_80196376]
 *  公式的含义，其实非常简单，就是希望目标数对应下标的那个数值要大一点。但是又不能是因为所有为止上的点的数值都变大导致了。

cnn = CNN()
    
    optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)
    loss_function = nn.CrossEntropyLoss()
    for epoch in range(EPOCH):
        for step, (b_x, b_y) in enumerate(train_loader):
            output = cnn(b_x)
            loss = loss_function(output, b_y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

## 测试结果 ##

print('finished training')
    test_out = cnn(test_x)
    predict_y = torch.argmax(test_out, 1).data.numpy()
    print('Accuracy in Test : %.4f%%' % (sum(predict_y == test_y.data.numpy()) * 100/ len(predict_y)))

我这里跑的一个结果是

finished training
    Accuracy in Test : 98.2000%

然后速度其实是有点慢的。之后会再看看其他的实现。

## 全部代码 ##

import torch
    import torch.nn as nn
    import torchvision
    import torch.utils.data as Data
    
    # Hyper Parameters
    EPOCH = 1  # 训练整批数据多少次, 为了节约时间, 我们只训练一次
    BATCH_SIZE = 50
    LR = 0.001  # 学习率
    DOWNLOAD_MNIST = True  # 已经下载好的话，会自动跳过的
    
    # Mnist 手写数字
    train_data = torchvision.datasets.MNIST(
        root='./mnist/',  # 保存或者提取位置
        train=True,  # this is training data
        transform=torchvision.transforms.ToTensor(),  # 转换 PIL.Image or numpy.ndarray 成
        # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
        download=DOWNLOAD_MNIST,  # 没下载就下载, 下载了就不用再下了
    )
    
    test_data = torchvision.datasets.MNIST(
        root='./mnist/',
        train=False
    )
    
    # 训练集丢BATCH_SIZE个, 图片大小为28*28
    train_loader = Data.DataLoader(
        dataset=train_data,
        batch_size=BATCH_SIZE,
        shuffle=True  # 是否打乱顺序
    )
    
    # test_data为 [10000, 28, 28]这样的一个数组，这里就只截取一段就好了
    test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)
    test_y = test_data.test_labels
    
    
    # cnn
    
    class CNN(nn.Module):
        def __init__(self):
            super(CNN, self).__init__()
            self.layer1 = nn.Sequential(
                # (1, 28, 28)
                nn.Conv2d(
                    in_channels=1,
                    out_channels=16,
                    kernel_size=5,  # 卷积filter, 移动块长
                    stride=1,  # filter的每次移动步长
                    padding=2,
                    groups=1
                ),
                # (16, 28, 38)
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)
                # (16, 14, 14)
            )
            self.layer2 = nn.Sequential(
    
                nn.Conv2d(
                    in_channels=16,
                    out_channels=32,
                    kernel_size=5,
                    stride=1,
                    padding=2
                ),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)
            )
            self.layer3 = nn.Linear(32 * 7 * 7, 10)
    
        def forward(self, x):
            # print(x.shape)
            x = self.layer1(x)
            # print(x.shape)
            x = self.layer2(x)
            # print(x.shape)
            x = x.view(x.size(0), -1)
            # print(x.shape)
            x = self.layer3(x)
            # print(x.shape)
            return x
    
    
    cnn = CNN()
    
    optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)
    loss_function = nn.CrossEntropyLoss()
    for epoch in range(EPOCH):
        for step, (b_x, b_y) in enumerate(train_loader):
            output = cnn(b_x)
            loss = loss_function(output, b_y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
    print('finished training')
    test_out = cnn(test_x)
    predict_y = torch.argmax(test_out, 1).data.numpy()
    print('Accuracy in Test : %.4f%%' % (sum(predict_y == test_y.data.numpy()) * 100/ len(predict_y)))

## 参考 ##

*  [https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/5-03-A-CNN/][https_morvanzhou.github.io_tutorials_machine-learning_tensorflow_5-03-A-CNN]
 *  [https://github.com/sunshineatnoon/Paper-Implementations][https_github.com_sunshineatnoon_Paper-Implementations]

[pytorch_mnist]: https://blog.csdn.net/a19990412/article/details/83870632
[Link 1]: https://www.zhihu.com/question/22298352
[padding_stride]: https://blog.csdn.net/a19990412/article/details/83904476
[https_blog.csdn.net_zziahgf_article_details_80196376]: https://blog.csdn.net/zziahgf/article/details/80196376
[https_morvanzhou.github.io_tutorials_machine-learning_tensorflow_5-03-A-CNN]: https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/5-03-A-CNN/
[https_github.com_sunshineatnoon_Paper-Implementations]: https://github.com/sunshineatnoon/Paper-Implementations