分别在(ModelAtrs)Ascend、(Ubuntu16.04服务器+18.04镜像)GPU、(Ubuntu18.04)CPU下通过MindSpore实现（cifar10）图像分类

Anaconda安装
在要运行的环境下安装Anaconda（或Miniconda），我选择的是Anaconda。Anaconda下载地址
安装步骤

#获取下载的文件Anaconda3-2021.04-Linux-x86_64.sh
cd ./home
wget https://repo.anaconda.com/archive/Anaconda3-2021.05-Linux-x86_64.sh
#执行安装文件
bash ./Anaconda3-2021.04-Linux-x86_64.sh
#同意安装协议输入yes和一堆回车
#安装结束需要输入yes初始化Miniconda
source ~/.bashrc     #更新环境变量
conda -V   #查看是否安装成功(或者另开一个窗口测试)

MindSpore下载
版本列表地址：根据不同环境（CPU、GPU）下载不同版本MindSpore。本文以MindSpore1.1.1为例，GPU加速的MindSpore下载地址。

ResNet-50实现cifar10图像分类
具体实验介绍参考另一篇文章使用ResNet-50网络实现图像分类
文件结构
cifar10：下载地址。解压得到得到cifar10
resnet.py：下载地址
mindsporetest.py

from IPython import get_ipython
import mindspore.nn as nn
from mindspore import dtype as mstype
import mindspore.dataset as ds
import mindspore.dataset.vision.c_transforms as C
import mindspore.dataset.transforms.c_transforms as C2
from mindspore import context
import numpy as np
import matplotlib.pyplot as plt

context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
#根据不同加速环境选择CPU、GPU、Ascend
def create_dataset(data_home, repeat_num=1, batch_size=32, do_train=True, device_target="CPU"):
    """
    create data for next use such as training or inferring
    """

    cifar_ds = ds.Cifar10Dataset(data_home,num_parallel_workers=8, shuffle=True)

    c_trans = []
    if do_train:
        c_trans += [
            C.RandomCrop((32, 32), (4, 4, 4, 4)),
            C.RandomHorizontalFlip(prob=0.5)
        ]

    c_trans += [
        C.Resize((224, 224)),
        C.Rescale(1.0 / 255.0, 0.0),
        C.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),
        C.HWC2CHW()
    ]

    type_cast_op = C2.TypeCast(mstype.int32)

    cifar_ds = cifar_ds.map(operations=type_cast_op, input_columns="label", num_parallel_workers=8)
    cifar_ds = cifar_ds.map(operations=c_trans, input_columns="image", num_parallel_workers=8)

    cifar_ds = cifar_ds.batch(batch_size, drop_remainder=True)
    cifar_ds = cifar_ds.repeat(repeat_num)

    return cifar_ds


ds_train_path = "./cifar10/train/"
dataset_show = create_dataset(ds_train_path)
with open(ds_train_path+"batches.meta.txt","r",encoding="utf-8") as f:
    all_name = [name.replace("\n","") for name in f.readlines()]

iterator_show= dataset_show.create_dict_iterator()
dict_data = next(iterator_show)
images = dict_data["image"].asnumpy()
labels = dict_data["label"].asnumpy()
count = 1
get_ipython().run_line_magic('matplotlib', 'inline')
for i in images:
    plt.subplot(4, 8, count)
    # Images[0].shape is (3,224,224).We need transpose as (224,224,3) for using in plt.show().
    picture_show = np.transpose(i,(1,2,0))
    picture_show = picture_show/np.amax(picture_show)
    picture_show = np.clip(picture_show, 0, 1)
    plt.title(all_name[labels[count-1]])
    picture_show = np.array(picture_show,np.float32)
    plt.imshow(picture_show)
    count += 1
    plt.axis("off")

print("The dataset size is:", dataset_show.get_dataset_size())
print("The batch tensor is:",images.shape)
plt.show()


from resnet import resnet50

net = resnet50(batch_size=32, num_classes=10)

import mindspore.nn as nn
from mindspore.nn import SoftmaxCrossEntropyWithLogits

ls = SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
opt = nn.Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01, 0.9)



