p47068915
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add ssd&yolov3 CN README

This commit is contained in:
chengxianbin 2021-03-06 14:14:22 +08:00
parent a726ebd087
commit 9a61763629
4 changed files with 1256 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

356
model_zoo/official/cv/ssd/README_CN.md Normal file
View File

@ -0,0 +1,356 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [SSD说明](#ssd说明)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [Ascend上训练](#ascend上训练)
- [GPU训练](#gpu训练)
- [评估过程](#评估过程)
- [Ascend处理器环境评估](#ascend处理器环境评估)
- [GPU处理器环境评估](#gpu处理器环境评估)
- [模型描述](#模型描述)
- [性能](#性能)
- [评估性能](#评估性能)
- [推理性能](#推理性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# SSD说明
SSD将边界框的输出空间离散成一组默认框，每个特征映射位置具有不同的纵横比和尺度。在预测时，网络对每个默认框中存在的对象类别进行评分，并对框进行调整以更好地匹配对象形状。此外，网络将多个不同分辨率的特征映射的预测组合在一起，自然处理各种大小的对象。
[论文](https://arxiv.org/abs/1512.02325)： Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg.European Conference on Computer Vision (ECCV), 2016 (In press).
# 模型架构
SSD方法基于前向卷积网络，该网络产生固定大小的边界框集合，并针对这些框内存在的对象类实例进行评分，然后通过非极大值抑制步骤进行最终检测。早期的网络层基于高质量图像分类的标准体系结构，被称为基础网络。后来通过向网络添加辅助结构进行检测。
# 数据集
使用的数据集： [COCO2017](<http://images.cocodataset.org/>)
- 数据集大小：19 GB
- 训练集：18 GB，118000张图像
- 验证集：1 GB，5000张图像
- 标注：241 MB，实例，字幕，person_keypoints等
- 数据格式：图像和json文件
- 注意：数据在dataset.py中处理
# 环境要求
- 安装[MindSpore](https://www.mindspore.cn/install)。
- 下载数据集COCO2017。
- 本示例默认使用COCO2017作为训练数据集，您也可以使用自己的数据集。
1. 如果使用coco数据集。**执行脚本时选择数据集coco。**
安装Cython和pycocotool，也可以安装mmcv进行数据处理。
```python
pip install Cython
pip install pycocotools
```
并在`config.py`中更改COCO_ROOT和其他您需要的设置。目录结构如下：
```text
.
└─cocodataset
├─annotations
├─instance_train2017.json
└─instance_val2017.json
├─val2017
└─train2017
```
2. 如果使用自己的数据集。**执行脚本时选择数据集为other。**
将数据集信息整理成TXT文件，每行如下：
```text
train2017/0000001.jpg 0,259,401,459,7 35,28,324,201,2 0,30,59,80,2
```
每行是按空间分割的图像标注，第一列是图像的相对路径，其余为[xmin,ymin,xmax,ymax,class]格式的框和类信息。我们从`IMAGE_DIR`（数据集目录）和`ANNO_PATH`（TXT文件路径）的相对路径连接起来的图像路径中读取图像。在`config.py`中设置`IMAGE_DIR`和`ANNO_PATH`。
# 快速入门
通过官方网站安装MindSpore后，您可以按照如下步骤进行训练和评估：
- Ascend处理器环境运行
```shell script
# Ascend分布式训练
sh run_distribute_train.sh [DEVICE_NUM] [EPOCH_SIZE] [LR] [DATASET] [RANK_TABLE_FILE]
```
```shell script
# Ascend处理器环境运行eval
sh run_eval.sh [DATASET] [CHECKPOINT_PATH] [DEVICE_ID]
```
- GPU处理器环境运行
```shell script
# GPU分布式训练
sh run_distribute_train_gpu.sh [DEVICE_NUM] [EPOCH_SIZE] [LR] [DATASET]
```
```shell script
# GPU处理器环境运行eval
sh run_eval_gpu.sh [DATASET] [CHECKPOINT_PATH] [DEVICE_ID]
```
# 脚本说明
## 脚本及样例代码
```text
.
└─ cv
└─ ssd
├─ README.md ## SSD相关说明
├─ scripts
├─ run_distribute_train.sh ## Ascend分布式shell脚本
├─ run_distribute_train_gpu.sh ## GPU分布式shell脚本
├─ run_eval.sh ## Ascend评估shell脚本
└─ run_eval_gpu.sh ## GPU评估shell脚本
├─ src
├─ __init__.py ## 初始化文件
├─ box_util.py ## bbox工具
├─ coco_eval.py ## coco指标工具
├─ config.py ## 总配置
├─ dataset.py ## 创建并处理数据集
├─ init_params.py ## 参数工具
├─ lr_schedule.py ## 学习率生成器
└─ ssd.py ## SSD架构
├─ eval.py ## 评估脚本
├─ train.py ## 训练脚本
└─ mindspore_hub_conf.py ## MindSpore Hub接口
```
## 脚本参数
```text
train.py和config.py中主要参数如下：
"device_num": 1 # 使用设备数量
"lr": 0.05 # 学习率初始值
"dataset": coco # 数据集名称
"epoch_size": 500 # 轮次大小
"batch_size": 32 # 输入张量的批次大小
"pre_trained": None # 预训练检查点文件路径
"pre_trained_epoch_size": 0 # 预训练轮次大小
"save_checkpoint_epochs": 10 # 两个检查点之间的轮次间隔。默认情况下，每10个轮次都会保存检查点。
"loss_scale": 1024 # 损失放大
"class_num": 81 # 数据集类数
"image_shape": [300, 300] # 作为模型输入的图像高和宽
"mindrecord_dir": "/data/MindRecord_COCO" # MindRecord路径
"coco_root": "/data/coco2017" # COCO2017数据集路径
"voc_root": "" # VOC原始数据集路径
"image_dir": "" # 其他数据集图片路径，如果使用coco或voc，此参数无效。
"anno_path": "" # 其他数据集标注路径，如果使用coco或voc，此参数无效。
```
## 训练过程
运行`train.py`训练模型。如果`mindrecord_dir`为空，则会通过`coco_root`（coco数据集）或`image_dir`和`anno_path`（自己的数据集）生成[MindRecord](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/convert_dataset.html)文件。**注意，如果mindrecord_dir不为空，将使用mindrecord_dir代替原始图像。**
### Ascend上训练
- 分布式
```shell script
sh run_distribute_train.sh [DEVICE_NUM] [EPOCH_SIZE] [LR] [DATASET] [RANK_TABLE_FILE] [PRE_TRAINED](optional) [PRE_TRAINED_EPOCH_SIZE](optional)
```
此脚本需要五或七个参数。
- `DEVICE_NUM`：分布式训练的设备数。
- `EPOCH_NUM`：分布式训练的轮次数。
- `LR`：分布式训练的学习率初始值。
- `DATASET`：分布式训练的数据集模式。
- `RANK_TABLE_FILE`：[rank_table.json](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools)的路径。最好使用绝对路径。
- `PRE_TRAINED`：预训练检查点文件的路径。最好使用绝对路径。
- `PRE_TRAINED_EPOCH_SIZE`：预训练的轮次数。
训练结果保存在当前路径中，文件夹名称以"LOG"开头。 您可在此文件夹中找到检查点文件以及结果，如下所示。
```text
epoch: 1 step: 458, loss is 3.1681802
epoch time: 228752.4654865265, per step time: 499.4595316299705
epoch: 2 step: 458, loss is 2.8847265
epoch time: 38912.93382644653, per step time: 84.96273761232868
epoch: 3 step: 458, loss is 2.8398118
epoch time: 38769.184827804565, per step time: 84.64887516987896
...
epoch: 498 step: 458, loss is 0.70908034
epoch time: 38771.079778671265, per step time: 84.65301261718616
epoch: 499 step: 458, loss is 0.7974688
epoch time: 38787.413120269775, per step time: 84.68867493508685
epoch: 500 step: 458, loss is 0.5548882
epoch time: 39064.8467540741, per step time: 85.29442522723602
```
### GPU训练
- 分布式
```shell script
sh run_distribute_train_gpu.sh [DEVICE_NUM] [EPOCH_SIZE] [LR] [DATASET] [PRE_TRAINED](optional) [PRE_TRAINED_EPOCH_SIZE](optional)
```
此脚本需要五或七个参数。
- `DEVICE_NUM`：分布式训练的设备数。
- `EPOCH_NUM`：分布式训练的轮次数。
- `LR`：分布式训练的学习率初始值。
- `DATASET`：分布式训练的数据集模式。
- `PRE_TRAINED`：预训练检查点文件的路径。最好使用绝对路径。
- `PRE_TRAINED_EPOCH_SIZE`：预训练的轮次数。
训练结果保存在当前路径中，文件夹名称以"LOG"开头。 您可在此文件夹中找到检查点文件以及结果，如下所示。
```text
epoch: 1 step: 1, loss is 420.11783
epoch: 1 step: 2, loss is 434.11032
epoch: 1 step: 3, loss is 476.802
...
epoch: 1 step: 458, loss is 3.1283689
epoch time: 150753.701, per step time: 329.157
...
```
## 评估过程
### Ascend处理器环境评估
```shell script
sh run_eval.sh [DATASET] [CHECKPOINT_PATH] [DEVICE_ID]
```
此脚本需要两个参数。
- `DATASET`：评估数据集的模式。
- `CHECKPOINT_PATH`：检查点文件的绝对路径。
- `DEVICE_ID`: 评估的设备ID。
> 在训练过程中可以生成检查点。
推理结果保存在示例路径中，文件夹名称以“eval”开头。您可以在日志中找到类似以下的结果。
```text
Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.238
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.400
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.240
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.039
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.198
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.438
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.250
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.389
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.424
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.122
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.434
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.697
========================================
mAP: 0.23808886505483504
```
### GPU处理器环境评估
```shell script
sh run_eval_gpu.sh [DATASET] [CHECKPOINT_PATH] [DEVICE_ID]
```
此脚本需要两个参数。
- `DATASET`：评估数据集的模式。
- `CHECKPOINT_PATH`：检查点文件的绝对路径。
- `DEVICE_ID`: 评估的设备ID。
> 在训练过程中可以生成检查点。
推理结果保存在示例路径中，文件夹名称以“eval”开头。您可以在日志中找到类似以下的结果。
```text
Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.224
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.375
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.228
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.034
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.189
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.407
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.243
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.382
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.417
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.120
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.425
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.686
========================================
mAP: 0.2244936111705981
```
# 模型描述
## 性能
### 评估性能
| 参数 | Ascend | GPU |
| -------------------------- | -------------------------------------------------------------| -------------------------------------------------------------|
| 模型版本 | SSD V1 | SSD V1 |
| 资源 | Ascend 910；CPU： 2.60GHz，192核；内存：755 GB | NV SMX2 V100-16G |
| 上传日期 | 2020-06-01 | 2020-09-24 |
| MindSpore版本 | 0.3.0-alpha | 1.0.0 |
| 数据集 | COCO2017 | COCO2017 |
| 训练参数 | epoch = 500, batch_size = 32 | epoch = 800, batch_size = 32 |
| 优化器 | Momentum | Momentum |
| 损失函数 | Sigmoid交叉熵，SmoothL1Loss | Sigmoid交叉熵，SmoothL1Loss |
| 速度 | 8卡：90毫秒/步 | 8卡：121毫秒/步 |
| 总时长 | 8卡：4.81小时 | 8卡：12.31小时 |
| 参数(M) | 34 | 34 |
|脚本 | https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/ssd | https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/ssd |
### 推理性能
| 参数 | Ascend | GPU |
| ------------------- | ----------------------------| ----------------------------|
| 模型版本 | SSD V1 | SSD V1 |
| 资源 | Ascend 910 | GPU |
| 上传日期 | 2020-06-01 | 2020-09-24 |
| MindSpore版本 | 0.3.0-alpha | 1.0.0 |
| 数据集 | COCO2017 | COCO2017 |
| batch_size | 1 | 1 |
| 输出 | mAP | mAP |
| 准确率 | IoU=0.50: 23.8% | IoU=0.50: 22.4% |
| 推理模型 | 34M（.ckpt文件） | 34M（.ckpt文件） |
# 随机情况说明
dataset.py中设置了“create_dataset”函数内的种子，同时还使用了train.py中的随机种子。
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

349
model_zoo/official/cv/yolov3_darknet53/README_CN.md Normal file
View File

@ -0,0 +1,349 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [YOLOv3-DarkNet53描述](#yolov3-darknet53描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [训练](#训练)
- [分布式训练](#分布式训练)
- [评估过程](#评估过程)
- [评估](#评估)
- [模型描述](#模型描述)
- [性能](#性能)
- [评估性能](#评估性能)
- [推理性能](#推理性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# YOLOv3-DarkNet53描述
You only look once（YOLO）是最先进的实时物体检测系统。YOLOv3非常快速和准确。
先前的检测系统重新利用分类器或定位器来执行检测，将模型应用于多个位置和尺度的图像。图像的高分区域被认为是检测。
YOLOv3使用了完全不同的方法。该方法将单个神经网络应用于全图像，将图像划分为区域，并预测每个区域的边界框和概率。这些边界框由预测概率加权。
YOLOv3使用了一些技巧来改进训练，提高性能，包括多尺度预测、更好的主干分类器等等，详情见论文。
[论文](https://pjreddie.com/media/files/papers/YOLOv3.pdf): YOLOv3: An Incremental Improvement.Joseph Redmon, Ali Farhadi,
University of Washington
# 模型架构
YOLOv3使用DarkNet53执行特征提取，这是YOLOv2中的Darknet-19和残差网络的一种混合方法。DarkNet53使用连续的3×3和1×1卷积层，并且有一些快捷连接，而且DarkNet53明显更大，它有53层卷积层。
# 数据集
使用的数据集：[COCO 2014](https://cocodataset.org/#download)
- 数据集大小：19G，123287张图片，80个物体类别
- 训练集：13G，82783张图像
- 验证集：6GM，40504张图像
- 标注：241M，训练/验证标注
- 数据格式：zip文件
- 注：数据将在yolo_dataset.py中处理，并在使用前解压文件。
# 环境要求
- 硬件（Ascend/GPU）
- 使用Ascend或GPU处理器来搭建硬件环境。如需试用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/zh-CN/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/zh-CN/master/index.html)
# 快速入门
通过官方网站安装MindSpore后，您可以按照如下步骤进行训练和评估：如果在GPU上运行，请在python命令中添加`--device_target=GPU`，或者使用“_gpu”shell脚本（“xxx_gpu.sh”）。
```python
# 下面的脚本中的darknet53_backbone.ckpt是从darknet53训练得到的。
# pretrained_backbone可以使用src/convert_weight.py，将darknet53.conv.74转换为MindSpore checkpoint。可通过`https://pjreddie.com/media/files/darknet53.conv.74`获取darknet53.conv.74。
# training_shape参数定义网络图像形状，默认为""。
# 意思是使用10种形状作为输入形状，或者可以设置某种形状。
# 通过python命令执行训练示例(1卡)。
python train.py \
--data_dir=./dataset/coco2014 \
--pretrained_backbone=darknet53_backbone.ckpt \
--is_distributed=0 \
--lr=0.1 \
--T_max=320 \
--max_epoch=320 \
--warmup_epochs=4 \
--training_shape=416 \
--lr_scheduler=cosine_annealing > log.txt 2>&1 &
```
```shell script
# shell脚本单机训练示例(1卡)
sh run_standalone_train.sh dataset/coco2014 darknet53_backbone.ckpt
```
```shell script
# 对于Ascend设备，使用shell脚本分布式训练示例(8卡)
sh run_distribute_train.sh dataset/coco2014 darknet53_backbone.ckpt rank_table_8p.json
```
```shell script
# 对于GPU设备，使用shell脚本分布式训练示例(8卡)
sh run_distribute_train_gpu.sh dataset/coco2014 darknet53_backbone.ckpt
```
```python
# 使用python命令评估
python eval.py \
--data_dir=./dataset/coco2014 \
--pretrained=yolov3.ckpt \
--testing_shape=416 > log.txt 2>&1 &
```
```shell script
# 通过shell脚本运行评估
sh run_eval.sh dataset/coco2014/ checkpoint/0-319_102400.ckpt
```
# 脚本说明
## 脚本及样例代码
```text
.
└─yolov3_darknet53
├─README.md
├─mindspore_hub_conf.md # Mindspore Hub配置
├─scripts
├─run_standalone_train.sh # 在Ascend中启动单机训练(1卡)
├─run_distribute_train.sh # 在Ascend中启动分布式训练(8卡)
└─run_eval.sh # 在Ascend中启动评估
├─run_standalone_train_gpu.sh # 在GPU中启动单机训练(1卡)
├─run_distribute_train_gpu.sh # 在GPU中启动分布式训练(8卡)
└─run_eval_gpu.sh # 在GPU中启动评估
├─src
├─__init__.py # python初始化文件
├─config.py # 参数配置
├─darknet.py # 网络骨干
├─distributed_sampler.py # 数据集迭代器
├─initializer.py #参数初始化器
├─logger.py # 日志函数
├─loss.py # 损失函数
├─lr_scheduler.py # 生成学习率
├─transforms.py # 预处理数据
├─util.py # 工具函数
├─yolo.py # yolov3网络
├─yolo_dataset.py # 为YOLOV3创建数据集
├─eval.py # 评估网络
└─train.py # 训练网络
```
## 脚本参数
```text
train.py中主要参数如下：
可选参数：
-h, --help 显示此帮助消息并退出。
--Device_target 实现代码的设备：“Ascend" | "GPU"。默认设置："Ascend"。
--data_dir DATA_DIR 训练数据集目录。
--per_batch_size PER_BATCH_SIZE
训练批次大小。默认设置：32。
--pretrained_backbone PRETRAINED_BACKBONE
DarkNet53的ckpt文件。默认设置：""。
--resume_yolov3 RESUME_YOLOV3
YOLOv3的ckpt文件，用于微调。默认设置：""。
--lr_scheduler LR_SCHEDULER
学习率调度器，选项：exponential，cosine_annealing。默认设置：exponential。
--lr LR 学习率。默认设置：0.001。
--lr_epochs LR_EPOCHS
lr changing轮次，用“,”分隔。默认设置：220,250。
--lr_gamma LR_GAMMA 降低lr的exponential lr_scheduler因子。默认设置：0.1。
--eta_min ETA_MIN cosine_annealing调度器中的eta_min。默认设置：0。
--T_max T_MAX cosine_annealing调度器中的T-max。默认设置：320。
--max_epoch MAX_EPOCH
训练模型的最大轮次数。默认设置：320。
--warmup_epochs WARMUP_EPOCHS
热身轮次。默认设置：0。
--weight_decay WEIGHT_DECAY
权重衰减因子。默认设置：0.0005。
--momentum MOMENTUM 动量。默认设置：0.9。
--loss_scale LOSS_SCALE
静态损失等级。默认设置：1024。
--label_smooth LABEL_SMOOTH
CE中是否使用标签平滑。默认设置：0。
--label_smooth_factor LABEL_SMOOTH_FACTOR
独热平滑强度。默认设置：0.1。
--log_interval LOG_INTERVAL
日志记录迭代间隔。默认设置：100。
--ckpt_path CKPT_PATH
检查点保存位置。默认设置：outputs/。
--ckpt_interval CKPT_INTERVAL
保存检查点间隔。默认设置：None。
--is_save_on_master IS_SAVE_ON_MASTER
在主进程序号或所有进程序号上保存ckpt。1为主进程序号， 0为所有进程序号。默认设置：1。
--is_distributed IS_DISTRIBUTED
是否分布训练，1表示是，0表示否，默认设置：1。
--rank RANK 分布式本地排名。默认设置：0。
--group_size GROUP_SIZE
设备进程总数。默认设置：1。
--need_profiler NEED_PROFILER
是否使用调优器。0表示否，1表示是。默认设置：0。
--training_shape TRAINING_SHAPE
固定训练形状。默认设置：""。
--resize_rate RESIZE_RATE
多尺度训练的调整率。默认设置：None。
```
## 训练过程
### 训练
```python
python train.py \
--data_dir=./dataset/coco2014 \
--pretrained_backbone=darknet53_backbone.ckpt \
--is_distributed=0 \
--lr=0.1 \
--T_max=320 \
--max_epoch=320 \
--warmup_epochs=4 \
--training_shape=416 \
--lr_scheduler=cosine_annealing > log.txt 2>&1 &
```
上述python命令将在后台运行，您可以通过`log.txt`文件查看结果。如果在GPU上运行，请在python命令中添加`--device_target=GPU`。
训练结束后，您可在默认输出文件夹下找到检查点文件。损失值的实现如下：
```text
# grep "loss:" train/log.txt
2020-08-20 14:14:43,640:INFO:epoch[0], iter[0], loss:7809.262695, 0.15 imgs/sec, lr:9.746589057613164e-06
2020-08-20 14:15:05,142:INFO:epoch[0], iter[100], loss:2778.349033, 133.92 imgs/sec, lr:0.0009844054002314806
2020-08-20 14:15:31,796:INFO:epoch[0], iter[200], loss:535.517361, 130.54 imgs/sec, lr:0.0019590642768889666
...
```
模型检查点将会储存在输出目录。
### 分布式训练
对于Ascend设备，使用shell脚本分布式训练示例(8卡)
```shell script
sh run_distribute_train.sh dataset/coco2014 darknet53_backbone.ckpt rank_table_8p.json
```
对于GPU设备，使用shell脚本分布式训练示例(8卡)
```shell script
sh run_distribute_train_gpu.sh dataset/coco2014 darknet53_backbone.ckpt
```
上述shell脚本将在后台运行分布训练。您可以通过`train_parallel[X]/log.txt`文件查看结果。损失值的实现如下：
```text
# 分布式训练示例(8卡)
epoch[0], iter[0], loss:14623.384766, 1.23 imgs/sec, lr:7.812499825377017e-05
epoch[0], iter[100], loss:1486.253051, 15.01 imgs/sec, lr:0.007890624925494194
epoch[0], iter[200], loss:288.579535, 490.41 imgs/sec, lr:0.015703124925494194
epoch[0], iter[300], loss:153.136754, 531.99 imgs/sec, lr:0.023515624925494194
epoch[1], iter[400], loss:106.429322, 405.14 imgs/sec, lr:0.03132812678813934
...
epoch[318], iter[102000], loss:34.135306, 431.06 imgs/sec, lr:9.63797629083274e-06
epoch[319], iter[102100], loss:35.652469, 449.52 imgs/sec, lr:2.409552052995423e-06
epoch[319], iter[102200], loss:34.652273, 384.02 imgs/sec, lr:2.409552052995423e-06
epoch[319], iter[102300], loss:35.430038, 423.49 imgs/sec, lr:2.409552052995423e-06
...
```
## 评估过程
### 评估
运行以下命令。如果在GPU上运行，请在python命令中添加`--device_target=GPU`，或者使用“_gpu”shell脚本（“xxx_gpu.sh”）。
```python
python eval.py \
--data_dir=./dataset/coco2014 \
--pretrained=yolov3.ckpt \
--testing_shape=416 > log.txt 2>&1 &
```
或者
```shell script
sh run_eval.sh dataset/coco2014/ checkpoint/0-319_102400.ckpt
```
上述python命令将在后台运行，您可以通过log.txt文件查看结果。测试数据集的mAP如下：
```text
# log.txt
=============coco eval reulst=========
Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.311
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.528
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.322
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.127
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.323
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.428
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.259
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.398
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.423
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.224
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.442
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.551
```
# 模型描述
## 性能
### 评估性能
| 参数 | YOLO |YOLO |
| -------------------------- | ----------------------------------------------------------- |------------------------------------------------------------ |
| 模型版本 | YOLOv3 |YOLOv3 |
| 资源 | Ascend 910；CPU 2.60GHz，192核；内存：755G | NV SMX2 V100-16G；CPU 2.10GHz，96核；内存：251G |
| 上传日期 | 2020-06-31 | 2020-09-02 |
| MindSpore版本 | 0.5.0-alpha | 0.7.0 |
| 数据集 | COCO2014 | COCO2014 |
| 训练参数 | epoch=320，batch_size=32，lr=0.001，momentum=0.9 | epoch=320，batch_size=32，lr=0.001，momentum=0.9 |
| 优化器 | Momentum | Momentum |
| 损失函数 | 带logits的Sigmoid交叉熵 | 带logits的Sigmoid交叉熵 |
| 输出 | 边界框和标签 | 边界框和标签 |
| 损失 | 34 | 34 |
| 速度 | 1卡：350毫秒/步; | 1卡: 600毫秒/步; |
| 总时长 | 8卡：18.5小时 | 8卡: 18小时(shape=416) |
| 参数(M) | 62.1 | 62.1 |
| 微调检查点 | 474M (.ckpt文件) | 474M (.ckpt文件) |
| 脚本 | https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/yolov3_darknet53 | https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/yolov3_darknet53 |
### 推理性能
| 参数 | YOLO |YOLO |
| ------------------- | --------------------------- |------------------------------|
| 模型版本 | YOLOv3 | YOLOv3 |
| 资源 | Ascend 910 | NV SMX2 V100-16G |
| 上传日期 | 2020-06-31 | 2020-08-20 |
| MindSpore版本 | 0.5.0-alpha | 0.7.0 |
| 数据集 | COCO2014，40504张图像 | COCO2014，40504张图像 |
| batch_size | 1 | 1 |
| 输出 | mAP | mAP |
| 准确性 | 8卡: 31.1% | 8卡: 29.7%~30.3% (shape=416)|
| 推理模型 | 474M (.ckpt文件) | 474M (.ckpt文件) |
# 随机情况说明
在distributed_sampler.py、transforms.py、yolo_dataset.py文件中有随机种子。
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

313
model_zoo/official/cv/yolov3_darknet53_quant/README_CN.md Normal file
View File

@ -0,0 +1,313 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [YOLOv3-DarkNet53-Quant描述](#yolov3-darknet53-quant描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [Ascend上训练](#ascend上训练)
- [分布式训练](#分布式训练)
- [评估过程](#评估过程)
- [Ascend评估](#ascend评估)
- [模型描述](#模型描述)
- [性能](#性能)
- [评估性能](#评估性能)
- [推理性能](#推理性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# YOLOv3-DarkNet53-Quant描述
You only look once（YOLO）是最先进的实时物体检测系统。YOLOv3非常快速和准确。
先前的检测系统重新利用分类器或定位器来执行检测，将模型应用于多个位置和尺度的图像。图像的高分区域被认为是检测。
YOLOv3使用了完全不同的方法。该方法将单个神经网络应用于全图像，将图像划分为区域，并预测每个区域的边界框和概率。这些边界框由预测概率加权。
YOLOv3使用了一些技巧来改进训练，提高性能，包括多尺度预测、更好的主干分类器等等，详情见论文。
为了减小权重的大小，提高低位计算性能，采用了int8量化。
[论文](https://pjreddie.com/media/files/papers/YOLOv3.pdf)： YOLOv3: An Incremental Improvement.Joseph Redmon, Ali Farhadi, University of Washington
# 模型架构
YOLOv3使用DarkNet53执行特征提取，这是YOLOv2中的Darknet-19和残差网络的一种混合方法。DarkNet53使用连续的3×3和1×1卷积层，并且有一些快捷连接，而且DarkNet53明显更大，它有53层卷积层。
# 数据集
使用的数据集：[COCO 2014](https://cocodataset.org/#download)
- 数据集大小：19G，123287张图片，80个物体类别
- 训练集：13G，82783张图片
- 验证集：6GM，40504张图片
- 标注：241M，训练/验证标注
- 数据格式：zip文件
- 注：数据将在yolo_dataset.py中处理，并在使用前解压文件。
# 环境要求
- 硬件（Ascend处理器）
- 准备Ascend或GPU处理器搭建硬件环境。如需试用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/zh-CN/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/zh-CN/master/index.html)
# 快速入门
通过官方网站安装MindSpore后，您可以按照如下步骤进行训练和评估：
```python
# 下面的脚本中的yolov3_darknet53_noquin.ckpt是从yolov3-darknet53训练得到的。
# resume_yolov3参数是必需的。
# training_shape参数定义网络图像形状，默认为""。
# 意思是使用10种形状作为输入形状，或者可以设置某种形状。
# 通过python命令执行训练示例(1卡)。
python train.py \
--data_dir=./dataset/coco2014 \
--resume_yolov3=yolov3_darknet53_noquant.ckpt \
--is_distributed=0 \
--per_batch_size=16 \
--lr=0.012 \
--T_max=135 \
--max_epoch=135 \
--warmup_epochs=5 \
--lr_scheduler=cosine_annealing > log.txt 2>&1 &
```
```shell script
# shell脚本单机训练示例(1卡)
sh run_standalone_train.sh dataset/coco2014 yolov3_darknet53_noquant.ckpt
```
```shell script
# shell脚本分布式训练示例(8卡)
sh run_distribute_train.sh dataset/coco2014 yolov3_darknet53_noquant.ckpt rank_table_8p.json
```
```python
# 使用python命令评估
python eval.py \
--data_dir=./dataset/coco2014 \
--pretrained=yolov3_quent.ckpt \
--testing_shape=416 > log.txt 2>&1 &
```
```shell script
# 通过shell脚本运行评估
sh run_eval.sh dataset/coco2014/ checkpoint/yolov3_quant.ckpt 0
```
# 脚本说明
## 脚本及样例代码
```text
.
└─yolov3_darknet53_quant
├─README.md
├─mindspore_hub_conf.md # Mindspore Hub配置
├─scripts
├─run_standalone_train.sh # 在Ascend中启动单机训练(1卡)
├─run_distribute_train.sh # 在Ascend中启动分布式训练(8卡)
└─run_eval.sh # 在Ascend中启动评估
├─src
├─__init__.py # python初始化文件
├─config.py # 参数配置
├─darknet.py # 网络骨干
├─distributed_sampler.py # 数据集迭代器
├─initializer.py # 参数初始化器
├─logger.py # 日志函数
├─loss.py # 损失函数
├─lr_scheduler.py # 生成学习率
├─transforms.py # 预处理数据
├─util.py # 工具函数
├─yolo.py # YOLOV3网络
├─yolo_dataset.py # 为YOLOV3创建数据集
├─eval.py # 评估网络
└─train.py # 训练网络
```
## 脚本参数
```text
train.py中主要参数如下：
可选参数：
-h, --help 显示此帮助消息并退出。
--data_dir DATA_DIR 训练数据集目录。默认设置：""。
--per_batch_size PER_BATCH_SIZE
每个设备的批次大小。默认设置：16。
--resume_yolov3 RESUME_YOLOV3
YOLOv3的ckpt文件，用于微调。默认设置：""。
--lr_scheduler LR_SCHEDULER
学习率调度器，选项：exponential，cosine_annealing。默认设置：exponential。
--lr LR 学习率。默认设置：0.012。
--lr_epochs LR_EPOCHS
lr changing轮次，用“,”分隔。默认设置：92, 105。
--lr_gamma LR_GAMMA 降低lr的exponential lr_scheduler因子。默认设置：0.1。
--eta_min ETA_MIN cosine_annealing调度器中的eta_min。默认设置：0。
--T_max T_MAX cosine_annealing调度器中的T-max。默认设置：135。
--max_epoch MAX_EPOCH
训练模型的最大轮次数。默认设置：135。
--warmup_epochs WARMUP_EPOCHS
热身轮次。默认设置：0。
--weight_decay WEIGHT_DECAY
权重衰减因子。默认设置：0.0005。
--momentum MOMENTUM 动量。默认设置：0.9。
--loss_scale LOSS_SCALE
静态损失等级。默认设置：1024。
--label_smooth LABEL_SMOOTH
CE中是否使用标签平滑。默认设置：0。
--label_smooth_factor LABEL_SMOOTH_FACTOR
独热平滑强度。默认设置：0.1。
--log_interval LOG_INTERVAL
日志记录迭代间隙。默认设置：100。
--ckpt_path CKPT_PATH
检查点保存位置。默认设置："outputs/"。
--ckpt_interval CKPT_INTERVAL
保存检查点间隔。默认设置：None。
--is_save_on_master IS_SAVE_ON_MASTER
在主进程序号或所有进程序号上保存ckpt。1为主进程序号， 0为所有进程序号。默认设置：1。
--is_distributed IS_DISTRIBUTED
是否分布训练，1表示是，0表示否。 默认设置：0。
--rank RANK 分布式本地进程序号。默认设置：0。
--group_size GROUP_SIZE
设备进程总数。默认设置：1。
--need_profiler NEED_PROFILER
是否使用调优器。1表示是，0表示否。默认设置：0。
--training_shape TRAINING_SHAPE
固定训练形状。默认设置：""。
--resize_rate RESIZE_RATE
多尺度训练的调整率。默认设置：None。
```
## 训练过程
### Ascend上训练
### 分布式训练
```shell script
sh run_distribute_train.sh dataset/coco2014 yolov3_darknet53_noquant.ckpt rank_table_8p.json
```
上述shell脚本将在后台运行分布训练。您可以通过`train_parallel[X]/log.txt`文件查看结果。损失值的实现如下：
```text
# 分布式训练示例(8卡)
epoch[0], iter[0], loss:483.341675, 0.31 imgs/sec, lr:0.0
epoch[0], iter[100], loss:55.690952, 3.46 imgs/sec, lr:0.0
epoch[0], iter[200], loss:54.045728, 126.54 imgs/sec, lr:0.0
epoch[0], iter[300], loss:48.771608, 133.04 imgs/sec, lr:0.0
epoch[0], iter[400], loss:48.486769, 139.69 imgs/sec, lr:0.0
epoch[0], iter[500], loss:48.649275, 143.29 imgs/sec, lr:0.0
epoch[0], iter[600], loss:44.731309, 144.03 imgs/sec, lr:0.0
epoch[1], iter[700], loss:43.037023, 136.08 imgs/sec, lr:0.0
epoch[1], iter[800], loss:41.514788, 132.94 imgs/sec, lr:0.0
…
epoch[133], iter[85700], loss:33.326716, 136.14 imgs/sec, lr:6.497331924038008e-06
epoch[133], iter[85800], loss:34.968744, 136.76 imgs/sec, lr:6.497331924038008e-06
epoch[134], iter[85900], loss:35.868543, 137.08 imgs/sec, lr:1.6245529650404933e-06
epoch[134], iter[86000], loss:35.740817, 139.49 imgs/sec, lr:1.6245529650404933e-06
epoch[134], iter[86100], loss:34.600463, 141.47 imgs/sec, lr:1.6245529650404933e-06
epoch[134], iter[86200], loss:36.641916, 137.91 imgs/sec, lr:1.6245529650404933e-06
epoch[134], iter[86300], loss:32.819769, 138.17 imgs/sec, lr:1.6245529650404933e-06
epoch[134], iter[86400], loss:35.603033, 142.23 imgs/sec, lr:1.6245529650404933e-06
epoch[134], iter[86500], loss:34.303755, 145.18 imgs/sec, lr:1.6245529650404933e-06
```
## 评估过程
### Ascend评估
运行以下命令。
```python
python eval.py \
--data_dir=./dataset/coco2014 \
--pretrained=0-130_83330.ckpt \
--testing_shape=416 > log.txt 2>&1 &
```
或者
```shell script
sh run_eval.sh dataset/coco2014/ checkpoint/0-130_83330.ckpt 0
```
上述python命令将在后台运行，您可以通过log.txt文件查看结果。测试数据集的mAP如下：
```text
# log.txt
=============coco eval reulst=========
Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.310
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.531
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.322
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.130
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.326
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.425
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.260
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.402
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.429
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.232
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.450
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.558
```
# 模型描述
## 性能
### 评估性能
| 参数 | Ascend |
| -------------------------- | ---------------------------------------------------------------------------------------------- |
| 模型版本 | YOLOv3_Darknet53_Quant V1 |
| 资源 | Ascend 910; CPU 2.60GHz，192核; 内存：755G |
| 上传日期 | 2020-06-31 |
| MindSpore版本 | 0.6.0-alpha |
| 数据集 | COCO2014 |
| 训练参数 | epoch=135，batch_size=16，lr=0.012，momentum=0.9 |
| 优化器 | Momentum |
| 损失函数 | 带logits的Sigmoid交叉熵 |
| 输出 | 边界框和标签 |
| 损失 | 34 |
| 速度 | 1卡：135毫秒/步; |
| 总时长 | 8卡：23.5小时 |
| 参数 (M) | 62.1 |
| 微调检查点 | 474M (.ckpt文件) |
| 脚本 | https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/yolov3_darknet53_quant |
### 推理性能
| 参数 | Ascend |
| ------------------- | --------------------------- |
| 模型版本 | YOLOv3_Darknet53_Quant V1 |
| 资源 | Ascend 910 |
| 上传日期 | 2020-06-31 |
| MindSpore版本 | 0.6.0-alpha |
| 数据集 | COCO2014，40,504张图片 |
| batch_size | 1 |
| 输出 | mAP |
| 准确率 | 8pcs：31.0% |
| 推理模型 | 474M (.ckpt文件) |
# 随机情况说明
在distributed_sampler.py、transforms.py、yolo_dataset.py文件中有随机种子。
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。

238
model_zoo/official/cv/yolov3_resnet18/README_CN.md Normal file
View File

@ -0,0 +1,238 @@
# 目录
<!-- TOC -->
- [目录](#目录)
- [YOLOv3_ResNet18描述](#yolov3_resnet18描述)
- [模型架构](#模型架构)
- [数据集](#数据集)
- [环境要求](#环境要求)
- [快速入门](#快速入门)
- [脚本说明](#脚本说明)
- [脚本及样例代码](#脚本及样例代码)
- [脚本参数](#脚本参数)
- [训练过程](#训练过程)
- [Ascend上训练](#ascend上训练)
- [评估过程](#评估过程)
- [Ascend评估](#ascend评估)
- [模型描述](#模型描述)
- [性能](#性能)
- [评估性能](#评估性能)
- [推理性能](#推理性能)
- [随机情况说明](#随机情况说明)
- [ModelZoo主页](#modelzoo主页)
<!-- /TOC -->
# YOLOv3_ResNet18描述
基于ResNet-18的YOLOv3网络，支持训练和评估。
[论文](https://arxiv.org/abs/1804.02767): Joseph Redmon, Ali Farhadi. arXiv preprint arXiv:1804.02767, 2018.2, 4, 7, 11.
# 模型架构
YOLOv3整体网络架构如下：
我们使用ResNet18作为YOLOv3_ResNet18的主干。ResNet18架构分为四个阶段。ResNet架构分别使用大小为7×7和3×3的内核执行初始卷积和最大池化。此后每个阶段的网络都有不同的残差模块（2, 2, 2, 2），包含两个3×3的卷积层。最后是一个平均池化层和一个全连接层。
# 数据集
使用的数据集：[COCO 2017](<http://images.cocodataset.org/>)
- 数据集大小：19 GB
- 训练集：18 GB，118000张图片
- 验证集：1GB，5000张图片
- 标注：241 MB，包含实例，字幕，person_keypoints等
- 数据格式：图片和json文件
- 标注：数据在dataset.py中处理。
- 数据集
1. 目录结构如下：
```
.
├── annotations # 标注jsons
├── train2017 # 训练数据集
└── val2017 # 推理数据集
```
2. 将数据集信息整理成TXT文件，每行如下：
```
train2017/0000001.jpg 0,259,401,459,7 35,28,324,201,2 0,30,59,80,2
```
每行是按空间分割的图像标注，第一列是图像的相对路径，其余为[xmin,ymin,xmax,ymax,class]格式的框和类信息。`dataset.py`是解析脚本，我们从`image_dir`（数据集目录）和`anno_path`（TXT文件路径）的相对路径连接起来的图像路径中读取图像。`image_dir`和`anno_path`为外部输入。
# 环境要求
- 硬件（Ascend处理器）
- 准备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/tutorial/training/zh-CN/master/index.html)
- [MindSpore Python API](https://www.mindspore.cn/doc/api_python/zh-CN/master/index.html)
# 快速入门
通过官方网站安装MindSpore后，您可以按照如下步骤进行训练和评估：
- Ascend处理器环境运行
```shell script
# 运行单机训练示例
sh run_standalone_train.sh [DEVICE_ID] [EPOCH_SIZE] [MINDRECORD_DIR] [IMAGE_DIR] [ANNO_PATH]
# 运行分布式训练示例
sh run_distribute_train.sh [DEVICE_NUM] [EPOCH_SIZE] [MINDRECORD_DIR] [IMAGE_DIR] [ANNO_PATH] [RANK_TABLE_FILE]
# 运行评估示例
sh run_eval.sh [DEVICE_ID] [CKPT_PATH] [MINDRECORD_DIR] [IMAGE_DIR] [ANNO_PATH]
```
# 脚本说明
## 脚本及样例代码
```text
└── cv
├── README.md // 所有模型相关说明
├── mindspore_hub_conf.md // Mindspore Hub配置
└── yolov3_resnet18
├── README.md // yolov3_resnet18相关说明
├── scripts
├── run_distribute_train.sh // Ascend上分布式shell脚本
├── run_standalone_train.sh // Ascend上分布式shell脚本
└── run_eval.sh // Ascend上评估的shell脚本
├── src
├── dataset.py // 创建数据集
├── yolov3.py // yolov3架构
├── config.py // 参数配置
└── utils.py // 工具函数
├── train.py // 训练脚本
└── eval.py // 评估脚本
```
## 脚本参数
```text
train.py和config.py中主要参数如下：
device_num: 使用设备编号，默认为1。
lr: 学习率，默认为0.001。
epoch_size: 轮次大小，默认为50。
batch_size: 批次大小，默认为32。
pre_trained: 预训练的检查点文件路径。
pre_trained_epoch_size: 预训练的轮次大小。
mindrecord_dir: Mindrecord目录。
image_dir: 数据集路径。
anno_path: 标注路径。
img_shape: 输入到模型的图像高度和宽度。
```
## 训练过程
### Ascend上训练
训练模型运行`train.py`，使用数据集`image_dir`、`anno_path`和`mindrecord_dir`。如果`mindrecord_dir`为空，则通过`image_dir`和`anno_path`（图像绝对路径由`image_dir`和`anno_path`中的相对路径连接）生成[MindRecord](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/convert_dataset.html)文件。**注意，如果`mindrecord_dir`不为空，将使用`mindrecord_dir`而不是`image_dir`和`anno_path`。**
- 单机模式
```shell script
sh run_standalone_train.sh 0 50 ./Mindrecord_train ./dataset ./dataset/train.txt
```
输入变量为设备编号、轮次大小、MindRecord目录路径、数据集目录路径、训练TXT文件路径。
- 分布式模式
```shell script
sh run_distribute_train.sh 8 150 /data/Mindrecord_train /data /data/train.txt /data/hccl.json
```
输入变量为设备编号、轮次大小、MindRecord目录路径、数据集目录路径、训练TXT文件路径和[hccl_tools配置文件](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools)。**最好使用绝对路径。**
每步的损失值和时间如下：
```text
epoch:145 step:156, loss is 12.202981
epoch time:25599.22742843628, per step time:164.0976117207454
epoch:146 step:156, loss is 16.91706
epoch time:23199.971675872803, per step time:148.7177671530308
epoch:147 step:156, loss is 13.04007
epoch time:23801.95164680481, per step time:152.57661312054364
epoch:148 step:156, loss is 10.431475
epoch time:23634.241580963135, per step time:151.50154859591754
epoch:149 step:156, loss is 14.665991
epoch time:24118.8325881958, per step time:154.60790120638333
epoch:150 step:156, loss is 10.779521
epoch time:25319.57221031189, per step time:162.30495006610187
```
注意结果为两类（人与脸），使用了我们自己的标注与COCO 2017，您可以更改`config.py`中的`num_classes`来训练您的数据集。我们将在COCO 2017中支持80个分类。
## 评估过程
### Ascend评估
运行`eval.py`，数据集为`image_dir`、`anno_path`(评估TXT)、`mindrecord_dir`和`ckpt_path`。`ckpt_path`是[检查点](https://www.mindspore.cn/tutorial/training/zh-CN/master/use/save_model.html)文件的路径。
```shell script
sh run_eval.sh 0 yolo.ckpt ./Mindrecord_eval ./dataset ./dataset/eval.txt
```
输入变量为设备编号、检查点路径、MindRecord目录路径、数据集目录路径、训练TXT文件路径。
您将获得每类的精度和召回值：
```text
class 0 precision is 88.18%, recall is 66.00%
class 1 precision is 85.34%, recall is 79.13%
```
注意精度和召回值是使用我们自己的标注和COCO 2017的两种分类（人与脸）的结果。
# 模型描述
## 性能
### 评估性能
| 参数 | Ascend |
| -------------------------- | ----------------------------------------------------------- |
| 模型版本 | YOLOv3_Resnet18 V1 |
| 资源 | Ascend 910 ；CPU 2.60GHz，192核；内存：755G |
| 上传日期 | 2020-06-01 |
| MindSpore版本 | 0.2.0-alpha |
| 数据集 | COCO2017 |
| 训练参数 | epoch = 150, batch_size = 32, lr = 0.001 |
| 优化器 | Adam |
| 损失函数 | Sigmoid交叉熵 |
| 输出 | 概率 |
| 速度 | 1pc：120毫秒/步; 8卡：160毫秒/步 |
| 总时长 | 1pc：150分钟; 8卡: 70分钟 |
| 参数(M) | 189 |
| 脚本 | [yolov3_resnet18脚本](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/yolov3_resnet18) | [yolov3_resnet18脚本](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/yolov3_resnet18) |
### 推理性能
| 参数 | Ascend |
| ------------------- | ----------------------------------------------- |
| 模型版本 | YOLOv3_Resnet18 V1 |
| 资源 | Ascend 910 |
| 上传日期 | 2020-06-01 |
| MindSpore版本 | 0.2.0-alpha |
| 数据集 | COCO2017 |
| batch_size | 1 |
| 输出 | 精度和召回 |
| 准确性 | class 0: 88.18%/66.00%; class 1: 85.34%/79.13% |
# 随机情况说明
在dataset.py中，我们设置了“create_dataset”函数内的种子。同时还使用了train.py中的随机种子。
# ModelZoo主页
请浏览官网[主页](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。