欢迎使用PaddleX！¶

PaddleX是基于飞桨核心框架、开发套件和工具组件的深度学习全流程开发工具。具备 全流程打通 、融合产业实践 、易用易集成 三大特点。

项目官网: http://www.paddlepaddle.org.cn/paddle/paddlex
项目GitHub: https://github.com/PaddlePaddle/PaddleX
官方QQ用户群: 1045148026
GitHub Issue反馈: http://www.github.com/PaddlePaddle/PaddleX/issues

10分钟快速上手使用¶

本文档在一个小数据集上展示了如何通过PaddleX进行训练。本示例同步在AIStudio上，可直接在线体验模型训练。

本示例代码源于Github tutorials/train/classification/mobilenetv3_small_ssld.py，用户可自行下载至本地运行。

PaddleX中的所有模型训练跟随以下3个步骤，即可快速完成训练代码开发！

步骤		说明
第1步	定义transforms	用于定义模型训练、验证、预测过程中，输入图像的预处理和数据增强操作
第2步	定义datasets	用于定义模型要加载的训练、验证数据集
第3步	定义模型开始训练	选择需要的模型，进行训练

注意：不同模型的transforms、datasets和训练参数都有较大差异，更多模型训练，可直接根据文档教程获取更多模型的训练代码。模型训练教程

PaddleX的其它用法

使用VisualDL查看训练过程中的指标变化
加载训练保存的模型进行预测

1. 安装PaddleX

安装相关过程和问题可以参考PaddleX的安装文档。

pip install paddlex -i https://mirror.baidu.com/pypi/simple

2. 准备蔬菜分类数据集

wget https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz
tar xzvf vegetables_cls.tar.gz

3. 定义训练/验证图像处理流程transforms

由于训练时数据增强操作的加入，因此模型在训练和验证过程中，数据处理流程需要分别进行定义。如下所示，代码在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()
])

4. 定义dataset加载图像分类数据集

定义数据集，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/val_list.txt',
    label_list='vegetables_cls/labels.txt',
    transforms=eval_transforms)

5. 使用MobileNetV3_small_ssld模型开始训练

本文档中使用百度基于蒸馏方法得到的MobileNetV3预训练模型，模型结构与MobileNetV3一致，但精度更高。PaddleX内置了20多种分类模型，查阅PaddleX模型库了解更多分类模型。

num_classes = len(train_dataset.labels)
model = pdx.cls.MobileNetV3_small_ssld(num_classes=num_classes)

model.train(num_epochs=20,
            train_dataset=train_dataset,
            train_batch_size=32,
            eval_dataset=eval_dataset,
            lr_decay_epochs=[4, 6, 8],
            save_dir='output/mobilenetv3_small_ssld',
            use_vdl=True)

6. 训练过程使用VisualDL查看训练指标变化

模型在训练过程中，训练指标和在验证集上的指标，均会以标准输出流形式，输出到命令终端。在用户设定use_vdl=True的前提下，也会使用VisualDL格式打点到save_dir目录下的vdl_log文件夹，用户可都终端通过如下命令启动visualdl，查看可视化的指标变化趋势。

visualdl --logdir output/mobilenetv3_small_ssld --port 8001

服务启动后，通过浏览器打开https://0.0.0.0:8001或https://localhost:8001即可。

如果您使用的是AIStudio平台进行训练，不能通过此方式启动visualdl，请参考AIStudio VisualDL启动教程使用

7. 加载训练保存的模型预测

模型在训练过程中，会每间隔一定轮数保存一次模型，在验证集上评估效果最好的一轮会保存在save_dir目录下的best_model文件夹。通过如下方式可加载模型，进行预测。

import paddlex as pdx
model = pdx.load_model('output/mobilenetv3_small_ssld/best_model')
result = model.predict('vegetables_cls/bocai/100.jpg')
print("Predict Result: ", result)

预测结果输出如下,

Predict Result: Predict Result: [{'score': 0.9999393, 'category': 'bocai', 'category_id': 0}]

更多使用教程

快速安装¶

以下安装过程默认用户已安装好paddlepaddle-gpu或paddlepaddle(版本大于或等于1.8.1)，paddlepaddle安装方式参照飞桨官网

pip安装¶

注意其中pycocotools在Windows安装较为特殊，可参考下面的Windows安装命令

pip install paddlex -i https://mirror.baidu.com/pypi/simple

Anaconda安装¶

Anaconda是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项。使用Anaconda可以通过创建多个独立的Python环境，避免用户的Python环境安装太多不同版本依赖导致冲突。

参考Anaconda安装PaddleX文档

代码安装¶

github代码会跟随开发进度不断更新

git clone https://github.com/PaddlePaddle/PaddleX.git
cd PaddleX
git checkout develop
python setup.py install

pycocotools安装问题¶

PaddleX依赖pycocotools包，如安装pycocotools失败，可参照如下方式安装pycocotools

Windows安装时可能会提示缺少Microsoft Visual C++ 2015 build tools，点击下载VC build tools安装再执行如下pip命令

pip install cython
pip install git+https://gitee.com/jiangjiajun/philferriere-cocoapi.git#subdirectory=PythonAPI

Linux/Mac系统下，直接使用pip安装如下两个依赖即可

pip install cython  
pip install pycocotools

数据准备¶

数据标注工具¶

PaddleX支持图像分类、目标检测、实例分割和语义分割四大视觉领域常见的任务，对于每类视觉任务，都支持了特定的数据格式。PaddleX目前支持了图像分类的ImageNet格式，目标检测的PascalVOC格式，实例分割的MSCOCO格式（MSCOCO也可以用于目标检测）以及语义分割数据格式。

常见标注工具¶

图像分类无需标注工具，用户只需以txt文件记录每张图片的类别标签即可。对于目标检测、实例分割和语义分割，PaddleX已经与主流的标注工具进行了适配，用户可根据自己的需求，选择以下标注工具进行数据标注。

标注工具	图像分类	目标检测	实例分割	语义分割	安装
Labelme	-	√	√	√	pip install labelme （本地数据标注）
精灵标注	√	√*	√	√	官网下载（本地数据标注）
EasyData	√	√	√	√	Web页面标注（需上传数据进行标注)

数据标注完成后，参照如下流程，将标注数据转为可用PaddleX模型训练的数据组织格式。

注：精灵标注的目标检测数据可以在工具内部导出为PascalVOC格式，因此paddlex未提供精灵标注数据到PascalVOC格式的转换

标注数据格式转换¶

目前所有标注工具，生成的标注文件，均为与原图同名的json格式文件，如1.jpg在标注完成后，则会在标注文件保存的目录生成1.json文件。转换时参照以下步骤

将所有的原图文件放在同一个目录下，如pics目录

将所有的标注json文件放在同一个目录下，如annotations目录

使用如下命令进行转换

注：精灵标注的目标检测数据可以在工具内部导出为PascalVOC格式，因此paddlex未提供精灵标注数据到PascalVOC格式的转换

paddlex --data_conversion --source labelme --to PascalVOC --pics ./pics --annotations ./annotations --save_dir ./converted_dataset_dir

--source表示数据标注来源，支持labelme、jingling和easydata（分别表示数据来源于LabelMe，精灵标注助手和EasyData）--to表示数据需要转换成为的格式，支持ImageNet（图像分类）、PascalVOC（目标检测），MSCOCO（实例分割，也可用于目标检测）和SEG(语义分割)--pics指定原图所在的目录路径--annotations指定标注文件所在的目录路径

数据格式说明¶

图像分类ImageNet¶

数据文件夹结构¶

在PaddleX中，图像分类支持ImageNet数据集格式。数据集目录data_dir下包含多个文件夹，每个文件夹中的图像均属于同一个类别，文件夹的命名即为类别名（注意路径中不要包括中文，空格）。如下为示例结构

MyDataset/ # 图像分类数据集根目录
|--dog/ # 当前文件夹所有图片属于dog类别
|  |--d1.jpg
|  |--d2.jpg
|  |--...
|  |--...
|
|--...
|
|--snake/ # 当前文件夹所有图片属于snake类别
|  |--s1.jpg
|  |--s2.jpg
|  |--...
|  |--...

划分训练集验证集¶

为了用于训练，我们需要在MyDataset目录下准备train_list.txt, val_list.txt和labels.txt三个文件，分别用于表示训练集列表，验证集列表和类别标签列表。点击下载图像分类示例数据集

labels.txt

labels.txt用于列出所有类别，类别对应行号表示模型训练过程中类别的id(行号从0开始计数)，例如labels.txt为以下内容

dog
cat
snake

即表示该分类数据集中共有3个类别，分别为dog，cat和snake，在模型训练中dog对应的类别id为0, cat对应1，以此类推

train_list.txt

train_list.txt列出用于训练时的图片集合，与其对应的类别id，示例如下

dog/d1.jpg 0
dog/d2.jpg 0
cat/c1.jpg 1
... ...
snake/s1.jpg 2

其中第一列为相对对MyDataset的相对路径，第二列为图片对应类别的类别id

val_list.txt

val_list列出用于验证时的图片集成，与其对应的类别id，格式与train_list.txt一致

PaddleX数据集加载¶

示例代码如下,

import paddlex as pdx
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()
])
train_dataset = pdx.datasets.ImageNet(
                    data_dir='./MyDataset',
                    file_list='./MyDataset/train_list.txt',
                    label_list='./MyDataset/labels.txt',
                    transforms=train_transforms)
eval_dataset = pdx.datasets.ImageNet(
                    data_dir='./MyDataset',
                    file_list='./MyDataset/eval_list.txt',
                    label_list='./MyDataset/labels.txt',
                    transforms=eval_transforms)

目标检测PascalVOC¶

数据集文件夹结构¶

在PaddleX中，目标检测支持PascalVOC数据集格式。建议用户将数据集按照如下方式进行组织，原图均放在同一目录，如JPEGImages，标注的同名xml文件均放在同一目录，如Annotations，示例如下

MyDataset/ # 目标检测数据集根目录
|--JPEGImages/ # 原图文件所在目录
|  |--1.jpg
|  |--2.jpg
|  |--...
|  |--...
|
|--Annotations/ # 标注文件所在目录
|  |--1.xml
|  |--2.xml
|  |--...
|  |--...

划分训练集验证集¶

为了用于训练，我们需要在MyDataset目录下准备train_list.txt, val_list.txt和labels.txt三个文件，分别用于表示训练集列表，验证集列表和类别标签列表。点击下载目标检测示例数据集

labels.txt

labels.txt用于列出所有类别，类别对应行号表示模型训练过程中类别的id(行号从0开始计数)，例如labels.txt为以下内容

dog
cat
snake

表示该检测数据集中共有3个目标类别，分别为dog，cat和snake，在模型训练中dog对应的类别id为0, cat对应1，以此类推

train_list.txt

train_list.txt列出用于训练时的图片集合，与其对应的标注文件，示例如下

JPEGImages/1.jpg Annotations/1.xml
JPEGImages/2.jpg Annotations/2.xml
... ...

其中第一列为原图相对MyDataset的相对路径，第二列为标注文件相对MyDataset的相对路径

val_list.txt

val_list列出用于验证时的图片集成，与其对应的标注文件，格式与val_list.txt一致

PaddleX数据集加载¶

示例代码如下，

import paddlex as pdx
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),
])

train_dataset = pdx.datasets.VOCDetection(
                        data_dir='./MyDataset',
                        file_list='./MyDataset/train_list.txt',
                        label_list='./MyDataset/labels.txt',
                        transforms=train_transforms)
eval_dataset = pdx.datasets.VOCDetection(
                        data_dir='./MyDataset',
                        file_list='./MyDataset/val_list.txt',
                        label_list='MyDataset/labels.txt',
                        transforms=eval_transforms)

实例分割MSCOCO¶

数据集文件夹结构¶

在PaddleX中，实例分割支持MSCOCO数据集格式（MSCOCO格式同样也可以用于目标检测）。建议用户将数据集按照如下方式进行组织，原图均放在同一目录，如JPEGImages，标注文件（如annotations.json）放在与JPEGImages所在目录同级目录下，示例结构如下

MyDataset/ # 实例分割数据集根目录
|--JPEGImages/ # 原图文件所在目录
|  |--1.jpg
|  |--2.jpg
|  |--...
|  |--...
|
|--annotations.json # 标注文件所在目录

划分训练集验证集¶

在PaddleX中，为了区分训练集和验证集，在MyDataset同级目录，使用不同的json表示数据的划分，例如train.json和val.json。点击下载实例分割示例数据集。

MSCOCO数据的标注文件采用json格式，用户可使用Labelme, 精灵标注助手或EasyData等标注工具进行标注，参见数据标注工具

PaddleX加载数据集¶

示例代码如下，

import paddlex as pdx
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),
])

train_dataset = pdx.dataset.CocoDetection(
                    data_dir='./MyDataset/JPEGImages',
                    ann_file='./MyDataset/train.json',
                    transforms=train_transforms)
eval_dataset = pdx.dataset.CocoDetection(
                    data_dir='./MyDataset/JPEGImages',
                    ann_file='./MyDataset/val.json',
                    transforms=eval_transforms)

语义分割Seg¶

数据集文件夹结构¶

在PaddleX中，标注文件为png文件。建议用户将数据集按照如下方式进行组织，原图均放在同一目录，如JPEGImages，标注的同名png文件均放在同一目录，如Annotations，示例如下

MyDataset/ # 语义分割数据集根目录
|--JPEGImages/ # 原图文件所在目录
|  |--1.jpg
|  |--2.jpg
|  |--...
|  |--...
|
|--Annotations/ # 标注文件所在目录
|  |--1.png
|  |--2.png
|  |--...
|  |--...

语义分割的标注图像，如1.png，为单通道图像,像素标注类别需要从0开始递增（一般0表示background背景), 例如0， 1， 2， 3表示4种类别，标注类别最多255个类别(其中像素值255不参与训练和评估)。

划分训练集验证集¶

为了用于训练，我们需要在MyDataset目录下准备train_list.txt, val_list.txt和labels.txt三个文件，分别用于表示训练集列表，验证集列表和类别标签列表。点击下载语义分割示例数据集

labels.txt

labels.txt用于列出所有类别，类别对应行号表示模型训练过程中类别的id(行号从0开始计数)，例如labels.txt为以下内容

backgrond
human
car

表示该检测数据集中共有3个分割类别，分别为background，human和car，在模型训练中background对应的类别id为0, human对应1，以此类推，如不知具体类别标签，可直接在labels.txt逐行写0，1，2…序列即可。

train_list.txt

train_list.txt列出用于训练时的图片集合，与其对应的标注文件，示例如下

JPEGImages/1.jpg Annotations/1.png
JPEGImages/2.jpg Annotations/2.png
... ...

其中第一列为原图相对MyDataset的相对路径，第二列为标注文件相对MyDataset的相对路径

val_list.txt

val_list列出用于验证时的图片集成，与其对应的标注文件，格式与val_list.txt一致

PaddleX数据集加载¶

示例代码如下，

import paddlex as pdx
from paddlex.seg import transforms

train_transforms = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.ResizeRangeScaling(),
    transforms.RandomPaddingCrop(crop_size=512),
    transforms.Normalize()
])

eval_transforms = transforms.Compose([
    transforms.ResizeByLong(long_size=512),
    transforms.Padding(target_size=512),
    transforms.Normalize()
])

train_dataset = pdx.datasets.SegDataset(
                        data_dir='./MyDataset',
                        file_list='./MyDataset/train_list.txt',
                        label_list='./MyDataset/labels.txt',
                        transforms=train_transforms)
eval_dataset = pdx.datasets.SegDataset(
                        data_dir='./MyDataset',
                        file_list='./MyDataset/val_list.txt',
                        label_list='MyDataset/labels.txt',
                        transforms=eval_transforms)

模型训练¶

PaddleX集成了PaddleClas、PaddleDetection和PaddleSeg三大CV工具套件中，在工业领域应用成熟的模型，并提供了统一，易用的API使用接口，帮助用户快速完成视觉领域的图像分类、目标检测、实例分割和语义分割模型的训练。

图像分类¶

介绍¶

PaddleX共提供了20+的图像分类模型，可满足开发者不同场景的需求下的使用。

Top1精度: 模型在ImageNet数据集上的测试精度
预测速度：单张图片的预测用时（不包括预处理和后处理)
“-“表示指标暂未更新

模型(点击获取代码)	Top1精度	模型大小	GPU预测速度	Arm预测速度	备注
MobileNetV3_small_ssld	71.3%	21.0MB	6.809ms	-	模型小，预测速度快，适用于低性能或移动端设备
MobileNetV2	72.2%	14.0MB	4.546ms	-	模型小，预测速度快，适用于低性能或移动端设备
ShuffleNetV2	68.8%	9.0MB	6.101ms	-	模型体积小，预测速度快，适用于低性能或移动端设备
ResNet50_vd_ssld	82.4%	102.8MB	9.058ms	-	模型精度高，适用于服务端部署

开始训练¶

代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练
如保存为mobilenetv3_small_ssld.py，如下命令即可开始训练
python mobilenetv3_small_ssld.py

目标检测¶

介绍¶

PaddleX目前提供了FasterRCNN和YOLOv3两种检测结构,多种backbone模型，可满足开发者不同场景和性能的需求。

Box MMAP: 模型在COCO数据集上的测试精度
预测速度：单张图片的预测用时（不包括预处理和后处理)
“-“表示指标暂未更新

模型(点击获取代码)	Box MMAP	模型大小	GPU预测速度	Arm预测速度	备注
YOLOv3-MobileNetV1	29.3%	99.2MB	15.442ms	-	模型小，预测速度快，适用于低性能或移动端设备
YOLOv3-MobileNetV3	31.6%	100.7MB	143.322ms	-	模型小，移动端上预测速度有优势
YOLOv3-DarkNet53	38.9	249.2MB	42.672ms	-	模型较大，预测速度快，适用于服务端
FasterRCNN-ResNet50-FPN	37.2%	167.7MB	197.715ms	-	模型精度高，适用于服务端部署
FasterRCNN-ResNet18-FPN	32.6%	173.2MB	-	-	模型精度高，适用于服务端部署
FasterRCNN-HRNet-FPN	36.0%	115.MB	81.592ms	-	模型精度高，预测速度快，适用于服务端部署

开始训练¶

代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练
如保存为yolov3_mobilenetv1.py，如下命令即可开始训练
python yolov3_mobilenetv1.py

实例分割¶

介绍¶

PaddleX目前提供了MaskRCNN实例分割模型结构,多种backbone模型，可满足开发者不同场景和性能的需求。

Box MMAP/Seg MMAP: 模型在COCO数据集上的测试精度
预测速度：单张图片的预测用时（不包括预处理和后处理)
“-“表示指标暂未更新

模型(点击获取代码)	Box MMAP/Seg MMAP	模型大小	GPU预测速度	Arm预测速度	备注
MaskRCNN-ResNet50-FPN	38.7%/34.7%	177.7MB	160.185ms	-	模型精度高，适用于服务端部署
MaskRCNN-ResNet18-FPN	33.6/30.5	189.1MB	-	-	模型精度高，适用于服务端部署
MaskRCNN-HRNet-FPN	38.7%/34.7%	120.7MB	-	-	模型精度高，预测速度快，适用于服务端部署

开始训练¶

代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练
如保存为mask_r50_fpn.py，如下命令即可开始训练
python mask_r50_fpn.py

语义分割¶

介绍¶

PaddleX目前提供了DeepLabv3p、UNet、HRNet和FastSCNN四种语义分割结构,多种backbone模型，可满足开发者不同场景和性能的需求。

mIOU: 模型在CityScape数据集上的测试精度
预测速度：单张图片的预测用时（不包括预处理和后处理)
“-“表示指标暂未更新

模型(点击获取代码)	mIOU	模型大小	GPU预测速度	Arm预测速度	备注
DeepLabv3p-MobileNetV2-x0.25	-	2.9MB	-	-	模型小，预测速度快，适用于低性能或移动端设备
DeepLabv3p-MobileNetV2-x1.0	69.8%	11MB	-	-	模型小，预测速度快，适用于低性能或移动端设备
DeepLabv3p-Xception65	79.3%	158MB	-	-	模型大，精度高，适用于服务端
UNet	-	52MB	-	-	模型较大，精度高，适用于服务端
HRNet	79.4%	37MB	-	-	模型较小，模型精度高，适用于服务端部署
FastSCNN	-	4.5MB	-	-	模型小，预测速度快，适用于低性能或移动端设备

开始训练¶

代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练
如保存为deeplabv3p_mobilenetv2_x0.25.py，如下命令即可开始训练
python deeplabv3p_mobilenetv2_x0.25.py

加载模型预测¶

PaddleX可以使用paddlex.load_model接口加载模型（包括训练过程中保存的模型，导出的部署模型，量化模型以及裁剪的模型）进行预测，同时PaddleX中也内置了一系列的可视化工具函数，帮助用户方便地检查模型的效果。

注意：使用paddlex.load_model接口加载仅用于模型预测，如需要在此模型基础上继续训练，可以将该模型作为预训练模型进行训练，具体做法是在训练代码中，将train函数中的pretrain_weights参数指定为预训练模型路径。

图像分类¶

点击下载如下示例代码中模型

import paddlex as pdx
test_jpg = 'mobilenetv3_small_ssld_imagenet/test.jpg'
model = pdx.load_model('mobilenetv3_small_ssld_imagenet')
result = model.predict(test_jpg)
print("Predict Result: ", result)

结果输入如下

Predict Result: [{'category_id': 21, 'category': 'killer_whale', 'score': 0.8262267}]

测试图片如下

分类模型predict接口说明文档

目标检测¶

点击下载如下示例代码中模型

import paddlex as pdx
test_jpg = 'yolov3_mobilenetv1_coco/test.jpg'
model = pdx.load_model('yolov3_mobilenetv1_coco')

# predict接口并未过滤低置信度识别结果，用户根据需求按score值进行过滤
result = model.predict(test_jpg)

# 可视化结果存储在./visualized_test.jpg, 见下图
pdx.det.visualize(test_jpg, result, threshold=0.3, save_dir='./')

YOLOv3模型predict接口说明文档
可视化pdx.det.visualize接口说明文档

注意：目标检测和实例分割模型在调用predict接口得到的结果需用户自行过滤低置信度结果，在paddlex.det.visualize接口中，我们提供了threshold用于过滤，置信度低于此值的结果将被过滤，不会可视化。

实例分割¶

点击下载如下示例代码中模型

import paddlex as pdx
test_jpg = 'mask_r50_fpn_coco/test.jpg'
model = pdx.load_model('mask_r50_fpn_coco')

# predict接口并未过滤低置信度识别结果，用户根据需求按score值进行过滤
result = model.predict(test_jpg)

# 可视化结果存储在./visualized_test.jpg, 见下图
pdx.det.visualize(test_jpg, result, threshold=0.5, save_dir='./')

MaskRCNN模型predict接口说明文档
可视化pdx.det.visualize接口说明文档

注意：目标检测和实例分割模型在调用predict接口得到的结果需用户自行过滤低置信度结果，在paddlex.det.visualize接口中，我们提供了threshold用于过滤，置信度低于此值的结果将被过滤，不会可视化。

语义分割¶

import paddlex as pdx
test_jpg = './deeplabv3p_mobilenetv2_coco/test.jpg'
model = pdx.load_model('./deeplabv3p_mobilenetv2_coco')
result = model.predict(test_jpg)
pdx.seg.visualize(test_jpg, result, weight=0.0, save_dir='./')

在上述示例代码中，通过调用paddlex.seg.visualize可以对语义分割的预测结果进行可视化，可视化的结果保存在save_dir下。其中weight参数用于调整预测结果和原图结果融合展现时的权重，0.0时只展示预测结果mask的可视化，1.0时只展示原图可视化。

公开数据集训练模型下载¶

PaddleX提供了部分公开数据集上训练好的模型，用户可以直接下载后参照本文档加载使用。

