基于 MindStudio 完成 SE-ResNeXt101- PyTorch 模型开发_torch npu

基于MindStudio完成SE-ResNext101-Pytorch模型的开发视频链接可参见：
https://www.bilibili.com/video/BV1GP411L74d?spm_id_from=333.999.0.0

基于 MindStudio 完成 SE-ResNeXt101- PyTorch 模型开发

一、PyTorch环境搭建和配置

1.PyTorch简介

​ PyTorch是一个开源的Python机器学习库，基于Torch，用于自然语言处理等应用程序。2017年1月，由Facebook人工智能研究院（FAIR）基于Torch推出了PyTorch。它是一个基于Python的可续计算包，提供两个高级功能：1、具有强大的GPU加速的张量计算（如NumPy）。2、包含自动求导系统的深度神经网络。PyTorch是专门针对 GPU 加速的深度神经网络（DNN）编程。Torch 是一个经典的对多维矩阵数据进行操作的张量（tensor ）库，在机器学习和其他数学密集型应用有广泛应用。

​ PyTorch具有如下优点：

​ **1.简洁：**代码易于理解，PyTorch的源码只有TensorFlow的十分之一左右，更少的抽象、更直观的设计使得PyTorch的源码十分易于阅读。

​ **2.速度：**PyTorch 的灵活性不以速度为代价，在许多评测中，PyTorch 的速度表现胜过 TensorFlow和Keras 等框架。

​ **3.易用：**PyTorch 是所有的框架中面向对象设计的最优雅的一个。PyTorch的面向对象的接口设计来源于Torch，而Torch的接口设计以灵活易用而著称，Keras作者最初就是受Torch的启发才开发了Keras。PyTorch继承了Torch的衣钵，尤其是API的设计和模块的接口都与Torch高度一致。PyTorch的设计最符合人们的思维，它让用户尽可能地专注于实现自己的想法，即所思即所得，不需要考虑太多关于框架本身的束缚。

​ **4.活跃的社区：**PyTorch 提供了完整的文档，循序渐进的指南，作者亲自维护的论坛供用户交流和求教问题。Facebook 人工智能研究院对 PyTorch 提供了强力支持。

​ PyTorch(Caffe2) 通过混合前端，分布式训练以及工具和库生态系统实现快速，灵活的实验和高效生产。PyTorch 和 TensorFlow 具有不同计算图实现形式，TensorFlow 采用静态图机制(预定义后再使用)，PyTorch采用动态图机制(运行时动态定义)。PyTorch 具有以下高级特征：

• 混合前端:新的混合前端在急切模式下提供易用性和灵活性，同时无缝转换到图形模式，以便在C ++运行时环境中实现速度，优化和功能。
• 分布式训练:通过利用本地支持集合操作的异步执行和可从Python和C ++访问的对等通信，优化了性能。
• Python优先: PyTorch为了深入集成到Python中而构建的，因此它可以与流行的库和Cython和Numba等软件包一起使用。
• 丰富的工具和库:活跃的研究人员和开发人员社区建立了丰富的工具和库生态系统，用于扩展PyTorch并支持从计算机视觉到强化学习等领域的开发。
• 本机ONNX支持:以标准ONNX（开放式神经网络交换）格式导出模型，以便直接访问与ONNX兼容的平台，运行时，可视化工具等。
• C++前端：C++前端是PyTorch的纯C++接口，它遵循已建立的Python前端的设计和体系结构。它旨在实现高性能，低延迟和裸机C++应用程序的研究。 使用GPU和CPU优化的深度学习张量库。

2.Ascend PyTorch

基于PyTorch框架的动态图概念，参考对于友商CUDNN、CPU、CUDA、MKL、MKLDNN等算子的实现和库的支持的方式，通过调用单一Ascend TBE算子或调用多个Ascend TBE算子组合的方式，实现PyTorch框架对Ascend NPU的支持。

