使用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)