案例实践----从感知机到卷积神经网络(mindspore)

swl.乌鸦

已于 2022-07-29 14:54:11 修改

阅读量817

点赞数 2

分类专栏：深度学习文章标签：深度学习 python

于 2022-07-11 17:24:00 首次发布

本文链接：https://blog.csdn.net/lwsc_/article/details/125713076

版权

深度学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

前言

本实践案例参考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)