方案中，Ascend NPU被当做是和GPU同一类别的设备，包括内存管理，设备管理，以及算子调用实现。因此在适配修改方案中，会仿照PyTorch结构中原有的CUDA形式，做一个NPU的扩展。

3.AscendPyTorch环境安装配置

1. 选择合适的AscendPytorch版本

2. 安装Pytorch依赖环境

   如果使用非root用户安装，用户需要在本步骤的每句命令后加**–user**，示例如：pip3 install pyyaml --user。

   pip install pyyaml
   pip install wheel
   1
   2

3. 编译安装PyTorch和昇腾插件

   首先安装官方torch包，然后编译安装插件。

   #x86_64
   pip3 install torch==1.8.1 #若使用pip命令安装cpu版本PyTorch报错，请手动下载whl包安装，下载地址：（https://download.pytorch.org/whl/torch）
   
   #aarch64
   git clone -b v1.8.1 https://github.com/pytorch/pytorch.git --depth=1 pytorch_v1.8.1
   #进入源码安装包获取被动依赖代码。
   cd pytorch_v1.8.1
   git submodule sync
   git submodule update --init --recursive 
   #执行编译安装。
   python3 setup.py install
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11

   编译生成pytorch插件的二进制安装包。

   git clone -b master https://gitee.com/ascend/pytorch.git
   cd pytorch  
   # 下载master分支代码，进入插件根目录
   # 指定python版本编包方式：
   bash ci/build.sh --python=3.7
   # 或
   bash ci/build.sh --python=3.8
   # 或
   bash ci/build.sh --python=3.9
   1
   2
   3
   4
   5
   6
   7
   8
   9

   然后安装pytorch/dist下生成的插件torch_npu包，{arch}为架构名称。可以进入目录下查看

   pip install --upgrade dist/torch_npu-1.8.1rc1-cp37-cp37m-linux_{arch}.whl
   1

4. 最后运行环境变量

   在pytorch目录下执行设置环境变量

   source env.sh
   1

具体安装链接参考https://gitee.com/ascend/pytorch

二、MindStudio工具简介和安装

1.MindStudio工具简介

​ MindStudio是一套基于华为自研昇腾AI处理器开发的AI全栈开发工具平台，包括网络模型移植、应用开发、推理运行及自定义算子开发等功能。通过MindStudio能够进行工程管理、编译、调试、运行、性能分析等全流程开发，提高开发效率。同时，MindStudio是一套基于IntelliJ框架的开发工具链平台，提供了应用开发、调试、模型转换功能，同时还提供了网络移植、优化和分析功能，为用户开发应用程序带来了极大的便利。MindStudio提供以下4项服务功能。

​ 针对安装与部署，MindStudio提供多种部署方式，支持多种主流操作系统，为开发者提供最大便利。

​ 针对算子开发，MindStudio提供包含UT测试、ST测试、TIK算子调试等的全套算子开发流程。支持TensorFlow、PyTorch、MindSpore等多种主流框架的TBE和AI CPU自定义算子开发。

​ 针对网络模型的开发，MindStudio支持TensorFlow、PyTorch、MindSpore框架的模型训练，支持多种主流框架的模型转换。集成了训练可视化、脚本转换、模型转换、精度比对等工具，提升了网络模型移植、分析和优化的效率。

​ 针对应用开发，MindStudio集成了Profiling性能调优、编译器、MindX SDK的应用开发、可视化pipeline业务流编排等工具，为开发者提供了图形化的集成开发环境，通过MindStudio能够进行工程管理、编译、调试、性能分析等全流程开发，能够很大程度提高开发效率。

​ MindStudio功能框架如下图所示，目前含有的工具链包括：模型转换工具、模型训练工具、自定义算子开发工具、应用开发工具、工程管理工具、编译工具、流程编排工具、精度比对工具、日志管理工具、性能分析工具、设备管理工具等多种工具。

MindStudio具有如下功能：

​ 1.TBE算子开发

