Skip to content

P
PaddleHub

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

通知 285
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 a4d455b8 编写于 作者: H haoyuying 提交者： GitHub
浏览文件
操作

Update module docs (#1605)

上级 2fd801c3
隐藏空白更改
内联 并排
Showing with 2288 addition and 1306 deletion
demo/image_classification/README.md
浏览文件 @ a4d455b8
...@@ -8,6 +8,18 @@ ...@@ -8,6 +8,18 @@
$ hub run resnet50_vd_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5 $ hub run resnet50_vd_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
``` ```
## 脚本预测
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='resnet50_vd_imagenet_ssld',)
result = model.predict([PATH/TO/IMAGE])
```
## 如何开始Fine-tune ## 如何开始Fine-tune
在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用resnet50_vd_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用resnet50_vd_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
......
demo/style_transfer/README.md
浏览文件 @ a4d455b8
...@@ -8,6 +8,17 @@ ...@@ -8,6 +8,17 @@
$ hub run msgnet --input_path "/PATH/TO/ORIGIN/IMAGE" --style_path "/PATH/TO/STYLE/IMAGE" $ hub run msgnet --input_path "/PATH/TO/ORIGIN/IMAGE" --style_path "/PATH/TO/STYLE/IMAGE"
``` ```
## 脚本预测
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='msgnet')
result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path ='style_tranfer')
```
## 如何开始Fine-tune ## 如何开始Fine-tune
在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用msgnet模型对[MiniCOCO](../../docs/reference/datasets.md#class-hubdatasetsMiniCOCO)等数据集进行Fine-tune。 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用msgnet模型对[MiniCOCO](../../docs/reference/datasets.md#class-hubdatasetsMiniCOCO)等数据集进行Fine-tune。
...@@ -164,4 +175,4 @@ https://github.com/zhanghang1989/PyTorch-Multi-Style-Transfer ...@@ -164,4 +175,4 @@ https://github.com/zhanghang1989/PyTorch-Multi-Style-Transfer
paddlepaddle >= 2.0.0rc paddlepaddle >= 2.0.0rc
paddlehub >= 2.0.0 paddlehub >= 2.0.0
\ No newline at end of file
modules/image/Image_editing/colorization/deoldify/README.md
浏览文件 @ a4d455b8
# deoldify
## 模型概述 |模型名称|deoldify|
deoldify是用于图像和视频的着色渲染模型，该模型能够实现给黑白照片和视频恢复原彩。 | :--- | :---: |
|类别|图像-图像编辑|
|网络|NoGAN|
|数据集|ILSVRC 2012|
|是否支持Fine-tuning|否|
|模型大小|834MB|
|指标|-|
|最新更新日期|2021-04-13|
## API 说明
```python ## 一、模型基本信息
def predict(self, input):
```
着色变换API，得到着色后的图片或者视频。 - ### 应用效果展示
- 样例结果示例(左为原图，右为效果图)：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/130886749-668dfa38-42ed-4a09-8d4a-b18af0475375.jpg" width = "450" height = "300" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130886685-76221736-839a-46a2-8415-e5e0dd3b345e.png" width = "450" height = "300" hspace='10'/>
</p>
- ### 模型介绍
**参数** - deoldify是用于图像和视频的着色渲染模型，该模型能够实现给黑白照片和视频恢复原彩。
* input(str): 图片或者视频的路径； - 更多详情请参考：[deoldify](https://github.com/jantic/DeOldify)
**返回** ## 二、安装
若输入是图片，返回值为： - ### 1、环境依赖
* pred_img(np.ndarray): BGR图片数据；
* out_path(str): 保存图片路径。
若输入是视频，返回值为： - paddlepaddle >= 2.0.0
* frame_pattern_combined(str): 视频着色后单帧数据保存路径；
* vid_out_path(str): 视频保存路径。
```python - paddlehub >= 2.0.0
def run_image(self, img):
```
图像着色API， 得到着色后的图片。
**参数** - NOTE: 使用该模型需要自行安装ffmpeg，若您使用conda环境，推荐使用如下语句进行安装。
* img (str｜np.ndarray): 图片路径或则BGR格式图片。 ```shell
$ conda install x264=='1!152.20180717' ffmpeg=4.0.2 -c conda-forge
```
**返回**
* pred_img(np.ndarray): BGR图片数据； - ### 2、安装
- ```shell
$ hub install deoldify
```
- 如您安装时遇到问题，可参考：[零基础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 run_video(self, video):
```
视频着色API， 得到着色后的视频。
**参数**
* video (str): 待处理视频路径。
**返回** ## 三、模型API预测
- ### 1、代码示例
* frame_pattern_combined(str): 视频着色后单帧数据保存路径； ```python
* vid_out_path(str): 视频保存路径。 import paddlehub as hub
## 预测代码示例 model = hub.Module(name='deoldify')
model.predict('/PATH/TO/IMAGE/OR/VIDEO')
```
```python - ### 2、API
import paddlehub as hub
model = hub.Module(name='deoldify') - ```python
model.predict('/PATH/TO/IMAGE/OR/VIDEO') def predict(self, input):
``` ```
## 服务部署 - 着色变换API，得到着色后的图片或者视频。
PaddleHub Serving可以部署一个在线照片着色服务。 - **参数**
## 第一步：启动PaddleHub Serving - input(str): 图片或者视频的路径；
运行启动命令： - **返回**
```shell
$ hub serving start -m deoldify
```
这样就完成了一个图像着色的在线服务API的部署，默认端口号为8866。 - 若输入是图片，返回值为：
- pred_img(np.ndarray): BGR图片数据；
- out_path(str): 保存图片路径。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - 若输入是视频，返回值为：
- frame_pattern_combined(str): 视频着色后单帧数据保存路径；
- vid_out_path(str): 视频保存路径。
## 第二步：发送预测请求 - ```python
def run_image(self, img):
```
- 图像着色API， 得到着色后的图片。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **参数**
```python - img (str｜np.ndarray): 图片路径或则BGR格式图片。
import requests
import json
import base64
import cv2 - **返回**
import numpy as np
def cv2_to_base64(image): - pred_img(np.ndarray): BGR图片数据；
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请求 - ```python
org_im = cv2.imread('/PATH/TO/ORIGIN/IMAGE') def run_video(self, video):
data = {'images':cv2_to_base64(org_im)} ```
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/deoldify"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
img = base64_to_cv2(r.json()["results"])
cv2.imwrite('/PATH/TO/SAVE/IMAGE', img)
```
- 视频着色API， 得到着色后的视频。
## 模型相关信息 - **参数**
### 模型代码 - video (str): 待处理视频路径。
https://github.com/jantic/DeOldify - **返回**
### 依赖 - frame_pattern_combined(str): 视频着色后单帧数据保存路径；
- vid_out_path(str): 视频保存路径。
paddlepaddle >= 2.0.0rc ## 四、服务部署
paddlehub >= 1.8.3 - PaddleHub Serving可以部署一个在线照片着色服务
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m deoldify
```
- 这样就完成了一个图像着色的在线服务API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
import cv2
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/ORIGIN/IMAGE')
data = {'images':cv2_to_base64(org_im)}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/deoldify"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
img = base64_to_cv2(r.json()["results"])
cv2.imwrite('/PATH/TO/SAVE/IMAGE', img)
```
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
适配paddlehub2.0版本
modules/image/Image_editing/colorization/photo_restoration/README.md
浏览文件 @ a4d455b8
## 模型概述 # photo_restoration
photo_restoration 是针对老照片修复的模型。它主要由两个部分组成：着色和超分。着色模型基于deoldify |模型名称|photo_restoration|
，超分模型基于realsr. 用户可以根据自己的需求选择对图像进行着色或超分操作。因此在使用该模型时，请预先安装deoldify和realsr两个模型。 | :--- | :---: |
|类别|图像-图像编辑|
|网络|基于deoldify和realsr模型|
|是否支持Fine-tuning|否|
|模型大小|64MB+834MB|
|指标|-|
|最新更新日期|2021-08-19|
## API
```python ## 一、模型基本信息
def run_image(self,
input,
model_select= ['Colorization', 'SuperResolution'],
save_path = 'photo_restoration'):
```
预测API，用于图片修复。 - ### 应用效果展示
- 样例结果示例(左为原图，右为效果图)：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/130897828-d0c86b81-63d1-4e9a-8095-bc000b8c7ca8.jpg" width = "260" height = "400" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130897762-5c9fa711-62bc-4067-8d44-f8feff8c574c.png" width = "260" height = "400" hspace='10'/>
</p>
**参数**
* input (numpy.ndarray｜str): 图片数据，numpy.ndarray 或者 str形式。ndarray.shape 为 \[H, W, C\]，BGR格式; str为图片的路径。
* model_select (list\[str\]): 选择对图片对操作，\['Colorization'\]对图像只进行着色操作， \['SuperResolution'\]对图像只进行超分操作； - ### 模型介绍
默认值为\['Colorization', 'SuperResolution'\]。
* save_path (str): 保存图片的路径, 默认为'photo_restoration'。 - photo_restoration 是针对老照片修复的模型。它主要由两个部分组成：着色和超分。着色模型基于deoldify
，超分模型基于realsr. 用户可以根据自己的需求选择对图像进行着色或超分操作。因此在使用该模型时，请预先安装deoldify和realsr两个模型。
**返回** ## 二、安装
* output (numpy.ndarray): 照片修复结果，ndarray.shape 为 \[H, W, C\]，BGR格式。 - ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
## 代码示例 - NOTE: 使用该模型需要自行安装ffmpeg，若您使用conda环境，推荐使用如下语句进行安装。
图片修复代码示例： ```shell
$ conda install x264=='1!152.20180717' ffmpeg=4.0.2 -c conda-forge
```
- ### 2、安装
- ```shell
$ hub install photo_restoration
```
- 如您安装时遇到问题，可参考：[零基础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 cv2
import paddlehub as hub
model = hub.Module(name='photo_restoration', visualization=True)
im = cv2.imread('/PATH/TO/IMAGE')
res = model.run_image(im)
``` ## 三、模型API预测
- ### 1、代码示例
## 服务部署 ```python
import cv2
import paddlehub as hub
PaddleHub Serving可以部署一个照片修复的在线服务。 model = hub.Module(name='photo_restoration', visualization=True)
im = cv2.imread('/PATH/TO/IMAGE')
res = model.run_image(im)
## 第一步：启动PaddleHub Serving ```
- ### 2、API
运行启动命令：
```shell ```python
$ hub serving start -m photo_restoration def run_image(self,
``` input,
model_select= ['Colorization', 'SuperResolution'],
save_path = 'photo_restoration'):
```
这样就完成了一个照片修复的服务化API的部署，默认端口号为8866。 - 预测API，用于图片修复。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - **参数**
## 第二步：发送预测请求 - input (numpy.ndarray｜str): 图片数据，numpy.ndarray 或者 str形式。ndarray.shape 为 \[H, W, C\]，BGR格式; str为图片的路径。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - model_select (list\[str\]): 选择对图片对操作，\['Colorization'\]对图像只进行着色操作， \['SuperResolution'\]对图像只进行超分操作；
默认值为\['Colorization', 'SuperResolution'\]。
```python - save_path (str): 保存图片的路径, 默认为'photo_restoration'。
import requests
import json
import base64
import cv2 - **返回**
import numpy as np
def cv2_to_base64(image): - output (numpy.ndarray): 照片修复结果，ndarray.shape 为 \[H, W, C\]，BGR格式。
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), 'model_select': ['Colorization', 'SuperResolution']}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/photo_restoration"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
img = base64_to_cv2(r.json()["results"])
cv2.imwrite('PATH/TO/SAVE/IMAGE', img)
```
### 依赖
paddlepaddle >= 2.0.0rc ## 四、服务部署
paddlehub >= 1.8.2 - PaddleHub Serving可以部署一个照片修复的在线服务。
- ## 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m photo_restoration
```
- 这样就完成了一个照片修复的服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
import cv2
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), 'model_select': ['Colorization', 'SuperResolution']}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/photo_restoration"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
img = base64_to_cv2(r.json()["results"])
cv2.imwrite('PATH/TO/SAVE/IMAGE', img)
```
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
适配paddlehub2.0版本
modules/image/Image_editing/super_resolution/falsr_c/README.md
浏览文件 @ a4d455b8
## 模型概述 # falsr_c
falsr_c是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
## 命令行预测 |模型名称|falsr_c|
| :--- | :---: |
|类别|图像-图像编辑|
|网络|falsr_c|
|数据集|DIV2k|
|是否支持Fine-tuning|否|
|模型大小|4.4MB|
|PSNR|37.66|
|最新更新日期|2021-02-26|
```
$ hub run falsr_c --input_path "/PATH/TO/IMAGE"
``` ## 一、模型基本信息
## API - ### 应用效果展示
- 样例结果示例(左为原图，右为效果图)：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/133558583-0b7049db-ed1f-4a16-8676-f2141fcb3dee.png" width = "450" height = "300" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130899031-a6f8c58a-5cb7-4105-b990-8cca5ae15368.png" width = "450" height = "300" hspace='10'/>
</p>
```python
def reconstruct(self,
images=None,
paths=None,
use_gpu=False,
visualization=False,
output_dir="falsr_c_output")
```
预测API，用于图像超分辨率。 - ### 模型介绍
**参数** - falsr_c是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - 更多详情请参考：[falsr_c](https://github.com/xiaomi-automl/FALSR)
* paths (list\[str\]): 图片的路径；
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
**返回** ## 二、安装
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为： - ### 1、环境依赖
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 超分辨后图像。
```python - paddlepaddle >= 2.0.0
def save_inference_model(self,
dirname='falsr_c_save_model',
model_filename=None,
params_filename=None,
combined=False)
```
将模型保存到指定路径。 - paddlehub >= 2.0.0
**参数**
* dirname: 存在模型的目录名称 - ### 2、安装
* model\_filename: 模型文件名称，默认为\_\_model\_\_ - ```shell
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效) $ hub install falsr_c
* 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)
```python ## 三、模型API预测
import cv2 - ### 1、命令行预测
import paddlehub as hub
sr_model = hub.Module(name='falsr_c') - ```
im = cv2.imread('/PATH/TO/IMAGE').astype('float32') $ hub run falsr_c --input_path "/PATH/TO/IMAGE"
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。 ```
res = sr_model.reconstruct(images=[im], visualization=True) - ### 代码示例
print(res[0]['data'])
sr_model.save_inference_model()
```
## 服务部署 ```python
import cv2
import paddlehub as hub
PaddleHub Serving可以部署一个图像超分的在线服务。 sr_model = hub.Module(name='falsr_c')
im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
res = sr_model.reconstruct(images=[im], visualization=True)
print(res[0]['data'])
sr_model.save_inference_model()
```
## 第一步：启动PaddleHub Serving - ### 2、API
运行启动命令： - ```python
def reconstruct(self,
images=None,
paths=None,
use_gpu=False,
visualization=False,
output_dir="falsr_c_output")
```
```shell - 预测API，用于图像超分辨率。
$ hub serving start -m falsr_c
```
这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。 - **参数**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
## 第二步：发送预测请求 - **返回**
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 超分辨后图像。
```python - ```python
import requests def save_inference_model(self,
import json dirname='falsr_c_save_model',
import base64 model_filename=None,
params_filename=None,
combined=False)
```
import cv2 - 将模型保存到指定路径。
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请求 * dirname: 存在模型的目录名称
org_im = cv2.imread('/PATH/TO/IMAGE') * model\_filename: 模型文件名称，默认为\_\_model\_\_
data = {'images':[cv2_to_base64(org_im)]} * params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
headers = {"Content-type": "application/json"} * combined: 是否将参数保存到统一的一个文件中
url = "http://127.0.0.1:8866/predict/falsr_c"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = base64_to_cv2(r.json()["results"][0]['data'])
cv2.imwrite('falsr_c_X2.png', sr)
print("save image as falsr_c_X2.png")
```
### 查看代码
https://github.com/xiaomi-automl/FALSR
## 四、服务部署
### 依赖 - PaddleHub Serving可以部署一个图像超分的在线服务。
paddlepaddle >= 1.8.0 - ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m falsr_c
```
- 这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
import cv2
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/falsr_c"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = base64_to_cv2(r.json()["results"][0]['data'])
cv2.imwrite('falsr_c_X2.png', sr)
print("save image as falsr_c_X2.png")
```
## 五、更新历史
* 1.0.0
初始发布
paddlehub >= 1.7.1
modules/image/Image_editing/super_resolution/realsr/README.md
浏览文件 @ a4d455b8
# realsr
## 模型概述 |模型名称|reasr|
realsr是用于图像和视频超分模型，该模型基于Toward Real-World Single Image Super-Resolution: A New Benchmark and A New Mode，它能够将输入的图片和视频超分四倍。 | :--- | :---: |
|类别|图像-图像编辑|
|网络|LP-KPN|
|数据集|RealSR dataset|
|是否支持Fine-tuning|否|
|模型大小|64MB|
|PSNR|29.05|
|最新更新日期|2021-02-26|
## API 说明
```python
def predict(self, input):
```
超分API，得到超分后的图片或者视频。 ## 一、模型基本信息
- ### 应用效果展示
**参数** - 样例结果示例(左为原图，右为效果图)：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/133558583-0b7049db-ed1f-4a16-8676-f2141fcb3dee.png" width = "450" height = "300" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130789888-a0d4f78e-acd6-44c1-9570-7390e90ae8dc.png" width = "450" height = "300" hspace='10'/>
</p>
* input (str): 图片或者视频的路径； - ### 模型介绍
**返回** - realsr是用于图像和视频超分模型，该模型基于Toward Real-World Single Image Super-Resolution: A New Benchmark and A New Mode，它能够将输入的图片和视频超分四倍。
- 更多详情请参考：[realsr](https://github.com/csjcai/RealSR)
若输入是图片，返回值为： ## 二、安装
* pred_img(np.ndarray): BGR图片数据；
* out_path(str): 保存图片路径。
若输入是视频，返回值为： - ### 1、环境依赖
* frame_pattern_combined(str): 视频超分后单帧数据保存路径；
* vid_out_path(str): 视频保存路径。
```python - paddlepaddle >= 2.0.0
def run_image(self, img):
```
图像超分API， 得到超分后的图片。
**参数** - paddlehub >= 2.0.0
* img (str｜np.ndarray): 图片路径或则BGR格式图片。 - NOTE: 使用该模型需要自行安装ffmpeg，若您使用conda环境，推荐使用如下语句进行安装。
**返回** ```shell
$ conda install x264=='1!152.20180717' ffmpeg=4.0.2 -c conda-forge
```
* pred_img(np.ndarray): BGR图片数据；
```python - ### 2、安装
def run_video(self, video):
```
视频超分API， 得到超分后的视频。
**参数** - ```shell
$ hub install realsr
```
- 如您安装时遇到问题，可参考：[零基础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)
* video(str): 待处理视频路径。
**返回**
* frame_pattern_combined(str): 视频超分后单帧数据保存路径； ## 三、模型API预测
* vid_out_path(str): 视频保存路径。
## 预测代码示例 - ### 1、代码示例
```python ```python
import paddlehub as hub import paddlehub as hub
model = hub.Module(name='realsr') model = hub.Module(name='realsr')
model.predict('/PATH/TO/IMAGE/OR/VIDEO') model.predict('/PATH/TO/IMAGE/OR/VIDEO')
``` ```
- ### 2、API
## 服务部署 - ```python
def predict(self, input):
```
PaddleHub Serving可以部署一个在线照片超分服务。 - 超分API，得到超分后的图片或者视频。
## 第一步：启动PaddleHub Serving
运行启动命令： - **参数**
```shell
$ hub serving start -m realsr
```
这样就完成了一个图像超分的在线服务API的部署，默认端口号为8866。 - input (str): 图片或者视频的路径；
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - **返回**
## 第二步：发送预测请求 - 若输入是图片，返回值为：
- pred_img(np.ndarray): BGR图片数据；
- out_path(str): 保存图片路径。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 若输入是视频，返回值为：
- frame_pattern_combined(str): 视频超分后单帧数据保存路径；
- vid_out_path(str): 视频保存路径。
```python - ```python
import requests def run_image(self, img):
import json ```
import base64 - 图像超分API， 得到超分后的图片。
import cv2 - **参数**
import numpy as np
def cv2_to_base64(image): - img (str｜np.ndarray): 图片路径或则BGR格式图片。
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/realsr"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
img = base64_to_cv2(r.json()["results"])
cv2.imwrite('/PATH/TO/SAVE/IMAGE', img)
``` - pred_img(np.ndarray): BGR图片数据；
## 模型相关信息 - ```python
def run_video(self, video):
```
- 视频超分API， 得到超分后的视频。
### 模型代码 - **参数**
https://github.com/csjcai/RealSR - video(str): 待处理视频路径。
### 依赖 - **返回**
paddlepaddle >= 2.0.0rc - frame_pattern_combined(str): 视频超分后单帧数据保存路径；
- vid_out_path(str): 视频保存路径。
## 四、服务部署
- PaddleHub Serving可以部署一个在线照片超分服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m realsr
```
- 这样就完成了一个图像超分的在线服务API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
import cv2
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/realsr"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
img = base64_to_cv2(r.json()["results"])
cv2.imwrite('/PATH/TO/SAVE/IMAGE', img)
```
## 五、更新历史
* 1.0.0
初始发布
* 1.0.1
适配paddlehub2.0版本
paddlehub >= 1.8.3
modules/image/Image_gan/style_transfer/msgnet/README.md 0 → 100644
浏览文件 @ a4d455b8
# msgnet
|模型名称|msgnet|
| :--- | :---: |
|类别|图像-图像编辑|
|网络|msgnet|
|数据集|COCO2014|
|是否支持Fine-tuning|是|
|模型大小|68MB|
|指标|-|
|最新更新日期|2021-07-29|
## 一、模型基本信息
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/130910325-d72f34b2-d567-4e77-bb60-35148864301e.jpg" width = "450" height = "300" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130910195-9433e4a7-3596-4677-85d2-2ffc16939597.png" width = "450" height = "300" hspace='10'/>
</p>
- ### 模型介绍
- 本示例将展示如何使用PaddleHub对预训练模型进行finetune并完成预测任务。
- 更多详情请参考：[msgnet](https://github.com/zhanghang1989/PyTorch-Multi-Style-Transfer)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install msgnet
```
- 如您安装时遇到问题，可参考：[零基础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.命令行预测
```
$ hub run msgnet --input_path "/PATH/TO/ORIGIN/IMAGE" --style_path "/PATH/TO/STYLE/IMAGE"
```
- ### 2.预测代码示例
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='msgnet')
result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path ='style_tranfer')
```
- ### 3.如何开始Fine-tune
- 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用msgnet模型对[MiniCOCO](../../docs/reference/datasets.md#class-hubdatasetsMiniCOCO)等数据集进行Fine-tune。
- 代码步骤
- Step1: 定义数据预处理方式
- ```python
import paddlehub.vision.transforms as T
transform = T.Compose([T.Resize((256, 256), interpolation='LINEAR')])
```
- `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
- Step2: 下载数据集并使用
- ```python
from paddlehub.datasets.minicoco import MiniCOCO
styledata = MiniCOCO(transform=transform, mode='train')
```
- `transforms`: 数据预处理方式。
- `mode`: 选择数据模式，可选项有 `train`, `test`， 默认为`train`。
- 数据集的准备代码可以参考 [minicoco.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.MiniCOCO()`会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
- Step3: 加载预训练模型
- ```python
model = hub.Module(name='msgnet', load_checkpoint=None)
```
- `name`: 选择预训练模型的名字。
- `load_checkpoint`: 是否加载自己训练的模型，若为None，则加载提供的模型默认参数。
- Step4: 选择优化策略和运行配置
- ```python
optimizer = paddle.optimizer.Adam(learning_rate=0.0001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='test_style_ckpt')
trainer.train(styledata, epochs=101, batch_size=4, eval_dataset=styledata, log_interval=10, save_interval=10)
```
- 模型预测
- 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。我们使用该模型来进行预测。predict.py脚本如下：
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='msgnet', load_checkpoint="/PATH/TO/CHECKPOINT")
result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path ='style_tranfer')
```
- 参数配置正确后，请执行脚本`python predict.py`， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
- **Args**
* `origin`:原始图像路径或BGR格式图片；
* `style`: 风格图像路径；
* `visualization`: 是否可视化，默认为True；
* `save_path`: 保存结果的路径，默认保存路径为'style_tranfer'。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 四、服务部署
- PaddleHub Serving可以部署一个在线风格迁移服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m msgnet
```
- 这样就完成了一个风格迁移服务化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/ORIGIN/IMAGE')
style_im = cv2.imread('/PATH/TO/STYLE/IMAGE')
data = {'images':[[cv2_to_base64(org_im)], cv2_to_base64(style_im)]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/msgnet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
data = base64_to_cv2(r.json()["results"]['data'][0])
cv2.imwrite('style.png', data)
```
## 五、更新历史
* 1.0.0
初始发布
modules/image/classification/resnet50_vd_animals/README.md
浏览文件 @ a4d455b8
```shell # resnet50_vd_animals
$ hub install resnet50_vd_animals==1.0.0
```
<p align="center"> |模型名称|resnet50_vd_animals|
<img src="http://bj.bcebos.com/ibox-thumbnail98/77fa9b7003e4665867855b2b65216519?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A05%3A10Z%2F1800%2F%2F1df0ecb4a52adefeae240c9e2189e8032560333e399b3187ef1a76e4ffa5f19f" hspace='5' width=800/> <br /> ResNet 系列的网络结构 | :--- | :---: |
</p> |类别|图像-图像分类|
|网络|ResNet50_vd|
|数据集|百度自建动物数据集|
|是否支持Fine-tuning|否|
|模型大小|154MB|
|指标|-|
|最新更新日期|2021-02-26|
模型的详情可参考[论文](https://arxiv.org/pdf/1812.01187.pdf)
## 命令行预测 ## 一、模型基本信息
```
hub run resnet50_vd_animals --input_path "/PATH/TO/IMAGE"
```
## API - ### 模型介绍
```python - ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种，可用于图像分类和特征提取。该 PaddleHub Module 采用百度自建动物数据集训练得到，支持7978种动物的分类识别。
def get_expected_image_width()
```
返回预处理的图片宽度，也就是224。 - 模型的详情可参考[论文](https://arxiv.org/pdf/1812.01187.pdf)
```python ## 二、安装
def get_expected_image_height()
```
返回预处理的图片高度，也就是224。 - ### 1、环境依赖
```python - paddlepaddle >= 2.0.0
def get_pretrained_images_mean()
```
返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。 - paddlehub >= 2.0.0
```python - ### 2、安装
def get_pretrained_images_std()
```
返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。 - ```shell
$ hub install resnet50_vd_animals==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)
## 三、模型API预测
- ### 1、命令行预测
```python - ```
def context(trainable=True, pretrained=True) hub run resnet50_vd_animals --input_path "/PATH/TO/IMAGE"
``` ```
**参数** - ### 2、代码示例
* trainable (bool): 计算图的参数是否为可训练的； - ```python
* pretrained (bool): 是否加载默认的预训练模型。 import paddlehub as hub
import cv2
**返回** classifier = hub.Module(name="resnet50_vd_animals")
* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量； result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为： # or
* classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出； # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
* feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。 ```
* context\_prog(fluid.Program): 计算图，用于迁移学习。 - ### 3、API
```python - ```python
def classification(images=None, def get_expected_image_width()
paths=None, ```
batch_size=1,
use_gpu=False,
top_k=1):
```
**参数** - 返回预处理的图片宽度，也就是224。
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； - ```python
* paths (list\[str\]): 图片的路径； def get_expected_image_height()
* batch\_size (int): batch 的大小； ```
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
**返回** - 返回预处理的图片高度，也就是224。
res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。 - ```python
def get_pretrained_images_mean()
```
```python - 返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。 - ```python
def get_pretrained_images_std()
```
**参数** - 返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
* dirname: 存在模型的目录名称
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 代码示例 - ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
```python - **参数**
import paddlehub as hub
import cv2
classifier = hub.Module(name="resnet50_vd_animals") * images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')]) - **返回**
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
## 服务部署 - res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
PaddleHub Serving可以部署一个在线动物识别服务。 - ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
## 第一步：启动PaddleHub Serving - 将模型保存到指定路径。
运行启动命令： - **参数**
```shell
$ hub serving start -m resnet50_vd_animals
```
这样就完成了一个在线动物识别服务化API的部署，默认端口号为8866。 * dirname: 存在模型的目录名称
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求 ## 四、服务部署
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - PaddleHub Serving可以部署一个在线动物识别服务。
```python - ### 第一步：启动PaddleHub Serving
import requests
import json
import cv2
import base64
- 运行启动命令：
def cv2_to_base64(image): - ```shell
data = cv2.imencode('.jpg', image)[1] $ hub serving start -m resnet50_vd_animals
return base64.b64encode(data.tostring()).decode('utf8') ```
- 这样就完成了一个在线动物识别服务化API的部署，默认端口号为8866。
# 发送HTTP请求 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/resnet50_vd_animals"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果 - ### 第二步：发送预测请求
print(r.json()["results"])
```
### 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
[PaddlePaddle/models 图像分类](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification) ```python
import requests
import json
import cv2
import base64
### 依赖
paddlepaddle >= 1.6.2 def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
paddlehub >= 1.6.0
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/resnet50_vd_animals"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
modules/image/classification/resnet50_vd_imagenet_ssld/README.md 0 → 100644
浏览文件 @ a4d455b8
# resnet50_vd_imagenet_ssld
|模型名称|resnet50_vd_imagenet_ssld|
| :--- | :---: |
|类别|图像-图像分类|
|网络|ResNet_vd|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|148MB|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 模型介绍
- ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种，可用于图像分类和特征提取。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install resnet50_vd_imagenet_ssld
```
- 如您安装时遇到问题，可参考：[零基础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 resnet50_vd_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='resnet50_vd_imagenet_ssld')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
- 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用resnet50_vd_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
- 代码步骤
- Step1: 定义数据预处理方式
- ```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
- `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
- Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
* `transforms`: 数据预处理方式。
* `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
* 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
- Step3: 加载预训练模型
- ```python
model = hub.Module(name="resnet50_vd_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
- Step4: 选择优化策略和运行配置
```python
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
- 运行配置
- `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* `model`: 被优化模型；
* `optimizer`: 优化器选择；
* `use_vdl`: 是否使用vdl可视化训练过程；
* `checkpoint_dir`: 保存模型参数的地址；
* `compare_metrics`: 保存最优模型的衡量指标；
- `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
* `train_dataset`: 训练时所用的数据集；
* `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
- 模型预测
- 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='resnet50_vd_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg'])
```
- **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 四、服务部署
- PaddleHub Serving可以部署一个在线分类任务服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m resnet50_vd_imagenet_ssld
```
- 这样就完成了一个分类任务服务化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)], 'top_k':2}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/resnet50_vd_imagenet_ssld"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
data =r.json()["results"]['data']
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
升级为动态图版本
modules/image/semantic_segmentation/ExtremeC3_Portrait_Segmentation/README.md
浏览文件 @ a4d455b8
## 概述 # ExtremeC3_Portrait_Segmentation
* 基于 ExtremeC3 模型实现的轻量化人像分割模型
* 模型具体规格如下： |模型名称|ExtremeC3_Portrait_Segmentation|
|model|ExtremeC3| | :--- | :---: |
|----|----| |类别|图像-图像分割|
|Param|0.038 M| |网络|ExtremeC3|
|Flop|0.128 G| |数据集|EG1800, Baidu fashion dataset|
|是否支持Fine-tuning|否|
* 模型参数转换至 [ext_portrait_segmentation](https://github.com/clovaai/ext_portrait_segmentation) 项目 |模型大小|0.038MB|
* 感谢 [ext_portrait_segmentation](https://github.com/clovaai/ext_portrait_segmentation) 项目提供的开源代码和模型 |指标|-|
|最新更新日期|2021-02-26|
## 效果展示
![](https://ai-studio-static-online.cdn.bcebos.com/1261398a98e24184852bdaff5a4e1dbd7739430f59fb47e8b84e3a2cfb976107) ## 一、模型基本信息
## API - ### 应用效果展示
```python
def Segmentation( - 样例结果示例：
images=None, <p align="center">
paths=None, <img src="https://ai-studio-static-online.cdn.bcebos.com/1261398a98e24184852bdaff5a4e1dbd7739430f59fb47e8b84e3a2cfb976107" hspace='10'/> <br />
batch_size=1, </p>
output_dir='output',
visualization=False):
``` - ### 模型介绍
人像分割 API * 基于 ExtremeC3 模型实现的轻量化人像分割模型
**参数** * 更多详情请参考： [ExtremeC3_Portrait_Segmentation](https://github.com/clovaai/ext_portrait_segmentation) 项目
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表 ## 二、安装
* batch_size (int) : 数据批大小
* output_dir (str) : 可视化图像输出目录 - ### 1、环境依赖
* visualization (bool) : 是否可视化 - paddlepaddle >= 2.0.0
**返回** - paddlehub >= 2.0.0
* results (list[dict{"mask":np.ndarray,"result":np.ndarray}]): 输出图像数据列表
- ### 2、安装
**代码示例**
```python - ```shell
import cv2 $ hub install ExtremeC3_Portrait_Segmentation
import paddlehub as hub ```
model = hub.Module(name='ExtremeC3_Portrait_Segmentation') - 如您安装时遇到问题，可参考：[零基础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)
result = model.Segmentation(
images=[cv2.imread('/PATH/TO/IMAGE')],
paths=None, ## 三、模型API预测
batch_size=1,
output_dir='output', - ### 1、代码示例
visualization=False)
``` ```python
import cv2
## 查看代码 import paddlehub as hub
https://github.com/clovaai/ext_portrait_segmentation
model = hub.Module(name='ExtremeC3_Portrait_Segmentation')
## 依赖
paddlepaddle >= 2.0.0rc0 result = model.Segmentation(
paddlehub >= 2.0.0b1 images=[cv2.imread('/PATH/TO/IMAGE')],
paths=None,
batch_size=1,
output_dir='output',
visualization=False)
```
- ### 2、API
```python
def Segmentation(
images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False):
```
- 人像分割 API
- **参数**
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
- **返回**
* results (list[dict{"mask":np.ndarray,"result":np.ndarray}]): 输出图像数据列表
## 四、更新历史
* 1.0.0
初始发布
modules/image/semantic_segmentation/ace2p/README.md
浏览文件 @ a4d455b8
```shell # ace2p
$ hub install ace2p==1.1.0
```
<p align="center"> |模型名称|ace2p|
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_network.jpg" hspace='10'/> <br /> | :--- | :---: |
</p> |类别|图像-图像分割|
|网络|ACE2P|
|数据集|LIP|
|是否支持Fine-tuning|否|
|模型大小|259MB|
|指标|-|
|最新更新日期|2021-02-26|
## 命令行预测
``` ## 一、模型基本信息
hub run ace2p --input_path "/PATH/TO/IMAGE"
```
## API - ### 应用效果展示
```python - 网络结构：
def segmentation(images=None, <p align="center">
paths=None, <img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_network.jpg" hspace='10'/> <br />
batch_size=1, </p>
use_gpu=False,
output_dir='ace2p_output',
visualization=False):
```
预测API，用于图像分割得到人体解析。 - 调色板
**参数** <p align="left">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_palette.jpg" hspace='10'/> <br />
</p>
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - 样例结果示例：
* paths (list\[str\]): 图片的路径； <p align="center">
* batch\_size (int): batch 的大小； <img src="https://user-images.githubusercontent.com/35907364/130913092-312a5f37-842e-4fd0-8db4-5f853fd8419f.jpg" width = "337" height = "505" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130913765-c9572c77-c6bf-46ec-9653-04ff356b4b85.png" width = "337" height = "505" hspace='10'/>
* use\_gpu (bool): 是否使用 GPU； </p>
* output\_dir (str): 保存处理结果的文件目录；
* visualization (bool): 是否将识别结果保存为图片文件。
**返回** - ### 模型介绍
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有'path', 'data'，相应的取值为： - 人体解析(Human Parsing)是细粒度的语义分割任务，其旨在识别像素级别的人类图像的组成部分（例如，身体部位和服装）。ACE2P通过融合底层特征，全局上下文信息和边缘细节，端到端地训练学习人体解析任务。该结构针对Intersection over Union指标进行针对性的优化学习，提升准确率。以ACE2P单人人体解析网络为基础的解决方案在CVPR2019第三届LIP挑战赛中赢得了全部三个人体解析任务的第一名。该PaddleHub Module采用ResNet101作为骨干网络，接受输入图片大小为473x473x3。
* path (str): 原输入图片的路径；
* data (numpy.ndarray): 图像分割得到的结果，shape 为`H * W`，元素的取值为0-19，表示每个像素的分类结果，映射顺序与下面的调色板相同。
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。
**参数** ## 二、安装
* dirname: 存在模型的目录名称 - ### 1、环境依赖
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中。
## 代码示例 - paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0
import paddlehub as hub
import cv2
human_parser = hub.Module(name="ace2p") - ### 2.安装
result = human_parser.segmentation(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = human_parser.segmentation((paths=['/PATH/TO/IMAGE'])
```
## 服务部署 - ```shell
$ hub install ace2p
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
PaddleHub Serving可以部署一个人体解析的在线服务。 ## 三、模型API预测
- ### 1、命令行预测
### 第一步：启动PaddleHub Serving ```shell
$ hub install ace2p==1.1.0
```
运行启动命令： - ### 2、代码示例
```shell
$ hub serving start -m ace2p
```
这样就完成了一个人体解析服务化API的部署，默认端口号为8866。 ```python
import paddlehub as hub
import cv2
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 human_parser = hub.Module(name="ace2p")
result = human_parser.segmentation(images=[cv2.imread('/PATH/TO/IMAGE')])
```
- ### 3、API
### 第二步：发送预测请求 ```python
def segmentation(images=None,
paths=None,
batch_size=1,
use_gpu=False,
output_dir='ace2p_output',
visualization=False):
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 预测API，用于图像分割得到人体解析。
```python - **参数**
import requests
import json
import cv2
import base64
import numpy as np * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* output\_dir (str): 保存处理结果的文件目录；
* visualization (bool): 是否将识别结果保存为图片文件。
- **返回**
def cv2_to_base64(image): * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有'path', 'data'，相应的取值为：
data = cv2.imencode('.jpg', image)[1] * path (str): 原输入图片的路径；
return base64.b64encode(data.tostring()).decode('utf8') * data (numpy.ndarray): 图像分割得到的结果，shape 为`H * W`，元素的取值为0-19，表示每个像素的分类结果，映射顺序与下面的调色板相同。
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
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请求 * dirname: 存在模型的目录名称
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]} * model\_filename: 模型文件名称，默认为\_\_model\_\_
headers = {"Content-type": "application/json"} * params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
url = "http://127.0.0.1:8866/predict/ace2p" * combined: 是否将参数保存到统一的一个文件中。
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(base64_to_cv2(r.json()["results"][0]['data']))
```
## 调色板 ## 四、服务部署
<p align="left"> - PaddleHub Serving可以部署一个人体解析的在线服务。
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_palette.jpg" hspace='10'/> <br />
</p>
## 依赖 - ### 第一步：启动PaddleHub Serving
paddlepaddle >= 1.6.2 - 运行启动命令：
```shell
$ hub serving start -m ace2p
```
paddlehub >= 1.6.0 - 这样就完成了一个人体解析服务化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请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ace2p"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(base64_to_cv2(r.json()["results"][0]['data']))
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
适配paddlehub2.0版本
modules/image/semantic_segmentation/deeplabv3p_xception65_humanseg/README.md
浏览文件 @ a4d455b8
## 命令行预测 # deeplabv3p_xception65_humanseg
``` |模型名称|deeplabv3p_xception65_humanseg|
hub run deeplabv3p_xception65_humanseg --input_path "/PATH/TO/IMAGE" | :--- | :---: |
``` |类别|图像-图像分割|
|网络|deeplabv3p|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|162MB|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/130913092-312a5f37-842e-4fd0-8db4-5f853fd8419f.jpg" width = "337" height = "505" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130913256-41056b21-1c3d-4ee2-b481-969c94754609.png" width = "337" height = "505" hspace='10'/>
</p>
- ### 模型介绍
- DeepLabv3+使用百度自建数据集进行训练，可用于人像分割，支持任意大小的图片输入。
<p align="center"> <p align="center">
<img src="https://paddlehub.bj.bcebos.com/paddlehub-img/deeplabv3plus.png" hspace='10'/> <br /> <img src="https://paddlehub.bj.bcebos.com/paddlehub-img/deeplabv3plus.png" hspace='10'/> <br />
</p> </p>
## API - 更多详情请参考：[deeplabv3p](https://github.com/PaddlePaddle/PaddleSeg)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install deeplabv3p_xception65_humanseg
```
- 如您安装时遇到问题，可参考：[零基础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 deeplabv3p_xception65_humanseg --input_path "/PATH/TO/IMAGE"
```
- ### 2.预测代码示例
```python
import paddlehub as hub
import cv2
human_seg = hub.Module(name="deeplabv3p_xception65_humanseg")
result = human_seg.segmentation(images=[cv2.imread('/PATH/TO/IMAGE')])
```
- ### 3.API
```python ```python
def segmentation(images=None, def segmentation(images=None,
paths=None, paths=None,
batch_size=1, batch_size=1,
use_gpu=False, use_gpu=False,
visualization=False, visualization=False,
output_dir='humanseg_output') output_dir='humanseg_output')
``` ```
预测API，用于人像分割。 - 预测API，用于人像分割。
**参数** - **参数**
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径； * paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小； * batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU； * use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件； * visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。 * output\_dir (str): 图片的保存路径。
**返回** - **返回**
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为： * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）； * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。 * data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。
```python ```python
def save_inference_model(dirname, def save_inference_model(dirname,
model_filename=None, model_filename=None,
params_filename=None, params_filename=None,
combined=True) combined=True)
``` ```
将模型保存到指定路径。 - 将模型保存到指定路径。
**参数** - **参数**
* dirname: 存在模型的目录名称 * dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_ * model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效) * params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中 * combined: 是否将参数保存到统一的一个文件中
## 代码示例
```python ## 四、服务部署
import paddlehub as hub
import cv2
human_seg = hub.Module(name="deeplabv3p_xception65_humanseg") - PaddleHub Serving可以部署一个人像分割的在线服务。
result = human_seg.segmentation(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = human_seg.segmentation(paths=['/PATH/TO/IMAGE'])
```
## 服务部署 - ### 第一步：启动PaddleHub Serving
PaddleHub Serving可以部署一个人像分割的在线服务。 - 运行启动命令：
## 第一步：启动PaddleHub Serving ```shell
$ hub serving start -m deeplabv3p_xception65_humanseg
```
运行启动命令： - 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
```shell
$ hub serving start -m deeplabv3p_xception65_humanseg
```
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - ### 第二步：发送预测请求
## 第二步：发送预测请求 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 ```python
import requests
import json
import cv2
import base64
import numpy as np
```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 cv2_to_base64(image): def base64_to_cv2(b64str):
data = cv2.imencode('.jpg', image)[1] data = base64.b64decode(b64str.encode('utf8'))
return base64.b64encode(data.tostring()).decode('utf8') data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return 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/deeplabv3p_xception65_humanseg"
r = requests.post(url=url, headers=headers, # 保存图片
mask =cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY)
rgba = np.concatenate((org_im, np.expand_dims(mask, axis=2)), axis=2)
cv2.imwrite("segment_human_server.png", rgba)
```
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
* 1.0.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/deeplabv3p_xception65_humanseg"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果 * 1.1.0
print(base64_to_cv2(r.json()["results"][0]['data']))
```
### 查看代码 提升预测性能
[PaddleSeg 特色垂类模型 - 人像分割](https://github.com/PaddlePaddle/PaddleSeg/tree/release/v0.4.0/contrib) * 1.1.1
### 依赖 修复预测后处理图像数据超过[0,255]范围
paddlepaddle >= 1.6.2 * 1.1.2
paddlehub >= 1.6.0 修复cudnn为8.0.4显存泄露问题
modules/image/semantic_segmentation/humanseg_lite/README.md
浏览文件 @ a4d455b8
## 模型概述 # humanseg_lite
|模型名称|humanseg_lite|
| :--- | :---: |
|类别|图像-图像分割|
|网络|shufflenet|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|541k|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/130913092-312a5f37-842e-4fd0-8db4-5f853fd8419f.jpg" width = "337" height = "505" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130916087-7d537ad9-bbc8-4bce-9382-8eb132b35532.png" width = "337" height = "505" hspace='10'/>
</p>
- ### 模型介绍
- HumanSeg_lite是在ShuffleNetV2网络结构的基础上进行优化，进一步减小了网络规模，网络大小只有541K，量化后只有187K， 适用于手机自拍人像分割，且能在移动端进行实时分割。
- 更多详情请参考：[humanseg_lite](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.2/contrib/HumanSeg)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install humanseg_lite
```
- 如您安装时遇到问题，可参考：[零基础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、命令行预测
```
hub run humanseg_lite --input_path "/PATH/TO/IMAGE"
```
- ### 2、代码示例
- 图片分割及视频分割代码示例：
HumanSeg_lite是基于ShuffleNetV2网络结构的基础上进行优化的人像分割模型，进一步减小了网络规模，网络大小只有541K，量化后只有187K，适用于手机自拍人像分割等实时分割场景。 ```python
import cv2
import paddlehub as hub
human_seg = hub.Module(name='humanseg_lite')
im = cv2.imread('/PATH/TO/IMAGE')
#visualization=True可以用于查看人像分割图片效果，可设置为False提升运行速度。
res = human_seg.segment(images=[im],visualization=True)
print(res[0]['data'])
human_seg.video_segment('/PATH/TO/VIDEO')
human_seg.save_inference_model('/PATH/TO/SAVE/MODEL')
## 命令行预测 ```
- 视频流预测代码示例：
``` ```python
hub run humanseg_lite --input_path "/PATH/TO/IMAGE" import cv2
import numpy as np
import paddlehub as hub
``` human_seg = hub.Module('humanseg_lite')
cap_video = cv2.VideoCapture('\PATH\TO\VIDEO')
fps = cap_video.get(cv2.CAP_PROP_FPS)
save_path = 'humanseg_lite_video.avi'
width = int(cap_video.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap_video.get(cv2.CAP_PROP_FRAME_HEIGHT))
cap_out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (width, height))
prev_gray = None
prev_cfd = None
while cap_video.isOpened():
ret, frame_org = cap_video.read()
if ret:
[img_matting, prev_gray, prev_cfd] = human_seg.video_stream_segment(frame_org=frame_org, frame_id=cap_video.get(1), prev_gray=prev_gray, prev_cfd=prev_cfd)
img_matting = np.repeat(img_matting[:, :, np.newaxis], 3, axis=2)
bg_im = np.ones_like(img_matting) * 255
comb = (img_matting * frame_org + (1 - img_matting) * bg_im).astype(np.uint8)
cap_out.write(comb)
else:
break
cap_video.release()
cap_out.release()
## API ```
```python - ### 3、API
def segment(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_lite_output')
```
预测API，用于人像分割。 ```python
def segment(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_lite_output')
```
**参数** - 预测API，用于人像分割。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - **参数**
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
**返回** * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为： - **返回**
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。
```python * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
def video_stream_segment(self, * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
frame_org, * data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
预测API，用于逐帧对视频人像分割。
**参数** ```python
def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
* frame_org (numpy.ndarray): 单帧图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - 预测API，用于逐帧对视频人像分割。
* frame_id (int): 当前帧的编号；
* prev_gray (numpy.ndarray): 前一帧输入网络图像的灰度图；
* prev_cfd (numpy.ndarray): 前一帧光流追踪图和预测结果融合图
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
- **参数**
**返回** * frame_org (numpy.ndarray): 单帧图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* frame_id (int): 当前帧的编号；
* prev_gray (numpy.ndarray): 前一帧输入网络图像的灰度图；
* prev_cfd (numpy.ndarray): 前一帧光流追踪图和预测结果融合图
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。
* cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图；
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图
- **返回**
```python * img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。
def video_segment(self, * cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图；
video_path=None, * optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图
use_gpu=False,
save_dir='humanseg_lite_video_result'):
```
预测API，用于视频人像分割。
**参数** ```python
def video_segment(self,
video_path=None,
use_gpu=False,
save_dir='humanseg_lite_video_result'):
```
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。 - 预测API，用于视频人像分割。
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
- **参数**
```python * video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
def save_inference_model(dirname='humanseg_lite_model', * use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
model_filename=None, * save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
params_filename=None,
combined=True)
```
将模型保存到指定路径。
**参数** ```python
def save_inference_model(dirname='humanseg_lite_model',
model_filename=None,
params_filename=None,
combined=True)
```
* dirname: 存在模型的目录名称 - 将模型保存到指定路径。
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 代码示例 - **参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
图片分割及视频分割代码示例： ## 四、服务部署
```python
import cv2
import paddlehub as hub
human_seg = hub.Module(name='humanseg_lite') - PaddleHub Serving可以部署一个人像分割的在线服务。
im = cv2.imread('/PATH/TO/IMAGE')
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
res = human_seg.segment(images=[im],visualization=True)
print(res[0]['data'])
human_seg.video_segment('/PATH/TO/VIDEO')
human_seg.save_inference_model('/PATH/TO/SAVE/MODEL')
``` - ### 第一步：启动PaddleHub Serving
视频流预测代码示例：
```python
import cv2
import numpy as np
import paddlehub as hub
human_seg = hub.Module('humanseg_lite') - 运行启动命令：
cap_video = cv2.VideoCapture('\PATH\TO\VIDEO')
fps = cap_video.get(cv2.CAP_PROP_FPS)
save_path = 'humanseg_lite_video.avi'
width = int(cap_video.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap_video.get(cv2.CAP_PROP_FRAME_HEIGHT))
cap_out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (width, height))
prev_gray = None
prev_cfd = None
while cap_video.isOpened():
ret, frame_org = cap_video.read()
if ret:
[img_matting, prev_gray, prev_cfd] = human_seg.video_stream_segment(frame_org=frame_org, frame_id=cap_video.get(1), prev_gray=prev_gray, prev_cfd=prev_cfd)
img_matting = np.repeat(img_matting[:, :, np.newaxis], 3, axis=2)
bg_im = np.ones_like(img_matting) * 255
comb = (img_matting * frame_org + (1 - img_matting) * bg_im).astype(np.uint8)
cap_out.write(comb)
else:
break
cap_video.release() ```shell
cap_out.release() $ hub serving start -m humanseg_lite
```
``` - 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
## 服务部署
PaddleHub Serving可以部署一个人像分割的在线服务。 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
## 第一步：启动PaddleHub Serving - ### 第二步：发送预测请求
运行启动命令： - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```shell
$ hub serving start -m humanseg_lite
```
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。 ```python
import requests
import json
import base64
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 import cv2
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/humanseg_lite"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
```python # 保存图片
import requests mask =cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY)
import json rgba = np.concatenate((org_im, np.expand_dims(mask, axis=2)), axis=2)
import base64 cv2.imwrite("segment_human_lite.png", rgba)
```
import cv2
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): * 1.0.0
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) 初始发布
data = cv2.imdecode(data, cv2.IMREAD_COLOR) * 1.1.0
return data
新增视频人像分割接口
# 发送HTTP请求
org_im = cv2.imread('PATH/TO/IMAGE') 新增视频流人像分割接口
data = {'images':[cv2_to_base64(org_im)]} * 1.1.1
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/humanseg_lite" 修复cudnn为8.0.4显存泄露问题
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存图片
mask =cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY)
rgba = np.concatenate((org_im, np.expand_dims(mask, axis=2)), axis=2)
cv2.imwrite("segment_human_lite.png", rgba)
```
### 查看代码
https://github.com/PaddlePaddle/PaddleSeg/tree/develop/contrib/HumanSeg
### 依赖
paddlepaddle >= 1.8.0
paddlehub >= 1.7.1
modules/image/semantic_segmentation/humanseg_mobile/README.md
浏览文件 @ a4d455b8
## 模型概述 # humanseg_mobile
|模型名称|humanseg_mobile|
| :--- | :---: |
|类别|图像-图像分割|
|网络|hrnet|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|5.8MB|
|指标|-|
|最新更新日期|2021-02-26|
HumanSeg-mobile是基于HRNet(Deep High-Resolution Representation Learning for Visual Recognition)的人像分割网络。HRNet在特征提取过程中保持了高分辨率的信息，保持了物体的细节信息，并可通过控制每个分支的通道数调整模型的大小。HumanSeg-mobile采用了HRNet_w18_small_v1的网络结构，模型大小只有5.8M， 适用于移动端或服务端CPU的前置摄像头场景。
## 命令行预测 ## 一、模型基本信息
``` - ### 应用效果展示
hub run humanseg_mobile --input_path "/PATH/TO/IMAGE"
```
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/130913092-312a5f37-842e-4fd0-8db4-5f853fd8419f.jpg" width = "337" height = "505" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130914325-3795e241-b611-46a1-aa70-ffc47326c86a.png" width = "337" height = "505" hspace='10'/>
</p>
- ### 模型介绍
## API - HumanSeg-mobile采用了HRNet_w18_small_v1的网络结构，模型大小只有5.8M， 适用于移动端或服务端CPU的前置摄像头场景。
```python - 更多详情请参考：[humanseg_mobile](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.2/contrib/HumanSeg)
def segment(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_mobile_output')
```
预测API，用于人像分割。 ## 二、安装
**参数** - ### 1、环境依赖
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - paddlepaddle >= 2.0.0
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
**返回** - paddlehub >= 2.0.0
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为： - ### 2、安装
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。 - ```shell
$ hub install humanseg_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)
## 三、模型API预测
```python - ### 1、命令行预测
def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
预测API，用于逐帧对视频人像分割。 ```
hub run humanseg_mobile --input_path "/PATH/TO/IMAGE"
```
- ### 2、代码示例
**参数** - 图片分割及视频分割代码示例：
* frame_org (numpy.ndarray): 单帧图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； ```python
* frame_id (int): 当前帧的编号； import cv2
* prev_gray (numpy.ndarray): 前一帧输入网络图像的灰度图； import paddlehub as hub
* prev_cfd (numpy.ndarray): 前一帧光流追踪图和预测结果融合图
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
human_seg = hub.Module(name='humanseg_mobile')
im = cv2.imread('/PATH/TO/IMAGE')
#visualization=True可以用于查看人像分割图片效果，可设置为False提升运行速度。
res = human_seg.segment(images=[im],visualization=True)
print(res[0]['data'])
human_seg.video_segment('/PATH/TO/VIDEO')
human_seg.save_inference_model('/PATH/TO/SAVE/MODEL')
**返回** ```
- 视频流预测代码示例：
* img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。 ```python
* cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图； import cv2
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图 import numpy as np
import paddlehub as hub
human_seg = hub.Module('humanseg_mobile')
cap_video = cv2.VideoCapture('\PATH\TO\VIDEO')
fps = cap_video.get(cv2.CAP_PROP_FPS)
save_path = 'humanseg_mobile_video.avi'
width = int(cap_video.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap_video.get(cv2.CAP_PROP_FRAME_HEIGHT))
cap_out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (width, height))
prev_gray = None
prev_cfd = None
while cap_video.isOpened():
ret, frame_org = cap_video.read()
if ret:
[img_matting, prev_gray, prev_cfd] = human_seg.video_stream_segment(frame_org=frame_org, frame_id=cap_video.get(1), prev_gray=prev_gray, prev_cfd=prev_cfd)
img_matting = np.repeat(img_matting[:, :, np.newaxis], 3, axis=2)
bg_im = np.ones_like(img_matting) * 255
comb = (img_matting * frame_org + (1 - img_matting) * bg_im).astype(np.uint8)
cap_out.write(comb)
else:
break
```python cap_video.release()
def video_segment(self, cap_out.release()
video_path=None,
use_gpu=False,
save_dir='humanseg_mobile_video_result'):
```
预测API，用于视频人像分割。 ```
**参数** - ### 3、API
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。 ```python
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置； def segment(images=None,
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。 paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_mobile_output')
```
- 预测API，用于人像分割。
```python - **参数**
def save_inference_model(dirname='humanseg_mobile_model',
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。 * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
**参数** - **返回**
* dirname: 存在模型的目录名称 * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
* model\_filename: 模型文件名称，默认为\_\_model\_\_ * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效) * data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。
* combined: 是否将参数保存到统一的一个文件中
## 代码示例
图片分割及视频分割代码示例： ```python
def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
```python - 预测API，用于逐帧对视频人像分割。
import cv2
import paddlehub as hub
human_seg = hub.Module(name='humanseg_mobile') - **参数**
im = cv2.imread('/PATH/TO/IMAGE')
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
res = human_seg.segment(images=[im],visualization=True)
print(res[0]['data'])
human_seg.video_segment('/PATH/TO/VIDEO')
human_seg.save_inference_model('/PATH/TO/SAVE/MODEL')
``` * frame_org (numpy.ndarray): 单帧图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
视频流预测代码示例： * frame_id (int): 当前帧的编号；
* prev_gray (numpy.ndarray): 前一帧输入网络图像的灰度图；
* prev_cfd (numpy.ndarray): 前一帧光流追踪图和预测结果融合图
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
```python
import cv2
import numpy as np
import paddlehub as hub
human_seg = hub.Module('humanseg_mobile') - **返回**
cap_video = cv2.VideoCapture('\PATH\TO\VIDEO')
fps = cap_video.get(cv2.CAP_PROP_FPS)
save_path = 'humanseg_mobile_video.avi'
width = int(cap_video.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap_video.get(cv2.CAP_PROP_FRAME_HEIGHT))
cap_out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (width, height))
prev_gray = None
prev_cfd = None
while cap_video.isOpened():
ret, frame_org = cap_video.read()
if ret:
[img_matting, prev_gray, prev_cfd] = human_seg.video_stream_segment(frame_org=frame_org, frame_id=cap_video.get(1), prev_gray=prev_gray, prev_cfd=prev_cfd)
img_matting = np.repeat(img_matting[:, :, np.newaxis], 3, axis=2)
bg_im = np.ones_like(img_matting) * 255
comb = (img_matting * frame_org + (1 - img_matting) * bg_im).astype(np.uint8)
cap_out.write(comb)
else:
break
cap_video.release() * img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。
cap_out.release() * cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图；
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图
```
## 服务部署 ```python
def video_segment(self,
video_path=None,
use_gpu=False,
save_dir='humanseg_mobile_video_result'):
```
PaddleHub Serving可以部署一个人像分割的在线服务。 - 预测API，用于视频人像分割。
## 第一步：启动PaddleHub Serving - **参数**
运行启动命令： * video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
```shell
$ hub serving start -m humanseg_mobile
```
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。 ```python
def save_inference_model(dirname='humanseg_mobile_model',
model_filename=None,
params_filename=None,
combined=True)
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 将模型保存到指定路径。
## 第二步：发送预测请求 - **参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 ## 四、服务部署
```python - PaddleHub Serving可以部署一个人像分割的在线服务。
import requests
import json
import base64
import cv2 - ### 第一步：启动PaddleHub Serving
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请求 ```shell
org_im = cv2.imread('/PATH/TO/IMAGE') $ hub serving start -m humanseg_mobile
data = {'images':[cv2_to_base64(org_im)]} ```
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/humanseg_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存图片 - 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
mask =cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY)
rgba = np.concatenate((org_im, np.expand_dims(mask, axis=2)), axis=2)
cv2.imwrite("segment_human_mobile.png", rgba)
```
### 查看代码 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
<https://github.com/PaddlePaddle/PaddleSeg/tree/develop/contrib/HumanSeg> - ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
### 依赖 ```python
import requests
import json
import base64
paddlepaddle >= 1.8.0 import cv2
import numpy as np
paddlehub >= 1.7.1 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/humanseg_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存图片
mask =cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY)
rgba = np.concatenate((org_im, np.expand_dims(mask, axis=2)), axis=2)
cv2.imwrite("segment_human_mobile.png", rgba)
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
新增视频人像分割接口
新增视频流人像分割接口
* 1.1.1
修复cudnn为8.0.4显存泄露问题
modules/image/semantic_segmentation/humanseg_server/README.md
浏览文件 @ a4d455b8
## 模型概述 # humanseg_server
|模型名称|humanseg_server|
| :--- | :---: |
|类别|图像-图像分割|
|网络|hrnet|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|159MB|
|指标|-|
|最新更新日期|2021-02-26|
高精度模型，适用于服务端GPU且背景复杂的人像场景， 模型结构为Deeplabv3+/Xcetion65, 模型大小为158M，网络结构如图：
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/paddlehub-img/deeplabv3plus.png" hspace='10'/> <br />
</p>
## 命令行预测
``` ## 一、模型基本信息
hub run humanseg_server --input_path "/PATH/TO/IMAGE"
```
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/130913092-312a5f37-842e-4fd0-8db4-5f853fd8419f.jpg" width = "337" height = "505" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130915531-bd4b2294-47e4-47e1-b9d3-3c1fa8b90f8f.png" width = "337" height = "505" hspace='10'/>
</p>
- ### 模型介绍
## API - HumanSeg-server使用百度自建数据集进行训练，可用于人像分割，支持任意大小的图片输入。
```python - 更多详情请参考：[humanseg_server](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.2/contrib/HumanSeg)
def segment(self,
images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_server_output'):
```
预测API，用于人像分割。 ## 二、安装
**参数** - ### 1、环境依赖
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - paddlepaddle >=2.0.0
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
**返回** - paddlehub >= 2.0.0
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。
```python
def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
预测API，用于逐帧对视频人像分割。 - ### 2、安装
**参数** - ```shell
$ hub install humanseg_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)
* frame_org (numpy.ndarray): 单帧图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； ## 三、模型API预测
* frame_id (int): 当前帧的编号；
* prev_gray (numpy.ndarray): 前一帧输入网络图像的灰度图；
* prev_cfd (numpy.ndarray): 前一帧光流追踪图和预测结果融合图；
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 1、命令行预测
**返回** ```
hub run humanseg_server --input_path "/PATH/TO/IMAGE"
```
- ### 2、代码示例
* img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)； - 图片分割及视频分割代码示例：
* cur_gray (numpy.ndarray): 当前帧输入分割网络图像的灰度图；
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图。
```python
import cv2
import paddlehub as hub
```python human_seg = hub.Module(name='humanseg_server')
def video_segment(self, im = cv2.imread('/PATH/TO/IMAGE')
video_path=None, #visualization=True可以用于查看人像分割图片效果，可设置为False提升运行速度。
use_gpu=False, res = human_seg.segment(images=[im],visualization=True)
save_dir='humanseg_server_video'): print(res[0]['data'])
``` human_seg.video_segment('/PATH/TO/VIDEO')
human_seg.save_inference_model('/PATH/TO/SAVE/MODEL')
预测API，用于视频人像分割。 ```
- 视频流预测代码示例：
**参数** ```python
import cv2
import numpy as np
import paddlehub as hub
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果； human_seg = hub.Module('humanseg_server')
* use\_gpu (bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置； cap_video = cv2.VideoCapture('\PATH\TO\VIDEO')
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。 fps = cap_video.get(cv2.CAP_PROP_FPS)
save_path = 'humanseg_server_video.avi'
width = int(cap_video.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap_video.get(cv2.CAP_PROP_FRAME_HEIGHT))
cap_out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (width, height))
prev_gray = None
prev_cfd = None
while cap_video.isOpened():
ret, frame_org = cap_video.read()
if ret:
[img_matting, prev_gray, prev_cfd] = human_seg.video_stream_segment(frame_org=frame_org, frame_id=cap_video.get(1), prev_gray=prev_gray, prev_cfd=prev_cfd)
img_matting = np.repeat(img_matting[:, :, np.newaxis], 3, axis=2)
bg_im = np.ones_like(img_matting) * 255
comb = (img_matting * frame_org + (1 - img_matting) * bg_im).astype(np.uint8)
cap_out.write(comb)
else:
break
cap_video.release()
cap_out.release()
```python ```
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True):
```
将模型保存到指定路径。 - ### 3、API
**参数** ```python
def segment(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_server_output')
```
* dirname: 存在模型的目录名称 - 预测API，用于人像分割。
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 代码示例 - **参数**
图片分割及视频分割代码示例： * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
```python * paths (list\[str\]): 图片的路径；
import cv2 * batch\_size (int): batch 的大小；
import paddlehub as hub * use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
human_seg = hub.Module(name='humanseg_server') - **返回**
im = cv2.imread('/PATH/TO/IMAGE')
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
res = human_seg.segment(images=[im],visualization=True)
print(res[0]['data'])
human_seg.video_segment('/PATH/TO/VIDEO')
human_seg.save_inference_model('/PATH/TO/SAVE/MODEL')
``` * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
视频流预测代码示例： * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
```python * data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。
import cv2
import numpy as np
import paddlehub as hub
human_seg = hub.Module('humanseg_server')
cap_video = cv2.VideoCapture('\PATH\TO\VIDEO')
fps = cap_video.get(cv2.CAP_PROP_FPS)
save_path = 'humanseg_server_video.avi'
width = int(cap_video.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap_video.get(cv2.CAP_PROP_FRAME_HEIGHT))
cap_out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (width, height))
prev_gray = None
prev_cfd = None
while cap_video.isOpened():
ret, frame_org = cap_video.read()
if ret:
[img_matting, prev_gray, prev_cfd] = human_seg.video_stream_segment(frame_org=frame_org, frame_id=cap_video.get(1), prev_gray=prev_gray, prev_cfd=prev_cfd)
img_matting = np.repeat(img_matting[:, :, np.newaxis], 3, axis=2)
bg_im = np.ones_like(img_matting) * 255
comb = (img_matting * frame_org + (1 - img_matting) * bg_im).astype(np.uint8)
cap_out.write(comb)
else:
break
cap_video.release() ```python
cap_out.release() def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
``` - 预测API，用于逐帧对视频人像分割。
## 服务部署 - **参数**
PaddleHub Serving可以部署一个人像分割的在线服务。 * frame_org (numpy.ndarray): 单帧图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* frame_id (int): 当前帧的编号；
* prev_gray (numpy.ndarray): 前一帧输入网络图像的灰度图；
* prev_cfd (numpy.ndarray): 前一帧光流追踪图和预测结果融合图
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
## 第一步：启动PaddleHub Serving
运行启动命令： - **返回**
```shell
$ hub serving start -m humanseg_server
```
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。 * img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。
* cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图；
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求 ```python
def video_segment(self,
video_path=None,
use_gpu=False,
save_dir='humanseg_server_video_result'):
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 预测API，用于视频人像分割。
```python - **参数**
import requests
import json
import base64
import cv2 * video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
import numpy as np * use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
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请求 ```python
org_im = cv2.imread('PATH/TO/IMAGE') def save_inference_model(dirname='humanseg_server_model',
data = {'images':[cv2_to_base64(org_im)]} model_filename=None,
headers = {"Content-type": "application/json"} params_filename=None,
url = "http://127.0.0.1:8866/predict/humanseg_server" combined=True)
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
# 保存图片
mask =cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY)
rgba = np.concatenate((org_im, np.expand_dims(mask, axis=2)), axis=2)
cv2.imwrite("segment_human_server.png", rgba)
```
- 将模型保存到指定路径。
### 查看代码 - **参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
https://github.com/PaddlePaddle/PaddleSeg/tree/develop/contrib/HumanSeg ## 四、服务部署
- PaddleHub Serving可以部署一个人像分割的在线服务。
### 依赖 - ### 第一步：启动PaddleHub Serving
paddlepaddle >= 1.8.0
paddlehub >= 1.7.1 - 运行启动命令：
```shell
$ hub serving start -m humanseg_server
```
- 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
import cv2
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/humanseg_server"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 保存图片
mask =cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY)
rgba = np.concatenate((org_im, np.expand_dims(mask, axis=2)), axis=2)
cv2.imwrite("segment_human_server.png", rgba)
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
新增视频人像分割接口
新增视频流人像分割接口
* 1.1.1
修复cudnn为8.0.4显存泄露问题
modules/thirdparty/image/semantic_segmentation/U2Net/README.md
浏览文件 @ a4d455b8
## 概述 # U2Net
* ![](http://latex.codecogs.com/svg.latex?U^2Net)的网络结构如下图，其类似于编码-解码(Encoder-Decoder)结构的 U-Net
* 每个 stage 由新提出的 RSU模块(residual U-block) 组成. 例如，En_1 即为基于 RSU 构建的
![](https://ai-studio-static-online.cdn.bcebos.com/999d37b4ffdd49dc9e3315b7cec7b2c6918fdd57c8594ced9dded758a497913d) |模型名称|U2Net|
| :--- | :---: |
|类别|图像-图像分割|
|网络|U^2Net|
|数据集|-|
|是否支持Fine-tuning|否|
|模型大小|254MB|
|指标|-|
|最新更新日期|2021-02-26|
## 效果展示
![](https://ai-studio-static-online.cdn.bcebos.com/4d77bc3a05cf48bba6f67b797978f4cdf10f38288b9645d59393dd85cef58eff)
![](https://ai-studio-static-online.cdn.bcebos.com/865b7b6a262b4ce3bbba4a5c0d973d9eea428bc3e8af4f76a1cdab0c04e3dd33)
![](https://ai-studio-static-online.cdn.bcebos.com/11c9eba8de6d4316b672f10b285245061821f0a744e441f3b80c223881256ca0)
## API
```python ## 一、模型基本信息
def Segmentation(
images=None, - ### 应用效果展示
- 效果展示
<p align="center">
<img src="https://ai-studio-static-online.cdn.bcebos.com/4d77bc3a05cf48bba6f67b797978f4cdf10f38288b9645d59393dd85cef58eff" width = "450" height = "300" hspace='10'/> <img src="https://ai-studio-static-online.cdn.bcebos.com/11c9eba8de6d4316b672f10b285245061821f0a744e441f3b80c223881256ca0" width = "450" height = "300" hspace='10'/>
</p>
- ### 模型介绍
* ![](http://latex.codecogs.com/svg.latex?U^2Net)的网络结构如下图，其类似于编码-解码(Encoder-Decoder)结构的 U-Net，每个 stage 由新提出的 RSU模块(residual U-block) 组成. 例如，En_1 即为基于 RSU 构建的
* - 更多详情请参考：[U2Net](https://github.com/xuebinqin/U-2-Net)
![](https://ai-studio-static-online.cdn.bcebos.com/999d37b4ffdd49dc9e3315b7cec7b2c6918fdd57c8594ced9dded758a497913d)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install U2Net
```
- 如您安装时遇到问题，可参考：[零基础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
model = hub.Module(name='U2Net')
result = model.Segmentation(
images=[cv2.imread('/PATH/TO/IMAGE')],
paths=None, paths=None,
batch_size=1, batch_size=1,
input_size=320, input_size=320,
output_dir='output', output_dir='output',
visualization=False): visualization=True)
``` ```
图像前景背景分割 API - ### 2、API
**参数** ```python
* images (list[np.ndarray]) : 输入图像数据列表（BGR） def Segmentation(
* paths (list[str]) : 输入图像路径列表 images=None,
* batch_size (int) : 数据批大小 paths=None,
* input_size (int) : 输入图像大小 batch_size=1,
* output_dir (str) : 可视化图像输出目录 input_size=320,
* visualization (bool) : 是否可视化 output_dir='output',
visualization=False):
**返回** ```
* results (list[np.ndarray]): 输出图像数据列表 - 图像前景背景分割 API
**代码示例** - **参数**
```python * images (list[np.ndarray]) : 输入图像数据列表（BGR）
import cv2 * paths (list[str]) : 输入图像路径列表
import paddlehub as hub * batch_size (int) : 数据批大小
* input_size (int) : 输入图像大小
model = hub.Module(name='U2Net') * output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
result = model.Segmentation(
images=[cv2.imread('/PATH/TO/IMAGE')], - **返回**
paths=None, * results (list[np.ndarray]): 输出图像数据列表
batch_size=1,
input_size=320, ## 四、更新历史
output_dir='output',
visualization=True) * 1.0.0
```
初始发布
## 查看代码
https://github.com/NathanUA/U-2-Net
## 依赖
paddlepaddle >= 2.0.0rc0
paddlehub >= 2.0.0b1
modules/thirdparty/image/semantic_segmentation/U2Netp/README.md
浏览文件 @ a4d455b8
## 概述 # U2Netp
* ![](http://latex.codecogs.com/svg.latex?U^2Net)的网络结构如下图，其类似于编码-解码(Encoder-Decoder)结构的 U-Net
* 每个 stage 由新提出的 RSU模块(residual U-block) 组成. 例如，En_1 即为基于 RSU 构建的 |模型名称|U2Netp|
* ![](http://latex.codecogs.com/svg.latex?U^2Net^+)是一个小型化的![](http://latex.codecogs.com/svg.latex?U^2Net) | :--- | :---: |
|类别|图像-图像分割|
![](https://ai-studio-static-online.cdn.bcebos.com/999d37b4ffdd49dc9e3315b7cec7b2c6918fdd57c8594ced9dded758a497913d) |网络|U^2Net|
|数据集|-|
## 效果展示 |是否支持Fine-tuning|否|
![](https://ai-studio-static-online.cdn.bcebos.com/4d77bc3a05cf48bba6f67b797978f4cdf10f38288b9645d59393dd85cef58eff) |模型大小|6.7MB|
![](https://ai-studio-static-online.cdn.bcebos.com/865b7b6a262b4ce3bbba4a5c0d973d9eea428bc3e8af4f76a1cdab0c04e3dd33) |指标|-|
![](https://ai-studio-static-online.cdn.bcebos.com/11c9eba8de6d4316b672f10b285245061821f0a744e441f3b80c223881256ca0) |最新更新日期|2021-02-26|
## API
```python
def Segmentation( ## 一、模型基本信息
images=None,
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://ai-studio-static-online.cdn.bcebos.com/4d77bc3a05cf48bba6f67b797978f4cdf10f38288b9645d59393dd85cef58eff" width = "450" height = "300" hspace='10'/> <img src="https://ai-studio-static-online.cdn.bcebos.com/11c9eba8de6d4316b672f10b285245061821f0a744e441f3b80c223881256ca0" width = "450" height = "300" hspace='10'/>
</p>
- ### 模型介绍
* U2Netp的网络结构如下图，其类似于编码-解码(Encoder-Decoder)结构的 U-Net, 每个 stage 由新提出的 RSU模块(residual U-block) 组成. 例如，En_1 即为基于 RSU 构建的, 它是一个小型化的模型
![](https://ai-studio-static-online.cdn.bcebos.com/999d37b4ffdd49dc9e3315b7cec7b2c6918fdd57c8594ced9dded758a497913d)
* - 更多详情请参考：[U2Net](https://github.com/xuebinqin/U-2-Net)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install U2Netp
```
- 如您安装时遇到问题，可参考：[零基础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
model = hub.Module(name='U2Netp')
result = model.Segmentation(
images=[cv2.imread('/PATH/TO/IMAGE')],
paths=None, paths=None,
batch_size=1, batch_size=1,
input_size=320, input_size=320,
output_dir='output', output_dir='output',
visualization=False): visualization=True)
``` ```
图像前景背景分割 API - ### 2、API
**参数** ```python
* images (list[np.ndarray]) : 输入图像数据列表（BGR） def Segmentation(
* paths (list[str]) : 输入图像路径列表 images=None,
* batch_size (int) : 数据批大小 paths=None,
* input_size (int) : 输入图像大小 batch_size=1,
* output_dir (str) : 可视化图像输出目录 input_size=320,
* visualization (bool) : 是否可视化 output_dir='output',
visualization=False):
**返回** ```
* results (list[np.ndarray]): 输出图像数据列表 - 图像前景背景分割 API
**代码示例** - **参数**
```python * images (list[np.ndarray]) : 输入图像数据列表（BGR）
import cv2 * paths (list[str]) : 输入图像路径列表
import paddlehub as hub * batch_size (int) : 数据批大小
* input_size (int) : 输入图像大小
model = hub.Module(name='U2Netp') * output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
result = model.Segmentation(
images=[cv2.imread('/PATH/TO/IMAGE')], - **返回**
paths=None, * results (list[np.ndarray]): 输出图像数据列表
batch_size=1,
input_size=320, ## 四、更新历史
output_dir='output',
visualization=True) * 1.0.0
```
初始发布
## 查看代码
https://github.com/NathanUA/U-2-Net
## 依赖
paddlepaddle >= 2.0.0rc0
paddlehub >= 2.0.0b1
modules/thirdparty/video/Video_editing/SkyAR/README.md
浏览文件 @ a4d455b8
## 模型概述 # SkyAR
* SkyAR 是一种用于视频中天空置换与协调的视觉方法，该方法能够在风格可控的视频中自动生成逼真的天空背景。
* 该算法是一种完全基于视觉的解决方案，它的好处就是可以处理非静态图像，同时不受拍摄设备的限制，也不需要用户交互，可以处理在线或离线视频。
* 算法主要由三个核心组成：
* 天空抠图网络（Sky Matting Network）：就是一种 Matting 图像分隔，用于检测视频帧中天空区域的视频，可以精确地获得天空蒙版。
* 运动估计（Motion Estimation）：恢复天空运动的运动估计器，使生成的天空与摄像机的运动同步。
* 图像融合（Image Blending）：将用户指定的天空模板混合到视频帧中。除此之外，还用于重置和着色，使混合结果在其颜色和动态范围内更具视觉逼真感。
* 整体框架图如下：
![](http://p4.itc.cn/q_70/images03/20201114/42eaf00af8dd4aa4ae3c0cdc6e50b793.jpeg) |模型名称|SkyAR|
* 参考论文：Zhengxia Zou. [Castle in the Sky: Dynamic Sky Replacement and Harmonization in Videos](https://arxiv.org/abs/2010.11800). CoRR, abs/2010.118003, 2020. | :--- | :---: |
* 官方开源项目： [jiupinjia/SkyAR](https://github.com/jiupinjia/SkyAR) |类别|图像-图像分割|
## 模型安装 |网络|UNet|
```shell |数据集|UNet|
$hub install SkyAR |是否支持Fine-tuning|否|
``` |模型大小|206MB|
|指标|-|
|最新更新日期|2021-02-26|
## 效果展示 ## 一、模型基本信息
* 原始视频：
![原始视频](https://img-blog.csdnimg.cn/20210126142046572.gif) - ### 应用效果展示
- 样例结果示例：
* 原始视频：
* 木星： ![原始视频](https://img-blog.csdnimg.cn/20210126142046572.gif)
![木星](https://img-blog.csdnimg.cn/20210125211435619.gif) * 木星：
* 雨天：
![雨天](https://img-blog.csdnimg.cn/2021012521152492.gif) ![木星](https://img-blog.csdnimg.cn/20210125211435619.gif)
* 银河： * 雨天：
![银河](https://img-blog.csdnimg.cn/20210125211523491.gif) ![雨天](https://img-blog.csdnimg.cn/2021012521152492.gif)
* 第九区飞船： * 银河：
![第九区飞船](https://img-blog.csdnimg.cn/20210125211520955.gif) ![银河](https://img-blog.csdnimg.cn/20210125211523491.gif)
* 原始视频： * 第九区飞船：
![原始视频](https://img-blog.csdnimg.cn/20210126142038716.gif) ![第九区飞船](https://img-blog.csdnimg.cn/20210125211520955.gif)
* 漂浮城堡： * 原始视频：
![漂浮城堡](https://img-blog.csdnimg.cn/20210125211514997.gif) ![原始视频](https://img-blog.csdnimg.cn/20210126142038716.gif)
* 电闪雷鸣： * 漂浮城堡：
![电闪雷鸣](https://img-blog.csdnimg.cn/20210125211433591.gif) ![漂浮城堡](https://img-blog.csdnimg.cn/20210125211514997.gif)
* 超级月亮： * 电闪雷鸣：
![超级月亮](https://img-blog.csdnimg.cn/20210125211417524.gif) ![电闪雷鸣](https://img-blog.csdnimg.cn/20210125211433591.gif)
* 超级月亮：
## API 说明 ![超级月亮](https://img-blog.csdnimg.cn/20210125211417524.gif)
```python - ### 模型介绍
def MagicSky(
video_path, save_path, config='jupiter', - SkyAR是一种用于视频中天空置换与协调的视觉方法，主要由三个核心组成：天空抠图网络、运动估计和图像融合。
is_rainy=False, preview_frames_num=0, is_video_sky=False, is_show=False,
skybox_img=None, skybox_video=None, rain_cap_path=None, - 更多详情请参考：[SkyAR](https://github.com/jiupinjia/SkyAR)
halo_effect=True, auto_light_matching=False,
relighting_factor=0.8, recoloring_factor=0.5, skybox_center_crop=0.5
)
```
深度估计API - 参考论文：Zhengxia Zou. [Castle in the Sky: Dynamic Sky Replacement and Harmonization in Videos](https://arxiv.org/abs/2010.11800). CoRR, abs/2010.118003, 2020.
**参数** ## 二、安装
* video_path(str)：输入视频路径 - ### 1、环境依赖
* save_path(str)：视频保存路径
* config(str): 预设 SkyBox 配置，所有预设配置如下，如果使用自定义 SkyBox，请设置为 None：
```
[
'cloudy', 'district9ship', 'floatingcastle', 'galaxy', 'jupiter',
'rainy', 'sunny', 'sunset', 'supermoon', 'thunderstorm'
]
```
* skybox_img(str)：自定义的 SkyBox 图像路径
* skybox_video(str)：自定义的 SkyBox 视频路径
* is_video_sky(bool)：自定义 SkyBox 是否为视频
* rain_cap_path(str)：自定义下雨效果视频路径
* is_rainy(bool): 天空是否下雨
* halo_effect(bool)：是否开启 halo effect
* auto_light_matching(bool)：是否开启自动亮度匹配
* relighting_factor(float): Relighting factor
* recoloring_factor(float): Recoloring factor
* skybox_center_crop(float)：SkyBox center crop factor
* preview_frames_num(int)：设置预览帧数量，即只处理开头这几帧，设为 0，则为全部处理
* is_show(bool)：是否图形化预览
## 预测代码示例 - paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0
import paddlehub as hub
model = hub.Module(name='SkyAR') - ### 2、安装
model.MagicSky( ```shell
video_path=[path to input video path], $hub install SkyAR
save_path=[path to save video path] ```
) - 如您安装时遇到问题，可参考：[零基础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预测
https://github.com/jm12138/SkyAR_Paddle_GUI - ### 1、代码示例
### 依赖 ```python
import paddlehub as hub
paddlepaddle >= 2.0.0rc0 model = hub.Module(name='SkyAR')
model.MagicSky(
video_path=[path to input video path],
save_path=[path to save video path]
)
```
- ### 2、API
```python
def MagicSky(
video_path, save_path, config='jupiter',
is_rainy=False, preview_frames_num=0, is_video_sky=False, is_show=False,
skybox_img=None, skybox_video=None, rain_cap_path=None,
halo_effect=True, auto_light_matching=False,
relighting_factor=0.8, recoloring_factor=0.5, skybox_center_crop=0.5
)
```
- **参数**
* video_path(str)：输入视频路径
* save_path(str)：视频保存路径
* config(str): 预设 SkyBox 配置，所有预设配置如下，如果使用自定义 SkyBox，请设置为 None：
```
[
'cloudy', 'district9ship', 'floatingcastle', 'galaxy', 'jupiter',
'rainy', 'sunny', 'sunset', 'supermoon', 'thunderstorm'
]
```
* skybox_img(str)：自定义的 SkyBox 图像路径
* skybox_video(str)：自定义的 SkyBox 视频路径
* is_video_sky(bool)：自定义 SkyBox 是否为视频
* rain_cap_path(str)：自定义下雨效果视频路径
* is_rainy(bool): 天空是否下雨
* halo_effect(bool)：是否开启 halo effect
* auto_light_matching(bool)：是否开启自动亮度匹配
* relighting_factor(float): Relighting factor
* recoloring_factor(float): Recoloring factor
* skybox_center_crop(float)：SkyBox center crop factor
* preview_frames_num(int)：设置预览帧数量，即只处理开头这几帧，设为 0，则为全部处理
* is_show(bool)：是否图形化预览
## 四、更新历史
* 1.0.0
初始发布
paddlehub >= 2.0.0rc0
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或