merge develop

README_ch.md

@@ -23,28 +23,17 @@
 
 ## 近期更新
 
-- 🔥️ 2022.9.14 晚上8:30  **商超零售新革命-生鲜智能结算产业应用**，扫码进群获取直播链接
-
-  <div align="center">
-    <img src="https://user-images.githubusercontent.com/11568925/189877049-d17ddcea-22d2-44ab-91fe-36d12af3add8.png" width = "200" height = "200"/>
-  </div>
-
-- 🔥️ 2022.9.13发布[PP-ShiTuV2](./docs/zh_CN/PPShiTu/PPShiTuV2_introduction.md)，recall1精度提升8个点，覆盖[20+识别场景](./docs/zh_CN/introduction/ppshitu_application_scenarios.md)，新增[库管理工具](./deploy/shitu_index_manager/)，[Android Demo](./docs/zh_CN/quick_start/quick_start_recognition.md)全新体验。
-
+- 🔥️ 发布[PP-ShiTuV2](docs/zh_CN/models/PP-ShiTu/README.md)，recall1精度提升8个点，覆盖[20+识别场景](docs/zh_CN/deployment/PP-ShiTu/application_scenarios.md)，新增[库管理工具](./deploy/shitu_index_manager/)，[Android Demo](./docs/zh_CN/quick_start/quick_start_recognition.md)全新体验。
 - 2022.9.4 新增[生鲜产品自主结算范例库](./docs/zh_CN/samples/Fresh_Food_Recogniiton/README.md)，具体内容可以在AI Studio上体验。
-
-- 2022.6.15 发布[PULC超轻量图像分类实用方案](docs/zh_CN/PULC/PULC_train.md)，CPU推理3ms，精度比肩SwinTransformer，覆盖人、车、OCR场景九大常见任务。
-
+- 2022.6.15 发布[PULC超轻量图像分类实用方案](docs/zh_CN/training/PULC.md)，CPU推理3ms，精度比肩SwinTransformer，覆盖人、车、OCR场景九大常见任务。
 - 2022.5.23 新增[人员出入管理范例库](https://aistudio.baidu.com/aistudio/projectdetail/4094475)，具体内容可以在 AI Studio 上体验。
-
-- 2022.5.20 上线[PP-HGNet](./docs/zh_CN/models/PP-HGNet.md), [PP-LCNetv2](./docs/zh_CN/models/PP-LCNetV2.md)。
-
-- [more](./docs/zh_CN/others/update_history.md)
+- 2022.5.20 上线[PP-HGNet](./docs/zh_CN/models/ImageNet1k/PP-HGNet.md), [PP-LCNetv2](./docs/zh_CN/models/ImageNet1k/PP-LCNetV2.md)。
+- [more](docs/zh_CN/version_history.md)
 
 ## 特性
 
-PaddleClas发布了[PP-HGNet](docs/zh_CN/models/PP-HGNet.md)、[PP-LCNetv2](docs/zh_CN/models/PP-LCNetV2.md)、 [PP-LCNet](docs/zh_CN/models/PP-LCNet.md)和[SSLD半监督知识蒸馏方案](docs/zh_CN/advanced_tutorials/ssld.md)等算法，
-并支持多种图像分类、识别相关算法，在此基础上打造[PULC超轻量图像分类方案](docs/zh_CN/PULC/PULC_quickstart.md)和[PP-ShiTu图像识别系统](./docs/zh_CN/quick_start/quick_start_recognition.md)。
+PaddleClas发布了[PP-HGNet](docs/zh_CN/models/ImageNet1k/PP-HGNet.md)、[PP-LCNetv2](docs/zh_CN/models/ImageNet1k/PP-LCNetV2.md)、 [PP-LCNet](docs/zh_CN/models/ImageNet1k/PP-LCNet.md)和[SSLD半监督知识蒸馏方案](docs/zh_CN/training/advanced/ssld.md)等算法，
+并支持多种图像分类、识别相关算法，在此基础上打造[PULC超轻量图像分类方案](docs/zh_CN/quick_start/PULC.md)和[PP-ShiTu图像识别系统](./docs/zh_CN/quick_start/quick_start_recognition.md)。
 ![](https://user-images.githubusercontent.com/11568925/189267545-7a6eefa0-b4fc-4ed0-ae9d-7c6d53f59798.png)
 
 
@@ -59,7 +48,7 @@ PaddleClas发布了[PP-HGNet](docs/zh_CN/models/PP-HGNet.md)、[PP-LCNetv2](docs
 
 ## 快速体验
 
-PULC超轻量图像分类方案快速体验：[点击这里](docs/zh_CN/PULC/PULC_quickstart.md)
+PULC超轻量图像分类方案快速体验：[点击这里](docs/zh_CN/quick_start/PULC.md)
 
 PP-ShiTu图像识别快速体验：[点击这里](./docs/zh_CN/quick_start/quick_start_recognition.md)
 
@@ -75,66 +64,66 @@ PP-ShiTuV2 Android Demo APP，可扫描如下二维码，下载体验
 
 - 基于PP-ShiTu v2的生鲜品自助结算： [点击这里](./docs/zh_CN/samples/Fresh_Food_Recogniiton/README.md)
 - 基于PULC人员出入视频管理： [点击这里](./docs/zh_CN/samples/Personnel_Access/README.md)
-- 基于 PP-ShiTu 的智慧商超商品识别：[点击这里](./docs/zh_CN/Goods_Recognition/README.md)
+- 基于 PP-ShiTu 的智慧商超商品识别：[点击这里](./docs/zh_CN/samples/Goods_Recognition/README.md)
 - 基于PP-ShiTu电梯内电瓶车入室识别：[点击这里](./docs/zh_CN/samples//Electromobile_In_Elevator_Detection/README.md)
 
 ## 文档教程
-- [环境准备](docs/zh_CN/installation/install_paddleclas.md)
-- [PP-ShiTuV2图像识别系统介绍](./docs/zh_CN/PPShiTu/PPShiTuV2_introduction.md)
+- [环境准备](docs/zh_CN/installation.md)
+- [PP-ShiTuV2图像识别系统介绍](docs/zh_CN/models/PP-ShiTu/README.md)
   - [图像识别快速体验](docs/zh_CN/quick_start/quick_start_recognition.md)
-  - [20+应用场景库](docs/zh_CN/introduction/ppshitu_application_scenarios.md)
+  - [20+应用场景库](docs/zh_CN/deployment/PP-ShiTu/application_scenarios.md)
   - 子模块算法介绍及模型训练
-    - [主体检测](./docs/zh_CN/image_recognition_pipeline/mainbody_detection.md)
-    - [特征提取模型](./docs/zh_CN/image_recognition_pipeline/feature_extraction.md)
-    - [向量检索](./docs/zh_CN/image_recognition_pipeline/vector_search.md)
-    - [哈希编码](docs/zh_CN/image_recognition_pipeline/deep_hashing.md)
+    - [主体检测](docs/zh_CN/training/PP-ShiTu/mainbody_detection.md)
+    - [特征提取模型](docs/zh_CN/training/PP-ShiTu/feature_extraction.md)
+    - [向量检索](docs/zh_CN/deployment/PP-ShiTu/vector_search.md)
+    - [哈希编码](docs/zh_CN/training/PP-ShiTu/deep_hashing.md)
   - PipeLine 推理部署
-    - [基于python预测引擎推理](docs/zh_CN/inference_deployment/python_deploy.md#2)
+    - [基于python预测引擎推理](docs/zh_CN/deployment/image_classification/python.md#2)
     - [基于C++预测引擎推理](deploy/cpp_shitu/readme.md)
-    - [服务化部署](docs/zh_CN/inference_deployment/recognition_serving_deploy.md)
-    - [端侧部署](docs/zh_CN/inference_deployment/lite_shitu.md)
-    - [库管理工具](docs/zh_CN/inference_deployment/shitu_gallery_manager.md)
-- [PULC超轻量图像分类实用方案](docs/zh_CN/PULC/PULC_train.md)
-  - [超轻量图像分类快速体验](docs/zh_CN/PULC/PULC_quickstart.md)
-  - [超轻量图像分类模型库](docs/zh_CN/PULC/PULC_model_list.md)
-    - [PULC有人/无人分类模型](docs/zh_CN/PULC/PULC_person_exists.md)
-    - [PULC人体属性识别模型](docs/zh_CN/PULC/PULC_person_attribute.md)
-    - [PULC佩戴安全帽分类模型](docs/zh_CN/PULC/PULC_safety_helmet.md)
-    - [PULC交通标志分类模型](docs/zh_CN/PULC/PULC_traffic_sign.md)
-    - [PULC车辆属性识别模型](docs/zh_CN/PULC/PULC_vehicle_attribute.md)
-    - [PULC有车/无车分类模型](docs/zh_CN/PULC/PULC_car_exists.md)
-    - [PULC含文字图像方向分类模型](docs/zh_CN/PULC/PULC_text_image_orientation.md)
-    - [PULC文本行方向分类模型](docs/zh_CN/PULC/PULC_textline_orientation.md)
-    - [PULC语种分类模型](docs/zh_CN/PULC/PULC_language_classification.md)
-  - [模型训练](docs/zh_CN/PULC/PULC_train.md)
+    - [服务化部署](docs/zh_CN/deployment/PP-ShiTu/paddle_serving.md)
+    - [端侧部署](docs/zh_CN/deployment/PP-ShiTu/paddle_lite.md)
+    - [库管理工具](docs/zh_CN/deployment/PP-ShiTu/gallery_manager.md)
+- [PULC超轻量图像分类实用方案](docs/zh_CN/training/PULC.md)
+  - [超轻量图像分类快速体验](docs/zh_CN/quick_start/PULC.md)
+  - [超轻量图像分类模型库](docs/zh_CN/models/PULC/model_list.md)
+    - [PULC有人/无人分类模型](docs/zh_CN/models/PULC/PULC_person_exists.md)
+    - [PULC人体属性识别模型](docs/zh_CN/models/PULC/PULC_person_attribute.md)
+    - [PULC佩戴安全帽分类模型](docs/zh_CN/models/PULC/PULC_safety_helmet.md)
+    - [PULC交通标志分类模型](docs/zh_CN/models/PULC/PULC_traffic_sign.md)
+    - [PULC车辆属性识别模型](docs/zh_CN/models/PULC/PULC_vehicle_attribute.md)
+    - [PULC有车/无车分类模型](docs/zh_CN/models/PULC/PULC_car_exists.md)
+    - [PULC含文字图像方向分类模型](docs/zh_CN/models/PULC/PULC_text_image_orientation.md)
+    - [PULC文本行方向分类模型](docs/zh_CN/models/PULC/PULC_textline_orientation.md)
+    - [PULC语种分类模型](docs/zh_CN/models/PULC/PULC_language_classification.md)
+  - [模型训练](docs/zh_CN/training/PULC.md)
   - 推理部署
-    - [基于python预测引擎推理](docs/zh_CN/inference_deployment/python_deploy.md#1)
-    - [基于C++预测引擎推理](docs/zh_CN/inference_deployment/cpp_deploy.md)
-    - [服务化部署](docs/zh_CN/inference_deployment/classification_serving_deploy.md)
-    - [端侧部署](docs/zh_CN/inference_deployment/paddle_lite_deploy.md)
-    - [Paddle2ONNX模型转化与预测](deploy/paddle2onnx/readme.md)
+    - [基于python预测引擎推理](docs/zh_CN/deployment/image_classification/python.md#1)
+    - [基于C++预测引擎推理](docs/zh_CN/deployment/image_classification/cpp/linux.md)
+    - [服务化部署](docs/zh_CN/deployment/image_classification/paddle_serving.md)
+    - [端侧部署](docs/zh_CN/deployment/image_classification/paddle_lite.md)
+    - [Paddle2ONNX模型转化与预测](docs/zh_CN/deployment/image_classification/paddle2onnx.md)
   - [模型压缩](deploy/slim/README.md)
 - PP系列骨干网络模型
-  - [PP-HGNet](docs/zh_CN/models/PP-HGNet.md)
-  - [PP-LCNetv2](docs/zh_CN/models/PP-LCNetV2.md)
-  - [PP-LCNet](docs/zh_CN/models/PP-LCNet.md)
-- [SSLD半监督知识蒸馏方案](docs/zh_CN/advanced_tutorials/ssld.md)
+  - [PP-HGNet](docs/zh_CN/models/ImageNet1k/PP-HGNet.md)
+  - [PP-LCNetv2](docs/zh_CN/models/ImageNet1k/PP-LCNetV2.md)
+  - [PP-LCNet](docs/zh_CN/models/ImageNet1k/PP-LCNet.md)
+- [SSLD半监督知识蒸馏方案](docs/zh_CN/training/advanced/ssld.md)
 - 前沿算法
-  - [骨干网络和预训练模型库](docs/zh_CN/algorithm_introduction/ImageNet_models.md)
+  - [骨干网络和预训练模型库](docs/zh_CN/models/ImageNet1k/model_list.md)
   - [度量学习](docs/zh_CN/algorithm_introduction/metric_learning.md)
-    - [ReID](./docs/zh_CN/algorithm_introduction/reid.md)
-  - [模型压缩](docs/zh_CN/algorithm_introduction/model_prune_quantization.md)
+    - [ReID](./docs/zh_CN/algorithm_introduction/ReID.md)
+  - [模型压缩](docs/zh_CN/algorithm_introduction/prune_quantization.md)
   - [模型蒸馏](docs/zh_CN/algorithm_introduction/knowledge_distillation.md)
-  - [数据增强](docs/zh_CN/advanced_tutorials/DataAugmentation.md)
+  - [数据增强](docs/zh_CN/training/config_discription/data_augmentation.md)
 - [产业实用范例库](docs/zh_CN/samples)
 - [30分钟快速体验图像分类](docs/zh_CN/quick_start/quick_start_classification_new_user.md)
 - FAQ
-  - [图像识别精选问题](docs/zh_CN/faq_series/faq_2021_s2.md)
-  - [图像分类精选问题](docs/zh_CN/faq_series/faq_selected_30.md)
-  - [图像分类FAQ第一季](docs/zh_CN/faq_series/faq_2020_s1.md)
-  - [图像分类FAQ第二季](docs/zh_CN/faq_series/faq_2021_s1.md)
-  - [图像分类FAQ第三季](docs/zh_CN/faq_series/faq_2022_s1.md)
-- [社区贡献指南](./docs/zh_CN/advanced_tutorials/how_to_contribute.md)
+  - [图像识别精选问题](docs/zh_CN/FAQ/faq_2021_s2.md)
+  - [图像分类精选问题](docs/zh_CN/FAQ/faq_selected_30.md)
+  - [图像分类FAQ第一季](docs/zh_CN/FAQ/faq_2020_s1.md)
+  - [图像分类FAQ第二季](docs/zh_CN/FAQ/faq_2021_s1.md)
+  - [图像分类FAQ第三季](docs/zh_CN/FAQ/faq_2022_s1.md)
+- [社区贡献指南](docs/zh_CN/community/how_to_contribute.md)
 - [许可证书](#许可证书)
 - [贡献代码](#贡献代码)
 
@@ -147,7 +136,7 @@ PP-ShiTuV2 Android Demo APP，可扫描如下二维码，下载体验
 </div>
 
 
-PP-ShiTuV2是一个实用的轻量级通用图像识别系统，主要由主体检测、特征学习和向量检索三个模块组成。该系统从骨干网络选择和调整、损失函数的选择、数据增强、学习率变换策略、正则化参数选择、预训练模型使用以及模型裁剪量化多个方面，采用多种策略，对各个模块的模型进行优化，PP-ShiTuV2相比V1，Recall1提升近8个点。更多细节请参考[PP-ShiTuV2详细介绍](./docs/zh_CN/PPShiTu/PPShiTuV2_introduction.md)。
+PP-ShiTuV2是一个实用的轻量级通用图像识别系统，主要由主体检测、特征学习和向量检索三个模块组成。该系统从骨干网络选择和调整、损失函数的选择、数据增强、学习率变换策略、正则化参数选择、预训练模型使用以及模型裁剪量化多个方面，采用多种策略，对各个模块的模型进行优化，PP-ShiTuV2相比V1，Recall1提升近8个点。更多细节请参考[PP-ShiTuV2详细介绍](docs/zh_CN/models/PP-ShiTu/README.md)。
 
 <a name="识别效果展示"></a>
 
@@ -216,7 +205,7 @@ PaddleClas提供了覆盖人、车、OCR场景九大常见任务的分类模型
 <a name="贡献代码"></a>
 ## 贡献代码
 我们非常欢迎你为PaddleClas贡献代码，也十分感谢你的反馈。
-如果想为PaddleCLas贡献代码，可以参考[贡献指南](./docs/zh_CN/advanced_tutorials/how_to_contribute.md)。
+如果想为PaddleCLas贡献代码，可以参考[贡献指南](docs/zh_CN/community/how_to_contribute.md)。
 
 - 非常感谢[nblib](https://github.com/nblib)修正了PaddleClas中RandErasing的数据增广配置文件。
 - 非常感谢[chenpy228](https://github.com/chenpy228)修正了PaddleClas文档中的部分错别字。

README_en.md

@@ -68,18 +68,18 @@ Quick experience of **P**ractical **U**ltra **L**ight-weight image **C**lassific
 - [Install PaddleClas Environment](./docs/en/installation/install_paddleclas_en.md)
 - [PP-ShiTuV2 Image Recognition Systems Introduction](./docs/en/PPShiTu/PPShiTuV2_introduction.md)
   - [Image Recognition Quick Start](docs/en/quick_start/quick_start_recognition_en.md)
-  - [20+ application scenarios](docs/zh_CN/introduction/ppshitu_application_scenarios.md)
+  - [20+ application scenarios](docs/zh_CN/deployment/PP-ShiTu/application_scenarios.md)
   - Submodule Introduction and Model Training
-    - [Mainbody Detection](./docs/zh_CN/image_recognition_pipeline/mainbody_detection.md)
+    - [Mainbody Detection](docs/zh_CN/training/PP-ShiTu/mainbody_detection.md)
     - [Feature Extraction](./docs/en/image_recognition_pipeline/feature_extraction_en.md)
     - [Vector Search](./docs/en/image_recognition_pipeline/vector_search_en.md)
-    - [Hash Encoding](./docs/zh_CN/image_recognition_pipeline/deep_hashing.md)
+    - [Hash Encoding](docs/zh_CN/training/PP-ShiTu/deep_hashing.md)
   - PipeLine Inference and Deployment
     - [Python Inference](docs/en/inference_deployment/python_deploy_en.md)
     - [C++ Inference](deploy/cpp_shitu/readme_en.md)
     - [Serving Deployment](docs/en/inference_deployment/recognition_serving_deploy_en.md)
     - [Lite Deployment](docs/en/inference_deployment/paddle_lite_deploy_en.md)
-    - [Shitu Gallery Manager Tool](docs/zh_CN/inference_deployment/shitu_gallery_manager.md)
+    - [Shitu Gallery Manager Tool](docs/zh_CN/deployment/PP-ShiTu/gallery_manager.md)
 - [Practical Ultra Light-weight image Classification solutions](./docs/en/PULC/PULC_train_en.md)
   - [PULC Quick Start](docs/en/PULC/PULC_quickstart_en.md)
   - [PULC Model Zoo](docs/en/PULC/PULC_model_list_en.md)

deploy/configs/PULC/table_attribute/inference_table_attribute.yaml

+Global:
+  infer_imgs: "images/PULC/table_attribute/val_3610.jpg"
+  inference_model_dir: "./models/table_attribute_infer"
+  batch_size: 1
+  use_gpu: True
+  enable_mkldnn: True
+  cpu_num_threads: 10
+  benchmark: False
+  use_fp16: False
+  ir_optim: True
+  use_tensorrt: False
+  gpu_mem: 8000
+  enable_profile: False
+
+PreProcess:
+  transform_ops:
+    - ResizeImage:
+        size: [224, 224]
+    - NormalizeImage:
+        scale: 1.0/255.0
+        mean: [0.485, 0.456, 0.406]
+        std: [0.229, 0.224, 0.225]
+        order: ''
+        channel_num: 3
+    - ToCHWImage:
+
+PostProcess:
+  main_indicator: TableAttribute  
+  TableAttribute:
+    source_threshold: 0.5
+    number_threshold: 0.5
+    color_threshold: 0.5
+    clarity_threshold : 0.5
+    obstruction_threshold: 0.5
+    angle_threshold: 0.5

deploy/configs/inference_cls_multilabel.yaml

@@ -25,11 +25,12 @@ PreProcess:
         order: ''
         channel_num: 3
     - ToCHWImage:
-    
+
 PostProcess:
-  main_indicator: MultiLabelTopk
-  MultiLabelTopk:
-    topk: 5
-    class_id_map_file: None
+  main_indicator: MultiLabelThreshOutput
+  MultiLabelThreshOutput:
+    threshold: 0.5
+    class_id_map_file: "../ppcls/utils/NUS-WIDE-SCENE_label_list.txt"
+    delimiter: " "
   SavePreLabel:
-    save_dir: ./pre_label/
+    save_dir: ./pre_label/
\ No newline at end of file

deploy/cpp_shitu/README.md

+../../docs/zh_CN/deployment/PP-ShiTu/cpp.md
\ No newline at end of file

deploy/python/postprocess.py

@@ -82,10 +82,11 @@ class ThreshOutput(object):
 
 
 class Topk(object):
-    def __init__(self, topk=1, class_id_map_file=None):
+    def __init__(self, topk=1, class_id_map_file=None, delimiter=None):
         assert isinstance(topk, (int, ))
-        self.class_id_map = self.parse_class_id_map(class_id_map_file)
         self.topk = topk
+        self.class_id_map = self.parse_class_id_map(class_id_map_file)
+        self.delimiter = delimiter if delimiter is not None else " "
 
     def parse_class_id_map(self, class_id_map_file):
         if class_id_map_file is None:
@@ -102,21 +103,20 @@ class Topk(object):
             with open(class_id_map_file, "r") as fin:
                 lines = fin.readlines()
                 for line in lines:
-                    partition = line.split("\n")[0].partition(" ")
+                    partition = line.split("\n")[0].partition(self.delimiter)
                     class_id_map[int(partition[0])] = str(partition[-1])
         except Exception as ex:
             print(ex)
             class_id_map = None
         return class_id_map
 
-    def __call__(self, x, file_names=None, multilabel=False):
+    def __call__(self, x, file_names=None):
         if file_names is not None:
             assert x.shape[0] == len(file_names)
         y = []
         for idx, probs in enumerate(x):
             index = probs.argsort(axis=0)[-self.topk:][::-1].astype(
-                "int32") if not multilabel else np.where(
-                    probs >= 0.5)[0].astype("int32")
+                "int32")
             clas_id_list = []
             score_list = []
             label_name_list = []
@@ -138,12 +138,56 @@ class Topk(object):
         return y
 
 
-class MultiLabelTopk(Topk):
-    def __init__(self, topk=1, class_id_map_file=None):
-        super().__init__()
+class MultiLabelThreshOutput(object):
+    def __init__(self, threshold=0.5, class_id_map_file=None, delimiter=None):
+        self.threshold = threshold
+        self.delimiter = delimiter if delimiter is not None else " "
+        self.class_id_map = self.parse_class_id_map(class_id_map_file)
+
+    def parse_class_id_map(self, class_id_map_file):
+        if class_id_map_file is None:
+            return None
+
+        if not os.path.exists(class_id_map_file):
+            print(
+                "Warning: If want to use your own label_dict, please input legal path!\nOtherwise label_names will be empty!"
+            )
+            return None
+
+        try:
+            class_id_map = {}
+            with open(class_id_map_file, "r") as fin:
+                lines = fin.readlines()
+                for line in lines:
+                    partition = line.split("\n")[0].partition(self.delimiter)
+                    class_id_map[int(partition[0])] = str(partition[-1])
+        except Exception as ex:
+            print(ex)
+            class_id_map = None
+        return class_id_map
 
     def __call__(self, x, file_names=None):
-        return super().__call__(x, file_names, multilabel=True)
+        y = []
+        for idx, probs in enumerate(x):
+            index = np.where(probs >= self.threshold)[0].astype("int32")
+            clas_id_list = []
+            score_list = []
+            label_name_list = []
+            for i in index:
+                clas_id_list.append(i.item())
+                score_list.append(probs[i].item())
+                if self.class_id_map is not None:
+                    label_name_list.append(self.class_id_map[i.item()])
+            result = {
+                "class_ids": clas_id_list,
+                "scores": np.around(
+                    score_list, decimals=5).tolist(),
+                "label_names": label_name_list
+            }
+            if file_names is not None:
+                result["file_name"] = file_names[idx]
+            y.append(result)
+        return y
 
 
 class SavePreLabel(object):
@@ -320,3 +364,49 @@ class VehicleAttribute(object):
                         ).astype(np.int8).tolist()
             batch_res.append({"attributes": label_res, "output": pred_res})
         return batch_res
+
+
+class TableAttribute(object):
+    def __init__(
+            self,
+            source_threshold=0.5,
+            number_threshold=0.5,
+            color_threshold=0.5,
+            clarity_threshold=0.5,
+            obstruction_threshold=0.5,
+            angle_threshold=0.5, ):
+        self.source_threshold = source_threshold
+        self.number_threshold = number_threshold
+        self.color_threshold = color_threshold
+        self.clarity_threshold = clarity_threshold
+        self.obstruction_threshold = obstruction_threshold
+        self.angle_threshold = angle_threshold
+
+    def __call__(self, batch_preds, file_names=None):
+        # postprocess output of predictor
+        batch_res = []
+
+        for res in batch_preds:
+            res = res.tolist()
+            label_res = []
+            source = 'Scanned' if res[0] > self.source_threshold else 'Photo'
+            number = 'Little' if res[1] > self.number_threshold else 'Numerous'
+            color = 'Black-and-White' if res[
+                2] > self.color_threshold else 'Multicolor'
+            clarity = 'Clear' if res[3] > self.clarity_threshold else 'Blurry'
+            obstruction = 'Without-Obstacles' if res[
+                4] > self.number_threshold else 'With-Obstacles'
+            angle = 'Horizontal' if res[
+                5] > self.number_threshold else 'Tilted'
+
+            label_res = [source, number, color, clarity, obstruction, angle]
+
+            threshold_list = [
+                self.source_threshold, self.number_threshold,
+                self.color_threshold, self.clarity_threshold,
+                self.obstruction_threshold, self.angle_threshold
+            ]
+            pred_res = (np.array(res) > np.array(threshold_list)
+                        ).astype(np.int8).tolist()
+            batch_res.append({"attributes": label_res, "output": pred_res})
+        return batch_res

deploy/python/predict_cls.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 import os
 
 import cv2
@@ -136,7 +135,8 @@ def main(config):
             for number, result_dict in enumerate(batch_results):
                 if "PersonAttribute" in config[
                         "PostProcess"] or "VehicleAttribute" in config[
-                            "PostProcess"]:
+                            "PostProcess"] or "TableAttribute" in config[
+                                "PostProcess"]:
                     filename = batch_names[number]
                     print("{}:\t {}".format(filename, result_dict))
                 else:

deploy/slim/auto_compression/README.md

+# 图像分类模型自动压缩示例
+
+目录：
+- [1. 简介](#1-简介)
+- [2. Benchmark](#2-benchmark)
+- [3. 自动压缩流程](#3-自动压缩流程)
+  - [3.1 准备环境](#31-准备准备)
+  - [3.2 准备数据集](#32-准备数据集)
+  - [3.3 准备预测模型](#33-准备预测模型)
+  - [3.4 自动压缩并产出模型](#34-自动压缩并产出模型)
+- [4. 配置文件介绍](#4-配置文件介绍)
+- [5. 预测部署](#5-预测部署)
+  - [5.1 Python预测推理](#51-python预测推理)
+  - [5.2 PaddleLite端侧部署](#52-paddlelite端侧部署)
+- [6. FAQ](#6-faq)
+
+
+## 1. 简介
+本示例将以图像分类模型MobileNetV3为例，介绍如何使用PaddleClas中Inference部署模型进行自动压缩。本示例使用的自动压缩策略为量化训练和蒸馏。
+
+## 2. Benchmark
+
+### PaddleClas模型
+
+| 模型 | 策略 | Top-1 Acc | GPU 耗时(ms) | ARM CPU 耗时(ms) | 配置文件 | Inference模型 |
+|:------:|:------:|:------:|:------:|:------:|:------:|:------:|
+| MobileNetV3_large_x1_0 | Baseline | 75.32 | - | 16.62 | - | [Model](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/MobileNetV3_large_x1_0_infer.tar) |
+| MobileNetV3_large_x1_0 | 量化+蒸馏 | 74.40 | - | 9.85 | [Config](./mbv3_qat_dis.yaml) | [Model](https://paddle-slim-models.bj.bcebos.com/act/MobileNetV3_large_x1_0_QAT.tar) |
+
+
+- ARM CPU 测试环境：`SDM865(4xA77+4xA55)`
+
+
+## 3. 自动压缩流程
+
+#### 3.1 准备环境
+
+- python >= 3.6
+- PaddlePaddle >= 2.3 （可从[PaddlePaddle官网](https://www.paddlepaddle.org.cn/install/quick?docurl=/documentation/docs/zh/install/pip/linux-pip.html)下载安装）
+- PaddleSlim >= 2.3
+
+安装paddlepaddle：
+```shell
+# CPU
+pip install paddlepaddle
+# GPU
+pip install paddlepaddle-gpu
+```
+
+安装paddleslim：
+```shell
+pip install paddleslim
+```
+
+#### 3.2 准备数据集
+本案例默认以ImageNet1k数据进行自动压缩实验，如数据集为非ImageNet1k格式数据， 请参考[PaddleClas数据准备文档](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.3/docs/zh_CN/data_preparation/classification_dataset.md)。将下载好的数据集放在当前目录下`./ILSVRC2012`。
+
+
+#### 3.3 准备预测模型
+预测模型的格式为：`model.pdmodel` 和 `model.pdiparams`，带`pdmodel`后缀的是模型文件，带`pdiparams`后缀的是权重文件。
+
+注：其他像`__model__`和`__params__`分别对应`model.pdmodel` 和 `model.pdiparams`文件。
+
+可在[PaddleClas预训练模型库](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.3/docs/zh_CN/algorithm_introduction/ImageNet_models.md)中直接获取Inference模型，具体可参考下方获取MobileNetV3模型示例：
+
+```shell
+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
+```
+也可根据[PaddleClas文档](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.3/docs/zh_CN/inference_deployment/export_model.md)导出Inference模型。
+
+#### 3.4 自动压缩并产出模型
+
+蒸馏量化自动压缩示例通过run.py脚本启动，会使用接口 ```paddleslim.auto_compression.AutoCompression``` 对模型进行量化训练和蒸馏。配置config文件中模型路径、数据集路径、蒸馏、量化和训练等部分的参数，配置完成后便可开始自动压缩。
+
+**单卡启动**
+
+```shell
+export CUDA_VISIBLE_DEVICES=0
+python run.py --save_dir='./save_quant_mobilev3/' --config_path='./configs/mbv3_qat_dis.yaml'
+```
+
+**多卡启动**
+
+图像分类训练任务中往往包含大量训练数据，以ImageNet-1k为例，如果使用单卡训练，会非常耗时，使用分布式训练可以达到几乎线性的加速比。
+
+```shell
+export CUDA_VISIBLE_DEVICES=0,1,2,3
+python -m paddle.distributed.launch run.py --save_dir='./save_quant_mobilev3/' --config_path='./configs/mbv3_qat_dis.yaml'
+```
+多卡训练指的是将训练任务按照一定方法拆分到多个训练节点完成数据读取、前向计算、反向梯度计算等过程，并将计算出的梯度上传至服务节点。服务节点在收到所有训练节点传来的梯度后，会将梯度聚合并更新参数。最后将参数发送给训练节点，开始新一轮的训练。多卡训练一轮训练能训练```batch size * num gpus```的数据，比如单卡的```batch size```为128，单轮训练的数据量即128，而四卡训练的```batch size```为128，单轮训练的数据量为512。
+
+注意 ```learning rate``` 与 ```batch size``` 呈线性关系，这里单卡 ```batch size``` 为128，对应的 ```learning rate``` 为0.001，那么如果 ```batch size``` 减小4倍改为32，```learning rate``` 也需除以4；多卡时 ```batch size``` 为128，```learning rate``` 需乘上卡数。所以改变 ```batch size``` 或改变训练卡数都需要对应修改 ```learning rate```。
+
+加载训练好的模型进行量化训练时，一般`learning rate`可比原始训练的`learning rate`小10倍。
+
+
+## 4. 配置文件介绍
+自动压缩相关配置主要有：
+- 压缩策略配置，如量化（Quantization），知识蒸馏（Distillation），结构化稀疏（ChannelPrune），ASP半结构化稀疏（ASPPrune ），非结构化稀疏（UnstructurePrune）。
+- 训练超参配置（TrainConfig）：主要设置学习率、训练次数（epochs）和优化器等。
+- 全局配置（Global）：需提供inference模型文件路径，输入名称等信息。
+
+详细介绍可参考[ACT超参详细教程](https://github.com/PaddlePaddle/PaddleSlim/blob/develop/example/auto_compression/hyperparameter_tutorial.md)
+
+注意```DataLoader```的使用与```PaddleClas```中的相同，保持与```PaddleClas```中相同配置即可。不同模型```DataLoader```的配置可参考[PaddleClas配置文件](https://github.com/PaddlePaddle/PaddleClas/tree/develop/ppcls/configs/ImageNet)。
+
+
+
+
+## 5. 预测部署
+#### 5.1 Python预测推理
+Python预测推理可参考：
+- [Python部署](https://github.com/PaddlePaddle/PaddleClas/blob/develop/docs/zh_CN/inference_deployment/python_deploy.md)
+
+
+
+#### 5.2 PaddleLite端侧部署
+PaddleLite端侧部署可参考：
+- [Paddle Lite部署](https://github.com/PaddlePaddle/PaddleClas/blob/develop/docs/zh_CN/inference_deployment/paddle_lite_deploy.md)
+
+## 6. FAQ

deploy/slim/auto_compression/mbv3_qat_dis.yaml

+# global configs
+Global:
+  output_dir: ./output/
+  device: gpu
+  model_dir: ./MobileNetV3_large_x1_0_infer
+  model_filename: inference.pdmodel
+  params_filename: inference.pdiparams
+  input_name: inputs
+  
+Distillation:
+  alpha: 1.0
+  loss: soft_label
+
+Quantization:
+  use_pact: true
+  activation_bits: 8
+  is_full_quantize: false
+  onnx_format: true
+  activation_quantize_type: moving_average_abs_max
+  weight_quantize_type: channel_wise_abs_max
+  not_quant_pattern:
+  - skip_quant
+  quantize_op_types:
+  - conv2d
+  - depthwise_conv2d
+  weight_bits: 8
+
+TrainConfig:
+  epochs: 2
+  eval_iter: 5000
+  learning_rate: 0.001
+  optimizer_builder:
+    optimizer:
+      type: Momentum
+    weight_decay: 0.00005
+  origin_metric: 0.7532
+  
+
+DataLoader:
+  Train:
+    dataset:
+      name: ImageNetDataset
+      image_root: ./dataset/ILSVRC2012/
+      cls_label_path: ./dataset/ILSVRC2012/train_list.txt
+      transform_ops:
+        - DecodeImage:
+            to_rgb: True
+            channel_first: False
+        - RandCropImage:
+            size: 224
+        - RandFlipImage:
+            flip_code: 1
+        - AutoAugment:
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+
+    sampler:
+      name: DistributedBatchSampler
+      batch_size: 128
+      drop_last: False
+      shuffle: True
+    loader:
+      num_workers: 8
+      use_shared_memory: True
+
+  Eval:
+    dataset: 
+      name: ImageNetDataset
+      image_root: ./dataset/ILSVRC2012/
+      cls_label_path: ./dataset/ILSVRC2012/val_list.txt
+      transform_ops:
+        - DecodeImage:
+            to_rgb: True
+            channel_first: False
+        - ResizeImage:
+            resize_short: 256
+        - CropImage:
+            size: 224
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+    sampler:
+      name: DistributedBatchSampler
+      batch_size: 32
+      drop_last: False
+      shuffle: False
+    loader:
+      num_workers: 4
+      use_shared_memory: True

deploy/slim/auto_compression/run.py

+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import, division, print_function
+
+import os
+import sys
+import argparse
+import functools
+from functools import partial
+import math
+from tqdm import tqdm
+
+import numpy as np
+import paddle
+import paddleslim
+from paddle.jit import to_static
+from paddleslim.analysis import dygraph_flops as flops
+
+__dir__ = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.abspath(os.path.join(__dir__, '../../')))
+from paddleslim.auto_compression import AutoCompression
+
+from ppcls.data import build_dataloader
+from ppcls.utils import config as conf
+from ppcls.utils.logger import init_logger
+
+
+def reader_wrapper(reader, input_name):
+    def gen():
+        for i, (imgs, label) in enumerate(reader()):
+            yield {input_name: imgs}
+
+    return gen
+
+
+def eval_function(exe, compiled_test_program, test_feed_names,
+                  test_fetch_list):
+    results = []
+    with tqdm(
+            total=len(val_loader),
+            bar_format='Evaluation stage, Run batch:|{bar}| {n_fmt}/{total_fmt}',
+            ncols=80) as t:
+        for batch_id, (image, label) in enumerate(val_loader):
+
+            # top1_acc, top5_acc
+            if len(test_feed_names) == 1:
+                image = np.array(image)
+                label = np.array(label).astype('int64')
+                pred = exe.run(compiled_test_program,
+                               feed={test_feed_names[0]: image},
+                               fetch_list=test_fetch_list)
+                pred = np.array(pred[0])
+                label = np.array(label).reshape((-1, 1))
+                sort_array = pred.argsort(axis=1)
+                top_1_pred = sort_array[:, -1:][:, ::-1]
+                top_1 = np.mean(label == top_1_pred)
+                top_5_pred = sort_array[:, -5:][:, ::-1]
+                acc_num = 0
+                for i in range(len(label)):
+                    if label[i][0] in top_5_pred[i]:
+                        acc_num += 1
+                top_5 = float(acc_num) / len(label)
+                results.append([top_1, top_5])
+            else:
+                # eval "eval model", which inputs are image and label, output is top1 and top5 accuracy
+                image = np.array(image)
+                label = np.array(label).astype('int64')
+                result = exe.run(compiled_test_program,
+                                 feed={
+                                     test_feed_names[0]: image,
+                                     test_feed_names[1]: label
+                                 },
+                                 fetch_list=test_fetch_list)
+                result = [np.mean(r) for r in result]
+                results.append(result)
+            t.update()
+    result = np.mean(np.array(results), axis=0)
+    return result[0]
+
+
+def main():
+    args = conf.parse_args()
+    global config
+    config = conf.get_config(args.config, overrides=args.override, show=False)
+
+    assert os.path.exists(
+        os.path.join(config["Global"]["model_dir"], 'inference.pdmodel')
+    ) and os.path.exists(
+        os.path.join(config["Global"]["model_dir"], 'inference.pdiparams'))
+    if "Query" in config["DataLoader"]["Eval"]:
+        config["DataLoader"]["Eval"] = config["DataLoader"]["Eval"]["Query"]
+
+    init_logger()
+    train_dataloader = build_dataloader(config["DataLoader"], "Train",
+                                        config["Global"]['device'], False)
+    if isinstance(config['TrainConfig']['learning_rate'], dict) and config[
+            'TrainConfig']['learning_rate']['type'] == 'CosineAnnealingDecay':
+
+        gpu_num = paddle.distributed.get_world_size()
+        step = len(train_dataloader)
+        config['TrainConfig']['learning_rate']['T_max'] = step
+        print('total training steps:', step)
+
+    global val_loader
+    val_loader = build_dataloader(config["DataLoader"], "Eval",
+                                  config["Global"]['device'], False)
+
+    if config["Global"]['device'] == 'gpu':
+        rank_id = paddle.distributed.get_rank()
+        place = paddle.CUDAPlace(rank_id)
+        paddle.set_device('gpu')
+    else:
+        place = paddle.CPUPlace()
+        paddle.set_device('cpu')
+
+    ac = AutoCompression(
+        model_dir=config["Global"]["model_dir"],
+        model_filename=config["Global"]["model_filename"],
+        params_filename=config["Global"]["params_filename"],
+        save_dir=config["Global"]['output_dir'],
+        config=config,
+        train_dataloader=reader_wrapper(
+            train_dataloader, input_name=config['Global']['input_name']),
+        eval_callback=eval_function if rank_id == 0 else None,
+        eval_dataloader=reader_wrapper(
+            val_loader, input_name=config['Global']['input_name']))
+
+    ac.compress()
+
+
+if __name__ == '__main__':
+    paddle.enable_static()
+    main()

docs/en/PULC/PULC_person_attribute_en.md

@@ -131,6 +131,27 @@ print(next(result))
 [{'attributes': ['Male', 'Age18-60', 'Back', 'Glasses: False', 'Hat: False', 'HoldObjectsInFront: False', 'Backpack', 'Upper: LongSleeve UpperPlaid', 'Lower:  Trousers', 'No boots'], 'output': [0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1], 'filename': 'pulc_demo_imgs/person_attribute/090004.jpg'}]
 ```
 
+**Note**: The `output` value index 0 means whether to wear a hat, index value 1 means whether to wear glasses, index value 2-7 means top style, index value means bottom style, index value 14 means whether to wear boots, index value 15-17 means the type of bag on the back, index value 18 means whether the front is holding something, index value 19-21 means age, index value 22 means gender, and index value 23-25 means direction. For details, see [code](../../../ppcls/data/postprocess/attr_rec.py#L84). Specifically, person attribute include the following types:
+
+```
+- Gender: Male Female
+- Age: AgeLess18, Age18-60, AgeOver60
+- Direction: Front, Side, Back
+- Accessories: glasses, hat, none
+- Front holding: yes, no
+- Bags: Backpack, Shoulder, Handbag
+- Upper styles: UpperStride, UpperLogo, UpperPlaid, UpperSplice
+- Lower style: LowerStripe, LowerPattern
+- Short sleeved: yes, no
+- Long sleeved: yes, no
+- Long coat: yes, no
+- Trousers: yes, no
+- Shorts: yes, no
+- Skirts & Skirts: Yes, No
+- Wear boots: yes, no
+```
+
+
 <a name="3"></a>
 
 ## 3. Training, Evaluation and Inference

docs/en/PULC/PULC_vehicle_attribute_en.md

@@ -132,6 +132,8 @@ print(next(result))
 [{'attributes': 'Color: (yellow, prob: 0.9893476963043213), Type: (hatchback, prob: 0.9734097719192505)', 'output': [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 'filename': 'pulc_demo_imgs/vehicle_attribute/0002_c002_00030670_0.jpg'}]
 ```
 
+**Note**: The value index of `output` is 0-9 to indicate the color attribute, and the corresponding colors are: yellow, orange, green, gray, red, blue, white,  golden, brown, black; the index is 10-18 to represent the model attributes, the corresponding models are sedan, suv, van, hatchback, mpv, pickup, bus, truck, estate.
+
 <a name="3"></a>
 
 ## 3. Training, Evaluation and Inference

docs/en/image_recognition_pipeline/feature_extraction_en.md

@@ -176,14 +176,14 @@ Model training mainly includes the starting training and restoring training from
 **Notice:**
 The online evaluation method is used by default in the configuration file. If you want to speed up the training, you can turn off the online evaluation function, just add `-o Global.eval_during_train=False` after the above scripts.
 
-After training, the final model files `latest.pdparams`, `best_model.pdarams` and the training log file `train.log` will be generated in the output directory. Among them, `best_model` saves the best model under the current evaluation index, and `latest` is used to save the latest generated model, which is convenient to resume training from the checkpoint when training task is interrupted. Training can be resumed from a checkpoint by adding `-o Global.checkpoint="path_to_resume_checkpoint"` to the end of the above training scripts, as shown below.
+After training, the final model files `latest.pdparams`, `best_model.pdarams` and the training log file `train.log` will be generated in the output directory. Among them, `best_model` saves the best model under the current evaluation index, and `latest` is used to save the latest generated model, which is convenient to resume training from the checkpoint when training task is interrupted. Training can be resumed from a checkpoint by adding `-o Global.checkpoints="path_to_resume_checkpoint"` to the end of the above training scripts, as shown below.
 
 - Single machine and single card checkpoint recovery training
   ```shell
   export CUDA_VISIBLE_DEVICES=0
   python3.7 tools/train.py \
   -c ./ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml \
-  -o Global.checkpoint="output/RecModel/latest"
+  -o Global.checkpoints="output/RecModel/latest"
   ```
 - Single-machine multi-card checkpoint recovery training
   ```shell
@@ -191,7 +191,7 @@ After training, the final model files `latest.pdparams`, `best_model.pdarams` an
   python3.7 -m paddle.distributed.launch --gpus="0,1,2,3" \
   tools/train.py \
   -c ./ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml \
-  -o Global.checkpoint="output/RecModel/latest"
+  -o Global.checkpoints="output/RecModel/latest"
   ```
 
 <a name="5.3"></a>

docs/en/quick_start/quick_start_multilabel_classification_en.md

@@ -51,6 +51,9 @@ python3 -m paddle.distributed.launch \
 
 After training 10 epochs, the best correctness of the validation set should be around 0.95.
 
+**Note:**
+1. Currently, the loss function for multi-label classification only supports `MultiLabelLoss` (BCE Loss).
+2. Currently, the evaluation metrics of multi-label classification support `Accuracy_Score` and `HammingDistance`. Please look forward to the support of other evaluation metrics.
 
 <a name="3"></a>
 ## 3. Model Evaluation
@@ -74,7 +77,7 @@ python3 tools/infer.py \
 Obtain an output silimar to the following:
 
 ```
-[{'class_ids': [6, 13, 17, 23, 26, 30], 'scores': [0.95683, 0.5567, 0.55211, 0.99088, 0.5943, 0.78767], 'file_name': './deploy/images/0517_2715693311.jpg', 'label_names': []}]
+[{'class_ids': [6, 13, 17, 23, 30], 'scores': [0.98217, 0.78129, 0.64377, 0.9942, 0.96109], 'label_names': ['clouds', 'lake', 'ocean', 'sky', 'water'], 'file_name': 'deploy/images/0517_2715693311.jpg'}]
 ```
 
 
@@ -107,11 +110,14 @@ Inference and prediction through predictive engines:
 
 ```
 python3 python/predict_cls.py \
-     -c configs/inference_multilabel_cls.yaml
+     -c configs/inference_cls_multilabel.yaml
 ```
+The predicted pictures are as follows:
 
-Obtain an output silimar to the following:
+![](../../images/quick_start/multi_label_demo.png)
+
+After executing the inference command, obtain an output silimar to the following:
 
 ```
-0517_2715693311.jpg:    class id(s): [6, 13, 17, 23, 26, 30], score(s): [0.96, 0.56, 0.55, 0.99, 0.59, 0.79], label_name(s): []
+0517_2715693311.jpg:    class id(s): [6, 13, 17, 23, 30], score(s): [0.98, 0.78, 0.64, 0.99, 0.96], label_name(s): ['clouds', 'lake', 'ocean', 'sky', 'water']
 ```

docs/zh_CN/faq_series/faq_2020_s1.md → docs/zh_CN/FAQ/faq_2020_s1.md

@@ -33,7 +33,7 @@ ResNet_va 至 vd 的结构如下图所示，ResNet 最早提出时为 va 结构
 **A**:
 
 ResNet 系列模型中，相比于其他模型，ResNet_vd 模型在预测速度几乎不变的情况下，精度有非常明显的提升，因此推荐大家使用 ResNet_vd 系列模型。
-[ResNet 及其 vd 系列模型文档](../models/ResNet_and_vd.md)中给出了 batch size=4 的情况下，在 T4 GPU 上，不同模型的的预测耗时、FLOPs、Params 与精度的变化曲线，可以根据自己自己的实际部署场景中的需求，去选择合适的模型，如果希望模型存储大小尽可能小或者预测速度尽可能快，则可以使用 ResNet18_vd 模型，如果希望获得尽可能高的精度，则建议使用 ResNet152_vd 或者 ResNet200_vd 模型。更多关于 ResNet 系列模型的介绍可以参考文档：[ResNet 及其 vd 系列模型文档](../models/ResNet_and_vd.md)。
+[ResNet 及其 vd 系列模型文档](../models/ImageNet1k/ResNet_and_vd.md)中给出了 batch size=4 的情况下，在 T4 GPU 上，不同模型的的预测耗时、FLOPs、Params 与精度的变化曲线，可以根据自己自己的实际部署场景中的需求，去选择合适的模型，如果希望模型存储大小尽可能小或者预测速度尽可能快，则可以使用 ResNet18_vd 模型，如果希望获得尽可能高的精度，则建议使用 ResNet152_vd 或者 ResNet200_vd 模型。更多关于 ResNet 系列模型的介绍可以参考文档：[ResNet 及其 vd 系列模型文档](../models/ImageNet1k/ResNet_and_vd.md)。
 
 * 精度-预测速度变化曲线
 
@@ -55,7 +55,7 @@ ResNet 系列模型中，相比于其他模型，ResNet_vd 模型在预测速度
 ### Q1.7 大卷积核一定可以带来正向收益吗？
 
 **A**: 不一定，将网络中的所有卷积核都增大未必会带来性能的提升，甚至会有有损性能，在论文 [MixConv: Mixed Depthwise Convolutional Kernels](https://arxiv.org/abs/1907.09595)
-中指出，在一定范围内提升卷积核大小对精度的提升有正向作用，但是超出后会有损精度。所以考虑到模型的大小、计算量等问题，一般不选用大的卷积核去设计网络。同时，在 [PP-LCNet](../models/PP-LCNet.md) 文章中，也有关于大卷积核的实验。
+中指出，在一定范围内提升卷积核大小对精度的提升有正向作用，但是超出后会有损精度。所以考虑到模型的大小、计算量等问题，一般不选用大的卷积核去设计网络。同时，在 [PP-LCNet](../models/ImageNet1k/PP-LCNet.md) 文章中，也有关于大卷积核的实验。
 
 <a name="2"></a>
 ## 第 2 期
@@ -88,7 +88,7 @@ ResNet 系列模型中，相比于其他模型，ResNet_vd 模型在预测速度
 
 ### Q2.5 PaddleClas 中提供了很多 ssld 模型，其应用的价值是？
 
-**A**: PaddleClas 中提供了很多 ssld 预训练模型，其通过半监督知识蒸馏的方法获得了更好的预训练权重，在迁移任务或者下游视觉任务中，无须替换结构文件、只需要替换精度更高的 ssld 预训练模型即可提升精度，如在 PaddleSeg 中，[HRNet](https://github.com/PaddlePaddle/PaddleSeg/blob/release/v0.7.0/docs/model_zoo.md) 使用了 ssld 预训练模型的权重后，精度大幅度超越业界同样的模型的精度，在 PaddleDetection 中，[PP-YOLO](https://github.com/PaddlePaddle/PaddleDetection/blob/release/0.4/configs/ppyolo/README_cn.md) 使用了 ssld 预训练权重后，在较高的 baseline 上仍有进一步的提升。使用 ssld 预训练权重做分类的迁移表现也很抢眼，在 [SSLD 蒸馏策略](../advanced_tutorials/knowledge_distillation.md) 部分介绍了知识蒸馏对于分类任务迁移的收益。
+**A**: PaddleClas 中提供了很多 ssld 预训练模型，其通过半监督知识蒸馏的方法获得了更好的预训练权重，在迁移任务或者下游视觉任务中，无须替换结构文件、只需要替换精度更高的 ssld 预训练模型即可提升精度，如在 PaddleSeg 中，[HRNet](https://github.com/PaddlePaddle/PaddleSeg/blob/release/v0.7.0/docs/model_zoo.md) 使用了 ssld 预训练模型的权重后，精度大幅度超越业界同样的模型的精度，在 PaddleDetection 中，[PP-YOLO](https://github.com/PaddlePaddle/PaddleDetection/blob/release/0.4/configs/ppyolo/README_cn.md) 使用了 ssld 预训练权重后，在较高的 baseline 上仍有进一步的提升。使用 ssld 预训练权重做分类的迁移表现也很抢眼，在 [SSLD 蒸馏策略](../training/advanced/knowledge_distillation.md) 部分介绍了知识蒸馏对于分类任务迁移的收益。
 
 
 <a name="3"></a>
@@ -96,13 +96,13 @@ ResNet 系列模型中，相比于其他模型，ResNet_vd 模型在预测速度
 
 ### Q3.1: DenseNet 模型相比于 ResNet 有什么改进呢？有哪些特点或者应用场景呢？
 
-**A**: DenseNet 相比于 ResNet，设计了一个更激进的密集连接机制，通过考虑特征重用和旁路的设置，进一步减少了参数量，而且从一定程度上缓解了梯度弥散的问题，因为引入了更加密集的连接，因此模型更容易训练，而且具有一定的正则化效果。在数据量不是很多的图像分类场景中，DenseNet 是一个不错的选择。更多关于 DenseNet 的介绍与系列模型可以参考 [DenseNet 模型文档](../models/DPN_DenseNet.md)。
+**A**: DenseNet 相比于 ResNet，设计了一个更激进的密集连接机制，通过考虑特征重用和旁路的设置，进一步减少了参数量，而且从一定程度上缓解了梯度弥散的问题，因为引入了更加密集的连接，因此模型更容易训练，而且具有一定的正则化效果。在数据量不是很多的图像分类场景中，DenseNet 是一个不错的选择。更多关于 DenseNet 的介绍与系列模型可以参考 [DenseNet 模型文档](../models/ImageNet1k/DPN_DenseNet.md)。
 
 
 
 ### Q3.2: DPN 网络相比于 DenseNet 有哪些改进呢？
 
-**A**：DPN 的全称是 Dual Path Networks，即双通道网络。该网络是由 DenseNet 和 ResNeXt 结合的一个网络，其证明了 DenseNet 能从靠前的层级中提取到新的特征，而 ResNeXt 本质上是对之前层级中已提取特征的复用。作者进一步分析发现，ResNeXt 对特征有高复用率，但冗余度低，DenseNet 能创造新特征，但冗余度高。结合二者结构的优势，作者设计了 DPN 网络。最终 DPN 网络在同样 FLOPS 和参数量下，取得了比 ResNeXt 与 DenseNet 更好的结果。更多关于 DPN 的介绍与系列模型可以参考 [DPN 模型文档](../models/DPN_DenseNet.md)。
+**A**：DPN 的全称是 Dual Path Networks，即双通道网络。该网络是由 DenseNet 和 ResNeXt 结合的一个网络，其证明了 DenseNet 能从靠前的层级中提取到新的特征，而 ResNeXt 本质上是对之前层级中已提取特征的复用。作者进一步分析发现，ResNeXt 对特征有高复用率，但冗余度低，DenseNet 能创造新特征，但冗余度高。结合二者结构的优势，作者设计了 DPN 网络。最终 DPN 网络在同样 FLOPS 和参数量下，取得了比 ResNeXt 与 DenseNet 更好的结果。更多关于 DPN 的介绍与系列模型可以参考 [DPN 模型文档](../models/ImageNet1k/DPN_DenseNet.md)。
 
 
 ### Q3.3: 怎么使用多个模型进行预测融合呢？
@@ -276,7 +276,7 @@ Cosine_decay 和 piecewise_decay 的学习率变化曲线如下图所示，容
 
 **A**:一般来说，数据集的规模对性能影响至关重要，但是图片的标注往往比较昂贵，所以有标注的图片数量往往比较稀少，在这种情况下，数据的增广尤为重要。在训练 ImageNet-1k 的标准数据增广中，主要使用了 Random_Crop 与 Random_Flip 两种数据增广方式，然而，近些年，越来越多的数据增广方式被提出，如 cutout、mixup、cutmix、AutoAugment 等。实验表明，这些数据的增广方式可以有效提升模型的精度。具体到数据集来说：
 
-- ImageNet-1k：下表列出了 ResNet50 在 8 种不同的数据增广方式的表现，可以看出，相比 baseline，所有的数据增广方式均有收益，其中 cutmix 是目前最有效的数据增广。更多数据增广的介绍请参考[**数据增广章节**](../advanced_tutorials/DataAugmentation.md)。
+- ImageNet-1k：下表列出了 ResNet50 在 8 种不同的数据增广方式的表现，可以看出，相比 baseline，所有的数据增广方式均有收益，其中 cutmix 是目前最有效的数据增广。更多数据增广的介绍请参考[**数据增广章节**](../training/config_discription/data_augmentation.md)。
 
 | 模型       | 数据增广方式         | Test top-1 |
 |:--:|:--:|:--:|
@@ -314,7 +314,7 @@ Cosine_decay 和 piecewise_decay 的学习率变化曲线如下图所示，容
 
 - 挖掘相关数据：用在现有数据集上训练饱和的模型去对相关的数据做预测，将置信度较高的数据打 label 后加入训练集进一步训练，如此循环操作，可进一步提升模型的精度。
 
-- 知识蒸馏：可以先使用一个较大的模型在该数据集上训练一个精度较高的 teacher model，然后使用该 teacher model 去教导一个 Student model，其中，Student model 即为目标模型。PaddleClas 提供了百度自研的 SSLD 知识蒸馏方案，即使在 ImageNet-1k 这么有挑战的分类任务上，其也能稳定提升 3% 以上。SSLD 知识蒸馏的的章节请参考 [**SSLD 知识蒸馏**](../advanced_tutorials/knowledge_distillation.md)。
+- 知识蒸馏：可以先使用一个较大的模型在该数据集上训练一个精度较高的 teacher model，然后使用该 teacher model 去教导一个 Student model，其中，Student model 即为目标模型。PaddleClas 提供了百度自研的 SSLD 知识蒸馏方案，即使在 ImageNet-1k 这么有挑战的分类任务上，其也能稳定提升 3% 以上。SSLD 知识蒸馏的的章节请参考 [**SSLD 知识蒸馏**](../training/advanced/knowledge_distillation.md)。
 
 
 <a name="6"></a>

docs/zh_CN/faq_series/faq_2021_s1.md → docs/zh_CN/FAQ/faq_2021_s1.md

@@ -71,7 +71,7 @@
 
 ### Q2.4: 移动端或嵌入式端上哪些网络具有优势？
 
-建议使用移动端系列的网络，网络详情可以参考[移动端系列网络结构介绍](../models/Mobile.md)。如果任务的速度更重要，可以考虑 MobileNetV3 系列，如果模型大小更重要，可以根据移动端系列网络结构介绍中的 StorageSize-Accuracy 来确定具体的结构。
+建议使用移动端系列的网络，网络详情可以参考[移动端系列网络结构介绍](../models/ImageNet1k/Mobile.md)。如果任务的速度更重要，可以考虑 MobileNetV3 系列，如果模型大小更重要，可以根据移动端系列网络结构介绍中的 StorageSize-Accuracy 来确定具体的结构。
 
 ### Q2.5: 既然移动端网络非常快，为什么还要使用诸如 ResNet 这样参数量和计算量较大的网络？
 

docs/zh_CN/faq_series/faq_2021_s2.md → docs/zh_CN/FAQ/faq_2021_s2.md

@@ -72,7 +72,7 @@ w_t+1 = w_t - v_t+1
 **A**：主体检测这块的输出数量是可以通过配置文件配置的。在配置文件中 Global.threshold 控制检测的阈值，小于该阈值的检测框被舍弃，Global.max_det_results 控制最大返回的结果数，这两个参数共同决定了输出检测框的数量。
 
 #### Q1.4.2 训练主体检测模型的数据是如何选择的？换成更小的模型会有损精度吗？
-**A**：训练数据是在 COCO、Object365、RPC、LogoDet 等公开数据集中随机抽取的子集。目前我们在 2.3 版本中推出了超轻量的主体检测模型，具体信息可以参考[主体检测](../image_recognition_pipeline/mainbody_detection.md#2-模型选择)。关于主体检测模型的更多信息请参考[主体检测](../image_recognition_pipeline/mainbody_detection.md)。
+**A**：训练数据是在 COCO、Object365、RPC、LogoDet 等公开数据集中随机抽取的子集。目前我们在 2.3 版本中推出了超轻量的主体检测模型，具体信息可以参考[主体检测](../training/PP-ShiTu/mainbody_detection.md#2-模型选择)。关于主体检测模型的更多信息请参考[主体检测](../training/PP-ShiTu/mainbody_detection.md)。
 
 #### Q1.4.3: 目前使用的主体检测模型检测在某些场景中会有误检？
 **A**：目前的主体检测模型训练时使用了 COCO、Object365、RPC、LogoDet 等公开数据集，如果被检测数据是类似工业质检等于常见类别差异较大的数据，需要基于目前的检测模型重新微调训练。
@@ -182,7 +182,7 @@ PaddlePaddle is installed successfully! Let's start deep learning with PaddlePad
 **A**：如果使用的是 release/2.2 分支，建议更新为 release/2.3 分支，在 release/2.3 分支中，我们使用 faiss 检索模块替换了 Möbius 检索模型，具体可以参考[向量检索教程](../../../deploy/vector_search/README.md)。如仍存在问题，可以在用户微信群中联系我们，也可以在 GitHub 提 issue。
 
 #### Q2.4.2: 识别模型怎么在预训练模型的基础上进行微调训练？
-**A**：识别模型的微调训练和分类模型的微调训练类似，识别模型可以加载商品的预训练模型，训练过程可以参考[识别模型训练](../../zh_CN/models_training/recognition.md)，后续我们也会持续细化这块的文档。
+**A**：识别模型的微调训练和分类模型的微调训练类似，识别模型可以加载商品的预训练模型，训练过程可以参考[识别模型训练](../training/metric_learning/training.md)，后续我们也会持续细化这块的文档。
 
 #### Q2.4.3: 训练 metric learning 时，每个 epoch 中，无法跑完所有 mini-batch，为什么？
 **A**：在训练 metric learning 时，使用的 Sampler 是 DistributedRandomIdentitySampler，该 Sampler 不会采样全部的图片，导致会让每一个 epoch 采样的数据不是所有的数据，所以无法跑完显示的 mini-batch 是正常现象。该问题在 release/2.3 分支已经优化，请更新到 release/2.3 使用。

docs/zh_CN/faq_series/faq_selected_30.md → docs/zh_CN/FAQ/faq_selected_30.md

@@ -32,7 +32,7 @@
 >>
 * Q: 怎样根据自己的任务选择合适的模型进行训练？
 * A: 如果希望在服务器部署，或者希望精度尽可能地高，对模型存储大小或者预测速度的要求不是很高，那么推荐使用 ResNet_vd、Res2Net_vd、DenseNet、Xception 等适合于服务器端的系列模型；如果希望在移动端侧部署，则推荐使用 MobileNetV3、GhostNet
-    等适合于移动端的系列模型。同时，我们推荐在选择模型的时候可以参考[模型库](../algorithm_introduction/ImageNet_models.md)中的速度-精度指标图。
+    等适合于移动端的系列模型。同时，我们推荐在选择模型的时候可以参考[模型库](../models/ImageNet1k/model_list.md)中的速度-精度指标图。
 
 >>
 * Q: 如何进行参数初始化，什么样的初始化可以加快模型收敛？
@@ -126,7 +126,7 @@
 
 >>
 * Q: 数据量不足的情况下，目前有哪些常见的数据增广方法来增加训练样本的丰富度呢？
-* A: PaddleClas 中将目前比较常见的数据增广方法分为了三大类，分别是图像变换类、图像裁剪类和图像混叠类，图像变换类主要包括 AutoAugment 和 RandAugment，图像裁剪类主要包括 CutOut、RandErasing、HideAndSeek 和 GridMask，图像混叠类主要包括 Mixup 和 Cutmix，更详细的关于数据增广的介绍可以参考：[数据增广章节](../algorithm_introduction/DataAugmentation.md)。
+* A: PaddleClas 中将目前比较常见的数据增广方法分为了三大类，分别是图像变换类、图像裁剪类和图像混叠类，图像变换类主要包括 AutoAugment 和 RandAugment，图像裁剪类主要包括 CutOut、RandErasing、HideAndSeek 和 GridMask，图像混叠类主要包括 Mixup 和 Cutmix，更详细的关于数据增广的介绍可以参考：[数据增广章节](../algorithm_introduction/data_augmentation.md)。
 >>
 * Q: 对于遮挡情况比较常见的图像分类场景，该使用什么数据增广方法去提升模型的精度呢？
 * A: 在训练的过程中可以尝试对训练集使用 CutOut、RandErasing、HideAndSeek 和 GridMask 等裁剪类数据增广方法，让模型也能够不止学习到显著区域，也能关注到非显著性区域，从而在遮挡的情况下，也能较好地完成识别任务。
@@ -214,7 +214,7 @@
 
 >>
 * Q: 怎么在 windows 上或者 cpu 上面模型训练呢？
-* A: 可以参考[开始使用教程](../models_training/classification.md)，详细介绍了在 Linux、Windows、CPU 等环境中进行模型训练、评估与预测的教程。
+* A: 可以参考[开始使用教程](../training/single_label_classification/training.md)，详细介绍了在 Linux、Windows、CPU 等环境中进行模型训练、评估与预测的教程。
 >>
 * Q: 怎样在模型训练的时候使用 label smoothing 呢？
 * A: 可以在配置文件中的 `Loss` 字段下进行设置，如下所示，`epsilon=0.1` 表示设置该值为 0.1，若不设置 `epsilon` 字段，则不使用 `label smoothing`。

docs/zh_CN/Makefile

-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line, and also
-# from the environment for the first two.
-SPHINXOPTS    ?=
-SPHINXBUILD   ?= sphinx-build
-
-#SOURCEDIR     = source
-BUILDDIR      = build
-
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/zh_CN/advanced_tutorials/gallery2fc.md

-# 识别模型转分类模型
-
-PaddleClas 提供了 `gallery2fc.py` 工具，帮助大家将识别模型转为分类模型。目前该工具仅支持转换量化后模型，因此建议使用 PaddleClas 提供的 `general_PPLCNet_x2_5_pretrained_v1.0_quant` 预训练模型，该模型为量化后的通用识别模型，backbone 为 PPLCNet_x2_5。
-
-如需使用其他模型，关于量化的具体操作请参考文档 [模型量化](./model_prune_quantization.md)。
-
-## 一、模型转换说明
-
-### 1.1 准备底库数据、预训练模型
-
-#### 1. 底库数据集
-
-首先需要准备好底库数据，下面以 PaddleClas 提供的饮料数据集（drink_dataset_v1.0）为例进行说明，饮料数据集获取方法：
-
-```shell
-cd PaddleClas/
-wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/drink_dataset_v1.0.tar
-tar -xf drink_dataset_v1.0.tar
-```
-
-饮料数据集的底库图片路径为 `drink_dataset_v1.0/gallery/`，底库图片列表可在 `drink_dataset_v1.0/gallery/drink_label.txt` 中查看，关于底库数据格式说明，请参考文档[数据集格式说明](../data_preparation/recognition_dataset.md#1-数据集格式说明)。
-
-#### 2. 预训练模型
-
-在开始转换模型前，需要准备好预训练模型，下面以量化后的 `general_PPLCNet_x2_5` 模型为例，下载预训练模型：
-
-```shell
-cd PaddleClas/pretrained/
-wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/pretrain/general_PPLCNet_x2_5_pretrained_v1.0_quant.pdparams
-```
-
-### 1.2 准备配置文件
-
-在进行模型转换时，需要通过配置文件定义所需参数，本例中所用配置文件为 `ppcls/configs/GeneralRecognition/Gallery2FC_PPLCNet_x2_5.yaml`，对于配置文件字段的说明，如下所示：
-
-* Global:
-    * pretrained_model: 预训练模型路径，无需包含 `.pdparams` 后缀名；
-    * image_shape: 模型输入数据尺寸，无需包含 batch size 维度；
-    * save_inference_dir: 转换后模型的保存路径；
-* Arch: 模型结构相关定义，可参考 [配置说明](../models_training/config_description.md#3-%E8%AF%86%E5%88%AB%E6%A8%A1%E5%9E%8B)；
-* IndexProcess: 底库数据集相关定义
-    * image_root: 底库数据集路径；
-    * data_file: 底库数据集列表文件路径；
-
-### 1.3 模型转换
-
-在完成上述准备工作后，即可进行模型转换，命令如下所示：
-
-```python
-python ppcls/utils/gallery2fc.py -c ppcls/configs/GeneralRecognition/Gallery2FC_PPLCNet_x2_5.yaml
-```
-
-在上述命令执行完成后，转换并导出的模型保存在目录 `./inference/general_PPLCNet_x2_5_quant/` 下。在推理部署时，需要注意的是，模型的输出结果通常有多个，应选取分类结果作为模型输出，需要注意区分。

docs/zh_CN/advanced_tutorials/index.rst

-高级教程
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   DataAugmentation.md
-   knowledge_distillation.md
-   model_prune_quantization.md
-   code_overview.md
-   how_to_contribute.md
-   
-   

docs/zh_CN/algorithm_introduction/reid.md → docs/zh_CN/algorithm_introduction/ReID.md

@@ -320,31 +320,31 @@
 
 ##### 4.2.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考基于 Visual Studio 2019 Community CMake 编译指南完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考基于 Visual Studio 2019 Community CMake 编译指南完成相应的预测库编译和模型预测工作。
 
 #### 4.3 服务化部署
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考Paddle Serving 代码仓库。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/recognition_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../deployment/PP-ShiTu/paddle_serving.md)来完成相应的部署工作。
 
 #### 4.4 端侧部署
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考Paddle Lite 代码仓库。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 #### 4.5 Paddle2ONNX 模型转换与预测
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考Paddle2ONNX 代码仓库。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。
 
 ### 5. 总结
 
 #### 5.1 方法总结与对比
 
-上述算法能快速地迁移至多数的ReID模型中（参考 [PP-ShiTuV2](../PPShiTu/PPShiTuV2_introduction.md) ），能进一步提升ReID模型的性能，
+上述算法能快速地迁移至多数的ReID模型中（参考 [PP-ShiTuV2](../models/PP-ShiTu/README.md) ），能进一步提升ReID模型的性能，
 
 #### 5.2 使用建议/FAQ
 

docs/zh_CN/algorithm_introduction/DataAugmentation.md → docs/zh_CN/algorithm_introduction/data_augmentation.md

@@ -240,7 +240,7 @@ Mixup 是最先提出的图像混叠增广方案，其原理简单、方便实
 
 ![][test_cutmix]
 
-关于数据增强相关的实战部分实参考[数据增强实战](../advanced_tutorials/DataAugmentation.md)。
+关于数据增强相关的实战部分实参考[数据增强实战](../training/config_discription/data_augmentation.md)。
 
 
 ## 参考文献

docs/zh_CN/algorithm_introduction/deep_hashing_introduction.md → docs/zh_CN/algorithm_introduction/deep_hashing.md

@@ -55,7 +55,7 @@ LCDSH是一种局部约束深度监督哈希算法。该方案通过学习图像
 `DSHSD`: ppcls/configs/DeepHash/DSHSD.yaml
 `LCDSH`: ppcls/configs/DeepHash/LCDSH.yaml
 
-具体训练方法，请参考[分类模型训练文档](../models_training/classification.md)
+具体训练方法，请参考[分类模型训练文档](../training/single_label_classification/training.md)
 
 <a name='4'></a>
 ## 4. 总结及建议

docs/zh_CN/algorithm_introduction/image_classification.md

@@ -46,12 +46,12 @@ CIFAR-10 数据集由 10 个类的 60000 个彩色图像组成，图像分辨率
 <a name="2.2"></a>
 ### 2.2 模型准备
 
-在数据确定后，模型往往决定了最终算法精度的上限，在图像分类领域，经典的模型层出不穷，PaddleClas 提供了 36 个系列共 175 个 ImageNet 预训练模型。具体的精度、速度等指标请参考[骨干网络和预训练模型库](./ImageNet_models.md)。
+在数据确定后，模型往往决定了最终算法精度的上限，在图像分类领域，经典的模型层出不穷，PaddleClas 提供了 36 个系列共 175 个 ImageNet 预训练模型。具体的精度、速度等指标请参考[骨干网络和预训练模型库](../models/ImageNet1k/model_list.md)。
 
 <a name="2.3"></a>
 ### 2.3 模型训练
 
-在准备好数据、模型后，便可以开始迭代模型并更新模型的参数。经过多次迭代最终可以得到训练好的模型来做图像分类任务。图像分类的训练过程需要很多经验，涉及很多超参数的设置，PaddleClas 提供了一些列的[训练调优方法](../models_training/train_strategy.md)，可以快速助你获得高精度的模型。
+在准备好数据、模型后，便可以开始迭代模型并更新模型的参数。经过多次迭代最终可以得到训练好的模型来做图像分类任务。图像分类的训练过程需要很多经验，涉及很多超参数的设置，PaddleClas 提供了一些列的[训练调优方法](../training/single_label_classification/training_strategy.md)，可以快速助你获得高精度的模型。
 
 <a name="2.4"></a>
 ### 2.4 模型评估

docs/zh_CN/algorithm_introduction/index.rst

-算法介绍
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   image_classification.md
-   metric_learning.md
-   knowledge_distillation.md
-   model_prune_quantization.md
-   ImageNet_models.md
-   DataAugmentation.md

docs/zh_CN/others/course_link.md → docs/zh_CN/community/courses.md

@@ -16,19 +16,16 @@
     - Metric Learning——更鲁棒的检索特征
     - Logo识别等方向延展
   - [超轻量图像识别系统概览](https://aistudio.baidu.com/aistudio/education/lessonvideo/1890318)
-    - 图像识别技术选型策略 
+    - 图像识别技术选型策略
     - 推理速度提升8倍的秘籍
-    - 四大典型行业应用案例 
+    - 四大典型行业应用案例
   - [SOTA模型炼丹秘诀](https://aistudio.baidu.com/aistudio/education/lessonvideo/1890323)
     - CPU定制模型PP-LCNet优化思路
     - Vison Transformer模型的应用拓展
   - [商品识别产业痛点剖析](https://aistudio.baidu.com/aistudio/education/lessonvideo/1896890)
     - 特征提取技术详解
-    - 向量快速检索揭秘 
+    - 向量快速检索揭秘
   - [手把手教你玩转图像识别](https://aistudio.baidu.com/aistudio/education/lessonvideo/1911507)
-    - 产业应用十问十答 
+    - 产业应用十问十答
     - 智能零售下的应用案例
     - 识别系统快速落地方案
-  
-  
-

docs/zh_CN/conf.py

-# Configuration file for the Sphinx documentation builder.
-#
-# This file only contains a selection of the most common options. For a full
-# list see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Path setup --------------------------------------------------------------
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-import sphinx_rtd_theme
-from recommonmark.parser import CommonMarkParser
-#import sphinx-markdown-tables
-# -- Project information -----------------------------------------------------
-
-project = 'PaddleClas'
-copyright = '2021, PaddleClas'
-author = 'PaddleClas'
-
-# The full version, including alpha/beta/rc tags
-release = '2.3.0'
-
-
-# -- General configuration ---------------------------------------------------
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-source_parsers = {
-    '.md': CommonMarkParser,
-}
-source_suffix = ['.rst', '.md']
-extensions = [
-     'recommonmark',
-     'sphinx_markdown_tables'
- ]
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = 'zh_CN'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = "sphinx_rtd_theme"
-html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']

docs/zh_CN/data_preparation/index.rst

-数据准备
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   recognition_dataset.md
-   classification_dataset.md

docs/zh_CN/introduction/ppshitu_application_scenarios.md → docs/zh_CN/deployment/PP-ShiTu/application_scenarios.md

@@ -58,7 +58,7 @@ PP-ShiTu对原数据集进行了`Gallery`库和`Query`库划分，并生成了
 <a name="2.1 环境配置"></a>
 
 ### 2.1 环境配置
-- 安装：请先参考文档[环境准备](../installation/install_paddleclas.md)配置PaddleClas运行环境
+- 安装：请先参考文档[环境准备](../../installation.md)配置PaddleClas运行环境
 - 进入`deploy`运行目录，本部分所有内容与命令均需要在`deploy`目录下运行，可以通过下面命令进入`deploy`目录。
 ```shell
 cd deploy
@@ -176,7 +176,7 @@ python3.7 python/predict_system.py -c configs/inference_general.yaml -o Global.u
 其中`bbox`表示检测出的主体所在位置，`rec_docs`表示索引库中与检测框最为相似的类别，`rec_scores`表示对应的置信度。
 检测的可视化结果也保存在`output`文件夹下，对于本张图像，识别结果可视化如下所示。
 
-![](../../images/ppshitu_application_scenarios/systerm_result.jpg)
+![](../../../images/ppshitu_application_scenarios/systerm_result.jpg)
 
 <a name="2.4.2 基于文件夹的批量识别"></a>
 

deploy/cpp_shitu/readme.md → docs/zh_CN/deployment/PP-ShiTu/cpp.md

@@ -361,6 +361,6 @@ cd ..
 
 ## 4.  使用自己模型
 
-使用自己训练的模型，可以参考[模型导出](../../docs/zh_CN/inference_deployment/export_model.md)，导出`inference model`，用于模型预测。
+使用自己训练的模型，可以参考[模型导出](../export_model.md)，导出`inference model`，用于模型预测。
 
 同时注意修改`yaml`文件中具体参数。

docs/zh_CN/inference_deployment/recognition_serving_deploy.md → docs/zh_CN/deployment/PP-ShiTu/paddle_serving.md

-简体中文 | [English](../../en/inference_deployment/recognition_serving_deploy_en.md)
+简体中文 | [English](../../../en/inference_deployment/recognition_serving_deploy_en.md)
 
 # 识别模型服务化部署
 
@@ -188,7 +188,7 @@ python3.7 -m pip install paddle-serving-server-gpu==0.7.0.post112 # GPU with CUD
   pipeline_http_client.py     # http方式发送pipeline预测请求的脚本
   pipeline_rpc_client.py      # rpc方式发送pipeline预测请求的脚本
   recognition_web_service.py  # 启动pipeline服务端的脚本
-  readme.md                   # 识别模型服务化部署文档
+  paddle2onnx.md                   # 识别模型服务化部署文档
   run_cpp_serving.sh          # 启动C++ Pipeline Serving部署的脚本
   test_cpp_serving_client.py  # rpc方式发送C++ Pipeline serving预测请求的脚本
   ```
@@ -225,7 +225,7 @@ python3.7 -m pip install paddle-serving-server-gpu==0.7.0.post112 # GPU with CUD
   # 一键编译安装Serving server、设置 SERVING_BIN
   source ./build_server.sh python3.7
   ```
-  **注：** [build_server.sh](../build_server.sh#L55-L62) 所设定的路径可能需要根据实际机器上的环境如CUDA、python版本等作一定修改，然后再编译；如果执行 `build_server.sh` 过程中遇到非网络原因的报错，则可以手动将脚本中的命令逐条复制到终端执行。
+  **注：** [build_server.sh](../../../../deploy/paddleserving/build_server.sh#L55-L62) 所设定的路径可能需要根据实际机器上的环境如CUDA、python版本等作一定修改，然后再编译；如果执行 `build_server.sh` 过程中遇到非网络原因的报错，则可以手动将脚本中的命令逐条复制到终端执行。
 
 - C++ Serving使用的输入输出格式与Python不同，因此需要执行以下命令，将4个文件复制到下的文件覆盖掉[3.1](#31-模型转换)得到文件夹中的对应4个prototxt文件。
   ```shell

docs/zh_CN/inference_deployment/python_deploy.md → docs/zh_CN/deployment/PP-ShiTu/python.md

 # Python 预测推理
 
-首先请参考文档[环境准备](../installation/install_paddleclas.md)配置运行环境。
+首先请参考文档[环境准备](../../installation.md)配置运行环境。
 
 ## 目录
 
-- [1. 图像分类模型推理](#1)
-- [2. PP-ShiTu模型推理](#2)
-    - [2.1 主体检测模型推理](#2.1)
-    - [2.2 特征提取模型推理](#2.2)
-    - [2.3 PP-ShiTu PipeLine推理](#2.3)
+- [1. PP-ShiTu模型推理](#1)
+    - [1.1 主体检测模型推理](#1.1)
+    - [1.2 特征提取模型推理](#1.2)
+    - [1.3 PP-ShiTu PipeLine推理](#1.3)
 
 <a name="1"></a>
 
-## 1. 图像分类推理
-
-首先请参考文档[模型导出](./export_model.md)准备 inference 模型，然后进入 PaddleClas 的 `deploy` 目录下：
-
-```shell
-cd PaddleClas/deploy
-```
-
-使用以下命令进行预测：
-
-```shell
-python3.7 python/predict_cls.py -c configs/inference_cls.yaml
-```
-
-在配置文件 `configs/inference_cls.yaml` 中有以下字段用于配置预测参数：
-* `Global.infer_imgs`：待预测的图片文件（夹）路径；
-* `Global.inference_model_dir`：inference 模型文件所在文件夹的路径，该文件夹下需要有文件 `inference.pdmodel` 和 `inference.pdiparams` 两个文件；
-* `Global.use_gpu`：是否使用 GPU 预测，默认为 `True`；
-* `Global.enable_mkldnn`：是否启用 `MKL-DNN` 加速库，默认为 `False`。注意 `enable_mkldnn` 与 `use_gpu` 同时为 `True` 时，将忽略 `enable_mkldnn`，而使用 GPU 预测；
-* `Global.use_fp16`：是否启用 `FP16`，默认为 `False`；
-* `Global.use_tensorrt`：是否使用 TesorRT 预测引擎，默认为 `False`；
-* `PreProcess`：用于数据预处理配置；
-* `PostProcess`：由于后处理配置；
-* `PostProcess.Topk.class_id_map_file`：数据集 label 的映射文件，默认为 `../ppcls/utils/imagenet1k_label_list.txt`，该文件为 PaddleClas 所使用的 ImageNet 数据集 label 映射文件。
-
-**注意**:
-* 如果使用 VisionTransformer 系列模型，如 `DeiT_***_384`, `ViT_***_384` 等，请注意模型的输入数据尺寸，该类模型需要修改参数： `PreProcess.resize_short=384`, `PreProcess.resize=384`。
-* 如果你希望提升评测模型速度，使用 GPU 评测时，建议开启 TensorRT 加速预测，使用 CPU 评测时，建议开启 MKL-DNN 加速预测。
-
-<a name="2"></a>
-
-## 2. PP-ShiTu模型推理
+## 1. PP-ShiTu模型推理
 
 PP-ShiTu整个Pipeline包含三部分：主体检测、特征提取模型、特征检索。其中主体检测模型、特征提取模型可以单独推理使用。单独使用主体检测详见[主体检测模型推理](#2.1)，特征提取模型单独推理详见[特征提取模型推理](#2.2)， PP-ShiTu整体推理详见[PP-ShiTu PipeLine推理](#2.3)。
 
 <a name="2.1"></a>
 
-### 2.1 主体检测模型推理
+### 1.1 主体检测模型推理
 
 进入 PaddleClas 的 `deploy` 目录下：
 
@@ -78,7 +46,7 @@ python3.7 python/predict_det.py -c configs/inference_det.yaml
 
 <a name="2.2"></a>
 
-### 2.2 特征提取模型推理
+### 1.2 特征提取模型推理
 
 下面以商品图片的特征提取为例，介绍特征提取模型推理。首先进入 PaddleClas 的 `deploy` 目录下：
 
@@ -103,12 +71,12 @@ python3.7 python/predict_rec.py -c configs/inference_rec.yaml
 
 上述预测命令可以得到一个 512 维的特征向量，直接输出在在命令行中。
 
-在配置文件 `configs/inference_det.yaml` 中有以下字段用于配置预测参数：
+在配置文件 `configs/inference_rec.yaml` 中有以下字段用于配置预测参数：
 * `Global.infer_imgs`：待预测的图片文件路径；
 * `Global.use_gpu`： 是否使用 GPU 预测，默认为 `True`。
 
-<a name="2.3"></a>
+<a name="1.3"></a>
 
-### 2.3. PP-ShiTu PipeLine推理
+### 1.3 PP-ShiTu PipeLine推理
 
-主体检测、特征提取和向量检索的串联预测，可以参考[图像识别快速开始](../quick_start/quick_start_recognition.md)。
+主体检测、特征提取和向量检索的串联预测，可以参考[图像识别快速开始](../../quick_start/quick_start_recognition.md)。

docs/zh_CN/advanced_tutorials/shitu_deploy.md → docs/zh_CN/deployment/PP-ShiTu/shitu_deploy.md

@@ -11,7 +11,7 @@
   - [2.2 识别模型调优](#2.2)
 - [3.模型加速](#3)
 
-在[PP-ShiTu快速开始](../quick_start/quick_start_recognition.md)中，主要展示了`PP-ShiTu`的快速开始demo。那么本文档主要介绍，如何将`PP-ShiTu`应用到自己的需求中，及如何继续调优，优化识别效果。具体可以分成以下三种情况
+在[PP-ShiTu快速开始](../../quick_start/quick_start_recognition.md)中，主要展示了`PP-ShiTu`的快速开始demo。那么本文档主要介绍，如何将`PP-ShiTu`应用到自己的需求中，及如何继续调优，优化识别效果。具体可以分成以下三种情况
 
 - 直接使用官方模型
 - 根据需求对模型进行调优
@@ -35,7 +35,7 @@
 
 ### 1.1 下载官方模型及数据准备
 
-模型下载及pipline 运行详见[图像识别快速开始](../quick_start/quick_start_recognition.md)
+模型下载及pipline 运行详见[图像识别快速开始](../../quick_start/quick_start_recognition.md)
 
 下载模型后，要准备相应的数据，即所迁移应用的具体数据，数据量根据实际情况，自行决定，但是不能太少，会影响精度。将准备的数据分成两部分：1）建库图像（gallery），2）测试图像。其中建库数据无需过多，但需保证每个类别包含此类别物体不同角度的图像，建议每个类别至少5张图，请根据实际情况，具体调节。
 
@@ -49,7 +49,7 @@
 
 对于加入检索的数据，每个类别尽量准备此类别的各角度的图像，丰富类别信息。准备的图像只能包含此类别，同时图像背景尽可能的少、简单。即将要加入检索根据标注的包围框信息，裁剪出bbox图像作为新的要加入的图像，以提高检索库的图像质量。
 
-收集好图像后，数据整理及建库流程详见[图像识别快速开始](../quick_start/quick_start_recognition.md)中`3.2 建立新的索引库`
+收集好图像后，数据整理及建库流程详见[图像识别快速开始](../../quick_start/quick_start_recognition.md)中`3.2 建立新的索引库`
 
 <a name="1.3"></a>
 
@@ -77,12 +77,12 @@
 
 在使用官方模型后，如果不满足精度需求，则可以参考此部分文档，进行模型调优
 
-因为要对模型进行训练，所以收集自己的数据集。数据准备及相应格式请参考：[特征提取文档](../image_recognition_pipeline/feature_extraction.md)中 `4.1数据准备`部分、[识别数据集说明](../data_preparation/recognition_dataset.md)。值得注意的是，此部分需要准备大量的数据，以保证识别模型效果。训练配置文件参考：[通用识别模型配置文件](../../../ppcls/configs/GeneralRecognition/GeneralRecognition_PPLCNet_x2_5.yaml)，训练方法参考：[识别模型训练](../models_training/recognition.md)
+因为要对模型进行训练，所以收集自己的数据集。数据准备及相应格式请参考：[特征提取文档](../../training/PP-ShiTu/feature_extraction.md)中 `4.1数据准备`部分、[识别数据集说明](../../training/metric_learning/dataset.md)。值得注意的是，此部分需要准备大量的数据，以保证识别模型效果。训练配置文件参考：[通用识别模型配置文件](../../../../ppcls/configs/GeneralRecognition/GeneralRecognition_PPLCNet_x2_5.yaml)，训练方法参考：[识别模型训练](../../training/metric_learning/training.md)
 
-- 数据增强：根据实际情况选择不同数据增强方法。如：实际应用中数据遮挡比较严重，建议添加`RandomErasing`增强方法。详见[数据增强文档](./DataAugmentation.md)
-- 换不同的`backbone`，一般来说，越大的模型，特征提取能力更强。不同`backbone`详见[模型介绍](../algorithm_introduction/ImageNet_models.md)
-- 选择不同的`Metric Learning`方法。不同的`Metric Learning`方法，对不同的数据集效果可能不太一样，建议尝试其他`Loss`,详见[Metric Learning](../algorithm_introduction/metric_learning.md)
-- 采用蒸馏方法，对小模型进行模型能力提升，详见[模型蒸馏](../algorithm_introduction/knowledge_distillation.md)
+- 数据增强：根据实际情况选择不同数据增强方法。如：实际应用中数据遮挡比较严重，建议添加`RandomErasing`增强方法。详见[数据增强文档](../../training/config_discription/data_augmentation.md)
+- 换不同的`backbone`，一般来说，越大的模型，特征提取能力更强。不同`backbone`详见[模型介绍](../../models/ImageNet1k/model_list.md)
+- 选择不同的`Metric Learning`方法。不同的`Metric Learning`方法，对不同的数据集效果可能不太一样，建议尝试其他`Loss`,详见[Metric Learning](../../algorithm_introduction/metric_learning.md)
+- 采用蒸馏方法，对小模型进行模型能力提升，详见[模型蒸馏](../../algorithm_introduction/knowledge_distillation.md)
 - 增补数据集。针对错误样本，添加badcase数据
 
 模型训练完成后，参照[1.2 检索库更新](#1.2)进行检索库更新。同时，对整个pipeline进行测试，如果精度不达预期，则重复此步骤。
@@ -94,4 +94,4 @@
 模型加速主要以下几种方法：
 
 - 替换小模型：一般来说，越小的模型预测速度相对越快
-- 模型裁剪、量化：请参考文档[模型压缩](./model_prune_quantization.md)，压缩配置文件修改请参考[slim相关配置文件](../../../ppcls/configs/slim/)。
+- 模型裁剪、量化：请参考文档[模型压缩](../../training/advanced/prune_quantization.md)，压缩配置文件修改请参考[slim相关配置文件](../../../../ppcls/configs/slim/)。

docs/zh_CN/image_recognition_pipeline/vector_search.md → docs/zh_CN/deployment/PP-ShiTu/vector_search.md

@@ -25,7 +25,7 @@
 
 值得注意的是，为了更好是适配性，目前版本，`PaddleClas` 中暂时**只使用 CPU 进行向量检索**。
 
-![](../../images/structure.jpg)
+![](../../../images/structure.jpg)
 
 如上图中所示，向量检索部分，在整个 `PP-ShiTu` 系统中有两部分内容
 
@@ -127,7 +127,7 @@ IndexProcess:
 ### 4.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` 文件。
 
@@ -145,4 +145,4 @@ IndexProcess:
 
 - `return_k`: 检索结果返回 `k` 个结果
 - `score_thres`: 检索匹配的阈值
-- `hamming_radius`: 汉明距离半径。此参数只有在使用二值特征模型，`dist_type`设置为`hamming`时才能生效。具体二值特征模型使用方法请参考[哈希编码](./deep_hashing.md)
+- `hamming_radius`: 汉明距离半径。此参数只有在使用二值特征模型，`dist_type`设置为`hamming`时才能生效。具体二值特征模型使用方法请参考[哈希编码](../../training/PP-ShiTu/deep_hashing.md)

docs/zh_CN/inference_deployment/export_model.md → docs/zh_CN/deployment/export_model.md

@@ -17,7 +17,7 @@ PaddlePaddle 支持导出 inference 模型用于部署推理场景，相比于
 <a name="1"></a>
 ## 1. 环境准备
 
-首先请参考文档文档[环境准备](../installation/install_paddleclas.md)配置运行环境。
+首先请参考文档文档[环境准备](../installation.md)配置运行环境。
 
 <a name="2"></a>
 ## 2. 分类模型导出
@@ -46,7 +46,7 @@ python tools/export_model.py \
 <a name="3"></a>
 ## 3. 主体检测模型导出
 
-主体检测模型的导出，可以参考[主体检测介绍](../image_recognition_pipeline/mainbody_detection.md)。
+主体检测模型的导出，可以参考[主体检测介绍](../training/PP-ShiTu/mainbody_detection.md)。
 
 <a name="4"></a>
 ## 4. 识别模型导出
@@ -91,9 +91,16 @@ python3 tools/export_model.py \
 
 导出的 inference 模型文件可用于预测引擎进行推理部署，根据不同的部署方式/平台，可参考：
 
-* [Python 预测](./inference/python_deploy.md)
-* [C++ 预测](./inference/cpp_deploy.md)（目前仅支持分类模型）
-* [Python Whl 预测](./inference/whl_deploy.md)（目前仅支持分类模型）
-* [PaddleHub Serving 部署](./deployment/paddle_hub_serving_deploy.md)（目前仅支持分类模型）
-* [PaddleServing 部署](./deployment/paddle_serving_deploy.md)
-* [PaddleLite 部署](./deployment/paddle_lite_deploy.md)（目前仅支持分类模型）
+图像分类模型部署：
+* [Python 预测](./image_classification/python.md)
+* [C++ 预测](./image_classification/cpp/linux.md)
+* [Python Whl 预测](./image_classification/whl.md)（目前仅支持分类模型）
+* [PaddleHub Serving 部署](./image_classification/paddle_hub.md)（目前仅支持分类模型）
+* [PaddleServing 部署](./image_classification/paddle_serving.md)
+* [PaddleLite 部署](./image_classification/paddle_lite.md)
+
+PP-ShiTu 部署：
+* [Python 预测](./PP-ShiTu/python.md)
+* [C++ 预测](./PP-ShiTu/cpp.md)
+* [PaddleServing 部署](./PP-ShiTu/paddle_serving.md)
+* [PaddleLite 部署](./PP-ShiTu/paddle_lite.md)

docs/zh_CN/inference_deployment/cpp_deploy.md → docs/zh_CN/deployment/image_classification/cpp/linux.md

@@ -25,7 +25,7 @@
 - Linux 环境，推荐使用 docker。
 - Windows 环境，目前支持基于 `Visual Studio 2019 Community` 进行编译；此外，如果您希望通过生成 `sln 解决方案` 的方式进行编译，可以参考该文档：[https://zhuanlan.zhihu.com/p/145446681](https://zhuanlan.zhihu.com/p/145446681)
 
-* 该文档主要介绍基于 Linux 环境下的 PaddleClas C++ 预测流程，如果需要在 Windows 环境下使用预测库进行 C++ 预测，具体编译方法请参考 [Windows 下编译教程](./cpp_deploy_on_windows.md)。
+* 该文档主要介绍基于 Linux 环境下的 PaddleClas C++ 预测流程，如果需要在 Windows 环境下使用预测库进行 C++ 预测，具体编译方法请参考 [Windows 下编译教程](windows.md)。
 
 <a name="1.1"></a>
 ### 1.1 编译 opencv 库
@@ -255,7 +255,7 @@ make
 <a name="3.1"></a>
 ### 3.1 准备 inference model
 
-首先需要准备 inference model，关于将模型导出为 inference model 的具体步骤，可以参考 [模型导出](./export_model.md) 文档。假设导出的预测模型文件放在 `./inference` 目录下，则目录结构如下。
+首先需要准备 inference model，关于将模型导出为 inference model 的具体步骤，可以参考 [模型导出](../../export_model.md) 文档。假设导出的预测模型文件放在 `./inference` 目录下，则目录结构如下。
 
 ```
 inference/
@@ -293,6 +293,6 @@ sh tools/run.sh
 
 * 最终屏幕上会输出结果，如下图所示。
 
-![](../../images/inference_deployment/cpp_infer_result.png)
+![](../../../../images/inference_deployment/cpp_infer_result.png)
 
 其中 `class id` 表示置信度最高的类别对应的 id，score 表示图片属于该类别的概率。

docs/zh_CN/inference_deployment/cpp_deploy_on_windows.md → docs/zh_CN/deployment/image_classification/cpp/windows.md

@@ -61,19 +61,19 @@ paddle_inference_install_dir
 
 1. 打开 Visual Studio 2019 Community，点击 `继续但无需代码`
 
-![step2](../../images/inference_deployment/vs2019_step1.png)
+![step2](../../../../images/inference_deployment/vs2019_step1.png)
 
 2. 点击：`文件`->`打开`->`CMake`
 
-![step2.1](../../images/inference_deployment/vs2019_step2.png)
+![step2.1](../../../../images/inference_deployment/vs2019_step2.png)
 
 选择项目代码所在路径，并打开 `CMakeList.txt`：
 
-![step2.2](../../images/inference_deployment/vs2019_step3.png)
+![step2.2](../../../../images/inference_deployment/vs2019_step3.png)
 
 3. 点击：`项目`->`CMake 设置`
 
-![step3](../../images/inference_deployment/vs2019_step4.png)
+![step3](../../../../images/inference_deployment/vs2019_step4.png)
 
 4. 请设置以下参数的值
 
@@ -102,13 +102,13 @@ paddle_inference_install_dir
    * `PADDLE_LIB`：该路径下需要有 `CMakeCache.txt` 文件，一般为 `paddle_inference_install_dir/`。
 * 在使用 `CPU` 版预测库时，请不要勾选 `WITH_GPU` - `保存到 JSON`。
 
-![step4](../../images/inference_deployment/vs2019_step5.png)
+![step4](../../../../images/inference_deployment/vs2019_step5.png)
 
 设置完成后，点击上图中 `保存并生成 CMake 缓存以加载变量`。
 
 5. 点击`生成`->`全部生成`
 
-![step6](../../images/inference_deployment/vs2019_step6.png)
+![step6](../../../../images/inference_deployment/vs2019_step6.png)
 
 在编译完成后，会生成可执行文件 `clas_system.exe`。并且，如未设置 `DCONFIG_LIB` 与 `DCLS_LIB`，则会在 `.\lib\` 目录下生成 `config lib` 和 `cls lib` 两个静态链接库文件（`libconfig.a`、`libcls.a`）。类似地，你也可以仅编译生成 `config lib` 和 `cls lib` 两个静态链接库文件，只需打开路径为 `D:\projects\PaddleClas\deploy\cpp\lib\CMakeList.txt` 的 `CMake` 文件并进行编译即可，具体参考[2. 使用 Visual Studio 2019 编译](#2)，完成编译后，同样可在 `.\lib\` 目录下生成静态链接库文件，静态链接库文件可用于二次开发。
 
@@ -118,7 +118,7 @@ paddle_inference_install_dir
 <a name='3.1'></a>
 ### 3.1 准备 inference model
 
-首先需要准备 inference model，关于将模型导出为 inference model 的具体步骤，可以参考 [模型导出](./export_model.md) 文档。假设导出的预测模型文件放在 `./inference` 目录下，则目录结构如下。
+首先需要准备 inference model，关于将模型导出为 inference model 的具体步骤，可以参考 [模型导出](../../export_model.md) 文档。假设导出的预测模型文件放在 `./inference` 目录下，则目录结构如下。
 
 ```
 inference/

docs/zh_CN/deployment/image_classification/paddle2onnx.md

+# paddle2onnx 模型转化与预测
+
+## 目录
+
+- [paddle2onnx 模型转化与预测](#paddle2onnx-模型转化与预测)
+  - [1. 环境准备](#1-环境准备)
+  - [2. 模型转换](#2-模型转换)
+  - [3. onnx 预测](#3-onnx-预测)
+
+## 1. 环境准备
+
+需要准备 Paddle2ONNX 模型转化环境，和 ONNX 模型预测环境。
+
+Paddle2ONNX 支持将 PaddlePaddle inference 模型格式转化到 ONNX 模型格式，算子目前稳定支持导出 ONNX Opset 9~11。
+更多细节可参考 [Paddle2ONNX](https://github.com/PaddlePaddle/Paddle2ONNX#paddle2onnx)
+
+- 安装 Paddle2ONNX
+    ```shell
+    python3.7 -m pip install paddle2onnx
+    ```
+
+- 安装 ONNX 推理引擎
+    ```shell
+    python3.7 -m pip install onnxruntime
+    ```
+下面以 ResNet50_vd 为例，介绍如何将 PaddlePaddle inference 模型转换为 ONNX 模型，并基于 ONNX 引擎预测。
+
+## 2. 模型转换
+
+- ResNet50_vd inference模型下载
+
+    ```shell
+    cd deploy
+    mkdir models && cd models
+    wget -nc https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/ResNet50_vd_infer.tar && tar xf ResNet50_vd_infer.tar
+    cd ..
+    ```
+
+- 模型转换
+
+    使用 Paddle2ONNX 将 Paddle 静态图模型转换为 ONNX 模型格式：
+    ```shell
+    paddle2onnx --model_dir=./models/ResNet50_vd_infer/ \
+    --model_filename=inference.pdmodel \
+    --params_filename=inference.pdiparams \
+    --save_file=./models/ResNet50_vd_infer/inference.onnx \
+    --opset_version=10 \
+    --enable_onnx_checker=True
+    ```
+
+转换完毕后，生成的ONNX 模型 `inference.onnx` 会被保存在 `./models/ResNet50_vd_infer/` 路径下
+
+## 3. onnx 预测
+
+执行如下命令：
+```shell
+python3.7 python/predict_cls.py \
+-c configs/inference_cls.yaml \
+-o Global.use_onnx=True \
+-o Global.use_gpu=False \
+-o Global.inference_model_dir=./models/ResNet50_vd_infer
+```
+
+结果如下：
+```
+ILSVRC2012_val_00000010.jpeg:   class id(s): [153, 204, 229, 332, 155], score(s): [0.69, 0.10, 0.02, 0.01, 0.01], label_name(s): ['Maltese dog, Maltese terrier, Maltese', 'Lhasa, Lhasa apso', 'Old English sheepdog, bobtail', 'Angora, Angora rabbit', 'Shih-Tzu']
+```

docs/zh_CN/inference_deployment/paddle_hub_serving_deploy.md → docs/zh_CN/deployment/image_classification/paddle_hub.md

-简体中文 | [English](../../en/inference_deployment/paddle_hub_serving_deploy_en.md)
+简体中文 | [English](../../../en/inference_deployment/paddle_hub_serving_deploy_en.md)
 
 # 基于 PaddleHub Serving 的服务部署
 
@@ -54,7 +54,7 @@ python3.7 -m pip install paddlehub==2.1.0 --upgrade -i https://pypi.tuna.tsinghu
   "inference_model_dir": "../inference/"
   ```
 * 模型文件（包括 `.pdmodel` 与 `.pdiparams`）的名称必须为 `inference`。
-* 我们提供了大量基于 ImageNet-1k 数据集的预训练模型，模型列表及下载地址详见[模型库概览](../algorithm_introduction/ImageNet_models.md)，也可以使用自己训练转换好的模型。
+* 我们提供了大量基于 ImageNet-1k 数据集的预训练模型，模型列表及下载地址详见[模型库概览](../../models/ImageNet1k/model_list.md)，也可以使用自己训练转换好的模型。
 
 
 <a name="4"></a>
@@ -236,4 +236,4 @@ list: 返回结果
     'class_id_map_file':
     ```
 
-为了避免不必要的延时以及能够以 batch_size 进行预测，数据预处理逻辑（包括 `resize`、`crop` 等操作）均在客户端完成，因此需要在 [PaddleClas/deploy/hubserving/test_hubserving.py#L41-L47](../../../deploy/hubserving/test_hubserving.py#L41-L47) 以及 [PaddleClas/deploy/hubserving/test_hubserving.py#L51-L76](../../../deploy/hubserving/test_hubserving.py#L51-L76) 中修改数据预处理逻辑相关代码。
+为了避免不必要的延时以及能够以 batch_size 进行预测，数据预处理逻辑（包括 `resize`、`crop` 等操作）均在客户端完成，因此需要在 [PaddleClas/deploy/hubserving/test_hubserving.py#L41-L47](../../../../deploy/hubserving/test_hubserving.py#L41-L47) 以及 [PaddleClas/deploy/hubserving/test_hubserving.py#L51-L76](../../../../deploy/hubserving/test_hubserving.py#L51-L76) 中修改数据预处理逻辑相关代码。

docs/zh_CN/inference_deployment/paddle_lite_deploy.md → docs/zh_CN/deployment/image_classification/paddle_lite.md

@@ -2,7 +2,7 @@
 
 本教程将介绍基于[Paddle Lite](https://github.com/PaddlePaddle/Paddle-Lite) 在移动端部署PaddleClas分类模型的详细步骤。
 
-Paddle Lite是飞桨轻量化推理引擎，为手机、IOT端提供高效推理能力，并广泛整合跨平台硬件，为端侧部署及应用落地问题提供轻量化的部署方案。如果希望直接测试速度，可以参考[Paddle-Lite移动端benchmark测试教程](../../docs/zh_CN/extension/paddle_mobile_inference.md)。
+Paddle Lite是飞桨轻量化推理引擎，为手机、IOT端提供高效推理能力，并广泛整合跨平台硬件，为端侧部署及应用落地问题提供轻量化的部署方案。如果希望直接测试速度，可以参考[Paddle-Lite移动端benchmark测试教程](../../models/ImageNet1k/paddle_lite_benchmark.md)。
 
 ---
 

docs/zh_CN/inference_deployment/classification_serving_deploy.md → docs/zh_CN/deployment/image_classification/paddle_serving.md

-简体中文 | [English](../../en/inference_deployment/classification_serving_deploy_en.md)
+简体中文 | [English](../../../en/inference_deployment/classification_serving_deploy_en.md)
 
 # 分类模型服务化部署
 
@@ -141,7 +141,7 @@ classification_web_service.py # 启动pipeline服务端的脚本
 config.yml                    # 启动pipeline服务的配置文件
 pipeline_http_client.py       # http方式发送pipeline预测请求的脚本
 pipeline_rpc_client.py        # rpc方式发送pipeline预测请求的脚本
-readme.md                     # 分类模型服务化部署文档
+paddle2onnx.md                     # 分类模型服务化部署文档
 run_cpp_serving.sh            # 启动C++ Serving部署的脚本
 test_cpp_serving_client.py    # rpc方式发送C++ serving预测请求的脚本
 ```
@@ -182,7 +182,7 @@ test_cpp_serving_client.py    # rpc方式发送C++ serving预测请求的脚本
   # 一键编译安装Serving server、设置 SERVING_BIN
   source ./build_server.sh python3.7
   ```
-  **注：**[build_server.sh](../../../deploy/paddleserving/build_server.sh#L55-L62)所设定的路径可能需要根据实际机器上的环境如CUDA、python版本等作一定修改，然后再编译；如果执行`build_server.sh`过程中遇到非网络原因的报错，则可以手动将脚本中的命令逐条复制到终端执行。
+  **注：**[build_server.sh](../../../../deploy/paddleserving/build_server.sh#L55-L62)所设定的路径可能需要根据实际机器上的环境如CUDA、python版本等作一定修改，然后再编译；如果执行`build_server.sh`过程中遇到非网络原因的报错，则可以手动将脚本中的命令逐条复制到终端执行。
 
 - 修改客户端文件 `ResNet50_vd_client/serving_client_conf.prototxt` ，将 `feed_type:` 后的字段改为20，将第一个 `shape:` 后的字段改为1并删掉其余的 `shape` 字段。
   ```log
@@ -194,9 +194,9 @@ test_cpp_serving_client.py    # rpc方式发送C++ serving预测请求的脚本
     shape: 1
   }
   ```
-- 修改 [`test_cpp_serving_client`](../../../deploy/paddleserving/test_cpp_serving_client.py) 的部分代码
-  1. 修改 [`load_client_config`](../../../deploy/paddleserving/test_cpp_serving_client.py#L28) 处的代码，将 `load_client_config` 后的路径改为 `ResNet50_vd_client/serving_client_conf.prototxt` 。
-  2. 修改 [`feed={"inputs": image}`](../../../deploy/paddleserving/test_cpp_serving_client.py#L45) 处的代码，将 `inputs` 改为与 `ResNet50_vd_client/serving_client_conf.prototxt` 中 `feed_var` 字段下面的 `name` 一致。由于部分模型client文件中的 `name` 为 `x` 而不是 `inputs` ，因此使用这些模型进行C++ Serving部署时需要注意这一点。
+- 修改 [`test_cpp_serving_client`](../../../../deploy/paddleserving/test_cpp_serving_client.py) 的部分代码
+  1. 修改 [`load_client_config`](../../../../deploy/paddleserving/test_cpp_serving_client.py#L28) 处的代码，将 `load_client_config` 后的路径改为 `ResNet50_vd_client/serving_client_conf.prototxt` 。
+  2. 修改 [`feed={"inputs": image}`](../../../../deploy/paddleserving/test_cpp_serving_client.py#L45) 处的代码，将 `inputs` 改为与 `ResNet50_vd_client/serving_client_conf.prototxt` 中 `feed_var` 字段下面的 `name` 一致。由于部分模型client文件中的 `name` 为 `x` 而不是 `inputs` ，因此使用这些模型进行C++ Serving部署时需要注意这一点。
 
 - 启动服务：
   ```shell

docs/zh_CN/deployment/image_classification/python.md

+# Python 预测推理
+
+首先请参考文档[环境准备](../../installation.md)配置运行环境。
+
+## 目录
+
+- [1. 图像分类模型推理](#1)
+
+<a name="1"></a>
+
+## 1. 图像分类推理
+
+首先请参考文档[模型导出](../export_model.md)准备 inference 模型，然后进入 PaddleClas 的 `deploy` 目录下：
+
+```shell
+cd PaddleClas/deploy
+```
+
+使用以下命令进行预测：
+
+```shell
+python3.7 python/predict_cls.py -c configs/inference_cls.yaml
+```
+
+在配置文件 `configs/inference_cls.yaml` 中有以下字段用于配置预测参数：
+* `Global.infer_imgs`：待预测的图片文件（夹）路径；
+* `Global.inference_model_dir`：inference 模型文件所在文件夹的路径，该文件夹下需要有文件 `inference.pdmodel` 和 `inference.pdiparams` 两个文件；
+* `Global.use_gpu`：是否使用 GPU 预测，默认为 `True`；
+* `Global.enable_mkldnn`：是否启用 `MKL-DNN` 加速库，默认为 `False`。注意 `enable_mkldnn` 与 `use_gpu` 同时为 `True` 时，将忽略 `enable_mkldnn`，而使用 GPU 预测；
+* `Global.use_fp16`：是否启用 `FP16`，默认为 `False`；
+* `Global.use_tensorrt`：是否使用 TesorRT 预测引擎，默认为 `False`；
+* `PreProcess`：用于数据预处理配置；
+* `PostProcess`：由于后处理配置；
+* `PostProcess.Topk.class_id_map_file`：数据集 label 的映射文件，默认为 `../ppcls/utils/imagenet1k_label_list.txt`，该文件为 PaddleClas 所使用的 ImageNet 数据集 label 映射文件。
+
+**注意**:
+* 如果使用 VisionTransformer 系列模型，如 `DeiT_***_384`, `ViT_***_384` 等，请注意模型的输入数据尺寸，该类模型需要修改参数： `PreProcess.resize_short=384`, `PreProcess.resize=384`。
+* 如果你希望提升评测模型速度，使用 GPU 评测时，建议开启 TensorRT 加速预测，使用 CPU 评测时，建议开启 MKL-DNN 加速预测。

docs/zh_CN/inference_deployment/whl_deploy.md → docs/zh_CN/deployment/image_classification/whl.md

@@ -39,14 +39,14 @@ python3 setup.py install
 ## 2. 快速开始
 * 使用 `ResNet50` 模型，以下图（`PaddleClas/docs/images/inference_deployment/whl_demo.jpg`）为例进行说明。
 
-![](../../images/inference_deployment/whl_demo.jpg)
+![](../../../images/inference_deployment/whl_demo.jpg)
 
 
 * 在 Python 代码中使用
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='ResNet50')
-infer_imgs='docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs='docs/images/deployment/whl_demo.jpg'
 result=clas.predict(infer_imgs)
 print(next(result))
 ```
@@ -91,7 +91,7 @@ Predict complete!
 
 * 命令行中
 ```bash
-paddleclas --model_name=ViT_base_patch16_384 --infer_imgs='docs/images/inference_deployment/whl_demo.jpg' --resize_short=384 --crop_size=384
+paddleclas --model_name=ViT_base_patch16_384 --infer_imgs='docs/images/deployment/whl_demo.jpg' --resize_short=384 --crop_size=384
 ```
 
 * Python 代码中
@@ -123,14 +123,14 @@ paddleclas -h
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='ResNet50')
-infer_imgs = 'docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs = 'docs/images/deployment/whl_demo.jpg'
 result=clas.predict(infer_imgs)
 print(next(result))
 ```
 
 * CLI
 ```bash
-paddleclas --model_name='ResNet50' --infer_imgs='docs/images/inference_deployment/whl_demo.jpg'
+paddleclas --model_name='ResNet50' --infer_imgs='docs/images/deployment/whl_demo.jpg'
 ```
 
 <a name="4.3"></a>
@@ -141,14 +141,14 @@ paddleclas --model_name='ResNet50' --infer_imgs='docs/images/inference_deploymen
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(inference_model_dir='./inference/')
-infer_imgs = 'docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs = 'docs/images/deployment/whl_demo.jpg'
 result=clas.predict(infer_imgs)
 print(next(result))
 ```
 
 * CLI
 ```bash
-paddleclas --inference_model_dir='./inference/' --infer_imgs='docs/images/inference_deployment/whl_demo.jpg'
+paddleclas --inference_model_dir='./inference/' --infer_imgs='docs/images/deployment/whl_demo.jpg'
 ```
 
 <a name="4.4"></a>
@@ -197,7 +197,7 @@ paddleclas --model_name='ResNet50' --infer_imgs='https://raw.githubusercontent.c
 import cv2
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='ResNet50')
-infer_imgs = cv2.imread("docs/images/inference_deployment/whl_demo.jpg")[:, :, ::-1]
+infer_imgs = cv2.imread("docs/images/deployment/whl_demo.jpg")[:, :, ::-1]
 result=clas.predict(infer_imgs)
 print(next(result))
 ```
@@ -243,12 +243,12 @@ class_id<space>class_name<\n>
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='ResNet50', class_id_map_file='./ppcls/utils/imagenet1k_label_list.txt')
-infer_imgs = 'docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs = 'docs/images/deployment/whl_demo.jpg'
 result=clas.predict(infer_imgs)
 print(next(result))
 ```
 
 * CLI
 ```bash
-paddleclas --model_name='ResNet50' --infer_imgs='docs/images/inference_deployment/whl_demo.jpg' --class_id_map_file='./ppcls/utils/imagenet1k_label_list.txt'
+paddleclas --model_name='ResNet50' --infer_imgs='docs/images/deployment/whl_demo.jpg' --class_id_map_file='./ppcls/utils/imagenet1k_label_list.txt'
 ```

docs/zh_CN/faq_series/index.rst

-FAQ系列
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   faq_2021_s2.md
-   faq_2021_s1.md
-   faq_2020_s1.md
-   faq_selected_30.md

docs/zh_CN/image_recognition_pipeline/index.rst

-图像识别流程
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   mainbody_detection.md
-   feature_extraction.md
-   vector_search.md

docs/zh_CN/index.rst

-欢迎使用PaddleClas图像分类库！
-================================
-
-.. toctree::
-   :maxdepth: 1
-
-   introduction/index
-   installation/index
-   quick_start/index
-   image_recognition_pipeline/index
-   data_preparation/index
-   models_training/index
-   inference_deployment/index
-   models/index
-   algorithm_introduction/index
-   advanced_tutorials/index
-   others/index
-   faq_series/index

docs/zh_CN/inference_deployment/index.rst

-推理部署
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   export_model.md
-   python_deploy.md
-   cpp_deploy.md
-   paddle_serving_deploy.md
-   paddle_hub_serving_deploy.md
-   paddle_lite_deploy.md
-   whl_deploy.md
-   cpp_deploy_on_windows.md
-   
-   
-   

docs/zh_CN/installation/index.rst

-安装
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   install_paddle.md
-   install_paddleclas.md

docs/zh_CN/introduction/function_intro.md

-## PaddleClas 功能特性
-
-飞桨图像识别套件 PaddleClas 是飞桨为工业界和学术界所准备的一个图像识别任务的工具集，助力使用者训练出更好的视觉模型和应用落地。具体地，它包含以下几个核心特性。
-
-
-- 实用的图像识别系统：集成了目标检测、特征学习、图像检索等模块，广泛适用于各类图像识别任务。
-提供商品识别、车辆识别、 logo 识别和动漫人物识别等 4 个场景应用示例。
-
-- 丰富的预训练模型库：提供了 36 个系列共 175 个 ImageNet 预训练模型，其中 7 个精选系列模型支持结构快速修改。
-
-- 全面易用的特征学习组件：集成 arcmargin, triplet loss 等 12 度量学习方法，通过配置文件即可随意组合切换。
-
-- SSLD 知识蒸馏： 14 个分类预训练模型，精度普遍提升 3% 以上；其中 ResNet50_vd 模型在 ImageNet-1k 数据集上的 Top-1 精度达到了 84.0%，Res2Net200_vd 预训练模型 Top-1 精度高达 85.1% 。
-
-- 数据增广：支持 AutoAugment 、 Cutout 、 Cutmix 等 8 种数据增广算法详细介绍、代码复现和在统一实验环境下的效果评估。
-
-
-![](../../images/recognition.gif)
-
-更多关于图像识别快速体验、算法详解、模型训练评估与预测部署方法，请参考[首页 README 文档教程](../../../README_ch.md)。

docs/zh_CN/introduction/index.rst

-介绍
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   function_intro.md
-   more_demo/index

docs/zh_CN/introduction/more_demo/cartoon.md

-## 动漫人物图片识别效果图
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069080-a821e0b7-8a10-4946-bf05-ff093cc16064.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069100-7539d292-1bd8-4655-8a6d-d1f2238bd618.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069103-f91359d4-1197-4a6e-b2f7-434c76a6b704.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069108-ad54ae1d-610d-4cfa-9cd6-8ee8d280d61d.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069114-3c771434-84a8-4e58-961e-d35edfbfe5ef.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069119-e8d85be5-da87-4125-ae8b-9fd4cac139d9.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069124-98c30894-4837-4f2f-8399-3d3ebadfd0a1.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069125-a9edf115-33a1-48bf-9e4f-7edbc4269a1e.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069129-98553a25-00e2-4f0f-9b44-dfc4e4f6b6d1.png " width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069131-f7649bb2-255c-4725-a635-799b8b4d815a.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069135-acb69b89-55db-41ac-9846-e2536ef3d955.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069137-1f0abfdb-6608-432e-bd40-c8e1ab86ef8b.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069140-18c6a439-f117-498d-9cdb-ade71cc2c248.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069145-80452f86-afcf-42b5-8423-328cca9e4750.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069154-63a25c1c-b448-44c2-8baf-eb31952c5476.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069156-1b881c6b-5680-4f9a-aef1-2491af50675d.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069161-8759f3d4-8456-43ea-bf54-99a646d5a109.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069167-937aa847-c661-431c-b3dc-5a3c890b31cd.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069170-43d0dce4-6c62-485d-adf4-364c8467c251.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069175-70bc9e50-b833-4a2a-8a3f-c0775dac49c2.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069179-d01f8a0f-4383-4b08-b064-4e6bb006e745.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069184-d423a84c-c9dd-4125-9dc7-397cae21efc9.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069188-fc4deb80-38a2-4c50-9a29-30cee4c8e374.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069193-77a19ee8-b1e2-4c27-9016-3440a1547470.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069196-5f050524-ac08-4831-89f5-9e9e3ce085c1.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069200-4f963171-c790-4f43-8ca3-2e701ad3731c.jpeg" width = "400" /> </div>

docs/zh_CN/introduction/more_demo/index.rst

-介绍
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   cartoon.md
-   logo.md
-   more_demo.md
-   product.md
-   vehicle.md

docs/zh_CN/introduction/more_demo/logo.md

-## 商标图片识别效果图
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096687-5b562e2d-0653-4be6-861d-1936a4440df2.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096698-4b95eb4b-6638-47dc-ae48-7b40744a31ba.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096701-4a4b2bd9-85f2-4d55-be4b-be6ab5e0fb81.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096706-ef4ad024-7284-4cb3-975a-779fd06b96f5.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096710-620b0495-cc83-4501-a104-dfe20afb53d2.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096713-48e629aa-c637-4603-b005-18570fa94d6d.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096715-709957f2-50bb-4edb-a6e4-e7d5601872c7.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096717-a74744cc-4fb8-4e78-b1cb-20409582ca52.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096721-d4af003c-7945-4591-9e47-4e428dc2628c.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096726-460af6ab-8595-4fb4-9960-4c66b18bee1e.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096728-81494000-92b5-40ad-a6a7-606dae3548a3.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096731-2e980977-9ee6-4e29-bdf7-8397820f70e8.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096732-7d425b45-6b04-4984-948d-278da13dd802.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096735-a9c85c14-5965-4529-a235-ce00035bd7ab.jpg " width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096736-3182efc6-ba43-4cde-9397-88a131f4fed8.jpg " width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096737-91e6fa24-1eb5-4aba-9271-5a3722cbe35b.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096740-f440f89b-5f95-493a-b087-00c7cd3481ef.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096747-31b924e3-ffb2-45ab-872e-4ff923ed04f1.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096752-1f98c937-5d83-4c29-b495-01971b5fb258.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096756-a994c7e2-b9e7-40ba-9934-78c10666217b.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096757-879749e0-9e04-4d1e-a07b-6a4322975a84.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096761-5b682ce8-4f83-4fbb-bfb7-df749912aa8b.png " width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096767-e8f701eb-d0e8-4304-b031-e2bff8c199f3.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096778-ec2ad374-b9fc-427e-9e8b-8e5d2afc6394.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096783-9ec5e04d-19e3-463d-ad9d-7a26202bbb9c.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096788-44f04979-18ca-4ba6-b833-7489b344ffff.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096791-6989451e-157c-4101-8b54-7578b05eb7c9.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096796-cc4477cf-016c-4b19-86c3-61824704ecf5.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096798-ba33ee0d-45b8-48ad-a8fa-14cd643a6976.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096805-e29a2ba8-4785-4ca6-9e0d-596fad6ce8dc.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096812-7d8c57a5-fbae-4496-8144-3b40ac74fef0.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096816-50f0ac3d-f2eb-4011-a34e-58e2e215b7b0.jpg " width = "400" /> </div>

docs/zh_CN/introduction/more_demo/more_demo.md

-## 识别效果展示
-- 商品识别
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277277-7b29f596-35f6-4f00-8d2b-0ef0be57a090.jpg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277291-f7d2b2a1-5790-4f5b-a0e6-f5c52d04a69a.jpg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277300-8ce0d5ce-e0ca-46ea-bb9a-74df0df66ae3.jpg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277308-14a097bd-2bcd-41ce-a9e6-5e9cd0bd8b08.jpg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277311-208ae574-a708-46e2-a41e-c639322913b1.jpg" width = "400" /> </div>
-
-[更多效果图](product.md)
-
-
-- 动漫人物识别
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069108-ad54ae1d-610d-4cfa-9cd6-8ee8d280d61d.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069100-7539d292-1bd8-4655-8a6d-d1f2238bd618.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140069080-a821e0b7-8a10-4946-bf05-ff093cc16064.jpeg" width = "400" /> </div>
-
-[更多效果图](cartoon.md)
-
-
-- logo识别
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096687-5b562e2d-0653-4be6-861d-1936a4440df2.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096701-4a4b2bd9-85f2-4d55-be4b-be6ab5e0fb81.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096706-ef4ad024-7284-4cb3-975a-779fd06b96f5.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096713-48e629aa-c637-4603-b005-18570fa94d6d.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096752-1f98c937-5d83-4c29-b495-01971b5fb258.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140096767-e8f701eb-d0e8-4304-b031-e2bff8c199f3.jpeg" width = "400" /> </div>
-
-
-[更多效果图](logo.md)
-
-
-- 车辆识别
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243899-c60f0a51-db9b-438a-9f2d-0d2893c200bb.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243905-7eeb938d-d88f-4540-a667-06e08dcf1f55.jpeg" width = "400" /> </div>
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243911-735a6ec0-a624-4965-b3cd-2b9f52fa8d65.jpeg" width = "400" /> </div>
-
-[更多效果图](vehicle.md)

docs/zh_CN/introduction/more_demo/product.md

-## 商品图片识别效果图
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277277-7b29f596-35f6-4f00-8d2b-0ef0be57a090.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277287-7bdad02a-8e3c-4e04-861c-95a5dae1f3c6.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277291-f7d2b2a1-5790-4f5b-a0e6-f5c52d04a69a.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277294-80aaab94-5109-41be-97f8-3ada73118963.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277296-2a8d7846-cd2e-454e-8b72-46233da09451.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277300-8ce0d5ce-e0ca-46ea-bb9a-74df0df66ae3.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277302-25c973eb-f9aa-42ce-b9e9-66cee738c241.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277303-3d3460da-c6aa-4994-b585-17bc9f3df504.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277306-20cbef71-cc58-4ae1-965b-4806e82988a9.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277308-14a097bd-2bcd-41ce-a9e6-5e9cd0bd8b08.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277309-be092d1c-6513-472c-8b7f-685f4353ae5b.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277311-208ae574-a708-46e2-a41e-c639322913b1.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277314-72901737-5ef5-4a23-820b-1db58c5e6ca0.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277318-aef4080c-24f2-4d92-be3c-45b500b75584.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277320-8046d0df-1256-41ce-a8d6-6d2c1292462c.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277321-e3864473-6a8e-485f-81f2-562b902d6cff.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277324-0aacc27f-699a-437b-bac0-4a20c90b47b1.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277328-8d28f754-8645-4c05-a9a6-0312bbe2f890.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277333-59da1513-e7e5-455c-ab73-7a3162216923.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277335-454c0423-5398-4348-aaab-e2652fd08999.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277338-a7d09c28-1b86-4cf5-bd79-99d51c5b5311.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277343-9c456d21-8018-4cd5-9c0b-cc7c087fac69.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277345-2ef780f1-d7c9-4cf2-a370-f220a052eb71.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277347-baa4b870-7fca-4d4c-8528-fad720270024.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277351-e0691080-ede4-49ae-9075-d36a41cebf25.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277354-509f8f85-f171-44e9-8ca1-4c3cae77b5fb.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277357-39d572b8-60ee-44db-9e0e-2c0ea2be2ed3.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277359-6caf33f6-2a38-48e5-b349-f4dd1ef2566b.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277362-260daa87-1db7-4f89-ba9c-1b32876fd3b6.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277366-14cfd2f9-d044-4288-843e-463a1816163e.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277368-b0e96341-e030-4e4d-8010-6f7c3bc94d2f.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277370-1f26e4e5-9988-4427-a035-44bfd9d472d6.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277372-27e60b60-cd5c-4b05-ae38-2e9524c627f3.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277374-bd292bb2-e1f9-4d5f-aa49-d67ac571d01b.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277377-b0b8cdb9-8196-4598-ae47-b615914bf6bf.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277382-fc89d18a-a57b-4331-adbb-bda3584fb122.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277386-d676467c-9846-4051-8192-b3e089d01cdc.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277390-83f66d3f-c415-47e6-b651-6b51fbe59bbf.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277394-9895d654-3163-4dd9-882c-ac5a893e2ad3.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277396-9e5e3aa3-6d9e-40ab-a325-2edea452156d.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277399-b92e2092-eabd-45c8-bf36-b2e238167892.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277404-285f943a-de70-48b8-9545-53e229b7350d.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277406-0b7ec434-f064-4985-80f3-c00735b3e32d.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277408-4f9b8b19-42c2-4ba4-bf6d-b95ababe0313.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277409-6df0faf7-71b7-4c9a-a875-36ae7ee7129d.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277411-9c2b364a-749d-465e-a85d-29a69e9ff3ef.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277413-c54a462c-dd3b-4ad0-985d-ef0ec1f216ec.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277414-6d922055-cd59-4f84-b5b6-651209d6336a.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277417-78e1322e-4039-4232-b217-1be4f207f804.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277419-181822a3-bae6-4c4f-9959-59e991c2df6c.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277422-76f09d84-cb47-4332-aa88-a12458cd8993.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277424-a72203b5-1a99-4464-a39c-245f7a891f25.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277429-521ac9a6-e4c3-4c74-9c5b-8e8dd6cddf34.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277433-4f9fb9c8-7930-4303-b54e-a6eace347923.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277434-f3aa3565-a2c5-4c1c-ab44-930a8b073b5f.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277437-90cf1cd7-6a62-4ac4-ac85-3aa534e50cee.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277439-54e168bc-9518-429e-9e97-cb9ca5e811c9.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277441-a3c277d7-c889-4556-b74a-400cadf8b771.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277442-22a0cd38-acd8-4b5a-8e59-c4bea852fb79.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277444-ea662034-c17f-47ba-9ea3-694d3cb0c880.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277448-a71f4a0a-c3cc-4432-a803-843b7c65307f.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277449-0b3a2e98-3e09-4bd6-be32-c35f44154e8a.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277452-e36ccc63-8e39-4973-a336-4ace855d25e6.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277454-bddd9527-b189-4771-ab9e-52085db5a44d.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277455-7ea277ba-bc75-48db-9567-40e1acb56f02.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277460-0f5ee4dc-5ece-45d5-8ef9-666f1be41b76.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277461-37cab773-6341-4c91-b1f4-780d530eab3b.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277465-8f53ef9d-0465-4a90-afac-b1dd3c970b72.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277467-655ddabe-cbe0-4d1f-a30e-c2965428e8d7.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277470-4587e905-3fc8-4dad-84ee-0844ba4d2474.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277473-a155944f-efe3-492a-babc-2f3fe700a99b.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277475-c95ab821-f5ae-427a-8721-8991f9c7f29f.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277479-55b59855-2ed6-4526-9481-6b92b25fef97.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277484-556f0e4c-007b-4f6a-b21f-c485f630cbcb.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277486-a39eb069-bc13-415e-b936-ba294216dfac.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277487-80952841-6a76-4fb3-8049-fe15ce8f7cfb.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277491-e892a6a8-6f9a-46c7-83e0-261cfb92d276.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277494-520f483e-654d-4399-9684-1fcd9778b76e.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277496-54b1ada5-e6a6-4654-a8a6-739511cec750.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277500-ff7e2afd-9cd7-484a-bd1e-362226f5197f.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277501-94489261-bea5-4492-bf3e-98cc8aaa7a7f.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277504-567a32bc-a573-4154-a9cd-6acbec923768.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277506-e893d4d5-43ce-4df1-9f08-3cdf6a8c7e2c.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277509-5766629f-bb92-4552-b34a-647e29b9a89b.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277511-8821708b-09f0-4aab-86dd-40ae3794697a.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277515-ed6a0dff-bd91-4233-a9af-e2744df7c7e0.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277519-1883d6a1-9348-4514-8924-dde27dd38704.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277524-b9d8515c-4df2-410a-b4a6-da098cb9da61.jpg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140277526-52a9c666-a799-4921-b371-41d97d7d9242.jpg" width = "400" /> </div>

docs/zh_CN/introduction/more_demo/vehicle.md

-## 车辆图片识别效果图
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243899-c60f0a51-db9b-438a-9f2d-0d2893c200bb.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243904-fdbe2e01-dc7c-449a-8e9e-baea4f85fee4.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243905-7eeb938d-d88f-4540-a667-06e08dcf1f55.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243908-c7f1e3ea-92a7-429b-888c-732b9ec5398f.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243911-735a6ec0-a624-4965-b3cd-2b9f52fa8d65.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243913-baec489a-5463-472b-b5d1-418bcd4eb978.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243916-f50dfcdd-2d5f-48f9-876f-dbc05f4afa30.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243920-7a65ec82-8312-421e-985a-c394f11af28f.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243922-458e6dca-fb80-4baf-951e-9651080dc242.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243926-5df3036b-9ea1-441c-b30a-b4f847df25ab.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243927-7673d94a-fbb0-4a92-a3f3-c879a432a7db.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243928-91082855-c5a7-4a3f-aeea-7a2e51e43183.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243929-88fe7efa-b212-4105-af2f-2248a6cb2877.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243933-49e71d02-8228-40ec-99b2-3ed862bf4ba5.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243935-530fbfa3-0d34-4d9d-bd59-2fde5659f7e5.jpeg" width = "400" /> </div>
-
-<div align="center"> <img src="https://user-images.githubusercontent.com/12560511/140243940-d289fc7d-d343-4aa5-a807-9ce09a241ccd.jpeg" width = "400" /> </div>

docs/zh_CN/make.bat

-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-
-set SOURCEDIR=source
-set BUILDDIR=build
-
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.https://www.sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-
-:end
-popd

docs/zh_CN/models/DLA.md → docs/zh_CN/models/ImageNet1k/DLA.md

@@ -22,7 +22,7 @@ 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   |
@@ -42,4 +42,4 @@ DLA(Deep Layer Aggregation)。 视觉识别需要丰富的表示形式，其范
 | DLA46_c  | 224       | 256               | 1.06                           | 2.08                           | 3.23                           |
 | DLA60    | 224       | 256               | 2.78                           | 5.36                           | 8.29                           |
 | DLA60x_c | 224       | 256               | 1.79                           | 3.68                           | 5.19                           |
-| DLA60x   | 224       | 256               | 5.98                           | 9.24                           | 12.52                          |
+| DLA60x   | 224       | 256               | 5.98                           | 9.24                           | 12.52                          |
\ No newline at end of file

docs/zh_CN/models/DPN_DenseNet.md → docs/zh_CN/models/ImageNet1k/DPN_DenseNet.md

@@ -15,13 +15,13 @@ DPN 的全称是 Dual Path Networks，即双通道网络。该网络是由 Dense
 
 该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.DPN.flops.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.DPN.flops.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.DPN.params.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.DPN.params.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.DPN.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.DPN.png)
 
-![](../../images/models/T4_benchmark/t4.fp16.bs4.DPN.png)
+![](../../../images/models/T4_benchmark/t4.fp16.bs4.DPN.png)
 
 目前 PaddleClas 开源的这两类模型的预训练模型一共有 10 个，其指标如上图所示，可以看到，在相同的 FLOPS 和参数量下，相比 DenseNet，DPN 拥有更高的精度。但是由于 DPN 有更多的分支，所以其推理速度要慢于 DenseNet。由于 DenseNet264 的网络层数最深，所以该网络是 DenseNet 系列模型中参数量最大的网络，DenseNet161 的网络的宽度最大，导致其是该系列中网络中计算量最大、精度最高的网络。从推理速度来看，计算量大且精度高的的 DenseNet161 比 DenseNet264 具有更快的速度，所以其比 DenseNet264 具有更大的优势。
 

docs/zh_CN/models/EfficientNet_and_ResNeXt101_wsl.md → docs/zh_CN/models/ImageNet1k/EfficientNet_and_ResNeXt101_wsl.md

@@ -16,13 +16,13 @@ ResNeXt 是 facebook 于 2016 年提出的一种对 ResNet 的改进版网络。
 
 该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.EfficientNet.flops.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.EfficientNet.flops.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.EfficientNet.params.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.EfficientNet.params.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs1.EfficientNet.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs1.EfficientNet.png)
 
-![](../../images/models/T4_benchmark/t4.fp16.bs1.EfficientNet.png)
+![](../../../images/models/T4_benchmark/t4.fp16.bs1.EfficientNet.png)
 
 目前 PaddleClas 开源的这两类模型的预训练模型一共有 14 个。从上图中可以看出 EfficientNet 系列网络优势非常明显，ResNeXt101_wsl 系列模型由于用到了更多的数据，最终的精度也更高。EfficientNet_B0_Small 是去掉了 SE_block 的 EfficientNet_B0，其具有更快的推理速度。
 

docs/zh_CN/models/HRNet.md → docs/zh_CN/models/ImageNet1k/HRNet.md

@@ -14,13 +14,13 @@ HRNet 是 2019 年由微软亚洲研究院提出的一种全新的神经网络
 
 该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.HRNet.flops.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.HRNet.flops.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.HRNet.params.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.HRNet.params.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.HRNet.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.HRNet.png)
 
-![](../../images/models/T4_benchmark/t4.fp16.bs4.HRNet.png)
+![](../../../images/models/T4_benchmark/t4.fp16.bs4.HRNet.png)
 
 目前 PaddleClas 开源的这类模型的预训练模型一共有 7 个，其指标如图所示，其中 HRNet_W48_C 指标精度异常的原因可能是因为网络训练的正常波动。
 

docs/zh_CN/models/HarDNet.md → docs/zh_CN/models/ImageNet1k/HarDNet.md

@@ -32,4 +32,3 @@ HarDNet（Harmonic DenseNet）是 2019 年由国立清华大学提出的一种
 | HarDNet85    | 224       | 256               | 6.24                           | 14.85                          | 20.57                          |
 | HarDNet39_ds | 224       | 256               | 1.40                           | 2.30                           | 3.33                           |
 | HarDNet68_ds | 224       | 256               | 2.26                           | 3.34                           | 5.06                           |
-

docs/zh_CN/models/Inception.md → docs/zh_CN/models/ImageNet1k/Inception.md

@@ -22,13 +22,13 @@ InceptionV4 是 2016 年由 Google 设计的新的神经网络，当时残差结
 
 该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.Inception.flops.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.Inception.flops.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.Inception.params.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.Inception.params.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.Inception.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.Inception.png)
 
-![](../../images/models/T4_benchmark/t4.fp16.bs4.Inception.png)
+![](../../../images/models/T4_benchmark/t4.fp16.bs4.Inception.png)
 
 上图反映了 Xception 系列和 InceptionV4 的精度和其他指标的关系。其中 Xception_deeplab 与论文结构保持一致，Xception 是 PaddleClas 的改进模型，在预测速度基本不变的情况下，精度提升约 0.6%。关于该改进模型的详细介绍正在持续更新中，敬请期待。
 

docs/zh_CN/models/Mobile.md → docs/zh_CN/models/ImageNet1k/Mobile.md

@@ -21,13 +21,13 @@ MobileNetV3 是 Google 于 2019 年提出的一种基于 NAS 的新的轻量级
 
 GhostNet 是华为于 2020 年提出的一种全新的轻量化网络结构，通过引入 ghost module，大大减缓了传统深度网络中特征的冗余计算问题，使得网络的参数量和计算量大大降低。
 
-![](../../images/models/mobile_arm_top1.png)
+![](../../../images/models/mobile_arm_top1.png)
 
-![](../../images/models/mobile_arm_storage.png)
+![](../../../images/models/mobile_arm_storage.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.mobile_trt.flops.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.mobile_trt.flops.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.mobile_trt.params.png)
+![](../../../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 网络结构。

docs/zh_CN/models/PP-HGNet.md → docs/zh_CN/models/ImageNet1k/PP-HGNet.md

@@ -44,11 +44,11 @@ PP-HGNet 作者针对 GPU 设备，对目前 GPU 友好的网络做了分析和
 
 PP-HGNet 骨干网络的整体结构如下：
 
-![](../../images/PP-HGNet/PP-HGNet.png)
+![](../../../images/PP-HGNet/PP-HGNet.png)
 
 其中，PP-HGNet是由多个HG-Block组成，HG-Block的细节如下：
 
-![](../../images/PP-HGNet/PP-HGNet-block.png)
+![](../../../images/PP-HGNet/PP-HGNet-block.png)
 
 <a name='1.3'></a>
 
@@ -65,8 +65,8 @@ PP-HGNet 目前提供的模型的精度、速度指标及预训练权重链接
 | PPHGNet_base_ssld | 85.00| 97.35 | 5.97   | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPHGNet_base_ssld_pretrained.pdparams) | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPHGNet_base_ssld_infer.tar) |
 
 **备注：**
-    
-* 1. `_ssld` 表示使用 `SSLD 蒸馏`后的模型。关于 `SSLD蒸馏` 的内容，详情 [SSLD 蒸馏](../advanced_tutorials/knowledge_distillation.md)。
+
+* 1. `_ssld` 表示使用 `SSLD 蒸馏`后的模型。关于 `SSLD蒸馏` 的内容，详情 [SSLD 蒸馏](../../training/advanced/knowledge_distillation.md)。
 * 2. PP-HGNet 更多模型指标及权重，敬请期待。
 
 PP-HGNet 与其他模型的比较如下，其中测试机器为 NVIDIA® Tesla® V100，开启 TensorRT 引擎，精度类型为 FP32。在相同速度下，PP-HGNet 精度均超越了其他 SOTA CNN 模型，在与 SwinTransformer 模型的比较中，在更高精度的同时，速度快 2 倍以上。
@@ -89,8 +89,8 @@ PP-HGNet 与其他模型的比较如下，其中测试机器为 NVIDIA® Tesla®
 | ResNeXt101_32x48d_wsl    | 85.37      | 97.69       | 55.07       |
 | SwinTransformer_base     | 85.2       | 97.5        | 13.53       |  
 | <b>PPHGNet_base_ssld<b> | <b>85.00<b>| <b>97.35<b> | <b>5.97<b>   |
-    
-    
+
+
 <a name="2"></a>
 
 ## 2. 模型快速体验
@@ -123,31 +123,31 @@ python3 -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple
 pip3 install paddleclas
 ```
 
-<a name="2.3"></a> 
-    
+<a name="2.3"></a>
+
 ### 2.3 预测
 
 * 在命令行中使用 PPHGNet_small 的权重快速预测
-    
+
 ```bash
 paddleclas --model_name=PPHGNet_small  --infer_imgs="docs/images/inference_deployment/whl_demo.jpg"
 ```
-    
+
 结果如下：
 ```
 >>> result
 class_ids: [8, 7, 86, 82, 81], scores: [0.71479, 0.08682, 0.00806, 0.0023, 0.00121], label_names: ['hen', 'cock', 'partridge', 'ruffed grouse, partridge, Bonasa umbellus', 'ptarmigan'], filename: docs/images/inference_deployment/whl_demo.jpg
 Predict complete!
 ```  
-    
-**备注**： 更换 PPHGNet 的其他 scale 的模型时，只需替换 `model_name`，如将此时的模型改为 `PPHGNet_tiny` 时，只需要将 `--model_name=PPHGNet_small` 改为 `--model_name=PPHGNet_tiny` 即可。   
 
-    
+**备注**： 更换 PPHGNet 的其他 scale 的模型时，只需替换 `model_name`，如将此时的模型改为 `PPHGNet_tiny` 时，只需要将 `--model_name=PPHGNet_small` 改为 `--model_name=PPHGNet_tiny` 即可。  
+
+
 * 在 Python 代码中预测
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='PPHGNet_small')
-infer_imgs = 'docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs = 'docs/images/deployment/whl_demo.jpg'
 result = clas.predict(infer_imgs)
 print(next(result))
 ```
@@ -159,19 +159,19 @@ print(next(result))
 >>> result
 [{'class_ids': [8, 7, 86, 82, 81], 'scores': [0.71479, 0.08682, 0.00806, 0.0023, 0.00121], 'label_names': ['hen', 'cock', 'partridge', 'ruffed grouse, partridge, Bonasa umbellus', 'ptarmigan'], 'filename': 'docs/images/inference_deployment/whl_demo.jpg'}]
 ```
-    
-    
-<a name="3"></a> 
-    
+
+
+<a name="3"></a>
+
 ## 3. 模型训练、评估和预测
-    
+
 <a name="3.1"></a>  
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档[环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档[环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
-<a name="3.2"></a> 
+<a name="3.2"></a>
 
 ### 3.2 数据准备
 
@@ -200,15 +200,15 @@ cd path_to_PaddleClas
 ```
 
 其中 `train/` 和 `val/` 分别为训练集和验证集。`train_list.txt` 和 `val_list.txt` 分别为训练集和验证集的标签文件。
-    
-**备注：** 
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+**备注：**
+
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
 
-<a name="3.3"></a> 
+<a name="3.3"></a>
 
-### 3.3 模型训练 
+### 3.3 模型训练
 
 
 在 `ppcls/configs/ImageNet/PPHGNet/PPHGNet_small.yaml` 中提供了 PPHGNet_small 训练配置，可以通过如下脚本启动训练：
@@ -218,11 +218,11 @@ export CUDA_VISIBLE_DEVICES=0,1,2,3
 python3 -m paddle.distributed.launch \
     --gpus="0,1,2,3" \
     tools/train.py \
-        -c ppcls/configs/ImageNet/PPHGNet/PPHGNet_small.yaml 
+        -c ppcls/configs/ImageNet/PPHGNet/PPHGNet_small.yaml
 ```
 
 
-**备注：** 
+**备注：**
 
 * 当前精度最佳的模型会保存在 `output/PPHGNet_small/best_model.pdparams`
 
@@ -249,7 +249,7 @@ python3 tools/eval.py \
 ```python
 python3 tools/infer.py \
     -c ppcls/configs/ImageNet/PPHGNet/PPHGNet_small.yaml \
-    -o Global.pretrained_model=output/PPHGNet_small/best_model 
+    -o Global.pretrained_model=output/PPHGNet_small/best_model
 ```
 
 输出结果如下：
@@ -258,30 +258,30 @@ python3 tools/infer.py \
 [{'class_ids': [8, 7, 86, 82, 81], 'scores': [0.71479, 0.08682, 0.00806, 0.0023, 0.00121], 'file_name': 'docs/images/inference_deployment/whl_demo.jpg', 'label_names': ['hen', 'cock', 'partridge', 'ruffed grouse, partridge, Bonasa umbellus', 'ptarmigan']}]
 ```
 
-**备注：** 
+**备注：**
 
 * 这里`-o Global.pretrained_model="output/PPHGNet_small/best_model"` 指定了当前最佳权重所在的路径，如果指定其他权重，只需替换对应的路径即可。
-    
+
 * 默认是对 `docs/images/inference_deployment/whl_demo.jpg` 进行预测，此处也可以通过增加字段 `-o Infer.infer_imgs=xxx` 对其他图片预测。
-    
+
 * 默认输出的是 Top-5 的值，如果希望输出 Top-k 的值，可以指定`-o Infer.PostProcess.topk=k`，其中，`k` 为您指定的值。
 
 
-    
+
 <a name="4"></a>
 
 ## 4. 模型推理部署
 
-<a name="4.1"></a> 
+<a name="4.1"></a>
 
 ### 4.1 推理模型准备
 
 Paddle Inference 是飞桨的原生推理库， 作用于服务器端和云端，提供高性能的推理能力。相比于直接基于预训练模型进行预测，Paddle Inference可使用MKLDNN、CUDNN、TensorRT 进行预测加速，从而实现更优的推理性能。更多关于Paddle Inference推理引擎的介绍，可以参考[Paddle Inference官网教程](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/infer/inference/inference_cn.html)。
-    
+
 当使用 Paddle Inference 推理时，加载的模型类型为 inference 模型。本案例提供了两种获得 inference 模型的方法，如果希望得到和文档相同的结果，请选择[直接下载 inference 模型](#6.1.2)的方式。
 
-    
-<a name="4.1.1"></a> 
+
+<a name="4.1.1"></a>
 
 ### 4.1.1 基于训练得到的权重导出 inference 模型
 
@@ -303,7 +303,7 @@ python3 tools/export_model.py \
 ```
 
 
-<a name="4.1.2"></a> 
+<a name="4.1.2"></a>
 
 ### 4.1.2 直接下载 inference 模型
 
@@ -324,7 +324,7 @@ wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPHGNet
 │   └── inference.pdmodel
 ```
 
-<a name="4.2"></a> 
+<a name="4.2"></a>
 
 ### 4.2 基于 Python 预测引擎推理
 
@@ -375,33 +375,32 @@ ILSVRC2012_val_00030010.jpeg:	class id(s): [80, 83, 136, 23, 93], score(s): [0.8
 ```
 
 
-<a name="4.3"></a> 
+<a name="4.3"></a>
 
 ### 4.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
-<a name="4.4"></a> 
+<a name="4.4"></a>
 
 ### 4.4 服务化部署
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
-    
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
 
-<a name="4.5"></a> 
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
+
+<a name="4.5"></a>
 
 ### 4.5 端侧部署
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
-    
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
 
-<a name="4.6"></a> 
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
+
+<a name="4.6"></a>
 
 ### 4.6 Paddle2ONNX 模型转换与预测
-    
-Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/models/PP-LCNet.md → docs/zh_CN/models/ImageNet1k/PP-LCNet.md

@@ -37,8 +37,8 @@
   - [4.5 端侧部署](#4.5)
   - [4.6 Paddle2ONNX 模型转换与预测](#4.6)
 - [5. 引用](#5)
-  
-  
+
+
 
 <a name="1"></a>
 
@@ -49,14 +49,14 @@
 在计算机视觉领域中，骨干网络的好坏直接影响到整个视觉任务的结果。在之前的一些工作中，相关的研究者普遍将 FLOPs 或者 Params 作为优化目的，但是在工业界真实落地的场景中，推理速度才是考量模型好坏的重要指标，然而，推理速度和准确性很难兼得。考虑到工业界有很多基于 Intel CPU 的应用，所以我们本次的工作旨在使骨干网络更好的适应 Intel CPU，从而得到一个速度更快、准确率更高的轻量级骨干网络，与此同时，目标检测、语义分割等下游视觉任务的性能也同样得到提升。
 
 近年来，有很多轻量级的骨干网络问世，尤其最近两年，各种 NAS 搜索出的网络层出不穷，这些网络要么主打 FLOPs 或者 Params 上的优势，要么主打 ARM 设备上的推理速度的优势，很少有网络专门针对 Intel CPU 做特定的优化，导致这些网络在 Intel CPU 端的推理速度并不是很完美。基于此，我们针对 Intel CPU 设备以及其加速库 MKLDNN 设计了特定的骨干网络 PP-LCNet，比起其他的轻量级的 SOTA 模型，该骨干网络可以在不增加推理时间的情况下，进一步提升模型的性能，最终大幅度超越现有的 SOTA 模型。与其他模型的对比图如下。
-![](../../images/PP-LCNet/PP-LCNet-Acc.png)
+![](../../../images/PP-LCNet/PP-LCNet-Acc.png)
 
 <a name="1.2"></a>
 
 ### 1.2 模型细节
 
 网络结构整体如下图所示。
-![](../../images/PP-LCNet/PP-LCNet.png)
+![](../../../images/PP-LCNet/PP-LCNet.png)
 我们经过大量的实验发现，在基于 Intel CPU 设备上，尤其当启用 MKLDNN 加速库后，很多看似不太耗时的操作反而会增加延时，比如 elementwise-add 操作、split-concat 结构等。所以最终我们选用了结构尽可能精简、速度尽可能快的 block 组成我们的 BaseNet（类似 MobileNetV1）。基于 BaseNet，我们通过实验，总结了四条几乎不增加延时但是可以提升模型精度的方法，融合这四条策略，我们组合成了 PP-LCNet。下面对这四条策略一一介绍：
 
 <a name="1.2.1"></a>
@@ -83,7 +83,7 @@ SE 模块是 SENet 提出的一种通道注意力机制，可以有效提升模
 最终，PP-LCNet 中的 SE 模块的位置选用了表格中第三行的方案。
 
 <a name="1.2.3"></a>
-    
+
 #### 1.2.3 合适的位置添加更大的卷积核
 
 在 MixNet 的论文中，作者分析了卷积核大小对模型性能的影响，结论是在一定范围内大的卷积核可以提升模型的性能，但是超过这个范围会有损模型的性能，所以作者组合了一种 split-concat 范式的 MixConv，这种组合虽然可以提升模型的性能，但是不利于推理。我们通过实验总结了一些更大的卷积核在不同位置的作用，类似 SE 模块的位置，更大的卷积核在网络的中后部作用更明显，下表展示了 5x5 卷积核的位置对精度的影响：
@@ -96,9 +96,9 @@ SE 模块是 SENet 提出的一种通道注意力机制，可以有效提升模
 
 
 实验表明，更大的卷积核放在网络的中后部即可达到放在所有位置的精度，与此同时，获得更快的推理速度。PP-LCNet 最终选用了表格中第三行的方案。
-    
+
 <a name="1.2.4"></a>
-    
+
 #### 1.2.4 GAP 后使用更大的 1x1 卷积层
 
 在 GoogLeNet 之后，GAP（Global-Average-Pooling）后往往直接接分类层，但是在轻量级网络中，这样会导致 GAP 后提取的特征没有得到进一步的融合和加工。如果在此后使用一个更大的 1x1 卷积层（等同于 FC 层），GAP 后的特征便不会直接经过分类层，而是先进行了融合，并将融合的特征进行分类。这样可以在不影响模型推理速度的同时大大提升准确率。
@@ -113,17 +113,17 @@ 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="1.3"></a>
-    
+
 ### 1.3 实验结果
 
 <a name="1.3.1"></a>
-    
+
 #### 1.3.1 图像分类
 
 图像分类我们选用了 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) | 预训练模型下载地址 | inference模型下载地址 |
-|:--:|:--:|:--:|:--:|:--:|:--:|:--:|:--:| 
+|:--:|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
 | PPLCNet_x0_25  | 1.5 | 18  | 51.86 | 75.65 | 1.74 | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x0_25_pretrained.pdparams) | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPLCNet_x0_25_infer.tar) |
 | PPLCNet_x0_35  | 1.6 | 29  | 58.09 | 80.83 | 1.92 | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x0_35_pretrained.pdparams) | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPLCNet_x0_35_infer.tar) |
 | PPLCNet_x0_5   | 1.9 | 47  | 63.14 | 84.66 | 2.05 | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x0_5_pretrained.pdparams) | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPLCNet_x0_5_infer.tar) |
@@ -136,7 +136,7 @@ BaseNet 经过以上四个方面的改进，得到了 PP-LCNet。下表进一步
 | PPLCNet_x1_0_ssld | 3.0 | 161 | 74.39 | 92.09 | 2.46 | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x1_0_ssld_pretrained.pdparams) | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPLCNet_x1_0_ssld_infer.tar) |
 | PPLCNet_x2_5_ssld | 9.0 | 906 | 80.82 | 95.33 | 5.39 | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/PPLCNet_x2_5_ssld_pretrained.pdparams) | [下载链接](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPLCNet_x2_5_ssld_infer.tar) |
 
-其中 `_ssld` 表示使用 `SSLD 蒸馏`后的模型。关于 `SSLD蒸馏` 的内容，详情 [SSLD 蒸馏](../advanced_tutorials/knowledge_distillation.md)。
+其中 `_ssld` 表示使用 `SSLD 蒸馏`后的模型。关于 `SSLD蒸馏` 的内容，详情 [SSLD 蒸馏](../../training/advanced/knowledge_distillation.md)。
 
 与其他轻量级网络的性能对比：
 
@@ -156,7 +156,7 @@ BaseNet 经过以上四个方面的改进，得到了 PP-LCNet。下表进一步
 | <b>PPLCNet_x1_0<b>     |<b> 3.0<b> | <b>161<b> | <b>71.32<b> | <b>90.03<b> | <b>2.46<b> |
 
 <a name="1.3.2"></a>
-    
+
 #### 1.3.2 目标检测
 
 目标检测的方法我们选用了百度自研的 PicoDet，该方法主打轻量级目标检测场景，下表展示了在 COCO 数据集上、backbone 选用 PP-LCNet 与 MobileNetV3 的结果的比较，无论在精度还是速度上，PP-LCNet 的优势都非常明显。
@@ -169,7 +169,7 @@ MobileNetV3_large_x0_75 | 25.8 | 11.1 |
 <b>PPLCNet_x1_0<b> | <b>26.9<b> | <b>7.9<b> |
 
 <a name="1.3.3"></a>
-    
+
 #### 1.3.3 语义分割
 
 语义分割的方法我们选用了 DeeplabV3+，下表展示了在 Cityscapes 数据集上、backbone 选用 PP-LCNet 与 MobileNetV3 的比较，在精度和速度方面，PP-LCNet 的优势同样明显。
@@ -186,8 +186,8 @@ MobileNetV3_large_x0_75 | 64.53 | 151 |
 ## 1.4 Benchmark
 
 <a name="1.4.1"></a>
-    
-#### 1.4.1 基于 Intel Xeon Gold 6148 的预测速度    
+
+#### 1.4.1 基于 Intel Xeon Gold 6148 的预测速度  
 
 | Model | Latency(ms)<br/>bs=1, thread=10 |
 |:--:|:--:|
@@ -199,11 +199,11 @@ MobileNetV3_large_x0_75 | 64.53 | 151 |
 | PPLCNet_x1_5   | 3.19 |
 | PPLCNet_x2_0   | 4.27 |
 | PPLCNet_x2_5   | 5.39 |
-    
+
 **备注：** 精度类型为 FP32，推理过程使用 MKLDNN。
 
 <a name="1.4.2"></a>
-    
+
 #### 1.4.2 基于 V100 GPU 的预测速度
 
 | Models        | Latency(ms)<br>bs=1 | Latency(ms)<br/>bs=4 | Latency(ms)<br/>bs=8 |
@@ -215,7 +215,7 @@ MobileNetV3_large_x0_75 | 64.53 | 151 |
 | PPLCNet_x1_0  | 0.73                         | 1.64                             | 2.53                           |
 | PPLCNet_x1_5  | 0.82                         | 2.06                             | 3.12                           |
 | PPLCNet_x2_0  | 0.94                         | 2.58                             | 4.08                           |
-    
+
 **备注：** 精度类型为 FP32，推理过程使用 TensorRT。
 
 <a name="1.4.3"></a>
@@ -232,15 +232,15 @@ MobileNetV3_large_x0_75 | 64.53 | 151 |
 | PPLCNet_x1_5  | 20.55                            | 12.26                             | 7.54                              |
 | PPLCNet_x2_0  | 33.79                            | 20.17                             | 12.10                             |
 | PPLCNet_x2_5  | 49.89                            | 29.60                             | 17.82                             |
-    
+
 **备注：** 精度类型为 FP32。
 
-<a name="2"></a>   
-    
+<a name="2"></a>  
+
 ## 2. 模型快速体验
 
-<a name="2.1"></a>   
-    
+<a name="2.1"></a>  
+
 ### 2.1 安装 paddlepaddle
 
 - 您的机器安装的是 CUDA9 或 CUDA10，请运行以下命令安装
@@ -266,32 +266,32 @@ python3 -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple
 ```  
 pip3 install paddleclas
 ```
-    
-<a name="2.3"></a> 
-    
+
+<a name="2.3"></a>
+
 ### 2.3 预测
 
 * 在命令行中使用 PPLCNet_x1_0 的权重快速预测
-    
+
 ```bash
 paddleclas --model_name=PPLCNet_x1_0  --infer_imgs="docs/images/inference_deployment/whl_demo.jpg"
 ```
-    
+
 结果如下：
 ```
 >>> result
 class_ids: [8, 7, 86, 81, 85], scores: [0.91347, 0.03779, 0.0036, 0.00117, 0.00112], label_names: ['hen', 'cock', 'partridge', 'ptarmigan', 'quail'], filename: docs/images/inference_deployment/whl_demo.jpg
 Predict complete!
-```   
-    
-**备注**： 更换 PPLCNet 的其他 scale 的模型时，只需替换 `model_name`，如将此时的模型改为 `PPLCNet_x2_0` 时，只需要将 `--model_name=PPLCNet_x1_0` 改为 `--model_name=PPLCNet_x2_0` 即可。   
+```  
+
+**备注**： 更换 PPLCNet 的其他 scale 的模型时，只需替换 `model_name`，如将此时的模型改为 `PPLCNet_x2_0` 时，只需要将 `--model_name=PPLCNet_x1_0` 改为 `--model_name=PPLCNet_x2_0` 即可。  
+
 
-    
 * 在 Python 代码中预测
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='PPLCNet_x1_0')
-infer_imgs='docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs='docs/images/deployment/whl_demo.jpg'
 result=clas.predict(infer_imgs)
 print(next(result))
 ```
@@ -303,18 +303,18 @@ print(next(result))
 >>> result
 [{'class_ids': [8, 7, 86, 81, 85], 'scores': [0.91347, 0.03779, 0.0036, 0.00117, 0.00112], 'label_names': ['hen', 'cock', 'partridge', 'ptarmigan', 'quail'], 'filename': 'docs/images/inference_deployment/whl_demo.jpg'}]
 ```
-        
-<a name="3"></a> 
-    
+
+<a name="3"></a>
+
 ## 3. 模型训练、评估和预测
-    
+
 <a name="3.1"></a>  
 
 ### 3.1 环境配置
 
-* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../../installation.md) 配置 PaddleClas 运行环境。
 
-<a name="3.2"></a> 
+<a name="3.2"></a>
 
 ### 3.2 数据准备
 
@@ -343,15 +343,15 @@ cd path_to_PaddleClas
 ```
 
 其中 `train/` 和 `val/` 分别为训练集和验证集。`train_list.txt` 和 `val_list.txt` 分别为训练集和验证集的标签文件。
-    
-**备注：** 
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+**备注：**
 
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
-<a name="3.3"></a> 
 
-### 3.3 模型训练 
+<a name="3.3"></a>
+
+### 3.3 模型训练
 
 
 在 `ppcls/configs/ImageNet/PPLCNet/PPLCNet_x1_0.yaml` 中提供了 PPLCNet_x1_0 训练配置，可以通过如下脚本启动训练：
@@ -361,11 +361,11 @@ export CUDA_VISIBLE_DEVICES=0,1,2,3
 python3 -m paddle.distributed.launch \
     --gpus="0,1,2,3" \
     tools/train.py \
-        -c ppcls/configs/ImageNet/PPLCNet/PPLCNet_x1_0.yaml 
+        -c ppcls/configs/ImageNet/PPLCNet/PPLCNet_x1_0.yaml
 ```
 
 
-**备注：** 
+**备注：**
 
 * 当前精度最佳的模型会保存在 `output/PPLCNet_x1_0/best_model.pdparams`
 
@@ -392,7 +392,7 @@ python3 tools/eval.py \
 ```python
 python3 tools/infer.py \
     -c ppcls/configs/ImageNet/PPLCNet/PPLCNet_x1_0.yaml \
-    -o Global.pretrained_model=output/PPLCNet_x1_0/best_model 
+    -o Global.pretrained_model=output/PPLCNet_x1_0/best_model
 ```
 
 输出结果如下：
@@ -401,30 +401,30 @@ python3 tools/infer.py \
 [{'class_ids': [8, 7, 86, 81, 85], 'scores': [0.91347, 0.03779, 0.0036, 0.00117, 0.00112], 'file_name': 'docs/images/inference_deployment/whl_demo.jpg', 'label_names': ['hen', 'cock', 'partridge', 'ptarmigan', 'quail']}]
 ```
 
-**备注：** 
+**备注：**
 
 * 这里`-o Global.pretrained_model="output/PPLCNet_x1_0/best_model"` 指定了当前最佳权重所在的路径，如果指定其他权重，只需替换对应的路径即可。
-    
+
 * 默认是对 `docs/images/inference_deployment/whl_demo.jpg` 进行预测，此处也可以通过增加字段 `-o Infer.infer_imgs=xxx` 对其他图片预测。
-    
+
 * 默认输出的是 Top-5 的值，如果希望输出 Top-k 的值，可以指定`-o Infer.PostProcess.topk=k`，其中，`k` 为您指定的值。
 
 
-    
+
 <a name="4"></a>
 
 ## 4. 模型推理部署
 
-<a name="4.1"></a> 
+<a name="4.1"></a>
 
 ### 4.1 推理模型准备
 
 Paddle Inference 是飞桨的原生推理库， 作用于服务器端和云端，提供高性能的推理能力。相比于直接基于预训练模型进行预测，Paddle Inference可使用MKLDNN、CUDNN、TensorRT 进行预测加速，从而实现更优的推理性能。更多关于Paddle Inference推理引擎的介绍，可以参考[Paddle Inference官网教程](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/infer/inference/inference_cn.html)。
-    
+
 当使用 Paddle Inference 推理时，加载的模型类型为 inference 模型。本案例提供了两种获得 inference 模型的方法，如果希望得到和文档相同的结果，请选择[直接下载 inference 模型](#6.1.2)的方式。
 
-    
-<a name="4.1.1"></a> 
+
+<a name="4.1.1"></a>
 
 ### 4.1.1 基于训练得到的权重导出 inference 模型
 
@@ -446,7 +446,7 @@ python3 tools/export_model.py \
 ```
 
 
-<a name="4.1.2"></a> 
+<a name="4.1.2"></a>
 
 ### 4.1.2 直接下载 inference 模型
 
@@ -467,7 +467,7 @@ wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/PPLCNet
 │   └── inference.pdmodel
 ```
 
-<a name="4.2"></a> 
+<a name="4.2"></a>
 
 ### 4.2 基于 Python 预测引擎推理
 
@@ -518,37 +518,37 @@ ILSVRC2012_val_00030010.jpeg:	class id(s): [80, 23, 93, 81, 99], score(s): [0.87
 ```
 
 
-<a name="4.3"></a> 
+<a name="4.3"></a>
 
 ### 4.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
-<a name="4.4"></a> 
+<a name="4.4"></a>
 
 ### 4.4 服务化部署
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
-    
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
 
-<a name="4.5"></a> 
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
+
+<a name="4.5"></a>
 
 ### 4.5 端侧部署
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
-    
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
 
-<a name="4.6"></a> 
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
+
+<a name="4.6"></a>
 
 ### 4.6 Paddle2ONNX 模型转换与预测
-    
+
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
 PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](@shuilong)来完成相应的部署工作。
 
-  
+
 <a name="5"></a>
 
 ## 5. 引用
@@ -556,7 +556,7 @@ PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模
 如果你的论文用到了 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},

docs/zh_CN/models/PP-LCNetV2.md → docs/zh_CN/models/ImageNet1k/PP-LCNetV2.md

@@ -43,13 +43,13 @@
 
 ### 1.1 模型简介
 
-骨干网络对计算机视觉下游任务的影响不言而喻，不仅对下游模型的性能影响很大，而且模型效率也极大地受此影响，但现有的大多骨干网络在真实应用中的效率并不理想，特别是缺乏针对 Intel CPU 平台所优化的骨干网络，我们测试了现有的主流轻量级模型，发现在 Intel CPU 平台上的效率并不理想，然而目前 Intel CPU 平台在工业界仍有大量使用场景，因此我们提出了 PP-LCNet 系列模型，PP-LCNetV2 是在 [PP-LCNetV1](./PP-LCNet.md) 基础上所改进的。
+骨干网络对计算机视觉下游任务的影响不言而喻，不仅对下游模型的性能影响很大，而且模型效率也极大地受此影响，但现有的大多骨干网络在真实应用中的效率并不理想，特别是缺乏针对 Intel CPU 平台所优化的骨干网络，我们测试了现有的主流轻量级模型，发现在 Intel CPU 平台上的效率并不理想，然而目前 Intel CPU 平台在工业界仍有大量使用场景，因此我们提出了 PP-LCNet 系列模型，PP-LCNetV2 是在 [PP-LCNetV1](PP-LCNet.md) 基础上所改进的。
 
 <a name="1.2"></a>
 
 ## 1.2 模型细节
 
-![](../../images/PP-LCNetV2/net.png)
+![](../../../images/PP-LCNetV2/net.png)
 
 PP-LCNetV2 模型的网络整体结构如上图所示。PP-LCNetV2 模型是在 PP-LCNetV1 的基础上优化而来，主要使用重参数化策略组合了不同大小卷积核的深度卷积，并优化了点卷积、Shortcut等。
 
@@ -59,7 +59,7 @@ PP-LCNetV2 模型的网络整体结构如上图所示。PP-LCNetV2 模型是在
 
 卷积核的大小决定了卷积层感受野的大小，通过组合使用不同大小的卷积核，能够获取不同尺度的特征，因此 PPLCNetV2 在 Stage4、Stage5 中，在同一层组合使用 kernel size 分别为 5、3、1 的 DW 卷积，同时为了避免对模型效率的影响，使用重参数化（Re parameterization，Rep）策略对同层的 DW 卷积进行融合，如下图所示。
 
-![](../../images/PP-LCNetV2/rep.png)
+![](../../../images/PP-LCNetV2/rep.png)
 
 <a name="1.2.2"></a>
 
@@ -67,7 +67,7 @@ PP-LCNetV2 模型的网络整体结构如上图所示。PP-LCNetV2 模型是在
 
 深度可分离卷积通常由一层 DW 卷积和一层 PW 卷积组成，用以替换标准卷积，为了使深度可分离卷积具有更强的拟合能力，我们尝试使用两层 PW 卷积，同时为了控制模型效率不受影响，两层 PW 卷积设置为：第一个在通道维度对特征图压缩，第二个再通过放大还原特征图通道，如下图所示。通过实验发现，该策略能够显著提高模型性能，同时为了平衡对模型效率带来的影响，PPLCNetV2 仅在 Stage4 中使用了该策略。
 
-![](../../images/PP-LCNetV2/split_pw.png)
+![](../../../images/PP-LCNetV2/split_pw.png)
 
 <a name="1.2.3"></a>
 
@@ -75,7 +75,7 @@ PP-LCNetV2 模型的网络整体结构如上图所示。PP-LCNetV2 模型是在
 
 残差结构（residual）自提出以来，被诸多模型广泛使用，但在轻量级卷积神经网络中，由于残差结构所带来的元素级（element-wise）加法操作，会对模型的速度造成影响，我们在 PP-LCNetV2 中，以 Stage 为单位实验了残差结构对模型的影响，发现残差结构的使用并非一定会带来性能的提高，因此 PPLCNetV2 仅在最后一个 Stage 中的使用了残差结构：在 Block 中增加 Shortcut，如下图所示。
 
-![](../../images/PP-LCNetV2/shortcut.png)
+![](../../../images/PP-LCNetV2/shortcut.png)
 
 <a name="1.2.4"></a>
 
@@ -102,7 +102,7 @@ PPLCNetV2 目前提供的模型的精度、速度指标及预训练权重链接
 
 **备注：**
 
-* 1. `_ssld` 表示使用 `SSLD 蒸馏`后的模型。关于 `SSLD蒸馏` 的内容，详情 [SSLD 蒸馏](../advanced_tutorials/knowledge_distillation.md)。
+* 1. `_ssld` 表示使用 `SSLD 蒸馏`后的模型。关于 `SSLD蒸馏` 的内容，详情 [SSLD 蒸馏](../../training/advanced/knowledge_distillation.md)。
 * 2. PP-LCNetV2 更多模型指标及权重，敬请期待。
 
 在不使用额外数据的前提下，PPLCNetV2_base 模型在图像分类 ImageNet 数据集上能够取得超过 77% 的 Top1 Acc，同时在 Intel CPU 平台的推理时间在 4.4 ms 以下，如下表所示，其中推理时间基于 Intel(R) Xeon(R) Gold 6271C CPU @ 2.60GHz 硬件平台，OpenVINO 推理平台。
@@ -169,7 +169,7 @@ Predict complete
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='PPLCNetV2_base')
-infer_imgs='docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs='docs/images/deployment/whl_demo.jpg'
 result=clas.predict(infer_imgs)
 print(next(result))
 ```
@@ -191,7 +191,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档[环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档[环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -225,7 +225,7 @@ cd path_to_PaddleClas
 
 **备注：**
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
 
 <a name="3.3"></a>
@@ -401,7 +401,7 @@ ILSVRC2012_val_00030010.jpeg:	class id(s): [80, 143, 81, 137, 98], score(s): [0.
 
 ### 4.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="4.4"></a>
 
@@ -409,7 +409,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="4.5"></a>
 
@@ -417,7 +417,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="4.6"></a>
 
@@ -425,4 +425,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/models/ImageNet1k/README.md

+model_list.md
\ No newline at end of file

docs/zh_CN/models/RedNet.md → docs/zh_CN/models/ImageNet1k/RedNet.md

@@ -32,4 +32,4 @@
 | RedNet38  | 224       | 256               | 6.24             | 21.39            | 41.26             |
 | RedNet50  | 224       | 256               | 8.04             | 27.71            | 53.73             |
 | RedNet101 | 224       | 256               | 13.07            | 44.12            | 83.28             |
-| RedNet152 | 224       | 256               | 18.66            | 63.27            | 119.48            |
+| RedNet152 | 224       | 256               | 18.66            | 63.27            | 119.48            |
\ No newline at end of file

docs/zh_CN/models/ResNet.md → docs/zh_CN/models/ImageNet1k/ResNet.md

@@ -126,12 +126,12 @@ PaddleClas 提供的 ResNet 系列的模型包括 ResNet50，ResNet50_vd，ResNe
 
 **备注：** 推理过程使用 TensorRT。
 
-<a name="2"></a>   
-    
+<a name="2"></a>  
+
 ## 2. 模型快速体验
 
-<a name="2.1"></a>   
-    
+<a name="2.1"></a>  
+
 ### 2.1 安装 paddlepaddle
 
 - 您的机器安装的是 CUDA9 或 CUDA10，请运行以下命令安装
@@ -157,31 +157,31 @@ python3 -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple
 ```  
 pip3 install paddleclas
 ```
-<a name="2.3"></a> 
-    
+<a name="2.3"></a>
+
 ### 2.3 预测
 
 * 在命令行中使用 ResNet50 的权重快速预测
-    
+
 ```bash
 paddleclas --model_name=ResNet50  --infer_imgs="docs/images/inference_deployment/whl_demo.jpg"
 ```
-    
+
 结果如下：
 ```
 >>> result
 class_ids: [8, 7, 86, 82, 80], scores: [0.97968, 0.02028, 3e-05, 1e-05, 0.0], label_names: ['hen', 'cock', 'partridge', 'ruffed grouse, partridge, Bonasa umbellus', 'black grouse'], filename: docs/images/inference_deployment/whl_demo.jpg
 Predict complete!
 ```
-    
-**备注**： 更换 ResNet 的其他 scale 的模型时，只需替换 `model_name`，如将此时的模型改为 `ResNet18` 时，只需要将 `--model_name=ResNet50` 改为 `--model_name=ResNet18` 即可。   
 
-    
+**备注**： 更换 ResNet 的其他 scale 的模型时，只需替换 `model_name`，如将此时的模型改为 `ResNet18` 时，只需要将 `--model_name=ResNet50` 改为 `--model_name=ResNet18` 即可。  
+
+
 * 在 Python 代码中预测
 ```python
 from paddleclas import PaddleClas
 clas = PaddleClas(model_name='ResNet50')
-infer_imgs = 'docs/images/inference_deployment/whl_demo.jpg'
+infer_imgs = 'docs/images/deployment/whl_demo.jpg'
 result = clas.predict(infer_imgs)
 print(next(result))
 ```
@@ -195,17 +195,17 @@ print(next(result))
 ```
 
 
-<a name="3"></a> 
-    
+<a name="3"></a>
+
 ## 3. 模型训练、评估和预测
-    
+
 <a name="3.1"></a>  
 
 ### 3.1 环境配置
 
-* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../../installation.md) 配置 PaddleClas 运行环境。
 
-<a name="3.2"></a> 
+<a name="3.2"></a>
 
 ### 3.2 数据准备
 
@@ -234,15 +234,15 @@ cd path_to_PaddleClas
 ```
 
 其中 `train/` 和 `val/` 分别为训练集和验证集。`train_list.txt` 和 `val_list.txt` 分别为训练集和验证集的标签文件。
-    
-**备注：** 
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+**备注：**
+
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
 
-<a name="3.3"></a> 
+<a name="3.3"></a>
 
-### 3.3 模型训练 
+### 3.3 模型训练
 
 
 在 `ppcls/configs/ImageNet/ResNet/ResNet50.yaml` 中提供了 ResNet50 训练配置，可以通过如下脚本启动训练：
@@ -252,11 +252,11 @@ export CUDA_VISIBLE_DEVICES=0,1,2,3
 python3 -m paddle.distributed.launch \
     --gpus="0,1,2,3" \
     tools/train.py \
-        -c ppcls/configs/ImageNet/ResNet/ResNet50.yaml 
+        -c ppcls/configs/ImageNet/ResNet/ResNet50.yaml
 ```
 
 
-**备注：** 
+**备注：**
 
 * 当前精度最佳的模型会保存在 `output/ResNet50/best_model.pdparams`
 
@@ -283,7 +283,7 @@ python3 tools/eval.py \
 ```python
 python3 tools/infer.py \
     -c ppcls/configs/ImageNet/ResNet/ResNet50.yaml \
-    -o Global.pretrained_model=output/ResNet50/best_model 
+    -o Global.pretrained_model=output/ResNet50/best_model
 ```
 
 输出结果如下：
@@ -292,30 +292,30 @@ python3 tools/infer.py \
 [{'class_ids': [8, 7, 86, 82, 80], 'scores': [0.97968, 0.02028, 3e-05, 1e-05, 0.0], 'file_name': 'docs/images/inference_deployment/whl_demo.jpg', 'label_names': ['hen', 'cock', 'partridge', 'ruffed grouse, partridge, Bonasa umbellus', 'black grouse']}]
 ```
 
-**备注：** 
+**备注：**
 
 * 这里`-o Global.pretrained_model="output/ResNet50/best_model"` 指定了当前最佳权重所在的路径，如果指定其他权重，只需替换对应的路径即可。
-    
+
 * 默认是对 `docs/images/inference_deployment/whl_demo.jpg` 进行预测，此处也可以通过增加字段 `-o Infer.infer_imgs=xxx` 对其他图片预测。
-    
+
 * 默认输出的是 Top-5 的值，如果希望输出 Top-k 的值，可以指定`-o Infer.PostProcess.topk=k`，其中，`k` 为您指定的值。
 
 
-    
+
 <a name="4"></a>
 
 ## 4. 模型推理部署
 
-<a name="4.1"></a> 
+<a name="4.1"></a>
 
 ### 4.1 推理模型准备
 
 Paddle Inference 是飞桨的原生推理库， 作用于服务器端和云端，提供高性能的推理能力。相比于直接基于预训练模型进行预测，Paddle Inference可使用MKLDNN、CUDNN、TensorRT 进行预测加速，从而实现更优的推理性能。更多关于Paddle Inference推理引擎的介绍，可以参考[Paddle Inference官网教程](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/infer/inference/inference_cn.html)。
-    
+
 当使用 Paddle Inference 推理时，加载的模型类型为 inference 模型。本案例提供了两种获得 inference 模型的方法，如果希望得到和文档相同的结果，请选择[直接下载 inference 模型](#6.1.2)的方式。
 
-    
-<a name="4.1.1"></a> 
+
+<a name="4.1.1"></a>
 
 ### 4.1.1 基于训练得到的权重导出 inference 模型
 
@@ -337,7 +337,7 @@ python3 tools/export_model.py \
 ```
 
 
-<a name="4.1.2"></a> 
+<a name="4.1.2"></a>
 
 ### 4.1.2 直接下载 inference 模型
 
@@ -358,7 +358,7 @@ wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/ResNet5
 │   └── inference.pdmodel
 ```
 
-<a name="4.2"></a> 
+<a name="4.2"></a>
 
 ### 4.2 基于 Python 预测引擎推理
 
@@ -409,32 +409,32 @@ ILSVRC2012_val_00030010.jpeg:	class id(s): [80, 23, 83, 93, 136], score(s): [1.0
 ```
 
 
-<a name="4.3"></a> 
+<a name="4.3"></a>
 
 ### 4.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
-<a name="4.4"></a> 
+<a name="4.4"></a>
 
 ### 4.4 服务化部署
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
-    
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
 
-<a name="4.5"></a> 
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
+
+<a name="4.5"></a>
 
 ### 4.5 端侧部署
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
-    
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
 
-<a name="4.6"></a> 
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
+
+<a name="4.6"></a>
 
 ### 4.6 Paddle2ONNX 模型转换与预测
-    
+
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
 PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](@shuilong)来完成相应的部署工作。

docs/zh_CN/models/ResNet_and_vd.md → docs/zh_CN/models/ImageNet1k/ResNet_and_vd.md

@@ -21,13 +21,13 @@ ResNet 系列模型是在 2015 年提出的，一举在 ILSVRC2015 比赛中取
 
 该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.ResNet.flops.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.ResNet.flops.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.ResNet.params.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.ResNet.params.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.ResNet.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.ResNet.png)
 
-![](../../images/models/T4_benchmark/t4.fp16.bs4.ResNet.png)
+![](../../../images/models/T4_benchmark/t4.fp16.bs4.ResNet.png)
 
 
 通过上述曲线可以看出，层数越多，准确率越高，但是相应的参数量、计算量和延时都会增加。ResNet50_vd_ssld 通过用更强的 teacher 和更多的数据，将其在 ImageNet-1k 上的验证集 top-1 精度进一步提高，达到了 82.39%，刷新了 ResNet50 系列模型的精度。

docs/zh_CN/models/SEResNext_and_Res2Net.md → docs/zh_CN/models/ImageNet1k/SEResNext_and_Res2Net.md

@@ -20,13 +20,13 @@ Res2Net 是 2019 年提出的一种全新的对 ResNet 的改进方案，该方
 该系列模型的 FLOPS、参数量以及 T4 GPU 上的预测耗时如下图所示。
 
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.SeResNeXt.flops.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.SeResNeXt.flops.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.SeResNeXt.params.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.SeResNeXt.params.png)
 
-![](../../images/models/T4_benchmark/t4.fp32.bs4.SeResNeXt.png)
+![](../../../images/models/T4_benchmark/t4.fp32.bs4.SeResNeXt.png)
 
-![](../../images/models/T4_benchmark/t4.fp16.bs4.SeResNeXt.png)
+![](../../../images/models/T4_benchmark/t4.fp16.bs4.SeResNeXt.png)
 
 
 目前 PaddleClas 开源的这三类的预训练模型一共有 24 个，其指标如图所示，从图中可以看出，在同样 Flops 和 Params 下，改进版的模型往往有更高的精度，但是推理速度往往不如 ResNet 系列。另一方面，Res2Net 表现也较为优秀，相比 ResNeXt 中的 group 操作、SEResNet 中的 SE 结构操作，Res2Net 在相同 Flops、Params 和推理速度下往往精度更佳。

docs/zh_CN/models/SwinTransformer.md → docs/zh_CN/models/ImageNet1k/SwinTransformer.md

@@ -70,14 +70,14 @@ Swin Transformer 是一种新的视觉 Transformer 网络，可以用作计算
 
 ## 2. 模型快速体验
 
-安装 paddlepaddle 和 paddleclas 即可快速对图片进行预测，体验方法可以参考[ResNet50 模型快速体验](./ResNet.md#2-模型快速体验)。
+安装 paddlepaddle 和 paddleclas 即可快速对图片进行预测，体验方法可以参考[ResNet50 模型快速体验](./ResNet.md#2)。
 
 <a name="3"></a>
 
 ## 3. 模型训练、评估和预测
 
 
-此部分内容包括训练环境配置、ImageNet数据的准备、SwinTransformer 在 ImageNet 上的训练、评估、预测等内容。在 `ppcls/configs/ImageNet/SwinTransformer/` 中提供了 SwinTransformer 的训练配置，可以通过如下脚本启动训练：此部分内容可以参考[ResNet50 模型训练、评估和预测](./ResNet.md#3-模型训练评估和预测)。
+此部分内容包括训练环境配置、ImageNet数据的准备、SwinTransformer 在 ImageNet 上的训练、评估、预测等内容。在 `ppcls/configs/ImageNet/SwinTransformer/` 中提供了 SwinTransformer 的训练配置，可以通过如下脚本启动训练：此部分内容可以参考[ResNet50 模型训练、评估和预测](./ResNet.md#3)。
 
 **备注：** 由于 SwinTransformer 系列模型默认使用的 GPU 数量为 8 个，所以在训练时，需要指定8个GPU，如`python3 -m paddle.distributed.launch --gpus="0,1,2,3,4,5,6,7" tools/train.py -c xxx.yaml`, 如果使用 4 个 GPU 训练，默认学习率需要减小一半，精度可能有损。
 
@@ -92,19 +92,19 @@ Swin Transformer 是一种新的视觉 Transformer 网络，可以用作计算
 
 Paddle Inference 是飞桨的原生推理库， 作用于服务器端和云端，提供高性能的推理能力。相比于直接基于预训练模型进行预测，Paddle Inference可使用 MKLDNN、CUDNN、TensorRT 进行预测加速，从而实现更优的推理性能。更多关于Paddle Inference推理引擎的介绍，可以参考[Paddle Inference官网教程](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/infer/inference/inference_cn.html)。
 
-Inference 的获取可以参考 [ResNet50 推理模型准备](./ResNet.md#41-推理模型准备) 。
+Inference 的获取可以参考 [ResNet50 推理模型准备](./ResNet.md#4.1) 。
 
 <a name="4.2"></a>
 
 ### 4.2 基于 Python 预测引擎推理
 
-PaddleClas 提供了基于 python 预测引擎推理的示例。您可以参考[ResNet50 基于 Python 预测引擎推理](./ResNet.md#42-基于-python-预测引擎推理) 对 SwinTransformer 完成推理预测。
+PaddleClas 提供了基于 python 预测引擎推理的示例。您可以参考[ResNet50 基于 Python 预测引擎推理](./ResNet.md#4.2) 对 SwinTransformer 完成推理预测。
 
 <a name="4.3"></a>
 
 ### 4.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="4.4"></a>
 
@@ -112,7 +112,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="4.5"></a>
 
@@ -120,7 +120,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="4.6"></a>
 

docs/zh_CN/algorithm_introduction/ImageNet_models.md → docs/zh_CN/models/ImageNet1k/model_list.md

-<!-- 简体中文 | [English](../../en/algorithm_introduction/ImageNet_models.md) -->
+<!-- 简体中文 | [English](../../en/algorithm_introduction/model_list.md) -->
 
 
 # ImageNet 预训练模型库
@@ -49,20 +49,20 @@
 
 常见服务器端模型的精度指标与其预测耗时的变化曲线如下图所示。
 
-![](../../images/models/V100_benchmark/v100.fp32.bs1.main_fps_top1_s.png)
+![](../../../images/models/V100_benchmark/v100.fp32.bs1.main_fps_top1_s.png)
 
 常见移动端模型的精度指标与其预测耗时的变化曲线如下图所示。
 
-![](../../images/models/mobile_arm_top1.png)
+![](../../../images/models/mobile_arm_top1.png)
 
 部分VisionTransformer模型的精度指标与其预测耗时的变化曲线如下图所示.
 
-![](../../images/models/V100_benchmark/v100.fp32.bs1.visiontransformer.png)
+![](../../../images/models/V100_benchmark/v100.fp32.bs1.visiontransformer.png)
 
 <a name="SSLD"></a>
 
 ## SSLD 知识蒸馏预训练模型
-基于 SSLD 知识蒸馏的预训练模型列表如下所示，更多关于 SSLD 知识蒸馏方案的介绍可以参考：[SSLD 知识蒸馏文档](./knowledge_distillation.md)。
+基于 SSLD 知识蒸馏的预训练模型列表如下所示，更多关于 SSLD 知识蒸馏方案的介绍可以参考：[SSLD 知识蒸馏文档](../../algorithm_introduction/knowledge_distillation.md)。
 
 <a name="SSLD_server"></a>
 
@@ -111,7 +111,7 @@
 
 ## PP-LCNet & PP-LCNetV2 系列 <sup>[[28](#ref28)]</sup>
 
-PP-LCNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[PP-LCNet 系列模型文档](../models/PP-LCNet.md)，[PP-LCNetV2 系列模型文档](../models/PP-LCNetV2.md)。
+PP-LCNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[PP-LCNet 系列模型文档](PP-LCNet.md)，[PP-LCNetV2 系列模型文档](PP-LCNetV2.md)。
 
 | 模型           | Top-1 Acc | Top-5 Acc | time(ms)<sup>*</sup><br>bs=1 | FLOPs(M) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 |:--:|:--:|:--:|:--:|----|----|----|:--:|
@@ -137,7 +137,7 @@ PP-LCNet 系列模型的精度、速度指标如下表所示，更多关于该
 
 ## PP-HGNet 系列
 
-PP-HGNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[PP-HGNet 系列模型文档](../models/PP-HGNet.md)。
+PP-HGNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[PP-HGNet 系列模型文档](PP-HGNet.md)。
 
 | 模型  | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 | ---  | --- | --- | --- | --- | --- | --- | --- | --- | --- |
@@ -151,7 +151,7 @@ PP-HGNet 系列模型的精度、速度指标如下表所示，更多关于该
 
 ## ResNet 系列 <sup>[[1](#ref1)]</sup>
 
-ResNet 及其 Vd 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[ResNet 及其 Vd 系列模型文档](../models/ResNet_and_vd.md)。
+ResNet 及其 Vd 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[ResNet 及其 Vd 系列模型文档](ResNet_and_vd.md)。
 
 | 模型                  | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                              | inference模型下载地址                      |
 |---------------------|-----------|-----------|-----------------------|----------------------|----------|-----------|----------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------|
@@ -175,7 +175,7 @@ ResNet 及其 Vd 系列模型的精度、速度指标如下表所示，更多关
 
 ## 移动端系列 <sup>[[3](#ref3)][[4](#ref4)][[5](#ref5)][[6](#ref6)][[23](#ref23)]</sup>
 
-移动端系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[移动端系列模型文档](../models/Mobile.md)。
+移动端系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[移动端系列模型文档](Mobile.md)。
 
 | 模型          | Top-1 Acc | Top-5 Acc | SD855 time(ms)<br>bs=1, thread=1 | SD855 time(ms)<br/>bs=1, thread=2 | SD855 time(ms)<br/>bs=1, thread=4 | FLOPs(M) | Params(M) | <span style="white-space:nowrap;">模型大小(M)</span> | 预训练模型下载地址 | inference模型下载地址 |
 |----------------------------------|-----------|-----------|------------------------|----------|-----------|---------|-----------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
@@ -224,7 +224,7 @@ ResNet 及其 Vd 系列模型的精度、速度指标如下表所示，更多关
 
 ## SEResNeXt 与 Res2Net 系列 <sup>[[7](#ref7)][[8](#ref8)][[9](#ref9)]</sup>
 
-SEResNeXt 与 Res2Net 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[SEResNeXt 与 Res2Net 系列模型文档](../models/SEResNext_and_Res2Net.md)。
+SEResNeXt 与 Res2Net 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[SEResNeXt 与 Res2Net 系列模型文档](SEResNext_and_Res2Net.md)。
 
 
 | 模型                  | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                              | inference模型下载地址               |
@@ -259,7 +259,7 @@ SEResNeXt 与 Res2Net 系列模型的精度、速度指标如下表所示，更
 
 ## DPN 与 DenseNet 系列 <sup>[[14](#ref14)][[15](#ref15)]</sup>
 
-DPN 与 DenseNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[DPN 与 DenseNet 系列模型文档](../models/DPN_DenseNet.md)。
+DPN 与 DenseNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[DPN 与 DenseNet 系列模型文档](DPN_DenseNet.md)。
 
 
 | 模型                  | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                              | inference模型下载地址 |
@@ -279,7 +279,7 @@ DPN 与 DenseNet 系列模型的精度、速度指标如下表所示，更多关
 
 ## HRNet 系列 <sup>[[13](#ref13)]</sup>
 
-HRNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[HRNet 系列模型文档](../models/HRNet.md)。
+HRNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[HRNet 系列模型文档](HRNet.md)。
 
 | 模型          | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                      | inference模型下载地址             |
 |-------------|-----------|-----------|------------------|------------------|----------|-----------|--------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------|
@@ -298,7 +298,7 @@ HRNet 系列模型的精度、速度指标如下表所示，更多关于该系
 
 ## Inception 系列 <sup>[[10](#ref10)][[11](#ref11)][[12](#ref12)][[26](#ref26)]</sup>
 
-Inception 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[Inception 系列模型文档](../models/Inception.md)。
+Inception 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[Inception 系列模型文档](Inception.md)。
 
 | 模型                  | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                              | inference模型下载地址                     |
 |--------------------|-----------|-----------|-----------------------|----------------------|----------|-----------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
@@ -315,7 +315,7 @@ Inception 系列模型的精度、速度指标如下表所示，更多关于该
 
 ## EfficientNet 与 ResNeXt101_wsl 系列 <sup>[[16](#ref16)][[17](#ref17)]</sup>
 
-EfficientNet 与 ResNeXt101_wsl 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[EfficientNet 与 ResNeXt101_wsl 系列模型文档](../models/EfficientNet_and_ResNeXt101_wsl.md)。
+EfficientNet 与 ResNeXt101_wsl 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[EfficientNet 与 ResNeXt101_wsl 系列模型文档](EfficientNet_and_ResNeXt101_wsl.md)。
 
 | 模型                        | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                                    | inference模型下载地址                           |
 |---------------------------|-----------|-----------|------------------|------------------|----------|-----------|----------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
@@ -338,7 +338,7 @@ EfficientNet 与 ResNeXt101_wsl 系列模型的精度、速度指标如下表所
 
 ## ResNeSt 与 RegNet 系列 <sup>[[24](#ref24)][[25](#ref25)]</sup>
 
-ResNeSt 与 RegNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[ResNeSt 与 RegNet 系列模型文档](../models/ResNeSt_RegNet.md)。
+ResNeSt 与 RegNet 系列模型的精度、速度指标如下表所示，更多关于该系列的模型介绍可以参考：[ResNeSt 与 RegNet 系列模型文档](ResNeSt_RegNet.md)。
 
 | 模型                   | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                                      | inference模型下载地址                          |
 |------------------------|-----------|-----------|------------------|------------------|----------|-----------|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|
@@ -350,7 +350,7 @@ ResNeSt 与 RegNet 系列模型的精度、速度指标如下表所示，更多
 
 ## ViT_and_DeiT 系列 <sup>[[31](#ref31)][[32](#ref32)]</sup>
 
-ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模型的精度、速度指标如下表所示. 更多关于该系列模型的介绍可以参考： [ViT_and_DeiT 系列模型文档](../models/ViT_and_DeiT.md)。
+ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模型的精度、速度指标如下表所示. 更多关于该系列模型的介绍可以参考： [ViT_and_DeiT 系列模型文档](ViT_and_DeiT.md)。
 
 | 模型                  | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 |------------------------|-----------|-----------|------------------|------------------|----------|------------------------|------------------------|------------------------|------------------------|
@@ -377,7 +377,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## RepVGG 系列 <sup>[[36](#ref36)]</sup>
 
-关于 RepVGG 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[RepVGG 系列模型文档](../models/RepVGG.md)。
+关于 RepVGG 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[RepVGG 系列模型文档](RepVGG.md)。
 
 | 模型                     | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 |------------------------|-----------|-----------|------------------|------------------|----------|-----------|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|
@@ -396,7 +396,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## MixNet 系列 <sup>[[29](#ref29)]</sup>
 
-关于 MixNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[MixNet 系列模型文档](../models/MixNet.md)。
+关于 MixNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[MixNet 系列模型文档](MixNet.md)。
 
 | 模型     | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(M) | Params(M) | 预训练模型下载地址                                           | inference模型下载地址                                        |
 | -------- | --------- | --------- | ---------------- | ---------------- | ----------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -408,7 +408,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## ReXNet 系列 <sup>[[30](#ref30)]</sup>
 
-关于 ReXNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[ReXNet 系列模型文档](../models/ReXNet.md)。
+关于 ReXNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[ReXNet 系列模型文档](ReXNet.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -422,7 +422,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## SwinTransformer 系列 <sup>[[27](#ref27)]</sup>
 
-关于 SwinTransformer 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[SwinTransformer 系列模型文档](../models/SwinTransformer.md)。
+关于 SwinTransformer 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[SwinTransformer 系列模型文档](SwinTransformer.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                                               | inference模型下载地址                                      |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -441,7 +441,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## LeViT 系列 <sup>[[33](#ref33)]</sup>
 
-关于 LeViT 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[LeViT 系列模型文档](../models/LeViT.md)。
+关于 LeViT 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[LeViT 系列模型文档](LeViT.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(M) | Params(M) | 预训练模型下载地址                                               | inference模型下载地址                                      |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -457,7 +457,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## Twins 系列 <sup>[[34](#ref34)]</sup>
 
-关于 Twins 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[Twins 系列模型文档](../models/Twins.md)。
+关于 Twins 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[Twins 系列模型文档](Twins.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                                               | inference模型下载地址                                      |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -474,7 +474,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## HarDNet 系列 <sup>[[37](#ref37)]</sup>
 
-关于 HarDNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[HarDNet 系列模型文档](../models/HarDNet.md)。
+关于 HarDNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[HarDNet 系列模型文档](HarDNet.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -487,7 +487,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## DLA 系列 <sup>[[38](#ref38)]</sup>
 
-关于 DLA 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[DLA 系列模型文档](../models/DLA.md)。
+关于 DLA 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[DLA 系列模型文档](DLA.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -505,7 +505,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## RedNet 系列 <sup>[[39](#ref39)]</sup>
 
-关于 RedNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[RedNet 系列模型文档](../models/RedNet.md)。
+关于 RedNet 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[RedNet 系列模型文档](RedNet.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -519,7 +519,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## TNT 系列 <sup>[[35](#ref35)]</sup>
 
-关于 TNT 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[TNT 系列模型文档](../models/TNT.md)。
+关于 TNT 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[TNT 系列模型文档](TNT.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | FLOPs(G) | Params(M) | 预训练模型下载地址                                               | inference模型下载地址                                      |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -531,7 +531,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## CSWinTransformer 系列 <sup>[[40](#ref40)]</sup>
 
-关于 CSWinTransformer 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[CSWinTransformer 系列模型文档](../models/CSWinTransformer.md)。
+关于 CSWinTransformer 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[CSWinTransformer 系列模型文档](CSWinTransformer.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                                               | inference模型下载地址                                      |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -547,7 +547,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## PVTV2 系列 <sup>[[41](#ref41)]</sup>
 
-关于 PVTV2 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[PVTV2 系列模型文档](../models/PVTV2.md)。
+关于 PVTV2 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[PVTV2 系列模型文档](PVTV2.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址                                               | inference模型下载地址                                      |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -564,7 +564,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## MobileViT 系列 <sup>[[42](#ref42)]</sup>
 
-关于 MobileViT 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[MobileViT 系列模型文档](../models/MobileViT.md)。
+关于 MobileViT 系列模型的精度、速度指标如下表所示，更多介绍可以参考：[MobileViT 系列模型文档](MobileViT.md)。
 
 | 模型       | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(M) | Params(M) | 预训练模型下载地址                                               | inference模型下载地址                                      |
 | ---------- | --------- | --------- | ---------------- | ---------------- | -------- | --------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
@@ -576,7 +576,7 @@ ViT(Vision Transformer) 与 DeiT（Data-efficient Image Transformers）系列模
 
 ## 其他模型
 
-关于 AlexNet <sup>[[18](#ref18)]</sup>、SqueezeNet 系列 <sup>[[19](#ref19)]</sup>、VGG 系列 <sup>[[20](#ref20)]</sup>、DarkNet53 <sup>[[21](#ref21)]</sup> 等模型的精度、速度指标如下表所示，更多介绍可以参考：[其他模型文档](../models/Others.md)。
+关于 AlexNet <sup>[[18](#ref18)]</sup>、SqueezeNet 系列 <sup>[[19](#ref19)]</sup>、VGG 系列 <sup>[[20](#ref20)]</sup>、DarkNet53 <sup>[[21](#ref21)]</sup> 等模型的精度、速度指标如下表所示，更多介绍可以参考：[其他模型文档](Others.md)。
 
 | 模型                     | Top-1 Acc | Top-5 Acc | time(ms)<br>bs=1 | time(ms)<br>bs=4 | time(ms)<br/>bs=8 | FLOPs(G) | Params(M) | 预训练模型下载地址 | inference模型下载地址 |
 |------------------------|-----------|-----------|------------------|------------------|----------|-----------|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|

docs/zh_CN/others/paddle_mobile_inference.md → docs/zh_CN/models/ImageNet1k/paddle_lite_benchmark.md

@@ -15,7 +15,7 @@
 
 [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 进行了[移动端模型的性能评估](./Mobile.md)，本部分以 `ImageNet1k` 数据集的 `MobileNetV1` 模型为例，介绍怎样使用 `Paddle-Lite`，在移动端(基于骁龙855的安卓开发平台)对进行模型速度评估。
 
 <a name='2'></a>
 

docs/zh_CN/PPShiTu/PPShiTuV2_introduction.md → docs/zh_CN/models/PP-ShiTu/README.md

@@ -40,10 +40,10 @@ PP-ShiTuV2 是基于 PP-ShiTuV1 改进的一个实用轻量级通用图像识别
 | :--------- | :---------------------- | :------------------ |
 |            |                         | recall@1            |
 | PP-ShiTuV1 | 64(30+34)MB             | 66.8%                 |
-| PP-ShiTuV2 | 49(30+19)               | 73.8%                 |
+| PP-ShiTuV2 | 49(30+19)MB               | 73.8%                 |
 
 **注：**
-- recall及mAP指标的介绍可以参考 [常用指标](../algorithm_introduction/reid.md#22-常用指标)。
+- recall及mAP指标的介绍可以参考 [常用指标](../../algorithm_introduction/ReID.md#22-常用指标)。
 - 延时是基于 Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz 测试得到，开启 MKLDNN 加速策略，线程数为10。
 
 ## 2. 模型快速体验
@@ -70,10 +70,10 @@ PP-ShiTuV2 是基于 PP-ShiTuV1 改进的一个实用轻量级通用图像识别
   ```shell
   # 如果您的机器安装的是 CUDA9 或 CUDA10，请运行以下命令安装
   python3.7 -m pip install paddlepaddle-gpu -i https://mirror.baidu.com/pypi/simple
-  
+
   # 如果您的机器是CPU，请运行以下命令安装
   python3.7 -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple
-  
+
   # 安装 faiss 库
   python3.7 -m pip install faiss-cpu==1.7.1post2
   ```
@@ -82,7 +82,7 @@ PP-ShiTuV2 是基于 PP-ShiTuV1 改进的一个实用轻量级通用图像识别
   ```shell
   # 进入到PaddleClas根目录下
   cd PaddleClas
-  
+
   # 安装paddleclas
   python3.7 setup.py install
   ```
@@ -92,7 +92,7 @@ PP-ShiTuV2 是基于 PP-ShiTuV1 改进的一个实用轻量级通用图像识别
   ```shell
   # 下载并解压demo数据
   wget -nc https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/drink_dataset_v2.0.tar && tar -xf drink_dataset_v2.0.tar
-  
+
   # 执行识别命令
   paddleclas \
   --model_name=PP-ShiTuV2 \
@@ -109,17 +109,17 @@ PP-ShiTuV2 是基于 PP-ShiTuV1 改进的一个实用轻量级通用图像识别
 
 考虑到检测速度、模型大小、检测精度等因素，最终选择 PaddleDetection 自研的轻量级模型 `PicoDet-LCNet_x2_5` 作为 PP-ShiTuV2 的主体检测模型
 
-主体检测模型的数据集、训练、评估、推理等详细信息可以参考文档：[picodet_lcnet_x2_5_640_mainbody](../image_recognition_pipeline/mainbody_detection.md)。
+主体检测模型的数据集、训练、评估、推理等详细信息可以参考文档：[picodet_lcnet_x2_5_640_mainbody](../../training/PP-ShiTu/mainbody_detection.md)。
 
 ### 3.2 特征提取
 
-特征提取是图像识别中的关键一环，它的作用是将输入的图片转化为固定维度的特征向量，用于后续的 [向量检索](./vector_search.md) 。考虑到特征提取模型的速度、模型大小、特征提取性能等因素，最终选择 PaddleClas 自研的 [`PPLCNetV2_base`](../models/PP-LCNetV2.md) 作为特征提取网络。相比 PP-ShiTuV1 所使用的 `PPLCNet_x2_5`， `PPLCNetV2_base` 基本保持了较高的分类精度，并减少了40%的推理时间<sup>*</sup>。
+特征提取是图像识别中的关键一环，它的作用是将输入的图片转化为固定维度的特征向量，用于后续的 [向量检索](./vector_search.md) 。考虑到特征提取模型的速度、模型大小、特征提取性能等因素，最终选择 PaddleClas 自研的 [`PPLCNetV2_base`](../ImageNet1k/PP-LCNetV2.md) 作为特征提取网络。相比 PP-ShiTuV1 所使用的 `PPLCNet_x2_5`， `PPLCNetV2_base` 基本保持了较高的分类精度，并减少了40%的推理时间<sup>*</sup>。
 
 **注：** <sup>*</sup>推理环境基于 Intel(R) Xeon(R) Gold 6271C CPU @ 2.60GHz 硬件平台，OpenVINO 推理平台。
 
 在实验过程中我们也发现可以对 `PPLCNetV2_base` 进行适当的改进，在保持速度基本不变的情况下，让其在识别任务中得到更高的性能，包括：去掉 `PPLCNetV2_base` 末尾的 `ReLU` 和 `FC`、将最后一个 stage(RepDepthwiseSeparable) 的 stride 改为1。
 
-特征提取模型的数据集、训练、评估、推理等详细信息可以参考文档：[PPLCNetV2_base_ShiTu](../image_recognition_pipeline/feature_extraction.md)。
+特征提取模型的数据集、训练、评估、推理等详细信息可以参考文档：[PPLCNetV2_base_ShiTu](../../training/PP-ShiTu/feature_extraction.md)。
 
 ### 3.3 向量检索
 
@@ -127,7 +127,7 @@ PP-ShiTuV2 是基于 PP-ShiTuV1 改进的一个实用轻量级通用图像识别
 
 在 PP-ShiTuV2 识别系统中，我们使用了 [Faiss](https://github.com/facebookresearch/faiss) 向量检索开源库对此部分进行支持，其具有适配性好、安装方便、算法丰富、同时支持CPU与GPU的优点。
 
-PP-ShiTuV2 系统中关于 Faiss 向量检索库的安装及使用可以参考文档：[vector search](../image_recognition_pipeline/vector_search.md)。
+PP-ShiTuV2 系统中关于 Faiss 向量检索库的安装及使用可以参考文档：[vector search](../../deployment/PP-ShiTu/vector_search.md)。
 
 ## 4. 推理部署
 
@@ -137,7 +137,7 @@ Paddle Inference 是飞桨的原生推理库， 作用于服务器端和云端
 当使用 Paddle Inference 推理时，加载的模型类型为 inference 模型。本案例提供了两种获得 inference 模型的方法，如果希望得到和文档相同的结果，请选择 [直接下载 inference 模型](#412-直接下载-inference-模型) 的方式。
 
 #### 4.1.1 基于训练得到的权重导出 inference 模型
-- 主体检测模型权重导出请参考文档 [主体检测推理模型准备](../image_recognition_pipeline/mainbody_detection.md#41-推理模型准备)，或者参照 [4.1.2](#412-直接下载-inference-模型) 直接下载解压即可。
+- 主体检测模型权重导出请参考文档 [主体检测推理模型准备](../../training/PP-ShiTu/mainbody_detection.md#41-推理模型准备)，或者参照 [4.1.2](#412-直接下载-inference-模型) 直接下载解压即可。
 
 - 特征提取模型权重导出可以参考以下命令：
   ```shell
@@ -234,12 +234,12 @@ Inference: 37.95266151428223 ms per batch image
 其中 `bbox` 表示检测出的主体所在位置，`rec_docs` 表示索引库中与检测框最为相似的类别，`rec_scores` 表示对应的相似度。
 
 ### 4.4 基于 C++ 预测引擎推理
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考 [服务器端 C++ 预测](../../../deploy/cpp_shitu/readme.md) 来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考 [基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md) 完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考 [服务器端 C++ 预测](../../../../deploy/cpp_shitu/readme.md) 来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考 [基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md) 完成相应的预测库编译和模型预测工作。
 
 ### 4.5 服务化部署
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考 [Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考 [模型服务化部署](../inference_deployment/recognition_serving_deploy.md) 来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考 [模型服务化部署](../../deployment/PP-ShiTu/paddle_serving.md) 来完成相应的部署工作。
 
 ### 4.6 端侧部署
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考 [Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
@@ -247,7 +247,7 @@ Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深
 ### 4.7 Paddle2ONNX 模型转换与预测
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考 [Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考 [Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md) 来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考 [Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md) 来完成相应的部署工作。
 
 ## 参考文献
 1. Schall, Konstantin, et al. "GPR1200: A Benchmark for General-Purpose Content-Based Image Retrieval." International Conference on Multimedia Modeling. Springer, Cham, 2022.

docs/zh_CN/PULC/PULC_car_exists.md → docs/zh_CN/models/PULC/PULC_car_exists.md

@@ -59,7 +59,7 @@
 **备注：**
 
 * `Tpr`指标的介绍可以参考 [3.3节](#3.3)的备注部分，延时是基于 Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz 测试得到，开启 MKLDNN 加速策略，线程数为10。
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 
 <a name="2"></a>
@@ -140,7 +140,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档[环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档[环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -166,7 +166,7 @@ print(next(result))
 
 处理后的数据集部分数据可视化如下：
 
-![](../../images/PULC/docs/car_exists_data_demo.jpeg)
+![](../../../images/PULC/docs/car_exists_data_demo.jpeg)
 
 此处提供了经过上述方法处理好的数据，可以直接下载得到。
 
@@ -208,9 +208,9 @@ cd ../
 
 **备注：**
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考 [PaddleClas 分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考 [PaddleClas 分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
-* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../advanced_tutorials/ssld.md#3.2)。
+* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../../training/advanced/ssld.md#3.2)。
 
 
 <a name="3.3"></a>
@@ -285,7 +285,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md)。
 
 <a name="4.1.1"></a>
 
@@ -326,7 +326,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -443,7 +443,7 @@ objects365_00001521.jpeg:       class id(s): [0], score(s): [0.99], label_name(s
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -451,7 +451,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -459,7 +459,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -467,4 +467,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_language_classification.md → docs/zh_CN/models/PULC/PULC_language_classification.md

@@ -53,7 +53,7 @@
 
 **备注：**
 
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 <a name="2"></a>
 
@@ -133,7 +133,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -145,7 +145,7 @@ print(next(result))
 
 [第1节](#1)中提供的模型使用内部数据训练得到，该数据集暂时不方便公开。这里基于 [Multi-lingual scene text detection and recognition](https://rrc.cvc.uab.es/?ch=15&com=downloads) 开源数据集构造了一个多语种demo数据集，用于体验本案例的预测过程。
 
-![](../../images/PULC/docs/language_classification_original_data.png)
+![](../../../images/PULC/docs/language_classification_original_data.png)
 
 <a name="3.2.2"></a>
 
@@ -198,7 +198,7 @@ cd ../
 ***备注：***
 
 -  这里的`label_list.txt`是4类语种分类模型对应的类别列表，如果自己构造的数据集语种类别发生变化，需要自行调整。
--  如果想要自己构造训练集和验证集，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+-  如果想要自己构造训练集和验证集，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
 <a name="3.3"></a>
 
@@ -265,7 +265,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md)。
 
 <a name="4.1.1"></a>
 
@@ -309,7 +309,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -426,7 +426,7 @@ word_35404.png:    class id(s): [4, 6], score(s): [0.89, 0.01], label_name(s): [
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -434,7 +434,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -442,7 +442,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -450,4 +450,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_person_attribute.md → docs/zh_CN/models/PULC/PULC_person_attribute.md

@@ -60,7 +60,7 @@
 **备注：**
 
 * 延时是基于 Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz 测试得到，开启 MKLDNN 加速策略，线程数为10。
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 
 <a name="2"></a>
@@ -132,6 +132,26 @@ print(next(result))
 [{'attributes': ['Male', 'Age18-60', 'Back', 'Glasses: False', 'Hat: False', 'HoldObjectsInFront: False', 'Backpack', 'Upper: LongSleeve UpperPlaid', 'Lower:  Trousers', 'No boots'], 'output': [0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1], 'filename': 'pulc_demo_imgs/person_attribute/090004.jpg'}]
 ```
 
+**备注**：其中 `output` 的值索引为0表示是否佩戴帽子，索引值为1表示是否佩戴眼镜，索引值2-7表示上衣风格，索引值8-13表示下装风格，索引值14表示是否穿靴子，索引值15-17表示背的包的类型，索引值18表示正面是否持物，索引值19-21表示年龄，索引值22表示性别，索引值23-25表示朝向。详情可以查看[代码](../../../../ppcls/data/postprocess/attr_rec.py#L84)。具体地，属性包含以下类型：
+
+```
+- 性别：男、女
+- 年龄：小于18、18-60、大于60
+- 朝向：朝前、朝后、侧面
+- 配饰：眼镜、帽子、无
+- 正面持物：是、否
+- 包：双肩包、单肩包、手提包
+- 上衣风格：带条纹、带logo、带格子、拼接风格
+- 下装风格：带条纹、带图案
+- 短袖上衣：是、否
+- 长袖上衣：是、否
+- 长外套：是、否
+- 长裤：是、否
+- 短裤：是、否
+- 短裙&裙子：是、否
+- 穿靴：是、否
+```
+
 <a name="3"></a>
 
 ## 3. 模型训练、评估和预测
@@ -140,7 +160,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -273,7 +293,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md)。
 
 <a name="4.1.1"></a>
 
@@ -314,7 +334,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -426,7 +446,7 @@ python3.7 python/predict_cls.py -c configs/PULC/person_attribute/inference_perso
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -434,7 +454,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -442,7 +462,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -450,4 +470,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_person_exists.md → docs/zh_CN/models/PULC/PULC_person_exists.md

@@ -59,7 +59,7 @@
 **备注：**
 
 * `Tpr`指标的介绍可以参考 [3.2 小节](#3.2)的备注部分，延时是基于 Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz 测试得到，开启 MKLDNN 加速策略，线程数为10。
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 
 <a name="2"></a>
@@ -139,7 +139,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档[环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档[环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -163,7 +163,7 @@ print(next(result))
 
 处理后的数据集部分数据可视化如下：
 
-![](../../images/PULC/docs/person_exists_data_demo.png)
+![](../../../images/PULC/docs/person_exists_data_demo.png)
 
 此处提供了经过上述方法处理好的数据，可以直接下载得到。
 
@@ -210,9 +210,9 @@ cd ../
 
 **备注：**
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考 [PaddleClas 分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考 [PaddleClas 分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
-* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../advanced_tutorials/ssld.md#3.2)。
+* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../../training/advanced/ssld.md#3.2)。
 
 
 <a name="3.3"></a>
@@ -287,7 +287,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md)。
 
 <a name="4.1.1"></a>
 
@@ -328,7 +328,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -445,7 +445,7 @@ objects365_02035329.jpg:	class id(s): [1], score(s): [1.00], label_name(s): ['so
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -453,7 +453,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -461,7 +461,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -469,4 +469,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_safety_helmet.md → docs/zh_CN/models/PULC/PULC_safety_helmet.md

@@ -59,7 +59,7 @@
 
 * `Tpr`指标的介绍可以参考 [3.3小节](#3.3)的备注部分，延时是基于 Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz 测试得到，开启MKLDNN加速策略，线程数为10。
 
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 
 <a name="2"></a>
@@ -139,7 +139,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -165,7 +165,7 @@ print(next(result))
 
 处理后的数据集部分数据可视化如下：
 
-![](../../images/PULC/docs/safety_helmet_data_demo.jpg)
+![](../../../images/PULC/docs/safety_helmet_data_demo.jpg)
 
 此处提供了经过上述方法处理好的数据，可以直接下载得到。
 
@@ -201,7 +201,7 @@ cd ../
 
 **备注：**
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
 <a name="3.3"></a>
 
@@ -273,7 +273,7 @@ python3 tools/infer.py \
 
 ### 4.1 UDML 知识蒸馏
 
-UDML 知识蒸馏是一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[UDML 知识蒸馏](../advanced_tutorials/knowledge_distillation.md#1.2.3)。
+UDML 知识蒸馏是一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[UDML 知识蒸馏](../../training/advanced/knowledge_distillation.md#1.2.3)。
 
 <a name="4.1.1"></a>
 
@@ -295,7 +295,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注**：此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -411,7 +411,7 @@ safety_helmet_test_2.png:       class id(s): [0], score(s): [1.00], label_name(s
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -419,7 +419,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -427,7 +427,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -435,4 +435,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_text_image_orientation.md → docs/zh_CN/models/PULC/PULC_text_image_orientation.md

@@ -52,7 +52,7 @@
 
 **备注：**
 
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 <a name="2"></a>
 
@@ -131,7 +131,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -143,7 +143,7 @@ print(next(result))
 
 [第1节](#1)中提供的模型使用内部数据训练得到，该数据集暂时不方便公开。这里基于 [ICDAR2019-ArT](https://ai.baidu.com/broad/introduction?dataset=art)、 [XFUND](https://github.com/doc-analysis/XFUND) 和 [ICDAR2015](https://rrc.cvc.uab.es/?ch=4&com=introduction) 三个公开数据集构造了一个小规模含文字图像方向分类数据集，用于体验本案例。
 
-![](../../images/PULC/docs/text_image_orientation_original_data.png)
+![](../../../images/PULC/docs/text_image_orientation_original_data.png)
 
 <a name="3.2.2"></a>
 
@@ -155,7 +155,7 @@ print(next(result))
 
 处理后的数据集部分数据可视化如下：
 
-![](../../images/PULC/docs/text_image_orientation_data_demo.png)
+![](../../../images/PULC/docs/text_image_orientation_data_demo.png)
 
 此处提供了经过上述方法处理好的数据，可以直接下载得到。
 
@@ -205,13 +205,13 @@ cd ../
 └── label_list.txt
 ```
 
-其中`img_0/`、`img_90/`、`img_180/`和`img_270/`分别存放了4个角度的训练集和验证集数据。`train_list.txt`和`test_list.txt`分别为训练集和验证集的标签文件，`train_list.txt.debug`和`test_list.txt.debug`分别为训练集和验证集的`debug`标签文件，其分别是`train_list.txt`和`test_list.txt`的子集，用该文件可以快速体验本案例的流程。`distill_data/`是补充文字数据，该集合和`train`集合的混合数据用于本案例的`SKL-UGI知识蒸馏策略`，对应的训练标签文件为`train_list_for_distill.txt`。关于如何得到蒸馏的标签可以参考[知识蒸馏标签获得](../advanced_tutorials/ssld.md#3.2)。
+其中`img_0/`、`img_90/`、`img_180/`和`img_270/`分别存放了4个角度的训练集和验证集数据。`train_list.txt`和`test_list.txt`分别为训练集和验证集的标签文件，`train_list.txt.debug`和`test_list.txt.debug`分别为训练集和验证集的`debug`标签文件，其分别是`train_list.txt`和`test_list.txt`的子集，用该文件可以快速体验本案例的流程。`distill_data/`是补充文字数据，该集合和`train`集合的混合数据用于本案例的`SKL-UGI知识蒸馏策略`，对应的训练标签文件为`train_list_for_distill.txt`。关于如何得到蒸馏的标签可以参考[知识蒸馏标签获得](../../training/advanced/ssld.md#3.2)。
 
 **备注：**
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
-* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../advanced_tutorials/ssld.md#3.2)。
+* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../../training/advanced/ssld.md#3.2)。
 
 <a name="3.3"></a>
 
@@ -277,7 +277,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md)。
 
 <a name="4.1.1"></a>
 
@@ -319,7 +319,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -433,7 +433,7 @@ img_rot180_demo.jpg:    class id(s): [2, 1], score(s): [0.88, 0.04], label_name(
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -441,7 +441,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -449,7 +449,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -457,4 +457,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_textline_orientation.md → docs/zh_CN/models/PULC/PULC_textline_orientation.md

@@ -59,9 +59,9 @@
 
 **备注：**
 
-* 其中不带\*的模型表示分辨率为224x224，带\*的模型表示分辨率为48x192（h\*w）,数据增强从网络中的 stride 改为 `[2, [2, 1], [2, 1], [2, 1], [2, 1]]`，其中，外层列表中的每一个元素代表网络结构下采样层的stride，该策略为 [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR) 提供的文本行方向分类器方案。带\*\*的模型表示分辨率为80x160（h\*w）, 网络中的 stride 改为 `[2, [2, 1], [2, 1], [2, 1], [2, 1]]`，其中，外层列表中的每一个元素代表网络结构下采样层的stride，此分辨率是经过[超参数搜索策略](PULC_train.md#4-超参搜索)搜索得到的。
+* 其中不带\*的模型表示分辨率为224x224，带\*的模型表示分辨率为48x192（h\*w）,数据增强从网络中的 stride 改为 `[2, [2, 1], [2, 1], [2, 1], [2, 1]]`，其中，外层列表中的每一个元素代表网络结构下采样层的stride，该策略为 [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR) 提供的文本行方向分类器方案。带\*\*的模型表示分辨率为80x160（h\*w）, 网络中的 stride 改为 `[2, [2, 1], [2, 1], [2, 1], [2, 1]]`，其中，外层列表中的每一个元素代表网络结构下采样层的stride，此分辨率是经过[超参数搜索策略](../../training/PULC.md#4-超参搜索)搜索得到的。
 * 延时是基于 Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz 测试得到，开启 MKLDNN 加速策略，线程数为10。
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 <a name="2"></a>
 
@@ -139,7 +139,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -165,7 +165,7 @@ print(next(result))
 
 处理后的数据集部分数据可视化如下：
 
-![](../../images/PULC/docs/textline_orientation_data_demo.png)
+![](../../../images/PULC/docs/textline_orientation_data_demo.png)
 
 此处提供了经过上述方法处理好的数据，可以直接下载得到。
 
@@ -203,7 +203,7 @@ cd ../
 
 **备注：**
 
-* 关于 `train_list.txt`、`val_list.txt` 的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `train_list.txt`、`val_list.txt` 的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
 
 <a name="3.3"></a>
@@ -273,7 +273,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md)。
 
 <a name="4.1.1"></a>
 
@@ -314,7 +314,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。
 
@@ -430,7 +430,7 @@ textline_orientation_test_1_1.png:    class id(s): [1], score(s): [1.00], label_
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -438,7 +438,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -446,7 +446,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -454,4 +454,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_traffic_sign.md → docs/zh_CN/models/PULC/PULC_traffic_sign.md

@@ -58,7 +58,7 @@
 
 **备注：**
 
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 
 <a name="2"></a>
@@ -138,7 +138,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -234,9 +234,9 @@ traffic_sign
 
 **备注：**
 
-* 关于 `label_list_train.txt`、`label_list_test.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `label_list_train.txt`、`label_list_test.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../../training/single_label_classification/dataset.md#1-数据集格式说明) 。
 
-* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../advanced_tutorials/ssld.md)。
+* 关于如何得到蒸馏的标签文件可以参考[知识蒸馏标签获得方法](../../training/advanced/ssld.md)。
 
 
 <a name="3.3"></a>
@@ -303,7 +303,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md#3.2)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md#3.2)。
 
 <a name="4.1.1"></a>
 
@@ -344,7 +344,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.2 节](#3.2)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -458,7 +458,7 @@ python3.7 python/predict_cls.py -c configs/PULC/traffic_sign/inference_traffic_s
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -466,7 +466,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -474,7 +474,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -482,4 +482,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/PULC/PULC_vehicle_attribute.md → docs/zh_CN/models/PULC/PULC_vehicle_attribute.md

@@ -60,7 +60,7 @@
 **备注：**
 
 * 延时是基于 Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz 测试得到，开启 MKLDNN 加速策略，线程数为10。
-* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../models/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
+* 关于PP-LCNet的介绍可以参考[PP-LCNet介绍](../ImageNet1k/PP-LCNet.md)，相关论文可以查阅[PP-LCNet paper](https://arxiv.org/abs/2109.15099)。
 
 
 <a name="2"></a>
@@ -132,6 +132,7 @@ print(next(result))
 [{'attributes': 'Color: (yellow, prob: 0.9893476963043213), Type: (hatchback, prob: 0.9734097719192505)', 'output': [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], 'filename': 'pulc_demo_imgs/vehicle_attribute/0002_c002_00030670_0.jpg'}]
 ```
 
+**备注**：其中 `output` 的值索引为0-9表示颜色属性，对应的颜色分别是：yellow(黄色), orange(橙色), green(绿色), gray(灰色), red(红色), blue(蓝色), white(白色), golden(金色), brown(棕色), black(黑色)；索引为10-18表示车型属性，对应的车型分别是sedan(轿车), suv(越野车), van(面包车), hatchback(掀背车), mpv(多用途汽车), pickup(皮卡车), bus(公共汽车), truck(卡车), estate(旅行车)。
 
 <a name="3"></a>
 
@@ -141,7 +142,7 @@ print(next(result))
 
 ### 3.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="3.2"></a>
 
@@ -297,7 +298,7 @@ python3 tools/infer.py \
 
 ### 4.1 SKL-UGI 知识蒸馏
 
-SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../advanced_tutorials/ssld.md)。
+SKL-UGI 知识蒸馏是 PaddleClas 提出的一种简单有效的知识蒸馏方法，关于该方法的介绍，可以参考[SKL-UGI 知识蒸馏](../../training/advanced/ssld.md)。
 
 <a name="4.1.1"></a>
 
@@ -338,7 +339,7 @@ python3 -m paddle.distributed.launch \
 
 ## 5. 超参搜索
 
-在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](PULC_train.md#4-超参搜索)来获得更好的训练超参数。
+在 [3.3 节](#3.3)和 [4.1 节](#4.1)所使用的超参数是根据 PaddleClas 提供的 `超参数搜索策略` 搜索得到的，如果希望在自己的数据集上得到更好的结果，可以参考[超参数搜索策略](../../training/PULC.md#4-超参搜索)来获得更好的训练超参数。
 
 **备注：** 此部分内容是可选内容，搜索过程需要较长的时间，您可以根据自己的硬件情况来选择执行。如果没有更换数据集，可以忽略此节内容。
 
@@ -450,7 +451,7 @@ python3.7 python/predict_cls.py -c configs/PULC/vehicle_attribute/inference_vehi
 
 ### 6.3 基于 C++ 预测引擎推理
 
-PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../inference_deployment/cpp_deploy.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../inference_deployment/cpp_deploy_on_windows.md)完成相应的预测库编译和模型预测工作。
+PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服务器端 C++ 预测](../../deployment/image_classification/cpp/linux.md)来完成相应的推理部署。如果您使用的是 Windows 平台，可以参考[基于 Visual Studio 2019 Community CMake 编译指南](../../deployment/image_classification/cpp/windows.md)完成相应的预测库编译和模型预测工作。
 
 <a name="6.4"></a>
 
@@ -458,7 +459,7 @@ PaddleClas 提供了基于 C++ 预测引擎推理的示例，您可以参考[服
 
 Paddle Serving 提供高性能、灵活易用的工业级在线推理服务。Paddle Serving 支持 RESTful、gRPC、bRPC 等多种协议，提供多种异构硬件和多种操作系统环境下推理解决方案。更多关于Paddle Serving 的介绍，可以参考[Paddle Serving 代码仓库](https://github.com/PaddlePaddle/Serving)。
 
-PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../inference_deployment/paddle_serving_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示例，您可以参考[模型服务化部署](../../deployment/image_classification/paddle_serving.md)来完成相应的部署工作。
 
 <a name="6.5"></a>
 
@@ -466,7 +467,7 @@ PaddleClas 提供了基于 Paddle Serving 来完成模型服务化部署的示
 
 Paddle Lite 是一个高性能、轻量级、灵活性强且易于扩展的深度学习推理框架，定位于支持包括移动端、嵌入式以及服务器端在内的多硬件平台。更多关于 Paddle Lite 的介绍，可以参考[Paddle Lite 代码仓库](https://github.com/PaddlePaddle/Paddle-Lite)。
 
-PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../inference_deployment/paddle_lite_deploy.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，您可以参考[端侧部署](../../deployment/image_classification/paddle_lite.md)来完成相应的部署工作。
 
 <a name="6.6"></a>
 
@@ -474,4 +475,4 @@ PaddleClas 提供了基于 Paddle Lite 来完成模型端侧部署的示例，
 
 Paddle2ONNX 支持将 PaddlePaddle 模型格式转化到 ONNX 模型格式。通过 ONNX 可以完成将 Paddle 模型到多种推理引擎的部署，包括TensorRT/OpenVINO/MNN/TNN/NCNN，以及其它对 ONNX 开源格式进行支持的推理引擎或硬件。更多关于 Paddle2ONNX 的介绍，可以参考[Paddle2ONNX 代码仓库](https://github.com/PaddlePaddle/Paddle2ONNX)。
 
-PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../../deploy/paddle2onnx/readme.md)来完成相应的部署工作。
+PaddleClas 提供了基于 Paddle2ONNX 来完成 inference 模型转换 ONNX 模型并作推理预测的示例，您可以参考[Paddle2ONNX 模型转换与预测](../../deployment/image_classification/paddle2onnx.md)来完成相应的部署工作。

docs/zh_CN/models/PULC/README.md

+model_list.md
\ No newline at end of file

docs/zh_CN/models/index.rst

-模型库
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   DPN_DenseNet.md
-   models_intro.md
-   RepVGG.md
-   EfficientNet_and_ResNeXt101_wsl.md
-   ViT_and_DeiT.md
-   SwinTransformer.md
-   Others.md
-   SEResNext_and_Res2Net.md
-   ESNet.md
-   HRNet.md
-   ReXNet.md
-   Inception.md
-   TNT.md
-   RedNet.md
-   DLA.md
-   ResNeSt_RegNet.md
-   PP-LCNet.md
-   HarDNet.md
-   ResNet_and_vd.md
-   LeViT.md
-   Mobile.md
-   MixNet.md
-   Twins.md

docs/zh_CN/models_training/index.rst

-模型训练
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   config_description.md
-   classification.md
-   recognition.md
-   train_strategy.md

docs/zh_CN/others/index.rst

-其他
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   transfer_learning.md
-   train_with_DALI.md
-   VisualDL.md
-   train_on_xpu.md
-   feature_visiualization.md
-   paddle_mobile_inference.md
-   course_link.md
-   competition_support.md
-   update_history.md
-   versions.md
-   
-   
-   
-   

docs/zh_CN/others/versions.md

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

docs/zh_CN/PULC/PULC_quickstart.md → docs/zh_CN/quick_start/PULC.md

@@ -7,8 +7,8 @@
 ## 目录
 
 - [1. 安装](#1)
-  - [1.1 安装PaddlePaddle](#11)
-  - [1.2 安装PaddleClas whl包](#12)
+  - [1.1 安装PaddlePaddle](#1.1)
+  - [1.2 安装PaddleClas whl包](#1.2)
 - [2. 快速体验](#2)
   - [2.1 命令行使用](#2.1)
   - [2.2 Python脚本使用](#2.2)
@@ -122,4 +122,4 @@ PULC 系列模型的名称和简介如下：
 
 通过本节内容，相信您已经熟练掌握 PaddleClas whl 包的 PULC 模型使用方法并获得了初步效果。
 
-PULC 方法产出的系列模型在人、车、OCR等方向的多个场景中均验证有效，用超轻量模型就可实现与 SwinTransformer 模型接近的精度，预测速度提高 40+ 倍。并且打通数据、模型训练、压缩和推理部署全流程，具体地，您可以参考[PULC有人/无人分类模型](PULC_person_exists.md)、[PULC人体属性识别模型](PULC_person_attribute.md)、[PULC佩戴安全帽分类模型](PULC_safety_helmet.md)、[PULC交通标志分类模型](PULC_traffic_sign.md)、[PULC车辆属性识别模型](PULC_vehicle_attribute.md)、[PULC有车/无车分类模型](PULC_car_exists.md)、[PULC含文字图像方向分类模型](PULC_text_image_orientation.md)、[PULC文本行方向分类模型](PULC_textline_orientation.md)、[PULC语种分类模型](PULC_language_classification.md)。
+PULC 方法产出的系列模型在人、车、OCR等方向的多个场景中均验证有效，用超轻量模型就可实现与 SwinTransformer 模型接近的精度，预测速度提高 40+ 倍。并且打通数据、模型训练、压缩和推理部署全流程，具体地，您可以参考[PULC有人/无人分类模型](../models/PULC/PULC_person_exists.md)、[PULC人体属性识别模型](../models/PULC/PULC_person_attribute.md)、[PULC佩戴安全帽分类模型](../models/PULC/PULC_safety_helmet.md)、[PULC交通标志分类模型](../models/PULC/PULC_traffic_sign.md)、[PULC车辆属性识别模型](../models/PULC/PULC_vehicle_attribute.md)、[PULC有车/无车分类模型](../models/PULC/PULC_car_exists.md)、[PULC含文字图像方向分类模型](../models/PULC/PULC_text_image_orientation.md)、[PULC文本行方向分类模型](../models/PULC/PULC_textline_orientation.md)、[PULC语种分类模型](../models/PULC/PULC_language_classification.md)。

docs/zh_CN/quick_start/index.rst

-快速开始
-================================
-
-.. toctree::
-   :maxdepth: 2
-
-   quick_start_classification_new_user.md
-   quick_start_classification_professional.md
-   quick_start_recognition.md
-   quick_start_multilabel_classification.md

docs/zh_CN/advanced_tutorials/code_overview.md → docs/zh_CN/quick_start/overview.md

@@ -245,15 +245,15 @@ Slim:
     name: pact
 ```
 
-训练方法详见模型[裁剪量化使用介绍](../advanced_tutorials/model_prune_quantization.md)，
-算法介绍详见[裁剪量化算法介绍](../algorithm_introduction/model_prune_quantization.md)。
+训练方法详见模型[裁剪量化使用介绍](../training/advanced/prune_quantization.md)，
+算法介绍详见[裁剪量化算法介绍](../algorithm_introduction/prune_quantization.md)。
 
 <a name="3"></a>
 ## 3. 预测部署代码和方式
 
-* 如果希望将对分类模型进行离线量化，可以参考 [模型量化裁剪教程](../advanced_tutorials/model_prune_quantization.md) 中离线量化部分。
-* 如果希望在服务端使用 python 进行部署，可以参考 [python inference 预测教程](../inference_deployment/python_deploy.md)。
-* 如果希望在服务端使用 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)。
+* 如果希望将对分类模型进行离线量化，可以参考 [模型量化裁剪教程](../training/advanced/prune_quantization.md) 中离线量化部分。
+* 如果希望在服务端使用 python 进行部署，可以参考 [python inference 预测教程](../deployment/image_classification/python.md)。
+* 如果希望在服务端使用 cpp 进行部署，可以参考 [cpp inference 预测教程](../deployment/image_classification/cpp/linux.md)。
+* 如果希望将分类模型部署为服务，可以参考 [hub serving 预测部署教程](../deployment/image_classification/paddle_hub.md)。
+* 如果希望在移动端使用分类模型进行预测，可以参考 [PaddleLite 预测部署教程](../deployment/image_classification/paddle_lite.md)。
+* 如果希望使用 whl 包对分类模型进行预测，可以参考 [whl 包预测](../deployment/image_classification/whl.md)。

docs/zh_CN/quick_start/quick_start_classification_new_user.md

@@ -8,12 +8,12 @@
 * [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)
+    * [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>
@@ -48,7 +48,7 @@
 
 ##  2. 环境安装与配置
 
-具体安装步骤可详看[环境准备](../installation/install_paddleclas.md)。
+具体安装步骤可详看[环境准备](../installation.md)。
 
 <a name='3'></a>
 

docs/zh_CN/quick_start/quick_start_classification_professional.md

 # 30 分钟玩转 PaddleClas（进阶版）
 
-此处提供了专业用户在 linux 操作系统上使用 PaddleClas 的快速上手教程，主要内容基于 CIFAR-100 数据集，快速体验不同模型的训练、加载不同预训练模型、SSLD 知识蒸馏方案和数据增广的效果。请事先参考[安装指南](../installation/install_paddleclas.md)配置运行环境和克隆 PaddleClas 代码。
+此处提供了专业用户在 linux 操作系统上使用 PaddleClas 的快速上手教程，主要内容基于 CIFAR-100 数据集，快速体验不同模型的训练、加载不同预训练模型、SSLD 知识蒸馏方案和数据增广的效果。请事先参考[安装指南](../installation.md)配置运行环境和克隆 PaddleClas 代码。
 
 ------
 
@@ -37,7 +37,7 @@
 cd path_to_PaddleClas
 ```
 
-<a name="1.1.1"></a> 
+<a name="1.1.1"></a>
 
 #### 1.1.1 准备 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 零基础训练：不加载预训练模型的训练
 
@@ -87,12 +87,12 @@ python3 -m paddle.distributed.launch \
         -o Optimizer.lr.learning_rate=0.01
 ```
 
-* **注意**: 
+* **注意**:
 
 * `--gpus`中指定的 GPU 可以是 `CUDA_VISIBLE_DEVICES` 指定的 GPU 的子集。
 * 由于初始学习率和 batch-size 需要保持线性关系，所以训练从 4 个 GPU 切换到 1 个 GPU 训练时，总 batch-size 缩减为原来的 1/4，学习率也需要缩减为原来的 1/4，所以改变了默认的学习率从 0.04 到 0.01。
 
-<a name="2.1.2"></a> 
+<a name="2.1.2"></a>
 
 
 #### 2.1.2 迁移学习
@@ -145,13 +145,13 @@ python3 -m paddle.distributed.launch \
 
 ## 3. 数据增广
 
-PaddleClas 包含了很多数据增广的方法，如 Mixup、Cutout、RandomErasing 等，具体的方法可以参考[数据增广的章节](../algorithm_introduction/DataAugmentation.md)。
+PaddleClas 包含了很多数据增广的方法，如 Mixup、Cutout、RandomErasing 等，具体的方法可以参考[数据增广的章节](../algorithm_introduction/data_augmentation.md)。
 
-<a name="3.1"></a> 
+<a name="3.1"></a>
 
 ### 3.1 数据增广的尝试-Mixup
 
-基于[数据增广的章节](../algorithm_introduction/DataAugmentation.md) `3.3 节` 中的训练方法，结合 Mixup 的数据增广方式进行训练，具体的训练脚本如下所示。
+基于[数据增广的章节](../algorithm_introduction/data_augmentation.md) `3.3 节` 中的训练方法，结合 Mixup 的数据增广方式进行训练，具体的训练脚本如下所示。
 
 ```shell
 export CUDA_VISIBLE_DEVICES=0,1,2,3
@@ -243,11 +243,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 单标签分类模型评估。
 
@@ -259,7 +259,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 单标签分类模型预测
 
@@ -272,7 +272,7 @@ 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 模型进行模型推理
 

docs/zh_CN/quick_start/quick_start_multilabel_classification.md

 # 多标签分类 quick start
 
-基于 [NUS-WIDE-SCENE](https://lms.comp.nus.edu.sg/wp-content/uploads/2019/research/nuswide/NUS-WIDE.html) 数据集，体验多标签分类的训练、评估、预测的过程，该数据集是 NUS-WIDE 数据集的一个子集。请首先安装 PaddlePaddle 和 PaddleClas，具体安装步骤可详看 [环境准备](../installation/install_paddleclas.md)。
+基于 [NUS-WIDE-SCENE](https://lms.comp.nus.edu.sg/wp-content/uploads/2019/research/nuswide/NUS-WIDE.html) 数据集，体验多标签分类的训练、评估、预测的过程，该数据集是 NUS-WIDE 数据集的一个子集。请首先安装 PaddlePaddle 和 PaddleClas，具体安装步骤可详看 [环境准备](../installation.md)。
 
 
 ## 目录
@@ -50,6 +50,10 @@ python3 -m paddle.distributed.launch \
 
 训练 10 epoch 之后，验证集最好的正确率应该在 0.95 左右。
 
+**注意:**
+1. 目前多标签分类的损失函数仅支持`MultiLabelLoss`(BCE Loss)。
+2. 目前多标签分类的评估指标支持`AccuracyScore`和`HammingDistance`,其他评估指标敬请期待。
+
 <a name="3"></a>
 
 ## 3. 模型评估
@@ -70,8 +74,8 @@ python3 tools/infer.py \
 ```
 
 得到类似下面的输出：
-```  
-[{'class_ids': [6, 13, 17, 23, 26, 30], 'scores': [0.95683, 0.5567, 0.55211, 0.99088, 0.5943, 0.78767], 'file_name': './deploy/images/0517_2715693311.jpg', 'label_names': []}]
+```
+[{'class_ids': [6, 13, 17, 23, 30], 'scores': [0.98217, 0.78129, 0.64377, 0.9942, 0.96109], 'label_names': ['clouds', 'lake', 'ocean', 'sky', 'water'], 'file_name': 'deploy/images/0517_2715693311.jpg'}]
 ```
 
 <a name="5"></a>
@@ -100,10 +104,13 @@ cd ./deploy
 
 ```
 python3 python/predict_cls.py \
-     -c configs/inference_multilabel_cls.yaml
+     -c configs/inference_cls_multilabel.yaml
 ```
+推理图片如下：
 
-得到类似下面的输出：
+![](../../images/quick_start/multi_label_demo.png)
+
+执行推理命令后，得到类似下面的输出：
 ```
-0517_2715693311.jpg:    class id(s): [6, 13, 17, 23, 26, 30], score(s): [0.96, 0.56, 0.55, 0.99, 0.59, 0.79], label_name(s): []
+0517_2715693311.jpg:    class id(s): [6, 13, 17, 23, 30], score(s): [0.98, 0.78, 0.64, 0.99, 0.96], label_name(s): ['clouds', 'lake', 'ocean', 'sky', 'water']
 ```

docs/zh_CN/quick_start/quick_start_recognition.md

@@ -82,7 +82,7 @@
 
 ### 2.1 环境配置
 
-* 安装：请先参考文档 [环境准备](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考文档 [环境准备](../installation.md) 配置 PaddleClas 运行环境。
 
 * 进入 `deploy` 运行目录。本部分所有内容与命令均需要在 `deploy` 目录下运行，可以通过下面的命令进入 `deploy` 目录。
 
@@ -107,7 +107,7 @@
 
 本章节 demo 数据下载地址如下: [drink_dataset_v2.0.tar(瓶装饮料数据)](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/drink_dataset_v2.0.tar)，
 
-下面以 **drink_dataset_v2.0.tar** 为例介绍PC端的 PP-ShiTu 快速体验流程。用户也可以自行下载并解压其它场景的数据进行体验：[22种场景数据下载](../introduction/ppshitu_application_scenarios.md#1-应用场景介绍)。
+下面以 **drink_dataset_v2.0.tar** 为例介绍PC端的 PP-ShiTu 快速体验流程。用户也可以自行下载并解压其它场景的数据进行体验：[22种场景数据下载](../deployment/PP-ShiTu/application_scenarios.md#1-应用场景介绍)。
 
 如果希望体验服务端主体检测和各垂类方向的识别模型，可以参考 [2.4 服务端识别模型列表](#24-服务端识别模型列表)
 
@@ -300,7 +300,7 @@ python3.7 python/predict_system.py -c configs/inference_general.yaml -o Global.i
 python3.7 python/build_gallery.py -c configs/inference_general.yaml -o IndexProcess.data_file="./drink_dataset_v2.0/gallery/drink_label_all.txt" -o IndexProcess.index_dir="./drink_dataset_v2.0/index_all"
 ```
 
-最终构建完毕的新的索引库保存在文件夹 `./drink_dataset_v2.0/index_all` 下。具体 `yaml` 请参考[向量检索文档](../image_recognition_pipeline/vector_search.md)。
+最终构建完毕的新的索引库保存在文件夹 `./drink_dataset_v2.0/index_all` 下。具体 `yaml` 请参考[向量检索文档](../deployment/PP-ShiTu/vector_search.md)。
 
 <a name="基于新的索引库的图像识别"></a>
 
@@ -377,4 +377,4 @@ wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/recognit
 
 按照上述步骤下载模型和测试数据后，您可以重新建立索引库，并进行相关方向识别模型的测试。
 
-* 更多关于主体检测的介绍可以参考：[主体检测教程文档](../image_recognition_pipeline/mainbody_detection.md)；关于特征提取的介绍可以参考：[特征提取教程文档](../image_recognition_pipeline/feature_extraction.md)；关于向量检索的介绍可以参考：[向量检索教程文档](../image_recognition_pipeline/vector_search.md)。
+* 更多关于主体检测的介绍可以参考：[主体检测教程文档](../training/PP-ShiTu/mainbody_detection.md)；关于特征提取的介绍可以参考：[特征提取教程文档](../training/PP-ShiTu/feature_extraction.md)；关于向量检索的介绍可以参考：[向量检索教程文档](../deployment/PP-ShiTu/vector_search.md)。

docs/zh_CN/samples/Fresh_Food_Recogniiton/README.md

@@ -12,10 +12,9 @@
 
 深圳市银歌云技术有限公司基于飞桨的图像识别开发套件PaddleClas，提供了一套基于计算机视觉的完整生鲜品自主结算方案，其通过结算平台的摄像头拍摄的图像，自动的识别称上的商品，整个流程在1秒内完成，无需售卖人员的操作及称重。整个流程，实现了精度高、速度快，无需人工干预的自动结算效果。减少人工成本的同时，大大提高了效率和用户体验。
 
-本案例使用了飞桨图像分类开发套件中的通用图像识别系统[PP-ShiTuV2](../../PPShiTu/PPShiTuV2_introduction.md)。
+本案例使用了飞桨图像分类开发套件中的通用图像识别系统[PP-ShiTuV2](../../models/PP-ShiTu/README.md)。
 
 
 ![result](./imgs/yingeo.png)
 
 **注**: AI Studio在线运行代码请参考[生鲜品自主结算](https://aistudio.baidu.com/aistudio/projectdetail/4486158)
-

docs/zh_CN/algorithm_introduction/action_rec_by_classification.md → docs/zh_CN/samples/action_rec_by_classification.md

@@ -44,7 +44,7 @@
 <a name="2.1"></a>
 
 ### 2.1 PaddleClas 环境安装
-请根据[环境准备](../installation/install_paddleclas.md)完成PaddleClas的环境依赖准备。
+请根据[环境准备](../installation.md)完成PaddleClas的环境依赖准备。
 
 <a name="2.2"></a>
 
@@ -71,7 +71,7 @@
 <a name="2.2.3"></a>
 
 #### 2.2.3 标注文件准备
-根据[PaddleClas数据集格式说明](../data_preparation/classification_dataset.md)，标注文件样例如下，其中`0`,`1`分别是图片对应所属的类别：
+根据[PaddleClas数据集格式说明](../training/single_label_classification/dataset.md)，标注文件样例如下，其中`0`,`1`分别是图片对应所属的类别：
 ```
     # 每一行采用"空格"分隔图像路径与标注
     train/000001.jpg 0
@@ -88,9 +88,9 @@
 
 完成上述内容后，放置于`dataset`目录下，文件结构如下：
 ```
-data/ 
+data/
 ├── images  # 放置所有图片
-├── phone_label_list.txt # 标签文件 
+├── phone_label_list.txt # 标签文件
 ├── phone_train_list.txt # 训练列表，包含图片及其对应类型
 └── phone_val_list.txt   # 测试列表，包含图片及其对应类型
 ```
@@ -104,7 +104,7 @@ export CUDA_VISIBLE_DEVICES=0,1,2,3
 python3 -m paddle.distributed.launch \
     --gpus="0,1,2,3" \
     tools/train.py \
-        -c ./ppcls/configs/practical_models/PPHGNet_tiny_calling_halfbody.yaml \ 
+        -c ./ppcls/configs/practical_models/PPHGNet_tiny_calling_halfbody.yaml \
         -o Arch.pretrained=True
 ```
 其中 `Arch.pretrained` 为 `True`表示使用预训练权重帮助训练。

docs/zh_CN/image_recognition_pipeline/deep_hashing.md → docs/zh_CN/training/PP-ShiTu/deep_hashing.md

@@ -10,8 +10,8 @@
 ## 目录
 
 - [1. 特征模型二值特征训练](#1)
-	- [1.1 PP-ShiTu特征提取模型二值训练](#1.1)
-	- [1.2 其他特征模型二值训练](#1.2)
+    - [1.1 PP-ShiTu特征提取模型二值训练](#1.1)
+    - [1.2 其他特征模型二值训练](#1.2)
 - [2. 检索算法配置](#2)
 
 <a name="1"></a>
@@ -47,15 +47,15 @@ python3.7 -m paddle.distributed.launch tools/train.py \
 
 ### 1.2 其他特征模型二值训练
 
-其他二值特征训练模型的配置文件位于`ppcls/configs/DeepHash/`文件夹下，此文件夹下的相关配置文件主要是复现相关`deep hashing`相关算法。包括：`DCH, DSHSD, LCDSH`三种算法。这三种算法相关介绍，详见[Deep Hashing相关算法介绍](../algorithm_introduction/deep_hashing_introduction.md)。
+其他二值特征训练模型的配置文件位于`ppcls/configs/DeepHash/`文件夹下，此文件夹下的相关配置文件主要是复现相关`deep hashing`相关算法。包括：`DCH, DSHSD, LCDSH`三种算法。这三种算法相关介绍，详见[Deep Hashing相关算法介绍](../../algorithm_introduction/deep_hashing.md)。
 
-相关训练方法，请参考[分类模型训练文档](../models_training/classification.md)。
+相关训练方法，请参考[分类模型训练文档](../single_label_classification/training.md)。
 
 <a name="2"></a>
 
 ## 2. 检索算法配置
 
-在PP-ShiTu中使用二值特征，部署及离线推理配置请参考`deploy/configs/inference_general_binary.yaml`。配置文件中相关参数介绍请参考[向量检索文档](./vector_search.md).
+在PP-ShiTu中使用二值特征，部署及离线推理配置请参考`deploy/configs/inference_general_binary.yaml`。配置文件中相关参数介绍请参考[向量检索文档](../../deployment/PP-ShiTu/vector_search.md).
 
 其中需值得注意的是，二值检索相关配置应设置如下：
 

docs/zh_CN/image_recognition_pipeline/feature_extraction.md → docs/zh_CN/training/PP-ShiTu/feature_extraction.md

-简体中文 | [English](../../en/image_recognition_pipeline/feature_extraction_en.md)
+简体中文 | [English](../../../en/image_recognition_pipeline/feature_extraction_en.md)
 # 特征提取
 
 ## 目录
 
-- [1. 摘要](#1-摘要)
-- [2. 介绍](#2-介绍)
-- [3. 方法](#3-方法)
-    - [3.1 Backbone](#31-backbone)
-    - [3.2 Neck](#32-neck)
-    - [3.3 Head](#33-head)
-    - [3.4 Loss](#34-loss)
-    - [3.5 Data Augmentation](#35-data-augmentation)
-- [4. 实验部分](#4-实验部分)
-- [5. 自定义特征提取](#5-自定义特征提取)
-  - [5.1 数据准备](#51-数据准备)
-  - [5.2 模型训练](#52-模型训练)
-  - [5.3 模型评估](#53-模型评估)
-  - [5.4 模型推理](#54-模型推理)
-    - [5.4.1 导出推理模型](#541-导出推理模型)
-    - [5.4.2 获取特征向量](#542-获取特征向量)
-- [6. 总结](#6-总结)
-- [7. 参考文献](#7-参考文献)
+- [特征提取](#特征提取)
+  - [目录](#目录)
+  - [1. 摘要](#1-摘要)
+  - [2. 介绍](#2-介绍)
+  - [3. 方法](#3-方法)
+      - [3.1 Backbone](#31-backbone)
+      - [3.2 Neck](#32-neck)
+      - [3.3 Head](#33-head)
+      - [3.4 Loss](#34-loss)
+      - [3.5 Data Augmentation](#35-data-augmentation)
+  - [4. 实验部分](#4-实验部分)
+  - [5. 自定义特征提取](#5-自定义特征提取)
+    - [5.1 数据准备](#51-数据准备)
+    - [5.2 模型训练](#52-模型训练)
+    - [5.3 模型评估](#53-模型评估)
+    - [5.4 模型推理](#54-模型推理)
+      - [5.4.1 导出推理模型](#541-导出推理模型)
+      - [5.4.2 获取特征向量](#542-获取特征向量)
+  - [6. 总结](#6-总结)
+  - [7. 参考文献](#7-参考文献)
 
 <a name="1"></a>
 
 ## 1. 摘要
 
-特征提取是图像识别中的关键一环，它的作用是将输入的图片转化为固定维度的特征向量，用于后续的[向量检索](./vector_search.md)。一个好的特征需要具备“相似度保持性”，即相似度高的图片对，其特征的相似度也比较高（特征空间中的距离比较近），相似度低的图片对，其特征相似度要比较低（特征空间中的距离比较远）。为此[Deep Metric Learning](../algorithm_introduction/metric_learning.md)领域内提出了不少方法用以研究如何通过深度学习来获得具有强表征能力的特征。
+特征提取是图像识别中的关键一环，它的作用是将输入的图片转化为固定维度的特征向量，用于后续的[向量检索](../../deployment/PP-ShiTu/vector_search.md)。一个好的特征需要具备“相似度保持性”，即相似度高的图片对，其特征的相似度也比较高（特征空间中的距离比较近），相似度低的图片对，其特征相似度要比较低（特征空间中的距离比较远）。为此[Deep Metric Learning](../../algorithm_introduction/metric_learning.md)领域内提出了不少方法用以研究如何通过深度学习来获得具有强表征能力的特征。
 
 <a name="2"></a>
 
 ## 2. 介绍
 
 为了图像识别任务的灵活定制，我们将整个网络分为 Backbone、 Neck、 Head 以及 Loss 部分，整体结构如下图所示:
-![](../../images/feature_extraction_framework.png)
+![](../../../images/feature_extraction_framework.png)
 图中各个模块的功能为:
 
-- **Backbone**: 用于提取输入图像初步特征的骨干网络，一般由配置文件中的 [Backbone](../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L33-L37) 以及 [BackboneStopLayer](../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L38-L39) 字段共同指定。
-- **Neck**: 用以特征增强及特征维度变换。可以是一个简单的 FC Layer，用来做特征维度变换；也可以是较复杂的 FPN 结构，用以做特征增强，一般由配置文件中的 [Neck](../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L40-L51) 字段指定。
-- **Head**: 用来将 `Neck` 的输出 feature 转化为 logits，让模型在训练阶段能以分类任务的形式进行训练。除了常用的 FC Layer 外，还可以替换为 [CosMargin](../../../ppcls/arch/gears/cosmargin.py), [ArcMargin](../../../ppcls/arch/gears/arcmargin.py), [CircleMargin](../../../ppcls/arch/gears/circlemargin.py) 等模块，一般由配置文件中的 [Head](`../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L52-L60) 字段指定。
-- **Loss**: 指定所使用的 Loss 函数。我们将 Loss 设计为组合 loss 的形式，可以方便地将 Classification Loss 和 Metric learning Loss 组合在一起，一般由配置文件中的 [Loss](../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L63-L77) 字段指定。
+- **Backbone**: 用于提取输入图像初步特征的骨干网络，一般由配置文件中的 [Backbone](../../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L33-L37) 以及 [BackboneStopLayer](../../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L38-L39) 字段共同指定。
+- **Neck**: 用以特征增强及特征维度变换。可以是一个简单的 FC Layer，用来做特征维度变换；也可以是较复杂的 FPN 结构，用以做特征增强，一般由配置文件中的 [Neck](../../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L40-L51) 字段指定。
+- **Head**: 用来将 `Neck` 的输出 feature 转化为 logits，让模型在训练阶段能以分类任务的形式进行训练。除了常用的 FC Layer 外，还可以替换为 [CosMargin](../../../../ppcls/arch/gears/cosmargin.py), [ArcMargin](../../../../ppcls/arch/gears/arcmargin.py), [CircleMargin](../../../../ppcls/arch/gears/circlemargin.py) 等模块，一般由配置文件中的 [Head](../../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L52-L60) 字段指定。
+- **Loss**: 指定所使用的 Loss 函数。我们将 Loss 设计为组合 loss 的形式，可以方便地将 Classification Loss 和 Metric learning Loss 组合在一起，一般由配置文件中的 [Loss](../../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L63-L77) 字段指定。
 
 <a name="3"></a>
 
@@ -47,26 +49,26 @@
 
 #### 3.1 Backbone
 
-Backbone 部分采用了 [PP-LCNetV2_base](../models/PP-LCNetV2.md)，其在 `PPLCNet_V1` 的基础上，加入了包括Rep 策略、PW 卷积、Shortcut、激活函数改进、SE 模块改进等多个优化点，使得最终分类精度与 `PPLCNet_x2_5` 相近，且推理延时减少了40%<sup>*</sup>。在实验过程中我们对 `PPLCNetV2_base` 进行了适当的改进，在保持速度基本不变的情况下，让其在识别任务中得到更高的性能，包括：去掉 `PPLCNetV2_base` 末尾的 `ReLU` 和 `FC`、将最后一个 stage(RepDepthwiseSeparable) 的 stride 改为1。
+Backbone 部分采用了 [PP-LCNetV2_base](../../models/ImageNet1k/PP-LCNetV2.md)，其在 `PPLCNet_V1` 的基础上，加入了包括Rep 策略、PW 卷积、Shortcut、激活函数改进、SE 模块改进等多个优化点，使得最终分类精度与 `PPLCNet_x2_5` 相近，且推理延时减少了40%<sup>*</sup>。在实验过程中我们对 `PPLCNetV2_base` 进行了适当的改进，在保持速度基本不变的情况下，让其在识别任务中得到更高的性能，包括：去掉 `PPLCNetV2_base` 末尾的 `ReLU` 和 `FC`、将最后一个 stage(RepDepthwiseSeparable) 的 stride 改为1。
 
 
 **注：** <sup>*</sup>推理环境基于 Intel(R) Xeon(R) Gold 6271C CPU @ 2.60GHz 硬件平台，OpenVINO 推理平台。
 
 #### 3.2 Neck
 
-Neck 部分采用了 [BN Neck](../../../ppcls/arch/gears/bnneck.py)，对 Backbone 抽取得到的特征的每个维度进行标准化操作，减少了同时优化度量学习损失函数和分类损失函数的难度，加快收敛速度。
+Neck 部分采用了 [BN Neck](../../../../ppcls/arch/gears/bnneck.py)，对 Backbone 抽取得到的特征的每个维度进行标准化操作，减少了同时优化度量学习损失函数和分类损失函数的难度，加快收敛速度。
 
 #### 3.3 Head
 
-Head 部分选用 [FC Layer](../../../ppcls/arch/gears/fc.py)，使用分类头将 feature 转换成 logits 供后续计算分类损失。
+Head 部分选用 [FC Layer](../../../../ppcls/arch/gears/fc.py)，使用分类头将 feature 转换成 logits 供后续计算分类损失。
 
 #### 3.4 Loss
 
-Loss 部分选用 [Cross entropy loss](../../../ppcls/loss/celoss.py) 和 [TripletAngularMarginLoss](../../../ppcls/loss/tripletangularmarginloss.py)，在训练时以分类损失和基于角度的三元组损失来指导网络进行优化。我们基于原始的 TripletLoss (困难三元组损失)进行了改进，将优化目标从 L2 欧几里得空间更换成余弦空间，并加入了 anchor 与 positive/negtive 之间的硬性距离约束，让训练与测试的目标更加接近，提升模型的泛化能力。详细的配置文件见 [GeneralRecognitionV2_PPLCNetV2_base.yaml](../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L63-77)。
+Loss 部分选用 [Cross entropy loss](../../../../ppcls/loss/celoss.py) 和 [TripletAngularMarginLoss](../../../../ppcls/loss/tripletangularmarginloss.py)，在训练时以分类损失和基于角度的三元组损失来指导网络进行优化。我们基于原始的 TripletLoss (困难三元组损失)进行了改进，将优化目标从 L2 欧几里得空间更换成余弦空间，并加入了 anchor 与 positive/negtive 之间的硬性距离约束，让训练与测试的目标更加接近，提升模型的泛化能力。详细的配置文件见 [GeneralRecognitionV2_PPLCNetV2_base.yaml](../../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L63-77)。
 
 #### 3.5 Data Augmentation
 
-我们考虑到实际相机拍摄时目标主体可能出现一定的旋转而不一定能保持正立状态，因此我们在数据增强中加入了适当的 [随机旋转增强](../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L117)，以提升模型在真实场景中的检索能力。
+我们考虑到实际相机拍摄时目标主体可能出现一定的旋转而不一定能保持正立状态，因此我们在数据增强中加入了适当的 [随机旋转增强](../../../../ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml#L117)，以提升模型在真实场景中的检索能力。
 
 <a name="4"></a>
 
@@ -121,7 +123,7 @@ Loss 部分选用 [Cross entropy loss](../../../ppcls/loss/celoss.py) 和 [Tripl
 
 ### 5.1 数据准备
 
-首先需要基于任务定制自己的数据集。数据集格式与文件结构详见 [数据集格式说明](../data_preparation/recognition_dataset.md)。
+首先需要基于任务定制自己的数据集。数据集格式与文件结构详见 [数据集格式说明](../metric_learning/dataset.md)。
 
 准备完毕之后还需要在配置文件中修改数据配置相关的内容, 主要包括数据集的地址以及类别数量。对应到配置文件中的位置如下所示：
 
@@ -185,14 +187,14 @@ Loss 部分选用 [Cross entropy loss](../../../ppcls/loss/celoss.py) 和 [Tripl
 **注意：**
 配置文件中默认采用`在线评估`的方式，如果你想加快训练速度，可以关闭`在线评估`功能，只需要在上述命令的后面，增加 `-o Global.eval_during_train=False`。
 
-训练完毕后，在 output 目录下会生成最终模型文件 `latest.pdparams`，`best_model.pdarams` 和训练日志文件 `train.log`。其中，`best_model` 保存了当前评测指标下的最佳模型，`latest` 用来保存最新生成的模型, 方便在任务中断的情况下从断点位置恢复训练。通过在上述训练命令的末尾加上`-o Global.checkpoint="path_to_resume_checkpoint"`即可从断点恢复训练，示例如下。
+训练完毕后，在 output 目录下会生成最终模型文件 `latest.pdparams`，`best_model.pdarams` 和训练日志文件 `train.log`。其中，`best_model` 保存了当前评测指标下的最佳模型，`latest` 用来保存最新生成的模型, 方便在任务中断的情况下从断点位置恢复训练。通过在上述训练命令的末尾加上`-o Global.checkpoints="path_to_resume_checkpoint"`即可从断点恢复训练，示例如下。
 
 - 单机单卡断点恢复训练
   ```shell
   export CUDA_VISIBLE_DEVICES=0
   python3.7 tools/train.py \
   -c ./ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml \
-  -o Global.checkpoint="output/RecModel/latest"
+  -o Global.checkpoints="output/RecModel/latest"
   ```
 - 单机多卡断点恢复训练
   ```shell
@@ -200,7 +202,7 @@ Loss 部分选用 [Cross entropy loss](../../../ppcls/loss/celoss.py) 和 [Tripl
   python3.7 -m paddle.distributed.launch --gpus="0,1,2,3" \
   tools/train.py \
   -c ./ppcls/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base.yaml \
-  -o Global.checkpoint="output/RecModel/latest"
+  -o Global.checkpoints="output/RecModel/latest"
   ```
 
 <a name="5.3"></a>
@@ -265,7 +267,7 @@ wangzai.jpg:    [-7.82453567e-02  2.55877394e-02 -3.66694555e-02  1.34572461e-02
  -3.40284109e-02  8.35561901e-02  2.10910216e-02 -3.27066667e-02]
 ```
 
-在实际使用过程中，仅仅得到特征可能并不能满足业务需求。如果想进一步通过特征检索来进行图像识别，可以参照文档 [向量检索](./vector_search.md)。
+在实际使用过程中，仅仅得到特征可能并不能满足业务需求。如果想进一步通过特征检索来进行图像识别，可以参照文档 [向量检索](../../deployment/PP-ShiTu/vector_search.md)。
 
 <a name="6"></a>
 

docs/zh_CN/image_recognition_pipeline/mainbody_detection.md → docs/zh_CN/training/PP-ShiTu/mainbody_detection.md

@@ -116,7 +116,7 @@ pip install -r requirements.txt
 
 我们使用 [mainbody_detection/picodet_lcnet_x2_5_640_mainbody.yml](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.3/configs/picodet/application/mainbody_detection/picodet_lcnet_x2_5_640_mainbody.yml) 配置进行训练，配置文件摘要如下：
 
-![](../../images/det/PaddleDetection_config.png)
+![](../../../images/det/PaddleDetection_config.png)
 
 从上图看到 `mainbody_detection/picodet_lcnet_x2_5_640_mainbody.yml` 配置需要依赖其他的配置文件，这些配置文件的含义如下:
 
@@ -221,7 +221,7 @@ python tools/export_model.py -c configs/picodet/application/mainbody_detection/p
 
 导出模型之后，在主体检测与识别任务中，就可以将检测模型的路径更改为该 inference 模型路径，完成预测。
 
-以商品识别为例，其配置文件为 [inference_product.yaml](../../../deploy/configs/inference_product.yaml)，修改其中的 `Global.det_inference_model_dir` 字段为导出的主体检测 inference 模型目录，参考[图像识别快速开始教程](../quick_start/quick_start_recognition.md)，即可完成商品检测与识别过程。
+以商品识别为例，其配置文件为 [inference_product.yaml](../../../../deploy/configs/inference_product.yaml)，修改其中的 `Global.det_inference_model_dir` 字段为导出的主体检测 inference 模型目录，参考[图像识别快速开始教程](../../quick_start/quick_start_recognition.md)，即可完成商品检测与识别过程。
 
 <a name="4.3"></a>
 ### 4.3 其他推理方式

docs/zh_CN/PULC/PULC_train.md → docs/zh_CN/training/PULC.md

@@ -32,7 +32,7 @@ PULC 方案在人、车、OCR等方向的多个场景中均验证有效，用超
 
 方案主要包括 4 部分，分别是：PP-LCNet轻量级骨干网络、SSLD预训练权重、数据增强策略集成(EDA)和 SKL-UGI 知识蒸馏算法。此外，我们还采用了超参搜索的方法，高效优化训练中的超参数。下面，我们以有人/无人场景为例，对方案进行说明。
 
-**备注**：针对一些特定场景，我们提供了基础的训练文档供参考，例如[有人/无人分类模型](PULC_person_exists.md)等，您可以在[这里](./PULC_model_list.md)找到这些文档。如果这些文档中的方法不能满足您的需求，或者您需要自定义训练任务，您可以参考本文档。
+**备注**：针对一些特定场景，我们提供了基础的训练文档供参考，例如[有人/无人分类模型](../models/PULC/PULC_person_exists.md)等，您可以在[这里](../models/PULC/model_list.md)找到这些文档。如果这些文档中的方法不能满足您的需求，或者您需要自定义训练任务，您可以参考本文档。
 
 <a name="2"></a>
 
@@ -51,7 +51,7 @@ train/10.jpg 1
 ...
 ```
 
-如果您想获取更多常用分类数据集的信息，可以参考文档可以参考 [PaddleClas 分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+如果您想获取更多常用分类数据集的信息，可以参考文档可以参考 [PaddleClas 分类数据集格式说明](single_label_classification/dataset.md#1-数据集格式说明) 。
 
 <a name="2.2"></a>
 
@@ -105,7 +105,7 @@ cd ../
 
 #### 3.1 骨干网络PP-LCNet
 
-PULC 采用了轻量骨干网络 PP-LCNet，相比同精度竞品速度快 50%，您可以在[PP-LCNet介绍](../models/PP-LCNet.md)查阅该骨干网络的详细介绍。
+PULC 采用了轻量骨干网络 PP-LCNet，相比同精度竞品速度快 50%，您可以在[PP-LCNet介绍](../models/ImageNet1k/PP-LCNet.md)查阅该骨干网络的详细介绍。
 直接使用 PP-LCNet 训练的命令为：
 
 ```shell
@@ -152,14 +152,14 @@ python3 -m paddle.distributed.launch \
 
 #### 3.2 SSLD预训练权重
 
-SSLD 是百度自研的半监督蒸馏算法，在 ImageNet 数据集上，模型精度可以提升 3-7 个点，您可以在 [SSLD 介绍](../advanced_tutorials/ssld.md)找到详细介绍。我们发现，使用SSLD预训练权重，可以有效提升应用分类模型的精度。此外，在训练中使用更小的分辨率，可以有效提升模型精度。同时，我们也对学习率进行了优化。
+SSLD 是百度自研的半监督蒸馏算法，在 ImageNet 数据集上，模型精度可以提升 3-7 个点，您可以在 [SSLD 介绍](advanced/ssld.md)找到详细介绍。我们发现，使用SSLD预训练权重，可以有效提升应用分类模型的精度。此外，在训练中使用更小的分辨率，可以有效提升模型精度。同时，我们也对学习率进行了优化。
 基于以上三点改进，我们训练得到模型精度为 92.1%，提升 2.6%。
 
 <a name="3.3"></a>
 
 #### 3.3 EDA数据增强策略
 
-数据增强是视觉算法中常用的优化策略，可以对模型精度有明显提升。除了传统的 RandomCrop，RandomFlip 等方法之外，我们还应用了 RandomAugment 和 RandomErasing。您可以在[数据增强介绍](../advanced_tutorials/DataAugmentation.md)找到详细介绍。
+数据增强是视觉算法中常用的优化策略，可以对模型精度有明显提升。除了传统的 RandomCrop，RandomFlip 等方法之外，我们还应用了 RandomAugment 和 RandomErasing。您可以在[数据增强介绍](config_discription/data_augmentation.md)找到详细介绍。
 由于这两种数据增强对图片的修改较大，使分类任务变难，在一些小数据集上可能会导致模型欠拟合，我们将提前设置好这两种方法启用的概率。
 基于以上改进，我们训练得到模型精度为 93.43%，提升 1.3%。
 
@@ -167,7 +167,7 @@ SSLD 是百度自研的半监督蒸馏算法，在 ImageNet 数据集上，模
 
 #### 3.4 SKL-UGI模型蒸馏
 
-模型蒸馏是一种可以有效提升小模型精度的方法，您可以在[知识蒸馏介绍](../advanced_tutorials/ssld.md)找到详细介绍。我们选择 ResNet101_vd 作为教师模型进行蒸馏。为了适应蒸馏过程，我们在此也对网络不同 stage 的学习率进行了调整。基于以上改进，我们训练得到模型精度为 95.6%，提升 1.4%。
+模型蒸馏是一种可以有效提升小模型精度的方法，您可以在[知识蒸馏介绍](advanced/ssld.md)找到详细介绍。我们选择 ResNet101_vd 作为教师模型进行蒸馏。为了适应蒸馏过程，我们在此也对网络不同 stage 的学习率进行了调整。基于以上改进，我们训练得到模型精度为 95.6%，提升 1.4%。
 
 <a name="3.5"></a>
 

docs/zh_CN/others/feature_visiualization.md → docs/zh_CN/training/advanced/feature_visiualization.md

@@ -17,13 +17,13 @@
 
 ## 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)，或使用以下命令下载。
+首先需要选定研究的模型，本文设定 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
 ```
 
-其他模型网络结构代码及预训练模型请自行下载：[模型库](../../../ppcls/arch/backbone/)，[预训练模型](../algorithm_introduction/ImageNet_models.md)。
+其他模型网络结构代码及预训练模型请自行下载：[模型库](../../../ppcls/arch/backbone/)，[预训练模型](../../models/ImageNet1k/model_list.md)。
 
  <a name='3'></a>
 
@@ -49,7 +49,7 @@ wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_pretrain
         return x, fm
 ```
 
-然后修改代码[fm_vis.py](../../../ppcls/utils/feature_maps_visualization/fm_vis.py)，引入 `ResNet50`，实例化 `net` 对象：
+然后修改代码[fm_vis.py](../../../../ppcls/utils/feature_maps_visualization/fm_vis.py)，引入 `ResNet50`，实例化 `net` 对象：
 
 ```python
 from resnet import ResNet50
@@ -82,7 +82,7 @@ python tools/feature_maps_visualization/fm_vis.py \
 
 * 输入图片：  
 
-![](../../images/feature_maps/feature_visualization_input.jpg)
+![](../../../images/feature_maps/feature_visualization_input.jpg)
 
 * 运行下面的特征图可视化脚本
 
@@ -99,4 +99,4 @@ python tools/feature_maps_visualization/fm_vis.py \
 
 * 输出特征图保存为 `output.png`，如下所示。
 
-![](../../images/feature_maps/feature_visualization_output.jpg)
+![](../../../images/feature_maps/feature_visualization_output.jpg)

docs/zh_CN/advanced_tutorials/knowledge_distillation.md → docs/zh_CN/training/advanced/knowledge_distillation.md

@@ -16,6 +16,7 @@
         - [1.2.5 DKD](#1.2.5)
         - [1.2.6 DIST](#1.2.6)
         - [1.2.7 MGD](#1.2.7)
+        - [1.2.8 WSL](#1.2.8)
 - [2. 使用方法](#2)
     - [2.1 环境配置](#2.1)
     - [2.2 数据准备](#2.2)
@@ -91,7 +92,7 @@ Park 等人提出了 RKD [10]，基于关系的知识蒸馏算法，RKD 中进
 
 SSLD是百度于2021年提出的一种简单的半监督知识蒸馏方案，通过设计一种改进的JS散度作为损失函数，结合基于ImageNet22k数据集的数据挖掘策略，最终帮助15个骨干网络模型的精度平均提升超过3%。
 
-更多关于SSLD的原理、模型库与使用介绍，请参考：[SSLD知识蒸馏算法介绍](./ssld.md)。
+更多关于SSLD的原理、模型库与使用介绍，请参考：[SSLD知识蒸馏算法介绍](ssld.md)。
 
 
 ##### 1.2.1.2 SSLD 配置
@@ -152,8 +153,8 @@ DML论文中，在蒸馏的过程中，不依赖于教师模型，两个结构
 
 | 策略 | 骨干网络 | 配置文件 | Top-1 acc | 下载链接 |
 | --- | --- | --- | --- | --- |
-| baseline | PPLCNet_x2_5 | [PPLCNet_x2_5.yaml](../../../ppcls/configs/ImageNet/PPLCNet/PPLCNet_x2_5.yaml) | 74.93% | - |
-| DML | PPLCNet_x2_5 | [PPLCNet_x2_5_dml.yaml](../../../ppcls/configs/ImageNet/Distillation/PPLCNet_x2_5_dml.yaml) | 76.68%(**+1.75%**) | - |
+| baseline | PPLCNet_x2_5 | [PPLCNet_x2_5.yaml](../../../../ppcls/configs/ImageNet/PPLCNet/PPLCNet_x2_5.yaml) | 74.93% | - |
+| DML | PPLCNet_x2_5 | [PPLCNet_x2_5_dml.yaml](../../../../ppcls/configs/ImageNet/Distillation/PPLCNet_x2_5_dml.yaml) | 76.68%(**+1.75%**) | - |
 
 
 * 注：完整的PPLCNet_x2_5模型训练了360epoch，这里为了方便对比，baseline和DML均训练了100epoch，因此指标比官网最终开源出来的模型精度（76.60%）低一些。
@@ -211,8 +212,8 @@ UDML 是百度飞桨视觉团队提出的无需依赖教师模型的知识蒸馏
 
 | 策略 | 骨干网络 | 配置文件 | Top-1 acc | 下载链接 |
 | --- | --- | --- | --- | --- |
-| baseline | PPLCNet_x2_5 | [PPLCNet_x2_5.yaml](../../../ppcls/configs/ImageNet/PPLCNet/PPLCNet_x2_5.yaml) | 74.93% | - |
-| UDML | PPLCNet_x2_5 | [PPLCNet_x2_5_dml.yaml](../../../ppcls/configs/ImageNet/Distillation/PPLCNet_x2_5_udml.yaml) | 76.74%(**+1.81%**) | - |
+| baseline | PPLCNet_x2_5 | [PPLCNet_x2_5.yaml](../../../../ppcls/configs/ImageNet/PPLCNet/PPLCNet_x2_5.yaml) | 74.93% | - |
+| UDML | PPLCNet_x2_5 | [PPLCNet_x2_5_dml.yaml](../../../../ppcls/configs/ImageNet/Distillation/PPLCNet_x2_5_udml.yaml) | 76.74%(**+1.81%**) | - |
 
 
 ##### 1.2.3.2 UDML 配置
@@ -263,7 +264,7 @@ Loss:
         weight: 1.0
 ```
 
-**注意(：** 上述在网络中指定`return_patterns`，返回中间层特征的功能是基于TheseusLayer，更多关于TheseusLayer的使用说明，请参考：[TheseusLayer 使用说明](./theseus_layer.md)。
+**注意(：** 上述在网络中指定`return_patterns`，返回中间层特征的功能是基于TheseusLayer，更多关于TheseusLayer的使用说明，请参考：[TheseusLayer 使用说明](theseus_layer.md)。
 
 
 <a name='1.2.4'></a>
@@ -287,8 +288,8 @@ AFD提出在蒸馏的过程中，利用基于注意力的元网络学习特征
 
 | 策略 | 骨干网络 | 配置文件 | Top-1 acc | 下载链接 |
 | --- | --- | --- | --- | --- |
-| baseline | ResNet18 | [ResNet18.yaml](../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
-| AFD | ResNet18 | [resnet34_distill_resnet18_afd.yaml](../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_afd.yaml) | 71.68%(**+0.88%**) | - |
+| baseline | ResNet18 | [ResNet18.yaml](../../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
+| AFD | ResNet18 | [resnet34_distill_resnet18_afd.yaml](../../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_afd.yaml) | 71.68%(**+0.88%**) | - |
 
 注意：这里为了与论文的训练配置保持对齐，设置训练的迭代轮数为100epoch，因此baseline精度低于PaddleClas中开源出的模型精度（71.0%）
 
@@ -375,7 +376,7 @@ Loss:
         weight: 1.0
 ```
 
-**注意(：** 上述在网络中指定`return_patterns`，返回中间层特征的功能是基于TheseusLayer，更多关于TheseusLayer的使用说明，请参考：[TheseusLayer 使用说明](./theseus_layer.md)。
+**注意(：** 上述在网络中指定`return_patterns`，返回中间层特征的功能是基于TheseusLayer，更多关于TheseusLayer的使用说明，请参考：[TheseusLayer 使用说明](theseus_layer.md)。
 
 <a name='1.2.5'></a>
 
@@ -398,8 +399,8 @@ DKD将蒸馏中常用的 KD Loss 进行了解耦成为Target Class Knowledge Dis
 
 | 策略 | 骨干网络 | 配置文件 | Top-1 acc | 下载链接 |
 | --- | --- | --- | --- | --- |
-| baseline | ResNet18 | [ResNet18.yaml](../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
-| AFD | ResNet18 | [resnet34_distill_resnet18_dkd.yaml](../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_dkd.yaml) | 72.59%(**+1.79%**) | - |
+| baseline | ResNet18 | [ResNet18.yaml](../../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
+| DKD | ResNet18 | [resnet34_distill_resnet18_dkd.yaml](../../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_dkd.yaml) | 72.59%(**+1.79%**) | - |
 
 
 ##### 1.2.5.2 DKD 配置
@@ -466,8 +467,8 @@ Loss:
 
 | 策略 | 骨干网络 | 配置文件 | Top-1 acc | 下载链接 |
 | --- | --- | --- | --- | --- |
-| baseline | ResNet18 | [ResNet18.yaml](../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
-| DIST | ResNet18 | [resnet34_distill_resnet18_dist.yaml](../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_dist.yaml) | 71.99%(**+1.19%**) | - |
+| baseline | ResNet18 | [ResNet18.yaml](../../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
+| DIST | ResNet18 | [resnet34_distill_resnet18_dist.yaml](../../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_dist.yaml) | 71.99%(**+1.19%**) | - |
 
 
 ##### 1.2.6.2 DIST 配置
@@ -532,8 +533,8 @@ Loss:
 
 | 策略 | 骨干网络 | 配置文件 | Top-1 acc | 下载链接 |
 | --- | --- | --- | --- | --- |
-| baseline | ResNet18 | [ResNet18.yaml](../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
-| MGD | ResNet18 | [resnet34_distill_resnet18_mgd.yaml](../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_mgd.yaml) | 71.86%(**+1.06%**) | - |
+| baseline | ResNet18 | [ResNet18.yaml](../../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
+| MGD | ResNet18 | [resnet34_distill_resnet18_mgd.yaml](../../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_mgd.yaml) | 71.86%(**+1.06%**) | - |
 
 
 ##### 1.2.7.2 MGD 配置
@@ -583,6 +584,73 @@ Loss:
         weight: 1.0
 ```
 
+<a name='1.2.8'></a>
+
+#### 1.2.8 WSL
+
+##### 1.2.8.1 WSL 算法介绍
+
+论文信息：
+
+
+> [Rethinking Soft Labels For Knowledge Distillation: A Bias-variance Tradeoff Perspective](https://arxiv.org/abs/2102.0650)
+>
+> Helong Zhou, Liangchen Song, Jiajie Chen, Ye Zhou, Guoli Wang, Junsong Yuan, Qian Zhang
+>
+> ICLR, 2021
+
+WSL (Weighted Soft Labels) 损失函数根据教师模型与学生模型关于真值标签的 CE Loss 比值，对每个样本的 KD Loss 分别赋予权重。若学生模型相对教师模型在某个样本上预测结果更好，则对该样本赋予较小的权重。该方法简单、有效，使各个样本的权重可自适应调节，提升了蒸馏精度。
+
+在ImageNet1k公开数据集上，效果如下所示。
+
+| 策略 | 骨干网络 | 配置文件 | Top-1 acc | 下载链接 |
+| --- | --- | --- | --- | --- |
+| baseline | ResNet18 | [ResNet18.yaml](../../../../ppcls/configs/ImageNet/ResNet/ResNet18.yaml) | 70.8% | - |
+| WSL | ResNet18 | [resnet34_distill_resnet18_wsl.yaml](../../../../ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_wsl.yaml) | 72.23%(**+1.43%**) | - |
+
+
+##### 1.2.8.2 WSL 配置
+
+WSL 配置如下所示。在模型构建Arch字段中，需要同时定义学生模型与教师模型，教师模型固定参数，且需要加载预训练模型。在损失函数Loss字段中，需要定义`DistillationGTCELoss`（学生与真值标签之间的CE loss）以及`DistillationWSLLoss`（学生与教师之间的WSL loss），作为训练的损失函数。
+
+
+```yaml
+# model architecture
+Arch:
+  name: "DistillationModel"
+  # if not null, its lengths should be same as models
+  pretrained_list:
+  # if not null, its lengths should be same as models
+  freeze_params_list:
+  - True
+  - False
+  models:
+    - Teacher:
+        name: ResNet34
+        pretrained: True
+
+    - Student:
+        name: ResNet18
+        pretrained: False
+
+  infer_model_name: "Student"
+
+
+# loss function config for traing/eval process
+Loss:
+  Train:
+    - DistillationGTCELoss:
+        weight: 1.0
+        model_names: ["Student"]
+    - DistillationWSLLoss:
+        weight: 2.5
+        model_name_pairs: [["Student", "Teacher"]]
+        temperature: 2
+  Eval:
+    - CELoss:
+        weight: 1.0
+```
+
 <a name="2"></a>
 
 ## 2. 模型训练、评估和预测
@@ -591,7 +659,7 @@ Loss:
 
 ### 2.1 环境配置
 
-* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../../installation.md) 配置 PaddleClas 运行环境。
 
 <a name="2.2"></a>
 
@@ -633,7 +701,7 @@ cat train_list.txt train_list_unlabel.txt > train_list_all.txt
 
 **备注：**
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../single_label_classification/dataset.md#1-数据集格式说明) 。
 
 
 <a name="2.3"></a>
@@ -641,7 +709,7 @@ cat train_list.txt train_list_unlabel.txt > train_list_all.txt
 ### 2.3 模型训练
 
 
-以SSLD知识蒸馏算法为例，介绍知识蒸馏算法的模型训练、评估、预测等过程。配置文件为 [PPLCNet_x2_5_ssld.yaml](../../../ppcls/configs/ImageNet/Distillation/PPLCNet_x2_5_ssld.yaml) ，使用下面的命令可以完成模型训练。
+以SSLD知识蒸馏算法为例，介绍知识蒸馏算法的模型训练、评估、预测等过程。配置文件为 [PPLCNet_x2_5_ssld.yaml](../../../../ppcls/configs/ImageNet/Distillation/PPLCNet_x2_5_ssld.yaml) ，使用下面的命令可以完成模型训练。
 
 
 ```shell
@@ -710,7 +778,7 @@ python3 tools/export_model.py \
 
 最终在`inference`目录下会产生`inference.pdiparams`、`inference.pdiparams.info`、`inference.pdmodel` 3个文件。
 
-关于更多模型推理相关的教程，请参考：[Python 预测推理](../inference_deployment/python_deploy.md)。
+关于更多模型推理相关的教程，请参考：[Python 预测推理](../../deployment/image_classification/python.md)。
 
 
 <a name="3"></a>

docs/zh_CN/advanced_tutorials/model_prune_quantization.md → docs/zh_CN/training/advanced/prune_quantization.md

@@ -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 模型的训练方法](../single_label_classification/training.md)以及 [PaddleSlim](https://paddleslim.readthedocs.io/zh_CN/latest/index.html)，相关裁剪、量化方法可以参考[模型裁剪量化算法介绍文档](../../algorithm_introduction/prune_quantization.md)。
 
 -----------
 
@@ -61,7 +61,7 @@ python3.7 setup.py install
 <a name="1.2"></a>
 ### 1.2 准备训练好的模型
 
-PaddleClas 提供了一系列训练好的[模型](../models/models_intro.md)，如果待量化的模型不在列表中，需要按照[常规训练](../models_training/classification.md)方法得到训练好的模型。
+PaddleClas 提供了一系列训练好的[模型](../models/models_intro.md)，如果待量化的模型不在列表中，需要按照[常规训练](../single_label_classification/training.md)方法得到训练好的模型。
 
 <a name="2"></a>
 ## 2. 快速开始
@@ -92,7 +92,7 @@ cd PaddleClas
 python3.7 tools/train.py -c ppcls/configs/slim/ResNet50_vd_quantization.yaml -o Global.device=cpu
 ```
 
-其中 `yaml` 文件解析详见[参考文档](../models_training/config_description.md)。为了保证精度，`yaml` 文件中已经使用 `pretrained model`.
+其中 `yaml` 文件解析详见[参考文档](../config_discription/basic.md)。为了保证精度，`yaml` 文件中已经使用 `pretrained model`.
 
 
 * 单机多卡/多机多卡启动
@@ -108,7 +108,7 @@ python3.7 -m paddle.distributed.launch \
 <a name="2.1.2"></a>
 #### 2.1.2 离线量化
 
-**注意**：目前离线量化，必须使用已经训练好的模型，导出的 `inference model` 进行量化。一般模型导出 `inference model` 可参考[教程](../inference_deployment/export_model.md).
+**注意**：目前离线量化，必须使用已经训练好的模型，导出的 `inference model` 进行量化。一般模型导出 `inference model` 可参考[教程](../../deployment/export_model.md).
 
 一般来说，离线量化损失模型精度较多。
 
@@ -160,10 +160,10 @@ python3.7 tools/export.py \
 <a name="4"></a>
 ## 4. 模型部署
 
-上述步骤导出的模型可以直接使用 inferecne 进行部署，参考 [inference 部署](../inference_deployment/)。
+上述步骤导出的模型可以直接使用 inferecne 进行部署，参考 [inference 部署](../../deployment/)。
 
 也通过 PaddleLite 的 opt 模型转换工具，完成 inference 模型到移动端模型转换，用于移动端的模型部署。
-移动端模型部署的可参考 [移动端模型部署](../inference_deployment/paddle_lite_deploy.md)。
+移动端模型部署的可参考 [移动端模型部署](../../deployment/image_classification/paddle_lite.md)。
 
 <a name="5"></a>
 ## 5. 训练超参数建议

docs/zh_CN/advanced_tutorials/ssld.md → docs/zh_CN/training/advanced/ssld.md

@@ -80,7 +80,7 @@ SSLD 蒸馏方案的一大特色就是无需使用图像的真值标签，因此
 
 此外，在无标注数据选择的过程中，我们发现使用更加通用的数据，即使不需要严格的数据筛选过程，也可以帮助知识蒸馏任务获得稳定的精度提升，因而提出了SKL-UGI (Symmetrical-KL Unlabeled General Images distillation)知识蒸馏方案。
 
-通用数据可以使用ImageNet数据或者与场景相似的数据集。更多关于SKL-UGI的应用，请参考：[超轻量图像分类方案PULC使用教程](../PULC/PULC_train.md)。
+通用数据可以使用ImageNet数据或者与场景相似的数据集。更多关于SKL-UGI的应用，请参考：[超轻量图像分类方案PULC使用教程](../PULC.md)。
 
 
 <a name="2"></a>
@@ -154,9 +154,9 @@ python3 -m paddle.distributed.launch --gpus="0,1,2,3" tools/train.py -c ppcls/co
 cat train_list.txt train_list_unlabel.txt > train_list_all.txt
 ```
 
-更多关于图像分类任务的数据标签说明，请参考：[PaddleClas图像分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明)
+更多关于图像分类任务的数据标签说明，请参考：[PaddleClas图像分类数据集格式说明](../single_label_classification/dataset.md#1-数据集格式说明)
 
-PaddleClas中集成了PULC超轻量图像分类实用方案，里面包含SSLD ImageNet预训练模型的使用以及更加通用的无标签数据的知识蒸馏方案，更多详细信息，请参考[PULC超轻量图像分类实用方案使用教程](../PULC/PULC_train.md)。
+PaddleClas中集成了PULC超轻量图像分类实用方案，里面包含SSLD ImageNet预训练模型的使用以及更加通用的无标签数据的知识蒸馏方案，更多详细信息，请参考[PULC超轻量图像分类实用方案使用教程](../PULC.md)。
 
 <a name="4"></a>
 

docs/zh_CN/advanced_tutorials/theseus_layer.md → docs/zh_CN/training/advanced/theseus_layer.md

@@ -44,7 +44,7 @@ class net(TheseusLayer):
 * 以 `.` 作为网络层级的分隔符；
 * 对于 `nn.Sequential` 类型或是 `nn.LayerList` 类型的层，使用 `["index"]` 指定其子层。
 
-以 `MobileNetV1` 网络为例，其模型结构定义在 [MobileNetV1](../../../ppcls/arch/backbone/legendary_models/mobilenet_v1.py)，为方便说明，可参考下方网络结构及不同网络层所对应的网络层描述符。可以清晰看出，对于 `MobileNetV1` 网络的任一子层，均可按层级结构逐层指定，不同层级结构间使用 `.` 进行分隔即可。
+以 `MobileNetV1` 网络为例，其模型结构定义在 [MobileNetV1](../../../../ppcls/arch/backbone/legendary_models/mobilenet_v1.py)，为方便说明，可参考下方网络结构及不同网络层所对应的网络层描述符。可以清晰看出，对于 `MobileNetV1` 网络的任一子层，均可按层级结构逐层指定，不同层级结构间使用 `.` 进行分隔即可。
 
 ```shell
 # 网络层对象的变量名（该对象所属类）....................(该网络层对应的网络层描述符)

docs/zh_CN/others/train_on_xpu.md → docs/zh_CN/training/advanced/train_on_xpu.md

@@ -3,10 +3,10 @@
 ## 目录
 * [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)
+    * [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>
 
@@ -17,7 +17,7 @@
 <a name='2'></a>
 
 ## 2. 昆仑训练
-* 数据来源和预训练模型参考[quick_start](../quick_start/quick_start_classification_new_user.md)。昆仑训练效果与 CPU/GPU 对齐。
+* 数据来源和预训练模型参考[quick_start](../../quick_start/quick_start_classification_new_user.md)。昆仑训练效果与 CPU/GPU 对齐。
 
 <a name='2.1'></a>
 

docs/zh_CN/others/VisualDL.md → docs/zh_CN/training/config_discription/VisualDL.md

@@ -53,4 +53,4 @@ python3 tools/train.py -c config.yaml
 
 在启动 VisualDL 后，即可在浏览器中查看训练过程，输入地址 `127.0.0.1:8840`：
 
-![](../../images/VisualDL/train_loss.png)
+![](../../../images/VisualDL/train_loss.png)

docs/zh_CN/models_training/config_description.md → docs/zh_CN/training/config_discription/basic.md

@@ -30,12 +30,12 @@
 - [3. 识别模型](#3)
   - [3.1 结构(Arch)](#3.1)
   - [3.2 评估指标(Metric)](#3.2)
-  
+
 
 <a name="1"></a>
 ### 1.分类模型
 
-此处以 `ResNet50_vd` 在 `ImageNet-1k` 上的训练配置为例，详解各个参数的意义。[配置路径](../../../ppcls/configs/ImageNet/ResNet/ResNet50_vd.yaml)。
+此处以 `ResNet50_vd` 在 `ImageNet-1k` 上的训练配置为例，详解各个参数的意义。[配置路径](../../../../ppcls/configs/ImageNet/ResNet/ResNet50_vd.yaml)。
 
 <a name="1.1"></a>
 #### 1.1 全局配置(Global)
@@ -102,7 +102,7 @@
     values: [0.1, 0.01, 0.001, 0.0001]
 ```
 
-添加方法及参数请查看 [learning_rate.py](../../../ppcls/optimizer/learning_rate.py)。
+添加方法及参数请查看 [learning_rate.py](../../../../ppcls/optimizer/learning_rate.py)。
 
 <a name="1.5"></a>
 #### 1.5 数据读取模块(DataLoader)
@@ -181,7 +181,7 @@ batch_transform_ops 中参数的含义：
 <a name="2"></a>
 ### 2.蒸馏模型
 
-**注**：此处以 `MobileNetV3_large_x1_0` 在 `ImageNet-1k` 上蒸馏 `MobileNetV3_small_x1_0` 的训练配置为例，详解各个参数的意义。[配置路径](../../../ppcls/configs/ImageNet/Distillation/mv3_large_x1_0_distill_mv3_small_x1_0.yaml)。这里只介绍与分类模型有区别的参数。
+**注**：此处以 `MobileNetV3_large_x1_0` 在 `ImageNet-1k` 上蒸馏 `MobileNetV3_small_x1_0` 的训练配置为例，详解各个参数的意义。[配置路径](../../../../ppcls/configs/ImageNet/Distillation/mv3_large_x1_0_distill_mv3_small_x1_0.yaml)。这里只介绍与分类模型有区别的参数。
 
 <a name="2.1"></a>
 #### 2.1 结构（Arch）
@@ -234,7 +234,7 @@ batch_transform_ops 中参数的含义：
 <a name="3"></a>
 ### 3. 识别模型
 
-**注**：此处以 `ResNet50` 在 `LogoDet-3k` 上的训练配置为例，详解各个参数的意义。[配置路径](../../../ppcls/configs/Logo/ResNet50_ReID.yaml)。这里只介绍与分类模型有区别的参数。
+**注**：此处以 `ResNet50` 在 `LogoDet-3k` 上的训练配置为例，详解各个参数的意义。[配置路径](../../../../ppcls/configs/Logo/ResNet50_ReID.yaml)。这里只介绍与分类模型有区别的参数。
 
 <a name="3.1"></a>
 #### 3.1 结构(Arch)

docs/zh_CN/advanced_tutorials/DataAugmentation.md → docs/zh_CN/training/config_discription/data_augmentation.md

@@ -51,7 +51,7 @@
 
 在图像分类任务中，图像数据的增广是一种常用的正则化方法，常用于数据量不足或者模型参数较多的场景。在本章节中，我们将对除 ImageNet 分类任务标准数据增强外的 8 种数据增强方式进行简单的介绍和对比，用户也可以将这些增广方法应用到自己的任务中，以获得模型精度的提升。这 8 种数据增强方式在 ImageNet 上的精度指标如下所示。
 
-![](../../images/image_aug/main_image_aug.png)
+![](../../../images/image_aug/main_image_aug.png)
 
 更具体的指标如下表所示：
 
@@ -91,7 +91,7 @@
 
 增广后的可视化效果如下所示。
 
-![](../../images/image_aug/image_aug_samples_s.jpg)
+![](../../../images/image_aug/image_aug_samples_s.jpg)
 
 具体如下表所示：
 
@@ -147,7 +147,7 @@ PaddleClas 中集成了上述所有的数据增强策略，每种数据增强策
 
 `AotoAugment` 的图像增广方式的配置如下。`AutoAugment` 是在 uint8 的数据格式上转换的，所以其处理过程应该放在归一化操作(`NormalizeImage`)之前。
 
-```yaml        
+```yaml  
       transform_ops:
         - DecodeImage:
             to_rgb: True
@@ -192,7 +192,7 @@ PaddleClas 中集成了上述所有的数据增强策略，每种数据增强策
 
 `RandAugment` 的图像增广方式的配置如下，其中用户需要指定其中的参数 `num_layers` 与 `magnitude`，默认的数值分别是 `2` 和 `5`。`RandAugment` 是在 uint8 的数据格式上转换的，所以其处理过程应该放在归一化操作(`NormalizeImage`)之前。
 
-```yaml        
+```yaml  
       transform_ops:
         - DecodeImage:
             to_rgb: True
@@ -229,7 +229,7 @@ PaddleClas 中集成了上述所有的数据增强策略，每种数据增强策
 
 `TimmAutoAugment` 的图像增广方式的配置如下，其中用户需要指定其中的参数 `config_str`、`interpolation`、`img_size`，默认的数值分别是 `rand-m9-mstd0.5-inc1`、`bicubic`、`224`。`TimmAutoAugment` 是在 uint8 的数据格式上转换的，所以其处理过程应该放在归一化操作(`NormalizeImage`)之前。
 
-```yaml        
+```yaml  
       transform_ops:
         - DecodeImage:
             to_rgb: True
@@ -604,14 +604,14 @@ Mixup 是最先提出的图像混叠增广方案，其原理简单、方便实
 <a name="2"></a>
 
 ## 2. 模型训练、评估和预测
-    
+
 <a name="2.1"></a>  
 
 ### 2.1 环境配置
 
-* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../installation/install_paddleclas.md) 配置 PaddleClas 运行环境。
+* 安装：请先参考 [Paddle 安装教程](../installation/install_paddle.md) 以及 [PaddleClas 安装教程](../../installation.md) 配置 PaddleClas 运行环境。
 
-<a name="2.2"></a> 
+<a name="2.2"></a>
 
 ### 2.2 数据准备
 
@@ -640,15 +640,15 @@ cd path_to_PaddleClas
 ```
 
 其中 `train/` 和 `val/` 分别为训练集和验证集。`train_list.txt` 和 `val_list.txt` 分别为训练集和验证集的标签文件。
-    
-**备注：** 
 
-* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../data_preparation/classification_dataset.md#1-数据集格式说明) 。
+**备注：**
+
+* 关于 `train_list.txt`、`val_list.txt`的格式说明，可以参考[PaddleClas分类数据集格式说明](../single_label_classification/dataset.md#1-数据集格式说明) 。
 
 
-<a name="2.3"></a> 
+<a name="2.3"></a>
 
-### 2.3 模型训练 
+### 2.3 模型训练
 
 
 在 `ppcls/configs/ImageNet/DataAugment` 中提供了基于 ResNet50 的不同的数据增强的训练配置，这里以使用 `AutoAugment` 为例，介绍数据增强的使用方法。可以通过如下脚本启动训练：
@@ -658,11 +658,11 @@ export CUDA_VISIBLE_DEVICES=0,1,2,3
 python3 -m paddle.distributed.launch \
     --gpus="0,1,2,3" \
     tools/train.py \
-        -c ppcls/configs/ImageNet/DataAugment/ResNet50_AutoAugment.yaml 
+        -c ppcls/configs/ImageNet/DataAugment/ResNet50_AutoAugment.yaml
 ```
 
 
-**备注：** 
+**备注：**
 
 * 1.当前精度最佳的模型会保存在 `output/ResNet50/best_model.pdparams`。
 * 2.如需更改数据增强类型，只需要替换`ppcls/configs/ImageNet/DataAugment`中的其他的配置文件即可。
@@ -670,7 +670,7 @@ python3 -m paddle.distributed.launch \
 * 4.由于图像混叠时需对 label 进行混叠，无法计算训练数据的准确率，所以在训练过程中没有打印训练准确率。
 * 5.在使用数据增强后，由于训练数据更难，所以训练损失函数可能较大，训练集的准确率相对较低，但其有拥更好的泛化能力，所以验证集的准确率相对较高。
 * 6.在使用数据增强后，模型可能会趋于欠拟合状态，建议可以适当的调小 `l2_decay` 的值来获得更高的验证集准确率。
-* 7.几乎每一类图像增强均含有超参数，我们只提供了基于 ImageNet-1k 的超参数，其他数据集需要用户自己调试超参数，具体超参数的含义用户可以阅读相关的论文，调试方法也可以参考[训练技巧](../models_training/train_strategy.md)。
+* 7.几乎每一类图像增强均含有超参数，我们只提供了基于 ImageNet-1k 的超参数，其他数据集需要用户自己调试超参数，具体超参数的含义用户可以阅读相关的论文，调试方法也可以参考[训练技巧](../single_label_classification/training_strategy.md)。
 
 <a name="2.4"></a>
 
@@ -695,7 +695,7 @@ python3 tools/eval.py \
 ```python
 python3 tools/infer.py \
     -c ppcls/configs/ImageNet/DataAugment/ResNet50_AutoAugment.yaml \
-    -o Global.pretrained_model=output/ResNet50/best_model 
+    -o Global.pretrained_model=output/ResNet50/best_model
 ```
 
 输出结果如下：
@@ -704,12 +704,12 @@ python3 tools/infer.py \
 [{'class_ids': [8, 7, 86, 81, 85], 'scores': [0.91347, 0.03779, 0.0036, 0.00117, 0.00112], 'file_name': 'docs/images/inference_deployment/whl_demo.jpg', 'label_names': ['hen', 'cock', 'partridge', 'ptarmigan', 'quail']}]
 ```
 
-**备注：** 
+**备注：**
 
 * 这里`-o Global.pretrained_model="output/ResNet50/best_model"` 指定了当前最佳权重所在的路径，如果指定其他权重，只需替换对应的路径即可。
-    
+
 * 默认是对 `docs/images/inference_deployment/whl_demo.jpg` 进行预测，此处也可以通过增加字段 `-o Infer.infer_imgs=xxx` 对其他图片预测。
-    
+
 * 默认输出的是 Top-5 的值，如果希望输出 Top-k 的值，可以指定`-o Infer.PostProcess.topk=k`，其中，`k` 为您指定的值。
 
 
@@ -737,14 +737,14 @@ python3 tools/infer.py \
 
 
 
-[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
+[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/models_training/recognition.md → docs/zh_CN/training/metric_learning/training.md

@@ -14,11 +14,11 @@
 
 <img src="../../images/structure.png"/>
 
-在Android端或PC端体验整体图像识别系统，或查看特征库建立方法，可以参考 [图像识别快速开始文档](../quick_start/quick_start_recognition.md)。
+在Android端或PC端体验整体图像识别系统，或查看特征库建立方法，可以参考 [图像识别快速开始文档](../../quick_start/quick_start_recognition.md)。
 
 以下内容，主要对上述三个步骤的训练部分进行介绍。
 
-在训练开始之前，请参考 [安装指南](../installation/install_paddleclas.md) 配置运行环境。
+在训练开始之前，请参考 [安装指南](../../installation.md) 配置运行环境。
 
 ##  目录
 
@@ -45,7 +45,7 @@
 
 关于主体检测数据集构造与模型训练方法可以参考： [30分钟快速上手PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection/blob/develop/docs/tutorials/GETTING_STARTED_cn.md#30%E5%88%86%E9%92%9F%E5%BF%AB%E9%80%9F%E4%B8%8A%E6%89%8Bpaddledetection)。
 
-更多关于 PaddleClas 中提供的主体检测的模型介绍与下载请参考：[主体检测教程](../image_recognition_pipeline/mainbody_detection.md)。
+更多关于 PaddleClas 中提供的主体检测的模型介绍与下载请参考：[主体检测教程](../PP-ShiTu/mainbody_detection.md)。
 
 <a name="2"></a>
 
@@ -163,7 +163,7 @@ python3.7 -m paddle.distributed.launch tools/train.py \
 
 **注**：其中，`-c` 用于指定配置文件的路径，`-o` 用于指定需要修改或者添加的参数，其中 `-o Arch.Backbone.pretrained=True` 表示 Backbone 在训练开始前会加载预训练模型；`-o Arch.Backbone.pretrained` 也可以指定为模型权重文件的路径，使用时换成自己的预训练模型权重文件的路径即可；`-o Global.device=gpu` 表示使用 GPU 进行训练。如果希望使用 CPU 进行训练，则设置 `-o Global.device=cpu`即可。
 
-更详细的训练配置，也可以直接修改模型对应的配置文件。具体配置参数参考[配置文档](config_description.md)。
+更详细的训练配置，也可以直接修改模型对应的配置文件。具体配置参数参考[配置文档](../config_discription/basic.md)。
 
 运行上述训练命令，可以看到输出日志，示例如下：
 
@@ -177,7 +177,7 @@ python3.7 -m paddle.distributed.launch tools/train.py \
 
 此处配置文件的 Backbone 是 MobileNetV1，如果想使用其他 Backbone，可以重写参数 `Arch.Backbone.name`，比如命令中增加 `-o Arch.Backbone.name={其他 Backbone 的名字}`。此外，由于不同模型 `Neck` 部分的输入维度不同，更换 Backbone 后可能需要改写 `Neck` 的输入大小，改写方式类似替换 Backbone 的名字。
 
-在训练 Loss 部分，此处使用了 [CELoss](../../../ppcls/loss/celoss.py) 和 [TripletLossV2](../../../ppcls/loss/triplet.py)，配置文件如下：
+在训练 Loss 部分，此处使用了 [CELoss](../../../../ppcls/loss/celoss.py) 和 [TripletLossV2](../../../../ppcls/loss/triplet.py)，配置文件如下：
 
 ```yaml
 Loss:
@@ -189,7 +189,7 @@ Loss:
         margin: 0.5
 ```
 
-最终的总 Loss 是所有 Loss 的加权和，其中 weight 定义了特定 Loss 在最终总 Loss 的权重。如果想替换其他 Loss，也可以在配置文件中更改 Loss 字段，目前支持的 Loss 请参考 [Loss](../../../ppcls/loss/__init__.py)。
+最终的总 Loss 是所有 Loss 的加权和，其中 weight 定义了特定 Loss 在最终总 Loss 的权重。如果想替换其他 Loss，也可以在配置文件中更改 Loss 字段，目前支持的 Loss 请参考 [Loss](../../../../ppcls/loss/__init__.py)。
 
 <a name="2.2.2"></a>
 
@@ -257,7 +257,7 @@ python3.7 -m paddle.distributed.launch tools/eval.py \
 
 可配置的部分评估参数说明如下：
 * `Global.pretrained_model`：待评估的模型的预训练模型文件路径，不同于 `Global.Backbone.pretrained`，此处的预训练模型是整个模型的权重，而 `Global.Backbone.pretrained` 只是 Backbone 部分的权重。当需要做模型评估时，需要加载整个模型的权重。
-* `Metric.Eval`：待评估的指标，默认评估 `recall@1`、`recall@5`、`mAP`。当你不准备评测某一项指标时，可以将对应的试标从配置文件中删除；当你想增加某一项评测指标时，也可以参考 [Metric](../../../ppcls/metric/metrics.py) 部分在配置文件 `Metric.Eval` 中添加相关的指标。
+* `Metric.Eval`：待评估的指标，默认评估 `recall@1`、`recall@5`、`mAP`。当你不准备评测某一项指标时，可以将对应的试标从配置文件中删除；当你想增加某一项评测指标时，也可以参考 [Metric](../../../../ppcls/metric/metrics.py) 部分在配置文件 `Metric.Eval` 中添加相关的指标。
 
 **注意：**
 
@@ -280,7 +280,7 @@ python3.7 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 维特征。
 
-有了上述命令将生成的模型结构文件(`inference.pdmodel`)和模型权重文件(`inference.pdiparams`)，接下来就可以使用预测引擎进行推理。使用 inference 模型推理的流程可以参考[基于 Python 预测引擎预测推理](../inference_deployment/python_deploy.md)。
+有了上述命令将生成的模型结构文件(`inference.pdmodel`)和模型权重文件(`inference.pdiparams`)，接下来就可以使用预测引擎进行推理。使用 inference 模型推理的流程可以参考[基于 Python 预测引擎预测推理](../../deployment/image_classification/python.md)。
 
 <a name="3"></a>
 
@@ -325,7 +325,7 @@ python3.7 -m pip install faiss-cpu==1.7.1post2
 <a name="度量学习"></a>
 - 度量学习（Metric Learning）
 
-  度量学习研究如何在一个特定的任务上学习一个距离函数，使得该距离函数能够帮助基于近邻的算法（kNN、k-means 等）取得较好的性能。深度度量学习(Deep Metric Learning)是度量学习的一种方法，它的目标是学习一个从原始特征到低维稠密的向量空间（嵌入空间，embedding space）的映射，使得同类对象在嵌入空间上使用常用的距离函数（欧氏距离、cosine 距离等）计算的距离比较近，而不同类的对象之间的距离则比较远。深度度量学习在计算机视觉领域取得了非常多的成功的应用，比如人脸识别、商品识别、图像检索、行人重识别等。更详细的介绍请参考[此文档](../algorithm_introduction/metric_learning.md)。
+  度量学习研究如何在一个特定的任务上学习一个距离函数，使得该距离函数能够帮助基于近邻的算法（kNN、k-means 等）取得较好的性能。深度度量学习(Deep Metric Learning)是度量学习的一种方法，它的目标是学习一个从原始特征到低维稠密的向量空间（嵌入空间，embedding space）的映射，使得同类对象在嵌入空间上使用常用的距离函数（欧氏距离、cosine 距离等）计算的距离比较近，而不同类的对象之间的距离则比较远。深度度量学习在计算机视觉领域取得了非常多的成功的应用，比如人脸识别、商品识别、图像检索、行人重识别等。更详细的介绍请参考[此文档](../../algorithm_introduction/metric_learning.md)。
 
 <a name="图像检索数据集介绍"></a>
 

docs/zh_CN/models_training/distributed_training.md → docs/zh_CN/training/single_label_classification/distributed_training.md

@@ -42,7 +42,7 @@ python3 -m paddle.distributed.launch \
 
 ## 3. 性能效果测试
 
-* 在单机8卡V100的机器上，基于[SSLD知识蒸馏训练策略](../advanced_tutorials/ssld.md)（数据量500W）进行模型训练，不同模型的训练耗时以及单机8卡加速比情况如下所示。
+* 在单机8卡V100的机器上，基于[SSLD知识蒸馏训练策略](../advanced/ssld.md)（数据量500W）进行模型训练，不同模型的训练耗时以及单机8卡加速比情况如下所示。
 
 
 | 模型    | 精度     | 单机单卡耗时 | 单机8卡耗时 | 加速比  |
@@ -52,7 +52,7 @@ python3 -m paddle.distributed.launch \
 | PPLCNet_x0_25_ssld  | 53.43% | 21.8d   | 6.2d  | **3.99** |
 
 
-* 在4机8卡V100的机器上，基于[SSLD知识蒸馏训练策略](../advanced_tutorials/ssld.md)（数据量500W）进行模型训练，不同模型的训练耗时以及多机加速比情况如下所示。
+* 在4机8卡V100的机器上，基于[SSLD知识蒸馏训练策略](../advanced/ssld.md)（数据量500W）进行模型训练，不同模型的训练耗时以及多机加速比情况如下所示。
 
 
 | 模型    | 精度     | 单机8卡耗时 | 4机8卡耗时 | 加速比  |

docs/zh_CN/models_training/classification.md → docs/zh_CN/training/single_label_classification/training.md

@@ -6,7 +6,7 @@
 
 图像分类是计算机视觉里很基础但又重要的一个领域，其研究成果一直影响着计算机视觉甚至深度学习的发展，图像分类有很多子领域，如多标签分类、细粒度分类等，此处只对单标签图像分类做一个简述。
 
-具体图像分类算法介绍详见[文档](../algorithm_introduction/image_classification.md)。
+具体图像分类算法介绍详见[文档](../../algorithm_introduction/image_classification.md)。
 
 ## 目录
 
@@ -54,20 +54,20 @@ CIFAR-10 数据集由 10 个类的 60000 个彩色图像组成，图像分辨率
 <a name="2.1"></a>
 ### 2.1 数据及其预处理
 
-数据的质量及数量往往可以决定一个模型的好坏。在图像分类领域，数据包括图像及标签。在大部分情形下，带有标签的数据比较匮乏，所以数量很难达到使模型饱和的程度，为了可以使模型学习更多的图像特征，图像数据在进入模型之前要经过很多图像变换或者数据增强，来保证输入图像数据的多样性，从而保证模型有更好的泛化能力。PaddleClas 提供了训练 ImageNet-1k 的标准图像变换，也提供了多种数据增强的方法，相关代码可以查看[数据处理](../../../ppcls/data/preprocess)，配置文件可以参考[数据增强配置文件](../../../ppcls/configs/ImageNet/DataAugment)，相关数据增强算法详见[增强介绍文档](../algorithm_introduction/DataAugmentation.md)。
+数据的质量及数量往往可以决定一个模型的好坏。在图像分类领域，数据包括图像及标签。在大部分情形下，带有标签的数据比较匮乏，所以数量很难达到使模型饱和的程度，为了可以使模型学习更多的图像特征，图像数据在进入模型之前要经过很多图像变换或者数据增强，来保证输入图像数据的多样性，从而保证模型有更好的泛化能力。PaddleClas 提供了训练 ImageNet-1k 的标准图像变换，也提供了多种数据增强的方法，相关代码可以查看[数据处理](../../../../ppcls/data/preprocess)，配置文件可以参考[数据增强配置文件](../../../../ppcls/configs/ImageNet/DataAugment)，相关数据增强算法详见[增强介绍文档](../../algorithm_introduction/data_augmentation.md)。
 
 <a name="2.2"></a>
 
 ### 2.2 模型准备
 
-在数据确定后，模型往往决定了最终算法精度的上限，在图像分类领域，经典的模型层出不穷，PaddleClas 提供了 35 个系列共 164 个 ImageNet 预训练模型。具体的精度、速度等指标请参考[骨干网络和预训练模型库](../algorithm_introduction/ImageNet_models.md)。
+在数据确定后，模型往往决定了最终算法精度的上限，在图像分类领域，经典的模型层出不穷，PaddleClas 提供了 35 个系列共 164 个 ImageNet 预训练模型。具体的精度、速度等指标请参考[骨干网络和预训练模型库](../../models/ImageNet1k/model_list.md)。
 
 <a name="2.3"></a>
 ### 2.3 模型训练
 
-在准备好数据、模型后，便可以开始迭代模型并更新模型的参数。经过多次迭代最终可以得到训练好的模型来做图像分类任务。图像分类的训练过程需要很多经验，涉及很多超参数的设置，PaddleClas 提供了一些列的[训练调优方法](./train_strategy.md)，可以快速助你获得高精度的模型。
+在准备好数据、模型后，便可以开始迭代模型并更新模型的参数。经过多次迭代最终可以得到训练好的模型来做图像分类任务。图像分类的训练过程需要很多经验，涉及很多超参数的设置，PaddleClas 提供了一些列的[训练调优方法](training_strategy.md)，可以快速助你获得高精度的模型。
 
-同时，PaddleClas 还支持使用VisualDL 可视化训练过程。VisualDL 是飞桨可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、高维数据分布等。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。更多细节请查看[VisualDL](../others/VisualDL.md)。
+同时，PaddleClas 还支持使用VisualDL 可视化训练过程。VisualDL 是飞桨可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、高维数据分布等。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。更多细节请查看[VisualDL](../config_discription/VisualDL.md)。
 
 <a name="2.4"></a>
 ### 2.4 模型评估
@@ -77,7 +77,7 @@ CIFAR-10 数据集由 10 个类的 60000 个彩色图像组成，图像分辨率
 <a name="3"></a>
 ## 3. 使用方法介绍
 
-请参考[安装指南](../installation/install_paddleclas.md)配置运行环境，并根据[快速开始](../quick_start/quick_start_classification_new_user.md)文档准备 flower102 数据集，本章节下面所有的实验均以 flower102 数据集为例。
+请参考[安装指南](../../installation.md)配置运行环境，并根据[快速开始](../../quick_start/quick_start_classification_new_user.md)文档准备 flower102 数据集，本章节下面所有的实验均以 flower102 数据集为例。
 
 PaddleClas 目前支持的训练/评估环境如下：
 ```shell
@@ -109,7 +109,7 @@ python3 tools/train.py \
 
 其中，`-c` 用于指定配置文件的路径，`-o` 用于指定需要修改或者添加的参数，其中 `-o Arch.pretrained=False` 表示不使用预训练模型，`-o Global.device=gpu` 表示使用 GPU 进行训练。如果希望使用 CPU 进行训练，则需要将 `Global.device` 设置为 `cpu`。
 
-更详细的训练配置，也可以直接修改模型对应的配置文件。具体配置参数参考[配置文档](config_description.md)。
+更详细的训练配置，也可以直接修改模型对应的配置文件。具体配置参数参考[配置文档](../config_discription/basic.md)。
 
 运行上述命令，可以看到输出日志，示例如下：
 
@@ -132,7 +132,7 @@ python3 tools/train.py \
     ...
     ```
 
-训练期间也可以通过 VisualDL 实时观察 loss 变化，详见 [VisualDL](../others/VisualDL.md)。
+训练期间也可以通过 VisualDL 实时观察 loss 变化，详见 [VisualDL](../config_discription/VisualDL.md)。
 
 <a name="3.1.2"></a>
 #### 3.1.2 模型微调
@@ -148,7 +148,7 @@ python3 tools/train.py \
 
 其中 `Arch.pretrained` 设置为 `True` 表示加载 ImageNet 的预训练模型，此外，`Arch.pretrained` 也可以指定具体的模型权重文件的地址，使用时需要换成自己的预训练模型权重文件的路径。
 
-我们也提供了大量基于 `ImageNet-1k` 数据集的预训练模型，模型列表及下载地址详见[模型库概览](../algorithm_introduction/ImageNet_models.md)。
+我们也提供了大量基于 `ImageNet-1k` 数据集的预训练模型，模型列表及下载地址详见[模型库概览](../../models/ImageNet1k/model_list.md)。
 
 
 <a name="3.1.3"></a>
@@ -243,7 +243,7 @@ python3 -m paddle.distributed.launch \
 
 其中 `Arch.pretrained` 为 `True` 或 `False`，当然也可以设置加载预训练权重文件的路径，使用时需要换成自己的预训练模型权重文件路径，也可以直接在配置文件中修改该路径。
 
-30 分钟玩转 PaddleClas [尝鲜版](../quick_start/quick_start_classification_new_user.md)与[进阶版](../quick_start/quick_start_classification_professional.md)中包含大量模型微调的示例，可以参考该章节在特定的数据集上进行模型微调。
+30 分钟玩转 PaddleClas [尝鲜版](../../quick_start/quick_start_classification_new_user.md)与[进阶版](../../quick_start/quick_start_classification_professional.md)中包含大量模型微调的示例，可以参考该章节在特定的数据集上进行模型微调。
 
 <a name="3.2.3"></a>
 

docs/zh_CN/models_training/train_strategy.md → docs/zh_CN/training/single_label_classification/training_strategy.md

@@ -35,7 +35,7 @@
 ### 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)
+![](../../../images/models/lr_decay.jpeg)
 
 另外，从图中我们也可以看到，cosine_decay 里学习率小的轮数较少，这样会影响到最终的精度，所以为了使得 cosine_decay 发挥更好的效果，建议迭代更多的轮数，如 200 轮。
 
@@ -102,7 +102,7 @@ Label_smoothing 是深度学习中的一种正则化方法，其全称是 Label
 
 ## 7. 使用数据增广方式提升精度
 
-一般来说，数据集的规模对性能影响至关重要，但是图片的标注往往比较昂贵，所以有标注的图片数量往往比较稀少，在这种情况下，数据的增广尤为重要。在训练 ImageNet-1k 的标准数据增广中，主要使用了 random_crop 与 random_flip 两种数据增广方式，然而，近些年，越来越多的数据增广方式被提出，如 cutout、mixup、cutmix、AutoAugment 等。实验表明，这些数据的增广方式可以有效提升模型的精度，下表列出了 ResNet50 在 8 种不同的数据增广方式的表现，可以看出，相比 baseline，所有的数据增广方式均有收益，其中 cutmix 是目前最有效的数据增广。更多数据增广的介绍请参考[**数据增广章节**](../algorithm_introduction/DataAugmentation.md)。
+一般来说，数据集的规模对性能影响至关重要，但是图片的标注往往比较昂贵，所以有标注的图片数量往往比较稀少，在这种情况下，数据的增广尤为重要。在训练 ImageNet-1k 的标准数据增广中，主要使用了 random_crop 与 random_flip 两种数据增广方式，然而，近些年，越来越多的数据增广方式被提出，如 cutout、mixup、cutmix、AutoAugment 等。实验表明，这些数据的增广方式可以有效提升模型的精度，下表列出了 ResNet50 在 8 种不同的数据增广方式的表现，可以看出，相比 baseline，所有的数据增广方式均有收益，其中 cutmix 是目前最有效的数据增广。更多数据增广的介绍请参考[**数据增广章节**](../../algorithm_introduction/data_augmentation.md)。
 
 | 模型       | 数据增广方式         | Test top-1 |
 |:--:|:--:|:--:|

docs/zh_CN/others/update_history.md → docs/zh_CN/version_history.md

+# 版本更新信息
+----------
+## 目录
+* [1. v2.3](#1)
+* [2. v2.2](#2)
+
+<a name='1'></a>
+
+## 1. v2.3
+
+- 模型更新
+  - 添加轻量化模型预训练权重，包括检测模型、特征模型
+  - 发布 PP-LCNet 系列模型，此系列模型是专门在 CPU 上设计运行的自研模型
+  - SwinTransformer、Twins、Deit 支持从 scrach 直接训练，达到论文精度
+- 框架基础能力
+  - 添加 DeepHash 模块，支持特征模型直接输出二值特征
+  - 添加 PKSampler，特征模型不能多机多卡的训练的问题
+  - 支持 PaddleSlim：支持分类模型、特征模型的量化、裁剪训练及离线量化功能
+  - Legendary models 支持模型中间结果输出
+  - 支持多标签分类训练
+- 预测部署
+  - 使用 Faiss 替换原有特征检索库，提升平台适配性
+  - 支持 PaddleServing：支持分类模型、图像识别流程的部署
+
+- 推荐库版本
+  - python 版本：3.7
+  - PaddlePaddle 版本：2.1.3
+  - PaddleSlim 版本：2.2.0
+  - PaddleServing 版本：0.6.1
+
+<a name='2'></a>
+
+## 2. v2.2
+
+- 模型更新
+  - 添加 LeViT、Twins、TNT、DLA、HardNet、RedNet、SwinTransfomer 模型
+- 框架基础能力
+  - 将分类模型分为两类
+    -  legendary models：引入 TheseusLayer 基类，及增加了修改网络功能接口，同时支持网络截断输出功能
+    - model zoo：其他普通分类模型
+  - 添加 Metric Learning 算法支持
+    - 添加多种相关 Loss 算法，及基础网络模块 gears（支持与 backbone、loss 组合）方便使用
+    - 同时支持普通分类及 metric learning 相关任务训练
+  - 支持静态图训练
+  - 分类训练支持 dali 加速
+  - 支持 fp16 训练
+- 应用更新
+  - 添加商品识别、车辆识别（车辆细粒度分类、车辆 ReID）、logo 识别、动漫人物识别应用具体案例及相关模型
+  - 添加图像识别完整 pipeline，包含检测模块、特征提取模块、向量检索模块
+- 预测部署
+  - 添加百度自研向量检索模块 Mobius，支持图像识别系统预测部署
+  - 图像识别，建立特征库支持 batch_size>1
+- 文档更新
+  - 添加图像识别相关文档
+  - 修复之前文档 bug
+- 推荐库版本
+  - python 版本：3.7
+  - PaddlePaddle：2.1.2
+
 # 更新日志
 
 - 2022.4.21 新增 CVPR2022 oral论文 [MixFormer](https://arxiv.org/pdf/2204.02557.pdf) 相关[代码](https://github.com/PaddlePaddle/PaddleClas/pull/1820/files)。
 - 2021.11.1 发布[PP-ShiTu技术报告](https://arxiv.org/pdf/2111.00775.pdf)，新增饮料识别demo。
-- 2021.10.23 发布轻量级图像识别系统PP-ShiTu，CPU上0.2s即可完成在10w+库的图像识别。[点击这里](../quick_start/quick_start_recognition.md)立即体验。
-- 2021.09.17 发布PP-LCNet系列超轻量骨干网络模型, 在Intel CPU上，单张图像预测速度约5ms，ImageNet-1K数据集上Top1识别准确率达到80.82%，超越ResNet152的模型效果。PP-LCNet的介绍可以参考[论文](https://arxiv.org/pdf/2109.15099.pdf), 或者[PP-LCNet模型介绍](../models/PP-LCNet.md)，相关指标和预训练权重可以从 [这里](../algorithm_introduction/ImageNet_models.md)下载。
-- 2021.08.11 更新 7 个[FAQ](../faq_series/faq_2021_s2.md)。
-- 2021.06.29 添加 Swin-transformer 系列模型，ImageNet1k 数据集上 Top1 acc 最高精度可达 87.2%；支持训练预测评估与 whl 包部署，预训练模型可以从[这里](../algorithm_introduction/ImageNet_models.md)下载。
+- 2021.10.23 发布轻量级图像识别系统PP-ShiTu，CPU上0.2s即可完成在10w+库的图像识别。[点击这里](quick_start/quick_start_recognition.md)立即体验。
+- 2021.09.17 发布PP-LCNet系列超轻量骨干网络模型, 在Intel CPU上，单张图像预测速度约5ms，ImageNet-1K数据集上Top1识别准确率达到80.82%，超越ResNet152的模型效果。PP-LCNet的介绍可以参考[论文](https://arxiv.org/pdf/2109.15099.pdf), 或者[PP-LCNet模型介绍](../models/PP-LCNet.md)，相关指标和预训练权重可以从 [这里](models/ImageNet1k/model_list.md)下载。
+- 2021.08.11 更新 7 个[FAQ](FAQ/faq_2021_s2.md)。
+- 2021.06.29 添加 Swin-transformer 系列模型，ImageNet1k 数据集上 Top1 acc 最高精度可达 87.2%；支持训练预测评估与 whl 包部署，预训练模型可以从[这里](models/ImageNet1k/model_list.md)下载。
 - 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

paddleclas.py

@@ -192,7 +192,8 @@ PULC_MODEL_BASE_DOWNLOAD_URL = "https://paddleclas.bj.bcebos.com/models/PULC/inf
 PULC_MODELS = [
     "car_exists", "language_classification", "person_attribute",
     "person_exists", "safety_helmet", "text_image_orientation",
-    "textline_orientation", "traffic_sign", "vehicle_attribute"
+    "textline_orientation", "traffic_sign", "vehicle_attribute",
+    "table_attribute"
 ]
 
 SHITU_MODEL_BASE_DOWNLOAD_URL = "https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/{}_infer.tar"
@@ -278,6 +279,7 @@ def init_config(model_type, model_name, inference_model_dir, **kwargs):
     if "thresh" in kwargs and kwargs[
             "thresh"] and "ThreshOutput" in cfg.PostProcess:
         cfg.PostProcess.ThreshOutput.thresh = kwargs["thresh"]
+
     if cfg.get("PostProcess"):
         if "Topk" in cfg.PostProcess:
             if "topk" in kwargs and kwargs["topk"]:
@@ -297,7 +299,25 @@ def init_config(model_type, model_name, inference_model_dir, **kwargs):
             if "type_threshold" in kwargs and kwargs["type_threshold"]:
                 cfg.PostProcess.VehicleAttribute.type_threshold = kwargs[
                     "type_threshold"]
-
+        if "TableAttribute" in cfg.PostProcess:
+            if "source_threshold" in kwargs and kwargs["source_threshold"]:
+                cfg.PostProcess.VehicleAttribute.color_threshold = kwargs[
+                    "source_threshold"]
+            if "number_threshold" in kwargs and kwargs["number_threshold"]:
+                cfg.PostProcess.VehicleAttribute.color_threshold = kwargs[
+                    "number_threshold"]
+            if "color_threshold" in kwargs and kwargs["color_threshold"]:
+                cfg.PostProcess.VehicleAttribute.color_threshold = kwargs[
+                    "color_threshold"]
+            if "clarity_threshold" in kwargs and kwargs["clarity_threshold"]:
+                cfg.PostProcess.VehicleAttribute.color_threshold = kwargs[
+                    "clarity_threshold"]
+            if "obstruction_threshold" in kwargs and kwargs["obstruction_threshold"]:
+                cfg.PostProcess.VehicleAttribute.color_threshold = kwargs[
+                    "obstruction_threshold"]
+            if "angle_threshold" in kwargs and kwargs["angle_threshold"]:
+                cfg.PostProcess.VehicleAttribute.color_threshold = kwargs[
+                    "angle_threshold"]
     if "save_dir" in kwargs and kwargs["save_dir"]:
         cfg.PostProcess.SavePreLabel.save_dir = kwargs["save_dir"]
 

ppcls/configs/ImageNet/Distillation/resnet34_distill_resnet18_wsl.yaml

+# global configs
+Global:
+  checkpoints: null
+  pretrained_model: null
+  output_dir: ./output/r34_r18_wsl
+  device: "gpu"
+  save_interval: 1
+  eval_during_train: True
+  eval_interval: 1
+  epochs: 100
+  print_batch_step: 10
+  use_visualdl: False
+  # used for static mode and model export
+  image_shape: [3, 224, 224]
+  save_inference_dir: "./inference"
+
+# model architecture
+Arch:
+  name: "DistillationModel"
+  # if not null, its lengths should be same as models
+  pretrained_list:
+  # if not null, its lengths should be same as models
+  freeze_params_list:
+  - True
+  - False
+  models:
+    - Teacher:
+        name: ResNet34
+        pretrained: True
+
+    - Student:
+        name: ResNet18
+        pretrained: False
+
+  infer_model_name: "Student"
+
+
+# loss function config for traing/eval process
+Loss:
+  Train:
+    - DistillationGTCELoss:
+        weight: 1.0
+        model_names: ["Student"]
+    - DistillationWSLLoss:
+        weight: 2.5
+        model_name_pairs: [["Student", "Teacher"]]
+        temperature: 2
+  Eval:
+    - CELoss:
+        weight: 1.0
+
+
+Optimizer:
+  name: Momentum
+  momentum: 0.9
+  weight_decay: 1e-4
+  lr:
+    name: MultiStepDecay
+    learning_rate: 0.1
+    milestones: [30, 60, 90]
+    step_each_epoch: 1
+    gamma: 0.1
+
+
+# data loader for train and eval
+DataLoader:
+  Train:
+    dataset:
+        name: ImageNetDataset
+        image_root: "./dataset/ILSVRC2012/"
+        cls_label_path: "./dataset/ILSVRC2012/train_list.txt"
+        transform_ops:
+          - DecodeImage:
+              to_rgb: True
+              channel_first: False
+          - RandCropImage:
+              size: 224
+          - RandFlipImage:
+              flip_code: 1
+          - NormalizeImage:
+              scale: 0.00392157
+              mean: [0.485, 0.456, 0.406]
+              std: [0.229, 0.224, 0.225]
+              order: ''
+
+    sampler:
+        name: DistributedBatchSampler
+        batch_size: 64
+        drop_last: False
+        shuffle: True
+    loader:
+        num_workers: 8
+        use_shared_memory: True
+
+  Eval:
+    dataset: 
+        name: ImageNetDataset
+        image_root: "./dataset/ILSVRC2012/"
+        cls_label_path: "./dataset/ILSVRC2012/val_list.txt"
+        transform_ops:
+          - DecodeImage:
+              to_rgb: True
+              channel_first: False
+          - ResizeImage:
+              resize_short: 256
+          - CropImage:
+              size: 224
+          - NormalizeImage:
+              scale: 0.00392157
+              mean: [0.485, 0.456, 0.406]
+              std: [0.229, 0.224, 0.225]
+              order: ''
+    sampler:
+        name: DistributedBatchSampler
+        batch_size: 64
+        drop_last: False
+        shuffle: False
+    loader:
+        num_workers: 4
+        use_shared_memory: True
+
+Infer:
+  infer_imgs: "docs/images/inference_deployment/whl_demo.jpg"
+  batch_size: 10
+  transforms:
+      - DecodeImage:
+          to_rgb: True
+          channel_first: False
+      - ResizeImage:
+          resize_short: 256
+      - CropImage:
+          size: 224
+      - NormalizeImage:
+          scale: 1.0/255.0
+          mean: [0.485, 0.456, 0.406]
+          std: [0.229, 0.224, 0.225]
+          order: ''
+      - ToCHWImage:
+  PostProcess:
+    name: Topk
+    topk: 5
+    class_id_map_file: "ppcls/utils/imagenet1k_label_list.txt"
+
+Metric:
+    Train:
+    - DistillationTopkAcc:
+        model_key: "Student"
+        topk: [1, 5]
+    Eval:
+    - DistillationTopkAcc:
+        model_key: "Student"
+        topk: [1, 5]

ppcls/configs/PULC/table_attribute/PPLCNet_x1_0.yaml

+# global configs
+Global:
+  checkpoints: null
+  pretrained_model: null
+  output_dir: "./output/"
+  device: "gpu"
+  save_interval: 1
+  eval_during_train: True
+  eval_interval: 1
+  epochs: 20
+  print_batch_step: 10
+  use_visualdl: False
+  # used for static mode and model export
+  image_shape: [3, 224, 224]
+  save_inference_dir: "./inference"
+  use_multilabel: True
+
+# model architecture
+Arch:
+  name: "PPLCNet_x1_0"
+  pretrained: True
+  use_ssld: True
+  class_num: 6
+  
+
+# loss function config for traing/eval process
+Loss:
+  Train:
+    - MultiLabelLoss:
+        weight: 1.0
+        weight_ratio: True
+        size_sum: True
+  Eval:
+    - MultiLabelLoss:
+        weight: 1.0
+        weight_ratio: True
+        size_sum: True
+
+Optimizer:
+  name: Momentum
+  momentum: 0.9
+  lr:
+    name: Cosine
+    learning_rate: 0.01
+    warmup_epoch: 5
+  regularizer:
+    name: 'L2'
+    coeff: 0.0005
+
+# data loader for train and eval
+DataLoader:
+  Train:
+    dataset:
+      name: MultiLabelDataset
+      image_root: "dataset/table_attribute/"
+      cls_label_path: "dataset/table_attribute/train_list.txt"
+      label_ratio: True
+      transform_ops:
+        - DecodeImage:
+            to_rgb: True
+            channel_first: False
+        - ResizeImage:
+            size: [224, 224]
+        - RandFlipImage:
+            flip_code: 1
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+    sampler:
+      name: DistributedBatchSampler
+      batch_size: 64
+      drop_last: True
+      shuffle: True
+    loader:
+      num_workers: 4
+      use_shared_memory: True
+  Eval:
+    dataset:
+      name: MultiLabelDataset
+      image_root: "dataset/table_attribute/"
+      cls_label_path: "dataset/table_attribute/val_list.txt"
+      label_ratio: True
+      transform_ops:
+        - DecodeImage:
+            to_rgb: True
+            channel_first: False
+        - ResizeImage:
+            size: [224, 224]
+        - NormalizeImage:
+            scale: 1.0/255.0
+            mean: [0.485, 0.456, 0.406]
+            std: [0.229, 0.224, 0.225]
+            order: ''
+    sampler:
+      name: DistributedBatchSampler
+      batch_size: 64
+      drop_last: False
+      shuffle: False
+    loader:
+      num_workers: 4
+      use_shared_memory: True
+
+Infer:
+  infer_imgs: deploy/images/PULC/table_attribute/val_3610.jpg
+  batch_size: 10
+  transforms:
+    - DecodeImage:
+        to_rgb: True
+        channel_first: False
+    - ResizeImage:
+        size: [224, 224]
+    - NormalizeImage:
+        scale: 1.0/255.0
+        mean: [0.485, 0.456, 0.406]
+        std: [0.229, 0.224, 0.225]
+        order: ''
+    - ToCHWImage:
+  PostProcess:
+    name: TableAttribute
+    source_threshold: 0.5
+    number_threshold: 0.5
+    color_threshold: 0.5
+    clarity_threshold : 0.5
+    obstruction_threshold: 0.5
+    angle_threshold: 0.5
+
+Metric:
+  Eval:
+    - ATTRMetric:
+
+

ppcls/configs/quick_start/professional/MobileNetV1_multilabel.yaml

@@ -99,7 +99,7 @@ DataLoader:
       use_shared_memory: True
 
 Infer:
-  infer_imgs: ./deploy/images/0517_2715693311.jpg
+  infer_imgs: deploy/images/0517_2715693311.jpg
   batch_size: 10
   transforms:
     - DecodeImage:
@@ -116,9 +116,10 @@ Infer:
         order: ''
     - ToCHWImage:
   PostProcess:
-    name: MultiLabelTopk
-    topk: 5
-    class_id_map_file: None
+    name: MultiLabelThreshOutput
+    threshold: 0.5
+    class_id_map_file: "ppcls/utils/NUS-WIDE-SCENE_label_list.txt"
+    delimiter: " "
 
 Metric:
   Train:

ppcls/configs/reid/strong_baseline/softmax_triplet_with_center.yaml

@@ -87,7 +87,7 @@ Optimizer:
   - SGD:
       scope: CenterLoss
       lr:
-        name: Constant
+        name: ConstLR
         learning_rate: 1000.0 # NOTE: set to ori_lr*(1/centerloss_weight) to avoid manually scaling centers' gradidents.
 
 # data loader for train and eval

ppcls/data/dataloader/pk_sampler.py

@@ -53,14 +53,14 @@ class PKSampler(DistributedBatchSampler):
             f"PKSampler configs error, sample_per_id({sample_per_id}) must be a divisor of batch_size({batch_size})."
         assert hasattr(self.dataset,
                        "labels"), "Dataset must have labels attribute."
-        self.sample_per_label = sample_per_id
+        self.sample_per_id = sample_per_id
         self.label_dict = defaultdict(list)
         self.sample_method = sample_method
         for idx, label in enumerate(self.dataset.labels):
             self.label_dict[label].append(idx)
         self.label_list = list(self.label_dict)
-        assert len(self.label_list) * self.sample_per_label > self.batch_size, \
-            "batch size should be smaller than "
+        assert len(self.label_list) * self.sample_per_id >= self.batch_size, \
+            f"batch size({self.batch_size}) should not be bigger than than #classes({len(self.label_list)})*sample_per_id({self.sample_per_id})"
         if self.sample_method == "id_avg_prob":
             self.prob_list = np.array([1 / len(self.label_list)] *
                                       len(self.label_list))
@@ -94,7 +94,7 @@ class PKSampler(DistributedBatchSampler):
                     format(diff))
 
     def __iter__(self):
-        label_per_batch = self.batch_size // self.sample_per_label
+        label_per_batch = self.batch_size // self.sample_per_id
         for _ in range(len(self)):
             batch_index = []
             batch_label_list = np.random.choice(
@@ -104,17 +104,17 @@ class PKSampler(DistributedBatchSampler):
                 p=self.prob_list)
             for label_i in batch_label_list:
                 label_i_indexes = self.label_dict[label_i]
-                if self.sample_per_label <= len(label_i_indexes):
+                if self.sample_per_id <= len(label_i_indexes):
                     batch_index.extend(
                         np.random.choice(
                             label_i_indexes,
-                            size=self.sample_per_label,
+                            size=self.sample_per_id,
                             replace=False))
                 else:
                     batch_index.extend(
                         np.random.choice(
                             label_i_indexes,
-                            size=self.sample_per_label,
+                            size=self.sample_per_id,
                             replace=True))
             if not self.drop_last or len(batch_index) == self.batch_size:
                 yield batch_index

ppcls/data/postprocess/__init__.py

@@ -16,11 +16,12 @@ import importlib
 
 from . import topk, threshoutput
 
-from .topk import Topk, MultiLabelTopk
-from .threshoutput import ThreshOutput
+from .topk import Topk
+from .threshoutput import ThreshOutput, MultiLabelThreshOutput
 from .attr_rec import VehicleAttribute, PersonAttribute
 
 
+
 def build_postprocess(config):
     config = copy.deepcopy(config)
     model_name = config.pop("name")

ppcls/data/postprocess/attr_rec.py

@@ -71,7 +71,6 @@ class VehicleAttribute(object):
         return batch_res
 
 
-
 class PersonAttribute(object):
     def __init__(self,
                  threshold=0.5,
@@ -171,3 +170,58 @@ class PersonAttribute(object):
             batch_res.append({"attributes": label_res, "output": pred_res})
         return batch_res
 
+
+class TableAttribute(object):
+    def __init__(
+            self,
+            source_threshold=0.5,
+            number_threshold=0.5,
+            color_threshold=0.5,
+            clarity_threshold=0.5,
+            obstruction_threshold=0.5,
+            angle_threshold=0.5, ):
+        self.source_threshold = source_threshold
+        self.number_threshold = number_threshold
+        self.color_threshold = color_threshold
+        self.clarity_threshold = clarity_threshold
+        self.obstruction_threshold = obstruction_threshold
+        self.angle_threshold = angle_threshold
+
+    def __call__(self, x, file_names=None):
+        if isinstance(x, dict):
+            x = x['logits']
+        assert isinstance(x, paddle.Tensor)
+        if file_names is not None:
+            assert x.shape[0] == len(file_names)
+        x = F.sigmoid(x).numpy()
+
+        # postprocess output of predictor
+        batch_res = []
+        for idx, res in enumerate(x):
+            res = res.tolist()
+            label_res = []
+            source = 'Scanned' if res[0] > self.source_threshold else 'Photo'
+            number = 'Little' if res[1] > self.number_threshold else 'Numerous'
+            color = 'Black-and-White' if res[
+                2] > self.color_threshold else 'Multicolor'
+            clarity = 'Clear' if res[3] > self.clarity_threshold else 'Blurry'
+            obstruction = 'Without-Obstacles' if res[
+                4] > self.number_threshold else 'With-Obstacles'
+            angle = 'Horizontal' if res[
+                5] > self.number_threshold else 'Tilted'
+
+            label_res = [source, number, color, clarity, obstruction, angle]
+
+            threshold_list = [
+                self.source_threshold, self.number_threshold,
+                self.color_threshold, self.clarity_threshold,
+                self.obstruction_threshold, self.angle_threshold
+            ]
+            pred_res = (np.array(res) > np.array(threshold_list)
+                        ).astype(np.int8).tolist()
+            batch_res.append({
+                "attributes": label_res,
+                "output": pred_res,
+                "file_name": file_names[idx]
+            })
+        return batch_res

ppcls/data/postprocess/threshoutput.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+import numpy as np
 import paddle.nn.functional as F
 
 
@@ -34,3 +36,55 @@ class ThreshOutput(object):
                 result["file_name"] = file_names[idx]
             y.append(result)
         return y
+
+
+class MultiLabelThreshOutput(object):
+    def __init__(self, threshold=0.5, class_id_map_file=None, delimiter=None):
+        self.threshold = threshold
+        self.delimiter = delimiter if delimiter is not None else " "
+        self.class_id_map = self.parse_class_id_map(class_id_map_file)
+
+    def parse_class_id_map(self, class_id_map_file):
+        if class_id_map_file is None:
+            return None
+        if not os.path.exists(class_id_map_file):
+            print(
+                "Warning: If want to use your own label_dict, please input legal path!\nOtherwise label_names will be empty!"
+            )
+            return None
+
+        try:
+            class_id_map = {}
+            with open(class_id_map_file, "r") as fin:
+                lines = fin.readlines()
+                for line in lines:
+                    partition = line.split("\n")[0].partition(self.delimiter)
+                    class_id_map[int(partition[0])] = str(partition[-1])
+        except Exception as ex:
+            print(ex)
+            class_id_map = None
+        return class_id_map
+
+    def __call__(self, x, file_names=None):
+        y = []
+        x = F.sigmoid(x).numpy()
+        for idx, probs in enumerate(x):
+            index = np.where(probs >= self.threshold)[0].astype("int32")
+            clas_id_list = []
+            score_list = []
+            label_name_list = []
+            for i in index:
+                clas_id_list.append(i.item())
+                score_list.append(probs[i].item())
+                if self.class_id_map is not None:
+                    label_name_list.append(self.class_id_map[i.item()])
+            result = {
+                "class_ids": clas_id_list,
+                "scores": np.around(
+                    score_list, decimals=5).tolist(),
+                "label_names": label_name_list    
+            }
+            if file_names is not None:
+                result["file_name"] = file_names[idx]
+            y.append(result)
+        return y

ppcls/data/postprocess/topk.py

@@ -46,19 +46,18 @@ class Topk(object):
             class_id_map = None
         return class_id_map
 
-    def __call__(self, x, file_names=None, multilabel=False):
+    def __call__(self, x, file_names=None):
         if isinstance(x, dict):
             x = x['logits']
         assert isinstance(x, paddle.Tensor)
         if file_names is not None:
             assert x.shape[0] == len(file_names)
-        x = F.softmax(x, axis=-1) if not multilabel else F.sigmoid(x)
+        x = F.softmax(x, axis=-1)
         x = x.numpy()
         y = []
         for idx, probs in enumerate(x):
             index = probs.argsort(axis=0)[-self.topk:][::-1].astype(
-                "int32") if not multilabel else np.where(
-                    probs >= 0.5)[0].astype("int32")
+                "int32")
             clas_id_list = []
             score_list = []
             label_name_list = []
@@ -79,10 +78,3 @@ class Topk(object):
             y.append(result)
         return y
 
-
-class MultiLabelTopk(Topk):
-    def __init__(self, topk=1, class_id_map_file=None):
-        super().__init__()
-
-    def __call__(self, x, file_names=None):
-        return super().__call__(x, file_names, multilabel=True)

ppcls/engine/engine.py

@@ -502,7 +502,7 @@ class Engine(object):
         assert self.mode == "export"
         use_multilabel = self.config["Global"].get(
             "use_multilabel",
-            False) and "ATTRMetric" in self.config["Metric"]["Eval"][0]
+            False) or "ATTRMetric" in self.config["Metric"]["Eval"][0]
         model = ExportModel(self.config["Arch"], self.model, use_multilabel)
         if self.config["Global"]["pretrained_model"] is not None:
             load_dygraph_pretrain(model.base_model,

ppcls/engine/evaluation/classification.py

@@ -81,8 +81,9 @@ def classification_eval(engine, epoch_id=0):
         # gather Tensor when distributed
         if paddle.distributed.get_world_size() > 1:
             label_list = []
-
-            paddle.distributed.all_gather(label_list, batch[1])
+            label = batch[1].cuda() if engine.config["Global"][
+                "device"] == "gpu" else batch[1]
+            paddle.distributed.all_gather(label_list, label)
             labels = paddle.concat(label_list, 0)
 
             if isinstance(out, list):

ppcls/loss/__init__.py

@@ -26,6 +26,7 @@ from .distillationloss import DistillationDistanceLoss
 from .distillationloss import DistillationRKDLoss
 from .distillationloss import DistillationKLDivLoss
 from .distillationloss import DistillationDKDLoss
+from .distillationloss import DistillationWSLLoss
 from .distillationloss import DistillationMultiLabelLoss
 from .distillationloss import DistillationDISTLoss
 from .distillationloss import DistillationPairLoss

ppcls/loss/distillationloss.py

@@ -22,6 +22,7 @@ from .distanceloss import DistanceLoss
 from .rkdloss import RKdAngle, RkdDistance
 from .kldivloss import KLDivLoss
 from .dkdloss import DKDLoss
+from .wslloss import WSLLoss
 from .dist_loss import DISTLoss
 from .multilabelloss import MultiLabelLoss
 from .mgd_loss import MGDLoss
@@ -262,6 +263,34 @@ class DistillationDKDLoss(DKDLoss):
         return loss_dict
 
 
+class DistillationWSLLoss(WSLLoss):
+    """
+    DistillationWSLLoss
+    """
+
+    def __init__(self,
+                 model_name_pairs=[],
+                 key=None,
+                 temperature=2.0,
+                 name="wsl_loss"):
+        super().__init__(temperature)
+        self.model_name_pairs = model_name_pairs
+        self.key = key
+        self.name = name
+
+    def forward(self, predicts, batch):
+        loss_dict = dict()
+        for idx, pair in enumerate(self.model_name_pairs):
+            out1 = predicts[pair[0]]
+            out2 = predicts[pair[1]]
+            if self.key is not None:
+                out1 = out1[self.key]
+                out2 = out2[self.key]
+            loss = super().forward(out1, out2, batch)
+            loss_dict[f"{self.name}_{pair[0]}_{pair[1]}"] = loss
+        return loss_dict
+
+
 class DistillationMultiLabelLoss(MultiLabelLoss):
     """
     DistillationMultiLabelLoss

ppcls/loss/wslloss.py

+# copyright (c) 2022 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle
+import paddle.nn as nn
+import paddle.nn.functional as F
+
+
+class WSLLoss(nn.Layer):
+    """
+    Weighted Soft Labels Loss
+    paper: https://arxiv.org/pdf/2102.00650.pdf
+    code reference: https://github.com/bellymonster/Weighted-Soft-Label-Distillation
+    """
+
+    def __init__(self, temperature=2.0, use_target_as_gt=False):
+        super().__init__()
+        self.temperature = temperature
+        self.use_target_as_gt = use_target_as_gt
+
+    def forward(self, logits_student, logits_teacher, target=None):
+        """Compute weighted soft labels loss.
+        Args:
+            logits_student: student's logits with shape (batch_size, num_classes)
+            logits_teacher: teacher's logits with shape (batch_size, num_classes)
+            target: ground truth labels with shape (batch_size)
+        """
+        if target is None or self.use_target_as_gt:
+            target = logits_teacher.argmax(axis=-1)
+
+        target = F.one_hot(
+            target.reshape([-1]), num_classes=logits_student[0].shape[0])
+
+        s_input_for_softmax = logits_student / self.temperature
+        t_input_for_softmax = logits_teacher / self.temperature
+
+        ce_loss_s = -paddle.sum(target *
+                                F.log_softmax(logits_student.detach()),
+                                axis=1)
+        ce_loss_t = -paddle.sum(target *
+                                F.log_softmax(logits_teacher.detach()),
+                                axis=1)
+
+        ratio = ce_loss_s / (ce_loss_t + 1e-7)
+        ratio = paddle.maximum(ratio, paddle.zeros_like(ratio))
+
+        kd_loss = -paddle.sum(F.softmax(t_input_for_softmax) *
+                              F.log_softmax(s_input_for_softmax),
+                              axis=1)
+        weight = 1 - paddle.exp(-ratio)
+
+        weighted_kd_loss = (self.temperature**2) * paddle.mean(kd_loss *
+                                                               weight)
+
+        return weighted_kd_loss

ppcls/optimizer/learning_rate.py

@@ -15,117 +15,228 @@
 from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
 
-from paddle.optimizer import lr
-from paddle.optimizer.lr import LRScheduler
+from abc import abstractmethod
+from typing import Union
 
+from paddle.optimizer import lr
 from ppcls.utils import logger
 
 
-class Linear(object):
+class LRBase(object):
+    """Base class for custom learning rates
+
+    Args:
+        epochs (int): total epoch(s)
+        step_each_epoch (int): number of iterations within an epoch
+        learning_rate (float): learning rate
+        warmup_epoch (int): number of warmup epoch(s)
+        warmup_start_lr (float): start learning rate within warmup
+        last_epoch (int): last epoch
+        by_epoch (bool): learning rate decays by epoch when by_epoch is True, else by iter
+        verbose (bool): If True, prints a message to stdout for each update. Defaults to False
+    """
+
+    def __init__(self,
+                 epochs: int,
+                 step_each_epoch: int,
+                 learning_rate: float,
+                 warmup_epoch: int,
+                 warmup_start_lr: float,
+                 last_epoch: int,
+                 by_epoch: bool,
+                 verbose: bool=False) -> None:
+        """Initialize and record the necessary parameters
+        """
+        super(LRBase, self).__init__()
+        if warmup_epoch >= epochs:
+            msg = f"When using warm up, the value of \"Global.epochs\" must be greater than value of \"Optimizer.lr.warmup_epoch\". The value of \"Optimizer.lr.warmup_epoch\" has been set to {epochs}."
+            logger.warning(msg)
+            warmup_epoch = epochs
+        self.epochs = epochs
+        self.step_each_epoch = step_each_epoch
+        self.learning_rate = learning_rate
+        self.warmup_epoch = warmup_epoch
+        self.warmup_steps = self.warmup_epoch if by_epoch else round(
+            self.warmup_epoch * self.step_each_epoch)
+        self.warmup_start_lr = warmup_start_lr
+        self.last_epoch = last_epoch
+        self.by_epoch = by_epoch
+        self.verbose = verbose
+
+    @abstractmethod
+    def __call__(self, *kargs, **kwargs) -> lr.LRScheduler:
+        """generate an learning rate scheduler
+
+        Returns:
+            lr.LinearWarmup: learning rate scheduler
+        """
+        pass
+
+    def linear_warmup(
+            self,
+            learning_rate: Union[float, lr.LRScheduler]) -> lr.LinearWarmup:
+        """Add an Linear Warmup before learning_rate
+
+        Args:
+            learning_rate (Union[float, lr.LRScheduler]): original learning rate without warmup
+
+        Returns:
+            lr.LinearWarmup: learning rate scheduler with warmup
+        """
+        warmup_lr = lr.LinearWarmup(
+            learning_rate=learning_rate,
+            warmup_steps=self.warmup_steps,
+            start_lr=self.warmup_start_lr,
+            end_lr=self.learning_rate,
+            last_epoch=self.last_epoch,
+            verbose=self.verbose)
+        return warmup_lr
+
+
+class Constant(lr.LRScheduler):
+    """Constant learning rate Class implementation
+
+    Args:
+        learning_rate (float): The initial learning rate
+        last_epoch (int, optional): The index of last epoch. Default: -1.
     """
-    Linear learning rate decay
+
+    def __init__(self, learning_rate, last_epoch=-1, **kwargs):
+        self.learning_rate = learning_rate
+        self.last_epoch = last_epoch
+        super(Constant, self).__init__()
+
+    def get_lr(self) -> float:
+        """always return the same learning rate
+        """
+        return self.learning_rate
+
+
+class ConstLR(LRBase):
+    """Constant learning rate
+
     Args:
-        lr (float): The initial learning rate. It is a python float number.
-        epochs(int): The decay step size. It determines the decay cycle.
-        end_lr(float, optional): The minimum final learning rate. Default: 0.0001.
-        power(float, optional): Power of polynomial. Default: 1.0.
-        warmup_epoch(int): The epoch numbers for LinearWarmup. Default: 0.
-        warmup_start_lr(float): Initial learning rate of warm up. Default: 0.0.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
+        epochs (int): total epoch(s)
+        step_each_epoch (int): number of iterations within an epoch
+        learning_rate (float): learning rate
+        warmup_epoch (int): number of warmup epoch(s)
+        warmup_start_lr (float): start learning rate within warmup
+        last_epoch (int): last epoch
+        by_epoch (bool): learning rate decays by epoch when by_epoch is True, else by iter
     """
 
     def __init__(self,
+                 epochs,
+                 step_each_epoch,
                  learning_rate,
+                 warmup_epoch=0,
+                 warmup_start_lr=0.0,
+                 last_epoch=-1,
+                 by_epoch=False,
+                 **kwargs):
+        super(ConstLR, self).__init__(epochs, step_each_epoch, learning_rate,
+                                      warmup_epoch, warmup_start_lr,
+                                      last_epoch, by_epoch)
+
+    def __call__(self):
+        learning_rate = Constant(
+            learning_rate=self.learning_rate, last_epoch=self.last_epoch)
+
+        if self.warmup_steps > 0:
+            learning_rate = self.linear_warmup(learning_rate)
+
+        setattr(learning_rate, "by_epoch", self.by_epoch)
+        return learning_rate
+
+
+class Linear(LRBase):
+    """Linear learning rate decay
+
+    Args:
+        epochs (int): total epoch(s)
+        step_each_epoch (int): number of iterations within an epoch
+        learning_rate (float): learning rate
+        end_lr (float, optional): The minimum final learning rate. Defaults to 0.0.
+        power (float, optional): Power of polynomial. Defaults to 1.0.
+        warmup_epoch (int): number of warmup epoch(s)
+        warmup_start_lr (float): start learning rate within warmup
+        last_epoch (int): last epoch
+        by_epoch (bool): learning rate decays by epoch when by_epoch is True, else by iter
+    """
+
+    def __init__(self,
                  epochs,
                  step_each_epoch,
+                 learning_rate,
                  end_lr=0.0,
                  power=1.0,
+                 cycle=False,
                  warmup_epoch=0,
                  warmup_start_lr=0.0,
                  last_epoch=-1,
+                 by_epoch=False,
                  **kwargs):
-        super().__init__()
-        if warmup_epoch >= epochs:
-            msg = f"When using warm up, the value of \"Global.epochs\" must be greater than value of \"Optimizer.lr.warmup_epoch\". The value of \"Optimizer.lr.warmup_epoch\" has been set to {epochs}."
-            logger.warning(msg)
-            warmup_epoch = epochs
-        self.learning_rate = learning_rate
-        self.steps = (epochs - warmup_epoch) * step_each_epoch
+        super(Linear, self).__init__(epochs, step_each_epoch, learning_rate,
+                                     warmup_epoch, warmup_start_lr, last_epoch,
+                                     by_epoch)
+        self.decay_steps = (epochs - self.warmup_epoch) * step_each_epoch
         self.end_lr = end_lr
         self.power = power
-        self.last_epoch = last_epoch
-        self.warmup_steps = round(warmup_epoch * step_each_epoch)
-        self.warmup_start_lr = warmup_start_lr
+        self.cycle = cycle
+        self.warmup_steps = round(self.warmup_epoch * step_each_epoch)
+        if self.by_epoch:
+            self.decay_steps = self.epochs - self.warmup_epoch
 
     def __call__(self):
         learning_rate = lr.PolynomialDecay(
             learning_rate=self.learning_rate,
-            decay_steps=self.steps,
+            decay_steps=self.decay_steps,
             end_lr=self.end_lr,
             power=self.power,
+            cycle=self.cycle,
             last_epoch=self.
-            last_epoch) if self.steps > 0 else self.learning_rate
+            last_epoch) if self.decay_steps > 0 else self.learning_rate
+
         if self.warmup_steps > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_steps,
-                start_lr=self.warmup_start_lr,
-                end_lr=self.learning_rate,
-                last_epoch=self.last_epoch)
-        return learning_rate
+            learning_rate = self.linear_warmup(learning_rate)
 
+        setattr(learning_rate, "by_epoch", self.by_epoch)
+        return learning_rate
 
-class Constant(LRScheduler):
-    """
-    Constant learning rate
-    Args:
-        lr (float): The initial learning rate. It is a python float number.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-    """
 
-    def __init__(self, learning_rate, last_epoch=-1, **kwargs):
-        self.learning_rate = learning_rate
-        self.last_epoch = last_epoch
-        super().__init__()
+class Cosine(LRBase):
+    """Cosine learning rate decay
 
-    def get_lr(self):
-        return self.learning_rate
+    ``lr = 0.05 * (math.cos(epoch * (math.pi / epochs)) + 1)``
 
-
-class Cosine(object):
-    """
-    Cosine learning rate decay
-    lr = 0.05 * (math.cos(epoch * (math.pi / epochs)) + 1)
     Args:
-        lr(float): initial learning rate
-        step_each_epoch(int): steps each epoch
-        epochs(int): total training epochs
-        eta_min(float): Minimum learning rate. Default: 0.0.
-        warmup_epoch(int): The epoch numbers for LinearWarmup. Default: 0.
-        warmup_start_lr(float): Initial learning rate of warm up. Default: 0.0.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
+        epochs (int): total epoch(s)
+        step_each_epoch (int): number of iterations within an epoch
+        learning_rate (float): learning rate
+        eta_min (float, optional): Minimum learning rate. Defaults to 0.0.
+        warmup_epoch (int, optional): The epoch numbers for LinearWarmup. Defaults to 0.
+        warmup_start_lr (float, optional): start learning rate within warmup. Defaults to 0.0.
+        last_epoch (int, optional): last epoch. Defaults to -1.
+        by_epoch (bool, optional): learning rate decays by epoch when by_epoch is True, else by iter. Defaults to False.
     """
 
     def __init__(self,
-                 learning_rate,
-                 step_each_epoch,
                  epochs,
+                 step_each_epoch,
+                 learning_rate,
                  eta_min=0.0,
                  warmup_epoch=0,
                  warmup_start_lr=0.0,
                  last_epoch=-1,
+                 by_epoch=False,
                  **kwargs):
-        super().__init__()
-        if warmup_epoch >= epochs:
-            msg = f"When using warm up, the value of \"Global.epochs\" must be greater than value of \"Optimizer.lr.warmup_epoch\". The value of \"Optimizer.lr.warmup_epoch\" has been set to {epochs}."
-            logger.warning(msg)
-            warmup_epoch = epochs
-        self.learning_rate = learning_rate
-        self.T_max = (epochs - warmup_epoch) * step_each_epoch
+        super(Cosine, self).__init__(epochs, step_each_epoch, learning_rate,
+                                     warmup_epoch, warmup_start_lr, last_epoch,
+                                     by_epoch)
+        self.T_max = (self.epochs - self.warmup_epoch) * self.step_each_epoch
         self.eta_min = eta_min
-        self.last_epoch = last_epoch
-        self.warmup_steps = round(warmup_epoch * step_each_epoch)
-        self.warmup_start_lr = warmup_start_lr
+        if self.by_epoch:
+            self.T_max = self.epochs - self.warmup_epoch
 
     def __call__(self):
         learning_rate = lr.CosineAnnealingDecay(
@@ -134,51 +245,47 @@ class Cosine(object):
             eta_min=self.eta_min,
             last_epoch=self.
             last_epoch) if self.T_max > 0 else self.learning_rate
+
         if self.warmup_steps > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_steps,
-                start_lr=self.warmup_start_lr,
-                end_lr=self.learning_rate,
-                last_epoch=self.last_epoch)
+            learning_rate = self.linear_warmup(learning_rate)
+
+        setattr(learning_rate, "by_epoch", self.by_epoch)
         return learning_rate
 
 
-class Step(object):
-    """
-    Piecewise learning rate decay
+class Step(LRBase):
+    """Step learning rate decay
+
     Args:
-        step_each_epoch(int): steps each epoch
-        learning_rate (float): The initial learning rate. It is a python float number.
+        epochs (int): total epoch(s)
+        step_each_epoch (int): number of iterations within an epoch
+        learning_rate (float): learning rate
         step_size (int): the interval to update.
-        gamma (float, optional): The Ratio that the learning rate will be reduced. ``new_lr = origin_lr * gamma`` .
-            It should be less than 1.0. Default: 0.1.
-        warmup_epoch(int): The epoch numbers for LinearWarmup. Default: 0.
-        warmup_start_lr(float): Initial learning rate of warm up. Default: 0.0.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
+        gamma (float, optional): The Ratio that the learning rate will be reduced. ``new_lr = origin_lr * gamma``. It should be less than 1.0. Default: 0.1.
+        warmup_epoch (int, optional): The epoch numbers for LinearWarmup. Defaults to 0.
+        warmup_start_lr (float, optional): start learning rate within warmup. Defaults to 0.0.
+        last_epoch (int, optional): last epoch. Defaults to -1.
+        by_epoch (bool, optional): learning rate decays by epoch when by_epoch is True, else by iter. Defaults to False.
     """
 
     def __init__(self,
+                 epochs,
+                 step_each_epoch,
                  learning_rate,
                  step_size,
-                 step_each_epoch,
-                 epochs,
                  gamma,
                  warmup_epoch=0,
                  warmup_start_lr=0.0,
                  last_epoch=-1,
+                 by_epoch=False,
                  **kwargs):
-        super().__init__()
-        if warmup_epoch >= epochs:
-            msg = f"When using warm up, the value of \"Global.epochs\" must be greater than value of \"Optimizer.lr.warmup_epoch\". The value of \"Optimizer.lr.warmup_epoch\" has been set to {epochs}."
-            logger.warning(msg)
-            warmup_epoch = epochs
-        self.step_size = step_each_epoch * step_size
-        self.learning_rate = learning_rate
+        super(Step, self).__init__(epochs, step_each_epoch, learning_rate,
+                                   warmup_epoch, warmup_start_lr, last_epoch,
+                                   by_epoch)
+        self.step_size = step_size * step_each_epoch
         self.gamma = gamma
-        self.last_epoch = last_epoch
-        self.warmup_steps = round(warmup_epoch * step_each_epoch)
-        self.warmup_start_lr = warmup_start_lr
+        if self.by_epoch:
+            self.step_size = step_size
 
     def __call__(self):
         learning_rate = lr.StepDecay(
@@ -186,177 +293,102 @@ class Step(object):
             step_size=self.step_size,
             gamma=self.gamma,
             last_epoch=self.last_epoch)
+
         if self.warmup_steps > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_steps,
-                start_lr=self.warmup_start_lr,
-                end_lr=self.learning_rate,
-                last_epoch=self.last_epoch)
+            learning_rate = self.linear_warmup(learning_rate)
+
+        setattr(learning_rate, "by_epoch", self.by_epoch)
         return learning_rate
 
 
-class Piecewise(object):
-    """
-    Piecewise learning rate decay
+class Piecewise(LRBase):
+    """Piecewise learning rate decay
+
     Args:
-        boundaries(list): A list of steps numbers. The type of element in the list is python int.
-        values(list): A list of learning rate values that will be picked during different epoch boundaries.
-            The type of element in the list is python float.
-        warmup_epoch(int): The epoch numbers for LinearWarmup. Default: 0.
-        warmup_start_lr(float): Initial learning rate of warm up. Default: 0.0.
-        by_epoch(bool): Whether lr decay by epoch. Default: False.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
+        epochs (int): total epoch(s)
+        step_each_epoch (int): number of iterations within an epoch
+        decay_epochs (List[int]): A list of steps numbers. The type of element in the list is python int.
+        values (List[float]): A list of learning rate values that will be picked during different epoch boundaries.
+        warmup_epoch (int, optional): The epoch numbers for LinearWarmup. Defaults to 0.
+        warmup_start_lr (float, optional): start learning rate within warmup. Defaults to 0.0.
+        last_epoch (int, optional): last epoch. Defaults to -1.
+        by_epoch (bool, optional): learning rate decays by epoch when by_epoch is True, else by iter. Defaults to False.
     """
 
     def __init__(self,
+                 epochs,
                  step_each_epoch,
                  decay_epochs,
                  values,
-                 epochs,
                  warmup_epoch=0,
                  warmup_start_lr=0.0,
-                 by_epoch=False,
                  last_epoch=-1,
+                 by_epoch=False,
                  **kwargs):
-        super().__init__()
-        if warmup_epoch >= epochs:
-            msg = f"When using warm up, the value of \"Global.epochs\" must be greater than value of \"Optimizer.lr.warmup_epoch\". The value of \"Optimizer.lr.warmup_epoch\" has been set to {epochs}."
-            logger.warning(msg)
-            warmup_epoch = epochs
-        self.boundaries_steps = [step_each_epoch * e for e in decay_epochs]
-        self.boundaries_epoch = decay_epochs
+        super(Piecewise,
+              self).__init__(epochs, step_each_epoch, values[0], warmup_epoch,
+                             warmup_start_lr, last_epoch, by_epoch)
         self.values = values
-        self.last_epoch = last_epoch
-        self.warmup_steps = round(warmup_epoch * step_each_epoch)
-        self.warmup_epoch = warmup_epoch
-        self.warmup_start_lr = warmup_start_lr
-        self.by_epoch = by_epoch
+        self.boundaries_steps = [e * step_each_epoch for e in decay_epochs]
+        if self.by_epoch is True:
+            self.boundaries_steps = decay_epochs
 
     def __call__(self):
-        if self.by_epoch:
-            learning_rate = lr.PiecewiseDecay(
-                boundaries=self.boundaries_epoch,
-                values=self.values,
-                last_epoch=self.last_epoch)
-            if self.warmup_epoch > 0:
-                learning_rate = lr.LinearWarmup(
-                    learning_rate=learning_rate,
-                    warmup_steps=self.warmup_epoch,
-                    start_lr=self.warmup_start_lr,
-                    end_lr=self.values[0],
-                    last_epoch=self.last_epoch)
-        else:
-            learning_rate = lr.PiecewiseDecay(
-                boundaries=self.boundaries_steps,
-                values=self.values,
-                last_epoch=self.last_epoch)
-            if self.warmup_steps > 0:
-                learning_rate = lr.LinearWarmup(
-                    learning_rate=learning_rate,
-                    warmup_steps=self.warmup_steps,
-                    start_lr=self.warmup_start_lr,
-                    end_lr=self.values[0],
-                    last_epoch=self.last_epoch)
+        learning_rate = lr.PiecewiseDecay(
+            boundaries=self.boundaries_steps,
+            values=self.values,
+            last_epoch=self.last_epoch)
+
+        if self.warmup_steps > 0:
+            learning_rate = self.linear_warmup(learning_rate)
+
         setattr(learning_rate, "by_epoch", self.by_epoch)
         return learning_rate
 
 
-class MultiStepDecay(LRScheduler):
-    """
-    Update the learning rate by ``gamma`` once ``epoch`` reaches one of the milestones.
-    The algorithm can be described as the code below.
-    .. code-block:: text
-        learning_rate = 0.5
-        milestones = [30, 50]
-        gamma = 0.1
-        if epoch < 30:
-            learning_rate = 0.5
-        elif epoch < 50:
-            learning_rate = 0.05
-        else:
-            learning_rate = 0.005
+class MultiStepDecay(LRBase):
+    """MultiStepDecay learning rate decay
+
     Args:
-        learning_rate (float): The initial learning rate. It is a python float number.
-        milestones (tuple|list): List or tuple of each boundaries. Must be increasing.
-        gamma (float, optional): The Ratio that the learning rate will be reduced. ``new_lr = origin_lr * gamma`` .
-            It should be less than 1.0. Default: 0.1.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-        verbose (bool, optional): If ``True``, prints a message to stdout for each update. Default: ``False`` .
-
-    Returns:
-        ``MultiStepDecay`` instance to schedule learning rate.
-    Examples:
-
-        .. code-block:: python
-            import paddle
-            import numpy as np
-            # train on default dynamic graph mode
-            linear = paddle.nn.Linear(10, 10)
-            scheduler = paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[2, 4, 6], gamma=0.8, verbose=True)
-            sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
-            for epoch in range(20):
-                for batch_id in range(5):
-                    x = paddle.uniform([10, 10])
-                    out = linear(x)
-                    loss = paddle.mean(out)
-                    loss.backward()
-                    sgd.step()
-                    sgd.clear_gradients()
-                    scheduler.step()    # If you update learning rate each step
-              # scheduler.step()        # If you update learning rate each epoch
-            # train on static graph mode
-            paddle.enable_static()
-            main_prog = paddle.static.Program()
-            start_prog = paddle.static.Program()
-            with paddle.static.program_guard(main_prog, start_prog):
-                x = paddle.static.data(name='x', shape=[None, 4, 5])
-                y = paddle.static.data(name='y', shape=[None, 4, 5])
-                z = paddle.static.nn.fc(x, 100)
-                loss = paddle.mean(z)
-                scheduler = paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[2, 4, 6], gamma=0.8, verbose=True)
-                sgd = paddle.optimizer.SGD(learning_rate=scheduler)
-                sgd.minimize(loss)
-            exe = paddle.static.Executor()
-            exe.run(start_prog)
-            for epoch in range(20):
-                for batch_id in range(5):
-                    out = exe.run(
-                        main_prog,
-                        feed={
-                            'x': np.random.randn(3, 4, 5).astype('float32'),
-                            'y': np.random.randn(3, 4, 5).astype('float32')
-                        },
-                        fetch_list=loss.name)
-                    scheduler.step()    # If you update learning rate each step
-              # scheduler.step()        # If you update learning rate each epoch
+        epochs (int): total epoch(s)
+        step_each_epoch (int): number of iterations within an epoch
+        learning_rate (float): learning rate
+        milestones (List[int]): List of each boundaries. Must be increasing.
+        gamma (float, optional): The Ratio that the learning rate will be reduced. ``new_lr = origin_lr * gamma``. It should be less than 1.0. Defaults to 0.1.
+        warmup_epoch (int, optional): The epoch numbers for LinearWarmup. Defaults to 0.
+        warmup_start_lr (float, optional): start learning rate within warmup. Defaults to 0.0.
+        last_epoch (int, optional): last epoch. Defaults to -1.
+        by_epoch (bool, optional): learning rate decays by epoch when by_epoch is True, else by iter. Defaults to False.
     """
 
     def __init__(self,
-                 learning_rate,
-                 milestones,
                  epochs,
                  step_each_epoch,
+                 learning_rate,
+                 milestones,
                  gamma=0.1,
+                 warmup_epoch=0,
+                 warmup_start_lr=0.0,
                  last_epoch=-1,
-                 verbose=False):
-        if not isinstance(milestones, (tuple, list)):
-            raise TypeError(
-                "The type of 'milestones' in 'MultiStepDecay' must be 'tuple, list', but received %s."
-                % type(milestones))
-        if not all([
-                milestones[i] < milestones[i + 1]
-                for i in range(len(milestones) - 1)
-        ]):
-            raise ValueError('The elements of milestones must be incremented')
-        if gamma >= 1.0:
-            raise ValueError('gamma should be < 1.0.')
+                 by_epoch=False,
+                 **kwargs):
+        super(MultiStepDecay, self).__init__(
+            epochs, step_each_epoch, learning_rate, warmup_epoch,
+            warmup_start_lr, last_epoch, by_epoch)
         self.milestones = [x * step_each_epoch for x in milestones]
         self.gamma = gamma
-        super().__init__(learning_rate, last_epoch, verbose)
+        if self.by_epoch:
+            self.milestones = milestones
 
-    def get_lr(self):
-        for i in range(len(self.milestones)):
-            if self.last_epoch < self.milestones[i]:
-                return self.base_lr * (self.gamma**i)
-        return self.base_lr * (self.gamma**len(self.milestones))
+    def __call__(self):
+        learning_rate = lr.MultiStepDecay(
+            learning_rate=self.learning_rate,
+            milestones=self.milestones,
+            gamma=self.gamma,
+            last_epoch=self.last_epoch)
+
+        if self.warmup_steps > 0:
+            learning_rate = self.linear_warmup(learning_rate)
+
+        setattr(learning_rate, "by_epoch", self.by_epoch)
+        return learning_rate

ppcls/utils/NUS-WIDE-SCENE_label_list.txt

+0 airport
+1 beach
+2 bridge
+3 buildings
+4 castle
+5 cityscape
+6 clouds
+7 frost
+8 garden
+9 glacier
+10 grass
+11 harbor
+12 house
+13 lake
+14 moon
+15 mountain
+16 nighttime
+17 ocean
+18 plants
+19 railroad
+20 rainbow
+21 reflection
+22 road
+23 sky
+24 snow
+25 street
+26 sunset
+27 temple
+28 town
+29 valley
+30 water
+31 waterfall
+32 window

test_tipc/README.md

@@ -115,3 +115,4 @@ bash test_tipc/test_train_inference_python.sh ./test_tipc/configs/MobileNetV3/Mo
 - [test_serving_infer_python 使用](docs/test_serving_infer_python.md)：测试python serving功能。
 - [test_serving_infer_cpp 使用](docs/test_serving_infer_cpp.md)：测试cpp serving功能。
 - [test_train_fleet_inference_python 使用](./docs/test_train_fleet_inference_python.md)：测试基于Python的多机多卡训练与推理等基本功能。
+- [benchmark_train 使用](./docs/benchmark_train.md)：测试基于Python的训练benchmark等基本功能。

test_tipc/configs/GeneralRecognitionV2/GeneralRecognitionV2_PPLCNetV2_base_train_infer_python.txt

@@ -51,7 +51,7 @@ inference:python/predict_rec.py -c configs/inference_rec.yaml
 null:null
 null:null
 ===========================train_benchmark_params==========================
-batch_size:256
+batch_size:128
 fp_items:fp32|fp16
 epoch:1
 --profiler_options:batch_range=[10,20];state=GPU;tracer_option=Default;profile_path=model.profile

test_tipc/test_train_inference_python.sh

@@ -274,11 +274,15 @@ else
                 # export FLAGS_cudnn_deterministic=True
                 sleep 5
                 eval $cmd
-                eval "cat ${save_log}/${model_name}/train.log >> ${save_log}.log"
+                if [[ $model_name == *GeneralRecognition* ]]; then
+                    eval "cat ${save_log}/RecModel/train.log >> ${save_log}.log"
+                else
+                    eval "cat ${save_log}/${model_name}/train.log >> ${save_log}.log"
+                fi
                 status_check $? "${cmd}" "${status_log}" "${model_name}" "${save_log}.log"
                 sleep 5
 
-                if [[ $FILENAME == *GeneralRecognition* ]]; then
+                if [[ $model_name == *GeneralRecognition* ]]; then
                     set_eval_pretrain=$(func_set_params "${pretrain_model_key}" "${save_log}/RecModel/${train_model_name}")
                 else
                     set_eval_pretrain=$(func_set_params "${pretrain_model_key}" "${save_log}/${model_name}/${train_model_name}")
@@ -300,7 +304,7 @@ else
                 if [ ${run_export} != "null" ]; then
                     # run export model
                     save_infer_path="${save_log}"
-                    if [[ $FILENAME == *GeneralRecognition* ]]; then
+                    if [[ $model_name == *GeneralRecognition* ]]; then
                         set_eval_pretrain=$(func_set_params "${pretrain_model_key}" "${save_log}/RecModel/${train_model_name}")
                     else
                         set_export_weight=$(func_set_params "${export_weight}" "${save_log}/${model_name}/${train_model_name}")