devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

手写数字识别之训练调试与优化_调取训练模型进行手写数字识别

作者：Gausst松鼠会 | 2024-02-16 11:25:05

赞

踩

调取训练模型进行手写数字识别

内容都是百度AIstudio的内容，我只是在这里做个笔记，不是原创。

上一节我们研究了资源部署优化的方法，通过使用单GPU和分布式部署，提升模型训练的效率。本节我们依旧横向展开"横纵式"，如 图1 所示，探讨在手写数字识别任务中，为了保证模型的真实效果，在模型训练部分，对模型进行一些调试和优化的方法。

 

训练过程优化思路主要有如下五个关键环节：

1. 计算分类准确率，观测模型训练效果。

交叉熵损失函数只能作为优化目标，无法直接准确衡量模型的训练效果。准确率可以直接衡量训练效果，但由于其离散性质，不适合做为损失函数优化神经网络。

2. 检查模型训练过程，识别潜在问题。

如果模型的损失或者评估指标表现异常，通常需要打印模型每一层的输入和输出来定位问题，分析每一层的内容来获取错误的原因。

3. 加入校验或测试，更好评价模型效果。

理想的模型训练结果是在训练集和验证集上均有较高的准确率，如果训练集上的准确率高于验证集，说明网络训练程度不够；如果验证集的准确率高于训练集，可能是发生了过拟合现象。通过在优化目标中加入正则化项的办法，解决过拟合的问题。

4. 加入正则化项，避免模型过拟合。

飞桨框架支持为整体参数加入正则化项，这是通常的做法。此外，飞桨框架也支持为某一层或某一部分的网络单独加入正则化项，以达到精细调整参数训练的效果。

5. 可视化分析。

