add network's chinese readme

This commit is contained in:
linqingke 2020-11-21 09:43:34 +08:00
parent 0b992c077b
commit 7e7babd4a1
6 changed files with 1475 additions and 0 deletions

View File

@ -0,0 +1,353 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [CNN+CTC描述](#cnnctc描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [特性](#特性)
- [混合精度](#混合精度)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [训练](#训练)
- [训练结果](#训练结果)
- [评估过程](#评估过程)
- [评估](#评估)
- [模型描述](#模型描述)
- [性能](#性能)
- [训练性能](#训练性能)
- [评估性能](#评估性能)
- [用法](#用法)
- [推理](#推理)
- [在预训练模型上继续训练](#在预训练模型上继续训练)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# CNN+CTC描述
本文描述了对场景文本识别STR的三个主要贡献。
首先检查训练和评估数据集不一致的内容,以及导致的性能差距。
再引入一个统一的四阶段STR框架目前大多数STR模型都能够适应这个框架。
使用这个框架可以广泛评估以前提出的STR模块并发现以前未开发的模块组合。
第三,分析在一致的训练和评估数据集下,模块对性能的贡献,包括准确率、速度和内存需求。
这些分析清除了当前比较的障碍,有助于了解现有模块的性能增益。
[论文](https://arxiv.org/abs/1904.01906) J. Baek, G. Kim, J. Lee, S. Park, D. Han, S. Yun, S. J. Oh, and H. Lee, “What is wrong with scene text recognition model comparisons? dataset and model analysis,” ArXiv, vol. abs/1904.01906, 2019.
# 模型架构
示例在MindSpore上使用MJSynth和SynthText数据集训练CNN+CTC模型进行文本识别。
# 数据集
[MJSynth](https://www.robots.ox.ac.uk/~vgg/data/text/)和[SynthText](https://github.com/ankush-me/SynthText)数据集用于模型训练。[The IIIT 5K-word dataset](https://cvit.iiit.ac.in/research/projects/cvit-projects/the-iiit-5k-word-dataset)数据集用于评估。
- 步骤1
所有数据集均经过预处理,以.lmdb格式存储点击[**此处**](https://drive.google.com/drive/folders/192UfE9agQUMNq6AgU3_E05_FcPZK4hyt)可下载。
- 步骤2
解压下载的文件重命名MJSynth数据集为MJSynthText数据集为STIIIT数据集为IIIT。
- 步骤3
将上述三个数据集移至`cnctc_data`文件夹中,结构如下:
```
|--- CNNCTC/
|--- cnnctc_data/
|--- ST/
data.mdb
lock.mdb
|--- MJ/
data.mdb
lock.mdb
|--- IIIT/
data.mdb
lock.mdb
......
```
- 步骤4
预处理数据集:
```
python src/preprocess_dataset.py
```
这大约需要75分钟。
# 特性
## 混合精度
采用[混合精度](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/enable_mixed_precision.html)的训练方法使用支持单精度和半精度数据来提高深度学习神经网络的训练速度,同时保持单精度训练所能达到的网络精度。混合精度训练提高计算速度、减少内存使用的同时,支持在特定硬件上训练更大的模型或实现更大批次的训练。
以FP16算子为例如果输入数据类型为FP32MindSpore后台会自动降低精度来处理数据。用户可打开INFO日志搜索“reduce precision”查看精度降低的算子。
# 环境要求
- 硬件Ascend
- 准备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)
- 如需查看详情,请参见如下资源:
- [MindSpore教程](https://www.mindspore.cn/tutorial/zh-CN/master/index.html)
- [MindSpore API](https://www.mindspore.cn/api/zh-CN/master/index.html)
# 快速入门
- 安装依赖:
```
pip install lmdb
pip install Pillow
pip install tqdm
pip install six
```
- 单机训练:
```
bash scripts/run_standalone_train_ascend.sh $PRETRAINED_CKPT
```
- 分布式训练:
```
bash scripts/run_distribute_train_ascend.sh $RANK_TABLE_FILE $PRETRAINED_CKPT
```
- 评估:
```
bash scripts/run_eval_ascend.sh $TRAINED_CKPT
```
# 脚本说明
## 脚本及样例代码
完整代码结构如下:
```
|--- CNNCTC/
|---README.md // CNN+CTC相关描述
|---train.py // 训练脚本
|---eval.py // 评估脚本
|---scripts
|---run_standalone_train_ascend.sh // Ascend单机shell脚本
|---run_distribute_train_ascend.sh // Ascend分布式shell脚本
|---run_eval_ascend.sh // Ascend评估shell脚本
|---src
|---__init__.py // init文件
|---cnn_ctc.py // cnn_ctc网络
|---config.py // 总配置
|---callback.py // 损失回调文件
|---dataset.py // 处理数据集
|---util.py // 常规操作
|---generate_hccn_file.py // 生成分布式json文件
|---preprocess_dataset.py // 预处理数据集
```
## 脚本参数
在`config.py`中可以同时配置训练参数和评估参数。
参数:
* `--CHARACTER`:字符标签。
* `--NUM_CLASS`类别数包含所有字符标签和CTCLoss的<blank>标签。
* `--HIDDEN_SIZE`:模型隐藏大小。
* `--FINAL_FEATURE_WIDTH`:特性的数量。
* `--IMG_H`:输入图像高度。
* `--IMG_W`:输入图像宽度。
* `--TRAIN_DATASET_PATH`:训练数据集的路径。
* `--TRAIN_DATASET_INDEX_PATH`:决定顺序的训练数据集索引文件的路径。
* `--TRAIN_BATCH_SIZE`:训练批次大小。在批次大小和索引文件中,必须确保输入数据是固定的形状。
* `--TRAIN_DATASET_SIZE`:训练数据集大小。
* `--TEST_DATASET_PATH`:测试数据集的路径。
* `--TEST_BATCH_SIZE`:测试批次大小。
* `--TEST_DATASET_SIZE`:测试数据集大小。
* `--TRAIN_EPOCHS`:总训练轮次。
* `--CKPT_PATH`:模型检查点文件路径,可用于恢复训练和评估。
* `--SAVE_PATH`:模型检查点文件保存路径。
* `--LR`:单机训练学习率。
* `--LR_PARA`:分布式训练学习率。
* `--Momentum`:动量。
* `--LOSS_SCALE`:损失放大,避免梯度下溢。
* `--SAVE_CKPT_PER_N_STEP`每N步保存模型检查点文件。
* `--KEEP_CKPT_MAX_NUM`:模型检查点文件保存数量上限。
## 训练过程
### 训练
- 单机训练:
```
bash scripts/run_standalone_train_ascend.sh $PRETRAINED_CKPT
```
结果和检查点被写入`./train`文件夹。日志可以在`./train/log`中找到,损失值记录在`./train/loss.log`中。
`$PRETRAINED_CKPT`为模型检查点的路径,**可选**。如果值为none模型将从头开始训练。
- 分布式训练:
```
bash scripts/run_distribute_train_ascend.sh $RANK_TABLE_FILE $PRETRAINED_CKPT
```
结果和检查点分别写入设备`i`的`./train_parallel_{i}`文件夹。
日志可以在`./train_parallel_{i}/log_{i}.log`中找到,损失值记录在`./train_parallel_{i}/loss.log`中。
在Ascend上运行分布式任务时需要`$RANK_TABLE_FILE`。
`$PATH_TO_CHECKPOINT`为模型检查点的路径,**可选**。如果值为none模型将从头开始训练。
### 训练结果
训练结果保存在示例路径中文件夹名称以“train”或“train_parallel”开头。您可在此路径下的日志中找到检查点文件以及结果如下所示。
```
# 分布式训练结果8P
epoch: 1 step: 1 , loss is 76.25, average time per step is 0.335177839748392712
epoch: 1 step: 2 , loss is 73.46875, average time per step is 0.36798572540283203
epoch: 1 step: 3 , loss is 69.46875, average time per step is 0.3429678678512573
epoch: 1 step: 4 , loss is 64.3125, average time per step is 0.33512671788533527
epoch: 1 step: 5 , loss is 58.375, average time per step is 0.33149147033691406
epoch: 1 step: 6 , loss is 52.7265625, average time per step is 0.3292975425720215
...
epoch: 1 step: 8689 , loss is 9.706798802612482, average time per step is 0.3184656601312549
epoch: 1 step: 8690 , loss is 9.70612545289855, average time per step is 0.3184725407765116
epoch: 1 step: 8691 , loss is 9.70695776049204, average time per step is 0.31847309686135555
epoch: 1 step: 8692 , loss is 9.707279624277456, average time per step is 0.31847339290613375
epoch: 1 step: 8693 , loss is 9.70763437950938, average time per step is 0.3184720295013031
epoch: 1 step: 8694 , loss is 9.707695425072046, average time per step is 0.31847410284595573
epoch: 1 step: 8695 , loss is 9.708408273381295, average time per step is 0.31847338271072345
epoch: 1 step: 8696 , loss is 9.708703753591953, average time per step is 0.3184726025560777
epoch: 1 step: 8697 , loss is 9.709536406025824, average time per step is 0.31847212061114694
epoch: 1 step: 8698 , loss is 9.708542263610315, average time per step is 0.3184715309307257
```
## 评估过程
### 评估
- 评估:
```
bash scripts/run_eval_ascend.sh $TRAINED_CKPT
```
在IIIT数据集上评估模型并打印样本结果和总准确率。
# 模型描述
## 性能
### 训练性能
| 参数 | Faster R-CNN |
| -------------------------- | ----------------------------------------------------------- |
| 模型版本 | V1 |
| 资源 | Ascend 910CPU 2.60GHz192核内存755G |
| 上传日期 | 2020-09-28 |
| MindSpore版本 | 1.0.0 |
| 数据集 | MJSynth、SynthText |
| 训练参数 | epoch=3, batch_size=192 |
| 优化器 | RMSProp |
| 损失函数 | CTCLoss |
| 速度 | 1卡300毫秒/步8卡310毫秒/步 |
| 总时间 | 1卡18小时8卡2.3小时 |
| 参数(M) | 177 |
| 脚本 | https://gitee.com/mindspore/mindspore/tree/master/model_zoo/office/cv/cnnctc |
### 评估性能
| 参数 | Faster R-CNN |
| ------------------- | --------------------------- |
| 模型版本 | V1 |
| 资源 | Ascend 910 |
| 上传日期 | 2020-09-28 |
| MindSpore版本 | 1.0.0 |
| 数据集 | IIIT5K |
| batch_size | 192 |
| 输出 |准确率 |
| 准确率 | 85% |
| 推理模型 | 675M.ckpt文件 |
## 用法
### 推理
如果您需要在GPU、Ascend 910、Ascend 310等多个硬件平台上使用训练好的模型进行推理请参考此[链接](https://www.mindspore.cn/tutory/zh-CN/master/advanced_use/network_migration.html)。以下为简单示例:
- Ascend处理器环境运行
```
# 设置上下文
context.set_context(mode=context.GRAPH_HOME, device_target=cfg.device_target)
context.set_context(device_id=cfg.device_id)
# 加载未知数据集进行推理
dataset = dataset.create_dataset(cfg.data_path, 1, False)
# 定义模型
net = CNNCTC(cfg.NUM_CLASS, cfg.HIDDEN_SIZE, cfg.FINAL_FEATURE_WIDTH)
opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01,
cfg.momentum, weight_decay=cfg.weight_decay)
loss = P.CTCLoss(preprocess_collapse_repeated=False,
ctc_merge_repeated=True,
ignore_longer_outputs_than_inputs=False)
model = Model(net, loss_fn=loss, optimizer=opt, metrics={'acc'})
# 加载预训练模型
param_dict = load_checkpoint(cfg.checkpoint_path)
load_param_into_net(net, param_dict)
net.set_train(False)
# Make predictions on the unseen dataset
acc = model.eval(dataset)
print("accuracy: ", acc)
```
### 在预训练模型上继续训练
- Ascend处理器环境运行
```
# 加载数据集
dataset = create_dataset(cfg.data_path, 1)
batch_num = dataset.get_dataset_size()
# 定义模型
net = CNNCTC(cfg.NUM_CLASS, cfg.HIDDEN_SIZE, cfg.FINAL_FEATURE_WIDTH)
# 如果pre_trained为True则继续训练
if cfg.pre_trained:
param_dict = load_checkpoint(cfg.checkpoint_path)
load_param_into_net(net, param_dict)
lr = lr_steps(0, lr_max=cfg.lr_init, total_epochs=cfg.epoch_size,
steps_per_epoch=batch_num)
opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()),
Tensor(lr), cfg.momentum, weight_decay=cfg.weight_decay)
loss = P.CTCLoss(preprocess_collapse_repeated=False,
ctc_merge_repeated=True,
ignore_longer_outputs_than_inputs=False)
model = Model(net, loss_fn=loss, optimizer=opt, metrics={'acc'},
amp_level="O2", keep_batchnorm_fp32=False, loss_scale_manager=None)
# 设置回调
config_ck = CheckpointConfig(save_checkpoint_steps=batch_num * 5,
keep_checkpoint_max=cfg.keep_checkpoint_max)
time_cb = TimeMonitor(data_size=batch_num)
ckpoint_cb = ModelCheckpoint(prefix="train_googlenet_cifar10", directory="./",
config=config_ck)
loss_cb = LossMonitor()
# 开始训练
model.train(cfg.epoch_size, dataset, callbacks=[time_cb, ckpoint_cb, loss_cb])
print("train success")
```
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

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
- 训练集18G118,000个图像
- 验证集1G5000个图像
- 标注集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 910CPU 2.60GHz192核内存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.5057.6% |
| 推理模型 | 250M.ckpt文件 |
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

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 CPU2.60GHz192核内存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)。

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算子为例如果输入数据类型为FP32MindSpore后台会自动降低精度来处理数据。用户可打开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 910CPU2.60GHz192核内存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 |
| 批次大小 | 1308P |
| 输出 | 概率 |
| 准确率 | 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)。

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: 20loss is 0.80383
device_0/log:epcoh 2, step: 40loss is 0.77951
...
device_1/log:epoch 1, step: 20loss is 0.78026
device_1/log:epcoh 2, step: 40loss 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.60GHz192内核内存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)
```

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算子为例如果输入数据类型为FP32MindSpore后台会自动降低精度来处理数据。用户可打开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脚本的使用方法如下
- 昇腾Ascendsh 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 CPU2.60GHz192核内存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 | 1308卡 |
| 输出 | 概率 |
| 准确率 | 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)。