cnn分类图像cifar10

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

cnn分类图像cifar10_第1张图片

命名的格式大概是这样的: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模型的计算过程

cnn分类图像cifar10_第2张图片

输入当然是一张图片,经过卷积的运算,会把图像的尺寸缩小,通道数增多,那么这个计算结果就叫做特征图,在这个特征图上进行降采样,也就是池化,池化的结果一般是比较明确的,就是把这个图像的尺寸缩小了,缩小后在进行卷积,卷积后的图像尺寸进一步缩小,通道数增多,可能会有再次的降采样,再次的卷积,反复多次后,最后这个图像的尺寸会变得非常的小,通道数会变得非常多,计算到最后图像尺寸会变成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)

 

你可能感兴趣的:(深度学习杂文,cnn,分类,人工智能)