Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
大约 1 年 前同步成功

通知 282
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 9611b1db 编写于 作者: S shinichiye 提交者： GitHub
浏览文件
操作

Update module docs (#1601)

上级 14f9f3af
隐藏空白更改
内联 并排
Showing with 4241 addition and 2161 deletion
modules/image/instance_segmentation/solov2/README.md
浏览文件 @ 9611b1db
## 模型概述
# solov2
solov2是基于'SOLOv2: Dynamic, Faster and Stronger'实现的快速实例分割的模型。该模型基于SOLOV1, 并且针对mask的检测效果和运行效率进行改进，在实例分割任务中表现优秀。相对语义分割，实例分割需要标注出图上同一物体的不同个体。solov2实例分割效果如下：
| 模型名称 | solov2 |
| :------------------ | :-----------: |
| 类别 | 图像-实例分割 |
| 网络 | - |
| 数据集 | COCO2014 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 165M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
<div align="center">
<img src="example.png" width = "642" height = "400" />
</div>
## API
```python
def predict(self,
image: Union[str, np.ndarray],
threshold: float = 0.5,
visualization: bool = False,
save_dir: str = 'solov2_result'):
```
预测API，实例分割。
**参数**
* image (Union\[str, np.ndarray\]): 图片路径或者图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* threshold (float): 检测模型输出结果中，预测得分低于该阈值的框将被滤除，默认值为0.5；
* visualization (bool): 是否将可视化图片保存；
* save_dir (str): 保存图片到路径， 默认为"solov2_result"。
**返回**
* res (dict): 识别结果，关键字有 'segm', 'label', 'score'对应的取值为：
* segm (np.ndarray): 实例分割结果,取值为0或1。0表示背景，1为实例；
* label (list): 实例分割结果类别id；
* score (list):实例分割结果类别得分；
## 代码示例
```python
import cv2
import paddlehub as hub
img = cv2.imread('/PATH/TO/IMAGE')
model = hub.Module(name='solov2', use_gpu=False)
output = model.predict(image=img,visualization=False)
```
## 服务部署
PaddleHub Serving可以部署一个实例分割的在线服务。
## 第一步：启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m solov2
```
## 一、模型基本信息
默认端口号为8866。
- ### 应用效果展示
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
org_im = cv2.imread('/PATH/TO/IMAGE')
h, w, c = org_im.shape
data = {'images':[cv2_to_base64(org_im)]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/solov2"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
seg = base64.b64decode(r.json()["results"]['segm'].encode('utf8'))
seg = np.fromstring(seg, dtype=np.int32).reshape((-1, h, w))
label = base64.b64decode(r.json()["results"]['label'].encode('utf8'))
label = np.fromstring(label, dtype=np.int64)
score = base64.b64decode(r.json()["results"]['score'].encode('utf8'))
score = np.fromstring(score, dtype=np.float32)
print('seg', seg)
print('label', label)
print('score', score)
```
### 查看代码
https://github.com/PaddlePaddle/PaddleDetection
### 依赖
paddlepaddle >= 2.0.0
<div align="center">
<img src="https://user-images.githubusercontent.com/76040149/133250741-83040204-acfc-4348-af90-acac74f40cd8.png" height = "300" />
</div>
paddlehub >= 2.0.0
- ### 模型介绍
- solov2是基于"SOLOv2: Dynamic, Faster and Stronger"实现的快速实例分割的模型。该模型基于SOLOV1, 并且针对mask的检测效果和运行效率进行改进，在实例分割任务中表现优秀。相对语义分割，实例分割需要标注出图上同一物体的不同个体。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install solov2
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run openpose_hands_estimation --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import cv2
import paddlehub as hub
img = cv2.imread('/PATH/TO/IMAGE')
model = hub.Module(name='solov2', use_gpu=False)
output = model.predict(image=img, visualization=False)
```
- ### 3、API
- ```python
def predict(image: Union[str, np.ndarray],
threshold: float = 0.5,
visualization: bool = False,
save_dir: str = 'solov2_result'):
```
- 预测API，实例分割。
- **参数**
- image (Union[str, np.ndarray]): 图片路径或者图片数据，ndarray.shape 为 [H, W, C]，BGR格式；
- threshold (float): 检测模型输出结果中，预测得分低于该阈值的框将被滤除，默认值为0.5；
- visualization (bool): 是否将可视化图片保存；
- save_dir (str): 保存图片到路径， 默认为"solov2_result"。
- **返回**
- res (dict): 识别结果，关键字有 'segm', 'label', 'score'对应的取值为：
- segm (np.ndarray): 实例分割结果,取值为0或1。0表示背景，1为实例；
- label (list): 实例分割结果类别id；
- score (list):实例分割结果类别得分；s
## 四、服务部署
- PaddleHub Serving可以部署一个实例分割的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m solov2 -p 8866
```
- 这样就完成了一个实例分割的在线服务API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
org_im = cv2.imread('/PATH/TO/IMAGE')
h, w, c = org_im.shape
data = {'images':[cv2_to_base64(org_im)]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/solov2"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
seg = base64.b64decode(r.json()["results"]['segm'].encode('utf8'))
seg = np.fromstring(seg, dtype=np.int32).reshape((-1, h, w))
label = base64.b64decode(r.json()["results"]['label'].encode('utf8'))
label = np.fromstring(label, dtype=np.int64)
score = base64.b64decode(r.json()["results"]['score'].encode('utf8'))
score = np.fromstring(score, dtype=np.float32)
print('seg', seg)
print('label', label)
print('score', score)
```
## 五、更新历史
* 1.0.0
初始发布
* ```shell
$ hub install hand_pose_localization==1.0.0
```
modules/image/keypoint_detection/face_landmark_localization/README.md
浏览文件 @ 9611b1db
## 命令行预测
# face_landmark_localization
```
hub run face_landmark_localization --input_path "/PATH/TO/IMAGE"
```
| 模型名称 | face_landmark_localization |
| :------------------ | :------------------------: |
| 类别 | 图像-关键点检测 |
| 网络 | Face_Landmark |
| 数据集 | AFW/AFLW |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 3M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
## API
## 一、模型基本信息
```python
def __init__(face_detector_module=None)
```
- ### 应用效果展示
- 人脸关键点（左）、模型检测效果（右）
**参数**
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133222449-a1c2d444-a839-4c0e-9203-30d67eeb2246.jpeg" hspace="5" width="300"/> <img src="https://user-images.githubusercontent.com/76040149/133229934-e7357767-28e0-4253-bf71-f948de9966f1.jpg" hspace="5" height="300"/>
</p>
* face\_detector\_module (class): 人脸检测模型，默认为 ultra\_light\_fast\_generic\_face\_detector\_1mb\_640.
- ### 模型介绍
- 人脸关键点检测是人脸识别和分析领域中的关键一步，它是诸如自动人脸识别、表情分析、三维人脸重建及三维动画等其它人脸相关问题的前提和突破口。该 PaddleHub Module 的模型转换自 https://github.com/lsy17096535/face-landmark ，支持同一张图中的多个人脸检测。
```python
def keypoint_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
output_dir='face_landmark_output',
visualization=False)
```
识别输入图片中的所有人脸关键点，每张人脸检测出68个关键点（人脸轮廓17个点，左右眉毛各5个点，左右眼睛各6个点，鼻子9个点，嘴巴20个点）
## 二、安装
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/resources/face_landmark.jpg" hspace='5' width=500/> <br />
</p>
- ### 1、环境依赖
**参数**
- paddlepaddle >= 1.6.2
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，当为 None 时，默认设为face\_landmark\_output。
- paddlehub >= 1.6.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
**返回**
- ### 2、安装
* res (list\[dict\]): 识别结果的列表，列表元素为 dict, 有以下两个字段：
* save\_path : 可视化图片的保存路径（仅当visualization=True时存在）；
* data: 图片中每张人脸的关键点坐标
- ```shell
$ hub install face_landmark_localization
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
```python
def set_face_detector_module(face_detector_module)
```
## 三、模型API预测
设置为人脸关键点检测模型进行人脸检测的底座模型
- ### 1、命令行预测
**参数**
- ```shell
$ hub run face_landmark_localization --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* face\_detector\_module (class): 人脸检测模型
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
face_landmark = hub.Module(name="face_landmark_localization")
# Replace face detection module to speed up predictions but reduce performance
# face_landmark.set_face_detector_module(hub.Module(name="ultra_light_fast_generic_face_detector_1mb_320"))
result = face_landmark.keypoint_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_landmark.keypoint_detection(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
```python
def get_face_detector_module()
```
- ```python
def __init__(face_detector_module=None):
```
获取为人脸关键点检测模型进行人脸检测的底座模型
- **参数**
- face_detector_module (class): 人脸检测模型，默认为 ultra_light_fast_generic_face_detector_1mb_640.
**返回**
- ```python
def keypoint_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
output_dir='face_landmark_output',
visualization=False):
```
* 当前模型使用的人脸检测模型。
- 识别输入图片中的所有人脸关键点，每张人脸检测出68个关键点（人脸轮廓17个点，左右眉毛各5个点，左右眼睛各6个点，鼻子9个点，嘴巴20个点）
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径，由于人脸关键点检测模型由人脸检测+关键点检测两个模型组成，因此保存后会存在两个子目录，其中`face_landmark`为人脸关键点模型，`detector`为人脸检测模型。
- **参数**
**参数**
- images (list[numpy.ndarray]): 图片数据，ndarray.shape 为 [H, W, C]，BGR格式；
- paths (list[str]): 图片的路径；
- batch_size (int): batch 的大小；
- use_gpu (bool): 是否使用 GPU；
- visualization (bool): 是否将识别结果保存为图片文件；
- output_dir (str): 图片的保存路径，当为 None 时，默认设为face_landmark_output。
* dirname: 存在模型的目录名称
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- **返回**
- res (list[dict]): 识别结果的列表，列表元素为 dict, 有以下两个字段：
- save_path : 可视化图片的保存路径（仅当visualization=True时存在）；
- data: 图片中每张人脸的关键点坐标
## 代码示例
- ```python
def set_face_detector_module(face_detector_module):
```
```python
import paddlehub as hub
import cv2
- 设置为人脸关键点检测模型进行人脸检测的底座模型
- **参数**
- face_detector_module (class): 人脸检测模型
face_landmark = hub.Module(name="face_landmark_localization")
- ```python
def get_face_detector_module():
```
# Replace face detection module to speed up predictions but reduce performance
# face_landmark.set_face_detector_module(hub.Module(name="ultra_light_fast_generic_face_detector_1mb_320"))
- 获取为人脸关键点检测模型进行人脸检测的底座模型
- **返回**
- 当前模型使用的人脸检测模型。
result = face_landmark.keypoint_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_landmark.keypoint_detection(paths=['/PATH/TO/IMAGE'])
```
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=False):
```
- 将模型保存到指定路径，由于人脸关键点检测模型由人脸检测+关键点检测两个模型组成，因此保存后会存在两个子目录，其中`face_landmark`为人脸关键点模型，`detector`为人脸检测模型。
- **参数**
- dirname: 存在模型的目录名称
- model_filename: 模型文件名称，默认为\__model__
- params_filename: 参数文件名称，默认为\__params__(仅当combined为True时生效)
- combined: 是否将参数保存到统一的一个文件中
## 四、服务部署
- PaddleHub Serving可以部署一个在线人脸关键点检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m face_landmark_localization -p 8866
```
- 这样就完成了一个人脸关键点服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
import paddlehub as hub
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/face_landmark_localization"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 服务部署
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
PaddleHub Serving可以部署一个在线人脸关键点检测服务。
* 1.0.2
## 第一步：启动PaddleHub Serving
* ```shell
$ hub install face_landmark_localization==1.0.2
```
运行启动命令：
```shell
$ hub serving start -m face_landmark_localization
```
这样就完成了一个人脸关键点服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
import paddlehub as hub
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/face_landmark_localization"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
### 查看代码
https://github.com/lsy17096535/face-landmark
## Module贡献者
[Jason](https://github.com/jiangjiajun)
### 依赖
paddlepaddle >= 1.6.2
paddlehub >= 1.6.0
modules/image/keypoint_detection/hand_pose_localization/readme.md 0 → 100644
浏览文件 @ 9611b1db
# hand_pose_localization
| 模型名称 | hand_pose_localization |
| :------------------ | :--------------------: |
| 类别 | 图像-关键点检测 |
| 网络 | |
| 数据集 | MPII, NZSL |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 130M |
| 最新更新日期 | 2021-06-02 |
| 数据指标 | |
## 一、模型基本信息
- ### 应用效果展示
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133246893-f47cfdce-b9c1-490b-b1de-f837b61caf18.png" align="center" width="500">
</p>
- ### 模型介绍
- openpose 手部关键点检测模型。更多详情请参考：[openpose开源项目](https://github.com/CMU-Perceptual-Computing-Lab/openpose)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install hand_pose_localization
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- 本模型不支持命令行预测
- ### 1、预测代码示例
- ```python
import cv2
import paddlehub as hub
# use_gpu：是否使用GPU进行预测
model = hub.Module(name='hand_pose_localization', use_gpu=False)
# 调用关键点检测API
result = model.keypoint_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = model.keypoint_detection(paths=['/PATH/TO/IMAGE'])
# 打印预测结果
print(result)
```
- ### 2、API
- ```python
def keypoint_detection(images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False)：
```
- 预测API，识别出人体手部关键点。
- **参数**
- images (list[numpy.ndarray]): 图片数据，ndarray.shape 为 [H, W, C], 默认设为 None；
- paths (list[str]): 图片的路径, 默认设为 None；
- batch_size (int): batch 的大小，默认设为 1；
- visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
- output_dir (str): 图片的保存路径，默认设为 output。
- **返回**
- res (list[list[list[int](https://www.paddlepaddle.org.cn/hubdetail?name=hand_pose_localization&en_category=KeyPointDetection)]]): 每张图片识别到的21个手部关键点组成的列表，每个关键点的格式为[x, y](https://www.paddlepaddle.org.cn/hubdetail?name=hand_pose_localization&en_category=KeyPointDetection)，若有关键点未识别到则为None
## 四、服务部署
- PaddleHub Serving可以部署一个在线人体手部关键点检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m hand_pose_localization -p 8866
```
- 这样就完成了一个人体手部关键点检测的在线服务API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
# 图片Base64编码函数
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/hand_pose_localization"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
适配paddlehub 2.0
* ```shell
$ hub install hand_pose_localization==1.0.1
```
modules/image/keypoint_detection/human_pose_estimation_resnet50_mpii/README.md
浏览文件 @ 9611b1db
## 命令行预测
```
hub run human_pose_estimation_resnet50_mpii --input_path "/PATH/TO/IMAGE"
```
## API 说明
```python
def keypoint_detection(self,
images=None,
paths=None,
batch_size=1,
use_gpu=False,
output_dir='output_pose',
visualization=False)
```
预测API，识别出人体骨骼关键点。
**参数**
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 output\_pose。
**返回**
* res (list[dict]): 识别元素的列表，列表元素为 dict，关键字为 'path', 'data'，相应的取值为：
* path (str): 原图的路径；
* data (OrderedDict): 人体骨骼关键点的坐标。
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。
**参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 预测代码示例
```python
import cv2
import paddlehub as hub
pose_estimation = hub.Module(name="human_pose_estimation_resnet50_mpii")
result = pose_estimation.keypoint_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = pose_estimation.keypoint_detection(paths=['/PATH/TO/IMAGE'])
```
## 服务部署
PaddleHub Serving可以部署一个在线人脸关键点检测服务。
## 第一步：启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m human_pose_estimation_resnet50_mpii
```
这样就完成了一个人体骨骼关键点识别的在线服务API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/human_pose_estimation_resnet50_mpii"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 模型相关信息
### 模型代码
https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/human_pose_estimation
### 依赖
paddlepaddle >= 1.6.2
paddlehub >= 1.6.0
# human_pose_estimation_resnet50_mpii
| 模型名称 | human_pose_estimation_resnet50_mpii |
| :------------------ | :---------------------------------: |
| 类别 | 图像-关键点检测 |
| 网络 | Pose_Resnet50 |
| 数据集 | MPII |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 121M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | |
## 一、模型基本信息
- ### 应用效果展示
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133231581-1dffc391-652d-417f-b8ad-a3c22b8092e8.jpg" width="300">
</p>
- ### 模型介绍
- 人体骨骼关键点检测(Pose Estimation) 是计算机视觉的基础算法之一，在很多cv任务中起到了基础性的作用，如行为识别、人物跟踪、步态识别等领域。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install human_pose_estimation_resnet50_mpii
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run human_pose_estimation_resnet50_mpii --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import cv2
import paddlehub as hub
pose_estimation = hub.Module(name="human_pose_estimation_resnet50_mpii")
result = pose_estimation.keypoint_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = pose_estimation.keypoint_detection(paths=['/PATH/TO/IMAGE'])
# PaddleHub示例图片下载方法：
# wget https://paddlehub.bj.bcebos.com/resources/test_image.jpg
```
- ### 3、API
- ```python
def keypoint_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
output_dir='output_pose',
visualization=False):
```
- 预测API，识别出人体骨骼关键点。
- **参数**
- images (list[numpy.ndarray]): 图片数据，ndarray.shape 为 [H, W, C]；
- paths (list[str]): 图片的路径；
- batch_size (int): batch 的大小；
- use_gpu (bool): 是否使用 GPU；
- visualization (bool): 是否将识别结果保存为图片文件；
- output_dir (str): 图片的保存路径，默认设为 output_pose。
- **返回**
- res (list): 识别元素的列表，列表元素为 dict，关键字为 'path', 'data'，相应的取值为：
- path (str): 原图的路径；
- data (OrderedDict): 人体骨骼关键点的坐标。
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True):
```
- 将模型保存到指定路径。
- **参数**
- dirname: 存在模型的目录名称
- model_filename: 模型文件名称，默认为__model__
- params_filename: 参数文件名称，默认为__params__(仅当combined为True时生效)
- combined: 是否将参数保存到统一的一个文件中
## 四、服务部署
- PaddleHub Serving可以部署一个在线人体骨骼关键点识别服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m human_pose_estimation_resnet50_mpii -p 8866
```
- 这样就完成了一个人体骨骼关键点识别的在线服务API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/human_pose_estimation_resnet50_mpii"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
# r.json()['results']即为keypoint_detection函数返回的结果
```
## 五、更新历史
* 1.0.0
* 1.1.0
* 1.1.1
* ```shell
$ hub install human_pose_estimation_resnet50_mpii==1.1.1
```
modules/image/keypoint_detection/openpose_body_estimation/readme.md 0 → 100644
浏览文件 @ 9611b1db
# openpose_body_estimation
| 模型名称 | openpose_body_estimation |
| :------------------ | :------------------------: |
| 类别 | 图像-关键点检测 |
| 网络 | two-branch multi-stage CNN |
| 数据集 | MPII, COCO 2016 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 185M |
| 最新更新日期 | 2021-06-28 |
| 数据指标 | - |
## 一、模型基本信息
- ### 应用效果展示
- 人体关键点（左）、模型预测效果（右）
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133232647-011528a1-32f3-416f-a618-17ffbeba6bab.png" height = "300" hspace='10'/> <img src="https://user-images.githubusercontent.com/76040149/133232724-30979d86-8688-483e-abc3-a9159695a56c.png" height = "300" hspace='10'/>
</p>
- ### 模型介绍
- openpose_body_estimation是基于'Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields'构建的用于肢体关键点检测的模型，该模型可以与openpose_hands_estimation模型联合使用检测肢体和手部关键点。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install openpose_body_estimation
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run openpose_body_estimation --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
model = hub.Module(name='openpose_body_estimation')
result = model.predict('/PATH/TO/IMAGE')
model.save_inference_model('/PATH/TO/SAVE/MODEL')
# PaddleHub示例图片下载方法：
# wget https://paddlehub.bj.bcebos.com/resources/test_image.jpg
```
- ### 3、API
- ```python
def __init__(self, load_checkpoint: str = None):
```
- 模型初始化函数
- **参数**
- load_checkpoint(str): 肢体检测模型，用户可以指定自己的模型地址。 默认为None时，会使用PaddleHub提供的默认模型。
- ```python
def predict(self,
img,
save_path='openpose_body',
visualization=True):
```
- 识别输入图片中的所有人肢体关键点。
- **参数**
- img (numpy.ndarray|str): 图片数据，使用图片路径或者输入numpy.ndarray，BGR格式；
- save_path (str): 图片保存路径， 默认为'openpose_body'；
- visualization (bool): 是否将识别结果保存为图片文件；
- **返回**
- res (dict): 识别结果的列表，列表元素为 dict, 有以下两个字段：
- data : 可视化图片内容(numpy.ndarray，BGR格式);
- candidate: 图片中所有肢体关键点坐标;
- subset: 不同的人不同关键点对应的关键点坐标的索引。
- ```python
def save_inference_model(save_dir):
```
- 将模型保存到指定路径。
- **参数**
- save_dir(str): 存在模型的目录名称。
## 四、服务部署
- PaddleHub Serving可以部署一个在线肢体关键点检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m openpose_body_estimation -p 8866
```
- 这样就完成了一个肢体关键点服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
org_im = cv2.imread('/PATH/TO/IMAGE')
data = {'images':[cv2_to_base64(org_im)]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/openpose_body_estimation"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
canvas = base64_to_cv2(r.json()["results"]['data'])
cv2.imwrite('keypoint_body.png', canvas)
```
## 五、更新历史
* 1.0.0
初始发布
* ```shell
$ hub install openpose_body_estimation==1.0.0
```
modules/image/keypoint_detection/openpose_hands_estimation/readme.md 0 → 100644
浏览文件 @ 9611b1db
# openpose_hands_estimation
| 模型名称 | hand_pose_localization |
| :------------------ | :--------------------: |
| 类别 | 图像-关键点检测 |
| 网络 | - |
| 数据集 | MPII, NZSL |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 130M |
| 最新更新日期 | 2021-06-02 |
| 数据指标 | - |
## 一、模型基本信息
- ### 应用效果展示
- 手部关键点展示（左）、预测效果（右）
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133233743-dc6e3aaf-27fd-4f7d-95be-21c9383a2ea1.png" height="300"><img src="https://user-images.githubusercontent.com/76040149/133234189-f7a47940-2be2-445c-8043-b490b5402e15.png" height="300">
</p>
- ### 模型介绍
- penpose_hands_estimation是基于 'Hand Keypoint Detection in Single Images using Multiview Bootstrapping' 构建的用于手部关键点检测的模型。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- scikit-image
- scipy
- ```shell
$ pip install scikit-image scipy
```
- ### 2、安装
- ```shell
$ hub install openpose_hands_estimation
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run openpose_hands_estimation --input_path "/PATH/TO/IMAGE"
```
- Note：本模型先识别人体关键点以确定2个手的位置，再识别手部关键点；输入图片建议为半身照或全身照，手部没有遮挡；本模型需要用到openpose_body_estimation，若未安装则推理前会自动安装
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
model = hub.Module(name='openpose_hands_estimation')
result = model.predict('/PATH/TO/IMAGE')
model.save_inference_model('/PATH/TO/SAVE/MODEL')
```
- ### 3、API
- ```python
def __init__(load_checkpoint: str = None):
```
- **参数**
- load_checkpoint(str): 手部检测模型，用户可以指定自己的模型地址。 默认为None时，会使用PaddleHub提供的默认模型。
- ```python
def predict(img,
save_path='openpose_hand',
scale=[0.5, 1.0, 1.5, 2.0],
visualization=True):
```
- 识别输入图片中的所有人手部关键点。
- **参数**
- img (numpy.ndarray|str): 图片数据，使用图片路径或者输入numpy.ndarray，BGR格式；
- save_path (str): 图片保存路径， 默认为openpose_hand；
- scale (list): 搜索关键点时使用图片的不同尺度；
- visualization (bool): 是否将识别结果保存为图片文件；
- **返回**
- res (dict): 识别结果的列表，列表元素为 dict, 有以下两个字段：
- data : 可视化图片内容（numpy.ndarray，BGR格式）；
- all_hand_peaks: 图片中手部关键点坐标
- ```python
def save_inference_model(save_dir):
```
- 将模型保存到指定路径。
- **参数**
- save_dir(str): 存放模型的目录名称
## 四、服务部署
- PaddleHub Serving可以部署一个在线手部关键点检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m openpose_hands_estimation -p 8866
```
- 这样就完成了一个人体手部关键点检测的在线服务API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
org_im = cv2.imread('/PATH/TO/IMAGE')
data = {'images':[cv2_to_base64(org_im)]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/openpose_hands_estimation"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
canvas = base64_to_cv2(r.json()["results"]["data"])
cv2.imwrite('keypoint.png', canvas)
```
## 五、更新历史
* 1.0.0
初始发布
* ```shell
$ hub install hand_pose_localization==1.0.0
```
modules/image/text_recognition/chinese_ocr_db_crnn_mobile/README.md
浏览文件 @ 9611b1db
## 概述
# chinese_ocr_db_crnn_mobile
chinese_ocr_db_crnn_mobile Module用于识别图片当中的汉字。其基于[chinese_text_detection_db_mobile Module](https://www.paddlepaddle.org.cn/hubdetail?name=chinese_text_detection_db_mobile&en_category=TextRecognition)检测得到的文本框，继续识别文本框中的中文文字。之后对检测文本框进行角度分类。最终识别文字算法采用CRNN（Convolutional Recurrent Neural Network）即卷积递归神经网络。其是DCNN和RNN的组合，专门用于识别图像中的序列式对象。与CTC loss配合使用，进行文字识别，可以直接从文本词级或行级的标注中学习，不需要详细的字符级的标注。该Module是一个超轻量级中文OCR模型，支持直接预测。
|模型名称|chinese_ocr_db_crnn_mobile|
| :--- | :---: |
|类别|图像-文字识别|
|网络|Differentiable Binarization+RCNN|
|数据集|icdar2015数据集|
|是否支持Fine-tuning|否|
|模型大小|16M|
|最新更新日期|2021-05-31|
|数据指标|-|
## 一、模型基本信息
- ### 应用效果展示
- [OCR文字识别场景在线体验](https://www.paddlepaddle.org.cn/hub/scene/ocr)
- 样例结果示例：
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/image/ocr/rcnn.png" hspace='10'/> <br />
<img src="https://user-images.githubusercontent.com/76040149/133097562-d8c9abd1-6c70-4d93-809f-fa4735764836.png" width = "600" hspace='10'/> <br />
</p>
更多详情参考[An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition](https://arxiv.org/pdf/1507.05717.pdf)
- ### 模型介绍
## 命令行预测
- chinese_ocr_db_crnn_mobile Module用于识别图片当中的汉字。其基于[chinese_text_detection_db_mobile Module](../chinese_text_detection_db_mobile/)检测得到的文本框，识别文本框中的中文文字,再对检测文本框进行角度分类。最终识别文字算法采用CRNN（Convolutional Recurrent Neural Network）即卷积递归神经网络。该Module是一个超轻量级中文OCR模型，支持直接预测。
```shell
$ hub run chinese_ocr_db_crnn_mobile --input_path "/PATH/TO/IMAGE"
```
**该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133098254-7c642826-d6d7-4dd0-986e-371622337867.png" width = "300" height = "450" hspace='10'/> <br />
</p>
## API
- 更多详情参考：[An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition](https://arxiv.org/pdf/1507.05717.pdf)
### \_\_init\_\_(text_detector_module=None, enable_mkldnn=False)
构造ChineseOCRDBCRNN对象
**参数**
## 二、安装
* text_detector_module(str): 文字检测PaddleHub Module名字，如设置为None，则默认使用[chinese_text_detection_db_mobile Module](https://www.paddlepaddle.org.cn/hubdetail?name=chinese_text_detection_db_mobile&en_category=TextRecognition)。其作用为检测图片当中的文本。
* enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
- ### 1、环境依赖
- paddlepaddle >= 1.7.2
```python
def recognize_text(images=[],
paths=[],
use_gpu=False,
output_dir='ocr_result',
visualization=False,
box_thresh=0.5,
text_thresh=0.5,
angle_classification_thresh=0.9)
```
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
预测API，检测输入图片中的所有中文文本的位置。
- shapely
**参数**
- pyclipper
* paths (list\[str\]): 图片的路径；
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**
* box\_thresh (float): 检测文本框置信度的阈值；
* text\_thresh (float): 识别中文文本置信度的阈值；
* angle_classification_thresh(float): 文本角度分类置信度的阈值
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 ocr\_result；
- ```shell
$ pip install shapely pyclipper
```
- **该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
**返回**
- ### 2、安装
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* data (list\[dict\]): 识别文本结果，列表中每一个元素为 dict，各字段为：
* text(str): 识别得到的文本
* confidence(float): 识别文本结果置信度
* text_box_position(list): 文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
如果无识别结果则data为\[\]
* save_path (str, optional): 识别结果的保存路径，如不保存图片则save_path为''
- ```shell
$ hub install chinese_ocr_db_crnn_mobile
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
### 代码示例
```python
import paddlehub as hub
import cv2
ocr = hub.Module(name="chinese_ocr_db_crnn_mobile")
result = ocr.recognize_text(images=[cv2.imread('/PATH/TO/IMAGE')])
## 三、模型API预测
# or
# result = ocr.recognize_text(paths=['/PATH/TO/IMAGE'])
```
- ### 1、命令行预测
* 样例结果示例
- ```shell
$ hub run chinese_ocr_db_crnn_mobile --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/image/ocr/ocr_res.jpg" hspace='10'/> <br />
</p>
- ### 2、代码示例
- ```python
import paddlehub as hub
import cv2
## 服务部署
ocr = hub.Module(name="chinese_ocr_db_crnn_mobile", enable_mkldnn=True) # mkldnn加速仅在CPU下有效
result = ocr.recognize_text(images=[cv2.imread('/PATH/TO/IMAGE')])
PaddleHub Serving 可以部署一个目标检测的在线服务。
# or
# result = ocr.recognize_text(paths=['/PATH/TO/IMAGE'])
```
### 第一步：启动PaddleHub Serving
- ### 3、API
运行启动命令：
```shell
$ hub serving start -m chinese_ocr_db_crnn_mobile
```
- ```python
__init__(text_detector_module=None, enable_mkldnn=False)
```
- 构造ChineseOCRDBCRNN对象
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- **参数**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- text_detector_module(str): 文字检测PaddleHub Module名字，如设置为None，则默认使用[chinese_text_detection_db_mobile Module](../chinese_text_detection_db_mobile/)。其作用为检测图片当中的文本。
- enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
def recognize_text(images=[],
paths=[],
use_gpu=False,
output_dir='ocr_result',
visualization=False,
box_thresh=0.5,
text_thresh=0.5,
angle_classification_thresh=0.9)
```
```python
import requests
import json
import cv2
import base64
- 预测API，检测输入图片中的所有中文文本的位置。
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- **参数**
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_ocr_db_crnn_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- paths (list\[str\]): 图片的路径；
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**
- box\_thresh (float): 检测文本框置信度的阈值；
- text\_thresh (float): 识别中文文本置信度的阈值；
- angle_classification_thresh(float): 文本角度分类置信度的阈值
- visualization (bool): 是否将识别结果保存为图片文件；
- output\_dir (str): 图片的保存路径，默认设为 ocr\_result；
# 打印预测结果
print(r.json()["results"])
```
- **返回**
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
- data (list\[dict\]): 识别文本结果，列表中每一个元素为 dict，各字段为：
- text(str): 识别得到的文本
- confidence(float): 识别文本结果置信度
- text_box_position(list): 文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
如果无识别结果则data为\[\]
- save_path (str, optional): 识别结果的保存路径，如不保存图片则save_path为''
## 查看代码
https://github.com/PaddlePaddle/PaddleOCR
## 四、服务部署
### 依赖
- PaddleHub Serving 可以部署一个目标检测的在线服务。
paddlepaddle >= 1.7.2
- ### 第一步：启动PaddleHub Serving
paddlehub >= 1.6.0
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_ocr_db_crnn_mobile
```
shapely
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
pyclipper
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 更新历史
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_ocr_db_crnn_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
......@@ -156,3 +191,11 @@ pyclipper
* 1.1.1
支持文本中空格识别。
* 1.1.2
修复只能检出30字段问题。
- ```shell
$ hub install chinese_ocr_db_crnn_mobile==1.1.2
```
modules/image/text_recognition/chinese_ocr_db_crnn_server/README.md
浏览文件 @ 9611b1db
## 概述
# chinese_ocr_db_crnn_server
chinese_ocr_db_crnn_server Module用于识别图片当中的汉字。其基于[chinese_text_detection_db_server Module](https://www.paddlepaddle.org.cn/hubdetail?name=chinese_text_detection_db_server&en_category=TextRecognition)检测得到的文本框，继续识别文本框中的中文文字。识别文字算法采用CRNN（Convolutional Recurrent Neural Network）即卷积循环神经网络。其是DCNN和RNN的组合，专门用于识别图像中的序列式对象。与CTC loss配合使用，进行文字识别，可以直接从文本词级或行级的标注中学习，不需要详细的字符级的标注。该Module是一个通用的OCR模型，支持直接预测。
|模型名称|chinese_ocr_db_crnn_server|
| :--- | :---: |
|类别|图像-文字识别|
|网络|Differentiable Binarization+RCNN|
|数据集|icdar2015数据集|
|是否支持Fine-tuning|否|
|模型大小|116MB|
|最新更新日期|2021-05-31|
|数据指标|mAP@0.98|
## 一、模型基本信息
- ### 应用效果展示
- [OCR文字识别场景在线体验](https://www.paddlepaddle.org.cn/hub/scene/ocr)
- 样例结果示例：
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/image/ocr/rcnn.png" hspace='10'/> <br />
<img src="https://user-images.githubusercontent.com/76040149/133097562-d8c9abd1-6c70-4d93-809f-fa4735764836.png" width = "600" hspace='10'/> <br />
</p>
更多详情参考[An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition](https://arxiv.org/pdf/1507.05717.pdf)
- ### 模型介绍
## 命令行预测
- chinese_ocr_db_crnn_server Module用于识别图片当中的汉字。其基于[chinese_text_detection_db_server Module](../chinese_text_detection_db_server/)检测得到的文本框，识别文本框中的中文文字。识别文字算法采用CRNN（Convolutional Recurrent Neural Network）即卷积循环神经网络。该Module是一个通用的OCR模型，支持直接预测。
```shell
$ hub run chinese_ocr_db_crnn_server --input_path "/PATH/TO/IMAGE"
```
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133098254-7c642826-d6d7-4dd0-986e-371622337867.png" width = "300" height = "450" hspace='10'/> <br />
</p>
**该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
- 更多详情参考：[An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition](https://arxiv.org/pdf/1507.05717.pdf)
## API
## 二、安装
### \_\_init\_\_(text_detector_module=None, enable_mkldnn=False)
- ### 1、环境依赖
构造ChineseOCRDBCRNNServer对象
- paddlepaddle >= 1.7.2
**参数**
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
* text_detector_module(str): 文字检测PaddleHub Module名字，如设置为None，则默认使用[chinese_text_detection_db_server Module](https://www.paddlepaddle.org.cn/hubdetail?name=chinese_text_detection_db_server&en_category=TextRecognition)。其作用为检测图片当中的文本。
* enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
- shapely
```python
def recognize_text(images=[],
paths=[],
use_gpu=False,
output_dir='ocr_result',
visualization=False,
box_thresh=0.5,
text_thresh=0.5,
angle_classification_thresh=0.9)
```
- pyclipper
预测API，检测输入图片中的所有中文文本的位置。
- ```shell
$ pip install shapely pyclipper
```
- **该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
**参数**
- ### 2、安装
* paths (list\[str\]): 图片的路径；
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**
* box\_thresh (float): 检测文本框置信度的阈值；
* text\_thresh (float): 识别中文文本置信度的阈值；
* angle_classification_thresh(float): 文本角度分类置信度的阈值
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 ocr\_result；
- ```shell
$ hub install chinese_ocr_db_crnn_server
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
**返回**
## 三、模型API预测
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* data (list\[dict\]): 识别文本结果，列表中每一个元素为 dict，各字段为：
* text(str): 识别得到的文本
* confidence(float): 识别文本结果置信度
* text_box_position(list): 文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
如果无识别结果则data为\[\]
* save_path (str, optional): 识别结果的保存路径，如不保存图片则save_path为''
- ### 1、命令行预测
### 代码示例
- ```shell
$ hub run chinese_ocr_db_crnn_server --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
```python
import paddlehub as hub
import cv2
- ### 2、代码示例
ocr = hub.Module(name="chinese_ocr_db_crnn_server")
result = ocr.recognize_text(images=[cv2.imread('/PATH/TO/IMAGE')])
- ```python
import paddlehub as hub
import cv2
# or
# result = ocr.recognize_text(paths=['/PATH/TO/IMAGE'])
```
ocr = hub.Module(name="chinese_ocr_db_crnn_server", enable_mkldnn=True) # mkldnn加速仅在CPU下有效
result = ocr.recognize_text(images=[cv2.imread('/PATH/TO/IMAGE')])
* 样例结果示例
# or
# result = ocr.recognize_text(paths=['/PATH/TO/IMAGE'])
```
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/image/ocr/ocr_res.jpg" hspace='10'/> <br />
</p>
- ### 3、API
- ```python
def __init__(text_detector_module=None, enable_mkldnn=False)
```
## 服务部署
- 构造ChineseOCRDBCRNNServer对象
PaddleHub Serving 可以部署一个目标检测的在线服务。
- **参数**
### 第一步：启动PaddleHub Serving
- text_detector_module(str): 文字检测PaddleHub Module名字，如设置为None，则默认使用[chinese_text_detection_db_server Module](../chinese_text_detection_db_server/)。其作用为检测图片当中的文本。<br/>
- enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
运行启动命令：
```shell
$ hub serving start -m chinese_ocr_db_crnn_server
```
- ```python
def recognize_text(images=[],
paths=[],
use_gpu=False,
output_dir='ocr_result',
visualization=False,
box_thresh=0.5,
text_thresh=0.5,
angle_classification_thresh=0.9)
```
- 预测API，检测输入图片中的所有中文文本的位置。
- **参数**
- paths (list\[str\]): 图片的路径； <br/>
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； <br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- box\_thresh (float): 检测文本框置信度的阈值； <br/>
- text\_thresh (float): 识别中文文本置信度的阈值； <br/>
- angle_classification_thresh(float): 文本角度分类置信度的阈值 <br/>
- visualization (bool): 是否将识别结果保存为图片文件； <br/>
- output\_dir (str): 图片的保存路径，默认设为 ocr\_result；
- **返回**
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
- data (list\[dict\]): 识别文本结果，列表中每一个元素为 dict，各字段为：
- text(str): 识别得到的文本
- confidence(float): 识别文本结果置信度
- text_box_position(list): 文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
如果无识别结果则data为\[\]
- save_path (str, optional): 识别结果的保存路径，如不保存图片则save_path为''
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
### 第二步：发送预测请求
## 四、服务部署
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- PaddleHub Serving 可以部署一个目标检测的在线服务。
```python
import requests
import json
import cv2
import base64
- ### 第一步：启动PaddleHub Serving
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_ocr_db_crnn_server
```
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_ocr_db_crnn_server"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
# 打印预测结果
print(r.json()["results"])
```
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 查看代码
- ### 第二步：发送预测请求
https://github.com/PaddlePaddle/PaddleOCR
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
### 依赖
- ```python
import requests
import json
import cv2
import base64
paddlepaddle >= 1.7.2
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
paddlehub >= 1.6.0
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_ocr_db_crnn_server"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
shapely
# 打印预测结果
print(r.json()["results"])
```
pyclipper
## 更新历史
## 五、更新历史
* 1.0.0
......@@ -151,3 +183,11 @@ pyclipper
* 1.1.1
支持文本中空格识别。
* 1.1.2
修复检出字段无法超过30个问题。
- ```shell
$ hub install chinese_ocr_db_crnn_server==1.1.2
```
modules/image/text_recognition/chinese_text_detection_db_mobile/README.md
浏览文件 @ 9611b1db
## 概述
# chinese_text_detection_db_mobile
Differentiable Binarization（简称DB）是一种基于分割的文本检测算法。在各种文本检测算法中，基于分割的检测算法可以更好地处理弯曲等不规则形状文本，因此往往能取得更好的检测效果。但分割法后处理步骤中将分割结果转化为检测框的流程复杂，耗时严重。DB将二值化阈值加入训练中学习，可以获得更准确的检测边界，从而简化后处理流程。该Module是一个超轻量级文本检测模型，支持直接预测。
|模型名称|chinese_text_detection_db_mobile|
| :--- | :---: |
|类别|图像-文字识别|
|网络|Differentiable Binarization|
|数据集|icdar2015数据集|
|是否支持Fine-tuning|否|
|模型大小|2.6MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133101419-2d175dc4-2274-404d-b9f3-802f398a6ce4.jpg" width="500" alt="package" >
</p>
- ### 模型介绍
- DB（Differentiable Binarization）是一种基于分割的文本检测算法。此类算法可以更好地处理弯曲等不规则形状文本，因此检测效果往往会更好。但其后处理步骤中将分割结果转化为检测框的流程复杂，耗时严重。DB将二值化阈值加入训练中学习，可以获得更准确的检测边界，从而简化后处理流程。该Module是一个超轻量级文本检测模型，支持直接预测。
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/image/ocr/db_algo.png" hspace='10'/> <br />
<img src="https://user-images.githubusercontent.com/76040149/133101635-7fb142d3-9056-44da-8201-d931727d3977.png" width="800" hspace='10'/> <br />
</p>
更多详情参考[Real-time Scene Text Detection with Differentiable Binarization](https://arxiv.org/pdf/1911.08947.pdf)
更多详情参考：[Real-time Scene Text Detection with Differentiable Binarization](https://arxiv.org/pdf/1911.08947.pdf)
## 二、安装
- ### 1、环境依赖
## 命令行预测
- paddlepaddle >= 1.7.2
```shell
$ hub run chinese_text_detection_db_mobile --input_path "/PATH/TO/IMAGE"
```
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
- shapely
## API
- pyclipper
## API
- ```shell
$ pip install shapely pyclipper
```
- **该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
### \_\_init\_\_(enable_mkldnn=False)
- ### 2、安装
构造ChineseTextDetectionDB对象
- ```shell
$ hub install chinese_text_detection_db_mobile
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
**参数**
* enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
## 三、模型API预测
```python
def detect_text(paths=[],
images=[],
use_gpu=False,
output_dir='detection_result',
box_thresh=0.5,
visualization=False)
```
- ### 1、命令行预测
预测API，检测输入图片中的所有中文文本的位置。
- ```shell
$ hub run chinese_text_detection_db_mobile --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**参数**
- ### 2、代码示例
* paths (list\[str\]): 图片的路径；
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**
* box\_thresh (float): 检测文本框置信度的阈值；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 detection\_result；
- ```python
import paddlehub as hub
import cv2
**返回**
text_detector = hub.Module(name="chinese_text_detection_db_mobile", enable_mkldnn=True) # mkldnn加速仅在CPU下有效
result = text_detector.detect_text(images=[cv2.imread('/PATH/TO/IMAGE')])
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
* save_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
### 代码示例
- ### 3、API
```python
import paddlehub as hub
import cv2
- ```python
__init__(enable_mkldnn=False)
```
- 构造ChineseTextDetectionDB对象
text_detector = hub.Module(name="chinese_text_detection_db_mobile", enable_mkldnn=True)
result = text_detector.detect_text(images=[cv2.imread('/PATH/TO/IMAGE')])
- **参数**
- enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
- ```python
def detect_text(paths=[],
images=[],
use_gpu=False,
output_dir='detection_result',
box_thresh=0.5,
visualization=False)
```
- 预测API，检测输入图片中的所有中文文本的位置。
## 服务部署
- **参数**
PaddleHub Serving 可以部署一个目标检测的在线服务。
- paths (list\[str\]): 图片的路径；
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**
- box\_thresh (float): 检测文本框置信度的阈值；
- visualization (bool): 是否将识别结果保存为图片文件；
- output\_dir (str): 图片的保存路径，默认设为 detection\_result；
### 第一步：启动PaddleHub Serving
- **返回**
运行启动命令：
```shell
$ hub serving start -m chinese_text_detection_db_mobile
```
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
- data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
- save_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
### 第二步：发送预测请求
## 四、服务部署
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- PaddleHub Serving 可以部署一个目标检测的在线服务。
```python
import requests
import json
import cv2
import base64
- ### 第一步：启动PaddleHub Serving
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_text_detection_db_mobile
```
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_text_detection_db_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
# 打印预测结果
print(r.json()["results"])
```
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 查看代码
- ### 第二步：发送预测请求
https://github.com/PaddlePaddle/PaddleOCR
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
## 依赖
- ```python
import requests
import json
import cv2
import base64
paddlepaddle >= 1.7.2
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
paddlehub >= 1.6.0
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_text_detection_db_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
shapely
# 打印预测结果
print(r.json()["results"])
```
pyclipper
## 更新历史
## 五、更新历史
* 1.0.0
......@@ -141,6 +178,10 @@ pyclipper
增加更多预训练数据，更新预训练参数
1.1.0
* 1.0.4
使用超轻量级的三阶段模型（文本框检测-角度分类-文字识别）识别图片文字。
使用超轻量级的三阶段模型（文本框检测-角度分类-文字识别）识别图片文字。
- ```shell
$ hub install chinese_text_detection_db_mobile==1.0.4
```
modules/image/text_recognition/chinese_text_detection_db_server/README.md
浏览文件 @ 9611b1db
## 概述
# chinese_text_detection_db_server
Differentiable Binarization（简称DB）是一种基于分割的文本检测算法。在各种文本检测算法中，基于分割的检测算法可以更好地处理弯曲等不规则形状文本，因此往往能取得更好的检测效果。但分割法后处理步骤中将分割结果转化为检测框的流程复杂，耗时严重。DB将二值化阈值加入训练中学习，可以获得更准确的检测边界，从而简化后处理流程。该Module是一个通用的文本检测模型，支持直接预测。
|模型名称|chinese_text_detection_db_server|
| :--- | :---: |
|类别|图像-文字识别|
|网络|Differentiable Binarization|
|数据集|icdar2015数据集|
|是否支持Fine-tuning|否|
|模型大小|47MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/image/ocr/db_algo.png" hspace='10'/> <br />
<img src="https://user-images.githubusercontent.com/76040149/133101419-2d175dc4-2274-404d-b9f3-802f398a6ce4.jpg" width="500" alt="package" >
</p>
更多详情参考[Real-time Scene Text Detection with Differentiable Binarization](https://arxiv.org/pdf/1911.08947.pdf)
- ### 模型介绍
- DB（Differentiable Binarization）是一种基于分割的文本检测算法。此类算法可以更好地处理弯曲等不规则形状文本，因此检测效果往往会更好。但其后处理步骤中将分割结果转化为检测框的流程复杂，耗时严重。DB将二值化阈值加入训练中学习，可以获得更准确的检测边界，从而简化后处理流程。该Module是一个超轻量级文本检测模型，支持直接预测。
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133101635-7fb142d3-9056-44da-8201-d931727d3977.png" width="800" hspace='10'/> <br />
</p>
- 更多详情参考：[Real-time Scene Text Detection with Differentiable Binarization](https://arxiv.org/pdf/1911.08947.pdf)
## 命令行预测
```shell
$ hub run chinese_text_detection_db_server --input_path "/PATH/TO/IMAGE"
```
**该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
## 二、安装
## API
- ### 1、环境依赖
### \_\_init\_\_(enable_mkldnn=False)
- paddlepaddle >= 1.7.2
构造ChineseTextDetectionDBServer对象
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
- shapely
* enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
- pyclipper
```python
def detect_text(paths=[],
images=[],
use_gpu=False,
output_dir='detection_result',
box_thresh=0.5,
visualization=False)
```
- ```shell
$ pip install shapely pyclipper
```
- **该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
预测API，检测输入图片中的所有中文文本的位置。
- ### 2、安装
**参数**
- ```shell
$ hub install chinese_text_detection_db_server
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
* paths (list\[str\]): 图片的路径；
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**
* box\_thresh (float): 检测文本框置信度的阈值；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 detection\_result；
**返回**
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
* save_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
## 三、模型API预测
### 代码示例
- ### 1、命令行预测
```python
import paddlehub as hub
import cv2
- ```shell
$ hub run chinese_text_detection_db_server --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
text_detector = hub.Module(name="chinese_text_detection_db_server")
result = text_detector.detect_text(images=[cv2.imread('/PATH/TO/IMAGE')])
- ### 2、代码示例
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
- ```python
import paddlehub as hub
import cv2
text_detector = hub.Module(name="chinese_text_detection_db_server"), enable_mkldnn=True) # mkldnn加速仅在CPU下有效
result = text_detector.detect_text(images=[cv2.imread('/PATH/TO/IMAGE')])
## 服务部署
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
PaddleHub Serving 可以部署一个目标检测的在线服务。
- ### 3、API
### 第一步：启动PaddleHub Serving
- ```python
__init__(enable_mkldnn=False)
```
- 构造ChineseTextDetectionDBServer对象
运行启动命令：
```shell
$ hub serving start -m chinese_text_detection_db_server
```
- **参数**
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ```python
def detect_text(paths=[],
images=[],
use_gpu=False,
output_dir='detection_result',
box_thresh=0.5,
visualization=False)
```
- 预测API，检测输入图片中的所有中文文本的位置。
- **参数**
### 第二步：发送预测请求
- paths (list\[str\]): 图片的路径；
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**
- box\_thresh (float): 检测文本框置信度的阈值；
- visualization (bool): 是否将识别结果保存为图片文件；
- output\_dir (str): 图片的保存路径，默认设为 detection\_result；
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **返回**
```python
import requests
import json
import cv2
import base64
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
- data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
- ave_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_text_detection_db_server"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
## 四、服务部署
# 打印预测结果
print(r.json()["results"])
```
- PaddleHub Serving 可以部署一个目标检测的在线服务。
## 查看代码
- ### 第一步：启动PaddleHub Serving
https://github.com/PaddlePaddle/PaddleOCR
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_text_detection_db_server
```
## 依赖
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
paddlepaddle >= 1.7.2
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
paddlehub >= 1.6.0
- ### 第二步：发送预测请求
shapely
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
pyclipper
- ```python
import requests
import json
import cv2
import base64
## 更新历史
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/chinese_text_detection_db_server"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.0.2
* 1.0.1
支持mkldnn加速CPU计算
* 1.0.3
* 1.0.2
增加更多预训练数据，更新预训练参数
- ```shell
$ hub install chinese_text_detection_db_server==1.0.2
```
modules/text/lexical_analysis/jieba_paddle/README.md
浏览文件 @ 9611b1db
## 概述
# jieba_paddle
该Module是jieba使用PaddlePaddle深度学习框架搭建的切词网络（双向GRU）。
同时也支持jieba的传统切词方法，如精确模式、全模式、搜索引擎模式等切词模式，使用方法和jieba保持一致。
|模型名称|jieba_paddle|
| :--- | :---: |
|类别|文本-词法分析|
|网络|BiGRU+CRF|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|28KB|
|最新更新日期|2021-02-26|
|数据指标|-|
更多信息参考：https://github.com/fxsjy/jieba
## API 说明
### cut(sentence, use_paddle=True, cut_all=False, HMM=True)
## 一、模型基本信息
jieba_paddle预测接口，预测输入句子的分词结果
- ### 模型介绍
**参数**
- 该Module是jieba使用PaddlePaddle深度学习框架搭建的切词网络（双向GRU）。同时也支持jieba的传统切词方法，如精确模式、全模式、搜索引擎模式等切词模式，使用方法和jieba保持一致。
* sentence(str): 单句预测数据。
* use_paddle(bool): 是否使用paddle模式（双向GRU）切词，默认为True。
* cut_all 参数用来控制是否采用全模式，默认为True；
* HMM 参数用来控制是否使用 HMM 模型， 默认为True；
- 更多信息参考：[jieba](https://github.com/fxsjy/jieba)
**返回**
* results(list): 分词结果
### cut_for_search(sentence, HMM=True)
## 二、安装
jieba的搜索引擎模式切词，该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细
- ### 1、环境依赖
**参数**
- paddlepaddle >= 1.8.0
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
* sentence(str): 单句预测数据。
* HMM 参数用来控制是否使用 HMM 模型， 默认为True；
- ### 2、安装
### load_userdict(user_dict)
- ```shell
$ hub install jieba_paddle
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
指定自己自定义的词典，以便包含 jieba 词库里没有的词。虽然 jieba 有新词识别能力，但是自行添加新词可以保证更高的正确率。
**参数**
* user_dict(str): 自定义词典的路径
## 三、模型API预测
### extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
- ### 1、命令行预测
基于 TF-IDF 算法的关键词抽取
- ```shell
$ hub run jieba_paddle --input_text "今天天气真好"
```
或者
- ```shell
$ hub run senta_gru --input_file test.txt
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**参数**
- ### 2、预测代码示例
* sentence(str): 待提取的文本
* topK(int): 返回几个 TF/IDF 权重最大的关键词，默认值为 20
* withWeight(bool): 为是否一并返回关键词权重值，默认值为 False
* allowPOS(tuple): 仅包括指定词性的词，默认值为空，即不筛选
- ```python
import paddlehub as hub
### textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v'))
jieba = hub.Module(name="jieba_paddle")
results = jieba.cut("今天是个好日子", cut_all=False, HMM=True)
print(results)
# ['今天', '是', '个', '好日子']
```
基于 TextRank 算法的关键词抽取
**参数**
- ### 3、API
* sentence(str): 待提取的文本
* topK(int): 返回几个 TF/IDF 权重最大的关键词，默认值为 20
* withWeight(bool): 为是否一并返回关键词权重值，默认值为 False
* allowPOS(tuple): 仅包括指定词性的词，默认值为('ns', 'n', 'vn', 'v')
- ```python
def cut(sentence, use_paddle=True, cut_all=False, HMM=True)
```
- jieba_paddle预测接口，预测输入句子的分词结果
# Jieba_Paddle 服务部署
- **参数**
PaddleHub Serving可以部署一个切词服务，可以将此接口用于在线分词等web应用。
- sentence(str): 单句预测数据。
- use_paddle(bool): 是否使用paddle模式（双向GRU）切词，默认为True。
- cut_all 参数用来控制是否采用全模式，默认为True；
- HMM 参数用来控制是否使用 HMM 模型， 默认为True；
## 第一步：启动PaddleHub Serving
- **返回**
运行启动命令：
```shell
$ hub serving start -c serving_config.json
```
- results(list): 分词结果
`serving_config.json`的内容如下：
```json
{
"modules_info": {
"jieba_paddle": {
"init_args": {
"version": "1.0.0"
},
"predict_args": {}
}
},
"port": 8866,
"use_singleprocess": false,
"workers": 2
}
```
这样就完成了一个切词服务化API的部署，默认端口号为8866。
- ```python
def cut_for_search(sentence, HMM=True)
```
- jieba的搜索引擎模式切词，该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细
- **参数**
- sentence(str): 单句预测数据。
- HMM 参数用来控制是否使用 HMM 模型， 默认为True；
- **返回**
- results(list): 分词结果
- ```python
def load_userdict(user_dict)
```
- 指定自己自定义的词典，以便包含 jieba 词库里没有的词。虽然 jieba 有新词识别能力，但是自行添加新词可以保证更高的正确率。
- **参数**
- user_dict(str): 自定义词典的路径
- ```python
def extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
```
- 基于 TF-IDF 算法的关键词抽取
- **参数**
- sentence(str): 待提取的文本
- topK(int): 返回几个 TF/IDF 权重最大的关键词，默认值为 20
- withWeight(bool): 为是否一并返回关键词权重值，默认值为 False
- allowPOS(tuple): 仅包括指定词性的词，默认值为空，即不筛选
- **返回**
## 第二步：发送预测请求
- results(list): 关键词结果
- ```python
def textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v'))
```
- 基于 TextRank 算法的关键词抽取
- **参数**
- sentence(str): 待提取的文本
- topK(int): 返回几个 TF/IDF 权重最大的关键词，默认值为 20
- withWeight(bool): 为是否一并返回关键词权重值，默认值为 False
- allowPOS(tuple): 仅包括指定词性的词，默认值为('ns', 'n', 'vn', 'v')
- **返回**
- results(list): 关键词结果
## 四、服务部署
- PaddleHub Serving可以部署一个切词服务，可以将此接口用于在线分词等web应用。
- ## 第一步：启动PaddleHub Serving
- 运行启动命令：
```shell
$ hub serving start -c serving_config.json
```
- `serving_config.json`的内容如下：
```json
{
"modules_info": {
"jieba_paddle": {
"init_args": {
"version": "1.0.0"
},
"predict_args": {}
}
},
"port": 8866,
"use_singleprocess": false,
"workers": 2
}
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 这样就完成了一个切词服务化API的部署，默认端口号为8866。
```python
import requests
import json
# 待预测数据
text = "今天是个好日子"
- ## 第二步：发送预测请求
# 设置运行配置
# 对应本地预测jieba_paddle.cut(sentence=text, use_paddle=True)
data = {"sentence": text, "use_paddle": True}
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
# 指定预测方法为jieba_paddle并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/jieba_paddle"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
```python
import requests
import json
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
# 待预测数据
text = "今天是个好日子"
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
# 设置运行配置
# 对应本地预测jieba_paddle.cut(sentence=text, use_paddle=True)
data = {"sentence": text, "use_paddle": True}
## 查看代码
# 指定预测方法为jieba_paddle并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/jieba_paddle"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
https://github.com/fxsjy/jieba
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
## 依赖
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
PaddlePaddle >= 1.8.0
PaddleHub >= 1.8.0
## 更新历史
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install jieba_paddle==1.0.0
```
modules/text/lexical_analysis/lac/README.md
浏览文件 @ 9611b1db
## LAC API 说明
# lac
### \_\_init\_\_(user_dict=None)
|模型名称|lac|
| :--- | :---: |
|类别|文本-词法分析|
|网络|BiGRU+CRF|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|35MB|
|最新更新日期|2021-02-26|
|数据指标|Precision=88.0%，Recall=88.7%，F1-Score=88.4%|
## 一、模型基本信息
- ### 模型介绍
构造LAC对象
- Lexical Analysis of Chinese，简称 LAC，是一个联合的词法分析模型，能整体性地完成中文分词、词性标注、专名识别任务。在百度自建数据集上评测，LAC效果：Precision=88.0%，Recall=88.7%，F1-Score=88.4%。该PaddleHub Module支持预测。
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/130606395-60691079-d33f-4d74-a980-b4d9e3bc663e.png" height = "300" hspace='10'/> <br />
</p>
**参数**
- 更多详情请参考：[LAC论文](https://arxiv.org/abs/1807.01882)
* user_dict(str): 自定义词典路径。如果需要使用自定义词典，则可通过该参数设置，否则不用传入该参数。
### cut(text, use_gpu=False, batch_size=1, return_tag=True)
lac预测接口，预测输入句子的分词结果
**参数**
## 二、安装
* text(str or list): 待预测数据，单句预测数据（str类型）或者批量预测（list，每个元素为str
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
* return_tag(bool): 预测结果是否需要返回分词标签结果
- ### 1、环境依赖
### lexical_analysis(texts=[], data={}, use_gpu=False, batch_size=1, user_dict=None, return_tag=True)
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- 若使用词典干预功能，额外依赖第三方库 pyahocorasick
- ```shell
$ pip install pyahocorasick
```
- ### 2、安装
**该接口将会在未来版本被废弃，如有需要，请使用cut接口预测**
- ```shell
$ hub install lac
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
lac预测接口，预测输入句子的分词结果
**参数**
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
* return_tag(bool): 预测结果是否需要返回分词标签结果
**返回**
## 三、模型API预测
* results(list): 分词结果
- ### 1、命令行预测
### context(trainable=False)
- ```shell
$ hub run lac --input_text "今天是个好日子"
```
- 或者
- ```shell
$ hub run lac --input_file test.txt --user_dict user.dict
```
- test.txt 存放待分词文本， 如：
- ```shell
今天是个好日子
今天天气晴朗
```
- user.dict 为用户自定义词典，可以不指定，当指定自定义词典时，可以干预默认分词结果。如：
- ```shell
春天/SEASON
花/n 开/v
秋天的风
落 阳
```
- 词典文件每行表示一个定制化的item，由一个单词或多个连续的单词组成，每个单词后使用'/'表示标签，如果没有'/'标签则会使用模型默认的标签。每个item单词数越多，干预效果会越精准。
获取lac的预训练program以及program的输入输出变量
- Note：该PaddleHub Module使用词典干预功能时，依赖于第三方库pyahocorasick，请自行安装
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**参数**
- ### 2、预测代码示例
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变
- ```python
import paddlehub as hub
**返回**
lac = hub.Module(name="lac")
test_text = ["今天是个好日子", "天气预报说今天要下雨", "下一班地铁马上就要到了"]
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
results = lac.cut(text=test_text, use_gpu=False, batch_size=1, return_tag=True)
### set_user_dict(dict_path)
for result in results:
print(result['word'])
print(result['tag'])
# ['今天', '是', '个', '好日子']
# ['TIME', 'v', 'q', 'n']
# ['天气预报', '说', '今天', '要', '下雨']
# ['n', 'v', 'TIME', 'v', 'v']
# ['下', '一班', '地铁', '马上', '就要', '到', '了']
# ['f', 'm', 'n', 'd', 'v', 'v', 'xc']
```
- ### 3、API
加载用户自定义词典
- ```python
def __init__(user_dict=None)
```
- 构造LAC对象
**参数**
- **参数**
* dict_path(str ): 自定义词典路径
- user_dict(str): 自定义词典路径。如果需要使用自定义词典，则可通过该参数设置，否则不用传入该参数。
### del_user_dict()
删除自定义词典
- ```python
def cut(text, use_gpu=False, batch_size=1, return_tag=True)
```
### get_tags()
- lac预测接口，预测输入句子的分词结果
获取lac的标签
- **参数**
**返回**
- text(str or list): 待预测数据，单句预测数据（str类型）或者批量预测（list，每个元素为str
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
- return_tag(bool): 预测结果是否需要返回分词标签结果
* tag_name_dict(dict): lac的标签
## LAC 服务部署
- ```python
def lexical_analysis(texts=[], data={}, use_gpu=False, batch_size=1, user_dict=None, return_tag=True)
```
- **该接口将会在未来版本被废弃，如有需要，请使用cut接口预测**
PaddleHub Serving可以部署一个在线词法分析服务，可以将此接口用于词法分析、在线分词等在线web应用。
- lac预测接口，预测输入句子的分词结果
### 第一步：启动PaddleHub Serving
- **参数**
运行启动命令：
```shell
$ hub serving start -c serving_config.json
```
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
- return_tag(bool): 预测结果是否需要返回分词标签结果
`serving_config.json`的内容如下：
```json
{
"modules_info": {
"lac": {
"init_args": {
"version": "2.1.0",
"user_dict": "./test_dict.txt"
- **返回**
- results(list): 分词结果
- ```python
def set_user_dict(dict_path)
```
- 加载用户自定义词典
- **参数**
- dict_path(str ): 自定义词典路径
- ```python
def del_user_dict()
```
- 删除自定义词典
- ```python
def get_tags()
```
- 获取lac的标签
- **返回**
- tag_name_dict(dict): lac的标签
## 四、服务部署
- PaddleHub Serving可以部署一个在线词法分析服务，可以将此接口用于词法分析、在线分词等在线web应用。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -c serving_config.json
```
`serving_config.json`的内容如下：
```json
{
"modules_info": {
"lac": {
"init_args": {
"version": "2.1.0",
"user_dict": "./test_dict.txt"
},
"predict_args": {}
}
},
"predict_args": {}
"port": 8866,
"use_singleprocess": false,
"workers": 2
}
},
"port": 8866,
"use_singleprocess": false,
"workers": 2
}
```
其中user_dict含义为自定义词典路径，如果不使用lac自定义词典功能，则可以不填入。
```
- 其中user_dict含义为自定义词典路径，如果不使用lac自定义词典功能，则可以不填入。
- 这样就完成了一个词法分析服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
这样就完成了一个词法分析服务化API的部署，默认端口号为8866。
- ### 第二步：发送预测请求
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
### 第二步：发送预测请求
- ```python
import requests
import json
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
# 待预测数据
text = ["今天是个好日子", "天气预报说今天要下雨"]
```python
import requests
import json
# 设置运行配置
# 对应本地预测lac.analysis_lexical(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 待预测数据
text = ["今天是个好日子", "天气预报说今天要下雨"]
# 指定预测方法为lac并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/lac"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 设置运行配置
# 对应本地预测lac.analysis_lexical(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
# 指定预测方法为lac并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/lac"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
## 更新历史
## 五、更新历史
* 1.0.0
初始发布
初始发布
* 1.0.1
......@@ -167,3 +282,6 @@ print(json.dumps(r.json(), indent=4, ensure_ascii=False))
* 2.2.0
升级自定义词典功能，支持增加不属于lac默认提供的词性
- ```shell
$ hub install lac==2.2.0
```
modules/text/sentiment_analysis/emotion_detection_textcnn/README.md
浏览文件 @ 9611b1db
# EmotionDetectionTextCNN API说明
# emotion_detection_textcnn
## emotion_classify(texts=[], data={}, use_gpu=False, batch_size=1)
|模型名称|emotion_detection_textcnn|
| :--- | :---: |
|类别|文本-情感分析|
|网络|TextCNN|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|122MB|
|最新更新日期|2021-02-26|
|数据指标|-|
emotion_detection_textcnn预测接口，预测输入句子的情感分类(三分类，积极/中立/消极）
**参数**
## 一、模型基本信息
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
- ### 模型介绍
**返回**
- 对话情绪识别（Emotion Detection，简称EmoTect）专注于识别智能对话场景中用户的情绪，针对智能对话场景中的用户文本，自动判断该文本的情绪类别并给出相应的置信度，情绪类型分为积极、消极、中性。该模型基于TextCNN（多卷积核CNN模型），能够更好地捕捉句子局部相关性。
* results(list): 情感分类结果
### context(trainable=False, max_seq_len=128, num_slots=1)
获取该Module的预训练program以及program相应的输入输出。
**参数**
## 二、安装
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变。
* max_seq_len(int): 模型使用的最大序列长度。
* num_slots(int): 输入到模型所需要的文本个数，如完成单句文本分类任务，则num_slots=1；完成pointwise文本匹配任务，则num_slots=2；完成pairtwise文本匹配任务，则num_slots=3；
- ### 1、环境依赖
**返回**
- paddlepaddle >= 1.8.0
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
- ### 2、安装
## get_labels()
- ```shell
$ hub install emotion_detection_textcnn
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
获取emotion_detection_textcnn的类别
**返回**
* labels(dict): emotion_detection_textcnn的类别(三分类，积极/中立/消极)
## get_vocab_path()
获取预训练时使用的词汇表
## 三、模型API预测
**返回**
- ### 1、命令行预测
* vocab_path(str): 词汇表路径
- ```shell
$ hub run emotion_detection_textcnn --input_text "今天天气真好"
```
或者
- ```shell
$ hub run emotion_detection_textcnn --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
> 这部电影真的很差劲
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
# EmotionDetectionTextcnn 服务部署
- ### 2、预测代码示例
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ```python
import paddlehub as hub
## 第一步：启动PaddleHub Serving
module = hub.Module(name="emotion_detection_textcnn")
test_text = ["今天天气真好", "湿纸巾是干垃圾", "别来吵我"]
results = module.emotion_classify(texts=test_text)
运行启动命令：
```shell
$ hub serving start -m emotion_detection_textcnn
```
for result in results:
print(result['text'])
print(result['emotion_label'])
print(result['emotion_key'])
print(result['positive_probs'])
print(result['neutral_probs'])
print(result['negative_probs'])
# 今天天气真好 2 positive 0.9267 0.0714 0.0019
# 湿纸巾是干垃圾 1 neutral 0.0062 0.9896 0.0042
# 别来吵我 0 negative 0.0732 0.1477 0.7791
```
- ### 3、API
启动时会显示加载模型过程，启动成功后显示
```shell
Loading emotion_detection_textcnn successful.
```
- ```python
def emotion_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- emotion_detection_textcnn预测接口，预测输入句子的情感分类(三分类，积极/中立/消极）
这样就完成了服务化API的部署，默认端口号为8866。
- **参数**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
## 第二步：发送预测请求
- **返回**
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- results(list): 情感分类结果
```python
import requests
import json
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- ```python
def get_labels()
```
# 设置运行配置
# 对应本地预测emotion_detection_textcnn.emotion_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
- 获取emotion_detection_textcnn的类别
# 指定预测方法为emotion_detection_textcnn并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/emotion_detection_textcnn"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- **返回**
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- labels(dict): emotion_detection_textcnn的类别(三分类，积极/中立/消极)
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- ```python
def get_vocab_path()
```
## 更新历史
- 获取预训练时使用的词汇表
- **返回**
- vocab_path(str): 词汇表路径
## 四、服务部署
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ## 第一步：启动PaddleHub Serving
- 运行启动命令：
```shell
$ hub serving start -m emotion_detection_textcnn
```
- 启动时会显示加载模型过程，启动成功后显示
```shell
Loading emotion_detection_textcnn successful.
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ## 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
# 设置运行配置
# 对应本地预测emotion_detection_textcnn.emotion_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为emotion_detection_textcnn并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/emotion_detection_textcnn"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
......@@ -107,3 +184,7 @@ print(json.dumps(r.json(), indent=4, ensure_ascii=False))
* 1.2.0
模型升级，支持用于文本分类，文本匹配等各种任务迁移学习
- ```shell
$ hub install emotion_detection_textcnn==1.2.0
```
modules/text/sentiment_analysis/ernie_skep_sentiment_analysis/README.md
浏览文件 @ 9611b1db
## 概述
# ernie_skep_sentiment_analysis
|模型名称|ernie_skep_sentiment_analysis|
| :--- | :---: |
|类别|文本-情感分析|
|网络|SKEP|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|2.4G|
|最新更新日期|2021-02-26|
|数据指标|-|
SKEP（Sentiment Knowledge Enhanced Pre-training for Sentiment Analysis）是百度研究团队在2020年提出的基于情感知识增强的情感预训练算法，此算法采用无监督方法自动挖掘情感知识，然后利用情感知识构建预训练目标，从而让机器学会理解情感语义，在14项中英情感分析典型任务上全面超越SOTA，相关工作已经被ACL 2020录用。SKEP为各类情感分析任务提供统一且强大的情感语义表示。ernie_skep_sentiment_analysis Module可用于句子级情感分析任务预测。其在预训练时使用ERNIE 1.0 large预训练参数作为其网络参数初始化继续预训练。同时，该Module支持完成句子级情感分析任务迁移学习Fine-tune。
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/nlp/skep.png" hspace='10'/> <br />
</p>
更多详情参考ACL 2020论文[SKEP: Sentiment Knowledge Enhanced Pre-training for Sentiment Analysis](https://arxiv.org/abs/2005.05635)
## 命令行预测
```shell
$ hub run ernie_skep_sentiment_analysis --input_text='虽然小明很努力，但是他还是没有考100分'
```
## API
## 一、模型基本信息
```python
def predict_sentiment(texts=[], use_gpu=False)
```
- ### 模型介绍
预测API，分类输入文本的情感极性。
- SKEP（Sentiment Knowledge Enhanced Pre-training for Sentiment Analysis）是百度研究团队在2020年提出的基于情感知识增强的情感预训练算法，此算法采用无监督方法自动挖掘情感知识，然后利用情感知识构建预训练目标，从而让机器学会理解情感语义，在14项中英情感分析典型任务上全面超越SOTA，相关工作已经被ACL 2020录用。SKEP为各类情感分析任务提供统一且强大的情感语义表示。ernie_skep_sentiment_analysis Module可用于句子级情感分析任务预测。其在预训练时使用ERNIE 1.0 large预训练参数作为其网络参数初始化继续预训练。
**参数**
* texts (list\[str\]): 待预测文本；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
**返回**
* res (list\[dict\]): 情感分类结果的列表，列表中每一个元素为 dict，各字段为：
* text(str): 输入预测文本
* sentiment_label(str): 情感分类结果，或为positive或为negative
* positive_probs: 输入预测文本情感极性属于positive的概率
* negative_probs: 输入预测文本情感极性属于negative的概率
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/nlp/skep.png" width='600' hspace='10'/> <br />
</p>
```python
def context(trainable=True, max_seq_len=128)
```
用于获取Module的上下文信息，得到输入、输出以及预训练的Paddle Program副本
- 更多详情参考ACL 2020论文：[SKEP: Sentiment Knowledge Enhanced Pre-training for Sentiment Analysis](https://arxiv.org/abs/2005.05635)
**参数**
* trainable(bool): 设置为True时，Module中的参数在Fine-tune时也会随之训练，否则保持不变。
* max_seq_len(int): SKEP模型的最大序列长度，若序列长度不足，会通过padding方式补到**max_seq_len**, 若序列长度大于该值，则会以截断方式让序列长度为**max_seq_len**，max_seq_len可取值范围为0～512；
**返回**
* inputs: dict类型，各字段为：
* input_ids(Variable): Token Embedding，shape为\[batch_size, max_seq_len\]，dtype为int64类型；
* position_id(Variable): Position Embedding，shape为\[batch_size, max_seq_len\]，dtype为int64类型；
* segment_ids(Variable): Sentence Embedding，shape为\[batch_size, max_seq_len\]，dtype为int64类型；
* input_mask(Variable): token是否为padding的标识，shape为\[batch_size, max_seq_len\]，dtype为int64类型；
## 二、安装
* outputs：dict类型，Module的输出特征，各字段为：
* pooled_output(Variable): 句子粒度的特征，可用于文本分类等任务，shape为 \[batch_size, 768\]，dtype为int64类型；
* sequence_output(Variable): 字粒度的特征，可用于序列标注等任务，shape为 \[batch_size, seq_len, 768\]，dtype为int64类型；
- ### 1、环境依赖
* program：包含该Module计算图的Program。
- paddlepaddle >= 1.8.0
- paddlehub >= 1.7.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
```python
def get_embedding(texts, use_gpu=False, batch_size=1)
```
- ### 2、安装
用于获取输入文本的句子粒度特征与字粒度特征
- ```shell
$ hub install ernie_skep_sentiment_analysis==1.0.0
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
**参数**
* texts(list)：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
* use_gpu(bool)：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
**返回**
## 三、模型API预测
* results(list): embedding特征，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
- ### 1、命令行预测
```python
def get_params_layer()
```
- ```shell
$ hub run ernie_skep_sentiment_analysis --input_text='虽然小明很努力，但是他还是没有考100分'
```
- ### 2、预测代码示例
用于获取参数层信息，该方法与ULMFiTStrategy联用可以严格按照层数设置分层学习率与逐层解冻。
- ```python
import paddlehub as hub
**参数**
# Load ernie_skep_sentiment_analysis module.
module = hub.Module(name="ernie_skep_sentiment_analysis")
* 无
# Predict sentiment label
test_texts = ['你不是不聪明，而是不认真', '虽然小明很努力，但是他还是没有考100分']
results = module.predict_sentiment(test_texts, use_gpu=False)
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
# 你不是不聪明，而是不认真 negative 0.10738129168748856 0.8926186561584473
# 虽然小明很努力，但是他还是没有考100分 negative 0.05391530692577362 0.94608473777771
```
**返回**
- ### 3、API
* params_layer(dict): key为参数名，值为参数所在层数
- ```python
def predict_sentiment(texts=[], use_gpu=False)
```
- 预测API，分类输入文本的情感极性。
**代码示例**
- **参数**
情感极性预测代码示例：
- texts (list\[str\]): 待预测文本；
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
```python
import paddlehub as hub
- **返回**
# Load ernie_skep_sentiment_analysis module.
module = hub.Module(name="ernie_skep_sentiment_analysis")
- res (list\[dict\]): 情感分类结果的列表，列表中每一个元素为 dict，各字段为：
- text(str): 输入预测文本
- sentiment_label(str): 情感分类结果，或为positive或为negative
- positive_probs: 输入预测文本情感极性属于positive的概率
- negative_probs: 输入预测文本情感极性属于negative的概率
# Predict sentiment label
test_texts = ['你不是不聪明，而是不认真', '虽然小明很努力，但是他还是没有考100分']
results = module.predict_sentiment(test_texts, use_gpu=False)
```
## 服务部署
- ```python
def get_embedding(texts, use_gpu=False, batch_size=1)
```
PaddleHub Serving 可以部署一个目标检测的在线服务。
- 用于获取输入文本的句子粒度特征与字粒度特征
### 第一步：启动PaddleHub Serving
- **参数**
运行启动命令：
```shell
$ hub serving start -m ernie_skep_sentiment_analysis
```
- texts(list)：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
- use_gpu(bool)：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- **返回**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- results(list): embedding特征，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
## 四、服务部署
```python
import requests
import json
- PaddleHub Serving 可以部署一个目标检测的在线服务。
# 发送HTTP请求
data = {'texts':['你不是不聪明，而是不认真', '虽然小明很努力，但是他还是没有考100分']}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_skep_sentiment_analysis"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- ### 第一步：启动PaddleHub Serving
# 打印预测结果
print(r.json()["results"])
```
- 运行启动命令：
```shell
$ hub serving start -m ernie_skep_sentiment_analysis
```
## 查看代码
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
https://github.com/baidu/Senta
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
### 依赖
- ### 第二步：发送预测请求
paddlepaddle >= 1.8.0
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
paddlehub >= 1.7.0
```python
import requests
import json
# 发送HTTP请求
data = {'texts':['你不是不聪明，而是不认真', '虽然小明很努力，但是他还是没有考100分']}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_skep_sentiment_analysis"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 更新历史
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install ernie_skep_sentiment_analysis==1.0.0
```
modules/text/sentiment_analysis/senta_bilstm/README.md
浏览文件 @ 9611b1db
# SentaBiLSTM API说明
# senta_bilstm
|模型名称|senta_bilstm|
| :--- | :---: |
|类别|文本-情感分析|
|网络|BiLSTM|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|690MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
## 一、模型基本信息
senta_bilstm预测接口，预测输入句子的情感分类(二分类，积极/消极）
- ### 模型介绍
**参数**
- 情感倾向分析（Sentiment Classification，简称Senta）针对带有主观描述的中文文本，可自动判断该文本的情感极性类别并给出相应的置信度，能够帮助企业理解用户消费习惯、分析热点话题和危机舆情监控，为企业提供有利的决策支持。该模型基于一个双向LSTM结构，情感类型分为积极、消极。
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
**返回**
* results(list): 情感分类结果
## 二、安装
### context(trainable=False, max_seq_len=128, num_slots=1)
- ### 1、环境依赖
获取该Module的预训练program以及program相应的输入输出。
- paddlepaddle >= 1.8.0
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
- ### 2、安装
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变。
* max_seq_len(int): 模型使用的最大序列长度。
* num_slots(int): 输入到模型所需要的文本个数，如完成单句文本分类任务，则num_slots=1；完成pointwise文本匹配任务，则num_slots=2；完成pairtwise文本匹配任务，则num_slots=3；
- ```shell
$ hub install senta_bilstm
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
**返回**
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
## get_labels()
## 三、模型API预测
获取senta_bilstm的类别
- ### 1、命令行预测
**返回**
- ```shell
$ hub run senta_bilstm --input_text "这家餐厅很好吃"
```
或者
- ```shell
$ hub run senta_bilstm --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
> 这部电影真的很差劲
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* labels(dict): senta_bilstm的类别(二分类，积极/消极)
- ### 2、预测代码示例
## get_vocab_path()
- ```python
import paddlehub as hub
获取预训练时使用的词汇表
senta = hub.Module(name="senta_bilstm")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
results = senta.sentiment_classify(texts=test_text,
use_gpu=False,
batch_size=1)
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
# 这家餐厅很好吃 1 positive 0.9407 0.0593
# 这部电影真的很差劲 0 negative 0.02 0.98
```
**返回**
- ### 3、API
* vocab_path(str): 词汇表路径
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- senta_bilstm预测接口，预测输入句子的情感分类(二分类，积极/消极）
# SentaBiLSTM 服务部署
- **参数**
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
## 第一步：启动PaddleHub Serving
- **返回**
运行启动命令：
```shell
$ hub serving start -m senta_bilstm
```
- results(list): 情感分类结果
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_bilstm successful.
```
这样就完成了服务化API的部署，默认端口号为8866。
- ```python
def get_labels()
```
- 获取senta_bilstm的类别
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- **返回**
## 第二步：发送预测请求
- labels(dict): senta_bilstm的类别(二分类，积极/消极)
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
def get_vocab_path()
```
- 获取预训练时使用的词汇表
```python
import requests
import json
- **返回**
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- vocab_path(str): 词汇表路径
# 设置运行配置
# 对应本地预测senta_bilstm.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_bilstm并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_bilstm"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
## 四、服务部署
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
## 更新历史
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m senta_bilstm
```
- 启动时会显示加载模型过程，启动成功后显示
- ```shell
Loading senta_bilstm successful.
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
# 设置运行配置
# 对应本地预测senta_bilstm.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_bilstm并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_bilstm"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
词汇表升级
* 1.1.0
......@@ -107,3 +182,6 @@ print(json.dumps(r.json(), indent=4, ensure_ascii=False))
* 1.2.0
模型升级，支持用于文本分类，文本匹配等各种任务迁移学习
- ```shell
$ hub install senta_bilstm==1.2.0
```
modules/text/sentiment_analysis/senta_bow/README.md
浏览文件 @ 9611b1db
# SentaBOW API说明
# senta_bow
## sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
|模型名称|senta_bow|
| :--- | :---: |
|类别|文本-情感分析|
|网络|BOW|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|637MB|
|最新更新日期|2021-02-26|
|数据指标|-|
senta_bow预测接口，预测输入句子的情感分类(二分类，积极/消极）
**参数**
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
## 一、模型基本信息
**返回**
- ### 模型介绍
* results(list): 情感分类结果
- 情感倾向分析（Sentiment Classification，简称Senta）针对带有主观描述的中文文本，可自动判断该文本的情感极性类别并给出相应的置信度，能够帮助企业理解用户消费习惯、分析热点话题和危机舆情监控，为企业提供有利的决策支持。该模型基于一个BOW结构，情感类型分为积极、消极。
### context(trainable=False, max_seq_len=128, num_slots=1)
获取该Module的预训练program以及program相应的输入输出。
**参数**
## 二、安装
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变。
* max_seq_len(int): 模型使用的最大序列长度。
* num_slots(int): 输入到模型所需要的文本个数，如完成单句文本分类任务，则num_slots=1；完成pointwise文本匹配任务，则num_slots=2；完成pairtwise文本匹配任务，则num_slots=3；
- ### 1、环境依赖
**返回**
- paddlepaddle >= 1.8.0
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
- ### 2、安装
## get_labels()
- ```shell
$ hub install senta_bow
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
获取senta_bow的类别
**返回**
* labels(dict): senta_bow的类别(二分类，积极/消极)
## get_vocab_path()
## 三、模型API预测
获取预训练时使用的词汇表
- ### 1、命令行预测
**返回**
- ```shell
$ hub run senta_bow --input_text "这家餐厅很好吃"
```
- 或者
- ```shell
$ hub run senta_bow --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
> 这部电影真的很差劲
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* vocab_path(str): 词汇表路径
- ### 2、预测代码示例
# SentaBow 服务部署
- ```python
import paddlehub as hub
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
senta = hub.Module(name="senta_bow")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
## 第一步：启动PaddleHub Serving
results = senta.sentiment_classify(texts=test_text, use_gpu=False, batch_size=1)
运行启动命令：
```shell
$ hub serving start -m senta_bow
```
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
# 这家餐厅很好吃 1 positive 0.9782 0.0218
# 这部电影真的很差劲 0 negative 0.0124 0.9876
```
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_bow successful.
```
- ### 3、API
这样就完成了服务化API的部署，默认端口号为8866。
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- senta_bow预测接口，预测输入句子的情感分类(二分类，积极/消极）
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- **参数**
## 第二步：发送预测请求
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **返回**
```python
import requests
import json
- results(list): 情感分类结果
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
# 设置运行配置
# 对应本地预测senta_bow.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
- ```python
def get_labels()
```
# 指定预测方法为senta_bow并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_bow"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- 获取senta_bow的类别
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- **返回**
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- labels(dict): senta_bow的类别(二分类，积极/消极)
## 更新历史
- ```python
def get_vocab_path()
```
- 获取预训练时使用的词汇表
- **返回**
- vocab_path(str): 词汇表路径
## 四、服务部署
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ## 第一步：启动PaddleHub Serving
- 运行启动命令：
```shell
$ hub serving start -m senta_bow
```
- 启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_bow successful.
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ## 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
# 设置运行配置
# 对应本地预测senta_bow.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_bow并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_bow"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
词汇表升级
* 1.1.0
......@@ -107,3 +187,7 @@ print(json.dumps(r.json(), indent=4, ensure_ascii=False))
* 1.2.0
模型升级，支持用于文本分类，文本匹配等各种任务迁移学习
- ```shell
$ hub install senta_bow==1.2.0
```
modules/text/sentiment_analysis/senta_cnn/README.md
浏览文件 @ 9611b1db
# SentaCNN API说明
# senta_cnn
|模型名称|senta_cnn|
| :--- | :---: |
|类别|文本-情感分析|
|网络|CNN|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|637MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
## 一、模型基本信息
senta_cnn预测接口，预测输入句子的情感分类(二分类，积极/消极）
- ### 模型介绍
**参数**
- 情感倾向分析（Sentiment Classification，简称Senta）针对带有主观描述的中文文本，可自动判断该文本的情感极性类别并给出相应的置信度，能够帮助企业理解用户消费习惯、分析热点话题和危机舆情监控，为企业提供有利的决策支持。该模型基于一个CNN结构，情感类型分为积极、消极。
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
**返回**
## 二、安装
* results(list): 情感分类结果
- ### 1、环境依赖
### context(trainable=False, max_seq_len=128, num_slots=1)
- paddlepaddle >= 1.8.0
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
获取该Module的预训练program以及program相应的输入输出。
- ### 2、安装
**参数**
- ```shell
$ hub install senta_cnn
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变。
* max_seq_len(int): 模型使用的最大序列长度。
* num_slots(int): 输入到模型所需要的文本个数，如完成单句文本分类任务，则num_slots=1；完成pointwise文本匹配任务，则num_slots=2；完成pairtwise文本匹配任务，则num_slots=3；
**返回**
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
## 三、模型API预测
## get_labels()
- ### 1、命令行预测
获取senta_cnn的类别
- ```shell
$ hub run senta_cnn --input_text "这家餐厅很好吃"
```
或者
- ```shell
$ hub run senta_cnn --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
> 这部电影真的很差劲
- 通过命令行方式实现文字识别模型的调用，更多请见：[PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**返回**
- ### 2、预测代码示例
* labels(dict): senta_cnn的类别(二分类，积极/消极)
- ```python
import paddlehub as hub
## get_vocab_path()
senta = hub.Module(name="senta_cnn")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
results = senta.sentiment_classify(texts=test_text,
use_gpu=False,
batch_size=1)
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
# 这家餐厅很好吃 1 positive 0.7902 0.2098
# 这部电影真的很差劲 0 negative 0.0343 0.9657
```
获取预训练时使用的词汇表
- ### 3、API
**返回**
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- senta_cnn预测接口，预测输入句子的情感分类(二分类，积极/消极）
* vocab_path(str): 词汇表路径
- **参数**
# SentaCNN 服务部署
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- **返回**
## 第一步：启动PaddleHub Serving
- results(list): 情感分类结果
运行启动命令：
```shell
$ hub serving start -m senta_cnn
```
- ```python
def get_labels()
```
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_cnn successful.
```
- 获取senta_cnn的类别
这样就完成了服务化API的部署，默认端口号为8866。
- **返回**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- labels(dict): senta_cnn的类别(二分类，积极/消极)
## 第二步：发送预测请求
- ```python
def get_vocab_path()
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 获取预训练时使用的词汇表
```python
import requests
import json
- **返回**
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- vocab_path(str): 词汇表路径
# 设置运行配置
# 对应本地预测senta_cnn.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_cnn并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_cnn"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
## 四、服务部署
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ## 第一步：启动PaddleHub Serving
- 运行启动命令：
```shell
$ hub serving start -m senta_cnn
```
- 启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_cnn successful.
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ## 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
# 设置运行配置
# 对应本地预测senta_cnn.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_cnn并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_cnn"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
## 更新历史
* 1.0.0
初始发布
* 1.0.1
词汇表升级
* 1.1.0
......@@ -107,3 +183,7 @@ print(json.dumps(r.json(), indent=4, ensure_ascii=False))
* 1.2.0
模型升级，支持用于文本分类，文本匹配等各种任务迁移学习
- ```shell
$ hub install senta_cnn==1.2.0
```
modules/text/sentiment_analysis/senta_gru/README.md
浏览文件 @ 9611b1db
# SentaGRU API说明
# senta_gru
## sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
|模型名称|senta_gru|
| :--- | :---: |
|类别|文本-情感分析|
|网络|GRU|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|637MB|
|最新更新日期|2021-02-26|
|数据指标|-|
senta_gru预测接口，预测输入句子的情感分类(二分类，积极/消极）
**参数**
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
## 一、模型基本信息
**返回**
- ### 模型介绍
* results(list): 情感分类结果
- 情感倾向分析（Sentiment Classification，简称Senta）针对带有主观描述的中文文本，可自动判断该文本的情感极性类别并给出相应的置信度，能够帮助企业理解用户消费习惯、分析热点话题和危机舆情监控，为企业提供有利的决策支持。该模型基于一个GRU结构，情感类型分为积极、消极。
### context(trainable=False, max_seq_len=128, num_slots=1)
获取该Module的预训练program以及program相应的输入输出。
**参数**
## 二、安装
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变。
* max_seq_len(int): 模型使用的最大序列长度。
* num_slots(int): 输入到模型所需要的文本个数，如完成单句文本分类任务，则num_slots=1；完成pointwise文本匹配任务，则num_slots=2；完成pairtwise文本匹配任务，则num_slots=3；
- ### 1、环境依赖
**返回**
- paddlepaddle >= 1.8.0
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
- ### 2、安装
## get_labels()
- ```shell
$ hub install senta_gru
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
获取senta_gru的类别
**返回**
* labels(dict): senta_gru的类别(二分类，积极/消极)
## 三、模型API预测
## get_vocab_path()
- ### 1、命令行预测
获取预训练时使用的词汇表
- ```shell
$ hub run senta_gru --input_text "今天天气真好"
```
或者
- ```shell
$ hub run senta_gru --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
> 这部电影真的很差劲
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**返回**
- ### 2、预测代码示例
* vocab_path(str): 词汇表路径
- ```python
import paddlehub as hub
# SentaGRU 服务部署
senta = hub.Module(name="senta_gru")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
results = senta.sentiment_classify(texts=test_text, use_gpu=False, batch_size=1)
## 第一步：启动PaddleHub Serving
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
# 这家餐厅很好吃 1 positive 0.9607 0.0393
# 这部电影真的很差劲 0 negative 0.0187 0.9813
```
- ### 3、API
运行启动命令：
```shell
$ hub serving start -m senta_gru
```
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- senta_gru预测接口，预测输入句子的情感分类(二分类，积极/消极）
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_gru successful.
```
- **参数**
这样就完成了服务化API的部署，默认端口号为8866。
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- **返回**
## 第二步：发送预测请求
- results(list): 情感分类结果
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
def get_labels()
```
```python
import requests
import json
- 获取senta_gru的类别
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- **返回**
# 设置运行配置
# 对应本地预测senta_gru.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
- labels(dict): senta_gru的类别(二分类，积极/消极)
# 指定预测方法为senta_gru并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_gru"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- ```python
def get_vocab_path()
```
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 获取预训练时使用的词汇表
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- **返回**
## 更新历史
- vocab_path(str): 词汇表路径
## 四、服务部署
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ## 第一步：启动PaddleHub Serving
- 运行启动命令：
```shell
$ hub serving start -m senta_gru
```
- 启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_gru successful.
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ## 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
# 设置运行配置
# 对应本地预测senta_gru.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_gru并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_gru"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
词汇表升级
* 1.1.0
大幅提升预测性能
......@@ -107,3 +181,7 @@ print(json.dumps(r.json(), indent=4, ensure_ascii=False))
* 1.2.0
模型升级，支持用于文本分类，文本匹配等各种任务迁移学习
- ```shell
$ hub install senta_gru==1.2.0
```
modules/text/sentiment_analysis/senta_lstm/README.md
浏览文件 @ 9611b1db
# SentaLSTM API说明
# senta_lstm
|模型名称|senta_lstm|
| :--- | :---: |
|类别|文本-情感分析|
|网络|LSTM|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|637MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
senta_lstm预测接口，预测输入句子的情感分类(二分类，积极/消极）
## 一、模型基本信息
**参数**
- ### 模型介绍
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
- 情感倾向分析（Sentiment Classification，简称Senta）针对带有主观描述的中文文本，可自动判断该文本的情感极性类别并给出相应的置信度，能够帮助企业理解用户消费习惯、分析热点话题和危机舆情监控，为企业提供有利的决策支持。该模型基于一个LSTM结构，情感类型分为积极、消极。
**返回**
* results(list): 情感分类结果
## 二、安装
### context(trainable=False, max_seq_len=128, num_slots=1)
- ### 1、环境依赖
获取该Module的预训练program以及program相应的输入输出。
- paddlepaddle >= 1.8.0
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
- ### 2、安装
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变。
* max_seq_len(int): 模型使用的最大序列长度。
* num_slots(int): 输入到模型所需要的文本个数，如完成单句文本分类任务，则num_slots=1；完成pointwise文本匹配任务，则num_slots=2；完成pairtwise文本匹配任务，则num_slots=3；
- ```shell
$ hub install senta_lstm
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
**返回**
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
## get_labels()
## 三、模型API预测
获取senta_lstm的类别
- ### 1、命令行预测
**返回**
- ```shell
$ hub run senta_lstm --input_text "这家餐厅很好吃"
```
或者
- ```shell
$ hub run senta_lstm --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
> 这部电影真的很差劲
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* labels(dict): senta_lstm的类别(二分类，积极/消极)
- ### 2、预测代码示例
## get_vocab_path()
- ```python
import paddlehub as hub
获取预训练时使用的词汇表
senta = hub.Module(name="senta_lstm")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
results = senta.sentiment_classify(texts=test_text,
use_gpu=False,
batch_size=1)
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
# 这家餐厅很好吃 1 positive 0.9285 0.0715
# 这部电影真的很差劲 0 negative 0.0187 0.9813
```
**返回**
- ### 3、API
* vocab_path(str): 词汇表路径
- ```python
sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- senta_lstm预测接口，预测输入句子的情感分类(二分类，积极/消极）
# SentaLSTM 服务部署
- **参数**
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
## 第一步：启动PaddleHub Serving
- **返回**
运行启动命令：
```shell
$ hub serving start -m senta_lstm
```
- results(list): 情感分类结果
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_lstm successful.
```
这样就完成了服务化API的部署，默认端口号为8866。
- ```python
get_labels()
```
- 获取senta_lstm的类别
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- **返回**
## 第二步：发送预测请求
- labels(dict): senta_lstm的类别(二分类，积极/消极)
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
get_vocab_path()
```
- 获取预训练时使用的词汇表
```python
import requests
import json
- **返回**
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- vocab_path(str): 词汇表路径
# 设置运行配置
# 对应本地预测senta_lstm.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_lstm并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_lstm"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
## 四、服务部署
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- ## 第一步：启动PaddleHub Serving
## 更新历史
- 运行启动命令：
- ```shell
$ hub serving start -m senta_lstm
```
- 启动时会显示加载模型过程，启动成功后显示
- ```shell
Loading senta_lstm successful.
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ## 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
# 设置运行配置
# 对应本地预测senta_lstm.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为senta_lstm并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/senta_lstm"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
词汇表升级
* 1.1.0
大幅提升预测性能
* 1.2.0
模型升级，支持用于文本分类，文本匹配等各种任务迁移学习
- ```shell
$ hub install senta_lstm==1.2.0
```
modules/text/syntactic_analysis/DDParser/README.md
浏览文件 @ 9611b1db
# 命令行预测
# DDParser
```shell
$ hub run ddparser --input_text="百度是一家高科技公司"
```
|模型名称|DDParser|
| :--- | :---: |
|类别|文本-句法分析|
|网络|LSTM|
|数据集|搜索query、网页文本、语音输入等数据|
|是否支持Fine-tuning|否|
|模型大小|33MB|
|最新更新日期|2021-02-26|
|数据指标|-|
# API
## parse(texts=[], return\_visual=False)
依存分析接口，输入文本，输出依存关系。
## 一、模型基本信息
**参数**
- ### 模型介绍
* texts(list\[list\[str\] or list\[str\]]): 待预测数据。各元素可以是未分词的字符串，也可以是已分词的token列表。
* return\_visual(bool): 是否返回依存分析可视化结果。如果为True，返回结果中将包含'visual'字段。
- DDParser（Baidu Dependency Parser）是百度NLP基于大规模标注数据和深度学习平台飞桨研发的中文依存句法分析工具，可帮助用户直接获取输入文本中的关联词对、长距离依赖词对等。
**返回**
* results(list\[dict\]): 依存分析结果。每个元素都是dict类型，包含以下信息：
```python
{
'word': list[str], 分词结果。
'head': list[int], 当前成分其支配者的id。
'deprel': list[str], 当前成分与支配者的依存关系。
'prob': list[float], 从属者和支配者依存的概率。
'postag': list[str], 词性标签，只有当texts的元素是未分词的字符串时包含这个键。
'visual': 图像数组，可以使用cv2.imshow显示图像或cv2.imwrite保存图像。
}
```
## 二、安装
## visualize(word, head, deprel)
- ### 1、环境依赖
可视化接口，输入依存分析接口得到的信息，输出依存图形数组。
- paddlepaddle >= 1.8.2
- paddlehub >= 1.7.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
- 额外依赖ddparser
- ```shell
$ pip install ddparser
```
* word(list\[list\[str\]\): 分词信息。
* head(list\[int\]): 当前成分其支配者的id。
* deprel(list\[str\]): 当前成分与支配者的依存关系。
- ### 2、安装
**返回**
- ```shell
$ hub install ddparser
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
* data(numpy.array): 图像数组。可以使用cv2.imshow显示图像或cv2.imwrite保存图像。
**代码示例**
```python
import cv2
import paddlehub as hub
module = hub.Module(name="ddparser")
## 三、模型API预测
test_text = ["百度是一家高科技公司"]
results = module.parse(texts=test_text)
print(results)
- ### 1、命令行预测
test_tokens = [['百度', '是', '一家', '高科技', '公司']]
results = module.parse(texts=test_text, return_visual = True)
print(results)
- ```shell
$ hub run ddparser --input_text="百度是一家高科技公司"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
result = results[0]
data = module.visualize(result['word'],result['head'],result['deprel'])
# or data = result['visual']
cv2.imwrite('test.jpg',data)
```
- ### 2、预测代码示例
# DependencyParser 服务部署
- ```python
import cv2
import paddlehub as hub
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
module = hub.Module(name="ddparser")
## 第一步：启动PaddleHub Serving
test_text = ["百度是一家高科技公司"]
results = module.parse(texts=test_text)
print(results)
运行启动命令：
```shell
$ hub serving start -m ddparser
```
test_tokens = [['百度', '是', '一家', '高科技', '公司']]
results = module.parse(texts=test_text, return_visual = True)
print(results)
启动时会显示加载模型过程，启动成功后显示
```shell
Loading ddparser successful.
```
result = results[0]
data = module.visualize(result['word'],result['head'],result['deprel'])
# or data = result['visual']
cv2.imwrite('test.jpg',data)
```
- ### 3、API
这样就完成了服务化API的部署，默认端口号为8866。
- ```python
def parse(texts=[], return\_visual=False)
```
- 依存分析接口，输入文本，输出依存关系。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- **参数**
## 第二步：发送预测请求
- texts(list\[list\[str\] or list\[str\]]): 待预测数据。各元素可以是未分词的字符串，也可以是已分词的token列表。
- return\_visual(bool): 是否返回依存分析可视化结果。如果为True，返回结果中将包含'visual'字段。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **返回**
```python
import requests
import json
- results(list\[dict\]): 依存分析结果。每个元素都是dict类型，包含以下信息：
{
'word': list[str], 分词结果。
'head': list[int], 当前成分其支配者的id。
'deprel': list[str], 当前成分与支配者的依存关系。
'prob': list[float], 从属者和支配者依存的概率。
'postag': list[str], 词性标签，只有当texts的元素是未分词的字符串时包含这个键。
'visual': 图像数组，可以使用cv2.imshow显示图像或cv2.imwrite保存图像。
}
import numpy as np
import cv2
- ```python
def visualize(word, head, deprel)
```
# 待预测数据
text = ["百度是一家高科技公司"]
- 可视化接口，输入依存分析接口得到的信息，输出依存图形数组。
# 设置运行配置
return_visual = True
data = {"texts": text, "return_visual": return_visual}
- **参数**
# 指定预测方法为DuDepParser并发送post请求，content-type类型应指定json方式
url = "http://0.0.0.0:8866/predict/ddparser"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
results = r.json()['results']
- word(list\[list\[str\]\): 分词信息。
- head(list\[int\]): 当前成分其支配者的id。
- deprel(list\[str\]): 当前成分与支配者的依存关系。
for i in range(len(results)):
print(results[i]['word'])
# 不同于本地调用parse接口，serving返回的图像是list类型的，需要先用numpy加载再显示或保存。
cv2.imwrite('%s.jpg'%i, np.array(results[i]['visual']))
```
- **返回**
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- data(numpy.array): 图像数组。可以使用cv2.imshow显示图像或cv2.imwrite保存图像。
### 依赖
paddlepaddle >= 1.8.2
## 四、服务部署
paddlehub >= 1.7.0
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ## 第一步：启动PaddleHub Serving
## 更新历史
- 运行启动命令：
```shell
$ hub serving start -m ddparser
```
- 启动时会显示加载模型过程，启动成功后显示
```shell
Loading ddparser successful.
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ## 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import numpy as np
import cv2
# 待预测数据
text = ["百度是一家高科技公司"]
# 设置运行配置
return_visual = True
data = {"texts": text, "return_visual": return_visual}
# 指定预测方法为DuDepParser并发送post请求，content-type类型应指定json方式
url = "http://0.0.0.0:8866/predict/ddparser"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
results = r.json()['results']
for i in range(len(results)):
print(results[i]['word'])
# 不同于本地调用parse接口，serving返回的图像是list类型的，需要先用numpy加载再显示或保存。
cv2.imwrite('%s.jpg'%i, np.array(results[i]['visual']))
```
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install ddparser==1.0.0
```
modules/text/text_generation/CPM_LM/readme.md 0 → 100644
浏览文件 @ 9611b1db
# CPM_LM
| 模型名称 | CPM_LM |
| :------------------ | :-----------: |
| 类别 | 文本-文本生成 |
| 网络 | GPT-2 |
| 数据集 | 自建数据集 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 5.31G |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
## 一、模型基本信息
- ### 模型介绍
- CPM-LM 是一个基于 GPT-2 的预训练生成模型，参数规模达 26 亿，预训练中文数据规模 100 GB，使用了 64 块 V100 GPU，训练时间约为 3 周。能够在多种自然语言处理任务上进行零次学习或少次学习，并达到较好的效果。基于给定上文，模型可以续写出一致性高、可读性强的文本，达到现有中文生成模型的领先效果。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- sentencepiece==0.1.92
- **注意本模型对sentencepiece版本要求严格，在使用前请确认您所使用的版本是正确的**
- ```shell
$ pip install sentencepiece==0.1.92
```
- ### 2、安装
- ```shell
$ hub install CPM_LM
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- plato-mini不支持一行预测，仅支持python代码预测
- ### 1、预测代码示例
- ```python
import paddlehub as hub
model = hub.Module(name='CPM_LM') # 加载模型
```
- Note：模型参数转换至官方开源项目，由于模型较大，推荐在GPU环境下运行，并且请确保运行环境的内存大于20G且显卡显存大于12G，否则可能无法正常运行
- 使用 Greedy Search 生成文本：
- ```python
inputs = '''默写古诗:
日照香炉生紫烟，遥看瀑布挂前川。
飞流直下三千尺，'''
outputs = model.predict(inputs, max_len=10, end_word='\n')
print(inputs+outputs)
# 默写古诗:
# 日照香炉生紫烟，遥看瀑布挂前川。
# 飞流直下三千尺，疑是银河落九天。
```
- ```python
inputs = '''问题：西游记是谁写的？
答案：'''
outputs = model.predict(inputs, max_len=10, end_word='\n')
print(inputs+outputs)
# 问题:西游记是谁写的?
# 答案:吴承恩。
```
- ```python
inputs = '''小明决定去吃饭，小红继续写作业
问题：去吃饭的人是谁？
答案：'''
outputs = model.predict(inputs, max_len=10, end_word='\n')
print(inputs+outputs)
# 小明决定去吃饭,小红继续写作业
# 问题:去吃饭的人是谁?
# 答案:小明
```
- ```python
inputs = '''默写英文：
狗：dog
猫：'''
outputs = model.predict(inputs, max_len=10, end_word='\n')
print(inputs+outputs)
# 默写英文:
# 狗:dog
# 猫:cat
```
- ### 2、API
- ```python
def predict(text, max_len=32, end_word=None):
```
- 预测 API ，根据输入的文字进行文本生成，使用 Greedy Search 进行解码。
- **参数**
- text (str) : 输入文本
- max_len (int) : 生成文本的最大长度
- end_word (str or None) : 终止生成的标志词
- **返回**
- results (str): 生成的文本
- ```python
def tokenizer.encode(text):
```
- 编码 API
- **参数**
- text (str) : 输入文本
- **返回**
- results (list[int](https://www.paddlepaddle.org.cn/hubdetail?name=CPM_LM&en_category=TextGeneration)) : 输出编码
- ```python
def tokenizer.decode(ids):
```
- 解码 API
- **参数**
- ids (list[int](https://www.paddlepaddle.org.cn/hubdetail?name=CPM_LM&en_category=TextGeneration)) : 输入编码
- **返回**
- results (str) : 输出文本
- ```python
def model(x, kv_cache=None, use_cache=False):
```
- 模型前向计算 API
- **参数**
- x (tensor) : 输入编码
- kv_cache (tensor) : 输入的缓存
- use_cache (bool) : 是否使用缓存
- **返回**
- results (tensor) : 模型输出
## 四、服务部署
- PaddleHub Serving可以部署一个在线文本生成服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start --modules GPT2_CPM_LM -p 8866
```
- 这样就完成了一个对话机器人服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
text = "今天是个好日子"
data = {
"text": text,
"mode": "sample", # 'search' or 'sample'
# 可以更加需要设置上述 API 中提到的其他参数
}
url = "http://127.0.0.1:8866/predict/GPT2_CPM_LM"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
modules/text/text_generation/ernie_gen/README.md
浏览文件 @ 9611b1db
## 概述
# ernie_gen
ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。ernie_gen module是一个具备微调功能的module，可以快速完成特定场景module的制作。
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/resources/multi-flow-attention.png" hspace='10'/> <br />
</p>
更多详情参考论文[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)。
## API
```python
def finetune(
train_path,
dev_path=None,
save_dir="ernie_gen_result",
init_ckpt_path=None,
use_gpu=True,
max_steps=500,
batch_size=8,
max_encode_len=50,
max_decode_len=50,
learning_rate=5e-5,
warmup_proportion=0.1,
weight_decay=0.1,
noise_prob=0,
label_smooth=0,
beam_width=5,
length_penalty=1.0,
log_interval=100,
save_interval=200,
):
```
微调API，
**参数**
* train_path(str): 训练集路径。训练集的格式应为："序号\t输入文本\t标签"，例如："1\t床前明月光\t疑是地上霜"
* dev_path(str): 验证集路径。验证集的格式应为："序号\t输入文本\t标签"，例如："1\t举头望明月\t低头思故乡"
* save_dir(str): 模型保存以及验证集预测输出路径。
* init_ckpt_path(str): 模型初始化加载路径，可实现增量训练。
* use_gpu(bool): 是否使用GPU。
* max_steps(int): 最大训练步数。
* batch_size(int): 训练时的batch大小。
* max_encode_len(int): 最长编码长度。
* max_decode_len(int): 最长解码长度。
* learning_rate(float): 学习率大小。
* warmup_proportion(float): 学习率warmup比例。
* weight_decay(float): 权值衰减大小。
* noise_prob(float): 噪声概率，详见ernie gen论文。
* label_smooth(float): 标签平滑权重。
* beam_width(int): 验证集预测时的beam大小。
* length_penalty(float): 验证集预测时的长度惩罚权重。
* log_interval(int): 训练时的日志打印间隔步数。
* save_interval(int): 训练时的模型保存间隔部署。验证集将在模型保存完毕后进行预测。
**返回**
* result(dict): 运行结果。包含2个键:
```
last_save_path(str): 训练结束时的模型保存路径。
last_ppl(float): 训练结束时的模型困惑度。
```
```python
def export(
params_path,
module_name,
author,
max_encode_len=50,
max_decode_len=50,
version="1.0.0",
summary="",
author_email="",
export_path=".")
```
module导出API，通过此API可以一键将训练参数打包为hub module。
**参数**
* params_path(str): 模型参数路径。
* module_name(str): module名称，例如"ernie_gen_couplet"。
* author(str): 作者名称。
* max_encode_len(int): 最大编码长度。
* max_decode_len(int): 最大解码长度。
* version(str): 版本号。
* summary(str): module的英文简介。
* author_email(str): 作者的邮箱地址。
* export_path(str): module的导出路径。
**代码示例**
```python
import paddlehub as hub
module = hub.Module(name="ernie_gen")
result = module.finetune(
train_path='test_data/train.txt',
dev_path='test_data/dev.txt',
max_steps=300,
batch_size=2
)
module.export(params_path=result['last_save_path'], module_name="ernie_gen_test", author="test")
```
## 使用方式
模型转换完毕之后，通过`hub install $module_name`安装该模型，即可通过以下三种方式调用自制module：
1. 命令行预测
```shell
$ hub run $module_name --input_text="输入文本" --use_gpu True --beam_width 5
```
2. API预测
```python
import paddlehub as hub
module = hub.Module(name="$module_name")
test_texts = ["输入文本1", "输入文本2"]
# generate包含3个参数，texts为输入文本列表，use_gpu指定是否使用gpu，beam_width指定beam search宽度。
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
```
| 模型名称 | ernie_gen |
| :------------------ | :-----------: |
| 类别 | 文本-文本生成 |
| 网络 | ERNIE-GEN |
| 数据集 | - |
| 是否支持Fine-tuning | 是 |
| 模型大小 | 85K |
| 最新更新日期 | 2021-07-20 |
| 数据指标 | - |
3. 服务端部署
服务端启动模型服务：
## 一、模型基本信息
```shell
$ hub serving start -m $module_name -p 8866
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
客户端通过以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
# 发送HTTP请求
data = {'texts':["输入文本1", "输入文本2"],
'use_gpu':True, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/$module_name"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
```
**NOTE**: 上述`$module_name`为export指定的module_name。
您也可以将$module_name文件夹打包为tar.gz压缩包并联系PaddleHub工作人员上传至PaddleHub模型仓库，这样更多的用户可以通过一键安装的方式使用您的模型。PaddleHub非常欢迎您的贡献，共同推动开源社区成长。
## 查看代码
https://github.com/PaddlePaddle/ERNIE/blob/repro/ernie-gen/
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
paddlenlp >= 2.0.0
- ### 模型介绍
- ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。
- ernie_gen module是一个具备微调功能的module，可以快速完成特定场景module的制作。
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133191670-8eb1c542-f8e8-4715-adb2-6346b976fab1.png" width="600" hspace='10'/>
</p>
## 更新历史
- 更多详情请查看：[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- paddlenlp >= 2.0.0
- ### 2、安装
- ```shell
$ hub install ernie_gen
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ernie_gen需要**先针对特定数据集fine-tune**，才能使用
- 文本生成任务有很多种，ernie_gen仅提供了生成文本的基本参数，需要针对特定任务的数据集做fine-tune才能使用
- paddlehub提供了简单的fine-tune数据集：[train.txt](./test_data/train.txt), [dev.txt](./test_data/dev.txt)
- paddlehub也提供了多个fine-tune好的预训练模型：[对联生成](../ernie_gen_couplet/)，[情话生成](../ernie_gen_lover_words/)，[诗歌生成](../ernie_gen_poetry/)等
### 1、Fine-tune并封装
- #### Fine-tune代码实例
- ```python
import paddlehub as hub
module = hub.Module(name="ernie_gen")
result = module.finetune(
train_path='train.txt',
dev_path='dev.txt',
max_steps=300,
batch_size=2
)
module.export(params_path=result['last_save_path'], module_name="ernie_gen_test", author="test")
```
- #### API说明
- ```python
def finetune(train_path,
dev_path=None,
save_dir="ernie_gen_result",
init_ckpt_path=None,
use_gpu=True,
max_steps=500,
batch_size=8,
max_encode_len=15,
max_decode_len=15,
learning_rate=5e-5,
warmup_proportion=0.1,
weight_decay=0.1,
noise_prob=0,
label_smooth=0,
beam_width=5,
length_penalty=1.0,
log_interval=100,
save_interval=200):
```
- 微调模型参数的API
- **参数**
- train_path(str): 训练集路径。训练集的格式应为："序号\t输入文本\t标签"，例如："1\t床前明月光\t疑是地上霜"，注意\t不能使用空格替代
- dev_path(str): 验证集路径。验证集的格式应为："序号\t输入文本\t标签"，例如："1\t举头望明月\t低头思故乡"，注意\t不能使用空格替代
- save_dir(str): 模型保存以及验证集预测输出路径。
- init_ckpt_path(str): 模型初始化加载路径，可实现增量训练。
- use_gpu(bool): 是否使用GPU。
- max_steps(int): 最大训练步数。
- batch_size(int): 训练时的batch大小。
- max_encode_len(int): 最长编码长度。
- max_decode_len(int): 最长解码长度。
- learning_rate(float): 学习率大小。
- warmup_proportion(float): 学习率warmup比例。
- weight_decay(float): 权值衰减大小。
- noise_prob(float): 噪声概率，详见ernie gen论文。
- label_smooth(float): 标签平滑权重。
- beam_width(int): 验证集预测时的beam大小。
- length_penalty(float): 验证集预测时的长度惩罚权重。
- log_interval(int): 训练时的日志打印间隔步数。
- save_interval(int): 训练时的模型保存间隔部署。验证集将在模型保存完毕后进行预测。
- **返回**
- result(dict): 运行结果。包含2个键:
- last_save_path(str): 训练结束时的模型保存路径。
- last_ppl(float): 训练结束时的模型困惑度。
- ```python
def export(
params_path,
module_name,
author,
version="1.0.0",
summary="",
author_email="",
export_path="."):
```
- module导出API，通过此API可以一键将训练参数打包为hub module。
- **参数**
- params_path(str): 模型参数路径。
- module_name(str): module名称，例如"ernie_gen_couplet"。
- author(str): 作者名称。
- max_encode_len(int): 最大编码长度。
- max_decode_len(int): 最大解码长度
- version(str): 版本号。
- summary(str): module的英文简介。
- author_email(str): 作者的邮箱地址。
- export_path(str): module的导出路径。
### 2、模型预测
- **定义`$module_name`为export指定的module_name**
- 模型转换完毕之后，通过`hub install $module_name`安装该模型，即可通过以下2种方式调用自制module：
- #### 法1：命令行预测
- ```python
$ hub run $module_name --input_text="输入文本" --use_gpu True --beam_width 5
```
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- #### 法2：API预测
- ```python
import paddlehub as hub
module = hub.Module(name="$module_name")
test_texts = ["输入文本1", "输入文本2"]
# generate包含3个参数，texts为输入文本列表，use_gpu指定是否使用gpu，beam_width指定beam search宽度。
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
```
- 您也可以将`$module_name`文件夹打包为tar.gz压缩包并联系PaddleHub工作人员上传至PaddleHub模型仓库，这样更多的用户可以通过一键安装的方式使用您的模型。PaddleHub非常欢迎您的贡献，共同推动开源社区成长。
## 四、服务部署
- PaddleHub Serving 可以部署一个文本生成的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m $module_name -p 8866
```
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 客户端通过以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 发送HTTP请求
data = {'texts':["输入文本1", "输入文本2"],
'use_gpu':True, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/$module_name"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
```
- **NOTE:** 上述`$module_name`为export指定的module_name
## 五、更新历史
* 1.0.0
......@@ -189,8 +219,12 @@ paddlenlp >= 2.0.0
* 1.0.2
修复windows运行中的bug
修复windows运行中的bug
* 1.1.0
接入PaddleNLP
接入PaddleNLP
- ```shell
$ hub install ernie_gen==1.1.0
```
modules/text/text_generation/ernie_gen_acrostic_poetry/README.md
浏览文件 @ 9611b1db
## 概述
# ernie_gen_acrostic_poetry
ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。ernie_gen_acrostic_poetry采用开源诗歌数据集进行微调，可用于生成藏头诗。
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/resources/multi-flow-attention.png" hspace='10'/> <br />
</p>
更多详情参考论文[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
## 命令行预测
```shell
$ hub run ernie_gen_acrostic_poetry --input_text="我喜欢你" --use_gpu True --beam_width 5
```
**NOTE:** 命令行预测的方式只支持七言绝句，如需输出五言绝句、五言律诗、七言律诗，请使用API。
**参数**
* input_text: 诗歌的藏头，长度不应超过4，否则将被截断；
* use\_gpu: 是否使用 GPU；**若使用GPU，请先设置CUDA\_VISIBLE\_DEVICES环境变量**；
* beam\_width: beam search宽度，决定每个藏头输出的下文数目。
| 模型名称 | ernie_gen_acrostic_poetry |
| :------------------ | :-----------------------: |
| 类别 | 文本-文本生成 |
| 网络 | ERNIE-GEN |
| 数据集 | 开源诗歌数据集 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 1.64G |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
## API
## 一、基本信息
```python
def generate(texts, use_gpu=False, beam_width=5):
```
- ### 模型介绍
- ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。
- ernie_gen_acrostic_poetry采用开源诗歌数据集进行微调，可用于生成藏头诗。
预测API，输入诗歌藏头，输出诗歌下文。
**参数**
* texts (list\[str\]): 诗歌的藏头；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA\_VISIBLE\_DEVICES环境变量**；
* beam\_width: beam search宽度，决定每个藏头输出的下文数目。
**返回**
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133191670-8eb1c542-f8e8-4715-adb2-6346b976fab1.png" width="600" hspace='10'/>
</p>
* results (list\[list\]\[str\]): 诗歌下文，每个诗歌藏头会生成beam_width个下文。
- 更多详情请参考：[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
**代码示例**
```python
import paddlehub as hub
## 二、安装
# 在模型定义时，可以通过设置line=4或8指定输出绝句或律诗，设置word=5或7指定输出五言或七言。
# 默认line=4, word=7 即输出七言绝句。
module = hub.Module(name="ernie_gen_acrostic_poetry", line=4, word=7)
- ### 1、环境依赖
test_texts = ['我喜欢你']
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
```
- paddlepaddle >= 1.8.2
- paddlehub >= 1.7.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install ernie_gen_acrostic_poetry
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 服务部署
## 三、模型API预测
PaddleHub Serving 可以部署在线服务。
- ### 1、命令行预测
**NOTE:** 服务部署的方式只支持七言绝句，如需输出五言绝句、五言律诗、七言律诗，请使用API。
- ```shell
$ hub run ernie_gen_acrostic_poetry --input_text="我喜欢你" --use_gpu True --beam_width 5
```
- **NOTE:** 命令行预测的方式只支持七言绝句，如需输出五言绝句、五言律诗、七言律诗，请使用API。
- **参数**
- input_text: 诗歌的藏头，长度不应超过4，否则将被截断；
- use_gpu: 是否采用GPU进行预测；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
- beam_width: beam search宽度，决定每个藏头输出的下文数目。
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
### 第一步：启动PaddleHub Serving
- ### 2、预测代码示例
运行启动命令：
```shell
$ hub serving start -m ernie_gen_acrostic_poetry -p 8866
```
- ```python
import paddlehub as hub
# 在模型定义时，可以通过设置line=4或8指定输出绝句或律诗，设置word=5或7指定输出五言或七言。
# 默认line=4, word=7 即输出七言绝句。
module = hub.Module(name="ernie_gen_acrostic_poetry", line=4, word=7)
test_texts = ['我喜欢你']
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
# ['我方治地种秋芳，喜见新花照眼黄。欢友相逢头白尽，你缘何事得先尝。', '我今解此如意珠，喜汝为我返魂无。欢声百里镇如席，你若来时我自有。', '我今解此如意珠，喜汝为我返魂无。欢声百里镇如席，你若来时我自孤。', '我今解此如意珠，喜汝为我返魂无。欢声百里镇如席，你若来时我自如。', '我方治地种秋芳，喜见新花照眼黄。欢友相逢头白尽，你缘何事苦生凉。']
```
这样就完成了一个服务化API的部署，默认端口号为8866。
- ### 3、API
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ```python
hub.Module(name="ernie_gen_acrostic_poetry", line=4, word=7)
```
### 第二步：发送预测请求
- 在模型定义时，可以通过设置line=4或8指定输出绝句或律诗，设置word=5或7指定输出五言或七言。
- 默认line=4, word=7 即输出七言绝句。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
def generate(texts, use_gpu=False, beam_width=5):
```
```python
import requests
import json
- 预测API，输入诗歌藏头，输出诗歌下文。
- **参数**
- texts (list[str]): 诗歌的藏头；
- use_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
- beam_width: beam search宽度，决定每个藏头输出的下文数目。
- **返回**
- results (list[list]\[str]): 诗歌下文，每个诗歌藏头会生成beam_width个下文。
# 发送HTTP请求
data = {'texts':['我喜欢你'],
'use_gpu':True, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_gen_acrostic_poetry"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
## 四、服务部署
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
```
- PaddleHub Serving可以部署一个在线诗歌生成服务，可以将此接口用于在线web应用。
## 查看代码
- **NOTE:** 服务部署的方式只支持七言绝句，如需输出五言绝句、五言律诗、七言律诗，请使用API。
https://github.com/PaddlePaddle/ERNIE/blob/repro/ernie-gen/
- ### 第一步：启动PaddleHub Serving
### 依赖
- 运行启动命令：
- ```shell
$ hub serving start -m ernie_gen_acrostic_poetry -p 8866
```
paddlepaddle >= 2.0.0
- 这样就完成了一个服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
paddlehub >= 2.0.0
paddlenlp >= 2.0.0
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
## 更新历史
- ```python
import requests
import json
# 发送HTTP请求
data = {'texts':['我喜欢你'],
'use_gpu':True, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_gen_acrostic_poetry"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
# serving运行结果同本地运行结果（见上）
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
......@@ -116,6 +146,11 @@ paddlenlp >= 2.0.0
完善API的输入文本检查
* 1.1.0
- 1.1.0
接入PaddleNLP
- ```shell
$ hub install ernie_gen_poetry==1.1.0
```
modules/text/text_generation/ernie_gen_couplet/README.md
浏览文件 @ 9611b1db
## 概述
# ernie_gen_couplet
ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。ernie_gen_couplet采用开源对联数据集进行微调，可用于生成下联。
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/resources/multi-flow-attention.png" hspace='10'/> <br />
</p>
更多详情参考论文[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
## 命令行预测
```shell
$ hub run ernie_gen_couplet --input_text="人增福寿年增岁" --use_gpu True --beam_width 5
```
## API
```python
def generate(texts, use_gpu=False, beam_width=5):
```
预测API，由上联生成下联。
| 模型名称 | ernie_gen_couplet |
| :------------------ | :---------------: |
| 类别 | 文本-文本生成 |
| 网络 | ERNIE-GEN |
| 数据集 | 开源对联数据集 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 421M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
**参数**
## 一、模型基本信息
* texts (list\[str\]): 上联文本；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA\_VISIBLE\_DEVICES环境变量**；
* beam\_width: beam search宽度，决定每个上联输出的下联数量。
- 模型介绍
- ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。
- ernie_gen_couplet采用开源对联数据集进行微调，输入上联，可生成下联。
**返回**
* results (list\[list\]\[str\]): 下联文本，每个上联会生成beam_width个下联。
**代码示例**
```python
import paddlehub as hub
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133191670-8eb1c542-f8e8-4715-adb2-6346b976fab1.png" width="600" hspace='10'/>
</p>
module = hub.Module(name="ernie_gen_couplet")
- 更多详情请参考：[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
## 二、安装
- ### 1、环境依赖
test_texts = ["人增福寿年增岁", "风吹云乱天垂泪"]
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
```
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- paddlenlp >= 2.0.0
## 服务部署
- ### 2、安装
PaddleHub Serving 可以部署在线服务。
- ```shell
$ hub install ernie_gen_couplet
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
### 第一步：启动PaddleHub Serving
## 三、模型API预测
运行启动命令：
```shell
$ hub serving start -m ernie_gen_couplet -p 8866
```
- ### 1、命令行预测
这样就完成了一个服务化API的部署，默认端口号为8866。
- ```shell
$ hub run ernie_gen_couplet --input_text="人增福寿年增岁" --use_gpu True --beam_width 5
```
- input_text: 上联文本
- use_gpu: 是否采用GPU进行预测
- beam_width: beam search宽度，决定每个上联输出的下联数量。
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 2、预测代码示例
### 第二步：发送预测请求
- ```python
import paddlehub as hub
module = hub.Module(name="ernie_gen_couplet")
test_texts = ["人增福寿年增岁", "风吹云乱天垂泪"]
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
# ['春满乾坤喜满门', '竹报平安梅报春', '春满乾坤福满门', '春满乾坤酒满樽', '春满乾坤喜满家']
# ['雨打花残地痛心', '雨打花残地皱眉', '雨打花残地动容', '雨打霜欺地动容', '雨打花残地洒愁']
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ### 3、API
```python
import requests
import json
- ```python
def generate(texts, use_gpu=False, beam_width=5):
```
# 发送HTTP请求
- 预测API，由上联生成下联。
- **参数**
- texts (list[str]): 上联文本；
- use_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
- beam_width: beam search宽度，决定每个上联输出的下联数量。
- **返回**
- results (list[list]\[str]): 下联文本，每个上联会生成beam_width个下联。
data = {'texts':["人增福寿年增岁", "风吹云乱天垂泪"],
'use_gpu':False, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_gen_couplet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
```
## 四、服务部署
## 查看代码
- PaddleHub Serving可以部署一个在线对联生成服务，可以将此接口用于在线web应用。
https://github.com/PaddlePaddle/ERNIE/blob/repro/ernie-gen/
- ### 第一步：启动PaddleHub Serving
### 依赖
- 运行启动命令：
- ```shell
$ hub serving start -m ernie_gen_couplet -p 8866
```
paddlepaddle >= 2.0.0
- 这样就完成了一个服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
paddlehub >= 2.0.0
paddlenlp >= 2.0.0
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
## 更新历史
- ```python
import requests
import json
# 发送HTTP请求
data = {'texts':["人增福寿年增岁", "风吹云乱天垂泪"],
'use_gpu':False, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_gen_couplet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
# ['春满乾坤喜满门', '竹报平安梅报春', '春满乾坤福满门', '春满乾坤酒满樽', '春满乾坤喜满家']
# ['雨打花残地痛心', '雨打花残地皱眉', '雨打花残地动容', '雨打霜欺地动容', '雨打花残地洒愁']
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
......@@ -107,7 +138,11 @@ paddlenlp >= 2.0.0
* 1.0.2
完善API的输入文本检查
* 1.1.0
接入PaddleNLP
修复兼容性问题
* ```shell
$ hub install ernie_gen_couplet==1.1.0
```
modules/text/text_generation/ernie_gen_lover_words/README.md
浏览文件 @ 9611b1db
## 概述
# ernie_gen_lover_words
ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。ernie_gen_lover_words采用网络搜集的情诗、情话数据微调，可用于生成情话。
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/resources/multi-flow-attention.png" hspace='10'/> <br />
</p>
更多详情参考论文[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
## 命令行预测
```shell
$ hub run ernie_gen_lover_words --input_text="情人节" --use_gpu True --beam_width 5
```
## API
```python
def generate(texts, use_gpu=False, beam_width=5):
```
预测API，输入情话开头，输出情话下文。
**参数**
* texts (list\[str\]): 情话的开头；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA\_VISIBLE\_DEVICES环境变量**；
* beam\_width: beam search宽度，决定每个情话开头输出的下文数目。
**返回**
* results (list\[list\]\[str\]): 情话下文，每个情话开头会生成beam_width个下文。
**代码示例**
```python
import paddlehub as hub
module = hub.Module(name="ernie_gen_lover_words")
test_texts = ['情人节', '故乡', '小编带大家了解一下程序员情人节']
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
```
## 服务部署
PaddleHub Serving 可以部署在线服务。
| 模型名称 | ernie_gen_lover_words |
| :------------------ | :-------------------: |
| 类别 | 文本-文本生成 |
| 网络 | ERNIE-GEN |
| 数据集 | 网络情诗、情话数据 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 420M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
### 第一步：启动PaddleHub Serving
## 一、模型基本信息
运行启动命令：
```shell
$ hub serving start -m ernie_gen_lover_words -p 8866
```
这样就完成了一个服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
# 发送HTTP请求
data = {'texts':['情人节', '故乡', '小编带大家了解一下程序员情人节'],
'use_gpu':False, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_gen_lover_words"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
```
## 查看代码
https://github.com/PaddlePaddle/ERNIE/blob/repro/ernie-gen/
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
paddlenlp >= 2.0.0
- ### 模型介绍
- ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。
- ernie_gen_lover_words采用网络搜集的情诗、情话数据微调，可用于生成情话。
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133191670-8eb1c542-f8e8-4715-adb2-6346b976fab1.png" width="600" hspace='10'/>
</p>
## 更新历史
- 更多详情请参考：[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.8.2
- paddlehub >= 1.7.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install ernie_gen_lover_words
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run ernie_gen_lover_words --input_text "情人节" --use_gpu True --beam_width 5
```
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
module = hub.Module(name="ernie_gen_lover_words")
test_texts = ['情人节', '故乡', '小编带大家了解一下程序员情人节']
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
# '情人节，我愿做一条鱼，任你红烧、白煮、清蒸，然后躺在你温柔的胃里。', '情人节，对你的思念太重，压断了电话线，烧坏了手机卡，掏尽了钱包袋，吃光了安眠药，哎!可我还是思念你。', '情人节，对你的思念太重，压断了电话线，烧坏了手机卡，掏尽了钱包袋，吃光了安眠药，哎!可我还是思念你，祝你情人节快乐!', '情人节，对你的思念太重，压断了电话线，烧坏了手机卡，掏尽了钱包袋，吃光了安眠药，唉!可我还是思念你，祝你情人节快乐!', '情人节，对你的思念太重，压断了电话线，烧坏了手机卡，掏尽了钱包袋，吃光了安眠药，哎!可是我还是思念你。']
# ['故乡，是深秋的雨，云雾缭绕，夏日的阳光照耀下，像一只只翅膀，那就是思念。', '故乡，是深秋的雨，是诗人们吟咏的乡村序曲，但愿天下有情人，一定难忘。', '故乡，是深秋的雨，是诗人们吟咏的一篇美丽的诗章，但愿天下有情人，都一定走进了蒙蒙细雨中。', '故乡，是深秋的雨，是诗人们吟咏的一篇美丽的诗章，但愿天下有情人，都一定走进了蒙蒙的细雨，纷纷而来。', '故乡，是深秋的雨，是诗人们吟咏的一篇美丽的诗章，但愿天下有情人，都一定走进了蒙蒙的细雨中。']
# ['小编带大家了解一下程序员情人节，没有人会悄悄的下载数据库，没有人会升级!希望程序可以好好的工作!', '小编带大家了解一下程序员情人节，没有人会悄悄的下载数据库，没有人会升级!希望程序可以重新拥有!', '小编带大家了解一下程序员情人节，没有人会悄悄的下载数据库，没有人会升级!希望程序可以好好的工作。', '小编带大家了解一下程序员情人节，没有人会悄悄的下载数据库，没有人会升级!希望程序可以重新把我们送上。', '小编带大家了解一下程序员情人节，没有人会悄悄的下载数据库，没有人会升级!希望程序可以重新把我们送上!']
```
- ### 3、API
- ```python
def generate(texts, use_gpu=False, beam_width=5):
```
- 预测API，输入情话开头，输出情话下文。
- **参数**
- texts(list[str]):情话的开头
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- beam_width: beam search宽度，决定每个情话开头输出的下文数目
- **返回**
- results(list[list]\[str]): 情话下文，每个情话开头会生成beam_width个下文
## 四、服务部署
- PaddleHub Serving可以部署一个在线文本生成服务，可以将此接口用于在线web应用。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m ernie_gen_lover_words -p 8866
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 发送HTTP请求
data = {'texts':['情人节', '故乡', '小编带大家了解一下程序员情人节'],
'use_gpu':False, 'beam_width':5}
headers = {"Content-type": "application/json"}
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/ernie_gen_lover_words"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
......@@ -103,7 +131,7 @@ paddlenlp >= 2.0.0
* 1.0.1
完善API的输入文本检查
* 1.1.0
接入PaddleNLP
- ```shell
$ hub install ernie_gen_lover_words==1.0.1
```
modules/text/text_generation/ernie_gen_poetry/README.md
浏览文件 @ 9611b1db
## 概述
# ernie_gen_poetry
ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。ernie_gen_poetry采用开源诗歌数据集进行微调，可用于生成诗歌。
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/resources/multi-flow-attention.png" hspace='10'/> <br />
</p>
更多详情参考论文[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
## 命令行预测
```shell
$ hub run ernie_gen_poetry --input_text="昔年旅南服，始识王荆州。" --use_gpu True --beam_width 5
```
## API
| 模型名称 | ernie_gen_poetry |
| :------------------ | :--------------: |
| 类别 | 文本-文本生成 |
| 网络 | ERNIE-GEN |
| 数据集 | 开源诗歌数据集 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 422M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
```python
def generate(texts, use_gpu=False, beam_width=5):
```
## 一、模型基本信息
预测API，输入诗歌开头，输出诗歌下文。
- 模型介绍
- ERNIE-GEN 是面向生成任务的预训练-微调框架，首次在预训练阶段加入span-by-span 生成任务，让模型每次能够生成一个语义完整的片段。在预训练和微调中通过填充式生成机制和噪声感知机制来缓解曝光偏差问题。此外, ERNIE-GEN 采样多片段-多粒度目标文本采样策略, 增强源文本和目标文本的关联性，加强了编码器和解码器的交互。
- ernie_gen_poetry采用开源诗歌数据集进行微调，可用于生成诗歌。
**参数**
* texts (list\[str\]): 诗歌的开头；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA\_VISIBLE\_DEVICES环境变量**；
* beam\_width: beam search宽度，决定每个诗歌开头输出的下文数目。
**返回**
* results (list\[list\]\[str\]): 诗歌下文，每个诗歌开头会生成beam_width个下文。
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133191670-8eb1c542-f8e8-4715-adb2-6346b976fab1.png" width="600" hspace='10'/>
</p>
**代码示例**
- 更多详情请参考：[ERNIE-GEN:An Enhanced Multi-Flow Pre-training and Fine-tuning Framework for Natural Language Generation](https://arxiv.org/abs/2001.11314)
```python
import paddlehub as hub
module = hub.Module(name="ernie_gen_poetry")
## 二、安装
- ### 1、环境依赖
test_texts = ['昔年旅南服，始识王荆州。', '高名出汉阴，禅阁跨香岑。']
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
```
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- paddlenlp >= 2.0.0
## 服务部署
- ### 2、安装
PaddleHub Serving 可以部署在线服务。
- ```shell
$ hub install ernie_gen_poetry
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
### 第一步：启动PaddleHub Serving
## 三、模型API预测
运行启动命令：
```shell
$ hub serving start -m ernie_gen_poetry -p 8866
```
- ### 1、命令行预测
这样就完成了一个服务化API的部署，默认端口号为8866。
- ```shell
$ hub run ernie_gen_poetry --input_text="昔年旅南服，始识王荆州。" --use_gpu True --beam_width 5
```
- input_text: 诗歌的开头。
- use_gpu: 是否采用GPU进行预测。
- beam_width: beam search宽度，决定每个诗歌开头输出的下文数目。
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 2、预测代码示例
### 第二步：发送预测请求
- ```python
import paddlehub as hub
module = hub.Module(name="ernie_gen_poetry")
test_texts = ['昔年旅南服，始识王荆州。', '高名出汉阴，禅阁跨香岑。']
results = module.generate(texts=test_texts, use_gpu=True, beam_width=5)
for result in results:
print(result)
# ['一见便倾盖，论交更绸缪。别来二十年，日月如奔流。人生会合难，俯仰成春秋。', '一见便倾盖，论交更绸缪。别来二十年，日月如奔流。人生会合难，况乃岁月遒。君家富文史，我老无田畴。相逢不相识，各在天一陬。人生百年内，聚散如浮沤。况我与夫子，相逢', '一见便倾盖，论交更绸缪。别来二十年，日月如奔流。人生会合难，况乃岁月遒。君家富文史，我老无田畴。相逢不相识，各在天一陬。人生百年内，聚散如浮沤。况我与君别，飘零', '一见便倾盖，论交更绸缪。别来二十年，日月如奔流。人生会合难，况乃岁月遒。君家富文史，我老无田畴。相逢不相识，各在天一陬。人生百年内，聚散如浮沤。况复各异乡，各在', '一见便倾盖，论交更绸缪。别来二十年，日月如奔流。人生会合难，况乃岁月遒。君家富文史，我老无田畴。相逢不相识，各在天一陬。人生百年内，聚散如浮沤。况复各异乡，风雨']
# ['地僻无尘到，山高见水深。钟声传远寺，塔影落前林。欲问西来意，庭前柏树林。', '地僻无尘到，山高见水深。钟声传远寺，塔影落前林。欲问西来意，庭前柏树阴。', '地僻无尘到，山高见水深。钟声传远寺，塔影落前林。欲问西来意，庭前有桂林。', '地僻无尘到，山高见水深。钟声传远寺，塔影落前林。欲问西来意，庭前柏正森。', '地僻无尘到，山高见水深。钟声传远寺，塔影落前林。欲问西来意，庭前有桂阴。']
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ### 3、API
```python
import requests
import json
- ```python
def generate(texts, use_gpu=False, beam_width=5):
```
# 发送HTTP请求
- 预测API，输入诗歌开头，输出诗歌下文。
- **参数**
- texts (list[str]): 诗歌的开头；
- use_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
- beam_width: beam search宽度，决定每个诗歌开头输出的下文数目。
- **返回**
- results (list[list]\[str]): 诗歌下文，每个诗歌开头会生成beam_width个下文。
data = {'texts':['昔年旅南服，始识王荆州。', '高名出汉阴，禅阁跨香岑。'],
'use_gpu':False, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_gen_poetry"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
```
## 四、服务部署
## 查看代码
- PaddleHub Serving可以部署一个在线诗歌生成服务，可以将此接口用于在线web应用。
https://github.com/PaddlePaddle/ERNIE/blob/repro/ernie-gen/
- ### 第一步：启动PaddleHub Serving
### 依赖
- 运行启动命令：
- ```shell
$ hub serving start -m ernie_gen_poetry -p 8866
```
paddlepaddle >= 2.0.0
- 这样就完成了一个服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
paddlehub >= 2.0.0
paddlenlp >= 2.0.0
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
## 更新历史
- ```python
import requests
import json
# 发送HTTP请求
data = {'texts':['昔年旅南服，始识王荆州。', '高名出汉阴，禅阁跨香岑。'],
'use_gpu':False, 'beam_width':5}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ernie_gen_poetry"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存结果
results = r.json()["results"]
for result in results:
print(result)
# serving运行结果同本地运行结果（见上）
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
......@@ -108,6 +139,10 @@ paddlenlp >= 2.0.0
完善API的输入文本检查
* 1.1.0
- 1.1.0
修复兼容性问题
接入PaddleNLP
- ```shell
$ hub install ernie_gen_poetry==1.1.0
```
modules/text/text_generation/plato-mini/README.md
浏览文件 @ 9611b1db
```shell
$ hub install plato_mini==1.0.0
```
## 概述
近年来，人机对话系统受到了学术界和产业界的广泛关注并取得了不错的发展。开放域对话系统旨在建立一个开放域的多轮对话系统，使得机器可以流畅自然地与人进行语言交互，既可以进行日常问候类的闲聊，又可以完成特定功能，以使得开放域对话系统具有实际应用价值。具体的说，开放域对话可以继续拆分为支持不同功能的对话形式，例如对话式推荐，知识对话技术等，如何解决并有效融合以上多个技能面临诸多挑战。
[UnifiedTransformer](https://arxiv.org/abs/2006.16779)以[Transformer](https://arxiv.org/abs/1706.03762) 编码器为网络基本组件，采用灵活的注意力机制，十分适合文本生成任务，并在模型输入中加入了标识不同对话技能的special token，使得模型能同时支持闲聊对话、推荐对话和知识对话。
plato_mini包含6层的transformer结构，头数为12，隐藏层参数为768，参数量为89M。该模型在十亿级别的中文对话数据上进行预训练，通过PaddleHub加载后可直接用于对话任务。
## API
```python
def predict(data: Union[List[List[str]], str],
max_seq_len: int = 512,
batch_size: int = 1,
use_gpu: bool = False,
**kwargs):
```
预测API，输入对话上下文，输出机器回复。
**参数**
- `data`(Union[List[List[str]], str]): 在非交互模式中，数据类型为List[List[str]]，每个样本是一个List[str]，表示为对话内容
- `max_seq_len`(int): 每个样本的最大文本长度
- `batch_size`(int): 进行预测的batch_size
- `use_gpu`(bool): 是否使用gpu执行预测
- `kwargs`: 预测时传给模型的额外参数，以keyword方式传递。其余的参数详情请查看[UnifiedTransformer](https://github.com/PaddlePaddle/PaddleNLP/tree/develop/examples/dialogue/unified_transformer)。
**返回**
* `results`(List[str]): 每个元素为相应对话中模型的新回复
```python
def interactive_mode(max_turn=3)
```
进入交互模式。交互模式中，predict接口的data将支持字符串类型。
**参数**
- `max_turn`(int): 模型能记忆的对话轮次，当`max_turn`为1时，模型只能记住当前对话，无法获知之前的对话内容。
**代码示例**
```python
# 非交互模式
import paddlehub as hub
model = hub.Module(name='plato_mini')
data = [["你是谁？"], ["你好啊。", "吃饭了吗？",]]
result = model.predict(data)
```
```python
# 交互模式
import paddlehub as hub
model = hub.Module(name='plato_mini')
with model.interactive_mode(max_turn=3):
while True:
human_utterance = input("[Human]: ").strip()
robot_utterance = model.predict(human_utterance)[0]
print("[Bot]: %s"%robot_utterance)
```
## 服务部署
PaddleHub Serving可以部署在线服务。
### Step1: 启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m plato_mini
```
这样就完成了一个对话机器人服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
texts = [["今天是个好日子"], ["天气预报说今天要下雨"]]
data = {"data": texts}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/plato_mini"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 查看代码
https://github.com/PaddlePaddle/Knover
## 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.1.0
## 更新历史
# plato-mini
| 模型名称 | plato-mini |
| :------------------ | :--------------------: |
| 类别 | 文本-文本生成 |
| 网络 | Unified Transformer |
| 数据集 | 十亿级别的中文对话数据 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 5.28K |
| 最新更新日期 | 2021-06-30 |
| 数据指标 | - |
## 一、模型基本信息
- ### 模型介绍
- [UnifiedTransformer](https://arxiv.org/abs/2006.16779)以[Transformer](https://arxiv.org/abs/1706.03762) 编码器为网络基本组件，采用灵活的注意力机制，十分适合文本生成任务，并在模型输入中加入了标识不同对话技能的special token，使得模型能同时支持闲聊对话、推荐对话和知识对话。
该模型在十亿级别的中文对话数据上进行预训练，通过PaddleHub加载后可直接用于对话任务，仅支持中文对话。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.1.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install plato-mini
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- plato-mini不支持一行预测，仅支持python代码预测
- ### 1、预测代码示例
- ```python
# 非交互模式
import paddlehub as hub
model = hub.Module(name='plato-mini')
data = [["你是谁？"], ["你好啊。", "吃饭了吗？",]]
result = model.predict(data)
print(result)
# ['我是一个小角色,我是在玩游戏', '吃过了呢,你吃了没?']
# 每次的运行结果可能有所不同
```
- ```python
# 交互模式
# 使用命令行与机器人对话
import paddlehub as hub
import readline
model = hub.Module(name='plato-mini')
with model.interactive_mode(max_turn=3):
while True:
human_utterance = input("[Human]: ").strip()
robot_utterance = model.predict(human_utterance)[0]
print("[Bot]: %s"%robot_utterance)
```
- ### 2、API
- ```python
def predict(data, max_seq_len=512, batch_size=1, use_gpu=False, **kwargs):
```
- 预测API，输入对话上下文，输出机器回复。
- **参数**
- data(Union[List[List[str](https://www.paddlepaddle.org.cn/hubdetail?name=plato-mini&en_category=TextGeneration)], str]): 在非交互模式中，数据类型为List[List[str](https://www.paddlepaddle.org.cn/hubdetail?name=plato-mini&en_category=TextGeneration)]，每个样本是一个List[str](https://www.paddlepaddle.org.cn/hubdetail?name=plato-mini&en_category=TextGeneration)，表示为对话内容
- max_seq_len(int): 每个样本的最大文本长度
- batch_size(int): 进行预测的batch_size
- use_gpu(bool): 是否使用gpu执行预测
- kwargs: 预测时传给模型的额外参数，以keyword方式传递。其余的参数详情请查看[UnifiedTransformer](https://github.com/PaddlePaddle/PaddleNLP/tree/develop/examples/dialogue/unified_transformer)。
- **返回**
- results(List[str](https://www.paddlepaddle.org.cn/hubdetail?name=plato-mini&en_category=TextGeneration)): 每个元素为相应对话中模型的新回复
- ```python
def interactive_mode(max_turn=3):
```
- 配置交互模式并进入。
- **参数**
- max_turn(int): 模型能记忆的对话轮次，当max_turn为1时，模型只能记住当前对话，无法获知之前的对话内容。
## 四、服务部署
- PaddleHub Serving可以部署一个在线对话机器人服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m plato-mini -p 8866
```
- 这样就完成了一个对话机器人服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
texts = [["今天是个好日子"], ["天气预报说今天要下雨"]]
data = {"data": texts}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/plato_mini"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
# {'msg': '', 'results': ['是个好日子啊!', '下雨就不出门了,在家宅着吧'], 'status': '000'}
# 每次的运行结果可能有所不同
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install plato-mini==1.0.0
```
modules/text/text_generation/reading_pictures_writing_poems/readme.md 0 → 100644
浏览文件 @ 9611b1db
# reading_pictures_writing_poems
| 模型名称 | reading_pictures_writing_poems |
| :------------------ | :----------------------------: |
| 类别 | 文本-文本生成 |
| 网络 | 多网络级联 |
| 数据集 | - |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 3.16K |
| 最新更新日期 | 2021-04-26 |
| 数据指标 | - |
## 一、模型基本信息
- ### 应用效果展示
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133189274-ff86801f-017f-460e-adb0-1d381d74aff6.jpg" width="300">
</p>
- 输入以上图片生成的古诗是：
- 蕾蕾海河海，岳峰岳麓蔓。
- 不萌枝上春，自结心中线。
- ### 模型介绍
- 看图写诗（reading_pictures_writing_poems），该模型可自动根据图像生成古诗词。该PaddleHub Module支持预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.8.2
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- translate
- ```shell
$ pip install translate
```
- ### 2、安装
- ```shell
$ hub install reading_pictures_writing_poems
```
- 本模型还需要用到xception71_imagenet, ernie_gen_couplet, ernie_gen_poetry这3个模型
- 若您未安装这3个模型，代码运行时会自动帮您下载
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run reading_pictures_writing_poems --input_image "scenery.jpg"
```
- ### 2、预测代码示例
- ```python
import paddlehub as hub
readingPicturesWritingPoems = hub.Module(name="reading_pictures_writing_poems")
results = readingPicturesWritingPoems.WritingPoem(image = "scenery.jpg", use_gpu=False)
for result in results:
print(result)
```
- ### 3、API
- ```python
def WritingPoem(image, use_gpu=False):
```
- 看图写诗预测接口，预测输入一张图像，输出一首古诗词
- **参数**
- image(str): 待检测的图片路径
- use_gpu (bool): 是否使用 GPU
- **返回**
- results (list[dict](https://www.paddlepaddle.org.cn/hubdetail?name=reading_pictures_writing_poems&en_category=TextGeneration)): 识别结果的列表，列表中每一个元素为 dict，关键字有 image，Poetrys， 其中： image字段为原输入图片的路径，Poetrys字段为输出的古诗词
## 四、服务部署
- 本模型不支持hub serving
## 五、更新历史
* 1.0.0
初始发布
modules/text/text_review/porn_detection_lstm/README.md
浏览文件 @ 9611b1db
# PornDetectionLSTM API说明
## detection(texts=[], data={}, use_gpu=False, batch_size=1)
porn_detection_lstm预测接口，鉴定输入句子是否为包含色情文案
**参数**
* texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
* data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
**返回**
* results(list): 鉴定结果
## context(trainable=False)
获取porn_detection_lstm的预训练program以及program的输入输出变量
**参数**
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变
**返回**
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
## get_labels()
获取porn_detection_lstm的类别
**返回**
* labels(dict): porn_detection_lstm的类别
## get_vocab_path()
获取预训练时使用的词汇表
**返回**
* vocab_path(str): 词汇表路径
# PornDetectionLSTM 服务部署
PaddleHub Serving可以部署一个在线色情文案检测服务，可以将此接口用于在线web应用。
## 第一步：启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m porn_detection_lstm
```
启动时会显示加载模型过程，启动成功后显示
```shell
Loading porn_detection_lstm successful.
```
这样就完成了服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
# 待预测数据
text = ["黄片下载", "打击黄牛党"]
# 设置运行配置
# 对应本地预测porn_detection_lstm.detection(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为porn_detection_lstm并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/porn_detection_lstm"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
# porn_detection_lstm
| 模型名称 | senta_bilstm |
| :------------------ | :------------: |
| 类别 | 文本-文本审核 |
| 网络 | LSTM |
| 数据集 | 百度自建数据集 |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 1M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | - |
## 一、模型基本信息
- ### 模型介绍
- 色情检测模型可自动判别文本是否涉黄并给出相应的置信度，对文本中的色情描述、低俗交友、污秽文案进行识别。
- porn_detection_lstm采用LSTM网络结构并按字粒度进行切词，具有较高的分类精度。该模型最大句子长度为256字，仅支持预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install porn_detection_lstm
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run porn_detection_lstm --input_text "黄片下载"
```
- 或者
- ```shell
$ hub run porn_detection_lstm --input_file test.txt
```
- 其中test.txt存放待审查文本，每行仅放置一段待审核文本
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
porn_detection_lstm = hub.Module(name="porn_detection_lstm")
test_text = ["黄片下载", "打击黄牛党"]
results = porn_detection_lstm.detection(texts=test_text, use_gpu=True, batch_size=1)
for index, text in enumerate(test_text):
results[index]["text"] = text
for index, result in enumerate(results):
print(results[index])
# 输出结果如下：
# {'text': '黄片下载', 'porn_detection_label': 1, 'porn_detection_key': 'porn', 'porn_probs': 0.9879, 'not_porn_probs': 0.0121}
# {'text': '打击黄牛党', 'porn_detection_label': 0, 'porn_detection_key': 'not_porn', 'porn_probs': 0.0004, 'not_porn_probs': 0.9996}
```
- ### 3、API
- ```python
def detection(texts=[], data={}, use_gpu=False, batch_size=1):
```
- porn_detection_lstm预测接口，鉴定输入句子是否为黄文
- **参数**
- texts(list[str]): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测
- batch_size(int): 批处理大小
- **返回**
- results(list): 鉴定结果
- ```python
def context(trainable=False):
```
- 获取porn_detection_lstm的预训练program以及program的输入输出变量
- **参数**
- trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变。
- **返回**
- inputs(dict): program的输入变量
- outputs(dict): program的输出变量
- main_program(Program): 带有预训练参数的program
- ```python
def get_labels():
```
- 获取porn_detection_lstm的可识别的类别及其编号
- **返回**
- labels(dict): porn_detection_lstm的类别及其对应编号(二分类，是/不是)
- ```python
def get_vocab_path():
```
- 获取预训练时使用的词汇表
- **返回**
- vocab_path(str): 词汇表路径
## 四、服务部署
- PaddleHub Serving可以部署一个在线色情文案检测服务，可以将此接口用于在线web应用。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m porn_detection_lstm -p 8866
```
- 这样就完成了服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 待预测数据
text = ["黄片下载", "打击黄牛党"]
# 设置运行配置
# 对应本地预测porn_detection_lstm.detection(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
# 指定预测方法为porn_detection_lstm并发送post请求，content-type类型应指定json方式
# HOST_IP为服务器IP
url = "http://HOST_IP:8866/predict/porn_detection_lstm"
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(json.dumps(r.json(), indent=4, ensure_ascii=False))
```
- 关于PaddleHub Serving更多信息参考[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
大幅提升预测性能，同时简化接口使用
- ```shell
$ hub install porn_detection_lstm==1.1.0
```
modules/video/classification/videotag_tsn_lstm/README.md
浏览文件 @ 9611b1db
```shell
$ hub install videotag_tsn_lstm==1.0.0
```
![image](https://paddlehub.bj.bcebos.com/model/video/video_classifcation/VideoTag_TSN_AttentionLSTM.png)
# videotag_tsn_lstm
具体网络结构可参考论文[TSN](https://arxiv.org/abs/1608.00859)和[AttentionLSTM](https://arxiv.org/abs/1503.08909)。
|模型名称|videotag_tsn_lstm|
| :--- | :---: |
|类别|视频-视频分类|
|网络|TSN + AttentionLSTM|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|409MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## 命令行预测示例
```shell
hub run videotag_tsn_lstm --input_path 1.mp4 --use_gpu False
```
示例文件下载：
* [1.mp4](https://paddlehub.bj.bcebos.com/model/video/video_classifcation/1.mp4)
* [2.mp4](https://paddlehub.bj.bcebos.com/model/video/video_classifcation/2.mp4)
## API
```python
def classify(paths,
use_gpu=False,
threshold=0.5,
top_k=10)
```
用于视频分类预测
## 一、模型基本信息
**参数**
- ### 模型介绍
* paths(list\[str\])：mp4文件路径
* use_gpu(bool)：是否使用GPU预测，默认为False
* threshold(float)：预测结果阈值，只有预测概率大于阈值的类别会被返回，默认为0.5
* top_k(int): 返回预测结果的前k个，默认为10
- videotag_tsn_lstm是一个基于千万短视频预训练的视频分类模型，可直接预测短视频的中文标签。模型分为视频特征抽取和序列建模两个阶段，前者使用TSN网络提取视频特征，后者基于前者输出使用AttentionLSTM网络进行序列建模实现分类。模型基于百度实际短视频场景中的大规模数据训练得到，在实际业务中取得89.9%的Top-1精度，同时具有良好的泛化能力，适用于多种短视频中文标签分类场景。该PaddleHub Module可支持预测。
**返回**
* results(list\[dict\]): result中的每个元素为对应输入的预测结果，预测单个mp4文件时仅有1个元素。每个预测结果为dict，包含mp4文件路径path及其分类概率。例：
```shell
[{'path': '1.mp4', 'prediction': {'训练': 0.9771281480789185, '蹲': 0.9389840960502625, '杠铃': 0.8554490804672241, '健身房': 0.8479971885681152}}, {'path': '2.mp4', 'prediction': {'舞蹈': 0.8504238724708557}}]
```
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/model/video/video_classifcation/VideoTag_TSN_AttentionLSTM.png" width = "450" hspace='10'/> <br />
</p>
**代码示例**
- 具体网络结构可参考论文：[TSN](https://arxiv.org/abs/1608.00859) 和 [AttentionLSTM](https://arxiv.org/abs/1503.08909)。
```python
import paddlehub as hub
videotag = hub.Module(name="videotag_tsn_lstm")
# execute predict and print the result
results = videotag.classify(paths=["1.mp4","2.mp4"], use_gpu=True)
print(results)
```
## 二、安装
## 依赖
- ### 1、环境依赖
paddlepaddle >= 1.7.2
- paddlepaddle >= 1.7.2
- paddlehub >= 1.6.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
paddlehub >= 1.6.0
- ### 2、安装
## 更新历史
- ```shell
$ hub install videotag_tsn_lstm
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
hub run videotag_tsn_lstm --input_path 1.mp4 --use_gpu False
```
- 示例文件下载：
- [1.mp4](https://paddlehub.bj.bcebos.com/model/video/video_classifcation/1.mp4)
- [2.mp4](https://paddlehub.bj.bcebos.com/model/video/video_classifcation/2.mp4)
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
videotag = hub.Module(name="videotag_tsn_lstm")
# execute predict and print the result
results = videotag.classify(paths=["1.mp4","2.mp4"], use_gpu=False) # 示例文件请在上方下载
print(results)
#[{'path': '1.mp4', 'prediction': {'训练': 0.9771281480789185, '蹲': 0.9389840960502625, '杠铃': 0.8554490804672241, '健身房': 0.8479971885681152}}, {'path': '2.mp4', 'prediction': {'舞蹈': 0.8504238724708557}}]
```
- ### 3、API
- ```python
def classify(paths,
use_gpu=False,
threshold=0.5,
top_k=10)
```
- 用于视频分类预测
- **参数**
- paths(list\[str\])：mp4文件路径
- use_gpu(bool)：是否使用GPU预测，默认为False
- threshold(float)：预测结果阈值，只有预测概率大于阈值的类别会被返回，默认为0.5
- top_k(int): 返回预测结果的前k个，默认为10
- **返回**
- results(list\[dict\]): result中的每个元素为对应输入的预测结果，预测单个mp4文件时仅有1个元素。每个预测结果为dict，包含mp4文件路径path及其分类概率。
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install videotag_tsn_lstm==1.0.0
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或