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" />
<img src="https://user-images.githubusercontent.com/76040149/133250741-83040204-acfc-4348-af90-acac74f40cd8.png" height = "300" />
</div>
- ### 模型介绍
- solov2是基于"SOLOv2: Dynamic, Faster and Stronger"实现的快速实例分割的模型。该模型基于SOLOV1, 并且针对mask的检测效果和运行效率进行改进，在实例分割任务中表现优秀。相对语义分割，实例分割需要标注出图上同一物体的不同个体。
## API
```python
def predict(self,
image: Union[str, np.ndarray],
threshold: float = 0.5,
visualization: bool = False,
save_dir: str = 'solov2_result'):
```
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
预测API，实例分割。
- ### 2、安装
**参数**
- ```shell
$ hub install solov2
```
* image (Union\[str, np.ndarray\]): 图片路径或者图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* threshold (float): 检测模型输出结果中，预测得分低于该阈值的框将被滤除，默认值为0.5；
* visualization (bool): 是否将可视化图片保存；
* save_dir (str): 保存图片到路径， 默认为"solov2_result"。
- 如您安装时遇到问题，可参考：[零基础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 (dict): 识别结果，关键字有 'segm', 'label', 'score'对应的取值为：
* segm (np.ndarray): 实例分割结果,取值为0或1。0表示背景，1为实例；
* label (list): 实例分割结果类别id；
* score (list):实例分割结果类别得分；
- ### 1、命令行预测
- ```shell
$ hub run openpose_hands_estimation --input_path "/PATH/TO/IMAGE"
```
## 代码示例
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
```python
import cv2
import paddlehub as hub
- ### 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'):
```
img = cv2.imread('/PATH/TO/IMAGE')
model = hub.Module(name='solov2', use_gpu=False)
output = model.predict(image=img,visualization=False)
```
- 预测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
- PaddleHub Serving可以部署一个实例分割的在线服务。
运行启动命令：
- ### 第一步：启动PaddleHub Serving
```shell
$ hub serving start -m solov2
```
- 运行启动命令：
- ```shell
$ hub serving start -m solov2 -p 8866
```
默认端口号为8866。
- 这样就完成了一个实例分割的在线服务API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
- ### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
- ```python
import requests
import json
import cv2
import base64
import numpy as np
import numpy as np
def cv2_to_base64(image):
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
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请求
# 发送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))
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))
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)
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)
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)
```
print('seg', seg)
print('label', label)
print('score', score)
```
### 查看代码
## 五、更新历史
https://github.com/PaddlePaddle/PaddleDetection
* 1.0.0
初始发布
### 依赖
* ```shell
$ hub install hand_pose_localization==1.0.0
```
paddlepaddle >= 2.0.0
paddlehub >= 2.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"
```
* face\_detector\_module (class): 人脸检测模型
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
```python
def get_face_detector_module()
```
- ```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'])
```
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- ### 3、API
- ```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个点）
将模型保存到指定路径，由于人脸关键点检测模型由人脸检测+关键点检测两个模型组成，因此保存后会存在两个子目录，其中`face_landmark`为人脸关键点模型，`detector`为人脸检测模型。
**参数**
- **参数**
* dirname: 存在模型的目录名称
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- 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。
- **返回**
## 代码示例
- res (list[dict]): 识别结果的列表，列表元素为 dict, 有以下两个字段：
- save_path : 可视化图片的保存路径（仅当visualization=True时存在）；
- data: 图片中每张人脸的关键点坐标
```python
import paddlehub as hub
import cv2
- ```python
def set_face_detector_module(face_detector_module):
```
face_landmark = hub.Module(name="face_landmark_localization")
- 设置为人脸关键点检测模型进行人脸检测的底座模型
- **参数**
- face_detector_module (class): 人脸检测模型
# 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"))
- ```python
def get_face_detector_module():
```
- 获取为人脸关键点检测模型进行人脸检测的底座模型
- **返回**
- 当前模型使用的人脸检测模型。
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=False):
```
result = face_landmark.keypoint_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_landmark.keypoint_detection(paths=['/PATH/TO/IMAGE'])
```
- 将模型保存到指定路径，由于人脸关键点检测模型由人脸检测+关键点检测两个模型组成，因此保存后会存在两个子目录，其中`face_landmark`为人脸关键点模型，`detector`为人脸检测模型。
- **参数**
- dirname: 存在模型的目录名称
- model_filename: 模型文件名称，默认为\__model__
- params_filename: 参数文件名称，默认为\__params__(仅当combined为True时生效)
- combined: 是否将参数保存到统一的一个文件中
## 服务部署
## 四、服务部署
PaddleHub Serving可以部署一个在线人脸关键点检测服务。
- PaddleHub Serving可以部署一个在线人脸关键点检测服务。
## 第一步：启动PaddleHub Serving
- ### 第一步：启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m face_landmark_localization
```
- 运行启动命令：
- ```shell
$ hub serving start -m face_landmark_localization -p 8866
```
这样就完成了一个人脸关键点服务化API的部署，默认端口号为8866。
- 这样就完成了一个人脸关键点服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
- ### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
import paddlehub as hub
- ```python
import requests
import json
import cv2
import base64
import paddlehub as hub
def cv2_to_base64(image):
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))
# 发送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"])
```
# 打印预测结果
print(r.json()["results"])
```
### 查看代码
## 五、更新历史
https://github.com/lsy17096535/face-landmark
* 1.0.0
## Module贡献者
初始发布
[Jason](https://github.com/jiangjiajun)
* 1.0.1
### 依赖
* 1.0.2
paddlepaddle >= 1.6.2
* ```shell
$ hub install face_landmark_localization==1.0.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
## 命令行预测
# human_pose_estimation_resnet50_mpii
```
hub run human_pose_estimation_resnet50_mpii --input_path "/PATH/TO/IMAGE"
```
| 模型名称 | human_pose_estimation_resnet50_mpii |
| :------------------ | :---------------------------------: |
| 类别 | 图像-关键点检测 |
| 网络 | Pose_Resnet50 |
| 数据集 | MPII |
| 是否支持Fine-tuning | 否 |
| 模型大小 | 121M |
| 最新更新日期 | 2021-02-26 |
| 数据指标 | |
## API 说明
## 一、模型基本信息
```python
def keypoint_detection(self,
images=None,
paths=None,
batch_size=1,
use_gpu=False,
output_dir='output_pose',
visualization=False)
```
- ### 应用效果展示
预测API，识别出人体骨骼关键点。
<p align="center">
<img src="https://user-images.githubusercontent.com/76040149/133231581-1dffc391-652d-417f-b8ad-a3c22b8092e8.jpg" width="300">
</p>
**参数**
- ### 模型介绍
- 人体骨骼关键点检测(Pose Estimation) 是计算机视觉的基础算法之一，在很多cv任务中起到了基础性的作用，如行为识别、人物跟踪、步态识别等领域。
* 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。
## 二、安装
**返回**
- ### 1、环境依赖
* res (list[dict]): 识别元素的列表，列表元素为 dict，关键字为 'path', 'data'，相应的取值为：
* path (str): 原图的路径；
* data (OrderedDict): 人体骨骼关键点的坐标。
- paddlepaddle >= 1.6.2
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- paddlehub >= 1.6.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
将模型保存到指定路径。
- ### 2、安装
**参数**
- ```shell
$ hub install human_pose_estimation_resnet50_mpii
```
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- 如您安装时遇到问题，可参考：[零基础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预测
```python
import cv2
import paddlehub as hub
- ### 1、命令行预测
pose_estimation = hub.Module(name="human_pose_estimation_resnet50_mpii")
- ```shell
$ hub run human_pose_estimation_resnet50_mpii --input_path "/PATH/TO/IMAGE"
```
result = pose_estimation.keypoint_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = pose_estimation.keypoint_detection(paths=['/PATH/TO/IMAGE'])
```
- 通过命令行方式实现hub模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
## 服务部署
- ### 2、预测代码示例
PaddleHub Serving可以部署一个在线人脸关键点检测服务。
- ```python
import cv2
import paddlehub as hub
## 第一步：启动PaddleHub Serving
pose_estimation = hub.Module(name="human_pose_estimation_resnet50_mpii")
运行启动命令：
```shell
$ hub serving start -m 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'])
这样就完成了一个人体骨骼关键点识别的在线服务API的部署，默认端口号为8866。
# PaddleHub示例图片下载方法：
# wget https://paddlehub.bj.bcebos.com/resources/test_image.jpg
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 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):
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 将模型保存到指定路径。
```python
import requests
import json
import cv2
import base64
- **参数**
- dirname: 存在模型的目录名称
- model_filename: 模型文件名称，默认为__model__
- params_filename: 参数文件名称，默认为__params__(仅当combined为True时生效)
- combined: 是否将参数保存到统一的一个文件中
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
## 四、服务部署
- PaddleHub Serving可以部署一个在线人体骨骼关键点识别服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m human_pose_estimation_resnet50_mpii -p 8866
```
- 这样就完成了一个人体骨骼关键点识别的在线服务API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
# 发送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))
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```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')
# 打印预测结果
print(r.json()["results"])
```
# 发送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函数返回的结果
```
### 模型代码
## 五、更新历史
https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/human_pose_estimation
* 1.0.0
### 依赖
* 1.1.0
paddlepaddle >= 1.6.2
* 1.1.1
paddlehub >= 1.6.0
* ```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
PaddleHub Serving 可以部署一个目标检测的在线服务。
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'])
```
运行启动命令：
```shell
$ hub serving start -m chinese_ocr_db_crnn_mobile
```
- ### 3、API
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- ```python
__init__(text_detector_module=None, enable_mkldnn=False)
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- 构造ChineseOCRDBCRNN对象
### 第二步：发送预测请求
- **参数**
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 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
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')
- ```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\]): 图片的路径；
- 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；
- **返回**
- 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为''
# 发送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"])
```
## 四、服务部署
## 查看代码
- PaddleHub Serving 可以部署一个目标检测的在线服务。
https://github.com/PaddlePaddle/PaddleOCR
- ### 第一步：启动PaddleHub Serving
### 依赖
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_ocr_db_crnn_mobile
```
paddlepaddle >= 1.7.2
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
paddlehub >= 1.6.0
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
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_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对象
- **参数**
- 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。
## 服务部署
- ```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 Serving 可以部署一个目标检测的在线服务。
- 预测API，检测输入图片中的所有中文文本的位置。
### 第一步：启动PaddleHub Serving
- **参数**
运行启动命令：
```shell
$ hub serving start -m chinese_ocr_db_crnn_server
```
- 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；
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- **返回**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- 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为''
### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```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')
- PaddleHub Serving 可以部署一个目标检测的在线服务。
- ### 第一步：启动PaddleHub Serving
# 发送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))
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_ocr_db_crnn_server
```
# 打印预测结果
print(r.json()["results"])
```
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
## 查看代码
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
https://github.com/PaddlePaddle/PaddleOCR
- ### 第二步：发送预测请求
### 依赖
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
paddlepaddle >= 1.7.2
- ```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')
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://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>
```shell
$ hub run chinese_text_detection_db_mobile --input_path "/PATH/TO/IMAGE"
```
更多详情参考：[Real-time Scene Text Detection with Differentiable Binarization](https://arxiv.org/pdf/1911.08947.pdf)
**该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
## API
## 二、安装
## API
- ### 1、环境依赖
### \_\_init\_\_(enable_mkldnn=False)
- paddlepaddle >= 1.7.2
构造ChineseTextDetectionDB对象
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
- shapely
* enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
- pyclipper
- ```shell
$ pip install shapely pyclipper
```
- **该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
```python
def detect_text(paths=[],
images=[],
use_gpu=False,
output_dir='detection_result',
box_thresh=0.5,
visualization=False)
```
- ### 2、安装
预测API，检测输入图片中的所有中文文本的位置。
- ```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)
**参数**
* 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；
**返回**
## 三、模型API预测
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
* save_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
- ### 1、命令行预测
### 代码示例
- ```shell
$ hub run chinese_text_detection_db_mobile --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
```python
import paddlehub as hub
import cv2
- ### 2、代码示例
text_detector = hub.Module(name="chinese_text_detection_db_mobile", enable_mkldnn=True)
result = text_detector.detect_text(images=[cv2.imread('/PATH/TO/IMAGE')])
- ```python
import paddlehub as hub
import cv2
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
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')])
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
## 服务部署
- ### 3、API
PaddleHub Serving 可以部署一个目标检测的在线服务。
- ```python
__init__(enable_mkldnn=False)
```
### 第一步：启动PaddleHub Serving
- 构造ChineseTextDetectionDB对象
运行启动命令：
```shell
$ hub serving start -m chinese_text_detection_db_mobile
```
- **参数**
- enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
**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，检测输入图片中的所有中文文本的位置。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **参数**
```python
import requests
import json
import cv2
import base64
- 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；
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- **返回**
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
- data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
- save_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
# 发送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))
# 打印预测结果
print(r.json()["results"])
```
## 查看代码
## 四、服务部署
https://github.com/PaddlePaddle/PaddleOCR
- PaddleHub Serving 可以部署一个目标检测的在线服务。
## 依赖
- ### 第一步：启动PaddleHub Serving
paddlepaddle >= 1.7.2
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_text_detection_db_mobile
```
paddlehub >= 1.6.0
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
shapely
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
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_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 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>
```shell
$ hub run chinese_text_detection_db_server --input_path "/PATH/TO/IMAGE"
```
- 更多详情参考：[Real-time Scene Text Detection with Differentiable Binarization](https://arxiv.org/pdf/1911.08947.pdf)
**该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
## API
### \_\_init\_\_(enable_mkldnn=False)
## 二、安装
构造ChineseTextDetectionDBServer对象
- ### 1、环境依赖
**参数**
- paddlepaddle >= 1.7.2
* enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- shapely
- pyclipper
- ```shell
$ pip install shapely pyclipper
```
- **该Module依赖于第三方库shapely和pyclipper，使用该Module之前，请先安装shapely和pyclipper。**
- ### 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)
```python
def detect_text(paths=[],
images=[],
use_gpu=False,
output_dir='detection_result',
box_thresh=0.5,
visualization=False)
```
预测API，检测输入图片中的所有中文文本的位置。
**参数**
## 三、模型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；
- ### 1、命令行预测
**返回**
- ```shell
$ hub run chinese_text_detection_db_server --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
* save_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
- ### 2、代码示例
### 代码示例
- ```python
import paddlehub as hub
import cv2
```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')])
text_detector = hub.Module(name="chinese_text_detection_db_server")
result = text_detector.detect_text(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
# or
# result =text_detector.detect_text(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
__init__(enable_mkldnn=False)
```
- 构造ChineseTextDetectionDBServer对象
## 服务部署
- **参数**
PaddleHub Serving 可以部署一个目标检测的在线服务。
- enable_mkldnn(bool): 是否开启mkldnn加速CPU计算。该参数仅在CPU运行下设置有效。默认为False。
### 第一步：启动PaddleHub Serving
- ```python
def detect_text(paths=[],
images=[],
use_gpu=False,
output_dir='detection_result',
box_thresh=0.5,
visualization=False)
```
- 预测API，检测输入图片中的所有中文文本的位置。
运行启动命令：
```shell
$ hub serving start -m chinese_text_detection_db_server
```
- **参数**
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- 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；
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- **返回**
### 第二步：发送预测请求
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
- data (list): 检测文本框结果，文本框在原图中的像素坐标，4*2的矩阵，依次表示文本框左下、右下、右上、左上顶点的坐标
- ave_path (str): 识别结果的保存路径, 如不保存图片则save_path为''
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```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')
- PaddleHub Serving 可以部署一个目标检测的在线服务。
# 发送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))
- ### 第一步：启动PaddleHub Serving
# 打印预测结果
print(r.json()["results"])
```
- 运行启动命令：
- ```shell
$ hub serving start -m chinese_text_detection_db_server
```
## 查看代码
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
https://github.com/PaddlePaddle/PaddleOCR
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 依赖
- ### 第二步：发送预测请求
paddlepaddle >= 1.7.2
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
paddlehub >= 1.6.0
- ```python
import requests
import json
import cv2
import base64
shapely
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"])
```
pyclipper
## 更新历史
## 五、更新历史
* 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
* sentence(str): 单句预测数据。
* HMM 参数用来控制是否使用 HMM 模型， 默认为True；
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
### load_userdict(user_dict)
- ### 2、安装
指定自己自定义的词典，以便包含 jieba 词库里没有的词。虽然 jieba 有新词识别能力，但是自行添加新词可以保证更高的正确率。
- ```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)
**参数**
* user_dict(str): 自定义词典的路径
### extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
## 三、模型API预测
基于 TF-IDF 算法的关键词抽取
- ### 1、命令行预测
**参数**
- ```shell
$ hub run jieba_paddle --input_text "今天天气真好"
```
或者
- ```shell
$ hub run senta_gru --input_file test.txt
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* sentence(str): 待提取的文本
* topK(int): 返回几个 TF/IDF 权重最大的关键词，默认值为 20
* withWeight(bool): 为是否一并返回关键词权重值，默认值为 False
* allowPOS(tuple): 仅包括指定词性的词，默认值为空，即不筛选
- ### 2、预测代码示例
### textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v'))
- ```python
import paddlehub as hub
基于 TextRank 算法的关键词抽取
jieba = hub.Module(name="jieba_paddle")
**参数**
results = jieba.cut("今天是个好日子", cut_all=False, HMM=True)
print(results)
* sentence(str): 待提取的文本
* topK(int): 返回几个 TF/IDF 权重最大的关键词，默认值为 20
* withWeight(bool): 为是否一并返回关键词权重值，默认值为 False
* allowPOS(tuple): 仅包括指定词性的词，默认值为('ns', 'n', 'vn', 'v')
# ['今天', '是', '个', '好日子']
```
# Jieba_Paddle 服务部署
PaddleHub Serving可以部署一个切词服务，可以将此接口用于在线分词等web应用。
- ### 3、API
## 第一步：启动PaddleHub Serving
- ```python
def cut(sentence, use_paddle=True, cut_all=False, HMM=True)
```
- jieba_paddle预测接口，预测输入句子的分词结果
运行启动命令：
```shell
$ hub serving start -c serving_config.json
```
- **参数**
`serving_config.json`的内容如下：
```json
{
- sentence(str): 单句预测数据。
- use_paddle(bool): 是否使用paddle模式（双向GRU）切词，默认为True。
- cut_all 参数用来控制是否采用全模式，默认为True；
- HMM 参数用来控制是否使用 HMM 模型， 默认为True；
- **返回**
- results(list): 分词结果
- ```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": {
......@@ -86,50 +174,45 @@ $ hub serving start -c serving_config.json
"port": 8866,
"use_singleprocess": false,
"workers": 2
}
```
这样就完成了一个切词服务化API的部署，默认端口号为8866。
## 第二步：发送预测请求
}
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 这样就完成了一个切词服务化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对象
**参数**
* user_dict(str): 自定义词典路径。如果需要使用自定义词典，则可通过该参数设置，否则不用传入该参数。
## 一、模型基本信息
### cut(text, use_gpu=False, batch_size=1, return_tag=True)
- ### 模型介绍
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>
* text(str or list): 待预测数据，单句预测数据（str类型）或者批量预测（list，每个元素为str
* use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
* batch_size(int): 批处理大小
* return_tag(bool): 预测结果是否需要返回分词标签结果
- 更多详情请参考：[LAC论文](https://arxiv.org/abs/1807.01882)
### lexical_analysis(texts=[], data={}, use_gpu=False, batch_size=1, user_dict=None, return_tag=True)
**该接口将会在未来版本被废弃，如有需要，请使用cut接口预测**
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): 预测结果是否需要返回分词标签结果
- ### 1、环境依赖
**返回**
- paddlepaddle >= 1.6.2
* results(list): 分词结果
- paddlehub >= 1.6.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
### context(trainable=False)
- 若使用词典干预功能，额外依赖第三方库 pyahocorasick
获取lac的预训练program以及program的输入输出变量
- ```shell
$ pip install pyahocorasick
```
**参数**
- ### 2、安装
* trainable(bool): trainable=True表示program中的参数在Fine-tune时需要微调，否则保持不变
- ```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)
**返回**
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
### set_user_dict(dict_path)
加载用户自定义词典
## 三、模型API预测
**参数**
- ### 1、命令行预测
* dict_path(str ): 自定义词典路径
- ```shell
$ hub run lac --input_text "今天是个好日子"
```
- 或者
- ```shell
$ hub run lac --input_file test.txt --user_dict user.dict
```
### del_user_dict()
- test.txt 存放待分词文本， 如：
- ```shell
今天是个好日子
今天天气晴朗
```
- user.dict 为用户自定义词典，可以不指定，当指定自定义词典时，可以干预默认分词结果。如：
- ```shell
春天/SEASON
花/n 开/v
秋天的风
落 阳
```
- 词典文件每行表示一个定制化的item，由一个单词或多个连续的单词组成，每个单词后使用'/'表示标签，如果没有'/'标签则会使用模型默认的标签。每个item单词数越多，干预效果会越精准。
删除自定义词典
- Note：该PaddleHub Module使用词典干预功能时，依赖于第三方库pyahocorasick，请自行安装
### get_tags()
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
获取lac的标签
- ### 2、预测代码示例
**返回**
- ```python
import paddlehub as hub
* tag_name_dict(dict): lac的标签
lac = hub.Module(name="lac")
test_text = ["今天是个好日子", "天气预报说今天要下雨", "下一班地铁马上就要到了"]
## LAC 服务部署
results = lac.cut(text=test_text, use_gpu=False, batch_size=1, return_tag=True)
PaddleHub Serving可以部署一个在线词法分析服务，可以将此接口用于词法分析、在线分词等在线web应用。
for result in results:
print(result['word'])
print(result['tag'])
### 第一步：启动PaddleHub Serving
# ['今天', '是', '个', '好日子']
# ['TIME', 'v', 'q', 'n']
# ['天气预报', '说', '今天', '要', '下雨']
# ['n', 'v', 'TIME', 'v', 'v']
# ['下', '一班', '地铁', '马上', '就要', '到', '了']
# ['f', 'm', 'n', 'd', 'v', 'v', 'xc']
```
运行启动命令：
```shell
$ hub serving start -c serving_config.json
```
`serving_config.json`的内容如下：
```json
{
- ### 3、API
- ```python
def __init__(user_dict=None)
```
- 构造LAC对象
- **参数**
- user_dict(str): 自定义词典路径。如果需要使用自定义词典，则可通过该参数设置，否则不用传入该参数。
- ```python
def 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): 预测结果是否需要返回分词标签结果
- ```python
def lexical_analysis(texts=[], data={}, use_gpu=False, batch_size=1, user_dict=None, return_tag=True)
```
- **该接口将会在未来版本被废弃，如有需要，请使用cut接口预测**
- 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): 预测结果是否需要返回分词标签结果
- **返回**
- 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": {
......@@ -97,42 +210,44 @@ $ hub serving start -c serving_config.json
"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
......@@ -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
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
## get_labels()
- ### 2、安装
获取emotion_detection_textcnn的类别
- ```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)
**返回**
* labels(dict): emotion_detection_textcnn的类别(三分类，积极/中立/消极)
## get_vocab_path()
获取预训练时使用的词汇表
**返回**
## 三、模型API预测
* vocab_path(str): 词汇表路径
- ### 1、命令行预测
# EmotionDetectionTextcnn 服务部署
- ```shell
$ hub run emotion_detection_textcnn --input_text "今天天气真好"
```
或者
- ```shell
$ hub run emotion_detection_textcnn --input_file test.txt
```
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
## 第一步：启动PaddleHub Serving
> 这部电影真的很差劲
运行启动命令：
```shell
$ hub serving start -m emotion_detection_textcnn
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
启动时会显示加载模型过程，启动成功后显示
```shell
Loading emotion_detection_textcnn successful.
```
- ### 2、预测代码示例
这样就完成了服务化API的部署，默认端口号为8866。
- ```python
import paddlehub as hub
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
module = hub.Module(name="emotion_detection_textcnn")
test_text = ["今天天气真好", "湿纸巾是干垃圾", "别来吵我"]
results = module.emotion_classify(texts=test_text)
## 第二步：发送预测请求
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
```
```python
import requests
import json
- ### 3、API
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- ```python
def emotion_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- emotion_detection_textcnn预测接口，预测输入句子的情感分类(三分类，积极/中立/消极）
# 设置运行配置
# 对应本地预测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))
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
# 打印预测结果
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)
- results(list): 情感分类结果
## 更新历史
- ```python
def get_labels()
```
- 获取emotion_detection_textcnn的类别
- **返回**
- labels(dict): emotion_detection_textcnn的类别(三分类，积极/中立/消极)
- ```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
- SKEP（Sentiment Knowledge Enhanced Pre-training for Sentiment Analysis）是百度研究团队在2020年提出的基于情感知识增强的情感预训练算法，此算法采用无监督方法自动挖掘情感知识，然后利用情感知识构建预训练目标，从而让机器学会理解情感语义，在14项中英情感分析典型任务上全面超越SOTA，相关工作已经被ACL 2020录用。SKEP为各类情感分析任务提供统一且强大的情感语义表示。ernie_skep_sentiment_analysis Module可用于句子级情感分析任务预测。其在预训练时使用ERNIE 1.0 large预训练参数作为其网络参数初始化继续预训练。
```python
def predict_sentiment(texts=[], use_gpu=False)
```
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/model/nlp/skep.png" width='600' hspace='10'/> <br />
</p>
预测API，分类输入文本的情感极性。
- 更多详情参考ACL 2020论文：[SKEP: Sentiment Knowledge Enhanced Pre-training for Sentiment Analysis](https://arxiv.org/abs/2005.05635)
**参数**
* texts (list\[str\]): 待预测文本；
* use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
## 二、安装
**返回**
- ### 1、环境依赖
* res (list\[dict\]): 情感分类结果的列表，列表中每一个元素为 dict，各字段为：
* text(str): 输入预测文本
* sentiment_label(str): 情感分类结果，或为positive或为negative
* positive_probs: 输入预测文本情感极性属于positive的概率
* negative_probs: 输入预测文本情感极性属于negative的概率
- paddlepaddle >= 1.8.0
```python
def context(trainable=True, max_seq_len=128)
```
用于获取Module的上下文信息，得到输入、输出以及预训练的Paddle Program副本
- paddlehub >= 1.7.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
* trainable(bool): 设置为True时，Module中的参数在Fine-tune时也会随之训练，否则保持不变。
* max_seq_len(int): SKEP模型的最大序列长度，若序列长度不足，会通过padding方式补到**max_seq_len**, 若序列长度大于该值，则会以截断方式让序列长度为**max_seq_len**，max_seq_len可取值范围为0～512；
- ### 2、安装
**返回**
* 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类型；
- ```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)
* outputs：dict类型，Module的输出特征，各字段为：
* pooled_output(Variable): 句子粒度的特征，可用于文本分类等任务，shape为 \[batch_size, 768\]，dtype为int64类型；
* sequence_output(Variable): 字粒度的特征，可用于序列标注等任务，shape为 \[batch_size, seq_len, 768\]，dtype为int64类型；
* program：包含该Module计算图的Program。
```python
def get_embedding(texts, use_gpu=False, batch_size=1)
```
## 三、模型API预测
用于获取输入文本的句子粒度特征与字粒度特征
- ### 1、命令行预测
**参数**
- ```shell
$ hub run ernie_skep_sentiment_analysis --input_text='虽然小明很努力，但是他还是没有考100分'
```
* 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环境变量**；
- ### 2、预测代码示例
**返回**
- ```python
import paddlehub as hub
* results(list): embedding特征，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
# Load ernie_skep_sentiment_analysis module.
module = hub.Module(name="ernie_skep_sentiment_analysis")
```python
def get_params_layer()
```
# Predict sentiment label
test_texts = ['你不是不聪明，而是不认真', '虽然小明很努力，但是他还是没有考100分']
results = module.predict_sentiment(test_texts, use_gpu=False)
用于获取参数层信息，该方法与ULMFiTStrategy联用可以严格按照层数设置分层学习率与逐层解冻。
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
**返回**
- ```python
def predict_sentiment(texts=[], use_gpu=False)
```
- 预测API，分类输入文本的情感极性。
* params_layer(dict): key为参数名，值为参数所在层数
- **参数**
**代码示例**
- texts (list\[str\]): 待预测文本；
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量**；
情感极性预测代码示例：
- **返回**
```python
import paddlehub as hub
- res (list\[dict\]): 情感分类结果的列表，列表中每一个元素为 dict，各字段为：
- text(str): 输入预测文本
- sentiment_label(str): 情感分类结果，或为positive或为negative
- positive_probs: 输入预测文本情感极性属于positive的概率
- negative_probs: 输入预测文本情感极性属于negative的概率
# 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)
```
- ```python
def get_embedding(texts, use_gpu=False, batch_size=1)
```
## 服务部署
- 用于获取输入文本的句子粒度特征与字粒度特征
PaddleHub Serving 可以部署一个目标检测的在线服务。
- **参数**
### 第一步：启动PaddleHub Serving
- 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环境变量**；
运行启动命令：
```shell
$ hub serving start -m ernie_skep_sentiment_analysis
```
- **返回**
这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
- results(list): embedding特征，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
### 第二步：发送预测请求
## 四、服务部署
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- PaddleHub Serving 可以部署一个目标检测的在线服务。
```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))
- 运行启动命令：
```shell
$ hub serving start -m ernie_skep_sentiment_analysis
```
# 打印预测结果
print(r.json()["results"])
```
- 这样就完成了一个目标检测的服务化API的部署，默认端口号为8866。
## 查看代码
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
https://github.com/baidu/Senta
- ### 第二步：发送预测请求
### 依赖
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
paddlepaddle >= 1.8.0
```python
import requests
import json
paddlehub >= 1.7.0
# 发送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)
* 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；
- ### 2、安装
**返回**
- ```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()
获取senta_bilstm的类别
## 三、模型API预测
**返回**
- ### 1、命令行预测
* labels(dict): senta_bilstm的类别(二分类，积极/消极)
- ```shell
$ hub run senta_bilstm --input_text "这家餐厅很好吃"
```
或者
- ```shell
$ hub run senta_bilstm --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
## get_vocab_path()
> 这部电影真的很差劲
获取预训练时使用的词汇表
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**返回**
- ### 2、预测代码示例
* vocab_path(str): 词汇表路径
- ```python
import paddlehub as hub
# SentaBiLSTM 服务部署
senta = hub.Module(name="senta_bilstm")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
results = senta.sentiment_classify(texts=test_text,
use_gpu=False,
batch_size=1)
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
## 第一步：启动PaddleHub Serving
# 这家餐厅很好吃 1 positive 0.9407 0.0593
# 这部电影真的很差劲 0 negative 0.02 0.98
```
运行启动命令：
```shell
$ hub serving start -m senta_bilstm
```
- ### 3、API
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_bilstm successful.
```
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
这样就完成了服务化API的部署，默认端口号为8866。
- senta_bilstm预测接口，预测输入句子的情感分类(二分类，积极/消极）
**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_bilstm.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
- ```python
def get_labels()
```
- 获取senta_bilstm的类别
# 指定预测方法为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))
```
- labels(dict): senta_bilstm的类别(二分类，积极/消极)
关于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 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
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
## get_labels()
- ### 2、安装
获取senta_bow的类别
- ```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)
**返回**
* labels(dict): senta_bow的类别(二分类，积极/消极)
## get_vocab_path()
获取预训练时使用的词汇表
## 三、模型API预测
**返回**
- ### 1、命令行预测
* vocab_path(str): 词汇表路径
- ```shell
$ hub run senta_bow --input_text "这家餐厅很好吃"
```
- 或者
- ```shell
$ hub run senta_bow --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
# SentaBow 服务部署
> 这部电影真的很差劲
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
## 第一步：启动PaddleHub Serving
- ### 2、预测代码示例
运行启动命令：
```shell
$ hub serving start -m senta_bow
```
- ```python
import paddlehub as hub
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_bow successful.
```
senta = hub.Module(name="senta_bow")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
这样就完成了服务化API的部署，默认端口号为8866。
results = senta.sentiment_classify(texts=test_text, use_gpu=False, batch_size=1)
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
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
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
- ### 3、API
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- senta_bow预测接口，预测输入句子的情感分类(二分类，积极/消极）
# 设置运行配置
# 对应本地预测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))
- texts(list): 待预测数据，如果使用texts参数，则不用传入data参数，二选一即可
- data(dict): 预测数据，key必须为text，value是带预测数据。如果使用data参数，则不用传入texts参数，二选一即可。建议使用texts参数，data参数后续会废弃。
- use_gpu(bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置
- batch_size(int): 批处理大小
# 打印预测结果
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)
- results(list): 情感分类结果
## 更新历史
- ```python
def get_labels()
```
- 获取senta_bow的类别
- **返回**
- 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
获取该Module的预训练program以及program相应的输入输出。
- 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_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)
**返回**
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
## get_labels()
## 三、模型API预测
获取senta_cnn的类别
- ### 1、命令行预测
**返回**
- ```shell
$ hub run senta_cnn --input_text "这家餐厅很好吃"
```
或者
- ```shell
$ hub run senta_cnn --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
* labels(dict): senta_cnn的类别(二分类，积极/消极)
> 这部电影真的很差劲
## get_vocab_path()
- 通过命令行方式实现文字识别模型的调用，更多请见：[PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
获取预训练时使用的词汇表
- ### 2、预测代码示例
**返回**
- ```python
import paddlehub as hub
* vocab_path(str): 词汇表路径
senta = hub.Module(name="senta_cnn")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
results = senta.sentiment_classify(texts=test_text,
use_gpu=False,
batch_size=1)
# SentaCNN 服务部署
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
# 这家餐厅很好吃 1 positive 0.7902 0.2098
# 这部电影真的很差劲 0 negative 0.0343 0.9657
```
## 第一步：启动PaddleHub Serving
- ### 3、API
运行启动命令：
```shell
$ hub serving start -m senta_cnn
```
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_cnn successful.
```
- senta_cnn预测接口，预测输入句子的情感分类(二分类，积极/消极）
这样就完成了服务化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()
```
# 设置运行配置
# 对应本地预测senta_cnn.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
- 获取senta_cnn的类别
# 指定预测方法为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))
```
- labels(dict): senta_cnn的类别(二分类，积极/消极)
关于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 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
* inputs(dict): program的输入变量
* outputs(dict): program的输出变量
* main_program(Program): 带有预训练参数的program
- paddlehub >= 1.8.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
## get_labels()
- ### 2、安装
获取senta_gru的类别
- ```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)
**返回**
* labels(dict): senta_gru的类别(二分类，积极/消极)
## get_vocab_path()
## 三、模型API预测
获取预训练时使用的词汇表
- ### 1、命令行预测
**返回**
- ```shell
$ hub run senta_gru --input_text "今天天气真好"
```
或者
- ```shell
$ hub run senta_gru --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
* vocab_path(str): 词汇表路径
> 这部电影真的很差劲
# SentaGRU 服务部署
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ### 2、预测代码示例
## 第一步：启动PaddleHub Serving
- ```python
import paddlehub as hub
运行启动命令：
```shell
$ hub serving start -m senta_gru
```
senta = hub.Module(name="senta_gru")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_gru successful.
```
results = senta.sentiment_classify(texts=test_text, use_gpu=False, batch_size=1)
这样就完成了服务化API的部署，默认端口号为8866。
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
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 3、API
## 第二步：发送预测请求
- ```python
def sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
- senta_gru预测接口，预测输入句子的情感分类(二分类，积极/消极）
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **参数**
```python
import requests
import 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): 批处理大小
# 待预测数据
text = ["这家餐厅很好吃", "这部电影真的很差劲"]
- **返回**
# 设置运行配置
# 对应本地预测senta_gru.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
- results(list): 情感分类结果
# 指定预测方法为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))
```
- ```python
def get_labels()
```
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- 获取senta_gru的类别
## 更新历史
- **返回**
- labels(dict): senta_gru的类别(二分类，积极/消极)
- ```python
def get_vocab_path()
```
- 获取预训练时使用的词汇表
- **返回**
- 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)
* 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；
- ### 2、安装
**返回**
- ```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()
获取senta_lstm的类别
## 三、模型API预测
**返回**
- ### 1、命令行预测
* labels(dict): senta_lstm的类别(二分类，积极/消极)
- ```shell
$ hub run senta_lstm --input_text "这家餐厅很好吃"
```
或者
- ```shell
$ hub run senta_lstm --input_file test.txt
```
- test.txt 存放待预测文本， 如：
> 这家餐厅很好吃
## get_vocab_path()
> 这部电影真的很差劲
获取预训练时使用的词汇表
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
**返回**
- ### 2、预测代码示例
* vocab_path(str): 词汇表路径
- ```python
import paddlehub as hub
# SentaLSTM 服务部署
senta = hub.Module(name="senta_lstm")
test_text = ["这家餐厅很好吃", "这部电影真的很差劲"]
results = senta.sentiment_classify(texts=test_text,
use_gpu=False,
batch_size=1)
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
for result in results:
print(result['text'])
print(result['sentiment_label'])
print(result['sentiment_key'])
print(result['positive_probs'])
print(result['negative_probs'])
## 第一步：启动PaddleHub Serving
# 这家餐厅很好吃 1 positive 0.9285 0.0715
# 这部电影真的很差劲 0 negative 0.0187 0.9813
```
运行启动命令：
```shell
$ hub serving start -m senta_lstm
```
- ### 3、API
启动时会显示加载模型过程，启动成功后显示
```shell
Loading senta_lstm successful.
```
- ```python
sentiment_classify(texts=[], data={}, use_gpu=False, batch_size=1)
```
这样就完成了服务化API的部署，默认端口号为8866。
- senta_lstm预测接口，预测输入句子的情感分类(二分类，积极/消极）
**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_lstm.sentiment_classify(texts=text, batch_size=1, use_gpu=True)
data = {"texts": text, "batch_size": 1, "use_gpu":True}
- ```python
get_labels()
```
- 获取senta_lstm的类别
# 指定预测方法为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))
```
- labels(dict): senta_lstm的类别(二分类，积极/消极)
关于PaddleHub Serving更多信息参考[服务部署](https://github.com/PaddlePaddle/PaddleHub/blob/release/v1.6/docs/tutorial/serving.md)
- ```python
get_vocab_path()
```
## 更新历史
- 获取预训练时使用的词汇表
- **返回**
- vocab_path(str): 词汇表路径
## 四、服务部署
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- ## 第一步：启动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
大幅提升预测性能
......@@ -107,3 +179,7 @@ print(json.dumps(r.json(), indent=4, ensure_ascii=False))
* 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
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.8.2
- paddlehub >= 1.7.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- 额外依赖ddparser
- ```shell
$ pip install ddparser
```
- ### 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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run ddparser --input_text="百度是一家高科技公司"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import cv2
import paddlehub as hub
module = hub.Module(name="ddparser")
test_text = ["百度是一家高科技公司"]
results = module.parse(texts=test_text)
print(results)
test_tokens = [['百度', '是', '一家', '高科技', '公司']]
results = module.parse(texts=test_text, return_visual = True)
print(results)
result = results[0]
data = module.visualize(result['word'],result['head'],result['deprel'])
# or data = result['visual']
cv2.imwrite('test.jpg',data)
```
- ### 3、API
- ```python
def parse(texts=[], return\_visual=False)
```
- 依存分析接口，输入文本，输出依存关系。
- **参数**
- texts(list\[list\[str\] or list\[str\]]): 待预测数据。各元素可以是未分词的字符串，也可以是已分词的token列表。
- return\_visual(bool): 是否返回依存分析可视化结果。如果为True，返回结果中将包含'visual'字段。
- **返回**
- results(list\[dict\]): 依存分析结果。每个元素都是dict类型，包含以下信息：
{
'word': list[str], 分词结果。
'head': list[int], 当前成分其支配者的id。
......@@ -27,106 +100,86 @@ $ hub run ddparser --input_text="百度是一家高科技公司"
'postag': list[str], 词性标签，只有当texts的元素是未分词的字符串时包含这个键。
'visual': 图像数组，可以使用cv2.imshow显示图像或cv2.imwrite保存图像。
}
```
## visualize(word, head, deprel)
可视化接口，输入依存分析接口得到的信息，输出依存图形数组。
**参数**
* word(list\[list\[str\]\): 分词信息。
* head(list\[int\]): 当前成分其支配者的id。
* deprel(list\[str\]): 当前成分与支配者的依存关系。
**返回**
- ```python
def visualize(word, head, deprel)
```
* data(numpy.array): 图像数组。可以使用cv2.imshow显示图像或cv2.imwrite保存图像。
- 可视化接口，输入依存分析接口得到的信息，输出依存图形数组。
**代码示例**
- **参数**
```python
import cv2
import paddlehub as hub
- word(list\[list\[str\]\): 分词信息。
- head(list\[int\]): 当前成分其支配者的id。
- deprel(list\[str\]): 当前成分与支配者的依存关系。
module = hub.Module(name="ddparser")
- **返回**
test_text = ["百度是一家高科技公司"]
results = module.parse(texts=test_text)
print(results)
- data(numpy.array): 图像数组。可以使用cv2.imshow显示图像或cv2.imwrite保存图像。
test_tokens = [['百度', '是', '一家', '高科技', '公司']]
results = module.parse(texts=test_text, return_visual = True)
print(results)
result = results[0]
data = module.visualize(result['word'],result['head'],result['deprel'])
# or data = result['visual']
cv2.imwrite('test.jpg',data)
```
# DependencyParser 服务部署
## 四、服务部署
PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
- PaddleHub Serving可以部署一个在线情感分析服务，可以将此接口用于在线web应用。
## 第一步：启动PaddleHub Serving
- ## 第一步：启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m ddparser
```
- 运行启动命令：
```shell
$ hub serving start -m ddparser
```
启动时会显示加载模型过程，启动成功后显示
```shell
Loading ddparser successful.
```
- 启动时会显示加载模型过程，启动成功后显示
```shell
Loading ddparser successful.
```
这样就完成了服务化API的部署，默认端口号为8866。
- 这样就完成了服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
- ## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
```python
import requests
import json
import numpy as np
import cv2
import numpy as np
import cv2
# 待预测数据
text = ["百度是一家高科技公司"]
# 待预测数据
text = ["百度是一家高科技公司"]
# 设置运行配置
return_visual = True
data = {"texts": text, "return_visual": return_visual}
# 设置运行配置
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']
# 指定预测方法为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)):
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)
- 关于PaddleHub Serving更多信息参考：[服务部署](../../../../docs/docs_ch/tutorial/serving.md)
### 依赖
paddlepaddle >= 1.8.2
paddlehub >= 1.7.0
## 更新历史
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install ddparser==1.0.0
```
modules/text/text_generation/CPM_LM/readme.md 0 → 100644
浏览文件 @ 9611b1db
此差异已折叠。
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
初始发布
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或