目录
前言
本实践案例参考https://developer.huaweicloud.com/develop/aigallery/course.html进行的总结。
实践内容：基于华为深度学习MindSpore框架，搭建具有三层隐藏层的卷积神经网络，利用MNIST数据集训练。
代码实践
数据集加载与预处理
import os
import sys
import moxing as mox #华为云深度学习模型开发API----moxing
"""数据集存放到指定位置"""
datasets_dir = '../datasets'
if not os.path.exists(datasets_dir):
os.makedirs(datasets_dir)
if not os.path.exists(os.path.join(datasets_dir, 'MNIST_Data.zip')):
mox.file.copy('obs://modelarts-labs-bj4-v2/course/hwc_edu/python_module_framework/datasets/mindspore_data/MNIST_Data.zip',
os.path.join(datasets_dir, 'MNIST_Data.zip')) #将数据集压缩文件从公共桶里复制到指定路径
os.system('cd %s; unzip MNIST_Data.zip' % (datasets_dir)) #解压
sys.path.insert(0, os.path.join(os.getcwd(), '../datasets/MNIST_Data')) #添加路径
from load_data_all import load_data_all
from process_dataset import process_dataset
mnist_ds_train, mnist_ds_test, train_len, test_len = load_data_all(datasets_dir) # 加载数据集
mnist_ds_train = process_dataset(mnist_ds_train, batch_size= 60000) # 处理训练集
mnist_ds_test = process_dataset(mnist_ds_test, batch_size= 10000) # 处理测试集?下面是我实践过程中个别代码指令的理解
- ?moxing---MoXing是华为云深度学习服务提供的网络模型开发API。相对于TensorFlow和MXNet等原生API而言，MoXing API让模型的代码编写更加简单，而且能够自动获取高性能的分布式执行能力。(参考：http://t.csdn.cn/dO5Yh)
- 其中加载数据集load_data_all和处理数据集process_dataset详见https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9tb2RlbGFydHMtbGFicy1iajQtdjIub2JzLmNuLW5vcnRoLTQubXlodWF3ZWljbG91ZC5jb20vY291cnNlL21pbmRzcG9yZS9tbmlzdF9yZWNvZ25pdGlvbi81LmJpbmFyeTJ0ZW4uaXB5bmI=
?构建神经网络和评价函数
import mindspore
import mindspore.nn as nn
import mindspore.ops as ops
from mindspore.common.initializer import Normal
class Network(nn.Cell):
"""
该网络只有三层网络，分别是卷积层1、卷积层2和全连接层1，ReLU和MaxPool2d由于不带参数，所以不计入网络层数
"""
"""定义好卷积层、全连接层以及激活函数和最大池化层"""
def __init__(self, num_of_weights): #初始化权重
super(Network, self).__init__()
# Convolution 1
self.conv1 = nn.Conv2d(in_channels=1, out_channels=16,
kernel_size=5, pad_mode='valid',
stride=1, padding=0) # 卷积层1，输入为1个通道，输出为16个通道，卷积核大小为5，滑动步长为1，不做边缘填充
# Convolution 2
self.conv2 = nn.Conv2d(in_channels=16, out_channels=32,
kernel_size=5, pad_mode='valid',
stride=1, padding=0) # 卷积层2，输入为16个通道，输出为32个通道，卷积核大小为5，滑动步长为1，不做边缘填充
# Fully connected
self.fc = nn.Dense(32 * 4 * 4, 10, weight_init= Normal(0.02)) # 全连接层1，输入维度为32*4*4，输出维度为10
self.relu = nn.ReLU() # 激活层，使用卷积网络中最常用的ReLU激活函数
self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2) # 最大池化层
self.flatten = nn.Flatten()
def construct(self, x):
"""
构建前向传播函数
"""
# Convolution 1
out = self.conv1(x) # 卷积 28*28*1--->24*24*16
out = self.relu(out) # 激活
out = self.maxpool(out) # 池化 24*24*16--->12*12*16
# Convolution 2
out = self.conv2(out) # 卷积 12*12*16--->8*8*32
out = self.relu(out) # 激活
out = self.maxpool(out) # 池化 8*8*32--->4*4*32
# Fully connected 1
# out = out.view(out.size(0), -1) # 输入到全连接层之前需要将32个4*4大小的特性矩阵拉成一个一维向量
out = self.flatten(out)
out = self.fc(out) # 计算全连接层
return out
def evaluate(pred_y, true_y):
pred_labels = ops.Argmax(output_type=mindspore.int32)(pred_y) #ops.Argmax---返回张量沿轴的最大值
correct_num = (pred_labels == true_y).asnumpy().sum().item() #item()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回
return correct_num??下面是我实践过程中个别代码指令的理解
- ?def __init__(self, num_of_weights)----参数 num_of_weights是输入图像的大小，如28*28
- 关于最后到全连接层时的输入维度为什么是32*4*4，可结合下图的计算公式见代码注释的计算过程。（详细参考MindSpore官网:https://www.mindspore.cn/docs/api/zh-CN/r1.6/api_python/nn/mindspore.nn.Conv2d.html?highlight=conv#mindspore.nn.Conv2d）
?[注]最大池化层也会改变图像大小，不会改变通道数
- 在评价函数中，第一步先从最终训练输出的10个分数中取最大值即为预测结果；第二步，记录正确的预测数量，并返回。
定义交叉熵损失函数和优化器?
#损失函数
net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
#实例化网络和设置一些超参数-学习率和动量
network = Network(28*28)
lr = 0.01
momentum = 0.9
# 优化器
net_opt = nn.Momentum(network.trainable_params(), lr, momentum)训练脚本?
def train(network, mnist_ds_train, max_epoch = 50):
net = WithLossCell(network,net_loss) #将网络结构和损失函数包装起来
net = TrainOneStepCell(net, net_opt) #将网络结构和优化器包装起来
network.set_train() #设置神经网络为训练模式
for epoch in range(1, max_epoch + 1):
train_correct_num = 0.0
test_correct_num = 0.0
"""训练集"""
for inputs_train in mnist_ds_train:
output = net(*inputs_train)
train_x = inputs_train[0] #图片数据
train_y = inputs_train[1] #标签数据
pred_y_train = network.construct(train_x) # 前向传播
train_correct_num += evaluate(pred_y_train, train_y)
train_acc = float(train_correct_num) / train_len #利用正确的预测数比上整个输入数据数即准确率
"""测试集"""
for inputs_test in mnist_ds_test:
test_x = inputs_test[0]
test_y = inputs_test[1]
pred_y_test = network.construct(test_x)
test_correct_num += evaluate(pred_y_test, test_y)
test_acc = float(test_correct_num) / test_len
if(epoch == 1) or (epoch % 10 == 0):
print("epoch: {0}/{1}, train_losses: {2:.4f}, tain_acc: {3:.4f}, test_acc: {4:.4f}".format(epoch, max_epochs, output.asnumpy(), train_acc, test_acc, cflush=True))
??下面是我实践过程中个别代码指令的理解
- WithLossCell和TrainOneStepCell将网络结构同损失函数和优化器包装起来。详细参数课参考MindSpore官网搜索相应API
- network.set_train() 一般都会写上的语句，在开始训练前将神经网络设置为训练模式。
配置运行信息?
from mindspore import context
context.set_context(mode=context.GRAPH_MODE, device_target="GPU") # 当选择GPU时mindspore规格也需要切换到GPU?一般需要改的参数就是设备的规格即CPU还是GPU或者Ascend。
开始训练?
import time
from mindspore.nn import WithLossCell, TrainOneStepCell
max_epochs = 100
start_time = time.time()
print("*"*10 + "开始训练" + "*"*10)
train(network, mnist_ds_train, max_epoch= max_epochs)
print("*"*10 + "训练完成" + "*"*10)
cost_time = round(time.time() - start_time, 1)
print("训练总耗时： %.1f s" % cost_time)训练结果?
?可见准确率仅仅为59%左右，要想提高准确率，我又尝试提高训练轮次，在此基础上又增加了200轮次即共300轮次，最终准确率提高至94%左右，如下图：
?当学习率改为0.02，训练轮次为100轮时，正确率会先升高再降低，正确率不高，但比学习率为0.01训练100轮次的速度快：
?其实可以尝试多个参数，实践可跳转华为AI Galleryhttps://developer.huaweicloud.com/develop/aigallery/course.html