!8864 add network's chinese readme

From: @linqingke Reviewed-by: @oacjiewen,@yingjy Signed-off-by: @yingjy
5 years ago · 7aac8c0b89
--- a/model_zoo/official/cv/cnnctc/README_CN.md
+++ b/model_zoo/official/cv/cnnctc/README_CN.md
@@ -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数据集为MJ，SynthText数据集为ST，IIIT数据集为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算子为例，如果输入数据类型为FP32，MindSpore后台会自动降低精度来处理数据。用户可打开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 910；CPU 2.60GHz，192核；内存：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)。
--- a/model_zoo/official/cv/faster_rcnn/README_CN.md
+++ b/model_zoo/official/cv/faster_rcnn/README_CN.md
@@ -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)。
--- a/model_zoo/official/cv/lenet_quant/Readme_CN.md
+++ b/model_zoo/official/cv/lenet_quant/Readme_CN.md
@@ -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)。

--- a/model_zoo/official/cv/mobilenetv2_quant/README_CN.md
+++ b/model_zoo/official/cv/mobilenetv2_quant/README_CN.md
@@ -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)。
--- a/model_zoo/official/cv/psenet/README_CN.md
+++ b/model_zoo/official/cv/psenet/README_CN.md
@@ -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)
 ```

--- a/model_zoo/official/cv/resnet50_quant/README_CN.md
+++ b/model_zoo/official/cv/resnet50_quant/README_CN.md
@@ -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)。