提交 336893a5 编写于 作者: H haoyuying

add readme_en for 100 models

上级 e1989616
...@@ -77,7 +77,7 @@ ...@@ -77,7 +77,7 @@
T.RGB2LAB()], to_rgb=True) T.RGB2LAB()], to_rgb=True)
``` ```
- `transforms` The data enhancement module defines lots of data preprocessing methods. Users can replace the data preprocessing methods according to their needs. - `transforms` The data enhancement module defines lots of data preprocessing methods. Users can replace the data preprocessing methods according to their needs.
- Step2: Download the dataset - Step2: Download the dataset
- ```python - ```python
......
...@@ -50,13 +50,14 @@ $ hub run msgnet --input_path "/PATH/TO/ORIGIN/IMAGE" --style_path "/PATH/TO/STY ...@@ -50,13 +50,14 @@ $ hub run msgnet --input_path "/PATH/TO/ORIGIN/IMAGE" --style_path "/PATH/TO/STY
- ### 2.预测代码示例 - ### 2.预测代码示例
```python ```python
import paddle import paddle
import paddlehub as hub import paddlehub as hub
if __name__ == '__main__': if __name__ == '__main__':
model = hub.Module(name='msgnet') model = hub.Module(name='msgnet')
result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path ='style_tranfer') result = model.predict(origin=["/PATH/TO/ORIGIN/IMAGE"], style="/PATH/TO/STYLE/IMAGE", visualization=True, save_path ="/PATH/TO/SAVE/IMAGE")
``` ```
...@@ -86,7 +87,7 @@ if __name__ == '__main__': ...@@ -86,7 +87,7 @@ if __name__ == '__main__':
- `transforms`: 数据预处理方式。 - `transforms`: 数据预处理方式。
- `mode`: 选择数据模式,可选项有 `train`, `test`, 默认为`train`。 - `mode`: 选择数据模式,可选项有 `train`, `test`, 默认为`train`。
- 数据集的准备代码可以参考 [minicoco.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.MiniCOCO()`会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 - 数据集的准备代码可以参考 [minicoco.py](../../paddlehub/datasets/minicoco.py)。`hub.datasets.MiniCOCO()`会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
- Step3: 加载预训练模型 - Step3: 加载预训练模型
...@@ -117,7 +118,7 @@ if __name__ == '__main__': ...@@ -117,7 +118,7 @@ if __name__ == '__main__':
if __name__ == '__main__': if __name__ == '__main__':
model = hub.Module(name='msgnet', load_checkpoint="/PATH/TO/CHECKPOINT") 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') result = model.predict(origin=["/PATH/TO/ORIGIN/IMAGE"], style="/PATH/TO/STYLE/IMAGE", visualization=True, save_path ="/PATH/TO/SAVE/IMAGE")
``` ```
- 参数配置正确后,请执行脚本`python predict.py`, 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。 - 参数配置正确后,请执行脚本`python predict.py`, 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
......
# msgnet
|Module Name|msgnet|
| :--- | :---: |
|Category|image editing|
|Network|msgnet|
|Dataset|COCO2014|
|Fine-tuning supported or not|Yes|
|Module Size|68MB|
|Data indicators|-|
|Latest update date|2021-07-29|
## I. Basic Information
- ### Application Effect Display
- Sample results:
<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>
- ### Module Introduction
- Msgnet is a style transfer model. We will show how to use PaddleHub to finetune the pre-trained model and complete the prediction.
- For more information, please refer to [msgnet](https://github.com/zhanghang1989/PyTorch-Multi-Style-Transfer)
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install msgnet
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Command line Prediction
```
$ hub run msgnet --input_path "/PATH/TO/ORIGIN/IMAGE" --style_path "/PATH/TO/STYLE/IMAGE"
```
- ### 2、Prediction Code Example
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='msgnet')
result = model.predict(origin=["/PATH/TO/ORIGIN/IMAGE"], style="/PATH/TO/STYLE/IMAGE", visualization=True, save_path ="/PATH/TO/SAVE/IMAGE")
```
- ### 3.Fine-tune and Encapsulation
- After completing the installation of PaddlePaddle and PaddleHub, you can start using the msgnet model to fine-tune datasets such as [MiniCOCO](../../docs/reference/datasets.md#class-hubdatasetsMiniCOCO) by executing `python train.py`.
- Steps:
- Step1: Define the data preprocessing method
- ```python
import paddlehub.vision.transforms as T
transform = T.Compose([T.Resize((256, 256), interpolation='LINEAR')])
```
- `transforms` The data enhancement module defines lots of data preprocessing methods. Users can replace the data preprocessing methods according to their needs.
- Step2: Download the dataset
- ```python
from paddlehub.datasets.minicoco import MiniCOCO
styledata = MiniCOCO(transform=transform, mode='train')
```
* `transforms`: data preprocessing methods.
* `mode`: Select the data mode, the options are `train`, `test`, `val`. Default is `train`.
- Dataset preparation can be referred to [minicoco.py](../../paddlehub/datasets/minicoco.py). `hub.datasets.MiniCOCO()` will be automatically downloaded from the network and decompressed to the `$HOME/.paddlehub/dataset` directory under the user directory.
- Step3: Load the pre-trained model
- ```python
model = hub.Module(name='msgnet', load_checkpoint=None)
```
* `name`: model name.
* `load_checkpoint`: Whether to load the self-trained model, if it is None, load the provided parameters.
- Step4: Optimization strategy
- ```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)
```
- Model prediction
- When Fine-tune is completed, the model with the best performance on the verification set will be saved in the `${CHECKPOINT_DIR}/best_model` directory. We use this model to make predictions. The `predict.py` script is as follows:
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='msgnet', load_checkpoint="/PATH/TO/CHECKPOINT")
result = model.predict(origin=["/PATH/TO/ORIGIN/IMAGE"], style="/PATH/TO/STYLE/IMAGE", visualization=True, save_path ="/PATH/TO/SAVE/IMAGE")
```
- **Args**
* `origin`: Image path or ndarray data with format [H, W, C], BGR;
* `style`: Style image path;
* `visualization`: Whether to save the recognition results as picture files;
* `save_path`: Save path of the result, default is 'style_tranfer'.
## IV. Server Deployment
- PaddleHub Serving can deploy an online service of style transfer.
- ### Step 1: Start PaddleHub Serving
- Run the startup command:
- ```shell
$ hub serving start -m msgnet
```
- The servitization API is now deployed and the default port number is 8866.
- **NOTE:** If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
- ### Step 2: Send a predictive request
- With a configured server, use the following lines of code to send the prediction request and obtain the result:
```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
# Send an HTTP request
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)
```
## V. Release Note
- 1.0.0
First release
# resnet50_vd_animals
|Module Name|resnet50_vd_animals|
| :--- | :---: |
|Category |image classification|
|Network|ResNet50_vd|
|Dataset|Baidu self-built dataset|
|Fine-tuning supported or not|No|
|Module Size|154MB|
|Latest update date|2021-02-26|
|Data indicators|-|
## I. Basic Information
- ### Application Effect Display
- ResNet-vd is a variant of ResNet, which can be used for image classification and feature extraction. This module is trained by Baidu self-built animal data set and supports the classification and recognition of 7,978 animal species.
- For more information, please refer to [ResNet-vd](https://arxiv.org/pdf/1812.01187.pdf)
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install resnet50_vd_animals
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Command line Prediction
- ```shell
$ hub run resnet50_vd_animals --input_path "/PATH/TO/IMAGE"
```
- If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、Prediction Code Example
- ```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'])
```
- ### 3、API
- ```python
def get_expected_image_width()
```
- Returns the preprocessed image width, which is 224.
- ```python
def get_expected_image_height()
```
- Returns the preprocessed image height, which is 224.
- ```python
def get_pretrained_images_mean()
```
- Returns the mean value of the preprocessed image, which is \[0.485, 0.456, 0.406\].
- ```python
def get_pretrained_images_std()
```
- Return the standard deviation of the preprocessed image, which is \[0.229, 0.224, 0.225\].
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- **Parameter**
* images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
* paths (list\[str\]): image path;
* batch\_size (int): batch size;
* use\_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
* top\_k (int): return the top k prediction results.
- **Return**
- res (list\[dict\]): the list of classification results,key is the prediction label, value is the corresponding confidence.
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- Save the model to the specified path.
- **Parameters**
* dirname: Save path.
* model\_filename: model file name,defalt is \_\_model\_\_
* params\_filename: parameter file name,defalt is \_\_params\_\_(Only takes effect when `combined` is True)
* combined: Whether to save the parameters to a unified file.
## IV. Server Deployment
- PaddleHub Serving can deploy an online service of animal classification.
- ### Step 1: Start PaddleHub Serving
- Run the startup command:
- ```shell
$ hub serving start -m resnet50_vd_animals
```
- The servitization API is now deployed and the default port number is 8866.
- **NOTE:** If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
- ### Step 2: Send a predictive request
- With a configured server, use the following lines of code to send the prediction request and obtain the result
```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# Send an HTTP request
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 prediction results
print(r.json()["results"])
```
## V. Release Note
- 1.0.0
First release
...@@ -50,7 +50,7 @@ ...@@ -50,7 +50,7 @@
if __name__ == '__main__': if __name__ == '__main__':
model = hub.Module(name='resnet50_vd_imagenet_ssld') model = hub.Module(name='resnet50_vd_imagenet_ssld')
result = model.predict(['flower.jpg']) result = model.predict(['/PATH/TO/IMAGE'])
``` ```
- ### 3.如何开始Fine-tune - ### 3.如何开始Fine-tune
...@@ -134,7 +134,7 @@ ...@@ -134,7 +134,7 @@
if __name__ == '__main__': if __name__ == '__main__':
model = hub.Module(name='resnet50_vd_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') 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']) result = model.predict(['/PATH/TO/IMAGE'])
``` ```
......
# resnet50_vd_imagenet_ssld
|Module Name|resnet50_vd_imagenet_ssld|
| :--- | :---: |
|Category |image classification|
|Network|ResNet_vd|
|Dataset|ImageNet-2012|
|Fine-tuning supported or notFine-tuning|Yes|
|Module Size|148MB|
|Data indicators|-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Module Introduction
- ResNet-vd is a variant of ResNet, which can be used for image classification and feature extraction.
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install resnet50_vd_imagenet_ssld
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Command line Prediction
```shell
$ hub run resnet50_vd_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2、Prediction Code Example
```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='resnet50_vd_imagenet_ssld')
result = model.predict(['/PATH/TO/IMAGE'])
```
- ### 3.Fine-tune and Encapsulation
- After completing the installation of PaddlePaddle and PaddleHub, you can start using the user_guided_colorization model to fine-tune datasets such as [Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers) by excuting `python train.py`.
- Steps:
- Step1: Define the data preprocessing method
- ```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` The data enhancement module defines lots of data preprocessing methods. Users can replace the data preprocessing methods according to their needs.
- Step2: Download the dataset
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
* `transforms`: data preprocessing methods.
* `mode`: Select the data mode, the options are `train`, `test`, `val`. Default is `train`.
* `hub.datasets.Flowers()` will be automatically downloaded from the network and decompressed to the `$HOME/.paddlehub/dataset` directory under the user directory.
- Step3: Load the pre-trained model
- ```python
model = hub.Module(name="resnet50_vd_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: model name.
* `label_list`: set the output classification category. Default is Imagenet2012 category.
- Step4: Optimization strategy
```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)
```
- Run configuration
- `Trainer` mainly control the training of Fine-tune, including the following controllable parameters:
* `model`: Optimized model;
* `optimizer`: Optimizer selection;
* `use_vdl`: Whether to use vdl to visualize the training process;
* `checkpoint_dir`: The storage address of the model parameters;
* `compare_metrics`: The measurement index of the optimal model;
- `trainer.train` mainly control the specific training process, including the following controllable parameters:
* `train_dataset`: Training dataset;
* `epochs`: Epochs of training process;
* `batch_size`: Batch size;
* `num_workers`: Number of workers.
* `eval_dataset`: Validation dataset;
* `log_interval`:The interval for printing logs;
* `save_interval`: The interval for saving model parameters.
- Model prediction
- When Fine-tune is completed, the model with the best performance on the verification set will be saved in the `${CHECKPOINT_DIR}/best_model` directory. We use this model to make predictions. The `predict.py` script is as follows:
- ```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(['/PATH/TO/IMAGE'])
```
## IV. Server Deployment
- PaddleHub Serving can deploy an online service of classification.
- ### Step 1: Start PaddleHub Serving
- Run the startup command:
- ```shell
$ hub serving start -m resnet50_vd_imagenet_ssld
```
- The servitization API is now deployed and the default port number is 8866.
- **NOTE:** If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
- ### Step 2: Send a predictive request
- With a configured server, use the following lines of code to send the prediction request and obtain the result
```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
# Send an HTTP request
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']
```
## V. Release Note
* 1.0.0
First release
* 1.1.0
Upgrade to dynamic version.
# resnet_v2_50_imagenet
|Module Name|resnet_v2_50_imagenet|
| :--- | :---: |
|Category |image classification|
|Network|ResNet V2|
|Dataset|ImageNet-2012|
|Fine-tuning supported or not|No|
|Module Size|99MB|
|Latest update date|2021-02-26|
|Data indicators|-|
## I. Basic Information
- ### Application Effect Display
- This module utilizes ResNet50 structure and it is trained on ImageNet-2012.
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [How to install PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、Installation
- ```shell
$ hub install resnet_v2_50_imagenet
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Command line Prediction
- ```shell
$ hub run resnet_v2_50_imagenet --input_path "/PATH/TO/IMAGE"
```
- If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、Prediction Code Example
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="resnet_v2_50_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- Prediction API for classification.
- **Parameter**
- data (dict): key is 'image',value is the list of image path.
- **Return**
- result (list[dict]): the list of classification results,key is the prediction label, value is the corresponding confidence.
## IV. Release Note
- 1.0.0
First release
- 1.0.1
Fix encoding problem in python2
- ```shell
$ hub install resnet_v2_50_imagenet==1.0.1
```
# ExtremeC3_Portrait_Segmentation
|Module Name|ExtremeC3_Portrait_Segmentation|
| :--- | :---: |
|Category|image segmentation|
|Network |ExtremeC3|
|Dataset|EG1800, Baidu fashion dataset|
|Fine-tuning supported or not|No|
|Module Size|0.038MB|
|Data indicators|-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Application Effect Display
- Sample results:
<p align="center">
<img src="https://ai-studio-static-online.cdn.bcebos.com/1261398a98e24184852bdaff5a4e1dbd7739430f59fb47e8b84e3a2cfb976107" hspace='10'/> <br />
</p>
- ### Module Introduction
* ExtremeC3_Portrait_Segmentation is a light weigth module based on ExtremeC3 to achieve portrait segmentation.
* For more information, please refer to: [ExtremeC3_Portrait_Segmentation](https://github.com/clovaai/ext_portrait_segmentation).
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install ExtremeC3_Portrait_Segmentation
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Prediction Code Example
```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):
```
- Prediction API, used for portrait segmentation.
- **Parameter**
* images (list[np.ndarray]) : image data, ndarray.shape is in the format [H, W, C], BGR;
* paths (list[str]) :image path
* batch_size (int) : batch size
* output_dir (str) : save path of images, 'output' by default.
* visualization (bool) : whether to save the segmentation results as picture files.
- **Return**
* results (list[dict{"mask":np.ndarray,"result":np.ndarray}]): list of recognition results.
## IV. Release Note
- 1.0.0
First release
# Pneumonia_CT_LKM_PP
|Module Name|Pneumonia_CT_LKM_PP|
| :--- | :---: |
|Category|image segmentation|
|Network |-|
|Dataset|-|
|Fine-tuning supported or not|No|
|Module Size|35M|
|Data indicators|-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Module Introduction
- Pneumonia CT analysis model (Pneumonia-CT-LKM-PP) can efficiently complete the detection of lesions and outline the patient's CT images. Through post-processing codes, the number, volume, and lesions of lung lesions can be analyzed. This model has been fully trained by high-resolution and low-resolution CT image data, which can adapt to the examination data collected by different levels of CT imaging equipment.
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install Pneumonia_CT_LKM_PP==1.0.0
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Prediction Code Example
```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)
```
- Prediction API, used for CT analysis of pneumonia.
- **Parameter**
* data (dict): key is "image_np_path", value is the list of results which contains lesion and lung segmentation masks.
- **Return**
* result (list\[dict\]): the list of recognition results, where each element is dict and each field is:
* input_lesion_np_path: input path of lesion;
* output_lesion_np: segmentation result path of lesion;
* input_lung_np_path: input path of lung;
* output_lung_np:segmentation result path of lung.
## IV. Release Note
* 1.0.0
First release
# Pneumonia_CT_LKM_PP_lung
|Module Name|Pneumonia_CT_LKM_PP_lung|
| :--- | :---: |
|Category|image segmentation|
|Network |-|
|Dataset|-|
|Fine-tuning supported or not|No|
|Module Size|35M|
|Data indicators|-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Module Introduction
- Pneumonia CT analysis model (Pneumonia-CT-LKM-PP) can efficiently complete the detection of lesions and outline the patient's CT images. Through post-processing codes, the number, volume, and lesions of lung lesions can be analyzed. This model has been fully trained by high-resolution and low-resolution CT image data, which can adapt to the examination data collected by different levels of CT imaging equipment. (This module is a submodule of Pneumonia_CT_LKM_PP.)
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install Pneumonia_CT_LKM_PP_lung==1.0.0
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Prediction Code Example
```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)
```
- Prediction API, used for CT analysis of pneumonia.
- **Parameter**
* data (dict): key is "image_np_path", value is the list of results which contains lesion and lung segmentation masks.
- **Return**
* result (list\[dict\]): the list of recognition results, where each element is dict and each field is:
* input_lesion_np_path: input path of lesion;
* output_lesion_np: segmentation result path of lesion;
* input_lung_np_path: input path of lung;
* output_lung_np:segmentation result path of lung.
## IV. Release Note
* 1.0.0
First release
# U2Net
|Module Name |U2Net|
| :--- | :---: |
|Category |image segmentation|
|Network |U^2Net|
|Dataset|-|
|Fine-tuning supported or not|No|
|Module Size |254MB|
|Data indicators|-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Application Effect Display
- Sample results:
<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>
- ### Module Introduction
- Network architecture:
<p align="center">
<img src="https://ai-studio-static-online.cdn.bcebos.com/999d37b4ffdd49dc9e3315b7cec7b2c6918fdd57c8594ced9dded758a497913d" hspace='10'/> <br />
</p>
- For more information, please refer to: [U2Net](https://github.com/xuebinqin/U-2-Net)
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install U2Net
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Prediction Code Example
```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):
```
- Prediction API, obtaining segmentation result.
- **Parameter**
* images (list[np.ndarray]) : image data, ndarray.shape is in the format [H, W, C], BGR;
* paths (list[str]) : image path;
* batch_size (int) : batch size;
* input_size (int) : input image size, default is 320;
* output_dir (str) : save path of images, 'output' by default;
* visualization (bool) : whether to save the results as picture files.
- **Return**
* results (list[np.ndarray]): The list of segmentation results.
## IV. Release Note
- 1.0.0
First release
# U2Netp
|Module Name |U2Netp|
| :--- | :---: |
|Category |image segmentation|
|Network |U^2Net|
|Dataset|-|
|Fine-tuning supported or not|No|
|Module Size |6.7MB|
|Data indicators|-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Application Effect Display
- Sample results:
<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>
- ### Module Introduction
- Network architecture:
<p align="center">
<img src="https://ai-studio-static-online.cdn.bcebos.com/999d37b4ffdd49dc9e3315b7cec7b2c6918fdd57c8594ced9dded758a497913d" hspace='10'/> <br />
</p>
- For more information, please refer to: [U2Net](https://github.com/xuebinqin/U-2-Net)
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install U2Netp
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Prediction Code Example
```python
import cv2
import paddlehub as hub
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):
```
- Prediction API, obtaining segmentation result.
- **Parameter**
* images (list[np.ndarray]) : image data, ndarray.shape is in the format [H, W, C], BGR;
* paths (list[str]) : image path;
* batch_size (int) : batch size;
* input_size (int) : input image size, default is 320;
* output_dir (str) : save path of images, 'output' by default;
* visualization (bool) : whether to save the results as picture files.
- **Return**
* results (list[np.ndarray]): the list of segmentation results.
## IV. Release Note
- 1.0.0
First release
...@@ -57,7 +57,7 @@ ...@@ -57,7 +57,7 @@
- ### 1、命令行预测 - ### 1、命令行预测
```shell ```shell
$ hub install ace2p==1.1.0 $ hub run ace2p --input_path "/PATH/TO/IMAGE"
``` ```
- ### 2、代码示例 - ### 2、代码示例
......
# ace2p
|Module Name|ace2p|
| :--- | :---: |
|Category|image segmentation|
|Network|ACE2P|
|Dataset|LIP|
|Fine-tuning supported or not|No|
|Module Size|259MB|
|Data indicators|-|
|Latest update date |2021-02-26|
## I. Basic Information
- ### Application Effect Display
- Network architecture:
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_network.jpg" hspace='10'/> <br />
</p>
- Color palette
<p align="left">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/ace2p_palette.jpg" hspace='10'/> <br />
</p>
- Sample results:
<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>
- ### Module Introduction
- Human Parsing is a fine-grained semantic segmentation task that aims to identify the components (for example, body parts and clothing) of a human image at the pixel level. The PaddleHub Module uses ResNet101 as the backbone network, and accepts input image sizes of 473x473x3.
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install ace2p
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Command line Prediction
```shell
$ hub run ace2p --input_path "/PATH/TO/IMAGE"
```
- ### 2、Prediction Code Example
```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):
```
- Prediction API, used for human parsing.
- **Parameter**
* images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
* paths (list\[str\]): image path;
* batch\_size (int): batch size;
* use\_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
* output\_dir (str): save path of output, default is 'ace2p_output';
* visualization (bool): Whether to save the recognition results as picture files.
- **Return**
* res (list\[dict\]): The list of recognition results, where each element is dict and each field is:
* save\_path (str, optional): Save path of the result;
* data (numpy.ndarray): The result of portrait segmentation.
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- Save the model to the specified path.
- **Parameters**
* dirname: Save path.
* model\_filename: model file name,defalt is \_\_model\_\_
* params\_filename: parameter file name,defalt is \_\_params\_\_(Only takes effect when `combined` is True)
* combined: Whether to save the parameters to a unified file.
## IV. Server Deployment
- PaddleHub Serving can deploy an online service of human parsing
- ### Step 1: Start PaddleHub Serving
- Run the startup command:
```shell
$ hub serving start -m ace2p
```
- The servitization API is now deployed and the default port number is 8866.
- **NOTE:** If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
- ### Step 2: Send a predictive request
- With a configured server, use the following lines of code to send the prediction request and obtain the result
```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
# Send an HTTP request
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 prediction results
print(base64_to_cv2(r.json()["results"][0]['data']))
```
## 五、更新历史
- 1.0.0
First release
* 1.1.0
Adapt to paddlehub2.0
# deeplabv3p_xception65_humanseg
|Module Name |deeplabv3p_xception65_humanseg|
| :--- | :---: |
|Category|image segmentation|
|Network|deeplabv3p|
|Dataset|Baidu self-built dataset|
|Fine-tuning supported or not|No|
|Module Size|162MB|
|Data indicators |-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Application Effect Display
- Sample results:
<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>
- ### Module Introduction
- DeepLabv3+ model is trained by Baidu self-built dataset, which can be used for portrait segmentation.
<p align="center">
<img src="https://paddlehub.bj.bcebos.com/paddlehub-img/deeplabv3plus.png" hspace='10'/> <br />
</p>
- For more information, please refer to: [deeplabv3p](https://github.com/PaddlePaddle/PaddleSeg)
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
- ```shell
$ hub install deeplabv3p_xception65_humanseg
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Command line Prediction
```shell
hub run deeplabv3p_xception65_humanseg --input_path "/PATH/TO/IMAGE"
```
- ### 2、Prediction Code Example
```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')
```
- Prediction API, generating segmentation result.
- **Parameter**
* images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
* paths (list\[str\]): image path;
* batch\_size (int): batch size;
* use\_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
* visualization (bool): Whether to save the recognition results as picture files;
* output\_dir (str): save path of images.
- **Return**
* res (list\[dict\]): The list of recognition results, where each element is dict and each field is:
* save\_path (str, optional): Save path of the result;
* data (numpy.ndarray): The result of portrait segmentation.
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- Save the model to the specified path.
- **Parameters**
* dirname: Save path.
* model\_filename: model file name,defalt is \_\_model\_\_
* params\_filename: parameter file name,defalt is \_\_params\_\_(Only takes effect when `combined` is True)
* combined: Whether to save the parameters to a unified file.
## IV. Server Deployment
- PaddleHub Serving can deploy an online service of for human segmentation.
- ### Step 1: Start PaddleHub Serving
- Run the startup command:
- ```shell
$ hub serving start -m deeplabv3p_xception65_humanseg
```
- **NOTE:** If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
- ### Step 2: Send a predictive request
- With a configured server, use the following lines of code to send the prediction request and obtain the result
```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
# Send an HTTP request
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)
```
## V. Release Note
- 1.0.0
First release
* 1.1.0
Improve prediction performance
* 1.1.1
Fix the bug of image value out of range
* 1.1.2
Fix memory leakage problem of on cudnn 8.0.4
...@@ -250,4 +250,4 @@ ...@@ -250,4 +250,4 @@
Added video stream portrait segmentation interface Added video stream portrait segmentation interface
* 1.1.1 * 1.1.1
Fix the video memory leakage problem of on cudnn 8.0.4 Fix memory leakage problem of on cudnn 8.0.4
...@@ -248,6 +248,7 @@ ...@@ -248,6 +248,7 @@
Added video portrait split interface Added video portrait split interface
Added video stream portrait segmentation interface Added video stream portrait segmentation interface
* 1.1.1 * 1.1.1
Fix the video memory leakage problem of on cudnn 8.0.4 Fix memory leakage problem of on cudnn 8.0.4
...@@ -2,9 +2,9 @@ ...@@ -2,9 +2,9 @@
|模型名称|SkyAR| |模型名称|SkyAR|
| :--- | :---: | | :--- | :---: |
|类别|图像-图像分割| |类别|视频-视频编辑|
|网络|UNet| |网络|UNet|
|数据集|UNet| |数据集|-|
|是否支持Fine-tuning|否| |是否支持Fine-tuning|否|
|模型大小|206MB| |模型大小|206MB|
|指标|-| |指标|-|
......
# SkyAR
|Module Name|SkyAR|
| :--- | :---: |
|Category|video editing|
|Network|UNet|
|Dataset|-|
|Fine-tuning supported or not|No|
|Module Size|206MB|
|Data indicators|-|
|Latest update date|2021-02-26|
## I. Basic Information
- ### Application Effect Display
- Sample results:
* Input video:
![Input video](https://img-blog.csdnimg.cn/20210126142046572.gif)
* Jupiter:
![Jupiter](https://img-blog.csdnimg.cn/20210125211435619.gif)
* Rainy day:
![Rainy day](https://img-blog.csdnimg.cn/2021012521152492.gif)
* Galaxy:
![Galaxy](https://img-blog.csdnimg.cn/20210125211523491.gif)
* Ninth area spacecraft:
![Ninth area spacecraft](https://img-blog.csdnimg.cn/20210125211520955.gif)
* Input video:
![Input video](https://img-blog.csdnimg.cn/20210126142038716.gif)
* Floating castle:
![Floating castle](https://img-blog.csdnimg.cn/20210125211514997.gif)
* Thunder and lightning:
![Thunder and lightning](https://img-blog.csdnimg.cn/20210125211433591.gif)
* Super moon:
![Super moon](https://img-blog.csdnimg.cn/20210125211417524.gif)
- ### Module Introduction
- SkyAR is based on [Castle in the Sky: Dynamic Sky Replacement and Harmonization in Videos](https://arxiv.org/abs/2010.11800). It mainly consists of three parts: sky matting network, motion estimation and image fusion.
- For more information, please refer to:[SkyAR](https://github.com/jiupinjia/SkyAR)
## II. Installation
- ### 1、Environmental Dependence
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0
- ### 2、Installation
```shell
$hub install SkyAR
```
- In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [Linux_Quickstart](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## III. Module API Prediction
- ### 1、Prediction Code Example
```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
)
```
- **Parameter**
* video_path(str):input video path.
* save_path(str):save videp path.
* config(str): SkyBox configuration, all preset configurations are as follows, if you use a custom SkyBox, please set it to None:
```
[
'cloudy', 'district9ship', 'floatingcastle', 'galaxy', 'jupiter',
'rainy', 'sunny', 'sunset', 'supermoon', 'thunderstorm'
]
```
* skybox_img(str):custom SkyBox image path
* skybox_video(str):custom SkyBox video path
* is_video_sky(bool):customize whether SkyBox is a video
* rain_cap_path(str):custom video path with rain
* is_rainy(bool): whether the sky is raining
* halo_effect(bool):whether to open halo effect
* auto_light_matching(bool):whether to enable automatic brightness matching
* relighting_factor(float): relighting factor
* recoloring_factor(float): recoloring factor
* skybox_center_crop(float):skyBox center crop factor
* preview_frames_num(int):set the number of preview frames
* is_show(bool):whether to preview graphically
## IV. Release Note
- 1.0.0
First release
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册