类型	模型(点击下载)	数据集	大小	指标	指标数值
图像分类	MobileNetV3_small_ssld	ImageNet	13MB	Accuracy	71.3%
图像分类	ResNet50_vd_ssld	ImageNet	110MB	Accuracy	82.4%
目标检测	FasterRCNN-ResNet50-FPN	MSCOCO	179MB	Box MAP	37.7%
目标检测	YOLOv3-MobileNetV1	MSCOCO	106MB	Box MAP	29.3%
目标检测	YOLOv3-DarkNet53	MSCOCO	266MMB	Box MAP	34.8%
目标检测	YOLOv3-MobileNetV3	MSCOCO	101MB	Box MAP	31.6%
实例分割	MaskRCNN-ResNet50-FPN	MSCOCO	193MB	Box MAP/Seg MAP	38.7% / 34.7%
语义分割	DeepLabv3p-Xception65	人像分割	-	mIoU	-
语义分割	HRNet_w18_small	人像分割	-	mIou	-

PaddleX的load_model接口可以满足用户一般的模型调研需求，如若为更高性能的预测部署，可以参考如下文档

模型部署¶

部署模型导出¶

在服务端部署的模型需要首先将模型导出为inference格式模型，导出的模型将包括__model__、__params__和model.yml三个文名，分别为模型的网络结构，模型权重和模型的配置文件（包括数据预处理参数等等）。在安装完PaddleX后，在命令行终端使用如下命令导出模型到当前目录inferece_model下。

可直接下载小度熊分拣模型测试本文档的流程xiaoduxiong_epoch_12.tar.gz

paddlex --export_inference --model_dir=./xiaoduxiong_epoch_12 --save_dir=./inference_model

使用TensorRT预测时，需指定模型的图像输入shape:[w,h]。注：

分类模型请保持于训练时输入的shape一致。
指定[w,h]时，w和h中间逗号隔开，不允许存在空格等其他字符

paddlex --export_inference --model_dir=./xiaoduxiong_epoch_12 --save_dir=./inference_model --fixed_input_shape=[640,960]

服务端部署¶

Python部署¶

PaddleX已经集成了基于Python的高性能预测接口，在安装PaddleX后，可参照如下代码示例，进行预测。相关的接口文档可参考paddlex.deploy

导出预测模型¶

可参考模型导出将模型导出为inference格式的模型。

预测部署¶

点击下载测试图片 xiaoduxiong_test_image.tar.gz

单张图片预测

import paddlex as pdx
predictor = pdx.deploy.Predictor('./inference_model')
result = predictor.predict(image='xiaoduxiong_test_image/JPEGImages/WeChatIMG110.jpeg')

批量图片预测

import paddlex as pdx
predictor = pdx.deploy.Predictor('./inference_model')
image_list = ['xiaoduxiong_test_image/JPEGImages/WeChatIMG110.jpeg',
    'xiaoduxiong_test_image/JPEGImages/WeChatIMG111.jpeg']
result = predictor.predict(image_list=image_list)

关于预测速度的说明：采用Paddle的Predictor进行预测时，由于涉及到内存显存初始化等原因，在模型加载后刚开始预测速度会较慢，一般在模型运行20~50后（即预测20~30张图片）预测速度才会稳定。

预测性能对比¶

测试环境¶

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

服务端C++部署¶

Windows平台部署¶

说明¶

Windows 平台下，我们使用Visual Studio 2019 Community 进行了测试。微软从Visual Studio 2017开始即支持直接管理CMake跨平台编译项目，但是直到2019才提供了稳定和完全的支持，所以如果你想使用CMake管理项目编译构建，我们推荐你使用Visual Studio 2019环境下构建。

前置条件¶

Visual Studio 2019
CUDA 9.0 / CUDA 10.0, CUDNN 7+ （仅在使用GPU版本的预测库时需要）
CMake 3.0+

请确保系统已经安装好上述基本软件，我们使用的是VS2019的社区版。

下面所有示例以工作目录为 D:\projects演示。

Step1: 下载PaddleX预测代码¶

d:
mkdir projects
cd projects
git clone https://github.com/PaddlePaddle/PaddleX.git

说明：其中C++预测代码在PaddleX\deploy\cpp 目录，该目录不依赖任何PaddleX下其他目录。

Step2: 下载PaddlePaddle C++ 预测库 paddle_inference¶

PaddlePaddle C++ 预测库针对是否使用GPU、是否支持TensorRT、以及不同的CUDA版本提供了已经编译好的预测库，目前PaddleX依赖于Paddle 1.8，基于Paddle 1.8的Paddle预测库下载链接如下所示:

版本说明	预测库(1.8.2版本)	编译器	构建工具	cuDNN	CUDA
cpu_avx_mkl	paddle_inference	MSVC 2015 update 3	CMake v3.16.0
cpu_avx_openblas	paddle_inference	MSVC 2015 update 3	CMake v3.16.0
cuda9.0_cudnn7_avx_mkl	paddle_inference	MSVC 2015 update 3	CMake v3.16.0	7.4.1	9.0
cuda9.0_cudnn7_avx_openblas	paddle_inference	MSVC 2015 update 3	CMake v3.16.0	7.4.1	9.0
cuda10.0_cudnn7_avx_mkl	paddle_inference	MSVC 2015 update 3	CMake v3.16.0	7.5.0	9.0

请根据实际情况选择下载，如若以上版本不满足您的需求，请至C++预测库下载列表选择符合的版本。

将预测库解压后，其所在目录（例如D:\projects\fluid_inference\）下主要包含的内容有：

├── \paddle\ # paddle核心库和头文件
|
├── \third_party\ # 第三方依赖库和头文件
|
└── \version.txt # 版本和编译信息

Step3: 安装配置OpenCV¶

在OpenCV官网下载适用于Windows平台的3.4.6版本，下载地址
运行下载的可执行文件，将OpenCV解压至指定目录，例如D:\projects\opencv
配置环境变量，如下流程所示
- 我的电脑->属性->高级系统设置->环境变量
- 在系统变量中找到Path（如没有，自行创建），并双击编辑
- 新建，将opencv路径填入并保存，如D:\projects\opencv\build\x64\vc14\bin

Step4: 使用Visual Studio 2019直接编译CMake¶

打开Visual Studio 2019 Community，点击继续但无需代码

_images/vs2019_step1.png step2 2. 点击： 文件->打开->CMake

_images/vs2019_step2.png step2.1

选择C++预测代码所在路径（例如D:\projects\PaddleX\deploy\cpp），并打开CMakeList.txt：

_images/vs2019_step3.png step2.2 3. 点击：项目->CMake设置

_images/vs2019_step4.png step3 4. 点击浏览，分别设置编译选项指定CUDA、OpenCV、Paddle预测库的路径

_images/vs2019_step5.png step3

依赖库路径的含义说明如下（带*表示仅在使用GPU版本预测库时指定, 其中CUDA库版本尽量与Paddle预测库的对齐，例如Paddle预测库是使用9.0、10.0版本编译的，则编译PaddleX预测代码时不使用9.2、10.1等版本CUDA库）：

参数名	含义
*CUDA_LIB	CUDA的库路径, 注：请将CUDNN的cudnn.lib文件拷贝到CUDA_LIB路径下
OPENCV_DIR	OpenCV的安装路径，
PADDLE_DIR	Paddle c++预测库的路径

注意：

如果使用CPU版预测库，请把WITH_GPU的值去掉勾
如果使用的是openblas版本，请把WITH_MKL的值去掉勾
Windows环境下编译会自动下载YAML，如果编译环境无法访问外网，可手动下载： yaml-cpp.zip yaml-cpp.zip文件下载后无需解压，在cmake/yaml.cmake中将URL https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip 中的网址，改为下载文件的路径。
如果需要使用模型加密功能，需要手动下载Windows预测模型加密工具。例如解压到D:/projects，解压后目录为D:/projects/paddlex-encryption。编译时需勾选WITH_EBNCRYPTION并且在ENCRTYPTION_DIR填入D:/projects/paddlex-encryption。

_images/vs2019_step_encryption.png step_encryption

_images/vs2019_step6.png step4

设置完成后, 点击上图中保存并生成CMake缓存以加载变量。 5. 点击生成->全部生成

_images/vs2019_step7.png step6

Step5: 预测及可视化¶

在加载模型前，请检查你的模型目录中文件应该包括model.yml、__model__和__params__三个文件。如若不满足这个条件，请参考模型导出为Inference文档将模型导出为部署格式。

上述Visual Studio 2019编译产出的可执行文件在out\build\x64-Release目录下，打开cmd，并切换到该目录：

D:
cd D:\projects\PaddleX\deploy\cpp\out\build\x64-Release

编译成功后，预测demo的入口程序为paddlex_inference\detector.exe，paddlex_inference\classifier.exe，paddlex_inference\segmenter.exe，用户可根据自己的模型类型选择，其主要命令参数说明如下：

参数	说明
model_dir	导出的预测模型所在路径
image	要预测的图片文件路径
image_list	按行存储图片路径的.txt文件
use_gpu	是否使用 GPU 预测, 支持值为0或1(默认值为0)
gpu_id	GPU 设备ID, 默认值为0
save_dir	保存可视化结果的路径, 默认值为"output"，classfier无该参数
key	加密过程中产生的密钥信息，默认值为""表示加载的是未加密的模型
batch_size	预测的批量大小，默认为1
thread_num	预测的线程数，默认为cpu处理器个数
use_ir_optim	是否使用图优化策略，支持值为0或1（默认值为1，图像分割默认值为0）

样例¶

可使用小度熊识别模型中导出的inference_model和测试图片进行预测, 例如导出到D:\projects，模型路径为D:\projects\inference_model。

关于预测速度的说明：Paddle在部署预测时，由于涉及到内存显存初始化等原因，在模型加载后刚开始预测速度会较慢，一般在模型运行20~50后（即预测20~30张图片）预测速度才会稳定。

样例一：(使用未加密的模型对单张图像做预测)¶

不使用GPU测试图片 D:\images\xiaoduxiong.jpeg

.\paddlex_inference\detector.exe --model_dir=D:\projects\inference_model --image=D:\images\xiaoduxiong.jpeg --save_dir=output

图片文件可视化预测结果会保存在save_dir参数设置的目录下。

样例二：(使用未加密的模型对图像列表做预测)¶

使用GPU预测多个图片D:\images\image_list.txt，image_list.txt内容的格式如下：

D:\images\xiaoduxiong1.jpeg
D:\images\xiaoduxiong2.jpeg
...
D:\images\xiaoduxiongn.jpeg

.\paddlex_inference\detector.exe --model_dir=D:\projects\inference_model --image_list=D:\images\image_list.txt --use_gpu=1 --save_dir=output --batch_size=2 --thread_num=2

图片文件可视化预测结果会保存在save_dir参数设置的目录下。

样例三：(使用加密后的模型对单张图片进行预测)¶

如果未对模型进行加密，请参考加密PaddleX模型对模型进行加密。例如加密后的模型所在目录为D:\projects\encrypted_inference_model。

.\paddlex_inference\detector.exe --model_dir=D:\projects\encrypted_inference_model --image=D:\images\xiaoduxiong.jpeg --save_dir=output --key=kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=

--key传入加密工具输出的密钥，例如kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=, 图片文件可视化预测结果会保存在save_dir参数设置的目录下。

Linux平台部署¶

说明¶

本文档在 Linux平台使用GCC 4.8.5 和 GCC 4.9.4测试过，如果需要使用更高G++版本编译使用，则需要重新编译Paddle预测库，请参考: 从源码编译Paddle预测库。

前置条件¶

G++ 4.8.2 ~ 4.9.4
CUDA 9.0 / CUDA 10.0, CUDNN 7+ （仅在使用GPU版本的预测库时需要）
CMake 3.0+

请确保系统已经安装好上述基本软件，下面所有示例以工作目录 /root/projects/演示。

Step1: 下载代码¶

git clone https://github.com/PaddlePaddle/PaddleX.git

说明：其中C++预测代码在/root/projects/PaddleX/deploy/cpp 目录，该目录不依赖任何PaddleX下其他目录。

Step2: 下载PaddlePaddle C++ 预测库 paddle_inference¶

PaddlePaddle C++ 预测库针对不同的CPU，CUDA，以及是否支持TensorRT，提供了不同的预编译版本，目前PaddleX依赖于Paddle1.8版本，以下提供了多个不同版本的Paddle预测库:

版本说明	预测库(1.8.2版本)
ubuntu14.04_cpu_avx_mkl	paddle_inference
ubuntu14.04_cpu_avx_openblas	paddle_inference
ubuntu14.04_cpu_noavx_openblas	paddle_inference
ubuntu14.04_cuda9.0_cudnn7_avx_mkl	paddle_inference
ubuntu14.04_cuda10.0_cudnn7_avx_mkl	paddle_inference
ubuntu14.04_cuda10.1_cudnn7.6_avx_mkl_trt6	paddle_inference

更多和更新的版本，请根据实际情况下载: C++预测库下载列表

下载并解压后/root/projects/fluid_inference目录包含内容为：

fluid_inference
├── paddle # paddle核心库和头文件
|
├── third_party # 第三方依赖库和头文件
|
└── version.txt # 版本和编译信息

注意: 预编译版本除nv-jetson-cuda10-cudnn7.5-trt5 以外其它包都是基于GCC 4.8.5编译，使用高版本GCC可能存在 ABI兼容性问题，建议降级或自行编译预测库。

Step3: 编译¶

编译cmake的命令在scripts/build.sh中，请根据实际情况修改主要参数，其主要内容说明如下：

# 是否使用GPU(即是否使用 CUDA)
WITH_GPU=OFF
# 使用MKL or openblas
WITH_MKL=ON
# 是否集成 TensorRT(仅WITH_GPU=ON 有效)
WITH_TENSORRT=OFF
# TensorRT 的路径，如果需要集成TensorRT，需修改为您实际安装的TensorRT路径
TENSORRT_DIR=/root/projects/TensorRT/
# Paddle 预测库路径, 请修改为您实际安装的预测库路径
PADDLE_DIR=/root/projects/fluid_inference
# Paddle 的预测库是否使用静态库来编译
# 使用TensorRT时，Paddle的预测库通常为动态库
WITH_STATIC_LIB=OFF
# CUDA 的 lib 路径
CUDA_LIB=/usr/local/cuda/lib64
# CUDNN 的 lib 路径
CUDNN_LIB=/usr/local/cuda/lib64

# 是否加载加密后的模型
WITH_ENCRYPTION=ON
# 加密工具的路径, 如果使用自带预编译版本可不修改
sh $(pwd)/scripts/bootstrap.sh # 下载预编译版本的加密工具
ENCRYPTION_DIR=$(pwd)/paddlex-encryption

# OPENCV 路径, 如果使用自带预编译版本可不修改
sh $(pwd)/scripts/bootstrap.sh  # 下载预编译版本的opencv
OPENCV_DIR=$(pwd)/deps/opencv3gcc4.8/

# 以下无需改动
rm -rf build
mkdir -p build
cd build
cmake .. \
    -DWITH_GPU=${WITH_GPU} \
    -DWITH_MKL=${WITH_MKL} \
    -DWITH_TENSORRT=${WITH_TENSORRT} \
    -DWITH_ENCRYPTION=${WITH_ENCRYPTION} \
    -DTENSORRT_DIR=${TENSORRT_DIR} \
    -DPADDLE_DIR=${PADDLE_DIR} \
    -DWITH_STATIC_LIB=${WITH_STATIC_LIB} \
    -DCUDA_LIB=${CUDA_LIB} \
    -DCUDNN_LIB=${CUDNN_LIB} \
    -DENCRYPTION_DIR=${ENCRYPTION_DIR} \
    -DOPENCV_DIR=${OPENCV_DIR}
make

注意： linux环境下编译会自动下载OPENCV, PaddleX-Encryption和YAML，如果编译环境无法访问外网，可手动下载：

opencv3gcc4.8.tar.bz2文件下载后解压，然后在script/build.sh中指定OPENCE_DIR为解压后的路径。

paddlex-encryption.zip文件下载后解压，然后在script/build.sh中指定ENCRYPTION_DIR为解压后的路径。

yaml-cpp.zip文件下载后无需解压，在cmake/yaml.cmake中将URL https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip 中的网址，改为下载文件的路径。

修改脚本设置好主要参数后，执行build脚本：

sh ./scripts/build.sh

Step4: 预测及可视化¶

在加载模型前，请检查你的模型目录中文件应该包括model.yml、__model__和__params__三个文件。如若不满足这个条件，请参考模型导出为Inference文档将模型导出为部署格式。

编译成功后，预测demo的可执行程序分别为build/demo/detector，build/demo/classifier，build/demo/segmenter，用户可根据自己的模型类型选择，其主要命令参数说明如下：

参数	说明
model_dir	导出的预测模型所在路径
image	要预测的图片文件路径
image_list	按行存储图片路径的.txt文件
use_gpu	是否使用 GPU 预测, 支持值为0或1(默认值为0)
use_trt	是否使用 TensorRT 预测, 支持值为0或1(默认值为0)
gpu_id	GPU 设备ID, 默认值为0
save_dir	保存可视化结果的路径, 默认值为"output"，classfier无该参数
key	加密过程中产生的密钥信息，默认值为""表示加载的是未加密的模型
batch_size	预测的批量大小，默认为1
thread_num	预测的线程数，默认为cpu处理器个数
use_ir_optim	是否使用图优化策略，支持值为0或1（默认值为1，图像分割默认值为0）

样例¶

可使用小度熊识别模型中导出的inference_model和测试图片进行预测，导出到/root/projects，模型路径为/root/projects/inference_model。

关于预测速度的说明：Paddle在部署预测时，由于涉及到内存显存初始化等原因，在模型加载后刚开始预测速度会较慢，一般在模型运行20~50后（即预测20~30张图片）预测速度才会稳定。

样例一：

不使用GPU测试图片 /root/projects/images/xiaoduxiong.jpeg

./build/demo/detector --model_dir=/root/projects/inference_model --image=/root/projects/images/xiaoduxiong.jpeg --save_dir=output

图片文件可视化预测结果会保存在save_dir参数设置的目录下。

样例二:

使用GPU预测多个图片/root/projects/image_list.txt，image_list.txt内容的格式如下：

/root/projects/images/xiaoduxiong1.jpeg
/root/projects/images/xiaoduxiong2.jpeg
...
/root/projects/images/xiaoduxiongn.jpeg

./build/demo/detector --model_dir=/root/projects/inference_model --image_list=/root/projects/images_list.txt --use_gpu=1 --save_dir=output --batch_size=2 --thread_num=2

图片文件可视化预测结果会保存在save_dir参数设置的目录下。

模型加密部署¶

PaddleX提供一个轻量级的模型加密部署方案，通过PaddleX内置的模型加密工具对推理模型进行加密，预测部署SDK支持直接加载密文模型并完成推理，提升AI模型部署的安全性。

目前加密方案已支持Windows，Linux系统

1. 方案简介¶

1.1 简介¶

（1）加密算法的选择和支持的库

一般使用OpenSSL库来支持数据的加解密，OpenSSL提供了大量的加解密算法，包括对称加密算法（AES等）和非对称加密算法（RSA等）。

两种算法使用的场景不同，非对称加密算法一般应用于数字签名和密钥协商的场景下，而对称加密算法一般应用于纯数据加密场景，性能更优。在对模型的加密过程中使用对称加密算法。

以下对模型加密场景实现的说明中以开发一个C/C++库为基础，采用AES对称加密算法，为了加解密前后能够快速判断解密是否成功，使用AES-GCM加解密模式，在密钥的安全性上使用长度为256位的密钥数据。

（2）实现模型保护的一般步骤：

_images/encryption_process.png

下面是对提供的C/C++加解密库内部实现的中文描述，参考以下步骤可以实现一套加解密库来适应自己的场景并通过内存数据加载到Paddle Inference预测库中

1）考虑到加密的模型文件解密后需要从内存加载数据，使用conbine的模式生成模型文件和参数文件。

2）项目集成OpenSSL，使用静态库的形式。

3）实现AES算法接口，借助OpenSSL提供的EVP接口，在EVP接口中指定算法类型，算法使用对称加解密算法中的AES，加解密模式使用AES-GCM，密钥长度为256位，AES-GCM的实现可以参考官方提供的例子自己进行封装接口：AES-GCM实现。

4）利用OpenSSL库实现SHA256摘要算法，这部分下面有用（可选）。关于SHA256的hash计算可以参考OpenSSL提供的example：OpenSSL 信息摘要例子。

5）在模型加密环节直接对model文件和params文件的数据内容进行加密后保存到新的文件，为了新的文件能够被区分和可迭代，除了加密后的数据外还添加了头部信息，比如为了判断该文件类型使用固定的魔数作为文件的开头；为了便于后面需求迭代写入版本号以示区别；为了能够在解密时判断是否采用了相同的密钥将加密时的密钥进行SHA256计算后存储；这三部分构成了目前加密后文件的头部信息。加密后的文件包含头部信息 + 密文信息。

6）在模型解密环节根据加密后的文件读取相关的加密数据到内存中，对内存数据使用AES算法进行解密，注意解密时需要采用与加密时一致的加密算法和加密的模式，以及密钥的数据和长度，否则会导致解密后数据错误。

7）集成模型预测的C/C++库，在具体使用预测时一般涉及paddle::AnalysisConfig和paddle:Predictor，为了能够从内存数据中直接load解密后的模型明文数据（避免模型解密后创建临时文件），这里需要将AnalysisConfig的模型加载函数从SetModel替换为SetModelBuffer来实现从内存中加载模型数据。

需要注意的是，在本方案中，密钥集成在上层预测服务的代码中。故模型的安全强度等同于代码抵御逆向调试的强度。为了保护密钥和模型的安全，开发者还需对自己的应用进行加固保护。常见的应用加固手段有：代码混淆，二进制文件加壳等等，亦或将加密机制更改为AES白盒加密技术来保护密钥。这类技术领域内有大量商业和开源产品可供选择，此处不一一赘述。

1.2 加密工具¶

Linux版本 PaddleX模型加密工具，编译脚本会自动下载该版本加密工具，您也可以选择手动下载。

Windows版本 PaddleX模型加密工具，该版本加密工具需手动下载，如果您在使用Visual Studio 2019编译C++预测代码的过程中已经下载过该工具，此处可不必重复下载。

Linux加密工具包含内容为：

paddlex-encryption
├── include # 头文件：paddle_model_decrypt.h（解密）和paddle_model_encrypt.h（加密）
|
├── lib # libpmodel-encrypt.so和libpmodel-decrypt.so动态库
|
└── tool # paddlex_encrypt_tool

Windows加密工具包含内容为：

paddlex-encryption
├── include # 头文件：paddle_model_decrypt.h（解密）和paddle_model_encrypt.h（加密）
|
├── lib # pmodel-encrypt.dll和pmodel-decrypt.dll动态库 pmodel-encrypt.lib和pmodel-encrypt.lib静态库
|
└── tool # paddlex_encrypt_tool.exe 模型加密工具

1.3 加密PaddleX模型¶

