mirrors
/
PaddleClas
mirror of https://github.com/PaddlePaddle/PaddleClas.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

add menu and modify documentation

pull/1546/head
sibo2rr 2021-11-25 15:40:40 +08:00 committed by gaotingquan
parent 0fa1fd71e9
commit 7dbf7d66ea
61 changed files with 1093 additions and 712 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/zh_CN/advanced_tutorials/DataAugmentation.md
View File

@ -1,7 +1,7 @@
# 数据增强分类实战
---
本节将基于 ImageNet-1K 的数据集详细介绍数据增强实验，如果想快速体验此方法，可以参考 [**30分钟玩转PaddleClas（进阶版）**](../quick_start/quick_start_classification_professional.md)中基于 CIFAR100 的数据增强实验。如果想了解相关算法的内容，请参考[数据增强算法介绍](../algorithm_introduction/DataAugmentation.md)。
本节将基于 ImageNet-1K 的数据集详细介绍数据增强实验，如果想快速体验此方法，可以参考 [**30 分钟玩转 PaddleClas（进阶版）**](../quick_start/quick_start_classification_professional.md)中基于 CIFAR100 的数据增强实验。如果想了解相关算法的内容，请参考[数据增强算法介绍](../algorithm_introduction/DataAugmentation.md)。
## 目录
@ -249,7 +249,7 @@
```
<a name="1.10"></a>
### 1.10 Mixup与Cutmix同时使用
### 1.10 Mixup 与 Cutmix 同时使用
`Mixup` 与 `Cutmix`同时使用的配置如下，其中用户需要指定额外的参数 `prob`，该参数控制不同数据增强的概率，默认为 `0.5`。

6
docs/zh_CN/advanced_tutorials/code_overview.md
View File

@ -189,9 +189,9 @@ def build_optimizer(config, epochs, step_each_epoch, parameters):
```yaml
Global:
save_interval: 1 # 模型保存的epoch间隔
save_interval: 1 # 模型保存的 epoch 间隔
eval_during_train: True # 是否进行训练时评估
eval_interval: 1 # 评估的epoch间隔
eval_interval: 1 # 评估的 epoch 间隔
```
<a name="2.6"></a>
@ -246,4 +246,4 @@ Slim:
* 如果希望在服务端使用 cpp 进行部署，可以参考 [cpp inference 预测教程](../inference_deployment/cpp_deploy.md) 。
* 如果希望将分类模型部署为服务，可以参考 [hub serving 预测部署教程](../inference_deployment/paddle_hub_serving_deploy.md) 。
* 如果希望在移动端使用分类模型进行预测，可以参考 [PaddleLite 预测部署教程](../inference_deployment/paddle_lite_deploy.md) 。
* 如果希望使用 whl 包对分类模型进行预测，可以参考 [whl包预测](../inference_deployment/whl_deploy.md) 。
* 如果希望使用 whl 包对分类模型进行预测，可以参考 [whl 包预测](../inference_deployment/whl_deploy.md) 。

24
docs/zh_CN/advanced_tutorials/how_to_contribute.md
View File

@ -12,8 +12,8 @@
- [1.2.4 使用 pre-commit 勾子](#1.2.4)
- [1.2.5 修改与提交代码](#1.2.5)
- [1.2.6 保持本地仓库最新](#1.2.6)
- [1.2.7 push到远程仓库](#1.2.7)
- [1.2.8 提交Pull Request](#1.2.8)
- [1.2.7 push 到远程仓库](#1.2.7)
- [1.2.8 提交 Pull Request](#1.2.8)
- [1.2.9 签署 CLA 协议和通过单元测试](#1.2.9)
- [1.2.10 删除分支](#1.2.10)
- [1.2.11 提交代码的一些约定](#1.2.11)
@ -56,7 +56,7 @@ PaddleClas 欢迎大家向 repo 中积极贡献代码，下面给出一些贡献
* 将远程仓库 clone 到本地
```shell
# 拉取develop分支的代码
# 拉取 develop 分支的代码
git clone https://github.com/USERNAME/PaddleClas.git -b develop
cd PaddleClas
```
@ -106,10 +106,10 @@ git checkout -b new_branch
也可以基于远程或者上游的分支创建新的分支，命令如下。
```shell
# 基于用户远程仓库(origin)的develop创建new_branch分支
# 基于用户远程仓库(origin)的 develop 创建 new_branch 分支
git checkout -b new_branch origin/develop
# 基于上游远程仓库(upstream)的develop创建new_branch分支
# 如果需要从upstream创建新的分支，需要首先使用git fetch upstream获取上游代码
# 基于上游远程仓库(upstream)的 develop 创建 new_branch 分支
# 如果需要从 upstream 创建新的分支，需要首先使用 git fetch upstream 获取上游代码
git checkout -b new_branch upstream/develop
```
@ -168,19 +168,19 @@ git commit -m "your commit info"
```shell
git fetch upstream
# 如果是希望提交到其他分支，则需要从upstream的其他分支pull代码，这里是develop
# 如果是希望提交到其他分支，则需要从 upstream 的其他分支 pull 代码，这里是 develop
git pull upstream develop
```
<a name="1.2.7"></a>
#### 1.2.7 push到远程仓库
#### 1.2.7 push 到远程仓库
```shell
git push origin new_branch
```
<a name="1.2.8"></a>
#### 1.2.8 提交Pull Request
#### 1.2.8 提交 Pull Request
点击 new pull request，选择本地分支和目标分支，如下图所示。在 PR 的描述说明中，填写该 PR 所完成的功能。接下来等待 review ，如果有需要修改的地方，参照上述步骤更新 origin 中的对应分支即可。
@ -214,10 +214,10 @@ git push origin :new_branch
* 删除本地分支
```shell
# 切换到develop分支，否则无法删除当前分支
# 切换到 develop 分支，否则无法删除当前分支
git checkout develop
# 删除new_branch分支
# 删除 new_branch 分支
git branch -D new_branch
```
@ -228,7 +228,7 @@ git branch -D new_branch
1）请保证 Travis-CI 中单元测试能顺利通过。如果没过，说明提交的代码存在问题，官方维护人员一般不做评审。
2）提交 Pull Reques t前：
2）提交 Pull Request 前：
请注意 commit 的数量。

6
docs/zh_CN/advanced_tutorials/knowledge_distillation.md
View File

@ -16,7 +16,7 @@
- [4.1 使用方法](#4.1)
- [4.2 迁移学习 finetune](#4.2)
- [4.3 目标检测](#4.3)
- [5. SSLD实战](#5)
- [5. SSLD 实战](#5)
- [5.1 参数配置](#5.1)
- [5.2 启动命令](#5.2)
- [5.3 注意事项](#5.3)
@ -204,9 +204,9 @@ SSLD 的流程图如下图所示。
在这里可以看出，对于未蒸馏模型，过度调整中间层学习率反而降低最终检测模型的性能指标。基于该蒸馏模型，我们也提供了领先的服务端实用目标检测方案，详细的配置与训练代码均已开源，可以参考 [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection/tree/master/configs/rcnn_enhance)。
<a name="5"></a>
## 5. SSLD实战
## 5. SSLD 实战
本节将基于 ImageNet-1K 的数据集详细介绍 SSLD 蒸馏实验，如果想快速体验此方法，可以参考 [**30分钟玩转 PaddleClas（进阶版）**](../quick_start/quick_start_classification_professional.md) 中基于 CIFAR100 的 SSLD 蒸馏实验。
本节将基于 ImageNet-1K 的数据集详细介绍 SSLD 蒸馏实验，如果想快速体验此方法，可以参考 [**30 分钟玩转 PaddleClas（进阶版）**](../quick_start/quick_start_classification_professional.md) 中基于 CIFAR100 的 SSLD 蒸馏实验。
<a name="5.1"></a>
### 5.1 参数配置

4
docs/zh_CN/advanced_tutorials/model_prune_quantization.md
View File

@ -11,7 +11,7 @@
本教程将介绍如何使用飞桨模型压缩库 PaddleSlim 做 PaddleClas 模型的压缩，即裁剪、量化功能。
[PaddleSlim](https://github.com/PaddlePaddle/PaddleSlim) 集成了模型剪枝、量化（包括量化训练和离线量化）、蒸馏和神经网络搜索等多种业界常用且领先的模型压缩功能，如果您感兴趣，可以关注并了解。
在开始本教程之前，建议先了解 [PaddleClas模型的训练方法](../models_training/classification.md) 以及 [PaddleSlim](https://paddleslim.readthedocs.io/zh_CN/latest/index.html)，相关裁剪、量化方法可以参考[模型裁剪量化算法介绍文档](../algorithm_introduction/model_prune_quantization.md)。
在开始本教程之前，建议先了解 [PaddleClas 模型的训练方法](../models_training/classification.md) 以及 [PaddleSlim](https://paddleslim.readthedocs.io/zh_CN/latest/index.html)，相关裁剪、量化方法可以参考[模型裁剪量化算法介绍文档](../algorithm_introduction/model_prune_quantization.md)。
-----------
@ -160,7 +160,7 @@ python3.7 tools/export.py \
<a name="4"></a>
## 4. 模型部署
上述步骤导出的模型可以直接使用 inferecne 进行部署，参考 [inference部署](../inference_deployment/)。
上述步骤导出的模型可以直接使用 inferecne 进行部署，参考 [inference 部署](../inference_deployment/)。
也通过 PaddleLite 的 opt 模型转换工具，完成 inference 模型到移动端模型转换，用于移动端的模型部署。
移动端模型部署的可参考 [移动端模型部署](../inference_deployment/paddle_lite_deploy.md)。

8
docs/zh_CN/algorithm_introduction/DataAugmentation.md
View File

@ -61,7 +61,7 @@
| **Process** | (N, 3, 224, 224)<br>float32 | (N, 3, 224, 224)<br>float32 | \- | \- | \- | \- | \- | \- | Y | Y |
PaddleClas中集成了上述所有的数据增强策略，每种数据增强策略的参考论文与参考开源代码均在下面的介绍中列出。下文将介绍这些策略的原理与使用方法，并以下图为例，对变换后的效果进行可视化。为了说明问题，本章节中将 `RandCrop` 替换为 `Resize`。
PaddleClas 中集成了上述所有的数据增强策略，每种数据增强策略的参考论文与参考开源代码均在下面的介绍中列出。下文将介绍这些策略的原理与使用方法，并以下图为例，对变换后的效果进行可视化。为了说明问题，本章节中将 `RandCrop` 替换为 `Resize`。
![][test_baseline]
<a name="3"></a>
@ -143,7 +143,7 @@ Cutout 可以理解为 Dropout 的一种扩展操作，不同的是 Dropout 是
`RandomErasing` 与 `Cutout` 方法类似，同样是为了解决训练出的模型在有遮挡数据上泛化能力较差的问题，作者在论文中也指出，随机裁剪的方式与随机水平翻转具有一定的互补性。作者也在行人再识别(REID)上验证了该方法的有效性。与 `Cutout` 不同的是，在 `RandomErasing` 中，图片以一定的概率接受该种预处理方法，生成掩码的尺寸大小与长宽比也是根据预设的超参数随机生成。
PaddleClas中 `RandomErasing` 的使用方法如下所示。
PaddleClas 中 `RandomErasing` 的使用方法如下所示。
经过 RandomErasing 数据增强后结果如下图所示。
@ -163,10 +163,10 @@ PaddleClas中 `RandomErasing` 的使用方法如下所示。
![][hide_and_seek_mask_expanation]
PaddleClas中 `HideAndSeek` 的使用方法如下所示。
PaddleClas 中 `HideAndSeek` 的使用方法如下所示。
经过 HideAndSeek数据增强后结果如下图所示。
经过 HideAndSeek 数据增强后结果如下图所示。
![][test_hideandseek]

54
docs/zh_CN/algorithm_introduction/ImageNet_models.md
View File

@ -5,34 +5,32 @@
## 目录
- [ImageNet 预训练模型库](#imagenet-预训练模型库)
- [目录](#目录)
- [1. 模型库概览图](#1)
- [2. SSLD 知识蒸馏预训练模型](#2)
- [2.1 服务器端知识蒸馏模型](#2.1)
- [2.2 移动端知识蒸馏模型](#2.2)
- [2.3 Intel CPU 端知识蒸馏模型](#2.3)
- [3. PP-LCNet 系列](#3)
- [4. ResNet 系列](#4)
- [5. 移动端系列](#5)
- [6. SEResNeXt 与 Res2Net 系列](#6)
- [7. DPN 与 DenseNet 系列](#7)
- [8. HRNet 系列](#8)
- [9. Inception 系列](#9)
- [10. EfficientNet 与 ResNeXt101_wsl 系列](#10)
- [11. ResNeSt 与 RegNet系列](#11)
- [12. ViT_and_DeiT 系列](#12)
- [13. RepVGG 系列](#13)
- [14. MixNet 系列](#14)
- [15. ReXNet 系列](#15)
- [16. SwinTransformer 系列](#16)
- [17. LeViT 系列](#17)
- [18. Twins 系列](#18)
- [19. HarDNet 系列](#19)
- [20. DLA 系列](#20)
- [21. RedNet 系列](#21)
- [22. TNT 系列](#22)
- [23. 其他模型](#23)
- [1. 模型库概览图](#1)
- [2. SSLD 知识蒸馏预训练模型](#2)
- [2.1 服务器端知识蒸馏模型](#2.1)
- [2.2 移动端知识蒸馏模型](#2.2)
- [2.3 Intel CPU 端知识蒸馏模型](#2.3)
- [3. PP-LCNet 系列](#3)
- [4. ResNet 系列](#4)
- [5. 移动端系列](#5)
- [6. SEResNeXt 与 Res2Net 系列](#6)
- [7. DPN 与 DenseNet 系列](#7)
- [8. HRNet 系列](#8)
- [9. Inception 系列](#9)
- [10. EfficientNet 与 ResNeXt101_wsl 系列](#10)
- [11. ResNeSt 与 RegNet系列](#11)
- [12. ViT_and_DeiT 系列](#12)
- [13. RepVGG 系列](#13)
- [14. MixNet 系列](#14)
- [15. ReXNet 系列](#15)
- [16. SwinTransformer 系列](#16)
- [17. LeViT 系列](#17)
- [18. Twins 系列](#18)
- [19. HarDNet 系列](#19)
- [20. DLA 系列](#20)
- [21. RedNet 系列](#21)
- [22. TNT 系列](#22)
- [23. 其他模型](#23)
<a name="1"></a>

4
docs/zh_CN/data_preparation/classification_dataset.md
View File

@ -22,11 +22,11 @@ PaddleClas 使用 `txt` 格式文件指定训练集和测试集，以 `ImageNet1
```shell
# 每一行采用"空格"分隔图像路径与标注
# 下面是train_list.txt中的格式样例
# 下面是 train_list.txt 中的格式样例
train/n01440764/n01440764_10026.JPEG 0
...
# 下面是val_list.txt中的格式样例
# 下面是 val_list.txt 中的格式样例
val/ILSVRC2012_val_00000001.JPEG 65
...
```

4
docs/zh_CN/image_recognition_pipeline/feature_extraction.md
View File

