Merge branch 'master' of https://github.com/PaddlePaddle/PaddleClas

README.md

 # PaddleClas
 
+**文档教程**：https://paddleclas.readthedocs.io （正在持续更新中）
+
 ## 简介
 PaddleClas的目的是为工业界和学术界提供一个图像分类任务相关的百宝箱，特色如下：
-- 模型库：ResNet_vd、MobileNetV3等25种系列的分类网络结构和训练技巧，以及对应的117个分类预训练模型和性能评估
+- 模型库：ResNet_vd、MobileNetV3等23种系列的分类网络结构和训练技巧，以及对应的117个分类预训练模型和性能评估
 
-- 高阶使用：高精度的实用模型蒸馏方案（准确率82.39%的ResNet50_vd和78.9%的MobileNetV3）、8种数据增广方法的复现和验证
+- 高阶使用：高精度的实用知识蒸馏方案（准确率82.39%的ResNet50_vd和78.9%的MobileNetV3）、8种数据增广方法的复现和验证
 
-- 应用拓展：常见视觉任务的特色方案，包括图像分类领域的迁移学习（百度自研的10w类图像分类预训练模型）和通用目标检测（mAP 47.8%的实用检测方案）等
+- 应用拓展：常见视觉任务的特色方案，包括图像分类领域的迁移学习（百度自研的10万类图像分类预训练模型）和通用目标检测（mAP 47.8%的实用检测方案）等
 
-- 实用工具：便于工业应用部署的实用工具，包括TensorRT预测、移动端预测、INT8量化、多机训练、PaddleHub等
+- 实用工具：便于工业应用部署的实用工具，包括TensorRT预测、移动端预测、模型服务化部署等
 
 - 赛事支持：助力多个视觉全球挑战赛取得领先成绩，包括2018年Kaggle Open Images V4图像目标检测挑战赛冠军、2019年Kaggle地标检索挑战赛亚军等
 
 ## 模型库
 