对模型完成加密后，加密工具会产生随机密钥信息(用于AES加解密使用），需要在后续加密部署时传入该密钥来用于解密。

密钥由32字节key + 16字节iv组成，注意这里产生的key是经过base64编码后的，这样可以扩充key的选取范围

Linux平台:

# 假设模型在/root/projects下
./paddlex-encryption/tool/paddlex_encrypt_tool -model_dir /root/projects/paddlex_inference_model -save_dir /root/projects/paddlex_encrypted_model

Windows平台:

# 假设模型在D:/projects下
.\paddlex-encryption\tool\paddlex_encrypt_tool.exe -model_dir D:\projects\paddlex_inference_model -save_dir D:\projects\paddlex_encrypted_model

-model_dir用于指定inference模型路径（参考导出inference模型将模型导出为inference格式模型），可使用导出小度熊识别模型中导出的inference_model。加密完成后，加密过的模型会保存至指定的-save_dir下，包含__model__.encrypted、__params__.encrypted和model.yml三个文件，同时生成密钥信息，命令输出如下图所示，密钥为kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=

_images/encrypt.png

2. PaddleX C++加密部署¶

2.1 Linux平台使用¶

参考Linux平台编译指南编译C++部署代码。编译成功后，预测demo的可执行程序分别为build/demo/detector，build/demo/classifier，build/demo/segmenter，用户可根据自己的模型类型选择，其主要命令参数说明如下：

参数	说明
model_dir	导出的预测模型所在路径
image	要预测的图片文件路径
image_list	按行存储图片路径的.txt文件
use_gpu	是否使用 GPU 预测, 支持值为0或1(默认值为0)
use_trt	是否使用 TensorRT 预测, 支持值为0或1(默认值为0)
gpu_id	GPU 设备ID, 默认值为0
save_dir	保存可视化结果的路径, 默认值为"output"，classifier无该参数
key	加密过程中产生的密钥信息，默认值为""表示加载的是未加密的模型
batch_size	预测的批量大小，默认为1
thread_num	预测的线程数，默认为cpu处理器个数
use_ir_optim	是否使用图优化策略，支持值为0或1（默认值为1，图像分割默认值为0）

样例¶

可使用导出小度熊识别模型中的测试图片进行预测。

样例一：¶

不使用GPU测试图片 /root/projects/images/xiaoduxiong.jpeg

./build/demo/detector --model_dir=/root/projects/paddlex_encrypted_model --image=/root/projects/xiaoduxiong.jpeg --save_dir=output --key=kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=

--key传入加密工具输出的密钥，例如kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=, 图片文件可视化预测结果会保存在save_dir参数设置的目录下。

样例二:¶

使用GPU预测多个图片/root/projects/image_list.txt，image_list.txt内容的格式如下：

/root/projects/images/xiaoduxiong1.jpeg
/root/projects/xiaoduxiong2.jpeg
...
/root/projects/xiaoduxiongn.jpeg

./build/demo/detector --model_dir=/root/projects/models/paddlex_encrypted_model --image_list=/root/projects/images_list.txt --use_gpu=1 --save_dir=output --key=kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=

--key传入加密工具输出的密钥，例如kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=, 图片文件可视化预测结果会保存在save_dir参数设置的目录下。

2.2 Windows平台使用¶

参考Windows平台编译指南。需自行下载Windows版PaddleX加密工具压缩包，解压，在编译指南的编译流程基础上，在CMake设置中勾选WITH_ENCRYPTION，ENCRYPTION_DIR填写为加密工具包解压后的目录，再进行编译。参数与Linux版本预测部署一致。预测demo的入口程序为paddlex_inference\detector.exe，paddlex_inference\classifier.exe，paddlex_inference\segmenter.exe。

样例¶

可使用导出小度熊识别模型中的测试图片进行预测。

样例一：¶

不使用GPU测试单张图片，例如图片为D:\images\xiaoduxiong.jpeg，加密后的模型目录为D:\projects\paddlex_encrypted_model

.\paddlex_inference\detector.exe --model_dir=D:\projects\paddlex_encrypted_model --image=D:\images\xiaoduxiong.jpeg --save_dir=output --key=kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=

--key传入加密工具输出的密钥，例如kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=, 图片文件可视化预测结果会保存在save_dir参数设置的目录下。

样例二:¶

使用GPU预测图片列表，例如图片列表为D:\projects\image_list.txt，image_list.txt的内容如下：

D:\projects\images\xiaoduxiong1.jpeg
D:\projects\images\xiaoduxiong2.jpeg
...
D:\projects\images\xiaoduxiongn.jpeg

加密后的模型目录例如为D:\projects\paddlex_encrypted_model

.\paddlex_inference\detector.exe --model_dir=D:\projects\paddlex_encrypted_model --image_list=D:\projects\images_list.txt --use_gpu=1 --save_dir=output --key=kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=

--key传入加密工具输出的密钥，例如kLAl1qOs5uRbFt0/RrIDTZW2+tOf5bzvUIaHGF8lJ1c=, 图片文件可视化预测结果会保存在save_dir参数设置的目录下。

Nvidia-Jetson开发板¶

说明¶

本文档在 Linux平台使用GCC 4.8.5 和 GCC 4.9.4测试过，如果需要使用更高G++版本编译使用，则需要重新编译Paddle预测库，请参考: NVIDIA Jetson嵌入式硬件预测库源码编译。

前置条件¶

G++ 4.8.2 ~ 4.9.4
CUDA 9.0 / CUDA 10.0, CUDNN 7+ （仅在使用GPU版本的预测库时需要）
CMake 3.0+

请确保系统已经安装好上述基本软件，下面所有示例以工作目录 /root/projects/演示。

Step1: 下载代码¶

git clone https://github.com/PaddlePaddle/PaddleX.git

说明：其中C++预测代码在/root/projects/PaddleX/deploy/cpp 目录，该目录不依赖任何PaddleX下其他目录。

Step2: 下载PaddlePaddle C++ 预测库 paddle_inference¶

目前PaddlePaddle为Nvidia-Jetson 提供了一个基于1.6.2版本的C++ 预测库。

版本说明	预测库(1.6.2版本)
nv-jetson-cuda10-cudnn7.5-trt5	paddle_inference

下载并解压后/root/projects/fluid_inference目录包含内容为：

fluid_inference
├── paddle # paddle核心库和头文件
|
├── third_party # 第三方依赖库和头文件
|
└── version.txt # 版本和编译信息

Step3: 编译¶

编译cmake的命令在scripts/jetson_build.sh中，请根据实际情况修改主要参数，其主要内容说明如下：

# 是否使用GPU(即是否使用 CUDA)
WITH_GPU=OFF
# 使用MKL or openblas
WITH_MKL=OFF
# 是否集成 TensorRT(仅WITH_GPU=ON 有效)
WITH_TENSORRT=OFF
# TensorRT 的路径，如果需要集成TensorRT，需修改为您实际安装的TensorRT路径
TENSORRT_DIR=/root/projects/TensorRT/
# Paddle 预测库路径, 请修改为您实际安装的预测库路径
PADDLE_DIR=/root/projects/fluid_inference
# Paddle 的预测库是否使用静态库来编译
# 使用TensorRT时，Paddle的预测库通常为动态库
WITH_STATIC_LIB=OFF
# CUDA 的 lib 路径
CUDA_LIB=/usr/local/cuda/lib64
# CUDNN 的 lib 路径
CUDNN_LIB=/usr/local/cuda/lib64

# 是否加载加密后的模型
WITH_ENCRYPTION=OFF

# OPENCV 路径, 如果使用自带预编译版本可不修改
sh $(pwd)/scripts/jetson_bootstrap.sh  # 下载预编译版本的opencv
OPENCV_DIR=$(pwd)/deps/opencv3/

# 以下无需改动
rm -rf build
mkdir -p build
cd build
cmake .. \
    -DWITH_GPU=${WITH_GPU} \
    -DWITH_MKL=${WITH_MKL} \
    -DWITH_TENSORRT=${WITH_TENSORRT} \
    -DWITH_ENCRYPTION=${WITH_ENCRYPTION} \
    -DTENSORRT_DIR=${TENSORRT_DIR} \
    -DPADDLE_DIR=${PADDLE_DIR} \
    -DWITH_STATIC_LIB=${WITH_STATIC_LIB} \
    -DCUDA_LIB=${CUDA_LIB} \
    -DCUDNN_LIB=${CUDNN_LIB} \
    -DENCRYPTION_DIR=${ENCRYPTION_DIR} \
    -DOPENCV_DIR=${OPENCV_DIR}
make

注意： linux环境下编译会自动下载OPENCV和YAML，如果编译环境无法访问外网，可手动下载：

opencv3_aarch.tgz文件下载后解压，然后在script/build.sh中指定OPENCE_DIR为解压后的路径。

yaml-cpp.zip文件下载后无需解压，在cmake/yaml.cmake中将URL https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip 中的网址，改为下载文件的路径。

修改脚本设置好主要参数后，执行build脚本：

sh ./scripts/jetson_build.sh

Step4: 预测及可视化¶

在加载模型前，请检查你的模型目录中文件应该包括model.yml、__model__和__params__三个文件。如若不满足这个条件，请参考模型导出为Inference文档将模型导出为部署格式。

编译成功后，预测demo的可执行程序分别为build/demo/detector，build/demo/classifier，build/demo/segmenter，用户可根据自己的模型类型选择，其主要命令参数说明如下：

参数	说明
model_dir	导出的预测模型所在路径
image	要预测的图片文件路径
image_list	按行存储图片路径的.txt文件
use_gpu	是否使用 GPU 预测, 支持值为0或1(默认值为0)
use_trt	是否使用 TensorRT 预测, 支持值为0或1(默认值为0)
gpu_id	GPU 设备ID, 默认值为0
save_dir	保存可视化结果的路径, 默认值为"output"，classfier无该参数
key	加密过程中产生的密钥信息，默认值为""表示加载的是未加密的模型
batch_size	预测的批量大小，默认为1
thread_num	预测的线程数，默认为cpu处理器个数
use_ir_optim	是否使用图优化策略，支持值为0或1（默认值为1，图像分割默认值为0）

样例¶

可使用小度熊识别模型中导出的inference_model和测试图片进行预测，导出到/root/projects，模型路径为/root/projects/inference_model。

样例一：

不使用GPU测试图片 /root/projects/images/xiaoduxiong.jpeg

./build/demo/detector --model_dir=/root/projects/inference_model --image=/root/projects/images/xiaoduxiong.jpeg --save_dir=output

图片文件可视化预测结果会保存在save_dir参数设置的目录下。

样例二:

使用GPU预测多个图片/root/projects/image_list.txt，image_list.txt内容的格式如下：

/root/projects/images/xiaoduxiong1.jpeg
/root/projects/images/xiaoduxiong2.jpeg
...
/root/projects/images/xiaoduxiongn.jpeg

./build/demo/detector --model_dir=/root/projects/inference_model --image_list=/root/projects/images_list.txt --use_gpu=1 --save_dir=output --batch_size=2 --thread_num=2

图片文件可视化预测结果会保存在save_dir参数设置的目录下。

PaddleLite移动端部署¶

模型压缩¶

模型量化¶

为了更好地满足端侧部署场景下，低内存带宽、低功耗、低计算资源占用以及低模型存储等需求，PaddleX通过集成PaddleSlim实现模型量化，可提升PaddleLite端侧部署性能。

原理介绍¶

定点量化使用更少的比特数（如8-bit、3-bit、2-bit等）表示神经网络的权重和激活值，从而加速模型推理速度。PaddleX提供了训练后量化技术，其原理可参见训练后量化原理，该量化使用KL散度确定量化比例因子，将FP32模型转成INT8模型，且不需要重新训练，可以快速得到量化模型。

使用PaddleX量化模型¶

PaddleX提供了export_quant_model接口，让用户以接口的形式完成模型以post_quantization方式量化并导出。点击查看量化接口使用文档。

量化性能对比¶

模型量化后的性能对比指标请查阅PaddleSlim模型库

模型裁剪¶

为了更好地满足端侧部署场景下，低内存带宽、低功耗、低计算资源占用以及低模型存储等需求，PaddleX通过集成PaddleSlim实现模型裁剪，可提升PaddleLite端侧部署性能。

原理介绍¶

模型裁剪通过裁剪卷积层中Kernel输出通道的大小及其关联层参数大小，来减小模型大小和降低模型计算复杂度，可以加快模型部署后的预测速度，其关联裁剪的原理可参见PaddleSlim相关文档。一般而言，在同等模型精度前提下，数据复杂度越低，模型可以被裁剪的比例就越高。

裁剪方法¶

PaddleX提供了两种方式:

1.用户自行计算裁剪配置(推荐)，整体流程包含三个步骤,

第一步：使用数据集训练原始模型第二步：利用第一步训练好的模型，在验证数据集上计算模型中各个参数的敏感度，并将敏感度信息存储至本地文件第三步：使用数据集训练裁剪模型（与第一步差异在于需要在train接口中，将第二步计算得到的敏感信息文件传给接口的sensitivities_file参数）

在如上三个步骤中，相当于模型共需要训练两遍，分别对应第一步和第三步，但其中第三步训练的是裁剪后的模型，因此训练速度较第一步会更快。第二步会遍历模型中的部分裁剪参数，分别计算各个参数裁剪后对于模型在验证集上效果的影响，因此会反复在验证集上评估多次。

2.使用PaddleX内置的裁剪方案

PaddleX内置的模型裁剪方案是基于标准数据集上计算得到的参数敏感度信息，由于不同数据集特征分布会有较大差异，所以该方案相较于第1种方案训练得到的模型精度一般而言会更低（且用户自定义数据集与标准数据集特征分布差异越大，导致训练的模型精度会越低），仅在用户想节省时间的前提下可以参考使用，使用方式只需一步，

一步：使用数据集训练裁剪模型，在训练调用train接口时，将接口中的sensitivities_file参数设置为’DEFAULT’字符串

注：各模型内置的裁剪方案分别依据的数据集为：图像分类——ImageNet数据集、目标检测——PascalVOC数据集、语义分割——CityScape数据集

裁剪实验¶

基于上述两种方案，我们在PaddleX上使用样例数据进行了实验，在Tesla P40上实验指标如下所示:

图像分类¶

实验背景：使用MobileNetV2模型，数据集为蔬菜分类示例数据，裁剪训练代码见tutorials/compress/classification

模型	裁剪情况	模型大小	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

模型	裁剪情况	模型大小	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

模型	裁剪情况	模型大小	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

Android平台¶

PaddleX的安卓端部署由PaddleLite实现，部署的流程如下，首先将训练好的模型导出为inference model，然后对模型进行优化，最后使用PaddleLite的预测库进行部署，PaddleLite的详细介绍和使用可参考：PaddleLite文档

PaddleX –> Inference Model –> PaddleLite Opt –> PaddleLite Inference

文章简介：

1.介绍如何将PaddleX导出为inference model
2.使用PaddleLite的OPT模块对模型进行优化
3.介绍基于PaddleX Android SDK的安卓demo，以及如何快速部署训练好的模型
4.介绍PaddleX Android SDK和二次开发

1. 将PaddleX模型导出为inference模型¶

参考导出inference模型将模型导出为inference格式模型。

2. 将inference模型优化为PaddleLite模型¶

目前提供了两种方法将Paddle模型优化为PaddleLite模型:

1.python脚本优化模型，简单上手，目前支持最新的PaddleLite 2.6.1版本
2.bin文件优化模型(linux)，支持develop版本(Commit Id:11cbd50e)，适用于部署DeepLab模型和Unet模型的用户。

2.1 使用python脚本优化模型¶

pip install paddlelite
python export_lite.py --model_dir /path/to/inference_model --save_file /path/to/lite_model_name --place place/to/run

其中export_lite.py脚本请至github下载：https://github.com/PaddlePaddle/PaddleX/blob/develop/deploy/lite/export_lite.py

参数	说明
--model_dir	预测模型所在路径，包含"__model__", "__params__", "model.yml"文件
--save_file	模型输出的名称，假设为/path/to/lite_model_name, 则输出为路径为/path/to/lite_model_name.nb
--place	运行的平台，可选：arm\|opencl\|x86\|npu\|xpu\|rknpu\|apu，安卓部署请选择`arm`

2.3 使用bin文件优化模型(linux)¶

首先下载并解压: 模型优化工具opt

./opt --model_file=<model_path> \
      --param_file=<param_path> \
      --valid_targets=arm \
      --optimize_out_type=naive_buffer \
      --optimize_out=model_output_name

参数	说明
--model_file	导出inference模型中包含的网络结构文件：`__model__`所在的路径
--param_file	导出inference模型中包含的参数文件：`__params__`所在的路径
--valid_targets	指定模型可执行的backend，这里请指定为`arm`
--optimize_out_type	输出模型类型，目前支持两种类型：protobuf和naive_buffer，其中naive_buffer是一种更轻量级的序列化/反序列化，这里请指定为`naive_buffer`

详细的使用方法和参数含义请参考: 使用opt转化模型

3. 移动端（Android）Demo¶

PaddleX提供了一个基于Mobilenetv2模型和PaddleX Android SDK的安卓demo，可供用户体验，该demo位于/PaddleX/deploy/lite/android/demo，可直接导入Android Studio后运行，并支持用户替换其他PaddleX导出的检测或分割模型进行预测。

3.1 要求¶

Android Studio 3.4
Android手机或开发板

3.2 分类Demo¶

3.2.1 导入工程并运行¶

打开Android Studio，在”Welcome to Android Studio”窗口点击”Open an existing Android Studio project”，在弹出的路径选择窗口中进入/PaddleX/deploy/lite/android/demo目录，然后点击右下角的”Open”按钮，导入工程；
通过USB连接Android手机或开发板；
载入工程后，点击菜单栏的Run->Run ‘App’按钮，在弹出的”Select Deployment Target”窗口选择已经连接的Android设备，然后点击”OK”按钮；
运行成功后，Android设备将加载一个名为PaddleX Demo的App，默认会加载一个测试图片，同时还支持拍照和从图库选择照片进行预测；

注意：在工程构建的过程中会远程下载Mobilenetv2模型、yml配置文件、测试的图片，以及PaddleX Android SDK。

3.3 部署自定义模型¶

该demo还支持用户自定义模型来进行预测，可帮助用户快速验证自己训练好的模型，首先我们已经根据step1~step2描述，准备好了Lite模型(.nb文件)和yml配置文件(注意：导出Lite模型时需指定–place=arm)，然后在Android Studio的project视图中：

将.nb文件拷贝到/src/main/assets/model/目录下, 根据.nb文件的名字，修改文件/src/main/res/values/strings.xml中的MODEL_PATH_DEFAULT；
将.yml文件拷贝到/src/main/assets/config/目录下，根据.yml文件的名字，修改文件/src/main/res/values/strings.xml中的YAML_PATH_DEFAULT；
可根据需要替换测试图片，将图片拷贝到/src/main/assets/images/目录下，根据图片文件的名字，修改文件/src/main/res/values/strings.xml中的IMAGE_PATH_DEFAULT；
点击菜单栏的Run->Run ‘App’按钮，在弹出的”Select Deployment Target”窗口选择已经连接的Android设备，然后点击”OK”按钮；

4. PaddleX Android SDK和二次开发¶

PaddleX Android SDK是PaddleX基于Paddle-Lite开发的安卓端AI推理工具，以PaddleX导出的Yaml配置文件为接口，针对不同的模型实现图片的预处理，后处理，并进行可视化，开发者可集成到业务中。该SDK自底向上主要包括：Paddle-Lite推理引擎层，Paddle-Lite接口层以及PaddleX业务层。

Paddle-Lite推理引擎层，是在Android上编译好的二进制包，只涉及到Kernel 的执行，且可以单独部署，以支持极致的轻量级部署。
Paddle-Lite接口层，以Java接口封装了底层c++推理库。
PaddleX业务层，封装了PaddleX导出模型的预处理，推理和后处理，以及可视化，支持PaddleX导出的检测、分割、分类模型。

_images/paddlex_android_sdk_framework.jpg 架构

4.1 SDK安装¶

首先下载并解压PaddleX Android SDK，得到paddlex.aar文件，将拷贝到android工程目录app/libs/下面，然后为app的build.gradle添加依赖：

dependencies {
    implementation fileTree(include: ['*.jar','*aar'], dir: 'libs')
}

4.2 SDK使用用例¶

import com.baidu.paddlex.Predictor;
import com.baidu.paddlex.config.ConfigParser;
import com.baidu.paddlex.postprocess.DetResult;
import com.baidu.paddlex.postprocess.SegResult;
import com.baidu.paddlex.postprocess.ClsResult;
import com.baidu.paddlex.visual.Visualize;

// Predictor
Predictor predictor = new Predictor();
// model config
ConfigParser configParser = new ConfigParser();
// Visualize
Visualize visualize = new Visualize();
// image to predict
Mat predictMat;

// initialize
configParser.init(context, model_path, yaml_path, cpu_thread_num, cpu_power_mode);
visualize.init(configParser.getNumClasses());
predictor.init(context, configParser)

// run model
if (predictImage != null && predictor.isLoaded()) {
    predictor.setInputMat(predictMat);
    runModel();
}

// get result & visualize
if (configParser.getModelType().equalsIgnoreCase("segmenter")) {
    SegResult segResult = predictor.getSegResult();
    Mat visualizeMat  = visualize.draw(segResult, predictMat, predictor.getImageBlob());
} else if (configParser.getModelType().equalsIgnoreCase("detector")) {
    DetResult detResult = predictor.getDetResult();
    Mat visualizeMat = visualize.draw(detResult, predictMat);
} else if (configParser.getModelType().equalsIgnoreCase("classifier")) {
    ClsResult clsResult = predictor.getClsResult();
}

4.3 Result成员变量¶

注意：Result所有的成员变量以java bean的方式获取。

com.baidu.paddlex.postprocess.ClsResult

Fields¶

type (String|static): 值为”cls”。

categoryId (int): 类别ID。

category (String): 类别名称。

score (float): 预测置信度。

com.baidu.paddlex.postprocess.DetResult

Nested classes¶

DetResult.Box 模型预测的box结果。

Fields¶

type (String|static): 值为”det”。

boxes (List<DetResult.Box>): 模型预测的box结果。

com.baidu.paddlex.postprocess.DetResult.Box

Fields¶

categoryId (int): 类别ID。

category (String): 类别名称。

score (float): 预测置信度。

coordinate (float[4]): 预测框值:{xmin, ymin, xmax, ymax}。

com.baidu.paddlex.postprocess.SegResult

Nested classes¶

SegResult.Mask: 模型预测的mask结果。

Fields¶

type (String|static): 值为”Seg”。

mask (SegResult.Mask): 模型预测的mask结果。

com.baidu.paddlex.postprocess.SegResult.Mask

Fields¶

scoreData (float[]): 模型预测在各个类别的置信度，长度为: 1 * numClass * H * W

scoreShape (long[4]): scoreData的shape信息，[1,numClass,H,W]

labelData (long[]): 模型预测置信度最高的label，长度为: 1 * H * W * 1

labelShape (long[4]): labelData的shape信息，[1,H,W,1]

4.4 SDK二次开发¶

打开Android Studio新建项目(或加载已有项目)。点击菜单File->New->Import Module，导入工程/PaddleX/deploy/lite/android/sdk, Project视图会新增名为sdk的module
在app的build.grade里面添加依赖:

 dependencies {
     implementation project(':sdk')
 }

源代码位于sdk/main/java/下，修改源码进行二次开发后，点击菜单栏的Build->Run ‘sdk’按钮可编译生成aar，文件位于sdk/build/outputs/aar/路径下。

产业案例集¶

PaddleX精选飞桨视觉开发套件在产业实践中的成熟模型结构，提供统一易用的全流程API和模型部署SDK，打通模型在各种硬件设备上的部署流程，开放从模型训练到多端安全部署的全流程案例实践教程。

PaddleX模型介绍¶

PaddleX针对图像分类、目标检测、实例分割和语义分割4种视觉任务提供了丰富的模型算法，用户根据在实际场景中的需求选择合适的模型。

图像分类¶

图像分类任务指的是输入一张图片，模型预测图片的类别，如识别为风景、动物、车等。

_images/image_classification.png

对于图像分类任务，针对不同的应用场景，PaddleX提供了百度改进的模型，见下表所示:

表中GPU预测速度是使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla P40）。表中CPU预测速度 (测试CPU型号为)。表中骁龙855预测速度是使用处理器为骁龙855的手机测试得到。测速时模型输入大小为224 x 224，Top1准确率为ImageNet-1000数据集上评估所得。

模型	模型特点	存储体积	GPU预测速度（毫秒）	CPU(x86)预测速度（毫秒）	骁龙855(ARM)预测速度（毫秒）	Top1准确率
MobileNetV3_small_ssld	轻量高速，适用于追求高速的实时移动端场景	12.5MB	7.08837	-	6.546	71.3.0%
ShuffleNetV2	轻量级模型，精度相对偏低，适用于要求更小存储体积的实时移动端场景	10.2MB	15.40	-	10.941	68.8%
MobileNetV3_large_ssld	轻量级模型，在存储方面优势不大，在速度和精度上表现适中，适合于移动端场景	22.8MB	8.06651	-	19.803	79.0%
MobileNetV2	轻量级模型，适用于使用GPU预测的移动端场景	15.0MB	5.92667	-	23.318	72.2 %
ResNet50_vd_ssld	高精度模型，预测时间较短，适用于大多数的服务器端场景	103.5MB	7.79264	-	-	82.4%
ResNet101_vd_ssld	超高精度模型，预测时间相对较长，适用于有大数据量时的服务器端场景	180.5MB	13.34580	-	-	83.7%
Xception65	超高精度模型，预测时间更长，在处理较大数据量时有较高的精度，适用于服务器端场景	161.6MB	13.87017	-	-	80.3%

包括上述模型，PaddleX支持近20种图像分类模型，其余模型可参考PaddleX模型库

目标检测¶

目标检测任务指的是输入图像，模型识别出图像中物体的位置（用矩形框框出来，并给出框的位置），和物体的类别，如在手机等零件质检中，用于检测外观上的瑕疵等。

_images/object_detection.png

对于目标检测，针对不同的应用场景，PaddleX提供了主流的YOLOv3模型和Faster-RCNN模型，见下表所示

表中GPU预测速度是使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla P40）。表中CPU预测速度 (测试CPU型号为)。表中骁龙855预测速度是使用处理器为骁龙855的手机测试得到。测速时YOLOv3的输入大小为608 x 608，FasterRCNN的输入大小为800 x 1333，Box mmAP为COCO2017数据集上评估所得。

模型	模型特点	存储体积	GPU预测速度	CPU(x86)预测速度（毫秒）	骁龙855(ARM)预测速度（毫秒）	Box mmAP
YOLOv3-MobileNetV3_larget	适用于追求高速预测的移动端场景	100.7MB	143.322	-	-	31.6
YOLOv3-MobileNetV1	精度相对偏低，适用于追求高速预测的服务器端场景	99.2MB	15.422	-	-	29.3
YOLOv3-DarkNet53	在预测速度和模型精度上都有较好的表现，适用于大多数的服务器端场景	249.2MB	42.672	-	-	38.9
FasterRCNN-ResNet50-FPN	经典的二阶段检测器，预测速度相对较慢，适用于重视模型精度的服务器端场景	167.MB	83.189	-	-	37.2
FasterRCNN-HRNet_W18-FPN	适用于对图像分辨率较为敏感、对目标细节预测要求更高的服务器端场景	115.5MB	81.592	-	-	36
FasterRCNN-ResNet101_vd-FPN	超高精度模型，预测时间更长，在处理较大数据量时有较高的精度，适用于服务器端场景	244.3MB	156.097	-	-	40.5

除上述模型外，YOLOv3和Faster RCNN还支持其他backbone，详情可参考PaddleX模型库

实例分割¶

在目标检测中，模型识别出图像中物体的位置和物体的类别。而实例分割则是在目标检测的基础上，做了像素级的分类，将框内的属于目标物体的像素识别出来。

_images/instance_segmentation.png

PaddleX目前提供了实例分割MaskRCNN模型，支持5种不同的backbone网络，详情可参考PaddleX模型库

表中GPU预测速度是使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla P40）。表中CPU预测速度 (测试CPU型号为)。表中骁龙855预测速度是使用处理器为骁龙855的手机测试得到。测速时MaskRCNN的输入大小为800 x 1333，Box mmAP和Seg mmAP为COCO2017数据集上评估所得。

模型	模型特点	存储体积	GPU预测速度	CPU(x86)预测速度（毫秒）	骁龙855(ARM)预测速度（毫秒）	Box mmAP	Seg mmAP
MaskRCNN-HRNet_W18-FPN	适用于对图像分辨率较为敏感、对目标细节预测要求更高的服务器端场景	143.9MB	-	-	-	38.2	33.4
MaskRCNN-ResNet50-FPN	精度较高，适合大多数的服务器端场景	177.7M	-	-	-	38.7	34.7
MaskRCNN-ResNet101_vd-FPN	高精度但预测时间更长，在处理较大数据量时有较高的精度，适用于服务器端场景	253.7M	-	-	-	41.4	36.8

语义分割¶

语义分割用于对图像做像素级的分类，应用在人像分类、遥感图像识别等场景。

_images/semantic_segmentation.png

对于语义分割，PaddleX也针对不同的应用场景，提供了不同的模型选择，如下表所示

表中GPU预测速度是使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla P40）。表中CPU预测速度 (测试CPU型号为)。表中骁龙855预测速度是使用处理器为骁龙855的手机测试得到。测速时模型的输入大小为1024 x 2048，mIOU为Cityscapes数据集上评估所得。

模型	模型特点	存储体积	GPU预测速度	CPU(x86)预测速度（毫秒）	骁龙855(ARM)预测速度（毫秒）
DeepLabv3p-MobileNetV2_x1.0	轻量级模型，适用于移动端场景	-	-	-	69.8%
HRNet_W18_Small_v1	轻量高速，适用于移动端场景	-	-	-	-
FastSCNN	轻量高速，适用于追求高速预测的移动端或服务器端场景	-	-	-	69.64
HRNet_W18	高精度模型，适用于对图像分辨率较为敏感、对目标细节预测要求更高的服务器端场景	-	-	-	79.36
DeepLabv3p-Xception65	高精度但预测时间更长，在处理较大数据量时有较高的精度，适用于服务器且背景复杂的场景	-	-	-	79.3%

工业表计读数¶

本案例基于PaddleX实现对传统机械式指针表计的检测与自动读数功能，开放表计数据和预训练模型，并提供在windows系统的服务器端以及linux系统的jetson嵌入式设备上的部署指南。

读数流程¶

表计读数共分为三个步骤完成：

第一步，使用目标检测模型检测出图像中的表计
第二步，使用语义分割模型将各表计的指针和刻度分割出来
第三步，根据指针的相对位置和预知的量程计算出各表计的读数

_images/MeterReader_Architecture.jpg MeterReader_Architecture

表计检测：由于本案例中没有面积较小的表计，所以目标检测模型选择性能更优的YOLOv3。考虑到本案例主要在有GPU的设备上部署，所以骨干网路选择精度更高的DarkNet53。
刻度和指针分割：考虑到刻度和指针均为细小区域，语义分割模型选择效果更好的DeepLapv3。
读数后处理：首先，对语义分割的预测类别图进行图像腐蚀操作，以达到刻度细分的目的。然后把环形的表盘展开为矩形图像，根据图像中类别信息生成一维的刻度数组和一维的指针数组。接着计算刻度数组的均值，用均值对刻度数组进行二值化操作。最后定位出指针相对刻度的位置，根据刻度的根数判断表盘的类型以此获取表盘的量程，将指针相对位置与量程做乘积得到表盘的读数。

表计数据和预训练模型¶

本案例开放了表计测试图片，用于体验表计读数的预测推理全流程。还开放了表计检测数据集、指针和刻度分割数据集，用户可以使用这些数据集重新训练模型。

表计测试图片	表计检测数据集	指针和刻度分割数据集
meter_test	meter_det	meter_seg

本案例开放了预先训练好的检测模型和语义分割模型，可以使用这些模型快速体验表计读数全流程，也可以直接将这些模型部署在服务器端或jetson嵌入式设备上进行推理预测。

表计检测模型	指针和刻度分割模型
meter_det_inference_model	meter_seg_inference_model

快速体验表盘读数¶

可以使用本案例提供的预训练模型快速体验表计读数的自动预测全流程。如果不需要预训练模型，可以跳转至小节模型训练 重新训练模型。

前置依赖¶

Paddle paddle >= 1.8.0
Python >= 3.5
PaddleX >= 1.0.0

安装的相关问题参考PaddleX安装

测试表计读数¶

下载PaddleX源码:

git clone https://github.com/PaddlePaddle/PaddleX

预测执行文件位于PaddleX/examples/meter_reader/，进入该目录：

cd PaddleX/examples/meter_reader/

预测执行文件为reader_infer.py，其主要参数说明如下：

参数	说明
detector_dir	表计检测模型路径
segmenter_dir	指针和刻度分割模型路径
image	待预测的图片路径
image_dir	存储待预测图片的文件夹路径
save_dir	保存可视化结果的路径, 默认值为"output"
score_threshold	检测模型输出结果中，预测得分低于该阈值的框将被滤除，默认值为0.5
seg_batch_size	分割的批量大小，默认为2
seg_thread_num	分割预测的线程数，默认为cpu处理器个数
use_camera	是否使用摄像头采集图片，默认为False
camera_id	摄像头设备ID，默认值为0
use_erode	是否使用图像腐蚀对分割预测图进行细分，默认为False
erode_kernel	图像腐蚀操作时的卷积核大小，默认值为4

预测

若要使用GPU，则指定GPU卡号（以0号卡为例）：

export CUDA_VISIBLE_DEVICES=0

若不使用GPU，则将CUDA_VISIBLE_DEVICES指定为空:

export CUDA_VISIBLE_DEVICES=

预测单张图片

python3 reader_infer.py --detector_dir /path/to/det_inference_model --segmenter_dir /path/to/seg_inference_model --image /path/to/meter_test/20190822_168.jpg --save_dir ./output --use_erode

预测多张图片

python3 reader_infer.py --detector_dir /path/to/det_inference_model --segmenter_dir /path/to/seg_inference_model --image_dir /path/to/meter_test --save_dir ./output --use_erode

开启摄像头预测

python3 reader_infer.py --detector_dir /path/to/det_inference_model --segmenter_dir /path/to/seg_inference_model --save_dir ./output --use_erode --use_camera

推理部署¶

Windows系统的服务器端安全部署¶

c++部署¶

下载PaddleX源码:

git clone https://github.com/PaddlePaddle/PaddleX

将PaddleX\examples\meter_reader\deploy\cpp下的meter_reader文件夹和CMakeList.txt拷贝至PaddleX\deploy\cpp目录下，拷贝之前可以将PaddleX\deploy\cpp下原本的CMakeList.txt做好备份。
按照Windows平台部署中的Step2至Step4完成C++预测代码的编译。
编译成功后，可执行文件在out\build\x64-Release目录下，打开cmd，并切换到该目录：
```
cd PaddleX\deploy\cpp\out\build\x64-Release
```
预测程序为paddle_inference\meter_reader.exe，其主要命令参数说明如下：

参数	说明
det_model_dir	表计检测模型路径
seg_model_dir	指针和刻度分割模型路径
image	待预测的图片路径
image_list	按行存储图片路径的.txt文件
use_gpu	是否使用 GPU 预测, 支持值为0或1(默认值为0)
gpu_id	GPU 设备ID, 默认值为0
save_dir	保存可视化结果的路径, 默认值为"output"
det_key	检测模型加密过程中产生的密钥信息，默认值为""表示加载的是未加密的检测模型
seg_key	分割模型加密过程中产生的密钥信息，默认值为""表示加载的是未加密的分割模型
seg_batch_size	分割的批量大小，默认为2
thread_num	分割预测的线程数，默认为cpu处理器个数
use_camera	是否使用摄像头采集图片，支持值为0或1(默认值为0)
camera_id	摄像头设备ID，默认值为0
use_erode	是否使用图像腐蚀对分割预测图进行去噪，支持值为0或1(默认值为1)
erode_kernel	图像腐蚀操作时的卷积核大小，默认值为4
score_threshold	检测模型输出结果中，预测得分低于该阈值的框将被滤除，默认值为0.5

推理预测：

用于部署推理的模型应为inference格式，本案例提供的预训练模型均为inference格式，如若是重新训练的模型，需参考部署模型导出将模型导出为inference格式。

使用未加密的模型对单张图片做预测

.\paddlex_inference\meter_reader.exe --det_model_dir=\path\to\det_inference_model --seg_model_dir=\path\to\seg_inference_model --image=\path\to\meter_test\20190822_168.jpg --use_gpu=1 --use_erode=1 --save_dir=output

使用未加密的模型对图像列表做预测

.\paddlex_inference\meter_reader.exe --det_model_dir=\path\to\det_inference_model --seg_model_dir=\path\to\seg_inference_model --image_list=\path\to\meter_test\image_list.txt --use_gpu=1 --use_erode=1 --save_dir=output

使用未加密的模型开启摄像头做预测

.\paddlex_inference\meter_reader.exe --det_model_dir=\path\to\det_inference_model --seg_model_dir=\path\to\seg_inference_model --use_camera=1 --use_gpu=1 --use_erode=1 --save_dir=output

使用加密后的模型对单张图片做预测

如果未对模型进行加密，请参考加密PaddleX模型对模型进行加密。例如加密后的检测模型所在目录为\path\to\encrypted_det_inference_model，密钥为yEBLDiBOdlj+5EsNNrABhfDuQGkdcreYcHcncqwdbx0=；加密后的分割模型所在目录为\path\to\encrypted_seg_inference_model，密钥为DbVS64I9pFRo5XmQ8MNV2kSGsfEr4FKA6OH9OUhRrsY=

.\paddlex_inference\meter_reader.exe --det_model_dir=\path\to\encrypted_det_inference_model --seg_model_dir=\path\to\encrypted_seg_inference_model --image=\path\to\test.jpg --use_gpu=1 --use_erode=1 --save_dir=output --det_key yEBLDiBOdlj+5EsNNrABhfDuQGkdcreYcHcncqwdbx0= --seg_key DbVS64I9pFRo5XmQ8MNV2kSGsfEr4FKA6OH9OUhRrsY=

Linux系统的jeton嵌入式设备安全部署¶

c++部署¶

下载PaddleX源码:

git clone https://github.com/PaddlePaddle/PaddleX

将PaddleX/examples/meter_reader/deploy/cpp下的meter_reader文件夹和CMakeList.txt拷贝至PaddleX/deploy/cpp目录下，拷贝之前可以将PaddleX/deploy/cpp下原本的CMakeList.txt做好备份。
按照Nvidia-Jetson开发板部署中的Step2至Step3完成C++预测代码的编译。
编译成功后，可执行程为build/meter_reader/meter_reader，其主要命令参数说明如下：

参数	说明
det_model_dir	表计检测模型路径
seg_model_dir	指针和刻度分割模型路径
image	待预测的图片路径
image_list	按行存储图片路径的.txt文件
use_gpu	是否使用 GPU 预测, 支持值为0或1(默认值为0)
gpu_id	GPU 设备ID, 默认值为0
save_dir	保存可视化结果的路径, 默认值为"output"
det_key	检测模型加密过程中产生的密钥信息，默认值为""表示加载的是未加密的检测模型
seg_key	分割模型加密过程中产生的密钥信息，默认值为""表示加载的是未加密的分割模型
seg_batch_size	分割的批量大小，默认为2
thread_num	分割预测的线程数，默认为cpu处理器个数
use_camera	是否使用摄像头采集图片，支持值为0或1(默认值为0)
camera_id	摄像头设备ID，默认值为0
use_erode	是否使用图像腐蚀对分割预测图进行细分，支持值为0或1(默认值为1)
erode_kernel	图像腐蚀操作时的卷积核大小，默认值为4
score_threshold	检测模型输出结果中，预测得分低于该阈值的框将被滤除，默认值为0.5

推理预测：

用于部署推理的模型应为inference格式，本案例提供的预训练模型均为inference格式，如若是重新训练的模型，需参考部署模型导出将模型导出为inference格式。

使用未加密的模型对单张图片做预测

./build/meter_reader/meter_reader --det_model_dir=/path/to/det_inference_model --seg_model_dir=/path/to/seg_inference_model --image=/path/to/meter_test/20190822_168.jpg --use_gpu=1 --use_erode=1 --save_dir=output

使用未加密的模型对图像列表做预测

./build/meter_reader/meter_reader --det_model_dir=/path/to/det_inference_model --seg_model_dir=/path/to/seg_inference_model --image_list=/path/to/image_list.txt --use_gpu=1 --use_erode=1 --save_dir=output

使用未加密的模型开启摄像头做预测

./build/meter_reader/meter_reader --det_model_dir=/path/to/det_inference_model --seg_model_dir=/path/to/seg_inference_model --use_camera=1 --use_gpu=1 --use_erode=1 --save_dir=output

使用加密后的模型对单张图片做预测

如果未对模型进行加密，请参考加密PaddleX模型对模型进行加密。例如加密后的检测模型所在目录为/path/to/encrypted_det_inference_model，密钥为yEBLDiBOdlj+5EsNNrABhfDuQGkdcreYcHcncqwdbx0=；加密后的分割模型所在目录为/path/to/encrypted_seg_inference_model，密钥为DbVS64I9pFRo5XmQ8MNV2kSGsfEr4FKA6OH9OUhRrsY=

./build/meter_reader/meter_reader --det_model_dir=/path/to/encrypted_det_inference_model --seg_model_dir=/path/to/encrypted_seg_inference_model --image=/path/to/test.jpg --use_gpu=1 --use_erode=1 --save_dir=output --det_key yEBLDiBOdlj+5EsNNrABhfDuQGkdcreYcHcncqwdbx0= --seg_key DbVS64I9pFRo5XmQ8MNV2kSGsfEr4FKA6OH9OUhRrsY=

模型训练¶

前置依赖¶

Paddle paddle >= 1.8.0
Python >= 3.5
PaddleX >= 1.0.0

安装的相关问题参考PaddleX安装

训练¶

表盘检测的训练

python3 /path/to/PaddleX/examples/meter_reader/train_detection.py

指针和刻度分割的训练

python3 /path/to/PaddleX/examples/meter_reader/train_segmentation.py

运行以上脚本可以训练本案例的检测模型和分割模型。如果不需要本案例的数据和模型参数，可更换数据，选择合适的模型并调整训练参数。

人像分割模型¶

本教程基于PaddleX核心分割模型实现人像分割，开放预训练模型和测试数据、支持视频流人像分割、提供模型Fine-tune到Paddle-Lite移动端部署的全流程应用指南。

预训练模型和测试数据¶

预训练模型¶

本案例开放了两个在大规模人像数据集上训练好的模型，以满足服务器端场景和移动端场景的需求。使用这些模型可以快速体验视频流人像分割，也可以部署到移动端进行实时人像分割，也可以用于完成模型Fine-tuning。

模型类型	Checkpoint Parameter	Inference Model	Quant Inference Model	备注
HumanSeg-server	humanseg_server_params	humanseg_server_inference	--	高精度模型，适用于服务端GPU且背景复杂的人像场景，模型结构为Deeplabv3+/Xcetion65, 输入大小（512， 512）
HumanSeg-mobile	humanseg_mobile_params	humanseg_mobile_inference	humanseg_mobile_quant	轻量级模型, 适用于移动端或服务端CPU的前置摄像头场景，模型结构为HRNet_w18_small_v1，输入大小（192， 192）

Checkpoint Parameter为模型权重，用于Fine-tuning场景，包含__params__模型参数和model.yaml基础的模型配置信息。

Inference Model和Quant Inference Model为预测部署模型，包含__model__计算图结构、__params__模型参数和model.yaml基础的模型配置信息。

其中Inference Model适用于服务端的CPU和GPU预测部署，Qunat Inference Model为量化版本，适用于通过Paddle Lite进行移动端等端侧设备部署。

预训练模型的存储大小和推理时长如下所示，其中移动端模型的运行环境为cpu：骁龙855，内存：6GB，图片大小：192*192

模型	模型大小	计算耗时
humanseg_server_inference	158M	-
humanseg_mobile_inference	5.8 M	42.35ms
humanseg_mobile_quant	1.6M	24.93ms

执行以下脚本下载全部的预训练模型：

下载PaddleX源码：

git clone https://github.com/PaddlePaddle/PaddleX

下载预训练模型的代码位于PaddleX/examples/human_segmentation，进入该目录：

cd PaddleX/examples/human_segmentation

执行下载

python pretrain_weights/download_pretrain_weights.py

测试数据¶

supervise.ly发布了人像分割数据集Supervisely Persons, 本案例从中随机抽取一小部分数据并转化成PaddleX可直接加载的数据格式，运行以下代码可下载该数据、以及手机前置摄像头拍摄的人像测试视频video_test.mp4.

下载测试数据的代码位于PaddleX/xamples/human_segmentation，进入该目录并执行下载：

python data/download_data.py

快速体验视频流人像分割¶

前置依赖¶

PaddlePaddle >= 1.8.0
Python >= 3.5
PaddleX >= 1.0.0

安装的相关问题参考PaddleX安装

下载PaddleX源码：

git clone https://github.com/PaddlePaddle/PaddleX

视频流人像分割和背景替换的执行文件均位于PaddleX/examples/human_segmentation，进入该目录：

cd PaddleX/examples/human_segmentation

光流跟踪辅助的视频流人像分割¶

本案例将DIS（Dense Inverse Search-basedmethod）光流跟踪算法的预测结果与PaddleX的分割结果进行融合，以此改善视频流人像分割的效果。运行以下代码进行体验，以下代码位于PaddleX/xamples/human_segmentation：

通过电脑摄像头进行实时分割处理

python video_infer.py --model_dir pretrain_weights/humanseg_mobile_inference

对离线人像视频进行分割处理

python video_infer.py --model_dir pretrain_weights/humanseg_mobile_inference --video_path data/video_test.mp4

视频分割结果如下所示：

人像背景替换¶

本案例还实现了人像背景替换功能，根据所选背景对人像的背景画面进行替换，背景可以是一张图片，也可以是一段视频。人像背景替换的代码位于PaddleX/xamples/human_segmentation，进入该目录并执行：

通过电脑摄像头进行实时背景替换处理, 通过’–background_video_path’传入背景视频

python bg_replace.py --model_dir pretrain_weights/humanseg_mobile_inference --background_image_path data/background.jpg

对人像视频进行背景替换处理, 通过’–background_video_path’传入背景视频

python bg_replace.py --model_dir pretrain_weights/humanseg_mobile_inference --video_path data/video_test.mp4 --background_image_path data/background.jpg

对单张图像进行背景替换

python bg_replace.py --model_dir pretrain_weights/humanseg_mobile_inference --image_path data/human_image.jpg --background_image_path data/background.jpg

背景替换结果如下：

注意:

视频分割处理时间需要几分钟，请耐心等待。
提供的模型适用于手机摄像头竖屏拍摄场景，宽屏效果会略差一些。

模型Fine-tune¶

前置依赖¶

PaddlePaddle >= 1.8.0
Python >= 3.5
PaddleX >= 1.0.0

安装的相关问题参考PaddleX安装

下载PaddleX源码：

git clone https://github.com/PaddlePaddle/PaddleX

人像分割训练、评估、预测、模型导出、离线量化的执行文件均位于PaddleX/examples/human_segmentation，进入该目录：

cd PaddleX/examples/human_segmentation

模型训练¶

使用下述命令进行基于预训练模型的模型训练，请确保选用的模型结构model_type与模型参数pretrain_weights匹配。如果不需要本案例提供的测试数据，可更换数据、选择合适的模型并调整训练参数。

# 指定GPU卡号（以0号卡为例）
export CUDA_VISIBLE_DEVICES=0
# 若不使用GPU，则将CUDA_VISIBLE_DEVICES指定为空
# export CUDA_VISIBLE_DEVICES=
python train.py --model_type HumanSegMobile \
--save_dir output/ \
--data_dir data/mini_supervisely \
--train_list data/mini_supervisely/train.txt \
--val_list data/mini_supervisely/val.txt \
--pretrain_weights pretrain_weights/humanseg_mobile_params \
--batch_size 8 \
--learning_rate 0.001 \
--num_epochs 10 \
--image_shape 192 192

其中参数含义如下：

--model_type: 模型类型，可选项为：HumanSegServer和HumanSegMobile
--save_dir: 模型保存路径
--data_dir: 数据集路径
--train_list: 训练集列表路径
--val_list: 验证集列表路径
--pretrain_weights: 预训练模型路径
--batch_size: 批大小
--learning_rate: 初始学习率
--num_epochs: 训练轮数
--image_shape: 网络输入图像大小（w, h）

更多命令行帮助可运行下述命令进行查看：

python train.py --help

注意：可以通过更换--model_type变量与对应的--pretrain_weights使用不同的模型快速尝试。

评估¶

使用下述命令对模型在验证集上的精度进行评估：

python eval.py --model_dir output/best_model \
--data_dir data/mini_supervisely \
--val_list data/mini_supervisely/val.txt \
--image_shape 192 192

其中参数含义如下：

--model_dir: 模型路径
--data_dir: 数据集路径
--val_list: 验证集列表路径
--image_shape: 网络输入图像大小（w, h）

预测¶

使用下述命令对测试集进行预测，预测可视化结果默认保存在./output/result/文件夹中。

python infer.py --model_dir output/best_model \
--data_dir data/mini_supervisely \
--test_list data/mini_supervisely/test.txt \
--save_dir output/result \
--image_shape 192 192

其中参数含义如下：

--model_dir: 模型路径
--data_dir: 数据集路径
--test_list: 测试集列表路径
--image_shape: 网络输入图像大小（w, h）

模型导出¶

在服务端部署的模型需要首先将模型导出为inference格式模型，导出的模型将包括__model__、__params__和model.yml三个文名，分别为模型的网络结构，模型权重和模型的配置文件（包括数据预处理参数等等）。在安装完PaddleX后，在命令行终端使用如下命令完成模型导出：

paddlex --export_inference --model_dir output/best_model \
--save_dir output/export

其中参数含义如下：

--model_dir: 模型路径
--save_dir: 导出模型保存路径

离线量化¶

python quant_offline.py --model_dir output/best_model \
--data_dir data/mini_supervisely \
--quant_list data/mini_supervisely/val.txt \
--save_dir output/quant_offline \
--image_shape 192 192

其中参数含义如下：

--model_dir: 待量化模型路径
--data_dir: 数据集路径
--quant_list: 量化数据集列表路径，一般直接选择训练集或验证集
--save_dir: 量化模型保存路径
--image_shape: 网络输入图像大小（w, h）

Paddle-Lite移动端部署¶

本案例将人像分割模型在移动端进行部署，部署流程展示如下，通用的移动端部署流程参见PaddleLite移动端部署。

1. 将PaddleX模型导出为inference模型¶

本案例使用humanseg_mobile_quant预训练模型，该模型已经是inference模型，不需要再执行模型导出步骤。如果不使用预训练模型，则执行上一章节模型训练中的模型导出将自己训练的模型导出为inference格式。

2. 将inference模型优化为PaddleLite模型¶

下载并解压模型优化工具opt，进入模型优化工具opt所在路径后，执行以下命令：

./opt --model_file=<model_path> \
      --param_file=<param_path> \
      --valid_targets=arm \
      --optimize_out_type=naive_buffer \
      --optimize_out=model_output_name

参数	说明
--model_file	导出inference模型中包含的网络结构文件：`__model__`所在的路径
--param_file	导出inference模型中包含的参数文件：`__params__`所在的路径
--valid_targets	指定模型可执行的backend，这里请指定为`arm`
--optimize_out_type	输出模型类型，目前支持两种类型：protobuf和naive_buffer，其中naive_buffer是一种更轻量级的序列化/反序列化，这里请指定为`naive_buffer`
--optimize_out	输出模型的名称

更详细的使用方法和参数含义请参考: 使用opt转化模型

3. 移动端预测¶

PaddleX提供了基于PaddleX Android SDK的安卓demo，可供用户体验图像分类、目标检测、实例分割和语义分割，该demo位于PaddleX/deploy/lite/android/demo，用户将模型、配置文件和测试图片拷贝至该demo下进行预测。

3.1 前置依赖¶

Android Studio 3.4
Android手机或开发板

3.2 拷贝模型、配置文件和测试图片¶

将Lite模型（.nb文件）拷贝到PaddleX/deploy/lite/android/demo/app/src/main/assets/model/目录下, 根据.nb文件的名字，修改文件PaddleX/deploy/lite/android/demo/app/src/main/res/values/strings.xml中的MODEL_PATH_DEFAULT；
将配置文件（.yml文件）拷贝到PaddleX/deploy/lite/android/demo/app/src/main/assets/config/目录下，根据.yml文件的名字，修改文件PaddleX/deploy/lite/android/demo/app/src/main/res/values/strings.xml中的YAML_PATH_DEFAULT；
将测试图片拷贝到PaddleX/deploy/lite/android/demo/app/src/main/assets/images/目录下，根据图片文件的名字，修改文件PaddleX/deploy/lite/android/demo/app/src/main/res/values/strings.xml中的IMAGE_PATH_DEFAULT。

3.3 导入工程并运行¶

打开Android Studio，在”Welcome to Android Studio”窗口点击”Open an existing Android Studio project”，在弹出的路径选择窗口中进入PaddleX/deploy/lite/android/demo目录，然后点击右下角的”Open”按钮，导入工程；
通过USB连接Android手机或开发板；
工程编译完成后，点击菜单栏的Run->Run ‘App’按钮，在弹出的”Select Deployment Target”窗口选择已经连接的Android设备，然后点击”OK”按钮；
运行成功后，Android设备将加载一个名为PaddleX Demo的App，默认会加载一个测试图片，同时还支持拍照和从图库选择照片进行预测。

测试图片及其分割结果如下所示：

_images/beauty.png

PaddleX GUI¶

PaddleX GUI是基于PaddleX开发实现的可视化模型训练套件，可以让开发者免去代码开发的步骤，通过点选式地操作就可以快速完成模型的训练开发。PaddleXGUI具有 数据集可视化分析 、模型参数自动推荐 、跨平台使用 三大特点。

数据集可视化分析: PaddleX支持导入常见的图像分类、目标检测、实例分割和语义分割数据集，并对数据集的样本分布，标注结果进行可视化展示，数据集的情况一目了然！
模型参数自动推荐: 根据用户的电脑配置和数据集情况，自动推荐模型训练参数，免去用户查看文档，被各种参数所烦的忧心事！
跨平台使用: PaddleX GUI完全跨平台，支持Linux、Windows和Mac三大主流系统！

PaddleX GUI版本: v1.0
项目官网: http://www.paddlepaddle.org.cn/paddle/paddlex
项目GitHub: https://github.com/PaddlePaddle/PaddleX/tree/develop
官方QQ用户群: 1045148026
GitHub Issue反馈: http://www.github.com/PaddlePaddle/PaddleX/issues

API接口说明¶

数据处理与增强¶

transforms为PaddleX的模型训练提供了数据的预处理和数据增强接口。

paddlex.cls.transforms¶

对图像分类任务的数据进行操作。可以利用Compose类将图像预处理/增强操作进行组合。

Compose¶

paddlex.cls.transforms.Compose(transforms)

根据数据预处理/增强算子对输入数据进行操作。使用示例

参数

transforms (list): 数据预处理/数据增强列表。

Normalize¶

paddlex.cls.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])

