使用卷积神经网络进行图像分类

作者: PaddlePaddle
日期: 2021.05
摘要: 本示例教程将会演示如何使用飞桨的卷积神经网络来完成图像分类任务。这是一个较为简单的示例，将会使用一个由三个卷积层组成的网络完成cifar10数据集的图像分类任务。

一、环境配置

本教程基于Paddle 2.1 编写，如果你的环境不是本版本，请先参考官网安装 Paddle 2.1 。

  1. import paddle
  2. import paddle.nn.functional as F
  3. from paddle.vision.transforms import ToTensor
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  7. print(paddle.__version__)
  1. 2.1.0

二、加载数据集

本案例将会使用飞桨提供的API完成数据集的下载并为后续的训练任务准备好数据迭代器。cifar10数据集由60000张大小为32 * 32的彩色图片组成，其中有50000张图片组成了训练集，另外10000张图片组成了测试集。这些图片分为10个类别，将训练一个模型能够把图片进行正确的分类。

  1. transform = ToTensor()
  2. cifar10_train = paddle.vision.datasets.Cifar10(mode='train',
  3.                                                transform=transform)
  4. cifar10_test = paddle.vision.datasets.Cifar10(mode='test',
  5.                                               transform=transform)

三、组建网络

接下来使用飞桨定义一个使用了三个二维卷积（ Conv2D ) 且每次卷积之后使用 relu 激活函数，两个二维池化层（ MaxPool2D ），和两个线性变换层组成的分类网络，来把一个(32, 32, 3)形状的图片通过卷积神经网络映射为10个输出，这对应着10个分类的类别。

  1. class MyNet(paddle.nn.Layer):
  2.     def __init__(self, num_classes=1):
  3.         super(MyNet, self).__init__()
  5.         self.conv1 = paddle.nn.Conv2D(in_channels=3, out_channels=32, kernel_size=(3, 3))
  6.         self.pool1 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)
  8.         self.conv2 = paddle.nn.Conv2D(in_channels=32, out_channels=64, kernel_size=(3,3))
  9.         self.pool2 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)
  11.         self.conv3 = paddle.nn.Conv2D(in_channels=64, out_channels=64, kernel_size=(3,3))
  13.         self.flatten = paddle.nn.Flatten()
  15.         self.linear1 = paddle.nn.Linear(in_features=1024, out_features=64)
  16.         self.linear2 = paddle.nn.Linear(in_features=64, out_features=num_classes)
  18.     def forward(self, x):
  19.         x = self.conv1(x)
  20.         x = F.relu(x)
  21.         x = self.pool1(x)
  23.         x = self.conv2(x)
  24.         x = F.relu(x)
  25.         x = self.pool2(x)
  27.         x = self.conv3(x)
  28.         x = F.relu(x)
  30.         x = self.flatten(x)
  31.         x = self.linear1(x)
  32.         x = F.relu(x)
  33.         x = self.linear2(x)
  34.         return x

四、模型训练&预测

接下来，用一个循环来进行模型的训练，将会:

  • 使用 paddle.optimizer.Adam 优化器来进行优化。

  • 使用 F.cross_entropy 来计算损失值。

  • 使用 paddle.io.DataLoader 来加载数据并组建batch。

  1. epoch_num = 10
  2. batch_size = 32
  3. learning_rate = 0.001
  1. val_acc_history = []
  2. val_loss_history = []
  4. def train(model):
  5.     print('start training ... ')
  6.     # turn into training mode
  7.     model.train()
  9.     opt = paddle.optimizer.Adam(learning_rate=learning_rate,
  10.                                 parameters=model.parameters())
  12.     train_loader = paddle.io.DataLoader(cifar10_train,
  13.                                         shuffle=True,
  14.                                         batch_size=batch_size)
  16.     valid_loader = paddle.io.DataLoader(cifar10_test, batch_size=batch_size)
  18.     for epoch in range(epoch_num):
  19.         for batch_id, data in enumerate(train_loader()):
  20.             x_data = data[0]
  21.             y_data = paddle.to_tensor(data[1])
  22.             y_data = paddle.unsqueeze(y_data, 1)
  24.             logits = model(x_data)
  25.             loss = F.cross_entropy(logits, y_data)
  27.             if batch_id % 1000 == 0:
  28.                 print("epoch: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, loss.numpy()))
  29.             loss.backward()
  30.             opt.step()
  31.             opt.clear_grad()
  33.         # evaluate model after one epoch
  34.         model.eval()
  35.         accuracies = []
  36.         losses = []
  37.         for batch_id, data in enumerate(valid_loader()):
  38.             x_data = data[0]
  39.             y_data = paddle.to_tensor(data[1])
  40.             y_data = paddle.unsqueeze(y_data, 1)
  42.             logits = model(x_data)
  43.             loss = F.cross_entropy(logits, y_data)
  44.             acc = paddle.metric.accuracy(logits, y_data)
  45.             accuracies.append(acc.numpy())
  46.             losses.append(loss.numpy())
  48.         avg_acc, avg_loss = np.mean(accuracies), np.mean(losses)
  49.         print("[validation] accuracy/loss: {}/{}".format(avg_acc, avg_loss))
  50.         val_acc_history.append(avg_acc)
  51.         val_loss_history.append(avg_loss)
  52.         model.train()
  54. model = MyNet(num_classes=10)
  55. train(model)
  1. start training ... 
  2. epoch: 0, batch_id: 0, loss is: [2.7625809]
  1. plt.plot(val_acc_history, label = 'validation accuracy')
  3. plt.xlabel('Epoch')
  4. plt.ylabel('Accuracy')
  5. plt.ylim([0.5, 0.8])
  6. plt.legend(loc='lower right')
  1. <matplotlib.legend.Legend at 0x12c3686d0>

png

The End

从上面的示例可以看到，在cifar10数据集上，使用简单的卷积神经网络，用飞桨可以达到70%以上的准确率。你也可以通过调整网络结构和参数，达到更好的效果。