​ 支持自定义TBE（Tensor Boost Engine）算子开发，利用TBE的性能优化和代码生成能力，实现充分发挥昇腾AI处理器极致性能的自定义算子。

​ ① TBE算子工程创建、代码开发

​ ② TBE算子编译、运行、验证和部署

​ ③ TBE算子仿真运行与性能调优，辅助识别算子性能瓶颈

​ 2.模型转换

​ 将开源框架的网络模型（如Caffe、TensorFlow等）转换成昇腾AI处理器支持的离线模型，模型转换过程中可以实现算子调度的优化、权值数据重排、内存使用优化等。

​ ① 模型转换

​ ② 模型可视化，查看模型结构和算子属性

​ ③ 支持AIPP硬件图像预处理

​ 3.AI应用开发

​ 支持AI应用开发，通过使用开放的模型/算子加载与执行、媒体数据处理等C++ API，支撑用户开发深度神经网络应用，用于实现目标识别、图像分类等功能。

​ ① 应用工程创建、代码开发（C++）

​ ② 工程编译、上板运行、结果输出

​ ③ 工程的单步调试

​ ④ 应用性能分析，辅助应用性能瓶颈定位

​ 4.性能调优

​ 提供高效、易用、可灵活扩展的系统化性能分析工具，便于快速识别产品的关键性能瓶颈并提出针对性能优化的建议，实现产品的极致性能。

​ ① 性能数据自动采集与Profiling

​ ② 性能Timeline视图，查看运行的Stream和Task

​ ③ 性能统计视图分析，识别最耗时的算子

​ 5.算子比对

​ 为了定位/解决模型的精度问题，算子比对工具提供了将华为自有模型算子的运算结果与Caffe标准算子的运算结果进行比对的功能，以便快速确认误差发生的原因。

​ ① 整网或者指定网络层输出数据

​ ② 整网算子比对和分析

​ ③ Lower Bound比对算法，Vector比对算法（余弦相似度、最大绝对误差、累积相对误差、欧式相对距离等）

​ 6.智能代码编辑

​ 支持C/C++、Python语言语法高亮、定义跳转、自动完成、参数提示。

2.MindStudio安装

​ MindStudio支持Ubuntu，Euler和Cent OS多种操作系统。MindStudio可以在Ubuntu服务器上使用原生桌面自带的终端gnome-terminal进行安装，也可以在Windows服务器上通过SSH登录到Ubuntu服务器进行安装，因为MindStudio是一款GUI程序，所以在Windows服务器上通过SSH登录到Ubuntu服务器进行安装时，需要使用集成了Xserver的SSH终端（比如mobaxterm）。

2.1 安装流程

step1：环境要求

step2：准备软件包

step3：安装依赖

step4：安装MindStudio

2.2 环境要求

将MindStudio安装在Windows服务器上时，Windows服务器为本地环境，Linux服务器为远端环境。

本地环境要求：Windows 10 x86_64操作系统

本地环境依赖：

• Python（版本要求：3.7~3.9）
• MinGW
• CMake
• ACLib（可选，Windows工控机场景开发Windows应用）

2.3 准备软件包

1.软件安装前，请获取所需软件包和对应的数字签名文件。

（1）MindStudio_5.0.RC1_win.exe，MindStudio安装包，需要安装后使用

（2）MindStudio_5.0.RC1_win.zip，MindStudio免安装压缩包，解压后可直接运行

获取链接：https://www.hiascend.com/software/mindstudio/download

2.为了防止软件包在传递过程或存储期间被恶意篡改，下载软件包时需下载对应的数字签名文件用于完整性验证。

3.安装MindStudio的两种方式

（1）以免安装压缩包.zip文件形式，直接解压到相应文件目录即可

（2）下载exe文件以及对应的数字签名文件，

2.4 安装依赖

安装python依赖

1.在Python官网下载Python安装包到Windows本地系统。MindStudio目前支持Python版本为3.7~3.9，下面以安装Python3.7.5依赖包为例。选择Windows x86-64 executable installer。