对图像进行标准化。

对图像进行归一化到区间[0.0, 1.0]。
对图像进行减均值除以标准差操作。

参数¶

mean (list): 图像数据集的均值。默认为[0.485, 0.456, 0.406]。
std (list): 图像数据集的标准差。默认为[0.229, 0.224, 0.225]。

ResizeByShort¶

paddlex.cls.transforms.ResizeByShort(short_size=256, max_size=-1)

根据图像的短边调整图像大小（resize）。

获取图像的长边和短边长度。
根据短边与short_size的比例，计算长边的目标长度，此时高、宽的resize比例为short_size/原图短边长度。
如果max_size>0，调整resize比例：如果长边的目标长度>max_size，则高、宽的resize比例为max_size/原图长边长度。
根据调整大小的比例对图像进行resize。

参数¶

short_size (int): 调整大小后的图像目标短边长度。默认为256。
max_size (int): 长边目标长度的最大限制。默认为-1。

CenterCrop¶

paddlex.cls.transforms.CenterCrop(crop_size=224)

以图像中心点扩散裁剪长宽为crop_size的正方形

计算剪裁的起始点。
剪裁图像。

参数¶

crop_size (int): 裁剪的目标边长。默认为224。

RandomCrop¶

paddlex.cls.transforms.RandomCrop(crop_size=224, lower_scale=0.08, lower_ratio=3. / 4, upper_ratio=4. / 3)