用户不仅可以通过打印或使用matplotlib库作图，飞桨还集成了更专业的第三方绘图库tb-paddle，提供便捷的可视化分析。

 

  1. # 加载相关库
  2. import os
  3. import random
  4. import paddle
  5. import paddle.fluid as fluid
  6. from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
  7. import numpy as np
  8. from PIL import Image
  9.  
  10. import gzip
  11. import json
  12.  
  13. # 定义数据集读取器
  14. def load_data(mode='train'):
  15.  
  16.     # 读取数据文件
  17.     datafile = './work/mnist.json.gz'
  18.     print('loading mnist dataset from {} ......'.format(datafile))
  19.     data = json.load(gzip.open(datafile))
  20.     # 读取数据集中的训练集，验证集和测试集
  21.     train_set, val_set, eval_set = data
  22.  
  23.     # 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
  24.     IMG_ROWS = 28
  25.     IMG_COLS = 28
  26.     # 根据输入mode参数决定使用训练集，验证集还是测试
  27.     if mode == 'train':
  28.         imgs = train_set[0]
  29.         labels = train_set[1]
  30.     elif mode == 'valid':
  31.         imgs = val_set[0]
  32.         labels = val_set[1]
  33.     elif mode == 'eval':
  34.         imgs = eval_set[0]
  35.         labels = eval_set[1]
  36.     # 获得所有图像的数量
  37.     imgs_length = len(imgs)
  38.     # 验证图像数量和标签数量是否一致
  39.     assert len(imgs) == len(labels), \
  40.           "length of train_imgs({}) should be the same as train_labels({})".format(
  41.                   len(imgs), len(labels))
  42.  
  43.     index_list = list(range(imgs_length))
  44.  
  45.     # 读入数据时用到的batchsize
  46.     BATCHSIZE = 100
  47.  
  48.     # 定义数据生成器
  49.     def data_generator():
  50.         # 训练模式下，打乱训练数据
  51.         if mode == 'train':
  52.             random.shuffle(index_list)
  53.         imgs_list = []
  54.         labels_list = []
  55.         # 按照索引读取数据
  56.         for i in index_list:
  57.             # 读取图像和标签，转换其尺寸和类型
  58.             img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
  59.             label = np.reshape(labels[i], [1]).astype('int64')
  60.             imgs_list.append(img) 
  61.             labels_list.append(label)
  62.             # 如果当前数据缓存达到了batch size，就返回一个批次数据
  63.             if len(imgs_list) == BATCHSIZE:
  64.                 yield np.array(imgs_list), np.array(labels_list)
  65.                 # 清空数据缓存列表
  66.                 imgs_list = []
  67.                 labels_list = []
  68.  
  69.         # 如果剩余数据的数目小于BATCHSIZE，
  70.         # 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
  71.         if len(imgs_list) > 0:
  72.             yield np.array(imgs_list), np.array(labels_list)
  73.  
  74.     return data_generator
  75.  
  76.  
  77. # 定义模型结构
  78. class MNIST(fluid.dygraph.Layer):
  79.      def __init__(self):
  80.          super(MNIST, self).__init__()
  81.          
  82.          # 定义一个卷积层，使用relu激活函数
  83.          self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  84.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  85.          self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  86.          # 定义一个卷积层，使用relu激活函数
  87.          self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  88.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  89.          self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  90.          # 定义一个全连接层，输出节点数为10 
  91.          self.fc = Linear(input_dim=980, output_dim=10, act='softmax')
  92.     # 定义网络的前向计算过程
  93.      def forward(self, inputs, label=None):
  94.          x = self.conv1(inputs)
  95.          x = self.pool1(x)
  96.          x = self.conv2(x)
  97.          x = self.pool2(x)
  98.          x = fluid.layers.reshape(x, [x.shape[0], 980])
  99.          x = self.fc(x)
  100.          if label is not None:
  101.              acc = fluid.layers.accuracy(input=x, label=label)
  102.              return x, acc
  103.          else:
  104.              return x
  105.  
  106. #调用加载数据的函数
  107. train_loader = load_data('train')
  108.     
  109. #在使用GPU机器时，可以将use_gpu变量设置成True
  110. use_gpu = False
  111. place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
  112.  
  113. with fluid.dygraph.guard(place):
  114.     model = MNIST()
  115.     model.train() 
  116.     
  117.     #四种优化算法的设置方案，可以逐一尝试效果
  118.     optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  119.     #optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.01, momentum=0.9, parameter_list=model.parameters())
  120.     #optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  121.     #optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  122.     
  123.     EPOCH_NUM = 5
  124.     for epoch_id in range(EPOCH_NUM):
  125.         for batch_id, data in enumerate(train_loader()):
  126.             #准备数据
  127.             image_data, label_data = data
  128.             image = fluid.dygraph.to_variable(image_data)
  129.             label = fluid.dygraph.to_variable(label_data)
  130.             
  131.             #前向计算的过程，同时拿到模型输出值和分类准确率
  132.             predict, acc = model(image, label)
  133.             
  134.             #计算损失，取一个批次样本损失的平均值
  135.             loss = fluid.layers.cross_entropy(predict, label)
  136.             avg_loss = fluid.layers.mean(loss)
  137.             
  138.             #每训练了200批次的数据，打印下当前Loss的情况
  139.             if batch_id % 200 == 0:
  140.                 print("epoch: {}, batch: {}, loss is: {}, acc is {}".format(epoch_id, batch_id, avg_loss.numpy(), acc.numpy()))
  141.             
  142.             #后向传播，更新参数的过程
  143.             avg_loss.backward()
  144.             optimizer.minimize(avg_loss)
  145.             model.clear_gradients()
  146.  
  147.     #保存模型参数
  148.     fluid.save_dygraph(model.state_dict(), 'mnist')

在训练过程中，我们会发现模型在训练样本集上的损失在不断减小。但这是否代表模型在未来的应用场景上依然有效？为了验证模型的有效性，通常将样本集合分成三份，训练集、校验集和测试集。

  • 训练集 ：用于训练模型的参数，即训练过程中主要完成的工作。
  • 校验集 ：用于对模型超参数的选择，比如网络结构的调整、正则化项权重的选择等。
  • 测试集 ：用于模拟模型在应用后的真实效果。因为测试集没有参与任何模型优化或参数训练的工作，所以它对模型来说是完全未知的样本。在不以校验数据优化网络结构或模型超参数时，校验数据和测试数据的效果是类似的，均更真实的反映模型效果。

测试集上检验模型 

