Skip to content

P
PaddleX

PaddlePaddle / PaddleX

通知 138
Star 4
Fork 0
P
PaddleX
未验证 提交 8c6de1cb 编写于 作者: J Jason 提交者： GitHub
浏览文件
操作

Merge pull request #9 from jiangjiajun/develop 

Develop
上级 01d41a4d 996b48b9
展开全部 隐藏空白更改
内联 并排
Showing with 20407 addition and 556 deletion
.pre-commit-config.yaml 0 → 100644
浏览文件 @ 8c6de1cb
- repo: local
hooks:
- id: yapf
name: yapf
entry: yapf
language: system
args: [-i, --style .style.yapf]
files: \.py$
- repo: https://github.com/pre-commit/pre-commit-hooks
sha: a11d9314b22d8f8c7556443875b731ef05965464
hooks:
- id: check-merge-conflict
- id: check-symlinks
- id: end-of-file-fixer
- id: trailing-whitespace
- id: detect-private-key
- id: check-symlinks
- id: check-added-large-files
- repo: local
hooks:
- id: copyright_checker
name: copyright_checker
entry: python ./.copyright.hook
language: system
files: \.(c|cc|cxx|cpp|cu|h|hpp|hxx|proto|py)$
exclude: (?!.*third_party)^.*$
DataAnnotation/AnnotationNote/1_[图像分类]任务数据标注.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 1. 准备「图像分类」任务数据
### 图像分类的数据结构
```
data/mydataset/
|-- class 1
|-- 0001.jpg
|-- 0002.jpg
|-- ...
|-- class 2
|-- 0001.jpg
|-- 0002.jpg
|-- ...
```
class 1 及 class 2 文件夹需要命名为需要分类的类名，输入限定为英文字符，不可包含空格、中文或特殊字符。
DataAnnotation/AnnotationNote/2_[目标检测]及[实例分割]数据标注.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2. 使用LabelMe标注「目标检测」及「实例分割」任务数据
### 2.1 准备工作
* **2.1.1** 创建与图像文件夹相对应的文件夹，用于存储标注的json文件。
* **2.1.2**点击”Open Dir“按钮，选择需要标注的图像所在的文件夹打开，则”File List“对话框中会显示所有图像所对应的绝对路径。
### 2.2 目标检测标注
* **2.2.1** 打开矩形框标注工具，具体如下图所示
<div align=center><img width="800" height="450" src="./pics/detection1.png"/></div>
* **2.2.2** 使用拖拉的方式对目标物体进行标识，并在弹出的对话框中写明对应label（当label已存在时点击即可），具体如下图所示：
<div align=center><img width="800" height="450" src="./pics/detection3.png"/></div>
当框标注错误时，可点击右侧的“Edit Polygons”再点击标注框，通过拖拉进行修改，也可再点击“Delete Polygon”进行删除。
* **2.2.3** 点击右侧”Save“，将标注结果保存到***2.1.1***中创建的文件夹中
【注意】当所使用的模型是类似Mask R-CNN这类模型时，虽是目标检测模型，但却需要实例分割信息，具体参见***2.3***。
### 2.3 实例分割标注
* **2.3.1** 点击右侧的“Create Polygons”以打点的方式圈出目标的轮廓，并在弹出的对话框中写明对应label（当label已存在时点击即可），具体如下提所示：
<div align=center><img width="800" height="450" src="./pics/detection2.png"/></div>
当框标注错误时，可点击右侧的“Edit Polygons”再点击标注框，通过拖拉进行修改，也可再点击“Delete Polygon”进行删除。
* **2.3.2** 点击右侧”Save“，将标注结果保存到***2.1.1***中创建的文件夹中。
【注意】***2.2.2***和***2.3.1***中在在定义label名字时，都用英文命名，同时在名字后加上“_0”或“_1”分别代表目标是一个对象（iscrowd=0）还是一组对象（iscrowd=1）。一个对象表示能用一个矩形框（或大于等于一个多边形框）就能将一个独立对象表示出来，当需要使用多个多边形来表示一个对象时，在“_0”后加上同一个数字代表同一个对象；一组对象表示同一类型对象联系太紧密只能用一个矩形框（或一个多边形框）将一组对象圈出来。例如下图在进行目标检测标注时，水果单堆分割成一个个水果较不容易，所以将其定义为一组水果对象，label定为“fruit_1” ；在进行实例分割标注时，装饰品无法用一个多边形框表示出来，所以使用3个label为“decoration_00”的多边形表示。
<div align=center><img width="800" height="450" src="./pics/detection4.png"/></div>
## 2.4 目标检测任务数据目录结构
```
data/mydataset/
|-- JPEGImages
|-- 1.jpg
|-- 2.jpg
|-- Annotations
|-- 1.xml
|-- 2.xml
```
其中，Annotations文件夹中存放标注文件，JPEGImages文件夹中存放图像文件。
## 2.5 实例分割任务数据目录结构
```
data/mydataset/
|-- JPEGImages
|-- 1.jpg
|-- 2.jpg
|-- annotations.json
```
其中，`annotations.json`为标注文件，JPEGImages文件夹中存放图像文件。
DataAnnotation/AnnotationNote/3_[语义分割]任务数据标注.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 3 使用LabelMe标注「语义分割」任务数据
语义分割中常用的数据集是CityScape和COCO，此小节主要讲述CityScape数据集在LabelMe上标注的使用，有关COCO部分请参考 2.3 小节中有关Mask RCNN部分。
### 3.1 准备工作
* **3.1.1** 创建与图像文件夹相对应的文件夹，用于存储标注的json文件
* **3.1.2** 点击”Open Dir“按钮，选择需要标注的图像所在的文件夹打开，则”File List“对话框中会显示所有图像所对应的绝对路径
### 3.2 标注
* **3.2.1** 点击右侧的“Create Polygons”以打点的方式圈出目标的轮廓，并在弹出的对话框中写明对应label（当label已存在时点击即可），具体如下提所示：
<div align=center><img width="800" height="450" src="./pics/detection5.png"/></div>
当框标注错误时，可点击右侧的“Edit Polygons”再点击标注框，通过拖拉进行修改，也可再点击“Delete Polygon”进行删除。
* **3.2.2** 点击右侧”Save“，将标注结果保存到***3.1.1***中创建的文件夹中
## 3.3 语义分割任务数据目录结构：
```
data/mydataset/
|-- JPEGImages
|-- 1.jpg
|-- 2.jpg
|-- 3.jpg
|-- Annotations
|-- 1.png
|-- 2.png
|-- 3.png
(可选)|-- label.txt
```
其中JPEGImages为图片文件夹，Annotations为标签文件夹。您可以提供一份命名为“label.txt”的包含所有标注名的清单，用于直接呈现类别名称，将标注序号“1”、“2”、“3” 等显示为对应的“空调”、“桌子”、“花瓶”。
\ No newline at end of file
DataAnnotation/README.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
### LabelMe
LabelMe是目前广泛使用的数据标注工具，您也可以在保证标注文件格式与PaddleX所支持格式进行匹配的基础，上选用其他标注工具。
LabelMe GitHub地址：https://github.com/wkentaro/labelme
#### LabelMe的安装
***注：为了保证环境的统一，本文介绍了在Anaconda环境下安装及使用LabelMe的方法，您也可以根据您的实际情况及需求，采用其他方案***
Windows: 参考文档[[标注工具安装和使用/1_Windows/1_3_LabelMe安装.md]](../DataAnnotation/标注工具安装和使用/1_Windows/1_3_LabelMe安装.md)
Ubuntu: 参考文档[[标注工具安装和使用/2_Ubuntu/2_3_LabelMe安装.md]](../DataAnnotation/标注工具安装和使用/2_Ubuntu/2_3_LabelMe安装.md)
MacOS: 参考文档[[标注工具安装和使用/3_MacOS/3_3_LabelMe安装.md]](../DataAnnotation/标注工具安装和使用/3_MacOS/3_3_LabelMe安装.md)
#### 使用LabelMe标注你的数据集
参考文档[[AnnotationNote]](../DataAnnotation/AnnotationNote)
DataAnnotation/标注工具安装和使用/1_Windows/1_1_Anaconda安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.1.1.1 下载Anaconda
在Anaconda官网[(https://www.anaconda.com/distribution/)](https://www.anaconda.com/distribution/)选择“Windows”，并选择与所需python相对应的Anaconda版本进行下载（PaddlePaddle要求安装的Anaconda版本为64-bit）
## 2.1.1.2 安装Anaconda
打开下载的安装包（以.exe为后缀），根据引导完成安装，在安装过程中可以修改安装路径，具体如下图所示：
<div align=center><img width="580" height="400" src="./pics/anaconda1.png"/></div>
【注意】默认安装在Windows当前用户主目录下
## 2.1.1.3 使用Anaconda
- 点击Windows系统左下角的Windows图标，打开：所有程序->Anaconda3/2（64-bit）->Anaconda Prompt
- 在命令行中执行下述命令
```cmd
# 创建一个名为mypaddle的环境，指定python版本是3.5
conda create -n mypaddle python=3.5
# 创建好后，使用activate进入环境
conda activate mypaddle
python --version
# 若上述命令行出现Anaconda字样，则表示安装成功
# 退出环境
conda deactivate
```
DataAnnotation/标注工具安装和使用/1_Windows/1_2_PaddlePaddle安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 1. 安装PaddlePaddle
PaddlePaddle可以在64-bit的Windows7、Windows8、Windows10企业版、Windows10专业版上运行，同时支持python2（>=2.7.15）和python3（>= 3.5.1），但pip版本必须高于9.0.1。Windows版本同时支持CPU版和GPU版的PaddlePaddle，若使用GPU版，对于CUDA和CUDNN的安装，可参考NVIDIA官方文档[(https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)和[(https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/beginners_guide/install/Tables.html/#ciwhls-release)](https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/beginners_guide/install/Tables.html/#ciwhls-release)了解。目前，Windows环境暂不支持NCCL，分布式等相关功能。
- 在命令行中执行下述命令
```cmd
# 进入创建好的Anaconda环境
conda activate mypaddle
# （选择1）安装CPU版本PaddlePaddle
pip install -U paddlepaddle
# （选择2）安装GPU版本PaddlePaddle
pip install -U paddlepaddle-gpu
```
【注意】默认提供的安装包需要计算机支持AVX指令集和MKL，若环境不支持，可以在PaddlePaddle官网[(https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/beginners_guide/install/Tables.html/#ciwhls-release)](https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/beginners_guide/install/Tables.html/#ciwhls-release)下载openblas版本的安装包
- 安装成功后，打开python命令行，使用以下代码进行测试：
```python
import paddle.fluid as fluid
fluid.install_check.run_check()
# 若出现Your Paddle Fluid is installed successfully!字样则表示安装成功
```
DataAnnotation/标注工具安装和使用/1_Windows/1_3_LabelMe安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.1.3.1 安装LabelMe
在命令行中执行下述命令
```cmd
# 进入创建好的Anaconda环境
conda activate mypaddle
# （选择一）python版本为2.x
conda install pyqt
# （选择二）python版本为3.x
pip install pyqt5
# 安装LabelMe
pip install labelme
```
## 2.1.3.2 使用LabelMe
在命令行中执行下述命令，则会出现标注工具
```cmd
# 进入创建好的Anaconda环境
source activate mypaddle
# 开启LabelMe
```
LabelMe标注工具界面主要如下图所示：
<div align=center><img width="800" height="450" src="./pics/labelme1.png"/></div>
LabelMe默认标注多边形，可在图像中右键选择标注其他类型的框，如下图所示：
<div align=center><img width="800" height="450" src="./pics/labelme2.png"/></div>
DataAnnotation/标注工具安装和使用/2_Ubuntu/2_1_Anaconda安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.2.1.1 下载Anaconda
Ubuntu图形界面下：在Anaconda官网[(https://www.anaconda.com/distribution/)](https://www.anaconda.com/distribution/)选择“Linux”，并选择与所需python相对应的Anaconda版本进行下载
Ubuntu命令行界面下：使用”wget“进行下载
```cmd
# Anaconda2
wget https://repo.anaconda.com/archive/Anaconda2-2019.07-Linux-x86_64.sh --no-check-certificate
# Anaconda3
wget https://repo.anaconda.com/archive/Anaconda3-2019.07-Linux-x86_64.sh --no-check-certificate
```
## 2.2.1.2 安装Anaconda
***步骤一：安装***
在Anaconda安装包所在路径执行下述命令行
```cmd
# 运行所下载的Anaconda，例如：
bash ./Anaconda3-2019.07-Linux-x86_64.sh
```
【注意】安装过程中一直回车即可，直至出现设置路径时可对安装路径进行修改，否则默认安装在Ubuntu当前用户主目录下
***步骤二：设置环境变量***
在命令行中执行下述命令
```cmd
# 将anaconda的bin目录加入PATH
# 根据安装路径的不同，修改”~/anaconda3/bin“
echo 'export PATH="~/anaconda3/bin:$PATH"' >> ~/.bashrc
# 更新bashrc以立即生效
source ~/.bashrc
```
## 2.2.1.3 使用Anaconda
在命令行中执行下述命令
```cmd
# 创建一个名为mypaddle的环境，指定python版本是3.5
conda create -n mypaddle python=3.5
# 创建好后，使用activate进入环境
source activate mypaddle
python --version
# 若上述命令行出现Anaconda字样，则表示安装成功
# 退出环境
source deactivate
```
DataAnnotation/标注工具安装和使用/2_Ubuntu/2_2_PaddlePaddle安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.2.2.1 安装PaddlePaddle
PaddlePaddle可以在64-bit的Ubuntu14.04（支持CUDA8、CUDA10）、Ubuntu16.04（支持CUDA8、CUDA9、CUDA10）、Ubuntu18.04(支持CUDA10)上运行，同时支持python2（>=2.7.15）和python3（>= 3.5.1），但pip版本必须高于9.0.1。Windows版本同时支持CPU版和GPU版的PaddlePaddle，若使用GPU版，对于CUDA和CUDNN的安装，可参考NVIDIA官方文档[(https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)和[(https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/beginners_guide/install/Tables.html/#ciwhls-release)](https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/beginners_guide/install/Tables.html/#ciwhls-release)了解。
- 在命令行中执行下述命令
```cmd
# 进入创建好的Anaconda环境
source activate mypaddle
# （选择1）安装CPU版本PaddlePaddle
pip install -U paddlepaddle
# （选择2）安装GPU版本PaddlePaddle
pip install -U paddlepaddle-gpu
# （选择3）安装指定版本PaddlePaddle
pip install -U paddlepaddle-gpu==[版本号]
pip install -U paddlepaddle==[版本号]
```
【注意】版本号可参考PyPi官网[(https://pypi.org/project/paddlepaddle-gpu/#history)](https://pypi.org/project/paddlepaddle-gpu/#history)
- 安装成功后，打开python命令行，使用以下代码进行测试：
```python
import paddle.fluid as fluid
fluid.install_check.run_check()
# 若出现Your Paddle Fluid is installed successfully!字样则表示安装成功
```
DataAnnotation/标注工具安装和使用/2_Ubuntu/2_3_LabelMe安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.2.3.1 安装LabelMe
在命令行中执行下述命令
```cmd
# 进入创建好的Anaconda环境
source activate mypaddle
# （选择一）python版本为2.x
conda install pyqt
# （选择二）python版本为3.x
pip install pyqt5
# 安装LabelMe
pip install labelme
```
## 2.2.3.2 使用LabelMe
在命令行中执行下述命令，则会出现标注工具
```cmd
# 进入创建好的Anaconda环境
source activate mypaddle
# 开启LabelMe
labelme
```
LabelMe标注工具界面主要如下图所示：
<div align=center><img width="800" height="450" src="./pics/labelme1.png"/></div>
LabelMe默认标注多边形，可在图像中右键选择标注其他类型的框，如下图所示：
<div align=center><img width="800" height="450" src="./pics/labelme2.png"/></div>
DataAnnotation/标注工具安装和使用/3_MacOS/3_1_Anaconda安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.3.1.1 下载Anaconda
在Anaconda官网[(https://www.anaconda.com/distribution/)](https://www.anaconda.com/distribution/)选择“MacOS”，并选择与所需python相对应的Anaconda版本进行下载
## 2.3.1.2 安装Anaconda
***步骤一：安装***
打开下载的安装包（以.pkl为后缀），根据引导完成安装，在安装过程中可以修改安装路径，具体如下图所示：
<div align=center><img width="600" height="400" src="./pics/anaconda1.png"/></div>
【注意】默认安装在MacOS当前用户主目录下
***步骤二：设置环境变量***
在命令行中执行下述命令
```cmd
# 将anaconda的bin目录加入PATH
# 根据安装路径的不同，修改”/Users/anaconda3/bin“
echo 'export PATH="/Users/anaconda3/bin:$PATH"' >> ~/.bash_profile
# 更新bash_profile以立即生效
source ~/.bash_profile
```
## 2.3.1.3 使用Anaconda
在命令行中执行下述命令
```cmd
# 创建一个名为mypaddle的环境，指定python版本是3.5
conda create -n mypaddle python=3.5
# 创建好后，使用activate进入环境
source activate mypaddle
python --version
# 若上述命令行出现Anaconda字样，则表示安装成功
# 退出环境
source deactivate
```
DataAnnotation/标注工具安装和使用/3_MacOS/3_2_PaddlePaddle安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.3.2.1 安装PaddlePaddle
PaddlePaddle可以在64-bit的MacOS10.11、MacOS10.12、MacOS10.13、MacOS10.14上运行，同时支持python2（>=2.7.15）和python3（>= 3.5.1），但pip版本必须高于9.0.1。目前，MacOS环境仅支持CPU版PaddlePaddle。
- 在命令行中执行下述命令
```cmd
# 进入创建好的Anaconda环境
source activate mypaddle
# （选择1）安装CPU版本PaddlePaddle
pip install -U paddlepaddle
# （选择2）安装指定版本PaddlePaddle
pip install -U paddlepaddle==[版本号]
```
- 安装成功后，打开python命令行，使用以下代码进行测试：
```python
import paddle.fluid as fluid
fluid.install_check.run_check()
# 若出现Your Paddle Fluid is installed successfully!字样则表示安装成功
```
DataAnnotation/标注工具安装和使用/3_MacOS/3_3_LabelMe安装.md 已删除 100644 → 0
浏览文件 @ 01d41a4d
## 2.3.3.1 安装LabelMe
在命令行中执行下述命令
```cmd
# 进入创建好的Anaconda环境
source activate mypaddle
# （选择一）python版本为2.x
conda install pyqt
# （选择二）python版本为3.x
pip install pyqt5
# 安装LabelMe
pip install labelme
```
## 2.3.3.2 使用LabelMe
在命令行中执行下述命令，则会出现标注工具
```cmd
# 进入创建好的Anaconda环境
source activate mypaddle
# 开启LabelMe
labelme
```
LabelMe标注工具界面主要如下图所示：
<div align=center><img width="800" height="450" src="./pics/labelme1.png"/></div>
LabelMe默认标注多边形，可在图像中右键选择标注其他类型的框，如下图所示：
<div align=center><img width="800" height="450" src="./pics/labelme2.png"/></div>
README.md
浏览文件 @ 8c6de1cb
<img src="./paddlex.png" width = "300" height = "47" alt="PaddleX" align=center />
[![Build Status](https://travis-ci.org/PaddlePaddle/PaddleX.svg?branch=release/v1.6)](https://travis-ci.org/PaddlePaddle/PaddleX)
[![License](https://img.shields.io/badge/license-Apache%202-red.svg)](LICENSE)
[![Version](https://img.shields.io/github/release/PaddlePaddle/PaddleX.svg)](https://github.com/PaddlePaddle/PaddleX/releases)
![python version](https://img.shields.io/badge/python-3.6+-orange.svg)
![support os](https://img.shields.io/badge/os-linux%2C%20win%2C%20mac-yellow.svg)
<div align=center>
<br/><img src="./images/paddlexlogo.png" width = "450" height = "69" alt="PaddleX" align=center />
PaddleX是基于飞桨技术生态的全流程深度学习模型开发工具。具备易集成，易使用，全流程等特点。PaddleX作为深度学习开发工具，不仅提供了开源的内核代码，可供用户灵活使用或集成，同时也提供了配套的前端可视化客户端套件，让用户以可视化的方式进行模型开发，免去代码开发过程，访问[PaddleX官网](https://www.paddlepaddle.org.cn/paddlex/download)获取更多相关细节。
## 安装
查看[PaddleX安装文档](docs/install.md)
</br>
## 文档
推荐访问PaddleX在线使用文档，快速查阅读使用教程和API文档说明。
</div>
常用文档
- [10分钟快速上手PaddleX模型训练](docs/quick_start.md)
- [PaddleX使用教程](docs/tutorials)
- [PaddleX模型库](docs/model_zoo.md)
## 反馈
飞桨全流程开发工具，集飞桨核心框架、模型库、工具及组件等深度学习开发所需全部能力于一身，打通深度学习开发全流程，并提供简明易懂的Python API，方便用户根据实际生产需求进行直接调用或二次开发，为开发者提供飞桨全流程开发的最佳实践。
为了帮助开发者更好的了解飞桨的开发步骤以及所涉及的模块组件，进一步提升项目开发效率，我们还为开发者提供了基于PaddleX实现的图形化开发界即可面示例，用户可以基于该界面示例进行改造，开发符合自己习惯的操作界面。开发者可以根据实际业务需求，直接调用、改造PaddleX后端技术内核来开发项目，也可使用图形化开发界面快速体验飞桨模型开发全流程。
我们诚挚地邀请您前往 [官网](https://www.paddlepaddle.org.cn/paddle/paddlex)下载试用PaddleX可视化前端，并提出您的宝贵意见或贡献项目。PaddleX代码将在5月初随正式版本发布时，全部开源。
## 目录
* <a href="#1">**产品特性**</a>
* <a href="#2">**PaddleX 可视化前端**</a>
1. <a href="#a">下载可视化前端</a>
2. <a href="#b">准备数据</a>
3. <a href="#c">导入我的数据集</a>
4. <a href="#d">创建项目</a>
5. <a href="#e">项目开发</a>
* <a href="#3">**PaddleX 后端技术内核**</a>
* <a href="#4">**FAQ**</a>
## <a name="1">产品特性</a>
1. **全流程打通**
将深度学习开发从数据接入、模型训练、参数调优、模型评估、预测部署全流程打通，并提供可视化的使用界面，省去了对各环节间串连的代码开发与脚本调用，极大地提升了开发效率。
2. **开源技术内核**
集成PaddleCV领先的视觉算法和面向任务的开发套件、预训练模型应用工具PaddleHub、训练可视化工具VisualDL、模型压缩工具库PaddleSlim等技术能力于一身，并提供简明易懂的Python API，完全开源开放，易于集成和二次开发，为您的业务实践全程助力。
3. **本地一键安装**
高度兼容Windows、Mac、Linux系统，同时支持NVIDIA GPU加速深度学习训练。本地开发、保证数据安全，高度符合产业应用的实际需求。
4. **教程与服务**
从数据集准备到上线部署，为您提供业务开发全流程的文档说明及技术服务。开发者可以通过QQ群、微信群、GitHub社区等多种形式与飞桨团队及同业合作伙伴交流沟通。
## <a name="2">PaddleX 可视化前端</a>
**<a name="a">第一步：下载可视化前端</a>**
您需要前往 [官网](https://www.paddlepaddle.org.cn/paddle/paddlex)填写基本信息后下载试用PaddleX可视化前端
**<a name="b">第二步：准备数据**</a>
在开始模型训练前，您需要根据不同的任务类型，将数据标注为相应的格式。目前PaddleX支持【图像分类】、【目标检测】、【语义分割】、【实例分割】四种任务类型。不同类型任务的数据处理方式可查看[数据标注方式](https://github.com/PaddlePaddle/PaddleX/tree/master/DataAnnotation/AnnotationNote)。
**<a name="c">第三步：导入我的数据集</a>**
①数据标注完成后，您需要根据不同的任务，将数据和标注文件，按照客户端提示更名并保存到正确的文件中。
②在客户端新建数据集，选择与数据集匹配的任务类型，并选择数据集对应的路径，将数据集导入。
<img src="./images/00%E6%95%B0%E6%8D%AE%E9%9B%86%E5%AF%BC%E5%85%A5%E8%AF%B4%E6%98%8E.png" width = "500" height = "350" alt="00数据集导入说明" align=center />
③选定导入数据集后，客户端会自动校验数据及标注文件是否合规，校验成功后，您可根据实际需求，将数据集按比例划分为训练集、验证集、测试集。
④您可在「数据分析」模块按规则预览您标注的数据集，双击单张图片可放大查看。
<img src="./images/01%E6%95%B0%E6%8D%AE%E5%88%87%E5%88%86%E5%8F%8A%E9%A2%84%E8%A7%88.png" width = "500" height = "300" alt="01数据切分及预览" align=center />
**<a name="d">第四步：创建项目</a>**
① 在完成数据导入后，您可以点击「新建项目」创建一个项目。
② 您可根据实际任务需求选择项目的任务类型，需要注意项目所采用的数据集也带有任务类型属性，两者需要进行匹配。
<img src="./images/02%E5%88%9B%E5%BB%BA%E9%A1%B9%E7%9B%AE.png" width = "500" height = "300" alt="02创建项目" align=center />
<a name="e">**第五步：项目开发**</a>
① **数据选择**：项目创建完成后，您需要选择已载入客户端并校验后的数据集，并点击下一步，进入参数配置页面。
<img src="./images/03%E9%80%89%E6%8B%A9%E6%95%B0%E6%8D%AE%E9%9B%86.png" width = "400" height = "200" alt="03选择数据集" align=center />
② **参数配置**：主要分为**模型参数**、**训练参数**、**优化策略**三部分。您可根据实际需求选择模型结构及对应的训练参数、优化策略，使得任务效果最佳。
<img src="./images/04参数配置-2.png" width = "500" height = "500" alt="04参数配置-2" align=center />
参数配置完成后，点击启动训练，模型开始训练并进行效果评估。
③ **训练可视化**：
在训练过程中，您可通过VisualDL查看模型训练过程时的参数变化、日志详情，及当前最优的训练集和验证集训练指标。模型在训练过程中通过点击"终止训练"随时终止训练过程。
<img src="./images/05%E8%AE%AD%E7%BB%83%E5%8F%AF%E8%A7%86%E5%8C%96.png" width = "500" height = "350" alt="05训练可视化" align=center />
<img src="./images/06VisualDL.png" width = "500" height = "300" alt="06VisualDL" align=center />
模型训练结束后，点击”下一步“，进入模型评估页面。
④ **模型评估**
在模型评估页面，您可将训练后的模型应用在切分时留出的「验证数据集」以测试模型在验证集上的效果。评估方法包括混淆矩阵、精度、召回率等。在这个页面，您也可以直接查看模型在测试数据集上的预测效果。
根据评估结果，您可决定进入模型发布页面，或返回先前步骤调整参数配置重新进行训练。
<img src="./images/07%E6%A8%A1%E5%9E%8B%E8%AF%84%E4%BC%B0.jpg" width = "500" height = "550" alt="07模型评估" align=center />
⑤**模型发布**
当模型效果满意后，您可根据实际的生产环境需求，选择将模型发布为需要的版本。
<img src="./images/08%E6%A8%A1%E5%9E%8B%E5%8F%91%E5%B8%83.png" width = "450" height = "350" alt="08模型发布" align=center />
## <a name="3">PaddleX 技术内核</a>
将于2020年5月下旬全面开源，敬请期待
## <a name="4">FAQ</a>
1. **为什么我的数据集没办法切分？**
如果您的数据集已经被一个或多个项目引用，数据集将无法切分，您可以额外新建一个数据集，并引用同一批数据，再选择不同的切分比例。
2. **任务和项目的区别是什么？**
一个项目可以包含多条任务，一个项目拥有唯一的数据集，但采用不同的参数配置启动训练会创建多条任务，方便您对比采用不同参数配置的训练效果，并管理多个任务。
3. **为什么训练速度这么慢？**
PaddleX完全采用您本地的硬件进行计算，深度学习任务确实对算力的要求比较高，为了使您能快速体验应用PaddleX进行开发，我们适配了CPU硬件，但强烈建议您使用GPU以提升训练速度和开发体验。
4. **我可以在服务器或云平台上部署PaddleX么？**
当前PaddleX 可视化前端是一个适配本地单机安装的Client，无法在服务器上直接进行部署，您可以直接使用PaddleX Core后端技术内核，或采用飞桨核心框架进行服务器上的部署。如果您希望使用公有算力，强烈建议您尝试飞桨产品系列中的 [EasyDL](https://ai.baidu.com/easydl/) 或 [AI Studio](https://aistudio.baidu.com/aistudio/index)进行开发。
5. **为什么我的安装总是报错？**
PaddleX的安装包中打包了PaddlePaddle全流程开发所需的所有依赖，理论上不需要您额外安装CUDA等ToolKit (如使用NVIDIA GPU), 但对操作系统版本、处理器架构、驱动版本等有一定要求，如安装发生错误，建议您先检查开发环境是否与PaddleX推荐环境匹配。
**这里我们推荐您在以下环境中安装使用PaddleX：**
* **操作系统：**
* Windows 7/8/10（推荐Windows 10）；
* Mac OS 10.13+ ；
* Ubuntu 18.04+；
​ ***注：处理器需为x86_64架构，支持 MKL***
* **训练硬件：**
* **GPU**（Windows及Linux系统）：
推荐使用支持CUDA的NVIDIA显卡，例如：GTX 1070+以上性能的显卡；
Windows系统X86_64驱动版本>=411.31；
Linux系统X86_64驱动版本>=410.48；
显存8G以上；
* **CPU**：
PaddleX 当前支持您用本地CPU进行训练，但推荐使用GPU以获得更好的开发体验。
* **内存** ：建议8G以上
* **硬盘空间** ：建议SSD剩余空间1T以上（非必须）
​ ***注：PaddleX 在 Windows及Mac系统只支持单卡模式。Windows暂时不支持NCCL。***
**如果您有更多问题或建议，欢迎以issue的形式，或加入PaddleX官方QQ群（1045148026）直接反馈您的意见及建议**
<div align=center>
<img src="./images/09qq%E7%BE%A4%E4%BA%8C%E7%BB%B4%E7%A0%81.png" alt="09qq群二维码" align=center />
</div>
- 项目官网: https://www.paddlepaddle.org.cn/paddlex
- PaddleX用户QQ群: 1045148026 (手机QQ扫描如下二维码快速加入)
<img src="./QQGroup.jpeg" width="195" height="300" alt="QQGroup" align=center />
## 飞桨技术生态
- [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection)
- [PaddleSeg](https://github.com/PaddlePaddle/PaddleSeg)
- [PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
- [PaddleSlim](https://github.com/PaddlePaddle/PaddleSlim)
- [PaddleHub](https://github.com/PaddlePaddle/PaddleHub)
- [PaddleLite](https://github.com/PaddlePaddle/Paddle-Lite)
- [VisualDL](https://github.com/PaddlePaddle/VisualDL)
commit-prepare.sh 0 → 100644
浏览文件 @ 8c6de1cb
path=$(cd `dirname $0`; pwd)
cd $path
pip install pre-commit
pip install yapf
pre-commit install
docs/FAQ.md 0 → 100644
浏览文件 @ 8c6de1cb
# 常见问题
## 1. 训练过程因显存不够出错
> 通过使用在终端`nvidia-smi`命令，查看GPU是否被其它任务占用，尝试清除其它任务；
> 调低训练时的`batch_size`参数，从而降低显存的要求，注意需等比例调低`learning_rate`等参数；
> 选用更小的模型或backbone。
## 2. 是否有更小的模型，适用于更低配置的设备上运行
> 可以使用模型裁剪，参考文档[模型裁剪使用教程](slim/prune.md)，通过调整裁剪参数，可以控制模型裁剪后的大小，在实际实验中，如VOC检测数据，使用yolov3-mobilenet，原模型大小为XXM，裁剪后为XX M，精度基本保持不变
## 3. 如何配置训练时GPU的卡数
> 通过在终端export环境变量，或在Python代码中设置，可参考文档[CPU/多卡GPU训练](gpu_configure.md)
## 4. 想将之前训练的模型参数上继续训练
> 在训练调用`train`接口时，将`pretrain_weights`设为之前的模型保存路径即可
## 5. PaddleX保存的模型分为正常训练过程中产生、裁剪训练产生、导出为部署模型和量化保存这么多种，有什么差别，怎么区分
**不同模型的功能差异**
>1.正常模型训练保存
>
>>模型在正常训练过程，每间隔n个epoch保存的模型目录，模型可作为预训练模型参数，可使用PaddleX加载预测、或导出部署模型
>2.裁剪训练保存
>
>>模型在裁剪训练过程，每间隔n个epoch保存的模型目录，模型不可作为预训练模型参数，可使用PaddleX加载预测、或导出部署模型
>3.导出部署模型
>
>>为了模型在服务端部署，导出的模型目录，不可作为预训练模型参数，可使用PaddleX加载预测
>4.量化保存模型
>
>>为了提升模型预测速度，将模型参数进行量化保存的模型目录，模型不可作为预训练模型参数，可使用PaddleX加载预测
**区分方法**
>> 通过模型目录下model.yml文件中`status`字段来区别不同的模型类型, 'Normal'、'Prune'、'Infer'、'Quant'分别表示正常模型训练保存、裁剪训练保存、导出的部署模型、量化保存模型
## 6. 模型训练需要太久时间，或者训练速度太慢，怎么提速
> 1.模型训练速度与用户选定的模型大小，和设定的`batch_size`相关，模型大小可直接参考[模型库](model_zoo.md)中的指标，一般而言，模型越大，训练速度就越慢；
> 2.在模型速度之外，模型训练完成所需的时间又与用户设定的`num_epochs`迭代轮数相关，用户可以通过观察模型在验证集上的指标来决定是否提示结束掉训练进程（训练时设定`save_interval_epochs`参数，训练过程会每间隔`save_interval_epochs`轮数在验证集上计算指标，并保存模型）；
## 7. 如何设定迭代的轮数
> 1. 用户自行训练时，如不确定迭代的轮数，可以将轮数设高一些，同时注意设置`save_interval_epochs`，这样模型迭代每间隔相应轮数就会在验证集上进行评估和保存，可以根据不同轮数模型在验证集上的评估指标，判断模型是否已经收敛，若模型已收敛，可以自行结束训练进程
>
## 8. 只有CPU，没有GPU，如何提升训练速度
> 当没有GPU时，可以根据自己的CPU配置，选择是否使用多CPU进行训练，具体配置方式可以参考文档[多卡CPU/GPU训练](gpu_configure.md)
>
## 9. 电脑不能联网，训练时因为下载预训练模型失败，如何解决
> 可以预先通过其它方式准备好预训练模型，然后训练时自定义`pretrain_weights`即可，可参考文档[无联网模型训练](how_to_offline_run.md)
## 10. 每次训练新的模型，都需要重新下载预训练模型，怎样可以下载一次就搞定
> 1.可以按照9的方式来解决这个问题
> 2.每次训练前都设定`paddlex.pretrain_dir`路径，如设定`paddlex.pretrain_dir='/usrname/paddlex`，如此下载完的预训练模型会存放至`/usrname/paddlex`目录下，而已经下载在该目录的模型也不会再次重复下载
docs/Makefile 0 → 100644
浏览文件 @ 8c6de1cb
# 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 = .
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/README.md 0 → 100644
浏览文件 @ 8c6de1cb
# PaddleX文档
PaddleX的使用文档均在本目录结构下。文档采用Read the Docs方式组织，您可以直接访问[在线文档](https://www.baidu.com)进行查阅。
## 编译文档
在本目录下按如下步骤进行文档编译
- 安装依赖: `pip install -r requirements.txt`
- 编译: `make html`
编译完成后，编译文件在`_build`目录下，直接打开`_build/html/index.html`即可查阅。
docs/apis/datasets.md 0 → 100644
浏览文件 @ 8c6de1cb
# 数据集-datasets
## ImageNet类
```
paddlex.datasets.ImageNet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
```
读取ImageNet格式的分类数据集，并对样本进行相应的处理。ImageNet数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)
示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/classification/mobilenetv2.py#L25)
### 参数
> * **data_dir** (str): 数据集所在的目录路径。
> * **file_list** (str): 描述数据集图片文件和类别id的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
> * **label_list** (str): 描述数据集包含的类别信息文件路径。
> * **transforms** (paddlex.cls.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.cls.transforms](./transforms/cls_transforms.md)。
> * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
> * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。
> * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'thread'（Windows和Mac下会强制使用thread，该参数无效）。
> * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
## VOCDetection类
```
paddlex.datasets.VOCDetection(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
```
读取PascalVOC格式的检测数据集，并对样本进行相应的处理。PascalVOC数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)
示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/yolov3_mobilenetv1.py#L29)
### 参数
> * **data_dir** (str): 数据集所在的目录路径。
> * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
> * **label_list** (str): 描述数据集包含的类别信息文件路径。
> * **transforms** (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.det.transforms](./transforms/det_transforms.md)。
> * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
> * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。
> * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'thread'（Windows和Mac下会强制使用thread，该参数无效）。
> * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
## COCODetection类
```
paddlex.datasets.COCODetection(data_dir, ann_file, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
```
读取MSCOCO格式的检测数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。MSCOCO数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)
示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/mask_rcnn_r50_fpn.py#L27)
### 参数
> * **data_dir** (str): 数据集所在的目录路径。
> * **ann_file** (str): 数据集的标注文件，为一个独立的json格式文件。
> * **transforms** (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.det.transforms](./transforms/det_transforms.md)。
> * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
> * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。
> * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'thread'（Windows和Mac下会强制使用thread，该参数无效）。
> * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
## SegDataset类
```
paddlex.datasets.SegDataset(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
```
读取语分分割任务数据集，并对样本进行相应的处理。语义分割任务数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)
示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/segmentation/unet.py#L27)
### 参数
> * **data_dir** (str): 数据集所在的目录路径。
> * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
> * **label_list** (str): 描述数据集包含的类别信息文件路径。
> * **transforms** (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.seg.transforms](./transforms/seg_transforms.md)。
> * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
> * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。
> * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'thread'（Windows和Mac下会强制使用thread，该参数无效）。
> * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
docs/apis/deploy.md 0 → 100644
浏览文件 @ 8c6de1cb
# paddlex.deploy
使用AnalysisPredictor进行预测部署。
## create_predictor
```
paddlex.deploy.create_predictor(model_dir, use_gpu=False)
```
#### Args
* **model_dir**: 训练过程中保存的模型路径
* **use_gpu**: 是否使用GPU进行预测
#### Returns
* **Predictor**: paddlex.deploy.predictor.Predictor
### 示例
```
import paddlex
# 下
Predictor = paddlex.deploy.create_predictor(model_dir, use_gpu=True)
```
## ClassifyPredictor
继承至paddlex.deploy.predictor.Predictor，当model_dir/model.yml里面
```
paddlex.deploy.create_predictor(model_dir, use_gpu=False)
```
#### Args
* **model_dir**: 训练过程中保存的模型路径
* **use_gpu**: 是否使用GPU进行预测
#### Returns
* **Predictor**: paddlex.deploy.predictor.Predictor
### 示例
```
import paddlex
# 下
Predictor = paddlex.deploy.create_predictor(model_dir, use_gpu=True)
```
docs/apis/index.rst 0 → 100644
浏览文件 @ 8c6de1cb
接口说明
============================
.. toctree::
:maxdepth: 2
transforms/index.rst
datasets.md
models.md
slim.md
load_model.md
visualize.md
docs/apis/load_model.md 0 → 100644
浏览文件 @ 8c6de1cb
# 模型加载-load_model
PaddleX提供了统一的模型加载接口，支持加载PaddleX保存的模型，并在验证集上进行评估或对测试图片进行预测
## 函数接口
```
paddlex.load_model(model_dir)
```
### 参数
* **model_dir**: 训练过程中保存的模型路径
### 返回值
* **paddlex.cv.models**, 模型类。
### 示例
> 1. [点击下载](https://bj.bcebos.com/paddlex/models/garbage_epoch_12.tar.gz)PaddleX在垃圾分拣数据上训练的MaskRCNN模型
> 2. [点击下载](https://bj.bcebos.com/paddlex/datasets/garbage_ins_det.tar.gz)垃圾分拣数据集
```
import paddlex as pdx
model_dir = './garbage_epoch_12'
data_dir = './garbage_ins_det/JPEGImages'
ann_file = './garbage_ins_det/val.json'
# 加载垃圾分拣模型
model = pdx.load_model(model_dir)
# 预测
pred_result = model.predict('./garbage_ins_det/JPEGImages/000114.bmp')
# 在验证集上进行评估
eval_reader = pdx.cv.datasets.CocoDetection(data_dir=data_dir,
ann_file=ann_file
transforms=model.eval_transforms)
eval_result = model.evaluate(eval_reader, batch_size=1)
```
docs/apis/models.md 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
docs/apis/slim.md 0 → 100644
浏览文件 @ 8c6de1cb
# 模型压缩-slim
## 计算参数敏感度
```
paddlex.slim.cal_params_sensetives(model, save_file, eval_dataset, batch_size=8)
```
计算模型中可裁剪参数在验证集上的敏感度，并将敏感度信息保存至文件`save_file`
1. 获取模型中可裁剪卷积Kernel的名称。
2. 计算每个可裁剪卷积Kernel不同裁剪率下的敏感度。
【注意】卷积的敏感度是指在不同裁剪率下评估数据集预测精度的损失，通过得到的敏感度，可以决定最终模型需要裁剪的参数列表和各裁剪参数对应的裁剪率。
[查看使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/classification/cal_sensitivities_file.py#L33)
### 参数
* **model** (paddlex.cls.models/paddlex.det.models/paddlex.seg.models): paddlex加载的模型。
* **save_file** (str): 计算的得到的sensetives文件存储路径。
* **eval_dataset** (paddlex.datasets): 评估数据集的读取器。
* **batch_size** (int): 评估时的batch_size大小。
## 导出量化模型
```
paddlex.slim.export_quant_model(model, test_dataset, batch_size=2, batch_num=10, save_dir='./quant_model', cache_dir='./temp')
```
导出量化模型，该接口实现了Post Quantization量化方式，需要传入测试数据集，并设定`batch_size`和`batch_num`，模型会以`batch_size`的大小计算`batch_num`批样本数据，并以这些样本数据的计算结果为统计信息进行模型量化。
### 参数
* **model**(paddlex.cls.models/paddlex.det.models/paddlex.seg.models): paddlex加载的模型。
* **test_dataset**(paddlex.dataset): 测试数据集
* **batch_size**(int): 进行前向计算时的批数据大小
* **batch_num**(int): 进行向前计算时批数据数量
* **save_dir**(str): 量化后模型的保存目录
* **cache_dir**(str): 量化过程中的统计数据临时存储目录
### 使用示例
点击下载如下示例中的[模型](https://bj.bcebos.com/paddlex/models/vegetables_mobilenet.tar.gz)，[数据集](https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz)
```
import paddlex as pdx
model = pdx.load_model('vegetables_mobilenet')
test_dataset = pdx.datasets.ImageNet(
data_dir='vegetables_cls',
file_list='vegetables_cls/train_list.txt',
label_list='vegetables_cls/labels.txt',
transforms=model.eval_transforms)
pdx.slim.export_quant_model(model, test_dataset, save_dir='./quant_mobilenet')
```
docs/apis/transforms/cls_transforms.md 0 → 100644
浏览文件 @ 8c6de1cb
# 分类-paddlex.cls.transforms
对图像分类任务的数据进行操作。可以利用[Compose](#compose)类将图像预处理/增强操作进行组合。
## Compose类
```python
paddlex.cls.transforms.Compose(transforms)
```
根据数据预处理/增强算子对输入数据进行操作。 [使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/classification/mobilenetv2.py#L13)
### 参数
* **transforms** (list): 数据预处理/数据增强列表。
## RandomCrop类
```python
paddlex.cls.transforms.RandomCrop(crop_size=224, lower_scale=0.88, lower_ratio=3. / 4, upper_ratio=4. / 3)
```
对图像进行随机剪裁，模型训练时的数据增强操作。
1. 根据lower_scale、lower_ratio、upper_ratio计算随机剪裁的高、宽。
2. 根据随机剪裁的高、宽随机选取剪裁的起始点。
3. 剪裁图像。
4. 调整剪裁后的图像的大小到crop_size*crop_size。
### 参数
* **crop_size** (int): 随机裁剪后重新调整的目标边长。默认为224。
* **lower_scale** (float): 裁剪面积相对原面积比例的最小限制。默认为0.88。
* **lower_ratio** (float): 宽变换比例的最小限制。默认为3. / 4。
* **upper_ratio** (float): 宽变换比例的最小限制。默认为4. / 3。
## RandomHorizontalFlip类
```python
paddlex.cls.transforms.RandomHorizontalFlip(prob=0.5)
```
以一定的概率对图像进行随机水平翻转，模型训练时的数据增强操作。
### 参数
* **prob** (float): 随机水平翻转的概率。默认为0.5。
## RandomVerticalFlip类
```python
paddlex.cls.transforms.RandomVerticalFlip(prob=0.5)
```
以一定的概率对图像进行随机垂直翻转，模型训练时的数据增强操作。
### 参数
* **prob** (float): 随机垂直翻转的概率。默认为0.5。
## Normalize类
```python
paddlex.cls.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
```
对图像进行标准化。
1. 对图像进行归一化到区间[0.0, 1.0]。
2. 对图像进行减均值除以标准差操作。
### 参数
* **mean** (list): 图像数据集的均值。默认为[0.485, 0.456, 0.406]。
* **std** (list): 图像数据集的标准差。默认为[0.229, 0.224, 0.225]。
## ResizeByShort类
```python
paddlex.cls.transforms.ResizeByShort(short_size=256, max_size=-1)
```
根据图像的短边调整图像大小（resize）。
1. 获取图像的长边和短边长度。
2. 根据短边与short_size的比例，计算长边的目标长度，此时高、宽的resize比例为short_size/原图短边长度。
3. 如果max_size>0，调整resize比例：
如果长边的目标长度>max_size，则高、宽的resize比例为max_size/原图长边长度。
4. 根据调整大小的比例对图像进行resize。
### 参数
* **short_size** (int): 调整大小后的图像目标短边长度。默认为256。
* **max_size** (int): 长边目标长度的最大限制。默认为-1。
## CenterCrop类
```python
paddlex.cls.transforms.CenterCrop(crop_size=224)
```
以图像中心点扩散裁剪长宽为`crop_size`的正方形
1. 计算剪裁的起始点。
2. 剪裁图像。
### 参数
* **crop_size** (int): 裁剪的目标边长。默认为224。
## RandomRotate类
```python
paddlex.cls.transforms.RandomRotate(rotate_range=30, prob=0.5)
```
以一定的概率对图像在[-rotate_range, rotaterange]角度范围内进行旋转，模型训练时的数据增强操作。
### 参数
* **rotate_range** (int): 旋转度数的范围。默认为30。
* **prob** (float): 随机旋转的概率。默认为0.5。
## RandomDistort类
```python
paddlex.cls.transforms.RandomDistort(brightness_range=0.9, brightness_prob=0.5, contrast_range=0.9, contrast_prob=0.5, saturation_range=0.9, saturation_prob=0.5, hue_range=18, hue_prob=0.5)
```
以一定的概率对图像进行随机像素内容变换，模型训练时的数据增强操作。
1. 对变换的操作顺序进行随机化操作。
2. 按照1中的顺序以一定的概率对图像在范围[-range, range]内进行随机像素内容变换。
### 参数
* **brightness_range** (float): 明亮度因子的范围。默认为0.9。
* **brightness_prob** (float): 随机调整明亮度的概率。默认为0.5。
* **contrast_range** (float): 对比度因子的范围。默认为0.9。
* **contrast_prob** (float): 随机调整对比度的概率。默认为0.5。
* **saturation_range** (float): 饱和度因子的范围。默认为0.9。
* **saturation_prob** (float): 随机调整饱和度的概率。默认为0.5。
* **hue_range** (int): 色调因子的范围。默认为18。
* **hue_prob** (float): 随机调整色调的概率。默认为0.5。
docs/apis/transforms/det_transforms.md 0 → 100644
浏览文件 @ 8c6de1cb
# 检测-paddlex.det.transforms
对目标检测任务的数据进行操作。可以利用[Compose](#compose)类将图像预处理/增强操作进行组合。
## Compose类
```python
paddlex.det.transforms.Compose(transforms)
```
根据数据预处理/增强算子对输入数据进行操作。[使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/yolov3_mobilenetv1.py#L13)
### 参数
* **transforms** (list): 数据预处理/数据增强列表。
## ResizeByShort类
```python
paddlex.det.transforms.ResizeByShort(short_size=800, max_size=1333)
```
根据图像的短边调整图像大小（resize）。
1. 获取图像的长边和短边长度。
2. 根据短边与short_size的比例，计算长边的目标长度，此时高、宽的resize比例为short_size/原图短边长度。
3. 如果max_size>0，调整resize比例：
如果长边的目标长度>max_size，则高、宽的resize比例为max_size/原图长边长度。
4. 根据调整大小的比例对图像进行resize。
### 参数
* **short_size** (int): 短边目标长度。默认为800。
* **max_size** (int): 长边目标长度的最大限制。默认为1333。
## Padding类
```python
paddlex.det.transforms.Padding(coarsest_stride=1)
```
将图像的长和宽padding至coarsest_stride的倍数。如输入图像为[300, 640], `coarest_stride`为32，则由于300不为32的倍数，因此在图像最右和最下使用0值进行padding，最终输出图像为[320, 640]
1. 如果coarsest_stride为1则直接返回。
2. 计算宽和高与最邻近的coarest_stride倍数差值
3. 根据计算得到的差值，在图像最右和最下进行padding
### 参数
* **coarsest_stride** (int): 填充后的图像长、宽为该参数的倍数，默认为1。
## Resize类
```python
paddlex.det.transforms.Resize(target_size=608, interp='LINEAR')
```
调整图像大小（resize）。
* 当目标大小（target_size）类型为int时，根据插值方式，将图像resize为[target_size, target_size]。
* 当目标大小（target_size）类型为list或tuple时，根据插值方式，将图像resize为target_size。
【注意】当插值方式为“RANDOM”时，则随机选取一种插值方式进行resize，作为模型训练时的数据增强操作。
### 参数
* **target_size** (int/list/tuple): 短边目标长度。默认为608。
* **interp** (str): resize的插值方式，与opencv的插值方式对应，取值范围为['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM']。默认为"LINEAR"。
## RandomHorizontalFlip类
```python
paddlex.det.transforms.RandomHorizontalFlip(prob=0.5)
```
以一定的概率对图像进行随机水平翻转，模型训练时的数据增强操作。
### 参数
* **prob** (float): 随机水平翻转的概率。默认为0.5。
## Normalize类
```python
paddlex.det.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
```
对图像进行标准化。
1. 归一化图像到到区间[0.0, 1.0]。
2. 对图像进行减均值除以标准差操作。
### 参数
* **mean** (list): 图像数据集的均值。默认为[0.485, 0.456, 0.406]。
* **std** (list): 图像数据集的标准差。默认为[0.229, 0.224, 0.225]。
## RandomDistort类
```python
paddlex.det.transforms.RandomDistort(brightness_range=0.5, brightness_prob=0.5, contrast_range=0.5, contrast_prob=0.5, saturation_range=0.5, saturation_prob=0.5, hue_range=18, hue_prob=0.5)
```
以一定的概率对图像进行随机像素内容变换，模型训练时的数据增强操作。
1. 对变换的操作顺序进行随机化操作。
2. 按照1中的顺序以一定的概率对图像在范围[-range, range]内进行随机像素内容变换。
### 参数
* **brightness_range** (float): 明亮度因子的范围。默认为0.5。
* **brightness_prob** (float): 随机调整明亮度的概率。默认为0.5。
* **contrast_range** (float): 对比度因子的范围。默认为0.5。
* **contrast_prob** (float): 随机调整对比度的概率。默认为0.5。
* **saturation_range** (float): 饱和度因子的范围。默认为0.5。
* **saturation_prob** (float): 随机调整饱和度的概率。默认为0.5。
* **hue_range** (int): 色调因子的范围。默认为18。
* **hue_prob** (float): 随机调整色调的概率。默认为0.5。
## MixupImage类
```python
paddlex.det.transforms.MixupImage(alpha=1.5, beta=1.5, mixup_epoch=-1)
```
对图像进行mixup操作，模型训练时的数据增强操作，目前仅YOLOv3模型支持该transform。
当label_info中不存在mixup字段时，直接返回，否则进行下述操作：
1. 从随机beta分布中抽取出随机因子factor。
2. 根据不同情况进行处理：
* 当factor>=1.0时，去除label_info中的mixup字段，直接返回。
* 当factor<=0.0时，直接返回label_info中的mixup字段，并在label_info中去除该字段。
* 其余情况，执行下述操作：
（1）原图像乘以factor，mixup图像乘以(1-factor)，叠加2个结果。
（2）拼接原图像标注框和mixup图像标注框。
（3）拼接原图像标注框类别和mixup图像标注框类别。
（4）原图像标注框混合得分乘以factor，mixup图像标注框混合得分乘以(1-factor)，叠加2个结果。
3. 更新im_info中的augment_shape信息。
### 参数
* **alpha** (float): 随机beta分布的下限。默认为1.5。
* **beta** (float): 随机beta分布的上限。默认为1.5。
* **mixup_epoch** (int): 在前mixup_epoch轮使用mixup增强操作；当该参数为-1时，该策略不会生效。默认为-1。
## RandomExpand类
```python
paddlex.det.transforms.RandomExpand(max_ratio=4., prob=0.5, mean=[127.5, 127.5, 127.5])
```
随机扩张图像，模型训练时的数据增强操作，模型训练时的数据增强操作。
1. 随机选取扩张比例（扩张比例大于1时才进行扩张）。
2. 计算扩张后图像大小。
3. 初始化像素值为数据集均值的图像，并将原图像随机粘贴于该图像上。
4. 根据原图像粘贴位置换算出扩张后真实标注框的位置坐标。
### 参数
* **max_ratio** (float): 图像扩张的最大比例。默认为4.0。
* **prob** (float): 随机扩张的概率。默认为0.5。
* **mean** (list): 图像数据集的均值（0-255）。默认为[127.5, 127.5, 127.5]。
## RandomCrop类
```python
paddlex.det.transforms.RandomCrop(batch_sampler=None, satisfy_all=False, avoid_no_bbox=True)
```
随机裁剪图像，模型训练时的数据增强操作。
1. 根据batch_sampler计算获取裁剪候选区域的位置。
(1) 根据min scale、max scale、min aspect ratio、max aspect ratio计算随机剪裁的高、宽。
(2) 根据随机剪裁的高、宽随机选取剪裁的起始点。
(3) 筛选出裁剪候选区域：
* 当satisfy_all为True时，需所有真实标注框与裁剪候选区域的重叠度满足需求时，该裁剪候选区域才可保留。
* 当satisfy_all为False时，当有一个真实标注框与裁剪候选区域的重叠度满足需求时，该裁剪候选区域就可保留。
2. 遍历所有裁剪候选区域：
(1) 若真实标注框与候选裁剪区域不重叠，或其中心点不在候选裁剪区域，则将该真实标注框去除。
(2) 计算相对于该候选裁剪区域，真实标注框的位置，并筛选出对应的类别、混合得分。
(3) 若avoid_no_bbox为False，返回当前裁剪后的信息即可；反之，要找到一个裁剪区域中真实标注框个数不为0的区域，才返回裁剪后的信息。
### 参数
* **batch_sampler** (list): 随机裁剪参数的多种组合，每种组合包含8个值，如下：
- max sample (int)：满足当前组合的裁剪区域的个数上限。
- max trial (int): 查找满足当前组合的次数。
- min scale (float): 裁剪面积相对原面积，每条边缩短比例的最小限制。
- max scale (float): 裁剪面积相对原面积，每条边缩短比例的最大限制。
- min aspect ratio (float): 裁剪后短边缩放比例的最小限制。
- max aspect ratio (float): 裁剪后短边缩放比例的最大限制。
- min overlap (float): 真实标注框与裁剪图像重叠面积的最小限制。
- max overlap (float): 真实标注框与裁剪图像重叠面积的最大限制。
默认值为None，当为None时采用如下设置：
[[1, 1, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0],
[1, 50, 0.3, 1.0, 0.5, 2.0, 0.1, 1.0],
[1, 50, 0.3, 1.0, 0.5, 2.0, 0.3, 1.0],
[1, 50, 0.3, 1.0, 0.5, 2.0, 0.5, 1.0],
[1, 50, 0.3, 1.0, 0.5, 2.0, 0.7, 1.0],
[1, 50, 0.3, 1.0, 0.5, 2.0, 0.9, 1.0],
[1, 50, 0.3, 1.0, 0.5, 2.0, 0.0, 1.0]]
* **satisfy_all** (bool): 是否需要所有标注框满足条件，裁剪候选区域才保留。默认为False。
* **avoid_no_bbox** (bool)： 是否对裁剪图像不存在标注框的图像进行保留。默认为True。
docs/apis/transforms/index.rst 0 → 100644
浏览文件 @ 8c6de1cb
数据处理-transforms
============================
transforms为PaddleX的模型训练提供了数据的预处理和数据增强接口。
.. toctree::
:maxdepth: 1
cls_transforms.md
det_transforms.md
seg_transforms.md
docs/apis/transforms/seg_transforms.md 0 → 100644
浏览文件 @ 8c6de1cb
# 分割-paddlex.seg.transforms
对用于分割任务的数据进行操作。可以利用[Compose](#compose)类将图像预处理/增强操作进行组合。
## Compose类
```python
paddlex.seg.transforms.Compose(transforms)
```
根据数据预处理/数据增强列表对输入数据进行操作。[使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/segmentation/unet.py#L13)
### 参数
* **transforms** (list): 数据预处理/数据增强列表。
## RandomHorizontalFlip类
```python
paddlex.seg.transforms.RandomHorizontalFlip(prob=0.5)
```
以一定的概率对图像进行水平翻转,模型训练时的数据增强操作。
### 参数
* **prob** (float): 随机水平翻转的概率。默认值为0.5。
## RandomVerticalFlip类
```python
paddlex.seg.transforms.RandomVerticalFlip(prob=0.1)
```
以一定的概率对图像进行垂直翻转,模型训练时的数据增强操作。
### 参数
* **prob** (float): 随机垂直翻转的概率。默认值为0.1。
## Resize类
```python
paddlex.seg.transforms.Resize(target_size, interp='LINEAR')
```
调整图像大小（resize）。
- 当目标大小（target_size）类型为int时，根据插值方式，
将图像resize为[target_size, target_size]。
- 当目标大小（target_size）类型为list或tuple时，根据插值方式，
将图像resize为target_size, target_size的输入应为[w, h]或（w, h）。
### 参数
* **target_size** (int|list|tuple): 目标大小
* **interp** (str): resize的插值方式，与opencv的插值方式对应，
可选的值为['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4']，默认为"LINEAR"。
## ResizeByLong类
```python
paddlex.seg.transforms.ResizeByLong(long_size)
```
对图像长边resize到固定值，短边按比例进行缩放。
### 参数
* **long_size** (int): resize后图像的长边大小。
## ResizeRangeScaling类
```python
paddlex.seg.transforms.ResizeRangeScaling(min_value=400, max_value=600)
```
对图像长边随机resize到指定范围内，短边按比例进行缩放,模型训练时的数据增强操作。
### 参数
* **min_value** (int): 图像长边resize后的最小值。默认值400。
* **max_value** (int): 图像长边resize后的最大值。默认值600。
## ResizeStepScaling类
```python
paddlex.seg.transforms.ResizeStepScaling(min_scale_factor=0.75, max_scale_factor=1.25, scale_step_size=0.25)
```
对图像按照某一个比例resize，这个比例以scale_step_size为步长，在[min_scale_factor, max_scale_factor]随机变动,模型训练时的数据增强操作。
### 参数
* **min_scale_factor**（float), resize最小尺度。默认值0.75。
* **max_scale_factor** (float), resize最大尺度。默认值1.25。
* **scale_step_size** (float), resize尺度范围间隔。默认值0.25。
## Normalize类
```python
paddlex.seg.transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
```
对图像进行标准化。
1.图像像素归一化到区间 [0.0, 1.0]。
2.对图像进行减均值除以标准差操作。
### 参数
* **mean** (list): 图像数据集的均值。默认值[0.5, 0.5, 0.5]。
* **std** (list): 图像数据集的标准差。默认值[0.5, 0.5, 0.5]。
## Padding类
```python
paddlex.seg.transforms.Padding(target_size, im_padding_value=[127.5, 127.5, 127.5], label_padding_value=255)
```
对图像或标注图像进行padding，padding方向为右和下。根据提供的值对图像或标注图像进行padding操作。
### 参数
* **target_size** (int|list|tuple): padding后图像的大小。
* **im_padding_value** (list): 图像padding的值。默认为[127.5, 127.5, 127.5]。
* **label_padding_value** (int): 标注图像padding的值。默认值为255（仅在训练时需要设定该参数）。
## RandomPaddingCrop类
```python
paddlex.seg.transforms.RandomPaddingCrop(crop_size=512, im_padding_value=[127.5, 127.5, 127.5], label_padding_value=255)
```
对图像和标注图进行随机裁剪，当所需要的裁剪尺寸大于原图时，则进行padding操作，模型训练时的数据增强操作。
### 参数
* **crop_size**（int|list|tuple): 裁剪图像大小。默认为512。
* **im_padding_value** (list): 图像padding的值。默认为[127.5, 127.5, 127.5]。
* **label_padding_value** (int): 标注图像padding的值。默认值为255。
## RandomBlur类
```python
paddlex.seg.transforms.RandomBlur(prob=0.1)
```
以一定的概率对图像进行高斯模糊，模型训练时的数据增强操作。
### 参数
* **prob** (float): 图像模糊概率。默认为0.1。
## RandomRotation类
```python
paddlex.seg.transforms.RandomRotate(rotate_range=15, im_padding_value=[127.5, 127.5, 127.5], label_padding_value=255)
```
对图像进行随机旋转, 模型训练时的数据增强操作。
在旋转区间[-rotate_range, rotate_range]内，对图像进行随机旋转，当存在标注图像时，同步进行，
并对旋转后的图像和标注图像进行相应的padding。
### 参数
* **rotate_range** (float): 最大旋转角度。默认为15度。
* **im_padding_value** (list): 图像padding的值。默认为[127.5, 127.5, 127.5]。
* **label_padding_value** (int): 标注图像padding的值。默认为255。
## RandomScaleAspect类
```python
paddlex.seg.transforms.RandomScaleAspect(min_scale=0.5, aspect_ratio=0.33)
```
裁剪并resize回原始尺寸的图像和标注图像,模型训练时的数据增强操作。
按照一定的面积比和宽高比对图像进行裁剪，并reszie回原始图像的图像，当存在标注图时，同步进行。
### 参数
* **min_scale** (float)：裁取图像占原始图像的面积比，取值[0，1]，为0时则返回原图。默认为0.5。
* **aspect_ratio** (float): 裁取图像的宽高比范围，非负值，为0时返回原图。默认为0.33。
## RandomDistort类
```python
paddlex.seg.transforms.RandomDistort(brightness_range=0.5, brightness_prob=0.5, contrast_range=0.5, contrast_prob=0.5, saturation_range=0.5, saturation_prob=0.5, hue_range=18, hue_prob=0.5)
```
以一定的概率对图像进行随机像素内容变换，模型训练时的数据增强操作。
1.对变换的操作顺序进行随机化操作。
2.按照1中的顺序以一定的概率对图像在范围[-range, range]内进行随机像素内容变换。
### 参数
* **brightness_range** (float): 明亮度因子的范围。默认为0.5。
* **brightness_prob** (float): 随机调整明亮度的概率。默认为0.5。
* **contrast_range** (float): 对比度因子的范围。默认为0.5。
* **contrast_prob** (float): 随机调整对比度的概率。默认为0.5。
* **saturation_range** (float): 饱和度因子的范围。默认为0.5。
* **saturation_prob** (float): 随机调整饱和度的概率。默认为0.5。
* **hue_range** (int): 色调因子的范围。默认为18。
* **hue_prob** (float): 随机调整色调的概率。默认为0.5。
docs/apis/visualize.md 0 → 100644
浏览文件 @ 8c6de1cb
# 可视化-visualize
PaddleX提供了一系列模型预测和结果分析的可视化函数。
## 目标检测/实例分割预测结果可视化
```
paddlex.det.visualize(image, result, threshold=0.5, save_dir=None)
```
将目标检测/实例分割模型预测得到的Box框和Mask在原图上进行可视化
### 参数
> * **image** (str): 原图文件路径。
> * **result** (str): 模型预测结果。
> * **threshold**(float): score阈值，将Box置信度低于该阈值的框过滤不进行可视化。默认0.5
> * **save_dir**(str): 可视化结果保存路径。若为None，则表示不保存，该函数将可视化的结果以np.ndarray的形式返回；若设为目录路径，则将可视化结果保存至该目录下
### 使用示例
> 点击下载如下示例中的[模型](https://bj.bcebos.com/paddlex/models/garbage_epoch_12.tar.gz)和[测试图片](https://bj.bcebos.com/paddlex/datasets/garbage.bmp)
```
import paddlex as pdx
model = pdx.load_model('garbage_epoch_12')
result = model.predict('garbage.bmp')
pdx.det.visualize('garbage.bmp', result, save_dir='./')
# 预测结果保存在./visualize_garbage.bmp
```
## 语义分割预测结果可视化
```
paddlex.seg.visualize(image, result, weight=0.6, save_dir=None)
```
将语义分割模型预测得到的Mask在原图上进行可视化
### 参数
> * **image** (str): 原图文件路径。
> * **result** (str): 模型预测结果。
> * **weight**(float): mask可视化结果与原图权重因子，weight表示原图的权重。默认0.6
> * **save_dir**(str): 可视化结果保存路径。若为None，则表示不保存，该函数将可视化的结果以np.ndarray的形式返回；若设为目录路径，则将可视化结果保存至该目录下
### 使用示例
> 点击下载如下示例中的[模型](https://bj.bcebos.com/paddlex/models/cityscape_deeplab.tar.gz)和[测试图片](https://bj.bcebos.com/paddlex/datasets/city.png)
```
import paddlex as pdx
model = pdx.load_model('cityscape_deeplab')
result = model.predict('city.png')
pdx.det.visualize('city.png', result, save_dir='./')
# 预测结果保存在./visualize_city.png
```
## 模型裁剪比例可视化分析
```
paddlex.slim.visualize(model, sensitivities_file)
```
利用此接口，可以分析在不同的`eval_metric_loss`参数下，模型被裁剪的比例情况。可视化结果纵轴为eval_metric_loss参数值，横轴为对应的模型被裁剪的比例
### 参数
>* **model**: 使用PaddleX加载的模型
>* **sensitivities_file**: 模型各参数在验证集上计算得到的参数敏感度信息文件
### 使用示例
> 点击下载示例中的[模型](https://bj.bcebos.com/paddlex/models/vegetables_mobilenet.tar.gz)和[sensitivities_file](https://bj.bcebos.com/paddlex/slim_prune/mobilenetv2.sensitivities)
```
import paddlex as pdx
model = pdx.load_model('vegetables_mobilenet')
pdx.slim.visualize(model, 'mobilenetv2.sensitivities', save_dir='./')
# 可视化结果保存在./sensitivities.png
```
docs/conf.py 0 → 100644
浏览文件 @ 8c6de1cb
# 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 recommonmark
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# -- Project information -----------------------------------------------------
project = 'PaddleX'
copyright = '2020, paddlepaddle'
author = 'paddlepaddle'
# -- 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.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.napoleon',
'sphinx.ext.coverage',
'sphinx.ext.viewcode',
'sphinx.ext.mathjax',
'sphinx.ext.githubpages',
'sphinx.ext.napoleon',
'recommonmark',
'sphinx_markdown_tables',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# md file can also be parased
source_suffix = ['.rst', '.md']
# The master toctree document.
master_doc = 'index'
# 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'
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
# on_rtd is whether we are on readthedocs.org, this line of code grabbed from docs.readthedocs.org
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if not on_rtd: # only import and set the theme if we're building docs locally
import sphinx_rtd_theme
html_theme = 'sphinx_rtd_theme'
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
# otherwise, readthedocs.org uses their theme by default, so no need to specify it
# 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']
html_logo = 'images/paddlex.jpg'
docs/convertor.md 0 → 100644
浏览文件 @ 8c6de1cb
# 模型转换
## 转ONNX模型
PaddleX基于[Paddle2ONNX工具](https://github.com/PaddlePaddle/paddle2onnx)，提供了便捷的API，支持用户将PaddleX训练保存的模型导出为ONNX模型。
通过如下示例代码，用户即可将PaddleX训练好的MobileNetV2模型导出
```
import paddlex as pdx
pdx.convertor.to_onnx(model_dir='paddle_mobilenet', save_dir='onnx_mobilenet')
```
## 转PaddleLite模型
PaddleX可支持导出为[PaddleLite](https://github.com/PaddlePaddle/Paddle-Lite)支持的模型格式，用于支持用户将模型部署更多硬件设备。
通过如下示例代码，用户即可将PaddleX训练好的MobileNetV2模型导出
```
import paddlex as pdx
pdx.convertor.to_lite(model_dir='paddle_mobilenet', save_dir='lite_mobilnet', terminal='arm')
```
docs/datasets.md 0 → 100644
浏览文件 @ 8c6de1cb
# 数据集格式说明
---
## 图像分类ImageNet
图像分类ImageNet数据集包含对应多个标签的图像文件夹、标签文件及图像列表文件。
参考数据文件结构如下：
```
./dataset/ # 数据集根目录
|--labelA # 标签为labelA的图像目录
| |--a1.jpg
| |--...
| └--...
|
|--...
|
|--labelZ # 标签为labelZ的图像目录
| |--z1.jpg
| |--...
| └--...
|
|--train_list.txt # 训练文件列表文件
|
|--val_list.txt # 验证文件列表文件
|
└--labels.txt # 标签列表文件
```
其中，相应的文件名可根据需要自行定义。
`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为图像文件对应的标签id(从0开始)。如下所示：
```
labelA/a1.jpg 0
labelZ/z1.jpg 25
...
```
`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
```
labelA
labelB
...
```
[点击这里](https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz)，下载蔬菜分类分类数据集
在PaddleX中，使用`paddlex.cv.datasets.ImageNet`([API说明](./apis/datasets.html#imagenet))加载分类数据集
## 目标检测VOC
目标检测VOC数据集包含图像文件夹、标注信息文件夹、标签文件及图像列表文件。
参考数据文件结构如下：
```
./dataset/ # 数据集根目录
|--JPEGImages # 图像目录
| |--xxx1.jpg
| |--...
| └--...
|
|--Annotations # 标注信息目录
| |--xxx1.xml
| |--...
| └--...
|
|--train_list.txt # 训练文件列表文件
|
|--val_list.txt # 验证文件列表文件
|
└--labels.txt # 标签列表文件
```
其中，相应的文件名可根据需要自行定义。
`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为标注文件相对于dataset的相对路径。如下所示：
```
JPEGImages/xxx1.jpg Annotations/xxx1.xml
JPEGImages/xxx2.jpg Annotations/xxx2.xml
...
```
`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
```
labelA
labelB
...
```
[点击这里](https://bj.bcebos.com/paddlex/datasets/insect_det.tar.gz)，下载昆虫检测数据集
在PaddleX中，使用`paddlex.cv.datasets.VOCDetection`([API说明](./apis/datasets.html#vocdetection))加载目标检测VOC数据集
## 目标检测和实例分割COCO
目标检测和实例分割COCO数据集包含图像文件夹及图像标注信息文件。
参考数据文件结构如下：
```
./dataset/ # 数据集根目录
|--JPEGImages # 图像目录
| |--xxx1.jpg
| |--...
| └--...
|
|--train.json # 训练相关信息文件
|
└--val.json # 验证相关信息文件
```
其中，相应的文件名可根据需要自行定义。
`train.json`和`val.json`存储与标注信息、图像文件相关的信息。如下所示：
```
{
"annotations": [
{
"iscrowd": 0,
"category_id": 1,
"id": 1,
"area": 33672.0,
"image_id": 1,
"bbox": [232, 32, 138, 244],
"segmentation": [[32, 168, 365, 117, ...]]
},
...
],
"images": [
{
"file_name": "xxx1.jpg",
"height": 512,
"id": 267,
"width": 612
},
...
]
"categories": [
{
"name": "labelA",
"id": 1,
"supercategory": "component"
}
]
}
```
每个字段的含义如下所示：
| 域名 | 字段名 | 含义 | 数据类型 | 备注 |
|:-----|:--------|:------------|------|:-----|
| annotations | id | 标注信息id | int | 从1开始 |
| annotations | iscrowd | 标注框是否为一组对象 | int | 只有0、1两种取值 |
| annotations | category_id | 标注框类别id | int | |
| annotations | area | 标注框的面积 | float | |
| annotations | image_id | 当前标注信息所在图像的id | int | |
| annotations | bbox | 标注框坐标 | list | 长度为4，分别代表x,y,w,h |
| annotations | segmentation | 标注区域坐标 | list | list中有至少1个list，每个list由每个小区域坐标点的横纵坐标(x,y)组成 |
| images | id | 图像id | int | 从1开始 |
| images | file_name | 图像文件名 | str | |
| images | height | 图像高度 | int | |
| images | width | 图像宽度 | int | |
| categories | id | 类别id | int | 从1开始 |
| categories | name | 类别标签名 | str | |
| categories | supercategory | 类别父类的标签名 | str | |
[点击这里](https://bj.bcebos.com/paddlex/datasets/garbage_ins_det.tar.gz)，下载垃圾实例分割数据集
在PaddleX中，使用`paddlex.cv.datasets.COCODetection`([API说明](./apis/datasets.html#cocodetection))加载COCO格式数据集
## 语义分割数据
语义分割数据集包含原图、标注图及相应的文件列表文件。
参考数据文件结构如下：
```
./dataset/ # 数据集根目录
|--images # 原图目录
| |--xxx1.png
| |--...
| └--...
|
|--annotations # 标注图目录
| |--xxx1.png
| |--...
| └--...
|
|--train_list.txt # 训练文件列表文件
|
|--val_list.txt # 验证文件列表文件
|
└--labels.txt # 标签列表
```
其中，相应的文件名可根据需要自行定义。
`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为标注图像文件相对于dataset的相对路径。如下所示：
```
images/xxx1.png annotations/xxx1.png
images/xxx2.png annotations/xxx2.png
...
```
`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
```
labelA
labelB
...
```
标注图像为单通道图像，像素值即为对应的类别,像素标注类别需要从0开始递增，
例如0，1，2，3表示有4种类别，标注类别最多为256类。其中可以指定特定的像素值用于表示该值的像素不参与训练和评估（默认为255）。
[点击这里](https://bj.bcebos.com/paddlex/datasets/optic_disc_seg.tar.gz)，下载视盘语义分割数据集
在PaddleX中，使用`paddlex.cv.datasets.SegReader`([API说明](./apis/datasets.html#segreader))加载语义分割数据集
docs/deploy.md 0 → 100644
浏览文件 @ 8c6de1cb
# 模型预测部署
本文档指引用户如何采用更高性能地方式来部署使用PaddleX训练的模型。使用本文档模型部署方式，会在模型运算过程中，对模型计算图进行优化，同时减少内存操作，相对比普通的paddlepaddle模型加载和预测方式，预测速度平均可提升1倍，具体各模型性能对比见[预测性能对比](#预测性能对比)
## 服务端部署
### 导出inference模型
在服务端部署的模型需要首先将模型导出为inference格式模型，导出的模型将包括`__model__`、`__params__`和`model.yml`三个文名，分别为模型的网络结构，模型权重和模型的配置文件（包括数据预处理参数等等）。在安装完PaddleX后，在命令行终端使用如下命令导出模型到当前目录`inferece_model`下。
> 可直接下载垃圾检测模型测试本文档的流程[garbage_epoch_12.tar.gz](https://bj.bcebos.com/paddlex/models/garbage_epoch_12.tar.gz)
```
paddlex --export_inference --model_dir=./garbage_epoch_12 --save_dir=./inference_model
```
### Python部署
PaddleX已经集成了基于Python的高性能预测接口，在安装PaddleX后，可参照如下代码示例，进行预测。相关的接口文档可参考[paddlex.deploy](apis/deploy.md)
> 点击下载测试图片 [garbage.bmp](https://bj.bcebos.com/paddlex/datasets/garbage.bmp)
```
import paddlex as pdx
predictorpdx.deploy.create_predictor('./inference_model')
result = predictor.predict(image='garbage.bmp')
```
### C++部署
> C++部署方案正在整理中,即将开源...
### 预测性能对比
#### 测试环境
- CUDA 9.0
- CUDNN 7.5
- PaddlePaddle 1.71
- GPU: Tesla P40
- AnalysisPredictor 指采用Python的高性能预测方式
- Executor 指采用paddlepaddle普通的python预测方式
- Batch Size均为1，耗时单位为ms/image，只计算模型运行时间，不包括数据的预处理和后处理
| 模型 | AnalysisPredictor耗时 | Executor耗时 | 输入图像大小 |
| :---- | :--------------------- | :------------ | :------------ |
| resnet50 | 4.84 | 7.57 | 224*224 |
| mobilenet_v2 | 3.27 | 5.76 | 224*224 |
| unet | 22.51 | 34.60 |513*513 |
| deeplab_mobile | 63.44 | 358.31 |1025*2049 |
| yolo_mobilenetv2 | 15.20 | 19.54 | 608*608 |
| faster_rcnn_r50_fpn_1x | 50.05 | 69.58 |800*1088 |
| faster_rcnn_r50_1x | 326.11 | 347.22 | 800*1067 |
| mask_rcnn_r50_fpn_1x | 67.49 | 91.02 | 800*1088 |
| mask_rcnn_r50_1x | 326.11 | 350.94 | 800*1067 |
## 移动端部署
> Lite模型导出正在集成中，即将开源...
docs/gpu_configure.md 0 → 100644
浏览文件 @ 8c6de1cb
# 多卡GPU/CPU训练
## GPU卡数配置
PaddleX在训练过程中会优先选择**当前所有可用的GPU卡进行训练**，在评估时**分类和分割任务仍使用多张卡**而**检测任务只使用1张卡**进行计算，在预测时各任务**则只会使用1张卡进行计算**。
用户如想配置PaddleX在运行时使用的卡的数量，可在命令行终端（Shell）或Python代码中按如下方式配置：
命令行终端：
```
# 使用1号GPU卡
export CUDA_VISIBLE_DEVICES='1'
# 使用0, 1, 3号GPU卡
export CUDA_VISIBLE_DEVICES='0,1,3'
# 不使用GPU,仅使用CPU
export CUDA_VISIBLE_DEVICES=''
```
python代码：
```
# 注意：须要在第一次import paddlex或paddle前执行如下语句
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,3'
import paddlex as pdx
```
## 使用多个GPU卡训练
目前PaddlePaddle支持在Linux下使用多卡训练，Windows只支持单卡，在命令行终端输入`nvidia-smi`可以查看自己机器的GPU卡信息，如若提示命令未找到，则用户需要自行安装CUDA驱动。
PaddleX在多卡GPU下训练时，无需额外的配置，用户按照上文的方式，通过`CUDA_VISIBLE_DEVICES`环境变量配置所需要使用的卡的数量即可。
需要注意的是，在训练代码中，可根据卡的数量，调高`batch_size`和`learning_rate`等参数，GPU卡数量越多，则可以支持更高的`batch_size`(注意batch_size需能被卡的数量整除), 同时更高的`batch_size`也意味着学习率`learning_rate`也要对应上调。同理，在训练过程中，如若因显存或内存不够导致训练失败，用户也需自行调低`batch_size`，并且按比例调低学习率。
## CPU配置
PaddleX在训练过程中可以选择使用CPU进行训练、评估和预测。通过以下方式进行配置：
命令行终端：
```
export CUDA_VISIBLE_DEVICES=""
```
python代码：
```
# 注意：须要在第一次import paddlex或paddle前执行如下语句
import os
os.environ['CUDA_VISIBLE_DEVICES'] = ''
import paddlex as pdx
```
此时使用的CPU个数为1。
## 使用多个CPU训练
通过设置环境变量`CPU_NUM`可以改变CPU个数，如果未设置，则CPU数目默认设为1，即`CPU_NUM`=1。 在物理核心数量范围内，该参数的配置可以加速模型。
PaddleX在训练过程中会选择`CPU_NUM`个CPU进行训练，在评估时分类和分割任务仍使用`CPU_NUM`个CPU，而检测任务只使用1个CPU进行计算，在预测时各任务则只会使用1个CPU进行计算。
通过以下方式可设置CPU的个数：
命令行终端：
```
export CUDA_VISIBLE_DEVICES=""
export CPU_NUM=2
```
python代码：
```
# 注意：须要在第一次import paddlex或paddle前执行如下语句
import os
os.environ['CUDA_VISIBLE_DEVICES'] = ''
os.environ['CPU_NUM'] = '2'
import paddlex as pdx
```
docs/how_to_offline_run.md 0 → 100644
浏览文件 @ 8c6de1cb
# 无联网模型训练
PaddleX在模型训练时，存在以下两种情况需要进行联网下载
> 1.训练模型时，用户没有配置自定义的预训练模型权重`pretrain_weights`，此时PaddleX会自动联网下载在标准数据集上的预训练模型；
> 2.模型裁剪训练时，用户没有配置自定义的参数敏感度信息文件`sensitivities_file`，并将`sensitivities_file`配置成了'DEFAULT'字符串，此时PaddleX会自动联网下载模型在标准数据集上计算得到的参数敏感度信息文件。
## 如何在没联网的情况下进行模型训练
> 在训练模型时，不管是正常训练还是裁剪训练，用户可以提前准备好预训练权重或参数敏感度信息文档，只需自定义`pretrain_weights`或`sensitivities_file`， 将其设为本地的路径即可。
## 预训练模型下载地址
> 以下模型均为分类模型权重（UNet除外），用户在训练模型时，需要**根据分类模型的种类或backbone的种类**，选择对应的模型权重进行下载(目标检测在使用ResNet50作为Backbone时，使用下面表格中的ResNet50_cos作为预训练模型)
| 模型(点击下载) | 数据集 |
| :------------|:------|
| [ResNet18](https://paddle-imagenet-models-name.bj.bcebos.com/ResNet18_pretrained.tar) | ImageNet |
| [ResNet34](https://paddle-imagenet-models-name.bj.bcebos.com/ResNet34_pretrained.tar) | ImageNet |
| [ResNet50](http://paddle-imagenet-models-name.bj.bcebos.com/ResNet50_pretrained.tar) | ImageNet |
| [ResNet101](http://paddle-imagenet-models-name.bj.bcebos.com/ResNet101_pretrained.tar) | ImageNet |
| [ResNet50_vd](https://paddle-imagenet-models-name.bj.bcebos.com/ResNet50_vd_pretrained.tar) | ImageNet |
| [ResNet101_vd](https://paddle-imagenet-models-name.bj.bcebos.com/ResNet101_vd_pretrained.tar) | ImageNet |
| [MobileNetV1](http://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV1_pretrained.tar) | ImageNet |
| [MobileNetV2_x1.0](https://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV2_pretrained.tar) | ImageNet |
| [MobileNetV2_x0.5](https://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV2_x0_5_pretrained.tar) | ImageNet |
| [MobileNetV2_x2.0](https://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV2_x2_0_pretrained.tar) | ImageNet |
| [MobileNetV2_x0.25](https://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV2_x0_25_pretrained.tar) | ImageNet |
| [MobileNetV2_x1.5](https://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV2_x1_5_pretrained.tar) | ImageNet |
| [MobileNetV3_small](https://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV3_small_x1_0_pretrained.tar) | ImageNet |
| [MobileNetV3_large](https://paddle-imagenet-models-name.bj.bcebos.com/MobileNetV3_large_x1_0_pretrained.tar) | ImageNet |
| [DarkNet53](https://paddle-imagenet-models-name.bj.bcebos.com/DarkNet53_ImageNet1k_pretrained.tar) | ImageNet |
| [DenseNet121](https://paddle-imagenet-models-name.bj.bcebos.com/DenseNet121_pretrained.tar) | ImageNet |
| [DenseNet161](https://paddle-imagenet-models-name.bj.bcebos.com/DenseNet161_pretrained.tar) | ImageNet |
| [DenseNet201](https://paddle-imagenet-models-name.bj.bcebos.com/DenseNet201_pretrained.tar) | ImageNet |
| [ResNet50_cos](https://paddle-imagenet-models-name.bj.bcebos.com/ResNet50_cos_pretrained.tar) | ImageNet |
| [Xception41](https://paddle-imagenet-models-name.bj.bcebos.com/Xception41_deeplab_pretrained.tar) | ImageNet |
| [Xception65](https://paddle-imagenet-models-name.bj.bcebos.com/Xception65_deeplab_pretrained.tar) | ImageNet |
| [ShuffleNetV2](https://paddle-imagenet-models-name.bj.bcebos.com/ShuffleNetV2_pretrained.tar) | ImageNet |
| [UNet](https://paddleseg.bj.bcebos.com/models/unet_coco_v3.tgz) | MSCOCO |
docs/index.rst 0 → 100644
浏览文件 @ 8c6de1cb
欢迎使用PaddleX！
=======================================
PaddleX是基于飞桨技术生态的深度学习全流程开发工具。具备易集成，易使用，全流程等特点。PaddleX作为深度学习开发工具，不仅提供了开源的内核代码，可供用户灵活使用或集成，同时也提供了配套的前端可视化客户端套件，让用户以可视化地方式进行模型开发，相关细节可查阅PaddleX官网。
本文档为PaddleX内核代码使用手册
.. toctree::
:maxdepth: 1
:caption: 目录:
quick_start.md
install.md
model_zoo.md
slim/index
apis/index
datasets.md
gpu_configure.md
tutorials/index.rst
metrics.md
FAQ.md
* PaddleX版本: v0.1.0
* 项目官网: http://www.paddlepaddle.org.cn/paddlex
* 项目GitHub: https://github.com/PaddlePaddle/PaddleX/tree/develop
* 官方QQ用户群: 1045148026
* GitHub Issue反馈: http://www.github.com/PaddlePaddle/PaddleX/issues
docs/install.md 0 → 100644
浏览文件 @ 8c6de1cb
# 安装
> 以下安装过程默认用户已安装好Anaconda和CUDA 10.1（有GPU卡的情况下）， Anaconda的安装可参考其官网https://www.anaconda.com/
## Linux/Mac安装
```
# 使用conda创建虚拟环境
conda create -n paddlex python=3.7
conda activate paddlex
# 安装paddlepaddle
# cpu版: pip install paddlepaddle
pip install paddlepaddle-gpu
# 安装PaddleX
pip install paddlex
```
## Windows安装
```
# 使用conda创建虚拟环境
conda create -n paddlex python=3.7
conda activate paddlex
# 安装paddlepaddle
# cpu版: pip install paddlepaddle
pip install paddlepaddle-gpu
# 安装pycocotools
pip install git+https://github.com/philferriere/cocoapi.git#subdirectory=PythonAPI
# 安装PaddleX
pip install paddlex
```
docs/make.bat 0 → 100644
浏览文件 @ 8c6de1cb
@ECHO OFF
pushd %~dp0
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set SOURCEDIR=.
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.http://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/metrics.md 0 → 100644
浏览文件 @ 8c6de1cb
# 指标及日志含义
PaddleX在模型训练、评估过程中，都会有相应的日志和指标反馈，本文档用于说明这些日志和指标的含义。
## 训练通用统计信息
PaddleX所有模型在训练过程中，输出的日志信息都包含了6个通用的统计信息，用于辅助用户进行模型训练，例如**分割模型**的训练日志，如下图所示。
![](./images/seg_train.png)
各字段含义如下:
| 字段 | 字段值示例 | 含义 |
| -------------- | -------------------- | ------------------------------------------------------------ |
| Epoch | Epoch=4/20 | [迭代轮数]所有训练数据会被训练20轮，当前处于第4轮 |
| Step | Step=62/66 | [迭代步数]所有训练数据被训练一轮所需要的迭代步数为66，当前处于第62步 |
| loss | loss=0.007226 | [损失函数值]参与当前迭代步数的训练样本的平均损失函数值loss，loss值越低，表明模型在训练集上拟合的效果越好(如上日志中第1行表示第4个epoch的第62个Batch的loss值为0.007226) |
| lr | lr=0.008215 | [学习率]当前模型迭代过程中的学习率 |
| time_each_step | time_each_step=0.41s | [每步迭代时间]训练过程计算得到的每步迭代平均用时 |
| eta | eta=0:9:44 | [剩余时间]模型训练完成所需剩余时间预估为0小时9分钟44秒 |
| | | |
不同模型的日志中除了上述通用字段外，还有其它字段，这些字段含义可见文档后面对各任务模型的描述。
## 评估通用统计信息
PaddleX所有模型在训练过程中会根据用户设定的`save_interval_epochs`参数，每间隔一定轮数进行评估和保存。例如**分类模型**的评估日志，如下图所示。
![](images/cls_eval.png)
上图中第1行表明验证数据集中样本数为240，需要迭代8步才能评估完所有验证数据；第5行用于表明第2轮的模型已经完成保存操作；第6行则表明当前保存的模型中，第2轮的模型在验证集上指标最优（分类任务看`acc1`，此时`acc1`值为0.258333），最优模型会保存在`best_model`目录中。
## 分类特有统计信息
### 训练日志字段
分类任务的训练日志除了通用统计信息外，还包括`acc1`和`acc5`两个特有字段。
> 注： acck准确率是针对一张图片进行计算的：把模型在各个类别上的预测得分按从高往低进行排序，取出前k个预测类别，若这k个预测类别包含了真值类，则认为该图片分类正确。
![](images/cls_train.png)
上图中第1行中的`acc1`表示参与当前迭代步数的训练样本的平均top1准确率，值越高代表模型越优；`acc5`表示参与当前迭代步数的训练样本的平均top5（若类别数n少于5，则为topn）准确率，值越高代表模型越优。第4行中的`loss`表示整个训练集的平均损失函数值，`acc1`表示整个训练集的平均top1准确率，`acc5`表示整个训练集的平均top5准确率。
### 评估日志字段
![](images/cls_eval.png)
上图中第3行中的`acc1`表示整个验证集的平均top1准确率，`acc5`表示整个验证集的平均top5准确率。
## 检测特有统计信息
### 训练日志字段
#### YOLOv3
YOLOv3的训练日志只包括训练通用统计信息（见上文训练通用统计信息）。
![](images/yolo_train.png)
上图中第5行`loss`表示整个训练集的平均损失函数loss值。
#### FasterRCNN
FasterRCNN的训练日志除了通用统计信息外，还包括`loss_cls`、`loss_bbox`、`loss_rpn_cls`和`loss_rpn_bbox`，这些字段的含义如下:
| 字段 | 含义 |
| -------------- | --------------------------------------------- |
| loss_cls | RCNN子网络中分类损失函数值 |
| loss_bbox | RCNN子网络中检测框回归损失函数值 |
| loss_rpn_cls | RPN子网络中分类损失函数值 |
| loss_rpn_bbox | RPN子网络中检测框回归损失函数值 |
| loss | 所有子网络损失函数值之和 |
![](images/faster_train.png)
上图中第1行`loss`, `loss_cls`、`loss_bbox`、`loss_rpn_clss`、`loss_rpn_bbox`都是参与当前迭代步数的训练样本的损失值，而第7行是针整个训练集的损失函数值。
#### MaskRCNN
MaskRCNN的训练日志除了通用统计信息外，还包括`loss_cls`、`loss_bbox`、`loss_mask`、`loss_rpn_cls`和`loss_rpn_bbox`，这些字段的含义如下:
| 字段 | 含义 |
| -------------- | --------------------------------------------- |
| loss_cls | RCNN子网络中分类损失函数值 |
| loss_bbox | RCNN子网络中检测框回归损失函数值 |
| loss_mask | RCNN子网络中Mask回归损失函数值 |
| loss_rpn_cls | RPN子网络中分类损失函数值 |
| loss_rpn_bbox | RPN子网络中检测框回归损失函数值 |
| loss | 所有子网络损失函数值之和 |
![](images/mask_train.png)
上图中第1行`loss`, `loss_cls`、`loss_bbox`、`loss_mask`、`loss_rpn_clss`、`loss_rpn_bbox`都是参与当前迭代步数的训练样本的损失值，而第7行是针整个训练集的损失函数值。
### 评估日志字段
检测可以使用两种评估标准：VOC评估标准和COCO评估标准。
#### VOC评估标准
![](images/voc_eval.png)
> 注：`map`为平均准确率的平均值，即IoU(Intersection Over Union)取0.5时各个类别的准确率-召回率曲线下面积的平均值。
上图中第3行`bbox_map`表示检测任务中整个验证集的平均准确率平均值。
#### COCO评估标准
> 注：COCO评估指标可参见[COCO官网解释](http://cocodataset.org/#detection-eval)。PaddleX主要反馈`mmAP`，即AP at IoU=.50:.05:.95这项指标，为在各个IoU阈值下平均准确率平均值（mAP）的平均值。
COCO格式的数据集不仅可以用于训练目标检测模型，也可以用于训练实例分割模型。在目标检测中，PaddleX主要反馈针对检测框的`bbox_mmAP`指标；在实例分割中，还包括针对Mask的`seg_mmAP`指标。如下所示，第一张日志截图为目标检测的评估结果，第二张日志截图为实例分割的评估结果。
![](images/faster_eval.png)
上图中红框标注的`bbox_mmap`表示整个验证集的检测框平均准确率平均值。
![](images/mask_eval.png)
上图中红框标注的`bbox_mmap`和`seg_mmap`分别表示整个验证集的检测框平均准确率平均值、Mask平均准确率平均值。
## 分割特有统计信息
### 训练日志字段
语义分割的训练日志只包括训练通用统计信息（见上文训练通用统计信息）。
![](images/seg_train.png)
### 评估日志字段
语义分割的评估日志包括了`miou`、`category_iou`、`macc`、`category_acc`、`kappa`，这些字段的含义如下：
| 字段 | 含义 |
| -------------- | --------------------------------------------- |
| miou | 各类IoU(Intersection Over Union)的平均值 |
| category_iou | 各类别的IoU |
| macc | 平均准确率，即预测正确的像素数/总像素数 |
| category_acc | 各类别的准确率，即各类别预测正确的像素数/预测为该类别的总像素数 |
| kappa | kappa系数，用于一致性检验 |
![](images/seg_eval.png)
docs/model_zoo.md 0 → 100644
浏览文件 @ 8c6de1cb
# 模型库
本文档梳理了PaddleX v0.1.0支持的模型，同时也提供了在各个数据集上的预训练模型和对应验证集上的指标。用户也可自行下载对应的代码，在安装PaddleX后，即可使用相应代码训练模型。
表中相关模型也可下载好作为相应模型的预训练模型，通过`pretrain_weights`指定目录加载使用。
## 图像分类模型
> 表中模型相关指标均为在ImageNet数据集上使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla P4），预测速度为每张图片预测用时（不包括预处理和后处理）,表中符号`-`表示相关指标暂未测试。
| 模型 | 模型大小 | 预测速度（毫秒） | Top1准确率 | Top5准确率 |
| :----| :------- | :----------- | :--------- | :--------- |
| ResNet18| 46.9MB | 3.456 | 70.98% | 89.92% |
| ResNet34| 87.5MB | 5.668 | 74.57% | 92.14% |
| ResNet50| 102.7MB | 8.787 | 76.50% | 93.00% |
| ResNet101 |179.1MB | 15.447 | 77.56% | 93.64% |
| ResNet50_vd |102.8MB | 9.058 | 79.12% | 94.44% |
| ResNet101_vd| 179.2MB | 15.685 | 80.17% | 94.97% |
| DarkNet53|166.9MB | 11.969 | 78.04% | 94.05% |
| MobileNetV1 | 16.4MB | 2.609 | 70.99% | 89.68% |
| MobileNetV2 | 14.4MB | 4.546 | 72.15% | 90.65% |
| MobileNetV3_large| 22.8MB | - | 75.3% | 75.3% |
| MobileNetV3_small | 12.5MB | 6.809 | 67.46% | 87.12% |
| Xception41 |92.4MB | 13.757 | 79.30% | 94.53% |
| Xception65 | 144.6MB | 19.216 | 81.00% | 95.49% |
| Xception71| 151.9MB | 23.291 | 81.11% | 95.45% |
| DenseNet121 | 32.8MB | 12.437 | 75.66% | 92.58% |
| DenseNet161|116.3MB | 27.717 | 78.57% | 94.14% |
| DenseNet201| 84.6MB | 26.583 | 77.63% | 93.66% |
| ShuffleNetV2 | 10.2MB | 6.101 | 68.8% | 88.5% |
## 目标检测模型
> 表中模型相关指标均为在MSCOCO数据集上使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla V100测试得到,表中符号`-`表示相关指标暂未测试。
| 模型 | 模型大小 | 预测时间(毫秒) | BoxAP |
|:-------|:-----------|:-------------|:----------|
|FasterRCNN-ResNet50|135.6MB| 78.450 | 35.2 |
|FasterRCNN-ResNet50_vd| 135.7MB | 79.523 | 36.4 |
|FasterRCNN-ResNet101| 211.7MB | 107.342 | 38.3 |
|FasterRCNN-ResNet50-FPN| 167.2MB | 44.897 | 37.2 |
|FasterRCNN-ResNet50_vd-FPN|168.7MB | 45.773 | 38.9 |
|FasterRCNN-ResNet101-FPN| 251.7MB | 55.782 | 38.7 |
|FasterRCNN-ResNet101_vd-FPN |252MB | 58.785 | 40.5 |
|YOLOv3-DarkNet53|252.4MB | 21.944 | 38.9 |
|YOLOv3-MobileNetv1 |101.2MB | 12.771 | 29.3 |
|YOLOv3-MobileNetv3|94.6MB | - | 31.6 |
| YOLOv3-ResNet34|169.7MB | 15.784 | 36.2 |
## 实例分割模型
> 表中模型相关指标均为在MSCOCO数据集上测试得到。
| 模型 |模型大小 | 预测时间(毫秒) | BoxAP | SegAP |
|:---------|:---------|:----------|:---------|:--------|
|MaskRCNN-ResNet50|51.2MB| 86.096 | 36.5 |32.2|
|MaskRCNN-ResNet50-FPN|184.6MB | 65.859 | 37.9 |34.2|
|MaskRCNN-ResNet50_vd-FPN |185.5MB | 63.191 | 39.8 |35.4|
|MaskRCNN-ResNet101-FPN|268.6MB | 77.024 | 39.5 |35.2|
|MaskRCNN-ResNet101vd-FPN |268.6MB | 76.307 | 41.4 |36.8|
## 语义分割模型
> 表中符号`-`表示相关指标暂未测试。
| 模型| 模型大小 | 预测速度 | mIOU |
|:--------|:----------|:----------|:----------|
| UNet|53.7M | - |-|
| DeepLabv3+/Xception65| 165.1M |- | 0.7930 |
| DeepLabv3+/MobileNetV2 | 7.4M | - | 0.6981 |
docs/quick_start.md 0 → 100644
浏览文件 @ 8c6de1cb
# 10分钟快速上手使用
本文档在一个小数据集上展示了如何通过PaddleX进行训练，您可以阅读PaddleX的**使用教程**来了解更多模型任务的训练使用方式。
## 1. 准备蔬菜分类数据集
```
wget https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz
tar xzvf vegetables_cls.tar.gz
```
## 2. 训练代码开发
通过如下`train.py`代码进行训练
> 设置使用0号GPU卡
```
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
```
> 定义训练和验证时的数据处理流程, 在`train_transforms`中加入了`RandomCrop`和`RandomHorizontalFlip`两种数据增强方式
```
from paddlex.cls import transforms
train_transforms = transforms.Compose([
transforms.RandomCrop(crop_size=224),
transforms.RandomHorizontalFlip(),
transforms.Normalize()
])
eval_transforms = transforms.Compose([
transforms.ResizeByShort(short_size=256),
transforms.CenterCrop(crop_size=224),
transforms.Normalize()
])
```
> 定义数据集，`pdx.datasets.ImageNet`表示读取ImageNet格式的分类数据集
```
train_dataset = pdx.datasets.ImageNet(
data_dir='vegetables_cls',
file_list='vegetables_cls/train_list.txt',
label_list='vegetables_cls/labels.txt',
transforms=train_transforms,
shuffle=True)
eval_dataset = pdx.datasets.ImageNet(
data_dir='vegetables_cls',
file_list='vegetables_cls/train_list.txt',
label_list='vegetables_cls/labels.txt',
transforms=train_transforms)
```
> 模型训练
```
num_classes = len(train_dataset.labels)
model = pdx.cls.MobileNetV2(num_classes=num_classes)
model.train(num_epochs=10,
train_dataset=train_dataset,
train_batch_size=32,
eval_dataset=eval_dataset,
lr_decay_epochs=[4, 6, 8],
learning_rate=0.025,
save_dir='output/mobilenetv2',
use_vdl=True)
```
## 3. 模型训练
> `train.py`与解压后的数据集目录`vegetables_cls`放在同一目录下，在此目录下运行`train.py`即可开始训练。如果您的电脑上有GPU，这将会在10分钟内训练完成，如果为CPU也大概会在30分钟内训练完毕。
```
python train.py
```
## 4. 训练过程中查看训练指标
> 模型在训练过程中，所有的迭代信息将以标注输出流的形式，输出到命令执行的终端上，用户也可通过visualdl以可视化的方式查看训练指标的变化，通过如下方式启动visualdl后，在浏览器打开https://0.0.0.0:8001即可。
```
visualdl --logdir output/mobilenetv2/vdl_log --port 8000
```
![](./images/vdl1.jpg)
## 5. 训练完成使用模型进行测试
> 如使用训练过程中第8轮保存的模型进行测试
```
import paddlex as pdx
model = pdx.load_model('output/mobilenetv2/epoch_8')
result = model.predict('vegetables_cls/bocai/100.jpg', topk=3)
print("Predict Result:", result)
```
> 预测结果输出如下，预测按score进行排序，得到前三分类结果
```
Predict Result: Predict Result: [{'score': 0.9999393, 'category': 'bocai', 'category_id': 0}, {'score': 6.010089e-05, 'category': 'hongxiancai', 'category_id': 2}, {'score': 5.593914e-07, 'category': 'xilanhua', 'category_id': 5}]
```
## 其它推荐
- 1.[目标检测模型训练](tutorials/train/detection.md)
- 2.[语义分割模型训练](tutorials/train/segmentation.md)
- 3.[实例分割模型训练](tutorials/train/instance_segmentation.md)
- 3.[模型太大，想要更小的模型，试试模型裁剪吧!](tutorials/compress/classification.md)
docs/requirements.txt 0 → 100644
浏览文件 @ 8c6de1cb
sphinx
recommonmark
sphinx_markdown_tables
sphinx_rtd_theme
docs/slim/index.rst 0 → 100644
浏览文件 @ 8c6de1cb
模型压缩
============================
.. toctree::
:maxdepth: 2
prune.md
quant.md
docs/slim/prune.md 0 → 100644
浏览文件 @ 8c6de1cb
# 模型裁剪
## 原理介绍
模型裁剪用于减小模型的计算量和体积，可以加快模型部署后的预测速度，是一种减小模型大小和降低模型计算复杂度的常用方式，通过裁剪卷积层中Kernel输出通道的大小及其关联层参数大小来实现，其关联裁剪的原理可参见[PaddleSlim相关文档](https://paddlepaddle.github.io/PaddleSlim/algo/algo.html#id16)。**一般而言，在同等模型精度前提下，数据复杂度越低，模型可以被裁剪的比例就越高**。
## 裁剪方法
PaddleX提供了两种方式:
**1.用户自行计算裁剪配置(推荐)，整体流程包含三个步骤,**
> **第一步**： 使用数据集训练原始模型
> **第二步**：利用第一步训练好的模型，在验证数据集上计算模型中各个参数的敏感度，并将敏感度信息存储至本地文件
> **第三步**：使用数据集训练裁剪模型（与第一步差异在于需要在`train`接口中，将第二步计算得到的敏感信息文件传给接口的`sensitivities_file`参数）
> 在如上三个步骤中，**相当于模型共需要训练两遍**，分别对应第一步和第三步，但其中第三步训练的是裁剪后的模型，因此训练速度较第一步会更快。
> 第二步会遍历模型中的部分裁剪参数，分别计算各个参数裁剪后对于模型在验证集上效果的影响，**因此会反复在验证集上评估多次**。
**2.使用PaddleX内置的裁剪方案**
> PaddleX内置的模型裁剪方案是**基于标准数据集**上计算得到的参数敏感度信息，由于不同数据集特征分布会有较大差异，所以该方案相较于第1种方案训练得到的模型**精度一般而言会更低**（**且用户自定义数据集与标准数据集特征分布差异越大，导致训练的模型精度会越低**），仅在用户想节省时间的前提下可以参考使用，使用方式只需一步，
> **一步**： 使用数据集训练裁剪模型，在训练调用`train`接口时，将接口中的`sensitivities_file`参数设置为'DEFAULT'字符串
> 注：各模型内置的裁剪方案分别依据的数据集为： 图像分类——ImageNet数据集、目标检测——PascalVOC数据集、语义分割——CityScape数据集
## 裁剪实验
基于上述两种方案，我们在PaddleX上使用样例数据进行了实验，在Tesla P40上实验指标如下所示，
### 图像分类
实验背景：使用MobileNetV2模型，数据集为蔬菜分类示例数据，见[使用教程-模型压缩-图像分类](../tutorials/compress/classification.md)
| 模型 | 裁剪情况 | 模型大小 | Top1准确率(%) |GPU预测速度 | CPU预测速度 |
| :-----| :--------| :-------- | :---------- |:---------- |:----------|
|MobileNetV2 | 无裁剪（原模型）| 13.0M | 97.50|6.47ms |47.44ms |
|MobileNetV2 | 方案一(eval_metric_loss=0.10) | 2.1M | 99.58 |5.03ms |20.22ms |
|MobileNetV2 | 方案二(eval_metric_loss=0.10) | 6.0M | 99.58 |5.42ms |29.06ms |
### 目标检测
实验背景：使用YOLOv3-MobileNetV1模型，数据集为昆虫检测示例数据，见[使用教程-模型压缩-目标检测](../tutorials/compress/detection.md)
| 模型 | 裁剪情况 | 模型大小 | MAP(%) |GPU预测速度 | CPU预测速度 |
| :-----| :--------| :-------- | :---------- |:---------- | :---------|
|YOLOv3-MobileNetV1 | 无裁剪（原模型）| 139M | 67.57| 14.88ms |976.42ms |
|YOLOv3-MobileNetV1 | 方案一(eval_metric_loss=0.10) | 34M | 75.49 |10.60ms |558.49ms |
|YOLOv3-MobileNetV1 | 方案二(eval_metric_loss=0.05) | 29M | 50.27| 9.43ms |360.46ms |
### 语义分割
实验背景：使用UNet模型，数据集为视盘分割示例数据, 见[使用教程-模型压缩-语义分割](../tutorials/compress/segmentation.md)
| 模型 | 裁剪情况 | 模型大小 | mIOU(%) |GPU预测速度 | CPU预测速度 |
| :-----| :--------| :-------- | :---------- |:---------- | :---------|
|UNet | 无裁剪（原模型）| 77M | 91.22 |33.28ms |9523.55ms |
|UNet | 方案一(eval_metric_loss=0.10) |26M | 90.37 |21.04ms |3936.20ms |
|UNet | 方案二(eval_metric_loss=0.10) |23M | 91.21 |18.61ms |3447.75ms |
docs/slim/quant.md 0 → 100644
浏览文件 @ 8c6de1cb
# 模型量化
## 原理介绍
为了满足低内存带宽、低功耗、低计算资源占用以及低模型存储等需求，定点量化被提出。为此我们提供了训练后量化，该量化使用KL散度确定量化比例因子，将FP32模型转成INT8模型，且不需要重新训练，可以快速得到量化模型。
## 使用PaddleX量化模型
PaddleX提供了`export_quant_model`接口，让用户以接口的形式完成模型以post_quantization方式量化并导出。点击查看[量化接口使用文档](../apis/slim.md)。
## 量化性能对比
模型量化后的性能对比指标请查阅[PaddleSlim模型库](https://paddlepaddle.github.io/PaddleSlim/model_zoo.html)
docs/tutorials/README.md 0 → 100644
浏览文件 @ 8c6de1cb
# PaddleX使用教程
- [模型训练](./train)
- [模型裁剪](./compress)
docs/tutorials/compress/classification.md 0 → 100644
浏览文件 @ 8c6de1cb
# 分类模型裁剪
---
本文档训练代码可直接在PaddleX的Repo中下载，[代码tutorials/compress/classification](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/classification)
本文档按如下方式对模型进行了裁剪
> 第一步：在训练数据集上训练MobileNetV2
> 第二步：在验证数据集上计算模型中各个参数的敏感度信息
> 第三步：根据第二步计算的敏感度，设定`eval_metric_loss`，对模型裁剪后重新在训练数据集上训练
## 步骤一 训练MobileNetV2
> 模型训练使用文档可以直接参考[分类模型训练](../train/classification.md)，本文档在该代码基础上添加了部分参数选项，用户可直接下载模型训练代码[tutorials/compress/classification/mobilenetv2.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/classification/mobilenetv2.py)
> 使用如下命令开始模型训练
```
python mobilenetv2.py
```
## 步骤二 计算参数敏感度
> 参数敏感度的计算可以直接使用PaddleX提供的API`paddlex.slim.cal_params_sensitivities`，使用代码如下, 敏感度信息文件会保存至`save_file`
```
import os
# 选择使用0号卡
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
model_dir = './output/mobilenetv2/best_model'
model = pdx.load_model(model_dir)
# 定义验证所用的数据集
eval_dataset = pdx.datasets.ImageNet(
data_dir=dataset,
file_list=os.path.join(dataset, 'val_list.txt'),
label_list=os.path.join(dataset, 'labels.txt'),
transforms=model.eval_transforms)
pdx.slim.cal_params_sensitivities(model,
save_file,
eval_dataset,
batch_size=8)
```
> 本步骤代码已整理至[tutorials/compress/classification/cal_sensitivities_file.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/classification/cal_sensitivities_file.py)，用户可直接下载使用
> 使用如下命令开始计算敏感度
```
python cal_sensitivities_file.py --model_dir output/mobilenetv2/best_model --dataset vegetables_cls --save_file sensitivities.data
```
## 步骤三 开始裁剪训练
> 本步骤代码与步骤一使用同一份代码文件，使用如下命令开始裁剪训练
```
python mobilenetv2.py --model_dir output/mobilenetv2/best_model --sensitivities_file sensitivities.data --eval_metric_loss 0.10
```
## 实验效果
本教程的实验效果可以查阅[模型压缩文档](../../slim/prune.md)
docs/tutorials/compress/detection.md 0 → 100644
浏览文件 @ 8c6de1cb
# 检测模型裁剪
---
本文档训练代码可直接在PaddleX的Repo中下载，[代码tutorials/compress/detection](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/detection)
本文档按如下方式对模型进行了裁剪
> 第一步：在训练数据集上训练YOLOv3
> 第二步：在验证数据集上计算模型中各个参数的敏感度信息
> 第三步：根据第二步计算的敏感度，设定`eval_metric_loss`，对模型裁剪后重新在训练数据集上训练
## 步骤一 训练YOLOv3
> 模型训练使用文档可以直接参考[检测模型训练](../train/detection.md)，本文档在该代码基础上添加了部分参数选项，用户可直接下载模型训练代码[tutorials/compress/detection/yolov3_mobilnet.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/detection/yolov3_mobilenet.py)
> 使用如下命令开始模型训练
```
python yolov3_mobilenet.py
```
## 步骤二 计算参数敏感度
> 参数敏感度的计算可以直接使用PaddleX提供的API`paddlex.slim.cal_params_sensitivities`，使用代码如下, 敏感度信息文件会保存至`save_file`
```
import os
# 选择使用0号卡
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
model = pdx.load_model(model_dir)
# 定义验证所用的数据集
eval_dataset = pdx.datasets.ImageNet(
data_dir=dataset,
file_list=os.path.join(dataset, 'val_list.txt'),
label_list=os.path.join(dataset, 'labels.txt'),
transforms=model.eval_transforms)
pdx.slim.cal_params_sensitivities(model,
save_file,
eval_dataset,
batch_size=8)
```
> 本步骤代码已整理至[tutorials/compress/detection/cal_sensitivities_file.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/detection/cal_sensitivities_file.py)，用户可直接下载使用
> 使用如下命令开始计算敏感度
```
python cal_sensitivities_file.py --model_dir output/yolov3_mobile/best_model --dataset insect_det --save_file sensitivities.data
```
## 步骤三 开始裁剪训练
> 本步骤代码与步骤一使用同一份代码文件，使用如下命令开始裁剪训练
```
python yolov3_mobilenet.py --model_dir output/yolov3_mobile/best_model --sensitivities_file sensitivities.data --eval_metric_loss 0.10
```
## 实验效果
本教程的实验效果可以查阅[模型压缩文档](../../slim/prune.md)
docs/tutorials/compress/index.rst 0 → 100644
浏览文件 @ 8c6de1cb
模型压缩
=========================
.. toctree::
:maxdepth: 1
classification.md
detection.md
segmentation.md
docs/tutorials/compress/segmentation.md 0 → 100644
浏览文件 @ 8c6de1cb
# 分割模型裁剪
---
本文档训练代码可直接在PaddleX的Repo中下载，[代码tutorials/compress/segmentation](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/segmentation)
本文档按如下方式对模型进行了裁剪
> 第一步：在训练数据集上训练UNet
> 第二步：在验证数据集上计算模型中各个参数的敏感度信息
> 第三步：根据第二步计算的敏感度，设定`eval_metric_loss`，对模型裁剪后重新在训练数据集上训练
## 步骤一 训练UNet
> 模型训练使用文档可以直接参考[检测模型训练](../train/segmentation.md)，本文档在该代码基础上添加了部分参数选项，用户可直接下载模型训练代码[tutorials/compress/segmentation/unet.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/segmentation/unet.py)
> 使用如下命令开始模型训练
```
python unet.py
```
## 步骤二 计算参数敏感度
> 参数敏感度的计算可以直接使用PaddleX提供的API`paddlex.slim.cal_params_sensitivities`，使用代码如下, 敏感度信息文件会保存至`save_file`
```
import os
# 选择使用0号卡
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
model = pdx.load_model(model_dir)
# 定义验证所用的数据集
eval_dataset = pdx.datasets.ImageNet(
data_dir=dataset,
file_list=os.path.join(dataset, 'val_list.txt'),
label_list=os.path.join(dataset, 'labels.txt'),
transforms=model.eval_transforms)
pdx.slim.cal_params_sensitivities(model,
save_file,
eval_dataset,
batch_size=8)
```
> 本步骤代码已整理至[tutorials/compress/detection/cal_sensitivities_file.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/segmentation/cal_sensitivities_file.py)，用户可直接下载使用
> 使用如下命令开始计算敏感度
```
python cal_sensitivities_file.py --model_dir output/unet/best_model --dataset optic_disc_seg --save_file sensitivities.data
```
## 步骤三 开始裁剪训练
> 本步骤代码与步骤一使用同一份代码文件，使用如下命令开始裁剪训练
```
python unet.py --model_dir output/unet/best_model --sensitivities_file sensitivities.data --eval_metric_loss 0.10
```
## 实验效果
本教程的实验效果可以查阅[模型压缩文档](../../slim/prune.md)
docs/tutorials/index.rst 0 → 100644
浏览文件 @ 8c6de1cb
使用教程
=========================
.. toctree::
:maxdepth: 1
train/index.rst
compress/index.rst
docs/tutorials/train/classification.md 0 → 100644
浏览文件 @ 8c6de1cb
# 训练图像分类模型
---
本文档训练代码可参考PaddleX的[代码tutorial/train/classification/mobilenetv2.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/classification/mobilenetv2.py)
**1.下载并解压训练所需的数据集**
> 使用1张显卡训练并指定使用0号卡。
```python
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
```
> 这里使用蔬菜数据集，训练集、验证集和测试集共包含6189个样本，18个类别。
```python
veg_dataset = 'https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz'
pdx.utils.download_and_decompress(veg_dataset, path='./')
```
**2.定义训练和验证过程中的数据处理和增强操作**
> transforms用于指定训练和验证过程中的数据处理和增强操作流程，如下代码在训练过程中使用了`RandomCrop`和`RandomHorizontalFlip`进行数据增强，transforms的使用见[paddlex.cls.transforms](../../apis/transforms/cls_transforms.html#paddlex-cls-transforms)
```python
from paddlex.cls import transforms
train_transforms = transforms.Compose([
transforms.RandomCrop(crop_size=224),
transforms.RandomHorizontalFlip(),
transforms.Normalize()
])
eval_transforms = transforms.Compose([
transforms.ResizeByShort(short_size=256),
transforms.CenterCrop(crop_size=224),
transforms.Normalize()
])
```
**3.创建数据集读取器，并绑定相应的数据预处理流程**
> 通过不同的数据集读取器可以加载不同格式的数据集，数据集API的介绍见文档[paddlex.datasets](../../apis/datasets.md)
```python
train_dataset = pdx.datasets.ImageNet(
data_dir='vegetables_cls',
file_list='vegetables_cls/train_list.txt',
label_list='vegetables_cls/labels.txt',
transforms=train_transforms,
shuffle=True)
eval_dataset = pdx.datasets.ImageNet(
data_dir='vegetables_cls',
file_list='vegetables_cls/val_list.txt',
label_list='vegetables_cls/labels.txt',
transforms=eval_transforms)
```
**4.创建模型进行训练**
> 模型训练会默认自动下载和使用imagenet图像数据集上的预训练模型，用户也可自行指定`pretrain_weights`参数来设置预训练权重。模型训练过程每间隔`save_interval_epochs`轮会保存一次模型在`save_dir`目录下，同时在保存的过程中也会在验证数据集上计算相关指标。
> 分类模型的接口可见文档[paddlex.cls.models](../../apis/models.md)
```python
model = pdx.cls.MobileNetV2(num_classes=len(train_dataset.labels))
model.train(
num_epochs=10,
train_dataset=train_dataset,
train_batch_size=32,
eval_dataset=eval_dataset,
lr_decay_epochs=[4, 6, 8],
learning_rate=0.025,
save_dir='output/mobilenetv2',
use_vdl=True)
```
> 将`use_vdl`设置为`True`时可使用VisualDL查看训练指标。按以下方式启动VisualDL后，浏览器打开 https://0.0.0.0:8001即可。其中0.0.0.0为本机访问，如为远程服务, 改成相应机器IP。
```shell
visualdl --logdir output/mobilenetv2/vdl_log --port 8001
```
**5.验证或测试**
> 利用训练完的模型可继续在验证集上进行验证。
```python
eval_metrics = model.evaluate(eval_dataset, batch_size=8)
print("eval_metrics:", eval_metrics)
```
> 结果输出：
```
eval_metrics: OrderedDict([('acc1', 0.9895916733386709), ('acc5', 0.9983987189751802)])
```
> 训练完用模型对图片进行测试。
```python
predict_result = model.predict('./vegetables_cls/bocai/IMG_00000839.jpg', topk=5)
print("predict_result:", predict_result)
```
> 结果输出：
```
predict_result: [{'category_id': 13, 'category': 'bocai', 'score': 0.8607276},
{'category_id': 11, 'category': 'kongxincai', 'score': 0.06386806},
{'category_id': 2, 'category': 'suanmiao', 'score': 0.03736042},
{'category_id': 12, 'category': 'heiqiezi', 'score': 0.007879922},
{'category_id': 17, 'category': 'huluobo', 'score': 0.006327283}]
```
docs/tutorials/train/detection.md 0 → 100644
浏览文件 @ 8c6de1cb
# 训练目标检测模型
------
更多检测模型在VOC数据集或COCO数据集上的训练代码可参考[代码tutorials/train/detection/faster_rcnn_r50_fpn.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/faster_rcnn_r50_fpn.py)、[代码tutorials/train/detection/yolov3_mobilenetv1.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/yolov3_mobilenetv1.py)。
**1.下载并解压训练所需的数据集**
> 使用1张显卡训练并指定使用0号卡。
```python
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
```
> 这里使用昆虫数据集，训练集、验证集和测试集共包含217个样本，6个类别。
```python
insect_dataset = 'https://bj.bcebos.com/paddlex/datasets/insect_det.tar.gz'
pdx.utils.download_and_decompress(insect_dataset, path='./')
```
**2.定义训练和验证过程中的数据处理和增强操作**
> 在训练过程中使用`RandomHorizontalFlip`进行数据增强，由于接下来选择的模型是带FPN结构的Faster RCNN，所以使用`Padding`将输入图像的尺寸补齐到32的倍数，以保证FPN中两个需做相加操作的特征层的尺寸完全相同。transforms的使用见[paddlex.det.transforms](../../apis/transforms/det_transforms.md)
```python
from paddlex.det import transforms
train_transforms = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32)
])
eval_transforms = transforms.Compose([
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32),
])
```
**3.创建数据集读取器，并绑定相应的数据预处理流程**
> 数据集读取器的介绍见文档[paddlex.datasets](../../apis/datasets.md)
```python
train_dataset = pdx.datasets.VOCDetection(
data_dir='insect_det',
file_list='insect_det/train_list.txt',
label_list='insect_det/labels.txt',
transforms=train_transforms,
shuffle=True)
eval_dataset = pdx.datasets.VOCDetection(
data_dir='insect_det',
file_list='insect_det/val_list.txt',
label_list='insect_det/labels.txt',
transforms=eval_transforms)
```
**4.创建Faster RCNN模型，并进行训练**
> 创建带FPN结构的Faster RCNN模型，`num_classes` 需要设置为包含背景类的类别数，即: 目标类别数量(6) + 1
```python
num_classes = len(train_dataset.labels) + 1
model = pdx.det.FasterRCNN(num_classes=num_classes)
```
> 模型训练默认下载并使用在ImageNet数据集上训练得到的Backone，用户也可自行指定`pretrain_weights`参数来设置预训练权重。训练过程每间隔`save_interval_epochs`会在`save_dir`保存一次模型，与此同时也会在验证数据集上计算指标。检测模型的接口可见文档[paddlex.cv.models](../../apis/models.md#fasterrcnn)
```python
model.train(
num_epochs=12,
train_dataset=train_dataset,
train_batch_size=2,
eval_dataset=eval_dataset,
learning_rate=0.0025,
lr_decay_epochs=[8, 11],
save_dir='output/faster_rcnn_r50_fpn',
use_vdl=True)
```
> 将`use_vdl`设置为`True`时可使用VisualDL查看训练指标。按以下方式启动VisualDL后，浏览器打开 https://0.0.0.0:8001即可。其中0.0.0.0为本机访问，如为远程服务, 改成相应机器IP。
```shell
visualdl --logdir output/faster_rcnn_r50_fpn/vdl_log --port 8001
```
**5.验证或测试**
> 训练完利用模型可继续在验证集上进行验证。
```python
eval_metrics = model.evaluate(eval_dataset, batch_size=2)
print("eval_metrics:", eval_metrics)
```
> 结果输出：
```python
eval_metrics: {'bbox_map': 76.085371}
```
> 训练完用模型对图片进行测试。
```python
predict_result = model.predict('./insect_det/JPEGImages/1968.jpg')
```
> 可视化测试结果：
```python
pdx.det.visualize('./insect_det/JPEGImages/1968.jpg', predict_result, threshold=0.5, save_dir='./output/faster_rcnn_r50_fpn')
```
![](../images/visualized_fasterrcnn.jpg)
docs/tutorials/train/index.rst 0 → 100644
浏览文件 @ 8c6de1cb
模型训练
=========================
.. toctree::
:maxdepth: 1
classification.md
detection.md
instance_segmentation.md
segmentation.md
visualdl.md
docs/tutorials/train/instance_segmentation.md 0 → 100644
浏览文件 @ 8c6de1cb
# 训练实例分割模型
------
本文档训练代码可直接下载[代码tutorials/train/detection/mask_rcnn_r50_fpn.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/mask_rcnn_r50_fpn.py)。
**1.下载并解压训练所需的数据集**
> 使用1张显卡训练并指定使用0号卡。
```python
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
```
> 这里使用垃圾分拣数据集，训练集、验证集和测试共包含283个样本，6个类别。
```python
garbage_dataset = 'https://bj.bcebos.com/paddlex/datasets/garbage_ins_det.tar.gz'
pdx.utils.download_and_decompress(garbage_dataset, path='./')
```
**2.定义训练和验证过程中的数据处理和增强操作**
> 在训练过程中使用`RandomHorizontalFlip`进行数据增强，由于接下来选择的模型是带FPN结构的Mask RCNN，所以使用`PaddingImage`将输入图像的尺寸补齐到32的倍数，以保证FPN中两个需做相加操作的特征层的尺寸完全相同。transforms的使用见[paddlex.cv.transforms](../../apis/transforms/det_transforms.md)
```python
from paddlex.det import transforms
train_transforms = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32)
])
eval_transforms = transforms.Compose([
transforms.Normalize(),
transforms.ResizeByShort(short_size=800, max_size=1333),
transforms.Padding(coarsest_stride=32)
])
```
**3.创建数据集读取器，并绑定相应的数据预处理流程**
> 数据集读取器的介绍见文档[paddlex.datasets](../../apis/datasets.md)
```python
train_dataset = pdx.datasets.CocoDetection(
data_dir='garbage_ins_det/JPEGImages',
ann_file='garbage_ins_det/train.json',
transforms=train_transforms,
shuffle=True)
eval_dataset = pdx.datasets.CocoDetection(
data_dir='garbage_ins_det/JPEGImages',
ann_file='garbage_ins_det/val.json',
transforms=eval_transforms)
```
**4.创建Mask RCNN模型，并进行训练**
> 创建带FPN结构的Mask RCNN模型，`num_classes` 需要设置为包含背景类的类别数，即: 目标类别数量(6) + 1。
```python
num_classes = len(train_dataset.labels)
model = pdx.det.MaskRCNN(num_classes=num_classes
```
> 模型训练默认下载并使用在ImageNet数据集上训练得到的Backone，用户也可自行指定`pretrain_weights`参数来设置预训练权重。训练过程每间隔`save_interval_epochs`会在`save_dir`保存一次模型，与此同时也会在验证数据集上计算指标。检测模型的接口可见文档[paddlex.det.models](../../apis/models.md)。
```python
model.train(
num_epochs=12,
train_dataset=train_dataset,
train_batch_size=1,
eval_dataset=eval_dataset,
learning_rate=0.00125,
lr_decay_epochs=[8, 11],
save_dir='output/mask_rcnn_r50_fpn',
use_vdl=True)
```
> 将`use_vdl`设置为`True`时可使用VisualDL查看训练指标。按以下方式启动VisualDL后，浏览器打开 https://0.0.0.0:8001即可。其中0.0.0.0为本机访问，如为远程服务, 改成相应机器IP。
```shell
visualdl --logdir output/faster_rcnn_r50_fpn/vdl_log --port 8001
```
**5.验证或测试**
> 训练完利用模型可继续在验证集上进行验证。
```python
eval_metrics = model.evaluate(eval_dataset, batch_size=1)
print("eval_metrics:", eval_metrics)
```
> 结果输出：
```python
eval_metrics: {'bbox_mmap': 0.858306, 'segm_mmap': 0.864278}
```
> 训练完用模型对图片进行测试。
```python
predict_result = model.predict('./garbage_ins_det/JPEGImages/000114.bmp')
```
> 可视化测试结果：
```python
pdx.det.visualize('./garbage_ins_det/JPEGImages/000114.bmp', predict_result, threshold=0.7, save_dir='./output/mask_rcnn_r50_fpn')
```
![](../images/visualized_maskrcnn.bmp)
docs/tutorials/train/segmentation.md 0 → 100644
浏览文件 @ 8c6de1cb
# 训练语义分割模型
---
更多语义分割模型在Cityscapes数据集上的训练代码可参考[代码tutorials/train/segmentation/unet.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/segmentation/unet.py)、[代码tutorials/train/segmentation/deeplabv3p.py](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/segmentation/deeplabv3p.py)。
**1.下载并解压训练所需的数据集**
> 使用1张显卡训练并指定使用0号卡。
```python
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import paddlex as pdx
```
> 这里使用视盘分割数据集，训练集、验证集和测试集共包含343个样本，2个类别。
```python
optic_dataset = 'https://bj.bcebos.com/paddlex/datasets/optic_disc_seg.tar.gz'
pdx.utils.download_and_decompress(optic_dataset, path='./')
```
**2.定义训练和验证过程中的数据处理和增强操作**
> 在训练过程中使用`RandomHorizontalFlip`和`RandomPaddingCrop`进行数据增强，transforms的使用见[paddlex.seg.transforms](../../apis/transforms/seg_transforms.md)
```python
train_transforms = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.Resize(target_size=512),
transforms.RandomPaddingCrop(crop_size=500),
transforms.Normalize()
])
eval_transforms = transforms.Compose([
transforms.Resize(512),
transforms.Normalize()
])
```
**3.创建数据集读取器，并绑定相应的数据预处理流程**
> 数据集读取器的介绍见文档[paddlex.cv.datasets](../../apis/datasets.md)
```python
train_dataset = pdx.datasets.SegDataset(
data_dir='optic_disc_seg',
file_list='optic_disc_seg/train_list.txt',
label_list='optic_disc_seg/labels.txt',
transforms=train_transforms,
shuffle=True)
eval_dataset = pdx.datasets.SegDataset(
data_dir='optic_disc_seg',
file_list='optic_disc_seg/val_list.txt',
label_list='optic_disc_seg/labels.txt',
transforms=eval_transforms)
```
**4.创建DeepLabv3+模型，并进行训练**
> 创建DeepLabv3+模型，`num_classes` 需要设置为不包含背景类的类别数，即: 目标类别数量(1)，详细代码可参见[demo](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/segmentation/deeplabv3p.py#L44)。
```python
num_classes = num_classes
model = pdx.seg.DeepLabv3p(num_classes=num_classes)
```
> 模型训练默认下载并使用在ImageNet数据集上训练得到的Backone，用户也可自行指定`pretrain_weights`参数来设置预训练权重。
训练过程每间隔`save_interval_epochs`会在`save_dir`保存一次模型，与此同时也会在验证数据集上计算指标。
检测模型的接口可见文档[paddlex.seg.models](../../apis/models.md)。
```python
model.train(
num_epochs=40,
train_dataset=train_dataset,
train_batch_size=4,
eval_dataset=eval_dataset,
learning_rate=0.01,
save_dir='output/deeplab',
use_vdl=True)
```
> 将`use_vdl`设置为`True`时可使用VisualDL查看训练指标。按以下方式启动VisualDL后，浏览器打开 https://0.0.0.0:8001即可。其中0.0.0.0为本机访问，如为远程服务, 改成相应机器IP。
```shell
visualdl --logdir output/deeplab/vdl_log --port 8001
```
**5.验证或测试**
> 训练完利用模型可继续在验证集上进行验证。
```python
eval_metrics = model.evaluate(eval_dataset, batch_size=2)
print("eval_metrics:", eval_metrics)
```
> 结果输出：
```python
eval_metrics: {'miou': 0.8915175875548873, 'category_iou': [0.9956445981924432, 0.7873905769173314], 'macc': 0.9957137358816046, 'category_acc': [0.9975360650317765, 0.8948120441157331], 'kappa': 0.8788684558629085}
```
> 训练完用模型对图片进行测试。
```python
image_name = 'optic_disc_seg/JPEGImages/H0005.jpg'
predict_result = model.predict(image_name)
```
> 可视化测试结果：
```python
import paddlex as pdx
pdx.seg.visualize(image_name, predict_result, weight=0.4)
```
![](../images/visualized_deeplab.jpg)
docs/tutorials/train/visualdl.md 0 → 100644
浏览文件 @ 8c6de1cb
# VisualDL可视化训练指标
在使用PaddleX训练模型过程中，各个训练指标和评估指标会直接输出到标准输出流，同时也可通过VisualDL对训练过程中的指标进行可视化，只需在调用`train`函数时，将`use_vdl`参数设为`True`即可，如下代码所示，
```
model = paddlex.cls.ResNet50(num_classes=1000)
model.train(num_epochs=120, train_dataset=train_dataset,
train_batch_size=32, eval_dataset=eval_dataset,
log_interval_steps=10, save_interval_epochs=10,
save_dir='./output', use_vdl=True)
```
模型在训练过程中，会在`save_dir`下生成`vdl_log`目录，通过在命令行终端执行以下命令，启动VisualDL。
```
visualdl --logdir=output/vdl_log --port=8008
```
在浏览器打开`http://0.0.0.0:8008`便可直接查看随训练迭代动态变化的各个指标（0.0.0.0表示启动VisualDL所在服务器的IP，本机使用0.0.0.0即可）。
在训练分类模型过程中，使用VisualDL进行可视化的示例图如下所示。
> 训练过程中每个Step的`Loss`和相应`Top1准确率`变化趋势：
![](../../images/vdl1.jpg)
> 训练过程中每个Step的`学习率lr`和相应`Top5准确率`变化趋势：
![](../../images/vdl2.jpg)
> 训练过程中，每次保存模型时，模型在验证数据集上的`Top1准确率`和`Top5准确率`：
![](../../images/vdl3.jpg)
images/08模型发布.png 已删除 100644 → 0
浏览文件 @ 01d41a4d
此差异已折叠。
images/09qq群二维码.png 已删除 100644 → 0
浏览文件 @ 01d41a4d
此差异已折叠。
paddlex/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cls.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/command.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/coco.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/dataset.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/imagenet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/seg_dataset.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/shared_queue/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/shared_queue/queue.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/shared_queue/sharedmemory.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/datasets/voc.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/base.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/classifier.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/deeplabv3p.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/faster_rcnn.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/load_model.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/mask_rcnn.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/slim/post_quantization.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/slim/prune.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/slim/prune_config.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/slim/visualize.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/unet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/utils/detection_eval.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/utils/pretrain_weights.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/utils/seg_eval.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/utils/visualize.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/models/yolo_v3.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/backbone_utils.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/darknet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/densenet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/bbox_head.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/faster_rcnn.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/fpn.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/mask_head.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/mask_rcnn.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/roi_extractor.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/rpn_head.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/detection/yolo_v3.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/mobilenet_v1.py 0 → 100755
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/mobilenet_v2.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/mobilenet_v3.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/resnet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/segmentation/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/segmentation/deeplabv3p.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/segmentation/model_utils/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/segmentation/model_utils/libs.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/segmentation/model_utils/loss.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/segmentation/unet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/shufflenet_v2.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/nets/xception.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/transforms/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/transforms/box_utils.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/transforms/cls_transforms.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/transforms/det_transforms.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/transforms/ops.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/cv/transforms/seg_transforms.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/det.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/seg.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/slim.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/utils/__init__.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/utils/download.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/utils/logging.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/utils/save.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
paddlex/utils/utils.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
requirements.txt 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
setup.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/compress/README.md 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/compress/classification/mobilenetv2.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/compress/detection/cal_sensitivities_file.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/compress/detection/yolov3_mobilenet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/compress/segmentation/unet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/README.md 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/classification/mobilenetv2.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/classification/resnet50.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/detection/faster_rcnn_r50_fpn.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/detection/mask_rcnn_r50_fpn.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/detection/yolov3_mobilenetv1.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/segmentation/deeplabv3p.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
tutorials/train/segmentation/unet.py 0 → 100644
浏览文件 @ 8c6de1cb
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或