@ -35,7 +35,7 @@
## 3. 通用识别模型
在 PP-Shitu 中, 我们采用 [PP_LCNet_x2_5](../models/PP-LCNet.md) 作为骨干网络， Neck部分选用 Linear Layer, Head 部分选用 [ArcMargin](../../../ppcls/arch/gears/arcmargin.py)， Loss 部分选用 CELoss，详细的配置文件见[通用识别配置文件](../../../ppcls/configs/GeneralRecognition/GeneralRecognition_PPLCNet_x2_5.yaml)。其中，训练数据为如下 7 个公开数据集的汇总：
在 PP-Shitu 中, 我们采用 [PP_LCNet_x2_5](../models/PP-LCNet.md) 作为骨干网络， Neck 部分选用 Linear Layer, Head 部分选用 [ArcMargin](../../../ppcls/arch/gears/arcmargin.py)， Loss 部分选用 CELoss，详细的配置文件见[通用识别配置文件](../../../ppcls/configs/GeneralRecognition/GeneralRecognition_PPLCNet_x2_5.yaml)。其中，训练数据为如下 7 个公开数据集的汇总：
| 数据集 | 数据量 | 类别数 | 场景 | 数据集地址 |
| :------------: | :-------------: | :-------: | :-------: | :--------: |
| Aliproduct | 2498771 | 50030 | 商品 | [地址](https://retailvisionworkshop.github.io/recognition_challenge_2020/) |
@ -52,7 +52,7 @@
| :----------: | :---------: | :-------: | :-------: | :--------: | :--------: | :--------: | :--------: |
PP-LCNet-2.5x | 0.839 | 0.888 | 0.861 | 0.841 | 0.793 | 0.892 | 5.0
* 采用的评测指标为：`Recall@1`
* 速度评测机器的CPU具体信息为：`Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz`
* 速度评测机器的 CPU 具体信息为：`Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz`
* 速度指标的评测条件为： 开启 MKLDNN, 线程数设置为 10
* 预训练模型地址：[通用识别预训练模型](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/pretrain/general_PPLCNet_x2_5_pretrained_v1.0.pdparams)

12
docs/zh_CN/image_recognition_pipeline/mainbody_detection.md
View File

@ -45,14 +45,14 @@
基于上述研究，PaddleClas 中提供了 2 个通用主体检测模型，为轻量级与服务端主体检测模型，分别适用于端侧场景以及服务端场景。下面的表格中给出了在上述 5 个数据集上的平均 mAP 以及它们的模型大小、预测速度对比信息。
| 模型 | 模型结构 | 预训练模型下载地址 | inference模型下载地址 | mAP | inference模型大小(MB) | 单张图片预测耗时(不包含预处理)(ms) |
| 模型 | 模型结构 | 预训练模型下载地址 | inference 模型下载地址 | mAP | inference 模型大小(MB) | 单张图片预测耗时(不包含预处理)(ms) |
| :------------: | :-------------: | :------: | :-------: | :--------: | :-------: | :--------: |
| 轻量级主体检测模型 | PicoDet | [地址](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/pretrain/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_pretrained.pdparams) | [tar 格式文件地址](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.tar) [zip 格式文件地址](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.zip) | 40.1% | 30.1 | 29.8 |
| 服务端主体检测模型 | PP-YOLOv2 | [地址](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/pretrain/ppyolov2_r50vd_dcn_mainbody_v1.0_pretrained.pdparams) | [tar 格式文件地址](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/ppyolov2_r50vd_dcn_mainbody_v1.0_infer.tar) [zip 格式文件地址](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/ppyolov2_r50vd_dcn_mainbody_v1.0_infer.zip) | 42.5% | 210.5 | 466.6 |
* 注意
* 由于部分解压缩软件在解压上述 `tar` 格式文件时存在问题，建议非命令行用户下载 `zip` 格式文件并解压。`tar` 格式文件建议使用命令 `tar xf xxx.tar` 解压。
* 速度评测机器的CPU具体信息为：`Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz`，速度指标为开启 mkldnn ，线程数设置为 10 测试得到。
* 速度评测机器的 CPU 具体信息为：`Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz`，速度指标为开启 mkldnn ，线程数设置为 10 测试得到。
* 主体检测的预处理过程较为耗时，平均每张图在上述机器上的时间在 40~55 ms 左右，没有包含在上述的预测耗时统计中。
<a name="2.1"></a>
@ -143,13 +143,13 @@ pip install -r requirements.txt
```
coco_detection.yml：主要说明了训练数据和验证数据的路径
runtime.yml：主要说明了公共的运行参数，比如是否使用GPU、每多少个 epoch 存储 checkpoint 等
runtime.yml：主要说明了公共的运行参数，比如是否使用 GPU、每多少个 epoch 存储 checkpoint 等
optimizer_365e.yml：主要说明了学习率和优化器的配置
ppyolov2_r50vd_dcn.yml：主要说明模型和主干网络的情况
ppyolov2_reader.yml：主要说明数据读取器配置，如 batch size，并发加载子进程数等，同时包含读取后预处理操作，如resize、数据增强等等
ppyolov2_reader.yml：主要说明数据读取器配置，如 batch size，并发加载子进程数等，同时包含读取后预处理操作，如 resize、数据增强等等
```
在主体检测任务中，需要将 `datasets/coco_detection.yml` 中的 `num_classes` 参数修改为 1 （只有 1 个前景类别），同时将训练集和测试集的路径修改为自定义数据集的路径。
@ -165,7 +165,7 @@ PaddleDetection 提供了单卡/多卡训练模式，满足用户多种训练需
* GPU 单卡训练
```bash
# windows和Mac下不需要执行该命令
# windows 和 Mac 下不需要执行该命令
export CUDA_VISIBLE_DEVICES=0
python tools/train.py -c configs/ppyolo/ppyolov2_r50vd_dcn_365e_coco.yml
```
@ -185,7 +185,7 @@ python -m paddle.distributed.launch --gpus 0,1,2,3 tools/train.py -c configs/ppy
```bash
export CUDA_VISIBLE_DEVICES=0
# 指定pretrain_weights参数，加载通用的主体检测预训练模型
# 指定 pretrain_weights 参数，加载通用的主体检测预训练模型
python tools/train.py -c configs/ppyolo/ppyolov2_r50vd_dcn_365e_coco.yml -o pretrain_weights=https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/pretrain/ppyolov2_r50vd_dcn_mainbody_v1.0_pretrained.pdparams
```

8
docs/zh_CN/image_recognition_pipeline/vector_search.md
View File

@ -1,6 +1,6 @@
# 向量检索
向量检索技术在图像识别、图像检索中应用比较广泛。其主要目标是，对于给定的查询向量，在已经建立好的向量库中，与库中所有的待查询向量，进行特征向量的相似度或距离计算，得到相似度排序。在图像识别系统中，我们使用 [Faiss](https://github.com/facebookresearch/faiss) 对此部分进行支持，具体信息请详查 [Faiss官网](https://github.com/facebookresearch/faiss)。`Faiss` 主要有以下优势
向量检索技术在图像识别、图像检索中应用比较广泛。其主要目标是，对于给定的查询向量，在已经建立好的向量库中，与库中所有的待查询向量，进行特征向量的相似度或距离计算，得到相似度排序。在图像识别系统中，我们使用 [Faiss](https://github.com/facebookresearch/faiss) 对此部分进行支持，具体信息请详查 [Faiss 官网](https://github.com/facebookresearch/faiss)。`Faiss` 主要有以下优势
- 适配性好：支持 Windos、Linux、MacOS 系统
- 安装方便： 支持 `python` 接口，直接使用 `pip` 安装
@ -67,9 +67,9 @@ pip install faiss-cpu==1.7.1post2
建库的具体操作如下：
```shell
# 进入deploy目录
# 进入 deploy 目录
cd deploy
# yaml文件根据需要改成自己所需的具体yaml文件
# yaml 文件根据需要改成自己所需的具体 yaml 文件
python python/build_gallery.py -c configs/build_***.yaml
```
@ -105,7 +105,7 @@ IndexProcess:
### 3.2 检索配置文件参数
将检索的过程融合到 `PP-ShiTu` 的整体流程中，请参考 [README](../../../README_ch.md) 中 `PP-ShiTu图像识别系统介绍` 部分。检索具体使用操作请参考[识别快速开始文档](../quick_start/quick_start_recognition.md)。
将检索的过程融合到 `PP-ShiTu` 的整体流程中，请参考 [README](../../../README_ch.md) 中 `PP-ShiTu 图像识别系统介绍` 部分。检索具体使用操作请参考[识别快速开始文档](../quick_start/quick_start_recognition.md)。
其中，检索部分配置如下，整体检索配置文件，请参考 `deploy/configs/inference_*.yaml` 文件。

22
docs/zh_CN/inference_deployment/export_model.md
View File

@ -7,19 +7,19 @@ PaddlePaddle 支持导出 inference 模型用于部署推理场景，相比于
## 目录
- [环境准备](#环境准备)
- [分类模型导出](#分类模型导出)
- [主体检测模型导出](#主体检测模型导出)
- [识别模型导出](#识别模型导出)
- [命令参数说明](#命令参数说明)
- [1. 环境准备](#1)
- [2. 分类模型导出](#2)
- [3. 主体检测模型导出](#3)
- [4. 识别模型导出](#4)
- [5. 命令参数说明](#5)
<a name="环境准备"></a>
<a name="1"></a>
## 1. 环境准备
首先请参考文档[安装PaddlePaddle](../installation/install_paddle.md)和文档[安装PaddleClas](../installation/install_paddleclas.md)配置运行环境。
首先请参考文档[安装 PaddlePaddle](../installation/install_paddle.md)和文档[安装 PaddleClas](../installation/install_paddleclas.md)配置运行环境。
<a name="分类模型导出"></a>
<a name="2"></a>
## 2. 分类模型导出
进入 PaddleClas 目录下：
@ -43,12 +43,12 @@ python tools/export_model.py \
-o Global.save_inference_dir=./deploy/models/class_ResNet50_vd_ImageNet_infer
```
<a name="主体检测模型导出"></a>
<a name="3"></a>
## 3. 主体检测模型导出
主体检测模型的导出，可以参考[主题检测介绍](../image_recognition_pipeline/mainbody_detection.md)。
<a name="识别模型导出"></a>
<a name="4"></a>
## 4. 识别模型导出
进入 PaddleClas 目录下：
@ -74,7 +74,7 @@ python3 tools/export_model.py \
注意，此处保存的 inference 模型在 embedding 特征层做了截断，即导出后模型最终的输出为 n 维 embedding 特征。
<a name="命令参数说明"></a>
<a name="5"></a>
## 5. 命令参数说明
在上述模型导出命令中，所使用的配置文件需要与该模型的训练文件相同，在配置文件中有以下字段用于配置模型导出参数：

50
docs/zh_CN/inference_deployment/paddle_hub_serving_deploy.md
View File

@ -1,4 +1,4 @@
# 基于PaddleHub Serving的服务部署
# 基于 PaddleHub Serving 的服务部署
PaddleClas 支持通过 PaddleHub 快速进行服务化部署。目前支持图像分类的部署，图像识别的部署敬请期待。
@ -6,17 +6,17 @@ PaddleClas 支持通过 PaddleHub 快速进行服务化部署。目前支持图
## 目录
- [简介](#1)
- [准备环境](#2)
- [下载推理模型](#3)
- [安装服务模块](#4)
- [启动服务](#5)
- [5.1命令行命令启动](#5.1)
- [1. 简介](#1)
- [2. 准备环境](#2)
- [3. 下载推理模型](#3)
- [4. 安装服务模块](#4)
- [5. 启动服务](#5)
- [5.1 命令行命令启动](#5.1)
- [5.2 配置文件启动](#5.2)
- [发送预测请求](#6)
- [自定义修改服务模块](#7)
- [6. 发送预测请求](#6)
- [7. 自定义修改服务模块](#7)
<a name="1"></a>
## 1. 简介
@ -34,7 +34,7 @@ hubserving/clas/
<a name="2"></a>
## 2. 准备环境
```shell
# 安装paddlehub,请安装2.0版本
# 安装 paddlehub,请安装 2.0 版本
pip3 install paddlehub==2.1.0 --upgrade -i https://pypi.tuna.tsinghua.edu.cn/simple
```
@ -55,7 +55,7 @@ pip3 install paddlehub==2.1.0 --upgrade -i https://pypi.tuna.tsinghua.edu.cn/sim
```
需要注意，
* 模型文件（包括 `.pdmodel` 与 `.pdiparams`）名称必须为`inference`。
* 我们也提供了大量基于ImageNet-1k数据集的预训练模型，模型列表及下载地址详见[模型库概览](../models/models_intro.md)，也可以使用自己训练转换好的模型。
* 我们也提供了大量基于 ImageNet-1k 数据集的预训练模型，模型列表及下载地址详见[模型库概览](../models/models_intro.md)，也可以使用自己训练转换好的模型。
<a name="4"></a>
@ -63,14 +63,14 @@ pip3 install paddlehub==2.1.0 --upgrade -i https://pypi.tuna.tsinghua.edu.cn/sim
针对 Linux 环境和 Windows 环境，安装命令如下。
* 在Linux环境下，安装示例如下：
* 在 Linux 环境下，安装示例如下：
```shell
cd PaddleClas/deploy
# 安装服务模块：
hub install hubserving/clas/
```
* 在Windows环境下(文件夹的分隔符为`\`)，安装示例如下：
* 在 Windows 环境下(文件夹的分隔符为`\`)，安装示例如下：
```shell
cd PaddleClas\deploy
@ -98,10 +98,10 @@ $ hub serving start --modules Module1==Version1 \
**参数说明**：
|参数|用途|
|-|-|
|--modules/-m| [**必选**] PaddleHub Serving预安装模型，以多个Module==Version键值对的形式列出<br>*`当不指定Version时，默认选择最新版本`*|
|--port/-p| [**可选**] 服务端口，默认为8866|
|--use_multiprocess| [**可选**] 是否启用并发方式，默认为单进程方式，推荐多核CPU机器使用此方式<br>*`Windows操作系统只支持单进程方式`*|
|--workers| [**可选**] 在并发方式下指定的并发任务数，默认为`2*cpu_count-1`，其中`cpu_count`为CPU核数|
|--modules/-m| [**必选**] PaddleHub Serving 预安装模型，以多个 Module==Version 键值对的形式列出<br>*`当不指定 Version 时，默认选择最新版本`*|
|--port/-p| [**可选**] 服务端口，默认为 8866|
|--use_multiprocess| [**可选**] 是否启用并发方式，默认为单进程方式，推荐多核 CPU 机器使用此方式<br>*`Windows 操作系统只支持单进程方式`*|
|--workers| [**可选**] 在并发方式下指定的并发任务数，默认为`2*cpu_count-1`，其中`cpu_count`为 CPU 核数|
如按默认参数启动服务：```hub serving start -m clas_system```
@ -138,8 +138,8 @@ $ hub serving start --modules Module1==Version1 \
**参数说明**：
* `init_args`中的可配参数与`module.py`中的`_initialize`函数接口一致。其中，
- 当`use_gpu`为`true`时，表示使用GPU启动服务。
- 当`enable_mkldnn`为`true`时，表示使用MKL-DNN加速。
- 当`use_gpu`为`true`时，表示使用 GPU 启动服务。
- 当`enable_mkldnn`为`true`时，表示使用 MKL-DNN 加速。
* `predict_args`中的可配参数与`module.py`中的`predict`函数接口一致。
**注意**：
@ -148,7 +148,7 @@ $ hub serving start --modules Module1==Version1 \
* **`use_gpu` 不可与 `use_multiprocess` 同时为 `true`**；
* **`use_gpu` 与 `enable_mkldnn` 同时为 `true` 时，将忽略 `enable_mkldnn`，而使用 GPU**。
如使用 GPU 3号卡启动服务：
如使用 GPU 3 号卡启动服务：
```shell
cd PaddleClas/deploy
@ -189,8 +189,8 @@ python hubserving/test_hubserving.py --server_url http://127.0.0.1:8866/predict/
```
list: 返回结果
└─ list: 第一张图片结果
└─ list: 前k个分类结果，依score递减排序
└─ list: 前k个分类结果对应的score，依score递减排序
└─ list: 前 k 个分类结果，依 score 递减排序
└─ list: 前 k 个分类结果对应的 score，依 score 递减排序
└─ float: 该图分类耗时，单位秒
```
@ -224,7 +224,7 @@ list: 返回结果
```python
'topk':
```
* 更改后处理时的lable与class id对应映射文件：
* 更改后处理时的 lable 与 class id 对应映射文件：
```python
'class_id_map_file':
```

102
docs/zh_CN/inference_deployment/paddle_lite_deploy.md
View File

@ -1,32 +1,32 @@
# PaddleLite推理部署
# PaddleLite 推理部署
---
本教程将介绍基于[Paddle Lite](https://github.com/PaddlePaddle/Paddle-Lite)在移动端部署 PaddleClas 分类模型的详细步骤。识别模型的部署将在近期支持，敬请期待。
Paddle Lite是飞桨轻量化推理引擎，为手机、IOT端提供高效推理能力，并广泛整合跨平台硬件，为端侧部署及应用落地问题提供轻量化的部署方案。
Paddle Lite 是飞桨轻量化推理引擎，为手机、IOT 端提供高效推理能力，并广泛整合跨平台硬件，为端侧部署及应用落地问题提供轻量化的部署方案。
如果希望直接测试速度，可以参考[Paddle-Lite移动端benchmark测试教程](../others/paddle_mobile_inference.md)。
如果希望直接测试速度，可以参考[Paddle-Lite 移动端 benchmark 测试教程](../others/paddle_mobile_inference.md)。
---
## 目录
- [准备环境](#1)
- [1. 准备环境](#1)
- [1.1 准备交叉编译环境](#1.1)
- [1.2 准备预测库](#1.2)
- [开始运行](#2)
- [2.1模型优化](#2.1)
- [2.1.1 pip安装paddlelite并进行转换](#2.1.1)
- [2.1.2 源码编译Paddle-Lite生成opt工具](#2.1.2)
- [2. 开始运行](#2)
- [2.1 模型优化](#2.1)
- [2.1.1 pip 安装 paddlelite 并进行转换](#2.1.1)
- [2.1.2 源码编译 Paddle-Lite 生成 opt 工具](#2.1.2)
- [2.1.3 转换示例](#2.1.3)
- [2.2与手机联调](#2.2)
- [FAQ](#3)
- [2.2 与手机联调](#2.2)
- [3. FAQ](#3)
<a name="1"></a>
## 一、准备环境
## 1. 准备环境
Paddle Lite 目前支持以下平台部署：
* 电脑（编译Paddle Lite）
* 安卓手机（armv7或armv8）
* 电脑（编译 Paddle Lite）
* 安卓手机（armv7 或 armv8）
<a name="1.1"></a>
### 1.1 准备交叉编译环境
@ -54,13 +54,13 @@ Paddle Lite 目前支持以下平台部署：
```shell
git clone https://github.com/PaddlePaddle/Paddle-Lite.git
cd Paddle-Lite
# 如果使用编译方式，建议使用develop分支编译预测库
# 如果使用编译方式，建议使用 develop 分支编译预测库
git checkout develop
./lite/tools/build_android.sh --arch=armv8 --with_cv=ON --with_extra=ON
```
**注意**：编译Paddle-Lite获得预测库时，需要打开`--with_cv=ON --with_extra=ON`两个选项，`--arch`表示`arm`版本，这里指定为armv8，更多编译命令介绍请参考[Linux x86 环境下编译适用于 Android 的库](https://paddle-lite.readthedocs.io/zh/latest/source_compile/linux_x86_compile_android.html)，关于其他平台的编译操作，具体请参考[PaddleLite](https://paddle-lite.readthedocs.io/zh/latest/)中`源码编译`部分。
**注意**：编译 Paddle-Lite 获得预测库时，需要打开`--with_cv=ON --with_extra=ON`两个选项，`--arch`表示`arm`版本，这里指定为 armv8，更多编译命令介绍请参考[Linux x86 环境下编译适用于 Android 的库](https://paddle-lite.readthedocs.io/zh/latest/source_compile/linux_x86_compile_android.html)，关于其他平台的编译操作，具体请参考[PaddleLite](https://paddle-lite.readthedocs.io/zh/latest/)中`源码编译`部分。
直接下载预测库并解压后，可以得到`inference_lite_lib.android.armv8/`文件夹，通过编译Paddle-Lite得到的预测库位于`Paddle-Lite/build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/`文件夹下。
直接下载预测库并解压后，可以得到`inference_lite_lib.android.armv8/`文件夹，通过编译 Paddle-Lite 得到的预测库位于`Paddle-Lite/build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/`文件夹下。
预测库的文件目录如下：
```
@ -77,7 +77,7 @@ inference_lite_lib.android.armv8/
| `-- lib C++预测库
| |-- libpaddle_api_light_bundled.a C++静态库
| `-- libpaddle_light_api_shared.so C++动态库
|-- java Java预测库
|-- java Java 预测库
| |-- jar
| | `-- PaddlePredictor.jar
| |-- so
@ -89,7 +89,7 @@ inference_lite_lib.android.armv8/
```
<a name="2"></a>
## 二、开始运行
## 2. 开始运行
<a name="2.1"></a>
### 2.1 模型优化
@ -99,10 +99,10 @@ Paddle-Lite 提供了多种策略来自动优化原始的模型，其中包括
**注意**：如果已经准备好了 `.nb` 结尾的模型文件，可以跳过此步骤。
<a name="2.1.1"></a>
#### 2.1.1 [建议]pip安装paddlelite并进行转换
#### 2.1.1 [建议]pip 安装 paddlelite 并进行转换
Python下安装 `paddlelite`，目前最高支持 `Python3.7`。
**注意**：`paddlelite` whl包版本必须和预测库版本对应。
Python 下安装 `paddlelite`，目前最高支持 `Python3.7`。
**注意**：`paddlelite` whl 包版本必须和预测库版本对应。
```shell
pip install paddlelite==2.8
@ -112,23 +112,23 @@ pip install paddlelite==2.8
|选项|说明|
|-|-|
|--model_dir|待优化的PaddlePaddle模型（非combined形式）的路径|
|--model_file|待优化的PaddlePaddle模型（combined形式）的网络结构文件路径|
|--param_file|待优化的PaddlePaddle模型（combined形式）的权重文件路径|
|--optimize_out_type|输出模型类型，目前支持两种类型：protobuf和naive_buffer，其中naive_buffer是一种更轻量级的序列化/反序列化实现。若您需要在mobile端执行模型预测，请将此选项设置为naive_buffer。默认为protobuf|
|--model_dir|待优化的 PaddlePaddle 模型（非 combined 形式）的路径|
|--model_file|待优化的 PaddlePaddle 模型（combined 形式）的网络结构文件路径|
|--param_file|待优化的 PaddlePaddle 模型（combined 形式）的权重文件路径|
|--optimize_out_type|输出模型类型，目前支持两种类型：protobuf 和 naive_buffer，其中 naive_buffer 是一种更轻量级的序列化/反序列化实现。若您需要在 mobile 端执行模型预测，请将此选项设置为 naive_buffer。默认为 protobuf|
|--optimize_out|优化模型的输出路径|
|--valid_targets|指定模型可执行的backend，默认为arm。目前可支持x86、arm、opencl、npu、xpu，可以同时指定多个backend(以空格分隔)，Model Optimize Tool将会自动选择最佳方式。如果需要支持华为NPU（Kirin 810/990 Soc搭载的达芬奇架构NPU），应当设置为npu, arm|
|--record_tailoring_info|当使用 根据模型裁剪库文件 功能时，则设置该选项为true，以记录优化后模型含有的kernel和OP信息，默认为false|
|--valid_targets|指定模型可执行的 backend，默认为 arm。目前可支持 x86、arm、opencl、npu、xpu，可以同时指定多个 backend（以空格分隔），Model Optimize Tool 将会自动选择最佳方式。如果需要支持华为 NPU（Kirin 810/990 Soc 搭载的达芬奇架构 NPU），应当设置为 npu, arm|
|--record_tailoring_info|当使用 根据模型裁剪库文件 功能时，则设置该选项为 true，以记录优化后模型含有的 kernel 和 OP 信息，默认为 false|
`--model_file` 表示 inference 模型的 model 文件地址，`--param_file` 表示 inference 模型的 param 文件地址；`optimize_out` 用于指定输出文件的名称（不需要添加 `.nb` 的后缀）。直接在命令行中运行 `paddle_lite_opt`，也可以查看所有参数及其说明。
<a name="2.1.2"></a>
#### 2.1.2 源码编译Paddle-Lite生成opt工具
#### 2.1.2 源码编译 Paddle-Lite 生成 opt 工具
模型优化需要 Paddle-Lite 的 `opt` 可执行文件，可以通过编译 Paddle-Lite 源码获得，编译步骤如下：
```shell
# 如果准备环境时已经clone了Paddle-Lite，则不用重新clone Paddle-Lite
# 如果准备环境时已经 clone 了 Paddle-Lite，则不用重新 clone Paddle-Lite
git clone https://github.com/PaddlePaddle/Paddle-Lite.git
cd Paddle-Lite
git checkout develop
@ -148,17 +148,17 @@ cd build.opt/lite/api/
<a name="2.1.3"></a>
#### 2.1.3 转换示例
下面以PaddleClas的 `MobileNetV3_large_x1_0` 模型为例，介绍使用 `paddle_lite_opt` 完成预训练模型到inference模型，再到 Paddle-Lite 优化模型的转换。
下面以 PaddleClas 的 `MobileNetV3_large_x1_0` 模型为例，介绍使用 `paddle_lite_opt` 完成预训练模型到 inference 模型，再到 Paddle-Lite 优化模型的转换。
```shell
# 进入PaddleClas根目录
# 进入 PaddleClas 根目录
cd PaddleClas_root_path
# 下载并解压inference模型
# 下载并解压 inference 模型
wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/MobileNetV3_large_x1_0_infer.tar
tar -xf MobileNetV3_large_x1_0_infer.tar
# 将inference模型转化为Paddle-Lite优化模型
# 将 inference 模型转化为 Paddle-Lite 优化模型
paddle_lite_opt --model_file=./MobileNetV3_large_x1_0_infer/inference.pdmodel --param_file=./MobileNetV3_large_x1_0_infer/inference.pdiparams --optimize_out=./MobileNetV3_large_x1_0
```
@ -171,21 +171,21 @@ paddle_lite_opt --model_file=./MobileNetV3_large_x1_0_infer/inference.pdmodel --
首先需要进行一些准备工作。
1. 准备一台 arm8 的安卓手机，如果编译的预测库和 opt 文件是 armv7，则需要 arm7 的手机，并修改 Makefile 中 `ARM_ABI = arm7`。
2. 电脑上安装 ADB 工具，用于调试。 ADB安装方式如下：
2. 电脑上安装 ADB 工具，用于调试。 ADB 安装方式如下：
* MAC电脑安装ADB:
* MAC 电脑安装 ADB:
```shell
brew cask install android-platform-tools
```
* Linux安装ADB
* Linux 安装 ADB
```shell
sudo apt update
sudo apt install -y wget adb
```
* Window安装ADB
win上安装需要去谷歌的安卓平台下载ADB软件包进行安装：[链接](https://developer.android.com/studio)
* Window 安装 ADB
win 上安装需要去谷歌的安卓平台下载 ADB 软件包进行安装：[链接](https://developer.android.com/studio)
3. 手机连接电脑后，开启手机 `USB调试` 选项，选择 `文件传输` 模式，在电脑终端中输入：
3. 手机连接电脑后，开启手机 `USB 调试` 选项，选择 `文件传输` 模式，在电脑终端中输入：
```shell
adb devices
@ -202,15 +202,15 @@ List of devices attached
cd PaddleClas_root_path
cd deploy/lite/
# 运行prepare.sh
# prepare.sh 会将预测库文件、测试图像和使用的字典文件放置在预测库中的demo/cxx/clas文件夹下
# 运行 prepare.sh
# prepare.sh 会将预测库文件、测试图像和使用的字典文件放置在预测库中的 demo/cxx/clas 文件夹下
sh prepare.sh /{lite prediction library path}/inference_lite_lib.android.armv8
# 进入lite demo的工作目录
# 进入 lite demo 的工作目录
cd /{lite prediction library path}/inference_lite_lib.android.armv8/
cd demo/cxx/clas/
# 将C++预测动态库so文件复制到debug文件夹中
# 将 C++ 预测动态库 so 文件复制到 debug 文件夹中
cp ../../../cxx/lib/libpaddle_light_api_shared.so ./debug/
```
@ -240,28 +240,28 @@ demo/cxx/clas/
```shell
clas_model_file ./MobileNetV3_large_x1_0.nb # 模型文件地址
label_path ./imagenet1k_label_list.txt # 类别映射文本文件
resize_short_size 256 # resize之后的短边边长
resize_short_size 256 # resize 之后的短边边长
crop_size 224 # 裁剪后用于预测的边长
visualize 0 # 是否进行可视化，如果选择的话，会在当前文件夹下生成名为clas_result.png的图像文件。
visualize 0 # 是否进行可视化，如果选择的话，会在当前文件夹下生成名为 clas_result.png 的图像文件。
```
5. 启动调试，上述步骤完成后就可以使用ADB将文件夹 `debug/` push 到手机上运行，步骤如下：
5. 启动调试，上述步骤完成后就可以使用 ADB 将文件夹 `debug/` push 到手机上运行，步骤如下：
```shell
# 执行编译，得到可执行文件clas_system
# 执行编译，得到可执行文件 clas_system
make -j
# 将编译得到的可执行文件移动到debug文件夹中
# 将编译得到的可执行文件移动到 debug 文件夹中
mv clas_system ./debug/
# 将上述debug文件夹push到手机上
# 将上述 debug 文件夹 push 到手机上
adb push debug /data/local/tmp/
adb shell
cd /data/local/tmp/debug
export LD_LIBRARY_PATH=/data/local/tmp/debug:$LD_LIBRARY_PATH
# clas_system可执行文件的使用方式为:
# clas_system 可执行文件的使用方式为:
# ./clas_system 配置文件路径 测试图像路径
./clas_system ./config.txt ./tabby_cat.jpg
```
@ -275,7 +275,7 @@ export LD_LIBRARY_PATH=/data/local/tmp/debug:$LD_LIBRARY_PATH
</div>
<a name="3"></a>
## 三、FAQ
## 3. FAQ
Q1：如果想更换模型怎么办，需要重新按照流程走一遍吗？
A1：如果已经走通了上述步骤，更换模型只需要替换 `.nb` 模型文件即可，同时要注意修改下配置文件中的 `.nb` 文件路径以及类别映射文件（如有必要）。

13
docs/zh_CN/inference_deployment/paddle_serving_deploy.md
View File

@ -46,7 +46,6 @@ pip3 install paddle-serving-server-gpu==0.7.0.post112 # GPU with CUDA11.2 + Tens
```shell
pip install paddle-serving-server
```
<a name="3"></a>
## 3. 图像分类服务部署
<a name="3.1"></a>
@ -81,7 +80,7 @@ ResNet50_vd 推理模型转换完成后，会在当前文件夹多出 `ResNet50_
|- serving_client_conf.prototxt
|- serving_client_conf.stream.prototxt
```
得到模型文件之后，需要修改 `ResNet50_vd_server` 下文件 `serving_server_conf.prototxt` 中的 alias 名字：将 `fetch_var` 中的 `alias_name` 改为 `prediction`
得到模型文件之后，需要修改 serving_server_conf.prototxt 中的 alias 名字： 将`feed_var`中的`alias_name`改为`image`, 将`fetch_var`中的`alias_name`改为`prediction`
**备注**: Serving 为了兼容不同模型的部署，提供了输入输出重命名的功能。这样，不同的模型在推理部署时，只需要修改配置文件的 alias_name 即可，无需修改代码即可完成推理部署。
修改后的 serving_server_conf.prototxt 如下所示:
@ -155,7 +154,7 @@ python3 -m paddle_serving_client.convert --dirname ./general_PPLCNet_x2_5_lite_v
--serving_server ./general_PPLCNet_x2_5_lite_v1.0_serving/ \
--serving_client ./general_PPLCNet_x2_5_lite_v1.0_client/
```
识别推理模型转换完成后，会在当前文件夹多出 `general_PPLCNet_x2_5_lite_v1.0_serving/` 和 `general_PPLCNet_x2_5_lite_v1.0_serving/` 的文件夹。修改 `general_PPLCNet_x2_5_lite_v1.0_serving/` 目录下的 serving_server_conf.prototxt 中的 alias 名字： 将 `fetch_var` 中的 `alias_name` 改为 `features`。
识别推理模型转换完成后，会在当前文件夹多出`general_PPLCNet_x2_5_lite_v1.0_serving/` 和`general_PPLCNet_x2_5_lite_v1.0_serving/`的文件夹。修改`general_PPLCNet_x2_5_lite_v1.0_serving/`目录下的 serving_server_conf.prototxt 中的 alias 名字： 将`fetch_var`中的`alias_name`改为`features`。
修改后的 serving_server_conf.prototxt 内容如下：
```
feed_var {
@ -184,9 +183,9 @@ python3 -m paddle_serving_client.convert --dirname ./picodet_PPLCNet_x2_5_mainbo
--serving_server ./picodet_PPLCNet_x2_5_mainbody_lite_v1.0_serving/ \
--serving_client ./picodet_PPLCNet_x2_5_mainbody_lite_v1.0_client/
```
检测 inference 模型转换完成后，会在当前文件夹多出 `picodet_PPLCNet_x2_5_mainbody_lite_v1.0_serving/` 和 `picodet_PPLCNet_x2_5_mainbody_lite_v1.0_client/` 的文件夹。
检测 inference 模型转换完成后，会在当前文件夹多出`picodet_PPLCNet_x2_5_mainbody_lite_v1.0_serving/` 和`picodet_PPLCNet_x2_5_mainbody_lite_v1.0_client/`的文件夹。
**注意:** 此处不需要修改 `picodet_PPLCNet_x2_5_mainbody_lite_v1.0_serving/` 目录下的 serving_server_conf.prototxt 中的 alias 名字。
**注意:** 此处不需要修改`picodet_PPLCNet_x2_5_mainbody_lite_v1.0_serving/`目录下的 serving_server_conf.prototxt 中的 alias 名字。
- 下载并解压已经构建后的检索库 index
```
@ -195,7 +194,7 @@ wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/drink_da
```
<a name="4.2"></a>
## 4.2 服务部署和请求
**注意:** 识别服务涉及到多个模型，出于性能考虑采用 PipeLine 部署方式。Pipeline 部署方式当前不支持 windows 平台。
**注意:** 识别服务涉及到多个模型，出于性能考虑采用 PipeLine 部署方式。Pipeline 部署方式当前不支持 windows 平台。
- 进入到工作目录
```shell
cd ./deploy/paddleserving/recognition
@ -233,4 +232,4 @@ unset https_proxy
unset http_proxy
```
更多的服务部署类型，如 `RPC 预测服务` 等，可以参考 Serving 的[github 官网](https://github.com/PaddlePaddle/Serving/tree/v0.7.0/examples)
更多的服务部署类型，如 `RPC 预测服务` 等，可以参考 Serving 的[github 官网](https://github.com/PaddlePaddle/Serving/tree/develop/python/examples/imagenet)

20
docs/zh_CN/inference_deployment/python_deploy.md
View File

@ -2,16 +2,16 @@
---
首先请参考文档[安装PaddlePaddle](../installation/install_paddle.md)和文档[安装PaddleClas](../installation/install_paddleclas.md)配置运行环境。
首先请参考文档[安装 PaddlePaddle](../installation/install_paddle.md)和文档[安装 PaddleClas](../installation/install_paddleclas.md)配置运行环境。
## 目录
- [图像分类推理](#图像分类推理)
- [主体检测模型推理](#主体检测模型推理)
- [特征提取模型推理](#特征提取模型推理)
- [主体检测、特征提取和向量检索串联](#主体检测、特征提取和向量检索串联)
- [1. 图像分类推理](#1)
- [2. 主体检测模型推理](#2)
- [3. 特征提取模型推理](#3)
- [4. 主体检测、特征提取和向量检索串联](#4)
<a name="图像分类推理"></a>
<a name="1"></a>
## 1. 图像分类推理
首先请参考文档[模型导出](./export_model.md)准备 inference 模型，然后进入 PaddleClas 的 `deploy` 目录下：
@ -39,9 +39,9 @@ python python/predict_cls.py -c configs/inference_cls.yaml
**注意**:
* 如果使用 VisionTransformer 系列模型，如 `DeiT_***_384`, `ViT_***_384` 等，请注意模型的输入数据尺寸，部分模型需要修改参数： `PreProcess.resize_short=384`, `PreProcess.resize=384`。
* 如果你希望提升评测模型速度，使用gpu评测时，建议开启TensorRT加速预测，使用cpu评测时，建议开启MKL-DNN加速预测。
* 如果你希望提升评测模型速度，使用 GPU 评测时，建议开启 TensorRT 加速预测，使用 CPU 评测时，建议开启 MKL-DNN 加速预测。
<a name="主体检测模型推理"></a>
<a name="2"></a>
## 2. 主体检测模型推理
进入 PaddleClas 的 `deploy` 目录下：
@ -70,7 +70,7 @@ python python/predict_det.py -c configs/inference_det.yaml
* `Global.use_gpu`： 是否使用 GPU 预测，默认为 `True`。
<a name="特征提取模型推理"></a>
<a name="3"></a>
## 3. 特征提取模型推理
下面以商品特征提取为例，介绍特征提取模型推理。首先进入 PaddleClas 的 `deploy` 目录下：
@ -90,7 +90,7 @@ tar -xf ./models/product_ResNet50_vd_aliproduct_v1.0_infer.tar -C ./models/
上述预测命令可以得到一个 512 维的特征向量，直接输出在在命令行中。
<a name="主体检测、特征提取和向量检索串联"></a>
<a name="4"></a>
## 4. 主体检测、特征提取和向量检索串联
主体检测、特征提取和向量检索的串联预测，可以参考图像识别[快速体验](../quick_start/quick_start_recognition.md)。

67
docs/zh_CN/inference_deployment/whl_deploy.md
View File

@ -6,23 +6,24 @@ PaddleClas 支持 Python Whl 包方式进行预测，目前 Whl 包方式仅支
## 目录
- [安装paddleclas](#1)
- [快速开始](#2)
- [参数解释](#3)
- [使用示例](#4)
- [1. 安装 paddleclas](#1)
- [2. 快速开始](#2)
- [3. 参数解释](#3)
- [4. 使用示例](#4)
- [4.1 查看帮助信息](#4.1)
- [4.2 使用PaddleClas提供的预训练模型进行预测](#4.2)
- [4.2 使用 PaddleClas 提供的预训练模型进行预测](#4.2)
- [4.3 使用本地模型文件预测](#4.3)
- [4.4 批量预测](#4.4)
- [4.5 对网络图片进行预测](#4.5)
- [4.6 对`NumPy.ndarray`格式数据进行预测](#4.6)
- [4.7 保存预测结果](#4.7)
- [4.8 指定label name](#4.8)
<a name="1"></a>
## 一、安装paddleclas
- [4.8 指定 label name](#4.8)
* pip安装
<a name="1"></a>
## 1. 安装 paddleclas
* pip 安装
```bash
pip3 install paddleclas==2.2.1
@ -36,7 +37,7 @@ pip3 install dist/*
```
<a name="2"></a>
## 二、快速开始
## 2. 快速开始
* 使用`ResNet50`模型，以下图（`PaddleClas/docs/images/inference_deployment/whl_demo.jpg`）为例进行说明。
<div align="center">
@ -44,7 +45,7 @@ pip3 install dist/*
</div>
* 在Python代码中使用
* 在 Python 代码中使用
```python
from paddleclas import PaddleClas
clas = PaddleClas(model_name='ResNet50')
@ -72,17 +73,17 @@ Predict complete!
```
<a name="3"></a>
## 三、参数解释
以下参数可在命令行方式使用中通过参数指定，或在Python代码中实例化PaddleClas对象时作为构造函数的参数使用。
* model_name(str): 模型名称，使用PaddleClas提供的基于ImageNet1k的预训练模型。
## 3. 参数解释
以下参数可在命令行方式使用中通过参数指定，或在 Python 代码中实例化 PaddleClas 对象时作为构造函数的参数使用。
* model_name(str): 模型名称，使用 PaddleClas 提供的基于 ImageNet1k 的预训练模型。
* inference_model_dir(str): 本地模型文件目录，当未指定 `model_name` 时该参数有效。该目录下需包含 `inference.pdmodel` 和 `inference.pdiparams` 两个模型文件。
* infer_imgs(str): 待预测图片文件路径，或包含图片文件的目录，或网络图片的URL。
* use_gpu(bool): 是否使用GPU，默认为 `True`。
* gpu_mem(int): 使用的GPU显存大小，当 `use_gpu` 为 `True` 时有效，默认为8000。
* use_tensorrt(bool): 是否开启TensorRT预测，可提升GPU预测性能，需要使用带TensorRT的预测库，默认为 `False`。
* enable_mkldnn(bool): 是否开启MKLDNN，当 `use_gpu` 为 `False` 时有效，默认 `False`。
* cpu_num_threads(int): cpu预测时的线程数，当 `use_gpu` 为 `False` 且 `enable_mkldnn` 为 `True` 时有效，默认值为 `10`。
* batch_size(int): 预测时每个batch的样本数量，默认为 `1`。
* infer_imgs(str): 待预测图片文件路径，或包含图片文件的目录，或网络图片的 URL。
* use_gpu(bool): 是否使用 GPU，默认为 `True`。
* gpu_mem(int): 使用的 GPU 显存大小，当 `use_gpu` 为 `True` 时有效，默认为 8000。
* use_tensorrt(bool): 是否开启 TensorRT 预测，可提升 GPU 预测性能，需要使用带 TensorRT 的预测库，默认为 `False`。
* enable_mkldnn(bool): 是否开启 MKLDNN，当 `use_gpu` 为 `False` 时有效，默认 `False`。
* cpu_num_threads(int): CPU 预测时的线程数，当 `use_gpu` 为 `False` 且 `enable_mkldnn` 为 `True` 时有效，默认值为 `10`。
* batch_size(int): 预测时每个 batch 的样本数量，默认为 `1`。
* resize_short(int): 按图像较短边进行等比例缩放，默认为 `256`。
* crop_size(int): 将图像裁剪到指定大小，默认为 `224`。
* topk(int): 打印（返回）预测结果的前 `topk` 个类别和对应的分类概率，默认为 `5`。
@ -97,17 +98,17 @@ from paddleclas import PaddleClas, get_default_confg
paddleclas --model_name=ViT_base_patch16_384 --infer_imgs='docs/images/inference_deployment/whl_demo.jpg' --resize_short=384 --crop_size=384
```
* Python代码中
* Python 代码中
```python
from paddleclas import PaddleClas
clas = PaddleClas(model_name='ViT_base_patch16_384', resize_short=384, crop_size=384)
```
<a name="4"></a>
## 四、使用示例
## 4. 使用示例
PaddleClas提供两种使用方式：
1. Python代码中使用；
PaddleClas 提供两种使用方式：
1. Python 代码中使用；
2. 命令行中使用。
<a name="4.1"></a>
@ -119,8 +120,8 @@ paddleclas -h
```
<a name="4.2"></a>
### 4.2 使用PaddleClas提供的预训练模型进行预测
可以使用PaddleClas提供的预训练模型来预测，并通过参数`model_name`指定。此时PaddleClas会根据`model_name`自动下载指定模型，并保存在目录`~/.paddleclas/`下。
### 4.2 使用 PaddleClas 提供的预训练模型进行预测
可以使用 PaddleClas 提供的预训练模型来预测，并通过参数`model_name`指定。此时 PaddleClas 会根据`model_name`自动下载指定模型，并保存在目录`~/.paddleclas/`下。
* Python
```python
@ -156,7 +157,7 @@ paddleclas --inference_model_dir='./inference/' --infer_imgs='docs/images/infere
<a name="4.4"></a>
### 4.4 批量预测
当参数 `infer_imgs` 为包含图片文件的目录时，可以对图片进行批量预测，只需通过参数 `batch_size` 指定batch大小。
当参数 `infer_imgs` 为包含图片文件的目录时，可以对图片进行批量预测，只需通过参数 `batch_size` 指定 batch 大小。
* Python
```python
@ -193,7 +194,7 @@ paddleclas --model_name='ResNet50' --infer_imgs='https://raw.githubusercontent.c
<a name="4.6"></a>
### 4.6 对`NumPy.ndarray`格式数据进行预测
在Python中，可以对`Numpy.ndarray`格式的图像数据进行预测，只需通过参数`infer_imgs`指定即可。注意该图像数据必须为三通道图像数据。
在 Python 中，可以对`Numpy.ndarray`格式的图像数据进行预测，只需通过参数`infer_imgs`指定即可。注意该图像数据必须为三通道图像数据。
* python
```python
@ -207,7 +208,7 @@ print(next(result))
<a name="4.7"></a>
### 4.7 保存预测结果
可以指定参数`pre_label_out_dir='./output_pre_label/'`，将图片按其top1预测结果保存到`pre_label_out_dir`目录下对应类别的文件夹中。
可以指定参数`pre_label_out_dir='./output_pre_label/'`，将图片按其 top1 预测结果保存到`pre_label_out_dir`目录下对应类别的文件夹中。
* python
```python
@ -224,8 +225,8 @@ paddleclas --model_name='ResNet50' --infer_imgs='docs/images/whl/' --save_dir='.
```
<a name="4.8"></a>
### 4.8 指定label name
可以通过参数`class_id_map_file`指定`class id`与`lable`的对应关系。PaddleClas默认使用ImageNet1K的label_name（`ppcls/utils/imagenet1k_label_list.txt`）。
### 4.8 指定 label name
可以通过参数`class_id_map_file`指定`class id`与`lable`的对应关系。PaddleClas 默认使用 ImageNet1K 的 label_name（`ppcls/utils/imagenet1k_label_list.txt`）。
`class_id_map_file`文件内容格式应为：

19
docs/zh_CN/installation/install_paddle.md
View File

@ -1,9 +1,17 @@
# 安装 PaddlePaddle
---
## 目录
- [1. 环境要求](#1)
- [2.（建议）使用 Docker 环境](#2)
- [3. 通过 pip 安装 PaddlePaddle](#3)
- [4. 验证安装](#4)
目前， **PaddleClas** 要求 **PaddlePaddle** 版本 `>=2.0`。建议使用我们提供的 Docker 运行 PaddleClas，有关 Docker、nvidia-docker 的相关使用教程可以参考[链接](https://www.runoob.com/Docker/Docker-tutorial.html)。如果不使用 Docker，可以直接跳过 [2.（建议）使用 Docker 环境](#2) 部分内容，从 [3. 通过 pip 安装 PaddlePaddle](#3) 部分开始。
<a name='1'></a>
## 1. 环境要求
**版本要求**：
@ -33,17 +41,17 @@ cd /home/Projects
下述命令会创建一个名为 ppcls 的 Docker 容器，并将当前工作目录映射到容器内的 `/paddle` 目录。
```shell
# 对于GPU用户
# 对于 GPU 用户
sudo nvidia-docker run --name ppcls -v $PWD:/paddle --shm-size=8G --network=host -it paddlepaddle/paddle:2.1.0-gpu-cuda10.2-cudnn7 /bin/bash
# 对于CPU用户
# 对于 CPU 用户
sudo docker run --name ppcls -v $PWD:/paddle --shm-size=8G --network=host -it paddlepaddle/paddle:2.1.0 /bin/bash
```
**注意**：
* 首次使用该镜像时，下述命令会自动下载该镜像文件，下载需要一定的时间，请耐心等待；
* 上述命令会创建一个名为 ppcls 的 Docker 容器，之后再次使用该容器时无需再次运行该命令；
* 参数 `--shm-size=8G` 将设置容器的共享内存为8G，如机器环境允许，建议将该参数设置较大，如 `64G`；
* 参数 `--shm-size=8G` 将设置容器的共享内存为 8 G，如机器环境允许，建议将该参数设置较大，如 `64G`；
* 您也可以访问 [DockerHub](https://hub.Docker.com/r/paddlepaddle/paddle/tags/) 获取与您机器适配的镜像；
* 退出/进入 docker 容器：
* 在进入 Docker 容器后，可使用组合键 `Ctrl + P + Q` 退出当前容器，同时不关闭该容器；
@ -60,10 +68,10 @@ sudo docker run --name ppcls -v $PWD:/paddle --shm-size=8G --network=host -it pa
可运行下面的命令，通过 pip 安装最新版本 PaddlePaddle：
```bash
# 对于CPU用户
# 对于 CPU 用户
pip3 install paddlepaddle --upgrade -i https://mirror.baidu.com/pypi/simple
# 对于GPU用户
# 对于 GPU 用户
pip3 install paddlepaddle-gpu --upgrade -i https://mirror.baidu.com/pypi/simple
```
@ -71,6 +79,7 @@ pip3 install paddlepaddle-gpu --upgrade -i https://mirror.baidu.com/pypi/simple
* 如果先安装了 CPU 版本的 PaddlePaddle，之后想切换到 GPU 版本，那么需要使用 pip 先卸载 CPU 版本的 PaddlePaddle，再安装 GPU 版本的 PaddlePaddle，否则容易导致 PaddlePaddle 冲突。
* 您也可以从源码编译安装 PaddlePaddle，请参照 [PaddlePaddle 安装文档](http://www.paddlepaddle.org.cn/install/quick) 中的说明进行操作。
<a name='4'></a>
## 4. 验证安装
使用以下命令可以验证 PaddlePaddle 是否安装成功。

7
docs/zh_CN/installation/install_paddleclas.md
View File

@ -1,6 +1,12 @@
# 安装 PaddleClas
---
## 目录
* [1. 克隆 PaddleClas](#1)
* [2. 安装 Python 依赖库](#2)
<a name='1'></a>
## 1. 克隆 PaddleClas
@ -15,6 +21,7 @@ git clone https://github.com/PaddlePaddle/PaddleClas.git -b release/2.3
```shell
git clone https://gitee.com/paddlepaddle/PaddleClas.git -b release/2.3
```
<a name='2'></a>
## 2. 安装 Python 依赖库

4
docs/zh_CN/introduction/function_intro.md
View File

@ -4,7 +4,7 @@
- 实用的图像识别系统：集成了目标检测、特征学习、图像检索等模块，广泛适用于各类图像识别任务。
提供商品识别、车辆识别、 logo 识别和动漫人物识别等4个场景应用示例。
提供商品识别、车辆识别、 logo 识别和动漫人物识别等 4 个场景应用示例。
- 丰富的预训练模型库：提供了 36 个系列共 175 个 ImageNet 预训练模型，其中 7 个精选系列模型支持结构快速修改。
@ -19,4 +19,4 @@
<img src="../../images/recognition.gif" width = "400" />
</div>
更多关于图像识别快速体验、算法详解、模型训练评估与预测部署方法，请参考[首页README文档教程](../../../README_ch.md)。
更多关于图像识别快速体验、算法详解、模型训练评估与预测部署方法，请参考[首页 README文档教程](../../../README_ch.md)。

15
docs/zh_CN/models/DLA.md
View File

@ -1,11 +1,18 @@
# DLA系列
----
## 目录
* [1. 概述](#1)
* [2. 精度、FLOPS和参数量](#2)
## 概述
<a name='1'></a>
## 1. 概述
DLA (Deep Layer Aggregation)。 视觉识别需要丰富的表示形式，其范围从低到高，范围从小到大，分辨率从精细到粗糙。即使卷积网络中的要素深度很深，仅靠隔离层还是不够的：将这些表示法进行复合和聚合可改善对内容和位置的推断。尽管已合并了残差连接以组合各层，但是这些连接本身是“浅”的，并且只能通过简单的一步操作来融合。作者通过更深层的聚合来增强标准体系结构，以更好地融合各层的信息。Deep Layer Aggregation 结构迭代地和分层地合并了特征层次结构，以使网络具有更高的准确性和更少的参数。跨体系结构和任务的实验表明，与现有的分支和合并方案相比，Deep Layer Aggregation 可提高识别和分辨率。[论文地址](https://arxiv.org/abs/1707.06484)。
<a name='2'></a>
## 精度、FLOPS和参数量
## 2. 精度、FLOPS和参数量
| Model | Params (M) | FLOPs (G) | Top-1 (%) | Top-5 (%) |
|:-----------------:|:----------:|:---------:|:---------:|:---------:|
@ -14,8 +21,8 @@ DLA (Deep Layer Aggregation)。 视觉识别需要丰富的表示形式，其范
| DLA46x_c | 1.1 | 0.5 | 64.36 | 86.01 |
| DLA60 | 22.0 | 4.2 | 76.10 | 92.92 |
| DLA60x | 17.4 | 3.5 | 77.53 | 93.78 |
| DLA60x_c | 1.3 | 0.6 | 66.45 | 87.54 |
| DLA60x_c | 1.3 | 0.6 | 66.45 | 87.54 |
| DLA102 | 33.3 | 7.2 | 78.93 | 94.52 |
| DLA102x | 26.4 | 5.9 | 78.10 | 94.00 |
| DLA102x2 | 41.4 | 9.3 | 78.85 | 94.45 |
| DLA169 | 53.5 | 11.6 | 78.09 | 94.09 |
| DLA169 | 53.5 | 11.6 | 78.09 | 94.09 |

34
docs/zh_CN/models/DPN_DenseNet.md
View File

@ -1,10 +1,19 @@
# DPN与DenseNet系列
# DPN 与 DenseNet 系列
---
## 目录
## 概述
DenseNet是2017年CVPR best paper提出的一种新的网络结构，该网络设计了一种新的跨层连接的block，即dense-block。相比ResNet中的bottleneck，dense-block设计了一个更激进的密集连接机制，即互相连接所有的层，每个层都会接受其前面所有层作为其额外的输入。DenseNet将所有的dense-block堆叠，组合成了一个密集连接型网络。密集的连接方式使得DenseNe更容易进行梯度的反向传播，使得网络更容易训练。
DPN的全称是Dual Path Networks，即双通道网络。该网络是由DenseNet和ResNeXt结合的一个网络，其证明了DenseNet能从靠前的层级中提取到新的特征，而ResNeXt本质上是对之前层级中已提取特征的复用。作者进一步分析发现，ResNeXt对特征有高复用率，但冗余度低，DenseNet能创造新特征，但冗余度高。结合二者结构的优势，作者设计了DPN网络。最终DPN网络在同样FLOPS和参数量下，取得了比ResNeXt与DenseNet更好的结果。
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 V100 GPU 的预测速度](#3)
* [4. 基于 T4 GPU 的预测速度](#4)
该系列模型的FLOPS、参数量以及T4 GPU上的预测耗时如下图所示。
<a name='1'></a>
## 1. 概述
DenseNet 是 2017 年 CVPR best paper 提出的一种新的网络结构，该网络设计了一种新的跨层连接的 block，即 dense-block。相比 ResNet 中的 bottleneck，dense-block 设计了一个更激进的密集连接机制，即互相连接所有的层，每个层都会接受其前面所有层作为其额外的输入。DenseNet 将所有的 dense-block 堆叠，组合成了一个密集连接型网络。密集的连接方式使得 DenseNe 更容易进行梯度的反向传播，使得网络更容易训练。
DPN 的全称是 Dual Path Networks，即双通道网络。该网络是由 DenseNet 和 ResNeXt 结合的一个网络，其证明了 DenseNet 能从靠前的层级中提取到新的特征，而 ResNeXt 本质上是对之前层级中已提取特征的复用。作者进一步分析发现，ResNeXt 对特征有高复用率，但冗余度低，DenseNet 能创造新特征，但冗余度高。结合二者结构的优势，作者设计了 DPN 网络。最终 DPN 网络在同样 FLOPS 和参数量下，取得了比 ResNeXt 与 DenseNet 更好的结果。
该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
![](../../images/models/T4_benchmark/t4.fp32.bs4.DPN.flops.png)
@ -14,11 +23,12 @@ DPN的全称是Dual Path Networks，即双通道网络。该网络是由DenseNet
![](../../images/models/T4_benchmark/t4.fp16.bs4.DPN.png)
目前PaddleClas开源的这两类模型的预训练模型一共有10个，其指标如上图所示，可以看到，在相同的FLOPS和参数量下，相比DenseNet，DPN拥有更高的精度。但是由于DPN有更多的分支，所以其推理速度要慢于DenseNet。由于DenseNet264的网络层数最深，所以该网络是DenseNet系列模型中参数量最大的网络，DenseNet161的网络的宽度最大，导致其是该系列中网络中计算量最大、精度最高的网络。从推理速度来看，计算量大且精度高的的DenseNet161比DenseNet264具有更快的速度，所以其比DenseNet264具有更大的优势。
目前 PaddleClas 开源的这两类模型的预训练模型一共有 10 个，其指标如上图所示，可以看到，在相同的 FLOPS 和参数量下，相比 DenseNet，DPN 拥有更高的精度。但是由于 DPN 有更多的分支，所以其推理速度要慢于 DenseNet。由于 DenseNet264 的网络层数最深，所以该网络是 DenseNet 系列模型中参数量最大的网络，DenseNet161 的网络的宽度最大，导致其是该系列中网络中计算量最大、精度最高的网络。从推理速度来看，计算量大且精度高的的 DenseNet161 比 DenseNet264 具有更快的速度，所以其比 DenseNet264 具有更大的优势。
对于DPN系列网络，模型的FLOPS和参数量越大，模型的精度越高。其中，由于DPN107的网络宽度最大，所以其是该系列网络中参数量与计算量最大的网络。
对于 DPN 系列网络，模型的 FLOPS 和参数量越大，模型的精度越高。其中，由于 DPN107 的网络宽度最大，所以其是该系列网络中参数量与计算量最大的网络。
## 精度、FLOPS和参数量
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -35,8 +45,8 @@ DPN的全称是Dual Path Networks，即双通道网络。该网络是由DenseNet
## 基于V100 GPU的预测速度
<a name='3'></a>
## 3. 基于 V100 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP32<br>Batch Size=1<br>(ms) |
|-------------|-----------|-------------------|--------------------------|
@ -52,8 +62,8 @@ DPN的全称是Dual Path Networks，即双通道网络。该网络是由DenseNet
| DPN131 | 224 | 256 | 28.083 |
## 基于T4 GPU的预测速度
<a name='4'></a>
## 4. 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|-------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

17
docs/zh_CN/models/ESNet.md
View File

@ -1,10 +1,19 @@
# ESNet系列
---
## 目录
## 概述
* [1. 概述](#)
* [2. 精度、FLOPs和参数量](#FLOPs)
ESNet(Enhanced ShuffleNet)是百度自研的一个轻量级网络，该网络在ShuffleNetV2的基础上融合了MobileNetV3、GhostNet、PPLCNet的优点，组合成了一个在ARM设备上速度更快、精度更高的网络，由于其出色的表现，所以在PaddleDetection推出的[PP-PicoDet](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.3/configs/picodet)使用了该模型做backbone，配合更强的目标检测算法，最终的指标一举刷新了目标检测模型在ARM设备上的SOTA指标。
<a name='1'></a>
## 精度、FLOPs和参数量
## 1. 概述
ESNet(Enhanced ShuffleNet)是百度自研的一个轻量级网络，该网络在 ShuffleNetV2 的基础上融合了 MobileNetV3、GhostNet、PPLCNet 的优点，组合成了一个在 ARM 设备上速度更快、精度更高的网络，由于其出色的表现，所以在 PaddleDetection 推出的 [PP-PicoDet](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.3/configs/picodet) 使用了该模型做 backbone，配合更强的目标检测算法，最终的指标一举刷新了目标检测模型在 ARM 设备上的 SOTA 指标。
<a name='2'></a>
## 2.精度、FLOPs和参数量
| Models | Top1 | Top5 | FLOPs<br>(M) | Params<br/>(M) |
|:--:|:--:|:--:|:--:|:--:|
@ -13,4 +22,4 @@ ESNet(Enhanced ShuffleNet)是百度自研的一个轻量级网络，该网络在
| ESNet_x0_75 | 72.24 | 90.45 | 123.7 | 3.87 |
| ESNet_x1_0 | 73.92 | 91.40 | 197.3 | 4.64 |
关于Inference speed等信息，敬请期待。
关于 Inference speed 等信息，敬请期待。

29
docs/zh_CN/models/EfficientNet_and_ResNeXt101_wsl.md
View File

@ -1,12 +1,20 @@
# EfficientNet与ResNeXt101_wsl系列
# EfficientNet 与 ResNeXt101_wsl系列
-----
## 目录
## 概述
EfficientNet是Google于2019年发布的一个基于NAS的轻量级网络，其中EfficientNetB7刷新了当时ImageNet-1k的分类准确率。在该文章中，作者指出，传统的提升神经网络性能的方法主要是从网络的宽度、网络的深度、以及输入图片的分辨率入手，但是作者通过实验发现，平衡这三个维度对精度和效率的提升至关重要，于是，作者通过一系列的实验中总结出了如何同时平衡这三个维度的放缩，与此同时，基于这种放缩方法，作者在EfficientNet_B0的基础上，构建了EfficientNet系列中B1-B7共7个网络，并在同样FLOPS与参数量的情况下，精度达到了state-of-the-art的效果。
* [1. 概述](#1)
* [2. 精度、FLOPS和参数量](#2)
* [3. 基于 V100 GPU的预测速度](#3)
* [4. 基于 T4 GPU的预测速度](#4)
ResNeXt是facebook于2016年提出的一种对ResNet的改进版网络。在2019年，facebook通过弱监督学习研究了该系列网络在ImageNet上的精度上限，为了区别之前的ResNeXt网络，该系列网络的后缀为wsl，其中wsl是弱监督学习（weakly-supervised-learning）的简称。为了能有更强的特征提取能力，研究者将其网络宽度进一步放大，其中最大的ResNeXt101_32x48d_wsl拥有8亿个参数，将其在9.4亿的弱标签图片下训练并在ImageNet-1k上做finetune，最终在ImageNet-1k的top-1达到了85.4%，这也是迄今为止在ImageNet-1k的数据集上以224x224的分辨率下精度最高的网络。Fix-ResNeXt中，作者使用了更大的图像分辨率，针对训练图片和验证图片数据预处理不一致的情况下做了专门的Fix策略，并使得ResNeXt101_32x48d_wsl拥有了更高的精度，由于其用到了Fix策略，故命名为Fix-ResNeXt101_32x48d_wsl。
<a name='1'></a>
## 1. 概述
EfficientNet 是 Google 于 2019 年发布的一个基于 NAS 的轻量级网络，其中 EfficientNetB7 刷新了当时 ImageNet-1k 的分类准确率。在该文章中，作者指出，传统的提升神经网络性能的方法主要是从网络的宽度、网络的深度、以及输入图片的分辨率入手，但是作者通过实验发现，平衡这三个维度对精度和效率的提升至关重要，于是，作者通过一系列的实验中总结出了如何同时平衡这三个维度的放缩，与此同时，基于这种放缩方法，作者在 EfficientNet_B0 的基础上，构建了 EfficientNet 系列中 B1-B7 共 7 个网络，并在同样 FLOPS 与参数量的情况下，精度达到了 state-of-the-art 的效果。
ResNeXt 是 facebook 于 2016 年提出的一种对 ResNet 的改进版网络。在 2019 年，facebook 通过弱监督学习研究了该系列网络在 ImageNet 上的精度上限，为了区别之前的 ResNeXt 网络，该系列网络的后缀为 wsl，其中 wsl 是弱监督学习（weakly-supervised-learning）的简称。为了能有更强的特征提取能力，研究者将其网络宽度进一步放大，其中最大的 ResNeXt101_32x48d_wsl 拥有 8 亿个参数，将其在 9.4 亿的弱标签图片下训练并在 ImageNet-1k 上做 finetune，最终在 ImageNet-1k 的 top-1 达到了 85.4%，这也是迄今为止在 ImageNet-1k 的数据集上以 224x224 的分辨率下精度最高的网络。Fix-ResNeXt 中，作者使用了更大的图像分辨率，针对训练图片和验证图片数据预处理不一致的情况下做了专门的 Fix 策略，并使得 ResNeXt101_32x48d_wsl 拥有了更高的精度，由于其用到了 Fix 策略，故命名为 Fix-ResNeXt101_32x48d_wsl。
该系列模型的FLOPS、参数量以及T4 GPU上的预测耗时如下图所示。
该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
![](../../images/models/T4_benchmark/t4.fp32.bs4.EfficientNet.flops.png)
@ -16,9 +24,10 @@ ResNeXt是facebook于2016年提出的一种对ResNet的改进版网络。在2019
![](../../images/models/T4_benchmark/t4.fp16.bs1.EfficientNet.png)
目前PaddleClas开源的这两类模型的预训练模型一共有14个。从上图中可以看出EfficientNet系列网络优势非常明显，ResNeXt101_wsl系列模型由于用到了更多的数据，最终的精度也更高。EfficientNet_B0_Small是去掉了SE_block的EfficientNet_B0，其具有更快的推理速度。
目前 PaddleClas 开源的这两类模型的预训练模型一共有 14 个。从上图中可以看出 EfficientNet 系列网络优势非常明显，ResNeXt101_wsl 系列模型由于用到了更多的数据，最终的精度也更高。EfficientNet_B0_Small 是去掉了 SE_block 的 EfficientNet_B0，其具有更快的推理速度。
## 精度、FLOPS和参数量
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -37,8 +46,9 @@ ResNeXt是facebook于2016年提出的一种对ResNet的改进版网络。在2019
| EfficientNetB7 | 0.843 | 0.969 | 0.844 | 0.971 | 72.350 | 64.920 |
| EfficientNetB0_<br>small | 0.758 | 0.926 | | | 0.720 | 4.650 |
<a name='3'></a>
## 基于V100 GPU的预测速度
## 3. 基于 V100 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP32<br>Batch Size=1<br>(ms) |
|-------------------------------|-----------|-------------------|--------------------------|
@ -58,8 +68,9 @@ ResNeXt是facebook于2016年提出的一种对ResNet的改进版网络。在2019
| EfficientNetB0_<br>small | 224 | 256 | 1.692 |
<a name='4'></a>
## 基于T4 GPU的预测速度
## 4. 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|---------------------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

31
docs/zh_CN/models/HRNet.md
View File

@ -1,9 +1,18 @@
# HRNet系列
# HRNet 系列
-----
## 目录
## 概述
HRNet是2019年由微软亚洲研究院提出的一种全新的神经网络，不同于以往的卷积神经网络，该网络在网络深层仍然可以保持高分辨率，因此预测的关键点热图更准确，在空间上也更精确。此外，该网络在对分辨率敏感的其他视觉任务中，如检测、分割等，表现尤为优异。
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 V100 GPU 的预测速度](#3)
* [4. 基于 T4 GPU 的预测速度](#4)
该系列模型的FLOPS、参数量以及T4 GPU上的预测耗时如下图所示。
<a name='1'></a>
## 1. 概述
HRNet 是 2019 年由微软亚洲研究院提出的一种全新的神经网络，不同于以往的卷积神经网络，该网络在网络深层仍然可以保持高分辨率，因此预测的关键点热图更准确，在空间上也更精确。此外，该网络在对分辨率敏感的其他视觉任务中，如检测、分割等，表现尤为优异。
该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
![](../../images/models/T4_benchmark/t4.fp32.bs4.HRNet.flops.png)
@ -13,10 +22,10 @@ HRNet是2019年由微软亚洲研究院提出的一种全新的神经网络，
![](../../images/models/T4_benchmark/t4.fp16.bs4.HRNet.png)
目前PaddleClas开源的这类模型的预训练模型一共有7个，其指标如图所示，其中HRNet_W48_C指标精度异常的原因可能是因为网络训练的正常波动。
目前 PaddleClas 开源的这类模型的预训练模型一共有 7 个，其指标如图所示，其中 HRNet_W48_C 指标精度异常的原因可能是因为网络训练的正常波动。
## 精度、FLOPS和参数量
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -31,8 +40,8 @@ HRNet是2019年由微软亚洲研究院提出的一种全新的神经网络，
| HRNet_W64_C | 0.793 | 0.946 | 0.795 | 0.946 | 57.830 | 128.060 |
| SE_HRNet_W64_C_ssld | 0.847 | 0.973 | | | 57.830 | 128.970 |
## 基于V100 GPU的预测速度
<a name='3'></a>
## 3. 基于 V100 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP32<br>Batch Size=1<br>(ms) |
|-------------|-----------|-------------------|--------------------------|
@ -47,8 +56,8 @@ HRNet是2019年由微软亚洲研究院提出的一种全新的神经网络，
| HRNet_W64_C | 224 | 256 | 15.003 |
## 基于T4 GPU的预测速度
<a name='4'></a>
## 4. 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|-------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

14
docs/zh_CN/models/HarDNet.md
View File

@ -1,10 +1,18 @@
# HarDNet系列
---
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
HarDNet（Harmonic DenseNet）是 2019 年由国立清华大学提出的一种全新的神经网络，在低 MAC 和内存流量的条件下实现了高效率。与 FC-DenseNet-103，DenseNet-264，ResNet-50，ResNet-152 和SSD-VGG 相比，新网络的推理时间减少了 35%，36%，30%，32% 和 45%。我们使用了包括Nvidia Profiler 和 ARM Scale-Sim 在内的工具来测量内存流量，并验证推理延迟确实与内存流量消耗成正比，并且所提议的网络消耗的内存流量很低。[论文地址](https://arxiv.org/abs/1909.00948)。
<a name='1'></a>
## 1. 概述
## 精度、FLOPS和参数量
HarDNet（Harmonic DenseNet）是 2019 年由国立清华大学提出的一种全新的神经网络，在低 MAC 和内存流量的条件下实现了高效率。与 FC-DenseNet-103，DenseNet-264，ResNet-50，ResNet-152 和 SSD-VGG 相比，新网络的推理时间减少了 35%，36%，30%，32% 和 45%。我们使用了包括 Nvidia Profiler 和 ARM Scale-Sim 在内的工具来测量内存流量，并验证推理延迟确实与内存流量消耗成正比，并且所提议的网络消耗的内存流量很低。[论文地址](https://arxiv.org/abs/1909.00948)。
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Model | Params (M) | FLOPs (G) | Top-1 (%) | Top-5 (%) |
|:---------------------:|:----------:|:---------:|:---------:|:---------:|

34
docs/zh_CN/models/Inception.md
View File

@ -1,17 +1,26 @@
# Inception系列
# Inception 系列
-----
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 V100 GPU 的预测速度](#3)
* [4. 基于 T4 GPU 的预测速度](#4)
GoogLeNet是2014年由Google设计的一种新的神经网络结构，其与VGG网络并列成为当年ImageNet挑战赛的双雄。GoogLeNet首次引入Inception结构，在网络中堆叠该结构使得网络层数达到了22层，这也是卷积网络首次超过20层的标志。由于在Inception结构中使用了1x1的卷积用于通道数降维，并且使用了Global-pooling代替传统的多fc层加工特征的方式，最终的GoogLeNet网络的FLOPS和参数量远小于VGG网络，成为当时神经网络设计的一道亮丽风景线。
<a name='1'></a>
InceptionV3是Google 对InceptionV2的一种改进。首先，InceptionV3 对 Inception模块进行了优化，同时设计和使用了更多种类的Inception模块，与此同时，InceptionV3中的部分Inception模块将较大的方形二维卷积拆成两个较小的非对称卷积，这样可以大幅度节省参数量。
## 1. 概述
Xception 是 Google 继 Inception 后提出的对 InceptionV3 的另一种改进。在Xception中，作者使用了深度可分离卷积代替了传统的卷积操作，该操作大大节省了网络的FLOPS和参数量，但是精度反而有所提升。在DeeplabV3+中，作者将Xception做了进一步的改进，同时增加了Xception的层数，设计出了Xception65和Xception71的网络。
GoogLeNet 是 2014 年由 Google 设计的一种新的神经网络结构，其与 VGG 网络并列成为当年 ImageNet 挑战赛的双雄。GoogLeNet 首次引入 Inception 结构，在网络中堆叠该结构使得网络层数达到了 22 层，这也是卷积网络首次超过 20 层的标志。由于在 Inception 结构中使用了 1x1 的卷积用于通道数降维，并且使用了 Global-pooling 代替传统的多 fc 层加工特征的方式，最终的 GoogLeNet 网络的 FLOPS 和参数量远小于 VGG 网络，成为当时神经网络设计的一道亮丽风景线。
InceptionV4是2016年由Google设计的新的神经网络，当时残差结构风靡一时，但是作者认为仅使用Inception 结构也可以达到很高的性能。InceptionV4使用了更多的Inception module，在ImageNet上的精度再创新高。
InceptionV3 是 Google 对 InceptionV2 的一种改进。首先，InceptionV3 对 Inception 模块进行了优化，同时设计和使用了更多种类的 Inception 模块，与此同时，InceptionV3 中的部分 Inception 模块将较大的方形二维卷积拆成两个较小的非对称卷积，这样可以大幅度节省参数量。
Xception 是 Google 继 Inception 后提出的对 InceptionV3 的另一种改进。在 Xception 中，作者使用了深度可分离卷积代替了传统的卷积操作，该操作大大节省了网络的 FLOPS 和参数量，但是精度反而有所提升。在 DeeplabV3+ 中，作者将 Xception 做了进一步的改进，同时增加了 Xception 的层数，设计出了 Xception65 和 Xception71 的网络。
InceptionV4 是 2016 年由 Google 设计的新的神经网络，当时残差结构风靡一时，但是作者认为仅使用 Inception 结构也可以达到很高的性能。InceptionV4 使用了更多的 Inception module，在 ImageNet 上的精度再创新高。
该系列模型的FLOPS、参数量以及T4 GPU上的预测耗时如下图所示。
该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
![](../../images/models/T4_benchmark/t4.fp32.bs4.Inception.flops.png)
@ -21,11 +30,12 @@ InceptionV4是2016年由Google设计的新的神经网络，当时残差结构
![](../../images/models/T4_benchmark/t4.fp16.bs4.Inception.png)
上图反映了Xception系列和InceptionV4的精度和其他指标的关系。其中Xception_deeplab与论文结构保持一致，Xception是PaddleClas的改进模型，在预测速度基本不变的情况下，精度提升约0.6%。关于该改进模型的详细介绍正在持续更新中，敬请期待。
上图反映了 Xception 系列和 InceptionV4 的精度和其他指标的关系。其中 Xception_deeplab 与论文结构保持一致，Xception 是 PaddleClas 的改进模型，在预测速度基本不变的情况下，精度提升约 0.6%。关于该改进模型的详细介绍正在持续更新中，敬请期待。
<a name='2'></a>
## 精度、FLOPS和参数量
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -39,8 +49,9 @@ InceptionV4是2016年由Google设计的新的神经网络，当时残差结构
| InceptionV4 | 0.808 | 0.953 | 0.800 | 0.950 | 24.570 | 42.680 |
<a name='3'></a>
## 基于V100 GPU的预测速度
## 3. 基于 V100 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP32<br>Batch Size=1<br>(ms) |
|------------------------|-----------|-------------------|--------------------------|
@ -53,8 +64,9 @@ InceptionV4是2016年由Google设计的新的神经网络，当时残差结构
| InceptionV4 | 299 | 320 | 11.141 |
<a name='4'></a>
## 基于T4 GPU的预测速度
## 4. 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|--------------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

18
docs/zh_CN/models/LeViT.md
View File

@ -1,9 +1,19 @@
# LeViT
## 概述
LeViT是一种快速推理的、用于图像分类任务的混合神经网络。其设计之初考虑了网络模型在不同的硬件平台上的性能，因此能够更好地反映普遍应用的真实场景。通过大量实验，作者找到了卷积神经网络与Transformer体系更好的结合方式，并且提出了attention-based方法，用于整合Transformer中的位置信息编码。[论文地址](https://arxiv.org/abs/2104.01136)。
---
## 目录
## 精度、FLOPS和参数量
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
<a name='1'></a>
## 1. 概述
LeViT 是一种快速推理的、用于图像分类任务的混合神经网络。其设计之初考虑了网络模型在不同的硬件平台上的性能，因此能够更好地反映普遍应用的真实场景。通过大量实验，作者找到了卷积神经网络与 Transformer 体系更好的结合方式，并且提出了 attention-based 方法，用于整合 Transformer 中的位置信息编码。[论文地址](https://arxiv.org/abs/2104.01136)。
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(M) | Params<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -14,4 +24,4 @@ LeViT是一种快速推理的、用于图像分类任务的混合神经网络。
| LeViT-384 | 0.8191 | 0.9551 | 0.826 | 0.960 | 2353 | 39 |
**注**：与Reference的精度差异源于数据预处理不同及未使用蒸馏的head作为输出。
**注**：与 Reference 的精度差异源于数据预处理不同及未使用蒸馏的 head 作为输出。

12
docs/zh_CN/models/MixNet.md
View File

@ -1,6 +1,13 @@
# MixNet系列
---
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
<a name='1'></a>
## 1. 概述
MixNet是谷歌出的一篇关于轻量级网络的文章，主要工作就在于探索不同大小的卷积核的组合。作者发现目前网络有以下两个问题：
@ -9,8 +16,9 @@ MixNet是谷歌出的一篇关于轻量级网络的文章，主要工作就在
为了解决上面两个问题，文中提出一种新的混合深度分离卷积(MDConv)(mixed depthwise convolution)，将不同的核大小混合在一个卷积运算中，并且基于AutoML的搜索空间，提出了一系列的网络叫做MixNets，在ImageNet上取得了较好的效果。[论文地址](https://arxiv.org/pdf/1907.09595.pdf)
<a name='2'></a>
## 精度、FLOPS和参数量
## 2. 精度、FLOPS和参数量
| Models | Top1 | Top5 | Reference<br>top1| FLOPS<br>(M) | Params<br/>(M) |
|:--:|:--:|:--:|:--:|:--:|----|

32
docs/zh_CN/models/Mobile.md
View File

@ -1,15 +1,24 @@
# 移动端系列
---
## 目录
## 概述
MobileNetV1是Google于2017年发布的用于移动设备或嵌入式设备中的网络。该网络将传统的卷积操作替换深度可分离卷积，即Depthwise卷积和Pointwise卷积的组合，相比传统的卷积操作，该组合可以大大节省参数量和计算量。与此同时，MobileNetV1也可以用于目标检测、图像分割等其他视觉任务中。
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 SD855 的预测速度和存储大小](#3)
* [4. 基于 T4 GPU 的预测速度](#4)
MobileNetV2是Google继MobileNetV1提出的一种轻量级网络。相比MobileNetV1，MobileNetV2提出了Linear bottlenecks与Inverted residual block作为网络基本结构，通过大量地堆叠这些基本模块，构成了MobileNetV2的网络结构。最终，在FLOPS只有MobileNetV1的一半的情况下取得了更高的分类精度。
<a name='1'></a>
ShuffleNet系列网络是旷视提出的轻量化网络结构，到目前为止，该系列网络一共有两种典型的结构，即ShuffleNetV1与ShuffleNetV2。ShuffleNet中的Channel Shuffle操作可以将组间的信息进行交换，并且可以实现端到端的训练。在ShuffleNetV2的论文中，作者提出了设计轻量级网络的四大准则，并且根据四大准则与ShuffleNetV1的不足，设计了ShuffleNetV2网络。
## 1. 概述
MobileNetV1 是 Google 于 2017 年发布的用于移动设备或嵌入式设备中的网络。该网络将传统的卷积操作替换深度可分离卷积，即 Depthwise 卷积和 Pointwise 卷积的组合，相比传统的卷积操作，该组合可以大大节省参数量和计算量。与此同时，MobileNetV1 也可以用于目标检测、图像分割等其他视觉任务中。
MobileNetV3是Google于2019年提出的一种基于NAS的新的轻量级网络，为了进一步提升效果，将relu和sigmoid激活函数分别替换为hard_swish与hard_sigmoid激活函数，同时引入了一些专门减小网络计算量的改进策略。
MobileNetV2 是 Google 继 MobileNetV1 提出的一种轻量级网络。相比 MobileNetV1，MobileNetV2 提出了 Linear bottlenecks 与 Inverted residual block 作为网络基本结构，通过大量地堆叠这些基本模块，构成了 MobileNetV2 的网络结构。最终，在 FLOPS 只有 MobileNetV1 的一半的情况下取得了更高的分类精度。
GhostNet是华为于2020年提出的一种全新的轻量化网络结构，通过引入ghost module，大大减缓了传统深度网络中特征的冗余计算问题，使得网络的参数量和计算量大大降低。
ShuffleNet系列网络是旷视提出的轻量化网络结构，到目前为止，该系列网络一共有两种典型的结构，即 ShuffleNetV1 与 ShuffleNetV2。ShuffleNet 中的 Channel Shuffle 操作可以将组间的信息进行交换，并且可以实现端到端的训练。在 ShuffleNetV2 的论文中，作者提出了设计轻量级网络的四大准则，并且根据四大准则与 ShuffleNetV1 的不足，设计了 ShuffleNetV2 网络。
MobileNetV3 是 Google 于 2019 年提出的一种基于 NAS 的新的轻量级网络，为了进一步提升效果，将 relu 和 sigmoid 激活函数分别替换为 hard_swish 与 hard_sigmoid 激活函数，同时引入了一些专门减小网络计算量的改进策略。
GhostNet 是华为于 2020 年提出的一种全新的轻量化网络结构，通过引入 ghost module，大大减缓了传统深度网络中特征的冗余计算问题，使得网络的参数量和计算量大大降低。
![](../../images/models/mobile_arm_top1.png)
@ -20,10 +29,11 @@ GhostNet是华为于2020年提出的一种全新的轻量化网络结构，通
![](../../images/models/T4_benchmark/t4.fp32.bs4.mobile_trt.params.png)
目前PaddleClas开源的的移动端系列的预训练模型一共有35个，其指标如图所示。从图片可以看出，越新的轻量级模型往往有更优的表现，MobileNetV3代表了目前主流的轻量级神经网络结构。在MobileNetV3中，作者为了获得更高的精度，在global-avg-pooling后使用了1x1的卷积。该操作大幅提升了参数量但对计算量影响不大，所以如果从存储角度评价模型的优异程度，MobileNetV3优势不是很大，但由于其更小的计算量，使得其有更快的推理速度。此外，我们模型库中的ssld蒸馏模型表现优异，从各个考量角度下，都刷新了当前轻量级模型的精度。由于MobileNetV3模型结构复杂，分支较多，对GPU并不友好，GPU预测速度不如MobileNetV1。GhostNet于2020年提出，通过引入ghost的网络设计理念，大大降低了计算量和参数量，同时在精度上也超过前期最高的MobileNetV3网络结构。
目前 PaddleClas 开源的的移动端系列的预训练模型一共有 35 个，其指标如图所示。从图片可以看出，越新的轻量级模型往往有更优的表现，MobileNetV3代表了目前主流的轻量级神经网络结构。在 MobileNetV3 中，作者为了获得更高的精度，在 global-avg-pooling 后使用了 1x1 的卷积。该操作大幅提升了参数量但对计算量影响不大，所以如果从存储角度评价模型的优异程度，MobileNetV3优势不是很大，但由于其更小的计算量，使得其有更快的推理速度。此外，我们模型库中的 ssld 蒸馏模型表现优异，从各个考量角度下，都刷新了当前轻量级模型的精度。由于 MobileNetV3 模型结构复杂，分支较多，对 GPU 并不友好，GPU 预测速度不如 MobileNetV1。GhostNet 于 2020 年提出，通过引入 ghost 的网络设计理念，大大降低了计算量和参数量，同时在精度上也超过前期最高的 MobileNetV3 网络结构。
<a name='2'></a>
## 精度、FLOPS和参数量
## 2. 精度、FLOPS和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -65,8 +75,9 @@ GhostNet是华为于2020年提出的一种全新的轻量化网络结构，通
| GhostNet_x1_3 | 0.757 | 0.925 | 0.757 | 0.927 | 0.440 | 7.300 |
| GhostNet_x1_3_ssld | 0.794 | 0.945 | 0.757 | 0.927 | 0.440 | 7.300 |
<a name='3'></a>
## 基于SD855的预测速度和存储大小
## 3. 基于 SD855 的预测速度和存储大小
| Models | Batch Size=1(ms) | Storage Size(M) |
|:--:|:--:|:--:|
@ -108,8 +119,9 @@ GhostNet是华为于2020年提出的一种全新的轻量化网络结构，通
| GhostNet_x1_3 | 19.982 | 29.000 |
| GhostNet_x1_3_ssld | 19.982 | 29.000 |
<a name='4'></a>
## 基于T4 GPU的预测速度
## 4. 基于 T4 GPU 的预测速度
| Models | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|-----------------------------|-----------------------|-----------------------|-----------------------|-----------------------|-----------------------|-----------------------|

29
docs/zh_CN/models/Others.md
View File

@ -1,16 +1,25 @@
# 其他模型
-----
## 目录
## 概述
2012年，Alex等人提出的AlexNet网络在ImageNet大赛上以远超第二名的成绩夺冠，卷积神经网络乃至深度学习引起了广泛的关注。AlexNet使用relu作为CNN的激活函数，解决了sigmoid在网络较深时的梯度弥散问题。训练时使用Dropout随机丢掉一部分神经元，避免了模型过拟合。网络中使用重叠的最大池化代替了此前CNN中普遍使用的平均池化，避免了平均池化的模糊效果，提升了特征的丰富性。从某种意义上说，AlexNet引爆了神经网络的研究与应用热潮。
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 V100 GPU 的预测速度](#3)
* [4. 基于 T4 GPU 的预测速度](#4)
SqueezeNet在ImageNet-1k上实现了与AlexNet相同的精度，但只用了1/50的参数量。该网络的核心是Fire模块，Fire模块通过使用1x1的卷积实现通道降维，从而大大节省了参数量。作者通过大量堆叠Fire模块组成了SqueezeNet。
<a name='1'></a>
VGG由牛津大学计算机视觉组和DeepMind公司研究员一起研发的卷积神经网络。该网络探索了卷积神经网络的深度和其性能之间的关系，通过反复的堆叠3x3的小型卷积核和2x2的最大池化层，成功的构建了多层卷积神经网络并取得了不错的收敛精度。最终，VGG获得了ILSVRC 2014比赛分类项目的亚军和定位项目的冠军。
## 1. 概述
2012 年，Alex 等人提出的 AlexNet 网络在 ImageNet 大赛上以远超第二名的成绩夺冠，卷积神经网络乃至深度学习引起了广泛的关注。AlexNet 使用 relu 作为 CNN 的激活函数，解决了 sigmoid 在网络较深时的梯度弥散问题。训练时使用 Dropout 随机丢掉一部分神经元，避免了模型过拟合。网络中使用重叠的最大池化代替了此前 CNN 中普遍使用的平均池化，避免了平均池化的模糊效果，提升了特征的丰富性。从某种意义上说，AlexNet 引爆了神经网络的研究与应用热潮。
DarkNet53是YOLO作者在论文设计的用于目标检测的backbone，该网络基本由1x1与3x3卷积构成，共53层，取名为DarkNet53。
SqueezeNet 在 ImageNet-1k 上实现了与 AlexNet 相同的精度，但只用了 1/50 的参数量。该网络的核心是 Fire 模块，Fire 模块通过使用 1x1 的卷积实现通道降维，从而大大节省了参数量。作者通过大量堆叠 Fire 模块组成了 SqueezeNet。
VGG 由牛津大学计算机视觉组和 DeepMind 公司研究员一起研发的卷积神经网络。该网络探索了卷积神经网络的深度和其性能之间的关系，通过反复的堆叠 3x3 的小型卷积核和 2x2 的最大池化层，成功的构建了多层卷积神经网络并取得了不错的收敛精度。最终，VGG 获得了 ILSVRC 2014 比赛分类项目的亚军和定位项目的冠军。
## 精度、FLOPS和参数量
DarkNet53 是 YOLO 作者在论文设计的用于目标检测的 backbone，该网络基本由 1x1 与 3x3 卷积构成，共 53 层，取名为 DarkNet53。
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -24,8 +33,8 @@ DarkNet53是YOLO作者在论文设计的用于目标检测的backbone，该网
| DarkNet53 | 0.780 | 0.941 | 0.772 | 0.938 | 18.580 | 41.600 |
## 基于V100 GPU的预测速度
<a name='3'></a>
## 3. 基于 V100 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP32<br>Batch Size=1<br>(ms) |
@ -40,8 +49,8 @@ DarkNet53是YOLO作者在论文设计的用于目标检测的backbone，该网
| DarkNet53 | 256 | 256 | 3.139 |
## 基于T4 GPU的预测速度
<a name='4'></a>
## 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|-----------------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

80
docs/zh_CN/models/PP-LCNet.md
View File

@ -1,50 +1,50 @@
# PP-LCNet系列
# PP-LCNet 系列
---
## 目录
- [摘要](#1)
- [介绍](#2)
- [方法](#3)
- [1. 摘要](#1)
- [2. 介绍](#2)
- [3. 方法](#3)
- [3.1 更好的激活函数](#3.1)
- [3.2 合适的位置添加SE模块](#3.2)
- [3.2 合适的位置添加 SE 模块](#3.2)
- [3.3 合适的位置添加更大的卷积核](#3.3)
- [3.4 GAP后使用更大的1x1卷积层](#3.4)
- [实验部分](#4)
- [3.4 GAP 后使用更大的 1x1 卷积层](#3.4)
- [4. 实验部分](#4)
- [图像分类](#4.1)
- [目标检测](#4.2)
- [语义分割](#4.3)
- [总结](#5)
- [引用](#6)
- [5. 总结](#5)
- [6. 引用](#6)
<a name="1"></a>
## 一、摘要
## 1. 摘要
在计算机视觉领域中，骨干网络的好坏直接影响到整个视觉任务的结果。在之前的一些工作中，相关的研究者普遍将FLOPs或者Params作为优化目的，但是在工业界真实落地的场景中，推理速度才是考量模型好坏的重要指标，然而，推理速度和准确性很难兼得。考虑到工业界有很多基于Intel CPU的应用，所以我们本次的工作旨在使骨干网络更好的适应Intel CPU，从而得到一个速度更快、准确率更高的轻量级骨干网络，与此同时，目标检测、语义分割等下游视觉任务的性能也同样得到提升。
在计算机视觉领域中，骨干网络的好坏直接影响到整个视觉任务的结果。在之前的一些工作中，相关的研究者普遍将 FLOPs 或者 Params 作为优化目的，但是在工业界真实落地的场景中，推理速度才是考量模型好坏的重要指标，然而，推理速度和准确性很难兼得。考虑到工业界有很多基于 Intel CPU 的应用，所以我们本次的工作旨在使骨干网络更好的适应 Intel CPU，从而得到一个速度更快、准确率更高的轻量级骨干网络，与此同时，目标检测、语义分割等下游视觉任务的性能也同样得到提升。
<a name="2"></a>
## 二、介绍
## 2. 介绍
近年来，有很多轻量级的骨干网络问世，尤其最近两年，各种NAS搜索出的网络层出不穷，这些网络要么主打FLOPs或者Params上的优势，要么主打ARM设备上的推理速度的优势，很少有网络专门针对Intel CPU做特定的优化，导致这些网络在Intel CPU端的推理速度并不是很完美。基于此，我们针对Intel CPU设备以及其加速库MKLDNN设计了特定的骨干网络PP-LCNet，比起其他的轻量级的SOTA模型，该骨干网络可以在不增加推理时间的情况下，进一步提升模型的性能，最终大幅度超越现有的SOTA模型。与其他模型的对比图如下。
近年来，有很多轻量级的骨干网络问世，尤其最近两年，各种 NAS 搜索出的网络层出不穷，这些网络要么主打 FLOPs 或者 Params 上的优势，要么主打 ARM 设备上的推理速度的优势，很少有网络专门针对 Intel CPU 做特定的优化，导致这些网络在 Intel CPU 端的推理速度并不是很完美。基于此，我们针对 Intel CPU 设备以及其加速库 MKLDNN 设计了特定的骨干网络 PP-LCNet，比起其他的轻量级的 SOTA 模型，该骨干网络可以在不增加推理时间的情况下，进一步提升模型的性能，最终大幅度超越现有的 SOTA 模型。与其他模型的对比图如下。
<div align=center><img src="../../images/PP-LCNet/PP-LCNet-Acc.png" width="500" height="400"/></div>
<a name="3"></a>
## 三、方法
## 3. 方法
网络结构整体如下图所示。
<div align=center><img src="../../images/PP-LCNet/PP-LCNet.png" width="700" height="400"/></div>
我们经过大量的实验发现，在基于Intel CPU设备上，尤其当启用MKLDNN加速库后，很多看似不太耗时的操作反而会增加延时，比如elementwise-add操作、split-concat结构等。所以最终我们选用了结构尽可能精简、速度尽可能快的block组成我们的BaseNet（类似MobileNetV1）。基于BaseNet，我们通过实验，总结了四条几乎不增加延时但是可以提升模型精度的方法，融合这四条策略，我们组合成了PP-LCNet。下面对这四条策略一一介绍：
我们经过大量的实验发现，在基于 Intel CPU 设备上，尤其当启用 MKLDNN 加速库后，很多看似不太耗时的操作反而会增加延时，比如 elementwise-add 操作、split-concat 结构等。所以最终我们选用了结构尽可能精简、速度尽可能快的 block 组成我们的 BaseNet（类似 MobileNetV1）。基于 BaseNet，我们通过实验，总结了四条几乎不增加延时但是可以提升模型精度的方法，融合这四条策略，我们组合成了 PP-LCNet。下面对这四条策略一一介绍：
<a name="3.1"></a>
### 3.1 更好的激活函数
自从卷积神经网络使用了ReLU激活函数后，网络性能得到了大幅度提升，近些年ReLU激活函数的变体也相继出现，如Leaky-ReLU、P-ReLU、ELU等，2017年，谷歌大脑团队通过搜索的方式得到了swish激活函数，该激活函数在轻量级网络上表现优异，在2019年，MobileNetV3的作者将该激活函数进一步优化为H-Swish，该激活函数去除了指数运算，速度更快，网络精度几乎不受影响。我们也经过很多实验发现该激活函数在轻量级网络上有优异的表现。所以在PP-LCNet中，我们选用了该激活函数。
自从卷积神经网络使用了 ReLU 激活函数后，网络性能得到了大幅度提升，近些年 ReLU 激活函数的变体也相继出现，如 Leaky-ReLU、P-ReLU、ELU 等，2017 年，谷歌大脑团队通过搜索的方式得到了 swish 激活函数，该激活函数在轻量级网络上表现优异，在 2019 年，MobileNetV3 的作者将该激活函数进一步优化为 H-Swish，该激活函数去除了指数运算，速度更快，网络精度几乎不受影响。我们也经过很多实验发现该激活函数在轻量级网络上有优异的表现。所以在 PP-LCNet 中，我们选用了该激活函数。
<a name="3.2"></a>
### 3.2 合适的位置添加SE模块
### 3.2 合适的位置添加 SE 模块
SE模块是SENet提出的一种通道注意力机制，可以有效提升模型的精度。但是在Intel CPU端，该模块同样会带来较大的延时，如何平衡精度和速度是我们要解决的一个问题。虽然在MobileNetV3等基于NAS搜索的网络中对SE模块的位置进行了搜索，但是并没有得出一般的结论，我们通过实验发现，SE模块越靠近网络的尾部对模型精度的提升越大。下表也展示了我们的一些实验结果：
SE 模块是 SENet 提出的一种通道注意力机制，可以有效提升模型的精度。但是在 Intel CPU 端，该模块同样会带来较大的延时，如何平衡精度和速度是我们要解决的一个问题。虽然在 MobileNetV3 等基于 NAS 搜索的网络中对 SE 模块的位置进行了搜索，但是并没有得出一般的结论，我们通过实验发现，SE 模块越靠近网络的尾部对模型精度的提升越大。下表也展示了我们的一些实验结果：
| SE Location | Top-1 Acc(\%) | Latency(ms) |
@ -54,13 +54,13 @@ SE模块是SENet提出的一种通道注意力机制，可以有效提升模型
| <b>0000000000011<b> | <b>63.14<b> | <b>2.05<b> |
| 1111111111111 | 64.27 | 3.80 |
最终，PP-LCNet中的SE模块的位置选用了表格中第三行的方案。
最终，PP-LCNet 中的 SE 模块的位置选用了表格中第三行的方案。
<a name="3.3"></a>
### 3.3 合适的位置添加更大的卷积核
在MixNet的论文中，作者分析了卷积核大小对模型性能的影响，结论是在一定范围内大的卷积核可以提升模型的性能，但是超过这个范围会有损模型的性能，所以作者组合了一种split-concat范式的MixConv，这种组合虽然可以提升模型的性能，但是不利于推理。我们通过实验总结了一些更大的卷积核在不同位置的作用，类似SE模块的位置，更大的卷积核在网络的中后部作用更明显，下表展示了5x5卷积核的位置对精度的影响：
在 MixNet 的论文中，作者分析了卷积核大小对模型性能的影响，结论是在一定范围内大的卷积核可以提升模型的性能，但是超过这个范围会有损模型的性能，所以作者组合了一种 split-concat 范式的 MixConv，这种组合虽然可以提升模型的性能，但是不利于推理。我们通过实验总结了一些更大的卷积核在不同位置的作用，类似 SE 模块的位置，更大的卷积核在网络的中后部作用更明显，下表展示了 5x5 卷积核的位置对精度的影响：
| large-kernel Location | Top-1 Acc(\%) | Latency(ms) |
|-------------------|---------------|-------------|
@ -69,13 +69,13 @@ SE模块是SENet提出的一种通道注意力机制，可以有效提升模型
| <b>0000001111111<b> | <b>63.14<b> | <b>2.05<b> |
实验表明，更大的卷积核放在网络的中后部即可达到放在所有位置的精度，与此同时，获得更快的推理速度。PP-LCNet最终选用了表格中第三行的方案。
<a name="3.4"></a>
### 3.4 GAP后使用更大的1x1卷积层
实验表明，更大的卷积核放在网络的中后部即可达到放在所有位置的精度，与此同时，获得更快的推理速度。PP-LCNet 最终选用了表格中第三行的方案。
在GoogLeNet之后，GAP（Global-Average-Pooling）后往往直接接分类层，但是在轻量级网络中，这样会导致GAP后提取的特征没有得到进一步的融合和加工。如果在此后使用一个更大的1x1卷积层（等同于FC层），GAP后的特征便不会直接经过分类层，而是先进行了融合，并将融合的特征进行分类。这样可以在不影响模型推理速度的同时大大提升准确率。
BaseNet经过以上四个方面的改进，得到了PP-LCNet。下表进一步说明了每个方案对结果的影响：
<a name="3.4"></a>
### 3.4 GAP 后使用更大的 1x1 卷积层
在 GoogLeNet 之后，GAP（Global-Average-Pooling）后往往直接接分类层，但是在轻量级网络中，这样会导致 GAP 后提取的特征没有得到进一步的融合和加工。如果在此后使用一个更大的 1x1 卷积层（等同于 FC 层），GAP 后的特征便不会直接经过分类层，而是先进行了融合，并将融合的特征进行分类。这样可以在不影响模型推理速度的同时大大提升准确率。
BaseNet 经过以上四个方面的改进，得到了 PP-LCNet。下表进一步说明了每个方案对结果的影响：
| Activation | SE-block | Large-kernel | last-1x1-conv | Top-1 Acc(\%) | Latency(ms) |
|------------|----------|--------------|---------------|---------------|-------------|
@ -86,14 +86,14 @@ BaseNet经过以上四个方面的改进，得到了PP-LCNet。下表进一步
| <b>1<b> | <b>1<b> | <b>1<b> | <b>1<b> | <b>63.14<b> | <b>2.05<b> |
<a name="4"></a>
## 四、实验部分
## 4. 实验部分
<a name="4.1"></a>
### 4.1 图像分类
图像分类我们选用了ImageNet数据集，相比目前主流的轻量级网络，PP-LCNet在相同精度下可以获得更快的推理速度。当使用百度自研的SSLD蒸馏策略后，精度进一步提升，在Intel cpu端约5ms的推理速度下ImageNet的Top-1 Acc超过了80%。
图像分类我们选用了 ImageNet 数据集，相比目前主流的轻量级网络，PP-LCNet 在相同精度下可以获得更快的推理速度。当使用百度自研的 SSLD 蒸馏策略后，精度进一步提升，在 Intel cpu 端约 5ms 的推理速度下 ImageNet 的 Top-1 Acc 超过了 80%。
| Model | Params(M) | FLOPs(M) | Top-1 Acc(\%) | Top-5 Acc(\%) | Latency(ms) |
| Model | Params(M) | FLOPs(M) | Top-1 Acc(\%) | Top-5 Acc(\%) | Latency(ms) |
|-------|-----------|----------|---------------|---------------|-------------|
| PP-LCNet-0.25x | 1.5 | 18 | 51.86 | 75.65 | 1.74 |
| PP-LCNet-0.35x | 1.6 | 29 | 58.09 | 80.83 | 1.92 |
@ -106,8 +106,8 @@ BaseNet经过以上四个方面的改进，得到了PP-LCNet。下表进一步
| PP-LCNet-0.5x\* | 1.9 | 47 | 66.10 | 86.46 | 2.05 |
| PP-LCNet-1.0x\* | 3.0 | 161 | 74.39 | 92.09 | 2.46 |
| PP-LCNet-2.5x\* | 9.0 | 906 | 80.82 | 95.33 | 5.39 |
其中\*表示使用SSLD蒸馏后的模型。
其中\*表示使用 SSLD 蒸馏后的模型。
与其他轻量级网络的性能对比：
@ -129,19 +129,19 @@ BaseNet经过以上四个方面的改进，得到了PP-LCNet。下表进一步
<a name="4.2"></a>
### 4.2 目标检测
目标检测的方法我们选用了百度自研的PicoDet，该方法主打轻量级目标检测场景，下表展示了在COCO数据集上、backbone选用PP-LCNet与MobileNetV3的结果的比较，无论在精度还是速度上，PP-LCNet的优势都非常明显。
目标检测的方法我们选用了百度自研的 PicoDet，该方法主打轻量级目标检测场景，下表展示了在 COCO 数据集上、backbone 选用 PP-LCNet 与 MobileNetV3 的结果的比较，无论在精度还是速度上，PP-LCNet 的优势都非常明显。
| Backbone | mAP(%) | Latency(ms) |
|-------|-----------|----------|
MobileNetV3-large-0.35x | 19.2 | 8.1 |
<b>PP-LCNet-0.5x<b> | <b>20.3<b> | <b>6.0<b> |
MobileNetV3-large-0.75x | 25.8 | 11.1 |
<b>PP-LCNet-1x<b> | <b>26.9<b> | <b>7.9<b> |
<b>PP-LCNet-1x<b> | <b>26.9<b> | <b>7.9<b> |
<a name="4.3"></a>
### 4.3 语义分割
语义分割的方法我们选用了DeeplabV3+，下表展示了在Cityscapes数据集上、backbone选用PP-LCNet与MobileNetV3的比较，在精度和速度方面，PP-LCNet的优势同样明显。
语义分割的方法我们选用了 DeeplabV3+，下表展示了在 Cityscapes 数据集上、backbone 选用 PP-LCNet 与 MobileNetV3 的比较，在精度和速度方面，PP-LCNet 的优势同样明显。
| Backbone | mIoU(%) | Latency(ms) |
|-------|-----------|----------|
@ -151,17 +151,17 @@ MobileNetV3-large-0.75x | 64.53 | 151 |
<b>PP-LCNet-1x<b> | <b>66.03<b> | <b>96<b> |
<a name="5"></a>
## 五、总结
## 5. 总结
PP-LCNet没有像学术界那样死扣极致的FLOPs与Params，而是着眼于分析如何添加对Intel CPU友好的模块来提升模型的性能，这样可以更好的平衡准确率和推理时间，其中的实验结论也很适合其他网络结构设计的研究者，同时也为NAS搜索研究者提供了更小的搜索空间和一般结论。最终的PP-LCNet在产业界也可以更好的落地和应用。
PP-LCNet 没有像学术界那样死扣极致的 FLOPs 与 Params，而是着眼于分析如何添加对 Intel CPU 友好的模块来提升模型的性能，这样可以更好的平衡准确率和推理时间，其中的实验结论也很适合其他网络结构设计的研究者，同时也为 NAS 搜索研究者提供了更小的搜索空间和一般结论。最终的 PP-LCNet 在产业界也可以更好的落地和应用。
<a name="6"></a>
## 六、引用
## 6. 引用
如果你的论文用到了PP-LCNet的方法，请添加如下cite：
如果你的论文用到了 PP-LCNet 的方法，请添加如下 cite：
```
@misc{cui2021pplcnet,
title={PP-LCNet: A Lightweight CPU Convolutional Neural Network},
title={PP-LCNet: A Lightweight CPU Convolutional Neural Network},
author={Cheng Cui and Tingquan Gao and Shengyu Wei and Yuning Du and Ruoyu Guo and Shuilong Dong and Bin Lu and Ying Zhou and Xueying Lv and Qiwen Liu and Xiaoguang Hu and Dianhai Yu and Yanjun Ma},
year={2021},
eprint={2109.15099},

17
docs/zh_CN/models/ReXNet.md
View File

@ -1,11 +1,20 @@
# ReXNet系列
---
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
ReXNet是NAVER集团ClovaAI研发中心基于一种网络架构设计新范式而构建的网络。针对现有网络中存在的`Representational Bottleneck`问题，作者提出了一组新的设计原则。作者认为传统的网络架构设计范式会产生表达瓶颈，进而影响模型的性能。为研究此问题，作者研究了上万个随机网络生成特征的`matric rank`，同时进一步研究了网络层中通道配置方案。基于此，作者提出了一组简单而有效的设计原则，以消除表达瓶颈问题。[论文地址](https://arxiv.org/pdf/2007.00992.pdf)
<a name='1'></a>
## 1. 概述
ReXNet 是 NAVER 集团 ClovaAI 研发中心基于一种网络架构设计新范式而构建的网络。针对现有网络中存在的`Representational Bottleneck`问题，作者提出了一组新的设计原则。作者认为传统的网络架构设计范式会产生表达瓶颈，进而影响模型的性能。为研究此问题，作者研究了上万个随机网络生成特征的 `matric rank`，同时进一步研究了网络层中通道配置方案。基于此，作者提出了一组简单而有效的设计原则，以消除表达瓶颈问题。[论文地址](https://arxiv.org/pdf/2007.00992.pdf)
<a name='2'></a>
## 精度、FLOPS和参数量
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1| FLOPS<br/>(G) | Params<br/>(M) |
|:--:|:--:|:--:|:--:|:--:|----|
@ -15,4 +24,4 @@ ReXNet是NAVER集团ClovaAI研发中心基于一种网络架构设计新范式
| ReXNet_2_0 | 81.22 | 95.36 | 81.6 | 1.561 | 16.449 |
| ReXNet_3_0 | 82.09 | 96.12 | 82.8 | 3.445 | 34.833 |
关于Inference speed等信息，敬请期待。
关于 Inference speed 等信息，敬请期待。

14
docs/zh_CN/models/RedNet.md
View File

@ -1,11 +1,17 @@
# RedNet系列
---
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
<a name='1'></a>
## 1. 概述
在 ResNet 的 Backbone 和 Backbone 的所有 Bottleneck 位置上使用 Involution 替换掉了卷积，但保留了所有的卷积用于通道映射和融合。这些精心重新设计的实体联合起来，形成了一种新的高效 Backbone 网络，称为 RedNet。[论文地址](https://arxiv.org/abs/2103.06255)。
## 精度、FLOPS和参数量
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Model | Params (M) | FLOPs (G) | Top-1 (%) | Top-5 (%) |
|:---------------------:|:----------:|:---------:|:---------:|:---------:|
@ -13,4 +19,4 @@
| RedNet38 | 12.4 | 2.2 | 77.47 | 93.56 |
| RedNet50 | 15.5 | 2.7 | 78.33 | 94.17 |
| RedNet101 | 25.7 | 4.7 | 78.94 | 94.36 |
| RedNet152 | 34.0 | 6.8 | 79.17 | 94.40 |
| RedNet152 | 34.0 | 6.8 | 79.17 | 94.40 |

16
docs/zh_CN/models/RepVGG.md
View File

@ -1,11 +1,17 @@
# RepVGG系列
# RepVGG 系列
---
## 目录
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
<a name='1'></a>
## 概述
RepVGG（Making VGG-style ConvNets Great Again）系列模型是由清华大学(丁贵广团队)、旷视科技(孙剑等人)、港科大和阿伯里斯特威斯大学在2021年提出的一个简单但强大的卷积神经网络架构，该架构具有类似于VGG的推理时间主体，该主体仅由3x3卷积和ReLU的堆栈组成，而训练时间模型具有多分支拓扑。训练时间和推理时间架构的这种解耦是通过结构重新参数化(re-parameterization)技术实现的，因此该模型称为RepVGG。[论文地址](https://arxiv.org/abs/2101.03697)。
RepVGG(Making VGG-style ConvNets Great Again)系列模型是由清华大学(丁贵广团队)、旷视科技(孙剑等人)、港科大和阿伯里斯特威斯大学在2021 年提出的一个简单但强大的卷积神经网络架构，该架构具有类似于 VGG 的推理时间主体，该主体仅由 3x3 卷积和ReLU 的堆栈组成，而训练时间模型具有多分支拓扑。训练时间和推理时间架构的这种解耦是通过结构重新参数化(re-parameterization)技术实现的，因此该模型称为RepVGG。[论文地址](https://arxiv.org/abs/2101.03697)。
## 精度、FLOPS和参数量
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1| FLOPS<br>(G) |
|:--:|:--:|:--:|:--:|:--:|
@ -20,4 +26,4 @@ RepVGG（Making VGG-style ConvNets Great Again）系列模型是由清华大学(
| RepVGG_B2g4 | 0.7881 | 0.9448 | 0.7938 | |
| RepVGG_B3g4 | 0.7965 | 0.9485 | 0.8021 | |
关于Params、FLOPs、Inference speed等信息，敬请期待。
关于Params、FLOPs、Inference speed 等信息，敬请期待。

22
docs/zh_CN/models/ResNeSt_RegNet.md
View File

@ -1,13 +1,22 @@
# ResNeSt与RegNet系列
# ResNeSt 与 RegNet 系列
----
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 T4 GPU 的预测速度](#3)
ResNeSt系列模型是在2020年提出的，在原有的resnet网络结构上做了改进，通过引入K个Group和在不同Group中加入类似于SEBlock的attention模块，使得精度相比于基础模型ResNet有了大幅度的提高，且参数量和flops与基础的ResNet基本保持一致。
<a name='1'></a>
RegNet是由facebook于2020年提出，旨在深化设计空间理念的概念，在AnyNetX的基础上逐步改进，通过加入共享瓶颈ratio、共享组宽度、调整网络深度与宽度等策略，最终实现简化设计空间结构、提高设计空间的可解释性、改善设计空间的质量，并保持设计空间的模型多样性的目的。最终设计出的模型在类似的条件下，性能还要优于EfficientNet，并且在GPU上的速度提高了5倍。
## 1. 概述
ResNeSt 系列模型是在 2020 年提出的，在原有的 resnet 网络结构上做了改进，通过引入 K 个 Group 和在不同 Group 中加入类似于 SEBlock 的 attention 模块，使得精度相比于基础模型 ResNet 有了大幅度的提高，且参数量和 flops 与基础的 ResNet 基本保持一致。
## 精度、FLOPS和参数量
RegNet 是由 facebook 于 2020 年提出，旨在深化设计空间理念的概念，在 AnyNetX 的基础上逐步改进，通过加入共享瓶颈 ratio、共享组宽度、调整网络深度与宽度等策略，最终实现简化设计空间结构、提高设计空间的可解释性、改善设计空间的质量，并保持设计空间的模型多样性的目的。最终设计出的模型在类似的条件下，性能还要优于 EfficientNet，并且在 GPU 上的速度提高了 5 倍。
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -15,8 +24,9 @@ RegNet是由facebook于2020年提出，旨在深化设计空间理念的概念
| ResNeSt50 | 0.8083 | 0.9542| 0.8113 | -| 10.78 | 27.5 |
| RegNetX_4GF | 0.7850 | 0.9416| 0.7860 | -| 8.0 | 22.1 |
<a name='3'></a>
## 基于T4 GPU的预测速度
## 3. 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|--------------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

37
docs/zh_CN/models/ResNet_and_vd.md
View File

@ -1,16 +1,25 @@
# ResNet及其Vd系列
# ResNet 及其 Vd 系列
-----
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 V100 GPU 的预测速度](#3)
* [4. 基于 T4 GPU 的预测速度](#4)
ResNet系列模型是在2015年提出的，一举在ILSVRC2015比赛中取得冠军，top5错误率为3.57%。该网络创新性的提出了残差结构，通过堆叠多个残差结构从而构建了ResNet网络。实验表明使用残差块可以有效地提升收敛速度和精度。
<a name='1'></a>
斯坦福大学的Joyce Xu将ResNet称为「真正重新定义了我们看待神经网络的方式」的三大架构之一。由于ResNet卓越的性能，越来越多的来自学术界和工业界学者和工程师对其结构进行了改进，比较出名的有Wide-ResNet, ResNet-vc ,ResNet-vd, Res2Net等，其中ResNet-vc与ResNet-vd的参数量和计算量与ResNet几乎一致，所以在此我们将其与ResNet统一归为ResNet系列。
## 1. 概述
本次发布ResNet系列的模型包括ResNet50，ResNet50_vd，ResNet50_vd_ssld，ResNet200_vd等14个预训练模型。在训练层面上，ResNet的模型采用了训练ImageNet的标准训练流程，而其余改进版模型采用了更多的训练策略，如learning rate的下降方式采用了cosine decay，引入了label smoothing的标签正则方式，在数据预处理加入了mixup的操作，迭代总轮数从120个epoch增加到200个epoch。
ResNet 系列模型是在 2015 年提出的，一举在 ILSVRC2015 比赛中取得冠军，top5 错误率为 3.57%。该网络创新性的提出了残差结构，通过堆叠多个残差结构从而构建了 ResNet 网络。实验表明使用残差块可以有效地提升收敛速度和精度。
其中，ResNet50_vd_v2与ResNet50_vd_ssld采用了知识蒸馏，保证模型结构不变的情况下，进一步提升了模型的精度，具体地，ResNet50_vd_v2的teacher模型是ResNet152_vd（top1准确率80.59%），数据选用的是ImageNet-1k的训练集，ResNet50_vd_ssld的teacher模型是ResNeXt101_32x16d_wsl（top1准确率84.2%），数据选用结合了ImageNet-1k的训练集和ImageNet-22k挖掘的400万数据。知识蒸馏的具体方法正在持续更新中。
斯坦福大学的 Joyce Xu 将 ResNet 称为「真正重新定义了我们看待神经网络的方式」的三大架构之一。由于 ResNet 卓越的性能，越来越多的来自学术界和工业界学者和工程师对其结构进行了改进，比较出名的有 Wide-ResNet, ResNet-vc ,ResNet-vd, Res2Net 等，其中 ResNet-vc 与 ResNet-vd 的参数量和计算量与 ResNet 几乎一致，所以在此我们将其与 ResNet 统一归为 ResNet 系列。
该系列模型的FLOPS、参数量以及T4 GPU上的预测耗时如下图所示。
本次发布 ResNet 系列的模型包括 ResNet50，ResNet50_vd，ResNet50_vd_ssld，ResNet200_vd 等 14 个预训练模型。在训练层面上，ResNet 的模型采用了训练 ImageNet 的标准训练流程，而其余改进版模型采用了更多的训练策略，如 learning rate 的下降方式采用了 cosine decay，引入了 label smoothing 的标签正则方式，在数据预处理加入了 mixup 的操作，迭代总轮数从 120 个 epoch 增加到 200 个 epoch。
其中，ResNet50_vd_v2 与 ResNet50_vd_ssld 采用了知识蒸馏，保证模型结构不变的情况下，进一步提升了模型的精度，具体地，ResNet50_vd_v2 的 teacher 模型是 ResNet152_vd（top1 准确率 80.59%），数据选用的是 ImageNet-1k 的训练集，ResNet50_vd_ssld 的 teacher 模型是 ResNeXt101_32x16d_wsl（top1 准确率 84.2%），数据选用结合了 ImageNet-1k 的训练集和 ImageNet-22k 挖掘的 400 万数据。知识蒸馏的具体方法正在持续更新中。
该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
![](../../images/models/T4_benchmark/t4.fp32.bs4.ResNet.flops.png)
@ -21,10 +30,10 @@ ResNet系列模型是在2015年提出的，一举在ILSVRC2015比赛中取得冠
![](../../images/models/T4_benchmark/t4.fp16.bs4.ResNet.png)
通过上述曲线可以看出，层数越多，准确率越高，但是相应的参数量、计算量和延时都会增加。ResNet50_vd_ssld通过用更强的teacher和更多的数据，将其在ImageNet-1k上的验证集top-1精度进一步提高，达到了82.39%，刷新了ResNet50系列模型的精度。
通过上述曲线可以看出，层数越多，准确率越高，但是相应的参数量、计算量和延时都会增加。ResNet50_vd_ssld 通过用更强的 teacher 和更多的数据，将其在 ImageNet-1k 上的验证集 top-1 精度进一步提高，达到了 82.39%，刷新了 ResNet50 系列模型的精度。
## 精度、FLOPS和参数量
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -47,11 +56,12 @@ ResNet系列模型是在2015年提出的，一举在ILSVRC2015比赛中取得冠
| Fix_ResNet50_vd_ssld_v2 | 0.840 | 0.970 | | | 17.696 | 25.580 |
| ResNet101_vd_ssld | 0.837 | 0.967 | | | 16.100 | 44.570 |
* 注：`ResNet50_vd_ssld_v2`是在`ResNet50_vd_ssld`训练策略的基础上加上AutoAugment训练得到，`Fix_ResNet50_vd_ssld_v2`是固定`ResNet50_vd_ssld_v2`除FC层外所有的网络参数，在320x320的图像输入分辨率下，基于ImageNet1k数据集微调得到。
* 注：`ResNet50_vd_ssld_v2`是在`ResNet50_vd_ssld`训练策略的基础上加上 AutoAugment 训练得到，`Fix_ResNet50_vd_ssld_v2`是固定`ResNet50_vd_ssld_v2`除 FC 层外所有的网络参数，在 320x320 的图像输入分辨率下，基于 ImageNet1k 数据集微调得到。
<a name='3'></a>
## 基于V100 GPU的预测速度
## 3. 基于 V100 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP32<br>Batch Size=1<br>(ms) |
|------------------|-----------|-------------------|--------------------------|
@ -72,8 +82,9 @@ ResNet系列模型是在2015年提出的，一举在ILSVRC2015比赛中取得冠
| ResNet50_vd_ssld | 224 | 256 | 3.165 |
| ResNet101_vd_ssld | 224 | 256 | 5.252 |
<a name='4'></a>
## 基于T4 GPU的预测速度
## 4. 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|-------------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

34
docs/zh_CN/models/SEResNext_and_Res2Net.md
View File

@ -1,13 +1,23 @@
# SEResNeXt与Res2Net系列
# SEResNeXt 与 Res2Net 系列
## 概述
ResNeXt是ResNet的典型变种网络之一，ResNeXt发表于2017年的CVPR会议。在此之前，提升模型精度的方法主要集中在将网络变深或者变宽，这样增加了参数量和计算量，推理速度也会相应变慢。ResNeXt结构提出了通道分组（cardinality）的概念，作者通过实验发现增加通道的组数比增加深度和宽度更有效。其可以在不增加参数复杂度的前提下提高准确率，同时还减少了参数的数量，所以是比较成功的ResNet的变种。
-----
## 目录
SENet是2017年ImageNet分类比赛的冠军方案，其提出了一个全新的SE结构，该结构可以迁移到任何其他网络中，其通过控制scale的大小，把每个通道间重要的特征增强，不重要的特征减弱，从而让提取的特征指向性更强。
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
* [3. 基于 V100 GPU 的预测速度](#3)
* [4. 基于 T4 GPU 的预测速度](#4)
Res2Net是2019年提出的一种全新的对ResNet的改进方案，该方案可以和现有其他优秀模块轻松整合，在不增加计算负载量的情况下，在ImageNet、CIFAR-100等数据集上的测试性能超过了ResNet。Res2Net结构简单，性能优越，进一步探索了CNN在更细粒度级别的多尺度表示能力。Res2Net揭示了一个新的提升模型精度的维度，即scale，其是除了深度、宽度和基数的现有维度之外另外一个必不可少的更有效的因素。该网络在其他视觉任务如目标检测、图像分割等也有相当不错的表现。
<a name='1'></a>
该系列模型的FLOPS、参数量以及T4 GPU上的预测耗时如下图所示。
## 1. 概述
ResNeXt 是 ResNet 的典型变种网络之一，ResNeXt 发表于 2017 年的 CVPR 会议。在此之前，提升模型精度的方法主要集中在将网络变深或者变宽，这样增加了参数量和计算量，推理速度也会相应变慢。ResNeXt 结构提出了通道分组（cardinality）的概念，作者通过实验发现增加通道的组数比增加深度和宽度更有效。其可以在不增加参数复杂度的前提下提高准确率，同时还减少了参数的数量，所以是比较成功的 ResNet 的变种。
SENet 是 2017 年 ImageNet 分类比赛的冠军方案，其提出了一个全新的 SE 结构，该结构可以迁移到任何其他网络中，其通过控制 scale 的大小，把每个通道间重要的特征增强，不重要的特征减弱，从而让提取的特征指向性更强。
Res2Net 是 2019 年提出的一种全新的对 ResNet 的改进方案，该方案可以和现有其他优秀模块轻松整合，在不增加计算负载量的情况下，在 ImageNet、CIFAR-100 等数据集上的测试性能超过了 ResNet。Res2Net 结构简单，性能优越，进一步探索了 CNN 在更细粒度级别的多尺度表示能力。Res2Net 揭示了一个新的提升模型精度的维度，即 scale，其是除了深度、宽度和基数的现有维度之外另外一个必不可少的更有效的因素。该网络在其他视觉任务如目标检测、图像分割等也有相当不错的表现。
该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
![](../../images/models/T4_benchmark/t4.fp32.bs4.SeResNeXt.flops.png)
@ -19,11 +29,12 @@ Res2Net是2019年提出的一种全新的对ResNet的改进方案，该方案可
![](../../images/models/T4_benchmark/t4.fp16.bs4.SeResNeXt.png)
目前PaddleClas开源的这三类的预训练模型一共有24个，其指标如图所示，从图中可以看出，在同样Flops和Params下，改进版的模型往往有更高的精度，但是推理速度往往不如ResNet系列。另一方面，Res2Net表现也较为优秀，相比ResNeXt中的group操作、SEResNet中的SE结构操作，Res2Net在相同Flops、Params和推理速度下往往精度更佳。
目前 PaddleClas 开源的这三类的预训练模型一共有 24 个，其指标如图所示，从图中可以看出，在同样 Flops 和 Params 下，改进版的模型往往有更高的精度，但是推理速度往往不如 ResNet 系列。另一方面，Res2Net 表现也较为优秀，相比 ResNeXt 中的 group 操作、SEResNet 中的 SE 结构操作，Res2Net 在相同 Flops、Params 和推理速度下往往精度更佳。
<a name='2'></a>
## 精度、FLOPS和参数量
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -56,8 +67,9 @@ Res2Net是2019年提出的一种全新的对ResNet的改进方案，该方案可
| SENet154_vd | 0.814 | 0.955 | | | 45.830 | 114.290 |
<a name='3'></a>
## 基于V100 GPU的预测速度
## 3. 基于 V100 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP32<br>Batch Size=1<br>(ms) |
|-----------------------|-----------|-------------------|--------------------------|
@ -87,7 +99,9 @@ Res2Net是2019年提出的一种全新的对ResNet的改进方案，该方案可
| SENet154_vd | 224 | 256 | 50.406 |
## 基于T4 GPU的预测速度
<a name='4'></a>
## 4. 基于 T4 GPU 的预测速度
| Models | Crop Size | Resize Short Size | FP16<br>Batch Size=1<br>(ms) | FP16<br>Batch Size=4<br>(ms) | FP16<br>Batch Size=8<br>(ms) | FP32<br>Batch Size=1<br>(ms) | FP32<br>Batch Size=4<br>(ms) | FP32<br>Batch Size=8<br>(ms) |
|-----------------------|-----------|-------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|------------------------------|

18
docs/zh_CN/models/SwinTransformer.md
View File

@ -1,10 +1,18 @@
# SwinTransformer
---
## 目录
## 概述
Swin Transformer 是一种新的视觉Transformer网络，可以用作计算机视觉领域的通用骨干网路。SwinTransformer由移动窗口（shifted windows）表示的层次Transformer结构组成。移动窗口将自注意计算限制在非重叠的局部窗口上，同时允许跨窗口连接，从而提高了网络性能。[论文地址](https://arxiv.org/abs/2103.14030)。
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
<a name='1'></a>
## 精度、FLOPS和参数量
## 1. 概述
Swin Transformer 是一种新的视觉 Transformer 网络，可以用作计算机视觉领域的通用骨干网路。SwinTransformer 由移动窗口（shifted windows）表示的层次 Transformer 结构组成。移动窗口将自注意计算限制在非重叠的局部窗口上，同时允许跨窗口连接，从而提高了网络性能。[论文地址](https://arxiv.org/abs/2103.14030)。
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Params<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -17,6 +25,6 @@ Swin Transformer 是一种新的视觉Transformer网络，可以用作计算机
| SwinTransformer_large_patch4_window7_224<sup>[1]</sup> | 0.8596 | 0.9783 | 0.863 | 0.979 | 34.5 | 197 |
| SwinTransformer_large_patch4_window12_384<sup>[1]</sup> | 0.8719 | 0.9823 | 0.873 | 0.982 | 103.9 | 197 |
[1]：基于ImageNet22k数据集预训练，然后在ImageNet1k数据集迁移学习得到。
[1]：基于 ImageNet22k 数据集预训练，然后在 ImageNet1k 数据集迁移学习得到。
**注**：与Reference的精度差异源于数据预处理不同。
**注**：与 Reference 的精度差异源于数据预处理不同。

16
docs/zh_CN/models/TNT.md
View File

@ -1,11 +1,19 @@
# TNT系列
# TNT 系列
---
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
TNT（Transformer-iN-Transformer）系列模型由华为诺亚于2021年提出，用于对 patch 级别和 pixel 级别的表示进行建模。在每个 TNT 块中，outer transformer block 用于处理 patch 嵌入，inner transformer block 从 pixel 嵌入中提取局部特征。通过线性变换层将 pixel 级特征投影到 patch 嵌入空间，然后加入到 patch 中。通过对 TNT 块的叠加，建立了用于图像识别的 TNT 模型。在ImageNet 基准测试和下游任务上的实验证明了该 TNT 体系结构的优越性和有效性。例如，在计算量相当的情况下 TNT 能在 ImageNet 上达到 81.3% 的 top-1 精度，比 DeiT 高 1.5%。[论文地址](https://arxiv.org/abs/2103.00112)。
<a name='1'></a>
## 1. 概述
## 精度、FLOPS和参数量
TNT(Transformer-iN-Transformer)系列模型由华为诺亚于 2021 年提出，用于对 patch 级别和 pixel 级别的表示进行建模。在每个 TNT 块中，outer transformer block 用于处理 patch 嵌入，inner transformer block 从 pixel 嵌入中提取局部特征。通过线性变换层将 pixel 级特征投影到 patch 嵌入空间，然后加入到 patch 中。通过对 TNT 块的叠加，建立了用于图像识别的 TNT 模型。在 ImageNet 基准测试和下游任务上的实验证明了该 TNT 体系结构的优越性和有效性。例如，在计算量相当的情况下 TNT 能在 ImageNet 上达到 81.3% 的 top-1 精度，比 DeiT 高 1.5%。[论文地址](https://arxiv.org/abs/2103.00112)。
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Model | Params (M) | FLOPs (G) | Top-1 (%) | Top-5 (%) |
|:---------------------:|:----------:|:---------:|:---------:|:---------:|

97
docs/zh_CN/models/Tricks.md
View File

@ -1,54 +1,85 @@
# 训练技巧
---
## 目录
* [1.优化器的选择](#1)
* [2.学习率以及学习率下降策略的选择](#2)
* [2.1 学习率的概念](#2.1)
* [2.2 学习率下降策略](#2.2)
* [2.3 warmup 策略](#2.3)
* [3.batch_size 的选择](#3)
* [4.weight_decay 的选择](#4)
* [5.label_smoothing 的选择](#5)
* [6.针对小模型更改图片的 crop 面积与拉伸变换程度](#6)
* [7.使用数据增广方式提升精度](#7)
* [8. 通过 train_acc 和 test_acc 确定调优策略](#8)
* [9.通过已有的预训练模型提升自己的数据集的精度](#9)
* [10. 参考文献](#10)
<a name='1'></a>
## 1.优化器的选择
自深度学习发展以来，就有很多关于优化器的研究者工作，优化器的目的是为了让损失函数尽可能的小，从而找到合适的参数来完成某项任务。目前业界主要用到的优化器有SGD、RMSProp、Adam、AdaDelt等，其中由于带momentum的SGD优化器广泛应用于学术界和工业界，所以我们发布的模型也大都使用该优化器来实现损失函数的梯度下降。带momentum的SGD优化器有两个劣势，其一是收敛速度慢，其二是初始学习率的设置需要依靠大量的经验，然而如果初始学习率设置得当并且迭代轮数充足，该优化器也会在众多的优化器中脱颖而出，使得其在验证集上获得更高的准确率。一些自适应学习率的优化器如Adam、RMSProp等，收敛速度往往比较快，但是最终的收敛精度会稍差一些。如果追求更快的收敛速度，我们推荐使用这些自适应学习率的优化器，如果追求更高的收敛精度，我们推荐使用带momentum的SGD优化器。
自深度学习发展以来，就有很多关于优化器的研究者工作，优化器的目的是为了让损失函数尽可能的小，从而找到合适的参数来完成某项任务。目前业界主要用到的优化器 有 SGD、RMSProp、Adam、AdaDelt 等，其中由于带 momentum 的 SGD 优化器广泛应用于学术界和工业界，所以我们发布的模型也大都使用该优化器来实现损失函数的梯度下降。带 momentum 的 SGD 优化器有两个劣势，其一是收敛速度慢，其二是初始学习率的设置需要依靠大量的经验，然而如果初始学习率设置得当并且迭代轮数充足，该优化器也会在众多的优化器中脱颖而出，使得其在验证集上获得更高的准确率。一些自适应学习率的优化器如 Adam、RMSProp 等，收敛速度往往比较快，但是最终的收敛精度会稍差一些。如果追求更快的收敛速度，我们推荐使用这些自适应学习率的优化器，如果追求更高的收敛精度，我们推荐使用带 momentum 的 SGD 优化器。
<a name='2'></a>
## 2.学习率以及学习率下降策略的选择
学习率的选择往往和优化器以及数据和任务有关系。这里主要介绍以momentum+SGD作为优化器训练ImageNet-1k的学习率以及学习率下降的选择。
学习率的选择往往和优化器以及数据和任务有关系。这里主要介绍以 momentum+SGD 作为优化器训练 ImageNet-1k 的学习率以及学习率下降的选择。
### 学习率的概念：
<a name='2.1'></a>
### 2.1 学习率的概念：
学习率是通过损失函数的梯度调整网络权重的超参数的速度。学习率越低，损失函数的变化速度就越慢。虽然使用低学习率可以确保不会错过任何局部极小值，但也意味着将花费更长的时间来进行收敛，特别是在被困在高原区域的情况下。
### 学习率下降策略：
在整个训练过程中，我们不能使用同样的学习率来更新权重，否则无法到达最优点，所以需要在训练过程中调整学习率的大小。在训练初始阶段，由于权重处于随机初始化的状态，损失函数相对容易进行梯度下降，所以可以设置一个较大的学习率。在训练后期，由于权重参数已经接近最优值，较大的学习率无法进一步寻找最优值，所以需要设置一个较小的学习率。在训练整个过程中，很多研究者使用的学习率下降方式是piecewise_decay，即阶梯式下降学习率，如在ResNet50标准的训练中，我们设置的初始学习率是0.1，每30epoch学习率下降到原来的1/10，一共迭代120epoch。除了piecewise_decay，很多研究者也提出了学习率的其他下降方式，如polynomial_decay（多项式下降）、exponential_decay（指数下降）,cosine_decay（余弦下降）等，其中cosine_decay无需调整超参数，鲁棒性也比较高，所以成为现在提高模型精度首选的学习率下降方式。Cosine_decay和piecewise_decay的学习率变化曲线如下图所示，容易观察到，在整个训练过程中，cosine_decay都保持着较大的学习率，所以其收敛较为缓慢，但是最终的收敛效果较peicewise_decay更好一些。
<a name='2.2'></a>
### 2.2 学习率下降策略：
在整个训练过程中，我们不能使用同样的学习率来更新权重，否则无法到达最优点，所以需要在训练过程中调整学习率的大小。在训练初始阶段，由于权重处于随机初始化的状态，损失函数相对容易进行梯度下降，所以可以设置一个较大的学习率。在训练后期，由于权重参数已经接近最优值，较大的学习率无法进一步寻找最优值，所以需要设置一个较小的学习率。在训练整个过程中，很多研究者使用的学习率下降方式是 piecewise_decay，即阶梯式下降学习率，如在 ResNet50 标准的训练中，我们设置的初始学习率是 0.1，每 30 epoch 学习率下降到原来的 1/10，一共迭代 120 epoch。除了 piecewise_decay，很多研究者也提出了学习率的其他下降方式，如 polynomial_decay（多项式下降）、exponential_decay（指数下降）,cosine_decay（余弦下降）等，其中 cosine_decay 无需调整超参数，鲁棒性也比较高，所以成为现在提高模型精度首选的学习率下降方式。Cosine_decay 和 piecewise_decay 的学习率变化曲线如下图所示，容易观察到，在整个训练过程中，cosine_decay 都保持着较大的学习率，所以其收敛较为缓慢，但是最终的收敛效果较 peicewise_decay 更好一些。
![](../../images/models/lr_decay.jpeg)
另外，从图中我们也可以看到，cosine_decay里学习率小的轮数较少，这样会影响到最终的精度，所以为了使得cosine_decay发挥更好的效果，建议迭代更多的轮数，如200轮。
另外，从图中我们也可以看到，cosine_decay 里学习率小的轮数较少，这样会影响到最终的精度，所以为了使得 cosine_decay 发挥更好的效果，建议迭代更多的轮数，如 200 轮。
### warmup策略
如果使用较大的batch_size训练神经网络时，我们建议您使用warmup策略。Warmup策略顾名思义就是让学习率先预热一下，在训练初期我们不直接使用最大的学习率，而是用一个逐渐增大的学习率去训练网络，当学习率增大到最高点时，再使用学习率下降策略中提到的学习率下降方式衰减学习率的值。实验表明，在batch_size较大时，warmup可以稳定提升模型的精度。在训练MobileNetV3等batch_size较大的实验中，我们默认将warmup中的epoch设置为5，即先用5epoch将学习率从0增加到最大值，再去做相应的学习率衰减。
<a name='2.3'></a>
## 3.batch_size的选择
batch_size是训练神经网络中的一个重要的超参数，该值决定了一次将多少数据送入神经网络参与训练。在论文[1]中，作者通过实验发现，当batch_size的值与学习率的值呈线性关系时，收敛精度几乎不受影响。在训练ImageNet数据时，大部分的神经网络选择的初始学习率为0.1，batch_size是256，所以根据实际的模型大小和显存情况，可以将学习率设置为0.1\*k,batch_size设置为256\*k。
### 2.3 warmup 策略
如果使用较大的 batch_size 训练神经网络时，我们建议您使用 warmup 策略。Warmup 策略顾名思义就是让学习率先预热一下，在训练初期我们不直接使用最大的学习率，而是用一个逐渐增大的学习率去训练网络，当学习率增大到最高点时，再使用学习率下降策略中提到的学习率下降方式衰减学习率的值。实验表明，在 batch_size 较大时，warmup 可以稳定提升模型的精度。在训练 MobileNetV3 等 batch_size 较大的实验中，我们默认将 warmup 中的 epoch 设置为 5，即先用 5 epoch 将学习率从 0 增加到最大值，再去做相应的学习率衰减。
## 4.weight_decay的选择
过拟合是机器学习中常见的一个名词，简单理解即为模型在训练数据上表现很好，但在测试数据上表现较差，在卷积神经网络中，同样存在过拟合的问题，为了避免过拟合，很多正则方式被提出，其中，weight_decay是其中一个广泛使用的避免过拟合的方式。Weight_decay等价于在最终的损失函数后添加L2正则化，L2正则化使得网络的权重倾向于选择更小的值，最终整个网络中的参数值更趋向于0，模型的泛化性能相应提高。在各大深度学习框架的实现中，该值表达的含义是L2正则前的系数，在paddle框架中，该值的名称是l2_decay，所以以下都称其为l2_decay。该系数越大，表示加入的正则越强，模型越趋于欠拟合状态。在训练ImageNet的任务中，大多数的网络将该参数值设置为1e-4，在一些小的网络如MobileNet系列网络中，为了避免网络欠拟合，该值设置为1e-5~4e-5之间。当然，该值的设置也和具体的数据集有关系，当任务的数据集较大时，网络本身趋向于欠拟合状态，可以将该值适当减小，当任务的数据集较小时，网络本身趋向于过拟合状态，可以将该值适当增大。下表展示了MobileNetV1_x0_25在ImageNet-1k上使用不同l2_decay的精度情况。由于MobileNetV1_x0_25是一个比较小的网络，所以l2_decay过大会使网络趋向于欠拟合状态，所以在该网络中，相对1e-4，3e-5是更好的选择。
<a name='3'></a>
## 3.batch_size 的选择
batch_size 是训练神经网络中的一个重要的超参数，该值决定了一次将多少数据送入神经网络参与训练。在论文[1]中，作者通过实验发现，当 batch_size 的值与学习率的值呈线性关系时，收敛精度几乎不受影响。在训练 ImageNet 数据时，大部分的神经网络选择的初始学习率为 0.1，batch_size 是 256，所以根据实际的模型大小和显存情况，可以将学习率设置为 0.1\*k,batch_size 设置为 256\*k。
<a name='4'></a>
## 4.weight_decay 的选择
过拟合是机器学习中常见的一个名词，简单理解即为模型在训练数据上表现很好，但在测试数据上表现较差，在卷积神经网络中，同样存在过拟合的问题，为了避免过拟合，很多正则方式被提出，其中，weight_decay 是其中一个广泛使用的避免过拟合的方式。Weight_decay 等价于在最终的损失函数后添加 L2 正则化，L2 正则化使得网络的权重倾向于选择更小的值，最终整个网络中的参数值更趋向于 0，模型的泛化性能相应提高。在各大深度学习框架的实现中，该值表达的含义是 L2 正则前的系数，在 paddle 框架中，该值的名称是 l2_decay，所以以下都称其为 l2_decay。该系数越大，表示加入的正则越强，模型越趋于欠拟合状态。在训练 ImageNet 的任务中，大多数的网络将该参数值设置为 1e-4，在一些小的网络如 MobileNet 系列网络中，为了避免网络欠拟合，该值设置为 1e-5~4e-5 之间。当然，该值的设置也和具体的数据集有关系，当任务的数据集较大时，网络本身趋向于欠拟合状态，可以将该值适当减小，当任务的数据集较小时，网络本身趋向于过拟合状态，可以将该值适当增大。下表展示了 MobileNetV1_x0_25 在 ImageNet-1k 上使用不同 l2_decay 的精度情况。由于 MobileNetV1_x0_25 是一个比较小的网络，所以 l2_decay 过大会使网络趋向于欠拟合状态，所以在该网络中，相对 1e-4，3e-5 是更好的选择。
| 模型 | L2_decay | Train acc1/acc5 | Test acc1/acc5 |
|:--:|:--:|:--:|:--:|
| MobileNetV1_x0_25 | 1e-4 | 43.79%/67.61% | 50.41%/74.70% |
| MobileNetV1_x0_25 | 3e-5 | 47.38%/70.83% | 51.45%/75.45% |
另外，该值的设置也和训练过程中是否使用其他正则化有关系。如果训练过程中的数据预处理比较复杂，相当于训练任务变的更难，可以将该值适当减小，下表展示了在ImageNet-1k上，ResNet50在使用randaugment预处理方式后使用不同l2_decay的精度。容易观察到，在任务变难后，使用更小的l2_decay有助于模型精度的提升。
另外，该值的设置也和训练过程中是否使用其他正则化有关系。如果训练过程中的数据预处理比较复杂，相当于训练任务变的更难，可以将该值适当减小，下表展示了在 ImageNet-1k 上，ResNet50 在使用 randaugment 预处理方式后使用不同 l2_decay 的精度。容易观察到，在任务变难后，使用更小的 l2_decay 有助于模型精度的提升。
| 模型 | L2_decay | Train acc1/acc5 | Test acc1/acc5 |
|:--:|:--:|:--:|:--:|
| ResNet50 | 1e-4 | 75.13%/90.42% | 77.65%/93.79% |
| ResNet50 | 7e-5 | 75.56%/90.55% | 78.04%/93.74% |
综上所述，l2_decay可以根据具体的任务和模型去做相应的调整，通常简单的任务或者较大的模型，推荐使用较大的l2_decay,复杂的任务或者较小的模型，推荐使用较小的l2_decay。
综上所述，l2_decay 可以根据具体的任务和模型去做相应的调整，通常简单的任务或者较大的模型，推荐使用较大的 l2_decay,复杂的任务或者较小的模型，推荐使用较小的 l2_decay。
## 5.label_smoothing的选择
Label_smoothing是深度学习中的一种正则化方法，其全称是 Label Smoothing Regularization(LSR)，即标签平滑正则化。在传统的分类任务计算损失函数时，是将真实的one hot标签与神经网络的输出做相应的交叉熵计算，而label_smoothing是将真实的one hot标签做一个标签平滑的处理，使得网络学习的标签不再是一个hard label，而是一个有概率值的soft label，其中在类别对应的位置的概率最大，其他位置概率是一个非常小的数。具体的计算方式参见论文[2]。在label_smoothing里，有一个epsilon的参数值，该值描述了将标签软化的程度，该值越大，经过label smoothing后的标签向量的标签概率值越小，标签越平滑，反之，标签越趋向于hard label，在训练ImageNet-1k的实验里通常将该值设置为0.1。
在训练ImageNet-1k的实验中，我们发现，ResNet50大小级别及其以上的模型在使用label_smooting后，精度有稳定的提升。下表展示了ResNet50_vd在使用label_smoothing前后的精度指标。
<a name='5'></a>
## 5.label_smoothing 的选择
Label_smoothing 是深度学习中的一种正则化方法，其全称是 Label Smoothing Regularization(LSR)，即标签平滑正则化。在传统的分类任务计算损失函数时，是将真实的 one hot 标签与神经网络的输出做相应的交叉熵计算，而 label_smoothing 是将真实的 one hot 标签做一个标签平滑的处理，使得网络学习的标签不再是一个 hard label，而是一个有概率值的 soft label，其中在类别对应的位置的概率最大，其他位置概率是一个非常小的数。具体的计算方式参见论文[2]。在 label_smoothing 里，有一个 epsilon 的参数值，该值描述了将标签软化的程度，该值越大，经过 label smoothing 后的标签向量的标签概率值越小，标签越平滑，反之，标签越趋向于 hard label，在训练 ImageNet-1k 的实验里通常将该值设置为 0.1。
在训练 ImageNet-1k 的实验中，我们发现，ResNet50 大小级别及其以上的模型在使用 label_smooting 后，精度有稳定的提升。下表展示了 ResNet50_vd 在使用 label_smoothing 前后的精度指标。
| 模型 | Use_label_smoothing | Test acc1 |
|:--:|:--:|:--:|
| ResNet50_vd | 0 | 77.9% |
| ResNet50_vd | 1 | 78.4% |
同时，由于label_smoohing相当于一种正则方式，在相对较小的模型上，精度提升不明显甚至会有所下降，下表展示了ResNet18在ImageNet-1k上使用label_smoothing前后的精度指标。可以明显看到，在使用label_smoothing后，精度有所下降。
同时，由于 label_smoohing 相当于一种正则方式，在相对较小的模型上，精度提升不明显甚至会有所下降，下表展示了 ResNet18 在 ImageNet-1k 上使用 label_smoothing 前后的精度指标。可以明显看到，在使用 label_smoothing 后，精度有所下降。
| 模型 | Use_label_smoohing | Train acc1/acc5 | Test acc1/acc5 |
|:--:|:--:|:--:|:--:|
@ -56,18 +87,22 @@ Label_smoothing是深度学习中的一种正则化方法，其全称是 Label S
| ResNet18 | 1 | 68.00%/86.56% | 70.81%/89.89% |
综上所述，较大的模型使用label_smoohing可以有效提升模型的精度，较小的模型使用label_smoohing可能会降低模型的精度，所以在决定是否使用label_smoohing前，需要评估模型的大小和任务的难易程度。
综上所述，较大的模型使用 label_smoohing 可以有效提升模型的精度，较小的模型使用 label_smoohing 可能会降低模型的精度，所以在决定是否使用 label_smoohing 前，需要评估模型的大小和任务的难易程度。
## 6.针对小模型更改图片的crop面积与拉伸变换程度
在ImageNet-1k数据的标准预处理中，random_crop函数中定义了scale和ratio两个值，两个值分别确定了图片crop的大小和图片的拉伸程度，其中scale的默认取值范围是0.08-1(lower_scale-upper_scale),ratio的默认取值范围是3/4-4/3(lower_ratio-upper_ratio)。在非常小的网络训练中，此类数据增强会使得网络欠拟合，导致精度有所下降。为了提升网络的精度，可以使其数据增强变的更弱，即增大图片的crop区域或者减弱图片的拉伸变换程度。我们可以分别通过增大lower_scale的值或缩小lower_ratio与upper_scale的差距来实现更弱的图片变换。下表列出了使用不同lower_scale训练MobileNetV2_x0_25的精度，可以看到，增大图片的crop区域面积后训练精度和验证精度均有提升。
<a name='6'></a>
| 模型 | Scale取值范围 | Train_acc1/acc5 | Test_acc1/acc5 |
## 6.针对小模型更改图片的 crop 面积与拉伸变换程度
在 ImageNet-1k 数据的标准预处理中，random_crop 函数中定义了 scale 和 ratio 两个值，两个值分别确定了图片 crop 的大小和图片的拉伸程度，其中 scale 的默认取值范围是 0.08-1(lower_scale-upper_scale),ratio 的默认取值范围是 3/4-4/3(lower_ratio-upper_ratio)。在非常小的网络训练中，此类数据增强会使得网络欠拟合，导致精度有所下降。为了提升网络的精度，可以使其数据增强变的更弱，即增大图片的 crop 区域或者减弱图片的拉伸变换程度。我们可以分别通过增大 lower_scale 的值或缩小 lower_ratio 与 upper_scale 的差距来实现更弱的图片变换。下表列出了使用不同 lower_scale 训练 MobileNetV2_x0_25 的精度，可以看到，增大图片的 crop 区域面积后训练精度和验证精度均有提升。
| 模型 | Scale 取值范围 | Train_acc1/acc5 | Test_acc1/acc5 |
|:--:|:--:|:--:|:--:|
| MobileNetV2_x0_25 | [0.08,1] | 50.36%/72.98% | 52.35%/75.65% |
| MobileNetV2_x0_25 | [0.2,1] | 54.39%/77.08% | 53.18%/76.14% |
<a name='7'></a>
## 7.使用数据增广方式提升精度
一般来说，数据集的规模对性能影响至关重要，但是图片的标注往往比较昂贵，所以有标注的图片数量往往比较稀少，在这种情况下，数据的增广尤为重要。在训练ImageNet-1k的标准数据增广中，主要使用了random_crop与random_flip两种数据增广方式，然而，近些年，越来越多的数据增广方式被提出，如cutout、mixup、cutmix、AutoAugment等。实验表明，这些数据的增广方式可以有效提升模型的精度，下表列出了ResNet50在8种不同的数据增广方式的表现，可以看出，相比baseline，所有的数据增广方式均有收益，其中cutmix是目前最有效的数据增广。更多数据增广的介绍请参考[**数据增广章节**](https://paddleclas.readthedocs.io/zh_CN/latest/advanced_tutorials/image_augmentation/ImageAugment.html)。
一般来说，数据集的规模对性能影响至关重要，但是图片的标注往往比较昂贵，所以有标注的图片数量往往比较稀少，在这种情况下，数据的增广尤为重要。在训练 ImageNet-1k 的标准数据增广中，主要使用了 random_crop 与 random_flip 两种数据增广方式，然而，近些年，越来越多的数据增广方式被提出，如 cutout、mixup、cutmix、AutoAugment 等。实验表明，这些数据的增广方式可以有效提升模型的精度，下表列出了 ResNet50 在 8 种不同的数据增广方式的表现，可以看出，相比 baseline，所有的数据增广方式均有收益，其中 cutmix 是目前最有效的数据增广。更多数据增广的介绍请参考[**数据增广章节**](https://paddleclas.readthedocs.io/zh_CN/latest/advanced_tutorials/image_augmentation/ImageAugment.html)。
| 模型 | 数据增广方式 | Test top-1 |
|:--:|:--:|:--:|
@ -81,16 +116,22 @@ Label_smoothing是深度学习中的一种正则化方法，其全称是 Label S
| ResNet50 | Random-Erasing | 77.91% |
| ResNet50 | Hide-and-Seek | 77.43% |
## 8. 通过train_acc和test_acc确定调优策略
在训练网络的过程中，通常会打印每一个epoch的训练集准确率和验证集准确率，二者刻画了该模型在两个数据集上的表现。通常来说，训练集的准确率比验证集准确率微高或者二者相当是比较不错的状态。如果发现训练集的准确率比验证集高很多，说明在这个任务上已经过拟合，需要在训练过程中加入更多的正则，如增大l2_decay的值，加入更多的数据增广策略，加入label_smoothing策略等；如果发现训练集的准确率比验证集低一些，说明在这个任务上可能欠拟合，需要在训练过程中减弱正则效果，如减小l2_decay的值，减少数据增广方式，增大图片crop区域面积，减弱图片拉伸变换，去除label_smoothing等。
<a name='8'></a>
## 8. 通过 train_acc 和 test_acc 确定调优策略
在训练网络的过程中，通常会打印每一个 epoch 的训练集准确率和验证集准确率，二者刻画了该模型在两个数据集上的表现。通常来说，训练集的准确率比验证集准确率微高或者二者相当是比较不错的状态。如果发现训练集的准确率比验证集高很多，说明在这个任务上已经过拟合，需要在训练过程中加入更多的正则，如增大 l2_decay 的值，加入更多的数据增广策略，加入 label_smoothing 策略等；如果发现训练集的准确率比验证集低一些，说明在这个任务上可能欠拟合，需要在训练过程中减弱正则效果，如减小 l2_decay 的值，减少数据增广方式，增大图片 crop 区域面积，减弱图片拉伸变换，去除 label_smoothing 等。
<a name='9'></a>
## 9.通过已有的预训练模型提升自己的数据集的精度
在现阶段计算机视觉领域中，加载预训练模型来训练自己的任务已成为普遍的做法，相比从随机初始化开始训练，加载预训练模型往往可以提升特定任务的精度。一般来说，业界广泛使用的预训练模型是通过训练128万张图片1000类的ImageNet-1k数据集得到的，该预训练模型的fc层权重是是一个k\*1000的矩阵，其中k是fc层以前的神经元数，在加载预训练权重时，无需加载fc层的权重。在学习率方面，如果您的任务训练的数据集特别小（如小于1千张），我们建议你使用较小的初始学习率，如0.001（batch_size:256,下同），以免较大的学习率破坏预训练权重。如果您的训练数据集规模相对较大（大于10万），我们建议你尝试更大的初始学习率，如0.01或者更大。
在现阶段计算机视觉领域中，加载预训练模型来训练自己的任务已成为普遍的做法，相比从随机初始化开始训练，加载预训练模型往往可以提升特定任务的精度。一般来说，业界广泛使用的预训练模型是通过训练 128 万张图片 1000 类的 ImageNet-1k 数据集得到的，该预训练模型的 fc 层权重是是一个 k\*1000 的矩阵，其中 k 是 fc 层以前的神经元数，在加载预训练权重时，无需加载 fc 层的权重。在学习率方面，如果您的任务训练的数据集特别小（如小于 1 千张），我们建议你使用较小的初始学习率，如 0.001（batch_size:256,下同），以免较大的学习率破坏预训练权重。如果您的训练数据集规模相对较大（大于 10 万），我们建议你尝试更大的初始学习率，如 0.01 或者更大。
> 如果您觉得此文档对您有帮助，欢迎star我们的项目：[https://github.com/PaddlePaddle/PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
> 如果您觉得此文档对您有帮助，欢迎 star 我们的项目：[https://github.com/PaddlePaddle/PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
## 参考文献
<a name='10'></a>
## 10. 参考文献
[1]P. Goyal, P. Dolla ́r, R. B. Girshick, P. Noordhuis, L. Wesolowski, A. Kyrola, A. Tulloch, Y. Jia, and K. He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017.
[2]C.Szegedy,V.Vanhoucke,S.Ioffe,J.Shlens,andZ.Wojna. Rethinking the inception architecture for computer vision. CoRR, abs/1512.00567, 2015.

17
docs/zh_CN/models/Twins.md
View File

@ -1,9 +1,18 @@
# Twins
---
## 目录
## 概述
Twins网络包括Twins-PCPVT和Twins-SVT，其重点对空间注意力机制进行了精心设计，得到了简单却更为有效的方案。由于该体系结构仅涉及矩阵乘法，而目前的深度学习框架中对矩阵乘法有较高的优化程度，因此该体系结构十分高效且易于实现。并且，该体系结构在图像分类、目标检测和语义分割等多种下游视觉任务中都能够取得优异的性能。[论文地址](https://arxiv.org/abs/2104.13840)。
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
## 精度、FLOPs和参数量
<a name='1'></a>
## 1. 概述
Twins 网络包括 Twins-PCPVT 和 Twins-SVT，其重点对空间注意力机制进行了精心设计，得到了简单却更为有效的方案。由于该体系结构仅涉及矩阵乘法，而目前的深度学习框架中对矩阵乘法有较高的优化程度，因此该体系结构十分高效且易于实现。并且，该体系结构在图像分类、目标检测和语义分割等多种下游视觉任务中都能够取得优异的性能。[论文地址](https://arxiv.org/abs/2104.13840)。
<a name='2'></a>
## 2. 精度、FLOPs 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPs<br>(G) | Params<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -14,4 +23,4 @@ Twins网络包括Twins-PCPVT和Twins-SVT，其重点对空间注意力机制进
| alt_gvt_base | 0.8294 | 0.9621 | 0.832 | - | 8.3 | 56 |
| alt_gvt_large | 0.8331 | 0.9642 | 0.837 | - | 14.8 | 99.2 |
**注**：与Reference的精度差异源于数据预处理不同。
**注**：与 Reference 的精度差异源于数据预处理不同。

21
docs/zh_CN/models/ViT_and_DeiT.md
View File

@ -1,15 +1,22 @@
# ViT与DeiT系列
# ViT 与 DeiT 系列
---
## 目录
## 概述
* [1. 概述](#1)
* [2. 精度、FLOPS 和参数量](#2)
ViT（Vision Transformer）系列模型是Google在2020年提出的，该模型仅使用标准的Transformer结构，完全抛弃了卷积结构，将图像拆分为多个patch后再输入到Transformer中，展示了Transformer在CV领域的潜力。[论文地址](https://arxiv.org/abs/2010.11929)。
<a name='1'></a>
DeiT（Data-efficient Image Transformers）系列模型是由FaceBook在2020年底提出的，针对ViT模型需要大规模数据集训练的问题进行了改进，最终在ImageNet上取得了83.1%的Top1精度。并且使用卷积模型作为教师模型，针对该模型进行知识蒸馏，在ImageNet数据集上可以达到85.2%的Top1精度。[论文地址](https://arxiv.org/abs/2012.12877)。
## 1. 概述
ViT（Vision Transformer）系列模型是 Google 在 2020 年提出的，该模型仅使用标准的 Transformer 结构，完全抛弃了卷积结构，将图像拆分为多个 patch 后再输入到 Transformer 中，展示了 Transformer 在 CV 领域的潜力。[论文地址](https://arxiv.org/abs/2010.11929)。
DeiT（Data-efficient Image Transformers）系列模型是由 FaceBook 在 2020 年底提出的，针对 ViT 模型需要大规模数据集训练的问题进行了改进，最终在 ImageNet 上取得了 83.1%的 Top1 精度。并且使用卷积模型作为教师模型，针对该模型进行知识蒸馏，在 ImageNet 数据集上可以达到 85.2% 的 Top1 精度。[论文地址](https://arxiv.org/abs/2012.12877)。
## 精度、FLOPS和参数量
<a name='2'></a>
## 2. 精度、FLOPS 和参数量
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Params<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
@ -33,4 +40,4 @@ DeiT（Data-efficient Image Transformers）系列模型是由FaceBook在2020年
| DeiT_base_distilled_patch16_224 | 0.831 | 0.964 | 0.834 | 0.965 | | |
| DeiT_base_distilled_patch16_384 | 0.851 | 0.973 | 0.852 | 0.972 | | |
关于Params、FLOPs、Inference speed等信息，敬请期待。
关于 Params、FLOPs、Inference speed 等信息，敬请期待。

132
docs/zh_CN/models/models_intro.md
View File

@ -1,13 +1,24 @@
# 模型库概览
---
## 目录
## 概述
* [1. 概述](#1)
* [2. 评估环境](#2)
* [3. 预训练模型列表及下载地址](#3)
* [4. 参考文献](#4)
基于ImageNet1k分类数据集，PaddleClas支持的36种系列分类网络结构以及对应的175个图像分类预训练模型如下所示，训练技巧、每个系列网络结构的简单介绍和性能评估将在相应章节展现。
<a name='1'></a>
## 评估环境
* CPU的评估环境基于骁龙855（SD855）。
* Intel CPU的评估环境基于Intel(R) Xeon(R) Gold 6148。
* GPU评估环境基于V100和TensorRT。
## 1. 概述
基于 ImageNet1k 分类数据集，PaddleClas 支持的 36 种系列分类网络结构以及对应的 175 个图像分类预训练模型如下所示，训练技巧、每个系列网络结构的简单介绍和性能评估将在相应章节展现。
<a name='2'></a>
## 2. 评估环境
* CPU 的评估环境基于骁龙 855（SD855）。
* Intel CPU 的评估环境基于 Intel(R) Xeon(R) Gold 6148。
* GPU 评估环境基于 V100 和 TensorRT。
![](../../images/models/T4_benchmark/t4.fp32.bs4.main_fps_top1.png)
@ -17,19 +28,20 @@
![](../../images/models/mobile_arm_top1.png)
> 如果您觉得此文档对您有帮助，欢迎star我们的项目：[https://github.com/PaddlePaddle/PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
> 如果您觉得此文档对您有帮助，欢迎 star 我们的项目：[https://github.com/PaddlePaddle/PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
<a name='3'></a>
## 预训练模型列表及下载地址
## 3. 预训练模型列表及下载地址
- ResNet及其Vd系列
- ResNet系列<sup>[[1](#ref1)]</sup>([论文地址](http://openaccess.thecvf.com/content_cvpr_2016/html/He_Deep_Residual_Learning_CVPR_2016_paper.html))
- ResNet 及其 Vd 系列
- ResNet 系列<sup>[[1](#ref1)]</sup>([论文地址](http://openaccess.thecvf.com/content_cvpr_2016/html/He_Deep_Residual_Learning_CVPR_2016_paper.html))
- [ResNet18](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet18_pretrained.pdparams)
- [ResNet34](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet34_pretrained.pdparams)
- [ResNet50](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_pretrained.pdparams)
- [ResNet101](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet101_pretrained.pdparams)
- [ResNet152](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet152_pretrained.pdparams)
- ResNet_vc、ResNet_vd系列<sup>[[2](#ref2)]</sup>([论文地址](https://arxiv.org/abs/1812.01187))
- ResNet_vc、ResNet_vd 系列<sup>[[2](#ref2)]</sup>([论文地址](https://arxiv.org/abs/1812.01187))
- [ResNet50_vc](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_vc_pretrained.pdparams)
- [ResNet18_vd](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet18_vd_pretrained.pdparams)
- [ResNet34_vd](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet34_vd_pretrained.pdparams)
@ -45,7 +57,7 @@
- 轻量级模型系列
- PP-LCNet系列<sup>[[28](#ref28)]</sup>([论文地址](https://arxiv.org/pdf/2109.15099.pdf))
- PP-LCNet 系列<sup>[[28](#ref28)]</sup>([论文地址](https://arxiv.org/pdf/2109.15099.pdf))
- [PPLCNet_x0_25](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x0_25_pretrained.pdparams)
- [PPLCNet_x0_35](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x0_35_pretrained.pdparams)
- [PPLCNet_x0_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x0_5_pretrained.pdparams)
@ -57,7 +69,7 @@
- [PPLCNet_x0_5_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x0_5_ssld_pretrained.pdparams)
- [PPLCNet_x1_0_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x1_0_ssld_pretrained.pdparams)
- [PPLCNet_x2_5_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x2_5_ssld_pretrained.pdparams)
- MobileNetV3系列<sup>[[3](#ref3)]</sup>([论文地址](https://arxiv.org/abs/1905.02244))
- MobileNetV3 系列<sup>[[3](#ref3)]</sup>([论文地址](https://arxiv.org/abs/1905.02244))
- [MobileNetV3_large_x0_35](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV3_large_x0_35_pretrained.pdparams)
- [MobileNetV3_large_x0_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV3_large_x0_5_pretrained.pdparams)
- [MobileNetV3_large_x0_75](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV3_large_x0_75_pretrained.pdparams)
@ -71,7 +83,7 @@
- [MobileNetV3_large_x1_0_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV3_large_x1_0_ssld_pretrained.pdparams)
- [MobileNetV3_large_x1_0_ssld_int8]()(coming soon)
- [MobileNetV3_small_x1_0_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV3_small_x1_0_ssld_pretrained.pdparams)
- MobileNetV2系列<sup>[[4](#ref4)]</sup>([论文地址](https://arxiv.org/abs/1801.04381))
- MobileNetV2 系列<sup>[[4](#ref4)]</sup>([论文地址](https://arxiv.org/abs/1801.04381))
- [MobileNetV2_x0_25](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV2_x0_25_pretrained.pdparams)
- [MobileNetV2_x0_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV2_x0_5_pretrained.pdparams)
- [MobileNetV2_x0_75](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV2_x0_75_pretrained.pdparams)
@ -79,13 +91,13 @@
- [MobileNetV2_x1_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV2_x1_5_pretrained.pdparams)
- [MobileNetV2_x2_0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV2_x2_0_pretrained.pdparams)
- [MobileNetV2_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV2_ssld_pretrained.pdparams)
- MobileNetV1系列<sup>[[5](#ref5)]</sup>([论文地址](https://arxiv.org/abs/1704.04861))
- MobileNetV1 系列<sup>[[5](#ref5)]</sup>([论文地址](https://arxiv.org/abs/1704.04861))
- [MobileNetV1_x0_25](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV1_x0_25_pretrained.pdparams)
- [MobileNetV1_x0_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV1_x0_5_pretrained.pdparams)
- [MobileNetV1_x0_75](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV1_x0_75_pretrained.pdparams)
- [MobileNetV1](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV1_pretrained.pdparams)
- [MobileNetV1_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MobileNetV1_ssld_pretrained.pdparams)
- ShuffleNetV2系列<sup>[[6](#ref6)]</sup>([论文地址](https://arxiv.org/abs/1807.11164))
- ShuffleNetV2 系列<sup>[[6](#ref6)]</sup>([论文地址](https://arxiv.org/abs/1807.11164))
- [ShuffleNetV2_x0_25](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ShuffleNetV2_x0_25_pretrained.pdparams)
- [ShuffleNetV2_x0_33](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ShuffleNetV2_x0_33_pretrained.pdparams)
- [ShuffleNetV2_x0_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ShuffleNetV2_x0_5_pretrained.pdparams)
@ -93,16 +105,16 @@
- [ShuffleNetV2_x1_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ShuffleNetV2_x1_5_pretrained.pdparams)
- [ShuffleNetV2_x2_0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ShuffleNetV2_x2_0_pretrained.pdparams)
- [ShuffleNetV2_swish](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ShuffleNetV2_swish_pretrained.pdparams)
- GhostNet系列<sup>[[23](#ref23)]</sup>([论文地址](https://arxiv.org/pdf/1911.11907.pdf))
- GhostNet 系列<sup>[[23](#ref23)]</sup>([论文地址](https://arxiv.org/pdf/1911.11907.pdf))
- [GhostNet_x0_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/GhostNet_x0_5_pretrained.pdparams)
- [GhostNet_x1_0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/GhostNet_x1_0_pretrained.pdparams)
- [GhostNet_x1_3](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/GhostNet_x1_3_pretrained.pdparams)
- [GhostNet_x1_3_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/GhostNet_x1_3_ssld_pretrained.pdparams)
- MixNet系列<sup>[[29](#ref29)]</sup>([论文地址](https://arxiv.org/pdf/1907.09595.pdf))
- MixNet 系列<sup>[[29](#ref29)]</sup>([论文地址](https://arxiv.org/pdf/1907.09595.pdf))
- [MixNet_S](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MixNet_S_pretrained.pdparams)
- [MixNet_M](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MixNet_M_pretrained.pdparams)
- [MixNet_L](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/MixNet_L_pretrained.pdparams)
- ReXNet系列<sup>[[30](#ref30)]</sup>([论文地址](https://arxiv.org/pdf/2007.00992.pdf))
- ReXNet 系列<sup>[[30](#ref30)]</sup>([论文地址](https://arxiv.org/pdf/2007.00992.pdf))
- [ReXNet_1_0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ReXNet_1_0_pretrained.pdparams)
- [ReXNet_1_3](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ReXNet_1_3_pretrained.pdparams)
- [ReXNet_1_5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ReXNet_1_5_pretrained.pdparams)
@ -110,32 +122,32 @@
- [ReXNet_3_0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ReXNet_3_0_pretrained.pdparams)
- SEResNeXt与Res2Net系列
- ResNeXt系列<sup>[[7](#ref7)]</sup>([论文地址](https://arxiv.org/abs/1611.05431))
- SEResNeXt 与 Res2Net 系列
- ResNeXt 系列<sup>[[7](#ref7)]</sup>([论文地址](https://arxiv.org/abs/1611.05431))
- [ResNeXt50_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt50_32x4d_pretrained.pdparams)
- [ResNeXt50_64x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt50_64x4d_pretrained.pdparams)
- [ResNeXt101_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_32x4d_pretrained.pdparams)
- [ResNeXt101_64x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_64x4d_pretrained.pdparams)
- [ResNeXt152_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt152_32x4d_pretrained.pdparams)
- [ResNeXt152_64x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt152_64x4d_pretrained.pdparams)
- ResNeXt_vd系列
- ResNeXt_vd 系列
- [ResNeXt50_vd_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt50_vd_32x4d_pretrained.pdparams)
- [ResNeXt50_vd_64x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt50_vd_64x4d_pretrained.pdparams)
- [ResNeXt101_vd_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_vd_32x4d_pretrained.pdparams)
- [ResNeXt101_vd_64x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_vd_64x4d_pretrained.pdparams)
- [ResNeXt152_vd_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt152_vd_32x4d_pretrained.pdparams)
- [ResNeXt152_vd_64x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt152_vd_64x4d_pretrained.pdparams)
- SE_ResNet_vd系列<sup>[[8](#ref8)]</sup>([论文地址](https://arxiv.org/abs/1709.01507))
- SE_ResNet_vd 系列<sup>[[8](#ref8)]</sup>([论文地址](https://arxiv.org/abs/1709.01507))
- [SE_ResNet18_vd](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SE_ResNet18_vd_pretrained.pdparams)
- [SE_ResNet34_vd](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SE_ResNet34_vd_pretrained.pdparams)
- [SE_ResNet50_vd](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SE_ResNet50_vd_pretrained.pdparams)
- SE_ResNeXt系列
- SE_ResNeXt 系列
- [SE_ResNeXt50_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SE_ResNeXt50_32x4d_pretrained.pdparams)
- [SE_ResNeXt101_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SE_ResNeXt101_32x4d_pretrained.pdparams)
- SE_ResNeXt_vd系列
- SE_ResNeXt_vd 系列
- [SE_ResNeXt50_vd_32x4d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SE_ResNeXt50_vd_32x4d_pretrained.pdparams)
- [SENet154_vd](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SENet154_vd_pretrained.pdparams)
- Res2Net系列<sup>[[9](#ref9)]</sup>([论文地址](https://arxiv.org/abs/1904.01169))
- Res2Net 系列<sup>[[9](#ref9)]</sup>([论文地址](https://arxiv.org/abs/1904.01169))
- [Res2Net50_26w_4s](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Res2Net50_26w_4s_pretrained.pdparams)
- [Res2Net50_vd_26w_4s](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Res2Net50_vd_26w_4s_pretrained.pdparams)
- [Res2Net50_vd_26w_4s_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Res2Net50_vd_26w_4s_ssld_pretrained.pdparams)
@ -146,14 +158,14 @@
- [Res2Net200_vd_26w_4s_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Res2Net200_vd_26w_4s_ssld_pretrained.pdparams)
- Inception系列
- GoogLeNet系列<sup>[[10](#ref10)]</sup>([论文地址](https://arxiv.org/pdf/1409.4842.pdf))
- Inception 系列
- GoogLeNet 系列<sup>[[10](#ref10)]</sup>([论文地址](https://arxiv.org/pdf/1409.4842.pdf))
- [GoogLeNet](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/GoogLeNet_pretrained.pdparams)
- InceptionV3系列<sup>[[26](#ref26)]</sup>([论文地址](https://arxiv.org/abs/1512.00567))
- InceptionV3 系列<sup>[[26](#ref26)]</sup>([论文地址](https://arxiv.org/abs/1512.00567))
- [InceptionV3](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/InceptionV3_pretrained.pdparams)
- InceptionV4系列<sup>[[11](#ref11)]</sup>([论文地址](https://arxiv.org/abs/1602.07261))
- InceptionV4 系列<sup>[[11](#ref11)]</sup>([论文地址](https://arxiv.org/abs/1602.07261))
- [InceptionV4](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/InceptionV4_pretrained.pdparams)
- Xception系列<sup>[[12](#ref12)]</sup>([论文地址](http://openaccess.thecvf.com/content_cvpr_2017/html/Chollet_Xception_Deep_Learning_CVPR_2017_paper.html))
- Xception 系列<sup>[[12](#ref12)]</sup>([论文地址](http://openaccess.thecvf.com/content_cvpr_2017/html/Chollet_Xception_Deep_Learning_CVPR_2017_paper.html))
- [Xception41](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Xception41_pretrained.pdparams)
- [Xception41_deeplab](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Xception41_deeplab_pretrained.pdparams)
- [Xception65](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Xception65_pretrained.pdparams)
@ -161,8 +173,8 @@
- [Xception71](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Xception71_pretrained.pdparams)
- HRNet系列
- HRNet系列<sup>[[13](#ref13)]</sup>([论文地址](https://arxiv.org/abs/1908.07919))
- HRNet 系列
- HRNet 系列<sup>[[13](#ref13)]</sup>([论文地址](https://arxiv.org/abs/1908.07919))
- [HRNet_W18_C](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HRNet_W18_C_pretrained.pdparams)
- [HRNet_W18_C_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HRNet_W18_C_ssld_pretrained.pdparams)
- [HRNet_W30_C](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HRNet_W30_C_pretrained.pdparams)
@ -174,14 +186,14 @@
- [HRNet_W64_C](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HRNet_W64_C_pretrained.pdparams)
- [SE_HRNet_W64_C_ssld](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SE_HRNet_W64_C_ssld_pretrained.pdparams)
- DPN与DenseNet系列
- DPN系列<sup>[[14](#ref14)]</sup>([论文地址](https://arxiv.org/abs/1707.01629))
- DPN 与 DenseNet 系列
- DPN 系列<sup>[[14](#ref14)]</sup>([论文地址](https://arxiv.org/abs/1707.01629))
- [DPN68](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DPN68_pretrained.pdparams)
- [DPN92](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DPN92_pretrained.pdparams)
- [DPN98](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DPN98_pretrained.pdparams)
- [DPN107](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DPN107_pretrained.pdparams)
- [DPN131](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DPN131_pretrained.pdparams)
- DenseNet系列<sup>[[15](#ref15)]</sup>([论文地址](https://arxiv.org/abs/1608.06993))
- DenseNet 系列<sup>[[15](#ref15)]</sup>([论文地址](https://arxiv.org/abs/1608.06993))
- [DenseNet121](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DenseNet121_pretrained.pdparams)
- [DenseNet161](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DenseNet161_pretrained.pdparams)
- [DenseNet169](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DenseNet169_pretrained.pdparams)
@ -189,8 +201,8 @@
- [DenseNet264](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DenseNet264_pretrained.pdparams)
- EfficientNet与ResNeXt101_wsl系列
- EfficientNet系列<sup>[[16](#ref16)]</sup>([论文地址](https://arxiv.org/abs/1905.11946))
- EfficientNet 与 ResNeXt101_wsl 系列
- EfficientNet 系列<sup>[[16](#ref16)]</sup>([论文地址](https://arxiv.org/abs/1905.11946))
- [EfficientNetB0_small](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/EfficientNetB0_small_pretrained.pdparams)
- [EfficientNetB0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/EfficientNetB0_pretrained.pdparams)
- [EfficientNetB1](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/EfficientNetB1_pretrained.pdparams)
@ -200,22 +212,22 @@
- [EfficientNetB5](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/EfficientNetB5_pretrained.pdparams)
- [EfficientNetB6](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/EfficientNetB6_pretrained.pdparams)
- [EfficientNetB7](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/EfficientNetB7_pretrained.pdparams)
- ResNeXt101_wsl系列<sup>[[17](#ref17)]</sup>([论文地址](https://arxiv.org/abs/1805.00932))
- ResNeXt101_wsl 系列<sup>[[17](#ref17)]</sup>([论文地址](https://arxiv.org/abs/1805.00932))
- [ResNeXt101_32x8d_wsl](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_32x8d_wsl_pretrained.pdparams)
- [ResNeXt101_32x16d_wsl](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_32x16d_wsl_pretrained.pdparams)
- [ResNeXt101_32x32d_wsl](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_32x32d_wsl_pretrained.pdparams)
- [ResNeXt101_32x48d_wsl](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeXt101_32x48d_wsl_pretrained.pdparams)
- [Fix_ResNeXt101_32x48d_wsl](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/Fix_ResNeXt101_32x48d_wsl_pretrained.pdparams)
- ResNeSt与RegNet系列
- ResNeSt系列<sup>[[24](#ref24)]</sup>([论文地址](https://arxiv.org/abs/2004.08955))
- ResNeSt 与 RegNet 系列
- ResNeSt 系列<sup>[[24](#ref24)]</sup>([论文地址](https://arxiv.org/abs/2004.08955))
- [ResNeSt50_fast_1s1x64d](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeSt50_fast_1s1x64d_pretrained.pdparams)
- [ResNeSt50](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNeSt50_pretrained.pdparams)
- RegNet系列<sup>[[25](#ref25)]</sup>([paper link](https://arxiv.org/abs/2003.13678))
- RegNet 系列<sup>[[25](#ref25)]</sup>([paper link](https://arxiv.org/abs/2003.13678))
- [RegNetX_4GF](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RegNetX_4GF_pretrained.pdparams)
- Transformer系列
- Swin-transformer系列<sup>[[27](#ref27)]</sup>([论文地址](https://arxiv.org/pdf/2103.14030.pdf))
- Transformer 系列
- Swin-transformer 系列<sup>[[27](#ref27)]</sup>([论文地址](https://arxiv.org/pdf/2103.14030.pdf))
- [SwinTransformer_tiny_patch4_window7_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SwinTransformer_tiny_patch4_window7_224_pretrained.pdparams)
- [SwinTransformer_small_patch4_window7_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SwinTransformer_small_patch4_window7_224_pretrained.pdparams)
- [SwinTransformer_base_patch4_window7_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SwinTransformer_base_patch4_window7_224_pretrained.pdparams)
@ -226,7 +238,7 @@
- [SwinTransformer_large_patch4_window12_384_22kto1k](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SwinTransformer_large_patch4_window12_384_22kto1k_pretrained.pdparams)
- [SwinTransformer_large_patch4_window7_224_22k](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SwinTransformer_large_patch4_window7_224_22k_pretrained.pdparams)
- [SwinTransformer_large_patch4_window7_224_22kto1k](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SwinTransformer_large_patch4_window7_224_22kto1k_pretrained.pdparams)
- ViT系列<sup>[[31](#ref31)]</sup>([论文地址](https://arxiv.org/pdf/2010.11929.pdf))
- ViT 系列<sup>[[31](#ref31)]</sup>([论文地址](https://arxiv.org/pdf/2010.11929.pdf))
- [ViT_small_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ViT_small_patch16_224_pretrained.pdparams)
- [ViT_base_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ViT_base_patch16_224_pretrained.pdparams)
- [ViT_base_patch16_384](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ViT_base_patch16_384_pretrained.pdparams)
@ -234,7 +246,7 @@
- [ViT_large_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ViT_large_patch16_224_pretrained.pdparams)
- [ViT_large_patch16_384](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ViT_large_patch16_384_pretrained.pdparams)
- [ViT_large_patch32_384](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ViT_large_patch32_384_pretrained.pdparams)
- DeiT系列<sup>[[32](#ref32)]</sup>([论文地址](https://arxiv.org/pdf/2012.12877.pdf))
- DeiT 系列<sup>[[32](#ref32)]</sup>([论文地址](https://arxiv.org/pdf/2012.12877.pdf))
- [DeiT_tiny_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DeiT_tiny_patch16_224_pretrained.pdparams)
- [DeiT_small_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DeiT_small_patch16_224_pretrained.pdparams)
- [DeiT_base_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DeiT_base_patch16_224_pretrained.pdparams)
@ -243,36 +255,36 @@
- [DeiT_small_distilled_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DeiT_small_distilled_patch16_224_pretrained.pdparams)
- [DeiT_base_distilled_patch16_224](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DeiT_base_distilled_patch16_224_pretrained.pdparams)
- [DeiT_base_distilled_patch16_384](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DeiT_base_distilled_patch16_384_pretrained.pdparams)
- LeViT系列<sup>[[33](#ref33)]</sup>([论文地址](https://arxiv.org/pdf/2104.01136.pdf))
- LeViT 系列<sup>[[33](#ref33)]</sup>([论文地址](https://arxiv.org/pdf/2104.01136.pdf))
- [LeViT_128S](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/LeViT_128S_pretrained.pdparams)
- [LeViT_128](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/LeViT_128_pretrained.pdparams)
- [LeViT_192](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/LeViT_192_pretrained.pdparams)
- [LeViT_256](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/LeViT_256_pretrained.pdparams)
- [LeViT_384](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/LeViT_384_pretrained.pdparams)
- Twins系列<sup>[[34](#ref34)]</sup>([论文地址](https://arxiv.org/pdf/2104.13840.pdf))
- Twins 系列<sup>[[34](#ref34)]</sup>([论文地址](https://arxiv.org/pdf/2104.13840.pdf))
- [pcpvt_small](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/pcpvt_small_pretrained.pdparams)
- [pcpvt_base](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/pcpvt_base_pretrained.pdparams)
- [pcpvt_large](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/pcpvt_large_pretrained.pdparams)
- [alt_gvt_small](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/alt_gvt_small_pretrained.pdparams)
- [alt_gvt_base](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/alt_gvt_base_pretrained.pdparams)
- [alt_gvt_large](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/alt_gvt_large_pretrained.pdparams)
- TNT系列<sup>[[35](#ref35)]</sup>([论文地址](https://arxiv.org/pdf/2103.00112.pdf))
- TNT 系列<sup>[[35](#ref35)]</sup>([论文地址](https://arxiv.org/pdf/2103.00112.pdf))
- [TNT_small](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/TNT_small_pretrained.pdparams)
- 其他模型
- AlexNet系列<sup>[[18](#ref18)]</sup>([论文地址](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf))
- AlexNet 系列<sup>[[18](#ref18)]</sup>([论文地址](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf))
- [AlexNet](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/AlexNet_pretrained.pdparams)
- SqueezeNet系列<sup>[[19](#ref19)]</sup>([论文地址](https://arxiv.org/abs/1602.07360))
- SqueezeNet 系列<sup>[[19](#ref19)]</sup>([论文地址](https://arxiv.org/abs/1602.07360))
- [SqueezeNet1_0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SqueezeNet1_0_pretrained.pdparams)
- [SqueezeNet1_1](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/SqueezeNet1_1_pretrained.pdparams)
- VGG系列<sup>[[20](#ref20)]</sup>([论文地址](https://arxiv.org/abs/1409.1556))
- VGG 系列<sup>[[20](#ref20)]</sup>([论文地址](https://arxiv.org/abs/1409.1556))
- [VGG11](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/VGG11_pretrained.pdparams)
- [VGG13](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/VGG13_pretrained.pdparams)
- [VGG16](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/VGG16_pretrained.pdparams)
- [VGG19](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/VGG19_pretrained.pdparams)
- DarkNet系列<sup>[[21](#ref21)]</sup>([论文地址](https://arxiv.org/abs/1506.02640))
- DarkNet 系列<sup>[[21](#ref21)]</sup>([论文地址](https://arxiv.org/abs/1506.02640))
- [DarkNet53](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DarkNet53_pretrained.pdparams)
- RepVGG系列<sup>[[36](#ref36)]</sup>([论文地址](https://arxiv.org/pdf/2101.03697.pdf))
- RepVGG 系列<sup>[[36](#ref36)]</sup>([论文地址](https://arxiv.org/pdf/2101.03697.pdf))
- [RepVGG_A0](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RepVGG_A0_pretrained.pdparams)
- [RepVGG_A1](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RepVGG_A1_pretrained.pdparams)
- [RepVGG_A2](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RepVGG_A2_pretrained.pdparams)
@ -283,12 +295,12 @@
- [RepVGG_B1g4](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RepVGG_B1g4_pretrained.pdparams)
- [RepVGG_B2g4](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RepVGG_B2g4_pretrained.pdparams)
- [RepVGG_B3g4](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RepVGG_B3g4_pretrained.pdparams)
- HarDNet系列<sup>[[37](#ref37)]</sup>([论文地址](https://arxiv.org/pdf/1909.00948.pdf))
- HarDNet 系列<sup>[[37](#ref37)]</sup>([论文地址](https://arxiv.org/pdf/1909.00948.pdf))
- [HarDNet39_ds](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HarDNet39_ds_pretrained.pdparams)
- [HarDNet68_ds](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HarDNet68_ds_pretrained.pdparams)
- [HarDNet68](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HarDNet68_pretrained.pdparams)
- [HarDNet85](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/HarDNet85_pretrained.pdparams)
- DLA系列<sup>[[38](#ref38)]</sup>([论文地址](https://arxiv.org/pdf/1707.06484.pdf))
- DLA 系列<sup>[[38](#ref38)]</sup>([论文地址](https://arxiv.org/pdf/1707.06484.pdf))
- [DLA102](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DLA102_pretrained.pdparams)
- [DLA102x2](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DLA102x2_pretrained.pdparams)
- [DLA102x](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DLA102x_pretrained.pdparams)
@ -298,7 +310,7 @@
- [DLA60](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DLA60_pretrained.pdparams)
- [DLA60x_c](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DLA60x_c_pretrained.pdparams)
- [DLA60x](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/DLA60x_pretrained.pdparams)
- RedNet系列<sup>[[39](#ref39)]</sup>([论文地址](https://arxiv.org/pdf/2103.06255.pdf))
- RedNet 系列<sup>[[39](#ref39)]</sup>([论文地址](https://arxiv.org/pdf/2103.06255.pdf))
- [RedNet26](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RedNet26_pretrained.pdparams)
- [RedNet38](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RedNet38_pretrained.pdparams)
- [RedNet50](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/RedNet50_pretrained.pdparams)
@ -307,9 +319,11 @@
**注意**：以上模型中EfficientNetB1-B7的预训练模型转自[pytorch版EfficientNet](https://github.com/lukemelas/EfficientNet-PyTorch)，ResNeXt101_wsl系列预训练模型转自[官方repo](https://github.com/facebookresearch/WSL-Images)，剩余预训练模型均基于飞桨训练得到的，并在configs里给出了相应的训练超参数。
**注意**：以上模型中 EfficientNetB1-B7 的预训练模型转自[pytorch版 EfficientNet](https://github.com/lukemelas/EfficientNet-PyTorch)，ResNeXt101_wsl 系列预训练模型转自[官方 repo](https://github.com/facebookresearch/WSL-Images)，剩余预训练模型均基于飞桨训练得到的，并在 configs 里给出了相应的训练超参数。
## 参考文献
<a name='4'></a>
## 4. 参考文献
<a name="ref1">[1]</a> He K, Zhang X, Ren S, et al. Deep residual learning for image recognition[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2016: 770-778.

24
docs/zh_CN/models_training/classification.md
View File

@ -17,7 +17,7 @@
- [2.1 数据及其预处理](#2.1)
- [2.2 模型准备](#2.2)
- [2.3 模型训练](#2.3)
- [2.3 模型评估](#2.4)
- [2.4 模型评估](#2.4)
- [3. 使用方法介绍](#3)
- [3.1 基于 CPU /单卡 GPU 上的训练与评估](#3.1)
- [3.1.1 模型训练](#3.1.1)
@ -39,12 +39,12 @@
<a name="1.1"></a>
### 1.1 ImageNet-1k
ImageNet 项目是一个大型视觉数据库，用于视觉目标识别软件研究。该项目已手动注释了 1400 多万张图像，以指出图片中的对象，并在至少 100 万张图像中提供了边框。ImageNet-1k 是 ImageNet 数据集的子集，其包含1000 个类别。训练集包含 1281167 个图像数据，验证集包含 50000 个图像数据。2010 年以来，ImageNet 项目每年举办一次图像分类竞赛，即 ImageNet 大规模视觉识别挑战赛 (ILSVRC)。挑战赛使用的数据集即为 ImageNet-1k。到目前为止，ImageNet-1k 已经成为计算机视觉领域发展的最重要的数据集之一，其促进了整个计算机视觉的发展，很多计算机视觉下游任务的初始化模型都是基于该数据集训练得到的权重。
ImageNet 项目是一个大型视觉数据库，用于视觉目标识别软件研究。该项目已手动注释了 1400 多万张图像，以指出图片中的对象，并在至少 100 万张图像中提供了边框。ImageNet-1k 是 ImageNet 数据集的子集，其包含 1000 个类别。训练集包含 1281167 个图像数据，验证集包含 50000 个图像数据。2010 年以来，ImageNet 项目每年举办一次图像分类竞赛，即 ImageNet 大规模视觉识别挑战赛 (ILSVRC)。挑战赛使用的数据集即为 ImageNet-1k。到目前为止，ImageNet-1k 已经成为计算机视觉领域发展的最重要的数据集之一，其促进了整个计算机视觉的发展，很多计算机视觉下游任务的初始化模型都是基于该数据集训练得到的权重。
<a name="1.2"></a>
### 1.2 CIFAR-10/CIFAR-100
CIFAR-10 数据集由 10 个类的 60000 个彩色图像组成，图像分辨率为 32x32，每个类有 6000 个图像，其中训练集 5000 张，验证集 1000 张，10 个不同的类代表飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、轮船和卡车。CIFAR-100 数据集是 CIFAR-10 的扩展，由 100 个类的 60000 个彩色图像组成，图像分辨率为 32x32，每个类有600 个图像，其中训练集 500 张，验证集 100 张。由于这两个数据集规模较小，因此可以让研究人员快速尝试不同的算法。这两个数据集也是图像分类领域测试模型好坏的常用数据集。
CIFAR-10 数据集由 10 个类的 60000 个彩色图像组成，图像分辨率为 32x32，每个类有 6000 个图像，其中训练集 5000 张，验证集 1000 张，10 个不同的类代表飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、轮船和卡车。CIFAR-100 数据集是 CIFAR-10 的扩展，由 100 个类的 60000 个彩色图像组成，图像分辨率为 32x32，每个类有 600 个图像，其中训练集 500 张，验证集 100 张。由于这两个数据集规模较小，因此可以让研究人员快速尝试不同的算法。这两个数据集也是图像分类领域测试模型好坏的常用数据集。
<a name="2"></a>
## 2. 图像分类的流程
@ -79,18 +79,18 @@ CIFAR-10 数据集由 10 个类的 60000 个彩色图像组成，图像分辨率
PaddleClas 目前支持的训练/评估环境如下：
```shell
└── CPU/单卡GPU
└── CPU/单卡 GPU
   ├── Linux
   └── Windows
└── 多卡GPU
└── 多卡 GPU
└── Linux
```
<a name="3.1"></a>
### 3.1 基于CPU/单卡GPU上的训练与评估
### 3.1 基于 CPU/单卡 GPU 上的训练与评估
在基于 CPU/单卡 GPU 上训练与评估，推荐使用 `tools/train.py` 与 `tools/eval.py` 脚本。关于 Linux 平台多卡 GPU 环境下的训练与评估，请参考 [3.2. 基于Linux+GPU的模型训练与评估](#3.2)。
在基于 CPU/单卡 GPU 上训练与评估，推荐使用 `tools/train.py` 与 `tools/eval.py` 脚本。关于 Linux 平台多卡 GPU 环境下的训练与评估，请参考 [3.2. 基于 Linux+GPU 的模型训练与评估](#3.2)。
<a name="3.1.1"></a>
@ -111,7 +111,7 @@ python3 tools/train.py \
运行上述命令，可以看到输出日志，示例如下：
* 如果在训练中使用了 mixup 或者 cutmix 的数据增广方式，那么日志中将不会打印 top-1 与 top-k（默认为5）信息：
* 如果在训练中使用了 mixup 或者 cutmix 的数据增广方式，那么日志中将不会打印 top-1 与 top-k（默认为 5）信息：
```
...
[Train][Epoch 3/20][Avg]CELoss: 6.46287, loss: 6.46287
@ -120,7 +120,7 @@ python3 tools/train.py \
...
```
* 如果训练过程中没有使用 mixup 或者 cutmix 的数据增广，那么除了上述信息外，日志中也会打印出 top-1 与top-k（默认为5）的信息：
* 如果训练过程中没有使用 mixup 或者 cutmix 的数据增广，那么除了上述信息外，日志中也会打印出 top-1 与 top-k（默认为 5）的信息：
```
...
@ -214,7 +214,7 @@ python3 tools/eval.py \
参考如下方式启动模型训练，`paddle.distributed.launch` 通过设置 `gpus` 指定 GPU 运行卡号：
```bash
# PaddleClas通过launch方式启动多卡多进程训练
# PaddleClas 通过 launch 方式启动多卡多进程训练
export CUDA_VISIBLE_DEVICES=0,1,2,3
python3 -m paddle.distributed.launch \
@ -313,7 +313,7 @@ python3 tools/export_model.py \
上述命令将生成模型结构文件(`inference.pdmodel`) 和模型权重文件(`inference.pdiparams`)，然后可以使用预测引擎进行推理：
进入deploy目录下：
进入 deploy 目录下：
```bash
cd deploy
@ -340,4 +340,4 @@ python3 python/predict_cls.py \
注意: 如果使用 `Transformer` 系列模型，如 `DeiT_***_384`, `ViT_***_384` 等，请注意模型的输入数据尺寸，需要设置参数 `resize_short=384`, `resize=384`。
如果你希望提升评测模型速度，使用 GPU 评测时，建议开启 TensorRT 加速预测，使用 CPU 评测时，建议开启MKLDNN 加速预测。
如果你希望提升评测模型速度，使用 GPU 评测时，建议开启 TensorRT 加速预测，使用 CPU 评测时，建议开启 MKLDNN 加速预测。

20
docs/zh_CN/models_training/config_description.md
View File

@ -17,10 +17,10 @@
- [1.2 结构(Arch)](#1.2)
- [1.3 损失函数(Loss)](#1.3)
- [1.4 优化器(Optimizer)](#1.4)
- [1.5数据读取模块(DataLoader)](#1.5)
- [1.5 数据读取模块(DataLoader)](#1.5)
- [1.5.1 dataset](#1.5.1)
- [1.5.1 sampler](#1.5.2)
- [1.5.1 loader](#1.5.3)
- [1.5.2 sampler](#1.5.2)
- [1.5.3 loader](#1.5.3)
- [1.6 评估指标(Metric)](#1.6)
- [2. 蒸馏模型](#2)
- [2.1 结构(Arch)](#2.1)
@ -29,7 +29,7 @@
- [3. 识别模型](#3)
- [3.1 结构(Arch)](#3.1)
- [3.2 评估指标(Metric)](#3.2)
<a name="1"></a>
### 1.分类模型
@ -47,7 +47,7 @@
| save_interval | 每隔多少个 epoch 保存模型 | 1 | int |
| eval_during_train| 是否在训练时进行评估 | True | bool |
| eval_interval | 每隔多少个 epoch 进行模型评估 | 1 | int |
| epochs | 训练总epoch数 | | int |
| epochs | 训练总 epoch 数 | | int |
| print_batch_step | 每隔多少个 mini-batch 打印输出 | 10 | int |
| use_visualdl | 是否是用 visualdl 可视化训练过程 | False | bool |
| image_shape | 图片大小 | [3, 224, 224] | list, shape: (3,) |
@ -67,7 +67,7 @@
| class_num | 分类数 | 1000 | int |
| pretrained | 预训练模型 | False | bool, str |
**注**：此处的pretrained可以设置为 `True` 或者 `False`，也可以设置权重的路径。另外当 `Global.pretrained_model` 也设置相应路径时，此处的 `pretrained` 失效。
**注**：此处的 pretrained 可以设置为 `True` 或者 `False`，也可以设置权重的路径。另外当 `Global.pretrained_model` 也设置相应路径时，此处的 `pretrained` 失效。
<a name="1.3"></a>
#### 1.3 损失函数（Loss）
@ -87,7 +87,7 @@
| momentum | momentum 值 | 0.9 | float |
| lr.name | 学习率下降方式 | "Cosine" | "Linear"、"Piecewise"等其他下降方式 |
| lr.learning_rate | 学习率初始值 | 0.1 | float |
| lr.warmup_epoch | warmup 轮数 | 0 | int，如5 |
| lr.warmup_epoch | warmup 轮数 | 0 | int，如 5 |
| regularizer.name | 正则化方法名 | "L2" | ["L1", "L2"] |
| regularizer.coeff | 正则化系数 | 0.00007 | float |
@ -104,7 +104,7 @@
添加方法及参数请查看 [learning_rate.py](../../../ppcls/optimizer/learning_rate.py)。
<a name="1.5"></a>
#### 1.5数据读取模块(DataLoader)
#### 1.5 数据读取模块(DataLoader)
<a name="1.5.1"></a>
##### 1.5.1 dataset
@ -245,9 +245,9 @@ batch_transform_ops 中参数的含义：
| infer_add_softmax | infercne 是否添加 softmax | False | [True, False] |
| Backbone.name | Backbone 的名字 | ResNet50_last_stage_stride1 | PaddleClas 提供的其他 backbone |
| Backbone.pretrained | Backbone 预训练模型 | True | 布尔值或者预训练模型路径 |
| BackboneStopLayer.name | Backbone 中的输出层名字 | True | Backbone中的特征输出层的 `full_name` |
| BackboneStopLayer.name | Backbone 中的输出层名字 | True | Backbone 中的特征输出层的 `full_name` |
| Neck.name | 网络 Neck 部分名字 | VehicleNeck | 需传入字典结构，Neck 网络层的具体输入参数 |
| Neck.in_channels | 输入 Neck 部分的维度大小 | 2048 | 与BackboneStopLayer.name层的大小相同 |
| Neck.in_channels | 输入 Neck 部分的维度大小 | 2048 | 与 BackboneStopLayer.name 层的大小相同 |
| Neck.out_channels | 输出 Neck 部分的维度大小，即特征维度大小 | 512 | int |
| Head.name | 网络 Head 部分名字 | CircleMargin | Arcmargin 等 |
| Head.embedding_size | 特征维度大小 | 512 | 与 Neck.out_channels 保持一致 |

26
docs/zh_CN/models_training/recognition.md
View File

@ -22,7 +22,7 @@
- [1. 主体检测](#1)
- [2. 特征模型训练](#2)
- [2.1. 特征模型数据准备与处理](#2.1)
- [2. 2特征模型基于单卡 GPU 上的训练与评估](#2.2)
- [2. 2 特征模型基于单卡 GPU 上的训练与评估](#2.2)
- [2.2.1 特征模型训练](#2.2.2)
- [2.2.2 特征模型恢复训练](#2.2.2)
- [2.2.3 特征模型评估](#2.2.3)
@ -55,11 +55,11 @@
* 进入 `PaddleClas` 目录。
```bash
## linux or mac， $path_to_PaddleClas表示PaddleClas的根目录，用户需要根据自己的真实目录修改
## linux or mac， $path_to_PaddleClas 表示 PaddleClas 的根目录，用户需要根据自己的真实目录修改
cd $path_to_PaddleClas
```
* 进入 `dataset` 目录，为了快速体验PaddleClas图像检索模块，此处使用的数据集为 [CUB_200_2011](http://vision.ucsd.edu/sites/default/files/WelinderEtal10_CUB-200.pdf)，其是一个包含200类鸟的细粒度鸟类数据集。首先，下载 CUB_200_2011 数据集，下载方式请参考[官网](http://www.vision.caltech.edu/visipedia/CUB-200-2011.html)。
* 进入 `dataset` 目录，为了快速体验 PaddleClas 图像检索模块，此处使用的数据集为 [CUB_200_2011](http://vision.ucsd.edu/sites/default/files/WelinderEtal10_CUB-200.pdf)，其是一个包含 200 类鸟的细粒度鸟类数据集。首先，下载 CUB_200_2011 数据集，下载方式请参考[官网](http://www.vision.caltech.edu/visipedia/CUB-200-2011.html)。
```shell
# linux or mac
@ -71,21 +71,21 @@ cp {数据存放的路径}/CUB_200_2011.tgz .
# 解压
tar -xzvf CUB_200_2011.tgz
#进入CUB_200_2011目录
#进入 CUB_200_2011 目录
cd CUB_200_2011
```
该数据集在用作图像检索任务时，通常将前 100 类当做训练集，后 100 类当做测试集，所以此处需要将下载的数据集做一些后处理，来更好的适应 PaddleClas 的图像检索训练。
```shell
#新建train和test目录
#新建 train 和 test 目录
mkdir train && mkdir test
#将数据分成训练集和测试集，前100类作为训练集，后100类作为测试集
#将数据分成训练集和测试集，前 100 类作为训练集，后 100 类作为测试集
ls images | awk -F "." '{if(int($1)<101)print "mv images/"$0" train/"int($1)}' | sh
ls images | awk -F "." '{if(int($1)>100)print "mv images/"$0" test/"int($1)}' | sh
#生成train_list和test_list
#生成 train_list 和 test_list
tree -r -i -f train | grep jpg | awk -F "/" '{print $0" "int($2) " "NR}' > train_list.txt
tree -r -i -f test | grep jpg | awk -F "/" '{print $0" "int($2) " "NR}' > test_list.txt
```
@ -143,12 +143,12 @@ cd ../../
准备好配置文件之后，可以使用下面的方式启动图像检索任务的训练。PaddleClas 训练图像检索任务的方法是度量学习，关于度量学习的解析请参考[度量学习](#度量学习)。
```shell
# 单卡GPU
# 单卡 GPU
python3 tools/train.py \
-c ./ppcls/configs/quick_start/MobileNetV1_retrieval.yaml \
-o Arch.Backbone.pretrained=True \
-o Global.device=gpu
# 多卡GPU
# 多卡 GPU
export CUDA_VISIBLE_DEVICES=0,1,2,3
python3 -m paddle.distributed.launch tools/train.py \
-c ./ppcls/configs/quick_start/MobileNetV1_retrieval.yaml \
@ -169,7 +169,7 @@ python3 -m paddle.distributed.launch tools/train.py \
[Eval][Epoch 1][Avg]recall1: 0.46962, recall5: 0.75608, mAP: 0.21238
...
```
此处配置文件的 Backbone 是 MobileNetV1，如果想使用其他 Backbone，可以重写参数 `Arch.Backbone.name`，比如命令中增加 `-o Arch.Backbone.name={其他Backbone}`。此外，由于不同模型`Neck`部分的输入维度不同，更换 Backbone 后可能需要改写此处的输入大小，改写方式类似替换 Backbone 的名字。
此处配置文件的 Backbone 是 MobileNetV1，如果想使用其他 Backbone，可以重写参数 `Arch.Backbone.name`，比如命令中增加 `-o Arch.Backbone.name={其他 Backbone}`。此外，由于不同模型`Neck`部分的输入维度不同，更换 Backbone 后可能需要改写此处的输入大小，改写方式类似替换 Backbone 的名字。
在训练 Loss 部分，此处使用了 [CELoss](../../../ppcls/loss/celoss.py) 和 [TripletLossV2](../../../ppcls/loss/triplet.py)，配置文件如下：
@ -252,7 +252,7 @@ python3 -m paddle.distributed.launch tools/eval.py \
**注意：**
* 在加载待评估模型时，需要指定模型文件的路径，但无需包含文件后缀名，PaddleClas会自动补齐 `.pdparams` 的后缀，如 [2.2.2 特征模型恢复训练](#2.2.2)。
* 在加载待评估模型时，需要指定模型文件的路径，但无需包含文件后缀名，PaddleClas 会自动补齐 `.pdparams` 的后缀，如 [2.2.2 特征模型恢复训练](#2.2.2)。
* Metric learning 任务一般不评测 TopkAcc。
@ -271,7 +271,7 @@ python3 tools/export_model.py \
其中，`Global.pretrained_model` 用于指定模型文件路径，该路径仍无需包含模型文件后缀名（如[2.2.2 特征模型恢复训练](#2.2.2)）。当执行后，会在当前目录下生成 `./inference` 目录，目录下包含 `inference.pdiparams`、`inference.pdiparams.info`、`inference.pdmodel` 文件。`Global.save_inference_dir` 可以指定导出 inference 模型的路径。此处保存的 inference 模型在 embedding 特征层做了截断，即模型最终的输出为 n 维 embedding 特征。
上述命令将生成模型结构文件(`inference.pdmodel`)和模型权重文件(`inference.pdiparams`)，然后可以使用预测引擎进行推理。使用 inference 模型推理的流程可以参考[基于Python预测引擎预测推理](../inference_deployment/python_deploy.md)。
上述命令将生成模型结构文件(`inference.pdmodel`)和模型权重文件(`inference.pdiparams`)，然后可以使用预测引擎进行推理。使用 inference 模型推理的流程可以参考[基于 Python 预测引擎预测推理](../inference_deployment/python_deploy.md)。
<a name="3"></a>
@ -280,7 +280,7 @@ python3 tools/export_model.py \
PaddleClas 图像检索部分目前支持的环境如下：
```shell
└── CPU/单卡GPU
└── CPU/单卡 GPU
├── Linux
├── MacOS
└── Windows

20
docs/zh_CN/models_training/train_strategy.md
View File

@ -33,33 +33,33 @@
<a name="2.2"></a>
### 2.2 学习率下降策略：
在整个训练过程中，我们不能使用同样的学习率来更新权重，否则无法到达最优点，所以需要在训练过程中调整学习率的大小。在训练初始阶段，由于权重处于随机初始化的状态，损失函数相对容易进行梯度下降，所以可以设置一个较大的学习率。在训练后期，由于权重参数已经接近最优值，较大的学习率无法进一步寻找最优值，所以需要设置一个较小的学习率。在训练整个过程中，很多研究者使用的学习率下降方式是 piecewise_decay，即阶梯式下降学习率，如在 ResNet50 标准的训练中，我们设置的初始学习率是 0.1，每 30 epoch 学习率下降到原来的 1/10，一共迭代 120 epoch。除了 piecewise_decay，很多研究者也提出了学习率的其他下降方式，如polynomial_decay（多项式下降）、exponential_decay（指数下降）、cosine_decay（余弦下降）等，其中cosine_decay 无需调整超参数，鲁棒性也比较高，所以成为现在提高模型精度首选的学习率下降方式。Cosine_decay 和 piecewise_decay 的学习率变化曲线如下图所示，容易观察到，在整个训练过程中，cosine_decay 都保持着较大的学习率，所以其收敛较为缓慢，但是最终的收敛效果较 peicewise_decay 更好一些。
在整个训练过程中，我们不能使用同样的学习率来更新权重，否则无法到达最优点，所以需要在训练过程中调整学习率的大小。在训练初始阶段，由于权重处于随机初始化的状态，损失函数相对容易进行梯度下降，所以可以设置一个较大的学习率。在训练后期，由于权重参数已经接近最优值，较大的学习率无法进一步寻找最优值，所以需要设置一个较小的学习率。在训练整个过程中，很多研究者使用的学习率下降方式是 piecewise_decay，即阶梯式下降学习率，如在 ResNet50 标准的训练中，我们设置的初始学习率是 0.1，每 30 epoch 学习率下降到原来的 1/10，一共迭代 120 epoch。除了 piecewise_decay，很多研究者也提出了学习率的其他下降方式，如 polynomial_decay（多项式下降）、exponential_decay（指数下降）、cosine_decay（余弦下降）等，其中 cosine_decay 无需调整超参数，鲁棒性也比较高，所以成为现在提高模型精度首选的学习率下降方式。Cosine_decay 和 piecewise_decay 的学习率变化曲线如下图所示，容易观察到，在整个训练过程中，cosine_decay 都保持着较大的学习率，所以其收敛较为缓慢，但是最终的收敛效果较 peicewise_decay 更好一些。
![](../../images/models/lr_decay.jpeg)
另外，从图中我们也可以看到，cosine_decay 里学习率小的轮数较少，这样会影响到最终的精度，所以为了使得cosine_decay 发挥更好的效果，建议迭代更多的轮数，如 200 轮。
另外，从图中我们也可以看到，cosine_decay 里学习率小的轮数较少，这样会影响到最终的精度，所以为了使得 cosine_decay 发挥更好的效果，建议迭代更多的轮数，如 200 轮。
<a name="2.3"></a>
### 2.3 warmup 策略
如果使用较大的 batch_size 训练神经网络时，我们建议您使用 warmup 策略。Warmup 策略顾名思义就是让学习率先预热一下，在训练初期我们不直接使用最大的学习率，而是用一个逐渐增大的学习率去训练网络，当学习率增大到最高点时，再使用学习率下降策略中提到的学习率下降方式衰减学习率的值。实验表明，在 batch_size 较大时，warmup 可以稳定提升模型的精度。在训练 MobileNetV3 等 batch_size 较大的实验中，我们默认将warmup 中的 epoch 设置为 5，即先用 5 epoch 将学习率从 0 增加到最大值，再去做相应的学习率衰减。
如果使用较大的 batch_size 训练神经网络时，我们建议您使用 warmup 策略。Warmup 策略顾名思义就是让学习率先预热一下，在训练初期我们不直接使用最大的学习率，而是用一个逐渐增大的学习率去训练网络，当学习率增大到最高点时，再使用学习率下降策略中提到的学习率下降方式衰减学习率的值。实验表明，在 batch_size 较大时，warmup 可以稳定提升模型的精度。在训练 MobileNetV3 等 batch_size 较大的实验中，我们默认将 warmup 中的 epoch 设置为 5，即先用 5 epoch 将学习率从 0 增加到最大值，再去做相应的学习率衰减。
<a name="3"></a>
## 3.batch_size的选择
## 3.batch_size 的选择
batch_size 是训练神经网络中的一个重要的超参数，该值决定了一次将多少数据送入神经网络参与训练。在论文[1]中，作者通过实验发现，当 batch_size 的值与学习率的值呈线性关系时，收敛精度几乎不受影响。在训练 ImageNet 数据时，大部分的神经网络选择的初始学习率为 0.1，batch_size 是 256，所以根据实际的模型大小和显存情况，可以将学习率设置为 0.1\*k, batch_size 设置为 256\*k。
<a name="4"></a>
## 4.weight_decay的选择
过拟合是机器学习中常见的一个名词，简单理解即为模型在训练数据上表现很好，但在测试数据上表现较差，在卷积神经网络中，同样存在过拟合的问题，为了避免过拟合，很多正则方式被提出，其中，weight_decay 是其中一个广泛使用的避免过拟合的方式。Weight_decay 等价于在最终的损失函数后添加 L2 正则化，L2 正则化使得网络的权重倾向于选择更小的值，最终整个网络中的参数值更趋向于 0，模型的泛化性能相应提高。在各大深度学习框架的实现中，该值表达的含义是 L2 正则前的系数，在 paddle 框架中，该值的名称是 l2_decay，所以以下都称其为 l2_decay。该系数越大，表示加入的正则越强，模型越趋于欠拟合状态。在训练 ImageNet 的任务中，大多数的网络将该参数值设置为 1e-4，在一些小的网络如 MobileNet 系列网络中，为了避免网络欠拟合，该值设置为1e-5~4e-5 之间。当然，该值的设置也和具体的数据集有关系，当任务的数据集较大时，网络本身趋向于欠拟合状态，可以将该值适当减小，当任务的数据集较小时，网络本身趋向于过拟合状态，可以将该值适当增大。下表展示了 MobileNetV1_x0_25 在 ImageNet-1k 上使用不同 l2_decay 的精度情况。由于 MobileNetV1_x0_25 是一个比较小的网络，所以 l2_decay 过大会使网络趋向于欠拟合状态，所以在该网络中，相对 1e-4, 3e-5 是更好的选择。
## 4.weight_decay 的选择
过拟合是机器学习中常见的一个名词，简单理解即为模型在训练数据上表现很好，但在测试数据上表现较差，在卷积神经网络中，同样存在过拟合的问题，为了避免过拟合，很多正则方式被提出，其中，weight_decay 是其中一个广泛使用的避免过拟合的方式。Weight_decay 等价于在最终的损失函数后添加 L2 正则化，L2 正则化使得网络的权重倾向于选择更小的值，最终整个网络中的参数值更趋向于 0，模型的泛化性能相应提高。在各大深度学习框架的实现中，该值表达的含义是 L2 正则前的系数，在 paddle 框架中，该值的名称是 l2_decay，所以以下都称其为 l2_decay。该系数越大，表示加入的正则越强，模型越趋于欠拟合状态。在训练 ImageNet 的任务中，大多数的网络将该参数值设置为 1e-4，在一些小的网络如 MobileNet 系列网络中，为了避免网络欠拟合，该值设置为 1e-5~4e-5 之间。当然，该值的设置也和具体的数据集有关系，当任务的数据集较大时，网络本身趋向于欠拟合状态，可以将该值适当减小，当任务的数据集较小时，网络本身趋向于过拟合状态，可以将该值适当增大。下表展示了 MobileNetV1_x0_25 在 ImageNet-1k 上使用不同 l2_decay 的精度情况。由于 MobileNetV1_x0_25 是一个比较小的网络，所以 l2_decay 过大会使网络趋向于欠拟合状态，所以在该网络中，相对 1e-4, 3e-5 是更好的选择。
| 模型 | L2_decay | Train acc1/acc5 | Test acc1/acc5 |
|:--:|:--:|:--:|:--:|
| MobileNetV1_x0_25 | 1e-4 | 43.79%/67.61% | 50.41%/74.70% |
| MobileNetV1_x0_25 | 3e-5 | 47.38%/70.83% | 51.45%/75.45% |
另外，该值的设置也和训练过程中是否使用其他正则化有关系。如果训练过程中的数据预处理比较复杂，相当于训练任务变的更难，可以将该值适当减小，下表展示了在 ImageNet-1k上, ResNet50 在使用 randaugment 预处理方式后使用不同 l2_decay 的精度。容易观察到，在任务变难后，使用更小的 l2_decay 有助于模型精度的提升。
另外，该值的设置也和训练过程中是否使用其他正则化有关系。如果训练过程中的数据预处理比较复杂，相当于训练任务变的更难，可以将该值适当减小，下表展示了在 ImageNet-1k 上, ResNet50 在使用 randaugment 预处理方式后使用不同 l2_decay 的精度。容易观察到，在任务变难后，使用更小的 l2_decay 有助于模型精度的提升。
| 模型 | L2_decay | Train acc1/acc5 | Test acc1/acc5 |
|:--:|:--:|:--:|:--:|
@ -79,7 +79,7 @@ Label_smoothing 是深度学习中的一种正则化方法，其全称是 Label
| ResNet50_vd | 0 | 77.9% |
| ResNet50_vd | 1 | 78.4% |
同时，由于 label_smoohing 相当于一种正则方式，在相对较小的模型上，精度提升不明显甚至会有所下降，下表展示了 ResNet18 在 ImageNet-1k 上使用 label_smoothing 前后的精度指标。可以明显看到，在使用label_smoothing 后，精度有所下降。
同时，由于 label_smoohing 相当于一种正则方式，在相对较小的模型上，精度提升不明显甚至会有所下降，下表展示了 ResNet18 在 ImageNet-1k 上使用 label_smoothing 前后的精度指标。可以明显看到，在使用 label_smoothing 后，精度有所下降。
| 模型 | Use_label_smoohing | Train acc1/acc5 | Test acc1/acc5 |
|:--:|:--:|:--:|:--:|
@ -93,7 +93,7 @@ Label_smoothing 是深度学习中的一种正则化方法，其全称是 Label
## 6.针对小模型更改图片的 crop 面积与拉伸变换程度
在 ImageNet-1k 数据的标准预处理中，random_crop 函数中定义了 scale 和 ratio 两个值，两个值分别确定了图片 crop 的大小和图片的拉伸程度，其中 scale 的默认取值范围是 0.08-1(lower_scale-upper_scale), ratio 的默认取值范围是 3/4-4/3(lower_ratio-upper_ratio)。在非常小的网络训练中，此类数据增强会使得网络欠拟合，导致精度有所下降。为了提升网络的精度，可以使其数据增强变的更弱，即增大图片的 crop 区域或者减弱图片的拉伸变换程度。我们可以分别通过增大 lower_scale 的值或缩小 lower_ratio 与 upper_scale 的差距来实现更弱的图片变换。下表列出了使用不同 lower_scale 训练 MobileNetV2_x0_25 的精度，可以看到，增大图片的 crop 区域面积后训练精度和验证精度均有提升。
| 模型 | Scale取值范围 | Train_acc1/acc5 | Test_acc1/acc5 |
| 模型 | Scale 取值范围 | Train_acc1/acc5 | Test_acc1/acc5 |
|:--:|:--:|:--:|:--:|
| MobileNetV2_x0_25 | [0.08,1] | 50.36%/72.98% | 52.35%/75.65% |
| MobileNetV2_x0_25 | [0.2,1] | 54.39%/77.08% | 53.18%/76.14% |
@ -129,7 +129,7 @@ Label_smoothing 是深度学习中的一种正则化方法，其全称是 Label
在现阶段计算机视觉领域中，加载预训练模型来训练自己的任务已成为普遍的做法，相比从随机初始化开始训练，加载预训练模型往往可以提升特定任务的精度。一般来说，业界广泛使用的预训练模型是通过训练 128 万张图片 1000 类的 ImageNet-1k 数据集得到的，该预训练模型的 fc 层权重是一个 k\*1000 的矩阵，其中 k 是 fc 层以前的神经元数，在加载预训练权重时，无需加载 fc 层的权重。在学习率方面，如果您的任务训练的数据集特别小（如小于 1 千张），我们建议你使用较小的初始学习率，如 0.001（batch_size:256,下同），以免较大的学习率破坏预训练权重。如果您的训练数据集规模相对较大（大于 10 万），我们建议你尝试更大的初始学习率，如 0.01 或者更大。
> 如果您觉得此文档对您有帮助，欢迎star我们的项目：[https://github.com/PaddlePaddle/PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
> 如果您觉得此文档对您有帮助，欢迎 star 我们的项目：[https://github.com/PaddlePaddle/PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
## 参考文献
[1]P. Goyal, P. Dolla ́r, R. B. Girshick, P. Noordhuis, L. Wesolowski, A. Kyrola, A. Tulloch, Y. Jia, and K. He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017.

39
docs/zh_CN/others/VisualDL.md
View File

@ -1,13 +1,25 @@
# 使用VisualDL可视化训练过程
# 使用 VisualDL 可视化训练过程
--------
## 目录
* [1. 前言](#1)
* [2. 在 PaddleClas 中使用 VisualDL](#2)
* [2.1 设置 config 文件并启动训练](#2.1)
* [2.2 启动 VisualDL](#2.2)
## 前言
VisualDL是飞桨可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、高维数据分布等。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。更多细节请查看[VisualDL](https://github.com/PaddlePaddle/VisualDL/)。
<a name='1'></a>
## 在PaddleClas中使用VisualDL
现在PaddleClas支持在训练阶段使用VisualDL查看训练过程中学习率（learning rate）、损失值（loss）以及准确率（accuracy）的变化情况。
## 1. 前言
VisualDL 是飞桨可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、高维数据分布等。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。更多细节请查看[VisualDL](https://github.com/PaddlePaddle/VisualDL/)。
### 设置config文件并启动训练
在PaddleClas中使用VisualDL，只需在训练配置文件（config文件）中设置字段 `Global.use_visualdl` 为 `True`：
<a name='2'></a>
## 2. 在 PaddleClas 中使用 VisualDL
现在 PaddleClas 支持在训练阶段使用 VisualDL 查看训练过程中学习率（learning rate）、损失值（loss）以及准确率（accuracy）的变化情况。
<a name='2.1'></a>
### 2.1 设置 config 文件并启动训练
在 PaddleClas 中使用 VisualDL，只需在训练配置文件（config 文件）中设置字段 `Global.use_visualdl` 为 `True`：
```yaml
# config.yaml
@ -22,21 +34,22 @@ PaddleClas 会将 VisualDL 的日志保存在 `Global.output_dir` 字段指定
```shell
python3 tools/train.py -c config.yaml
```
<a name='2.2'></a>
### 启动VisualDL
在启动训练程序后，可以在新的终端session中启动VisualDL服务：
### 2.2 启动 VisualDL
在启动训练程序后，可以在新的终端 session 中启动 VisualDL 服务：
```shell
visualdl --logdir ./output/vdl/
```
上述命令中，参数`--logdir`用于指定保存 VisualDL 日志的目录，VisualDL将遍历并且迭代寻找指定目录的子目录，将所有实验结果进行可视化。也同样可以使用下述参数设定VisualDL服务的ip及端口号：
* `--host`：设定IP，默认为127.0.0.1
* `--port`：设定端口，默认为8040
上述命令中，参数`--logdir`用于指定保存 VisualDL 日志的目录，VisualDL 将遍历并且迭代寻找指定目录的子目录，将所有实验结果进行可视化。也同样可以使用下述参数设定 VisualDL 服务的 ip 及端口号：
* `--host`：设定 IP，默认为 127.0.0.1
* `--port`：设定端口，默认为 8040
更多参数信息，请查看[VisualDL](https://github.com/PaddlePaddle/VisualDL/blob/develop/README_CN.md#2-%E5%90%AF%E5%8A%A8%E9%9D%A2%E6%9D%BF)。
在启动VisualDL后，即可在浏览器中查看训练过程，输入地址`127.0.0.1:8840`：
在启动 VisualDL 后，即可在浏览器中查看训练过程，输入地址 `127.0.0.1:8840`：
<div align="center">
<img src="../../images/VisualDL/train_loss.png" width="400">

16
docs/zh_CN/others/competition_support.md
View File

@ -2,18 +2,18 @@
PaddleClas的建设源于百度实际视觉业务应用的淬炼和视觉前沿能力的探索，助力多个视觉重点赛事取得领先成绩，并且持续推进更多的前沿视觉问题的解决和落地应用。
* 2018年Kaggle Open Images V4图像目标检测挑战赛冠军
* 2018 年 Kaggle Open Images V4 图像目标检测挑战赛冠军
* 2019年Kaggle Open Images V5图像目标检测挑战赛亚军
* 2019 年 Kaggle Open Images V5 图像目标检测挑战赛亚军
* 技术报告可以参考：[https://arxiv.org/pdf/1911.07171.pdf](https://arxiv.org/pdf/1911.07171.pdf)
* 详细文档与开源的模型可以参考：[OIDV5目标检测github地址](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.2/static/docs/featured_model/champion_model/OIDV5_BASELINE_MODEL.md)
* 详细文档与开源的模型可以参考：[OIDV5目标检测 github 地址](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.2/static/docs/featured_model/champion_model/OIDV5_BASELINE_MODEL.md)
* 2019年Kaggle地标检索挑战赛亚军
* 2019 年 Kaggle 地标检索挑战赛亚军
* 技术报告可以参考：[https://arxiv.org/abs/1906.03990](https://arxiv.org/abs/1906.03990)
* 详细文档与开源的模型可以参考：[2019地标检索和识别github地址](https://github.com/PaddlePaddle/Research/tree/master/CV/landmark)
* 详细文档与开源的模型可以参考：[2019地标检索和识别 github 地址](https://github.com/PaddlePaddle/Research/tree/master/CV/landmark)
* 2019年Kaggle地标识别挑战赛亚军
* 2019 年 Kaggle 地标识别挑战赛亚军
* 技术报告可以参考：[https://arxiv.org/abs/1906.03990](https://arxiv.org/abs/1906.03990)
* 详细文档与开源的模型可以参考：[2019地标检索和识别github地址](https://github.com/PaddlePaddle/Research/tree/master/CV/landmark)
* 详细文档与开源的模型可以参考：[2019地标检索和识别 github 地址](https://github.com/PaddlePaddle/Research/tree/master/CV/landmark)
* 首届多媒体信息识别技术竞赛中印刷文本OCR、人脸识别和地标识别三项任务A级证书
* 首届多媒体信息识别技术竞赛中印刷文本 OCR、人脸识别和地标识别三项任务 A 级证书

29
docs/zh_CN/others/feature_visiualization.md
View File

@ -1,12 +1,23 @@
# 特征图可视化指南
-----
## 目录
## 一、概述
* [1. 概述](#1)
* [2. 准备工作](#2)
* [3. 修改模型](#3)
* [4. 结果](#4)
<a name='1'></a>
## 1. 概述
特征图是输入图片在卷积网络中的特征表达，对特征图的研究可以有利于我们对于模型的理解与设计，所以基于动态图我们使用本工具来可视化特征图。
## 二、准备工作
<a name='2'></a>
首先需要选定研究的模型，本文设定ResNet50作为研究模型，将模型组网代码[resnet.py](../../../ppcls/arch/backbone/legendary_models/resnet.py)拷贝到[目录](../../../ppcls/utils/feature_maps_visualization/)下，并下载[ResNet50预训练模型](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_pretrained.pdparams)，或使用以下命令下载。
## 2. 准备工作
首先需要选定研究的模型，本文设定 ResNet50 作为研究模型，将模型组网代码[resnet.py](../../../ppcls/arch/backbone/legendary_models/resnet.py)拷贝到[目录](../../../ppcls/utils/feature_maps_visualization/)下，并下载[ResNet50 预训练模型](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_pretrained.pdparams)，或使用以下命令下载。
```bash
wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_pretrained.pdparams
@ -14,11 +25,13 @@ wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_pretrain
其他模型网络结构代码及预训练模型请自行下载：[模型库](../../../ppcls/arch/backbone/)，[预训练模型](../models/models_intro.md)。
## 三、修改模型
<a name='3'></a>
找到我们所需要的特征图位置，设置self.fm将其fetch出来，本文以resnet50中的stem层之后的特征图为例。
## 3. 修改模型
在ResNet50的forward函数中指定要可视化的特征图
找到我们所需要的特征图位置，设置 self.fm 将其 fetch 出来，本文以 resnet50 中的 stem 层之后的特征图为例。
在 ResNet50 的 forward 函数中指定要可视化的特征图
```python
def forward(self, x):
@ -63,7 +76,9 @@ python tools/feature_maps_visualization/fm_vis.py \
+ `--save_path`：保存路径，如：`./tools/`
+ `--use_gpu`：是否使用 GPU 预测，默认值：True
## 四、结果
<a name='4'></a>
## 4. 结果
* 输入图片：

60
docs/zh_CN/others/paddle_mobile_inference.md
View File

@ -1,17 +1,31 @@
# Paddle-Lite
---
## 目录
## 一、简介
* [1. 简介](#1)
* [2. 评估步骤](#2)
* [2.1 导出 inference 模型](#2.1)
* [2.2 benchmark 二进制文件下载](#2.2)
* [2.3 模型速度 benchmark](#2.3)
* [2.4 模型优化与速度评估](#2.4)
<a name='1'></a>
## 1. 简介
[Paddle-Lite](https://github.com/PaddlePaddle/Paddle-Lite) 是飞桨推出的一套功能完善、易用性强且性能卓越的轻量化推理引擎。
轻量化体现在使用较少比特数用于表示神经网络的权重和激活，能够大大降低模型的体积，解决终端设备存储空间有限的问题，推理性能也整体优于其他框架。
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) 使用 Paddle-Lite 进行了[移动端模型的性能评估](../models/Mobile.md)，本部分以`ImageNet1k`数据集的`MobileNetV1`模型为例，介绍怎样使用`Paddle-Lite`，在移动端(基于骁龙855的安卓开发平台)对进行模型速度评估。
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) 使用 Paddle-Lite 进行了[移动端模型的性能评估](../models/Mobile.md)，本部分以`ImageNet1k`数据集的`MobileNetV1`模型为例，介绍怎样使用`Paddle-Lite`，在移动端(基于骁龙855 的安卓开发平台)对进行模型速度评估。
<a name='2'></a>
## 二、评估步骤
## 2. 评估步骤
### 2.1 导出inference模型
<a name='2.1'></a>
* 首先需要将训练过程中保存的模型存储为用于预测部署的固化模型，可以使用`tools/export_model.py`导出inference模型，具体使用方法如下。
### 2.1 导出 inference 模型
* 首先需要将训练过程中保存的模型存储为用于预测部署的固化模型，可以使用`tools/export_model.py`导出 inference 模型，具体使用方法如下。
```shell
python tools/export_model.py \
@ -22,38 +36,41 @@ python tools/export_model.py \
在上述命令中，通过参数 `Arch.pretrained` 指定训练过程中保存的模型参数文件，也可以指定参数 `Arch.pretrained=True` 加载 PaddleClas 提供的基于 ImageNet1k 的预训练模型参数，最终在 `inference/MobileNetV1` 文件夹下会保存得到 `inference.pdmodel` 与 `inference.pdiparmas` 文件。
<a name='2.2'></a>
### 2.2 benchmark二进制文件下载
### 2.2 benchmark 二进制文件下载
* 使用adb(Android Debug Bridge)工具可以连接Android手机与PC端，并进行开发调试等。安装好adb，并确保PC端和手机连接成功后，使用以下命令可以查看手机的ARM版本，并基于此选择合适的预编译库。
* 使用 adb(Android Debug Bridge)工具可以连接 Android 手机与 PC 端，并进行开发调试等。安装好 adb，并确保 PC 端和手机连接成功后，使用以下命令可以查看手机的 ARM 版本，并基于此选择合适的预编译库。
```shell
adb shell getprop ro.product.cpu.abi
```
* 下载benchmark_bin文件
* 下载 benchmark_bin 文件
请根据所用Android手机的ARM版本选择，ARM版本为v8，则使用以下命令下载：
请根据所用 Android 手机的 ARM 版本选择，ARM 版本为 v8，则使用以下命令下载：
```shell
wget -c https://paddle-inference-dist.bj.bcebos.com/PaddleLite/benchmark_0/benchmark_bin_v8
```
如果查看的ARM版本为v7，则需要下载v7版本的benchmark_bin文件，下载命令如下：
如果查看的 ARM 版本为 v7，则需要下载 v7 版本的 benchmark_bin 文件，下载命令如下：
```shell
wget -c https://paddle-inference-dist.bj.bcebos.com/PaddleLite/benchmark_0/benchmark_bin_v7
```
### 2.3 模型速度benchmark
<a name='2.3'></a>
PC端和手机连接成功后，使用下面的命令开始模型评估。
### 2.3 模型速度 benchmark
PC 端和手机连接成功后，使用下面的命令开始模型评估。
```
sh deploy/lite/benchmark/benchmark.sh ./benchmark_bin_v8 ./inference result_armv8.txt true
```
其中`./benchmark_bin_v8`为benchmark二进制文件路径，`./inference`为所有需要评测的模型的路径，`result_armv8.txt`为保存的结果文件，最后的参数`true`表示在评估之后会首先进行模型优化。最终在当前文件夹下会输出`result_armv8.txt`的评估结果文件，具体信息如下。
其中 `./benchmark_bin_v8` 为 benchmark 二进制文件路径，`./inference` 为所有需要评测的模型的路径，`result_armv8.txt`为保存的结果文件，最后的参数`true`表示在评估之后会首先进行模型优化。最终在当前文件夹下会输出`result_armv8.txt`的评估结果文件，具体信息如下。
```
PaddleLite Benchmark
@ -67,15 +84,16 @@ Threads=4 Warmup=10 Repeats=30
MobileNetV1 min = 10.03200 max = 9.94300 average = 9.97627
```
这里给出了不同线程数下的模型预测速度，单位为FPS，以线程数为1为例，MobileNetV1在骁龙855上的平均速度为`30.79750FPS`。
这里给出了不同线程数下的模型预测速度，单位为 FPS，以线程数为 1 为例，MobileNetV1 在骁龙855 上的平均速度为 `30.79750FPS`。
<a name='2.4'></a>
### 2.4 模型优化与速度评估
* 在2.3节中提到了在模型评估之前对其进行优化，在这里也可以首先对模型进行优化，再直接加载优化后的模型进行速度评估。
* 在 2.3 节中提到了在模型评估之前对其进行优化，在这里也可以首先对模型进行优化，再直接加载优化后的模型进行速度评估。
* Paddle-Lite 提供了多种策略来自动优化原始的训练模型，其中包括量化、子图融合、混合调度、Kernel优选等等方法。为了使优化过程更加方便易用，Paddle-Lite提供了opt 工具来自动完成优化步骤，输出一个轻量的、最优的可执行模型。可以在[Paddle-Lite模型优化工具页面](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)下载。在这里以`macOS`开发环境为例，下载[opt_mac](https://paddlelite-data.bj.bcebos.com/model_optimize_tool/opt_mac)模型优化工具，并使用下面的命令对模型进行优化。
* Paddle-Lite 提供了多种策略来自动优化原始的训练模型，其中包括量化、子图融合、混合调度、Kernel 优选等等方法。为了使优化过程更加方便易用，Paddle-Lite 提供了 opt 工具来自动完成优化步骤，输出一个轻量的、最优的可执行模型。可以在[Paddle-Lite 模型优化工具页面](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)下载。在这里以 `macOS` 开发环境为例，下载[opt_mac](https://paddlelite-data.bj.bcebos.com/model_optimize_tool/opt_mac)模型优化工具，并使用下面的命令对模型进行优化。
@ -92,15 +110,15 @@ mkdir ${opt_models_dir}
--optimize_out=${opt_models_dir}/MobileNetV1
```
其中`model_file`与`param_file`分别是导出的inference模型结构文件与参数文件地址，转换成功后，会在`opt_models`文件夹下生成`MobileNetV1.nb`文件。
其中 `model_file` 与 `param_file` 分别是导出的 inference 模型结构文件与参数文件地址，转换成功后，会在 `opt_models` 文件夹下生成 `MobileNetV1.nb` 文件。
使用benchmark_bin文件加载优化后的模型进行评估，具体的命令如下。
使用 benchmark_bin 文件加载优化后的模型进行评估，具体的命令如下。
```shell
bash benchmark.sh ./benchmark_bin_v8 ./opt_models result_armv8.txt
```
最终`result_armv8.txt`中结果如下：
最终 `result_armv8.txt` 中结果如下：
```
PaddleLite Benchmark
@ -114,6 +132,6 @@ Threads=4 Warmup=10 Repeats=30
MobileNetV1_lite min = 10.00600 max = 9.90000 average = 9.96177
```
以线程数为1为例，MobileNetV1在骁龙855上的平均速度为`30.84173 ms`。
以线程数为 1 为例，MobileNetV1 在骁龙855 上的平均速度为`30.84173 ms`。
更加具体的参数解释与Paddle-Lite使用方法可以参考 [Paddle-Lite 文档](https://paddle-lite.readthedocs.io/zh/latest/)。
更加具体的参数解释与 Paddle-Lite 使用方法可以参考 [Paddle-Lite 文档](https://paddle-lite.readthedocs.io/zh/latest/)。

37
docs/zh_CN/others/train_on_xpu.md
View File

@ -1,13 +1,27 @@
# 图像分类昆仑模型介绍(持续更新中)
------
## 目录
* [1. 前言](#1)
* [2. 昆仑训练](#2)
* [2.1 ResNet50](#2.1)
* [2.2 MobileNetV3](#2.2)
* [2.3 HRNet](#2.3)
* [2.4 VGG16/19](#2.4)
## 前言
<a name='1'></a>
* 本文档介绍了目前昆仑支持的模型以及如何在昆仑设备上训练这些模型。支持昆仑的PaddlePaddle安装参考install_kunlun(https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/paddle/install/install_Kunlun_zh.md)
## 1. 前言
## 昆仑训练
* 数据来源和预训练模型参考[quick_start](../quick_start/quick_start_classification_new_user.md)。昆仑训练效果与CPU/GPU对齐。
* 本文档介绍了目前昆仑支持的模型以及如何在昆仑设备上训练这些模型。支持昆仑的 PaddlePaddle 安装参考 install_kunlun(https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/paddle/install/install_Kunlun_zh.md)
### ResNet50
<a name='2'></a>
## 2. 昆仑训练
* 数据来源和预训练模型参考[quick_start](../quick_start/quick_start_classification_new_user.md)。昆仑训练效果与 CPU/GPU 对齐。
<a name='2.1'></a>
### 2.1 ResNet50
* 命令：
```shell
@ -18,9 +32,11 @@ python3.7 ppcls/static/train.py \
-o is_distributed=False
```
与cpu/gpu训练的区别是加上-o use_xpu=True, 表示执行在昆仑设备上。
与 cpu/gpu 训练的区别是加上 -o use_xpu=True, 表示执行在昆仑设备上。
### MobileNetV3
<a name='2.2'></a>
### 2.2 MobileNetV3
* 命令：
```shell
@ -31,7 +47,9 @@ python3.7 ppcls/static/train.py \
-o is_distributed=False
```
### HRNet
<a name='2.3'></a>
### 2.3 HRNet
* 命令：
```shell
@ -42,8 +60,9 @@ python3.7 ppcls/static/train.py \
-o use_gpu=False
```
<a name='2.4'></a>
### VGG16/19
### 2.4 VGG16/19
* 命令：
```shell

46
docs/zh_CN/others/train_with_DALI.md
View File

@ -1,28 +1,40 @@
# 使用DALI加速训练
# 使用 DALI 加速训练
----
## 目录
* [1. 前言](#1)
* [2. 安装 DALI](#2)
* [3. 使用 DALI](#3)
* [4. 使用 FP16 训练](#4)
## 前言
[NVIDIA数据加载库](https://docs.nvidia.com/deeplearning/dali/user-guide/docs/index.html)（The NVIDIA Data Loading Library，DALI）是用于数据加载和预处理的开源库，用于加速深度学习训练、推理过程，它可以直接构建飞桨Paddle的DataLoader数据读取器。
<a name='1'></a>
由于深度学习程序在训练阶段依赖大量数据，这些数据需要经过加载、预处理等操作后，才能送入训练程序，而这些操作通常在CPU完成，因此限制了训练速度进一步提高，特别是在batch_size较大时，数据读取可能成为训练速度的瓶颈。DALI可以基于GPU的高并行特性实现数据加载及预处理操作，可以进一步提高训练速度。
## 1. 前言
[NVIDIA 数据加载库](https://docs.nvidia.com/deeplearning/dali/user-guide/docs/index.html)（The NVIDIA Data Loading Library，DALI）是用于数据加载和预处理的开源库，用于加速深度学习训练、推理过程，它可以直接构建飞桨 Paddle 的 DataLoader 数据读取器。
## 安装DALI
目前DALI仅支持Linux x64平台，且CUDA版本大于等于10.2。
由于深度学习程序在训练阶段依赖大量数据，这些数据需要经过加载、预处理等操作后，才能送入训练程序，而这些操作通常在 CPU 完成，因此限制了训练速度进一步提高，特别是在 batch_size 较大时，数据读取可能成为训练速度的瓶颈。 DALI 可以基于 GPU 的高并行特性实现数据加载及预处理操作，可以进一步提高训练速度。
* 对于CUDA 10:
<a name='2'></a>
## 2.安装 DALI
目前 DALI 仅支持 Linux x64 平台，且 CUDA 版本大于等于 10.2。
* 对于 CUDA 10:
pip install --extra-index-url https://developer.download.nvidia.com/compute/redist nvidia-dali-cuda100
* 对于CUDA 11.0:
* 对于 CUDA 11.0:
pip install --extra-index-url https://developer.download.nvidia.com/compute/redist nvidia-dali-cuda110
关于更多DALI安装的信息，可以参考[DALI官方](https://docs.nvidia.com/deeplearning/dali/user-guide/docs/installation.html)。
关于更多 DALI 安装的信息，可以参考[DALI 官方](https://docs.nvidia.com/deeplearning/dali/user-guide/docs/installation.html)。
## 使用DALI
PaddleClas支持在静态图训练方式中使用DALI加速，由于DALI仅支持GPU训练，因此需要设置GPU，且DALI需要占用GPU显存，需要为DALI预留显存。使用DALI训练只需在训练配置文件中设置字段`use_dali=True`，或通过以下命令启动训练即可：
<a name='3'></a>
## 3. 使用 DALI
PaddleClas 支持在静态图训练方式中使用 DALI 加速，由于 DALI 仅支持 GPU 训练，因此需要设置 GPU，且 DALI 需要占用 GPU 显存，需要为 DALI 预留显存。使用 DALI 训练只需在训练配置文件中设置字段`use_dali=True`，或通过以下命令启动训练即可：
```shell
# 设置用于训练的GPU卡号
# 设置用于训练的 GPU 卡号
export CUDA_VISIBLE_DEVICES="0"
python ppcls/static/train.py -c ppcls/configs/ImageNet/ResNet/ResNet50.yaml -o use_dali=True
@ -31,10 +43,10 @@ python ppcls/static/train.py -c ppcls/configs/ImageNet/ResNet/ResNet50.yaml -o u
也可以使用多卡训练：
```shell
# 设置用于训练的GPU卡号
# 设置用于训练的 GPU 卡号
export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7"
# 设置用于神经网络训练的显存大小，可根据具体情况设置，一般可设置为0.8或0.7，剩余显存则预留DALI使用
# 设置用于神经网络训练的显存大小，可根据具体情况设置，一般可设置为 0.8 或 0.7，剩余显存则预留 DALI 使用
export FLAGS_fraction_of_gpu_memory_to_use=0.80
python -m paddle.distributed.launch \
@ -44,8 +56,10 @@ python -m paddle.distributed.launch \
-o use_dali=True
```
## 使用FP16训练
在上述基础上，使用FP16半精度训练，可以进一步提高速度，可以参考下面的配置与运行命令。
<a name='4'></a>
## 4. 使用 FP16 训练
在上述基础上，使用 FP16 半精度训练，可以进一步提高速度，可以参考下面的配置与运行命令。
```shell
export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7

51
docs/zh_CN/others/transfer_learning.md
View File

@ -1,33 +1,48 @@
# 图像分类迁移学习
迁移学习是机器学习领域的一个重要分支，广泛应用于文本、图像等各种领域，此处我们主要介绍的是图像分类领域的迁移学习，也就是我们常说的域迁移，比如将 ImageNet 分类模型迁移到我们自己场景的图像分类任务上，如花卉分类。
## 一、 超参搜索
----------
## 目录
* [1. 超参搜索](#1)
* [1.1 网格搜索](#1.1)
* [1.2 贝叶斯搜索](#1.2)
* [2. 大规模分类模型](#2)
* [3. 参考文献](#3)
<a name='1'></a>
## 1. 超参搜索
ImageNet 作为业界常用的图像分类数据被大家广泛使用，已经总结出一系列经验性的超参，使用这些超参往往能够得到不错的训练精度，而这些经验性的参数在迁移到自己的业务中时，有时效果不佳。有两种常用的超参搜索方法可以用于获得更好的模型超参。
<a name='1.1'></a>
### 1.1 网格搜索
网格搜索，即穷举搜索，通过查找搜索空间内所有的点，确定最优值。方法简单有效，但当搜索空间较大时，需要消耗大量的计算资源。
<a name='1.2'></a>
### 1.2 贝叶斯搜索
贝叶斯搜索，即贝叶斯优化，在搜索空间中随机选取超参数点，采用高斯过程，即根据上一个超参数点的结果，更新当前的先验信息，计算前面n个超参数点的后验概率分布，得到搜索空间中每一个超参数点的期望均值和方差，其中期望均值越大表示接近最优指标的可能性越大，方差越大表示不确定性越大。通常将选择期望均值大的超参数点称为`exporitation`，选择方差大的超参数点称为`exploration`。在贝叶斯优化中通过定义`acquisition function`权衡期望均值和方差。贝叶斯搜索认为当前选择的超参数点是处于最大值可能出现的位置。
贝叶斯搜索，即贝叶斯优化，在搜索空间中随机选取超参数点，采用高斯过程，即根据上一个超参数点的结果，更新当前的先验信息，计算前面 n 个超参数点的后验概率分布，得到搜索空间中每一个超参数点的期望均值和方差，其中期望均值越大表示接近最优指标的可能性越大，方差越大表示不确定性越大。通常将选择期望均值大的超参数点称为`exporitation`，选择方差大的超参数点称为`exploration`。在贝叶斯优化中通过定义`acquisition function`权衡期望均值和方差。贝叶斯搜索认为当前选择的超参数点是处于最大值可能出现的位置。
------
基于上述两种搜索方案，我们在8个开源数据集上将固定一组参数实验以及两种搜索方案做了对比实验，参照[1]的实验方案，我们对4个超参数进行搜索，搜索空间及实验结果如下所示：
基于上述两种搜索方案，我们在 8 个开源数据集上将固定一组参数实验以及两种搜索方案做了对比实验，参照[1]的实验方案，我们对 4 个超参数进行搜索，搜索空间及实验结果如下所示：
- 固定参数：
```
初始学习率lr=0.003，l2 decay=1e-4，label smoothing=False，mixup=False
初始学习率 lr=0.003，l2 decay=1e-4，label smoothing=False，mixup=False
```
- 超参搜索空间：
```
初始学习率lr: [0.1, 0.03, 0.01, 0.003, 0.001, 0.0003, 0.0001]
初始学习率 lr: [0.1, 0.03, 0.01, 0.003, 0.001, 0.0003, 0.0001]
L2 decay: [1e-3, 3e-4, 1e-4, 3e-5, 1e-5, 3e-6, 1e-6]
@ -36,7 +51,7 @@ Label smoothing: [False, True]
Mixup: [False, True]
```
网格搜索的搜索次数为196次，而贝叶斯搜索通过设置最大迭代次数（`max_iter`）和是否重复搜索（`de_duplication`）来确定搜索次数。我们设计了系列实验，baseline为ImageNet1k校验集Top1 Acc为79.12%的ResNet50_vd预训练模型，并固定超参，在新数据集上finetune得到的模型。下表给出了固定参数、网格搜索以及贝叶斯搜索的精度与搜索次数对比。
网格搜索的搜索次数为 196 次，而贝叶斯搜索通过设置最大迭代次数（`max_iter`）和是否重复搜索（`de_duplication`）来确定搜索次数。我们设计了系列实验，baseline 为 ImageNet1k 校验集 Top1 Acc 为 79.12% 的 ResNet50_vd 预训练模型，并固定超参，在新数据集上 finetune 得到的模型。下表给出了固定参数、网格搜索以及贝叶斯搜索的精度与搜索次数对比。
- 精度与搜索次数对比:
@ -52,22 +67,24 @@ Mixup: [False, True]
| FGVC Aircraft | 80.32% | 88.45% | 196 | 88.36% | 20 |
- 上述实验验证了贝叶斯搜索相比网格搜索，在减少搜索次数10倍左右条件下，精度只下降0%~0.4%。
- 当搜索空间进一步扩大时，例如将是否进行AutoAugment，RandAugment，Cutout， Cutmix以及Dropout这些正则化策略作为选择时，贝叶斯搜索能够在获取较优精度的前提下，有效地降低搜索次数。
- 上述实验验证了贝叶斯搜索相比网格搜索，在减少搜索次数 10 倍左右条件下，精度只下降 0%~0.4%。
- 当搜索空间进一步扩大时，例如将是否进行 AutoAugment，RandAugment，Cutout， Cutmix 以及 Dropout 这些正则化策略作为选择时，贝叶斯搜索能够在获取较优精度的前提下，有效地降低搜索次数。
## 二、 大规模分类模型
<a name='2'></a>
在实际应用中，由于训练数据的匮乏，往往将ImageNet1k数据集训练的分类模型作为预训练模型，进行图像分类的迁移学习。为了进一步助力解决实际问题，基于ResNet50_vd, 百度开源了自研的大规模分类预训练模型，其中训练数据为10万个类别，4300万张图片。10万类预训练模型的下载地址：[**下载地址**](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_vd_10w_pretrained.pdparams)
## 2. 大规模分类模型
我们在6个自有采集的数据集上进行迁移学习实验，采用一组固定参数以及网格搜索方式，其中训练轮数设置为20epochs，选用ResNet50_vd模型，ImageNet预训练精度为79.12%。实验数据集参数以及模型精度的对比结果如下：
在实际应用中，由于训练数据的匮乏，往往将 ImageNet1k 数据集训练的分类模型作为预训练模型，进行图像分类的迁移学习。为了进一步助力解决实际问题，基于 ResNet50_vd, 百度开源了自研的大规模分类预训练模型，其中训练数据为 10 万个类别，4300 万张图片。10 万类预训练模型的下载地址：[**下载地址**](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_vd_10w_pretrained.pdparams)
我们在 6 个自有采集的数据集上进行迁移学习实验，采用一组固定参数以及网格搜索方式，其中训练轮数设置为 20 epochs，选用 ResNet50_vd 模型，ImageNet 预训练精度为 79.12%。实验数据集参数以及模型精度的对比结果如下：
固定参数：
```
初始学习率lr=0.001，l2 decay=1e-4，label smoothing=False，mixup=False
初始学习率 lr=0.001，l2 decay=1e-4，label smoothing=False，mixup=False
```
| 数据集 | 数据统计 | **ImageNet预训练模型 <br />固定参数Top-1/参数搜索Top-1** | **大规模分类预训练模型<br />固定参数Top-1/参数搜索Top-1** |
| 数据集 | 数据统计 | **ImageNet 预训练模型 <br />固定参数 Top-1/参数搜索 Top-1** | **大规模分类预训练模型<br />固定参数 Top-1/参数搜索 Top-1** |
| --------------- | ----------------------------------------- | -------------------------------------------------------- | --------------------------------------------------------- |
| 花卉 | class:102<br />train:5789<br />valid:2396 | 0.7779/0.9883 | 0.9892/0.9954 |
| 手绘简笔画 | Class:18<br />train:1007<br />valid:432 | 0.8795/0.9196 | 0.9107/0.9219 |
@ -76,10 +93,10 @@ Mixup: [False, True]
| 椅子 | class:5<br />train:169<br />valid:78 | 0.8557/0.9688 | 0.9077/0.9792 |
| 地质 | class:4<br />train:671<br />valid:296 | 0.5719/0.8094 | 0.6781/0.8219 |
- 通过上述的实验验证了当使用一组固定参数时，相比于ImageNet预训练模型，使用大规模分类模型作为预训练模型在大多数情况下能够提升模型在新的数据集上得效果，通过参数搜索可以进一步提升精度。
- 通过上述的实验验证了当使用一组固定参数时，相比于 ImageNet 预训练模型，使用大规模分类模型作为预训练模型在大多数情况下能够提升模型在新的数据集上得效果，通过参数搜索可以进一步提升精度。
## 参考文献
<a name='3'></a>
## 3. 参考文献
[1] Kornblith, Simon, Jonathon Shlens, and Quoc V. Le. "Do better imagenet models transfer better?." *Proceedings of the IEEE conference on computer vision and pattern recognition*. 2019.

38
docs/zh_CN/others/update_history.md
View File

@ -8,49 +8,49 @@
- 2021.06.22,23,24 PaddleClas官方研发团队带来技术深入解读三日直播课。课程回放：[https://aistudio.baidu.com/aistudio/course/introduce/24519](https://aistudio.baidu.com/aistudio/course/introduce/24519)
- 2021.06.16 PaddleClas v2.2版本升级，集成Metric learning，向量检索等组件。新增商品识别、动漫人物识别、车辆识别和logo识别等4个图像识别应用。新增LeViT、Twins、TNT、DLA、HarDNet、RedNet系列30个预训练模型。
- 2021.04.15
- 添加`MixNet_L`和`ReXNet_3_0`系列模型，在ImageNet-1k上`MixNet` 模型Top1 Acc可达78.6%，`ReXNet`模型可达82.09%
- 添加 `MixNet_L` 和 `ReXNet_3_0` 系列模型，在 ImageNet-1k 上 `MixNet` 模型 Top1 Acc 可达 78.6%，`ReXNet` 模型可达 82.09%
- 2021.01.27
* 添加ViT与DeiT模型，在ImageNet上，ViT模型Top-1 Acc可达81.05%，DeiT模型可达85.5%。
* 添加 ViT 与 DeiT 模型，在 ImageNet 上，ViT 模型 Top-1 Acc 可达 81.05%，DeiT 模型可达 85.5%。
- 2021.01.08
* 添加whl包及其使用说明，直接安装paddleclas whl包，即可快速完成模型预测。
* 添加 whl 包及其使用说明，直接安装 paddleclas whl 包，即可快速完成模型预测。
- 2020.12.16
* 添加对cpp预测的tensorRT支持，预测加速更明显。
* 添加对 cpp 预测的 tensorRT 支持，预测加速更明显。
- 2020.12.06
* 添加SE_HRNet_W64_C_ssld模型，在ImageNet上Top-1 Acc可达0.8475。
* 添加 SE_HRNet_W64_C_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.8475。
- 2020.11.23
* 添加GhostNet_x1_3_ssld模型，在ImageNet上Top-1 Acc可达0.7938。
* 添加 GhostNet_x1_3_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.7938。
- 2020.11.09
* 添加InceptionV3结构和模型，在ImageNet上Top-1 Acc可达0.791。
* 添加 InceptionV3 结构和模型，在 ImageNet 上 Top-1 Acc 可达 0.791。
- 2020.10.20
* 添加Res2Net50_vd_26w_4s_ssld模型，在ImageNet上Top-1 Acc可达0.831；添加Res2Net101_vd_26w_4s_ssld模型，在ImageNet上Top-1 Acc可达0.839。
* 添加 Res2Net50_vd_26w_4s_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.831；添加 Res2Net101_vd_26w_4s_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.839。
- 2020.10.12
* 添加Paddle-Lite demo。
* 添加 Paddle-Lite demo。
- 2020.10.10
* 添加cpp inference demo。
* 添加FAQ30问。
* 添加 cpp inference demo。
* 添加 FAQ 30 问。
- 2020.09.17
* 添加HRNet_W48_C_ssld模型，在ImageNet上Top-1 Acc可达0.836；添加ResNet34_vd_ssld模型，在ImageNet上Top-1 Acc可达0.797。
* 添加 HRNet_W48_C_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.836；添加 ResNet34_vd_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.797。
* 2020.09.07
* 添加HRNet_W18_C_ssld模型，在ImageNet上Top-1 Acc可达0.81162；添加MobileNetV3_small_x0_35_ssld模型，在ImageNet上Top-1 Acc可达0.5555。
* 添加 HRNet_W18_C_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.81162；添加 MobileNetV3_small_x0_35_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 0.5555。
* 2020.07.14
* 添加Res2Net200_vd_26w_4s_ssld模型，在ImageNet上Top-1 Acc可达85.13%。
* 添加Fix_ResNet50_vd_ssld_v2模型，，在ImageNet上Top-1 Acc可达84.0%。
* 添加 Res2Net200_vd_26w_4s_ssld 模型，在 ImageNet 上 Top-1 Acc 可达 85.13%。
* 添加 Fix_ResNet50_vd_ssld_v2 模型，，在 ImageNet 上 Top-1 Acc 可达 84.0%。
* 2020.06.17
* 添加英文文档。
* 2020.06.12
* 添加对windows和CPU环境的训练与评估支持。
* 添加对 windows 和 CPU 环境的训练与评估支持。
* 2020.05.17
* 添加混合精度训练。
* 2020.05.09
* 添加Paddle Serving使用文档。
* 添加Paddle-Lite使用文档。
* 添加T4 GPU的FP32/FP16预测速度benchmark。
* 添加 Paddle Serving 使用文档。
* 添加 Paddle-Lite 使用文档。
* 添加 T4 GPU 的 FP32/FP16 预测速度 benchmark。
* 2020.04.10:
* 第一次提交。

60
docs/zh_CN/others/versions.md
View File

@ -1,50 +1,58 @@
# 版本更新信息
----------
## 目录
* [1. v2.3](#1)
* [2. v2.2](#2)
## v2.3
<a name='1'></a>
## 1. v2.3
- 模型更新
- 添加轻量化模型预训练权重，包括检测模型、特征模型
- 发布PP-LCNet系列模型，此系列模型是专门在CPU上设计运行的自研模型
- SwinTransformer、Twins、Deit支持从scrach直接训练，达到论文精度
- 发布 PP-LCNet 系列模型，此系列模型是专门在 CPU 上设计运行的自研模型
- SwinTransformer、Twins、Deit 支持从 scrach 直接训练，达到论文精度
- 框架基础能力
- 添加DeepHash模块，支持特征模型直接输出二值特征
- 添加PKSampler，特征模型不能多机多卡的训练的问题
- 支持PaddleSlim：支持分类模型、特征模型的量化、裁剪训练及离线量化功能
- Legendary models支持模型中间结果输出
- 添加 DeepHash 模块，支持特征模型直接输出二值特征
- 添加 PKSampler，特征模型不能多机多卡的训练的问题
- 支持 PaddleSlim：支持分类模型、特征模型的量化、裁剪训练及离线量化功能
- Legendary models 支持模型中间结果输出
- 支持多标签分类训练
- 预测部署
- 使用Faiss替换原有特征检索库，提升平台适配性
- 支持PaddleServing：支持分类模型、图像识别流程的部署
- 使用 Faiss 替换原有特征检索库，提升平台适配性
- 支持 PaddleServing：支持分类模型、图像识别流程的部署
- 推荐库版本
- python版本：3.7
- PaddlePaddle版本：2.1.3
- PaddleSlim版本：2.2.0
- PaddleServing版本：0.6.1
- python 版本：3.7
- PaddlePaddle 版本：2.1.3
- PaddleSlim 版本：2.2.0
- PaddleServing 版本：0.6.1
## v2.2
<a name='2'></a>
## 2. v2.2
- 模型更新
- 添加LeViT、Twins、TNT、DLA、HardNet、RedNet、SwinTransfomer模型
- 添加 LeViT、Twins、TNT、DLA、HardNet、RedNet、SwinTransfomer 模型
- 框架基础能力
- 将分类模型分为两类
- legendary models：引入TheseusLayer基类，及增加了修改网络功能接口，同时支持网络截断输出功能
- legendary models：引入 TheseusLayer 基类，及增加了修改网络功能接口，同时支持网络截断输出功能
- model zoo：其他普通分类模型
- 添加Metric Learning算法支持
- 添加多种相关Loss算法，及基础网络模块gears（支持与backbone、loss组合）方便使用
- 同时支持普通分类及metric learning相关任务训练
- 添加 Metric Learning 算法支持
- 添加多种相关 Loss 算法，及基础网络模块 gears（支持与 backbone、loss 组合）方便使用
- 同时支持普通分类及 metric learning 相关任务训练
- 支持静态图训练
- 分类训练支持dali加速
- 支持fp16训练
- 分类训练支持 dali 加速
- 支持 fp16 训练
- 应用更新
- 添加商品识别、车辆识别（车辆细粒度分类、车辆ReID）、logo识别、动漫人物识别应用具体案例及相关模型
- 添加图像识别完整pipeline，包含检测模块、特征提取模块、向量检索模块
- 添加商品识别、车辆识别（车辆细粒度分类、车辆 ReID）、logo 识别、动漫人物识别应用具体案例及相关模型
- 添加图像识别完整 pipeline，包含检测模块、特征提取模块、向量检索模块
- 预测部署
- 添加百度自研向量检索模块Mobius，支持图像识别系统预测部署
- 添加百度自研向量检索模块 Mobius，支持图像识别系统预测部署
- 图像识别，建立特征库支持 batch_size>1
- 文档更新
- 添加图像识别相关文档
- 修复之前文档bug
- 修复之前文档 bug
- 推荐库版本
- python版本：3.7
- python 版本：3.7
- PaddlePaddle：2.1.2

45
docs/zh_CN/quick_start/quick_start_classification_new_user.md
View File

@ -1,9 +1,23 @@
# 30分钟玩转PaddleClas（尝鲜版）
# 30 分钟玩转 PaddleClas（尝鲜版）
此教程主要针对初级用户，即深度学习相关理论知识处于入门阶段，具有一定的 Python 基础，能够阅读简单代码的用户。此内容主要包括使用 PaddleClas 进行图像分类网络训练及模型预测。
---
## 目录
- [1. 基础知识](#1)
- [2. 环境安装与配置](#2)
- [3. 数据的准备与处理](#3)
- [4. 模型训练](#4)
- [4.1 使用 CPU 进行模型训练](#4.1)
- [4.1.1 不使用预训练模型进行训练](#4.1.1)
- [4.1.2 不使用预训练模型进行训练](#4.1.2)
- [4.2 使用 GPU 进行模型训练](#4.2)
- [4.2.1 不使用预训练模型进行训练](#4.2.1)
- [4.2.2 不使用预训练模型进行训练](#4.2.2)
- [5. 模型预测](#5)
<a name="1"></a>
## 1. 基础知识
图像分类顾名思义就是一个模式分类问题，是计算机视觉中最基础的任务，它的目标是将不同的图像，划分到不同的类别。以下会对整个模型训练过程中需要了解到的一些概念做简单的解释，希望能够对初次体验 PaddleClas 的你有所帮助：
@ -36,10 +50,10 @@
## 3. 数据的准备与处理
进入PaddleClas目录：
进入 PaddleClas 目录：
```shell
# linux or mac， $path_to_PaddleClas表示PaddleClas的根目录，用户需要根据自己的真实目录修改
# linux or mac， $path_to_PaddleClas 表示 PaddleClas 的根目录，用户需要根据自己的真实目录修改
cd $path_to_PaddleClas
```
@ -56,9 +70,9 @@ unzip flowers102.zip
没有安装 `wget` 命令或者在 Windows 中下载的话，需要将地址拷贝到浏览器中下载，并进行解压到目录 `PaddleClas/dataset/` 下面即可。
解压完成后，在目录 `PaddleClas/dataset/flowers102` 下有用于训练和测试的三个 `.txt` 文件：`train_list.txt`（训练集，1020张图）、`val_list.txt`（验证集，1020张图）、`train_extra_list.txt`（更大的训练集，7169张图）。文件中每行格式：**图像相对路径** **图像的label_id**（注意：中间有空格），此外还有flowers102数据集 label id 与类别名称的映射文件：`flowers102_label_list.txt`。
解压完成后，在目录 `PaddleClas/dataset/flowers102` 下有用于训练和测试的三个 `.txt` 文件：`train_list.txt`（训练集，1020 张图）、`val_list.txt`（验证集，1020 张图）、`train_extra_list.txt`（更大的训练集，7169 张图）。文件中每行格式：**图像相对路径** **图像的 label_id**（注意：中间有空格），此外还有 flowers102 数据集 label id 与类别名称的映射文件：`flowers102_label_list.txt`。
flowers102数据集的图像文件存放在 `dataset/flowers102/jpg` 目录中，图像示例如下：
flowers102 数据集的图像文件存放在 `dataset/flowers102/jpg` 目录中，图像示例如下：
<div align="center">
<img src="../../images/quick_start/Examples-Flower-102.png" width = "800" />
@ -69,27 +83,26 @@ flowers102数据集的图像文件存放在 `dataset/flowers102/jpg` 目录中
```shell
# linux or mac
cd ../../
# windoes直接打开PaddleClas根目录即可
# windoes 直接打开 PaddleClas 根目录即可
```
## 4. 模型训练
<a name="4.1"></a>
### 4.1 使用CPU进行模型训练
### 4.1 使用 CPU 进行模型训练
由于使用 CPU 来进行模型训练，计算速度较慢，因此，此处以 ShuffleNetV2_x0_25 为例。此模型计算量较小，在 CPU 上计算速度较快。但是也因为模型较小，训练好的模型精度也不会太高。
#### 4.1.1 不使用预训练模型
```shell
# windows在cmd中进入PaddleClas根目录，执行此命令
# windows 在 cmd 中进入 PaddleClas 根目录，执行此命令
python tools/train.py -c ./ppcls/configs/quick_start/new_user/ShuffleNetV2_x0_25.yaml
```
- `-c` 参数是指定训练的配置文件路径，训练的具体超参数可查看 `yaml` 文件
- `yaml`文`Global.device` 参数设置为`cpu`，即使用CPU进行训练（若不设置，此参数默认为`True`）
- `yaml`文件中`epochs`参数设置为20，说明对整个数据集进行20个epoch迭代，预计训练20分钟左右（不同CPU，训练时间略有不同），此时训练模型不充分。若提高训练模型精度，请将此参数设大，如**40**，训练时间也会相应延长
- `yaml`文`Global.device` 参数设置为`cpu`，即使用 CPU 进行训练（若不设置，此参数默认为`True`）
- `yaml`文件中`epochs`参数设置为 20，说明对整个数据集进行 20 个 epoch 迭代，预计训练 20 分钟左右（不同 CPU，训练时间略有不同），此时训练模型不充分。若提高训练模型精度，请将此参数设大，如**40**，训练时间也会相应延长
#### 4.1.2 使用预训练模型
@ -101,7 +114,8 @@ python tools/train.py -c ./ppcls/configs/quick_start/new_user/ShuffleNetV2_x0_25
可以使用将使用与不使用预训练模型训练进行对比，观察 loss 的下降情况。
### 4.2 使用GPU进行模型训练
<a name="4.2"></a>
### 4.2 使用 GPU 进行模型训练
由于 GPU 训练速度更快，可以使用更复杂模型，因此以 ResNet50_vd 为例。与 ShuffleNetV2_x0_25 相比，此模型计算量较大，训练好的模型精度也会更高。
@ -125,13 +139,14 @@ python tools/train.py -c ./ppcls/configs/quick_start/new_user/ShuffleNetV2_x0_25
python tools/train.py -c ./ppcls/configs/quick_start/ResNet50_vd.yaml
```
训练完成后，验证集的`Top1 Acc`曲线如下所示，最高准确率为0.2735。训练精度曲线下图所示
训练完成后，验证集的`Top1 Acc`曲线如下所示，最高准确率为 0.2735。训练精度曲线下图所示
<div align="center">
<img src="../../images/quick_start/r50_vd_acc.png" width = "800" />
</div>
#### 4.2.1 使用预训练模型进行训练
<a name="4.2.2"></a>
#### 4.2.2 使用预训练模型进行训练
基于 ImageNet1k 分类预训练模型进行微调，训练脚本如下所示
@ -139,7 +154,7 @@ python tools/train.py -c ./ppcls/configs/quick_start/ResNet50_vd.yaml
python tools/train.py -c ./ppcls/configs/quick_start/ResNet50_vd.yaml -o Arch.pretrained=True
```
**注**：此训练脚本使用 GPU，如使用 CPU 可按照上文中[4.1 使用CPU进行模型训练](#4.1)所示，进行修改。
**注**：此训练脚本使用 GPU，如使用 CPU 可按照上文中[4.1 使用 CPU 进行模型训练](#4.1)所示，进行修改。
验证集的 `Top1 Acc` 曲线如下所示，最高准确率为 `0.9402`，加载预训练模型之后，flowers102 数据集精度大幅提升，绝对精度涨幅超过 65%。

38
docs/zh_CN/quick_start/quick_start_classification_professional.md
View File

@ -1,4 +1,4 @@
# 30分钟玩转PaddleClas（进阶版）
# 30 分钟玩转 PaddleClas（进阶版）
此处提供了专业用户在 linux 操作系统上使用 PaddleClas 的快速上手教程，主要内容基于 CIFAR-100 数据集，快速体验不同模型的训练、加载不同预训练模型、SSLD 知识蒸馏方案和数据增广的效果。请事先参考[安装指南](../installation/install_paddleclas.md)配置运行环境和克隆 PaddleClas 代码。
@ -8,7 +8,7 @@
- [1. 数据和模型准备](#1)
- [1.1 数据准备](#1.1)
- [1.1.1 准备CIFAR100](#1.1.1)
- [1.1.1 准备 CIFAR100](#1.1.1)
- [2. 模型训练](#2)
- [2.1 单标签训练](#2.1)
- [2.1.1 零基础训练：不加载预训练模型的训练](#2.1.1)
@ -20,7 +20,7 @@
- [5.1 单标签分类模型评估与推理](#5.1)
- [5.1.1 单标签分类模型评估](#5.1.1)
- [5.1.2 单标签分类模型预测](#5.1.2)
- [5.1.3 单标签分类使用inference模型进行模型推理](#5.1.3)
- [5.1.3 单标签分类使用 inference 模型进行模型推理](#5.1.3)
<a name="1"></a>
@ -37,9 +37,9 @@
cd path_to_PaddleClas
```
<a name="1.1.1"></a>
<a name="1.1.1"></a>
#### 1.1.1 准备CIFAR100
#### 1.1.1 准备 CIFAR100
* 进入 `dataset/` 目录，下载并解压 CIFAR100 数据集。
@ -54,11 +54,11 @@ cd ../
## 2. 模型训练
<a name="2.1"></a>
<a name="2.1"></a>
### 2.1 单标签训练
<a name="2.1.1"></a>
<a name="2.1.1"></a>
#### 2.1.1 零基础训练：不加载预训练模型的训练
@ -75,7 +75,7 @@ python3 -m paddle.distributed.launch \
验证集的最高准确率为 0.415 左右。
<a name="2.1.2"></a>
<a name="2.1.2"></a>
#### 2.1.2 迁移学习
@ -94,7 +94,7 @@ python3 -m paddle.distributed.launch \
验证集最高准确率为 0.718 左右，加载预训练模型之后，CIFAR100 数据集精度大幅提升，绝对精度涨幅 30%。
* 基于 ImageNet1k 分类预训练模型 ResNet50_vd_ssld_pretrained （准确率82.39%）进行微调，训练脚本如下所示。
* 基于 ImageNet1k 分类预训练模型 ResNet50_vd_ssld_pretrained （准确率 82.39%）进行微调，训练脚本如下所示。
```shell
export CUDA_VISIBLE_DEVICES=0,1,2,3
@ -130,11 +130,11 @@ python3 -m paddle.distributed.launch \
PaddleClas 包含了很多数据增广的方法，如 Mixup、Cutout、RandomErasing 等，具体的方法可以参考[数据增广的章节](../algorithm_introduction/DataAugmentation.md)。
<a name="3.1"></a>
<a name="3.1"></a>
### 3.1 数据增广的尝试-Mixup
基于[数据增广的章节](../algorithm_introduction/DataAugmentation.md) `3.3节` 中的训练方法，结合 Mixup 的数据增广方式进行训练，具体的训练脚本如下所示。
基于[数据增广的章节](../algorithm_introduction/DataAugmentation.md) `3.3 节` 中的训练方法，结合 Mixup 的数据增广方式进行训练，具体的训练脚本如下所示。
```shell
export CUDA_VISIBLE_DEVICES=0,1,2,3
@ -146,7 +146,7 @@ python3 -m paddle.distributed.launch \
```
最终CIFAR100验证集上的精度为 0.73，使用数据增广可以使得模型精度再次提升约 1.2%。
最终 CIFAR100 验证集上的精度为 0.73，使用数据增广可以使得模型精度再次提升约 1.2%。
@ -161,7 +161,7 @@ python3 -m paddle.distributed.launch \
## 4. 知识蒸馏
PaddleClas 包含了自研的 SSLD 知识蒸馏方案，具体的内容可以参考[知识蒸馏章节](../algorithm_introduction/knowledge_distillation.md), 本小节将尝试使用知识蒸馏技术对 MobileNetV3_large_x1_0 模型进行训练，使用 `2.1.2小节` 训练得到的 ResNet50_vd 模型作为蒸馏所用的教师模型，首先将 `2.1.2小节` 训练得到的 ResNet50_vd 模型保存到指定目录，脚本如下。
PaddleClas 包含了自研的 SSLD 知识蒸馏方案，具体的内容可以参考[知识蒸馏章节](../algorithm_introduction/knowledge_distillation.md), 本小节将尝试使用知识蒸馏技术对 MobileNetV3_large_x1_0 模型进行训练，使用 `2.1.2 小节` 训练得到的 ResNet50_vd 模型作为蒸馏所用的教师模型，首先将 `2.1.2 小节` 训练得到的 ResNet50_vd 模型保存到指定目录，脚本如下。
```shell
mkdir pretrained
@ -226,11 +226,11 @@ python3 -m paddle.distributed.launch \
## 5. 模型评估与推理
<a name="5.1"></a>
<a name="5.1"></a>
### 5.1 单标签分类模型评估与推理
<a name="5.1.1"></a>
<a name="5.1.1"></a>
#### 5.1.1 单标签分类模型评估。
@ -242,7 +242,7 @@ python3 tools/eval.py \
-o Global.pretrained_model="output_CIFAR/ResNet50_vd/best_model"
```
<a name="5.1.2"></a>
<a name="5.1.2"></a>
#### 5.1.2 单标签分类模型预测
@ -255,9 +255,9 @@ python3 tools/infer.py \
-o Global.pretrained_model=output_CIFAR/ResNet50_vd/best_model
```
<a name="5.1.3"></a>
<a name="5.1.3"></a>
#### 5.1.3 单标签分类使用inference模型进行模型推理
#### 5.1.3 单标签分类使用 inference 模型进行模型推理
通过导出 inference 模型，PaddlePaddle 支持使用预测引擎进行预测推理。接下来介绍如何用预测引擎进行推理：
首先，对训练好的模型进行转换：
@ -272,7 +272,7 @@ python3 tools/export_model.py \
使用预测引擎进行推理：
进入deploy目录下：
进入 deploy 目录下：
```bash
cd deploy

6
docs/zh_CN/quick_start/quick_start_multilabel_classification.md
View File

@ -1,4 +1,4 @@
# 多标签分类quick start
# 多标签分类 quick start
基于 [NUS-WIDE-SCENE](https://lms.comp.nus.edu.sg/wp-content/uploads/2019/research/nuswide/NUS-WIDE.html) 数据集，体验多标签分类的训练、评估、预测的过程，该数据集是 NUS-WIDE 数据集的一个子集。请首先安装 PaddlePaddle 和 PaddleClas，具体安装步骤可详看 [Paddle 安装文档](../installation/install_paddle.md)，[PaddleClas 安装文档](../installation/install_paddleclas.md)。
@ -10,7 +10,7 @@
* [3. 模型评估](#3)
* [4. 模型预测](#4)
* [5. 基于预测引擎预测](#5)
* [5.1 导出inference model](#5.1)
* [5.1 导出 inference model](#5.1)
* [5.2 基于预测引擎预测](#5.2)
<a name="1"></a>
@ -78,7 +78,7 @@ python3 tools/infer.py \
## 5. 基于预测引擎预测
<a name="5.1"></a>
### 5.1 导出inference model
### 5.1 导出 inference model
```bash
python3 tools/export_model.py \

26
docs/zh_CN/quick_start/quick_start_recognition.md
View File

@ -8,7 +8,7 @@
* [1. 环境配置](#环境配置)
* [2. 图像识别体验](#图像识别体验)
* [2.1 下载、解压inference 模型与demo数据](#2.1)
* [2.1 下载、解压 inference 模型与 demo 数据](#2.1)
* [2.2 瓶装饮料识别与检索](#瓶装饮料识别与检索)
* [2.2.1 识别单张图像](#识别单张图像)
* [2.2.2 基于文件夹的批量识别](#基于文件夹的批量识别)
@ -22,7 +22,7 @@
## 1. 环境配置
* 安装：请先参考 [Paddle安装教程](../installation/install_paddle.md) 以及 [PaddleClas安装教程](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
* 进入 `deploy` 运行目录。本部分所有内容与命令均需要在 `deploy` 目录下运行，可以通过下面的命令进入 `deploy` 目录。
@ -38,7 +38,7 @@
<a name="轻量级通用主体检测模型与轻量级通用识别模型"></a>
| 模型简介 | 推荐场景 | inference模型 | 预测配置文件 | 构建索引库的配置文件 |
| 模型简介 | 推荐场景 | inference 模型 | 预测配置文件 | 构建索引库的配置文件 |
| ------------ | ------------- | -------- | ------- | -------- |
| 轻量级通用主体检测模型 | 通用场景 |[tar 格式文件下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.tar) [zip 格式文件下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.zip) | - | - |
| 轻量级通用识别模型 | 通用场景 | [tar 格式下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/general_PPLCNet_x2_5_lite_v1.0_infer.tar) [zip 格式文件下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/general_PPLCNet_x2_5_lite_v1.0_infer.zip) | [inference_general.yaml](../../../deploy/configs/inference_general.yaml) | [build_general.yaml](../../../deploy/configs/build_general.yaml) |
@ -58,7 +58,7 @@
```shell
# 安装 homebrew
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)";
# 安装wget
# 安装 wget
brew install wget
```
@ -70,11 +70,11 @@ brew install wget
```shell
mkdir models
cd models
# 下载识别inference模型并解压
# 下载识别 inference 模型并解压
wget {模型下载链接地址} && tar -xf {压缩包的名称}
cd ..
# 下载demo数据并解压
# 下载 demo 数据并解压
wget {数据下载链接地址} && tar -xf {压缩包的名称}
```
@ -153,9 +153,9 @@ pip install faiss-cpu==1.7.1post2
运行下面的命令，对图像 `./drink_dataset_v1.0/test_images/nongfu_spring.jpeg` 进行识别与检索
```shell
# 使用下面的命令使用GPU进行预测
# 使用下面的命令使用 GPU 进行预测
python3.7 python/predict_system.py -c configs/inference_general.yaml
# 使用下面的命令使用CPU进行预测
# 使用下面的命令使用 CPU 进行预测
python3.7 python/predict_system.py -c configs/inference_general.yaml -o Global.use_gpu=False
```
@ -187,7 +187,7 @@ python3.7 python/predict_system.py -c configs/inference_general.yaml -o Global.u
如果希望预测文件夹内的图像，可以直接修改配置文件中的 `Global.infer_imgs` 字段，也可以通过下面的 `-o` 参数修改对应的配置。
```shell
# 使用下面的命令使用GPU进行预测，如果希望使用CPU预测，可以在命令后面添加 -o Global.use_gpu=False
# 使用下面的命令使用 GPU 进行预测，如果希望使用 CPU 预测，可以在命令后面添加 -o Global.use_gpu=False
python3.7 python/predict_system.py -c configs/inference_general.yaml -o Global.infer_imgs="./drink_dataset_v1.0/test_images/"
```
@ -290,14 +290,14 @@ python3.7 python/predict_system.py -c configs/inference_general.yaml -o Global.i
目前，我们更推荐您使用[轻量级通用主体检测模型与轻量级通用识别模型](#轻量级通用主体检测模型与轻量级通用识别模型)，以获得更好的测试结果。但是如果您希望体验服务端识别模型，服务器端通用主体检测模型与各方向识别模型、测试数据下载地址以及对应的配置文件地址如下。
| 模型简介 | 推荐场景 | inference模型 | 预测配置文件 | 构建索引库的配置文件 |
| 模型简介 | 推荐场景 | inference 模型 | 预测配置文件 | 构建索引库的配置文件 |
| ------------ | ------------- | -------- | ------- | -------- |
| 通用主体检测模型 | 通用场景 |[模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/ppyolov2_r50vd_dcn_mainbody_v1.0_infer.tar) | - | - |
| Logo 识别模型 | Logo场景 | [模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/logo_rec_ResNet50_Logo3K_v1.0_infer.tar) | [inference_logo.yaml](../../../deploy/configs/inference_logo.yaml) | [build_logo.yaml](../../../deploy/configs/build_logo.yaml) |
| Logo 识别模型 | Logo 场景 | [模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/logo_rec_ResNet50_Logo3K_v1.0_infer.tar) | [inference_logo.yaml](../../../deploy/configs/inference_logo.yaml) | [build_logo.yaml](../../../deploy/configs/build_logo.yaml) |
| 动漫人物识别模型 | 动漫人物场景 | [模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/cartoon_rec_ResNet50_iCartoon_v1.0_infer.tar) | [inference_cartoon.yaml](../../../deploy/configs/inference_cartoon.yaml) | [build_cartoon.yaml](../../../deploy/configs/build_cartoon.yaml) |
| 车辆细分类模型 | 车辆场景 | [模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/vehicle_cls_ResNet50_CompCars_v1.0_infer.tar) | [inference_vehicle.yaml](../../../deploy/configs/inference_vehicle.yaml) | [build_vehicle.yaml](../../../deploy/configs/build_vehicle.yaml) |
| 商品识别模型 | 商品场景 | [模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/product_ResNet50_vd_aliproduct_v1.0_infer.tar) | [inference_product.yaml](../../../deploy/configs/inference_product.yaml) | [build_product.yaml](../../../deploy/configs/build_product.yaml) |
| 车辆ReID模型 | 车辆ReID场景 | [模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/vehicle_reid_ResNet50_VERIWild_v1.0_infer.tar) | - | - |
| 车辆 ReID 模型 | 车辆 ReID 场景 | [模型下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/vehicle_reid_ResNet50_VERIWild_v1.0_infer.tar) | - | - |
```shell
cd PaddleClas/deploy/
@ -315,7 +315,7 @@ wget {识别模型下载链接地址} && tar -xf {压缩包的名称}
使用如下命令下载各方向识别模型的测试数据：
```shell
# 回到deploy目录下
# 回到 deploy 目录下
cd ..
# 下载测试数据并解压
wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/recognition_demo_data_en_v1.1.tar && tar -xf recognition_demo_data_en_v1.1.tar