对图像进行随机剪裁，模型训练时的数据增强操作。

根据lower_scale、lower_ratio、upper_ratio计算随机剪裁的高、宽。
根据随机剪裁的高、宽随机选取剪裁的起始点。
剪裁图像。
调整剪裁后的图像的大小到crop_size*crop_size。

参数¶

crop_size (int): 随机裁剪后重新调整的目标边长。默认为224。
lower_scale (float): 裁剪面积相对原面积比例的最小限制。默认为0.08。
lower_ratio (float): 宽变换比例的最小限制。默认为3. / 4。
upper_ratio (float): 宽变换比例的最小限制。默认为4. / 3。

RandomHorizontalFlip¶

paddlex.cls.transforms.RandomHorizontalFlip(prob=0.5)

以一定的概率对图像进行随机水平翻转，模型训练时的数据增强操作。

参数¶

prob (float): 随机水平翻转的概率。默认为0.5。

RandomVerticalFlip¶

paddlex.cls.transforms.RandomVerticalFlip(prob=0.5)

以一定的概率对图像进行随机垂直翻转，模型训练时的数据增强操作。

参数¶

prob (float): 随机垂直翻转的概率。默认为0.5。

RandomRotate¶

paddlex.cls.transforms.RandomRotate(rotate_range=30, prob=0.5)

以一定的概率对图像在[-rotate_range, rotaterange]角度范围内进行旋转，模型训练时的数据增强操作。

参数¶

rotate_range (int): 旋转度数的范围。默认为30。
prob (float): 随机旋转的概率。默认为0.5。

RandomDistort¶

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中的顺序以一定的概率对图像在范围[-range, range]内进行随机像素内容变换。

【注意】该数据增强必须在数据增强Normalize之前使用。

参数¶

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。

paddlex.det.transforms¶

对目标检测/实例分割任务的数据进行操作。可以利用Compose类将图像预处理/增强操作进行组合。

Compose¶

paddlex.det.transforms.Compose(transforms)

根据数据预处理/增强算子对输入数据进行操作。使用示例

参数¶

transforms (list): 数据预处理/数据增强列表。

Normalize¶

paddlex.det.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])

对图像进行标准化。

归一化图像到到区间[0.0, 1.0]。
对图像进行减均值除以标准差操作。

参数¶

mean (list): 图像数据集的均值。默认为[0.485, 0.456, 0.406]。
std (list): 图像数据集的标准差。默认为[0.229, 0.224, 0.225]。

ResizeByShort¶

paddlex.det.transforms.ResizeByShort(short_size=800, max_size=1333)

根据图像的短边调整图像大小（resize）。

获取图像的长边和短边长度。
根据短边与short_size的比例，计算长边的目标长度，此时高、宽的resize比例为short_size/原图短边长度。
如果max_size>0，调整resize比例：如果长边的目标长度>max_size，则高、宽的resize比例为max_size/原图长边长度。
根据调整大小的比例对图像进行resize。

参数¶

short_size (int): 短边目标长度。默认为800。
max_size (int): 长边目标长度的最大限制。默认为1333。

Padding¶

paddlex.det.transforms.Padding(coarsest_stride=1)

将图像的长和宽padding至coarsest_stride的倍数。如输入图像为[300, 640], coarest_stride为32，则由于300不为32的倍数，因此在图像最右和最下使用0值进行padding，最终输出图像为[320, 640]

如果coarsest_stride为1则直接返回。
计算宽和高与最邻近的coarest_stride倍数差值
根据计算得到的差值，在图像最右和最下进行padding

参数¶

coarsest_stride (int): 填充后的图像长、宽为该参数的倍数，默认为1。

Resize¶

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¶

paddlex.det.transforms.RandomHorizontalFlip(prob=0.5)

以一定的概率对图像进行随机水平翻转，模型训练时的数据增强操作。

参数¶

prob (float): 随机水平翻转的概率。默认为0.5。

RandomDistort¶

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中的顺序以一定的概率对图像在范围[-range, range]内进行随机像素内容变换。

【注意】该数据增强必须在数据增强Normalize之前使用。

参数¶

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¶

paddlex.det.transforms.MixupImage(alpha=1.5, beta=1.5, mixup_epoch=-1)

对图像进行mixup操作，模型训练时的数据增强操作，目前仅YOLOv3模型支持该transform。当label_info中不存在mixup字段时，直接返回，否则进行下述操作：

从随机beta分布中抽取出随机因子factor。
根据不同情况进行处理：
- 当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个结果。
更新im_info中的augment_shape信息。

参数¶

alpha (float): 随机beta分布的下限。默认为1.5。
beta (float): 随机beta分布的上限。默认为1.5。
mixup_epoch (int): 在前mixup_epoch轮使用mixup增强操作；当该参数为-1时，该策略不会生效。默认为-1。

RandomExpand类¶

paddlex.det.transforms.RandomExpand(ratio=4., prob=0.5, fill_value=[123.675, 116.28, 103.53])

随机扩张图像，模型训练时的数据增强操作。

随机选取扩张比例（扩张比例大于1时才进行扩张）。
计算扩张后图像大小。
初始化像素值为输入填充值的图像，并将原图像随机粘贴于该图像上。
根据原图像粘贴位置换算出扩张后真实标注框的位置坐标。
根据原图像粘贴位置换算出扩张后真实分割区域的位置坐标。

参数¶

ratio (float): 图像扩张的最大比例。默认为4.0。
prob (float): 随机扩张的概率。默认为0.5。
fill_value (list): 扩张图像的初始填充值（0-255）。默认为[123.675, 116.28, 103.53]。

【注意】该数据增强必须在数据增强Resize、ResizeByShort之前使用。

RandomCrop¶

paddlex.det.transforms.RandomCrop(aspect_ratio=[.5, 2.], thresholds=[.0, .1, .3, .5, .7, .9], scaling=[.3, 1.], num_attempts=50, allow_no_crop=True, cover_all_box=False)

随机裁剪图像，模型训练时的数据增强操作。

若allow_no_crop为True，则在thresholds加入’no_crop’。
随机打乱thresholds。
遍历thresholds中各元素： (1) 如果当前thresh为’no_crop’，则返回原始图像和标注信息。 (2) 随机取出aspect_ratio和scaling中的值并由此计算出候选裁剪区域的高、宽、起始点。 (3) 计算真实标注框与候选裁剪区域IoU，若全部真实标注框的IoU都小于thresh，则继续第3步。 (4) 如果cover_all_box为True且存在真实标注框的IoU小于thresh，则继续第3步。 (5) 筛选出位于候选裁剪区域内的真实标注框，若有效框的个数为0，则继续第3步，否则进行第4步。
换算有效真值标注框相对候选裁剪区域的位置坐标。
换算有效分割区域相对候选裁剪区域的位置坐标。

【注意】该数据增强必须在数据增强Resize、ResizeByShort之前使用。

参数¶

aspect_ratio (list): 裁剪后短边缩放比例的取值范围，以[min, max]形式表示。默认值为[.5, 2.]。
thresholds (list): 判断裁剪候选区域是否有效所需的IoU阈值取值列表。默认值为[.0, .1, .3, .5, .7, .9]。
scaling (list): 裁剪面积相对原面积的取值范围，以[min, max]形式表示。默认值为[.3, 1.]。
num_attempts (int): 在放弃寻找有效裁剪区域前尝试的次数。默认值为50。
allow_no_crop (bool): 是否允许未进行裁剪。默认值为True。
cover_all_box (bool): 是否要求所有的真实标注框都必须在裁剪区域内。默认值为False。

paddlex.seg.transforms¶

对用于分割任务的数据进行操作。可以利用Compose类将图像预处理/增强操作进行组合。

Compose¶

paddlex.seg.transforms.Compose(transforms)

根据数据预处理/数据增强列表对输入数据进行操作。使用示例

参数¶

transforms (list): 数据预处理/数据增强列表。

RandomHorizontalFlip¶

paddlex.seg.transforms.RandomHorizontalFlip(prob=0.5)

以一定的概率对图像进行水平翻转,模型训练时的数据增强操作。

参数¶

prob (float): 随机水平翻转的概率。默认值为0.5。

RandomVerticalFlip¶

paddlex.seg.transforms.RandomVerticalFlip(prob=0.1)

以一定的概率对图像进行垂直翻转,模型训练时的数据增强操作。

参数¶

prob (float): 随机垂直翻转的概率。默认值为0.1。

Resize¶

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¶

paddlex.seg.transforms.ResizeByLong(long_size)

对图像长边resize到固定值，短边按比例进行缩放。

参数¶

long_size (int): resize后图像的长边大小。

ResizeRangeScaling¶

paddlex.seg.transforms.ResizeRangeScaling(min_value=400, max_value=600)

对图像长边随机resize到指定范围内，短边按比例进行缩放,模型训练时的数据增强操作。

参数¶

min_value (int): 图像长边resize后的最小值。默认值400。
max_value (int): 图像长边resize后的最大值。默认值600。

ResizeStepScaling¶

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¶

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¶

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¶

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¶

paddlex.seg.transforms.RandomBlur(prob=0.1)

以一定的概率对图像进行高斯模糊，模型训练时的数据增强操作。

参数¶

prob (float): 图像模糊概率。默认为0.1。

RandomRotate¶

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¶

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¶

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]内进行随机像素内容变换。

【注意】该数据增强必须在数据增强Normalize之前使用。

参数¶

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。

数据增强与imgaug支持¶

数据增强操作可用于在模型训练时，增加训练样本的多样性，从而提升模型的泛化能力。

PaddleX内置增强操作¶

PaddleX对于图像分类、目标检测、实例分割和语义分割内置了部分常见的数据增强操作，如下表所示，

任务类型	增强方法
图像分类	RandomCrop、RandomHorizontalFlip、RandomVerticalFlip、 RandomRotate、 RandomDistort
目标检测实例分割	RandomHorizontalFlip、RandomDistort、RandomCrop、 MixupImage(仅支持YOLOv3模型)、RandomExpand
语义分割	RandomHorizontalFlip、RandomVerticalFlip、RandomRangeScaling、 RandomStepScaling、RandomPaddingCrop、 RandomBlur、 RandomRotate、RandomScaleAspect、RandomDistort

imgaug增强库的支持¶

PaddleX目前已适配imgaug图像增强库，用户可以直接在PaddleX构造transforms时，调用imgaug的方法, 如下示例

import paddlex as pdx
from paddlex.cls import transforms
import imgaug.augmenters as iaa
train_transforms = transforms.Compose([
    # 随机在[0.0 3.0]中选值对图像进行模糊
    iaa.blur.GaussianBlur(sigma=(0.0, 3.0)),
    transforms.RandomCrop(crop_size=224),
    transforms.Normalize()
])

除了上述用法，Compose接口中也支持imgaug的Someof、Sometimes、Sequential、Oneof等操作，开发者可以通过这些方法随意组合出增强流程。由于imgaug对于标注信息(目标检测框和实例分割mask)与PaddleX模型训练逻辑有部分差异，目前在检测和分割中，只支持pixel-level的增强方法,（即在增强时，不对图像的大小和方向做改变）其它方法仍在适配中，详情可见下表，

增强方法	图像分类	目标检测实例分割	语义分割	备注
imgaug.augmenters.arithmetic	√	√	√	Cutout, DropoutJpegCompression等
imgaug.augmenters.artistic	√	√	√	图像卡通化
imgaug.augmenters.blur	√	√	√	GaussianBlur, AverageBlur等
imgaug.augmenters.collections	√			提供了RandAugment方法
imgaug.augmenters.color	√	√	√	Brightness, Hue等色调的增强方法
imgaug.augmenters.contrast	√	√	√	多种对比度增强方式
imgaug.augmenters.convolutional	√	√	√	应用卷积kernel到图像
imgaug.augmenters.edges	√	√	√	图像边缘化等方法
imgaug.augmenters.flip	√			Fliplr和Flipud翻转方法
imgaug.augmenters.geometric	√			Affine、Rotate等增强方法
imgaug.augmenters.imgcorruptlike	√	√	√	GaussianNoise等图像噪声增强方法
imgaug.augmenters.pillike	√
imgaug.augmenters.pooling	√			应用pooling操作到图像
imgaug.augmenters.segmentation	√			应用分割方法到图像
imgaug.augmenters.size	√			Reisze、Crop、Pad等操作
imgaug.augmenters.weather	√	√	√	多种模拟天气等增强方法

需要注意的是，imgaug的基础方法中，如imgaug.augmenters.blur仅为图像处理操作，并无概率设置，而在CV模型训练中，增强操作往往是以一定概率应用在样本上，因此我们可以通过imgaug的Someof、Sometimes、Sequential、Oneof等操作来组合实现，如下代码所示，

Someof 执行定义增强方法列表中的部分方法

Sometimes 以一定概率执行定义的增强方法列表

Sequential 按顺序执行定义的增强方法列表

image imgaug.augmenters as iaa
from paddlex.cls import transforms
# 以0.6的概率对图像样本进行模糊
img_augmenters = iaa.Sometimes(0.6, [
    iaa.blur.GaussianBlur(sigma=(0.0, 3.0))
])
train_transforms = transforms.Compose([
    img_augmenters,
    transforms.RandomCrop(crop_size=224),
    transforms.Normalize()
])

数据集读取¶

paddlex.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数据集格式的介绍可查看文档:数据集格式说明

示例：代码文件

参数

data_dir (str): 数据集所在的目录路径。

file_list (str): 描述数据集图片文件和类别id的文件路径（文本内每行路径为相对data_dir的相对路径）。

label_list (str): 描述数据集包含的类别信息文件路径。

transforms (paddlex.cls.transforms): 数据集中每个样本的预处理/增强算子，详见paddlex.cls.transforms。

