cnn分类图像cifar10

使用CNN模型来分类图像，数据集采用的cifar10，cifar10共有6万张，这些图像共分为10类。

命名的格式大概是这样的：0_19761.jpg，它的第一个数字表示的就是图像所属的类，分成清楚的就知道了，第0类就是飞机。

加载数据集

这里我们使用pillow的函数来读取图像，使用numpy.array将其转换为矩阵的数据格式，这样这张图片就变成了数字，接着将其转换为pytorch当中的tensor，我们都知道图像数据它是0到255之间的整数，对于神经网络来说，使用较小的数字更加有利于计算，所以将值域压缩到0到1之间，简单来说就是在转换成tensor时，将其除以255，这样读取后的矩阵就变为了32x32x3，但在torch当中通常是将通道数放在前面，变形的方式采用permute，使用参数（2，0，1），将原始张量 x 的维度重新排列。对于y就是读取文件名的第一个数字即可。

import torch


def load_data():
    import PIL.Image
    import numpy as np
    import os

    xs = []
    ys = []

    #遍历文件夹下的所有文件
    for filename in os.listdir('data/cifar10'):

        #只要图片,过滤一些无关的文件
        if not filename.endswith('.jpg'):
            continue

        #读取图片信息
        x = PIL.Image.open('data/cifar10/%s' % filename)

        #转矩阵,数值压缩到0-1之间
        x = torch.FloatTensor(np.array(x)) / 255

        #变形,把通道放前面
        #[32, 32, 3] -> [3, 32, 32]
        x = x.permute(2, 0, 1)

        #y来自文件名的第一个字符
        y = int(filename[0])

        xs.append(x)
        ys.append(y)

    return xs, ys


xs, ys = load_data()

print(len(xs), len(ys), xs[0].shape, ys[0])

定义数据集

我们对数据集进行一个封装，便于后续的遍历

#定义数据集
class Dataset(torch.utils.data.Dataset):

    def __len__(self):
        return len(xs)

    def __getitem__(self, i):
        return xs[i], ys[i]


dataset = Dataset()

x, y = dataset[0]

print(len(dataset), x.shape, y)

定义loader

loader = torch.utils.data.DataLoader(dataset=dataset,
                                     batch_size=8,
                                     shuffle=True,
                                     drop_last=True)

x, y = next(iter(loader))

print(len(loader), x.shape, y)

(7500, torch.Size([8, 3, 32, 32]), tensor([5, 1, 6, 6, 4, 7, 5, 1]))

这里来看下数据的样例，可以看到在一批数据中，x是8张图片3通道32x32的尺寸，y就是八个数字，分别表示了x当中8张图片分别属于哪一类。

一般CNN模型的计算过程

输入当然是一张图片，经过卷积的运算，会把图像的尺寸缩小，通道数增多，那么这个计算结果就叫做特征图，在这个特征图上进行降采样，也就是池化，池化的结果一般是比较明确的，就是把这个图像的尺寸缩小了，缩小后在进行卷积，卷积后的图像尺寸进一步缩小，通道数增多，可能会有再次的降采样，再次的卷积，反复多次后，最后这个图像的尺寸会变得非常的小，通道数会变得非常多，计算到最后图像尺寸会变成1x1的，也就是每个通道数上只有一个像素，但通道数很多甚至几百上千，那么计算到这里之后图像的尺寸已经是1了，所以实际上我们将二维的图像变成了一维的向量，这样就可以输入全连接神经网络当中进行分类的计算了。 

定义模型

先来看初始化部分，这个神经网络模型一共包括了6个层，分别是三个CNN，一个pooling，1个relu，还有一个FC，这些神经网络层我们会在后面的计算时用到

class Model(torch.nn.Module):

    def __init__(self):
        super().__init__()

        #520的卷积层
        self.cnn1 = torch.nn.Conv2d(in_channels=3,
                                    out_channels=16,
                                    kernel_size=5,
                                    stride=2,
                                    padding=0)

        #311的卷积层
        self.cnn2 = torch.nn.Conv2d(in_channels=16,
                                    out_channels=32,
                                    kernel_size=3,
                                    stride=1,
                                    padding=1)

        #710的卷积层
        self.cnn3 = torch.nn.Conv2d(in_channels=32,
                                    out_channels=128,
                                    kernel_size=7,
                                    stride=1,
                                    padding=0)

        #池化层
        self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2)

        #激活函数
        self.relu = torch.nn.ReLU()

        #线性输出层
        self.fc = torch.nn.Linear(in_features=128, out_features=10)

    def forward(self, x):

        #第一次卷积,形状变化可以推演
        #[8, 3, 32, 32] -> [8, 16, 14, 14]
        x = self.cnn1(x)
        x = self.relu(x)

        #第二次卷积,因为是311的卷积,所以尺寸不变
        #[8, 16, 14, 14] -> [8, 32, 14, 14]
        x = self.cnn2(x)
        x = self.relu(x)

        #池化,尺寸减半
        #[8, 32, 14, 14] -> [8, 32, 7, 7]
        x = self.pool(x)

        #第三次卷积,因为核心是7,所以只有一步计算
        #[8, 32, 7, 7] -> [8, 128, 1, 1]
        x = self.cnn3(x)
        x = self.relu(x)

        #展平,便于线性计算,也相当于把图像变成向量
        #[8, 128, 1, 1] -> [8, 128]
        x = x.flatten(start_dim=1)

        #线性计算输出
        #[8, 128] -> [8, 10]
        return self.fc(x)


model = Model()

print(model(torch.randn(8, 3, 32, 32)).shape)

在计算部分，我们来看输入的数据，第一次卷积8张图三通道32x32尺寸，输入到卷积层，CNN的卷积结果让图像的尺寸缩小，通道数增多，然后进行激活，负数归0。接下来，进行CNN2的计算，311是这组参数是非常经典的，在CNN当中也是经常使用，结果是通道数增多而尺寸不变。然后进行一个池化的计算，图像的尺寸减半，然后再次的进行CNN计算，这里的CNN3的kernel size是7，所以在每一步计算的时候实际只计算了一步，图像的尺寸变成了1，通道数变为了128。然后调用flatten，变为8个128维的向量，然后进行线性的输出。

训练模型

这里遍历五次全量数据，训练的过程是非常标准化的，从loader当中获取数据，然后模型计算loss，，再对模型的参数进行调整。

def train():
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    loss_fun = torch.nn.CrossEntropyLoss()
    model.train()

    for epoch in range(5):
        for i, (x, y) in enumerate(loader):
            out = model(x)
            loss = loss_fun(out, y)

            loss.backward()
            optimizer.step()
            optimizer.zero_grad()

            if i % 2000 == 0:
                acc = (out.argmax(dim=1) == y).sum().item() / len(y)
                print(epoch, i, loss.item(), acc)

    torch.save(model, 'model/5.model')

测试

这里测试100批数据，最后的正确率是78%，虽然不是很高，但是验证了我们训练的过程是有效的。

@torch.no_grad()
def test():
    model = torch.load('model/5.model')
    model.eval()

    correct = 0
    total = 0
    for i in range(100):
        x, y = next(iter(loader))

        out = model(x).argmax(dim=1)

        correct += (out == y).sum().item()
        total += len(y)

    print(correct / total)