代码1

  1. with fluid.dygraph.guard():
  2.     print('start evaluation .......')
  3.     #加载模型参数
  4.     model = MNIST()
  5.     model_state_dict, _ = fluid.load_dygraph('mnist')
  6.     model.load_dict(model_state_dict)
  7.  
  8.     model.eval()
  9.     eval_loader = load_data('eval')
  10.  
  11.     acc_set = []
  12.     avg_loss_set = []
  13.     cnt=0
  14.     sum=0
  15.     for batch_id, data in enumerate(eval_loader()):
  16.         x_data, y_data = data
  17.         img = fluid.dygraph.to_variable(x_data)
  18.         label = fluid.dygraph.to_variable(y_data)
  19.         prediction= model(img)
  20.         # prediction=prediction.numpy().astype('int32')
  21.         label=label.numpy().astype('int64')
  22.         for i in range(len(label)):
  23.             # print(prediction[i],label[i])
  24.             tmp=np.argsort(prediction[i].numpy())
  25.             if(tmp[-1]==label[i]):
  26.                 # print('aaaa:',tmp[-1],label[i])
  27.                 cnt+=1
  28.         sum+=len(label)
  29.         # print(len(prediction))
  30.         # print("hello:",prediction.numpy().astype('int32'),label.numpy().astype('int32'))
  31.         # loss = fluid.layers.square_error_cost(input=prediction, label=label)
  32.         # avg_loss = fluid.layers.mean(loss)
  33.         # acc_set.append(float(acc.numpy()))
  34.         # avg_loss_set.append(float(avg_loss.numpy()))
  35.     
  36.     #计算多个batch的平均损失和准确率
  37.     # acc_val_mean = np.array(acc_set).mean()
  38.     # avg_loss_val_mean = np.array(avg_loss_set).mean()
  39.  
  40.     print("acc:",cnt/sum)
  41.     # print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))

代码2

  1. with fluid.dygraph.guard():
  2.     print('start evaluation .......')
  3.     #加载模型参数
  4.     model = MNIST()
  5.     model_state_dict, _ = fluid.load_dygraph('mnist')
  6.     model.load_dict(model_state_dict)
  7.  
  8.     model.eval()
  9.     eval_loader = load_data('eval')
  10.  
  11.     acc_set = []
  12.     avg_loss_set = []
  13.     for batch_id, data in enumerate(eval_loader()):
  14.         x_data, y_data = data
  15.         img = fluid.dygraph.to_variable(x_data)
  16.         label = fluid.dygraph.to_variable(y_data)
  17.         prediction, acc = model(img, label)
  18.         loss = fluid.layers.cross_entropy(input=prediction, label=label)
  19.         avg_loss = fluid.layers.mean(loss)
  20.         acc_set.append(float(acc.numpy()))
  21.         avg_loss_set.append(float(avg_loss.numpy()))
  22.     
  23.     #计算多个batch的平均损失和准确率
  24.     acc_val_mean = np.array(acc_set).mean()
  25.     avg_loss_val_mean = np.array(avg_loss_set).mean()
  26.  
  27.     print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))

 

单张图片预测

  1. # 读取一张本地的样例图片，转变成模型输入的格式
  2. def load_image(img_path):
  3.     # 从img_path中读取图像，并转为灰度图
  4.     im = Image.open(img_path).convert('L')
  5.     im.show()
  6.     im = im.resize((28, 28), Image.ANTIALIAS)
  7.     im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
  8.     # 图像归一化
  9.     im = 1.0 - im / 127.5
  10.     return im
  11.  
  12. # 定义预测过程
  13. with fluid.dygraph.guard():
  14.     model = MNIST()
  15.     params_file_path = 'mnist'
  16.     # img_path = './work/example_1.png'
  17.     img_p= './work/example_'
  18.     # 加载模型参数
  19.     cnt=0
  20.     model_dict, _ = fluid.load_dygraph("mnist")
  21.     model.load_dict(model_dict)
  22.     
  23.     model.eval()
  24.     for i in range(10):
  25.         img_path=img_p+str(i)+'.png'
  26.         tensor_img = load_image(img_path)
  27.         #模型反馈10个分类标签的对应概率
  28.         results = model(fluid.dygraph.to_variable(tensor_img))
  29.         #取概率最大的标签作为预测输出
  30.         lab = np.argsort(results.numpy())
  31.         # print(lab)
  32.         print("本次预测的数字是: ", lab[0][-1],i)
  33.         if(lab[0][-1]==i):
  34.             cnt+=1
  35.     print(cnt/10)

