基于libtorch的LeNet-5卷积神经网络实现(2)--Cifar-10数据分类

上篇文章中我们使用libtorch实现了LeNet-5卷积神经网络，并对Minst数据集进行训练与分类。本文我们尝试使用该实现的网络对更加复杂的Cifar-10数据集进行训练、分类。

基于libtorch的LeNet-5卷积神经网络实现

LeNet-5网络地总体结构如下，详细请参考上方地链接。

1. Cifar-10数据集介绍

Cifar-10是一个专门用于测试图像分类的公开数据集，其包含的彩色图像分为10种类型：飞机、轿车、鸟、猫、鹿、狗、蛙、马、船、货车。且这10种类型图像的标签依次为0、1、2、3、4、5、6、7、8、9。

该数据集分为Python、Matlab、C/C++三个不同的版本，顾名思义，三个版本分别适用于对应的三种编程语言。因为我们使用的是C/C++语言，所以使用对应的C/C++版本就好，该版本的数据集包含6个bin文件，如下图所示，其中data_batch_1.bin~data_batch_5.bin通常用于训练，而test_batch.bin则用于训练之后的识别测试。

如下图所示，每个bin文件包含10000*3073个字节数据，在每个3073数据块中，第一个字节是0~9的标签，后面3072字节则是彩色图像的三通道数据：红通道 --> 绿通道 --> 蓝通道 (1024 --> 1024 --> 1024)。其中每1024字节的数据就是一帧单通道的32*32图像，3帧32*32字节的单通道图像则组成了一帧彩色图像。所以总体来说，每一个bin文件包含了10000帧32*32的彩色图像。

2. 训练策略

(1) epoch

首先我们讲一下epoch的概念：一个epoch就是将所有的训练数据都输入神经网络，并完成前向传播、反向传播、参数更新的过程。比如我们使用Cifar-10数据集进行训练的时候，训练数据包含于5个bin文件中，每个bin文件有10000张32*32图像，因此总共有5*10000张训练图像，当我们把这5*10000张训练图像都输入网络并完成训练的过程，就是一个epoch过程。

然而，往往一个epoch过程过程达不到参数收敛的目的，因此需要执行多个epoch过程，也就是说：使用这5*10000张训练图像完成一次训练之后，在此次训练得到参数模型的基础上，再重复使用这5*10000张训练图像进行下一轮训练。

(2) 学习率的改变

我们把学习率α的初始值设置为0.001，每完成一个epoch，参数都进一步接近收敛状态，因此这个时候我们需要适当比例地减小α，以缩短步长：

α = α*0.8

3. 数据格式转换

(1) 图像格式转换

我们使用Opencv来读取Cifar-10图像为Mat格式，但是libtorch框架处理的数据格式为Tensor格式，因此首先需要把Mat格式的图像转换为Tensor格式。调用from_blob函数可方便进行转换，不过要注意转换时需指定数据维度为1*1*row*col，其中row、col分别为图像的高、宽。

//test_img[i]为Mat格式，test_img[i].data为Mat的数据首地址
//{ 1, 1, test_img[i].rows, test_img[i].cols }指定Tensor张量的维度为1*1*row*col
//torch::kFloat表示以float格式转换数据，该类型要与Mat本来的数据类型相一致，否则会出错
torch::Tensor inputs = torch::from_blob(test_img[i].data, { 1, 1, test_img[i].rows, test_img[i].cols }, torch::kFloat);

(1) 标签格式转换

我们读取的标签为单个uchar型数据，但是libtorch框架处理的数据格式为Tensor格式，因此首先需要把单个uchar数据转换为Tensor格式。调用from_blob函数也可方便转换，同样要注意转换时需指定数据维度为1，也就是只有一个数据的张量。

//test_label[i]为一个uchar数据，&test_label[i]表示该数据的地址
//{ 1 }表示该张量的维度为1
//torch::kByte表示以uchar类型读取该数据，该参数需要与数据本身的类型一致
//toType(torch::kLong)表示把Tensor张量转换为long int类型，因为要求标签的类型为long int
torch::Tensor labels = torch::from_blob(&test_label[i], { 1 }, torch::kByte).toType(torch::kLong);

4. 主要代码实现

(1) 读取Cifar-10数据与标签代码

读取到的图像为uchar型的三通道彩色图像，因此需要将其转换为单通道灰度图，并转换为-1~1之间的浮点型数据，方便后续的训练、分类。