num_workers (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为’auto’。当设为’auto’时，根据系统的实际CPU核数设置num_workers: 如果CPU核数的一半大于8，则num_workers为8，否则为CPU核数的一半。

buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。

parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持’thread’线程和’process’进程两种方式。默认为’process’（Windows和Mac下会强制使用thread，该参数无效）。

shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。

paddlex.datasets.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数据集格式的介绍可查看文档:数据集格式说明

示例：代码文件

参数

data_dir (str): 数据集所在的目录路径。

file_list (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对data_dir的相对路径）。

label_list (str): 描述数据集包含的类别信息文件路径。

transforms (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见paddlex.det.transforms。

num_workers (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为’auto’。当设为’auto’时，根据系统的实际CPU核数设置num_workers: 如果CPU核数的一半大于8，则num_workers为8，否则为CPU核数的一半。

buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。

parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持’thread’线程和’process’进程两种方式。默认为’process’（Windows和Mac下会强制使用thread，该参数无效）。

shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。

paddlex.datasets.CocoDetection¶

用于实例分割/目标检测模型

paddlex.datasets.CocoDetection(data_dir, ann_file, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)

读取MSCOCO格式的检测数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。MSCOCO数据集格式的介绍可查看文档:数据集格式说明

示例：代码文件

参数

data_dir (str): 数据集所在的目录路径。

ann_file (str): 数据集的标注文件，为一个独立的json格式文件。

transforms (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见paddlex.det.transforms。

num_workers (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为’auto’。当设为’auto’时，根据系统的实际CPU核数设置num_workers: 如果CPU核数的一半大于8，则num_workers为8，否则为CPU核数的一半。

buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。

parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持’thread’线程和’process’进程两种方式。默认为’process’（Windows和Mac下会强制使用thread，该参数无效）。

shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。

paddlex.datasets.SegDataset¶

用于语义分割模型

paddlex.datasets.SegDataset(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)

读取语义分割任务数据集，并对样本进行相应的处理。语义分割任务数据集格式的介绍可查看文档:数据集格式说明

示例：代码文件

参数

data_dir (str): 数据集所在的目录路径。

file_list (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对data_dir的相对路径）。

label_list (str): 描述数据集包含的类别信息文件路径。

transforms (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见paddlex.seg.transforms。

num_workers (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为’auto’。当设为’auto’时，根据系统的实际CPU核数设置num_workers: 如果CPU核数的一半大于8，则num_workers为8，否则为CPU核数的一半。

buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。

parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持’thread’线程和’process’进程两种方式。默认为’process’（Windows和Mac下会强制使用thread，该参数无效）。

shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。

paddlex.datasets.EasyDataCls¶

用于图像分类模型

paddlex.datasets.EasyDataCls(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)

读取EasyData平台标注图像分类数据集，并对样本进行相应的处理。

参数

data_dir (str): 数据集所在的目录路径。

file_list (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对data_dir的相对路径）。

label_list (str): 描述数据集包含的类别信息文件路径。

transforms (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见paddlex.cls.transforms。

num_workers (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为’auto’。当设为’auto’时，根据系统的实际CPU核数设置num_workers: 如果CPU核数的一半大于8，则num_workers为8，否则为CPU核数的一半。

buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。

parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持’thread’线程和’process’进程两种方式。默认为’process’（Windows和Mac下会强制使用thread，该参数无效）。

shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。

paddlex.datasets.EasyDataDet¶

用于目标检测/实例分割模型

paddlex.datasets.EasyDataDet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)

读取EasyData目标检测/实例分割格式数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。

参数

data_dir (str): 数据集所在的目录路径。

file_list (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对data_dir的相对路径）。

label_list (str): 描述数据集包含的类别信息文件路径。

transforms (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见paddlex.det.transforms。

num_workers (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为’auto’。当设为’auto’时，根据系统的实际CPU核数设置num_workers: 如果CPU核数的一半大于8，则num_workers为8，否则为CPU核数的一半。

buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。

parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持’thread’线程和’process’进程两种方式。默认为’process’（Windows和Mac下会强制使用thread，该参数无效）。

shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。

paddlex.datasets.EasyDataSeg¶

用于语义分割模型

paddlex.datasets.EasyDataSeg(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)

读取EasyData语义分割任务数据集，并对样本进行相应的处理。

参数

data_dir (str): 数据集所在的目录路径。

file_list (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对data_dir的相对路径）。

label_list (str): 描述数据集包含的类别信息文件路径。

transforms (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见paddlex.seg.transforms。

num_workers (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为’auto’。当设为’auto’时，根据系统的实际CPU核数设置num_workers: 如果CPU核数的一半大于8，则num_workers为8，否则为CPU核数的一半。

buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。

parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持’thread’线程和’process’进程两种方式。默认为’process’（Windows和Mac下会强制使用thread，该参数无效）。

shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。

视觉模型集¶

PaddleX目前支持四种视觉任务解决方案，包括图像分类、目标检测、实例分割和语义分割。对于每种视觉任务，PaddleX又提供了1种或多种模型，用户可根据需求及应用场景选取。

Image Classification¶

paddlex.cls.ResNet50¶

paddlex.cls.ResNet50(num_classes=1000)

构建ResNet50分类器，并实现其训练、评估和预测。

参数

num_classes (int): 类别数。默认为1000。

train¶

train(self, num_epochs, train_dataset, train_batch_size=64, eval_dataset=None, save_interval_epochs=1, log_interval_steps=2, save_dir='output', pretrain_weights='IMAGENET', optimizer=None, learning_rate=0.025, warmup_steps=0, warmup_start_lr=0.0, lr_decay_epochs=[30, 60, 90], lr_decay_gamma=0.1, use_vdl=False, sensitivities_file=None, eval_metric_loss=0.05, early_stop=False, early_stop_patience=5, resume_checkpoint=None)

参数

num_epochs (int): 训练迭代轮数。

train_dataset (paddlex.datasets): 训练数据读取器。

train_batch_size (int): 训练数据batch大小。同时作为验证数据batch大小。默认值为64。

eval_dataset (paddlex.datasets): 验证数据读取器。

save_interval_epochs (int): 模型保存间隔（单位：迭代轮数）。默认为1。

log_interval_steps (int): 训练日志输出间隔（单位：迭代步数）。默认为2。

save_dir (str): 模型保存路径。

pretrain_weights (str): 若指定为路径时，则加载路径下预训练模型；若为字符串’IMAGENET’，则自动下载在ImageNet图片数据上预训练的模型权重；若为None，则不使用预训练模型。默认为’IMAGENET’。

optimizer (paddle.fluid.optimizer): 优化器。当该参数为None时，使用默认优化器：fluid.layers.piecewise_decay衰减策略，fluid.optimizer.Momentum优化方法。

learning_rate (float): 默认优化器的初始学习率。默认为0.025。

warmup_steps (int): 默认优化器的warmup步数，学习率将在设定的步数内，从warmup_start_lr线性增长至设定的learning_rate，默认为0。

warmup_start_lr(float): 默认优化器的warmup起始学习率，默认为0.0。

lr_decay_epochs (list): 默认优化器的学习率衰减轮数。默认为[30, 60, 90]。

lr_decay_gamma (float): 默认优化器的学习率衰减率。默认为0.1。

use_vdl (bool): 是否使用VisualDL进行可视化。默认值为False。

sensitivities_file (str): 若指定为路径时，则加载路径下敏感度信息进行裁剪；若为字符串’DEFAULT’，则自动下载在ImageNet图片数据上获得的敏感度信息进行裁剪；若为None，则不进行裁剪。默认为None。

eval_metric_loss (float): 可容忍的精度损失。默认为0.05。

early_stop (bool): 是否使用提前终止训练策略。默认值为False。

early_stop_patience (int): 当使用提前终止训练策略时，如果验证集精度在early_stop_patience个epoch内连续下降或持平，则终止训练。默认值为5。

resume_checkpoint (str): 恢复训练时指定上次训练保存的模型路径。若为None，则不会恢复训练。默认值为None。

evaluate¶

evaluate(self, eval_dataset, batch_size=1, epoch_id=None, return_details=False)

参数

eval_dataset (paddlex.datasets): 验证数据读取器。

batch_size (int): 验证数据批大小。默认为1。

epoch_id (int): 当前评估模型所在的训练轮数。

return_details (bool): 是否返回详细信息，默认False。

返回值

dict: 当return_details为False时，返回dict, 包含关键字：’acc1’、’acc5’，分别表示最大值的accuracy、前5个最大值的accuracy。

tuple (metrics, eval_details): 当return_details为True时，增加返回dict，包含关键字：’true_labels’、’pred_scores’，分别代表真实类别id、每个类别的预测得分。

predict¶

predict(self, img_file, transforms=None, topk=5)

分类模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在ResNet50.test_transforms和ResNet50.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file (str|np.ndarray): 预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.cls.transforms): 数据预处理操作。

topk (int): 预测时前k个最大值。

返回值

list: 其中元素均为字典。字典的关键字为’category_id’、’category’、’score’，分别对应预测类别id、预测类别标签、预测得分。

batch_predict¶

batch_predict(self, img_file_list, transforms=None, topk=5, thread_num=2)

分类模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在ResNet50.test_transforms和ResNet50.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file_list (list|tuple): 对列表（或元组）中的图像同时进行预测，列表中的元素可以是图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.cls.transforms): 数据预处理操作。

topk (int): 预测时前k个最大值。

thread_num (int): 并发执行各图像预处理时的线程数。

返回值

list: 每个元素都为列表，表示各图像的预测结果。在各图像的预测列表中，其中元素均为字典。字典的关键字为’category_id’、’category’、’score’，分别对应预测类别id、预测类别标签、预测得分。

其它分类模型¶

PaddleX提供了共计22种分类模型，所有分类模型均提供同ResNet50相同的训练train，评估evaluate和预测predict接口，各模型效果可参考模型库。

模型	接口
ResNet18	paddlex.cls.ResNet18(num_classes=1000)
ResNet34	paddlex.cls.ResNet34(num_classes=1000)
ResNet50	paddlex.cls.ResNet50(num_classes=1000)
ResNet50_vd	paddlex.cls.ResNet50_vd(num_classes=1000)
ResNet50_vd_ssld	paddlex.cls.ResNet50_vd_ssld(num_classes=1000)
ResNet101	paddlex.cls.ResNet101(num_classes=1000)
ResNet101_vd	paddlex.cls.ResNet101_vd(num_classes=1000)
ResNet101_vd_ssld	paddlex.cls.ResNet101_vd_ssld(num_classes=1000)
DarkNet53	paddlex.cls.DarkNet53(num_classes=1000)
MoibileNetV1	paddlex.cls.MobileNetV1(num_classes=1000)
MobileNetV2	paddlex.cls.MobileNetV2(num_classes=1000)
MobileNetV3_small	paddlex.cls.MobileNetV3_small(num_classes=1000)
MobileNetV3_small_ssld	paddlex.cls.MobileNetV3_small_ssld(num_classes=1000)
MobileNetV3_large	paddlex.cls.MobileNetV3_large(num_classes=1000)
MobileNetV3_large_ssld	paddlex.cls.MobileNetV3_large_ssld(num_classes=1000)
Xception65	paddlex.cls.Xception65(num_classes=1000)
Xception71	paddlex.cls.Xception71(num_classes=1000)
ShuffleNetV2	paddlex.cls.ShuffleNetV2(num_classes=1000)
DenseNet121	paddlex.cls.DenseNet121(num_classes=1000)
DenseNet161	paddlex.cls.DenseNet161(num_classes=1000)
DenseNet201	paddlex.cls.DenseNet201(num_classes=1000)
HRNet_W18	paddlex.cls.HRNet_W18(num_classes=1000)
AlexNet	paddlex.cls.AlexNet(num_classes=1000)

Object Detection¶

paddlex.det.YOLOv3¶

paddlex.det.YOLOv3(num_classes=80, backbone='MobileNetV1', anchors=None, anchor_masks=None, ignore_threshold=0.7, nms_score_threshold=0.01, nms_topk=1000, nms_keep_topk=100, nms_iou_threshold=0.45, label_smooth=False, train_random_shapes=[320, 352, 384, 416, 448, 480, 512, 544, 576, 608])

构建YOLOv3检测器。注意在YOLOv3，num_classes不需要包含背景类，如目标包括human、dog两种，则num_classes设为2即可，这里与FasterRCNN/MaskRCNN有差别

参数

num_classes (int): 类别数。默认为80。

backbone (str): YOLOv3的backbone网络，取值范围为[‘DarkNet53’, ‘ResNet34’, ‘MobileNetV1’, ‘MobileNetV3_large’]。默认为’MobileNetV1’。

anchors (list|tuple): anchor框的宽度和高度，为None时表示使用默认值 [[10, 13], [16, 30], [33, 23], [30, 61], [62, 45], [59, 119], [116, 90], [156, 198], [373, 326]]。

anchor_masks (list|tuple): 在计算YOLOv3损失时，使用anchor的mask索引，为None时表示使用默认值 [[6, 7, 8], [3, 4, 5], [0, 1, 2]]。

ignore_threshold (float): 在计算YOLOv3损失时，IoU大于ignore_threshold的预测框的置信度被忽略。默认为0.7。

nms_score_threshold (float): 检测框的置信度得分阈值，置信度得分低于阈值的框应该被忽略。默认为0.01。

nms_topk (int): 进行NMS时，根据置信度保留的最大检测框数。默认为1000。

nms_keep_topk (int): 进行NMS后，每个图像要保留的总检测框数。默认为100。

nms_iou_threshold (float): 进行NMS时，用于剔除检测框IOU的阈值。默认为0.45。

label_smooth (bool): 是否使用label smooth。默认值为False。

train_random_shapes (list|tuple): 训练时从列表中随机选择图像大小。默认值为[320, 352, 384, 416, 448, 480, 512, 544, 576, 608]。

train¶

train(self, num_epochs, train_dataset, train_batch_size=8, eval_dataset=None, save_interval_epochs=20, log_interval_steps=2, save_dir='output', pretrain_weights='IMAGENET', optimizer=None, learning_rate=1.0/8000, warmup_steps=1000, warmup_start_lr=0.0, lr_decay_epochs=[213, 240], lr_decay_gamma=0.1, metric=None, use_vdl=False, sensitivities_file=None, eval_metric_loss=0.05, early_stop=False, early_stop_patience=5, resume_checkpoint=None)

YOLOv3模型的训练接口，函数内置了piecewise学习率衰减策略和momentum优化器。

参数

num_epochs (int): 训练迭代轮数。

train_dataset (paddlex.datasets): 训练数据读取器。

train_batch_size (int): 训练数据batch大小。目前检测仅支持单卡评估，训练数据batch大小与显卡数量之商为验证数据batch大小。默认值为8。

eval_dataset (paddlex.datasets): 验证数据读取器。

save_interval_epochs (int): 模型保存间隔（单位：迭代轮数）。默认为20。

log_interval_steps (int): 训练日志输出间隔（单位：迭代次数）。默认为2。

save_dir (str): 模型保存路径。默认值为’output’。

pretrain_weights (str): 若指定为路径时，则加载路径下预训练模型；若为字符串’IMAGENET’，则自动下载在ImageNet图片数据上预训练的模型权重；若为字符串’COCO’，则自动下载在COCO数据集上预训练的模型权重；若为None，则不使用预训练模型。默认为None。

optimizer (paddle.fluid.optimizer): 优化器。当该参数为None时，使用默认优化器：fluid.layers.piecewise_decay衰减策略，fluid.optimizer.Momentum优化方法。

learning_rate (float): 默认优化器的学习率。默认为1.0/8000。

warmup_steps (int): 默认优化器进行warmup过程的步数。默认为1000。

warmup_start_lr (int): 默认优化器warmup的起始学习率。默认为0.0。

lr_decay_epochs (list): 默认优化器的学习率衰减轮数。默认为[213, 240]。

lr_decay_gamma (float): 默认优化器的学习率衰减率。默认为0.1。

metric (bool): 训练过程中评估的方式，取值范围为[‘COCO’, ‘VOC’]。默认值为None。

use_vdl (bool): 是否使用VisualDL进行可视化。默认值为False。

sensitivities_file (str): 若指定为路径时，则加载路径下敏感度信息进行裁剪；若为字符串’DEFAULT’，则自动下载在PascalVOC数据上获得的敏感度信息进行裁剪；若为None，则不进行裁剪。默认为None。

eval_metric_loss (float): 可容忍的精度损失。默认为0.05。

early_stop (bool): 是否使用提前终止训练策略。默认值为False。

early_stop_patience (int): 当使用提前终止训练策略时，如果验证集精度在early_stop_patience个epoch内连续下降或持平，则终止训练。默认值为5。

resume_checkpoint (str): 恢复训练时指定上次训练保存的模型路径。若为None，则不会恢复训练。默认值为None。

evaluate¶

evaluate(self, eval_dataset, batch_size=1, epoch_id=None, metric=None, return_details=False)

YOLOv3模型的评估接口，模型评估后会返回在验证集上的指标box_map(metric指定为’VOC’时)或box_mmap(metric指定为COCO时)。

参数

eval_dataset (paddlex.datasets): 验证数据读取器。

batch_size (int): 验证数据批大小。默认为1。

epoch_id (int): 当前评估模型所在的训练轮数。

metric (bool): 训练过程中评估的方式，取值范围为[‘COCO’, ‘VOC’]。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则metric为’VOC’；如为COCODetection，则metric为’COCO’默认为None，如为EasyData类型数据集，同时也会使用’VOC’。

return_details (bool): 是否返回详细信息。默认值为False。

返回值

tuple (metrics, eval_details) | dict (metrics): 当return_details为True时，返回(metrics, eval_details)，当return_details为False时，返回metrics。metrics为dict，包含关键字：’bbox_mmap’或者’bbox_map‘，分别表示平均准确率平均值在各个阈值下的结果取平均值的结果（mmAP）、平均准确率平均值（mAP）。eval_details为dict，包含关键字：’bbox’，对应元素预测结果列表，每个预测结果由图像id、预测框类别id、预测框坐标、预测框得分；’gt‘：真实标注框相关信息。

predict¶

predict(self, img_file, transforms=None)

YOLOv3模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在YOLOv3.test_transforms和YOLOv3.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口

参数

img_file (str|np.ndarray): 预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.det.transforms): 数据预处理操作。

返回值

list: 预测结果列表，列表中每个元素均为一个dict，key包括’bbox’, ‘category’, ‘category_id’, ‘score’，分别表示每个预测目标的框坐标信息、类别、类别id、置信度，其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。

batch_predict¶

batch_predict(self, img_file_list, transforms=None, thread_num=2)

YOLOv3模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在YOLOv3.test_transforms和YOLOv3.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口

参数

img_file_list (str|np.ndarray): 对列表（或元组）中的图像同时进行预测，列表中的元素是预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.det.transforms): 数据预处理操作。

thread_num (int): 并发执行各图像预处理时的线程数。

返回值

list: 每个元素都为列表，表示各图像的预测结果。在各图像的预测结果列表中，每个元素均为一个dict，key包括’bbox’, ‘category’, ‘category_id’, ‘score’，分别表示每个预测目标的框坐标信息、类别、类别id、置信度，其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。

paddlex.det.FasterRCNN¶

paddlex.det.FasterRCNN(num_classes=81, backbone='ResNet50', with_fpn=True, aspect_ratios=[0.5, 1.0, 2.0], anchor_sizes=[32, 64, 128, 256, 512])

构建FasterRCNN检测器。 注意在FasterRCNN中，num_classes需要设置为类别数+背景类，如目标包括human、dog两种，则num_classes需设为3，多的一种为背景background类别

参数

num_classes (int): 包含了背景类的类别数。默认为81。

backbone (str): FasterRCNN的backbone网络，取值范围为[‘ResNet18’, ‘ResNet50’, ‘ResNet50_vd’, ‘ResNet101’, ‘ResNet101_vd’, ‘HRNet_W18’]。默认为’ResNet50’。

with_fpn (bool): 是否使用FPN结构。默认为True。

aspect_ratios (list): 生成anchor高宽比的可选值。默认为[0.5, 1.0, 2.0]。

anchor_sizes (list): 生成anchor大小的可选值。默认为[32, 64, 128, 256, 512]。

train¶

train(self, num_epochs, train_dataset, train_batch_size=2, eval_dataset=None, save_interval_epochs=1, log_interval_steps=2,save_dir='output', pretrain_weights='IMAGENET', optimizer=None, learning_rate=0.0025, warmup_steps=500, warmup_start_lr=1.0/1200, lr_decay_epochs=[8, 11], lr_decay_gamma=0.1, metric=None, use_vdl=False, early_stop=False, early_stop_patience=5, resume_checkpoint=None)

FasterRCNN模型的训练接口，函数内置了piecewise学习率衰减策略和momentum优化器。

参数

num_epochs (int): 训练迭代轮数。

train_dataset (paddlex.datasets): 训练数据读取器。

train_batch_size (int): 训练数据batch大小。目前检测仅支持单卡评估，训练数据batch大小与显卡数量之商为验证数据batch大小。默认为2。

eval_dataset (paddlex.datasets): 验证数据读取器。

save_interval_epochs (int): 模型保存间隔（单位：迭代轮数）。默认为1。

log_interval_steps (int): 训练日志输出间隔（单位：迭代次数）。默认为2。

save_dir (str): 模型保存路径。默认值为’output’。

pretrain_weights (str): 若指定为路径时，则加载路径下预训练模型；若为字符串’IMAGENET’，则自动下载在ImageNet图片数据上预训练的模型权重；若为字符串’COCO’，则自动下载在COCO数据集上预训练的模型权重（注意：暂未提供ResNet18的COCO预训练模型）；为None，则不使用预训练模型。默认为None。

optimizer (paddle.fluid.optimizer): 优化器。当该参数为None时，使用默认优化器：fluid.layers.piecewise_decay衰减策略，fluid.optimizer.Momentum优化方法。

learning_rate (float): 默认优化器的初始学习率。默认为0.0025。

warmup_steps (int): 默认优化器进行warmup过程的步数。默认为500。

warmup_start_lr (int): 默认优化器warmup的起始学习率。默认为1.0/1200。

lr_decay_epochs (list): 默认优化器的学习率衰减轮数。默认为[8, 11]。

lr_decay_gamma (float): 默认优化器的学习率衰减率。默认为0.1。

metric (bool): 训练过程中评估的方式，取值范围为[‘COCO’, ‘VOC’]。默认值为None。

use_vdl (bool): 是否使用VisualDL进行可视化。默认值为False。

early_stop (float): 是否使用提前终止训练策略。默认值为False。

early_stop_patience (int): 当使用提前终止训练策略时，如果验证集精度在early_stop_patience个epoch内连续下降或持平，则终止训练。默认值为5。

resume_checkpoint (str): 恢复训练时指定上次训练保存的模型路径。若为None，则不会恢复训练。默认值为None。

evaluate¶

evaluate(self, eval_dataset, batch_size=1, epoch_id=None, metric=None, return_details=False)

FasterRCNN模型的评估接口，模型评估后会返回在验证集上的指标box_map(metric指定为’VOC’时)或box_mmap(metric指定为COCO时)。

参数

eval_dataset (paddlex.datasets): 验证数据读取器。

batch_size (int): 验证数据批大小。默认为1。当前只支持设置为1。

epoch_id (int): 当前评估模型所在的训练轮数。

metric (bool): 训练过程中评估的方式，取值范围为[‘COCO’, ‘VOC’]。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则metric为’VOC’; 如为COCODetection，则metric为’COCO’。

return_details (bool): 是否返回详细信息。默认值为False。

返回值

tuple (metrics, eval_details) | dict (metrics): 当return_details为True时，返回(metrics, eval_details)，当return_details为False时，返回metrics。metrics为dict，包含关键字：’bbox_mmap’或者’bbox_map‘，分别表示平均准确率平均值在各个IoU阈值下的结果取平均值的结果（mmAP）、平均准确率平均值（mAP）。eval_details为dict，包含关键字：’bbox’，对应元素预测结果列表，每个预测结果由图像id、预测框类别id、预测框坐标、预测框得分；’gt‘：真实标注框相关信息。

predict¶

predict(self, img_file, transforms=None)

FasterRCNN模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在FasterRCNN.test_transforms和FasterRCNN.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file (str|np.ndarray): 预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.det.transforms): 数据预处理操作。

返回值

list: 预测结果列表，列表中每个元素均为一个dict，key包括’bbox’, ‘category’, ‘category_id’, ‘score’，分别表示每个预测目标的框坐标信息、类别、类别id、置信度，其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。

batch_predict¶

batch_predict(self, img_file_list, transforms=None, thread_num=2)

FasterRCNN模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在FasterRCNN.test_transforms和FasterRCNN.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file_list (list|tuple): 对列表（或元组）中的图像同时进行预测，列表中的元素是预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.det.transforms): 数据预处理操作。

thread_num (int): 并发执行各图像预处理时的线程数。

返回值

list: 每个元素都为列表，表示各图像的预测结果。在各图像的预测结果列表中，每个元素均为一个dict，key包括’bbox’, ‘category’, ‘category_id’, ‘score’，分别表示每个预测目标的框坐标信息、类别、类别id、置信度，其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。

Instance Segmentation¶

MaskRCNN¶

paddlex.det.MaskRCNN(num_classes=81, backbone='ResNet50', with_fpn=True, aspect_ratios=[0.5, 1.0, 2.0], anchor_sizes=[32, 64, 128, 256, 512])

构建MaskRCNN检测器。注意在MaskRCNN中，num_classes需要设置为类别数+背景类，如目标包括human、dog两种，则num_classes需设为3，多的一种为背景background类别

参数

num_classes (int): 包含了背景类的类别数。默认为81。

backbone (str): MaskRCNN的backbone网络，取值范围为[‘ResNet18’, ‘ResNet50’, ‘ResNet50_vd’, ‘ResNet101’, ‘ResNet101_vd’, ‘HRNet_W18’]。默认为’ResNet50’。

with_fpn (bool): 是否使用FPN结构。默认为True。

aspect_ratios (list): 生成anchor高宽比的可选值。默认为[0.5, 1.0, 2.0]。

anchor_sizes (list): 生成anchor大小的可选值。默认为[32, 64, 128, 256, 512]。

train¶

train(self, num_epochs, train_dataset, train_batch_size=1, eval_dataset=None, save_interval_epochs=1, log_interval_steps=20, save_dir='output', pretrain_weights='IMAGENET', optimizer=None, learning_rate=1.0/800, warmup_steps=500, warmup_start_lr=1.0 / 2400, lr_decay_epochs=[8, 11], lr_decay_gamma=0.1, metric=None, use_vdl=False, early_stop=False, early_stop_patience=5, resume_checkpoint=None)

MaskRCNN模型的训练接口，函数内置了piecewise学习率衰减策略和momentum优化器。

参数

num_epochs (int): 训练迭代轮数。

train_dataset (paddlex.datasets): 训练数据读取器。

train_batch_size (int): 训练数据batch大小。目前检测仅支持单卡评估，训练数据batch大小与显卡数量之商为验证数据batch大小。默认为1。

eval_dataset (paddlex.datasets): 验证数据读取器。

save_interval_epochs (int): 模型保存间隔（单位：迭代轮数）。默认为1。

log_interval_steps (int): 训练日志输出间隔（单位：迭代次数）。默认为2。

save_dir (str): 模型保存路径。默认值为’output’。

pretrain_weights (str): 若指定为路径时，则加载路径下预训练模型；若为字符串’IMAGENET’，则自动下载在ImageNet图片数据上预训练的模型权重；若为字符串’COCO’，则自动下载在COCO数据集上预训练的模型权重（注意：暂未提供ResNet18和HRNet_W18的COCO预训练模型）；若为None，则不使用预训练模型。默认为None。

optimizer (paddle.fluid.optimizer): 优化器。当该参数为None时，使用默认优化器：fluid.layers.piecewise_decay衰减策略，fluid.optimizer.Momentum优化方法。

learning_rate (float): 默认优化器的初始学习率。默认为0.00125。

warmup_steps (int): 默认优化器进行warmup过程的步数。默认为500。

warmup_start_lr (int): 默认优化器warmup的起始学习率。默认为1.0/2400。

lr_decay_epochs (list): 默认优化器的学习率衰减轮数。默认为[8, 11]。

lr_decay_gamma (float): 默认优化器的学习率衰减率。默认为0.1。

metric (bool): 训练过程中评估的方式，取值范围为[‘COCO’, ‘VOC’]。默认值为None。

use_vdl (bool): 是否使用VisualDL进行可视化。默认值为False。

early_stop (float): 是否使用提前终止训练策略。默认值为False。

early_stop_patience (int): 当使用提前终止训练策略时，如果验证集精度在early_stop_patience个epoch内连续下降或持平，则终止训练。默认值为5。

resume_checkpoint (str): 恢复训练时指定上次训练保存的模型路径。若为None，则不会恢复训练。默认值为None。

evaluate¶

evaluate(self, eval_dataset, batch_size=1, epoch_id=None, metric=None, return_details=False)

MaskRCNN模型的评估接口，模型评估后会返回在验证集上的指标box_mmap(metric指定为COCO时)和相应的seg_mmap。

参数

eval_dataset (paddlex.datasets): 验证数据读取器。

batch_size (int): 验证数据批大小。默认为1。当前只支持设置为1。

epoch_id (int): 当前评估模型所在的训练轮数。

metric (bool): 训练过程中评估的方式，取值范围为[‘COCO’, ‘VOC’]。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则metric为’VOC’; 如为COCODetection，则metric为’COCO’。

return_details (bool): 是否返回详细信息。默认值为False。

返回值

tuple (metrics, eval_details) | dict (metrics): 当return_details为True时，返回(metrics, eval_details)，当return_details为False时，返回metrics。metrics为dict，包含关键字：’bbox_mmap’和’segm_mmap’或者’bbox_map‘和’segm_map’，分别表示预测框和分割区域平均准确率平均值在各个IoU阈值下的结果取平均值的结果（mmAP）、平均准确率平均值（mAP）。eval_details为dict，包含关键字：’bbox’，对应元素预测框结果列表，每个预测结果由图像id、预测框类别id、预测框坐标、预测框得分；’mask’，对应元素预测区域结果列表，每个预测结果由图像id、预测区域类别id、预测区域坐标、预测区域得分；’gt‘：真实标注框和标注区域相关信息。

predict¶

predict(self, img_file, transforms=None)

MaskRCNN模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在FasterRCNN.test_transforms和FasterRCNN.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file (str|np.ndarray): 预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.det.transforms): 数据预处理操作。

返回值

list: 预测结果列表，列表中每个元素均为一个dict，key’bbox’, ‘mask’, ‘category’, ‘category_id’, ‘score’，分别表示每个预测目标的框坐标信息、Mask信息，类别、类别id、置信度。其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。Mask信息为原图大小的二值图，1表示像素点属于预测类别，0表示像素点是背景。

batch_predict¶

batch_predict(self, img_file_list, transforms=None, thread_num=2)

MaskRCNN模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在FasterRCNN.test_transforms和FasterRCNN.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file_list (list|tuple): 对列表（或元组）中的图像同时进行预测，列表中的元素可以是预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.det.transforms): 数据预处理操作。

thread_num (int): 并发执行各图像预处理时的线程数。

返回值

list: 每个元素都为列表，表示各图像的预测结果。在各图像的预测结果列表中，每个元素均为一个dict，key’bbox’, ‘mask’, ‘category’, ‘category_id’, ‘score’，分别表示每个预测目标的框坐标信息、Mask信息，类别、类别id、置信度。其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。Mask信息为原图大小的二值图，1表示像素点属于预测类别，0表示像素点是背景。

Semantic Segmentation¶

paddlex.seg.DeepLabv3p¶

paddlex.seg.DeepLabv3p(num_classes=2, backbone='MobileNetV2_x1.0', output_stride=16, aspp_with_sep_conv=True, decoder_use_sep_conv=True, encoder_with_aspp=True, enable_decoder=True, use_bce_loss=False, use_dice_loss=False, class_weight=None, ignore_index=255)

构建DeepLabv3p分割器。

参数

num_classes (int): 类别数。

backbone (str): DeepLabv3+的backbone网络，实现特征图的计算，取值范围为[‘Xception65’, ‘Xception41’, ‘MobileNetV2_x0.25’, ‘MobileNetV2_x0.5’, ‘MobileNetV2_x1.0’, ‘MobileNetV2_x1.5’, ‘MobileNetV2_x2.0’]，默认值为’MobileNetV2_x1.0’。

output_stride (int): backbone 输出特征图相对于输入的下采样倍数，一般取值为8或16。默认16。

aspp_with_sep_conv (bool): decoder模块是否采用separable convolutions。默认True。

decoder_use_sep_conv (bool)： decoder模块是否采用separable convolutions。默认True。

encoder_with_aspp (bool): 是否在encoder阶段采用aspp模块。默认True。

enable_decoder (bool): 是否使用decoder模块。默认True。

use_bce_loss (bool): 是否使用bce loss作为网络的损失函数，只能用于两类分割。可与dice loss同时使用。默认False。

use_dice_loss (bool): 是否使用dice loss作为网络的损失函数，只能用于两类分割，可与bce loss同时使用，当use_bce_loss和use_dice_loss都为False时，使用交叉熵损失函数。默认False。

class_weight (list/str): 交叉熵损失函数各类损失的权重。当class_weight为list的时候，长度应为num_classes。当class_weight为str时， weight.lower()应为’dynamic’，这时会根据每一轮各类像素的比重自行计算相应的权重，每一类的权重为：每类的比例 * num_classes。class_weight取默认值None是，各类的权重1，即平时使用的交叉熵损失函数。

ignore_index (int): label上忽略的值，label为ignore_index的像素不参与损失函数的计算。默认255。

train¶

train(self, num_epochs, train_dataset, train_batch_size=2, eval_dataset=None, eval_batch_size=1, save_interval_epochs=1, log_interval_steps=2, save_dir='output', pretrain_weights='IMAGENET', optimizer=None, learning_rate=0.01, lr_decay_power=0.9, use_vdl=False, sensitivities_file=None, eval_metric_loss=0.05, early_stop=False, early_stop_patience=5, resume_checkpoint=None):

DeepLabv3p模型的训练接口，函数内置了polynomial学习率衰减策略和momentum优化器。

参数

num_epochs (int): 训练迭代轮数。

train_dataset (paddlex.datasets): 训练数据读取器。

train_batch_size (int): 训练数据batch大小。同时作为验证数据batch大小。默认2。

eval_dataset (paddlex.datasets): 评估数据读取器。

save_interval_epochs (int): 模型保存间隔（单位：迭代轮数）。默认为1。

log_interval_steps (int): 训练日志输出间隔（单位：迭代次数）。默认为2。

save_dir (str): 模型保存路径。默认’output’

pretrain_weights (str): 若指定为路径时，则加载路径下预训练模型；若为字符串’IMAGENET’，则自动下载在ImageNet图片数据上预训练的模型权重；若为字符串’COCO’，则自动下载在COCO数据集上预训练的模型权重（注意：暂未提供Xception41、MobileNetV2_x0.25、MobileNetV2_x0.5、MobileNetV2_x1.5、MobileNetV2_x2.0的COCO预训练模型）；若为字符串’CITYSCAPES’，则自动下载在CITYSCAPES数据集上预训练的模型权重（注意：暂未提供Xception41、MobileNetV2_x0.25、MobileNetV2_x0.5、MobileNetV2_x1.5、MobileNetV2_x2.0的CITYSCAPES预训练模型）；若为None，则不使用预训练模型。默认’IMAGENET’。

optimizer (paddle.fluid.optimizer): 优化器。当该参数为None时，使用默认的优化器：使用fluid.optimizer.Momentum优化方法，polynomial的学习率衰减策略。

learning_rate (float): 默认优化器的初始学习率。默认0.01。

lr_decay_power (float): 默认优化器学习率衰减指数。默认0.9。

use_vdl (bool): 是否使用VisualDL进行可视化。默认False。

sensitivities_file (str): 若指定为路径时，则加载路径下敏感度信息进行裁剪；若为字符串’DEFAULT’，则自动下载在Cityscapes图片数据上获得的敏感度信息进行裁剪；若为None，则不进行裁剪。默认为None。

eval_metric_loss (float): 可容忍的精度损失。默认为0.05。

early_stop (bool): 是否使用提前终止训练策略。默认值为False。

early_stop_patience (int): 当使用提前终止训练策略时，如果验证集精度在early_stop_patience个epoch内连续下降或持平，则终止训练。默认值为5。

resume_checkpoint (str): 恢复训练时指定上次训练保存的模型路径。若为None，则不会恢复训练。默认值为None。

evaluate¶

evaluate(self, eval_dataset, batch_size=1, epoch_id=None, return_details=False):

DeepLabv3p模型评估接口。

参数

eval_dataset (paddlex.datasets): 评估数据读取器。

batch_size (int): 评估时的batch大小。默认1。

epoch_id (int): 当前评估模型所在的训练轮数。

return_details (bool): 是否返回详细信息。默认False。

返回值

dict: 当return_details为False时，返回dict。包含关键字：’miou’、’category_iou’、’macc’、 ‘category_acc’和’kappa’，分别表示平均iou、各类别iou、平均准确率、各类别准确率和kappa系数。

tuple (metrics, eval_details)：当return_details为True时，增加返回dict (eval_details)，包含关键字：’confusion_matrix’，表示评估的混淆矩阵。

predict¶

predict(self, img_file, transforms=None):

DeepLabv3p模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在DeepLabv3p.test_transforms和DeepLabv3p.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file (str|np.ndarray): 预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.seg.transforms): 数据预处理操作。

thread_num (int): 并发执行各图像预处理时的线程数。 返回值

dict: 包含关键字’label_map’和’score_map’, ‘label_map’存储预测结果灰度图，像素值表示对应的类别，’score_map’存储各类别的概率，shape=(h, w, num_classes)。

batch_predict¶

batch_predict(self, img_file_list, transforms=None):

DeepLabv3p模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在DeepLabv3p.test_transforms和DeepLabv3p.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。

参数

img_file_list (list|tuple): 对列表（或元组）中的图像同时进行预测，列表中的元素可以是预测图像路径或numpy数组(HWC排列，BGR格式)。

transforms (paddlex.seg.transforms): 数据预处理操作。

返回值

dict: 每个元素都为列表，表示各图像的预测结果。各图像的预测结果用字典表示，包含关键字’label_map’和’score_map’, ‘label_map’存储预测结果灰度图，像素值表示对应的类别，’score_map’存储各类别的概率，shape=(h, w, num_classes)。

paddlex.seg.UNet¶

paddlex.seg.UNet(num_classes=2, upsample_mode='bilinear', use_bce_loss=False, use_dice_loss=False, class_weight=None, ignore_index=255)

构建UNet分割器。

参数

num_classes (int): 类别数。

upsample_mode (str): UNet decode时采用的上采样方式，取值为’bilinear’时利用双线行差值进行上菜样，当输入其他选项时则利用反卷积进行上菜样，默认为’bilinear’。

use_bce_loss (bool): 是否使用bce loss作为网络的损失函数，只能用于两类分割。可与dice loss同时使用。默认False。

use_dice_loss (bool): 是否使用dice loss作为网络的损失函数，只能用于两类分割，可与bce loss同时使用。当use_bce_loss和use_dice_loss都为False时，使用交叉熵损失函数。默认False。

class_weight (list/str): 交叉熵损失函数各类损失的权重。当class_weight为list的时候，长度应为num_classes。当class_weight为str时， weight.lower()应为’dynamic’，这时会根据每一轮各类像素的比重自行计算相应的权重，每一类的权重为：每类的比例 * num_classes。class_weight取默认值None是，各类的权重1，即平时使用的交叉熵损失函数。

ignore_index (int): label上忽略的值，label为ignore_index的像素不参与损失函数的计算。默认255。

train 训练接口说明同 DeepLabv3p模型train接口

evaluate 评估接口说明同 DeepLabv3p模型evaluate接口

predict 预测接口说明同 DeepLabv3p模型predict接口

batch_predict 批量预测接口说明同 DeepLabv3p模型predict接口

paddlex.seg.HRNet¶

paddlex.seg.HRNet(num_classes=2, width=18, use_bce_loss=False, use_dice_loss=False, class_weight=None, ignore_index=255)

构建HRNet分割器。

参数

num_classes (int): 类别数。

width (int|str): 高分辨率分支中特征层的通道数量。默认值为18。可选择取值为[18, 30, 32, 40, 44, 48, 60, 64, ‘18_small_v1’]。’18_small_v1’是18的轻量级版本。

use_bce_loss (bool): 是否使用bce loss作为网络的损失函数，只能用于两类分割。可与dice loss同时使用。默认False。

use_dice_loss (bool): 是否使用dice loss作为网络的损失函数，只能用于两类分割，可与bce loss同时使用。当use_bce_loss和use_dice_loss都为False时，使用交叉熵损失函数。默认False。

class_weight (list|str): 交叉熵损失函数各类损失的权重。当class_weight为list的时候，长度应为num_classes。当class_weight为str时， weight.lower()应为’dynamic’，这时会根据每一轮各类像素的比重自行计算相应的权重，每一类的权重为：每类的比例 * num_classes。class_weight取默认值None是，各类的权重1，即平时使用的交叉熵损失函数。

ignore_index (int): label上忽略的值，label为ignore_index的像素不参与损失函数的计算。默认255。

train 训练接口说明同 DeepLabv3p模型train接口

evaluate 评估接口说明同 DeepLabv3p模型evaluate接口

predict 预测接口说明同 DeepLabv3p模型predict接口

batch_predict 批量预测接口说明同 DeepLabv3p模型predict接口

paddlex.seg.FastSCNN¶

paddlex.seg.FastSCNN(num_classes=2, use_bce_loss=False, use_dice_loss=False, class_weight=None, ignore_index=255, multi_loss_weight=[1.0])

构建FastSCNN分割器。

参数

num_classes (int): 类别数。

use_bce_loss (bool): 是否使用bce loss作为网络的损失函数，只能用于两类分割。可与dice loss同时使用。默认False。

use_dice_loss (bool): 是否使用dice loss作为网络的损失函数，只能用于两类分割，可与bce loss同时使用。当use_bce_loss和use_dice_loss都为False时，使用交叉熵损失函数。默认False。

class_weight (list/str): 交叉熵损失函数各类损失的权重。当class_weight为list的时候，长度应为num_classes。当class_weight为str时， weight.lower()应为’dynamic’，这时会根据每一轮各类像素的比重自行计算相应的权重，每一类的权重为：每类的比例 * num_classes。class_weight取默认值None是，各类的权重1，即平时使用的交叉熵损失函数。

ignore_index (int): label上忽略的值，label为ignore_index的像素不参与损失函数的计算。默认255。

multi_loss_weight (list): 多分支上的loss权重。默认计算一个分支上的loss，即默认值为[1.0]。也支持计算两个分支或三个分支上的loss，权重按[fusion_branch_weight, higher_branch_weight, lower_branch_weight]排列，fusion_branch_weight为空间细节分支和全局上下文分支融合后的分支上的loss权重，higher_branch_weight为空间细节分支上的loss权重，lower_branch_weight为全局上下文分支上的loss权重，若higher_branch_weight和lower_branch_weight未设置则不会计算这两个分支上的loss。

train 训练接口说明同 DeepLabv3p模型train接口

evaluate 评估接口说明同 DeepLabv3p模型evaluate接口

predict 预测接口说明同 DeepLabv3p模型predict接口

batch_predict 批量预测接口说明同 DeepLabv3p模型predict接口

模型压缩¶

paddlex.slim.cal_params_sensitivities¶

计算参数敏感度

paddlex.slim.cal_params_sensitivities(model, save_file, eval_dataset, batch_size=8)

计算模型中可裁剪参数在验证集上的敏感度，并将敏感度信息保存至文件save_file

获取模型中可裁剪卷积Kernel的名称。
计算每个可裁剪卷积Kernel不同裁剪率下的敏感度。【注意】卷积的敏感度是指在不同裁剪率下评估数据集预测精度的损失，通过得到的敏感度，可以决定最终模型需要裁剪的参数列表和各裁剪参数对应的裁剪率。查看使用示例

参数¶

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¶

导出量化模型

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): 量化过程中的统计数据临时存储目录

使用示例¶

点击下载如下示例中的模型，数据集

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')

预测结果可视化¶

PaddleX提供了一系列模型预测和结果分析的可视化函数。

paddlex.det.visualize¶

目标检测/实例分割预测结果可视化

paddlex.det.visualize(image, result, threshold=0.5, save_dir='./')

将目标检测/实例分割模型预测得到的Box框和Mask在原图上进行可视化。

参数¶

image (str|np.ndarray): 原图文件路径或numpy数组(HWC排列，BGR格式)。

result (str): 模型预测结果。

threshold(float): score阈值，将Box置信度低于该阈值的框过滤不进行可视化。默认0.5

save_dir(str): 可视化结果保存路径。若为None，则表示不保存，该函数将可视化的结果以np.ndarray的形式返回；若设为目录路径，则将可视化结果保存至该目录下。默认值为’./’。

使用示例¶

点击下载如下示例中的模型

import paddlex as pdx
model = pdx.load_model('xiaoduxiong_epoch_12')
result = model.predict('./xiaoduxiong_epoch_12/xiaoduxiong.jpeg')
pdx.det.visualize('./xiaoduxiong_epoch_12/xiaoduxiong.jpeg', result, save_dir='./')
# 预测结果保存在./visualize_xiaoduxiong.jpeg

paddlex.seg.visualize¶

语义分割模型预测结果可视化

paddlex.seg.visualize(image, result, weight=0.6, save_dir='./')

将语义分割模型预测得到的Mask在原图上进行可视化。

参数¶

image (str|np.ndarray): 原图文件路径或numpy数组(HWC排列，BGR格式)。

result (str): 模型预测结果。

weight(float): mask可视化结果与原图权重因子，weight表示原图的权重。默认0.6。

save_dir(str): 可视化结果保存路径。若为None，则表示不保存，该函数将可视化的结果以np.ndarray的形式返回；若设为目录路径，则将可视化结果保存至该目录下。默认值为’./’。

使用示例¶

点击下载如下示例中的模型和测试图片

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.det.draw_pr_curve¶

目标检测/实例分割准确率-召回率可视化

paddlex.det.draw_pr_curve(eval_details_file=None, gt=None, pred_bbox=None, pred_mask=None, iou_thresh=0.5, save_dir='./')

将目标检测/实例分割模型评估结果中各个类别的准确率和召回率的对应关系进行可视化，同时可视化召回率和置信度阈值的对应关系。

注：PaddleX在训练过程中保存的模型目录中，均包含eval_result.json文件，可将此文件路径传给eval_details_file参数，设定iou_threshold即可得到对应模型在验证集上的PR曲线图。

参数¶

eval_details_file (str): 模型评估结果的保存路径，包含真值信息和预测结果。默认值为None。

gt (list): 数据集的真值信息。默认值为None。

pred_bbox (list): 模型在数据集上的预测框。默认值为None。

pred_mask (list): 模型在数据集上的预测mask。默认值为None。

iou_thresh (float): 判断预测框或预测mask为真阳时的IoU阈值。默认值为0.5。

save_dir (str): 可视化结果保存路径。默认值为’./’。

注意：eval_details_file的优先级更高，只要eval_details_file不为None，就会从eval_details_file提取真值信息和预测结果做分析。当eval_details_file为None时，则用gt、pred_mask、pred_mask做分析。

使用示例¶

点击下载如下示例中的模型和数据集

方式一：分析训练过程中保存的模型文件夹中的评估结果文件eval_details.json，例如模型中的eval_details.json。

import paddlex as pdx
eval_details_file = 'insect_epoch_270/eval_details.json'
pdx.det.draw_pr_curve(eval_details_file, save_dir='./insect')

方式二：分析模型评估函数返回的评估结果。

import os
# 选择使用0号卡
os.environ['CUDA_VISIBLE_DEVICES'] = '0'

from paddlex.det import transforms
import paddlex as pdx

model = pdx.load_model('insect_epoch_270')
eval_dataset = pdx.datasets.VOCDetection(
    data_dir='insect_det',
    file_list='insect_det/val_list.txt',
    label_list='insect_det/labels.txt',
    transforms=model.eval_transforms)
metrics, evaluate_details = model.evaluate(eval_dataset, batch_size=8, return_details=True)
gt = evaluate_details['gt']
bbox = evaluate_details['bbox']
pdx.det.draw_pr_curve(gt=gt, pred_bbox=bbox, save_dir='./insect')

预测框的各个类别的准确率和召回率的对应关系、召回率和置信度阈值的对应关系可视化如下： _images/insect_bbox_pr_curve(iou-0.5).png

paddlex.slim.visualzie¶

模型裁剪比例可视化分析

paddlex.slim.visualize(model, sensitivities_file)

利用此接口，可以分析在不同的eval_metric_loss参数下，模型被裁剪的比例情况。可视化结果纵轴为eval_metric_loss参数值，横轴为对应的模型被裁剪的比例。

参数¶

model (paddlex.cv.models): 使用PaddleX加载的模型。

sensitivities_file (str): 模型各参数在验证集上计算得到的参数敏感度信息文件。

使用示例¶

点击下载示例中的模型和sensitivities_file

import paddlex as pdx
model = pdx.load_model('vegetables_mobilenet')
pdx.slim.visualize(model, 'mobilenetv2.sensitivities', save_dir='./')
# 可视化结果保存在./sensitivities.png

paddlex.transforms.visualize¶

数据预处理/增强过程可视化

paddlex.transforms.visualize(dataset,
                             img_count=3,
                             save_dir='vdl_output')

对数据预处理/增强中间结果进行可视化。可使用VisualDL查看中间结果：

VisualDL启动方式: visualdl –logdir vdl_output –port 8001
浏览器打开 https://0.0.0.0:8001即可，其中0.0.0.0为本机访问，如为远程服务, 改成相应机器IP

参数¶

dataset (paddlex.datasets): 数据集读取器。

img_count (int): 需要进行数据预处理/增强的图像数目。默认为3。

save_dir (str): 日志保存的路径。默认为’vdl_output’。

模型可解释性¶

目前PaddleX支持对于图像分类的结果以可视化的方式进行解释，支持LIME和NormLIME两种可解释性算法。

paddlex.interpret.lime¶

LIME可解释性结果可视化

paddlex.interpret.lime(img_file,
                       model,
                       num_samples=3000,
                       batch_size=50,
                       save_dir='./')

使用LIME算法将模型预测结果的可解释性可视化。LIME表示与模型无关的局部可解释性，可以解释任何模型。LIME的思想是以输入样本为中心，在其附近的空间中进行随机采样，每个采样通过原模型得到新的输出，这样得到一系列的输入和对应的输出，LIME用一个简单的、可解释的模型（比如线性回归模型）来拟合这个映射关系，得到每个输入维度的权重，以此来解释模型。

注意： 可解释性结果可视化目前只支持分类模型。

参数¶

img_file (str): 预测图像路径。

model (paddlex.cv.models): paddlex中的模型。

num_samples (int): LIME用于学习线性模型的采样数，默认为3000。

batch_size (int): 预测数据batch大小，默认为50。

save_dir (str): 可解释性可视化结果（保存为png格式文件）和中间文件存储路径。

使用示例¶

对预测可解释性结果可视化的过程可参见代码。

paddlex.interpret.normlime¶

NormLIME可解释性结果可视化

paddlex.interpret.normlime(img_file,
                           model,
                           dataset=None,
                           num_samples=3000,
                           batch_size=50,
                           save_dir='./',
                           normlime_weights_file=None)

使用NormLIME算法将模型预测结果的可解释性可视化。 NormLIME是利用一定数量的样本来出一个全局的解释。由于NormLIME计算量较大，此处采用一种简化的方式：使用一定数量的测试样本（目前默认使用所有测试样本），对每个样本进行特征提取，映射到同一个特征空间；然后以此特征做为输入，以模型输出做为输出，使用线性回归对其进行拟合，得到一个全局的输入和输出的关系。之后，对一测试样本进行解释时，使用NormLIME全局的解释，来对LIME的结果进行滤波，使最终的可视化结果更加稳定。

注意： 可解释性结果可视化目前只支持分类模型。

参数¶

img_file (str): 预测图像路径。

model (paddlex.cv.models): paddlex中的模型。

dataset (paddlex.datasets): 数据集读取器，默认为None。

num_samples (int): LIME用于学习线性模型的采样数，默认为3000。

batch_size (int): 预测数据batch大小，默认为50。

save_dir (str): 可解释性可视化结果（保存为png格式文件）和中间文件存储路径。

normlime_weights_file (str): NormLIME初始化文件名，若不存在，则计算一次，保存于该路径；若存在，则直接载入。

注意： dataset`读取的是一个数据集，该数据集不宜过大，否则计算时间会较长，但应包含所有类别的数据。NormLIME可解释性结果可视化目前只支持分类模型。

使用示例¶

对预测可解释性结果可视化的过程可参见代码。

更新日志¶

v1.1.0 2020.07.12

模型更新

新增语义分割模型HRNet、FastSCNN

目标检测FasterRCNN、实例分割MaskRCNN新增backbone HRNet

目标检测/实例分割模型新增COCO数据集预训练模型

集成X2Paddle，PaddleX所有分类模型和语义分割模型支持导出为ONNX协议

模型部署更新

模型加密增加支持Windows平台

新增Jetson、PaddleLite模型部署预测方案

C++部署代码新增batch批预测，并采用OpenMP对预处理进行并行加速

新增2个PaddleX产业案例

人像分割案例

工业表计读数案例

新增数据格式转换功能，LabelMe、精灵标注助手和EasyData平台标注的数据转为PaddleX支持加载的数据格式
PaddleX文档更新，优化文档结构

v1.0.0 2020.05.20

增加模型C++部署和Python部署代码
增加模型加密部署方案
增加分类模型的OpenVINO部署方案
增加模型可解释性的接口

v0.1.8 2020.05.17

修复部分代码Bug
新增EasyData平台数据标注格式支持
支持imgaug数据增强库的pixel-level算子

附录¶

PaddleX模型库¶

图像分类模型¶

表中模型相关指标均为在ImageNet数据集上使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla P40），预测速度为每张图片预测用时（不包括预处理和后处理），表中符号-表示相关指标暂未测试。

模型	模型大小	预测速度（毫秒）	Top1准确率（%）	Top5准确率（%）
ResNet18	46.2MB	3.72882	71.0	89.9
ResNet34	87.9MB	5.50876	74.6	92.1
ResNet50	103.4MB	7.76659	76.5	93.0
ResNet101	180.4MB	13.80876	77.6	93.6
ResNet50_vd	103.5MB	8.20476	79.1	94.4
ResNet101_vd	180.5MB	14.24643	80.2	95.0
ResNet50_vd_ssld	103.5MB	7.79264	82.4	96.1
ResNet101_vd_ssld	180.5MB	13.34580	83.7	96.7
DarkNet53	167.4MB	8.82047	78.0	94.1
MobileNetV1	17.4MB	3.42838	71.0	89.7
MobileNetV2	15.0MB	5.92667	72.2	90.7
MobileNetV3_large	22.8MB	8.31428	75.3	93.2
MobileNetV3_small	12.5MB	7.30689	68.2	88.1
MobileNetV3_large_ssld	22.8MB	8.06651	79.0	94.5
MobileNetV3_small_ssld	12.5MB	7.08837	71.3	90.1
Xception41	109.2MB	8.15611	79.6	94.4
Xception65	161.6MB	13.87017	80.3	94.5
DenseNet121	33.1MB	17.09874	75.7	92.6
DenseNet161	118.0MB	22.79690	78.6	94.1
DenseNet201	84.1MB	25.26089	77.6	93.7
ShuffleNetV2	10.2MB	15.40138	68.8	88.5
HRNet_W18	21.29MB	45.25514	76.9	93.4
AlexNet	244.4MB	-	56.7	79.2

目标检测模型¶

表中模型相关指标均为在MSCOCO数据集上使用PaddlePaddle Python预测接口测试得到（测试GPU型号为Nvidia Tesla V100测试得到），表中符号-表示相关指标暂未测试。

模型	模型大小	预测时间(毫秒)	BoxAP（%）
FasterRCNN-ResNet18-FPN	173.2M	-	32.6
FasterRCNN-ResNet50	136.0MB	197.715	35.2
FasterRCNN-ResNet50_vd	136.1MB	475.700	36.4
FasterRCNN-ResNet101	212.5MB	582.911	38.3
FasterRCNN-ResNet50-FPN	167.7MB	83.189	37.2
FasterRCNN-ResNet50_vd-FPN	167.8MB	128.277	38.9
FasterRCNN-ResNet101-FPN	244.2MB	119.788	38.7
FasterRCNN-ResNet101_vd-FPN	244.3MB	156.097	40.5
FasterRCNN-HRNet_W18-FPN	115.5MB	81.592	36
YOLOv3-DarkNet53	249.2MB	42.672	38.9
YOLOv3-MobileNetV1	99.2MB	15.442	29.3
YOLOv3-MobileNetV3_large	100.7MB	143.322	31.6
YOLOv3-ResNet34	170.3MB	23.185	36.2

实例分割模型¶

预测时间是在一张Nvidia Tesla V100的GPU上通过’evaluate()’接口测试MSCOCO验证集得到，包括数据加载、网络前向执行和后处理, batch size是1，表中符号-表示相关指标暂未测试。

模型	模型大小	预测时间(毫秒)	BoxAP (%)	MaskAP (%)
MaskRCNN-ResNet18-FPN	189.1MB	-	33.6	30.5
MaskRCNN-ResNet50	143.9MB	87	38.2	33.4
MaskRCNN-ResNet50-FPN	177.7MB	63.9	38.7	34.7
MaskRCNN-ResNet50_vd-FPN	177.7MB	63.1	39.8
MaskRCNN-ResNet101-FPN	253.6MB	77	39.5	35.2
MaskRCNN-ResNet101_vd-FPN	253.7MB	76.4	41.4	36.8
MaskRCNN-HRNet_W18-FPN	120.7MB	-	38.7	34.7

语义分割模型¶

以下指标均在MSCOCO验证集上测试得到，表中符号-表示相关指标暂未测试。

模型	模型大小	预测时间(毫秒)	mIoU（%）
DeepLabv3_MobileNetV2_x1.0	14.7MB	-	-
DeepLabv3_Xception65	329.3MB	-	-
UNet	107.3MB	-	-

以下指标均在Cityscapes验证集上测试得到，表中符号-表示相关指标暂未测试。

模型	模型大小	预测时间(毫秒)	mIoU（%）
DeepLabv3_MobileNetv2_x1.0	14.7MB	-	69.8
DeepLabv3_Xception65	329.3MB	-	79.3
HRNet_W18	77.3MB		79.36
Fast-SCNN	9.8MB		69.64

PaddleX压缩模型库¶

图像分类¶

数据集：ImageNet-1000

量化¶

模型	压缩策略	Top-1准确率	存储体积	TensorRT时延(V100, ms)
MobileNetV1	无	70.99%	17MB	-
MobileNetV1	量化	70.18% (-0.81%)	4.4MB	-
MobileNetV2	无	72.15%	15MB	-
MobileNetV2	量化	71.15% (-1%)	4.0MB	-
ResNet50	无	76.50%	99MB	2.71
ResNet50	量化	76.33% (-0.17%)	25.1MB	1.19

分类模型Lite时延(ms)

设备	模型类型	压缩策略	armv7 Thread 1	armv7 Thread 2	armv7 Thread 4	armv8 Thread 1	armv8 Thread 2	armv8 Thread 4
高通835	MobileNetV1	无	96.1942	53.2058	32.4468	88.4955	47.95	27.5189
高通835	MobileNetV1	量化	60.5615	32.4016	16.6596	56.5266	29.7178	15.1459
高通835	MobileNetV2	无	65.715	38.1346	25.155	61.3593	36.2038	22.849
高通835	MobileNetV2	量化	48.3495	30.3069	22.1506	45.8715	27.4105	18.2223
高通835	ResNet50	无	526.811	319.6486	205.8345	506.1138	335.1584	214.8936
高通835	ResNet50	量化	476.0507	256.5963	139.7266	461.9176	248.3795	149.353
高通855	MobileNetV1	无	33.5086	19.5773	11.7534	31.3474	18.5382	10.0811
高通855	MobileNetV1	量化	37.0498	21.7081	11.0779	14.0947	8.1926	4.2934
高通855	MobileNetV2	无	25.0396	15.2862	9.6609	22.909	14.1797	8.8325
高通855	MobileNetV2	量化	28.1631	18.3917	11.8333	16.9399	11.1772	7.4176
高通855	ResNet50	无	185.3705	113.0825	87.0741	177.7367	110.0433	74.4114
高通855	ResNet50	量化	328.2683	201.9937	106.744	242.6397	150.0338	79.8659
麒麟970	MobileNetV1	无	101.2455	56.4053	35.6484	94.8985	51.7251	31.9511
麒麟970	MobileNetV1	量化	62.4412	32.2585	16.6215	57.825	29.2573	15.1206
麒麟970	MobileNetV2	无	70.4176	42.0795	25.1939	68.9597	39.2145	22.6617
麒麟970	MobileNetV2	量化	53.0961	31.7987	21.8334	49.383	28.2358	18.3642
麒麟970	ResNet50	无	586.8943	344.0858	228.2293	573.3344	351.4332	225.8006
麒麟970	ResNet50	量化	489.6188	258.3279	142.6063	480.0064	249.5339	138.5284

剪裁¶

PaddleLite推理耗时说明：

环境：Qualcomm SnapDragon 845 + armv8

速度指标：Thread1/Thread2/Thread4耗时

模型	压缩策略	Top-1	存储体积	PaddleLite推理耗时	TensorRT推理速度(FPS)
MobileNetV1	无	70.99%	17MB	66.052\35.8014\19.5762	-
MobileNetV1	剪裁 -30%	70.4% (-0.59%)	12MB	46.5958\25.3098\13.6982	-
MobileNetV1	剪裁 -50%	69.8% (-1.19%)	9MB	37.9892\20.7882\11.3144	-

目标检测¶

量化¶

数据集： COCO2017

模型	压缩策略	数据集	Image/GPU	输入608 Box AP	存储体积	TensorRT时延(V100, ms)
MobileNet-V1-YOLOv3	无	COCO	8	29.3	95MB	-
MobileNet-V1-YOLOv3	量化	COCO	8	27.9 (-1.4)	25MB	-
R34-YOLOv3	无	COCO	8	36.2	162MB	-
R34-YOLOv3	量化	COCO	8	35.7 (-0.5)	42.7MB	-

剪裁¶

数据集：Pasacl VOC & COCO2017

PaddleLite推理耗时说明：

环境：Qualcomm SnapDragon 845 + armv8

速度指标：Thread1/Thread2/Thread4耗时

模型	压缩策略	数据集	Image/GPU	输入608 Box mmAP	存储体积	PaddleLite推理耗时(ms)(608*608)	TensorRT推理速度(FPS)(608*608)
MobileNet-V1-YOLOv3	无	Pascal VOC	8	76.2	94MB	1238\796.943\520.101	60.04
MobileNet-V1-YOLOv3	剪裁 -52.88%	Pascal VOC	8	77.6 (+1.4)	31MB	602.497\353.759\222.427	99.36
MobileNet-V1-YOLOv3	无	COCO	8	29.3	95MB	-	-
MobileNet-V1-YOLOv3	剪裁 -51.77%	COCO	8	26.0 (-3.3)	32MB	-	73.93

语义分割¶

数据集：Cityscapes

量化¶

模型	压缩策略	mIoU	存储体积
DeepLabv3-MobileNetv2	无	69.81	7.4MB
DeepLabv3-MobileNetv2	量化	67.59 (-2.22)	2.1MB

图像分割模型Lite时延(ms), 输入尺寸769 x 769

设备	模型类型	压缩策略	armv7 Thread 1	armv7 Thread 2	armv7 Thread 4	armv8 Thread 1	armv8 Thread 2	armv8 Thread 4
高通835	Deeplabv3-MobileNetV2	无	1282.8126	793.2064	653.6538	1193.9908	737.1827	593.4522
高通835	Deeplabv3-MobileNetV2	量化	981.44	658.4969	538.6166	885.3273	586.1284	484.0018
高通855	Deeplabv3-MobileNetV2	无	639.4425	390.1851	322.7014	477.7667	339.7411	262.2847
高通855	Deeplabv3-MobileNetV2	量化	705.7589	474.4076	427.2951	394.8352	297.4035	264.6724
麒麟970	Deeplabv3-MobileNetV2	无	1771.1301	1746.0569	1222.4805	1448.9739	1192.4491	760.606
麒麟970	Deeplabv3-MobileNetV2	量化	1320.386	918.5328	672.2481	1020.753	820.094	591.4114

剪裁¶

PaddleLite推理耗时说明：

环境：Qualcomm SnapDragon 845 + armv8

速度指标：Thread1/Thread2/Thread4耗时

模型	压缩方法	mIoU	存储体积	PaddleLite推理耗时	TensorRT推理速度(FPS)
FastSCNN	无	69.64	11MB	1226.36\682.96\415.664	39.53
FastSCNN	剪裁 -47.60%	66.68 (-2.96)	5.7MB	866.693\494.467\291.748	51.48

PaddleX指标及日志¶

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官网解释。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

PaddleX可解释性¶

目前深度学习模型普遍存在一个问题，因为使用模型预测还是一个黑盒，几乎无法去感知它的内部工作状态，预测结果的可信度一直遭到质疑。为此，PadlleX提供了2种对图像分类预测结果进行可解释性研究的算法：LIME和NormLIME。

LIME¶

LIME全称Local interpretable model-agnostic explanations，表示一种与模型无关的局部可解释性。其实现步骤主要如下：

获取图像的超像素。
以输入样本为中心，在其附近的空间中进行随机采样，每个采样即对对象中的超像素进行随机遮掩（每个采样的权重和该采样与原样本的距离成反比）。
每个采样通过预测模型得到新的输出，这样得到一系列的输入X和对应的输出Y。
将X转换为超像素特征F，用一个简单的、可解释的模型Model（这里使用岭回归）来拟合F和Y的映射关系。
Model将得到F每个输入维度的权重（每个维度代表一个超像素），以此来解释模型。

LIME的使用方式可参见代码示例和api介绍。在使用时，参数中的num_samples设置尤为重要，其表示上述步骤2中的随机采样的个数，若设置过小会影响可解释性结果的稳定性，若设置过大则将在上述步骤3耗费较长时间；参数batch_size则表示在计算上述步骤3时，预测的batch size，若设置过小将在上述步骤3耗费较长时间，而上限则根据机器配置决定。

最终LIME可解释性算法的可视化结果如下所示： _images/lime.png 图中绿色区域代表起正向作用的超像素，红色区域代表起反向作用的超像素，”First n superpixels”代表前n个权重比较大的超像素（由上述步骤5计算所得结果）。

NormLIME¶

NormLIME是在LIME上的改进，LIME的解释是局部性的，是针对当前样本给的特定解释，而NormLIME是利用一定数量的样本对当前样本的一个全局性的解释，有一定的降噪效果。其实现步骤如下所示：

下载Kmeans模型参数和ResNet50_vc网络前三层参数。（ResNet50_vc的参数是在ImageNet上训练所得网络的参数；使用ImageNet图像作为数据集，每张图像从ResNet50_vc的第三层输出提取对应超象素位置上的平均特征和质心上的特征，训练将得到此处的Kmeans模型）
使用测试集中的数据计算normlime的权重信息（如无测试集，可用验证集代替）:对每张图像的处理： (1) 获取图像的超像素。 (2) 使用ResNet50_vc获取第三层特征，针对每个超像素位置，组合质心特征和均值特征F。(3) 把F作为Kmeans模型的输入，计算每个超像素位置的聚类中心。(4) 使用训练好的分类模型，预测该张图像的label。对所有图像的处理：(1) 以每张图像的聚类中心信息组成的向量（若某聚类中心出现在盖章途中设置为1，反之为0）为输入，预测的label为输出，构建逻辑回归函数regression_func。(2) 由regression_func可获得每个聚类中心不同类别下的权重，并对权重进行归一化。
使用Kmeans模型获取需要可视化图像的每个超像素的聚类中心。
对需要可视化的图像的超像素进行随机遮掩构成新的图像。
对每张构造的图像使用预测模型预测label。
根据normlime的权重信息，每个超像素可获不同的权重，选取最高的权重为最终的权重，以此来解释模型。

NormLIME的使用方式可参见代码示例和api介绍。在使用时，参数中的num_samples设置尤为重要，其表示上述步骤2中的随机采样的个数，若设置过小会影响可解释性结果的稳定性，若设置过大则将在上述步骤3耗费较长时间；参数batch_size则表示在计算上述步骤3时，预测的batch size，若设置过小将在上述步骤3耗费较长时间，而上限则根据机器配置决定；而dataset则是由测试集或验证集构造的数据。

最终NormLIME可解释性算法的可视化结果如下所示： _images/normlime.png 图中绿色区域代表起正向作用的超像素，红色区域代表起反向作用的超像素，”First n superpixels”代表前n个权重比较大的超像素（由上述步骤5计算所得结果）。图中最后一行代表把LIME和NormLIME对应超像素权重相乘的结果。

训练参数调整¶

PaddleX所有训练接口中，内置的参数均为根据单GPU卡相应batch_size下的较优参数，用户在自己的数据上训练模型，涉及到参数调整时，如无太多参数调优经验，则可参考如下方式

1.Epoch数的调整¶

Epoch数是模型训练过程，迭代的轮数，用户可以设置较大的数值，根据模型迭代过程在验证集上的指标表现，来判断模型是否收敛，进而提前终止训练。此外也可以使用train接口中的early_stop策略，模型在训练过程会自动判断模型是否收敛自动中止。

2.batch_size和learning_rate¶

Batch Size指模型在训练过程中，一次性处理的样本数量

如若使用多卡训练， batch_size会均分到各张卡上（因此需要让batch size整除卡数）

Batch Size跟机器的显存/内存高度相关，batch_size越高，所消耗的显存/内存就越高

PaddleX在各个train接口中均配置了默认的batch size(默认针对单GPU卡)，如若训练时提示GPU显存不足，则相应调低BatchSize，如若GPU显存高或使用多张GPU卡时，可相应调高BatchSize。

如若用户调整batch size，则也注意需要对应调整其它参数，特别是train接口中默认的learning_rate值。如在YOLOv3模型中，默认train_batch_size为8，learning_rate为0.000125，当用户将模型在2卡机器上训练时，可以将train_batch_size调整为16, 那么同时learning_rate也可以对应调整为0.000125 * 2 = 0.00025

3.warmup_steps和warmup_start_lr¶

在训练模型时，一般都会使用预训练模型，例如检测模型在训练时使用backbone在ImageNet数据集上的预训练权重。但由于在自行训练时，自己的数据与ImageNet数据集存在较大的差异，可能会一开始由于梯度过大使得训练出现问题，因此可以在刚开始训练时，让学习率以一个较小的值，慢慢增长到设定的学习率。因此warmup_steps和warmup_start_lr就是这个作用，模型开始训练时，学习率会从warmup_start_lr开始，在warmup_steps个batch数据迭代后线性增长到设定的学习率。

例如YOLOv3的train接口，默认train_batch_size为8，learning_rate为0.000125, warmup_steps为1000， warmup_start_lr为0.0；在此参数配置下表示，模型在启动训练后，在前1000个step(每个step表示一个batch的数据，也就是8个样本)内，学习率会从0.0开始线性增长到设定的0.000125。

4.lr_decay_epochs和lr_decay_gamma¶

lr_decay_epochs用于让学习率在模型训练后期逐步衰减，它一般是一个list，如[6, 8, 10]，表示学习率在第6个epoch时衰减一次，第8个epoch时再衰减一次，第10个epoch时再衰减一次。每次学习率衰减为之前的学习率*lr_decay_gamma。

例如YOLOv3的train接口，默认num_epochs为270,learning_rate为0.000125， lr_decay_epochs为[213, 240]，lr_decay_gamma为0.1;在此参数配置下表示，模型在启动训练后，在前213个epoch中，训练时使用的学习率为0.000125，在第213至240个epoch之间，训练使用的学习率为0.000125x0.1=0.0000125，在240个epoch之后，使用的学习率为0.000125x0.1x0.1=0.00000125

5.参数设定时的约束¶

根据上述几个参数，可以了解到学习率的变化分为WarmUp热身阶段和Decay衰减阶段，

Wamup热身阶段：随着训练迭代，学习率从较低的值逐渐线性增长至设定的值，以step为单位

Decay衰减阶段：随着训练迭代，学习率逐步衰减，如每次衰减为之前的0.1，以epoch为单位 step与epoch的关系：1个epoch由多个step组成，例如训练样本有800张图像，train_batch_size为8, 那么每个epoch都要完整用这800张图片训一次模型，而每个epoch总共包含800//8即100个step

在PaddleX中，约束warmup必须在Decay之前结束，因此各参数设置需要满足下面条件

warmup_steps <= lr_decay_epochs[0] * num_steps_each_epoch

其中num_steps_each_epoch计算方式如下,

num_steps_each_eposh = num_samples_in_train_dataset // train_batch_size

因此，如若你在启动训练时，被提示warmup_steps should be less than...时，即表示需要根据上述公式调整你的参数啦，可以调整lr_decay_epochs或者是warmup_steps。

6.如何使用多GPU卡进行训练¶

在import paddlex前配置环境变量，代码如下

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0' # 使用第1张GPU卡进行训练
# 注意paddle或paddlex都需要在设置环境变量后再import
import paddlex as pdx

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '' # 不使用GPU，使用CPU进行训练
import paddlex as pdx

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,3' # 使用第1、2、4张GPU卡进行训练
import paddlex as pdx

欢迎使用PaddleX！¶

10分钟快速上手使用¶

快速安装¶

pip安装¶

Anaconda安装¶

代码安装¶

pycocotools安装问题¶

数据准备¶

数据标注工具¶

常见标注工具¶

标注数据格式转换¶

数据格式说明¶

图像分类ImageNet¶

数据文件夹结构¶

划分训练集验证集¶

PaddleX数据集加载¶

目标检测PascalVOC¶

数据集文件夹结构¶

划分训练集验证集¶

PaddleX数据集加载¶

实例分割MSCOCO¶

数据集文件夹结构¶

划分训练集验证集¶

PaddleX加载数据集¶

语义分割Seg¶

数据集文件夹结构¶

划分训练集验证集¶

PaddleX数据集加载¶

模型训练¶

图像分类¶

介绍¶

开始训练¶

相关文档¶

目标检测¶

介绍¶

开始训练¶

相关文档¶

实例分割¶

介绍¶

开始训练¶

相关文档¶

语义分割¶

介绍¶

开始训练¶

相关文档¶

加载模型预测¶

图像分类¶

目标检测¶

实例分割¶

语义分割¶

公开数据集训练模型下载¶

模型部署¶

部署模型导出¶

服务端部署¶

Python部署¶

导出预测模型¶

预测部署¶

预测性能对比¶

测试环境¶

性能对比¶

服务端C++部署¶

Windows平台部署¶

说明¶

前置条件¶

样例¶

Linux平台部署¶

说明¶

前置条件¶

样例¶

模型加密部署¶

1. 方案简介¶

1.1 简介¶

1.2 加密工具¶

1.3 加密PaddleX模型¶

2. PaddleX C++加密部署¶

2.1 Linux平台使用¶

样例¶

2.2 Windows平台使用¶

样例¶

Nvidia-Jetson开发板¶