其他安装细节请参考链接：

https://www.hiascend.com/document/detail/zh/mindstudio/50RC1/instg

2.打开系统命令行，输入python -V命令确认python版本是否为3.7.5。安装Python3相关依赖。

pip install xlrd==1.2.0 
pip install absl-py
pip install numpy
1
2
3

如若返回如下信息，则表示安装成功。

Successfully installed xlrd-1.2.0
Successfully installed absl-py-0.12.0 six-1.15.0
Successfully installed numpy-1.20.1
1
2
3

安装MinGW依赖

1.下载最新的MinGW安装包，根据系统选择对应版本，例如windows64位选择x86_64-posix-seh。

2.解压MinGW安装包到自定义路径。

3.将MinGW安装路径添加到系统变量中。

安装细节参见链接：

https://www.hiascend.com/document/detail/zh/mindstudio/50RC1/instg

4.打开系统命令行，输入gcc -v命令。
当界面提示“gcc version x.x.x (x86_64-posix-sjlj-rev0, Built by MinGW-W64 project)”信息时，表示安装成功。

安装CMake

CMake是个一个开源的跨平台自动化建构系统，用来管理软件建置的程序，并不依赖于某特定编译器，并可支持多层目录、多个应用程序与多个库。可以登录CMake官网下载CMake。以msi格式软件包为例，安装步骤如下：

1. 单击快捷键“win+R”，输入cmd，单击快捷键“Ctrl+Shift+Enter”，进入管理员权限命令提示符。若弹出“用户帐户控制”提示窗口，单击“是”。

2. 执行以下命令，安装软件包：

   msiexec /package {path}**{name}.msi

   例如：

   msiexec /package D:\cmake-3.16.5-win64-x64.msi

3. 安装。推荐安装版本3.16.5-win64-x64

安装细节参见链接：
https://www.hiascend.com/document/detail/zh/mindstudio/50RC1/instg

安装ACLlib包

如果用户需要开发Windows应用，并在本地编译或运行（已安装Atlas加速卡的Windows服务器才能运行），请安装此包和对应的依赖。详细操作请参见《CANN Windows版用户指南》的“ACLlib安装与卸载”章节和“配置开发环境”章节。

安装MindStudio

安装参考链接：

https://www.hiascend.com/document/detail/zh/mindstudio/50RC1/instg/instg_000023.html

启动MindStudio，如果没有报错信息且能正常进入欢迎界面如图，则表示MindStudio安装成功

三、训练工程创建，工程功能以及相关菜单介绍

1.启动MindStudio。

2.本文以SE-ResNeXt101模型为例，介绍使用MindStudio进行PyTorch模型训练开发。

下载SE-ResNeXt101项目代码，项目地址为：

https://gitee.com/ascend/modelzoo-his/tree/master/contrib/PyTorch/Research/cv/image_classification/SE-ResNext-101-32x4d

3.新建Ascend Training工程。工程信息由用户自行根据实际配置。单击“Next”，进入训练工程选择界面。

4.选择PyTorch Project

5.项目结构如图所示。该项目结构目录是将下载的SE-ResNext101项目拷贝到新建的工程目录下生成。

6.代码目录结构如图所示

├─ SE-ResNext-101-32x4d
    │─ demo.py				#（可选）用于运行单p在线推理
    │─ main.py				#主文件
    │─ models.py			#网络模型文件
    │─ README.md			#SE-ResNext101模型介绍相关文件
    │─ requirements.txt    	#Python依赖库信息
    └─test
       │─ env_npu.sh			#标准的npu环境变量
       │─ train_eval_8p.sh		#（可选）运行8p的eval脚本
       │─ train_finetune_1p.sh	#1p 模型迁移脚本，运行一定step，主要为功能实现，能够支持加载预训练模型修改class_num进行运行，一般将class_num设置为默认数据集class_num+1即可
       │─ train_full_1p.sh		#（可选）1p 完整训练脚本，要求能够复现精度性能，若使用8P脚本对齐精度则1P脚本非必须
       │─ train_full_8p.sh		#8p 完整训练脚本，要求能够复现精度性能
       │─ train_performance_1p.sh	#1p 性能脚本，运行一定step，得到性能数据，运行时长应该控制在30min内或1000step以内
       │─ train_performance_8p.sh	#8p 性能脚本，运行一定step，得到性能数据，运行时长应该控制在30min内或1000step以内
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7.点击File->Projects Structure->Add Python SDK->SSH Interpreter->Deploy

