Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
Browse Source

1. add README_CN to resnet and maskrcnn 

2. fix bug of bounding_box_encode kernel_name
tags/v1.2.0-rc1
gengdongjie 5 years ago
parent
b97efc9da2
commit
4df459f7ee
4 changed files with 1203 additions and 3 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -3
      mindspore/_extends/parallel_compile/tbe_compiler/compiler.py
  2. +454
    -0
      model_zoo/official/cv/maskrcnn/README_CN.md
  3. +498
    -0
      model_zoo/official/cv/resnet/README_CN.md
  4. +251
    -0
      model_zoo/official/cv/warpctc/README_CN.md

+ 0
- 3
mindspore/_extends/parallel_compile/tbe_compiler/compiler.py View File

@@ -105,9 +105,6 @@ def build_op(build_type, json_str):
raise ValueError("Op:{} function {} is not supported by Tbe.".format(op_name, build_type)) raise ValueError("Op:{} function {} is not supported by Tbe.".format(op_name, build_type))


# call function # call function
if op_name == "bounding_box_encode":
return op_func(*inputs_args, *outputs_args, *attrs_args, kernel_name_val=kernel_name)

if is_dynamic_shape: if is_dynamic_shape:
with te.op.dynamic(): with te.op.dynamic():
op_func(*inputs_args, *outputs_args, *attrs_args, kernel_name=kernel_name) op_func(*inputs_args, *outputs_args, *attrs_args, kernel_name=kernel_name)


+ 454
- 0
model_zoo/official/cv/maskrcnn/README_CN.md View File

@@ -0,0 +1,454 @@
# 目录

<!-- TOC -->