void read_cifar_bin(char *bin_path, vector<Mat> &img_liat, vector<uchar> &label_list)
{
  const int img_num = 10000;
  const int img_size = 3073;   //第一字节是标签
  const int img_size_1 = 1024;
  const int data_size = img_num * img_size;
  const int row = 32;
  const int col = 32;


  uchar *cifar_data = (uchar *)malloc(data_size);
  if (cifar_data == NULL)
  {
    cout << "malloc failed" << endl;
    return;
  }


  FILE *fp = fopen(bin_path, "rb");
  if (fp == NULL)
  {
    cout << "fopen file failed" << endl;
    free(cifar_data);
    return;
  }


  fread(cifar_data, 1, data_size, fp);


  img_liat.clear();
  label_list.clear();
  for (int i = 0; i < img_num; i++)
  {
    long int offset = i * img_size;
    long int offset0 = offset + 1;    //红
    long int offset1 = offset0 + img_size_1;    //绿
    long int offset2 = offset1 + img_size_1;   //蓝


    uchar label = cifar_data[offset];   //标签
    Mat img(row, col, CV_8UC3);


    for (int y = 0; y < row; y++)
    {
      for (int x = 0; x < col; x++)
      {
        int idx = y * col + x;
        img.at<Vec3b>(y, x) = Vec3b(cifar_data[offset2 + idx], cifar_data[offset1 + idx], cifar_data[offset0 + idx]);    //BGR
      }
    }


    Mat gray;
    cvtColor(img, gray, COLOR_BGR2GRAY);  //三通道彩色图转换为单通道灰度图
    gray.convertTo(gray, CV_32F);  //uchar转换为float
    gray = gray / 255.0;   //范围0~1
    gray = (gray - 0.5) / 0.5;  //范围-1~1


    img_liat.push_back(gray.clone());   //float
    label_list.push_back(label);       //uchar
  }


  fclose(fp);
  free(cifar_data);
}

(2) LeNet-5网络定义

struct LeNet5 : torch::nn::Module
{
  //arg_padding为C1层的padding参数，当输入图像为28*28时，需要将其填充为32x32的图像
  //这里可能有人会有疑惑，为什么没有定义S2、S4层，这是因为池化层放在前向传播函数中执行即可，不需要再定义了，详细见forward函数
  LeNet5(int arg_padding = 0)
    //C1层
    : C1(register_module("C1", torch::nn::Conv2d(torch::nn::Conv2dOptions(1, 6, 5).padding(arg_padding))))
    //C3层
    , C3(register_module("C3", torch::nn::Conv2d(6, 16, 5)))
    //C5层
    , C5(register_module("C5", torch::nn::Conv2d(16, 120, 5)))
    //F6层
    , F6(register_module("F6", torch::nn::Linear(120, 84)))
    //OUTPUT层
    , OUTPUT(register_module("OUTPUT", torch::nn::Linear(84, 10)))
  {


  }


  ~LeNet5()
  {


  }
  
  //该函数用于将多维数据一维展开成一维向量
  int64_t num_flat_features(torch::Tensor input)
  {
    int64_t num_features = 1;
    auto sizes = input.sizes();
    for (auto s : sizes) 
    {
      num_features *= s;
    }
    return num_features;
  }
  
  //前向传播函数
  torch::Tensor forward(torch::Tensor input)
  {
    namespace F = torch::nn::functional;
    //这一步其实包含了3个操作，首先是C1层的卷积，其次是将卷积结果输入Relu函数，接着是将Relu函数的结果做最大值的池化操作
    auto x = F::max_pool2d(F::relu(C1(input)), F::MaxPool2dFuncOptions({ 2,2 }));
    //这一步也包含了3个操作，首先是C3层的卷积，其次是将卷积结果输入Relu函数，接着是将Relu函数的结果做最大值的池化操作
    x = F::max_pool2d(F::relu(C3(x)), F::MaxPool2dFuncOptions({ 2,2 }));
    //将C5层的卷积结果输入Relu函数，Relu函数的结果作为本层输出
    x = F::relu(C5(x));
    //120张1*1的卷积结果图像按顺序展开成长度为120的一维向量
    x = x.view({ -1, num_flat_features(x) });
    //F6层的Affine计算
    x = F::relu(F6(x));
    //OUTPUT层的Affine计算，注意这里不包括Softmax层计算，Softmax层计算放到后面的交叉熵误差函数中去做
    x = OUTPUT(x);
    
    return x;
  }


  //要求这里的各层定义与本结构体开头处的定义保持一致
  int m_padding = 0;
  torch::nn::Conv2d  C1;
  torch::nn::Conv2d  C3;
  torch::nn::Conv2d  C5;
  torch::nn::Linear  F6;
  torch::nn::Linear  OUTPUT;
};

(3) 训练代码

Cifar-10图像本来就是32*32大小，因此不需要像Minst数据集那样填充数据。