8.点击File->settings->tools->deployment，配置映射。点击左上角加号，输入连接名称。 Local Path要求的是填入本地的项目名称路径，Deployment Path的是部署到服务器上的项目名称，这两个可以保持一致，也可以不保持一致。excluded paths（非必需）为配置忽略路径，表示忽略的项目文件不会上传到远程服务器。

9.选择所需要的python解释器。Name的值可以随意取。完成配置。等待进度条结束，将会自动上传项目到远程服务器。 Tools->Deployment-> 勾选Automatic Upload，可以在每次本地文件保存后，自动同步项目到服务器。

至此，本地项目连接到远程服务器的步骤完成。

四、使用MindStudio训练SE-ResNext101模型

1.模型介绍及数据集

1. 论文名称：Squeeze-and-Excitation Networks

2. 项目地址：https://gitee.com/ascend/modelzoo-his/tree/master/contrib/PyTorch/Research/cv/image_classification/SE-ResNext-101-32x4d

3. 模型架构：SE-ResNeXt101-32x4d是在Resenext101-32x4d模型基础上增加了SE模块。
   

4. 数据集：ImageNet数据集

   ImageNet是一个计算机视觉系统识别项目，是目前世界上图像识别最大的数据库。是美国斯坦福的计算机科学家，模拟人类的识别系统建立的。ImageNet数据集包含1000个类别，里面包含120多万的自然图像，大概有150G。且评价指标是固定的top1、top5等。

   ImageNet数据集下载链接：https://image-net.org/

2.代码介绍

• 运用mmclassification，mmclassification是一款基于 PyTorch 的开源图像分类工具箱, 集成了常用的图像分类网络，将数据加载，模型骨架，训练调参，流程等封装为模块调用。Github链接如下：
  https://github.com/open-mmlab/mmclassification/blob/master/configs/base/models/

• seresnext101_32x4d.py 配置文件如下：将模型的结构参数以字典的形式保存

  # model settings  
  model = dict(  
      type='ImageClassifier',  
      backbone=dict(  
          type='SEResNeXt',  
          depth=101,  
          num_stages=4,  
          out_indices=(3, ),  
          groups=32,  
          width_per_group=4,  
          se_ratio=16,  
          style='pytorch'),  
      neck=dict(type='GlobalAveragePooling'),  
      head=dict(  
          type='LinearClsHead',  
          num_classes=1000,  
          in_channels=2048,  
          loss=dict(type='CrossEntropyLoss', loss_weight=1.0),  
          topk=(1, 5),  
      ))  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20

