003 完整代码实现 - 图1

代码如下：在Anaconda上运行无问题

  1. # =============================================================================
  2. # 手写数字识别
  3. # 数据集：MINIT
  4. # 参考资料：百度AI STUDIO和飞桨
  5. # =============================================================================
  6. ####重构模型：卷积神经网络#####
  7. ####重构损失函数####
  8. ####优化算法####
  9. ####计算模型的分类准确率####
  10. ####加入正则化项，避免模型过拟合####
  11. ####可视化分析#####
  14. import random
  15. import paddle
  16. import paddle.fluid as fluid
  17. from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
  18. import numpy as np
  19. import matplotlib.pyplot as plt
  20. from PIL import Image
  21. # 安装visualdl
  22. #!pip install --upgrade --pre visualdl
  23. #from visualdl import LogWriter
  25. import gzip
  26. import json
  27. import os
  28. #电脑如果是cpu，需要加上下面在条程序，否则spyder会卡住或者崩溃报错
  29. #参考：https://blog.csdn.net/qq_44666320/article/details/106349356?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159454929319724843302313%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=159454929319724843302313&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v3~pc_rank_v3-2-106349356.pc_ecpm_v3_pc_rank_v3&utm_term=OMP%3A+Error+%2315%3A+Initializing+l
  30. os.environ['KMP_DUPLICATE_LIB_OK']='True'
  32. ##数据处理##
  33. def load_data(mode='train'):
  34.     datafile = './work/mnist.json.gz'
  35.     print('loading mnist dataset from {} ......'.format(datafile))
  36.     # 加载json数据文件
  37.     data = json.load(gzip.open(datafile))
  38.     print('mnist dataset load done')
  40.    # 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
  41.     IMG_ROWS = 28
  42.     IMG_COLS = 28
  43.     # 读取到的数据区分训练集，验证集，测试集
  44.     #只取数据集的10%用来建模，因为本程序采用的CPU的电脑，数据集过大spyder运行太慢甚至会崩溃。
  45.     train_set, val_set, eval_set = data
  46.     if mode=='train':
  47.         # 获得训练数据集
  48.         imgs, labels = train_set[0][:5000], train_set[1][:5000]
  49.     elif mode=='valid':
  50.         # 获得验证数据集
  51.         imgs, labels = val_set[0][:1000], val_set[1][:1000]
  52.     elif mode=='eval':
  53.         # 获得测试数据集
  54.         imgs, labels = eval_set[0][:1000], eval_set[1][:1000]
  55.     else:
  56.         raise Exception("mode can only be one of ['train', 'valid', 'eval']")
  57.     print("训练数据集数量: ", len(imgs))
  59.     # 校验数据
  60.     imgs_length = len(imgs)
  62.     assert len(imgs) == len(labels), \
  63.           "length of train_imgs({}) should be the same as train_labels({})".format(len(imgs), len(label))
  65.     # 获得数据集长度
  66.     imgs_length = len(imgs)
  68.     # 定义数据集每个数据的序号，根据序号读取数据
  69.     index_list = list(range(imgs_length))
  70.     # 读入数据时用到的批次大小
  71.     BATCHSIZE = 100
  73.     # 定义数据生成器
  74.     def data_generator():
  75.         if mode == 'train':
  76.             # 训练模式下打乱数据
  77.             random.shuffle(index_list)
  78.         imgs_list = []
  79.         labels_list = []
  80.         for i in index_list:
  81.             # 将数据处理成希望的格式，比如类型为float32，shape为[1, 28, 28]
  82.             img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
  83.             label = np.reshape(labels[i], [1]).astype('int64') #在数据处理部分，需要修改标签变量Label的格式，变成int64
  84.             imgs_list.append(img) 
  85.             labels_list.append(label)
  86.             if len(imgs_list) == BATCHSIZE:
  87.                 # 获得一个batchsize的数据，并返回
  88.                 yield np.array(imgs_list), np.array(labels_list)
  89.                 # 清空数据读取列表
  90.                 imgs_list = []
  91.                 labels_list = []
  93.         # 如果剩余数据的数目小于BATCHSIZE，
  94.         # 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
  95.         if len(imgs_list) > 0:
  96.             yield np.array(imgs_list), np.array(labels_list)
  97.     return data_generator
  99. ##模型搭建##
  100. #使用卷积神经网络
  101. # 多层卷积神经网络实现
  102. class MNIST(fluid.dygraph.Layer):
  103.      def __init__(self):
  104.          super(MNIST, self).__init__()
  106.          # 定义一个卷积层，使用relu激活函数
  107.          self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  108.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  109.          self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  110.          # 定义一个卷积层，使用relu激活函数
  111.          self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  112.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  113.          self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  114.          # 定义一个全连接层，输出节点数为10 
  115.          self.fc = Linear(input_dim=980, output_dim=10, act='softmax')
  116.     # 定义网络的前向计算过程
  117.      def forward(self, inputs, label):
  118.          x = self.conv1(inputs)
  119.          x = self.pool1(x)
  120.          x = self.conv2(x)
  121.          x = self.pool2(x)
  122.          x = fluid.layers.reshape(x, [x.shape[0], 980])
  123.          x = self.fc(x)
  124.          if label is not None:
  125.              acc = fluid.layers.accuracy(input=x, label=label)
  126.              return x, acc
  127.          else:
  128.              return x
  130. ##训练模型##
  131. #形成了四种比较成熟的优化算法：SGD、Momentum、AdaGrad和Adam
  132. #仅优化算法的设置有所差别
  133. #加入正则化项，避免模型过拟合
  134. #可视化分析：使用Matplotlib库绘制损失随训练下降的曲线图
  136. # =============================================================================
  137. # #在使用GPU机器时，可以将use_gpu变量设置成True
  138. # use_gpu = True
  139. # place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
  140. # with fluid.dygraph.guard(place):
  141. # =============================================================================
  143. #调用加载数据的函数
  144. train_loader = load_data('train')
  146. with fluid.dygraph.guard():
  147.     model = MNIST()
  148.     model.train() 
  150.     #四种优化算法的设置方案，可以逐一尝试效果
  151.     #optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  152.     #optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.01, momentum=0.9, parameter_list=model.parameters())
  153.     #optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  154.     optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.001, parameter_list=model.parameters())
  156.     #各种优化算法均可以加入正则化项，避免过拟合，参数regularization_coeff调节正则化项的权重,在该程序中发现加入正则项之后，
  157.     #模型的正确率acc是降低了，在后面的模型校验中，acc从0.97降到了0.91左右，可能需要经过进一步的调参才能达到一个较好的值
  158.     #optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, regularization=fluid.regularizer.L2Decay(regularization_coeff=0.1),parameter_list=model.parameters()))
  160.     #optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.01, regularization=fluid.regularizer.L2Decay(regularization_coeff=0.1),parameter_list=model.parameters())
  162.     EPOCH_NUM =10
  163.     iter=0
  164.     iters=[]
  165.     losses=[]
  166.     acces =[]
  167.     for epoch_id in range(EPOCH_NUM):
  168.         for batch_id, data in enumerate(train_loader()):
  169.             #准备数据，变得更加简洁
  170.             image_data, label_data = data
  171.             image = fluid.dygraph.to_variable(image_data)
  172.             label = fluid.dygraph.to_variable(label_data)
  174.             #前向计算的过程，同时拿到模型输出值和分类准确率
  175.             predict, acc = model(image, label)
  177.             #计算损失，取一个批次样本损失的平均值
  178.             loss = fluid.layers.cross_entropy(predict, label)
  179.             avg_loss = fluid.layers.mean(loss)
  181.             #每训练了5批次的数据，打印下当前Loss的情况
  182.             if batch_id % 10 == 0:
  183.                 print("epoch: {}, batch: {}, loss is: {}, acc is {}".format(epoch_id, batch_id, avg_loss.numpy(), acc.numpy()))
  184.                 iters.append(iter)
  185.                 losses.append(avg_loss.numpy()) #生成损失函数的值
  186.                 acces.append(float(acc.numpy())) #生成正确率的值
  187.                 iter = iter + 10
  189.             #后向传播，更新参数的过程
  190.             avg_loss.backward()
  191.             optimizer.minimize(avg_loss)
  192.             model.clear_gradients()
  193.       #保存模型参数
  194.     fluid.save_dygraph(model.state_dict(), 'mnist')
  198. # =============================================================================
  199. # #画出训练过程中Loss的变化曲线
  200. # plt.figure()
  201. # plt.title("train loss", fontsize=24)
  202. # plt.xlabel("iter", fontsize=14)
  203. # plt.ylabel("loss", fontsize=14)
  204. # plt.plot(iters, losses,color='red',label='train loss')
  205. # plt.plot(iters, acces,color='green',label='acc')
  206. # plt.grid()
  207. # plt.legend() #显示label
  208. # plt.show()
  209. # 
  210. # =============================================================================
  213. ##模型校验##
  214. # =============================================================================
  215. # # 加入校验或测试，更好评价模型效果 
  216. # 
  217. # 在训练过程中，我们会发现模型在训练样本集上的损失在不断减小。但这是否代表模型在未来的应用场景上依然有效？为了验证模型的有效性，通常将样本集合分成三份，训练集、校验集和测试集。
  218. # 
  219. # - **训练集** ：用于训练模型的参数，即训练过程中主要完成的工作。
  220. # - **校验集** ：用于对模型超参数的选择，比如网络结构的调整、正则化项权重的选择等。
  221. # - **测试集** ：用于模拟模型在应用后的真实效果。因为测试集没有参与任何模型优化或参数训练的工作，所以它对模型来说是完全未知的样本。在不以校验数据优化网络结构或模型超参数时，校验数据和测试数据的效果是类似的，均更真实的反映模型效果。
  222. # 
  223. # 如下程序读取上一步训练保存的模型参数，读取校验数据集，并测试模型在校验数据集上的效果。
  225. with fluid.dygraph.guard():
  226.     print('start evaluation .......')
  227.     #加载模型参数
  228.     model = MNIST()
  229.     model_state_dict, _ = fluid.load_dygraph('mnist')
  230.     model.load_dict(model_state_dict)
  232.     model.eval()
  233.     eval_loader = load_data('eval')
  235.     EPOCH_NUM =5 #设置成5是因为保证eval_iters和训练集里面的iters保持一致
  236.     eval_iter =0
  237.     eval_iters =[]
  238.     eval_acc = []
  239.     eval_losses = []    
  241.     for epoch_id in range(EPOCH_NUM):
  242.         for batch_id, data in enumerate(eval_loader()):
  243.             #准备数据，变得更加简洁
  244.             x_data, y_data = data
  245.             img = fluid.dygraph.to_variable(x_data)
  246.             label = fluid.dygraph.to_variable(y_data)
  248.             #前向计算的过程，同时拿到模型输出值和分类准确率
  249.             prediction, acc = model(img, label)
  251.             #计算损失，取一个批次样本损失的平均值
  252.             loss = fluid.layers.cross_entropy(input=prediction, label=label)
  253.             avg_loss = fluid.layers.mean(loss)
  255.             print("epoch: {}, batch: {}, eval loss is: {}, eval acc is {}".format(epoch_id, batch_id, avg_loss.numpy(), acc.numpy()))
  257.             eval_iters.append(eval_iter)
  258.             eval_acc.append(float(acc.numpy()))
  259.             eval_losses.append(float(avg_loss.numpy()))
  260.             eval_iter = eval_iter + 10     #设置成+10是因为保证eval_iters和训练集里面的iters保持一致
  262.     #计算多个batch的平均损失和准确率
  263.     acc_eval_mean = np.array(eval_acc).mean()
  264.     avg_loss_eval_mean = np.array(eval_losses).mean()
  266.     print('eval_loss={}, eval_acc={}'.format(avg_loss_eval_mean, acc_eval_mean))
  269. #画出训练集和测试集上的loss和acc
  270. plt.figure()
  271. plt.title("train loss", fontsize=24)
  272. plt.xlabel("iter", fontsize=14)
  273. plt.ylabel("loss", fontsize=14)
  274. plt.plot(iters, losses,color='red',label='train loss')
  275. plt.plot(iters, acces,color='green',label='train acc')
  276. plt.plot(iters, eval_losses,color='black',label='eval loss')
  277. plt.plot(iters, eval_acc,color='blue',label='eval acc')
  278. plt.grid()
  279. plt.legend() #显示label
  280. plt.show()
  284. ##模型测试-实例##
  285. # 读取一张本地的样例图片，转变成模型输入的格式
  286. def load_image(img_path):
  287.     # 从img_path中读取图像，并转为灰度图
  288.     im = Image.open(img_path).convert('L')
  289.     im.show()
  290.     im = im.resize((28, 28), Image.ANTIALIAS)
  291.     im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
  292.     # 图像归一化
  293.     im = 1.0 - im / 255.
  294.     return im
  296. # 定义预测过程
  297. with fluid.dygraph.guard():
  298.     model = MNIST()
  299.     params_file_path = 'mnist'
  300.     #img_path = './work/example_6.jpg'
  301.     img_path = './work/3.jpg'
  302.     # 加载模型参数
  303.     model_dict, _ = fluid.load_dygraph("mnist")
  304.     model.load_dict(model_dict)
  306.     model.eval()
  307.     tensor_img = load_image(img_path)
  308.     tensor_img = fluid.dygraph.to_variable(tensor_img)
  309.     #模型反馈10个分类标签的对应概率:顺序为0-1-2-3-4-5-6-7-8-9
  310.     results= model(tensor_img,None) #需要把参数label设置为None
  311.     #取概率最大的标签作为预测输出，argsort函数返回的是数组值从小到大的索引值
  312.     lab = np.argsort(results.numpy())
  313.     print("本次预测的数字是: ", lab[0][-1])
  314.     print(lab)
  315.     print(results)

输出结果：

loading mnist dataset from ./work/mnist.json.gz ……
mnist dataset load done
训练数据集数量: 5000
epoch: 0, batch: 0, loss is: [2.4915576], acc is [0.1]
epoch: 0, batch: 10, loss is: [1.5316845], acc is [0.69]
epoch: 0, batch: 20, loss is: [0.83047193], acc is [0.8]
epoch: 0, batch: 30, loss is: [0.51821786], acc is [0.85]
epoch: 0, batch: 40, loss is: [0.48973906], acc is [0.88]
epoch: 1, batch: 0, loss is: [0.38499394], acc is [0.89]
epoch: 1, batch: 10, loss is: [0.23730269], acc is [0.92]
epoch: 1, batch: 20, loss is: [0.25574294], acc is [0.94]
epoch: 1, batch: 30, loss is: [0.27882397], acc is [0.94]
epoch: 1, batch: 40, loss is: [0.1283002], acc is [0.98]
epoch: 2, batch: 0, loss is: [0.16451116], acc is [0.95]
epoch: 2, batch: 10, loss is: [0.3827349], acc is [0.88]
epoch: 2, batch: 20, loss is: [0.20935288], acc is [0.93]
epoch: 2, batch: 30, loss is: [0.23373388], acc is [0.91]
epoch: 2, batch: 40, loss is: [0.14140654], acc is [0.93]
epoch: 3, batch: 0, loss is: [0.15643257], acc is [0.95]
epoch: 3, batch: 10, loss is: [0.13176951], acc is [0.96]
epoch: 3, batch: 20, loss is: [0.04614418], acc is [0.99]
epoch: 3, batch: 30, loss is: [0.09424598], acc is [0.96]
epoch: 3, batch: 40, loss is: [0.09168195], acc is [0.97]
epoch: 4, batch: 0, loss is: [0.02923228], acc is [0.99]
epoch: 4, batch: 10, loss is: [0.13874717], acc is [0.97]
epoch: 4, batch: 20, loss is: [0.05634639], acc is [0.98]
epoch: 4, batch: 30, loss is: [0.06768931], acc is [0.99]
epoch: 4, batch: 40, loss is: [0.03969796], acc is [1.]
epoch: 5, batch: 0, loss is: [0.07368492], acc is [0.98]
epoch: 5, batch: 10, loss is: [0.11109852], acc is [0.96]
epoch: 5, batch: 20, loss is: [0.06013503], acc is [0.99]
epoch: 5, batch: 30, loss is: [0.04761858], acc is [1.]
epoch: 5, batch: 40, loss is: [0.1447768], acc is [0.95]
epoch: 6, batch: 0, loss is: [0.05016608], acc is [0.99]
epoch: 6, batch: 10, loss is: [0.05443259], acc is [0.98]
epoch: 6, batch: 20, loss is: [0.06043101], acc is [0.98]
epoch: 6, batch: 30, loss is: [0.02192996], acc is [1.]
epoch: 6, batch: 40, loss is: [0.11689008], acc is [0.97]
epoch: 7, batch: 0, loss is: [0.0725936], acc is [0.99]
epoch: 7, batch: 10, loss is: [0.11685197], acc is [0.97]
epoch: 7, batch: 20, loss is: [0.03049235], acc is [0.99]
epoch: 7, batch: 30, loss is: [0.02428434], acc is [0.99]
epoch: 7, batch: 40, loss is: [0.03178823], acc is [1.]
epoch: 8, batch: 0, loss is: [0.06074265], acc is [0.99]
epoch: 8, batch: 10, loss is: [0.0183008], acc is [1.]
epoch: 8, batch: 20, loss is: [0.03154246], acc is [1.]
epoch: 8, batch: 30, loss is: [0.05903977], acc is [0.98]
epoch: 8, batch: 40, loss is: [0.03373271], acc is [0.99]
epoch: 9, batch: 0, loss is: [0.03680596], acc is [0.99]
epoch: 9, batch: 10, loss is: [0.02522638], acc is [0.99]
epoch: 9, batch: 20, loss is: [0.0130638], acc is [1.]
epoch: 9, batch: 30, loss is: [0.02572271], acc is [0.99]
epoch: 9, batch: 40, loss is: [0.03820073], acc is [0.99]

