华为晟思Mindspore初体验:全场景统一式框架与函数式微分编程

华为晟思Mindspore初体验:全场景统一式框架与函数式微分编程

  • 1. Mindspore的全场景统一式框架
  • 2. Mindspore的自动微分技术(Automatic Differentiation)
  • 3. 安装与mnist数据集初步测试
  • 参考文献资料

1. Mindspore的全场景统一式框架

1.1 Mindspore的设计理念
边缘端和云端设备的协同信息处理在近年来得到了快速发展。MindSpore作为一种最近涌现的新框架,旨在提供端边云全场景的统一AI框架。MindSpore可部署于端、边、云不同的硬件环境,满足不同环境的差异化需求,如支持端侧的轻量化部署,支持云侧丰富的训练功能如自动微分、混合精度、模型易用编程等。
华为晟思Mindspore初体验:全场景统一式框架与函数式微分编程_第1张图片
1.2 MindSpore全场景的几个重要特性:

  • 端边云统一的C++推理接口,支持算法代码可快速迁移到不同硬件环境执行,如基于C++接口实现端侧训练。

  • 模型统一,端云使用相同的模型格式和定义,软件架构一致。MindSpore支持Ascend、GPU、CPU(x86、Arm)等多种硬件的执行,一次训练多处部署使用。

  • 多样化算力支持。提供统一的南向接口,支持新硬件的快捷添加使用。

  • 模型小型化技术,适配不同硬件环境和业务场景的要求,如量化压缩等。

  • 端边云协同技术的快速应用,如联邦学习、端侧训练等新技术。

2. Mindspore的自动微分技术(Automatic Differentiation)

  1. 自动微分技术
    MindSpore先构建的是基于反向模式的自动微分,并在该方法的基础上实现了正向微分。为了进一步说明前向微分与反向微分的区别,我们将被求导的原函数,对于神经网络结构中的前向与反向微分,可以写成具有N输入与M输出的函数F。对于具有N输入与M输出的函数F:
    ( Y 1 , Y 2 , . . . , Y M ) = F ( X 1 , X 2 , . . . , X N ) \left( Y_1,Y_2,...,Y_M \right) =F\left( X_1,X_2,...,X_N \right) (Y1,Y2,...,YM)=F(X1,X2,...,XN)
    函数 F()的导数可以记作一个雅可比矩阵:
    [ ∂ Y 1 ∂ X 1 . . . ∂ Y 1 ∂ X N . . . . . . . . . ∂ Y M ∂ X 1 . . . ∂ Y M ∂ X N ] \left[ \begin{matrix} \frac{\partial Y_1}{\partial X_1}& ...& \frac{\partial Y_1}{\partial X_N}\\ ...& ...& ...\\ \frac{\partial Y_M}{\partial X_1}& ...& \frac{\partial Y_M}{\partial X_N}\\ \end{matrix} \right] X1Y1...X1YM.........XNY1...XNYM
  2. 前向自动微分技术
    在Mindspore中, 微分是从输入开始向输出的方向计算的,因此每一次计算我们可以求得输出对某一输入的导数,即雅可比矩阵中的一列,如下图所示:
    [ ∂ Y 1 ∂ X 1 . . . ∂ Y M ∂ X 1 ] \left[ \begin{array}{c} \frac{\partial Y_1}{\partial X_1}\\ ...\\ \frac{\partial Y_M}{\partial X_1}\\ \end{array} \right] X1Y1...X1YM
    为了求取该列的值,自动微分将程序分解为一系列求导规则已知的基本操作,这些基本操作也可以被泛化表达为具有n输入和m输出的函数f:
    ( y 1 , y 2 , . . . , y m ) = f ( x 1 , x 2 , . . . , x n ) \left( y_1,y_2,...,y_m \right) =f\left( x_1,x_2,...,x_n \right) (y1,y2,...,ym)=f(x1,x2,...,xn)

[ ∂ Y j ∂ x 1 , . . . , ∂ Y j ∂ x N ] = [ ∂ Y j ∂ y 1 , . . . , ∂ Y j ∂ y m ] [ ∂ y 1 ∂ x 1 . . . ∂ y 1 ∂ x n . . . . . . . . . ∂ y m ∂ x 1 . . . ∂ y m ∂ x n ] \left[ \frac{\partial Y_j}{\partial x_1},...,\frac{\partial Y_j}{\partial x_N} \right] =\left[ \frac{\partial Y_j}{\partial y_1},...,\frac{\partial Y_j}{\partial y_m} \right] \left[ \begin{matrix} \frac{\partial y_1}{\partial x_1}& ...& \frac{\partial y_1}{\partial x_n}\\ ...& ...& ...\\ \frac{\partial y_m}{\partial x_1}& ...& \frac{\partial y_m}{\partial x_n}\\ \end{matrix} \right] [x1Yj,...,xNYj]=[y1Yj,...,ymYj] x1y1...x1ym.........xny1...xnym
PS: 感觉就是找了一个求导规则已知的 ( y 1 , y 2 , . . . , y m ) = f ( ) (y_1,y_2,...,y_m)=f() (y1,y2,...,ym)=f()作为中间量,完成链式求导过程。

后向自动微分技术可参见其官方文档[1]。

3. 安装与mnist数据集初步测试

3.1 安装
但遗憾的是,目前Mindspore的GPU版本只支持aarch和x86_64的linux系统,并不支持win10和mac系统。下面就以最新版的Mindspore的CPU安装流程进行演示。

  • 根据网站提示https://www.mindspore.cn/install,选择系统的python环境配置
    华为晟思Mindspore初体验:全场景统一式框架与函数式微分编程_第2张图片
  • 配置虚拟环境,避免安装包之间冲突