+基于ImageNet1k分类数据集，PaddleClas提供ResNet、ResNet_vd、EfficientNet、Res2Net、HRNet、MobileNetV3等23种系列的分类网络结构的简单介绍、论文指标复现配置，以及在复现过程中的训练技巧。与此同时，PaddleClas也提供了对应的117个图像分类预训练模型，并且基于TensorRT评估了所有模型的GPU预测时间，以及在骁龙855（SD855）上评估了移动端模型的CPU预测时间和存储大小。支持的***预训练模型列表、下载地址以及更多信息***请见文档教程中的[**模型库章节**](https://paddleclas.readthedocs.io/zh_CN/latest/zh_cn/models/models_intro.html)。
+
 <div align="center">
     <img src="docs/images/models/main_fps_top1.png" width="600">
 </div>
 
-基于ImageNet1k分类数据集，PaddleClas提供ResNet、ResNet_vd、EfficientNet、Res2Net、HRNet、MobileNetV3等25种常用分类网络结构的简单介绍，论文指标复现配置，以及在复现过程中的训练技巧。与此同时，PaddleClas也提供了117个图像分类预训练模型，并且基于TensorRT评估了所有模型的GPU预测时间，以及在骁龙855（SD855）上评估了移动端模型的CPU预测时间和存储大小。
-
-上图展示了一些适合服务器端应用的模型，使用V100，FP16和TensorRT预测一个batch的时间，其中batch_size=32，图中ResNet50_vd_ssld，是采用PaddleClas提供的SSLD蒸馏方法训练的模型。图中相同颜色和符号的点代表同一系列不同规模的模型。不同模型的FLOPS和Parameters、FP16和FP32的预测时间以及不同batch_size的预测时间正在持续更新中。
+上图展示了一些适合服务器端应用的模型，使用V100，FP16和TensorRT预测一个batch的时间，其中batch_size=32，图中ResNet50_vd_ssld，是采用PaddleClas提供的SSLD蒸馏方法训练的模型。图中相同颜色和符号的点代表同一系列不同规模的模型。不同模型的FLOPS和Parameters、FP16和FP32的预测时间以及不同batch_size的预测时间请参考文档教程中的[**模型库章节**](https://paddleclas.readthedocs.io/zh_CN/latest/zh_cn/models/models_intro.html)。
 
 <div align="center">
 <img
-src="docs/images/models/mobile_arm_top1.png" width="600">
+src="docs/images/models/mobile_arm_top1.png" width="700">
 </div>
 
-上图展示了一些适合移动端应用的模型，在SD855上预测一张图像的CPU时间以及模型的存储大小。图中MV3_large_x1_0_ssld（M是MobileNet的简称），MV3_small_x1_0_ssld、MV2_ssld和MV1_ssld，是采用PaddleClas提供的SSLD蒸馏方法训练的模型。MV3_large_x1_0_ssld_int8是进一步进行INT8量化的模型。不同模型的FLOPS和Parameters、以及更多的GPU预测时间正在持续更新中。
+上图展示了一些适合移动端应用的模型，在SD855上预测一张图像的CPU时间。图中MV3_large_x1_0_ssld（M是MobileNet的简称），MV3_small_x1_0_ssld、MV2_ssld和MV1_ssld，是采用PaddleClas提供的SSLD蒸馏方法训练的模型。MV3_large_x1_0_ssld_int8是进一步进行INT8量化的模型。不同模型的FLOPS、Parameters、模型存储大小，以及更多的GPU预测时间请参考文档教程中的[**模型库章节**](https://paddleclas.readthedocs.io/zh_CN/latest/zh_cn/models/models_intro.html)。
 
 - TODO
 - [ ] EfficientLite、GhostNet、RegNet论文指标复现和性能评估
 
 ## 高阶使用
 除了提供丰富的分类网络结构和预训练模型，PaddleClas也支持了一系列有助于图像分类任务效果和效率提升的算法或工具。
-### 模型蒸馏
+### 知识蒸馏
 
-模型蒸馏是指使用教师模型(teacher model)去指导学生模型(student model)学习特定任务，保证小模型在参数量不变的情况下，得到比较大的效果提升，甚至获得与大模型相似的精度指标。PaddleClas提供了一种简单的半监督标签模型蒸馏方案（SSLD，Simple Semi-supervised Label Distillation），使用该方案大幅提升了ResNet50_vd、MobileNetV1和MobileNetV3在ImageNet数据集上分类效果。该蒸馏方案的框架图和蒸馏模型效果如下图所示，详细的蒸馏方法介绍以及使用正在持续更新中。
+知识蒸馏是指使用教师模型(teacher model)去指导学生模型(student model)学习特定任务，保证小模型在参数量不变的情况下，得到比较大的效果提升，甚至获得与大模型相似的精度指标。
 
 <div align="center">
 <img
-src="docs/images/distillation/ppcls_distillation_v1.png" width="600">
+src="docs/images/distillation/distillation_perform.png" width="500">
 </div>
 
+PaddleClas提供了一种简单的半监督标签知识蒸馏方案（SSLD，Simple Semi-supervised Label Distillation），使用该方案大幅提升了ResNet50_vd、MobileNetV1、MobileNetV2和MobileNetV3在ImageNet数据集上分类效果，如上图所示。该知识蒸馏方案的框架图如下，详细的知识蒸馏方法介绍以及使用正在持续更新中。
+
 <div align="center">
 <img
-src="docs/images/distillation/distillation_perform.png" width="500">
+src="docs/images/distillation/ppcls_distillation_v1.png" width="700">
 </div>
 
 ### 数据增广
 
-在图像分类任务中，图像数据的增广是一种常用的正则化方法，可以有效提升图像分类的效果，尤其对于数据量不足或者模型网络较深的场景。PaddleClas支持了最新的8种数据增广算法的复现和在统一实验环境下效果评估，如下图所示。每种数据增广方法的详细介绍、对比的实验环境以及使用正在持续更新中。
+在图像分类任务中，图像数据的增广是一种常用的正则化方法，可以有效提升图像分类的效果，尤其对于数据量不足或者模型网络较大的场景。PaddleClas支持了最新的8种数据增广算法的复现和在统一实验环境下的效果评估，如下图所示。每种数据增广方法的详细介绍、对比的实验环境以及使用正在持续更新中。
 
 <div align="center">
 <img
@@ -66,7 +70,7 @@ src="docs/images/image_aug/main_image_aug.png" width="600">
 
 ### 图像分类的迁移学习
 
-在实际应用中，由于训练数据的匮乏，往往将ImageNet1K数据集训练的分类模型作为预训练模型，进行图像分类的迁移学习。为了进一步助力实际问题的解决，PaddleClas计划开源百度自研的基于10万种类别，4千多万的有标签数据训练的预训练模型，同时给出多种超参搜索方法。该部分内容正在持续更新中。
+在实际应用中，由于训练数据的匮乏，往往将ImageNet1K数据集训练的分类模型作为预训练模型，进行图像分类的迁移学习。为了进一步助力实际问题的解决，PaddleClas计划开源百度自研的基于10万种类别、4千多万的有标签数据训练的预训练模型，同时给出多种超参搜索方法。该部分内容正在持续更新中。
 
 ### 通用目标检测
 
@@ -82,16 +86,17 @@ src="docs/images/det/pssdet.png" width="500">
 - [ ] PaddleClas在人脸检测和识别中的特色应用
 
 ## 实用工具
-PaddlePaddle提供了一系列实用工具，便于工业应用部署PaddleClas，详细使用请参考文档教程。
+PaddlePaddle提供了一系列实用工具，便于工业应用部署PaddleClas，具体请参考文档教程中的[**实用工具章节**](https://paddleclas.readthedocs.io/zh_CN/latest/zh_cn/extension/index.html)。
 
 - TensorRT预测
-- 移动端预测
-- INT8量化
+- Paddle-Lite
+- 模型服务化部署
+- 模型量化
 - 多机训练
-- PaddleHub
+- Paddle Hub
 
 ## 赛事支持
-PaddleClas的建设源于百度实际视觉业务应用的淬炼和视觉前沿能力的探索，助力多个视觉重点赛事取得领先成绩，并且持续推进更多的前沿视觉问题的解决和落地应用。
+PaddleClas的建设源于百度实际视觉业务应用的淬炼和视觉前沿能力的探索，助力多个视觉重点赛事取得领先成绩，并且持续推进更多的前沿视觉问题的解决和落地应用。更多内容请关注文档教程中的[**赛事支持章节**](https://paddleclas.readthedocs.io/zh_CN/latest/zh_cn/competition_support.html)
 
 - 2018年Kaggle Open Images V4图像目标检测挑战赛冠军
 - 2019年Kaggle Open Images V5图像目标检测挑战赛亚军

docs/zh_CN/models/models_intro.md

@@ -7,6 +7,7 @@
 ![](../../images/models/main_fps_top1.png)
 ![](../../images/models/mobile_arm_top1.png)
 
+## 预训练模型列表及下载地址
 - 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/ResNet18_pretrained.tar)

docs/zh_cn/advanced_tutorials/image_augmentation/ImageAugment.md

+# 一、数据增广
+
+在图像分类任务中，图像数据的增广是一种常用的正则化方法，尤其对于数据量不足或者模型参数较多的场景。在本章节中，我们将对除 ImageNet 分类任务标准数据增广外的8种数据增广方式进行简单的介绍和对比，用户也可以将这些增广方法应用到自己的任务中，以获得模型精度的提升。
+
+
+# 二、常用数据增广方法
+
+如果没有特殊说明，本章节中所有示例为 ImageNet 分类，并且假设最终输入网络的数据维度为：`[batch-size, 3, 224, 224]`
+
+其中 ImageNet 分类训练阶段的标准数据增广方式分为以下几个步骤：
+
+1. 图像解码：简写为 `ImageDecode`
+2. 随机裁剪到长宽均为 224 的图像：简写为 `RandCrop`
+3. 水平方向随机翻转：简写为 `RandFlip`
+4. 图像数据的归一化：简写为 `Normalize`
+5. 图像数据的重排，`[224, 224, 3]` 变为 `[3, 224, 224]`：简写为 `Transpose`
+6. 多幅图像数据组成 batch 数据，如 `batch-size` 个 `[3, 224, 224]` 的图像数据拼组成 `[batch-size, 3, 224, 224]`：简写为 `Batch`
+
+相比于上述标准的图像增广方法，研究者也提出了很多改进的图像增广策略，这些策略均是在标准增广方法的不同阶段插入一定的操作，基于这些策略操作所处的不同阶段，我们将其分为了三类：
+
+1. 对 `RandCrop` 后的 224 的图像进行一些变换：AutoAugment，RandAugment
+2. 对`Transpose` 后的 224 的图像进行一些裁剪:CutOut，RandErasing，HideAndSeek，GridMask
+3. 对 `Batch` 后的数据进行混合：Mixup，Cutmix
+
+
+具体如下表所示：
+
+
+| 变换方法        | 输入                        | 输出                        | Auto-<br>Augment\[1\] | Rand-<br>Augment\[2\] | CutOut\[3\] | Rand<br>Erasing\[4\] | HideAnd-<br>Seek\[5\] | GridMask\[6\] | Mixup\[7\] | Cutmix\[8\] |
+|-------------|---------------------------|---------------------------|------------------|------------------|-------------|------------------|------------------|---------------|------------|------------|
+| Image<br>Decode | Binary                    | (224, 224, 3)<br>uint8      | Y                | Y                | Y           | Y                | Y                | Y             | Y          | Y |
+| RandCrop    | (:, :, 3)<br>uint8          | (224, 224, 3)<br>uint8      | Y                | Y                | Y           | Y                | Y                | Y             | Y          | Y |
+| **Process**     | (224, 224, 3)<br>uint8      | (224, 224, 3)<br>uint8      | Y                | Y                | \-          | \-               | \-               | \-            | \-         | \- |
+| RandFlip    | (224, 224, 3)<br>uint8      | (224, 224, 3)<br>float32    | Y                | Y                | Y           | Y                | Y                | Y             | Y          | Y |
+| Normalize   | (224, 224, 3)<br>uint8      | (3, 224, 224)<br>float32    | Y                | Y                | Y           | Y                | Y                | Y             | Y          | Y |
+| Transpose   | (224, 224, 3)<br>float32    | (3, 224, 224)<br>float32    | Y                | Y                | Y           | Y                | Y                | Y             | Y          | Y |
+| **Process**     | (3, 224, 224)<br>float32    | (3, 224, 224)<br>float32    | \-               | \-               | Y           | Y                | Y                | Y             | \-         | \- |
+| Batch       | (3, 224, 224)<br>float32    | (N, 3, 224, 224)<br>float32 | Y                | Y                | Y           | Y                | Y                | Y             | Y          | Y |
+| **Process**     | (N, 3, 224, 224)<br>float32 | (N, 3, 224, 224)<br>float32 | \-               | \-               | \-          | \-               | \-               | \-            | Y          | Y |
+
+
+PaddleClas中集成了上述所有的数据增广策略，下文将介绍这些策略的原理与使用方法，并以下图为例，对变换后的效果进行可视化。为了说明问题，本章节中将 `RandCrop` 替换为 `Resize`。
+
+![test_baseline][test_baseline]
+
+# 三、图像变换类
+
+图像变换类指的是对 `RandCrop` 后的 224 的图像进行一些变换，主要包括
+
++ AutoAugment
++ RandAugment
+
+## 3.1 AutoAugment
+
+论文地址：[https://arxiv.org/abs/1805.09501v1](https://arxiv.org/abs/1805.09501v1)
+
+开源代码github地址：[https://github.com/DeepVoltaire/AutoAugment](https://github.com/DeepVoltaire/AutoAugment)
+
+不同于常规的人工设计图像增广方式，AutoAugment 是在一系列图像增广子策略的搜索空间中通过搜索算法找到的适合特定数据集的图像增广方案。针对 ImageNet 数据集，最终搜索出来的数据增广方案包含 25 个子策略组合，每个子策略中都包含两种变换，针对每幅图像都随机的挑选一个子策略组合，然后以一定的概率来决定是否执行子策略中的每种变换。
+
+PaddleClas中`AutoAugment`的使用方法如下所示。
+
+```python
+from ppcls.data.imaug import DecodeImage
+from ppcls.data.imaug import ResizeImage
+from ppcls.data.imaug import ImageNetPolicy
+from ppcls.data.imaug import transform
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+autoaugment_op = ImageNetPolicy()
+
+ops = [decode_op, resize_op, autoaugment_op]
+
+imgs_dir = 图像路径
+fnames = os.listdir(imgs_dir)
+for f in fnames:
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+```
+
+结果如下图所示。
+
+![test_autoaugment][test_autoaugment]
+
+## 3.2 RandAugment
+
+论文地址：[https://arxiv.org/pdf/1909.13719.pdf](https://arxiv.org/pdf/1909.13719.pdf)
+
+开源代码github地址：[https://github.com/heartInsert/randaugment](https://github.com/heartInsert/randaugment)
+
+
+`AutoAugment` 的搜索方法比较暴力，直接在数据集上搜索针对该数据集的最优策略，其计算量很大。在 `RandAugment` 文章中作者发现，一方面，针对越大的模型，越大的数据集，使用 `AutoAugment` 方式搜索到的增广方式产生的收益也就越小；另一方面，这种搜索出的最优策略是针对该数据集的，其迁移能力较差，并不太适合迁移到其他数据集上。
+
+在 `RandAugment` 中，作者提出了一种随机增广的方式，不再像 `AutoAugment` 中那样使用特定的概率确定是否使用某种子策略，而是所有的子策略都会以同样的概率被选择到，论文中的实验也表明这种数据增广方式即使在大模型的训练中也具有很好的效果。
+
+
+PaddleClas中`RandAugment`的使用方法如下所示。
+
+```python
+from ppcls.data.imaug import DecodeImage
+from ppcls.data.imaug import ResizeImage
+from ppcls.data.imaug import RandAugment
+from ppcls.data.imaug import transform
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+randaugment_op = RandAugment()
+
+ops = [decode_op, resize_op, randaugment_op]
+
+imgs_dir = 图像路径
+fnames = os.listdir(imgs_dir)
+for f in fnames:
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+```
+
+结果如下图所示。
+
+![test_randaugment][test_randaugment]
+
+
+# 四、图像裁剪类
+
+图像裁剪类主要是对`Transpose` 后的 224 的图像进行一些裁剪，并将裁剪区域的像素值置为特定的常数（默认为0），主要包括：
+
++ CutOut
++ RandErasing
++ HideAndSeek
++ GridMask
+
+图像裁剪的这些增广并非一定要放在归一化之后，也有不少实现是放在归一化之前的，也就是直接对 uint8 的图像进行操作，两种方式的差别是：如果直接对 uint8 的图像进行操作，那么再经过归一化之后被裁剪的区域将不再是纯黑或纯白（减均值除方差之后像素值不为0）。而对归一后之后的数据进行操作，裁剪的区域会是纯黑或纯白。
+
+上述的裁剪变换思路是相同的，都是为了解决训练出的模型在有遮挡数据上泛化能力较差的问题，不同的是他们的裁剪方式、区域不太一样。
+
+## 4.1 Cutout
+
+论文地址：[https://arxiv.org/abs/1708.04552](https://arxiv.org/abs/1708.04552)
+
+开源代码github地址：[https://github.com/uoguelph-mlrg/Cutout](https://github.com/uoguelph-mlrg/Cutout)
+
+Cutout 可以理解为 Dropout 的一种扩展操作，不同的是 Dropout 是对图像经过网络后生成的特征进行遮挡，而 Cutout 是直接对输入的图像进行遮挡，相对于Dropout对噪声的鲁棒性更好。作者在论文中也进行了说明，这样做法有以下两点优势：(1) 通过 Cutout 可以模拟真实场景中主体被部分遮挡时的分类场景；(2) 可以促进模型充分利用图像中更多的内容来进行分类，防止网络只关注显著性的图像区域，从而发生过拟合。
+
+
+PaddleClas中`Cutout`的使用方法如下所示。
+
+```python
+from ppcls.data.imaug import DecodeImage
+from ppcls.data.imaug import ResizeImage
+from ppcls.data.imaug import Cutout
+from ppcls.data.imaug import transform
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+cutout_op = Cutout(n_holes=1, length=112)
+
+ops = [decode_op, resize_op, cutout_op]
+
+imgs_dir = 图像路径
+fnames = os.listdir(imgs_dir)
+for f in fnames:
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+```
+
+结果如下图所示。
+
+![test_cutout][test_cutout]
+
+## 4.2 RandomErasing
+
+论文地址：[https://arxiv.org/pdf/1708.04896.pdf](https://arxiv.org/pdf/1708.04896.pdf)
+
+开源代码github地址：[https://github.com/zhunzhong07/Random-Erasing](https://github.com/zhunzhong07/Random-Erasing)
+
+`RandomErasing` 与 `Cutout` 方法类似，同样是为了解决训练出的模型在有遮挡数据上泛化能力较差的问题，作者在论文中也指出，随机裁剪的方式与随机水平翻转具有一定的互补性。作者也在行人再识别（REID）上验证了该方法的有效性。与`Cutout`不同的是，在`RandomErasing`中，图片以一定的概率接受该种预处理方法，生成掩码的尺寸大小与长宽比也是根据预设的超参数随机生成。
+
+
+PaddleClas中`RandomErasing`的使用方法如下所示。
+
+```python
+from ppcls.data.imaug import DecodeImage
+from ppcls.data.imaug import ResizeImage
+from ppcls.data.imaug import ToCHWImage
+from ppcls.data.imaug import RandomErasing
+from ppcls.data.imaug import transform
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+randomerasing_op = RandomErasing()
+
+ops = [decode_op, resize_op, tochw_op, randomerasing_op]
+
+imgs_dir = 图像路径
+fnames = os.listdir(imgs_dir)
+for f in fnames:
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+    img = img.transpose((1, 2, 0))
+```
+
+结果如下图所示。
+
+![test_randomerassing][test_randomerassing]
+
+
+## 4.3 HideAndSeek
+
+论文地址：[https://arxiv.org/pdf/1811.02545.pdf](https://arxiv.org/pdf/1811.02545.pdf)
+
+开源代码github地址：[https://github.com/kkanshul/Hide-and-Seek](https://github.com/kkanshul/Hide-and-Seek)
+
+
+`HideAndSeek`论文将图像分为若干块区域(patch)，对于每块区域，都以一定的概率生成掩码，不同区域的掩码含义如下图所示。
+
+
+![hide_and_seek_mask_expanation][hide_and_seek_mask_expanation]
+
+
+PaddleClas中`HideAndSeek`的使用方法如下所示。
+
+```python
+from ppcls.data.imaug import DecodeImage
+from ppcls.data.imaug import ResizeImage
+from ppcls.data.imaug import ToCHWImage
+from ppcls.data.imaug import HideAndSeek
+from ppcls.data.imaug import transform
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+hide_and_seek_op = HideAndSeek()
+
+ops = [decode_op, resize_op, tochw_op, hide_and_seek_op]
+
+imgs_dir = 图像路径
+fnames = os.listdir(imgs_dir)
+for f in fnames:
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+    img = img.transpose((1, 2, 0))
+```
+
+结果如下图所示。
+
+![test_hideandseek][test_hideandseek]
+
+
+## 4.4 GridMask
+论文地址：[https://arxiv.org/abs/2001.04086](https://arxiv.org/abs/2001.04086)
+
+开源代码github地址：[https://github.com/akuxcw/GridMask](https://github.com/akuxcw/GridMask)
+
+
+作者在论文中指出，此前存在的基于对图像 crop 的方法存在两个问题，如下图所示：
+
+1. 过度删除区域可能造成目标主体大部分甚至全部被删除，或者导致上下文信息的丢失，导致增广后的数据成为噪声数据；
+2. 保留过多的区域，对目标主体及上下文基本产生不了什么影响，失去增广的意义。
+
+![gridmask-0][gridmask-0]
+
+因此如果避免过度删除或过度保留成为需要解决的核心问题。
+
+
+`GridMask`是通过生成一个与原图分辨率相同的掩码，并将掩码进行随机翻转，与原图相乘，从而得到增广后的图像，通过超参数控制生成的掩码网格的大小。
+
+
+在训练过程中，有两种以下使用方法：
+1. 设置一个概率p，从训练开始就对图片以概率p使用`GridMask`进行增广。
+2. 一开始设置增广概率为0，随着迭代轮数增加，对训练图片进行`GridMask`增广的概率逐渐增大，最后变为p。
+
+论文中验证上述第二种方法的训练效果更好一些。
+
+
+PaddleClas中`GridMask`的使用方法如下所示。
+
+
+```python
+from data.imaug import DecodeImage
+from data.imaug import ResizeImage
+from data.imaug import ToCHWImage
+from data.imaug import GridMask
+from data.imaug import transform
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+tochw_op = ToCHWImage()
+gridmask_op = GridMask(d1=96, d2=224, rotate=1, ratio=0.6, mode=1, prob=0.8)
+
+ops = [decode_op, resize_op, tochw_op, gridmask_op]
+
+imgs_dir = 图像路径
+fnames = os.listdir(imgs_dir)
+for f in fnames:
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+    img = img.transpose((1, 2, 0))
+```
+
+
+结果如下图所示。
+
+![test_gridmask][test_gridmask]
+
+
+# 五、图像混叠
+
+图像混叠主要对 `Batch` 后的数据进行混合，包括：
+
++ Mixup
++ Cutmix
+
+前文所述的图像变换与图像裁剪都是针对单幅图像进行的操作，而图像混叠是对两幅图像进行融合，生成一幅图像，两种方法的主要区别为混叠的方式不太一样。
+
+## 5.1 Mixup
+
+论文地址：[https://arxiv.org/pdf/1710.09412.pdf](https://arxiv.org/pdf/1710.09412.pdf)
+
+开源代码github地址：[https://github.com/facebookresearch/mixup-cifar10](https://github.com/facebookresearch/mixup-cifar10)
+
+Mixup 是最先提出的图像混叠增广方案，其原理简单、方便实现，不仅在图像分类上，在目标检测上也取得了不错的效果。为了便于实现，通常只对一个 batch 内的数据进行混叠，在 `Cutmix` 中也是如此。
+
+如下是 `imaug` 中的实现，需要指出的是，下述实现会出现对同一幅进行相加的情况，也就是最终得到的图和原图一样，随着 `batch-size` 的增加这种情况出现的概率也会逐渐减小。
+
+PaddleClas中`Mixup`的使用方法如下所示。
+
+```python
+from ppcls.data.imaug import DecodeImage
+from ppcls.data.imaug import ResizeImage
+from ppcls.data.imaug import ToCHWImage
+from ppcls.data.imaug import transform
+from ppcls.data.imaug import MixupOperator
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+tochw_op = ToCHWImage()
+hide_and_seek_op = HideAndSeek()
+mixup_op = MixupOperator()
+cutmix_op = CutmixOperator()
+
+ops = [decode_op, resize_op, tochw_op]
+
+imgs_dir = 图像路径
+
+batch = []
+fnames = os.listdir(imgs_dir)
+for idx, f in enumerate(fnames):
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+    batch.append( (img, idx) ) # fake label
+
+new_batch = mixup_op(batch)
+```
+
+结果如下图所示。
+
+![test_mixup][test_mixup]
+
+## 5.2 Cutmix
+
+论文地址：[https://arxiv.org/pdf/1905.04899v2.pdf](https://arxiv.org/pdf/1905.04899v2.pdf)
+
+开源代码github地址：[https://github.com/clovaai/CutMix-PyTorch](https://github.com/clovaai/CutMix-PyTorch)
+
+与  `Mixup` 直接对两幅图进行相加不一样，`Cutmix` 是从一幅图中随机裁剪出一个 `ROI`，然后覆盖当前图像中对应的区域，代码实现如下所示：
+
+```python
+rom ppcls.data.imaug import DecodeImage
+from ppcls.data.imaug import ResizeImage
+from ppcls.data.imaug import ToCHWImage
+from ppcls.data.imaug import transform
+from ppcls.data.imaug import CutmixOperator
+
+size = 224
+
+decode_op = DecodeImage()
+resize_op = ResizeImage(size=(size, size))
+tochw_op = ToCHWImage()
+hide_and_seek_op = HideAndSeek()
+cutmix_op = CutmixOperator()
+
+ops = [decode_op, resize_op, tochw_op]
+
+imgs_dir = 图像路径
+
+batch = []
+fnames = os.listdir(imgs_dir)
+for idx, f in enumerate(fnames):
+    data = open(os.path.join(imgs_dir, f)).read()
+    img = transform(data, ops)
+    batch.append( (img, idx) ) # fake label
+
+new_batch = cutmix_op(batch)
+```
+
+结果如下图所示。
+
+![test_cutmix][test_cutmix]
+
+
+
+# 六、实验
+
+基于PaddleClas，在ImageNet1k数据集上的分类精度如下。
+
+| 模型          | 初始学习率策略  | l2 decay | batch size | epoch | 数据变化策略         | Top1 Acc    | 论文中结论 |
+|-------------|------------------|--------------|------------|-------|----------------|------------|----|
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | 标准变换           | 0.7731 | - |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | AutoAugment    | 0.7795 |  0.7763 |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | mixup          | 0.7828 |  0.7790 |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | cutmix         | 0.7839 |  0.7860 |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | cutout         | 0.7801 |  - |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | gridmask       | 0.7785 |  0.7790 |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | random-augment | 0.7770 |  0.7760 |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | random erasing | 0.7791 |  - |
+| ResNet50 | 0.1/cosine_decay | 0.0001       | 256        | 300   | hide and seek  | 0.7743 |  0.7720 |
+
+**注意**：
+* 在这里的实验中，为了便于对比，我们将l2 decay固定设置为1e-4，在实际使用中，我们推荐尝试使用更小的l2 decay。结合数据增广，我们发现将l2 decay由1e-4减小为7e-5均能带来至少0.3~0.5%的精度提升。
+* 我们目前尚未对不同策略进行组合并验证效果，这一块后续我们会开展更多的对比实验，敬请期待。
+
+
+# 参考文献
+
+[1] Cubuk E D, Zoph B, Mane D, et al. Autoaugment: Learning augmentation strategies from data[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2019: 113-123.
+
+
+[2] Cubuk E D, Zoph B, Shlens J, et al. Randaugment: Practical automated data augmentation with a reduced search space[J]. arXiv preprint arXiv:1909.13719, 2019.
+
+[3] DeVries T, Taylor G W. Improved regularization of convolutional neural networks with cutout[J]. arXiv preprint arXiv:1708.04552, 2017.
+
+[4] Zhong Z, Zheng L, Kang G, et al. Random erasing data augmentation[J]. arXiv preprint arXiv:1708.04896, 2017.
+
+[5] Singh K K, Lee Y J. Hide-and-seek: Forcing a network to be meticulous for weakly-supervised object and action localization[C]//2017 IEEE international conference on computer vision (ICCV). IEEE, 2017: 3544-3553.
+
+[6] Chen P. GridMask Data Augmentation[J]. arXiv preprint arXiv:2001.04086, 2020.
+
+[7] Zhang H, Cisse M, Dauphin Y N, et al. mixup: Beyond empirical risk minimization[J]. arXiv preprint arXiv:1710.09412, 2017.
+
+[8] Yun S, Han D, Oh S J, et al. Cutmix: Regularization strategy to train strong classifiers with localizable features[C]//Proceedings of the IEEE International Conference on Computer Vision. 2019: 6023-6032.
+
+
+
+[test_baseline]: ../../../images/image_aug/test_baseline.jpeg
+[test_autoaugment]: ../../../images/image_aug/test_autoaugment.jpeg
+[test_cutout]: ../../../images/image_aug/test_cutout.jpeg
+[test_gridmask]: ../../../images/image_aug/test_gridmask.jpeg
+[gridmask-0]: ../../../images/image_aug/gridmask-0.png
+[test_hideandseek]: ../../../images/image_aug/test_hideandseek.jpeg
+[test_randaugment]: ../../../images/image_aug/test_randaugment.jpeg
+[test_randomerassing]: ../../../images/image_aug/test_randomerassing.jpeg
+[hide_and_seek_mask_expanation]: ../../../images/image_aug/hide-and-seek-visual.png
+[test_mixup]: ../../../images/image_aug/test_mixup.png
+[test_cutmix]: ../../../images/image_aug/test_cutmix.png

docs/zh_cn/advanced_tutorials/image_augmentation/index.rst

+图像增广
+================================
+
+.. toctree::
+   :maxdepth: 3
+
+   ImageAugment.md

docs/zh_cn/advanced_tutorials/index.rst

+高阶使用
+================================
+
+.. toctree::
+   :maxdepth: 1
+
+   image_augmentation/index
+   distillation/index
+

docs/zh_cn/competition_support.md

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

ppcls/data/imaug/autoaugment.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-#This code is based on https://github.com/DeepVoltaire/AutoAugment/blob/master/autoaugment.py
+# This code is based on https://github.com/DeepVoltaire/AutoAugment/blob/master/autoaugment.py
 
 from PIL import Image, ImageEnhance, ImageOps
 import numpy as np

ppcls/data/imaug/cutout.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# This code is based on https://github.com/uoguelph-mlrg/Cutout
+
 import numpy as np
 import random
 

ppcls/data/imaug/grid.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# This code is based on https://github.com/akuxcw/GridMask
+
 import numpy as np
 from PIL import Image
 import pdb

ppcls/data/imaug/hide_and_seek.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# This code is based on https://github.com/kkanshul/Hide-and-Seek
+
 import numpy as np
 import random
 

ppcls/data/imaug/randaugment.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-#This code is based on https://github.com/
+#This code is based on https://github.com/heartInsert/randaugment
 
 from PIL import Image, ImageEnhance, ImageOps
 import numpy as np

ppcls/data/imaug/random_erasing.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+#This code is based on https://github.com/zhunzhong07/Random-Erasing
+
 import math
 import random
 

ppcls/data/reader.py

@@ -140,7 +140,8 @@ def get_file_list(params):
     full_lines = shuffle_lines(full_lines, params["shuffle_seed"])
 
     # use only partial data for each trainer in distributed training
-    full_lines = full_lines[trainer_id::trainers_num]
+    img_per_trainer = len(full_lines) // trainers_num
+    full_lines = full_lines[trainer_id::trainers_num][:img_per_trainer]
 
     return full_lines
 

tools/infer/predict.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 import utils
 import argparse
 import numpy as np
@@ -24,6 +23,7 @@ from paddle.fluid.core import create_paddle_predictor
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+
 def parse_args():
     def str2bool(v):
         return v.lower() in ("true", "t", "1")
@@ -47,19 +47,18 @@ def parse_args():
 def create_predictor(args):
     config = AnalysisConfig(args.model_file, args.params_file)
 
-
-
     if args.use_gpu:
         config.enable_use_gpu(args.gpu_mem, 0)
     else:
         config.disable_gpu()
 
     config.disable_glog_info()
-    config.switch_ir_optim(args.ir_optim) # default true
+    config.switch_ir_optim(args.ir_optim)  # default true
     if args.use_tensorrt:
         config.enable_tensorrt_engine(
-                precision_mode=AnalysisConfig.Precision.Half if args.use_fp16 else AnalysisConfig.Precision.Float32,
-                max_batch_size=args.batch_size)
+            precision_mode=AnalysisConfig.Precision.Half
+            if args.use_fp16 else AnalysisConfig.Precision.Float32,
+            max_batch_size=args.batch_size)
 
     config.enable_memory_optim()
     # use zero copy
@@ -79,7 +78,7 @@ def create_operators():
     resize_op = utils.ResizeImage(resize_short=256)
     crop_op = utils.CropImage(size=(size, size))
     normalize_op = utils.NormalizeImage(
-            scale=img_scale, mean=img_mean, std=img_std)
+        scale=img_scale, mean=img_mean, std=img_std)
     totensor_op = utils.ToTensor()
 
     return [decode_op, resize_op, crop_op, normalize_op, totensor_op]
@@ -104,38 +103,62 @@ def main():
         assert args.model_name is not None
         assert args.use_tensorrt == True
     # HALF precission predict only work when using tensorrt
-    if args.use_fp16==True:
+    if args.use_fp16 == True:
         assert args.use_tensorrt == True
 
     operators = create_operators()
     predictor = create_predictor(args)
 
     inputs = preprocess(args.image_file, operators)
-    inputs = np.expand_dims(inputs, axis=0).repeat(args.batch_size, axis=0).copy()
+    inputs = np.expand_dims(
+        inputs, axis=0).repeat(
+            args.batch_size, axis=0).copy()
 
     input_names = predictor.get_input_names()
     input_tensor = predictor.get_input_tensor(input_names[0])
-    input_tensor.copy_from_cpu(inputs)
+
+    output_names = predictor.get_output_names()
+    output_tensor = predictor.get_output_tensor(output_names[0])
+
+    test_num = 500
+    test_time = 0.0
     if not args.enable_benchmark:
+        inputs = preprocess(args.image_file, operators)
+        inputs = np.expand_dims(
+            inputs, axis=0).repeat(
+                args.batch_size, axis=0).copy()
+        input_tensor.copy_from_cpu(inputs)
+
         predictor.zero_copy_run()
+
+        output = output_tensor.copy_to_cpu()
+        output = output.flatten()
+        cls = np.argmax(output)
+        score = output[cls]
+        logger.info("class: {0}".format(cls))
+        logger.info("score: {0}".format(score))
     else:
-        for i in range(0,1010):
-            if i == 10:
-                start = time.time()
+        for i in range(0, test_num + 10):
+            inputs = np.random.rand(args.batch_size, 3, 224,
+                                    224).astype(np.float32)
+            start_time = time.time()
+            input_tensor.copy_from_cpu(inputs)
+
             predictor.zero_copy_run()
 
-        end = time.time()
-        fp_message = "FP16" if args.use_fp16 else "FP32"
-        logger.info("{0}\t{1}\tbatch size: {2}\ttime(ms): {3}".format(args.model_name, fp_message, args.batch_size, end-start))
+            output = output_tensor.copy_to_cpu()
+            output = output.flatten()
+            if i >= 10:
+                test_time += time.time() - start_time
+            cls = np.argmax(output)
+            score = output[cls]
+            logger.info("class: {0}".format(cls))
+            logger.info("score: {0}".format(score))
 
-    output_names = predictor.get_output_names()
-    output_tensor = predictor.get_output_tensor(output_names[0])
-    output = output_tensor.copy_to_cpu()
-    output = output.flatten()
-    cls = np.argmax(output)
-    score = output[cls]
-    logger.info("class: {0}".format(cls))
-    logger.info("score: {0}".format(score))
+        fp_message = "FP16" if args.use_fp16 else "FP32"
+        logger.info("{0}\t{1}\tbatch size: {2}\ttime(ms): {3}".format(
+            args.model_name, fp_message, args.batch_size, 1000 * test_time /
+            test_num))
 
 
 if __name__ == "__main__":

tools/run_download.sh

+#!/usr/bin/env bash
+
+export PYTHONPATH=$PWD:$PYTHONPATH
+
+python tools/download.py -a ResNet34 -p ./pretrained/ -d 1