from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
from mindspore import load_checkpoint, load_param_into_net
import os
from mindspore import Model

model = Model(net, loss_fn=ls, optimizer=opt, metrics={'acc'})
# As for train, users could use model.train

epoch_size = 10
ds_train_path = "./cifar10/train/"
model_path = "./models/ckpt/mindspore_vision_application/"
os.system('rm -f {0}*.ckpt {0}*.meta {0}*.pb'.format(model_path))

dataset = create_dataset(ds_train_path )
batch_num = dataset.get_dataset_size()
config_ck = CheckpointConfig(save_checkpoint_steps=batch_num, keep_checkpoint_max=35)
ckpoint_cb = ModelCheckpoint(prefix="train_resnet_cifar10", directory=model_path, config=config_ck)
loss_cb = LossMonitor(142)
model.train(epoch_size, dataset, callbacks=[ckpoint_cb, loss_cb])

# As for evaluation, users could use model.eval
ds_eval_path = "./cifar10/test/"
eval_dataset = create_dataset(ds_eval_path, do_train=False)
res = model.eval(eval_dataset)
print("result: ", res)


# ## 总结
# 
# 本次体验，带领体验者了解了MindSpore的卷积神经网络ResNet-50，通过构建ResNet-50对CIFAR-10进行分类。可以看出MindSpore的ResNet-50的构建非常容易，损失函数和优化器都有封装好的API，对于初学者和研发人员都非常的友善。

（Ubuntu18.04服务器）CPU运行

云服务器信息

环境配置
配置安装Anaconda
进入mindsporetest.py的目录

#安装好Anaconda

#命令创建虚拟环境，Python版本为3.7.5
conda create –n MindSpore python==3.7.5
#激活对应虚拟环境：
conda activate MindSpore
#安装MindSpore 1.1.1版本
pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.1.1/MindSpore/cpu/ubuntu_x86/mindspore-1.1.1-cp37-cp37m-linux_x86_64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com
#测试是否安装成功
python
import mindspore     #无报错则说明安装成功
conda activate MindSpore
python mindsporetest.py
#如果报错相关的相关的包，再MindSpore下通过
#pip install matplotlib ipython
#进行下载

测试结果



结果分析
最后一个模型的正确率没有运行出来没因为前面有一行代码忘记注释掉了，前面发生了报错，时间主要花费在了训练和保存模型文件，并且一共迭代了十次，大概花费了9个小时，emmmm当初由于代金券余额不充足没有选择更高配置的环境。

还有一个有意思的事情，服务器下的CPU在运行时显示 training process will be performed with dataset no sink。具体分析可以查看这篇文章：MindSpore model.train中的dataset_sink_mode该如何理解？

至于或者Ubuntu18.04的图像化界面，刚开始直接使用命令行感觉不太舒服，总想安装一波图形化界面，其实也挺好玩的，就又试了一下。其实也很简单可以参考官方文章：Ubuntu系列弹性云服务器如何安装图形化界面？

（Ubuntu16.04服务器+18.04镜像）GPU加速

华为云服务器信息：

MindSpore环境搭建：
环境搭建思路：服务器能提供的GPU加速的Ubuntu版本只有16.04所以需要先在Ubuntu16.04上拉取cuda10.1-cudnn7-ubuntu18.04的镜像，然后在容器中通过Anaconda创建python3.7.5的环境并成功安装mindspore_gpu_1.1.1。

#安装nvidia-docker之前必须在宿主机上安装nvidia-driver和docker；

nvidia-smi                    # 检查宿主机是否安装了 nvidia-driver
docker version                # 检查宿主机上安装的docker版本
nvidia-docker version         # 检查宿主机上安装的nvidia-docker版本
#貌似服务器上都已经安装了

安装步骤
为避免不必要的错误，后续使用的全部都是nvidia-docker

#拉取nvidia/cuda:10.1-cudnn8-devel-ubuntu18.04的镜像
nvidia-docker pull nvidia/cuda:10.1-cudnn7-devel-ubuntu18.04  

#镜像内创建容器此处一定是nvidia-docker创建
nvidia-docker run -it nvidia/cuda:10.1-cudnn7-devel-ubuntu18.04 /bin/bash
#此时进入容器并有一个containerID

