人工智能初学教程 - 基于MindSpore

路人与大师

于 2024-06-19 11:27:08 发布

阅读量577

点赞数 6

文章标签：人工智能

本文链接：https://blog.csdn.net/weixin_41046245/article/details/139797383

版权

人工智能初学教程 - 基于MindSpore

MindSpore 教案

介绍

目标： 提供对 MindSpore 的全面介绍，包括其架构、特性和安装方法。

基本介绍

什么是 MindSpore？

MindSpore 是一个新的开源深度学习训练/推理框架，可用于移动、边缘和云场景。MindSpore 旨在为数据科学家和算法工程师提供友好的设计和高效的执行体验，原生支持昇腾 AI 处理器，并实现软硬件协同优化。同时，MindSpore 作为全球 AI 开源社区，旨在进一步推动 AI 软件/硬件应用生态系统的发展和丰富。

MindSpore 架构

详细信息请参考我们的架构指南.

自动微分

目前，主流深度学习框架中有两种自动微分技术：

操作符重载 (OO)： 重载编程语言的基本操作符以封装其梯度规则。在前向执行期间以操作符重载的方式记录网络的操作轨迹，然后应用链式法则到动态生成的数据流图实现自动微分。
源代码转换 (ST)： 这种技术源于函数式编程框架，并以即时编译 (JIT) 的形式对中间表达式 (编译过程中的程序表达形式) 进行自动微分转换，支持复杂的控制流场景、高阶函数和闭包。

PyTorch 使用了操作符重载技术。与源代码转换相比，操作符重载在运行时生成梯度图，因此无需考虑函数调用和控制流，这使得开发更容易。然而，操作符重载不能在编译时进行梯度图优化，控制流必须在运行时展开，因此难以实现极限性能优化。

MindSpore 基于源代码转换实现了自动微分。一方面，它支持自动控制流的自动微分，因此构建模型非常方便。另一方面，MindSpore 可以对神经网络进行静态编译优化以实现卓越的性能。

自动并行

MindSpore 自动并行的目标是构建一种结合数据并行、模型并行和混合并行的训练方法。它可以自动选择最低成本的模型拆分策略，以实现自动分布式并行训练。

目前，MindSpore 使用精细粒度的操作符拆分策略，即图中的每个操作符被拆分到一个集群中完成并行操作。这个期间的拆分策略可能非常复杂，但作为一个倡导 Pythonic 的开发者，您不需要关心底层实现，只需确保顶层 API 计算效率即可。

安装

Pip 模式方法安装

MindSpore 提供了跨多个后端的构建选项：

硬件平台	操作系统	状态
Ascend910	Ubuntu-x86	✔️
Ubuntu-aarch64	✔️
EulerOS-aarch64	✔️
CentOS-x86	✔️
CentOS-aarch64	✔️
GPU CUDA 10.1	Ubuntu-x86	✔️
CPU	Ubuntu-x86	✔️
Ubuntu-aarch64	✔️
Windows-x86	✔️

以 CPU 和 Ubuntu-x86 构建版本为例，使用 pip 安装：

从 MindSpore 下载页面下载 whl 文件，并安装该包。

pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.2.0-rc1/MindSpore/cpu/ubuntu_x86/mindspore-1.2.0rc1-cp37-cp37m-linux_x86_64.whl

运行以下命令验证安装：

import numpy as np
import mindspore.context as context
import mindspore.nn as nn
from mindspore import Tensor
from mindspore.ops import operations as P

context.set_context(mode=context.GRAPH_MODE, device_target="CPU")

class Mul(nn.Cell):
    def __init__(self):
        super(Mul, self).__init__()
        self.mul = P.Mul()

    def construct(self, x, y):
        return self.mul(x, y)

x = Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
y = Tensor(np.array([4.0, 5.0, 6.0]).astype(np.float32))

mul = Mul()
print(mul(x, y))

预期输出：
```
[ 4. 10. 18.]
```

更多关于不同环境下使用 pip 模式方法安装 MindSpore 的文档，请参考：

使用 pip 模式方法在 Ascend 环境中安装 MindSpore
使用 pip 模式方法在 GPU 环境中安装 MindSpore
使用 pip 模式方法在 CPU 环境中安装 MindSpore

源代码编译安装

在不同环境中使用源代码编译方法安装 MindSpore，请参考以下文档：

使用源代码编译方法在 Ascend 环境中安装 MindSpore
使用源代码编译方法在 GPU 环境中安装 MindSpore
使用源代码编译方法在 CPU 环境中安装 MindSpore

Docker 镜像

MindSpore Docker 镜像托管在 Docker Hub 上，目前支持以下容器化构建选项：

硬件平台	Docker 镜像仓库	标签	描述
CPU	mindspore/mindspore-cpu	x.y.z	预安装 MindSpore x.y.z CPU 版本的生产环境。
devel	开发环境，提供从源码构建 MindSpore（使用 CPU 后端），请参考 https://www.mindspore.cn/install/zh-cn 了解安装详情。
runtime	提供安装 MindSpore 二进制包（使用 CPU 后端）的运行时环境。
GPU	mindspore/mindspore-gpu	x.y.z	预安装 MindSpore x.y.z GPU 版本的生产环境。
devel	开发环境，提供从源码构建 MindSpore（使用 GPU CUDA10.1 后端），请参考 https://www.mindspore.cn/install/zh-cn 了解安装详情。
runtime	提供安装 MindSpore 二进制包（使用 GPU CUDA10.1 后端）的运行时环境。