过拟合现象

对于样本量有限、但需要使用强大模型的复杂任务，模型很容易出现过拟合的表现，即在训练集上的损失小，在验证集或测试集上的损失较大，如 图2 所示。

 反之，如果模型在训练集和测试集上均损失较大，则称为欠拟合。过拟合表示模型过于敏感，学习到了训练数据中的一些误差，而这些误差并不是真实的泛化规律（可推广到测试集上的规律）。欠拟合表示模型还不够强大，还没有很好的拟合已知的训练样本，更别提测试样本了。因为欠拟合情况容易观察和解决，只要训练loss不够好，就不断使用更强大的模型即可，因此实际中我们更需要处理好过拟合的问题。

 

造成过拟合的原因是模型过于敏感，而训练数据量太少或其中的噪音太多。

如图3 所示，理想的回归模型是一条坡度较缓的抛物线，欠拟合的模型只拟合出一条直线，显然没有捕捉到真实的规律，但过拟合的模型拟合出存在很多拐点的抛物线，显然是过于敏感，也没有正确表达真实规律。

 

如图4 所示，理想的分类模型是一条半圆形的曲线，欠拟合用直线作为分类边界，显然没有捕捉到真实的边界，但过拟合的模型拟合出很扭曲的分类边界，虽然对所有的训练数据正确分类，但对一些较为个例的样本所做出的妥协，高概率不是真实的规律。

 

归结到深度学习中，假设模型也会犯错，通过分析可能会由于如下两种情况导致：

  1. 情况1：训练数据存在噪音，导致模型学到了噪音，而不是真实规律。

  2. 情况2：使用强大模型（表示空间大）的同时训练数据太少，导致在训练数据上表现良好的候选假设太多，锁定了一个“虚假正确”的假设。

对于情况1，我们使用数据清洗和修正来解决。 对于情况2，我们或者限制模型表示能力，或者收集更多的训练数据。

而清洗训练数据中的错误，或收集更多的训练数据往往是一句“正确的废话”，在任何时候我们都想获得更多更高质量的数据。在实际项目中，更快、更低成本可控制过拟合的方法，只有限制模型的表示能力。

 

正则化项

为了防止模型过拟合，在没有扩充样本量的可能下，只能降低模型的复杂度，可以通过限制参数的数量或可能取值（参数值尽量小）实现。

具体来说，在模型的优化目标（损失）中人为加入对参数规模的惩罚项。当参数越多或取值越大时，该惩罚项就越大。通过调整惩罚项的权重系数，可以使模型在“尽量减少训练损失”和“保持模型的泛化能力”之间取得平衡。泛化能力表示模型在没有见过的样本上依然有效。正则化项的存在，增加了模型在训练集上的损失。

