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 @@
$ 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
在完成安装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 @@
$ 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
在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用msgnet模型对[MiniCOCO](../../docs/reference/datasets.md#class-hubdatasetsMiniCOCO)等数据集进行Fine-tune。
......
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>
**参数**
- ### 模型介绍
* input(str): 图片或者视频的路径；
- deoldify是用于图像和视频的着色渲染模型，该模型能够实现给黑白照片和视频恢复原彩。
**返回**
- 更多详情请参考：[deoldify](https://github.com/jantic/DeOldify)
若输入是图片，返回值为：
* pred_img(np.ndarray): BGR图片数据；
* out_path(str): 保存图片路径。
## 二、安装
若输入是视频，返回值为：
* frame_pattern_combined(str): 视频着色后单帧数据保存路径；
* vid_out_path(str): 视频保存路径。
- ### 1、环境依赖
```python
def run_image(self, img):
```
图像着色API， 得到着色后的图片。
- paddlepaddle >= 2.0.0
**参数**
- 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
def run_video(self, video):
```
视频着色API， 得到着色后的视频。
- ### 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)
* video (str): 待处理视频路径。
**返回**
* frame_pattern_combined(str): 视频着色后单帧数据保存路径；
* vid_out_path(str): 视频保存路径。
## 预测代码示例
## 三、模型API预测
- ### 1、代码示例
```python
import paddlehub as hub
```python
import paddlehub as hub
model = hub.Module(name='deoldify')
model.predict('/PATH/TO/IMAGE/OR/VIDEO')
```
model = hub.Module(name='deoldify')
model.predict('/PATH/TO/IMAGE/OR/VIDEO')
```
## 服务部署
- ### 2、API
PaddleHub Serving可以部署一个在线照片着色服务。
- ```python
def predict(self, input):
```
## 第一步：启动PaddleHub Serving
- 着色变换API，得到着色后的图片或者视频。
运行启动命令：
```shell
$ hub serving start -m deoldify
```
- **参数**
这样就完成了一个图像着色的在线服务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
import requests
import json
import base64
- ```python
def run_image(self, img):
```
- 图像着色API， 得到着色后的图片。
import cv2
import numpy as np
- **参数**
def cv2_to_base64(image):
- img (str｜np.ndarray): 图片路径或则BGR格式图片。
- **返回**
- pred_img(np.ndarray): BGR图片数据；
- ```python
def run_video(self, video):
```
- 视频着色API， 得到着色后的视频。
- **参数**
- video (str): 待处理视频路径。
- **返回**
- frame_pattern_combined(str): 视频着色后单帧数据保存路径；
- vid_out_path(str): 视频保存路径。
## 四、服务部署
- 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):
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)
```
# 发送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)
```
## 模型相关信息
### 模型代码
## 五、更新历史
https://github.com/jantic/DeOldify
* 1.0.0
### 依赖
初始发布
paddlepaddle >= 2.0.0rc
* 1.0.1
paddlehub >= 1.8.3
适配paddlehub2.0版本
modules/image/Image_editing/colorization/photo_restoration/README.md
浏览文件 @ a4d455b8
## 模型概述
# photo_restoration
photo_restoration 是针对老照片修复的模型。它主要由两个部分组成：着色和超分。着色模型基于deoldify
，超分模型基于realsr. 用户可以根据自己的需求选择对图像进行着色或超分操作。因此在使用该模型时，请预先安装deoldify和realsr两个模型。
|模型名称|photo_restoration|
| :--- | :---: |
|类别|图像-图像编辑|
|网络|基于deoldify和realsr模型|
|是否支持Fine-tuning|否|
|模型大小|64MB+834MB|
|指标|-|
|最新更新日期|2021-08-19|
## API
```python
def run_image(self,
input,
model_select= ['Colorization', 'SuperResolution'],
save_path = 'photo_restoration'):
```
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例(左为原图，右为效果图)：
<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>
- ### 模型介绍
预测API，用于图片修复。
- photo_restoration 是针对老照片修复的模型。它主要由两个部分组成：着色和超分。着色模型基于deoldify
，超分模型基于realsr. 用户可以根据自己的需求选择对图像进行着色或超分操作。因此在使用该模型时，请预先安装deoldify和realsr两个模型。
**参数**
## 二、安装
* input (numpy.ndarray｜str): 图片数据，numpy.ndarray 或者 str形式。ndarray.shape 为 \[H, W, C\]，BGR格式; str为图片的路径。
- ### 1、环境依赖
* model_select (list\[str\]): 选择对图片对操作，\['Colorization'\]对图像只进行着色操作， \['SuperResolution'\]对图像只进行超分操作；
默认值为\['Colorization', 'SuperResolution'\]。
- paddlepaddle >= 2.0.0
* save_path (str): 保存图片的路径, 默认为'photo_restoration'。
- paddlehub >= 2.0.0
**返回**
- NOTE: 使用该模型需要自行安装ffmpeg，若您使用conda环境，推荐使用如下语句进行安装。
* output (numpy.ndarray): 照片修复结果，ndarray.shape 为 \[H, W, C\]，BGR格式。
```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
## 三、模型API预测
- ### 1、代码示例
model = hub.Module(name='photo_restoration', visualization=True)
im = cv2.imread('/PATH/TO/IMAGE')
res = model.run_image(im)
```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)
```
- ### 2、API
```python
def run_image(self,
input,
model_select= ['Colorization', 'SuperResolution'],
save_path = 'photo_restoration'):
```
## 服务部署
- 预测API，用于图片修复。
PaddleHub Serving可以部署一个照片修复的在线服务。
- **参数**
## 第一步：启动PaddleHub Serving
- input (numpy.ndarray｜str): 图片数据，numpy.ndarray 或者 str形式。ndarray.shape 为 \[H, W, C\]，BGR格式; str为图片的路径。
运行启动命令：
- model_select (list\[str\]): 选择对图片对操作，\['Colorization'\]对图像只进行着色操作， \['SuperResolution'\]对图像只进行超分操作；
默认值为\['Colorization', 'SuperResolution'\]。
```shell
$ hub serving start -m photo_restoration
```
- save_path (str): 保存图片的路径, 默认为'photo_restoration'。
这样就完成了一个照片修复的服务化API的部署，默认端口号为8866。
- **返回**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- output (numpy.ndarray): 照片修复结果，ndarray.shape 为 \[H, W, C\]，BGR格式。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
## 四、服务部署
import cv2
import numpy as np
- PaddleHub Serving可以部署一个照片修复的在线服务。
def cv2_to_base64(image):
- ## 第一步：启动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):
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)
```
# 发送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
### 依赖
初始发布
paddlepaddle >= 2.0.0rc
* 1.0.1
paddlehub >= 1.8.2
适配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
- ### 应用效果展示
```python
def reconstruct(self,
- 样例结果示例(左为原图，右为效果图)：
<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>
- ### 模型介绍
- falsr_c是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
- 更多详情请参考：[falsr_c](https://github.com/xiaomi-automl/FALSR)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install falsr_c
```
- 如您安装时遇到问题，可参考：[零基础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 falsr_c --input_path "/PATH/TO/IMAGE"
```
- ### 代码示例
```python
import cv2
import paddlehub as hub
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()
```
- ### 2、API
- ```python
def reconstruct(self,
images=None,
paths=None,
use_gpu=False,
visualization=False,
output_dir="falsr_c_output")
```
```
预测API，用于图像超分辨率。
- 预测API，用于图像超分辨率。
**参数**
- **参数**
* 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): 图片的保存路径。
* 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'，对应的取值为：
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 超分辨后图像。
```python
def save_inference_model(self,
- ```python
def save_inference_model(self,
dirname='falsr_c_save_model',
model_filename=None,
params_filename=None,
combined=False)
```
将模型保存到指定路径。
**参数**
```
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- 将模型保存到指定路径。
## 代码示例
- **参数**
```python
import cv2
import paddlehub as hub
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
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可以部署一个图像超分的在线服务。
## 四、服务部署
## 第一步：启动PaddleHub Serving
- PaddleHub Serving可以部署一个图像超分的在线服务。
运行启动命令：
- ### 第一步：启动PaddleHub Serving
```shell
$ hub serving start -m falsr_c
```
- 运行启动命令：
这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
- ```shell
$ hub serving start -m falsr_c
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- 这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
## 第二步：发送预测请求
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ### 第二步：发送预测请求
```python
import requests
import json
import base64
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
import cv2
import numpy as np
import cv2
import numpy as np
def cv2_to_base64(image):
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
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")
```
# 发送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")
```
### 查看代码
https://github.com/xiaomi-automl/FALSR
## 五、更新历史
### 依赖
* 1.0.0
paddlepaddle >= 1.8.0
初始发布
paddlehub >= 1.7.1
modules/image/Image_editing/super_resolution/realsr/README.md
浏览文件 @ a4d455b8
# realsr
## 模型概述
realsr是用于图像和视频超分模型，该模型基于Toward Real-World Single Image Super-Resolution: A New Benchmark and A New Mode，它能够将输入的图片和视频超分四倍。
|模型名称|reasr|
| :--- | :---: |
|类别|图像-图像编辑|
|网络|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，它能够将输入的图片和视频超分四倍。
若输入是图片，返回值为：
* pred_img(np.ndarray): BGR图片数据；
* out_path(str): 保存图片路径。
- 更多详情请参考：[realsr](https://github.com/csjcai/RealSR)
若输入是视频，返回值为：
* frame_pattern_combined(str): 视频超分后单帧数据保存路径；
* vid_out_path(str): 视频保存路径。
```python
def run_image(self, img):
```
图像超分API， 得到超分后的图片。
## 二、安装
**参数**
- ### 1、环境依赖
* img (str｜np.ndarray): 图片路径或则BGR格式图片。
- paddlepaddle >= 2.0.0
**返回**
- paddlehub >= 2.0.0
* pred_img(np.ndarray): BGR图片数据；
- NOTE: 使用该模型需要自行安装ffmpeg，若您使用conda环境，推荐使用如下语句进行安装。
```python
def run_video(self, video):
```
视频超分API， 得到超分后的视频。
```shell
$ conda install x264=='1!152.20180717' ffmpeg=4.0.2 -c conda-forge
```
**参数**
* video(str): 待处理视频路径。
- ### 2、安装
**返回**
- ```shell
$ hub install realsr
```
* frame_pattern_combined(str): 视频超分后单帧数据保存路径；
* vid_out_path(str): 视频保存路径。
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 预测代码示例
```python
import paddlehub as hub
model = hub.Module(name='realsr')
model.predict('/PATH/TO/IMAGE/OR/VIDEO')
```
## 服务部署
## 三、模型API预测
PaddleHub Serving可以部署一个在线照片超分服务。
- ### 1、代码示例
## 第一步：启动PaddleHub Serving
```python
import paddlehub as hub
运行启动命令：
```shell
$ hub serving start -m realsr
```
model = hub.Module(name='realsr')
model.predict('/PATH/TO/IMAGE/OR/VIDEO')
```
- ### 2、API
这样就完成了一个图像超分的在线服务API的部署，默认端口号为8866。
- ```python
def predict(self, input):
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- 超分API，得到超分后的图片或者视频。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **参数**
```python
import requests
import json
import base64
- input (str): 图片或者视频的路径；
import cv2
import numpy as np
- **返回**
def cv2_to_base64(image):
- 若输入是图片，返回值为：
- pred_img(np.ndarray): BGR图片数据；
- out_path(str): 保存图片路径。
- 若输入是视频，返回值为：
- frame_pattern_combined(str): 视频超分后单帧数据保存路径；
- vid_out_path(str): 视频保存路径。
- ```python
def run_image(self, img):
```
- 图像超分API， 得到超分后的图片。
- **参数**
- img (str｜np.ndarray): 图片路径或则BGR格式图片。
- **返回**
- pred_img(np.ndarray): BGR图片数据；
- ```python
def run_video(self, video):
```
- 视频超分API， 得到超分后的视频。
- **参数**
- video(str): 待处理视频路径。
- **返回**
- 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):
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)
# 发送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
https://github.com/csjcai/RealSR
初始发布
### 依赖
* 1.0.1
paddlepaddle >= 2.0.0rc
适配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
$ hub install resnet50_vd_animals==1.0.0
```
# resnet50_vd_animals
<p align="center">
<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_animals|
| :--- | :---: |
|类别|图像-图像分类|
|网络|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
def get_expected_image_width()
```
- ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种，可用于图像分类和特征提取。该 PaddleHub Module 采用百度自建动物数据集训练得到，支持7978种动物的分类识别。
返回预处理的图片宽度，也就是224。
- 模型的详情可参考[论文](https://arxiv.org/pdf/1812.01187.pdf)
```python
def get_expected_image_height()
```
## 二、安装
返回预处理的图片高度，也就是224。
- ### 1、环境依赖
```python
def get_pretrained_images_mean()
```
- paddlepaddle >= 2.0.0
返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
- paddlehub >= 2.0.0
```python
def get_pretrained_images_std()
```
- ### 2、安装
返回预处理的图片标准差，也就是 \[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预测
```python
def context(trainable=True, pretrained=True)
```
- ### 1、命令行预测
**参数**
- ```
hub run resnet50_vd_animals --input_path "/PATH/TO/IMAGE"
```
* trainable (bool): 计算图的参数是否为可训练的；
* pretrained (bool): 是否加载默认的预训练模型。
- ### 2、代码示例
**返回**
- ```python
import paddlehub as hub
import cv2
* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
* classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
* feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
* context\_prog(fluid.Program): 计算图，用于迁移学习。
classifier = hub.Module(name="resnet50_vd_animals")
```python
def classification(images=None,
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def get_expected_image_width()
```
- 返回预处理的图片宽度，也就是224。
- ```python
def get_expected_image_height()
```
- 返回预处理的图片高度，也就是224。
- ```python
def get_pretrained_images_mean()
```
- 返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
- ```python
def get_pretrained_images_std()
```
- 返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
```
**参数**
- **参数**
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
**返回**
- **返回**
res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
```python
def save_inference_model(dirname,
- ```python
def save_inference_model(dirname,
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 paddlehub as hub
import cv2
classifier = hub.Module(name="resnet50_vd_animals")
## 四、服务部署
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- PaddleHub Serving可以部署一个在线动物识别服务。
## 服务部署
- ### 第一步：启动PaddleHub Serving
PaddleHub Serving可以部署一个在线动物识别服务。
- 运行启动命令：
## 第一步：启动PaddleHub Serving
- ```shell
$ hub serving start -m resnet50_vd_animals
```
运行启动命令：
```shell
$ hub serving start -m resnet50_vd_animals
```
- 这样就完成了一个在线动物识别服务化API的部署，默认端口号为8866。
这样就完成了一个在线动物识别服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
## 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/resnet50_vd_animals"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
### 查看代码
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/resnet50_vd_animals"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
[PaddlePaddle/models 图像分类](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification)
# 打印预测结果
print(r.json()["results"])
```
### 依赖
## 五、更新历史
paddlepaddle >= 1.6.2
* 1.0.0
paddlehub >= 1.6.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 模型实现的轻量化人像分割模型
* 模型具体规格如下：
|model|ExtremeC3|
|----|----|
|Param|0.038 M|
|Flop|0.128 G|
* 模型参数转换至 [ext_portrait_segmentation](https://github.com/clovaai/ext_portrait_segmentation) 项目
* 感谢 [ext_portrait_segmentation](https://github.com/clovaai/ext_portrait_segmentation) 项目提供的开源代码和模型
## 效果展示
![](https://ai-studio-static-online.cdn.bcebos.com/1261398a98e24184852bdaff5a4e1dbd7739430f59fb47e8b84e3a2cfb976107)
## API
```python
def Segmentation(
images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False):
```
人像分割 API
# ExtremeC3_Portrait_Segmentation
|模型名称|ExtremeC3_Portrait_Segmentation|
| :--- | :---: |
|类别|图像-图像分割|
|网络|ExtremeC3|
|数据集|EG1800, Baidu fashion dataset|
|是否支持Fine-tuning|否|
|模型大小|0.038MB|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://ai-studio-static-online.cdn.bcebos.com/1261398a98e24184852bdaff5a4e1dbd7739430f59fb47e8b84e3a2cfb976107" hspace='10'/> <br />
</p>
- ### 模型介绍
* 基于 ExtremeC3 模型实现的轻量化人像分割模型
* 更多详情请参考： [ExtremeC3_Portrait_Segmentation](https://github.com/clovaai/ext_portrait_segmentation) 项目
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
**参数**
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
- ### 2、安装
**返回**
* results (list[dict{"mask":np.ndarray,"result":np.ndarray}]): 输出图像数据列表
- ```shell
$ hub install ExtremeC3_Portrait_Segmentation
```
**代码示例**
```python
import cv2
import paddlehub as hub
- 如您安装时遇到问题，可参考：[零基础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)
model = hub.Module(name='ExtremeC3_Portrait_Segmentation')
result = model.Segmentation(
## 三、模型API预测
- ### 1、代码示例
```python
import cv2
import paddlehub as hub
model = hub.Module(name='ExtremeC3_Portrait_Segmentation')
result = model.Segmentation(
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}]): 输出图像数据列表
## 四、更新历史
## 查看代码
https://github.com/clovaai/ext_portrait_segmentation
* 1.0.0
## 依赖
paddlepaddle >= 2.0.0rc0
paddlehub >= 2.0.0b1
初始发布
modules/image/semantic_segmentation/ace2p/README.md
浏览文件 @ a4d455b8
```shell
$ hub install ace2p==1.1.0
```
# ace2p
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_network.jpg" hspace='10'/> <br />
</p>
|模型名称|ace2p|
| :--- | :---: |
|类别|图像-图像分割|
|网络|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">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_network.jpg" hspace='10'/> <br />
</p>
- 调色板
<p align="left">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_palette.jpg" hspace='10'/> <br />
</p>
- 样例结果示例：
<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/130913765-c9572c77-c6bf-46ec-9653-04ff356b4b85.png" width = "337" height = "505" hspace='10'/>
</p>
- ### 模型介绍
- 人体解析(Human Parsing)是细粒度的语义分割任务，其旨在识别像素级别的人类图像的组成部分（例如，身体部位和服装）。ACE2P通过融合底层特征，全局上下文信息和边缘细节，端到端地训练学习人体解析任务。该结构针对Intersection over Union指标进行针对性的优化学习，提升准确率。以ACE2P单人人体解析网络为基础的解决方案在CVPR2019第三届LIP挑战赛中赢得了全部三个人体解析任务的第一名。该PaddleHub Module采用ResNet101作为骨干网络，接受输入图片大小为473x473x3。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2.安装
- ```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)
## 三、模型API预测
- ### 1、命令行预测
```shell
$ hub install ace2p==1.1.0
```
- ### 2、代码示例
```python
import paddlehub as hub
import cv2
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，用于图像分割得到人体解析。
- 预测API，用于图像分割得到人体解析。
**参数**
- **参数**
* 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): 是否将识别结果保存为图片文件。
* 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): 是否将识别结果保存为图片文件。
**返回**
- **返回**
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有'path', 'data'，相应的取值为：
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有'path', 'data'，相应的取值为：
* path (str): 原输入图片的路径；
* data (numpy.ndarray): 图像分割得到的结果，shape 为`H * W`，元素的取值为0-19，表示每个像素的分类结果，映射顺序与下面的调色板相同。
```python
def save_inference_model(dirname,
```python
def save_inference_model(dirname,
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 paddlehub as hub
import cv2
## 四、服务部署
human_parser = hub.Module(name="ace2p")
result = human_parser.segmentation(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = human_parser.segmentation((paths=['/PATH/TO/IMAGE'])
```
- PaddleHub Serving可以部署一个人体解析的在线服务。
## 服务部署
- ### 第一步：启动PaddleHub Serving
PaddleHub Serving可以部署一个人体解析的在线服务。
- 运行启动命令：
### 第一步：启动PaddleHub Serving
```shell
$ hub serving start -m ace2p
```
运行启动命令：
```shell
$ hub serving start -m ace2p
```
- 这样就完成了一个人体解析服务化API的部署，默认端口号为8866。
这样就完成了一个人体解析服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
```python
import requests
import json
import cv2
import base64
import numpy as np
import numpy as np
def cv2_to_base64(image):
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
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))
# 发送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']))
```
# 打印预测结果
print(base64_to_cv2(r.json()["results"][0]['data']))
```
## 调色板
## 五、更新历史
<p align="left">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_palette.jpg" hspace='10'/> <br />
</p>
* 1.0.0
## 依赖
初始发布
paddlepaddle >= 1.6.2
* 1.1.0
paddlehub >= 1.6.0
适配paddlehub2.0版本
modules/image/semantic_segmentation/deeplabv3p_xception65_humanseg/README.md
浏览文件 @ a4d455b8
## 命令行预测
# deeplabv3p_xception65_humanseg
```
hub run deeplabv3p_xception65_humanseg --input_path "/PATH/TO/IMAGE"
```
|模型名称|deeplabv3p_xception65_humanseg|
| :--- | :---: |
|类别|图像-图像分割|
|网络|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">
<img src="https://paddlehub.bj.bcebos.com/paddlehub-img/deeplabv3plus.png" hspace='10'/> <br />
</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.命令行预测
```python
def segmentation(images=None,
```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
def segmentation(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_output')
```
```
预测API，用于人像分割。
- 预测API，用于人像分割。
**参数**
- **参数**
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
**返回**
- **返回**
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
* save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
* data (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-255 (0为全透明，255为不透明)，也即取值越大的像素点越可能为人体，取值越小的像素点越可能为背景。
```python
def save_inference_model(dirname,
```python
def save_inference_model(dirname,
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 paddlehub as hub
import cv2
human_seg = hub.Module(name="deeplabv3p_xception65_humanseg")
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
## 第一步：启动PaddleHub Serving
- 运行启动命令：
运行启动命令：
```shell
$ hub serving start -m deeplabv3p_xception65_humanseg
```
```shell
$ hub serving start -m deeplabv3p_xception65_humanseg
```
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
- 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
- ### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
```python
import requests
import json
import cv2
import base64
import numpy as np
import numpy as np
def cv2_to_base64(image):
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
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)
```
## 五、更新历史
* 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))
初始发布
# 打印预测结果
print(base64_to_cv2(r.json()["results"][0]['data']))
```
* 1.1.0
### 查看代码
提升预测性能
[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是基于ShuffleNetV2网络结构的基础上进行优化的人像分割模型，进一步减小了网络规模，网络大小只有541K，量化后只有187K，适用于手机自拍人像分割等实时分割场景。
|模型名称|humanseg_lite|
| :--- | :---: |
|类别|图像-图像分割|
|网络|shufflenet|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|541k|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
## 命令行预测
- ### 应用效果展示
```
hub run humanseg_lite --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/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)
## API
## 二、安装
```python
def segment(images=None,
- ### 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、代码示例
- 图片分割及视频分割代码示例：
```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
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()
```
- ### 3、API
```python
def segment(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_lite_output')
```
```
预测API，用于人像分割。
- 预测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'，对应的取值为：
* 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,
```python
def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
```
预测API，用于逐帧对视频人像分割。
- 预测API，用于逐帧对视频人像分割。
**参数**
- **参数**
* 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环境变量，否则不用设置；
* 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): 当前帧光流追踪图和预测结果融合图
* img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。
* cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图；
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图
```python
def video_segment(self,
```python
def video_segment(self,
video_path=None,
use_gpu=False,
save_dir='humanseg_lite_video_result'):
```
```
预测API，用于视频人像分割。
- 预测API，用于视频人像分割。
**参数**
- **参数**
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
```python
def save_inference_model(dirname='humanseg_lite_model',
```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: 是否将参数保存到统一的一个文件中
## 代码示例
图片分割及视频分割代码示例：
```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
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()
- **参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
```
## 服务部署
## 四、服务部署
PaddleHub Serving可以部署一个人像分割的在线服务。
- PaddleHub Serving可以部署一个人像分割的在线服务。
## 第一步：启动PaddleHub Serving
- ### 第一步：启动PaddleHub Serving
运行启动命令：
```shell
$ hub serving start -m humanseg_lite
```
- 运行启动命令：
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
```shell
$ hub serving start -m humanseg_lite
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
## 第二步：发送预测请求
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ### 第二步：发送预测请求
```python
import requests
import json
import base64
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
import cv2
import numpy as np
```python
import requests
import json
import base64
def cv2_to_base64(image):
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):
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))
# 发送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))
# 保存图片
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)
```
# 保存图片
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
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
### 依赖
新增视频人像分割接口
paddlepaddle >= 1.8.0
新增视频流人像分割接口
* 1.1.1
paddlehub >= 1.7.1
修复cudnn为8.0.4显存泄露问题
modules/image/semantic_segmentation/humanseg_mobile/README.md
浏览文件 @ a4d455b8
## 模型概述
# humanseg_mobile
HumanSeg-mobile是基于HRNet(Deep High-Resolution Representation Learning for Visual Recognition)的人像分割网络。HRNet在特征提取过程中保持了高分辨率的信息，保持了物体的细节信息，并可通过控制每个分支的通道数调整模型的大小。HumanSeg-mobile采用了HRNet_w18_small_v1的网络结构，模型大小只有5.8M， 适用于移动端或服务端CPU的前置摄像头场景。
|模型名称|humanseg_mobile|
| :--- | :---: |
|类别|图像-图像分割|
|网络|hrnet|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|5.8MB|
|指标|-|
|最新更新日期|2021-02-26|
## 命令行预测
```
hub run humanseg_mobile --input_path "/PATH/TO/IMAGE"
```
## 一、模型基本信息
## API
- ### 应用效果展示
```python
def segment(images=None,
- 样例结果示例：
<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>
- ### 模型介绍
- HumanSeg-mobile采用了HRNet_w18_small_v1的网络结构，模型大小只有5.8M， 适用于移动端或服务端CPU的前置摄像头场景。
- 更多详情请参考：[humanseg_mobile](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_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预测
- ### 1、命令行预测
```
hub run humanseg_mobile --input_path "/PATH/TO/IMAGE"
```
- ### 2、代码示例
- 图片分割及视频分割代码示例：
```python
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')
```
- 视频流预测代码示例：
```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()
cap_out.release()
```
- ### 3、API
```python
def segment(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_mobile_output')
```
```
预测API，用于人像分割。
- 预测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'，对应的取值为：
* 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,
```python
def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
```
预测API，用于逐帧对视频人像分割。
- 预测API，用于逐帧对视频人像分割。
**参数**
- **参数**
* 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环境变量，否则不用设置；
* 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): 当前帧光流追踪图和预测结果融合图
* img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。
* cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图；
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图
```python
def video_segment(self,
```python
def video_segment(self,
video_path=None,
use_gpu=False,
save_dir='humanseg_mobile_video_result'):
```
```
预测API，用于视频人像分割。
- 预测API，用于视频人像分割。
**参数**
- **参数**
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
```python
def save_inference_model(dirname='humanseg_mobile_model',
```python
def save_inference_model(dirname='humanseg_mobile_model',
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。
**参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 代码示例
图片分割及视频分割代码示例：
```python
import cv2
import paddlehub as hub
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')
```
视频流预测代码示例：
```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()
cap_out.release()
- 将模型保存到指定路径。
```
- **参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 服务部署
## 四、服务部署
PaddleHub Serving可以部署一个人像分割的在线服务。
- PaddleHub Serving可以部署一个人像分割的在线服务。
## 第一步：启动PaddleHub Serving
- ### 第一步：启动PaddleHub Serving
运行启动命令：
- 运行启动命令：
```shell
$ hub serving start -m humanseg_mobile
```
```shell
$ hub serving start -m humanseg_mobile
```
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
- 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
- ### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
```python
import requests
import json
import base64
import cv2
import numpy as np
import cv2
import numpy as np
def cv2_to_base64(image):
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
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))
# 发送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)
```
# 保存图片
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)
```
### 查看代码
## 五、更新历史
<https://github.com/PaddlePaddle/PaddleSeg/tree/develop/contrib/HumanSeg>
* 1.0.0
初始发布
* 1.1.0
### 依赖
新增视频人像分割接口
paddlepaddle >= 1.8.0
新增视频流人像分割接口
* 1.1.1
paddlehub >= 1.7.1
修复cudnn为8.0.4显存泄露问题
modules/image/semantic_segmentation/humanseg_server/README.md
浏览文件 @ a4d455b8
## 模型概述
# humanseg_server
高精度模型，适用于服务端GPU且背景复杂的人像场景， 模型结构为Deeplabv3+/Xcetion65, 模型大小为158M，网络结构如图：
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/paddlehub-img/deeplabv3plus.png" hspace='10'/> <br />
</p>
|模型名称|humanseg_server|
| :--- | :---: |
|类别|图像-图像分割|
|网络|hrnet|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|159MB|
|指标|-|
|最新更新日期|2021-02-26|
## 命令行预测
```
hub run humanseg_server --input_path "/PATH/TO/IMAGE"
```
## 一、模型基本信息
- ### 应用效果展示
## API
- 样例结果示例：
<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>
```python
def segment(self,
images=None,
- ### 模型介绍
- HumanSeg-server使用百度自建数据集进行训练，可用于人像分割，支持任意大小的图片输入。
- 更多详情请参考：[humanseg_server](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_server
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API预测
- ### 1、命令行预测
```
hub run humanseg_server --input_path "/PATH/TO/IMAGE"
```
- ### 2、代码示例
- 图片分割及视频分割代码示例：
```python
import cv2
import paddlehub as hub
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')
```
- 视频流预测代码示例：
```python
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()
cap_out.release()
```
- ### 3、API
```python
def segment(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='humanseg_server_output'):
```
output_dir='humanseg_server_output')
```
预测API，用于人像分割。
- 预测API，用于人像分割。
**参数**
- **参数**
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径。
* 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'，对应的取值为：
* 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,
```python
def video_stream_segment(self,
frame_org,
frame_id,
prev_gray,
prev_cfd,
use_gpu=False):
```
```
预测API，用于逐帧对视频人像分割。
- 预测API，用于逐帧对视频人像分割。
**参数**
- **参数**
* 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环境变量，否则不用设置。
* 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): 当前帧光流追踪图和预测结果融合图。
* img_matting (numpy.ndarray): 人像分割结果，仅包含Alpha通道，取值为0-1 (0为全透明，1为不透明)。
* cur_gray (numpy.ndarray): 当前帧输入网络图像的灰度图；
* optflow_map (numpy.ndarray): 当前帧光流追踪图和预测结果融合图
```python
def video_segment(self,
```python
def video_segment(self,
video_path=None,
use_gpu=False,
save_dir='humanseg_server_video'):
```
save_dir='humanseg_server_video_result'):
```
预测API，用于视频人像分割。
- 预测API，用于视频人像分割。
**参数**
- **参数**
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果；
* use\_gpu (bool): 是否使用GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
* video\_path (str): 待分割视频路径。若为None，则从本地摄像头获取视频，并弹出窗口显示在线分割结果。
* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
* save\_dir (str): 视频保存路径，仅在video\_path不为None时启用，保存离线视频处理结果。
```python
def save_inference_model(dirname,
```python
def save_inference_model(dirname='humanseg_server_model',
model_filename=None,
params_filename=None,
combined=True):
```
将模型保存到指定路径。
**参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 代码示例
图片分割及视频分割代码示例：
```python
import cv2
import paddlehub as hub
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')
```
视频流预测代码示例：
```python
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
combined=True)
```
- 将模型保存到指定路径。
cap_video.release()
cap_out.release()
- **参数**
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
```
## 四、服务部署
## 服务部署
- PaddleHub Serving可以部署一个人像分割的在线服务。
PaddleHub Serving可以部署一个人像分割的在线服务。
- ### 第一步：启动PaddleHub Serving
## 第一步：启动PaddleHub Serving
- 运行启动命令：
运行启动命令：
```shell
$ hub serving start -m humanseg_server
```
```shell
$ hub serving start -m humanseg_server
```
这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
- 这样就完成了一个人像分割的服务化API的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
- ### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import base64
```python
import requests
import json
import base64
import cv2
import numpy as np
import cv2
import numpy as np
def cv2_to_base64(image):
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
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))
# 发送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)
```
# 保存图片
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)
```
### 查看代码
## 五、更新历史
https://github.com/PaddlePaddle/PaddleSeg/tree/develop/contrib/HumanSeg
* 1.0.0
初始发布
* 1.1.0
### 依赖
新增视频人像分割接口
paddlepaddle >= 1.8.0
新增视频流人像分割接口
* 1.1.1
paddlehub >= 1.7.1
修复cudnn为8.0.4显存泄露问题
modules/thirdparty/image/semantic_segmentation/U2Net/README.md
浏览文件 @ a4d455b8
## 概述
* ![](http://latex.codecogs.com/svg.latex?U^2Net)的网络结构如下图，其类似于编码-解码(Encoder-Decoder)结构的 U-Net
* 每个 stage 由新提出的 RSU模块(residual U-block) 组成. 例如，En_1 即为基于 RSU 构建的
# U2Net
![](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,
paths=None,
batch_size=1,
input_size=320,
output_dir='output',
visualization=False):
```
图像前景背景分割 API
**参数**
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* input_size (int) : 输入图像大小
* output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
## 一、模型基本信息
- ### 应用效果展示
- 效果展示
<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
**返回**
* results (list[np.ndarray]): 输出图像数据列表
- ### 2、安装
- ```shell
$ hub install U2Net
```
**代码示例**
```python
import cv2
import paddlehub as hub
- 如您安装时遇到问题，可参考：[零基础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)
model = hub.Module(name='U2Net')
## 三、模型API预测
- ### 1、代码示例
result = model.Segmentation(
```python
import cv2
import paddlehub as hub
model = hub.Module(name='U2Net')
result = model.Segmentation(
images=[cv2.imread('/PATH/TO/IMAGE')],
paths=None,
batch_size=1,
input_size=320,
output_dir='output',
visualization=True)
```
```
- ### 2、API
```python
def Segmentation(
images=None,
paths=None,
batch_size=1,
input_size=320,
output_dir='output',
visualization=False):
```
- 图像前景背景分割 API
- **参数**
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* input_size (int) : 输入图像大小
* output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
- **返回**
* results (list[np.ndarray]): 输出图像数据列表
## 四、更新历史
## 查看代码
https://github.com/NathanUA/U-2-Net
* 1.0.0
## 依赖
paddlepaddle >= 2.0.0rc0
paddlehub >= 2.0.0b1
初始发布
modules/thirdparty/image/semantic_segmentation/U2Netp/README.md
浏览文件 @ a4d455b8
## 概述
* ![](http://latex.codecogs.com/svg.latex?U^2Net)的网络结构如下图，其类似于编码-解码(Encoder-Decoder)结构的 U-Net
* 每个 stage 由新提出的 RSU模块(residual U-block) 组成. 例如，En_1 即为基于 RSU 构建的
* ![](http://latex.codecogs.com/svg.latex?U^2Net^+)是一个小型化的![](http://latex.codecogs.com/svg.latex?U^2Net)
# U2Netp
![](https://ai-studio-static-online.cdn.bcebos.com/999d37b4ffdd49dc9e3315b7cec7b2c6918fdd57c8594ced9dded758a497913d)
|模型名称|U2Netp|
| :--- | :---: |
|类别|图像-图像分割|
|网络|U^2Net|
|数据集|-|
|是否支持Fine-tuning|否|
|模型大小|6.7MB|
|指标|-|
|最新更新日期|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,
paths=None,
batch_size=1,
input_size=320,
output_dir='output',
visualization=False):
```
图像前景背景分割 API
**参数**
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* input_size (int) : 输入图像大小
* output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<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
```
**返回**
* results (list[np.ndarray]): 输出图像数据列表
- 如您安装时遇到问题，可参考：[零基础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
## 三、模型API预测
- ### 1、代码示例
model = hub.Module(name='U2Netp')
```python
import cv2
import paddlehub as hub
result = model.Segmentation(
model = hub.Module(name='U2Netp')
result = model.Segmentation(
images=[cv2.imread('/PATH/TO/IMAGE')],
paths=None,
batch_size=1,
input_size=320,
output_dir='output',
visualization=True)
```
```
- ### 2、API
```python
def Segmentation(
images=None,
paths=None,
batch_size=1,
input_size=320,
output_dir='output',
visualization=False):
```
- 图像前景背景分割 API
- **参数**
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* input_size (int) : 输入图像大小
* output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
- **返回**
* results (list[np.ndarray]): 输出图像数据列表
## 四、更新历史
* 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 是一种用于视频中天空置换与协调的视觉方法，该方法能够在风格可控的视频中自动生成逼真的天空背景。
* 该算法是一种完全基于视觉的解决方案，它的好处就是可以处理非静态图像，同时不受拍摄设备的限制，也不需要用户交互，可以处理在线或离线视频。
* 算法主要由三个核心组成：
* 天空抠图网络（Sky Matting Network）：就是一种 Matting 图像分隔，用于检测视频帧中天空区域的视频，可以精确地获得天空蒙版。
* 运动估计（Motion Estimation）：恢复天空运动的运动估计器，使生成的天空与摄像机的运动同步。
* 图像融合（Image Blending）：将用户指定的天空模板混合到视频帧中。除此之外，还用于重置和着色，使混合结果在其颜色和动态范围内更具视觉逼真感。
* 整体框架图如下：
![](http://p4.itc.cn/q_70/images03/20201114/42eaf00af8dd4aa4ae3c0cdc6e50b793.jpeg)
* 参考论文：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)
## 模型安装
```shell
$hub install SkyAR
```
## 效果展示
* 原始视频：
# SkyAR
|模型名称|SkyAR|
| :--- | :---: |
|类别|图像-图像分割|
|网络|UNet|
|数据集|UNet|
|是否支持Fine-tuning|否|
|模型大小|206MB|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
* 原始视频：
![原始视频](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/20210125211523491.gif)
* 第九区飞船：
* 第九区飞船：
![第九区飞船](https://img-blog.csdnimg.cn/20210125211520955.gif)
* 原始视频：
* 原始视频：
![原始视频](https://img-blog.csdnimg.cn/20210126142038716.gif)
* 漂浮城堡：
* 漂浮城堡：
![漂浮城堡](https://img-blog.csdnimg.cn/20210125211514997.gif)
* 电闪雷鸣：
* 电闪雷鸣：
![电闪雷鸣](https://img-blog.csdnimg.cn/20210125211433591.gif)
* 超级月亮：
* 超级月亮：
![超级月亮](https://img-blog.csdnimg.cn/20210125211417524.gif)
## API 说明
- ### 模型介绍
- SkyAR是一种用于视频中天空置换与协调的视觉方法，主要由三个核心组成：天空抠图网络、运动估计和图像融合。
- 更多详情请参考：[SkyAR](https://github.com/jiupinjia/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.
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
```shell
$hub install SkyAR
```
- 如您安装时遇到问题，可参考：[零基础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 MagicSky(
## 三、模型API预测
- ### 1、代码示例
```python
import paddlehub as hub
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
)
```
深度估计API
```
**参数**
- **参数**
* video_path(str)：输入视频路径
* save_path(str)：视频保存路径
* config(str): 预设 SkyBox 配置，所有预设配置如下，如果使用自定义 SkyBox，请设置为 None：
```
[
* 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)：是否图形化预览
## 预测代码示例
```python
import paddlehub as hub
model = hub.Module(name='SkyAR')
model.MagicSky(
video_path=[path to input video path],
save_path=[path to save video path]
)
```
## 模型相关信息
]
```
* 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)：是否图形化预览
### 模型代码
https://github.com/jm12138/SkyAR_Paddle_GUI
## 四、更新历史
### 依赖
* 1.0.0
paddlepaddle >= 2.0.0rc0
初始发布
paddlehub >= 2.0.0rc0
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或