注意： 对于 GPU 开发镜像，不建议在构建后直接安装 whl 包，我们强烈建议您在 GPU 运行时镜像中传输并安装 whl 包。

CPU：

对于 CPU 后端，可以使用以下命令直接拉取并运行最新的稳定镜像：

docker pull mindspore/mindspore-cpu:1.1.0
docker run -it mindspore/mindspore-cpu:1.1.0 /bin/bash

GPU：

对于 GPU 后端，请确保预先安装了 nvidia-container-toolkit，以下是 Ubuntu 用户的安装指南：

DISTRIBUTION=$(. /etc/os-release; echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$DISTRIBUTION/nvidia-docker.list | tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit nvidia-docker2
sudo systemctl restart docker

然后编辑文件 daemon.json：

vim /etc/docker/daemon.json
{
    "runtimes": {
        "nvidia": {
            "path": "nvidia-container-runtime",
            "runtimeArgs": []
        }
    }
}

再次重启 Docker：

sudo systemctl daemon-reload
sudo systemctl restart docker

然后可以使用以下命令拉取并运行最新的稳定镜像：

docker pull mindspore/mindspore-gpu:1.1.0
docker run -it -v /dev/shm:/dev/shm --runtime=nvidia --privileged=true mindspore/mindspore-gpu:1.1.0 /bin/bash

要测试 Docker 镜像是否正常工作，请执行以下 Python 代码并检查输出：

import numpy as np
import mindspore.context as context
from mindspore import Tensor
from mindspore.ops import functional as F

context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")

x = Tensor(np.ones([

1, 3, 3, 4]).astype(np.float32))
y = Tensor(np.ones([1, 3, 3, 4]).astype(np.float32))
print(F.tensor_add(x, y))

输出应为：

[[[ 2.  2.  2.  2.],
  [ 2.  2.  2.  2.],
  [ 2.  2.  2.  2.]],

 [[ 2.  2.  2.  2.],
  [ 2.  2.  2.  2.],
  [ 2.  2.  2.  2.]],

 [[ 2.  2.  2.  2.],
  [ 2.  2.  2.  2.],
  [ 2.  2.  2.  2.]]]

如果您想了解更多关于 MindSpore Docker 镜像构建过程的信息，请查看 Docker 仓库了解详细信息。

快速入门

请参阅快速入门以实现图像分类。

文档和社区资源

文档

更多关于安装指南、教程和 API 的详细信息，请参阅用户文档。

这个教案涵盖了 MindSpore 的基本介绍、架构、自动微分和自动并行技术、安装方法、快速入门指南以及文档和社区资源。通过这个教案，初学者可以全面了解 MindSpore，并快速上手进行深度学习开发。

基本介绍

人工智能（AI）和深度学习是当前最热门的技术领域之一。MindSpore是华为推出的开源深度学习框架，旨在帮助开发者快速、高效地构建AI模型。本教程将带领初学者从基础知识入门，逐步掌握使用MindSpore进行深度学习的技能。

快速入门MindSpore

1. 数据集处理

MindSpore提供了基于Pipeline的数据引擎，通过Dataset和Transforms实现高效的数据预处理。在本教程中，我们使用MNIST数据集，并通过MindSpore的数据变换来预处理数据集。

下载数据集

from mindspore.dataset import MnistDataset

train_dataset = MnistDataset('MNIST_Data/train')
test_dataset = MnistDataset('MNIST_Data/test')

数据变换

from mindspore.dataset import vision, transforms

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

train_dataset = datapipe(train_dataset, 64)
test_dataset = datapipe(test_dataset, 64)

迭代数据集

for image, label in test_dataset.create_tuple_iterator():
    print(f"Image shape: {image.shape}, Label shape: {label.shape}")

2. 构建网络

使用mindspore.nn类作为构建所有网络的基类。在构建网络时，可以继承nn.Cell类并重写__init__和construct方法。

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()

3. 训练模型

loss_fn = nn.CrossEntropyLoss()
optimizer = nn.SGD(model.trainable_params(), 1e-2)

def forward_fn(data, label):
    logits = model(data)
    loss = loss_fn(logits, label)
    return loss, logits

grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)

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}]")

epochs = 3
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(model, train_dataset)

4. 保存和加载模型

mindspore.save_checkpoint(model, "model.ckpt")
model = Network()
param_dict = mindspore.load_checkpoint("model.ckpt")
param_not_load, _ = mindspore.load_param_into_net(model, param_dict)

以上是一个简单的MindSpore模型的快速实现教程。

以上教程涵盖了从基础入门到实际应用的多个方面，旨在帮助初学者快速掌握MindSpore的使用，并应用于各种深度学习任务。通过这些实践，你将能够深入理解深度学习的原理和应用，并具备实际项目开发的能力。

路人与大师

关注

6
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
人工智能初学教程 - 基于MindSpore

提供对 MindSpore 的全面介绍，包括其架构、特性和安装方法。MindSpore 是一个新的开源深度学习训练/推理框架，可用于移动、边缘和云场景。MindSpore 旨在为数据科学家和算法工程师提供友好的设计和高效的执行体验，原生支持昇腾 AI 处理器，并实现软硬件协同优化。同时，MindSpore 作为全球 AI 开源社区，旨在进一步推动 AI 软件/硬件应用生态系统的发展和丰富。基本介绍人工智能（AI）和深度学习是当前最热门的技术领域之一。
复制链接

扫一扫