• model.py详细模型文件，SE-ResNext101模型架构如下

  def forward(self, x):
          x = self.conv1(x)
          x = self.bn1(x)
          x = self.relu(x)
          x = self.maxpool(x)
  
          x = self.layer1(x)
          x = self.layer2(x)
          x = self.layer3(x)
          x = self.layer4(x)
  
          x = self.avgpool(x)
          x = x.view(x.size(0), -1)
          x = self.fc(x)
  
          return x
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• main.py主文件的参数设置

  def main():
      parser = argparse.ArgumentParser(description='PyTorch Se-ResNeXt101 ImageNet Training')
  
      # dataset setting
      parser.add_argument('--data_path', metavar='DIR', default='/opt/npu/imagenet',
                          help='path to dataset')
      parser.add_argument('--workers', default=192, type=int, metavar='N',
                          help='number of data loading workers (default: 4)')
  
      # training setting
      parser.add_argument('--epochs', default=100, type=int, metavar='N',
                          help='number of total epochs to run')
      parser.add_argument('--batch-size', default=128, type=int,
                          metavar='N',
                          help='mini-batch size (default: 256), this is the total '
                               'batch size of all GPUs on the current node when '
                               'using Data Parallel or Distributed Data Parallel')
      parser.add_argument('--lr', default=0.6, type=float,
                          metavar='LR', help='initial learning rate', dest='lr')
      parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
                          help='momentum')
      parser.add_argument('--weight-decay', default=1e-4, type=float,
                          metavar='W', help='weight decay (default: 1e-4)',
                          dest='weight_decay')
  
      # apex setting
      parser.add_argument('--amp', default=True, action='store_true',
                          help='use amp to train the model')
      parser.add_argument('--opt-level', default="O2", type=str, help='apex optimize level')
      parser.add_argument('--loss-scale-value', default=None, type=float, help='static loss scale value')
      parser.add_argument('--combine-grad', default=True, action='store_true',
                          help='use amp to train the model')
  
      # basic distribution setting 
      parser.add_argument('--ddp',
                          dest='ddp',
                          action='store_true',
                          help='use distribution training')
      parser.add_argument('--nodes', default=1, type=int,
                          help='number of data loading workers (default: 4)')
      parser.add_argument('--node_rank', default=0, type=int,
                          help='ranking within the nodes')
      parser.add_argument('--device_list', default='0,1,2,3,4,5,6,7', type=str, help='device id list')
      parser.add_argument('--seed', default=None, type=int,
                          help='seed for initializing training. ')
      parser.add_argument('--print-freq', default=10, type=int,
                          metavar='N', help='print frequency (default: 10)')
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47

• 模型训练过程：

  def train(train_loader, model, criterion, optimizer, epoch, deviceid, args):
      # switch to train mode
      batch_time = AverageMeter('Time', ':6.3f')
      data_time = AverageMeter('Data', ':6.3f')
      losses = AverageMeter('Loss', ':.4e')
      top1 = AverageMeter('Acc@1', ':6.2f')
      top5 = AverageMeter('Acc@5', ':6.2f')
      progress = ProgressMeter(
          len(train_loader),
          [batch_time, data_time, losses, top1, top5],
          prefix="Epoch: [{}]".format(epoch))
      # switch to train mode
      model.train()
      optimizer.zero_grad()
      end = time.time()
      for i, (images, target) in enumerate(train_loader):
          images = images.npu(non_blocking=True)
          target = target.long().npu(non_blocking=True)
          if args.mainprocess:
              # measure data loading timetime
              data_time.update(time.time() - end)
          output = model(images)
          loss = criterion(output, target.long())
          with amp.scale_loss(loss, optimizer) as scaled_loss:
              scaled_loss.backward()
          optimizer.step()
          optimizer.zero_grad()
          if args.mainprocess:
              acc1, acc5 = accuracy(output, target, topk=(1, 5))
              losses.update(loss.item(), images.size(0))
              top1.update(acc1[0], images.size(0))
              top5.update(acc5[0], images.size(0))
              # measure elapsed time
              batch_time.update(time.time() - end)
              end = time.time()
  
          if i % args.print_freq == 0 and args.mainprocess:
              progress.display(i)
  
          if args.stop_step_num is not None and i >= args.stop_step_num:
              break
  
      if args.mainprocess and batch_time.avg:
          print("[npu id:", deviceid, "]", "batch_size:", args.world_size * args.batch_size,
                'Time: {:.3f}'.format(batch_time.avg), '* FPS@all {:.3f}'.format(
                  args.batch_size * args.world_size / batch_time.avg))
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46

