基本介绍
本节将会整体介绍昇思MindSpore和华为昇腾AI全栈,并介绍昇思MindSpore在华为昇腾AI全栈中的位置。对昇思MindSpore感兴趣的开发者,最后可以参与昇思MindSpore的社区并一键三连(Watch/Star/Fork)。
昇思MindSpore介绍
昇思MindSpore是一个全场景深度学习框架,旨在实现易开发、高效执行、全场景统一部署三大目标。
其中,易开发表现为API友好、调试难度低;高效执行包括计算效率、数据预处理效率和分布式训练效率;全场景则指框架同时支持云、边缘以及端侧场景。
昇思MindSpore总体架构如下图所示:
- ModelZoo(模型库):ModelZoo提供可用的深度学习算法网络,也欢迎更多开发者贡献新的网络(ModelZoo地址)。
- MindSpore Extend(扩展库):昇思MindSpore的领域扩展库,支持拓展新领域场景,如GNN/深度概率编程/强化学习等,期待更多开发者来一起贡献和构建。
- MindSpore Science(科学计算):MindScience是基于昇思MindSpore融合架构打造的科学计算行业套件,包含了业界领先的数据集、基础模型、预置高精度模型和前后处理工具,加速了科学行业应用开发。
- MindExpression(全场景统一API):基于Python的前端表达与编程接口,支持两个融合(函数/OOP编程范式融合、AI+数值计算表达融合)以及两个统一(动静表达统一、单机分布式表达统一)。
- 第三方前端:支持第三方多语言前端表达,未来计划陆续提供C/C++等第三方前端的对接工作,引入更多的第三方生态。
- MindSpore Data(数据处理层):提供高效的数据处理、常用数据集加载等功能和编程接口,支持用户灵活地定义处理注册和pipeline并行优化。
- MindCompiler(AI编译器):图层的核心编译器,主要基于端云统一的MindIR实现三大功能,包括硬件无关的优化(类型推导、自动微分、表达式化简等)、硬件相关优化(自动并行、内存优化、图算融合、流水线执行等)、部署推理相关的优化(量化、剪枝等)。
- MindRT(全场景运行时):昇思MindSpore的运行时系统,包含云侧主机侧运行时系统、端侧以及更小IoT的轻量化运行时系统。
- MindSpore Insight(可视化调试调优工具):昇思MindSpore的可视化调试调优工具,能够可视化地查看训练过程、优化模型性能、调试精度问题、解释推理结果(了解更多)。
- MindSpore Armour(安全增强库):面向企业级运用时,安全与隐私保护相关增强功能,如对抗鲁棒性、模型安全测试、差分隐私训练、隐私泄露风险评估、数据漂移检测等技术(了解更多)。
执行流程
有了对昇思MindSpore总体架构的了解后,我们可以看看各个模块之间的整体配合关系,具体如图所示:
昇思MindSpore作为全场景AI框架,所支持的有端(手机与IOT设备)、边(基站与路由设备)、云(服务器)场景的不同系列硬件,包括昇腾系列产品、英伟达NVIDIA系列产品、Arm系列的高通骁龙、华为麒麟的芯片等系列产品。
左边蓝色方框的是MindSpore主体框架,主要提供神经网络在训练、验证过程中相关的基础API功能,另外还会默认提供自动微分、自动并行等功能。
蓝色方框往下是MindSpore Data模块,可以利用该模块进行数据预处理,包括数据采样、数据迭代、数据格式转换等不同的数据操作。在训练的过程会遇到很多调试调优的问题,因此有MindSpore Insight模块对loss曲线、算子执行情况、权重参数变量等调试调优相关的数据进行可视化,方便用户在训练过程中进行调试调优。
AI安全最简单的场景就是从攻防的视角来看,例如,攻击者在训练阶段掺入恶意数据,影响AI模型推理能力,于是MindSpore推出了MindSpore Armour模块,为MindSpore提供AI安全机制。
蓝色方框往上的内容跟算法开发相关的用户更加贴近,包括存放大量的AI算法模型库ModelZoo,提供面向不同领域的开发工具套件MindSpore DevKit,另外还有高阶拓展库MindSpore Extend,这里面值得一提的就是MindSpore Extend中的科学计算套件MindSciences,MindSpore首次探索将科学计算与深度学习结合,将数值计算与深度学习相结合,通过深度学习来支持电磁仿真、药物分子仿真等等。
神经网络模型训练完后,可以导出模型或者加载存放在MindSpore Hub中已经训练好的模型。接着有MindIR提供端云统一的IR格式,通过统一IR定义了网络的逻辑结构和算子的属性,将MindIR格式的模型文件 与硬件平台解耦,实现一次训练多次部署。因此如图所示,通过IR把模型导出到不同的模块执行推理。
设计理念
-
支持全场景统一部署
昇思MindSpore源于全产业的最佳实践,向数据科学家和算法工程师提供了统一的模型训练、推理和导出等接口,支持端、边、云等不同场景下的灵活部署,推动深度学习和科学计算等领域繁荣发展。
-
提供Python编程范式,简化AI编程
昇思MindSpore提供了Python编程范式,用户使用Python原生控制逻辑即可构建复杂的神经网络模型,AI编程变得简单。
-
提供动态图和静态图统一的编码方式
目前主流的深度学习框架的执行模式有两种,分别为静态图模式和动态图模式。静态图模式拥有较高的训练性能,但难以调试。动态图模式相较于静态图模式虽然易于调试,但难以高效执行。 昇思MindSpore提供了动态图和静态图统一的编码方式,大大增加了静态图和动态图的可兼容性,用户无需开发多套代码,仅变更一行代码便可切换动态图/静态图模式,用户可拥有更轻松的开发调试及性能体验。例如:
设置
set_context(mode=PYNATIVE_MODE)
可切换成动态图模式。设置
set_context(mode=GRAPH_MODE)
可切换成静态图模式。 -
采用AI和科学计算融合编程,使用户聚焦于模型算法的数学原生表达
在友好支持AI模型训练推理编程的基础上,扩展支持灵活自动微分编程能力,支持对函数、控制流表达情况下的微分求导和各种如正向微分、高阶微分等高级微分能力的支持,用户可基于此实现科学计算常用的微分函数编程表达,从而支持AI和科学计算融合编程开发。
-
分布式训练原生
随着神经网络模型和数据集的规模不断增大,分布式并行训练成为了神经网络训练的常见做法,但分布式并行训练的策略选择和编写十分复杂,这严重制约着深度学习模型的训练效率,阻碍深度学习的发展。MindSpore统一了单机和分布式训练的编码方式,开发者无需编写复杂的分布式策略,在单机代码中添加少量代码即可实现分布式训练,提高神经网络训练效率,大大降低了AI开发门槛,使用户能够快速实现想要的模型。
例如设置
set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL)
便可自动建立代价模型,为用户选择一种较优的并行模式。
层次结构
昇思MindSpore向用户提供了3个不同层次的API,支撑用户进行AI应用(算法/模型)开发,从高到低分别为High-Level Python API、Medium-Level Python API以及Low-Level Python API。高阶API提供了更好的封装性,低阶API提供更好的灵活性,中阶API兼顾灵活及封装,满足不同领域和层次的开发者需求。
-
High-Level Python API
第一层为高阶API,其在中阶API的基础上又提供了训练推理的管理、混合精度训练、调试调优等高级接口,方便用户控制整网的执行流程和实现神经网络的训练推理及调优。例如用户使用Model接口,指定要训练的神经网络模型和相关的训练设置,对神经网络模型进行训练。
-
Medium-Level Python API
第二层为中阶API,其封装了低阶API,提供网络层、优化器、损失函数等模块,用户可通过中阶API灵活构建神经网络和控制执行流程,快速实现模型算法逻辑。例如用户可调用Cell接口构建神经网络模型和计算逻辑,通过使用Loss模块和Optimizer接口为神经网络模型添加损失函数和优化方式,利用Dataset模块对数据进行处理以供模型的训练和推导使用。
-
Low-Level Python API
第三层为低阶API,主要包括张量定义、基础算子、自动微分等模块,用户可使用低阶API轻松实现张量定义和求导计算。例如用户可通过Tensor接口自定义张量,使用grad接口计算函数在指定处的导数。
华为昇腾AI全栈介绍
昇腾计算,是基于昇腾系列处理器构建的全栈AI计算基础设施及应用,包括昇腾Ascend系列芯片、Atlas系列硬件、CANN芯片使能、MindSpore AI框架、ModelArts、MindX应用使能等。
华为Atlas人工智能计算解决方案,是基于昇腾系列AI处理器,通过模块、板卡、小站、服务器、集群等丰富的产品形态,打造面向“端、边、云”的全场景AI基础设施方案,涵盖数据中心解决方案、智能边缘解决方案,覆盖深度学习领域推理和训练全流程。
昇腾AI全栈如下图所示:
下面简单介绍每个模块的作用:
- 昇腾应用使能:华为各大产品线基于MindSpore提供的AI平台或服务能力
- MindSpore:支持端、边、云独立的和协同的统一训练和推理框架
- CANN:昇腾芯片使能、驱动层(了解更多)。
- 计算资源:昇腾系列化IP、芯片和服务器
详细信息请点击华为昇腾官网。
以上基本介绍摘录自官方网站,整体来说解释得还是比较详细的。废话不多说,动手来看看吧。
快速入门
本节通过MindSpore的API来快速实现一个简单的深度学习模型。若想要深入了解MindSpore的使用方法,请参阅各节最后提供的参考链接。
import mindspore
from mindspore import nn
from mindspore.dataset import vision, transforms
from mindspore.dataset import MnistDataset
处理数据集
MindSpore提供基于Pipeline的数据引擎,通过数据集(Dataset)和数据变换(Transforms)实现高效的数据预处理。在本教程中,我们使用Mnist数据集,自动下载完成后,使用mindspore.dataset
提供的数据变换进行预处理。
本章节中的示例代码依赖
download
,可使用命令pip install download
安装。如本文档以Notebook运行时,完成安装后需要重启kernel才能执行后续代码。
# Download data from open datasets
from download import download
url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/" \
"notebook/datasets/MNIST_Data.zip"
path = download(url, "./", kind="zip", replace=True)
Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip (10.3 MB) file_sizes: 100%|██████████████████████████| 10.8M/10.8M [00:01<00:00, 6.73MB/s] Extracting zip file... Successfully downloaded / unzipped to ./
MNIST数据集目录结构如下:
MNIST_Data └── train ├── train-images-idx3-ubyte (60000个训练图片) ├── train-labels-idx1-ubyte (60000个训练标签) └── test ├── t10k-images-idx3-ubyte (10000个测试图片) ├── t10k-labels-idx1-ubyte (10000个测试标签)
数据下载完成后,获得数据集对象。
train_dataset = MnistDataset('MNIST_Data/train')
test_dataset = MnistDataset('MNIST_Data/test')
打印数据集中包含的数据列名,用于dataset的预处理。
print(train_dataset.get_col_names())
['image', 'label']
MindSpore的dataset使用数据处理流水线(Data Processing Pipeline),需指定map、batch、shuffle等操作。这里我们使用map对图像数据及标签进行变换处理,将输入的图像缩放为1/255,根据均值0.1307和标准差值0.3081进行归一化处理,然后将处理好的数据集打包为大小为64的batch。
def datapipe(dataset, batch_size):
image_transforms = [
vision.Rescale(1.0 / 255.0, 0),
vision.Normalize(mean=(0.1307,), std=(0.3081,)),
vision.HWC2CHW()
]
label_transform = transforms.TypeCast(mindspore.int32)
dataset = dataset.map(image_transforms, 'image')
dataset = dataset.map(label_transform, 'label')
dataset = dataset.batch(batch_size)
return dataset
# Map vision transforms and batch dataset
train_dataset = datapipe(train_dataset, 64)
test_dataset = datapipe(test_dataset, 64)
使用create_tuple_iterator 或create_dict_iterator对数据集进行迭代访问,查看数据和标签的shape和datatype。
for image, label in test_dataset.create_tuple_iterator():
print(f"Shape of image [N, C, H, W]: {image.shape} {image.dtype}")
print(f"Shape of label: {label.shape} {label.dtype}")
break
Shape of image [N, C, H, W]: (64, 1, 28, 28) Float32 Shape of label: (64,) Int32
for data in test_dataset.create_dict_iterator():
print(f"Shape of image [N, C, H, W]: {data['image'].shape} {data['image'].dtype}")
print(f"Shape of label: {data['label'].shape} {data['label'].dtype}")
break
Shape of image [N, C, H, W]: (64, 1, 28, 28) Float32 Shape of label: (64,) Int32
更多细节详见数据集 Dataset与数据变换 Transforms。
网络构建
mindspore.nn
类是构建所有网络的基类,也是网络的基本单元。当用户需要自定义网络时,可以继承nn.Cell
类,并重写__init__
方法和construct
方法。__init__
包含所有网络层的定义,construct
中包含数据(Tensor)的变换过程。
# Define model
class Network(nn.Cell):
def __init__(self):
super().__init__()
self.flatten = nn.Flatten()
self.dense_relu_sequential = nn.SequentialCell(
nn.Dense(28*28, 512),
nn.ReLU(),
nn.Dense(512, 512),
nn.ReLU(),
nn.Dense(512, 10)
)
def construct(self, x):
x = self.flatten(x)
logits = self.dense_relu_sequential(x)
return logits
model = Network()
print(model)
Network< (flatten): Flatten<> (dense_relu_sequential): SequentialCell< (0): Dense<input_channels=784, output_channels=512, has_bias=True> (1): ReLU<> (2): Dense<input_channels=512, output_channels=512, has_bias=True> (3): ReLU<> (4): Dense<input_channels=512, output_channels=10, has_bias=True> > >
更多细节详见网络构建。
模型训练
在模型训练中,一个完整的训练过程(step)需要实现以下三步:
- 正向计算:模型预测结果(logits),并与正确标签(label)求预测损失(loss)。
- 反向传播:利用自动微分机制,自动求模型参数(parameters)对于loss的梯度(gradients)。
- 参数优化:将梯度更新到参数上。
MindSpore使用函数式自动微分机制,因此针对上述步骤需要实现:
- 定义正向计算函数。
- 使用value_and_grad通过函数变换获得梯度计算函数。
- 定义训练函数,使用set_train设置为训练模式,执行正向计算、反向传播和参数优化。
# Instantiate loss function and optimizer
loss_fn = nn.CrossEntropyLoss()
optimizer = nn.SGD(model.trainable_params(), 1e-2)
# 1. Define forward function
def forward_fn(data, label):
logits = model(data)
loss = loss_fn(logits, label)
return loss, logits
# 2. Get gradient function
grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
# 3. Define function of one-step training
def train_step(data, label):
(loss, _), grads = grad_fn(data, label)
optimizer(grads)
return loss
def train(model, dataset):
size = dataset.get_dataset_size()
model.set_train()
for batch, (data, label) in enumerate(dataset.create_tuple_iterator()):
loss = train_step(data, label)
if batch % 100 == 0:
loss, current = loss.asnumpy(), batch
print(f"loss: {loss:>7f} [{current:>3d}/{size:>3d}]")
除训练外,我们定义测试函数,用来评估模型的性能。
def test(model, dataset, loss_fn):
num_batches = dataset.get_dataset_size()
model.set_train(False)
total, test_loss, correct = 0, 0, 0
for data, label in dataset.create_tuple_iterator():
pred = model(data)
total += len(data)
test_loss += loss_fn(pred, label).asnumpy()
correct += (pred.argmax(1) == label).asnumpy().sum()
test_loss /= num_batches
correct /= total
print(f"Test: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
训练过程需多次迭代数据集,一次完整的迭代称为一轮(epoch)。在每一轮,遍历训练集进行训练,结束后使用测试集进行预测。打印每一轮的loss值和预测准确率(Accuracy),可以看到loss在不断下降,Accuracy在不断提高。
epochs = 3
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
train(model, train_dataset)
test(model, test_dataset, loss_fn)
print("Done!")
Epoch 1 ------------------------------- loss: 2.302088 [ 0/938] loss: 2.290692 [100/938] loss: 2.266338 [200/938] loss: 2.205240 [300/938] loss: 1.907198 [400/938] loss: 1.455603 [500/938] loss: 0.861103 [600/938] loss: 0.767219 [700/938] loss: 0.422253 [800/938] loss: 0.513922 [900/938] Test: Accuracy: 83.8%, Avg loss: 0.529534 Epoch 2 ------------------------------- loss: 0.580867 [ 0/938] loss: 0.479347 [100/938] loss: 0.677991 [200/938] loss: 0.550141 [300/938] loss: 0.226565 [400/938] loss: 0.314738 [500/938] loss: 0.298739 [600/938] loss: 0.459540 [700/938] loss: 0.332978 [800/938] loss: 0.406709 [900/938] Test: Accuracy: 90.2%, Avg loss: 0.334828 Epoch 3 ------------------------------- loss: 0.461890 [ 0/938] loss: 0.242303 [100/938] loss: 0.281414 [200/938] loss: 0.207835 [300/938] loss: 0.206000 [400/938] loss: 0.409646 [500/938] loss: 0.193608 [600/938] loss: 0.217575 [700/938] loss: 0.212817 [800/938] loss: 0.202862 [900/938] Test: Accuracy: 91.9%, Avg loss: 0.280962 Done!
更多细节详见模型训练。
保存模型
模型训练完成后,需要将其参数进行保存。
# Save checkpoint
mindspore.save_checkpoint(model, "model.ckpt")
print("Saved Model to model.ckpt")
Saved Model to model.ckpt
加载模型
加载保存的权重分为两步:
- 重新实例化模型对象,构造模型。
- 加载模型参数,并将其加载至模型上。
# Instantiate a random initialized model
model = Network()
# Load checkpoint and load parameter to model
param_dict = mindspore.load_checkpoint("model.ckpt")
param_not_load, _ = mindspore.load_param_into_net(model, param_dict)
print(param_not_load)
param_not_load
是未被加载的参数列表,为空时代表所有参数均加载成功。
加载后的模型可以直接用于预测推理。
model.set_train(False)
for data, label in test_dataset:
pred = model(data)
predicted = pred.argmax(1)
print(f'Predicted: "{predicted[:10]}", Actual: "{label[:10]}"')
break
Predicted: "[3 9 6 1 6 7 4 5 2 2]", Actual: "[3 9 6 1 6 7 4 5 2 2]"
好了,今天先到这里吧。跟着官方的开发者文档来一步一步操作来实现还是比较容易入门的,想学习昇思MindSpore和华为昇腾AI全栈的同学,可以来试试。个人感觉在国内AI方面华为算是顶流的存在了,毕竟华为的实力在那里。有任何问题和疑惑,欢迎评论区留言探讨哦。
打卡图片: