m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

!8864 add network's chinese readme

Browse Source 
From: @linqingke
Reviewed-by: @oacjiewen,@yingjy
Signed-off-by: @yingjy
pull/8864/MERGE
mindspore-ci-bot 4 years ago committed by Gitee
parent c3939e7448 7e7babd4a1
commit 7aac8c0b89
6 changed files with 1475 additions and 0 deletions
Show Stats Download Patch File Download Diff File

353
model_zoo/official/cv/cnnctc/README_CN.md
View File

File diff suppressed because it is too large Load Diff

241
model_zoo/official/cv/faster_rcnn/README_CN.md
Unescape View File

@ -0,0 +1,241 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [Faster R-CNN描述](#faster-r-cnn描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [训练过程](#训练过程)
- [用法](#用法)
- [结果](#结果)
- [评估过程](#评估过程)
- [用法](#用法-1)
- [结果](#结果-1)
- [模型描述](#模型描述)
- [性能](#性能)
- [训练性能](#训练性能)
- [评估性能](#评估性能)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# Faster R-CNN描述
在Faster R-CNN之前，目标检测网络依靠区域候选算法来假设目标的位置，如SPPNet、Fast R-CNN等。研究结果表明，这些检测网络的运行时间缩短了，但区域方案的计算仍是瓶颈。
Faster R-CNN提出，基于区域检测器（如Fast R-CNN）的卷积特征映射也可以用于生成区域候选。在这些卷积特征的顶部构建区域候选网络（RPN）需要添加一些额外的卷积层（与检测网络共享整个图像的卷积特征，可以几乎无代价地进行区域候选），同时输出每个位置的区域边界和客观性得分。因此，RPN是一个全卷积网络，可以端到端训练，生成高质量的区域候选，然后送入Fast R-CNN检测。
[论文](https://arxiv.org/abs/1506.01497)： Ren S , He K , Girshick R , et al. Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks[J]. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2015, 39(6).
# 模型架构
Faster R-CNN是一个两阶段目标检测网络，该网络采用RPN，可以与检测网络共享整个图像的卷积特征，可以几乎无代价地进行区域候选计算。整个网络通过共享卷积特征，进一步将RPN和Fast R-CNN合并为一个网络。
# 数据集
使用的数据集：[COCO 2017](<https://cocodataset.org/>)
- 数据集大小：19G
- 训练集：18G，118,000个图像
- 验证集：1G，5000个图像
- 标注集：241M，实例，字幕，person_keypoints等
- 数据格式：图像和json文件
- 注意：数据在dataset.py中处理。
# 环境要求
- 安装[MindSpore](https://www.mindspore.cn/install)。
- 下载数据集COCO 2017。
- 本示例默认使用COCO 2017作为训练数据集，您也可以使用自己的数据集。
1. 若使用COCO数据集，**执行脚本时选择数据集COCO。**
安装Cython和pycocotool，也可以安装mmcv进行数据处理。
```
pip install Cython
pip install pycocotools
pip install mmcv==0.2.14
```
在`config.py`中更改COCO_ROOT和其他您需要的设置。目录结构如下：
```
.
└─cocodataset
├─annotations
├─instance_train2017.json
└─instance_val2017.json
├─val2017
└─train2017
```
2. 若使用自己的数据集，**执行脚本时选择数据集为other。**
将数据集信息整理成TXT文件，每行内容如下：
```
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文件路径）的相对路径中读取图像。`IMAGE_DIR`和`ANNO_PATH`可在`config.py`中设置。
# 快速入门
通过官方网站安装MindSpore后，您可以按照如下步骤进行训练和评估：
注意：1. 第一次运行生成MindRecord文件，耗时较长。
2. 预训练模型是在ImageNet2012上训练的ResNet-50检查点。
3. VALIDATION_JSON_FILE为标签文件。CHECKPOINT_PATH是训练后的检查点文件。
```
# 单机训练
sh run_standalone_train_ascend.sh [PRETRAINED_MODEL]
# 分布式训练
sh run_distribute_train_ascend.sh [RANK_TABLE_FILE] [PRETRAINED_MODEL]
# 评估
sh run_eval_ascend.sh [VALIDATION_JSON_FILE] [CHECKPOINT_PATH]
```
# 脚本说明
## 脚本及样例代码
```shell
.
└─faster_rcnn
├─README.md // Faster R-CNN相关说明
├─scripts
├─run_standalone_train_ascend.sh // Ascend单机shell脚本
├─run_distribute_train_ascend.sh // Ascend分布式shell脚本
└─run_eval_ascend.sh // Ascend评估shell脚本
├─src
├─FasterRcnn
├─__init__.py // init文件
├─anchor_generator.py // 锚点生成器
├─bbox_assign_sample.py // 第一阶段采样器
├─bbox_assign_sample_stage2.py // 第二阶段采样器
├─faster_rcnn_r50.py // Faster R-CNN网络
├─fpn_neck.py // 特征金字塔网络
├─proposal_generator.py // 候选生成器
├─rcnn.py // R-CNN网络
├─resnet50.py // 骨干网络
├─roi_align.py // ROI对齐网络
└─rpn.py // 区域候选网络
├─config.py // 总配置
├─dataset.py // 创建并处理数据集
├─lr_schedule.py // 学习率生成器
├─network_define.py // Faster R-CNN网络定义
└─util.py // 例行操作
├─eval.py // 评估脚本
└─train.py // 训练脚本
```
## 训练过程
### 用法
```
# Ascend单机训练
sh run_standalone_train_ascend.sh [PRETRAINED_MODEL]
# Ascend分布式训练
sh run_distribute_train_ascend.sh [RANK_TABLE_FILE] [PRETRAINED_MODEL]
```
> 运行分布式任务时需要用到RANK_TABLE_FILE指定的rank_table.json。您可以使用[hccl_tools](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools)生成该文件。
> PRETRAINED_MODEL应该是在ImageNet 2012上训练的ResNet-50检查点。现成的pretrained_models目前不可用。敬请期待。
> config.py中包含原数据集路径，可以选择“coco_root”或“image_dir”。
### 结果
训练结果保存在示例路径中，文件夹名称以“train”或“train_parallel”开头。您可以在loss_rankid.log中找到检查点文件以及结果，如下所示。
```
# 分布式训练结果（8P）
epoch: 1 step: 7393, rpn_loss: 0.12054, rcnn_loss: 0.40601, rpn_cls_loss: 0.04025, rpn_reg_loss: 0.08032, rcnn_cls_loss: 0.25854, rcnn_reg_loss: 0.14746, total_loss: 0.52655
epoch: 2 step: 7393, rpn_loss: 0.06561, rcnn_loss: 0.50293, rpn_cls_loss: 0.02587, rpn_reg_loss: 0.03967, rcnn_cls_loss: 0.35669, rcnn_reg_loss: 0.14624, total_loss: 0.56854
epoch: 3 step: 7393, rpn_loss: 0.06940, rcnn_loss: 0.49658, rpn_cls_loss: 0.03769, rpn_reg_loss: 0.03165, rcnn_cls_loss: 0.36353, rcnn_reg_loss: 0.13318, total_loss: 0.56598
...
epoch: 10 step: 7393, rpn_loss: 0.03555, rcnn_loss: 0.32666, rpn_cls_loss: 0.00697, rpn_reg_loss: 0.02859, rcnn_cls_loss: 0.16125, rcnn_reg_loss: 0.16541, total_loss: 0.36221
epoch: 11 step: 7393, rpn_loss: 0.19849, rcnn_loss: 0.47827, rpn_cls_loss: 0.11639, rpn_reg_loss: 0.08209, rcnn_cls_loss: 0.29712, rcnn_reg_loss: 0.18115, total_loss: 0.67676
epoch: 12 step: 7393, rpn_loss: 0.00691, rcnn_loss: 0.10168, rpn_cls_loss: 0.00529, rpn_reg_loss: 0.00162, rcnn_cls_loss: 0.05426, rcnn_reg_loss: 0.04745, total_loss: 0.10859
```
## 评估过程
### 用法
```
# Ascend评估
sh run_eval_ascend.sh [VALIDATION_JSON_FILE] [CHECKPOINT_PATH]
```
> 在训练过程中生成检查点。
### 结果
评估结果将保存在示例路径中，文件夹名为“eval”。在此文件夹下，您可以在日志中找到类似以下的结果。
```
Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.360
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.586
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.385
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.229
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.402
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.441
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.299
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.487
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.515
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.346
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.562
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.631
```
# 模型描述
## 性能
### 训练性能
| 参数 | Faster R-CNN |
| -------------------------- | ----------------------------------------------------------- |
| 模型版本 | V1 |
| 资源 | Ascend 910；CPU 2.60GHz，192核；内存：755G |
| 上传日期 | 2020/8/31 |
| MindSpore版本 | 1.0.0 |
| 数据集 | COCO 2017 |
| 训练参数 | epoch=12, batch_size=2 |
| 优化器 | SGD |
| 损失函数 | Softmax交叉熵，Sigmoid交叉熵，SmoothL1Loss |
| 速度 | 1卡：190毫秒/步；8卡：200毫秒/步 |
| 总时间 | 1卡：37.17小时；8卡：4.89小时 |
| 参数(M) | 250 |
| 脚本 | [Faster R-CNN脚本](https://gitee.com/mindspore/mindspore/tree/r1.0/model_zoo/office/cv/faster_rcnn) |
### 评估性能
| 参数 | Faster R-CNN |
| ------------------- | --------------------------- |
| 模型版本 | V1 |
| 资源 | Ascend 910 |
| 上传日期 | 2020/8/31 |
| MindSpore版本 | 1.0.0 |
| 数据集 | COCO2017 |
| batch_size | 2 |
| 输出 | mAP |
| 准确率 | IoU=0.50：57.6% |
| 推理模型 | 250M（.ckpt文件） |
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

186
model_zoo/official/cv/lenet_quant/Readme_CN.md
Unescape View File

@ -0,0 +1,186 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [LeNet描述](#lenet描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [训练](#训练)
- [评估过程](#评估过程)
- [评估](#评估)
- [模型描述](#模型描述)
- [性能](#性能)
- [评估性能](#评估性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# LeNet描述
LeNet是1998年提出的一种典型的卷积神经网络。它被用于数字识别并取得了巨大的成功。
[论文](https://ieeexplore.ieee.org/document/726791)： Y.Lecun, L.Bottou, Y.Bengio, P.Haffner.Gradient-Based Learning Applied to Document Recognition.*Proceedings of the IEEE*.1998.
这是LeNet的量化网络。
# 模型架构
LeNet非常简单，包含5层，由2个卷积层和3个全连接层组成。
# 数据集
使用的数据集：[MNIST](<http://yann.lecun.com/exdb/mnist/>)
- 数据集大小：52.4M，共10个类，6万张 28*28图像
- 训练集：6万张图像
- 测试集：1万张图像
- 数据格式：二进制文件
- 注：数据在dataset.py中处理。
- 目录结构如下：
```
└─Data
├─test
│ t10k-images.idx3-ubyte
│ t10k-labels.idx1-ubyte
│
└─train
train-images.idx3-ubyte
train-labels.idx1-ubyte
```
# 环境要求
- 硬件：Ascend
- 使用Ascend搭建硬件环境
- 框架
- [MindSpore](https://www.mindspore.cn/install/en)
- 如需查看详情，请参见如下资源：
- [MindSpore教程](https://www.mindspore.cn/tutorial/training/en/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/en/master/index.html)
# 快速入门
通过官方网站安装MindSpore后，您可以按照如下步骤进行训练和评估：
```python
# 进入../lenet目录，训练lenet网络，生成'.ckpt'文件。
sh run_standalone_train_ascend.sh [DATA_PATH]
# 进入lenet目录，训练LeNet-Quant
python train.py --device_target=Ascend --data_path=[DATA_PATH] --ckpt_path=[CKPT_PATH] --dataset_sink_mode=True
# 评估LeNet-Quant
python eval.py --device_target=Ascend --data_path=[DATA_PATH] --ckpt_path=[CKPT_PATH] --dataset_sink_mode=True
```
# 脚本说明
## 脚本及样例代码
```
├── model_zoo
├── README.md // 所有型号的描述
├── lenet_quant
├── README.md // LeNet-Quant描述
├──src
│ ├── config.py // 参数配置
│ ├── dataset.py // 创建数据集
│ ├── lenet_fusion.py // 自动构建LeNet-Quant的定量网络模型
│ ├── lenet_quant.py // 手动构建的LeNet-Quant定量网络模型
│ ├── loss_monitor.py // 监控网络损失和其他数据
├── requirements.txt // 需要的包
├── train.py // 使用Ascend训练LeNet-Quant网络
├── eval.py // 使用Ascend评估LeNet-Quant网络d
```
## 脚本参数
```python
train.py和config.py中主要参数如下：
--data_path：到训练和评估数据集的绝对全路径
--epoch_size：训练轮次数
--batch_size：训练批次大小
--image_height：输入到模型的图像高度
--image_width：输入到模型的图像宽度
--device_target：代码实施的设备可选值为"Ascend","GPU", "CPU"，目前只支持"Ascend"
--ckpt_path：训练后保存的检查点文件的绝对全路径
--data_path：数据集所在路径
```
## 训练过程
### 训练
```
python train.py --device_target=Ascend --dataset_path=/home/datasets/MNIST --dataset_sink_mode=True > log.txt 2>&1 &
```
训练结束，损失值如下：
```
# grep "Epoch " log.txt
Epoch:[ 1/ 10], step:[ 937/ 937], loss:[0.0081], avg loss:[0.0081], time:[11268.6832ms]
Epoch time:11269.352, per step time:12.027, avg loss:0.008
Epoch:[ 2/ 10], step:[ 937/ 937], loss:[0.0496], avg loss:[0.0496], time:[3085.2389ms]
Epoch time:3085.641, per step time:3.293, avg loss:0.050
Epoch:[ 3/ 10], step:[ 937/ 937], loss:[0.0017], avg loss:[0.0017], time:[3085.3510ms]
...
...
```
模型检查点保存在当前目录下。
## 评估过程
### 评估
在运行以下命令之前，请检查用于评估的检查点路径。
```
python eval.py --data_path Data --ckpt_path ckpt/checkpoint_lenet-1_937.ckpt > log.txt 2>&1 &
```
您可以通过log.txt文件查看结果。测试数据集的准确性如下：
```
# grep "Accuracy:" log.txt
'Accuracy':0.9842
```
# 模型描述
## 性能
### 评估性能
| 参数 | LeNet |
| -------------------------- | ----------------------------------------------------------- |
| 资源 | Ascend 910 CPU：2.60GHz，192核，内存：755G |
| 上传日期 | 2020-06-09 |
| MindSpore版本 | 0.5.0-beta |
| 数据集 | MNIST |
| 训练参数 | epoch=10, steps=937, batch_size = 64, lr=0.01 |
| 优化器 | Momentum |
| 损失函数 | Softmax交叉熵 |
| 输出 | 概率 |
| 损失 | 0.002 |
| 速度 |3.29毫秒/步 |
| 总时长 | 40秒 |
| 微调检查点 | 482k (.ckpt文件) |
| 脚本 | [脚本](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/lenet) |
# 随机情况说明
在dataset.py中，我们设置了“create_dataset”函数内的种子。
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

225
model_zoo/official/cv/mobilenetv2_quant/README_CN.md
Unescape View File

@ -0,0 +1,225 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [MobileNetV2描述](#mobilenetv2描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [特性](#特性)
- [混合精度](#混合精度)
- [环境要求](#环境要求)
- [脚本说明](#脚本说明)
- [脚本和样例代码](#脚本和样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [用法](#用法)
- [启动](#启动)
- [结果](#结果)
- [评估过程](#评估过程)
- [用法](#用法-1)
- [启动](#启动-1)
- [结果](#结果-1)
- [模型描述](#模型描述)
- [性能](#性能)
- [训练性能](#训练性能)
- [评估性能](#评估性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# MobileNetV2描述
MobileNetV2结合硬件感知神经网络架构搜索（NAS）和NetAdapt算法，已经可以移植到手机CPU上运行，后续随新架构进一步优化改进。（2019年11月20日）
[论文](https://arxiv.org/pdf/1905.02244)：Howard, Andrew, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang et al."Searching for MobileNetV2."In Proceedings of the IEEE International Conference on Computer Vision, pp. 1314-1324.2019.
此为MobileNetV2的量化网络。
# 模型架构
MobileNetV2总体网络架构如下：
[链接](https://arxiv.org/pdf/1905.02244)
# 数据集
使用的数据集：[imagenet](http://www.image-net.org/)
-数据集大小：125G，共1000个类、1.2万张彩色图像
- 训练集: 120G，共1.2万张图像
- 测试集：5G，共5万张图像
- 数据格式：RGB
- 注：数据在src/dataset.py中处理。
# 特性
## 混合精度
采用[混合精度](https://www.mindspore.cn/tutorial/training/en/master/advanced_use/enable_mixed_precision.html)的训练方法使用支持单精度和半精度数据来提高深度学习神经网络的训练速度，同时保持单精度训练所能达到的网络精度。混合精度训练提高计算速度、减少内存使用的同时，支持在特定硬件上训练更大的模型或实现更大批次的训练。
以FP16算子为例，如果输入数据类型为FP32，MindSpore后台会自动降低精度来处理数据。用户可打开INFO日志，搜索“reduce precision”查看精度降低的算子。
# 环境要求
- 硬件：昇腾处理器（Ascend）
- 使用昇腾处理器来搭建硬件环境。如需试用昇腾处理器，请发送[申请表](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)
# 脚本说明
## 脚本和样例代码
```python
├── mobileNetv2_quant
├── Readme.md # MobileNetV2-Quant相关描述
├── scripts
│ ├──run_train.sh # 使用昇腾处理器进行训练的shell脚本
│ ├──run_infer.sh # 使用昇腾处理器进行评估的shell脚本
├── src
│ ├──config.py # 参数配置
│ ├──dataset.py # 创建数据集
│ ├──launch.py # 启动python脚本
│ ├──lr_generator.py # 配置学习率
│ ├──mobilenetV2.py # MobileNetV2架构
│ ├──utils.py # 提供监控模块
├── train.py # 训练脚本
├── eval.py # 评估脚本
├── export.py # 导出检查点文件到air/onnx中
```
## 脚本参数
在config.py中可以同时配置训练参数和评估参数。
- 配置MobileNetV2-quant和ImageNet2012数据集。
```python
'class_num':1000 # 数据集类数
'batch_size':134 # 训练批次大小
'epoch_size':60 # Mobilenetv2-quant的训练轮次
'start epoch':200 # 非量化网络预训练轮次
'warmup_epochs':0 # 热身轮次
'lr':0.3 # 学习率
'momentum':0.9 # 动量
'weight_decay':4E-5 # 权重衰减值
'loss_scale':1024 # loss_scale初始值
'label_smooth':0.1 # 标签平滑因子
'loss_scale':1024 # loss_scale初始值
'save_checkpoint':True # 训练结束后是否保存检查点文件
'save_checkpoint_epochs':1 # 开始保存检查点文件的步骤
'keep_checkpoint_max':300 # 只保留最后一个keep_checkpoint_max检查点
'save_checkpoint_path':'./checkpoint' # 检查点文件保存的绝对全路径
```
## 训练过程
### 用法
使用python或shell脚本开始训练。shell脚本的使用方法如下：
- bash run_train.sh [Ascend] [RANK_TABLE_FILE] [DATASET_PATH] [PRETRAINED_CKPT_PATH]\（可选）
- bash run_train.sh [GPU] [DEVICE_ID_LIST] [DATASET_PATH] [PRETRAINED_CKPT_PATH]\（可选）
### 启动
``` bash
# 训练示例
>>> bash run_train.sh Ascend ~/hccl_4p_0123_x.x.x.x.json ~/imagenet/train/ ~/mobilenet.ckpt
>>> bash run_train.sh GPU 1,2 ~/imagenet/train/ ~/mobilenet.ckpt
```
### 结果
训练结果保存在示例路径中。`Ascend`处理器训练的检查点默认保存在`./train/device$i/checkpoint`，训练日志重定向到`./train/device$i/train.log`。`GPU`处理器训练的检查点默认保存在`./train/checkpointckpt_$i`中，训练日志重定向到`./train/train.log`中。
`train.log`内容如下：
```
epoch:[ 0/200], step:[ 624/ 625], loss:[5.258/5.258], time:[140412.236], lr:[0.100]
epoch time:140522.500, per step time:224.836, avg loss:5.258
epoch:[ 1/200], step:[ 624/ 625], loss:[3.917/3.917], time:[138221.250], lr:[0.200]
epoch time:138331.250, per step time:221.330, avg loss:3.917
```
## 评估过程
### 用法
使用python或shell脚本开始训练。shell脚本的使用方法如下：
- Ascend: sh run_infer_quant.sh Ascend [DATASET_PATH] [CHECKPOINT_PATH]
### 启动
```
# 推理示例
shell:
Ascend: sh run_infer_quant.sh Ascend ~/imagenet/val/ ~/train/mobilenet-60_1601.ckpt
```
> 训练过程中可以生成检查点。
### 结果
推理结果保存在示例路径，可以在`./val/infer.log`中找到如下结果：
```
result:{'acc':0.71976314102564111}
```
# 模型描述
## 性能
### 训练性能
| 参数 | MobilenetV2 |
| -------------------------- | ---------------------------------------------------------- |
| 模型版本 | V2 |
| 资源 | Ascend 910；CPU：2.60GHz，192核；内存：755G |
| 上传日期 | 2020-06-06 |
| MindSpore版本 | 0.3.0 |
| 数据集 | ImageNet |
| 训练参数 | src/config.py |
| 优化器 | Momentum |
| 损失函数 | Softmax交叉熵 |
| 输出 | ckpt文件 |
| 损失 | 1.913 |
| 准确率 | |
| 总时长 | 16 h |
| 参数(M) | batch_size=192, epoch=60 |
| 微调检查点 | |
| 推理模型 | |
#### 评估性能
| 参数 | |
| -------------------------- | ----------------------------- |
| 模型版本 | V2 |
| 资源 | Ascend 910 |
| 上传日期 | 2020-06-06 |
| MindSpore版本 | 0.3.0 |
| 数据集 | ImageNet, 1.2W |
| 批次大小 | 130（8P） |
| 输出 | 概率 |
| 准确率 | ACC1[71.78%] ACC5[90.90%] |
| 速度 | 200毫秒/步 |
| 总时长 | 5分钟 |
| 推理模型 | |
# 随机情况说明
[dataset.py](http://dataset.py/)中设置了“create_dataset”函数内的种子，同时还使用了train.py中的随机种子。
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

248
model_zoo/official/cv/psenet/README_CN.md
Unescape View File

@ -0,0 +1,248 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [PSENet概述](#psenet概述)
- [PSENet示例](#psenet示例)
- [概述](#概述)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本和样例代码](#脚本和样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [分布式训练](#分布式训练)
- [评估过程](#评估过程)
- [运行测试代码](#运行测试代码)
- [ICDAR2015评估脚本](#icdar2015评估脚本)
- [用法](#用法)
- [结果](#结果)
- [模型描述](#模型描述)
- [性能](#性能)
- [评估性能](#评估性能)
- [推理性能](#推理性能)
- [使用方法](#使用方法)
- [推理](#推理)
<!-- /TOC -->
# PSENet概述
随着卷积神经网络的发展，场景文本检测技术迅速发展，但其算法中存在的两大问题阻碍了这一技术的应用：第一，现有的大多数算法都需要四边形边框来精确定位任意形状的文本；第二，两个相邻文本可能会因错误检测而被覆盖。传统意义上，语义分割可以解决第一个问题，但无法解决第二个问题。而PSENet能够精确地检测出任意形状文本实例，同时解决了两个问题。具体地说，PSENet为每个文本实例生成不同的扩展内核，并逐渐将最小扩展内核扩展为具有完整形状的文本实例。由于最小内核之间的几何差别较大，PSNet可以有效分割封闭的文本实例，更容易地检测任意形状文本实例。通过在CTW1500、全文、ICDAR 2015和ICDAR 2017 MLT中进行多次实验，PSENet的有效性得以验证。
[论文](https://openaccess.thecvf.com/content_CVPR_2019/html/Wang_Shape_Robust_Text_Detection_With_Progressive_Scale_Expansion_Network_CVPR_2019_paper.html)： Wenhai Wang, Enze Xie, Xiang Li, Wenbo Hou, Tong Lu, Gang Yu, Shuai Shao; Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019, pp. 9336-9345
# PSENet示例
## 概述
渐进尺度扩展网络（PSENet）是一种能够很好地检测自然场景中任意形状文本的文本检测器。
# 数据集
使用的数据集：[ICDAR2015](https://rrc.cvc.uab.es/?ch=4&com=tasks#TextLocalization)
训练集：包括约4500个可读单词的1000张图像。
测试集：约2000个可读单词。
# 环境要求
- 硬件：昇腾处理器（Ascend）
- 使用Ascend处理器来搭建硬件环境。如需试用昇腾处理器，请发送[申请表](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)
- 如需查看详情，请参见如下资源：
- [MindSpore教程](https://www.mindspore.cn/tutory/training/en/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/zh-CN/master/index.html)
- 安装Mindspore
- 安装[pyblind11](https://github.com/pybind/pybind11)
- 安装[Opencv3.4](https://docs.opencv.org/3.4.9/d7/d9f/tutory_linux_install.html)
# 快速入门
通过官方网站安装MindSpore后，您可以按照如下步骤进行培训和评估：
```python
# 分布式训练运行示例
sh scripts/run_distribute_train.sh pretrained_model.ckpt
# 下载opencv库
download pyblind11, opencv3.4
# 安装pyblind11 opencv3.4
setup pyblind11(install the library by the pip command)
setup opencv3.4(compile source code install the library)
# 输入路径，运行Makefile，找到产品文件
cd ./src/ETSNET/pse/;make
# 运行test.py
python test.py --ckpt=pretrained_model.ckpt
# 单击[此处](https://rrc.cvc.uab.es/?ch=4&com=tasks#TextLocalization)下载评估方法
# 点击"我的方法"按钮，下载评估脚本
download script.py
# 运行评估示例
sh scripts/run_eval_ascend.sh
```
## 脚本说明
## 脚本和样例代码
```
└── PSENet
├── README.md // PSENet相关描述
├── scripts
├── run_distribute_train.sh // 用于分布式训练的shell脚本
└── run_eval_ascend.sh // 用于评估的shell脚本
├──src
├── __init__.py
├── generate_hccn_file.py // 创建rank.json文件
├── ETSNET
├── __init__.py
├── base.py // 卷积和BN算子
├── dice_loss.py // 计算PSENet损耗值
├── etsnet.py // PSENet中的子网
├── fpn.py // PSENet中的子网
├── resnet50.py // PSENet中的子网
├── pse // PSENet中的子网
├── __init__.py
├── adaptor.cpp
├── adaptor.h
├── Makefile
├──config.py // 参数配置
├──dataset.py // 创建数据集
├──network_define.py // PSENet架构
├──test.py // 测试脚本
├──train.py // 训练脚本
```
## 脚本参数
```python
train.py和config.py中主要参数如下：
-- pre_trained：是从零开始训练还是基于预训练模型训练。可选值为True、False。
-- device_id：用于训练或评估数据集的设备ID。当使用train.sh进行分布式训练时，忽略此参数。
-- device_num：使用train.sh进行分布式训练时使用的设备。
```
## 训练过程
### 分布式训练
```
sh scripts/run_distribute_train.sh pretrained_model.ckpt
```
上述shell脚本将在后台运行分布训练。可以通过`device[X]/test_*.log`文件查看结果。
采用以下方式达到损失值：
```
# grep "epoch：" device_*/loss.log
device_0/log:epoch： 1, step: 20，loss is 0.80383
device_0/log:epcoh： 2, step: 40，loss is 0.77951
...
device_1/log:epoch： 1, step: 20，loss is 0.78026
device_1/log:epcoh： 2, step: 40，loss is 0.76629
```
## 评估过程
### 运行测试代码
python test.py --ckpt=./device*/ckpt*/ETSNet-*.ckpt
### ICDAR2015评估脚本
#### 用法
+ 第一步：单击[此处](https://rrc.cvc.uab.es/?ch=4&com=tasks#TextLocalization)下载评估方法。
+ 第二步：单击"我的方法"按钮，下载评估脚本。
+ 第三步：建议将评估方法根符号链接到$MINDSPORE/model_zoo/psenet/eval_ic15/。如果您的文件夹结构不同，您可能需要更改评估脚本文件中的相应路径。
```
sh ./script/run_eval_ascend.sh.sh
```
#### 结果
Calculated!{"precision": 0.8147966668299853，"recall"：0.8006740491092923，"hmean"：0.8076736279747451，"AP"：0}
# 模型描述
## 性能
### 评估性能
| 参数 | PSENet |
| -------------------------- | ----------------------------------------------------------- |
| 模型版本 | Inception V1 |
| 资源 | Ascend 910； CPU： 2.60GHz，192内核；内存，755G |
| 上传日期 | 2020-09-15 |
| MindSpore版本 | 1.0-alpha |
| 数据集 | ICDAR2015 |
| 训练参数 | start_lr=0.1; lr_scale=0.1 |
| 优化器 | SGD |
| 损失函数 | LossCallBack |
| 输出 | 概率 |
| 损失 | 0.35 |
| 速度 | 1卡：444毫秒/步；4卡：446毫秒/步
| 总时间 | 1卡：75.48小时；4卡：18.87小时|
| 参数(M) | 27.36 |
| 微调检查点 | 109.44M （.ckpt file） |
| 脚本 | https://gitee.com/mindspore/mindspore/tree/master/model_zoo/psenet |
### 推理性能
| 参数 | PSENet |
| ------------------- | --------------------------- |
| 模型版本 | Inception V1 |
| 资源 | Ascend 910 |
| 上传日期 | 2020/09/15 |
| MindSpore版本 | 1.0-alpha |
| 数据集| ICDAR2015 |
| 输出 | 概率 |
| 准确性 | 1卡：81%; 4卡：81% |
## 使用方法
### 推理
如果您需要使用已训练模型在GPU、Ascend 910、Ascend 310等多个硬件平台上进行推理，可参考[此处](https://www.mindspore.cn/tutory/training/en/master/advanced_use/migrate_3rd_scripts.html)。操作示例如下：
```
# 加载未知数据集进行推理
dataset = dataset.create_dataset(cfg.data_path, 1, False)
# 定义模型
config.INFERENCE = False
net = ETSNet(config)
net = net.set_train()
param_dict = load_checkpoint(args.pre_trained)
load_param_into_net(net, param_dict)
print('Load Pretrained parameters done!')
criterion = DiceLoss(batch_size=config.TRAIN_BATCH_SIZE)
lrs = lr_generator(start_lr=1e-3, lr_scale=0.1, total_iters=config.TRAIN_TOTAL_ITER)
opt = nn.SGD(params=net.trainable_params(), learning_rate=lrs, momentum=0.99, weight_decay=5e-4)
# 模型变形
net = WithLossCell(net, criterion)
net = TrainOneStepCell(net, opt)
time_cb = TimeMonitor(data_size=step_size)
loss_cb = LossCallBack(per_print_times=20)
# 设置并应用检查点参数
ckpoint_cf = CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=2)
ckpoint_cb = ModelCheckpoint(prefix="ETSNet", config=ckpoint_cf, directory=config.TRAIN_MODEL_SAVE_PATH)
model = Model(net)
model.train(config.TRAIN_REPEAT_NUM, ds, dataset_sink_mode=False, callbacks=[time_cb, loss_cb, ckpoint_cb])
# 加载预训练模型
param_dict = load_checkpoint(cfg.checkpoint_path)
load_param_into_net(net, param_dict)
net.set_train(False)
# 对未知数据集进行预测
acc = model.eval(dataset)
print("accuracy: ", acc)
```

222
model_zoo/official/cv/resnet50_quant/README_CN.md
Unescape View File

@ -0,0 +1,222 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [ResNet-50概述](#resnet-50概述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [特性](#特性)
- [混合精度](#混合精度)
- [环境要求](#环境要求)
- [脚本说明](#脚本说明)
- [脚本和样例代码](#脚本和样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [用法](#用法)
- [启动](#启动)
- [结果](#结果)
- [评估过程](#评估过程)
- [用法](#用法-1)
- [启动](#启动-1)
- [结果](#结果-1)
- [模型描述](#模型描述)
- [性能](#性能)
- [训练性能](#训练性能)
- [评估性能](#评估性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# ResNet-50概述
ResNet-50是一个50层的卷积神经网络，可以将ImageNet图像分成1000个目标类，准确率达76%。
[论文](https://arxiv.org/abs/1512.03385)： Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun."Deep Residual Learning for Image Recognition."： He, Kaiming , et al. "Deep Residual Learning for Image Recognition." IEEE Conference on Computer Vision & Pattern Recognition IEEE Computer Society, 2016.
此为ResNet-50的量化分析网络。
## 模型架构
ResNet-50总体网络架构如下：
[链接](https://arxiv.org/pdf/1512.03385.pdf)
## 数据集
使用的数据集：[imagenet](http://www.image-net.org/)
-数据集大小：125G，共1000个类、1.2万张彩色图像
- 训练集：120G，共1.2万张图像
- 测试集：5G，共5万张图像
-数据格式：RGB
* 注：数据在src/dataset.py中处理。
## 特性
## 混合精度
采用[混合精度](https://www.mindspore.cn/tutorial/training/en/master/advanced_use/enable_mixed_precision.html)的训练方法使用支持单精度和半精度数据来提高深度学习神经网络的训练速度，同时保持单精度训练所能达到的网络精度。混合精度训练提高计算速度、减少内存使用的同时，支持在特定硬件上训练更大的模型或实现更大批次的训练。
以FP16算子为例，如果输入数据类型为FP32，MindSpore后台会自动降低精度来处理数据。用户可打开INFO日志，搜索“reduce precision”查看精度降低的算子。
# 环境要求
- 硬件：昇腾处理器（Ascend）
- 使用昇腾处理器来搭建硬件环境。如需试用昇腾处理器，请发送[申请表](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)
-如需查看详情，请参见如下资源：
- [MindSpore教程](https://www.mindspore.cn/tutorial/training/en/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/en/master/index.html)
## 脚本说明
## 脚本和样例代码
```python
├── resnet50_quant
├── Readme.md # ResNet-50-Quant相关描述
├── scripts
│ ├──run_train.sh # 使用昇腾处理器进行训练的shell脚本
│ ├──run_infer.sh # 使用昇腾处理器进行评估的shell脚本
├── model
│ ├──resnet_quant.py # 定义ResNet50-Quant的网络模型
├──src
│ ├──config.py # 参数配置
│ ├──dataset.py # 创建数据集
│ ├──launch.py # 启动Python脚本
│ ├──lr_generator.py # 配置学习速率
│ ├──crossentropy.py # 定义ResNet-50-Quant的交叉熵
├── train.py # 训练脚本
├── eval.py # 评估脚本
```
### 脚本参数
在config.py中可以同时配置训练参数和评估参数。
- 配置Resnet50-quent和ImageNet2012数据集。
```python
'class_num'：10 # 数据集的类数
"batch_size"：32 # 训练批次大小
"loss_scale"：1024 # loss_scale初始值
'momentum': 0.9 # 动量
'weight_decay'：1e-4 # 权重衰减值
'epoch_size'：120 # 训练轮次数
'pretrained_epoch_size'：90 # 非量化网络预训练轮次数
'data_load_mode': 'mindata' # 数据加载模式
'save_checkpoint'：True # 训练结束后是否保存检查点文件
"save_checkpoint_epochs": 1 # 开始保存检查点文件的步骤
'keep_checkpoint_max'：50 # 只保留最后一个keep_checkpoint_max检查点
'save_checkpoint_path'：'./' # 检查点文件保存的绝对全路径
"warmup_epochs"：0 # 热身轮次数
'lr_decay_mode'："cosine" # 学习速率衰减模式，包括step、step_decay、cosine及liner
'use_label_smooth'：True # 是否使用标签平滑
'label_smooth_factor': 0.1 # 标签平滑因子
"lr_init": 0 # 初始学习速率
'lr_max'：0.005 # 最大学习速率
```
## 训练过程
### 用法
- 晟腾（Ascend）: sh run_train.sh Ascend [RANK_TABLE_FILE] [DATASET_PATH] [PRETRAINED_CKPT_PATH]\（可选）
### 启动
```
# 训练示例
Ascend:bash run_train.sh Ascend ~/hccl_4p_0123_x.x.x.json ~/imagenet/train/
```
### 结果
训练结果保存在示例路径中。检查点默认保存在`./train/device$i/`，训练日志重定向到`./train/device$i/train.log`，内容如下：
```
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
```
## 评估过程
### 用法
使用python或shell脚本开始训练。shell脚本的使用方法如下：
- 昇腾（Ascend）：sh run_infer.sh Ascend[DATASET_PATH] [CHECKPOINT_PATH]
### 启动
```
# 推理示例
shell:
Ascend: sh run_infer.sh Ascend ~/imagenet/val/ ~/train/Resnet50-30_5004.ckpt
```
> 训练过程中可以生成检查点。
### 结果
推理结果保存在示例路径中，可以在`./eval/infer.log`中找到如下结果：
```
result:{'acc'：0.76576314102564111}
```
# 模型描述
## 性能
### 训练性能
| 参数 | Resnet50 |
| -------------------------- | ---------------------------------------------------------- |
| 模型版本 | V1 |
| 资源 | Ascend 910； CPU：2.60GHz，192核；内存：755G |
| 上传日期 | 2020-06-06 |
| MindSpore版本 | 0.3.0 |
| 数据集 | ImageNet |
| 训练参数 | src/config.py |
| 优化器 | Momentum |
| 损失函数 | SoftmaxCrossEntropy |
| 输出 | ckpt file |
| 损失 | 1.8 |
| 准确率 |
| 总时长 | 16h |
| 参数(M) | batch_size=32, epoch=30 |
| 微调检查点 |
| 推理模型 |
### 评估性能
| 参数列表 | Resnet50 |
| -------------------------- | ----------------------------- |
| 模型版本 | V1 |
| 资源 | Ascend 910 |
| 上传日期 | 2020-06-06 |
| MindSpore版本 | 0.3.0 |
| 数据集 | ImageNet, 1.2W |
| batch_size | 130（8卡） |
| 输出 | 概率 |
| 准确率 | ACC1[76.57%] ACC5[92.90%] |
| 速度 | 5毫秒/步 |
| 总时间 | 5分钟 |
| 推理模型 |
## 随机情况说明
[dataset.py](http://dataset.py/)中设置了“create_dataset”函数内的种子，同时还使用了train.py中的随机种子
## ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。
Write Preview
Loading…
Cancel
Save