Skip to content

P
PaddleHub

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

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

Update cv module docs

上级 9d5527df
隐藏空白更改
内联 并排
Showing with 1704 addition and 638 deletion
modules/image/Image_editing/colorization/user_guided_colorization/README.md 0 → 100644
浏览文件 @ fd4fb4db
# user_guided_colorization
|模型名称|user_guided_colorization|
| :--- | :---: |
|类别|图像-图像编辑|
|网络| Local and Global Hints Network |
|数据集|ILSVRC 2012|
|是否支持Fine-tuning|是|
|模型大小|131MB|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 模型介绍
- ### 应用效果展示
- 样例结果示例(左为原图，右为效果图)：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/136653401-6644bd46-d280-4c15-8d48-680b7eb152cb.png" width = "300" height = "450" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/136648959-40493c9c-08ec-46cd-a2a2-5e2038dcbfa7.png" width = "300" height = "450" hspace='10'/>
</p>
- user_guided_colorization 是基于''Real-Time User-Guided Image Colorization with Learned Deep Priors"的着色模型，该模型利用预先提供的着色块对图像进行着色。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install user_guided_colorization
```
- 如您安装时遇到问题，可参考：[零基础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 user_guided_colorization --input_path "/PATH/TO/IMAGE"
```
- ### 2.预测代码示例
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='user_guided_colorization')
model.set_config(prob=0.1)
result = model.predict(images=['/PATH/TO/IMAGE'])
```
- ### 3.如何开始Fine-tune
- 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用user_guided_colorization模型对[Canvas](../../docs/reference/datasets.md#class-hubdatasetsCanvas)等数据集进行Fine-tune。
- 代码步骤
- Step1: 定义数据预处理方式
- ```python
import paddlehub.vision.transforms as T
transform = T.Compose([T.Resize((256, 256), interpolation='NEAREST'),
T.RandomPaddingCrop(crop_size=176),
T.RGB2LAB()], to_rgb=True)
```
- `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
- Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Canvas
color_set = Canvas(transform=transform, mode='train')
```
* `transforms`: 数据预处理方式。
* `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
* `hub.datasets.Canvas()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
- Step3: 加载预训练模型
- ```python
model = hub.Module(name='user_guided_colorization', load_checkpoint=None)
model.set_config(classification=True, prob=1)
```
* `name`:加载模型的名字。
* `load_checkpoint`: 是否加载自己训练的模型，若为None，则加载提供的模型默认参数。
* `classification`: 着色模型分两部分训练，开始阶段`classification`设置为True, 用于浅层网络训练。训练后期将`classification`设置为False, 用于训练网络的输出层。
* `prob`: 每张输入图不加一个先验彩色块的概率，默认为1，即不加入先验彩色块。例如，当`prob`设定为0.9时，一张图上有两个先验彩色块的概率为(1-0.9)*(1-0.9)*0.9=0.009.
- Step4: 选择优化策略和运行配置
```python
optimizer = paddle.optimizer.Adam(learning_rate=0.0001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_colorization_ckpt_cls_1')
trainer.train(color_set, epochs=201, batch_size=25, eval_dataset=color_set, log_interval=10, save_interval=10)
```
- 运行配置
- `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='user_guided_colorization', load_checkpoint='/PATH/TO/CHECKPOINT')
model.set_config(prob=0.1)
result = model.predict(images=['house.png'])
```
- **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。若想获取油画风着色效果，请下载参数文件[油画着色](https://paddlehub.bj.bcebos.com/dygraph/models/canvas_rc.pdparams)
## 四、服务部署
- PaddleHub Serving可以部署一个在线着色任务服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m user_guided_colorization
```
- 这样就完成了一个着色任务服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data
# 发送HTTP请求
org_im = cv2.imread('/PATH/TO/IMAGE')
data = {'images':[cv2_to_base64(org_im)]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/user_guided_colorization"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
data = base64_to_cv2(r.json()["results"]['data'][0]['fake_reg'])
cv2.imwrite('color.png', data)
```
## 五、更新历史
* 1.0.0
初始发布
modules/image/Image_editing/super_resolution/dcscn/README.md
浏览文件 @ fd4fb4db
## 模型概述 # dcscn
DCSCN是基于Fast and Accurate Image Super Resolution by Deep CNN with Skip Connection and Network in Network设计的轻量化超分辨模型。该模型使用残差结构和跳连的方式构建网络来提取局部和全局特征，同时使用并行1*1的卷积网络学习细节特征提升模型性能。该模型提供的超分倍数为2倍。
## 命令行预测 |模型名称|dcscn|
| :--- | :---: |
|类别|图像-图像编辑|
|网络|dcscn|
|数据集|DIV2k|
|是否支持Fine-tuning|否|
|模型大小|260KB|
|指标|PSNR37.63|
|最新更新日期|2021-02-26|
```
$ hub run dcscn --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="dcscn_output")
```
预测API，用于图像超分辨率。 - ### 模型介绍
**参数** - DCSCN是基于Fast and Accurate Image Super Resolution by Deep CNN with Skip Connection and Network in Network设计的轻量化超分辨模型。该模型使用残差结构和跳连的方式构建网络来提取局部和全局特征，同时使用并行1*1的卷积网络学习细节特征提升模型性能。该模型提供的超分倍数为2倍。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - 更多详情请参考：[dcscn](https://github.com/jiny2001/dcscn-super-resolution)
* 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='dcscn_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 dcscn
* 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='dcscn') - ```
im = cv2.imread('/PATH/TO/IMAGE').astype('float32') $ hub run dcscn --input_path "/PATH/TO/IMAGE"
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。 ```
res = sr_model.reconstruct(images=[im], visualization=True) - ### 2、预测代码示例
print(res[0]['data'])
sr_model.save_inference_model()
```
## 服务部署 ```python
import cv2
import paddlehub as hub
PaddleHub Serving可以部署一个图像超分的在线服务。 sr_model = hub.Module(name='dcscn')
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 - ### 3、API
运行启动命令： - ```python
def reconstruct(self,
images=None,
paths=None,
use_gpu=False,
visualization=False,
output_dir="dcscn_output")
```
```shell - 预测API，用于图像超分辨率。
$ hub serving start -m dcscn
```
这样就完成了一个超分任务的服务化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='dcscn_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: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
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/dcscn"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = np.expand_dims(cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY), axis=2)
shape =sr.shape
org_im = cv2.cvtColor(org_im, cv2.COLOR_BGR2YUV)
uv = cv2.resize(org_im[...,1:], (shape[1], shape[0]), interpolation=cv2.INTER_CUBIC)
combine_im = cv2.cvtColor(np.concatenate((sr, uv), axis=2), cv2.COLOR_YUV2BGR)
cv2.imwrite('dcscn_X2.png', combine_im)
print("save image as dcscn_X2.png")
``` ## 四、服务部署
### 查看代码
https://github.com/jiny2001/dcscn-super-resolution - PaddleHub Serving可以部署一个图像超分的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
### 依赖 - ```shell
$ hub serving start -m dcscn
```
paddlepaddle >= 1.8.0 - 这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
paddlehub >= 1.7.1 - **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/dcscn"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = np.expand_dims(cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY), axis=2)
shape =sr.shape
org_im = cv2.cvtColor(org_im, cv2.COLOR_BGR2YUV)
uv = cv2.resize(org_im[...,1:], (shape[1], shape[0]), interpolation=cv2.INTER_CUBIC)
combine_im = cv2.cvtColor(np.concatenate((sr, uv), axis=2), cv2.COLOR_YUV2BGR)
cv2.imwrite('dcscn_X2.png', combine_im)
print("save image as dcscn_X2.png")
```
## 五、更新历史
* 1.0.0
初始发布
modules/image/Image_editing/super_resolution/falsr_a/README.md
浏览文件 @ fd4fb4db
## 模型概述 # falsr_a
falsr_a是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
## 命令行预测 |模型名称|falsr_a|
| :--- | :---: |
|类别|图像-图像编辑|
|网络|falsr_a|
|数据集|DIV2k|
|是否支持Fine-tuning|否|
|模型大小|8.9MB|
|指标|PSNR37.82|
|最新更新日期|2021-02-26|
```
$ hub run falsr_a --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_a_output")
```
预测API，用于图像超分辨率。 - ### 模型介绍
**参数** - falsr_a是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - 更多详情请参考：[falsr_a](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_a_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_a
* 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_a') - ```
im = cv2.imread('/PATH/TO/IMAGE').astype('float32') $ hub run falsr_a --input_path "/PATH/TO/IMAGE"
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。 ```
res = sr_model.reconstruct(images=[im], visualization=True) - ### 2、预测代码示例
print(res[0]['data'])
sr_model.save_inference_model()
```
## 服务部署 ```python
import cv2
import paddlehub as hub
PaddleHub Serving可以部署一个图像超分的在线服务。 sr_model = hub.Module(name='falsr_a')
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 - ### 3、API
运行启动命令： - ```python
def reconstruct(self,
images=None,
paths=None,
use_gpu=False,
visualization=False,
output_dir="falsr_a_output")
```
```shell - 预测API，用于图像超分辨率。
$ hub serving start -m falsr_a
```
这样就完成了一个超分任务的服务化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_a_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_a"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = base64_to_cv2(r.json()["results"][0]['data'])
cv2.imwrite('falsr_a_X2.png', sr)
print("save image as falsr_a_X2.png")
```
### 查看代码
https://github.com/xiaomi-automl/FALSR
### 依赖 ## 四、服务部署
- PaddleHub Serving可以部署一个图像超分的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m falsr_a
```
- 这样就完成了一个超分任务的服务化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_a"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = base64_to_cv2(r.json()["results"][0]['data'])
cv2.imwrite('falsr_a_X2.png', sr)
print("save image as falsr_a_X2.png")
```
## 五、更新历史
* 1.0.0
初始发布
paddlepaddle >= 1.8.0
paddlehub >= 1.7.1
modules/image/Image_editing/super_resolution/falsr_b/README.md
浏览文件 @ fd4fb4db
## 模型概述 # falsr_b
falsr_b是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。falsr_b较falsr_a更轻量化。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
## 命令行预测 |模型名称|falsr_b|
| :--- | :---: |
|类别|图像-图像编辑|
|网络|falsr_b|
|数据集|DIV2k|
|是否支持Fine-tuning|否|
|模型大小|4MB|
|指标|PSNR37.61|
|最新更新日期|2021-02-26|
```
$ hub run falsr_b --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=True,
output_dir="falsr_b_output")
```
预测API，用于图像超分辨率。 - ### 模型介绍
**参数** - falsr_b是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式； - 更多详情请参考：[falsr_b](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_b_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_b
* 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_b') - ```
im = cv2.imread('/PATH/TO/IMAGE').astype('float32') $ hub run falsr_b --input_path "/PATH/TO/IMAGE"
#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。 ```
res = sr_model.reconstruct(images=[im], visualization=True) - ### 2、预测代码示例
print(res[0]['data'])
sr_model.save_inference_model()
```
## 服务部署 ```python
import cv2
import paddlehub as hub
PaddleHub Serving可以部署一个图像超分的在线服务。 sr_model = hub.Module(name='falsr_b')
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 - ### 3、API
运行启动命令： - ```python
def reconstruct(self,
images=None,
paths=None,
use_gpu=False,
visualization=False,
output_dir="falsr_b_output")
```
```shell - 预测API，用于图像超分辨率。
$ hub serving start -m falsr_b
```
这样就完成了一个超分任务的服务化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_b_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_b"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = base64_to_cv2(r.json()["results"][0]['data'])
cv2.imwrite('falsr_b_X2.png', sr)
print("save image as falsr_b_X2.png")
```
### 查看代码
https://github.com/xiaomi-automl/FALSR
### 依赖 ## 四、服务部署
- PaddleHub Serving可以部署一个图像超分的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m falsr_b
```
- 这样就完成了一个超分任务的服务化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_b"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
sr = base64_to_cv2(r.json()["results"][0]['data'])
cv2.imwrite('falsr_b_X2.png', sr)
print("save image as falsr_b_X2.png")
```
## 五、更新历史
* 1.0.0
初始发布
paddlepaddle >= 1.8.0
paddlehub >= 1.7.1
modules/image/Image_gan/attgan_celeba/README.md 0 → 100644
浏览文件 @ fd4fb4db
# attgan_celeba
|模型名称|attgan_celeba|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|AttGAN|
|数据集|Celeba|
|是否支持Fine-tuning|否|
|模型大小|167MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/137855667-43c5c40c-28f5-45d8-accc-028e185b988f.JPG" width=1200><br/>
图1. AttGAN的效果图(图片属性分别为：original image, Bald, Bangs, Black_Hair, Blond_Hair, Brown_Hair, Bushy_Eyebrows, Eyeglasses, Gender, Mouth_Slightly_Open, Mustache, No_Beard, Pale_Skin, Aged)<br/>
</p>
- ### 模型介绍
- AttGAN 是一种生成对抗网络(Generative Adversarial Networks)，它利用分类损失和重构损失来保证改变特定的属性。该 PaddleHub Module 使用 Celeba 数据集训练完成，目前支持 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 这十三种人脸属性转换。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.5.2
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install attgan_celeba==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、命令行预测
- ```shell
$ hub run attgan_celeba --image "/PATH/TO/IMAGE" --style "target_attribute"
```
- **参数**
- image ：指定图片路径。
- style 指定拟转换的属性，可选择 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 中的一种。
- ### 2、预测代码示例
- ```python
import paddlehub as hub
attgan = hub.Module(name="attgan_celeba")
test_img_path = ["/PATH/TO/IMAGE"]
trans_attr = ["Bangs"]
# set input dict
input_dict = {"image": test_img_path, "style": trans_attr}
# execute predict and print the result
results = attgan.generate(data=input_dict)
print(results)
```
- ### 3、API
- ```python
def generate(data)
```
- 风格转换API，用于图像生成。
- **参数**
- data： dict 类型，有以下字段
- image (list\[str\])： list中每个元素为待转换的图片路径。
- style (list\[str\])： list中每个元素为字符串，填写待转换的人脸属性。
- **返回**
- res (list\[str\]): 提示生成图片的保存路径。
## 四、更新历史
* 1.0.0
初始发布
modules/image/Image_gan/cyclegan_cityscapes/README.md 0 → 100644
浏览文件 @ fd4fb4db
# cyclegan_cityscapes
|模型名称|cyclegan_cityscapes|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|CycleGAN|
|数据集|Cityscapes|
|是否支持Fine-tuning|否|
|模型大小|33MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/137839740-4be4cf40-816f-401e-a73f-6cda037041dd.png" width = "450" height = "300" hspace='10'/>
<br />
输入图像
<br />
<img src="https://user-images.githubusercontent.com/35907364/137839777-89fc705b-f0d7-4a93-94e2-76c0d3c5a0b0.png" width = "450" height = "300" hspace='10'/>
<br />
输出图像
<br />
</p>
- ### 模型介绍
- CycleGAN是生成对抗网络（Generative Adversarial Networks ）的一种，与传统的GAN只能单向生成图片不同，CycleGAN可以同时完成两个domain的图片进行相互转换。该PaddleHub Module使用Cityscapes数据集训练完成，支持图片从实景图转换为语义分割结果，也支持从语义分割结果转换为实景图。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.1.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install cyclegan_cityscapes==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、命令行预测
- ```shell
$ hub run cyclegan_cityscapes --input_path "/PATH/TO/IMAGE"
```
- **参数**
- input_path ：指定图片路径。
- ### 2、预测代码示例
- ```python
import paddlehub as hub
cyclegan = hub.Module(name="cyclegan_cityscapes")
test_img_path = "/PATH/TO/IMAGE"
# set input dict
input_dict = {"image": [test_img_path]}
# execute predict and print the result
results = cyclegan.generate(data=input_dict)
print(results)
```
- ### 3、API
- ```python
def generate(data)
```
- 风格转换API，用于图像生成。
- **参数**
- data： dict 类型，有以下字段:
- image (list\[str\])： list中每个元素为待转换的图片路径。
- **返回**
- res (list\[str\]): 每个元素为对应输入图片的预测结果。预测结果为dict类型，有以下字段：
- origin: 原输入图片路径.
- generated: 生成图片的路径。
## 四、更新历史
* 1.0.0
初始发布
modules/image/Image_gan/stargan_celeba/README.md 0 → 100644
浏览文件 @ fd4fb4db
# stargan_celeba
|模型名称|stargan_celeba|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|STGAN|
|数据集|Celeba|
|是否支持Fine-tuning|否|
|模型大小|33MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/137855887-f0abca76-2735-4275-b7ad-242decf31bb3.PNG" width=600><br/>
图1. StarGAN的效果图 (属性分别为：origial image, Black_Hair, Blond_Hair, Brown_Hair, Male, Aged)<br/>
</p>
- ### 模型介绍
- StarGAN 是为了解决跨多个域、多个数据集的训练而提出的生成对抗网络模型。单个 StarGAN 模型就可以实现多个风格域的转换。 该 PaddleHub Module 使用 Celeba 数据集训练完成，目前支持 "Black_Hair", "Blond_Hair", "Brown_Hair", "Female", "Male", "Aged" 这六种人脸属性转换。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.5.2
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install stargan_celeba==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、命令行预测
- ```shell
$ hub run stargan_celeba --image "/PATH/TO/IMAGE" --style "target_attribute"
```
- **参数**
- image ：指定图片路径。
- style 指定拟转换的属性，可选择 "Black_Hair", "Blond_Hair", "Brown_Hair", "Female", "Male", "Aged" 中的一个。
- ### 2、预测代码示例
- ```python
import paddlehub as hub
stargan = hub.Module(name="stargan_celeba")
test_img_path = ["/PATH/TO/IMAGE"]
trans_attr = ["Blond_Hair"]
# set input dict
input_dict = {"image": test_img_path, "style": trans_attr}
# execute predict and print the result
results = stargan.generate(data=input_dict)
print(results)
```
- ### 3、API
- ```python
def generate(data)
```
- 风格转换API，用于图像生成。
- **参数**
- data： dict 类型，有以下字段
- image (list\[str\])： list中每个元素为待转换的图片路径。
- style (list\[str\])： list中每个元素为字符串，填写待转换的人脸属性。
- **返回**
- res (list\[str\]): 提示生成图片的保存路径。
## 四、更新历史
* 1.0.0
初始发布
modules/image/Image_gan/stgan_celeba/README.md 0 → 100644
浏览文件 @ fd4fb4db
# stgan_celeba
|模型名称|stgan_celeba|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|STGAN|
|数据集|Celeba|
|是否支持Fine-tuning|否|
|模型大小|287MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## 一、模型基本信息
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/137856070-2a43facd-cda0-473f-8935-e61f5dd583d8.JPG" width=1200><br/>
STGAN的效果图(图片属性分别为：original image, Bald, Bangs, Black_Hair, Blond_Hair, Brown_Hair, Bushy_Eyebrows, Eyeglasses, Gender, Mouth_Slightly_Open, Mustache, No_Beard, Pale_Skin, Aged)<br/>
</p>
- ### 模型介绍
- STGAN 以原属性和目标属性的差值作为输入，并创造性地提出了 STUs (Selective transfer units) 来选择和修改 encoder 的特征，从而改善了转换效果和处理能力。 该 PaddleHub Module 使用 Celeba 数据集训练完成，目前支持 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 这十三种人脸属性转换。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.5.2
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install stgan_celeba==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、命令行预测
- ```shell
$ hub run stgan_celeba --image "/PATH/TO/IMAGE" --info "original_attributes" --style "target_attribute"
```
- **参数**
- image ：指定图片路径。
- info ：原图的属性，必须填写性别（ "Male" 或者 "Female"）。可选值有："Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 。比如输入图片是一个女孩，有着黑头发，那么就填写为 "Female,Black_Hair"。建议尽可能完整地填写原图具备的属性，比如一个黑发女孩还戴了眼镜，那么应填写为 "Female,Black_Hair,Eyeglasses"，否则有可能转换失败。
- style 指定拟转换的属性，可选择 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 中的一种。
- ### 2、预测代码示例
- ```python
import paddlehub as hub
stgan = hub.Module(name="stgan_celeba")
test_img_path = ["/PATH/TO/IMAGE"]
org_info = ["Female,Black_Hair"]
trans_attr = ["Bangs"]
# set input dict
input_dict = {"image": test_img_path, "style": trans_attr, "info": org_info}
# execute predict and print the result
results = stgan.generate(data=input_dict)
print(results)
```
- ### 3、API
- ```python
def generate(data)
```
- 风格转换API，用于图像生成。
- **参数**
- data： dict 类型，有以下字段
- image (list\[str\])： list中每个元素为待转换的图片路径。
- style (list\[str\])： list中每个元素为字符串，填写待转换的人脸属性。
- info (list\[str\])： 表示原图具备的人脸属性，填得越详细效果会越好，不同属性用逗号隔开。
- **返回**
- res (list\[str\]): 提示生成图片的保存路径。
## 四、更新历史
* 1.0.0
初始发布
modules/image/Image_gan/style_transfer/ID_Photo_GEN/README.md
浏览文件 @ fd4fb4db
## 概述 # ID_Photo_GEN
* 基于 face_landmark_localization 和 FCN_HRNet_W18_Face_Seg 模型实现的证件照生成模型，一键生成白底、红底和蓝底的人像照片
|模型名称|ID_Photo_GEN|
## 效果展示 | :--- | :---: |
![](https://img-blog.csdnimg.cn/20201224163307901.jpg) |类别|图像 - 图像生成|
|网络|HRNet_W18|
## API |数据集|-|
```python |是否支持Fine-tuning|否|
def Photo_GEN( |模型大小|28KB|
images=None, |最新更新日期|2021-02-26|
paths=None, |数据指标|-|
batch_size=1,
output_dir='output',
visualization=False, ## 一、模型基本信息
use_gpu=False):
``` - ### 应用效果展示
证件照生成 API - 样例结果示例：
<p align="center">
**参数** <img src="https://img-blog.csdnimg.cn/20201224163307901.jpg" >
* images (list[np.ndarray]) : 输入图像数据列表（BGR） </p>
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* output_dir (str) : 可视化图像输出目录 - ### 模型介绍
* visualization (bool) : 是否可视化
* use_gpu (bool) : 是否使用 GPU 进行推理 - 基于face_landmark_localization和FCN_HRNet_W18_Face_Seg模型实现的证件照生成模型，一键生成白底、红底和蓝底的人像照片
**返回**
* results (list[dict{"write":np.ndarray,"blue":np.ndarray,"red":np.ndarray}]): 输出图像数据列表 ## 二、安装
**代码示例** - ### 1、环境依赖
```python
import cv2 - paddlepaddle >= 2.0.0
import paddlehub as hub
- paddlehub >= 2.0.0
model = hub.Module(name='ID_Photo_GEN')
- ### 2、安装
result = model.Photo_GEN(
images=[cv2.imread('/PATH/TO/IMAGE')], - ```shell
paths=None, $ hub install ID_Photo_GEN
batch_size=1, ```
output_dir='output', - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
visualization=True, | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
use_gpu=False)
```
## 三、模型API预测
## 依赖
paddlepaddle >= 2.0.0rc0 - ### 1、预测代码示例
paddlehub >= 2.0.0b1
- ```python
import cv2
import paddlehub as hub
model = hub.Module(name='ID_Photo_GEN')
result = model.Photo_GEN(
images=[cv2.imread('/PATH/TO/IMAGE')],
paths=None,
batch_size=1,
output_dir='output',
visualization=True,
use_gpu=False)
```
- ### 2、API
- ```python
def Photo_GEN(
images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False,
use_gpu=False):
```
- 证件照生成API
- **参数**
* images (list[np.ndarray]) : 输入图像数据列表（BGR）
* paths (list[str]) : 输入图像路径列表
* batch_size (int) : 数据批大小
* output_dir (str) : 可视化图像输出目录
* visualization (bool) : 是否可视化
* use_gpu (bool) : 是否使用 GPU 进行推理
**NOTE:** paths和images两个参数选择其一进行提供数据
- **返回**
* results (list[dict{"write":np.ndarray,"blue":np.ndarray,"red":np.ndarray}]): 输出图像数据列表
## 四、更新历史
* 1.0.0
初始发布
modules/image/Image_gan/style_transfer/UGATIT_83w/README.md
浏览文件 @ fd4fb4db
## 模型概述 # UGATIT_83w
UGATIT 图像风格转换模型
模型可将输入的人脸图像转换成动漫风格 |模型名称|UGATIT_83w|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|U-GAT-IT|
|数据集|selfie2anime|
|是否支持Fine-tuning|否|
|模型大小|41MB|
|最新更新日期|2021-02-26|
|数据指标|-|
模型权重来自UGATIT-Paddle开源项目
模型所使用的权重为genA2B_0835000 ## 一、模型基本信息
模型详情请参考[UGATIT-Paddle开源项目](https://github.com/miraiwk/UGATIT-paddle) - ### 应用效果展示
- 样例结果示例(左为原图，右为效果图)：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/136651638-33cac040-edad-41ac-a9ce-7c0e678d8c52.jpg" width = "400" height = "400" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/136651644-dd1d3836-99b3-40f0-8543-37de18f9cfd9.jpg" width = "400" height = "400" hspace='10'/>
</p>
## 模型安装
```shell
$hub install UGATIT_83w
```
- ### 模型介绍
## API 说明 - UGATIT 图像风格转换模型, 模型可将输入的人脸图像转换成动漫风格.
```python
def style_transfer(
self,
images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False
)
```
风格转换API，将输入的人脸图像转换成动漫风格。 ## 二、安装
转换效果图如下： - ### 1、环境依赖
![输入图像](https://ai-studio-static-online.cdn.bcebos.com/d130fabd8bd34e53b2f942b3766eb6bbd3c19c0676d04abfbd5cc4b83b66f8b6) - paddlepaddle >= 1.8.2
![输出图像](https://ai-studio-static-online.cdn.bcebos.com/78653331ee2d472b81ff5bbccd6a904a80d2c5208f9c42c789b4f09a1ef46332)
**参数** - paddlehub >= 1.8.0
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None； - ### 2、安装
* paths (list\[str\]): 图片的路径，默认为 None；
* batch\_size (int): batch 的大小，默认设为 1；
* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
* output\_dir (str): 图片的保存路径，默认设为 output。
- ```shell
$ hub install UGATIT_83w
```
- 如您安装时遇到问题，可参考：[零基础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、预测代码示例
* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。 - ```python
import cv2
import paddlehub as hub
# 模型加载
# use_gpu：是否使用GPU进行预测
model = hub.Module(name='UGATIT_83w', use_gpu=False)
## 预测代码示例 # 模型预测
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
```python # or
import cv2 # result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
import paddlehub as hub ```
# 模型加载 - ### 2、API
# use_gpu：是否使用GPU进行预测
model = hub.Module('UGATIT_83w', use_gpu=False)
# 模型预测 - ```python
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')]) def style_transfer(
self,
images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False
)
```
# or - 风格转换API，将输入的人脸图像转换成动漫风格。
# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
```
## 服务部署 - **参数**
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
* paths (list\[str\]): 图片的路径，默认为 None；
* batch\_size (int): batch 的大小，默认设为 1；
* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
* output\_dir (str): 图片的保存路径，默认设为 output
PaddleHub Serving可以部署一个在线图像风格转换服务。 **NOTE:** paths和images两个参数选择其一进行提供数据
## 第一步：启动PaddleHub Serving - **返回**
运行启动命令： - res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
```shell
$ hub serving start -m UGATIT_w83
```
这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。 ## 四、服务部署
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - PaddleHub Serving可以部署一个在线图像风格转换服务。
## 第二步：发送预测请求 - ### 第一步：启动PaddleHub Serving
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 运行启动命令：
- ```shell
$ hub serving start -m UGATIT_83w
```
```python - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
import requests
import json
import cv2
import base64
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
def cv2_to_base64(image): - ### 第二步：发送预测请求
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
# 发送HTTP请求 - ```python
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]} import requests
headers = {"Content-type": "application/json"} import json
url = "http://127.0.0.1:8866/predict/UGATIT_w83" import cv2
r = requests.post(url=url, headers=headers, data=json.dumps(data)) import base64
# 打印预测结果
print(r.json()["results"])
```
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/UGATIT_83w"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
https://github.com/miraiwk/UGATIT-paddle # 打印预测结果
print(r.json()["results"])
```
### 依赖
paddlepaddle >= 1.8.0 ## 五、更新历史
paddlehub >= 1.8.0 * 1.0.0
初始发布
\ No newline at end of file
modules/image/Image_gan/style_transfer/UGATIT_92w/README.md
浏览文件 @ fd4fb4db
## 模型概述 # UGATIT_92w
UGATIT 图像风格转换模型
模型可将输入的人脸图像转换成动漫风格 |模型名称|UGATIT_92w|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|U-GAT-IT|
|数据集|selfie2anime|
|是否支持Fine-tuning|否|
|模型大小|41MB|
|最新更新日期|2021-02-26|
|数据指标|-|
模型权重来自UGATIT-Paddle开源项目
模型所使用的权重为genA2B_0924000 ## 一、模型基本信息
模型详情请参考[UGATIT-Paddle开源项目](https://github.com/miraiwk/UGATIT-paddle) - ### 应用效果展示
- 样例结果示例(左为原图，右为效果图)：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/136651638-33cac040-edad-41ac-a9ce-7c0e678d8c52.jpg" width = "400" height = "400" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/136653047-f00c30fb-521f-486f-8247-8d8f63649473.jpg" width = "400" height = "400" hspace='10'/>
</p>
## 模型安装
```shell
$hub install UGATIT_92w
```
- ### 模型介绍
## API 说明 - UGATIT 图像风格转换模型, 模型可将输入的人脸图像转换成动漫风格.
```python
def style_transfer(
self,
images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False
)
```
风格转换API，将输入的人脸图像转换成动漫风格。 ## 二、安装
转换效果图如下： - ### 1、环境依赖
![输入图像](https://ai-studio-static-online.cdn.bcebos.com/d130fabd8bd34e53b2f942b3766eb6bbd3c19c0676d04abfbd5cc4b83b66f8b6) - paddlepaddle >= 1.8.2
![输出图像](https://ai-studio-static-online.cdn.bcebos.com/b7305162ff6345e9b04507a196ebe854907b446936934844be8aae4b0297db18)
**参数** - paddlehub >= 1.8.0
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None； - ### 2、安装
* paths (list\[str\]): 图片的路径，默认为 None；
* batch\_size (int): batch 的大小，默认设为 1；
* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
* output\_dir (str): 图片的保存路径，默认设为 output。
- ```shell
$ hub install UGATIT_92w
```
- 如您安装时遇到问题，可参考：[零基础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、预测代码示例
* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。 - ```python
import cv2
import paddlehub as hub
# 模型加载
# use_gpu：是否使用GPU进行预测
model = hub.Module(name='UGATIT_92w', use_gpu=False)
## 预测代码示例 # 模型预测
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
```python # or
import cv2 # result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
import paddlehub as hub ```
# 模型加载 - ### 2、API
# use_gpu：是否使用GPU进行预测
model = hub.Module(name='UGATIT_92w', use_gpu=False)
# 模型预测 - ```python
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')]) def style_transfer(
self,
images=None,
paths=None,
batch_size=1,
output_dir='output',
visualization=False
)
```
# or - 风格转换API，将输入的人脸图像转换成动漫风格。
# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
```
## 服务部署 - **参数**
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
* paths (list\[str\]): 图片的路径，默认为 None；
* batch\_size (int): batch 的大小，默认设为 1；
* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
* output\_dir (str): 图片的保存路径，默认设为 output
PaddleHub Serving可以部署一个在线图像风格转换服务。 **NOTE:** paths和images两个参数选择其一进行提供数据
## 第一步：启动PaddleHub Serving - **返回**
运行启动命令： - res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
```shell
$ hub serving start -m UGATIT_92w
```
这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。 ## 四、服务部署
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - PaddleHub Serving可以部署一个在线图像风格转换服务。
## 第二步：发送预测请求 - ### 第一步：启动PaddleHub Serving
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 运行启动命令：
- ```shell
$ hub serving start -m UGATIT_92w
```
```python - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
import requests
import json
import cv2
import base64
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
def cv2_to_base64(image): - ### 第二步：发送预测请求
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
# 发送HTTP请求 - ```python
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]} import requests
headers = {"Content-type": "application/json"} import json
url = "http://127.0.0.1:8866/predict/UGATIT_92w" import cv2
r = requests.post(url=url, headers=headers, data=json.dumps(data)) import base64
# 打印预测结果
print(r.json()["results"])
```
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/UGATIT_92w"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
https://github.com/miraiwk/UGATIT-paddle # 打印预测结果
print(r.json()["results"])
```
### 依赖
paddlepaddle >= 1.8.0 ## 五、更新历史
paddlehub >= 1.8.0 * 1.0.0
初始发布
\ No newline at end of file
modules/image/Image_gan/style_transfer/animegan_v2_paprika_54/README.md
浏览文件 @ fd4fb4db
## 模型概述 # animegan_v2_paprika_54
AnimeGAN V2 图像风格转换模型
模型可将输入的图像转换成Paprika风格 |模型名称|animegan_v2_paprika_54|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|AnimeGAN|
|数据集|The Wind Rises|
|是否支持Fine-tuning|否|
|模型大小|9.4MB|
|最新更新日期|2021-07-30|
|数据指标|-|
模型权重转换自AnimeGAN V2官方开源项目
模型所使用的权重为Paprika-54.ckpt ## 一、模型基本信息
模型详情请参考[AnimeGAN V2 开源项目](https://github.com/TachibanaYoshino/AnimeGANv2) - ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/136652269-48b8c902-3a2b-46b7-a9f2-d500097bbb0e.jpg" width = "450" height = "300" hspace='10'/>
<br />
输入图像
<br />
<img src="https://user-images.githubusercontent.com/35907364/136653120-e081cd59-bc2b-4a91-a437-3a7d478e0763.jpg" width = "450" height = "300" hspace='10'/>
<br />
输出图像
<br />
</p>
## 模型安装
```shell
$hub install animegan_v2_paprika_54
```
- ### 模型介绍
## API 说明 - AnimeGAN V2 图像风格转换模型, 模型可将输入的图像转换成宫崎骏动漫风格，模型权重转换自[AnimeGAN V2官方开源项目](https://github.com/TachibanaYoshino/AnimeGAN)。
```python
def style_transfer(
self,
images=None,
paths=None,
output_dir='output',
visualization=False,
min_size=32,
max_size=1024
)
```
风格转换API，将输入的图片转换为漫画风格。 ## 二、安装
转换效果图如下： - ### 1、环境依赖
![输入图像](https://ai-studio-static-online.cdn.bcebos.com/bd002c4bb6a7427daf26988770bb18648b7d8d2bfd6746bfb9a429db4867727f) - paddlepaddle >= 1.8.0
![输出图像](https://ai-studio-static-online.cdn.bcebos.com/08ee95c94e0b4d4e8b2855a6ed40af5853b40c0047b3421aaa2f7c877fac5130)
- paddlehub >= 1.8.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**参数** - ### 2、安装
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None； - ```shell
* paths (list\[str\]): 图片的路径，默认为 None； $ hub install animegan_v2_paprika_54
* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False； ```
* output\_dir (str): 图片的保存路径，默认设为 output； - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
* min\_size (int): 输入图片的短边最小尺寸，默认设为 32； | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
* max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
## 三、模型API预测
**返回** - ### 1、预测代码示例
* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。 - ```python
import paddlehub as hub
import cv2
model = hub.Module(name="animegan_v2_paprika_54")
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
```
## 预测代码示例 - ### 2、API
```python - ```python
import cv2 def style_transfer(images=None,
import paddlehub as hub paths=None,
output_dir='output',
visualization=False,
min_size=32,
max_size=1024)
```
# 模型加载 - 风格转换API，将输入的图片转换为漫画风格。
# use_gpu：是否使用GPU进行预测
model = hub.Module(name='animegan_v2_paprika_54', use_gpu=False)
# 模型预测 - **参数**
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
# or - images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；<br/>
# result = model.style_transfer(paths=['/PATH/TO/IMAGE']) - paths (list\[str\]): 图片的路径；<br/>
``` - output\_dir (str): 图片的保存路径，默认设为 output；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- min\_size (int): 输入图片的短边最小尺寸，默认设为 32；<br/>
- max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
## 服务部署 **NOTE:** paths和images两个参数选择其一进行提供数据
PaddleHub Serving可以部署一个在线图像风格转换服务。 - **返回**
- res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
## 第一步：启动PaddleHub Serving
运行启动命令： ## 四、服务部署
```shell
$ hub serving start -m animegan_v2_paprika_54
```
这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。 - PaddleHub Serving可以部署一个在线图像风格转换服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - ### 第一步：启动PaddleHub Serving
## 第二步：发送预测请求 - 运行启动命令：
- ```shell
$ hub serving start -m animegan_v2_paprika_54
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
```python - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
import requests
import json
import cv2
import base64
- ### 第二步：发送预测请求
def cv2_to_base64(image): - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- ```python
import requests
import json
import cv2
import base64
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/animegan_v2_paprika_54"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果 def cv2_to_base64(image):
print(r.json()["results"]) 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/animegan_v2_paprika_54"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
## 模型相关信息 # 打印预测结果
print(r.json()["results"])
```
### 模型代码
https://github.com/TachibanaYoshino/AnimeGANv2 ## 五、更新历史
### 依赖 * 1.0.0
paddlepaddle >= 1.8.0 初始发布
paddlehub >= 1.8.0 * 1.0.1
适配paddlehub2.0
* 1.0.2
删除batch_size选项
modules/image/Image_gan/style_transfer/animegan_v2_paprika_97/README.md
浏览文件 @ fd4fb4db
## 模型概述 # animegan_v2_paprika_97
AnimeGAN V2 图像风格转换模型
模型可将输入的图像转换成Paprika风格 |模型名称|animegan_v2_paprika_97|
| :--- | :---: |
|类别|图像 - 图像生成|
|网络|AnimeGAN|
|数据集|Paprika|
|是否支持Fine-tuning|否|
|模型大小|9.7MB|
|最新更新日期|2021-07-30|
|数据指标|-|
模型权重转换自AnimeGAN V2官方开源项目
模型所使用的权重为Paprika-97.ckpt ## 一、模型基本信息
模型详情请参考[AnimeGAN V2 开源项目](https://github.com/TachibanaYoshino/AnimeGANv2) - ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/35907364/136652269-48b8c902-3a2b-46b7-a9f2-d500097bbb0e.jpg" width = "450" height = "300" hspace='10'/>
<br />
输入图像
<br />
<img src="https://user-images.githubusercontent.com/35907364/136652280-7e9ebfd2-8a45-4b5b-b3ac-f107770525c4.jpg" width = "450" height = "300" hspace='10'/>
<br />
输出图像
<br />
</p>
## 模型安装
```shell
$hub install animegan_v2_paprika_97
```
- ### 模型介绍
## API 说明 - AnimeGAN V2 图像风格转换模型, 模型可将输入的图像转换成红辣椒动漫风格，模型权重转换自[AnimeGAN V2官方开源项目](https://github.com/TachibanaYoshino/AnimeGAN)。
```python
def style_transfer(
self,
images=None,
paths=None,
output_dir='output',
visualization=False,
min_size=32,
max_size=1024
)
```
风格转换API，将输入的图片转换为漫画风格。 ## 二、安装
转换效果图如下： - ### 1、环境依赖
![输入图像](https://ai-studio-static-online.cdn.bcebos.com/bd002c4bb6a7427daf26988770bb18648b7d8d2bfd6746bfb9a429db4867727f) - paddlepaddle >= 1.8.0
![输出图像](https://ai-studio-static-online.cdn.bcebos.com/3b962a18a22e43028cc5530db1c5adb1a42e6aae4bb74b8598ee30ed52b59c8b)
- paddlehub >= 1.8.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**参数** - ### 2、安装
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None； - ```shell
* paths (list\[str\]): 图片的路径，默认为 None； $ hub install animegan_v2_paprika_97
* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False； ```
* output\_dir (str): 图片的保存路径，默认设为 output； - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
* min\_size (int): 输入图片的短边最小尺寸，默认设为 32； | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
* max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
## 三、模型API预测
**返回** - ### 1、预测代码示例
* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。 - ```python
import paddlehub as hub
import cv2
model = hub.Module(name="animegan_v2_paprika_97")
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
```
## 预测代码示例 - ### 2、API
```python - ```python
import cv2 def style_transfer(images=None,
import paddlehub as hub paths=None,
output_dir='output',
visualization=False,
min_size=32,
max_size=1024)
```
# 模型加载 - 风格转换API，将输入的图片转换为漫画风格。
# use_gpu：是否使用GPU进行预测
model = hub.Module(name='animegan_v2_paprika_97', use_gpu=False)
# 模型预测 - **参数**
result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
# or - images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；<br/>
# result = model.style_transfer(paths=['/PATH/TO/IMAGE']) - paths (list\[str\]): 图片的路径；<br/>
``` - output\_dir (str): 图片的保存路径，默认设为 output；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- min\_size (int): 输入图片的短边最小尺寸，默认设为 32；<br/>
- max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
## 服务部署 **NOTE:** paths和images两个参数选择其一进行提供数据
PaddleHub Serving可以部署一个在线图像风格转换服务。 - **返回**
- res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
## 第一步：启动PaddleHub Serving
运行启动命令： ## 四、服务部署
```shell
$ hub serving start -m animegan_v2_paprika_97
```
这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。 - PaddleHub Serving可以部署一个在线图像风格转换服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - ### 第一步：启动PaddleHub Serving
## 第二步：发送预测请求 - 运行启动命令：
- ```shell
$ hub serving start -m animegan_v2_paprika_97
```
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
```python - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
import requests
import json
import cv2
import base64
- ### 第二步：发送预测请求
def cv2_to_base64(image): - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- ```python
import requests
import json
import cv2
import base64
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/animegan_v2_paprika_97"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果 def cv2_to_base64(image):
print(r.json()["results"]) 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/animegan_v2_paprika_97"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
## 模型相关信息 # 打印预测结果
print(r.json()["results"])
```
### 模型代码
https://github.com/TachibanaYoshino/AnimeGANv2 ## 五、更新历史
### 依赖 * 1.0.0
paddlepaddle >= 1.8.0 初始发布
paddlehub >= 1.8.0 * 1.0.1
适配paddlehub2.0
* 1.0.2
删除batch_size选项
modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP/README.md 0 → 100644
浏览文件 @ fd4fb4db
# Pneumonia_CT_LKM_PP
|模型名称|Pneumonia_CT_LKM_PP|
| :--- | :---: |
|类别|图像-图像分割|
|网络|-|
|数据集|-|
|是否支持Fine-tuning|否|
|模型大小|35M|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 模型介绍
- 肺炎CT影像分析模型（Pneumonia-CT-LKM-PP）可以高效地完成对患者CT影像的病灶检测识别、病灶轮廓勾画，通过一定的后处理代码，可以分析输出肺部病灶的数量、体积、病灶占比等全套定量指标。值得强调的是，该系统采用的深度学习算法模型充分训练了所收集到的高分辨率和低分辨率的CT影像数据，能极好地适应不同等级CT影像设备采集的检查数据，有望为医疗资源受限和医疗水平偏低的基层医院提供有效的肺炎辅助诊断工具。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install Pneumonia_CT_LKM_PP==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
import paddlehub as hub
pneumonia = hub.Module(name="Pneumonia_CT_LKM_PP")
input_only_lesion_np_path = "/PATH/TO/ONLY_LESION_NP"
input_both_lesion_np_path = "/PATH/TO/LESION_NP"
input_both_lung_np_path = "/PATH/TO/LUNG_NP"
# set input dict
input_dict = {"image_np_path": [
[input_only_lesion_np_path],
[input_both_lesion_np_path, input_both_lung_np_path],
]}
# execute predict and print the result
results = pneumonia.segmentation(data=input_dict)
for result in results:
print(result)
```
- ### 2、API
```python
def segmentation(data)
```
- 预测API，用于肺炎CT影像分析。
- **参数**
* data (dict): key，str类型，"image_np_path"；value，list类型，每个元素为list类型，[用于病灶分析的影像numpy数组(文件后缀名.npy)路径, 用于肺部分割的影像numpy数组路径]，如果仅进行病灶分析不进行肺部分割，可以省略用于肺部分割的影像numpy数组路径
- **返回**
* result (list\[dict\]): 每个元素为对应输入的预测结果。每个预测结果为dict类型：预测结果有以下字段：
* input_lesion_np_path: 存放用于病灶分析的numpy数组路径；
* output_lesion_np: 存放病灶分析结果，numpy数组；
* input_lesion_np_path：存放用于肺部分割的numpy数组路径（仅当对应输入包含肺部影像numpy时存在该字段）
* output_lung_np：存放肺部分割结果，numpy数组（仅当对应输入包含肺部影像numpy时存在该字段）
## 四、更新历史
* 1.0.0
初始发布
modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP_lung/README.md 0 → 100644
浏览文件 @ fd4fb4db
# Pneumonia_CT_LKM_PP_lung
|模型名称|Pneumonia_CT_LKM_PP_lung|
| :--- | :---: |
|类别|图像-图像分割|
|网络|-|
|数据集|-|
|是否支持Fine-tuning|否|
|模型大小|35M|
|指标|-|
|最新更新日期|2021-02-26|
## 一、模型基本信息
- ### 模型介绍
- 肺炎CT影像分析模型（Pneumonia-CT-LKM-PP）可以高效地完成对患者CT影像的病灶检测识别、病灶轮廓勾画，通过一定的后处理代码，可以分析输出肺部病灶的数量、体积、病灶占比等全套定量指标。值得强调的是，该系统采用的深度学习算法模型充分训练了所收集到的高分辨率和低分辨率的CT影像数据，能极好地适应不同等级CT影像设备采集的检查数据，有望为医疗资源受限和医疗水平偏低的基层医院提供有效的肺炎辅助诊断工具。(此module为Pneumonia_CT_LKM_PP的子module。)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、安装
- ```shell
$ hub install Pneumonia_CT_LKM_PP_lung==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
import paddlehub as hub
pneumonia = hub.Module(name="Pneumonia_CT_LKM_PP_lung")
input_only_lesion_np_path = "/PATH/TO/ONLY_LESION_NP"
input_both_lesion_np_path = "/PATH/TO/LESION_NP"
input_both_lung_np_path = "/PATH/TO/LUNG_NP"
# set input dict
input_dict = {"image_np_path": [
[input_only_lesion_np_path],
[input_both_lesion_np_path, input_both_lung_np_path],
]}
# execute predict and print the result
results = pneumonia.segmentation(data=input_dict)
for result in results:
print(result)
```
- ### 2、API
```python
def segmentation(data)
```
- 预测API，用于肺炎CT影像分析。
- **参数**
* data (dict): key，str类型，"image_np_path"；value，list类型，每个元素为list类型，[用于病灶分析的影像numpy数组(文件后缀名.npy)路径, 用于肺部分割的影像numpy数组路径]，如果仅进行病灶分析不进行肺部分割，可以省略用于肺部分割的影像numpy数组路径
- **返回**
* result (list\[dict\]): 每个元素为对应输入的预测结果。每个预测结果为dict类型：预测结果有以下字段：
* input_lesion_np_path: 存放用于病灶分析的numpy数组路径；
* output_lesion_np: 存放病灶分析结果，numpy数组；
* input_lesion_np_path：存放用于肺部分割的numpy数组路径（仅当对应输入包含肺部影像numpy时存在该字段）
* output_lung_np：存放肺部分割结果，numpy数组（仅当对应输入包含肺部影像numpy时存在该字段）
## 四、更新历史
* 1.0.0
初始发布
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或