• 模型验证过程：

  def validate(val_loader, model, criterion, deviceid, args):
      # switch to validate mode
      batch_time = AverageMeter('Time', ':6.3f')
      losses = AverageMeter('Loss', ':.4e')
      top1 = AverageMeter('Acc@1', ':6.2f')
      top5 = AverageMeter('Acc@5', ':6.2f')
      progress = ProgressMeter(
          len(val_loader),
          [batch_time, losses, top1, top5],
          prefix='Test: ')
  
      # switch to evaluate mode
      model.eval()
      with torch.no_grad():
          end = time.time()
          for i, (images, target) in enumerate(val_loader):
              images = images.npu(non_blocking=True)
              target = target.to(torch.int32).npu(non_blocking=True)
              # compute output
              output = model(images)
              loss = criterion(output, target.long())
              # measure accuracy and record loss
              acc1, acc5 = accuracy(output, target, topk=(1, 5))
              if args.mainprocess:
                  losses.update(loss.item(), images.size(0))
                  top1.update(acc1[0], images.size(0))
                  top5.update(acc5[0], images.size(0))
                  # measure elapsed time
                  batch_time.update(time.time() - end)
              end = time.time()
              if i % args.print_freq == 0 and args.mainprocess:
                  progress.display(i)
          if args.mainprocess:
              print("[gpu id:", deviceid, "]", '[AVG-ACC] * Acc@1 {top1.avg:.3f} Acc@5 {top5.avg:.3f}'
                    .format(top1=top1, top5=top5))
      return top1.avg
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36

• 数据集加载函数：

  def dataloader(args):
      """ Create training & validation dataloader """
      traindir = os.path.join(args.data_path, 'train')
      valdir = os.path.join(args.data_path, 'val')
      normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                       std=[0.229, 0.224, 0.225])
  
      # Create Dataset
      train_dataset = datasets.ImageFolder(
          traindir,
          transforms.Compose([
              transforms.RandomResizedCrop(224),
              transforms.RandomHorizontalFlip(),
              transforms.ToTensor(),
              normalize,
          ]))
  
      val_dataset = datasets.ImageFolder(valdir, transforms.Compose([
          transforms.Resize(256),
          transforms.CenterCrop(224),
          transforms.ToTensor(),
          normalize,
      ]))
  
      # Create Sampler
      if args.distributed:
          train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset,       num_replicas=args.world_size, rank=args.rank)
      else:
          train_sampler = None
  
      # Create Loader
      train_loader = torch.utils.data.DataLoader(dataset = train_dataset,
                                                 batch_size=args.batch_size,
                                                 shuffle=(train_sampler is None),
                                                 num_workers=args.loader_workers,
                                                 drop_last=True,
                                                 pin_memory=False,
                                                 sampler=train_sampler)
  
      val_loader = torch.utils.data.DataLoader(dataset = val_dataset,
                                               batch_size=args.batch_size,
                                               shuffle=False,
                                               drop_last=True,
                                               num_workers=args.loader_workers,
                                               pin_memory=False,
                                               sampler=None)
  
      return train_loader, val_loader, train_sampler
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48

• 最后是精度定义函数，本项目的评价指标

  def accuracy(output, target, topk=(1,)):
      """Computes the accuracy over the k top predictions for the specified values of k"""
      with torch.no_grad():
          maxk = max(topk)
          batch_size = target.size(0)
  
          _, pred = output.topk(maxk, 1, True, True)
          pred = pred.t()
          correct = pred.eq(target.view(1, -1).expand_as(pred))
  
          res = []
          for k in topk:
              temp = correct[:k]
              correct_k = temp.reshape(-1).float().sum(0, keepdim=True)
              res.append(correct_k.mul_(100.0 / batch_size))
          return res
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

3.模型训练

1.在每次训练完成后，请将服务器中output目录下的文件同步到本地，否则再次运行时这些文件将会被删除，导致不能评估。

2.首先运行env.sh环境搭建脚本。