飞桨框架支持为所有参数加上统一的正则化项，也支持为特定的参数添加正则化项。前者的实现如下代码所示，仅在优化器中设置regularization参数即可实现。使用参数regularization_coeff调节正则化项的权重，权重越大时，对模型复杂度的惩罚越高。实现代码如下所示。

 

  1. # 加载相关库
  2. import os
  3. import random
  4. import paddle
  5. import paddle.fluid as fluid
  6. from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
  7. import numpy as np
  8. from PIL import Image
  9.  
  10. import gzip
  11. import json
  12.  
  13. # 定义数据集读取器
  14. def load_data(mode='train'):
  15.  
  16.     # 读取数据文件
  17.     datafile = './work/mnist.json.gz'
  18.     print('loading mnist dataset from {} ......'.format(datafile))
  19.     data = json.load(gzip.open(datafile))
  20.     # 读取数据集中的训练集，验证集和测试集
  21.     train_set, val_set, eval_set = data
  22.  
  23.     # 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
  24.     IMG_ROWS = 28
  25.     IMG_COLS = 28
  26.     # 根据输入mode参数决定使用训练集，验证集还是测试
  27.     if mode == 'train':
  28.         imgs = train_set[0]
  29.         labels = train_set[1]
  30.     elif mode == 'valid':
  31.         imgs = val_set[0]
  32.         labels = val_set[1]
  33.     elif mode == 'eval':
  34.         imgs = eval_set[0]
  35.         labels = eval_set[1]
  36.     # 获得所有图像的数量
  37.     imgs_length = len(imgs)
  38.     # 验证图像数量和标签数量是否一致
  39.     assert len(imgs) == len(labels), \
  40.           "length of train_imgs({}) should be the same as train_labels({})".format(
  41.                   len(imgs), len(labels))
  42.  
  43.     index_list = list(range(imgs_length))
  44.  
  45.     # 读入数据时用到的batchsize
  46.     BATCHSIZE = 100
  47.  
  48.     # 定义数据生成器
  49.     def data_generator():
  50.         # 训练模式下，打乱训练数据
  51.         if mode == 'train':
  52.             random.shuffle(index_list)
  53.         imgs_list = []
  54.         labels_list = []
  55.         # 按照索引读取数据
  56.         for i in index_list:
  57.             # 读取图像和标签，转换其尺寸和类型
  58.             img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
  59.             label = np.reshape(labels[i], [1]).astype('int64')
  60.             imgs_list.append(img) 
  61.             labels_list.append(label)
  62.             # 如果当前数据缓存达到了batch size，就返回一个批次数据
  63.             if len(imgs_list) == BATCHSIZE:
  64.                 yield np.array(imgs_list), np.array(labels_list)
  65.                 # 清空数据缓存列表
  66.                 imgs_list = []
  67.                 labels_list = []
  68.  
  69.         # 如果剩余数据的数目小于BATCHSIZE，
  70.         # 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
  71.         if len(imgs_list) > 0:
  72.             yield np.array(imgs_list), np.array(labels_list)
  73.  
  74.     return data_generator
  75.  
  76.  
  77. # 定义模型结构
  78. class MNIST(fluid.dygraph.Layer):
  79.      def __init__(self):
  80.          super(MNIST, self).__init__()
  81.          
  82.          # 定义一个卷积层，使用relu激活函数
  83.          self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  84.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  85.          self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  86.          # 定义一个卷积层，使用relu激活函数
  87.          self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  88.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  89.          self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  90.          # 定义一个全连接层，输出节点数为10 
  91.          self.fc = Linear(input_dim=980, output_dim=10, act='softmax')
  92.     # 定义网络的前向计算过程
  93.      def forward(self, inputs, label=None):
  94.          x = self.conv1(inputs)
  95.          x = self.pool1(x)
  96.          x = self.conv2(x)
  97.          x = self.pool2(x)
  98.          x = fluid.layers.reshape(x, [x.shape[0], 980])
  99.          x = self.fc(x)
  100.          if label is not None:
  101.              acc = fluid.layers.accuracy(input=x, label=label)
  102.              return x, acc
  103.          else:
  104.              return x
  105.  
  106. #调用加载数据的函数
  107. train_loader = load_data('train')
  108.     
  109. #在使用GPU机器时，可以将use_gpu变量设置成True
  110. use_gpu = True
  111. place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
  112.  
  113. with fluid.dygraph.guard(place):
  114.     model = MNIST()
  115.     model.train() 
  116.     
  117.     #四种优化算法的设置方案，可以逐一尝试效果
  118.     optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  119.     #optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.01, momentum=0.9, parameter_list=model.parameters())
  120.     #optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  121.     #optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  122.     
  123.     #各种优化算法均可以加入正则化项，避免过拟合，参数regularization_coeff调节正则化项的权重
  124.     #optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, regularization=fluid.regularizer.L2Decay(regularization_coeff=0.1),parameter_list=model.parameters()))
  125.     optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.01, regularization=fluid.regularizer.L2Decay(regularization_coeff=0.1),
  126.                                               parameter_list=model.parameters())
  127.     
  128.     EPOCH_NUM = 10
  129.     for epoch_id in range(EPOCH_NUM):
  130.         for batch_id, data in enumerate(train_loader()):
  131.             #准备数据，变得更加简洁
  132.             image_data, label_data = data
  133.             image = fluid.dygraph.to_variable(image_data)
  134.             label = fluid.dygraph.to_variable(label_data)
  135.             
  136.             #前向计算的过程，同时拿到模型输出值和分类准确率
  137.             predict, acc = model(image, label)
  138.  
  139.             #计算损失，取一个批次样本损失的平均值
  140.             loss = fluid.layers.cross_entropy(predict, label)
  141.             avg_loss = fluid.layers.mean(loss)
  142.             
  143.             #每训练了100批次的数据，打印下当前Loss的情况
  144.             if batch_id % 100 == 0:
  145.                 print("epoch: {}, batch: {}, loss is: {}, acc is {}".format(epoch_id, batch_id, avg_loss.numpy(), acc.numpy()))
  146.             
  147.             #后向传播，更新参数的过程
  148.             avg_loss.backward()
  149.             optimizer.minimize(avg_loss)
  150.             model.clear_gradients()
  151.  
  152.     #保存模型参数
  153.     fluid.save_dygraph(model.state_dict(), 'mnist')

