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

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

1.1 Mindspore的设计理念
边缘端和云端设备的协同信息处理在近年来得到了快速发展。MindSpore作为一种最近涌现的新框架，旨在提供端边云全场景的统一AI框架。MindSpore可部署于端、边、云不同的硬件环境，满足不同环境的差异化需求，如支持端侧的轻量化部署，支持云侧丰富的训练功能如自动微分、混合精度、模型易用编程等。

1.2 MindSpore全场景的几个重要特性：

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

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

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

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

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

2. Mindspore的自动微分技术（Automatic Differentiation）

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

$$\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{array}{ccc}\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{array}\right]$$
PS: 感觉就是找了一个求导规则已知的$(y_1,y_2,...,y_m)=f()$作为中间量，完成链式求导过程。

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

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

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

• 根据网站提示https://www.mindspore.cn/install，选择系统的python环境配置
  
• 配置虚拟环境，避免安装包之间冲突

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