void tran_lenet_5_cifar_10(void)
{


  vector<Mat> train_img_total;
  vector<uchar> train_label_total;


  //定义一个LeNet-5网络结构体，输入的图像是32x32图像，不需要填充
  LeNet5 net1(0);
  //使用交叉熵误差函数
  auto criterion = torch::nn::CrossEntropyLoss();
  
  int kNumberOfEpochs = 8;   //训练8个epoch 
  int data_file_num = 5;  //总共5个训练文件
  double alpha = 0.001;   //学习率初始值0.001
  for (int epoch = 0; epoch < kNumberOfEpochs; epoch++)
  {
    printf("epoch:%d\n", epoch+1);
    //定义梯度下降法优化器
    auto optimizer = torch::optim::SGD(net1.parameters(), torch::optim::SGDOptions(alpha).momentum(0.9));
    
    for (int k = 1; k <= data_file_num; k++)
    {


      printf("data_file_num:%d\n", k);


      auto running_loss = 0.;


      char str[200] = { 0 };
      sprintf(str, "D:/Program Files (x86)/Microsoft Visual Studio 14.0/prj/KNN_test/KNN_test/cifar-10-batches-bin/data_batch_%d.bin", k);
      //读取10000张cifar-10训练图像
      read_cifar_bin(str, train_img_total, train_label_total);


      for (int i = 0; i < train_img_total.size(); i++)
      {
        //Mat转换为Tensor
        torch::Tensor inputs = torch::from_blob(train_img_total[i].data, { 1, 1, train_img_total[i].rows, train_img_total[i].cols }, torch::kFloat);  //1*1*32*32
        //uchar转换为Tensor
        torch::Tensor labels = torch::from_blob(&train_label_total[i], { 1 }, torch::kByte).toType(torch::kLong);   //1
        //清零梯度
        optimizer.zero_grad();
        //前向传播
        auto outputs = net1.forward(inputs);
        //计算交叉熵误差
        auto loss = criterion(outputs, labels);
        //误差反向传播
        loss.backward();
        //更新参数
        optimizer.step();
        //累加每1000个误差值，方便查看训练时交叉熵误差函数的下降情况
        running_loss += loss.item().toFloat();
        if ((i + 1) % 1000 == 0)
        {
          printf("loss: %.3f\n", running_loss / 1000);
          running_loss = 0.;
        }
      }
    }


    alpha *= 0.8;  //完成一个epoch，减小学习率
  }
  
  printf("Finish training!\n");
  torch::serialize::OutputArchive archive;
  net1.save(archive);
  archive.save_to("mnist_cifar_10.pt");
  printf("Save the training result to mnist.pt.\n");


}
 

(4) 分类测试代码

void test_lenet_5_cifar_10(void)
{


  LeNet5 net1(0);


  torch::serialize::InputArchive archive;
  archive.load_from("mnist_cifar_10.pt");  //加载上一步骤训练好的模型


  net1.load(archive);
  //读取测试数据与标签
  vector<Mat> test_img;
  vector<uchar> test_label;
  read_cifar_bin("D:/Program Files (x86)/Microsoft Visual Studio 14.0/prj/KNN_test/KNN_test/cifar-10-batches-bin/test_batch.bin", test_img, test_label);


  int total_test_items = 0, passed_test_items = 0;
  double total_time = 0.0;
  
  for (int i = 0; i < test_img.size(); i++)
  {
    //将Mat格式转换为Tensor格式
    torch::Tensor inputs = torch::from_blob(test_img[i].data, { 1, 1, test_img[i].rows, test_img[i].cols }, torch::kFloat);  //1*1*32*32
    //uchar转换为Tensor
    torch::Tensor labels = torch::from_blob(&test_label[i], { 1 }, torch::kByte).toType(torch::kLong);   //1
    //使用训练好的模型对测试数据进行分类，也即前向传播过程
    auto outputs = net1.forward(inputs);
    //得到分类值，0 ~ 9
    auto predicted = (torch::max)(outputs, 1);
    //比较分类结果和对应的标签是否一致，如果一致则认为分类正确
    if (labels[0].item<int>() == std::get<1>(predicted).item<int>())
      passed_test_items++;


    total_test_items++;


    printf("label: %d.\n", labels[0].item<int>());
    printf("predicted label: %d.\n", std::get<1>(predicted).item<int>());
    
  }
  
  printf("total_test_items=%d, passed_test_items=%d, pass rate=%f\n", total_test_items, passed_test_items, passed_test_items*1.0 / total_test_items);
}

(5) main函数

int main()
{
  tran_lenet_5_cifar_10();  //训练
  test_lenet_5_cifar_10();  //测试


  return EXIT_SUCCESS;
}

5. 运行结果

运行上述代码，先训练模型、保存模型，然后再加载模型（实际使用时如果已经训练好模型，可直接加载模型而不需要再训练）。

训练时目标函数（损失函数）的变化如下图所示，可以看到其值逐步减小：

待训练完成以及保存模型之后，就可以加载模型对数据进行分类预测啦，我们的分类结果如下图所示，准确率达到了60.3%，这个分类结果并不理想，这是因为LeNet-5网络还是相对简单了，对相对Minst更复杂的数据分类效果并不好。因此在接下来的文章中我们将使用libtorch来实现更加复杂的网络，敬请期待~

欢迎扫码关注以下微信公众号，接下来会不定时更新更加精彩的内容噢～