- [目录](#目录)
- [MaskRCNN概述](#maskrcnn概述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本和样例代码](#脚本和样例代码)
- [脚本参数](#脚本参数)
- [训练脚本参数](#训练脚本参数)
- [参数配置](#参数配置)
- [训练过程](#训练过程)
- [训练](#训练)
- [分布式训练](#分布式训练)
- [训练结果](#训练结果)
- [评估过程](#评估过程)
- [评估](#评估)
- [评估结果](#评估结果)
- [模型说明](#模型说明)
- [性能](#性能)
- [训练性能](#训练性能)
- [评估性能](#评估性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo首页](#modelzoo首页)

<!-- /TOC -->

# MaskRCNN概述

MaskRCNN是一种概念简单、灵活、通用的目标实例分割框架，在检测出图像中目标的同时，还为每一个实例生成高质量掩码。这种称为Mask R-CNN的方法，通过添加与现有边框识别分支平行的预测目标掩码分支，达到扩展Faster R-CNN的目的。Mask R-CNN训练简单，运行速度达5fps，与Faster R-CNN相比，开销只有小幅上涨。此外，Mask R-CNN易于推广到其他任务。例如，允许在同一框架中预测人体姿势。
Mask R-CNN在COCO挑战赛的三个关键难点上都表现不俗，包括实例分割、边框目标检测和人物关键点检测。Mask R-CNN没有什么华而不实的附加功能，各任务的表现都优于现存所有单模型，包括COCO 2016挑战赛的胜出模型。

# 模型架构

MaskRCNN是一个两级目标检测网络，作为FasterRCNN的扩展模型，在现有的边框识别分支的基础上增加了一个预测目标掩码的分支。该网络采用区域候选网络（RPN），可与检测网络共享整个图像的卷积特征，无需任何代价就可轻松计算候选区域。整个网络通过共享卷积特征，将RPN和掩码分支合并为一个网络。

[论文](http://cn.arxiv.org/pdf/1703.06870v3)："MaskRCNN"

# 数据集

- [COCO2017](https://cocodataset.org/)是一个广泛应用的数据集，带有边框和像素级背景注释。这些注释可用于场景理解任务，如语义分割，目标检测和图像字幕制作。训练和评估的图像大小为118K和5K。

- 数据集大小：19G
- 训练：18G，118,000个图像
- 评估：1G，5000个图像
- 注释：241M；包括实例、字幕、人物关键点等

- 数据格式：图像及JSON文件
- 注：数据在[dataset.py](http://dataset.py/)中处理。

# 环境要求

- 硬件（昇腾处理器）
- 采用昇腾处理器搭建硬件环境。如需试用昇腾处理器，请发送[申请表](https://obs-9be7.obs.cn-east-2.myhuaweicloud.com/file/other/Ascend%20Model%20Zoo%E4%BD%93%E9%AA%8C%E8%B5%84%E6%BA%90%E7%94%B3%E8%AF%B7%E8%A1%A8.docx)至ascend@huawei.com，审核通过即可获得资源。
- 框架
- [MindSpore](https://gitee.com/mindspore/mindspore)
- 如需查看详情，请参见如下资源：
- [MindSpore教程](https://www.mindspore.cn/tutorial/training/zh-CN/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/zh-CN/master/index.html)

- 第三方库

```bash
pip install Cython
pip install pycocotools
pip install mmcv=0.2.14
```

# 快速入门

1. 下载COCO2017数据集。

2. 在`config.py`中修改COCO_ROOT及设置其他参数。参考目录结构如下：

```text
.
└─cocodataset
├─annotations
├─instance_train2017.json
└─instance_val2017.json
├─val2017
└─train2017
```

如您使用自己的数据集训练网络，**执行脚本时，请选择“其他”数据集。**
创建一个TXT文件用于存放数据集信息。参考如下文件内容：

```text
train2017/0000001.jpg 0,259,401,459,7 35,28,324,201,2 0,30,59,80,2
```

一行一个图像注释，以空格分割。第一列为图像的相对路径，其后紧跟着边框和类信息列，格式为[xmin,ymin,xmax,ymax,class]。图像可以从`IMAGE_DIR`（数据集目录）和`ANNO_PATH`（TXT文件路径）中的相对路径拼接而成的路径中读取，路径均可以在`config.py`中配置。

3. 执行训练脚本。
数据集准备完成后，按照如下步骤开始训练：

```text
# 分布式训练
sh run_distribute_train.sh [RANK_TABLE_FILE] [PRETRAINED_CKPT]

# 单机训练
sh run_standalone_train.sh [PRETRAINED_CKPT]
```

注：
1. 为加快数据预处理速度，MindSpore提供了MindRecord数据格式。因此，训练前首先需要生成基于COCO2017数据集的MindRecord文件。COCO2017原始数据集转换为MindRecord格式大概需要4小时。
2. 进行分布式训练前，需要提前创建JSON格式的[hccl配置文件](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools)。
3. PRETRAINED_CKPT是一个ResNet50检查点，通过ImageNet2012训练。

4. 执行评估脚本。
训练结束后，按照如下步骤启动评估：

```bash
# 评估
sh run_eval.sh [VALIDATION_JSON_FILE] [CHECKPOINT_PATH]
```

注：
1. VALIDATION_JSON_FILE是用于评估的标签JSON文件。

# 脚本说明

## 脚本和样例代码

```shell
.
└─MaskRcnn
├─README.md # README
├─scripts # shell脚本
├─run_standalone_train.sh # 单机模式训练（单卡）
├─run_distribute_train.sh # 并行模式训练（8卡）
└─run_eval.sh # 评估
├─src
├─maskrcnn
├─__init__.py
├─anchor_generator.py # 生成基础边框锚点
├─bbox_assign_sample.py # 过滤第一阶段学习中的正负边框
├─bbox_assign_sample.py # 过滤第二阶段学习中的正负边框
├─mask_rcnn_r50.py # MaskRCNN主要网络架构
├─fpn_neck.py # FPN网络
├─proposal_generator.py # 基于特征图生成候选区域
├─rcnn_cls.py # RCNN边框回归分支
├─rcnn_mask.py # RCNN掩码分支
├─resnet50.py # 骨干网
├─roi_align.py # 兴趣点对齐网络
└─rpn.py # 区域候选网络
├─config.py # 网络配置
├─dataset.py # 数据集工具
├─lr_schedule.py # 学习率生成器
├─network_define.py # MaskRCNN的网络定义
└─util.py # 例行操作
├─mindspore_hub_conf.py # MindSpore hub接口
├─eval.py # 评估脚本
└─train.py # 训练脚本
```

## 脚本参数

### 训练脚本参数

```bash
# 分布式训练
用法：sh run_distribute_train.sh [RANK_TABLE_FILE] [PRETRAINED_MODEL]

# 单机训练
用法：sh run_standalone_train.sh [PRETRAINED_MODEL]
```

### 参数配置

```bash
"img_width":1280, # 输入图像宽度
"img_height":768, # 输入图像高度

# 数据增强随机阈值
"keep_ratio": True,
"flip_ratio":0.5,
"photo_ratio":0.5,
"expand_ratio":1.0,

"max_instance_count":128, # 各图像的边框最大值
"mask_shape": (28, 28), # rcnn_mask中掩码的形状

# 锚点
"feature_shapes": [(192, 320), (96, 160), (48, 80), (24, 40), (12, 20)], # FPN特征图的形状
"anchor_scales": [8], # 基础锚点区域
"anchor_ratios": [0.5, 1.0, 2.0], # 基础锚点高宽比
"anchor_strides": [4, 8, 16, 32, 64], # 各特征图层的步长大小
"num_anchors": 3, # 各像素的锚点数

# ResNet
"resnet_block": [3, 4, 6, 3], # 各层区块数
"resnet_in_channels": [64, 256, 512, 1024], # 各层输入通道大小
"resnet_out_channels": [256, 512, 1024, 2048], # 各层输出通道大小

# FPN
"fpn_in_channels":[256, 512, 1024, 2048], # 各层输入通道大小
"fpn_out_channels": 256, # 各层输出通道大小
"fpn_num_outs":5, # 输出特征图大小

# RPN
"rpn_in_channels": 256, # 输入通道大小
"rpn_feat_channels":256, # 特征输出通道大小
"rpn_loss_cls_weight":1.0, # 边框分类在RPN损失中的权重
"rpn_loss_reg_weight":1.0, # 边框回归在RPN损失中的权重
"rpn_cls_out_channels":1, # 分类输出通道大小
"rpn_target_means":[0., 0., 0., 0.], # 边框编解码方式
"rpn_target_stds":[1.0, 1.0, 1.0, 1.0], # 边框编解码标准

# bbox_assign_sampler
"neg_iou_thr":0.3, # 交并后负样本阈值
"pos_iou_thr":0.7, # 交并后正样本阈值
"min_pos_iou":0.3, # 交并后最小正样本阈值
"num_bboxes":245520, # 边框总数
"num_gts": 128, # 地面真值总数
"num_expected_neg":256, # 负样本数
"num_expected_pos":128, # 正样本数

# 候选区域
"activate_num_classes":2, # RPN分类中的类数
"use_sigmoid_cls":True, # 在RPN分类中是否使用sigmoid作为损失函数

# roi_alignj
"roi_layer": dict(type='RoIAlign', out_size=7, mask_out_size=14, sample_num=2), # ROIAlign参数
"roi_align_out_channels": 256, # ROIAlign输出通道大小
"roi_align_featmap_strides":[4, 8, 16, 32], # ROIAling特征图不同层级的步长大小
"roi_align_finest_scale": 56, # ROIAlign最佳比例
"roi_sample_num": 640, # ROIAling层中的样本数

# bbox_assign_sampler_stage2 # 第二阶段边框赋值样本，参数含义类似于bbox_assign_sampler
"neg_iou_thr_stage2":0.5,
"pos_iou_thr_stage2":0.5,
"min_pos_iou_stage2":0.5,
"num_bboxes_stage2":2000,
"num_expected_pos_stage2":128,
"num_expected_neg_stage2":512,
"num_expected_total_stage2":512,

# rcnn # 第二阶段的RCNN参数，参数含义类似于FPN
"rcnn_num_layers":2,
"rcnn_in_channels":256,
"rcnn_fc_out_channels":1024,
"rcnn_mask_out_channels":256,
"rcnn_loss_cls_weight":1,
"rcnn_loss_reg_weight":1,
"rcnn_loss_mask_fb_weight":1,
"rcnn_target_means":[0., 0., 0., 0.],
"rcnn_target_stds":[0.1, 0.1, 0.2, 0.2],

# 训练候选区域
"rpn_proposal_nms_across_levels":False,
"rpn_proposal_nms_pre":2000, # RPN中NMS前的候选区域数
"rpn_proposal_nms_post":2000, # RPN中NMS后的候选区域数
"rpn_proposal_max_num":2000, # RPN中最大候选区域数
"rpn_proposal_nms_thr":0.7, # RPN中NMS的阈值
"rpn_proposal_min_bbox_size":0, # RPN中边框的最小尺寸

# 测试候选区域 # 部分参数与训练候选区域类似
"rpn_nms_across_levels":False,
"rpn_nms_pre":1000,
"rpn_nms_post":1000,
"rpn_max_num":1000,
"rpn_nms_thr":0.7,
"rpn_min_bbox_min_size":0,
"test_score_thr":0.05, # 打分阈值
"test_iou_thr":0.5, # 交并比阈值
"test_max_per_img":100, # 最大实例数
"test_batch_size":2, # 批次大小

"rpn_head_loss_type":"CrossEntropyLoss", # RPN中的损失类型
"rpn_head_use_sigmoid":True, # 是否在RPN中使用sigmoid
"rpn_head_weight":1.0, # RPN头的损失重量
"mask_thr_binary":0.5, # 输入RCNN的掩码阈值

# 逻辑回归
"base_lr":0.02, # 基础学习率
"base_step":58633, # 逻辑回归发生器中的基础步骤
"total_epoch":13, # 逻辑回归发生器总轮次
"warmup_step":500, # 逻辑回归发生器热身步骤
"warmup_mode":"linear", # 热身模式
"warmup_ratio":1/3.0, # 热身比
0.9, # 优化器中的动量

# 训练
"batch_size":2,
"loss_scale":1,
"momentum":0.91,
"weight_decay":1e-4,
"pretrain_epoch_size":0, # 预训练的轮次
"epoch_size":12, # 总轮次
"save_checkpoint":True, # 是否保存检查点
"save_checkpoint_epochs":1, # 检查点保存间隔
"keep_checkpoint_max":12, # 检查点最大保存数
"save_checkpoint_path":"./checkpoint", # 检查点所在路径

"mindrecord_dir":"/home/maskrcnn/MindRecord_COCO2017_Train", # MindRecord文件路径
"coco_root":"/home/maskrcnn/", # COCO根数据集的路径
"train_data_type":"train2017", # 训练数据集名称
"val_data_type":"val2017", # 评估数据集名称
"instance_set":"annotations/instances_{}.json", # 注释名称
"coco_classes":('background', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra',
'giraffe', 'backpack', 'umbrella', 'handbag', 'tie',
'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
'kite', 'baseball bat', 'baseball glove', 'skateboard',
'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup',
'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',
'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed',
'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote',
'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink',
'refrigerator', 'book', 'clock', 'vase', 'scissors',
'teddy bear', 'hair drier', 'toothbrush'),
"num_classes":81
```

## 训练过程

- 在`config.py`中设置配置项，包括loss_scale、学习率和网络超参。单击[此处](https://www.mindspore.cn/tutorial/training/zh-CN/master/use/data_preparation.html)获取更多数据集相关信息.

### 训练

- 运行`run_standalone_train.sh`开始MaskRCNN模型的非分布式训练。

```bash
# 单机训练
sh run_standalone_train.sh [PRETRAINED_MODEL]
```

### 分布式训练

- 运行`run_distribute_train.sh`开始Mask模型的分布式训练。

```bash
sh run_distribute_train.sh [RANK_TABLE_FILE] [PRETRAINED_MODEL]
```

> 运行分布式任务时要用到由RANK_TABLE_FILE指定的hccl.json文件。您可使用[hccl_tools](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools)生成该文件。
> 若不设置PRETRAINED_MODEL，模型将会从头开始训练。暂无预训练模型可用，请持续关注。
> 本操作涉及处理器内核绑定，需要设置`device_num`及处理器总数。若无需此操作，请删除`scripts/run_distribute_train.sh`中的`taskset`。

### 训练结果

训练结果将保存在示例路径，文件夹名称以“train”或“train_parallel”开头。您可以在loss_rankid.log中找到检查点文件及如下类似结果。

```bash
# 分布式训练结果（8P）
epoch:1 step:7393 ,rpn_loss:0.10626, rcnn_loss:0.81592, rpn_cls_loss:0.05862, rpn_reg_loss:0.04761, rcnn_cls_loss:0.32642, rcnn_reg_loss:0.15503, rcnn_mask_loss:0.33447, total_loss:0.92218
epoch:2 step:7393 ,rpn_loss:0.00911, rcnn_loss:0.34082, rpn_cls_loss:0.00341, rpn_reg_loss:0.00571, rcnn_cls_loss:0.07440, rcnn_reg_loss:0.05872, rcnn_mask_loss:0.20764, total_loss:0.34993
epoch:3 step:7393 ,rpn_loss:0.02087, rcnn_loss:0.98633, rpn_cls_loss:0.00665, rpn_reg_loss:0.01422, rcnn_cls_loss:0.35913, rcnn_reg_loss:0.21375, rcnn_mask_loss:0.41382, total_loss:1.00720
...
epoch:10 step:7393 ,rpn_loss:0.02122, rcnn_loss:0.55176, rpn_cls_loss:0.00620, rpn_reg_loss:0.01503, rcnn_cls_loss:0.12708, rcnn_reg_loss:0.10254, rcnn_mask_loss:0.32227, total_loss:0.57298
epoch:11 step:7393 ,rpn_loss:0.03772, rcnn_loss:0.60791, rpn_cls_loss:0.03058, rpn_reg_loss:0.00713, rcnn_cls_loss:0.23987, rcnn_reg_loss:0.11743, rcnn_mask_loss:0.25049, total_loss:0.64563
epoch:12 step:7393 ,rpn_loss:0.06482, rcnn_loss:0.47681, rpn_cls_loss:0.04770, rpn_reg_loss:0.01709, rcnn_cls_loss:0.16492, rcnn_reg_loss:0.04990, rcnn_mask_loss:0.26196, total_loss:0.54163
```

## 评估过程

### 评估

- 运行`run_eval.sh`进行评估。

```bash
# 推理
sh run_eval.sh [VALIDATION_ANN_FILE_JSON] [CHECKPOINT_PATH]
```

> 关于COCO2017数据集，VALIDATION_ANN_FILE_JSON参考数据集目录下的annotations/instances_val2017.json文件。
> 检查点可在训练过程中生成并保存，其文件夹名称以“train/checkpoint”或“train_parallel*/checkpoint”开头。

### 评估结果

推理结果将保存在示例路径，文件夹名为“eval”。您可在该文件夹的日志中找到如下类似结果。

```text


Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.376
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.598
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.405
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.239
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.414
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.475
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.311
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.500
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.528
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.371
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.572
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.653



Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.326
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.553
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.344
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.169
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.356
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.462
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.278
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.426
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.445
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.294
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.484
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.558
```

# 模型说明

## 性能

### 训练性能

| 参数 | MaskRCNN |

| 模型版本 | V1 |
| 资源 | Ascend 910；CPU： 2.60GHz，192核；内存：755G |
| 上传日期 | 2020-08-01 |
| MindSpore版本 | 0.6.0-alpha |
| 数据集 | COCO2017 |
| 训练参数 | epoch=12，batch_size=2 |
| 优化器 | SGD |
| 损失函数 | Softmax交叉熵，Sigmoid交叉熵，SmoothL1Loss |
| 速度 | 单卡：250毫秒/步；8P: 260毫秒/步 |
| 总时长 | 单卡：52小时；8卡：6.6小时 |
| 参数（M） | 280 |
| 脚本 | <https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/maskrcnn> |

### 评估性能

| 参数 | MaskRCNN |
| ------------------- | --------------------------- |
| 模型版本 | V1 |
| 资源 | Ascend 910 |
| 上传日期 | 2020-08-01 |
| MindSpore版本 | 0.6.0-alpha |
| 数据集 | COCO2017 |
| 批次大小 | 2 |
| 输出 | mAP |
| 精确度 | 交并比（IoU）=0.50:0.95 32.4% |
| 推理模型 | 254M（.ckpt文件） |

# 随机情况说明

[dataset.py](http://dataset.py/)中设置了“create_dataset”函数内的种子，同时还使用[train.py](http://train.py/)中的随机种子进行权重初始化。

# ModelZoo主页

请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

+ 498
- 0
model_zoo/official/cv/resnet/README_CN.md View File

@@ -0,0 +1,498 @@
# 目录

<!-- TOC -->

- [ResNet描述](#ResNet描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [特性](#特性)
- [混合精度](#混合精度)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [评估过程](#评估过程)
- [模型描述](#模型描述)
- [性能](#性能)
- [评估性能](#评估性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#ModelZoo主页)

<!-- /TOC -->

# ResNet描述

## 概述

残差神经网络（ResNet）由微软研究院何凯明等五位华人提出，通过ResNet单元，成功训练152层神经网络，赢得了ILSVRC2015冠军。ResNet前五项的误差率为3.57%，参数量低于VGGNet，因此效果非常显著。传统的卷积网络或全连接网络或多或少存在信息丢失的问题，还会造成梯度消失或爆炸，导致深度网络训练失败，ResNet则在一定程度上解决了这个问题。通过将输入信息传递给输出，确保信息完整性。整个网络只需要学习输入和输出的差异部分，简化了学习目标和难度。ResNet的结构大幅提高了神经网络训练的速度，并且大大提高了模型的准确率。正因如此，ResNet十分受欢迎，甚至可以直接用于ConceptNet网络。

如下为MindSpore使用CIFAR-10/ImageNet2012数据集对ResNet50/ResNet101/SE-ResNet50进行训练的示例。ResNet50和ResNet101可参考[论文1](https://arxiv.org/pdf/1512.03385.pdf)，SE-ResNet50是ResNet50的一个变体，可参考[论文2](https://arxiv.org/abs/1709.01507)和[论文3](https://arxiv.org/abs/1812.01187)。使用8卡Ascend 910训练SE-ResNet50，仅需24个周期，TOP1准确率就达到了75.9%（暂不支持用CIFAR-10数据集训练ResNet101以及用用CIFAR-10数据集训练SE-ResNet50）。

## 论文

1. [论文](https://arxiv.org/pdf/1512.03385.pdf)：Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun."Deep Residual Learning for Image Recognition"

2. [论文](https://arxiv.org/abs/1709.01507)：Jie Hu, Li Shen, Samuel Albanie, Gang Sun, Enhua Wu."Squeeze-and-Excitation Networks"

3. [论文](https://arxiv.org/abs/1812.01187)：Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, Mu Li."Bag of Tricks for Image Classification with Convolutional Neural Networks"

# 模型架构

ResNet的总体网络架构如下：
[链接](https://arxiv.org/pdf/1512.03385.pdf)

# 数据集

使用的数据集：[CIFAR-10](<http://www.cs.toronto.edu/~kriz/cifar.html>)

- 数据集大小：共10个类、60,000个32*32彩色图像
- 训练集：50,000个图像
- 测试集：10,000个图像
- 数据格式：二进制文件
- 注：数据在dataset.py中处理。
- 下载数据集。目录结构如下：

```text
├─cifar-10-batches-bin
│
└─cifar-10-verify-bin
```

使用的数据集：[ImageNet2012](http://www.image-net.org/)

- 数据集大小：共1000个类、224*224彩色图像
- 训练集：共1,281,167张图像
- 测试集：共50,000张图像
- 数据格式：JPEG
- 注：数据在dataset.py中处理。
- 下载数据集，目录结构如下：

```text
└─dataset
├─ilsvrc # 训练数据集
└─validation_preprocess # 评估数据集
```

# 特性

## 混合精度

采用[混合精度](https://www.mindspore.cn/tutorial/training/en/master/advanced_use/enable_mixed_precision.html)的训练方法使用支持单精度和半精度数据来提高深度学习神经网络的训练速度，同时保持单精度训练所能达到的网络精度。混合精度训练提高计算速度、减少内存使用的同时，支持在特定硬件上训练更大的模型或实现更大批次的训练。
以FP16算子为例，如果输入数据类型为FP32，MindSpore后台会自动降低精度来处理数据。用户可打开INFO日志，搜索“reduce precision”查看精度降低的算子。

# 环境要求

- 硬件(Ascend/GPU)
- 准备Ascend或GPU处理器搭建硬件环境。如需试用昇腾处理器，请发送[申请表](https://obs-9be7.obs.cn-east-2.myhuaweicloud.com/file/other/Ascend%20Model%20Zoo%E4%BD%93%E9%AA%8C%E8%B5%84%E6%BA%90%E7%94%B3%E8%AF%B7%E8%A1%A8.docx)至ascend@huawei.com，审核通过即可获得资源。
- 框架
- [MindSpore](https://www.mindspore.cn/install/en)
- 如需查看详情，请参见如下资源：
- [MindSpore教程](https://www.mindspore.cn/tutorial/training/zh-CN/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/zh-CN/master/index.html)

# 快速入门

通过官方网站安装MindSpore后，您可以按照如下步骤进行训练和评估：

- Ascend处理器环境运行

```text
# 分布式训练
用法：sh run_distribute_train.sh [resnet50|resnet101|se-resnet50] [cifar10|imagenet2012] [RANK_TABLE_FILE] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）

# 单机训练
用法：sh run_standalone_train.sh [resnet50|resnet101|se-resnet50] [cifar10|imagenet2012] [DATASET_PATH]
[PRETRAINED_CKPT_PATH]（可选）

# 运行评估示例
用法：sh run_eval.sh [resnet50|resnet101|se-resnet50] [cifar10|imagenet2012] [DATASET_PATH] [CHECKPOINT_PATH]
```

- GPU处理器环境运行

```text
# 分布式训练示例
sh run_distribute_train_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）

# 单机训练示例
sh run_standalone_train_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）

# 推理示例
sh run_eval_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [CHECKPOINT_PATH]
```

# 脚本说明

## 脚本及样例代码

```shell
.
└──resnet
├── README.md
├── scripts
├── run_distribute_train.sh # 启动Ascend分布式训练（8卡）
├── run_parameter_server_train.sh # 启动Ascend参数服务器训练(8卡)
├── run_eval.sh # 启动Ascend评估
├── run_standalone_train.sh # 启动Ascend单机训练（单卡）
├── run_distribute_train_gpu.sh # 启动GPU分布式训练（8卡）
├── run_parameter_server_train_gpu.sh # 启动GPU参数服务器训练（8卡）
├── run_eval_gpu.sh # 启动GPU评估
└── run_standalone_train_gpu.sh # 启动GPU单机训练（单卡）
├── src
├── config.py # 参数配置
├── dataset.py # 数据预处理
├── CrossEntropySmooth.py # ImageNet2012数据集的损失定义
├── lr_generator.py # 生成每个步骤的学习率
└── resnet.py # ResNet骨干网络，包括ResNet50、ResNet101和SE-ResNet50
├── eval.py # 评估网络
└── train.py # 训练网络
```

## 脚本参数

在config.py中可以同时配置训练参数和评估参数。

- 配置ResNet50和CIFAR-10数据集。

```text
"class_num":10, # 数据集类数
"batch_size":32, # 输入张量的批次大小
"loss_scale":1024, # 损失等级
"momentum":0.9, # 动量
"weight_decay":1e-4, # 权重衰减
"epoch_size":90, # 此值仅适用于训练；应用于推理时固定为1
"pretrain_epoch_size":0, # 加载预训练检查点之前已经训练好的模型的周期大小；实际训练周期大小等于epoch_size减去pretrain_epoch_size
"save_checkpoint":True, # 是否保存检查点
"save_checkpoint_epochs":5, # 两个检查点之间的周期间隔；默认情况下，最后一个检查点将在最后一步完成后保存
"keep_checkpoint_max":10, # 只保留最后一个keep_checkpoint_max检查点
"save_checkpoint_path":"./", # 检查点保存路径
"warmup_epochs":5, # 热身周期数
"lr_decay_mode":"poly” # 衰减模式可为步骤、策略和默认
"lr_init":0.01, # 初始学习率
"lr_end":0.0001, # 最终学习率
"lr_max":0.1, # 最大学习率
```

- 配置ResNet50和ImageNet2012数据集。

```text
"class_num":1001, # 数据集类数
"batch_size":256, # 输入张量的批次大小
"loss_scale":1024, # 损失等级
"momentum":0.9, # 动量优化器
"weight_decay":1e-4, # 权重衰减
"epoch_size":90, # 此值仅适用于训练；应用于推理时固定为1
"pretrain_epoch_size":0, # 加载预训练检查点之前已经训练好的模型的周期大小；实际训练周期大小等于epoch_size减去pretrain_epoch_size
"save_checkpoint":True, # 是否保存检查点
"save_checkpoint_epochs":5, # 两个检查点之间的周期间隔；默认情况下，最后一个检查点将在最后一个周期完成后保存
"keep_checkpoint_max":10, # 只保存最后一个keep_checkpoint_max检查点
"save_checkpoint_path":"./", # 检查点相对于执行路径的保存路径
"warmup_epochs":0, # 热身周期数
"lr_decay_mode":"Linear", # 用于生成学习率的衰减模式
"use_label_smooth":True, # 标签平滑
"label_smooth_factor":0.1, # 标签平滑因子
"lr_init":0, # 初始学习率
"lr_max":0.8, # 最大学习率
"lr_end":0.0, # 最小学习率
```

- 配置ResNet101和ImageNet2012数据集。

```text
"class_num":1001, # 数据集类数
"batch_size":32, # 输入张量的批次大小
"loss_scale":1024, # 损失等级
"momentum":0.9, # 动量优化器
"weight_decay":1e-4, # 权重衰减
"epoch_size":120, # 训练周期大小
"pretrain_epoch_size":0, # 加载预训练检查点之前已经训练好的模型的周期大小；实际训练周期大小等于epoch_size减去pretrain_epoch_size
"save_checkpoint":True, # 是否保存检查点
"save_checkpoint_epochs":5, # 两个检查点之间的周期间隔；默认情况下，最后一个检查点将在最后一个周期完成后保存
"keep_checkpoint_max":10, # 只保存最后一个keep_checkpoint_max检查点
"save_checkpoint_path":"./", # 检查点相对于执行路径的保存路径
"warmup_epochs":0, # 热身周期数
"lr_decay_mode":"cosine” # 用于生成学习率的衰减模式
"use_label_smooth":True, # 标签平滑
"label_smooth_factor":0.1, # 标签平滑因子
"lr":0.1 # 基础学习率
```

- 配置SE-ResNet50和ImageNet2012数据集。

```text
"class_num":1001, # 数据集类数
"batch_size":32, # 输入张量的批次大小
"loss_scale":1024, # 损失等级
"momentum":0.9, # 动量优化器
"weight_decay":1e-4, # 权重衰减
"epoch_size":28, # 创建学习率的周期大小
"train_epoch_size":24 # 实际训练周期大小
"pretrain_epoch_size":0, # 加载预训练检查点之前已经训练好的模型的周期大小；实际训练周期大小等于epoch_size减去pretrain_epoch_size
"save_checkpoint":True, # 是否保存检查点
"save_checkpoint_epochs":4, # 两个检查点之间的周期间隔；默认情况下，最后一个检查点将在最后一个周期完成后保存
"keep_checkpoint_max":10, # 只保存最后一个keep_checkpoint_max检查点
"save_checkpoint_path":"./", # checkpoint相对于执行路径的保存路径
"warmup_epochs":3, # 热身周期数
"lr_decay_mode":"cosine” # 用于生成学习率的衰减模式
"use_label_smooth":True, # 标签平滑
"label_smooth_factor":0.1, # 标签平滑因子
"lr_init":0.0, # 初始学习率
"lr_max":0.3, # 最大学习率
"lr_end":0.0001, # 最终学习率
```

## 训练过程

### 用法

#### Ascend处理器环境运行

```text
# 分布式训练
用法：sh run_distribute_train.sh [resnet50|resnet101|se-resnet50] [cifar10|imagenet2012] [RANK_TABLE_FILE] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）

# 单机训练
用法：sh run_standalone_train.sh [resnet50|resnet101|se-resnet50] [cifar10|imagenet2012] [DATASET_PATH]
[PRETRAINED_CKPT_PATH]（可选）

# 运行评估示例
用法：sh run_eval.sh [resnet50|resnet101|se-resnet50] [cifar10|imagenet2012] [DATASET_PATH] [CHECKPOINT_PATH]

```

分布式训练需要提前创建JSON格式的HCCL配置文件。

具体操作，参见[hccn_tools](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools)中的说明。

训练结果保存在示例路径中，文件夹名称以“train”或“train_parallel”开头。您可在此路径下的日志中找到检查点文件以及结果，如下所示。

#### GPU处理器环境运行

```text
# 分布式训练示例
sh run_distribute_train_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）

# 单机训练示例
sh run_standalone_train_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）

# 推理示例
sh run_eval_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [CHECKPOINT_PATH]
```

#### 运行参数服务器模式训练

- Ascend参数服务器训练示例

```text
sh run_parameter_server_train.sh [resnet50|resnet101] [cifar10|imagenet2012] [RANK_TABLE_FILE] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）
```

- GPU参数服务器训练示例

```text
sh run_parameter_server_train_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [PRETRAINED_CKPT_PATH]（可选）
```

### 结果

- 使用CIFAR-10数据集训练ResNet50

```text
# 分布式训练结果（8P）
epoch:1 step:195, loss is 1.9601055
epoch:2 step:195, loss is 1.8555021
epoch:3 step:195, loss is 1.6707983
epoch:4 step:195, loss is 1.8162166
epoch:5 step:195, loss is 1.393667
...
```

- 使用ImageNet2012数据集训练ResNet50

```text
# 分布式训练结果（8P）
epoch:1 step:5004, loss is 4.8995576
epoch:2 step:5004, loss is 3.9235563
epoch:3 step:5004, loss is 3.833077
epoch:4 step:5004, loss is 3.2795618
epoch:5 step:5004, loss is 3.1978393
...
```

- 使用ImageNet2012数据集训练ResNet101

```text
# 分布式训练结果（8P）
epoch:1 step:5004, loss is 4.805483
epoch:2 step:5004, loss is 3.2121816
epoch:3 step:5004, loss is 3.429647
epoch:4 step:5004, loss is 3.3667371
epoch:5 step:5004, loss is 3.1718972
...
epoch:67 step:5004, loss is 2.2768745
epoch:68 step:5004, loss is 1.7223864
epoch:69 step:5004, loss is 2.0665488
epoch:70 step:5004, loss is 1.8717369
...
```

- 使用ImageNet2012数据集训练SE-ResNet50

```text
# 分布式训练结果（8P）
epoch:1 step:5004, loss is 5.1779146
epoch:2 step:5004, loss is 4.139395
epoch:3 step:5004, loss is 3.9240637
epoch:4 step:5004, loss is 3.5011306
epoch:5 step:5004, loss is 3.3501816
...
```

## 评估过程

### 用法

#### Ascend处理器环境运行

```bash
# 评估
Usage: sh run_eval.sh [resnet50|resnet101|se-resnet50] [cifar10|imagenet2012] [DATASET_PATH] [CHECKPOINT_PATH]
```

```bash
# 评估示例
sh run_eval.sh resnet50 cifar10 ~/cifar10-10-verify-bin ~/resnet50_cifar10/train_parallel0/resnet-90_195.ckpt
```

> 训练过程中可以生成检查点。

#### GPU处理器环境运行

```bash
sh run_eval_gpu.sh [resnet50|resnet101] [cifar10|imagenet2012] [DATASET_PATH] [CHECKPOINT_PATH]
```

### 结果

评估结果保存在示例路径中，文件夹名为“eval”。您可在此路径下的日志找到如下结果：

- 使用CIFAR-10数据集评估ResNet50

```text
result:{'acc':0.91446314102564111} ckpt=~/resnet50_cifar10/train_parallel0/resnet-90_195.ckpt
```

- 使用ImageNet2012数据集评估ResNet50

```text
result:{'acc':0.7671054737516005} ckpt=train_parallel0/resnet-90_5004.ckpt
```

- 使用ImageNet2012数据集评估ResNet101

```text
result:{'top_5_accuracy':0.9429417413572343, 'top_1_accuracy':0.7853513124199744} ckpt=train_parallel0/resnet-120_5004.ckpt
```

- 使用ImageNet2012数据集评估SE-ResNet50

```text
result:{'top_5_accuracy':0.9342589628681178, 'top_1_accuracy':0.768065781049936} ckpt=train_parallel0/resnet-24_5004.ckpt

```

# 模型描述

## 性能

### 评估性能

#### CIFAR-10上的ResNet50

| 参数 | Ascend 910 | GPU |
| -------------------------- | -------------------------------------- |---------------------------------- |
| 模型版本 | ResNet50-v1.5 |ResNet50-v1.5|
| 资源 | Ascend 910；CPU：2.60GHz，192核；内存：755G | GPU(Tesla V100 SXM2)；CPU：2.1GHz，24核；内存：128G
| 上传日期 | 2020-04-01 | 2020-08-01
| MindSpore版本 | 0.1.0-alpha |0.6.0-alpha |
| 数据集 | CIFAR-10 | CIFAR-10
| 训练参数 | epoch=90, steps per epoch=195, batch_size = 32 |epoch=90, steps per epoch=195, batch_size = 32 |
| 优化器 | Momentum |Momentum|
| 损失函数 | Softmax交叉熵 | Softmax交叉熵 |
| 输出 | 概率 | 概率 |
| 损失 | 0.000356 | 0.000716 |
| 速度 | 18.4毫秒/步（8卡） |69毫秒/步（8卡）|
| 总时长 | 6分钟 | 20.2分钟|
| 参数(M) | 25.5 | 25.5 |
| 微调检查点 | 179.7M（.ckpt文件） | 179.7M（.ckpt文件） |
| 脚本 | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/resnet) | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/resnet) |

#### ImageNet2012上的ResNet50

| 参数 | Ascend 910 | GPU |
| -------------------------- | -------------------------------------- |---------------------------------- |
| 模型版本 | ResNet50-v1.5 |ResNet50-v1.5|
| 资源 | Ascend 910；CPU：2.60GHz，192核；内存：755G | GPU(Tesla V100 SXM2)；CPU：2.1GHz，24核；内存：128G
| 上传日期 | 2020-04-01 ; | 2020-08-01
| MindSpore版本 | 0.1.0-alpha |0.6.0-alpha |
| 数据集 | ImageNet2012 | ImageNet2012|
| 训练参数 | epoch=90, steps per epoch=626, batch_size = 256 |epoch=90, steps per epoch=5004, batch_size = 32 |
| 优化器 | Momentum |Momentum|
| 损失函数 | Softmax交叉熵 | Softmax交叉熵 |
| 输出 | 概率 | 概率 |
| 损失 | 1.8464266 | 1.9023 |
| 速度 | 118毫秒/步（8卡） |67.1毫秒/步（8卡）|
| 总时长 | 114分钟 | 500分钟|
| 参数(M) | 25.5 | 25.5 |
| 微调检查点| 197M（.ckpt文件） | 197M（.ckpt文件） |
| 脚本 | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/resnet) | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/resnet) |

#### ImageNet2012上的ResNet101

| 参数 | Ascend 910 | GPU |
| -------------------------- | -------------------------------------- |---------------------------------- |
| 模型版本 | ResNet101 |ResNet101|
| 资源 | Ascend 910；CPU：2.60GHz，192核；内存：755G GPU(Tesla V100 SXM2)；CPU：2.1GHz，24核；内存：128G
| 上传日期 | 2020-04-01 ; | 2020-08-01
| MindSpore版本 | 0.1.0-alpha |0.6.0-alpha |
| 数据集 | ImageNet2012 | ImageNet2012|
| 训练参数 | epoch=120, steps per epoch=5004, batch_size = 32 |epoch=120, steps per epoch=5004, batch_size = 32 |
| 优化器 | Momentum |Momentum|
| 损失函数 | Softmax交叉熵 | Softmax交叉熵 |
| 输出 |概率 | 概率 |
| 损失 | 1.6453942 | 1.7023412 |
| 速度 | 30.3毫秒/步（8卡） |108.6毫秒/步（8卡）|
| 总时长 | 301分钟 | 1100分钟|
| 参数(M) | 44.6 | 44.6 |
| 微调检查点| 343M（.ckpt文件） | 343M（.ckpt文件） |
|脚本 | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/resnet) | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/resnet) |

#### ImageNet2012上的SE-ResNet50

| 参数 | Ascend 910
| -------------------------- | ------------------------------------------------------------------------ |
| 模型版本 | SE-ResNet50 |
| 资源 | Ascend 910；CPU：2.60GHz，192核；内存：755G |
| 上传日期 | 2020-08-16 ； |
| MindSpore版本 | 0.7.0-alpha |
| 数据集 | ImageNet2012 |
| 训练参数 | epoch=24, steps per epoch=5004, batch_size = 32 |
| 优化器 | Momentum |
| 损失函数 | Softmax交叉熵 |
| 输出 | 概率 |
| 损失 | 1.754404 |
| 速度 | 24.6毫秒/步（8卡） |
| 总时长 | 49.3分钟 |
| 参数(M) | 25.5 |
| 微调检查点 | 215.9M （.ckpt文件） |
|脚本 | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/resnet) |

# 随机情况说明

[dataset.py](http://dataset.py/)中设置了“create_dataset”函数内的种子，同时还使用了train.py中的随机种子。

# ModelZoo主页

请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

+ 251
- 0
model_zoo/official/cv/warpctc/README_CN.md View File

@@ -0,0 +1,251 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [WarpCTC描述](#warpctc描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练脚本参数](#训练脚本参数)
- [参数配置](#参数配置)
- [数据集准备](#数据集准备)
- [训练过程](#训练过程)
- [训练](#训练)
- [分布式训练](#分布式训练)
- [评估过程](#评估过程)
- [评估](#评估)
- [模型描述](#模型描述)
- [性能](#性能)
- [训练性能](#训练性能)
- [评估性能](#评估性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# WarpCTC描述
以下为MindSpore中用自生成的验证码图像数据集来训练WarpCTC的例子。
# 模型架构
WarpCTC是带有一层FC神经网络的二层堆叠LSTM模型。详细信息请参见src/warpctc.py。
# 数据集
该数据集由第三方库[captcha](https://github.com/lepture/captcha)自行生成，可以在图像中随机生成数字0至9。在本网络中，我们设置数字个数为1至4。
# 环境要求
- 硬件（Ascend/GPU）
- 使用Ascend或GPU处理器来搭建硬件环境。如需试用昇腾处理器，请发送[申请表](https://obs-9be7.obs.cn-east-2.myhuaweicloud.com/file/other/Ascend%20Model%20Zoo%E4%BD%93%E9%AA%8C%E8%B5%84%E6%BA%90%E7%94%B3%E8%AF%B7%E8%A1%A8.docx)至ascend@huawie,审核通过即可获得资源。
- 框架
- [MindSpore](https://gitee.com/mindspore/mindspore)
- 如需查看详情，请参见如下资源：
- [MindSpore教程](https://www.mindspore.cn/tutorial/training/zh-CN/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/zh-CN/master/index.html)
# 快速入门
- 生成数据集
执行脚本`scripts/run_process_data.sh`生成数据集。默认情况下，shell脚本将分别生成10000个测试图片和50000个训练图片。
```text
$ cd scripts
$ sh run_process_data.sh
# 执行后，数据集如下：
.
└─warpctc
└─data
├─ train # 训练数据集
└─ test # 评估数据集
```
- 数据集准备完成后，您可以开始执行训练或评估脚本，具体步骤如下：
- Ascend处理器环境运行
```bash
# Ascend分布式训练示例
$ bash run_distribute_train.sh rank_table.json ../data/train
# Ascend评估示例
$ bash run_eval.sh ../data/test warpctc-30-97.ckpt Ascend
# Ascend中单机训练示例
$ bash run_standalone_train.sh ../data/train Ascend
```
在分布式训练中，JSON格式的HCCL配置文件需要提前创建。
详情参见如下链接：
[链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools)
- 在GPU环境运行
```bash
# Ascend分布式训练示例
$ bash run_distribute_train_for_gpu.sh 8 ../data/train
# GPU单机训练示例
$ bash run_standalone_train.sh ../data/train GPU
# GPU评估示例
$ bash run_eval.sh ../data/test warpctc-30-97.ckpt GPU
```
# 脚本说明
## 脚本及样例代码
```text
.
└──warpctc
├── README.md
├── script
├── run_distribute_train.sh # 启动Ascend分布式训练（8卡）
├── run_distribute_train_for_gpu.sh # 启动GPU分布式训练
├── run_eval.sh # 启动评估
├── run_process_data.sh # 启动数据集生成
└── run_standalone_train.sh # 启动单机训练（1卡）
├── src
├── config.py # 参数配置
├── dataset.py # 数据预处理
├── loss.py # CTC损失定义
├── lr_generator.py # 生成每个步骤的学习率
├── metric.py # warpctc网络准确指标
├── warpctc.py # warpctc网络定义
└── warpctc_for_train.py # 带梯度、损失和梯度剪裁的warpctc网络
├── mindspore_hub_conf.py # Mindspore Hub接口
├── eval.py # 评估网络
├── process_data.py # 数据集生成脚本
└── train.py # 训练网络
```
## 脚本参数
### 训练脚本参数
```bash
# Ascend分布式训练
用法: bash run_distribute_train.sh [RANK_TABLE_FILE] [DATASET_PATH]
# GPU分布式训练
用法： bash run_distribute_train_for_gpu.sh [RANK_SIZE] [DATASET_PATH]
# 单机训练
用法： bash run_standalone_train.sh [DATASET_PATH] [PLATFORM]
```
### 参数配置
在config.py中可以同时配置训练参数和评估参数。
```text
"max_captcha_digits": 4, # 每张图像的数字个数上限。
"captcha_width": 160, # captcha图片宽度。
"captcha_height": 64, # capthca图片高度。
"batch_size": 64, # 输入张量批次大小。
"epoch_size": 30, # 只对训练有效，推理固定值为1。
"hidden_size": 512, # LSTM层隐藏大小。
"learning_rate": 0.01, # 初始学习率。
"momentum": 0.9 # SGD优化器动量。
"save_checkpoint": True, # 是否保存检查点。
"save_checkpoint_steps": 97, # 两个检查点之间的迭代间隙。默认情况下，最后一个检查点将在最后一步迭代结束后保存。
"keep_checkpoint_max": 30, # 只保留最后一个keep_checkpoint_max检查点。
"save_checkpoint_path": "./checkpoint", # 检查点保存路径。
```
## 数据集准备
- 您可以参考[快速入门](#quick-start)中的“生成数据集”自动生成数据集，也可以自行选择生成验证码数据集。
## 训练过程
- 在`config.py`中设置选项，包括学习率和网络超参数。单击[MindSpore加载数据集教程](https://www.mindspore.cn/tutorial/training/zh-CN/master/use/data_preparation.html)，了解更多信息。
### 训练
- 在Ascend或GPU上运行`run_standalone_train.sh`进行WarpCTC模型的非分布式训练。
``` bash
bash run_standalone_train.sh [DATASET_PATH] [PLATFORM]
```
### 分布式训练
- 在Ascend上运行`run_distribute_train.sh`进行WarpCTC模型的分布式训练。
``` bash
bash run_distribute_train.sh [RANK_TABLE_FILE] [DATASET_PATH]
```
- 在GPU上运行`run_distribute_train_gpu.sh`进行WarpCTC模型的分布式训练。
``` bash
bash run_distribute_train_gpu.sh [RANK_SIZE] [DATASET_PATH]
```
## 评估过程
### 评估
- 运行`run_eval.sh`进行评估。
``` bash
bash run_eval.sh [DATASET_PATH] [CHECKPOINT_PATH] [PLATFORM]
```
# 模型描述
## 性能
### 训练性能
| 参数 | Ascend 910 | GPU |
| -------------------------- | --------------------------------------------- |---------------------------------- |
| 模型版本 | v1.0 | v1.0 |
| 资源 | Ascend 910，CPU 2.60GHz 192核，内存：755G | GPU(Tesla V100 SXM2)，CPU 2.1GHz 24核，内存： 128G
| 上传日期 | 2020-07-01 | 2020-08-01 |
| MindSpore版本 | 0.5.0-alpha | 0.6.0-alpha |
| 数据集 | Captcha | Captcha |
| 训练参数 | epoch=30, steps per epoch=98, batch_size = 64 | epoch=30, steps per epoch=98, batch_size = 64 |
| 优化器 | SGD | SGD |
| 损失函数 | CTCLoss | CTCLoss |
| 输出 | 概率 | 概率 |
| 损失 | 0.0000157 | 0.0000246 |
| 速度 | 980毫秒/步（8卡） | 150毫秒/步（8卡）|
| 总时长 | 30分钟 | 5分钟|
| 参数(M) | 2.75 | 2.75 |
| 微调检查点 | 20.3M (.ckpt文件) | 20.3M (.ckpt文件) |
| 脚本 | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/warpctc) | [链接](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/warpctc) |
### 评估性能
| 参数 | WarpCTC |
| ------------------- | --------------------------- |
| 模型版本 | V1.0 |
| 资源 | Ascend 910 |
| 上传日期 | 2020-08-01 |
| MindSpore版本 | 0.6.0-alpha |
| 数据集 | Captcha |
| batch_size | 64 |
| 输出 | ACC |
| 准确率 | 99.0% |
| 推理模型 | 20.3M (.ckpt文件) |
# 随机情况说明
在dataset.py中设置“create_dataset”函数内的种子。使用train.py中的随机种子进行权重初始化。
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

Write Preview
Loading…
Cancel
Save