mindspore_mindspore怎么样 - CSDN
精华内容
参与话题
  • 犹记得今年的华为开发者大会 HDC 2020 上,一直受人瞩目的深度学习框架 MindSpore 终于开源了。我之前一直关注 MindSpore,还是挺期待的。MindSpore 是一款...

    犹记得今年的华为开发者大会 HDC 2020 上,一直受人瞩目的深度学习框架 MindSpore 终于开源了。

    我之前一直关注 MindSpore,还是挺期待的。MindSpore 是一款支持端、边、云独立/协同的统一训练和推理框架。与 TensorFlow、PyTorch  等流行深度学习框架对标,MindSpore 旨在大幅度降低 AI 应用开发门槛,让人工智能无处不在。

    MindSpore 最大的特点就是开发门槛大大降低,提高开发效率,这样可以显著减少模型开发时间。

    因此,使用MindSpore的优势可以总结为以下四点:

    • 简单的开发体验

    • 灵活的调试模式

    • 充分发挥硬件潜能

    • 全场景快速部署

    既然开源了,那就赶紧上手,试一试这款开源的 MindSpore 怎么样!本文我将介绍 MindSpore 的安装和上手教程,通过一个简单的图像识别案例来跑完整个 AI 训练和测试流程。

    一、MindSpore 的安装

    开源框架 MindSpore 的安装方法有很多,可以在 Windows、Ubuntu 上安装,也可以在华为 Ascend 910 上安装。各种详尽的安装方法请见下面的链接:

    https://www.mindspore.cn/install

    下面介绍两种最简单的安装方法!

    1. Docker 安装

    Docker 安装最为简单,可参考:

    https://gitee.com/mindspore/mindspore#docker-image

    以 0.3.0-alpha 版本为例:

    • CPU:

      docker pull mindspore/mindspore-cpu:0.3.0-alpha

    • GPU:

      docker pull mindspore/mindspore-gpu:0.3.0-alpha

    安装好后,可以看到安装的镜像,并使用下面的命令创建一个你的容器:

    docker run -it mindspore/mindspore-cpu:0.3.0-alpha /bin/bash
    

    2. Win10+Anaconda+MindSpore

    使用 Win10 +Anaconda+MindSpore 的方式进行安装也非常简单,本文将采用这种方式安装 MindSpore。

    在 MindSpore 安装首页里,选择安装相关配置:

    • 版本:0.3.0-alpha

    • 硬件平台:CPU

    • 操作系统:Windows-64

    • 编程语言:Python 3.7.5

    首先,在 Win10 上安装 Anaconda,Anaconda 是一个开源的 Python 发行版本,其包含了 conda、Python 等 180 多个科学包及其依赖项。

    然后,创建一个虚拟环境。

    1). 打开 Anaconda 组件中的 Anaconda Prompt 终端:

    2). 使用下面的命令,创建一个虚拟环境 mindspore(名字可以自定义),并进入虚拟环境:

    conda create -n mindspore python=3.7.5 
    conda activate mindspore
    

    3). 安装依赖库,根据 https://gitee.com/mindspore/mindspore/blob/r0.3/requirements.txt 列出的依赖库,使用 conda 命令安装。例如:

    conda install numpy
    

    4). 根据之前选择的相关配置,在网站:https://www.mindspore.cn/versions 中选择所要相应的 MindSpore 版本:

    mindspore-0.3.0-cp37-cp37m-win_amd64.whl

    可以将.whl 文件下载到本地,使用 pip 安装(使用 conda 命令在线安装速度可能比较慢,因此可以选择将.whl文件下载到本地,使用 pip 命令安装):

    pip install mindspore-0.3.0-cp37-cp37m-win_amd64.whl
    

    最后测试是否安装成功,进入 Python shell,执行如下命令,如果没有提示 No module named 'mindspore' 等加载错误的信息,则说明安装成功。

    至此,安装完成!

    二、基于本地 Jupyter 实现 MNIST 手写数据集分类

    1. 安装 Jupyter Notebook

    首先,在虚拟环境 mindspore 中安装 Jupyter Notebook。方法是:打开 Anaconda 组件 Anaconda Navigator。

    在 Anaconda Navigator 中,Application on 选择刚建立的虚拟环境 mindspore,在组件 Jupyter Notebook 下点击 install,安装。安装完成后如下图:

    点击 Notebook 下的 Launch,即可打开 Jupyter Notebook。

    2. 下载数据集

    MNIST 手写数据集想必大家都很熟悉了,包含 0-9 的数字,由 60000 张训练图片和 10000 张测试图片组成。

    MNIST 数据集下载页面:

    http://yann.lecun.com/exdb/mnist/

    使用 MindSpore,我们可以通过直接定义一个 download_dataset 函数来自动下载 MNIST 数据集:

    def download_dataset():
        """Download the dataset from http://yann.lecun.com/exdb/mnist/."""
        print("******Downloading the MNIST dataset******")
        train_path = "./MNIST_Data/train/"
        test_path = "./MNIST_Data/test/"
        train_path_check = os.path.exists(train_path)
        test_path_check = os.path.exists(test_path)
        if train_path_check == False and test_path_check ==False:
            os.makedirs(train_path)
            os.makedirs(test_path)
        train_url = {"http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz", "http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz"}
        test_url = {"http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz", "http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz"}
        for url in train_url:
            url_parse = urlparse(url)
            # split the file name from url
            file_name = os.path.join(train_path,url_parse.path.split('/')[-1])
            if not os.path.exists(file_name.replace('.gz','')):
                file = urllib.request.urlretrieve(url, file_name)
                unzipfile(file_name)
                os.remove(file_name)
        for url in test_url:
            url_parse = urlparse(url)
            # split the file name from url
            file_name = os.path.join(test_path,url_parse.path.split('/')[-1])
            if not os.path.exists(file_name.replace('.gz','')):
                file = urllib.request.urlretrieve(url, file_name)
                unzipfile(file_name)
                os.remove(file_name)
    

    该函数实现将数据集自动下载在本地的 ./MNIST_Data 目录下,训练集放在子目录 /train 下,测试集放在子目录 /test 下。

    3. 数据预处理

    MNIST 数据集准备好了之后,下一步就要对数据集进行一些预处理,包括图片尺寸调整为 32x32(因为我们使用的是 LeNet-5 网络,后面会介绍),像素归一化、batch_size 设为 32(可调整),等等。

    MindSpore 提供了 mindspore.dataset.MnistDataset 来直接定义 Minist 数据集,非常方便。使用 mindspore.dataset.MnistDataset.map 映射函数,将数据操作应用到数据集。

    我们定义 create_dataset() 函数来创建数据集:

    def create_dataset(data_path, batch_size=32, repeat_size=1,
                       num_parallel_workers=1):
        """ create dataset for train or test
        Args:
            data_path: Data path
            batch_size: The number of data records in each group
            repeat_size: The number of replicated data records
            num_parallel_workers: The number of parallel workers
        """
        # define dataset
        mnist_ds = ds.MnistDataset(data_path)
    
    
        # define operation parameters
        resize_height, resize_width = 32, 32
        rescale = 1.0 / 255.0
        shift = 0.0
        rescale_nml = 1 / 0.3081
        shift_nml = -1 * 0.1307 / 0.3081
    
    
        # define map operations
        resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)  # Resize images to (32, 32)
        rescale_nml_op = CV.Rescale(rescale_nml, shift_nml) # normalize images
        rescale_op = CV.Rescale(rescale, shift) # rescale images
        hwc2chw_op = CV.HWC2CHW() # change shape from (height, width, channel) to (channel, height, width) to fit network.
        type_cast_op = C.TypeCast(mstype.int32) # change data type of label to int32 to fit network
    
    
        # apply map operations on images
        mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)
    
    
        # apply DatasetOps
        buffer_size = 10000
        mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)  # 10000 as in LeNet train script
        mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
        mnist_ds = mnist_ds.repeat(repeat_size)
    
    
        return mnist_ds
    

    通过上面的函数,就完成了对刚下载的 MNIST 数据集的预处理。

    4. 定义网络

    LeNet-5 是一种用于手写体字符识别的非常高效的卷积神经网络。LeNet-5 共有 7 层,不包含输入,每层都包含可训练参数;每个层有多个 Feature Map,每个 FeatureMap通过一种卷积滤波器提取输入的一种特征。

    1) 模型初始化

    使用 mindspore.common.initializer.TruncatedNormal 方法对参数进行初始化,定义 conv 和 fc_with_initialize 分别对卷积层和全连接层进行初始化。

    import mindspore.nn as nn
    from mindspore.common.initializer import TruncatedNormal
    
    
    def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
        """Conv layer weight initial."""
        weight = weight_variable()
        return nn.Conv2d(in_channels, out_channels,
                         kernel_size=kernel_size, stride=stride, padding=padding,
                         weight_init=weight, has_bias=False, pad_mode="valid")
    
    
    def fc_with_initialize(input_channels, out_channels):
        """Fc layer weight initial."""
        weight = weight_variable()
        bias = weight_variable()
        return nn.Dense(input_channels, out_channels, weight, bias)
    
    
    def weight_variable():
        """Weight initial."""
        return TruncatedNormal(0.02)
    

    使用 mindspore.common.initializer.TruncatedNormal 方法,可以非常便捷地实现网络权重系数的初始化操作,不需要自定义初始化函数。

    2) 定义 LeNet-5 网络

    MindSpore 来定义 LeNet-5 网络也很简单,根据网络结构,定义相应的卷积层和全连接层即可。在初始化函数 __init__ 种定义神经网络的各层,然后通过定义 construct 方法来完成神经网络的前向构造。

    class LeNet5(nn.Cell):
        """Lenet network structure."""
        # define the operator required
        def __init__(self):
            super(LeNet5, self).__init__()
            self.conv1 = conv(1, 6, 5)
            self.conv2 = conv(6, 16, 5)
            self.fc1 = fc_with_initialize(16 * 5 * 5, 120)
            self.fc2 = fc_with_initialize(120, 84)
            self.fc3 = fc_with_initialize(84, 10)
            self.relu = nn.ReLU()
            self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
            self.flatten = nn.Flatten()
    
    
        # use the preceding operators to construct networks
        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
    

    LeNet-5 是一个非常典型且简单的卷积神经网络,从 construct 方法可以详细看到 LeNet-5 各层的结构。

    3) 定义损失函数

    MindSpore 支持的损失函数有 SoftmaxCrossEntropyWithLogits、L1Loss、MSELoss 等。这里使用 SoftmaxCrossEntropyWithLogits 交叉熵损失函数。

    from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
    
    
    # define the loss function
    net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')
    

    4) 定义网络梯度下降算法

    MindSpore 支持的梯度下降算法有 Adam、AdamWeightDecay、Momentum 等。这里使用流行的 Momentum 算法。其中,学习率设为 0.01,momentum 参数设为 0.9。

    # learning rate setting
    lr = 0.01
    momentum = 0.9
    # define the optimizer
    net_opt = nn.Momentum(network.trainable_params(), lr, momentum)
    

    5. 训练网络

    1) 模型保存

    mindspore.train.callback.ModelCheckpoint 方法可以保存网络模型和参数。

    config_ck = CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)
    # save the network model and parameters for subsequence fine-tuning
    ckpoint_cb = ModelCheckpoint(prefix="checkpoint_lenet", config=config_ck)
    

    2) 训练网络

    训练网络使用 model.train 方法进行。这里把 epoch_size 设置为 1,对数据集进行 1 个迭代的训练。训练的过程中会打印 loss 值的变化。

    from mindspore.nn.metrics import Accuracy
    from mindspore.train.callback import LossMonitor
    from mindspore.train import Model
    
    
    def train_net(args, model, epoch_size, mnist_path, repeat_size, ckpoint_cb, sink_mode):
        """define the training method"""
        print("============== Starting Training ==============")
        #load training dataset
        ds_train = create_dataset(os.path.join(mnist_path, "train"), 32, repeat_size)
        model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor()], dataset_sink_mode=sink_mode)
    
    epoch_size = 1
    mnist_path = "./MNIST_Data
    # group layers into an object with training and evaluation features
    model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
    train_net(args, model, epoch_size, mnist_path, repeat_size, ckpoint_cb)
    

    其中,mnist_path 是 MNIST 数据集路径。

    3) 硬件信息

    在主函数中,别忘了配置 MindSpore 运行的硬件信息。因为我们是在 CPU 环境下,所以 ‘--device_target’ 设置为 “CPU”。

    parser = argparse.ArgumentParser(description='MindSpore LeNet Example')
    parser.add_argument('--device_target', type=str, default="CPU", choices=['Ascend', 'GPU', 'CPU'],
                            help='device where the code will be implemented (default: CPU)')
    args = parser.parse_args(args=[])
    context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target)
    

    这里的 '--device_target' 默认是 “CPU”,根据硬件情况也可以选择 “Ascend” 或 “GPU”。使用的是图模式 “context.GRAPH_MODE”。

    4) 模型训练

    执行程序,模型训练开始。训练过程中会打印 loss 值:

    ...
    epoch: 1 step: 262, loss is 1.9212162
    epoch: 1 step: 263, loss is 1.8498616
    epoch: 1 step: 264, loss is 1.7990671
    epoch: 1 step: 265, loss is 1.9492403
    epoch: 1 step: 266, loss is 2.0305142
    epoch: 1 step: 267, loss is 2.0657792
    epoch: 1 step: 268, loss is 1.9582214
    epoch: 1 step: 269, loss is 0.9459006
    epoch: 1 step: 270, loss is 0.8167224
    epoch: 1 step: 271, loss is 0.7432692
    ...
    

    可以看到 loss 总体来说会逐步减小,精度逐步提高,最终的 loss 为 0.067。

    训练完成之后,得到保存的模型文件:

    checkpoint_lenet-1_1875.ckpt

    6. 模型测试

    在得到模型文件后,使用 model.eval() 接口读入测试数据集,通过模型运行测试数据集得到的结果。定义测试函数 test_net():

    def test_net(args, network, model, mnist_path):
        """Define the evaluation method."""
        print("============== Starting Testing ==============")
        # load the saved model for evaluation
        param_dict = load_checkpoint("checkpoint_lenet-1_1875.ckpt")
        # load parameter to the network
        load_param_into_net(network, param_dict)
        # load testing dataset
        ds_eval = create_dataset(os.path.join(mnist_path, "test"))
        acc = model.eval(ds_eval, dataset_sink_mode=False)
        print("============== Accuracy:{} ==============".format(acc))
    

    运行测试网络:

    test_net(args, network, model, mnist_path)
    
    ============== Starting Testing ==============
    ============== Accuracy:{'Accuracy': 0.9663461538461539} ==============
    

    最终,可以看到刚刚训练的 LeNet-5 网络模型在测试集上的精度是 96.63%,效果非常不错。

    至此,我们使用 MindSpore 框架训练 LeNet-5 模型已经完成。实现了基于本地 Jupyter 实现 MNIST 手写数据集分类。总的来说,MindSpore 提供了很多模块化的方法来进行模型搭建和训练,非常方便我们能够快速搭建一个神经网络模型。大家可以根据自己实际需求,上手搭建一个自己的神经网络试试。

    本节完整代码:

    https://gitee.com/mindspore/docs/blob/master/tutorials/tutorial_code/lenet.py

    三、在云服务器上使用 MindSpore

    除了可以在本地使用 MindSpore 框架之外,我们还可以在华为云服务器上使用 MindSpore。在华为云上使用 MindSpore 的还有一个好处是,我们可以申请使用昇腾 AI 处理器资源池作为硬件。

    ModelArts 是华为云提供的面向开发者的一站式 AI 开发平台,而且集成了 MindSpore。下面我们将在 ModelArts 下使用 ResNet-50 网络识别 CIFAR-10 图片。

    1. 准备 ModelArts

    1) 进入华为云官网,注册账号。

    具体操作:

    https://support.huaweicloud.com/prepare-modelarts/modelarts_08_0001.html

    2) 获取访问密钥并完成 ModelArts 配置。

    具体操作:

    https://support.huaweicloud.com/prepare-modelarts/modelarts_08_0002.html

    3) 创建 OBS 桶

    具体操作:

    https://support.huaweicloud.com/prepare-modelarts/modelarts_08_0003.html

    2. 申请服务器昇腾 AI 处理器资源

    为了在 ModelArts 上使用华为云昇腾 AI 处理器,我们需要申请体验资格,申请方式也很简单,可在下面的网站上进行申请:

    https://console.huaweicloud.com/modelarts/?region=cn-north-4#/dashboard/applyModelArtsAscend910Beta

    申请时的内容大家可以填仔细些,一般正常的话两个工作日就批下来了。

    3. 数据准备

    1) 下载 CIFAR-10 数据集

    CIFAR-10 该数据集共有 60000 张彩色图像,这些图像是 32*32,分为 10 个类,每类 6000 张图。

    CIFAR-10 数据集下载地址:

    http://www.cs.toronto.edu/~kriz/cifar.html

    注意下载 CIFAR-10 binary version 版本。

    2) 新建一个自己的 OBS 桶(例如:mine-ms-dataset)

    ModelArts 使用对象存储服务(Object Storage Service,简称 OBS)进行数据存储,因此,在开始训练任务之前,需要将数据上传至 OBS。

    首先,登录 OBS 管理控制台:

    https://storage.huaweicloud.com/obs/?region=cn-north-4#/obs/manager/buckets

    创建 OBS 桶 mine-ms-dataset(名称可修改,下面类似)。

    然后,在刚创建的 OBS 桶里,创建用于存放数据的文件夹:在桶列表单击待操作的桶,在左侧导航栏,单击“对象”,新建文件夹 mine-cifar-10

    最后,将下载好的 CIFAR-10 数据集按照以下目录结构上传至数据目录 mine-cifar-10 中:

    └─对象存储/mine-ms-dataset/mine-cifar-10
        ├─train
        │      data_batch_1.bin
        │      data_batch_2.bin
        │      data_batch_3.bin
        │      data_batch_4.bin
        │      data_batch_5.bin
        │
        └─eval
            test_batch.bin

    4. 程序准备

    新建一个 OBS 桶(例如:mine-resnet50-train),在桶中创建代码目录(例如:mine-resnet50_cifar10_train)。同时在该桶中创建 output 目录和 log 目录,用来存放模型和日志。

    将网址:

    https://gitee.com/mindspore/docs/tree/master/tutorials/tutorial_code/sample_for_cloud/

    中的两个 .py 文件 dataset.pyresnet50_train.py 下载并上传到代码目录 mine-resnet50_cifar10_train 中。

    代码目录 mine-resnet50_cifar10_train 结构如下:

    └─对象存储/mine-resnet50-train
        ├─mine-resnet50_cifar10_train
        │      dataset.py
        │      resnet50_train.py
        │
        ├─output
        └─log

    5. 创建训练任务

    准备好数据和执行脚本以后,下面就可以在云服务器上创建训练任务了。

    1) 进入 ModelArts 控制台

    打开华为云 ModelArts 主页

    https://www.huaweicloud.com/product/modelarts.html

    点击“进入控制台”。

    2) 使用 MindSpore 作为常用框架创建训练作业

    在左侧导航栏中选择“训练管理 > 训练作业”,默认进入“训练作业”列表。

    在训练作业列表中,单击左上角“创建”,进入“创建训练作业”页面。

    在创建训练作业页面,训练作业名称自定义,例如 mine-resnet50-trainjob。填写训练作业相关参数,具体配置参数如下:

    值得注意的时,算法来源常用框架选择 Ascend-Powered-Engine,因为我们使用的是硬件是华为云昇腾 AI 处理器。MindSpore 版本选择 MindSpore-0.1-python3.7-aarch64 即可。

    配置完之后,点击下一步 -> 提交 -> 返回训练作业列表,可以看到训练作业 mine-resnet50-trainjob 正在运行:

    整个运行过程大概  8 分半钟,显示运行成功,表示模型训练测试完成。

    最后,点击训练作业 mine-resnet50-trainjob,在日志里可以看到模型在测试集上的准确率为 92.49%,说明该模型效果不错。

    我们还可以从 OBS 种下载日志文件并查看。

    以上就是在云上使用 MindSpore 的简单教程。

    四、总结:

    本文主要通过两个实际应用案例对开源框架 MindSpore 进行介绍。一是基于本地 Jupyter Notebook 的 MNIST 手写数据识别;二是基于华为云服务器的 CIFAR-10 图像分类。两个案例均围绕并使用了 MindSpore。

    从我个人的使用感觉来看,MindSpore 用起来还是很顺手的,而且函数封装得比较简洁,使用起来较为方便。通过手把手的教程,大家完全可以自己动手实操一下,感受一下开源框架 MindSpore 的魅力。

    大家也可以根据自己的具体应用场景和实用案例,使用 MindSpore,搭建神经网络模型,解决实际问题。无论是计算机视觉还是自然语言处理,相信 MindSpore 都能给大家带来流畅的体验。

    参考资料:

    https://www.mindspore.cn/

    https://www.mindspore.cn/tutorial/zh-CN/master/index.html

    https://support.huaweicloud.com/modelarts/index.html

    展开全文
  • Mindspore的快速上手

    2020-08-09 20:50:14
    Mindspore快速上手 本周末参加了华为mindspore深度学习框架的第三期训练营。在这次训练营中,mindspore由上次的0.3版本迅速的增加到了0.6版本。课程安排是这样的: 第一天: 1、快速上手mindspore指南 2、学习...

    Mindspore快速上手

    本周末参加了华为mindspore深度学习框架的第三期训练营。在这次训练营中,mindspore由上次的0.3版本迅速的增加到了0.6版本。课程安排是这样的:
    第一天:
    1、快速上手mindspore指南
    2、学习mindspore训练yolov3模型。
    3、如何快速用Mindspore训练bert模型
    4、用Mindspore Serving完成模型部署

    第二天:
    1、用MIndspore训练ResNet50模型
    2、性能大杀器——如何用Mindspore实现量化训练
    3、用Mindspore实现Wide&Deep模型
    通过这两天的爆肝学习,学习到很多知识,但是还有许多不明白的地方。这一篇就写出快速上手指南嘞。

    一、环境部署

    Mindspore架构:
    在这里插入图片描述

    使用环境:

    win10+anaconda+Mindspore

    步骤如下:

    安装配置如下:
    使用是Mindspore的0.5版本滴
    在这里插入图片描述
    1、先创建虚拟环境
    先点击这个
    在这里插入图片描述
    使用下面命令进行创建环境并进入环境

    conda create -n mindspore python=3.7.5 
    conda activate mindspore
    

    在这里插入图片描述
    2、安装Mindspore框架

    conda install https://ms-release.obs.cn-north-4.myhuaweicloud.com/0.5.0-beta/MindSpore/cpu/windows_x64/mindspore-0.5.0-cp37-cp37m-win_amd64.whl
    

    这里会自动安装MIndspore运行其他的包或者库的

    3.下载代码

    git clone https://github.com/mindspore-ai/docs.git
    

    4、进入目录,使用cd命令
    lenet.py文件在./doc/tutorials/tutorial_code目录下面,使用cd命令依次进入
    如图:
    在这里插入图片描述在这里插入图片描述在这里插入图片描述

    运行lenet.py文件
    在这里插入图片描述
    5.结果、结束。
    在这里插入图片描述在这里插入图片描述

    展开全文
  • win10 , cpu的情况下安装的mindspore。目前因为环境问题,所以,很少程序支持。下面我给出程序和验证过程和结果。

            win10  ,  cpu的情况下安装的mindspore。目前因为环境问题,所以,很少程序支持。下面我给出程序,验证过程和结果。

           参考资料: https://www.mindspore.cn/tutorial/zh-CN/master/quick_start/quick_start.html

           程序案例路径: https://gitee.com/mindspore/docs/blob/master/tutorials/tutorial_code/lenet.py

           程序我稍微做了点改动。

        

    import os
    import urllib.request
    from urllib.parse import urlparse
    import gzip
    import argparse
    import mindspore.dataset as ds
    import mindspore.nn as nn
    from mindspore import context
    from mindspore.train.serialization import load_checkpoint, load_param_into_net
    from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
    from mindspore.train import Model
    from mindspore.common.initializer import TruncatedNormal
    import mindspore.dataset.transforms.vision.c_transforms as CV
    import mindspore.dataset.transforms.c_transforms as C
    from mindspore.dataset.transforms.vision import Inter
    from mindspore.nn.metrics import Accuracy
    from mindspore.common import dtype as mstype
    from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
    
    
    def unzipfile(gzip_path):
        """unzip dataset file
        Args:
            gzip_path: dataset file path
        """
        open_file = open(gzip_path.replace('.gz',''), 'wb')
        gz_file = gzip.GzipFile(gzip_path)
        open_file.write(gz_file.read())
        gz_file.close()
    
    
    def download_dataset():
        """Download the dataset from http://yann.lecun.com/exdb/mnist/."""
        print("******Downloading the MNIST dataset******")
        train_path = "./MNIST_Data/train/"
        test_path = "./MNIST_Data/test/"
        train_path_check = os.path.exists(train_path)
        test_path_check = os.path.exists(test_path)
        if train_path_check == False and test_path_check ==False:
            os.makedirs(train_path)
            os.makedirs(test_path)
        train_url = {"http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz", "http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz"}
        test_url = {"http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz", "http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz"}
        for url in train_url:
            url_parse = urlparse(url)
            # split the file name from url
            file_name = os.path.join(train_path,url_parse.path.split('/')[-1])
            if not os.path.exists(file_name.replace('.gz','')):
                file = urllib.request.urlretrieve(url, file_name)
                unzipfile(file_name)
                os.remove(file_name)
        for url in test_url:
            url_parse = urlparse(url)
            # split the file name from url
            file_name = os.path.join(test_path,url_parse.path.split('/')[-1])
            if not os.path.exists(file_name.replace('.gz','')):
                file = urllib.request.urlretrieve(url, file_name)
                unzipfile(file_name)
                os.remove(file_name)
    
    
    def create_dataset(data_path, batch_size=32, repeat_size=1,
                       num_parallel_workers=1):
        """ create dataset for train or test
        Args:
            data_path: Data path
            batch_size: The number of data records in each group
            repeat_size: The number of replicated data records
            num_parallel_workers: The number of parallel workers
        """
        # define dataset
        mnist_ds = ds.MnistDataset(data_path)
    
        # define operation parameters
        resize_height, resize_width = 32, 32
        rescale = 1.0 / 255.0
        shift = 0.0
        rescale_nml = 1 / 0.3081
        shift_nml = -1 * 0.1307 / 0.3081
    
        # define map operations
        resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)  # Resize images to (32, 32)
        rescale_nml_op = CV.Rescale(rescale_nml, shift_nml) # normalize images
        rescale_op = CV.Rescale(rescale, shift) # rescale images
        hwc2chw_op = CV.HWC2CHW() # change shape from (height, width, channel) to (channel, height, width) to fit network.
        type_cast_op = C.TypeCast(mstype.int32) # change data type of label to int32 to fit network
    
        # apply map operations on images
        mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)
        mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)
    
        # apply DatasetOps
        buffer_size = 10000
        mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)  # 10000 as in LeNet train script
        mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
        mnist_ds = mnist_ds.repeat(repeat_size)
    
        return mnist_ds
    
    
    def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
        """Conv layer weight initial."""
        weight = weight_variable()
        return nn.Conv2d(in_channels, out_channels,
                         kernel_size=kernel_size, stride=stride, padding=padding,
                         weight_init=weight, has_bias=False, pad_mode="valid")
    
    
    def fc_with_initialize(input_channels, out_channels):
        """Fc layer weight initial."""
        weight = weight_variable()
        bias = weight_variable()
        return nn.Dense(input_channels, out_channels, weight, bias)
    
    
    def weight_variable():
        """Weight initial."""
        return TruncatedNormal(0.02)
    
    
    class LeNet5(nn.Cell):
        """Lenet network structure."""
        # define the operator required
        def __init__(self):
            super(LeNet5, self).__init__()
            self.conv1 = conv(1, 6, 5)
            self.conv2 = conv(6, 16, 5)
            self.fc1 = fc_with_initialize(16 * 5 * 5, 120)
            self.fc2 = fc_with_initialize(120, 84)
            self.fc3 = fc_with_initialize(84, 10)
            self.relu = nn.ReLU()
            self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
            self.flatten = nn.Flatten()
    
        # use the preceding operators to construct networks
        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
    
    
    def train_net(args, model, epoch_size, mnist_path, repeat_size, ckpoint_cb):
        """Define the training method."""
        print("============== Starting Training ==============")
        # load training dataset
        ds_train = create_dataset(os.path.join(mnist_path, "train"), 32, repeat_size)
        model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor()], dataset_sink_mode=False)
    
    
    def test_net(args, network, model, mnist_path):
        """Define the evaluation method."""
        print("============== Starting Testing ==============")
        # load the saved model for evaluation
        param_dict = load_checkpoint("checkpoint_lenet-1_1875.ckpt")
        # load parameter to the network
        load_param_into_net(network, param_dict)
        # load testing dataset
        ds_eval = create_dataset(os.path.join(mnist_path, "test"))
        acc = model.eval(ds_eval, dataset_sink_mode=False)
        print("============== Accuracy:{} ==============".format(acc))
    
    
    if __name__ == "__main__":
        parser = argparse.ArgumentParser(description='MindSpore LeNet Example')
        parser.add_argument('--device_target', type=str, default="CPU", choices=['Ascend', 'GPU', 'CPU'],
                            help='device where the code will be implemented (default: CPU)')
        args = parser.parse_args()
        context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target,
                            enable_mem_reuse=False)
        # download mnist dataset
        # download_dataset()
        # learning rate setting
        lr = 0.01
        momentum = 0.9
        epoch_size = 1
        mnist_path = "./MNIST_Data"
        # define the loss function
        net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')
        repeat_size = epoch_size
        # create the network
        network = LeNet5()
        # define the optimizer
        net_opt = nn.Momentum(network.trainable_params(), lr, momentum)
        config_ck = CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)
        # save the network model and parameters for subsequence fine-tuning
        ckpoint_cb = ModelCheckpoint(prefix="checkpoint_lenet", config=config_ck)
        # group layers into an object with training and evaluation features
        model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
    
        train_net(args, model, epoch_size, mnist_path, repeat_size, ckpoint_cb)
        test_net(args, network, model, mnist_path)

            大部分都是官方内容。

            注意官方文件的内容,下载数据集部分不能错。   配置路径等,剩下所有的设置都不需要,只需要直接运行

           

           运行成功。

           -------------------------

           你好,我是毛华望。 如果你有python基础的话,或者tensorflow基础的话,其实随意一点都可以的。问题不大。如果没有的话,就要把注意点注意一下了。

     

    展开全文
  • MindSpore学习

    2020-05-10 22:25:48
    MindSpore是华为推出的一款对标Pytorch的深度学习框架,目前

           MindSpore是华为推出的一款对标Pytorch的深度学习框架,目前

    展开全文
  • 因为mindspore开源的时间不长,所以,资料很少。 官网是少不了的。 https://www.mindspore.cn/tutorial/zh-CN/master/quick_start/quick_start.html 安装,教程,文档和程序托管。 目前也就只有官方的一些说明,...
  • 华为全联接大会2019,部分资源PPT文件,大概有几十个,需要的可以自行下载
  • 4 月 26 日,机器之心联合华为昇腾学院开设的线上公开课《轻松上手开源框架 MindSpore》第二课完成,GraphEngine 高级工程师王俊为大家带来了主题分享《MindSpore 中 GraphEngine 浅析》。 第二课精选问答 在第二...
  • 华为MindSpore

    千次阅读 2019-08-25 10:43:44
    华为MindSpore2019年8月23日,华为发布了全场景 AI 计算框架 MindSpore,并宣布 “MindSpore 将在2020年第一季度开源”。这是与 TensorFlow、PyTorch、PaddlePaddle 等框架竞争的一款产品。 2019年8月23日,华为...
  • 授权转自:机器之心今天上午,在上海举行的 2018 全联接大会上,华为轮值董事长徐直军宣布了华为的 AI 战略与全栈式解决方案,同时发布了两款全新 AI 芯片以及跨平台深...
  • 摘要:本文介绍了如何在Ubuntu 18.04上安装CPU版本的MindSpore V1.0。并使用安装好的MindSpore进行了LeNet的模型训练。 Part One:引言 在HC2020大会中,张小白就透露出了想试玩MindSpore V1.0的愿望。MindSpore是...
  • 今年的华为开发者大会 HDC 2020 上,除了**昇腾、鲲鹏等自研芯片硬件平台**之外,最令人期待的就是**深度学习框架 MindSpore 的开源**了。今天上午,华为 MindSpore **首席科学家陈雷**在活动中宣布这款产品正式开源...
  • ​相信大家都在淘宝购买过相关的商品。 比如某一天用户购买了一台台式主机后,淘宝会立刻给该用户推送与电脑相关的商品,例如电脑显示屏,键盘和鼠标等等。 ... ... 比如,在100个人中,有99个人在买了电脑之后,还...
  • ​自然语言处理(Natural Language Processing, NLP)是指计算机通过分析文本,建立计算框架实现语言表示及应用的模型,从而使其获得对语言的理解及应用的能力。 从1950年Turing提出著名的“图灵测试”以来,让...
  • 从官网上看上面没有说支持win10 。 但是实际上已经支持win10了,只是没有官网更新。安装方法。 win10官方网站。... Windows系统安装MindSpore 本文档介绍如何在CPU环境...
  • 点击蓝字关注我们扫码关注我们公众号: 计算机视觉战队扫码回复:华为开源,获取下载链接作者:杨军来源:知乎纯技术讨论,不涉及其他,部分我拿不准的地方,会直接以(?)标识出来,欢迎菊花厂同...
  • ​计算机视觉(Compute Vision,CV)给计算机装上了“眼睛”,让计算机像人类一样也有... 本文以典型的图片分类网络ResNet50为例,介绍一下如何使用MindSpore来完成一个CV应用的开发及部署。 ...
  • 最近华为开源了深度学习框架MindSpore,一时成为了热点。我之前也点评了很多微软、Google、腾讯等厂商的框架,有些点评文章还被官方社区收录,今天为大家解析下MindSpore。 首先阐明下我个人的观点,华为开源深度...
  • 本文是在宿主机Ubuntu16.04上安装Docker,并成功进行MindSpore1.0.0的GPU训练; Ubuntu 16.04 Docker Nvidia-docker (cuda:10.1-base) mindspore-gpu:1.0.0 Dokcer hub上配置好的mindspore-gpu镜像 一、 先讲述...
  • 演讲嘉宾 |于璠(华为MindSpore资深架构师)编辑 |刘静出品 |AI科技大本营(ID:rgznai100)9月,2019中国AI开发者大会(AI ProCo...
  • #含泪"一分钟"跑通MindSpore的LeNet模型 >前言:此文为r0.7-beta的操作实践,为什么我的眼里常含泪水,因为我对踩坑这件事爱得深沉。谨以此文献给和我一样踩坑的小伙伴,纪念踩坑的时刻。 ↑开局一张图,...
1 2 3 4 5 ... 20
收藏数 659
精华内容 263
关键字:

mindspore