点击Run->Edit Configurations，在弹出的配置页面中，点击左上角“+”按钮，选择Ascend Training，如下图。Name为该运行配置名称，不能重复。Executable填入本地被执行文件位置，选择./test/env_npu.sh。然后运行。

3.执行1p 完整训练脚本。

同上，点击Run->Edit Configurations，在弹出的配置页面中，点击左上角“+”按钮，选择Ascend Training，如下图。Name：train_full_1p。Executable选择./test/train_full_1p.sh。Command Arguments选择–data_path=/data/imagenet

参数配置如下：

训练过程如下图所示（部分）：(训练过程重定向到了910A_1p.log)

4.执行8p完整训练脚本

点击Run->Edit Configurations，在弹出的配置页面中，点击左上角“+”按钮，选择Ascend Training，如下图。Name：train_full_8p。Executable选择./test/train_full_8p.sh。Command Arguments选择–data_path=/data/imagenet

训练过程如下图所示（部分）：(训练过程重定向到了910A_8p.log)

五、FAQ

1. pip安装pytorch后在import torch时报错ImportError: llibpython3.7m.so: cannot open shared object file: No such file or directory。

   解决方法：如果环境上没有/usr/lib64，则复制/usr/lib目录：

   sudo cp /usr/local/python3.7.5/lib/libpython3.7m.so /usr/lib
   1

2. linux系统下如何查看CANN版本。

   解决方法步骤如下：

   1. 以软件包的安装用户登录软件包的安装环境。

   2. 进入软件包安装信息文件目录。（以下以Ascend-cann-toolkit软件包为例）

      cd /usr/local/Ascend/ascend-toolkit/latest/{arch}-linux
      1

      其中/usr/local/Ascend为root用户默认安装路径，请用户根据实际情况替换。*{arch}*表示CPU架构（arm64或x86_64）。

   3. 在命令行执行以下命令获取版本信息。

      cat ascend_toolkit_install.info
      1

3. 查看服务器的架构信息

   uname -m
   1

4. syntax error near unexpected token 报错问题，运行mindstudio时，控制台报错

   解决方法1：使用dos2unix工具进行处理。

   在linux上安装dos2unix工具：sudo apt-get install dos2unix（根据系统使用不同命令安装）

   安装成功后可以定义一个shell脚本，或者手动执行一下命令

   dos2unix *.sh

   就会看到：dos2unix: converting file *.sh to Unix format …

   就将这个文件转换为了linux下的执行文件了。

   解决方法2：根据报错行代码重新手动换行。

5. AscendPytorch1.5.0和AscendPytorch1.8.1两者差别很大。

   a.下载安装方面：

   # AscendPytorch1.5.0没有torch_npu包，只需要下载下面两者包即可
   pip install apex-0.1+ascend-cp37-cp37m-linux_aarch64.whl  
   pip install torch-1.5.0+ascend.post5.20220505-cp37-cp37m-linux_aarch64.whl
   
   # AscendPytorch1.8.1导入了torch_npu库
   apex-0.1+ascend.20220505-cp37-cp37m-linux_aarch64.whl         
   torch_npu-1.8.1rc2.20220505-cp37-cp37m-linux_aarch64.whl
   torch-1.8.1+ascend.rc2.20220505-cp37-cp37m-linux_aarch64.whl
   1
   2
   3
   4
   5
   6
   7
   8

   b.代码编写方面

   # AscendPytorch1.5.0没有torch_npu包，只需要下载下面两者包即可
   >>import torch
   >>torch.npu.set_device(0)
   
   # AscendPytorch1.8.1导入了torch_npu库
   >>import torch_npu
   >>torch_npu.npu.set_device(0)
   1
   2
   3
   4
   5
   6
   7

六、从昇腾官方体验更多内容和支持

欢迎大家在昇腾论坛进行讨论和交流：https://bbs.huaweicloud.com/forum/forum-726-1.html

在这可以进行问题的求助，也可以分享自己在使用昇腾过程中积累的经验。