conda create -c conda-forge -n mindspore_py39 -c conda-forge python=3.9.0
activate mindspore_py39
  • 安装mindspore以及依赖包
conda install mindspore-cpu -c mindspore -c conda-forge
  • 验证一下是否安装成功
python -c "import mindspore;mindspore.run_check()"

确认显示对应的版本号

MindSpore version:  1.8.1
The result of multiplication calculation is correct, MindSpore has been installed successfully!

3.2 手写数字识别小栗子

import mindspore.nn as nn

class LeNet5(nn.Cell):
    """
    LeNet-5网络结构
    """
    def __init__(self, num_class=10, num_channel=1):
        super(LeNet5, self).__init__()
        # 卷积层,输入的通道数为num_channel,输出的通道数为6,卷积核大小为5*5
        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
        # 卷积层,输入的通道数为6,输出的通道数为16,卷积核大小为5*5
        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
        # 全连接层,输入个数为16*5*5,输出个数为120
        self.fc1 = nn.Dense(16 * 5 * 5, 120)
        # 全连接层,输入个数为120,输出个数为84
        self.fc2 = nn.Dense(120, 84)
        # 全连接层,输入个数为84,分类的个数为num_class
        self.fc3 = nn.Dense(84, num_class)
        # ReLU激活函数
        self.relu = nn.ReLU()
        # 池化层
        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
        # 多维数组展平为一维数组
        self.flatten = nn.Flatten()

    def construct(self, x):
        # 使用定义好的运算构建前向网络
        x = self.conv1(x)
        x = self.relu(x)
        x = self.max_pool2d(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = self.max_pool2d(x)
        x = self.flatten(x)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.relu(x)
        x = self.fc3(x)
        return x

network = LeNet5(num_class=10)

也可以直接调用LeNet封装好的套件

import mindspore as ms
from mindvision.classification.models import lenet
from mindvision.engine.callback import LossMonitor
import mindspore.nn as nn

# 数据集加载
from mindvision.dataset import Mnist

# 下载并处理MNIST数据集
download_train = Mnist(path="./mnist", split="train", batch_size=32, repeat_num=1, shuffle=True, resize=32, download=True)
download_eval = Mnist(path="./mnist", split="test", batch_size=32, resize=32, download=True)
dataset_train = download_train.run()
dataset_eval = download_eval.run()

network = lenet(num_classes=10, pretrained=False)
# 定义损失函数
net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')

# 定义优化器函数
net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)
# 设置模型保存参数,模型训练保存参数的step为1875。
config_ck = ms.CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)

# 应用模型保存参数
ckpoint = ms.ModelCheckpoint(prefix="lenet", directory="./lenet", config=config_ck)
from mindvision.engine.callback import LossMonitor
# 初始化模型参数
model = ms.Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'accuracy'})

# 训练网络模型,并保存为lenet-1_1875.ckpt文件
model.train(10, dataset_train, callbacks=[ckpoint, LossMonitor(0.01, 1875)])

训练日志如下

Epoch:[  0/ 10], step:[ 1875/ 1875], loss:[0.042/1.242], time:11.194 ms, lr:0.01000
Epoch time: 14001.060 ms, per step time: 7.467 ms, avg loss: 1.242
Epoch:[  1/ 10], step:[ 1875/ 1875], loss:[0.004/0.078], time:8.553 ms, lr:0.01000
Epoch time: 13313.048 ms, per step time: 7.100 ms, avg loss: 0.078
Epoch:[  2/ 10], step:[ 1875/ 1875], loss:[0.003/0.051], time:69.822 ms, lr:0.01000
Epoch time: 10270.547 ms, per step time: 5.478 ms, avg loss: 0.051
Epoch:[  3/ 10], step:[ 1875/ 1875], loss:[0.070/0.038], time:13.964 ms, lr:0.01000
Epoch time: 13575.390 ms, per step time: 7.240 ms, avg loss: 0.038
Epoch:[  4/ 10], step:[ 1875/ 1875], loss:[0.003/0.030], time:11.171 ms, lr:0.01000
Epoch time: 13768.840 ms, per step time: 7.343 ms, avg loss: 0.030
Epoch:[  5/ 10], step:[ 1875/ 1875], loss:[0.009/0.023], time:9.547 ms, lr:0.01000
Epoch time: 11053.256 ms, per step time: 5.895 ms, avg loss: 0.023
Epoch:[  6/ 10], step:[ 1875/ 1875], loss:[0.005/0.020], time:10.208 ms, lr:0.01000
Epoch time: 14309.251 ms, per step time: 7.632 ms, avg loss: 0.020
Epoch:[  7/ 10], step:[ 1875/ 1875], loss:[0.002/0.019], time:10.551 ms, lr:0.01000
Epoch time: 13600.133 ms, per step time: 7.253 ms, avg loss: 0.019
Epoch:[  8/ 10], step:[ 1875/ 1875], loss:[0.006/0.017], time:9.891 ms, lr:0.01000
Epoch time: 13603.114 ms, per step time: 7.255 ms, avg loss: 0.017
Epoch:[  9/ 10], step:[ 1875/ 1875], loss:[0.001/0.014], time:11.275 ms, lr:0.01000
Epoch time: 10310.747 ms, per step time: 5.499 ms, avg loss: 0.014

Process finished with exit code 0

参考文献资料

[1] Mindspore 文档
[2] https://blog.csdn.net/tiexiaorenyu/article/details/124436106
[3] https://blog.csdn.net/m0_37605642/article/details/125691987

你可能感兴趣的:(计算机视觉,-,Opencv,强化学习等的,趣味小实验,python,计算机视觉,深度学习,边缘计算,图像处理)