start evaluation …….
loading mnist dataset from ./work/mnist.json.gz ……
mnist dataset load done
训练数据集数量: 1000
epoch: 0, batch: 0, eval loss is: [0.04049644], eval acc is [0.98]
epoch: 0, batch: 1, eval loss is: [0.05177031], eval acc is [0.98]
epoch: 0, batch: 2, eval loss is: [0.11455852], eval acc is [0.96]
epoch: 0, batch: 3, eval loss is: [0.11864574], eval acc is [0.96]
epoch: 0, batch: 4, eval loss is: [0.13767797], eval acc is [0.95]
epoch: 0, batch: 5, eval loss is: [0.09025951], eval acc is [0.97]
epoch: 0, batch: 6, eval loss is: [0.15296514], eval acc is [0.96]
epoch: 0, batch: 7, eval loss is: [0.06582429], eval acc is [0.97]
epoch: 0, batch: 8, eval loss is: [0.11204186], eval acc is [0.96]
epoch: 0, batch: 9, eval loss is: [0.22585735], eval acc is [0.93]
epoch: 1, batch: 0, eval loss is: [0.04049644], eval acc is [0.98]
epoch: 1, batch: 1, eval loss is: [0.05177031], eval acc is [0.98]
epoch: 1, batch: 2, eval loss is: [0.11455852], eval acc is [0.96]
epoch: 1, batch: 3, eval loss is: [0.11864574], eval acc is [0.96]
epoch: 1, batch: 4, eval loss is: [0.13767797], eval acc is [0.95]
epoch: 1, batch: 5, eval loss is: [0.09025951], eval acc is [0.97]
epoch: 1, batch: 6, eval loss is: [0.15296514], eval acc is [0.96]
epoch: 1, batch: 7, eval loss is: [0.06582429], eval acc is [0.97]
epoch: 1, batch: 8, eval loss is: [0.11204186], eval acc is [0.96]
epoch: 1, batch: 9, eval loss is: [0.22585735], eval acc is [0.93]
epoch: 2, batch: 0, eval loss is: [0.04049644], eval acc is [0.98]
epoch: 2, batch: 1, eval loss is: [0.05177031], eval acc is [0.98]
epoch: 2, batch: 2, eval loss is: [0.11455852], eval acc is [0.96]
epoch: 2, batch: 3, eval loss is: [0.11864574], eval acc is [0.96]
epoch: 2, batch: 4, eval loss is: [0.13767797], eval acc is [0.95]
epoch: 2, batch: 5, eval loss is: [0.09025951], eval acc is [0.97]
epoch: 2, batch: 6, eval loss is: [0.15296514], eval acc is [0.96]
epoch: 2, batch: 7, eval loss is: [0.06582429], eval acc is [0.97]
epoch: 2, batch: 8, eval loss is: [0.11204186], eval acc is [0.96]
epoch: 2, batch: 9, eval loss is: [0.22585735], eval acc is [0.93]
epoch: 3, batch: 0, eval loss is: [0.04049644], eval acc is [0.98]
epoch: 3, batch: 1, eval loss is: [0.05177031], eval acc is [0.98]
epoch: 3, batch: 2, eval loss is: [0.11455852], eval acc is [0.96]
epoch: 3, batch: 3, eval loss is: [0.11864574], eval acc is [0.96]
epoch: 3, batch: 4, eval loss is: [0.13767797], eval acc is [0.95]
epoch: 3, batch: 5, eval loss is: [0.09025951], eval acc is [0.97]
epoch: 3, batch: 6, eval loss is: [0.15296514], eval acc is [0.96]
epoch: 3, batch: 7, eval loss is: [0.06582429], eval acc is [0.97]
epoch: 3, batch: 8, eval loss is: [0.11204186], eval acc is [0.96]
epoch: 3, batch: 9, eval loss is: [0.22585735], eval acc is [0.93]
epoch: 4, batch: 0, eval loss is: [0.04049644], eval acc is [0.98]
epoch: 4, batch: 1, eval loss is: [0.05177031], eval acc is [0.98]
epoch: 4, batch: 2, eval loss is: [0.11455852], eval acc is [0.96]
epoch: 4, batch: 3, eval loss is: [0.11864574], eval acc is [0.96]
epoch: 4, batch: 4, eval loss is: [0.13767797], eval acc is [0.95]
epoch: 4, batch: 5, eval loss is: [0.09025951], eval acc is [0.97]
epoch: 4, batch: 6, eval loss is: [0.15296514], eval acc is [0.96]
epoch: 4, batch: 7, eval loss is: [0.06582429], eval acc is [0.97]
epoch: 4, batch: 8, eval loss is: [0.11204186], eval acc is [0.96]
epoch: 4, batch: 9, eval loss is: [0.22585735], eval acc is [0.93]
eval_loss=0.11100971214473247, eval_acc=0.9620000004768372

image.png
本次预测的数字是: 3
[[6 1 0 7 4 8 2 9 5 3]]
name tmp_13, dtype: VarType.FP32 shape: [1, 10] lod: {}
dim: 1, 10
layout: NCHW
dtype: float
data: [0.0011202 0.000324511 0.0128064 0.846113 0.00409311 0.104269 0.000196426 0.00348324 0.0120471 0.0155469]

总结：

003 完整代码实现 - 图3