#在容器内安装Anaconda
##容器内直接下载可能会报错，所以用exit退出容器
exit
##进入ubuntu下的./home文件夹下
cd ./home

#获得Anaconda安装文件
wget https://repo.anaconda.com/archive/Anaconda3-2021.05-Linux-x86_64.sh
#anaconda3.sh 文件拷贝至容器根目录下,containID换成自己的
nvidia-docker  cp ./home/Anaconda3-2021.05-Linux-x86_64.sh containerID:/
# 启动容器并进入
nvidia-docker  start containerID
nvidia-docker exec -it containerID  /bin/bash
# 安装anaconda
bash Anaconda3-2021.05-Linux-x86_64.sh
………
……… #一系列操作安装Anaconda
conda -V #查看是否安装成功
#安装anaconda后需先退出容器再进入，才能再容器中使用conda
exit
nvidia-docker  start containerID
nvidia-docker exec -it containerID  /bin/bash
#进入容器，创建MindSpore虚拟环境
conda create -n mindspore1.1.1 python=3.7.5 
# 激活指定环境
conda activate mindspore1.1.1 
###在从ubuntu向容器中拷贝文件时可以多开一个远程连接就不用一直进入和退出容器。

#下面操作为另一个连接窗口
#ubuntu下载GPU版本的mindspore_gpu-1.1.1-cp37-cp37m-linux_x86_64.whl并拷贝到容器中
cd ./home
wget https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.1.1/MindSpore/gpu/ubuntu_x86/cuda-10.1/mindspore_gpu-1.1.1-cp37-cp37m-linux_x86_64.whl
nvidia-docker  cp ./home/mindspore_gpu-1.1.1-cp37-cp37m-linux_x86_64.whl containerID:/
#在ubuntu下创建testGPU.py并拷贝到容器中测试环境是否配置成功
vim testGPU.py
nvidia-docker  cp ./home/testGPU.py containerID:/

#在容器中执行文件安装mindspore_gpu-1.1.1-cp37-cp37m-linux_x86_64.whl并测试
(mindspore1.1.1)root@containID: pip install mindspore_gpu-1.1.1-cp37-cp37m-linux_x86_64.whl
(mindspore1.1.1)root@containID: python testGPU.py
#运行结果如下，则说明安装成功
[[[ 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.]]]

testGPU.py

import numpy as np
from mindspore import Tensor
from mindspore.ops import functional as F
import mindspore.context as context
context.set_context(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))

实验文件结构
cifar10、resnet.py、mindsporetest.py(将device_target设为GPU)

nvidia-docker  cp ./home/cifar10 containerID:/
nvidia-docker  cp ./home/resnet.py containerID:/
nvidia-docker  cp ./home/mindsporetest.py containerID:/

测试结果

结果分析

实际测试结果还是比较快的，大概花费了40分钟左右吧，上面的实验步骤是参考了另一篇配置mindspore1.0.1的文章：【MindSpore】Ubuntu16.04上成功安装GPU版MindSpore1.0.1，收获颇多，而且文章很清晰。

在根据文章配置的时候也遇到了一些其他零碎的问题，但也参考搜索了其他文章并一一解决。(Nvidia-docker好像出了点问题)。

其实在前面测试了直接在ubuntu16.04配置环境，没有使用容器，也不了解这个概念，然后就把开始的那个服务器搞得进不去了，其实最开始参考的那篇文章也有问题。

（ModelArts服务器）Ascend加速

MindSpore：教程 (r1.2)机器视觉 >使用ResNet-50网络实现图像分类：使用ResNet-50网络实现图像分类

MindSpore教程：run in ModelAtrs

实验准备
使用ModelArts需要在对象存储服务中创建OBS桶，然后将通过OBS桶上传到ModelAtrs中。

实验结果：

实验分析
这个MoedelAtrs服务器是比较容易搭建的，而且测试速度极快，但是花费有点小高。而且对于那个文件目录我还是没有太过理解，不清楚那个wget下载的文件的存储位置，但也算是勉强出来结果了。具体代码和步骤可以参考官方教程。

最后贴上服务器费用…