可视化分析

训练模型时，经常需要观察模型的评价指标，分析模型的优化过程，以确保训练是有效的。可视化分析有两种工具：Matplotlib库和tb-paddle。

  • Matplotlib库：Matplotlib库是Python中使用的最多的2D图形绘图库，它有一套完全仿照MATLAB的函数形式的绘图接口，使用轻量级的PLT库（Matplotlib）作图是非常简单的。
  • tb-paddle：如果期望使用更加专业的作图工具，可以尝试tb-paddle。tb-paddle能够有效地展示飞桨框架在运行过程中的计算图、各种指标随着时间的变化趋势以及训练中使用到的数据信息。

 使用Matplotlib库绘制损失随训练下降的曲线图

  1. # 加载相关库
  2. import os
  3. import random
  4. import paddle
  5. import paddle.fluid as fluid
  6. from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
  7. #引入matplotlib库
  8. import matplotlib.pyplot as plt
  9. import numpy as np
  10. from PIL import Image
  11.  
  12. import gzip
  13. import json
  14.  
  15. # 定义数据集读取器
  16. def load_data(mode='train'):
  17.  
  18.     # 读取数据文件
  19.     datafile = './work/mnist.json.gz'
  20.     print('loading mnist dataset from {} ......'.format(datafile))
  21.     data = json.load(gzip.open(datafile))
  22.     # 读取数据集中的训练集，验证集和测试集
  23.     train_set, val_set, eval_set = data
  24.  
  25.     # 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
  26.     IMG_ROWS = 28
  27.     IMG_COLS = 28
  28.     # 根据输入mode参数决定使用训练集，验证集还是测试
  29.     if mode == 'train':
  30.         imgs = train_set[0]
  31.         labels = train_set[1]
  32.     elif mode == 'valid':
  33.         imgs = val_set[0]
  34.         labels = val_set[1]
  35.     elif mode == 'eval':
  36.         imgs = eval_set[0]
  37.         labels = eval_set[1]
  38.     # 获得所有图像的数量
  39.     imgs_length = len(imgs)
  40.     # 验证图像数量和标签数量是否一致
  41.     assert len(imgs) == len(labels), \
  42.           "length of train_imgs({}) should be the same as train_labels({})".format(
  43.                   len(imgs), len(labels))
  44.  
  45.     index_list = list(range(imgs_length))
  46.  
  47.     # 读入数据时用到的batchsize
  48.     BATCHSIZE = 100
  49.  
  50.     # 定义数据生成器
  51.     def data_generator():
  52.         # 训练模式下，打乱训练数据
  53.         if mode == 'train':
  54.             random.shuffle(index_list)
  55.         imgs_list = []
  56.         labels_list = []
  57.         # 按照索引读取数据
  58.         for i in index_list:
  59.             # 读取图像和标签，转换其尺寸和类型
  60.             img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
  61.             label = np.reshape(labels[i], [1]).astype('int64')
  62.             imgs_list.append(img) 
  63.             labels_list.append(label)
  64.             # 如果当前数据缓存达到了batch size，就返回一个批次数据
  65.             if len(imgs_list) == BATCHSIZE:
  66.                 yield np.array(imgs_list), np.array(labels_list)
  67.                 # 清空数据缓存列表
  68.                 imgs_list = []
  69.                 labels_list = []
  70.  
  71.         # 如果剩余数据的数目小于BATCHSIZE，
  72.         # 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
  73.         if len(imgs_list) > 0:
  74.             yield np.array(imgs_list), np.array(labels_list)
  75.  
  76.     return data_generator
  77.  
  78.  
  79. # 定义模型结构
  80. class MNIST(fluid.dygraph.Layer):
  81.      def __init__(self):
  82.          super(MNIST, self).__init__()
  83.          
  84.          # 定义一个卷积层，使用relu激活函数
  85.          self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  86.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  87.          self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  88.          # 定义一个卷积层，使用relu激活函数
  89.          self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  90.          # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
  91.          self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  92.          # 定义一个全连接层，输出节点数为10 
  93.          self.fc = Linear(input_dim=980, output_dim=10, act='softmax')
  94.     # 定义网络的前向计算过程
  95.      def forward(self, inputs, label=None):
  96.          x = self.conv1(inputs)
  97.          x = self.pool1(x)
  98.          x = self.conv2(x)
  99.          x = self.pool2(x)
  100.          x = fluid.layers.reshape(x, [x.shape[0], 980])
  101.          x = self.fc(x)
  102.          if label is not None:
  103.              acc = fluid.layers.accuracy(input=x, label=label)
  104.              return x, acc
  105.          else:
  106.              return x
  107.  
  108. #调用加载数据的函数
  109. train_loader = load_data('train')
  110.     
  111. #在使用GPU机器时，可以将use_gpu变量设置成True
  112. use_gpu = True
  113. place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
  114.  
  115. with fluid.dygraph.guard(place):
  116.     model = MNIST()
  117.     model.train() 
  118.     
  119.     #四种优化算法的设置方案，可以逐一尝试效果
  120.     optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  121.     
  122.     EPOCH_NUM = 10
  123.     iter=0
  124.     iters=[]
  125.     losses=[]
  126.     for epoch_id in range(EPOCH_NUM):
  127.         for batch_id, data in enumerate(train_loader()):
  128.             #准备数据，变得更加简洁
  129.             image_data, label_data = data
  130.             image = fluid.dygraph.to_variable(image_data)
  131.             label = fluid.dygraph.to_variable(label_data)
  132.             
  133.             #前向计算的过程，同时拿到模型输出值和分类准确率
  134.             predict, acc = model(image, label)
  135.  
  136.             #计算损失，取一个批次样本损失的平均值
  137.             loss = fluid.layers.cross_entropy(predict, label)
  138.             avg_loss = fluid.layers.mean(loss)
  139.             
  140.             #每训练了100批次的数据，打印下当前Loss的情况
  141.             if batch_id % 100 == 0:
  142.                 print("epoch: {}, batch: {}, loss is: {}, acc is {}".format(epoch_id, batch_id, avg_loss.numpy(), acc.numpy()))
  143.                 iters.append(iter)
  144.                 losses.append(avg_loss.numpy())
  145.                 iter = iter + 100
  146.  
  147.             #后向传播，更新参数的过程
  148.             avg_loss.backward()
  149.             optimizer.minimize(avg_loss)
  150.             model.clear_gradients()
  151.  
  152.     #保存模型参数
  153.     fluid.save_dygraph(model.state_dict(), 'mnist')

 

  1. #画出训练过程中Loss的变化曲线
  2. plt.figure()
  3. plt.title("train loss", fontsize=24)
  4. plt.xlabel("iter", fontsize=14)
  5. plt.ylabel("loss", fontsize=14)
  6. plt.plot(iters, losses,color='red',label='train loss') 
  7. plt.grid()
  8. plt.show()

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/92692
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号