+ 
+
+ 
+ 
+ 
+ 
+
+
+
+
+
+
| 
| 
| 
|
+| [**人脸检测**](#模型库) | [**2D关键点检测**](#️pp-tinypose-人体骨骼关键点识别) | [**多目标追踪**](#pp-tracking-实时多目标跟踪系统) | [**实例分割**](#模型库) |
+| 
| 
| 
| 
|
+| [**车辆分析——车牌识别**](#️pp-vehicle-实时车辆分析工具) | [**车辆分析——车流统计**](#️pp-vehicle-实时车辆分析工具) | [**车辆分析——违章检测**](#️pp-vehicle-实时车辆分析工具) | [**车辆分析——属性分析**](#️pp-vehicle-实时车辆分析工具) |
+| 
| 
| 
| 
|
+| [**行人分析——闯入分析**](#pp-human-实时行人分析工具) | [**行人分析——行为分析**](#pp-human-实时行人分析工具) | [**行人分析——属性分析**](#pp-human-实时行人分析工具) | [**行人分析——人流统计**](#pp-human-实时行人分析工具) |
+| 
| 
| 
| 
|
+
+同时，PaddleDetection提供了模型的在线体验功能，用户可以选择自己的数据进行在线推理。
+
+`说明`：考虑到服务器负载压力，在线推理均为CPU推理，完整的模型开发实例以及产业部署实践代码示例请前往[🎗️产业特色模型|产业工具](#️产业特色模型产业工具-1)。
+
+`传送门`：[模型在线体验](https://www.paddlepaddle.org.cn/models)
+
+
+ 
+
+ 
+
+PaddleDetection官方交流群二维码
+
+
+ 
+
+ 
+
+ 
+ | + Backbones + | ++ Necks + | ++ Loss + | ++ Common + | ++ Data Augmentation + | +
+
|
+
+
|
+
+
|
+
+
+
|
+
+
|
+
| + 2D Detection + | ++ Multi Object Tracking + | ++ KeyPoint Detection + | ++ Others + | +
+
|
+ + + | +
+
|
+
+
+
|
+
+
+
+
+
+
+
+
+
+
+
Product Update
+
+- 🔥 **2022.11.15：SOTA rotated object detector and small object detector based on PP-YOLOE**
+ - Rotated object detector [PP-YOLOE-R](configs/rotate/ppyoloe_r)
+ - SOTA Anchor-free rotated object detection model with high accuracy and efficiency
+ - A series of models, named s/m/l/x, for cloud and edge devices
+ - Avoiding using special operators to be deployed friendly with TensorRT.
+ - Small object detector [PP-YOLOE-SOD](configs/smalldet)
+ - End-to-end detection pipeline based on sliced images
+ - SOTA model on VisDrone based on original images.
+
+- 2022.8.26：PaddleDetection releases[release/2.5 version](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5)
+
+ - 🗳 Model features：
+
+ - Release [PP-YOLOE+](configs/ppyoloe): Increased accuracy by a maximum of 2.4% mAP to 54.9% mAP, 3.75 times faster model training convergence rate, and up to 2.3 times faster end-to-end inference speed; improved generalization for multiple downstream tasks
+ - Release [PicoDet-NPU](configs/picodet) model which supports full quantization deployment of models; add [PicoDet](configs/picodet) layout analysis model
+ - Release [PP-TinyPose Plus](./configs/keypoint/tiny_pose/). With 9.1% AP accuracy improvement in physical exercise, dance, and other scenarios, our PP-TinyPose Plus supports unconventional movements such as turning to one side, lying down, jumping, and high lifts
+
+ - 🔮 Functions in different scenarios
+
+ - Release the pedestrian analysis tool [PP-Human v2](./deploy/pipeline). It introduces four new behavior recognition: fighting, telephoning, smoking, and trespassing. The underlying algorithm performance is optimized, covering three core algorithm capabilities: detection, tracking, and attributes of pedestrians. Our model provides end-to-end development and model optimization strategies for beginners and supports online video streaming input.
+ - First release [PP-Vehicle](./deploy/pipeline), which has four major functions: license plate recognition, vehicle attribute analysis (color, model), traffic flow statistics, and violation detection. It is compatible with input formats, including pictures, online video streaming, and video. And we also offer our users a comprehensive set of tutorials for customization.
+
+ - 💡 Cutting-edge algorithms：
+
+ - Release [PaddleYOLO](https://github.com/PaddlePaddle/PaddleYOLO) which overs classic and latest models of [YOLO family](https://github.com/PaddlePaddle/PaddleYOLO/tree/develop/docs/MODEL_ZOO_en.md): YOLOv3, PP-YOLOE (a real-time high-precision object detection model developed by Baidu PaddlePaddle), and cutting-edge detection algorithms such as YOLOv4, YOLOv5, YOLOX, YOLOv6, YOLOv7 and YOLOv8
+ - Newly add high precision detection model based on [ViT](configs/vitdet) backbone network, with a 55.7% mAP accuracy on COCO dataset; newly add multi-object tracking model [OC-SORT](configs/mot/ocsort); newly add [ConvNeXt](configs/convnext) backbone network.
+
+ - 📋 Industrial applications: Newly add [Smart Fitness](https://aistudio.baidu.com/aistudio/projectdetail/4385813), [Fighting recognition](https://aistudio.baidu.com/aistudio/projectdetail/4086987?channelType=0&channel=0),[ and Visitor Analysis](https://aistudio.baidu.com/aistudio/projectdetail/4230123?channelType=0&channel=0).
+
+- 2022.3.24：PaddleDetection released[release/2.4 version](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.4)
+ - Release high-performanace SOTA object detection model [PP-YOLOE](configs/ppyoloe). It integrates cloud and edge devices and provides S/M/L/X versions. In particular, Verson L has the accuracy as 51.4% on COCO test 2017 dataset, inference speed as 78.1 FPS on a single Test V100. It supports mixed precision training, 33% faster than PP-YOLOv2. Its full range of multi-sized models can meet different hardware arithmetic requirements, and adaptable to server, edge-device GPU and other AI accelerator cards on servers.
+ - Release ultra-lightweight SOTA object detection model [PP-PicoDet Plus](configs/picodet) with 2% improvement in accuracy and 63% improvement in CPU inference speed. Add PicoDet-XS model with a 0.7M parameter, providing model sparsification and quantization functions for model acceleration. No specific post processing module is required for all the hardware, simplifying the deployment.
+ - Release the real-time pedestrian analysis tool [PP-Human](deploy/pphuman). It has four major functions: pedestrian tracking, visitor flow statistics, human attribute recognition and falling detection. For falling detection, it is optimized based on real-life data with accurate recognition of various types of falling posture. It can adapt to different environmental background, light and camera angle.
+ - Add [YOLOX](configs/yolox) object detection model with nano/tiny/S/M/L/X. X version has the accuracy as 51.8% on COCO Val2017 dataset.
+
+- [More releases](https://github.com/PaddlePaddle/PaddleDetection/releases)
+
+## 
Brief Introduction
+
+**PaddleDetection** is an end-to-end object detection development kit based on PaddlePaddle. Providing **over 30 model algorithm** and **over 300 pre-trained models**, it covers object detection, instance segmentation, keypoint detection, multi-object tracking. In particular, PaddleDetection offers **high- performance & light-weight** industrial SOTA models on **servers and mobile** devices, champion solution and cutting-edge algorithm. PaddleDetection provides various data augmentation methods, configurable network components, loss functions and other advanced optimization & deployment schemes. In addition to running through the whole process of data processing, model development, training, compression and deployment, PaddlePaddle also provides rich cases and tutorials to accelerate the industrial application of algorithm.
+
+
+
Features
+
+- **Rich model library**: PaddleDetection provides over 250 pre-trained models including **object detection, instance segmentation, face recognition, multi-object tracking**. It covers a variety of **global competition champion** schemes.
+- **Simple to use**: Modular design, decoupling each network component, easy for developers to build and try various detection models and optimization strategies, quick access to high-performance, customized algorithm.
+- **Getting Through End to End**: PaddlePaddle gets through end to end from data augmentation, constructing models, training, compression, depolyment. It also supports multi-architecture, multi-device deployment for **cloud and edge** device.
+- **High Performance**: Due to the high performance core, PaddlePaddle has clear advantages in training speed and memory occupation. It also supports FP16 training and multi-machine training.
+
+
+
Exchanges
+
+- If you have any question or suggestion, please give us your valuable input via [GitHub Issues](https://github.com/PaddlePaddle/PaddleDetection/issues)
+
+ Welcome to join PaddleDetection user groups on WeChat (scan the QR code, add and reply "D" to the assistant)
+
+ 
+ 
Kit Structure
+
+| + Architectures + | ++ Backbones + | ++ Components + | ++ Data Augmentation + | +
+
Object Detection+
Instance Segmentation+
Face Detection+
Multi-Object-Tracking+
KeyPoint-Detection+
|
+
+ Details+
|
+
+ Common+
KeyPoint+
FPN+
Loss+
Post-processing+
Speed+
|
+
+ Details+
|
+
Model Performance
+
+
+
+
Model libraries
+
+
Document tutorials
+
+### Introductory tutorials
+
+- [Installation](docs/tutorials/INSTALL_cn.md)
+- [Quick start](docs/tutorials/QUICK_STARTED_cn.md)
+- [Data preparation](docs/tutorials/data/README.md)
+- [Geting Started on PaddleDetection](docs/tutorials/GETTING_STARTED_cn.md)
+- [FAQ](docs/tutorials/FAQ)
+
+### Advanced tutorials
+
+- Configuration
+
+ - [RCNN Configuration](docs/tutorials/config_annotation/faster_rcnn_r50_fpn_1x_coco_annotation.md)
+ - [PP-YOLO Configuration](docs/tutorials/config_annotation/ppyolo_r50vd_dcn_1x_coco_annotation.md)
+
+- Compression based on [PaddleSlim](https://github.com/PaddlePaddle/PaddleSlim)
+
+ - [Pruning/Quantization/Distillation Tutorial](configs/slim)
+
+- [Inference deployment](deploy/README.md)
+
+ - [Export model for inference](deploy/EXPORT_MODEL.md)
+
+ - [Paddle Inference deployment](deploy/README.md)
+
+ - [Inference deployment with Python](deploy/python)
+ - [Inference deployment with C++](deploy/cpp)
+
+ - [Paddle-Lite deployment](deploy/lite)
+
+ - [Paddle Serving deployment](deploy/serving)
+
+ - [ONNX model export](deploy/EXPORT_ONNX_MODEL.md)
+
+ - [Inference benchmark](deploy/BENCHMARK_INFER.md)
+
+- Advanced development
+
+ - [Data processing module](docs/advanced_tutorials/READER.md)
+ - [New object detection models](docs/advanced_tutorials/MODEL_TECHNICAL.md)
+ - Custumization
+ - [Object detection](docs/advanced_tutorials/customization/detection.md)
+ - [Keypoint detection](docs/advanced_tutorials/customization/keypoint_detection.md)
+ - [Multiple object tracking](docs/advanced_tutorials/customization/pphuman_mot.md)
+ - [Action recognition](docs/advanced_tutorials/customization/action_recognotion/)
+ - [Attribute recognition](docs/advanced_tutorials/customization/pphuman_attribute.md)
+
+### Courses
+
+- **[Theoretical foundation] [Object detection 7-day camp](https://aistudio.baidu.com/aistudio/education/group/info/1617):** Overview of object detection tasks, details of RCNN series object detection algorithm and YOLO series object detection algorithm, PP-YOLO optimization strategy and case sharing, introduction and practice of AnchorFree series algorithm
+
+- **[Industrial application] [AI Fast Track industrial object detection technology and application](https://aistudio.baidu.com/aistudio/education/group/info/23670):** Super object detection algorithms, real-time pedestrian analysis system PP-Human, breakdown and practice of object detection industrial application
+
+- **[Industrial features] 2022.3.26** **[Smart City Industry Seven-Day Class](https://aistudio.baidu.com/aistudio/education/group/info/25620)** : Urban planning, Urban governance, Smart governance service, Traffic management, community governance.
+
+- **[Academic exchange] 2022.9.27 [YOLO Vision Event](https://www.youtube.com/playlist?list=PL1FZnkj4ad1NHVC7CMc3pjSQ-JRK-Ev6O):** As the first YOLO-themed event, PaddleDetection was invited to communicate with the experts in the field of Computer Vision around the world.
+
+### [Industrial tutorial examples](./industrial_tutorial/README.md)
+
+- [Rotated object detection based on PP-YOLOE-R](https://aistudio.baidu.com/aistudio/projectdetail/5058293)
+
+- [Aerial image detection based on PP-YOLOE-SOD](https://aistudio.baidu.com/aistudio/projectdetail/5036782)
+
+- [Fall down recognition based on PP-Human v2](https://aistudio.baidu.com/aistudio/projectdetail/4606001)
+
+- [Intelligent fitness recognition based on PP-TinyPose Plus](https://aistudio.baidu.com/aistudio/projectdetail/4385813)
+
+- [Road litter detection based on PP-PicoDet Plus](https://aistudio.baidu.com/aistudio/projectdetail/3561097)
+
+- [Visitor flow statistics based on FairMOT](https://aistudio.baidu.com/aistudio/projectdetail/2421822)
+
+- [Guest analysis based on PP-Human](https://aistudio.baidu.com/aistudio/projectdetail/4537344)
+
+- [More examples](./industrial_tutorial/README.md)
+
+## 
Applications
+
+- [Fitness app on android mobile](https://github.com/zhiboniu/pose_demo_android)
+- [PP-Tracking GUI Visualization Interface](https://github.com/yangyudong2020/PP-Tracking_GUi)
+
+## Recommended third-party tutorials
+
+- [Deployment of PaddleDetection for Windows I ](https://zhuanlan.zhihu.com/p/268657833)
+- [Deployment of PaddleDetection for Windows II](https://zhuanlan.zhihu.com/p/280206376)
+- [Deployment of PaddleDetection on Jestson Nano](https://zhuanlan.zhihu.com/p/319371293)
+- [How to deploy YOLOv3 model on Raspberry Pi for Helmet detection](https://github.com/PaddleCV-FAQ/PaddleDetection-FAQ/blob/main/Lite%E9%83%A8%E7%BD%B2/yolov3_for_raspi.md)
+- [Use SSD-MobileNetv1 for a project -- From dataset to deployment on Raspberry Pi](https://github.com/PaddleCV-FAQ/PaddleDetection-FAQ/blob/main/Lite%E9%83%A8%E7%BD%B2/ssd_mobilenet_v1_for_raspi.md)
+
+## 
Version updates
+
+Please refer to the[ Release note ](https://github.com/PaddlePaddle/Paddle/wiki/PaddlePaddle-2.3.0-Release-Note-EN)for more details about the updates
+
+## 
License
+
+PaddlePaddle is provided under the [Apache 2.0 license](LICENSE)
+
+## 
Contribute your code
+
+We appreciate your contributions and your feedback！
+
+- Thank [Mandroide](https://github.com/Mandroide) for code cleanup and
+- Thank [FL77N](https://github.com/FL77N/) for `Sparse-RCNN`model
+- Thank [Chen-Song](https://github.com/Chen-Song) for `Swin Faster-RCNN`model
+- Thank [yangyudong](https://github.com/yangyudong2020), [hchhtc123](https://github.com/hchhtc123) for developing PP-Tracking GUI interface
+- Thank Shigure19 for developing PP-TinyPose fitness APP
+- Thank [manangoel99](https://github.com/manangoel99) for Wandb visualization methods
+
+## 
Quote
+
+```
+@misc{ppdet2019,
+title={PaddleDetection, Object detection and instance segmentation toolkit based on PaddlePaddle.},
+author={PaddlePaddle Authors},
+howpublished = {\url{https://github.com/PaddlePaddle/PaddleDetection}},
+year={2019}
+}
+```
diff --git "a/PaddleDetection-release-2.6/activity/\347\233\264\346\222\255\347\255\224\347\226\221\347\254\254\344\270\200\346\234\237.md" "b/PaddleDetection-release-2.6/activity/\347\233\264\346\222\255\347\255\224\347\226\221\347\254\254\344\270\200\346\234\237.md"
new file mode 100644
index 0000000000000000000000000000000000000000..393bf18f7e64bb7360c4bba43d7b9b48662dd8e0
--- /dev/null
+++ "b/PaddleDetection-release-2.6/activity/\347\233\264\346\222\255\347\255\224\347\226\221\347\254\254\344\270\200\346\234\237.md"
@@ -0,0 +1,125 @@
+# 直播答疑第一期
+
+### 答疑全程回放可以通过链接下载观看：https://pan.baidu.com/s/168ouju4MxN5XJEb-GU1iAw 提取码: 92mw
+
+## PaddleDetection框架/API问题
+
+#### Q1. warmup能详细讲解下吗？
+A1. warmup是在训练初期学习率从0调整至预设学习率的过程，设置可以参考[源码](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.4/ppdet/optimizer.py#L156)，可以设置step数或epoch数
+
+#### Q2. 如果类别不匹配 也能用pretrain weights吗？
+A2. 可以，类别不匹配时，模型会自动不加载shape不匹配的权重，通常和类别数相关的权重位于head层
+
+#### Q3. 请问nms_eta怎么用呀，源码上没有写的很清楚，API文档也没有细说
+A3. 针对密集的场景，nms_eta会在每轮动态的调整nms阈值，避免过滤掉两个重叠程度很高但是属于不同物体的检测框，具体可以参考[源码](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/operators/detection/multiclass_nms_op.cc#L139)，默认为1，通常无需设置
+
+#### Q4. 请问anchor_cluster.py中的--size 是模型的input size 还是 实际使用图片的size？
+A4. 是实际推理时的图片尺寸，一般可以参考TestReader中的image_shape的设置。
+
+#### Q5. 请问为什么预测的坐标会出现负的值？
+A5. 模型算法中是有可能负值的情况，首先需要判断模型预测效果是否符合预期，如果正常可以考虑在后处理中增加clip的操作限制输出box在图像中；如果不正常，说明模型训练效果欠佳，需要进一步排查问题或调优
+
+#### Q6. PaddleDetection 人脸检测blazeface模型，一键式预测时load_params没有参数文件，从哪里下载?
+A6. blazeface的模型可以在[模型库](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.4/configs/face_detection#%E6%A8%A1%E5%9E%8B%E5%BA%93)中下载到，如果想部署需要参考[步骤](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.4/deploy/EXPORT_MODEL.md) 导出模型
+
+## PP-YOLOE问题
+#### Q1. 训练PP-YOLOE的时候，loss是越训练越高这种情况 是数据集的问题吗？
+A1. 可以从以下几个方面排查
+
+1. 数据: 首先确认数据集没问题，包括标注，类别等
+2. 超参数：base_lr根据batch_size调整，遵守线性原则；warmup_iters根据总的epoch数进行调整
+3. 预训练参数：可以加载官方提供的自在coco数据集上的预训练参数
+4. 网络结构方面：分析下box的分布情况 适当调整dfl的参数
+
+#### Q2. 检测模型选型问题：PicoDet、PP-YOLO系列如何选型
+A2. PicoDet是针对移动端设备设计的模型，是针对arm，x86等低算力设备上设计；PP-YOLO是针对服务器端设计的模型，英伟达N卡，百度昆仑卡等。手机端，无gpu桌面端，优先PicoDet；有高算力设备，如N卡，优先PP-YOLO系列；对延时不敏感的场景，更注重高精度，优先PP-YOLO系列
+
+#### Q3. ConvBNLayer中BN层的参数都不会使用L2Decay；PP-YOLOE-s的其它部分都会按照配置文件的设置使用0.0005的L2Decay。是这样吗
+A3. PP-YOLOE的backbone和neck部分使用了ConvBNLayer，其中BN层不会使用L2Decay，其他部分使用全局设置的0.0005的L2Decay
+
+#### Q4. PP-YOLOE的Conv的bias也不使用decay吗？
+A4. PP-YOLOE的backbone和neck部分的Conv是没有bias参数的，head部分的Conv bias使用全局decay
+
+#### Q5. 在测速时，为什么要用PaddleInference而不是直接加载模型测时间呢
+A5. PaddleInference会将paddle导出的预测模型会前向算子做融合，从而实现速度优化，并且实际部署过程也是使用PaddleInference实现
+
+#### Q6. PP-YOLOE系列在部署的时候，前后处理是不是一样的啊？
+A6. PP-YOLO系列模型在部署时的前处理都是 decode-resize-normalize-permute的流程，后处理方面PP-YOLOv2使用了Matrix NMS，PP-YOLOE使用的是普通的NMS算法
+
+#### Q7. 针对小目标和类别不平衡的数据集，PP-YOLOE有什么调整策略吗
+A7 针对小目标数据集，可以适当增大ppyoloe的输入尺寸，然后在模型中增加注意力机制，目前基于PP-YOLOE的小目标检测正在开发中；针对类别不平衡问题，可以从数据采样的角度处理，目前PP-YOLOE还没有专门针对类别不平衡问题的优化
+
+## PP-Human问题
+#### Q1. 请问pphuman用导出的模型18个点（不是官方17个点）去预测时，报错是为什么
+A1. 这个问题是关键点模型输出点的数量与行为识别模型不一致导致的。如果希望用18点模型预测，除了关键点用18点模型以外，还需要自建18点的动作识别模型。
+
+#### Q2. 为什么官方导出模型设置的window_size是50
+A2. 导出模型的设置与训练和预测的输入数据长度是一致的；我们主要采用的数据集是ntu、企业提供的实际数据等等。在训练这个模型的时候，我们对这些数据中摔倒的片段做了统计分析，基本上每个动作片段持续的帧数大约是40~80左右。综合考虑到实际使用的延迟以及预测效果，我们选择了50这个量级，在我们的这部分数据上既能完整描述一个完整动作，又不会使得延迟过大。
+
+总的来说，这个window_size的数值最好还是根据实际动作以及设备的情况进行选择。例如在某种设备上，50帧的长度根本不足以包含一个完整的动作，那么这个数值就需要扩大；又或者某些动作持续时间很短，50帧的长度包含了太多不相关的其他动作，容易造成误识别，那么这个数值可以适当缩小。
+
+
+#### Q3. PP-Human中如何替换检测、跟踪、关键点模型
+A3. 我们使用的模型都是PaddleDetection中模型进行导出得到的。理论上PP-Human所使用的模型都是可以直接替换的，但是需要注意是流程和前后处理一样的模型。
+
+#### Q4. PP-Human中的数据标注问题（检测、跟踪、关键点、行为、属性）标注工具推荐和标注步骤
+A4. 标注工具：检测 labelme, labelImg, cvat； 跟踪darklabel，cvat；关键点 labelme，cvat。检测标注可以使用tools/x2coco.py转换成coco格式
+
+#### Q5. PP-Human中如何更改label（属性和动作识别）
+A5. 在PPHuman中，动作识别被定义为基于骨骼点序列的分类问题，目前我们已经开源的摔倒动作识别是一个二分类问题；属性方面我们当前还暂时没有开放训练，正在建设中
+
+#### Q6. PP-Human的哪些功能支持单人、哪些支持多人
+A6. PP-Human的功能实现基于一套流程：检测->跟踪->具体功能。当前我们的具体功能模型每次处理的是单人的，即属性、动作等都是属于图像中每一个具体人的。但是基于这套流程下来，图像中的每一个人都得到了处理的。所以单人、多人实际都是一样支持的。
+
+#### Q7. PP-Human对视频流预测的支持及服务化部署
+A7. 目前正在建设当中，下个版本会支持这部分功能
+
+#### Q8. 在使用pphuman训练自己的数据集时，训练完进行测试时，可视化的标签如何更改，没有更改的情况下还是falling
+
+A8. 可视化的函数位于https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.4/deploy/python/visualize.py#L368，这里在可视化的时候将 action_text替换为期望的类别即可。
+
+#### Q9. 关键点检测可以实现一个连贯动作的检测吗，比如健身规范
+A9. 基于关键点是可以实现的。这里可以有不同思路去做：
+
+1. 如果是期望判定动作规范的程度，且这个动作可以很好的描述。那么可以在关键点模型获得的坐标的基础上，人工增加逻辑判断即可。这里我们提供一个安卓的健身APP示例：https://github.com/zhiboniu/pose_demo_android ，其中实现判定各项动作的逻辑可以参考https://github.com/zhiboniu/pose_demo_android/blob/release/1.0/app/src/main/cpp/pose_action.cc 。
+
+2. 当一个动作较难用逻辑去描述的时候，可能参考现有摔倒检测的案例，训练一个识别健身动作的模型，但对收集数据的要求会比较高。
+
+
+#### Q10. 有遮挡的生产环境中梯子，可以用关键点检测判断人员上下梯动作是否合规
+A10. 这个问题需要视遮挡的程度而定，如果遮挡过于严重时关键点检测模型的效果会大打折扣，从而导致行为的判断失准。此外，由于基于关键点的方案抹去了外观信息，如果只是从人物本身的动作上去做判断，那么在遮挡不严重的场景下是可以的。反之，如果梯子这个物体是判断动作是否合规的必要元素，那么这个方案其实不一定是最佳选择。
+
+#### Q11. 关键点做的行为识别并不是时序上的动作识别吗
+A11. 是时序的动作识别。这里是将一定时间范围内的每一帧关键点坐标组成一个时序的关键点序列，再通过行为识别模型去预测这个序列所属的行为类别。
+
+
+## 检测算法问题
+#### Q1. 大图片小目标 最终推理的图片也是大图片 怎么预处理呀
+A1. 小目标问题常见的处理方式是切图以及增大网络输入尺寸，如果使用基于anchor的检测算法，可以通过对目标物体大小聚类生成anchor，参考[脚本](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.4/tools/anchor_cluster.py)； 目前基于PP-YOLOE的小目标检测正在开发中
+
+#### Q2. 想问下大的目标对象怎么检测，比如发票
+A2. 如果使用基于anchor的检测算法，可以通过对目标物体大小聚类生成anchor，参考[脚本](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.4/tools/anchor_cluster.py)；另外可以增强深层特征提升大物体检测效果
+
+#### Q3. 在做预测时发现预测框特别多，有的框的置信度甚至低于0.1，请问如果将这种框过滤掉？也就是训练模型时就把这些极低置信度的预测结果过滤掉，避免在推理部署时，做不必要的计算，从而影响推理速度。
+A3. 后处理部分有两个过滤，1）是提取置信度最高的Top 100个框做nms。2）是根据设定阈值threshold进行过滤。如果你可以确认图片上目标相对比较少<10个，可以调整Top 100这个值到50或者更低，这样可以加速nms部分的计算。其次调整threshold这个影响最终检测的准确度和召回率的效果。
+
+#### Q4. 正负样本的比例一般怎么设计
+A4. 在PaddleDetection中，支持负样本训练，TrainDataset下设置allow_empty: true即可，通过数据集测试，负样本比例在0.3时对模型提升效果最明显。
+
+## 压缩部署问题
+#### Q1. PaddleDetection训练的模型导出inference model后，在做推理部署的时候，前后处理相关代码如何编写，有什么参考教程吗？
+A1. 目前PaddleDetection下的网络模型大部分都能够支持c++ inference，不同的处理方式针对不同功能，例如：PP-YOLOE速度测试不包含后处理，PicoDet为支持不同的第三方推理引擎会设置是否导出nms
+
+object_detector.cc是针对所有检测模型的流程，其中前处理大部分都是decode-resize-normalize-permute 部分网络会加入padding的操作；大部分模型的后处理操作都放在模型里面了，picodet有单独提供nms的后处理代码
+
+检测模型的输入统一为image，im_shape，scale_factor ，如果模型中没有使用im_shape，输出个数会减少，但是整套预处理流程不需要额外开发
+
+#### Q2. 针对TensorRT的加速问题，fp16在v100确实可以，但是耗时好像有点偏差，我在1080ti上，单张图片跑1000次，耗时50s，还是float32的，可是在v100上，float16耗时97
+A2. 目前PPYOLOE等模型的速度都有在V100上使用TensorRT FP16测试，关于速度测试有以下几个方面可以排查：
+
+1. 速度测试时是否正确设置warmup，以避免过长的启动时间影响速度测试准确度
+2. 在开启TensorRT时，生成engine文件的过程耗时较长，可以在https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.4/deploy/python/infer.py#L745 中将use_static设置为True
+
+
+#### Q3. PaddleDetection已经支持了在线量化一些模型，比如想训练其他的一个新模型，是不是可以轻松用起来qat？如果不能，为什么只能支持很有限的模型，而qat其他模型总会出各种各样的问题，原因是什么？
+A3. 目前PaddleDetection模型很多，只能针对部分模型开源了QAT的config，其他模型也是支持QAT的，只是配置文件没有覆盖到，如果量化报错，通常是配置问题。检测模型一般建议跳过head最后一个conv。如果想要跳过某些层量化，可以设置skip_quant，参考[代码](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.4/ppdet/modeling/heads/yolo_head.py#L97)
diff --git a/PaddleDetection-release-2.6/benchmark/README.md b/PaddleDetection-release-2.6/benchmark/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1c8bb2bf084a77226b069167ffc19ec9723e437d
--- /dev/null
+++ b/PaddleDetection-release-2.6/benchmark/README.md
@@ -0,0 +1,47 @@
+# 通用检测benchmark测试脚本说明
+
+```
+├── benchmark
+│ ├── analysis_log.py
+│ ├── prepare.sh
+│ ├── README.md
+│ ├── run_all.sh
+│ ├── run_benchmark.sh
+```
+
+## 脚本说明
+
+### prepare.sh
+相关数据准备脚本，完成数据、模型的自动下载
+### run_all.sh
+主要运行脚本，可完成所有相关模型的测试方案
+### run_benchmark.sh
+单模型运行脚本，可完成指定模型的测试方案
+
+## Docker 运行环境
+* docker image: registry.baidubce.com/paddlepaddle/paddle:2.1.2-gpu-cuda10.2-cudnn7
+* paddle = 2.1.2
+* python = 3.7
+
+## 运行benchmark测试
+
+### 运行所有模型
+```
+git clone https://github.com/PaddlePaddle/PaddleDetection.git
+cd PaddleDetection
+bash benchmark/run_all.sh
+```
+
+### 运行指定模型
+* Usage：bash run_benchmark.sh ${run_mode} ${batch_size} ${fp_item} ${max_epoch} ${model_name}
+* model_name: faster_rcnn, fcos, deformable_detr, gfl, hrnet, higherhrnet, solov2, jde, fairmot
+```
+git clone https://github.com/PaddlePaddle/PaddleDetection.git
+cd PaddleDetection
+bash benchmark/prepare.sh
+
+# 单卡
+CUDA_VISIBLE_DEVICES=0 bash benchmark/run_benchmark.sh sp 2 fp32 1 faster_rcnn
+# 多卡
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 bash benchmark/run_benchmark.sh mp 2 fp32 1 faster_rcnn
+```
diff --git a/PaddleDetection-release-2.6/benchmark/configs/faster_rcnn_r50_fpn_1x_coco.yml b/PaddleDetection-release-2.6/benchmark/configs/faster_rcnn_r50_fpn_1x_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..02f138559c8e866ce1d1c9e7dde40720df9cf400
--- /dev/null
+++ b/PaddleDetection-release-2.6/benchmark/configs/faster_rcnn_r50_fpn_1x_coco.yml
@@ -0,0 +1,48 @@
+_BASE_: [
+ '../../configs/datasets/coco_detection.yml',
+ '../../configs/runtime.yml',
+ '../../configs/faster_rcnn/_base_/optimizer_1x.yml',
+ '../../configs/faster_rcnn/_base_/faster_rcnn_r50_fpn.yml',
+]
+weights: output/faster_rcnn_r50_fpn_1x_coco/model_final
+
+worker_num: 2
+TrainReader:
+ sample_transforms:
+ - Decode: {}
+ - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
+ - RandomFlip: {prob: 0.5}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: true
+ drop_last: true
+ collate_batch: false
+
+
+EvalReader:
+ sample_transforms:
+ - Decode: {}
+ - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: false
+ drop_last: false
+
+
+TestReader:
+ sample_transforms:
+ - Decode: {}
+ - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: false
+ drop_last: false
diff --git a/PaddleDetection-release-2.6/benchmark/prepare.sh b/PaddleDetection-release-2.6/benchmark/prepare.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0133f2b6847e6e2baa445d499bf7cf9a2d77743b
--- /dev/null
+++ b/PaddleDetection-release-2.6/benchmark/prepare.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+pip install -U pip Cython
+pip install -r requirements.txt
+
+mv ./dataset/coco/download_coco.py . && rm -rf ./dataset/coco/* && mv ./download_coco.py ./dataset/coco/
+# prepare lite train data
+wget -nc -P ./dataset/coco/ https://paddledet.bj.bcebos.com/data/coco_benchmark.tar
+cd ./dataset/coco/ && tar -xvf coco_benchmark.tar && mv -u coco_benchmark/* .
+rm -rf coco_benchmark/
+
+cd ../../
+rm -rf ./dataset/mot/*
+# prepare mot mini train data
+wget -nc -P ./dataset/mot/ https://paddledet.bj.bcebos.com/data/mot_benchmark.tar
+cd ./dataset/mot/ && tar -xvf mot_benchmark.tar && mv -u mot_benchmark/* .
+rm -rf mot_benchmark/
diff --git a/PaddleDetection-release-2.6/benchmark/run_all.sh b/PaddleDetection-release-2.6/benchmark/run_all.sh
new file mode 100644
index 0000000000000000000000000000000000000000..cffeb09421cd14f45fc05e51b8922daab815ab67
--- /dev/null
+++ b/PaddleDetection-release-2.6/benchmark/run_all.sh
@@ -0,0 +1,47 @@
+# Use docker: paddlepaddle/paddle:latest-gpu-cuda10.1-cudnn7 paddle=2.1.2 python3.7
+#
+# Usage:
+# git clone https://github.com/PaddlePaddle/PaddleDetection.git
+# cd PaddleDetection
+# bash benchmark/run_all.sh
+log_path=${LOG_PATH_INDEX_DIR:-$(pwd)} # benchmark系统指定该参数,不需要跑profile时,log_path指向存speed的目录
+
+# run prepare.sh
+bash benchmark/prepare.sh
+
+model_name_list=(faster_rcnn fcos deformable_detr gfl hrnet higherhrnet solov2 jde fairmot)
+fp_item_list=(fp32)
+max_epoch=2
+
+for model_item in ${model_name_list[@]}; do
+ for fp_item in ${fp_item_list[@]}; do
+ case ${model_item} in
+ faster_rcnn) bs_list=(1 8) ;;
+ fcos) bs_list=(2) ;;
+ deformable_detr) bs_list=(2) ;;
+ gfl) bs_list=(2) ;;
+ hrnet) bs_list=(64) ;;
+ higherhrnet) bs_list=(20) ;;
+ solov2) bs_list=(2) ;;
+ jde) bs_list=(4) ;;
+ fairmot) bs_list=(6) ;;
+ *) echo "wrong model_name"; exit 1;
+ esac
+ for bs_item in ${bs_list[@]}
+ do
+ run_mode=sp
+ log_name=detection_${model_item}_bs${bs_item}_${fp_item} # 如:clas_MobileNetv1_mp_bs32_fp32_8
+ echo "index is speed, 1gpus, begin, ${log_name}"
+ CUDA_VISIBLE_DEVICES=0 bash benchmark/run_benchmark.sh ${run_mode} ${bs_item} \
+ ${fp_item} ${max_epoch} ${model_item} | tee ${log_path}/${log_name}_speed_1gpus 2>&1
+ sleep 60
+
+ run_mode=mp
+ log_name=detection_${model_item}_bs${bs_item}_${fp_item} # 如:clas_MobileNetv1_mp_bs32_fp32_8
+ echo "index is speed, 8gpus, run_mode is multi_process, begin, ${log_name}"
+ CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 bash benchmark/run_benchmark.sh ${run_mode} \
+ ${bs_item} ${fp_item} ${max_epoch} ${model_item}| tee ${log_path}/${log_name}_speed_8gpus8p 2>&1
+ sleep 60
+ done
+ done
+done
diff --git a/PaddleDetection-release-2.6/benchmark/run_benchmark.sh b/PaddleDetection-release-2.6/benchmark/run_benchmark.sh
new file mode 100644
index 0000000000000000000000000000000000000000..908bfe59fe0e88d73783bb1328017b561be24bec
--- /dev/null
+++ b/PaddleDetection-release-2.6/benchmark/run_benchmark.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+set -xe
+# Usage：CUDA_VISIBLE_DEVICES=0 bash benchmark/run_benchmark.sh ${run_mode} ${batch_size} ${fp_item} ${max_epoch} ${model_name}
+python="python3.7"
+# Parameter description
+function _set_params(){
+ run_mode=${1:-"sp"} # sp|mp
+ batch_size=${2:-"2"}
+ fp_item=${3:-"fp32"} # fp32|fp16
+ max_epoch=${4:-"1"}
+ model_item=${5:-"model_item"}
+ run_log_path=${TRAIN_LOG_DIR:-$(pwd)}
+# 添加日志解析需要的参数
+ base_batch_size=${batch_size}
+ mission_name="目标检测"
+ direction_id="0"
+ ips_unit="images/s"
+ skip_steps=10 # 解析日志，有些模型前几个step耗时长，需要跳过 (必填)
+ keyword="ips:" # 解析日志，筛选出数据所在行的关键字 (必填)
+ index="1"
+ model_name=${model_item}_bs${batch_size}_${fp_item}
+
+ device=${CUDA_VISIBLE_DEVICES//,/ }
+ arr=(${device})
+ num_gpu_devices=${#arr[*]}
+ log_file=${run_log_path}/${model_item}_${run_mode}_bs${batch_size}_${fp_item}_${num_gpu_devices}
+}
+function _train(){
+ echo "Train on ${num_gpu_devices} GPUs"
+ echo "current CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES, gpus=$num_gpu_devices, batch_size=$batch_size"
+
+ # set runtime params
+ set_optimizer_lr_sp=" "
+ set_optimizer_lr_mp=" "
+ # parse model_item
+ case ${model_item} in
+ faster_rcnn) model_yml="benchmark/configs/faster_rcnn_r50_fpn_1x_coco.yml"
+ set_optimizer_lr_sp="LearningRate.base_lr=0.001" ;;
+ fcos) model_yml="configs/fcos/fcos_r50_fpn_1x_coco.yml"
+ set_optimizer_lr_sp="LearningRate.base_lr=0.001" ;;
+ deformable_detr) model_yml="configs/deformable_detr/deformable_detr_r50_1x_coco.yml" ;;
+ gfl) model_yml="configs/gfl/gfl_r50_fpn_1x_coco.yml"
+ set_optimizer_lr_sp="LearningRate.base_lr=0.001" ;;
+ hrnet) model_yml="configs/keypoint/hrnet/hrnet_w32_256x192.yml" ;;
+ higherhrnet) model_yml="configs/keypoint/higherhrnet/higherhrnet_hrnet_w32_512.yml" ;;
+ solov2) model_yml="configs/solov2/solov2_r50_fpn_1x_coco.yml" ;;
+ jde) model_yml="configs/mot/jde/jde_darknet53_30e_1088x608.yml" ;;
+ fairmot) model_yml="configs/mot/fairmot/fairmot_dla34_30e_1088x608.yml" ;;
+ *) echo "Undefined model_item"; exit 1;
+ esac
+
+ set_batch_size="TrainReader.batch_size=${batch_size}"
+ set_max_epoch="epoch=${max_epoch}"
+ set_log_iter="log_iter=1"
+ if [ ${fp_item} = "fp16" ]; then
+ set_fp_item="--fp16"
+ else
+ set_fp_item=" "
+ fi
+
+ case ${run_mode} in
+ sp) train_cmd="${python} -u tools/train.py -c ${model_yml} ${set_fp_item} \
+ -o ${set_batch_size} ${set_max_epoch} ${set_log_iter} ${set_optimizer_lr_sp}" ;;
+ mp) rm -rf mylog
+ train_cmd="${python} -m paddle.distributed.launch --log_dir=./mylog \
+ --gpus=${CUDA_VISIBLE_DEVICES} tools/train.py -c ${model_yml} ${set_fp_item} \
+ -o ${set_batch_size} ${set_max_epoch} ${set_log_iter} ${set_optimizer_lr_mp}"
+ log_parse_file="mylog/workerlog.0" ;;
+ *) echo "choose run_mode(sp or mp)"; exit 1;
+ esac
+
+ timeout 15m ${train_cmd} > ${log_file} 2>&1
+ if [ $? -ne 0 ];then
+ echo -e "${train_cmd}, FAIL"
+ export job_fail_flag=1
+ else
+ echo -e "${train_cmd}, SUCCESS"
+ export job_fail_flag=0
+ fi
+ kill -9 `ps -ef|grep 'python'|awk '{print $2}'`
+
+ if [ $run_mode = "mp" -a -d mylog ]; then
+ rm ${log_file}
+ cp mylog/workerlog.0 ${log_file}
+ fi
+}
+
+source ${BENCHMARK_ROOT}/scripts/run_model.sh # 在该脚本中会对符合benchmark规范的log使用analysis.py 脚本进行性能数据解析;该脚本在联调时可从benchmark repo中下载https://github.com/PaddlePaddle/benchmark/blob/master/scripts/run_model.sh;如果不联调只想要产出训练log可以注掉本行,提交时需打开
+_set_params $@
+# _train # 如果只想产出训练log,不解析,可取消注释
+_run # 该函数在run_model.sh中,执行时会调用_train; 如果不联调只想要产出训练log可以注掉本行,提交时需打开
+
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/README.md b/PaddleDetection-release-2.6/configs/cascade_rcnn/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8084fac2e999cea4db11bca2f9bf12b56b0a44d9
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/README.md
@@ -0,0 +1,28 @@
+# Cascade R-CNN: High Quality Object Detection and Instance Segmentation
+
+## Model Zoo
+
+| 骨架网络 | 网络类型 | 每张GPU图片个数 | 学习率策略 |推理时间(fps) | Box AP | Mask AP | 下载 | 配置文件 |
+| :------------------- | :------------- | :-----: | :-----: | :------------: | :-----: | :-----: | :-----------------------------------------------------: | :-----: |
+| ResNet50-FPN | Cascade Faster | 1 | 1x | ---- | 41.1 | - | [下载链接](https://paddledet.bj.bcebos.com/models/cascade_rcnn_r50_fpn_1x_coco.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.yml) |
+| ResNet50-FPN | Cascade Mask | 1 | 1x | ---- | 41.8 | 36.3 | [下载链接](https://paddledet.bj.bcebos.com/models/cascade_mask_rcnn_r50_fpn_1x_coco.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.yml) |
+| ResNet50-vd-SSLDv2-FPN | Cascade Faster | 1 | 1x | ---- | 44.4 | - | [下载链接](https://paddledet.bj.bcebos.com/models/cascade_rcnn_r50_vd_fpn_ssld_1x_coco.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_1x_coco.yml) |
+| ResNet50-vd-SSLDv2-FPN | Cascade Faster | 1 | 2x | ---- | 45.0 | - | [下载链接](https://paddledet.bj.bcebos.com/models/cascade_rcnn_r50_vd_fpn_ssld_2x_coco.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_2x_coco.yml) |
+| ResNet50-vd-SSLDv2-FPN | Cascade Mask | 1 | 1x | ---- | 44.9 | 39.1 | [下载链接](https://paddledet.bj.bcebos.com/models/cascade_mask_rcnn_r50_vd_fpn_ssld_1x_coco.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_1x_coco.yml) |
+| ResNet50-vd-SSLDv2-FPN | Cascade Mask | 1 | 2x | ---- | 45.7 | 39.7 | [下载链接](https://paddledet.bj.bcebos.com/models/cascade_mask_rcnn_r50_vd_fpn_ssld_2x_coco.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_2x_coco.yml) |
+
+
+## Citations
+```
+@article{Cai_2019,
+ title={Cascade R-CNN: High Quality Object Detection and Instance Segmentation},
+ ISSN={1939-3539},
+ url={http://dx.doi.org/10.1109/tpami.2019.2956516},
+ DOI={10.1109/tpami.2019.2956516},
+ journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
+ publisher={Institute of Electrical and Electronics Engineers (IEEE)},
+ author={Cai, Zhaowei and Vasconcelos, Nuno},
+ year={2019},
+ pages={1–1}
+}
+```
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_fpn_reader.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_fpn_reader.yml
new file mode 100644
index 0000000000000000000000000000000000000000..9b9abccd63e499bfa9402f3038425470e4a6e953
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_fpn_reader.yml
@@ -0,0 +1,40 @@
+worker_num: 2
+TrainReader:
+ sample_transforms:
+ - Decode: {}
+ - RandomResize: {target_size: [[640, 1333], [672, 1333], [704, 1333], [736, 1333], [768, 1333], [800, 1333]], interp: 2, keep_ratio: True}
+ - RandomFlip: {prob: 0.5}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: true
+ drop_last: true
+ collate_batch: false
+
+
+EvalReader:
+ sample_transforms:
+ - Decode: {}
+ - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: false
+ drop_last: false
+
+
+TestReader:
+ sample_transforms:
+ - Decode: {}
+ - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: false
+ drop_last: false
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_mask_fpn_reader.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_mask_fpn_reader.yml
new file mode 100644
index 0000000000000000000000000000000000000000..9b9abccd63e499bfa9402f3038425470e4a6e953
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_mask_fpn_reader.yml
@@ -0,0 +1,40 @@
+worker_num: 2
+TrainReader:
+ sample_transforms:
+ - Decode: {}
+ - RandomResize: {target_size: [[640, 1333], [672, 1333], [704, 1333], [736, 1333], [768, 1333], [800, 1333]], interp: 2, keep_ratio: True}
+ - RandomFlip: {prob: 0.5}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: true
+ drop_last: true
+ collate_batch: false
+
+
+EvalReader:
+ sample_transforms:
+ - Decode: {}
+ - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: false
+ drop_last: false
+
+
+TestReader:
+ sample_transforms:
+ - Decode: {}
+ - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
+ - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
+ - Permute: {}
+ batch_transforms:
+ - PadBatch: {pad_to_stride: 32}
+ batch_size: 1
+ shuffle: false
+ drop_last: false
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_mask_rcnn_r50_fpn.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_mask_rcnn_r50_fpn.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ea2937babd488b1e874f75494093d942366315e5
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_mask_rcnn_r50_fpn.yml
@@ -0,0 +1,97 @@
+architecture: CascadeRCNN
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_cos_pretrained.pdparams
+
+
+CascadeRCNN:
+ backbone: ResNet
+ neck: FPN
+ rpn_head: RPNHead
+ bbox_head: CascadeHead
+ mask_head: MaskHead
+ # post process
+ bbox_post_process: BBoxPostProcess
+ mask_post_process: MaskPostProcess
+
+ResNet:
+ # index 0 stands for res2
+ depth: 50
+ norm_type: bn
+ freeze_at: 0
+ return_idx: [0,1,2,3]
+ num_stages: 4
+
+FPN:
+ out_channel: 256
+
+RPNHead:
+ anchor_generator:
+ aspect_ratios: [0.5, 1.0, 2.0]
+ anchor_sizes: [[32], [64], [128], [256], [512]]
+ strides: [4, 8, 16, 32, 64]
+ rpn_target_assign:
+ batch_size_per_im: 256
+ fg_fraction: 0.5
+ negative_overlap: 0.3
+ positive_overlap: 0.7
+ use_random: True
+ train_proposal:
+ min_size: 0.0
+ nms_thresh: 0.7
+ pre_nms_top_n: 2000
+ post_nms_top_n: 2000
+ topk_after_collect: True
+ test_proposal:
+ min_size: 0.0
+ nms_thresh: 0.7
+ pre_nms_top_n: 1000
+ post_nms_top_n: 1000
+
+
+CascadeHead:
+ head: CascadeTwoFCHead
+ roi_extractor:
+ resolution: 7
+ sampling_ratio: 0
+ aligned: True
+ bbox_assigner: BBoxAssigner
+
+BBoxAssigner:
+ batch_size_per_im: 512
+ bg_thresh: 0.5
+ fg_thresh: 0.5
+ fg_fraction: 0.25
+ cascade_iou: [0.5, 0.6, 0.7]
+ use_random: True
+
+CascadeTwoFCHead:
+ out_channel: 1024
+
+BBoxPostProcess:
+ decode:
+ name: RCNNBox
+ prior_box_var: [30.0, 30.0, 15.0, 15.0]
+ nms:
+ name: MultiClassNMS
+ keep_top_k: 100
+ score_threshold: 0.05
+ nms_threshold: 0.5
+
+
+MaskHead:
+ head: MaskFeat
+ roi_extractor:
+ resolution: 14
+ sampling_ratio: 0
+ aligned: True
+ mask_assigner: MaskAssigner
+ share_bbox_feat: False
+
+MaskFeat:
+ num_convs: 4
+ out_channel: 256
+
+MaskAssigner:
+ mask_resolution: 28
+
+MaskPostProcess:
+ binary_thresh: 0.5
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_rcnn_r50_fpn.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_rcnn_r50_fpn.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c5afe774347209812ed759e31fb03e5aff677d96
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/cascade_rcnn_r50_fpn.yml
@@ -0,0 +1,75 @@
+architecture: CascadeRCNN
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_cos_pretrained.pdparams
+
+
+CascadeRCNN:
+ backbone: ResNet
+ neck: FPN
+ rpn_head: RPNHead
+ bbox_head: CascadeHead
+ # post process
+ bbox_post_process: BBoxPostProcess
+
+ResNet:
+ # index 0 stands for res2
+ depth: 50
+ norm_type: bn
+ freeze_at: 0
+ return_idx: [0,1,2,3]
+ num_stages: 4
+
+FPN:
+ out_channel: 256
+
+RPNHead:
+ anchor_generator:
+ aspect_ratios: [0.5, 1.0, 2.0]
+ anchor_sizes: [[32], [64], [128], [256], [512]]
+ strides: [4, 8, 16, 32, 64]
+ rpn_target_assign:
+ batch_size_per_im: 256
+ fg_fraction: 0.5
+ negative_overlap: 0.3
+ positive_overlap: 0.7
+ use_random: True
+ train_proposal:
+ min_size: 0.0
+ nms_thresh: 0.7
+ pre_nms_top_n: 2000
+ post_nms_top_n: 2000
+ topk_after_collect: True
+ test_proposal:
+ min_size: 0.0
+ nms_thresh: 0.7
+ pre_nms_top_n: 1000
+ post_nms_top_n: 1000
+
+
+CascadeHead:
+ head: CascadeTwoFCHead
+ roi_extractor:
+ resolution: 7
+ sampling_ratio: 0
+ aligned: True
+ bbox_assigner: BBoxAssigner
+
+BBoxAssigner:
+ batch_size_per_im: 512
+ bg_thresh: 0.5
+ fg_thresh: 0.5
+ fg_fraction: 0.25
+ cascade_iou: [0.5, 0.6, 0.7]
+ use_random: True
+
+CascadeTwoFCHead:
+ out_channel: 1024
+
+BBoxPostProcess:
+ decode:
+ name: RCNNBox
+ prior_box_var: [30.0, 30.0, 15.0, 15.0]
+ nms:
+ name: MultiClassNMS
+ keep_top_k: 100
+ score_threshold: 0.05
+ nms_threshold: 0.5
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/optimizer_1x.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/optimizer_1x.yml
new file mode 100644
index 0000000000000000000000000000000000000000..63f898e9c52556bfa0fbbe9c369900c09ab3f94c
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/_base_/optimizer_1x.yml
@@ -0,0 +1,19 @@
+epoch: 12
+
+LearningRate:
+ base_lr: 0.01
+ schedulers:
+ - !PiecewiseDecay
+ gamma: 0.1
+ milestones: [8, 11]
+ - !LinearWarmup
+ start_factor: 0.001
+ steps: 1000
+
+OptimizerBuilder:
+ optimizer:
+ momentum: 0.9
+ type: Momentum
+ regularizer:
+ factor: 0.0001
+ type: L2
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b2c7e536d5ccaedf3ef25e7e36624b664897cfef
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.yml
@@ -0,0 +1,8 @@
+_BASE_: [
+ '../datasets/coco_instance.yml',
+ '../runtime.yml',
+ '_base_/optimizer_1x.yml',
+ '_base_/cascade_mask_rcnn_r50_fpn.yml',
+ '_base_/cascade_mask_fpn_reader.yml',
+]
+weights: output/cascade_mask_rcnn_r50_fpn_1x_coco/model_final
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_1x_coco.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_1x_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..0ab507caa9548e9118aeafb32f5c7394409601c8
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_1x_coco.yml
@@ -0,0 +1,18 @@
+_BASE_: [
+ '../datasets/coco_instance.yml',
+ '../runtime.yml',
+ '_base_/optimizer_1x.yml',
+ '_base_/cascade_mask_rcnn_r50_fpn.yml',
+ '_base_/cascade_mask_fpn_reader.yml',
+]
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_vd_ssld_v2_pretrained.pdparams
+weights: output/cascade_mask_rcnn_r50_vd_fpn_ssld_1x_coco/model_final
+
+ResNet:
+ depth: 50
+ variant: d
+ norm_type: bn
+ freeze_at: 0
+ return_idx: [0,1,2,3]
+ num_stages: 4
+ lr_mult_list: [0.05, 0.05, 0.1, 0.15]
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_2x_coco.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_2x_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..736ba2e7430717781364343312716d5b3f2ef4aa
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_mask_rcnn_r50_vd_fpn_ssld_2x_coco.yml
@@ -0,0 +1,29 @@
+_BASE_: [
+ '../datasets/coco_instance.yml',
+ '../runtime.yml',
+ '_base_/optimizer_1x.yml',
+ '_base_/cascade_mask_rcnn_r50_fpn.yml',
+ '_base_/cascade_mask_fpn_reader.yml',
+]
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_vd_ssld_v2_pretrained.pdparams
+weights: output/cascade_mask_rcnn_r50_vd_fpn_ssld_2x_coco/model_final
+
+ResNet:
+ depth: 50
+ variant: d
+ norm_type: bn
+ freeze_at: 0
+ return_idx: [0,1,2,3]
+ num_stages: 4
+ lr_mult_list: [0.05, 0.05, 0.1, 0.15]
+
+epoch: 24
+LearningRate:
+ base_lr: 0.01
+ schedulers:
+ - !PiecewiseDecay
+ gamma: 0.1
+ milestones: [12, 22]
+ - !LinearWarmup
+ start_factor: 0.1
+ steps: 1000
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b2cc7993b9885bb5feafbff53bcc82ae3049a148
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.yml
@@ -0,0 +1,8 @@
+_BASE_: [
+ '../datasets/coco_detection.yml',
+ '../runtime.yml',
+ '_base_/optimizer_1x.yml',
+ '_base_/cascade_rcnn_r50_fpn.yml',
+ '_base_/cascade_fpn_reader.yml',
+]
+weights: output/cascade_rcnn_r50_fpn_1x_coco/model_final
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_1x_coco.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_1x_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..905adbd61a5b2b5213d737d5ad2a49df650c8425
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_1x_coco.yml
@@ -0,0 +1,18 @@
+_BASE_: [
+ '../datasets/coco_detection.yml',
+ '../runtime.yml',
+ '_base_/optimizer_1x.yml',
+ '_base_/cascade_rcnn_r50_fpn.yml',
+ '_base_/cascade_fpn_reader.yml',
+]
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_vd_ssld_v2_pretrained.pdparams
+weights: output/cascade_rcnn_r50_vd_fpn_ssld_1x_coco/model_final
+
+ResNet:
+ depth: 50
+ variant: d
+ norm_type: bn
+ freeze_at: 0
+ return_idx: [0,1,2,3]
+ num_stages: 4
+ lr_mult_list: [0.05, 0.05, 0.1, 0.15]
diff --git a/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_2x_coco.yml b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_2x_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a6272145d03bb273c90ccf8d950c8b88f9b3e13b
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/cascade_rcnn/cascade_rcnn_r50_vd_fpn_ssld_2x_coco.yml
@@ -0,0 +1,29 @@
+_BASE_: [
+ '../datasets/coco_detection.yml',
+ '../runtime.yml',
+ '_base_/optimizer_1x.yml',
+ '_base_/cascade_rcnn_r50_fpn.yml',
+ '_base_/cascade_fpn_reader.yml',
+]
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_vd_ssld_v2_pretrained.pdparams
+weights: output/cascade_rcnn_r50_vd_fpn_ssld_2x_coco/model_final
+
+ResNet:
+ depth: 50
+ variant: d
+ norm_type: bn
+ freeze_at: 0
+ return_idx: [0,1,2,3]
+ num_stages: 4
+ lr_mult_list: [0.05, 0.05, 0.1, 0.15]
+
+epoch: 24
+LearningRate:
+ base_lr: 0.01
+ schedulers:
+ - !PiecewiseDecay
+ gamma: 0.1
+ milestones: [12, 22]
+ - !LinearWarmup
+ start_factor: 0.1
+ steps: 1000
diff --git a/PaddleDetection-release-2.6/configs/centernet/README.md b/PaddleDetection-release-2.6/configs/centernet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6dd52cd32608d6e76f08e50bbda8f3c2f4190418
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/README.md
@@ -0,0 +1,37 @@
+English | [简体中文](README_cn.md)
+
+# CenterNet (CenterNet: Objects as Points)
+
+## Table of Contents
+- [Introduction](#Introduction)
+- [Model Zoo](#Model_Zoo)
+- [Citations](#Citations)
+
+## Introduction
+
+[CenterNet](http://arxiv.org/abs/1904.07850) is an Anchor Free detector, which model an object as a single point -- the center point of its bounding box. The detector uses keypoint estimation to find center points and regresses to all other object properties. The center point based approach, CenterNet, is end-to-end differentiable, simpler, faster, and more accurate than corresponding bounding box based detectors.
+
+## Model Zoo
+
+### CenterNet Results on COCO-val 2017
+
+| backbone | input shape | mAP | FPS | download | config |
+| :--------------| :------- | :----: | :------: | :----: |:-----: |
+| DLA-34(paper) | 512x512 | 37.4 | - | - | - |
+| DLA-34 | 512x512 | 37.6 | - | [model](https://bj.bcebos.com/v1/paddledet/models/centernet_dla34_140e_coco.pdparams) | [config](./centernet_dla34_140e_coco.yml) |
+| ResNet50 + DLAUp | 512x512 | 38.9 | - | [model](https://bj.bcebos.com/v1/paddledet/models/centernet_r50_140e_coco.pdparams) | [config](./centernet_r50_140e_coco.yml) |
+| MobileNetV1 + DLAUp | 512x512 | 28.2 | - | [model](https://bj.bcebos.com/v1/paddledet/models/centernet_mbv1_140e_coco.pdparams) | [config](./centernet_mbv1_140e_coco.yml) |
+| MobileNetV3_small + DLAUp | 512x512 | 17 | - | [model](https://bj.bcebos.com/v1/paddledet/models/centernet_mbv3_small_140e_coco.pdparams) | [config](./centernet_mbv3_small_140e_coco.yml) |
+| MobileNetV3_large + DLAUp | 512x512 | 27.1 | - | [model](https://bj.bcebos.com/v1/paddledet/models/centernet_mbv3_large_140e_coco.pdparams) | [config](./centernet_mbv3_large_140e_coco.yml) |
+| ShuffleNetV2 + DLAUp | 512x512 | 23.8 | - | [model](https://bj.bcebos.com/v1/paddledet/models/centernet_shufflenetv2_140e_coco.pdparams) | [config](./centernet_shufflenetv2_140e_coco.yml) |
+
+
+## Citations
+```
+@article{zhou2019objects,
+ title={Objects as points},
+ author={Zhou, Xingyi and Wang, Dequan and Kr{\"a}henb{\"u}hl, Philipp},
+ journal={arXiv preprint arXiv:1904.07850},
+ year={2019}
+}
+```
diff --git a/PaddleDetection-release-2.6/configs/centernet/README_cn.md b/PaddleDetection-release-2.6/configs/centernet/README_cn.md
new file mode 100644
index 0000000000000000000000000000000000000000..d78cd40e3d3d8751422d3d6bde078ff21d08223d
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/README_cn.md
@@ -0,0 +1,36 @@
+简体中文 | [English](README.md)
+
+# CenterNet (CenterNet: Objects as Points)
+
+## 内容
+- [简介](#简介)
+- [模型库](#模型库)
+- [引用](#引用)
+
+## 内容
+
+[CenterNet](http://arxiv.org/abs/1904.07850)是Anchor Free检测器，将物体表示为一个目标框中心点。CenterNet使用关键点检测的方式定位中心点并回归物体的其他属性。CenterNet是以中心点为基础的检测方法，是端到端可训练的，并且相较于基于anchor的检测器更加检测高效。
+
+## 模型库
+
+### CenterNet在COCO-val 2017上结果
+
+| 骨干网络 | 输入尺寸 | mAP | FPS | 下载链接 | 配置文件 |
+| :--------------| :------- | :----: | :------: | :----: |:-----: |
+| DLA-34(paper) | 512x512 | 37.4 | - | - | - |
+| DLA-34 | 512x512 | 37.6 | - | [下载链接](https://bj.bcebos.com/v1/paddledet/models/centernet_dla34_140e_coco.pdparams) | [配置文件](./centernet_dla34_140e_coco.yml) |
+| ResNet50 + DLAUp | 512x512 | 38.9 | - | [下载链接](https://bj.bcebos.com/v1/paddledet/models/centernet_r50_140e_coco.pdparams) | [配置文件](./centernet_r50_140e_coco.yml) |
+| MobileNetV1 + DLAUp | 512x512 | 28.2 | - | [下载链接](https://bj.bcebos.com/v1/paddledet/models/centernet_mbv1_140e_coco.pdparams) | [配置文件](./centernet_mbv1_140e_coco.yml) |
+| MobileNetV3_small + DLAUp | 512x512 | 17 | - | [下载链接](https://bj.bcebos.com/v1/paddledet/models/centernet_mbv3_small_140e_coco.pdparams) | [配置文件](./centernet_mbv3_small_140e_coco.yml) |
+| MobileNetV3_large + DLAUp | 512x512 | 27.1 | - | [下载链接](https://bj.bcebos.com/v1/paddledet/models/centernet_mbv3_large_140e_coco.pdparams) | [配置文件](./centernet_mbv3_large_140e_coco.yml) |
+| ShuffleNetV2 + DLAUp | 512x512 | 23.8 | - | [下载链接](https://bj.bcebos.com/v1/paddledet/models/centernet_shufflenetv2_140e_coco.pdparams) | [配置文件](./centernet_shufflenetv2_140e_coco.yml) |
+
+## 引用
+```
+@article{zhou2019objects,
+ title={Objects as points},
+ author={Zhou, Xingyi and Wang, Dequan and Kr{\"a}henb{\"u}hl, Philipp},
+ journal={arXiv preprint arXiv:1904.07850},
+ year={2019}
+}
+```
diff --git a/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_dla34.yml b/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_dla34.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f8fb86912ef1ef48bdcde6363b5b228966fefd09
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_dla34.yml
@@ -0,0 +1,22 @@
+architecture: CenterNet
+pretrain_weights: https://bj.bcebos.com/v1/paddledet/models/pretrained/DLA34_pretrain.pdparams
+
+CenterNet:
+ backbone: DLA
+ neck: CenterNetDLAFPN
+ head: CenterNetHead
+ post_process: CenterNetPostProcess
+
+DLA:
+ depth: 34
+
+CenterNetDLAFPN:
+ down_ratio: 4
+
+CenterNetHead:
+ head_planes: 256
+ regress_ltrb: False
+
+CenterNetPostProcess:
+ max_per_img: 100
+ regress_ltrb: False
diff --git a/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_r50.yml b/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_r50.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f2dc2ee2897d190066250113c9dbf01a7b92e130
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_r50.yml
@@ -0,0 +1,34 @@
+architecture: CenterNet
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_vd_ssld_pretrained.pdparams
+norm_type: sync_bn
+use_ema: true
+ema_decay: 0.9998
+
+CenterNet:
+ backbone: ResNet
+ neck: CenterNetDLAFPN
+ head: CenterNetHead
+ post_process: CenterNetPostProcess
+
+ResNet:
+ depth: 50
+ variant: d
+ return_idx: [0, 1, 2, 3]
+ freeze_at: -1
+ norm_decay: 0.
+ dcn_v2_stages: [3]
+
+
+CenterNetDLAFPN:
+ first_level: 0
+ last_level: 4
+ down_ratio: 4
+ dcn_v2: False
+
+CenterNetHead:
+ head_planes: 256
+ regress_ltrb: False
+
+CenterNetPostProcess:
+ max_per_img: 100
+ regress_ltrb: False
diff --git a/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_reader.yml b/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_reader.yml
new file mode 100644
index 0000000000000000000000000000000000000000..81af4ab840502da6e738ac667dd0883041ba8992
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/_base_/centernet_reader.yml
@@ -0,0 +1,35 @@
+worker_num: 4
+TrainReader:
+ inputs_def:
+ image_shape: [3, 512, 512]
+ sample_transforms:
+ - Decode: {}
+ - FlipWarpAffine: {keep_res: False, input_h: 512, input_w: 512, use_random: True}
+ - CenterRandColor: {}
+ - Lighting: {eigval: [0.2141788, 0.01817699, 0.00341571], eigvec: [[-0.58752847, -0.69563484, 0.41340352], [-0.5832747, 0.00994535, -0.81221408], [-0.56089297, 0.71832671, 0.41158938]]}
+ - NormalizeImage: {mean: [0.40789655, 0.44719303, 0.47026116], std: [0.2886383 , 0.27408165, 0.27809834], is_scale: False}
+ - Permute: {}
+ - Gt2CenterNetTarget: {down_ratio: 4, max_objs: 128}
+ batch_size: 16
+ shuffle: True
+ drop_last: True
+ use_shared_memory: True
+
+EvalReader:
+ sample_transforms:
+ - Decode: {}
+ - WarpAffine: {keep_res: True, input_h: 512, input_w: 512}
+ - NormalizeImage: {mean: [0.40789655, 0.44719303, 0.47026116], std: [0.2886383 , 0.27408165, 0.27809834]}
+ - Permute: {}
+ batch_size: 1
+
+
+TestReader:
+ inputs_def:
+ image_shape: [3, 512, 512]
+ sample_transforms:
+ - Decode: {}
+ - WarpAffine: {keep_res: True, input_h: 512, input_w: 512}
+ - NormalizeImage: {mean: [0.40789655, 0.44719303, 0.47026116], std: [0.2886383 , 0.27408165, 0.27809834], is_scale: True}
+ - Permute: {}
+ batch_size: 1
diff --git a/PaddleDetection-release-2.6/configs/centernet/_base_/optimizer_140e.yml b/PaddleDetection-release-2.6/configs/centernet/_base_/optimizer_140e.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8c014e1ffe9f4971a9f322644bc943880ed57cec
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/_base_/optimizer_140e.yml
@@ -0,0 +1,14 @@
+epoch: 140
+
+LearningRate:
+ base_lr: 0.0005
+ schedulers:
+ - !PiecewiseDecay
+ gamma: 0.1
+ milestones: [90, 120]
+ use_warmup: False
+
+OptimizerBuilder:
+ optimizer:
+ type: Adam
+ regularizer: NULL
diff --git a/PaddleDetection-release-2.6/configs/centernet/centernet_dla34_140e_coco.yml b/PaddleDetection-release-2.6/configs/centernet/centernet_dla34_140e_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e6a66a9b955e1c53512e3d399a40a1e120f8a0d2
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/centernet_dla34_140e_coco.yml
@@ -0,0 +1,9 @@
+_BASE_: [
+ '../datasets/coco_detection.yml',
+ '../runtime.yml',
+ '_base_/optimizer_140e.yml',
+ '_base_/centernet_dla34.yml',
+ '_base_/centernet_reader.yml',
+]
+
+weights: output/centernet_dla34_140e_coco/model_final
diff --git a/PaddleDetection-release-2.6/configs/centernet/centernet_mbv1_140e_coco.yml b/PaddleDetection-release-2.6/configs/centernet/centernet_mbv1_140e_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..48429a1dd9ced07b4e906304a199a8e2193e235d
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/centernet_mbv1_140e_coco.yml
@@ -0,0 +1,21 @@
+_BASE_: [
+ 'centernet_r50_140e_coco.yml'
+]
+
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/MobileNetV1_pretrained.pdparams
+weights: output/centernet_mbv1_140e_coco/model_final
+
+CenterNet:
+ backbone: MobileNet
+ neck: CenterNetDLAFPN
+ head: CenterNetHead
+ post_process: CenterNetPostProcess
+
+MobileNet:
+ scale: 1.
+ with_extra_blocks: false
+ extra_block_filters: []
+ feature_maps: [3, 5, 11, 13]
+
+TrainReader:
+ batch_size: 32
diff --git a/PaddleDetection-release-2.6/configs/centernet/centernet_mbv3_large_140e_coco.yml b/PaddleDetection-release-2.6/configs/centernet/centernet_mbv3_large_140e_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..57830a9b5ab3c4124138a1283f964ae62fa2c00e
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/centernet_mbv3_large_140e_coco.yml
@@ -0,0 +1,22 @@
+_BASE_: [
+ 'centernet_r50_140e_coco.yml'
+]
+
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/MobileNetV3_large_x1_0_ssld_pretrained.pdparams
+weights: output/centernet_mbv3_large_140e_coco/model_final
+
+CenterNet:
+ backbone: MobileNetV3
+ neck: CenterNetDLAFPN
+ head: CenterNetHead
+ post_process: CenterNetPostProcess
+
+MobileNetV3:
+ model_name: large
+ scale: 1.
+ with_extra_blocks: false
+ extra_block_filters: []
+ feature_maps: [4, 7, 13, 16]
+
+TrainReader:
+ batch_size: 32
diff --git a/PaddleDetection-release-2.6/configs/centernet/centernet_mbv3_small_140e_coco.yml b/PaddleDetection-release-2.6/configs/centernet/centernet_mbv3_small_140e_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..de73f1b2f4023ecb9bfee96436403192b7f6d80f
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/centernet_mbv3_small_140e_coco.yml
@@ -0,0 +1,28 @@
+_BASE_: [
+ 'centernet_r50_140e_coco.yml'
+]
+
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/MobileNetV3_small_x1_0_ssld_pretrained.pdparams
+weights: output/centernet_mbv3_small_140e_coco/model_final
+
+CenterNet:
+ backbone: MobileNetV3
+ neck: CenterNetDLAFPN
+ head: CenterNetHead
+ post_process: CenterNetPostProcess
+
+MobileNetV3:
+ model_name: small
+ scale: 1.
+ with_extra_blocks: false
+ extra_block_filters: []
+ feature_maps: [4, 9, 12]
+
+CenterNetDLAFPN:
+ first_level: 0
+ last_level: 3
+ down_ratio: 8
+ dcn_v2: False
+
+TrainReader:
+ batch_size: 32
diff --git a/PaddleDetection-release-2.6/configs/centernet/centernet_r50_140e_coco.yml b/PaddleDetection-release-2.6/configs/centernet/centernet_r50_140e_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a8b1e98e3373507c8572ee77fab868f2b21bed64
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/centernet_r50_140e_coco.yml
@@ -0,0 +1,9 @@
+_BASE_: [
+ '../datasets/coco_detection.yml',
+ '../runtime.yml',
+ '_base_/optimizer_140e.yml',
+ '_base_/centernet_r50.yml',
+ '_base_/centernet_reader.yml',
+]
+
+weights: output/centernet_r50_140e_coco/model_final
diff --git a/PaddleDetection-release-2.6/configs/centernet/centernet_shufflenetv2_140e_coco.yml b/PaddleDetection-release-2.6/configs/centernet/centernet_shufflenetv2_140e_coco.yml
new file mode 100644
index 0000000000000000000000000000000000000000..9ccdae16400c77c0c7f2775db531e4687379f545
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/centernet/centernet_shufflenetv2_140e_coco.yml
@@ -0,0 +1,33 @@
+_BASE_: [
+ 'centernet_r50_140e_coco.yml'
+]
+
+pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ShuffleNetV2_x1_0_pretrained.pdparams
+weights: output/centernet_shufflenetv2_140e_coco/model_final
+
+CenterNet:
+ backbone: ShuffleNetV2
+ neck: CenterNetDLAFPN
+ head: CenterNetHead
+ post_process: CenterNetPostProcess
+
+ShuffleNetV2:
+ scale: 1.0
+ feature_maps: [5, 13, 17]
+ act: leaky_relu
+
+CenterNetDLAFPN:
+ first_level: 0
+ last_level: 3
+ down_ratio: 8
+ dcn_v2: False
+
+TrainReader:
+ batch_size: 32
+
+TestReader:
+ sample_transforms:
+ - Decode: {}
+ - WarpAffine: {keep_res: False, input_h: 512, input_w: 512}
+ - NormalizeImage: {mean: [0.40789655, 0.44719303, 0.47026116], std: [0.2886383 , 0.27408165, 0.27809834]}
+ - Permute: {}
diff --git a/PaddleDetection-release-2.6/configs/convnext/README.md b/PaddleDetection-release-2.6/configs/convnext/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..644d66815660427d2a6cdf587c014d8cb877eb15
--- /dev/null
+++ b/PaddleDetection-release-2.6/configs/convnext/README.md
@@ -0,0 +1,20 @@
+# ConvNeXt (A ConvNet for the 2020s)
+
+## 模型库
+### ConvNeXt on COCO
+
+| 网络网络 | 输入尺寸 | 图片数/GPU | 学习率策略 | mAPval
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+## 内容
+- [简介](#简介)
+- [切图使用说明](#切图使用说明)
+ - [小目标数据集下载](#小目标数据集下载)
+ - [统计数据集分布](#统计数据集分布)
+ - [SAHI切图](#SAHI切图)
+- [模型库](#模型库)
+ - [VisDrone模型](#VisDrone模型)
+ - [COCO模型](#COCO模型)
+ - [切图模型](#切图模型)
+ - [拼图模型](#拼图模型)
+ - [注意事项](#注意事项)
+- [模型库使用说明](#模型库使用说明)
+ - [训练](#训练)
+ - [评估](#评估)
+ - [预测](#预测)
+ - [部署](#部署)
+- [引用](#引用)
+
+
+## 简介
+PaddleDetection团队提供了针对VisDrone-DET、DOTA水平框、Xview等小目标场景数据集的基于PP-YOLOE改进的检测模型 PP-YOLOE-SOD，以及提供了一套使用[SAHI](https://github.com/obss/sahi)(Slicing Aided Hyper Inference)工具的切图和拼图的方案。
+
+ - PP-YOLOE-SOD 是PaddleDetection团队自研的小目标检测特色模型，使用**数据集分布相关的基于向量的DFL算法** 和 **针对小目标优化的中心先验优化策略**，并且**在模型的Neck(FPN)结构中加入Transformer模块**，以及结合增加P2层、使用large size等策略，最终在多个小目标数据集上达到极高的精度。
+
+ - 切图拼图方案**适用于任何检测模型**，建议**使用 PP-YOLOE-SOD 结合切图拼图方案**一起使用以达到最佳的效果。
+
+ - 官方 AI Studio 教程案例请参考 [基于PP-YOLOE-SOD的无人机航拍图像检测案例全流程实操](https://aistudio.baidu.com/aistudio/projectdetail/5036782)，欢迎一起动手实践学习。
+
+ - 第三方 AI Studio 教程案例可参考 [PPYOLOE：遥感场景下的小目标检测与部署(切图版)](https://aistudio.baidu.com/aistudio/projectdetail/4493701) 和 [涨分神器！基于PPYOLOE的切图和拼图解决方案](https://aistudio.baidu.com/aistudio/projectdetail/4438275)，欢迎一起动手实践学习。
+
+**注意:**
+ - **不通过切图拼图而直接使用原图或子图**去训练评估预测，推荐使用 PP-YOLOE-SOD 模型，更多细节和消融实验可参照[COCO模型](#COCO模型)和[VisDrone模型](./visdrone)。
+ - 是否需要切图然后使用子图去**训练**，建议首先参照[切图使用说明](#切图使用说明)中的[统计数据集分布](#统计数据集分布)分析一下数据集再确定，一般数据集中**所有的目标均极小**的情况下推荐切图去训练。
+ - 是否需要切图然后使用子图去**预测**，建议在切图训练的情况下，配合着**同样操作的切图策略和参数**去预测(inference)效果更佳。但其实即便不切图训练，也可进行切图预测(inference)，只需**在常规的预测命令最后加上`--slice_infer`以及相关子图参数**即可。
+ - 是否需要切图然后使用子图去**评估**，建议首先确保制作生成了合适的子图验证集，以及确保对应的标注框制作无误，并需要参照[模型库使用说明-评估](#评估)去**改动配置文件中的验证集(EvalDataset)的相关配置**，然后**在常规的评估命令最后加上`--slice_infer`以及相关子图参数**即可。
+ - `--slice_infer`的操作在PaddleDetection中默认**子图预测框会自动组合并拼回原图**，默认返回的是原图上的预测框，此方法也**适用于任何训好的检测模型**，无论是否切图训练。
+
+
+## 切图使用说明
+
+### 小目标数据集下载
+PaddleDetection团队整理提供的VisDrone-DET、DOTA水平框、Xview等小目标场景数据集的下载链接可以参照 [DataDownload.md](./DataDownload.md)。
+
+### 统计数据集分布
+
+对于待训的数据集(默认已处理为COCO格式，参照 [COCO格式数据集准备](../../docs/tutorials/data/PrepareDetDataSet.md#用户数据转成COCO数据)，首先统计**标注框的平均宽高占图片真实宽高的比例**分布：
+
+以DOTA水平框数据集的train数据集为例：
+
+```bash
+python tools/box_distribution.py --json_path dataset/DOTA/annotations/train.json --out_img box_distribution.jpg --eval_size 640 --small_stride 8
+```
+ - `--json_path` ：待统计数据集 COCO 格式 annotation 的json标注文件路径
+ - `--out_img` ：输出的统计分布图的路径
+ - `--eval_size` ：推理尺度（默认640）
+ - `--small_stride` ：模型最小步长（默认8）
+
+统计结果打印如下：
+```bash
+Suggested reg_range[1] is 13 # DFL算法中推荐值，在 PP-YOLOE-SOD 模型的配置文件的head中设置为此值，效果最佳
+Mean of all img_w is 2304.3981547196595 # 原图宽的平均值
+Mean of all img_h is 2180.9354151880766 # 原图高的平均值
+Median of ratio_w is 0.03799439775910364 # 标注框的宽与原图宽的比例的中位数
+Median of ratio_h is 0.04074914637387802 # 标注框的高与原图高的比例的中位数
+all_img with box: 1409 # 数据集图片总数(排除无框或空标注的图片)
+all_ann: 98905 # 数据集标注框总数
+Distribution saved as box_distribution.jpg
+```
+
+**注意:**
+- 一般情况下，在原始数据集全部有标注框的图片中，**原图宽高的平均值大于1500像素，且有1/2以上的图片标注框的平均宽高与原图宽高比例小于0.04时(通过打印中位数得到该值)**，建议进行切图训练。
+- `Suggested reg_range[1]` 为数据集在优化后DFL算法中推荐的`reg_range`上限，即`reg_max + 1`，在 PP-YOLOE-SOD 模型的配置文件的head中设置这个值。
+
+
+### SAHI切图
+
+针对需要切图的数据集，使用[SAHI](https://github.com/obss/sahi)库进行切图：
+
+#### 安装SAHI库：
+
+参考[SAHI installation](https://github.com/obss/sahi/blob/main/README.md#installation)进行安装，`pip install sahi`，参考[installation](https://github.com/obss/sahi/blob/main/README.md#installation)。
+
+#### 基于SAHI切图
+
+以DOTA水平框数据集的train数据集为例，切分后的**子图文件夹**与**子图json标注文件**共同保存在`dota_sliced`文件夹下，分别命名为`train_images_500_025`、`train_500_025.json`：
+
+```bash
+python tools/slice_image.py --image_dir dataset/DOTA/train/ --json_path dataset/DOTA/annotations/train.json --output_dir dataset/dota_sliced --slice_size 500 --overlap_ratio 0.25
+```
+ - `--image_dir`：原始数据集图片文件夹的路径
+ - `--json_path`：原始数据集COCO格式的json标注文件的路径
+ - `--output_dir`：切分后的子图及其json标注文件保存的路径
+ - `--slice_size`：切分以后子图的边长尺度大小(默认切图后为正方形)
+ - `--overlap_ratio`：切分时的子图之间的重叠率
+
+**注意:**
+- 如果切图然后使用子图去**训练**，则只能**离线切图**，即切完图后保存成子图，存放在内存空间中。
+- 如果切图然后使用子图去**评估或预测**，则既可以**离线切图**，也可以**在线切图**，PaddleDetection中支持切图并自动拼图组合结果到原图上。
+
+
+## 模型库
+
+### [VisDrone模型](visdrone/)
+
+| 模型 | COCOAPI mAPval
+
+
+
+
+
+
+ 
+
+ 
+
+ 
+
+
+
+