Merge from release.

modules/audio/keyword_spotting/kwmlp_speech_commands/README.md

+# kwmlp_speech_commands
+
+|模型名称|kwmlp_speech_commands|
+| :--- | :---: |
+|类别|语音-语言识别|
+|网络|Keyword-MLP|
+|数据集|Google Speech Commands V2|
+|是否支持Fine-tuning|否|
+|模型大小|1.6MB|
+|最新更新日期|2022-01-04|
+|数据指标|ACC 97.56%|
+
+## 一、模型基本信息
+
+### 模型介绍
+
+kwmlp_speech_commands采用了 [Keyword-MLP](https://arxiv.org/pdf/2110.07749v1.pdf) 的轻量级模型结构，并在 [Google Speech Commands V2](https://arxiv.org/abs/1804.03209) 数据集上进行了预训练，在其测试集的测试结果为 ACC 97.56%。
+
+<p align="center">
+<img src="https://d3i71xaburhd42.cloudfront.net/fa690a97f76ba119ca08fb02fa524a546c47f031/2-Figure1-1.png" hspace='10' height="550"/> <br />
+</p>
+
+
+更多详情请参考
+- [Speech Commands: A Dataset for Limited-Vocabulary Speech Recognition](https://arxiv.org/abs/1804.03209)
+- [ATTENTION-FREE KEYWORD SPOTTING](https://arxiv.org/pdf/2110.07749v1.pdf)
+- [Keyword-MLP](https://github.com/AI-Research-BD/Keyword-MLP)
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+  - paddlepaddle >= 2.2.0
+
+  - paddlehub >= 2.2.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+  - ```shell
+    $ hub install kwmlp_speech_commands
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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
+
+    model = hub.Module(
+        name='kwmlp_speech_commands',
+        version='1.0.0')
+
+    # 通过下列链接可下载示例音频
+    # https://paddlehub.bj.bcebos.com/paddlehub_dev/go.wav
+
+    # Keyword spotting
+    score, label = model.keyword_recognize('no.wav')
+    print(score, label)
+    # [0.89498246] no
+    score, label = model.keyword_recognize('go.wav')
+    print(score, label)
+    # [0.8997176] go
+    score, label = model.keyword_recognize('one.wav')
+    print(score, label)
+    # [0.88598305] one
+    ```
+
+- ### 2、API
+  - ```python
+    def keyword_recognize(
+        wav: os.PathLike,
+    )
+    ```
+    - 检测音频中包含的关键词。
+
+    - **参数**
+
+      - `wav`：输入的包含关键词的音频文件，格式为`*.wav`。
+
+    - **返回**
+
+      - 输出结果的得分和对应的关键词标签。
+
+
+## 四、更新历史
+
+* 1.0.0
+
+  初始发布
+
+  ```shell
+  $ hub install kwmlp_speech_commands
+  ```

modules/audio/keyword_spotting/kwmlp_speech_commands/__init__.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

modules/audio/keyword_spotting/kwmlp_speech_commands/feature.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import math
+
+import numpy as np
+import paddle
+import paddleaudio
+
+
+def create_dct(n_mfcc: int, n_mels: int, norm: str = 'ortho'):
+    n = paddle.arange(float(n_mels))
+    k = paddle.arange(float(n_mfcc)).unsqueeze(1)
+    dct = paddle.cos(math.pi / float(n_mels) * (n + 0.5) * k)  # size (n_mfcc, n_mels)
+    if norm is None:
+        dct *= 2.0
+    else:
+        assert norm == "ortho"
+        dct[0] *= 1.0 / math.sqrt(2.0)
+        dct *= math.sqrt(2.0 / float(n_mels))
+    return dct.t()
+
+
+def compute_mfcc(
+        x: paddle.Tensor,
+        sr: int = 16000,
+        n_mels: int = 40,
+        n_fft: int = 480,
+        win_length: int = 480,
+        hop_length: int = 160,
+        f_min: float = 0.0,
+        f_max: float = None,
+        center: bool = False,
+        top_db: float = 80.0,
+        norm: str = 'ortho',
+):
+    fbank = paddleaudio.features.spectrum.MelSpectrogram(
+        sr=sr,
+        n_mels=n_mels,
+        n_fft=n_fft,
+        win_length=win_length,
+        hop_length=hop_length,
+        f_min=0.0,
+        f_max=f_max,
+        center=center)(x)  # waveforms batch ~ (B, T)
+    log_fbank = paddleaudio.features.spectrum.power_to_db(fbank, top_db=top_db)
+    dct_matrix = create_dct(n_mfcc=n_mels, n_mels=n_mels, norm=norm)
+    mfcc = paddle.matmul(log_fbank.transpose((0, 2, 1)), dct_matrix).transpose((0, 2, 1))  # (B, n_mels, L)
+    return mfcc

modules/audio/keyword_spotting/kwmlp_speech_commands/kwmlp.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import paddle
+import paddle.nn as nn
+import paddle.nn.functional as F
+
+
+class Residual(nn.Layer):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+
+    def forward(self, x):
+        return self.fn(x) + x
+
+
+class PreNorm(nn.Layer):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.fn = fn
+        self.norm = nn.LayerNorm(dim)
+
+    def forward(self, x, **kwargs):
+        x = self.norm(x)
+        return self.fn(x, **kwargs)
+
+
+class PostNorm(nn.Layer):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        return self.norm(self.fn(x, **kwargs))
+
+
+class SpatialGatingUnit(nn.Layer):
+    def __init__(self, dim, dim_seq, act=nn.Identity(), init_eps=1e-3):
+        super().__init__()
+        dim_out = dim // 2
+
+        self.norm = nn.LayerNorm(dim_out)
+        self.proj = nn.Conv1D(dim_seq, dim_seq, 1)
+
+        self.act = act
+
+        init_eps /= dim_seq
+
+    def forward(self, x):
+        res, gate = x.split(2, axis=-1)
+        gate = self.norm(gate)
+
+        weight, bias = self.proj.weight, self.proj.bias
+        gate = F.conv1d(gate, weight, bias)
+
+        return self.act(gate) * res
+
+
+class gMLPBlock(nn.Layer):
+    def __init__(self, *, dim, dim_ff, seq_len, act=nn.Identity()):
+        super().__init__()
+        self.proj_in = nn.Sequential(nn.Linear(dim, dim_ff), nn.GELU())
+
+        self.sgu = SpatialGatingUnit(dim_ff, seq_len, act)
+        self.proj_out = nn.Linear(dim_ff // 2, dim)
+
+    def forward(self, x):
+        x = self.proj_in(x)
+        x = self.sgu(x)
+        x = self.proj_out(x)
+        return x
+
+
+class Rearrange(nn.Layer):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        x = x.transpose([0, 1, 3, 2]).squeeze(1)
+        return x
+
+
+class Reduce(nn.Layer):
+    def __init__(self, axis=1):
+        super().__init__()
+        self.axis = axis
+
+    def forward(self, x):
+        x = x.mean(axis=self.axis, keepdim=False)
+        return x
+
+
+class KW_MLP(nn.Layer):
+    """Keyword-MLP."""
+
+    def __init__(self,
+                 input_res=[40, 98],
+                 patch_res=[40, 1],
+                 num_classes=35,
+                 dim=64,
+                 depth=12,
+                 ff_mult=4,
+                 channels=1,
+                 prob_survival=0.9,
+                 pre_norm=False,
+                 **kwargs):
+        super().__init__()
+        image_height, image_width = input_res
+        patch_height, patch_width = patch_res
+        assert (image_height % patch_height) == 0 and (
+            image_width % patch_width) == 0, 'image height and width must be divisible by patch size'
+        num_patches = (image_height // patch_height) * (image_width // patch_width)
+
+        P_Norm = PreNorm if pre_norm else PostNorm
+
+        dim_ff = dim * ff_mult
+
+        self.to_patch_embed = nn.Sequential(Rearrange(), nn.Linear(channels * patch_height * patch_width, dim))
+
+        self.prob_survival = prob_survival
+
+        self.layers = nn.LayerList(
+            [Residual(P_Norm(dim, gMLPBlock(dim=dim, dim_ff=dim_ff, seq_len=num_patches))) for i in range(depth)])
+
+        self.to_logits = nn.Sequential(nn.LayerNorm(dim), Reduce(axis=1), nn.Linear(dim, num_classes))
+
+    def forward(self, x):
+        x = self.to_patch_embed(x)
+        layers = self.layers
+        x = nn.Sequential(*layers)(x)
+        return self.to_logits(x)

modules/audio/keyword_spotting/kwmlp_speech_commands/module.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+
+import numpy as np
+import paddle
+import paddleaudio
+
+from .feature import compute_mfcc
+from .kwmlp import KW_MLP
+from paddlehub.module.module import moduleinfo
+from paddlehub.utils.log import logger
+
+
+@moduleinfo(
+    name="kwmlp_speech_commands",
+    version="1.0.0",
+    summary="",
+    author="paddlepaddle",
+    author_email="",
+    type="audio/language_identification")
+class KWS(paddle.nn.Layer):
+    def __init__(self):
+        super(KWS, self).__init__()
+        ckpt_path = os.path.join(self.directory, 'assets', 'model.pdparams')
+        label_path = os.path.join(self.directory, 'assets', 'label.txt')
+
+        self.label_list = []
+        with open(label_path, 'r') as f:
+            for l in f:
+                self.label_list.append(l.strip())
+
+        self.sr = 16000
+        model_conf = {
+            'input_res': [40, 98],
+            'patch_res': [40, 1],
+            'num_classes': 35,
+            'channels': 1,
+            'dim': 64,
+            'depth': 12,
+            'pre_norm': False,
+            'prob_survival': 0.9,
+        }
+        self.model = KW_MLP(**model_conf)
+        self.model.set_state_dict(paddle.load(ckpt_path))
+        self.model.eval()
+
+    def load_audio(self, wav):
+        wav = os.path.abspath(os.path.expanduser(wav))
+        assert os.path.isfile(wav), 'Please check wav file: {}'.format(wav)
+        waveform, _ = paddleaudio.load(wav, sr=self.sr, mono=True, normal=False)
+        return waveform
+
+    def keyword_recognize(self, wav):
+        waveform = self.load_audio(wav)
+
+        # fix_length to 1s
+        if len(waveform) > self.sr:
+            waveform = waveform[:self.sr]
+        else:
+            waveform = np.pad(waveform, (0, self.sr - len(waveform)))
+
+        logits = self(paddle.to_tensor(waveform)).reshape([-1])
+        probs = paddle.nn.functional.softmax(logits)
+        idx = paddle.argmax(probs)
+        return probs[idx].numpy(), self.label_list[idx]
+
+    def forward(self, x):
+        if len(x.shape) == 1:  # x: waveform tensors with (B, T) shape
+            x = x.unsqueeze(0)
+
+        mfcc = compute_mfcc(x).unsqueeze(1)  # (B, C, n_mels, L)
+        logits = self.model(mfcc).squeeze(1)
+
+        return logits

modules/audio/keyword_spotting/kwmlp_speech_commands/requirements.txt

+paddleaudio==0.1.0

modules/audio/language_identification/ecapa_tdnn_common_language/README.md

+# ecapa_tdnn_common_language
+
+|模型名称|ecapa_tdnn_common_language|
+| :--- | :---: |
+|类别|语音-语言识别|
+|网络|ECAPA-TDNN|
+|数据集|CommonLanguage|
+|是否支持Fine-tuning|否|
+|模型大小|79MB|
+|最新更新日期|2021-12-30|
+|数据指标|ACC 84.9%|
+
+## 一、模型基本信息
+
+### 模型介绍
+
+ecapa_tdnn_common_language采用了[ECAPA-TDNN](https://arxiv.org/abs/2005.07143)的模型结构，并在[CommonLanguage](https://zenodo.org/record/5036977/)数据集上进行了预训练，在其测试集的测试结果为 ACC 84.9%。
+
+<p align="center">
+<img src="https://d3i71xaburhd42.cloudfront.net/9609f4817a7e769f5e3e07084db35e46696e82cd/3-Figure2-1.png" hspace='10' height="550"/> <br />
+</p>
+
+
+更多详情请参考
+- [CommonLanguage](https://zenodo.org/record/5036977#.Yc19b5Mzb0o)
+- [ECAPA-TDNN: Emphasized Channel Attention, Propagation and Aggregation in TDNN Based Speaker Verification](https://arxiv.org/pdf/2005.07143.pdf)
+- [The SpeechBrain Toolkit](https://github.com/speechbrain/speechbrain)
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+  - paddlepaddle >= 2.2.0
+
+  - paddlehub >= 2.2.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+  - ```shell
+    $ hub install ecapa_tdnn_common_language
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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
+
+    model = hub.Module(
+        name='ecapa_tdnn_common_language',
+        version='1.0.0')
+
+    # 通过下列链接可下载示例音频
+    # https://paddlehub.bj.bcebos.com/paddlehub_dev/zh.wav
+    # https://paddlehub.bj.bcebos.com/paddlehub_dev/en.wav
+    # https://paddlehub.bj.bcebos.com/paddlehub_dev/it.wav
+
+    # Language Identification
+    score, label = model.speaker_verify('zh.wav')
+    print(score, label)
+    # array([0.6214552], dtype=float32), 'Chinese_China'
+    score, label = model.speaker_verify('en.wav')
+    print(score, label)
+    # array([0.37193954], dtype=float32), 'English'
+    score, label = model.speaker_verify('it.wav')
+    print(score, label)
+    # array([0.46913534], dtype=float32), 'Italian'
+    ```
+
+- ### 2、API
+  - ```python
+    def language_identify(
+        wav: os.PathLike,
+    )
+    ```
+    - 判断输入人声音频的语言类别。
+
+    - **参数**
+
+      - `wav`：输入的说话人的音频文件，格式为`*.wav`。
+
+    - **返回**
+
+      - 输出结果的得分和对应的语言类别。
+
+
+## 四、更新历史
+
+* 1.0.0
+
+  初始发布
+
+  ```shell
+  $ hub install ecapa_tdnn_common_language
+  ```

modules/audio/language_identification/ecapa_tdnn_common_language/__init__.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

modules/audio/language_identification/ecapa_tdnn_common_language/ecapa_tdnn.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import math
+import os
+
+import paddle
+import paddle.nn as nn
+import paddle.nn.functional as F
+
+
+def length_to_mask(length, max_len=None, dtype=None):
+    assert len(length.shape) == 1
+
+    if max_len is None:
+        max_len = length.max().astype('int').item()  # using arange to generate mask
+    mask = paddle.arange(max_len, dtype=length.dtype).expand((len(length), max_len)) < length.unsqueeze(1)
+
+    if dtype is None:
+        dtype = length.dtype
+
+    mask = paddle.to_tensor(mask, dtype=dtype)
+    return mask
+
+
+class Conv1d(nn.Layer):
+    def __init__(
+            self,
+            in_channels,
+            out_channels,
+            kernel_size,
+            stride=1,
+            padding="same",
+            dilation=1,
+            groups=1,
+            bias=True,
+            padding_mode="reflect",
+    ):
+        super(Conv1d, self).__init__()
+
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.dilation = dilation
+        self.padding = padding
+        self.padding_mode = padding_mode
+
+        self.conv = nn.Conv1D(
+            in_channels,
+            out_channels,
+            self.kernel_size,
+            stride=self.stride,
+            padding=0,
+            dilation=self.dilation,
+            groups=groups,
+            bias_attr=bias,
+        )
+
+    def forward(self, x):
+        if self.padding == "same":
+            x = self._manage_padding(x, self.kernel_size, self.dilation, self.stride)
+        else:
+            raise ValueError("Padding must be 'same'. Got {self.padding}")
+
+        return self.conv(x)
+
+    def _manage_padding(self, x, kernel_size: int, dilation: int, stride: int):
+        L_in = x.shape[-1]  # Detecting input shape
+        padding = self._get_padding_elem(L_in, stride, kernel_size, dilation)  # Time padding
+        x = F.pad(x, padding, mode=self.padding_mode, data_format="NCL")  # Applying padding
+        return x
+
+    def _get_padding_elem(self, L_in: int, stride: int, kernel_size: int, dilation: int):
+        if stride > 1:
+            n_steps = math.ceil(((L_in - kernel_size * dilation) / stride) + 1)
+            L_out = stride * (n_steps - 1) + kernel_size * dilation
+            padding = [kernel_size // 2, kernel_size // 2]
+        else:
+            L_out = (L_in - dilation * (kernel_size - 1) - 1) // stride + 1
+
+            padding = [(L_in - L_out) // 2, (L_in - L_out) // 2]
+
+        return padding
+
+
+class BatchNorm1d(nn.Layer):
+    def __init__(
+            self,
+            input_size,
+            eps=1e-05,
+            momentum=0.9,
+            weight_attr=None,
+            bias_attr=None,
+            data_format='NCL',
+            use_global_stats=None,
+    ):
+        super(BatchNorm1d, self).__init__()
+
+        self.norm = nn.BatchNorm1D(
+            input_size,
+            epsilon=eps,
+            momentum=momentum,
+            weight_attr=weight_attr,
+            bias_attr=bias_attr,
+            data_format=data_format,
+            use_global_stats=use_global_stats,
+        )
+
+    def forward(self, x):
+        x_n = self.norm(x)
+        return x_n
+
+
+class TDNNBlock(nn.Layer):
+    def __init__(
+            self,
+            in_channels,
+            out_channels,
+            kernel_size,
+            dilation,
+            activation=nn.ReLU,
+    ):
+        super(TDNNBlock, self).__init__()
+        self.conv = Conv1d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            dilation=dilation,
+        )
+        self.activation = activation()
+        self.norm = BatchNorm1d(input_size=out_channels)
+
+    def forward(self, x):
+        return self.norm(self.activation(self.conv(x)))
+
+
+class Res2NetBlock(nn.Layer):
+    def __init__(self, in_channels, out_channels, scale=8, dilation=1):
+        super(Res2NetBlock, self).__init__()
+        assert in_channels % scale == 0
+        assert out_channels % scale == 0
+
+        in_channel = in_channels // scale
+        hidden_channel = out_channels // scale
+
+        self.blocks = nn.LayerList(
+            [TDNNBlock(in_channel, hidden_channel, kernel_size=3, dilation=dilation) for i in range(scale - 1)])
+        self.scale = scale
+
+    def forward(self, x):
+        y = []
+        for i, x_i in enumerate(paddle.chunk(x, self.scale, axis=1)):
+            if i == 0:
+                y_i = x_i
+            elif i == 1:
+                y_i = self.blocks[i - 1](x_i)
+            else:
+                y_i = self.blocks[i - 1](x_i + y_i)
+            y.append(y_i)
+        y = paddle.concat(y, axis=1)
+        return y
+
+
+class SEBlock(nn.Layer):
+    def __init__(self, in_channels, se_channels, out_channels):
+        super(SEBlock, self).__init__()
+
+        self.conv1 = Conv1d(in_channels=in_channels, out_channels=se_channels, kernel_size=1)
+        self.relu = paddle.nn.ReLU()
+        self.conv2 = Conv1d(in_channels=se_channels, out_channels=out_channels, kernel_size=1)
+        self.sigmoid = paddle.nn.Sigmoid()
+
+    def forward(self, x, lengths=None):
+        L = x.shape[-1]
+        if lengths is not None:
+            mask = length_to_mask(lengths * L, max_len=L)
+            mask = mask.unsqueeze(1)
+            total = mask.sum(axis=2, keepdim=True)
+            s = (x * mask).sum(axis=2, keepdim=True) / total
+        else:
+            s = x.mean(axis=2, keepdim=True)
+
+        s = self.relu(self.conv1(s))
+        s = self.sigmoid(self.conv2(s))
+
+        return s * x
+
+
+class AttentiveStatisticsPooling(nn.Layer):
+    def __init__(self, channels, attention_channels=128, global_context=True):
+        super().__init__()
+
+        self.eps = 1e-12
+        self.global_context = global_context
+        if global_context:
+            self.tdnn = TDNNBlock(channels * 3, attention_channels, 1, 1)
+        else:
+            self.tdnn = TDNNBlock(channels, attention_channels, 1, 1)
+        self.tanh = nn.Tanh()
+        self.conv = Conv1d(in_channels=attention_channels, out_channels=channels, kernel_size=1)
+
+    def forward(self, x, lengths=None):
+        C, L = x.shape[1], x.shape[2]  # KP: (N, C, L)
+
+        def _compute_statistics(x, m, axis=2, eps=self.eps):
+            mean = (m * x).sum(axis)
+            std = paddle.sqrt((m * (x - mean.unsqueeze(axis)).pow(2)).sum(axis).clip(eps))
+            return mean, std
+
+        if lengths is None:
+            lengths = paddle.ones([x.shape[0]])
+
+        # Make binary mask of shape [N, 1, L]
+        mask = length_to_mask(lengths * L, max_len=L)
+        mask = mask.unsqueeze(1)
+
+        # Expand the temporal context of the pooling layer by allowing the
+        # self-attention to look at global properties of the utterance.
+        if self.global_context:
+            total = mask.sum(axis=2, keepdim=True).astype('float32')
+            mean, std = _compute_statistics(x, mask / total)
+            mean = mean.unsqueeze(2).tile((1, 1, L))
+            std = std.unsqueeze(2).tile((1, 1, L))
+            attn = paddle.concat([x, mean, std], axis=1)
+        else:
+            attn = x
+
+        # Apply layers
+        attn = self.conv(self.tanh(self.tdnn(attn)))
+
+        # Filter out zero-paddings
+        attn = paddle.where(mask.tile((1, C, 1)) == 0, paddle.ones_like(attn) * float("-inf"), attn)
+
+        attn = F.softmax(attn, axis=2)
+        mean, std = _compute_statistics(x, attn)
+
+        # Append mean and std of the batch
+        pooled_stats = paddle.concat((mean, std), axis=1)
+        pooled_stats = pooled_stats.unsqueeze(2)
+
+        return pooled_stats
+
+
+class SERes2NetBlock(nn.Layer):
+    def __init__(
+            self,
+            in_channels,
+            out_channels,
+            res2net_scale=8,
+            se_channels=128,
+            kernel_size=1,
+            dilation=1,
+            activation=nn.ReLU,
+    ):
+        super(SERes2NetBlock, self).__init__()
+        self.out_channels = out_channels
+        self.tdnn1 = TDNNBlock(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            dilation=1,
+            activation=activation,
+        )
+        self.res2net_block = Res2NetBlock(out_channels, out_channels, res2net_scale, dilation)
+        self.tdnn2 = TDNNBlock(
+            out_channels,
+            out_channels,
+            kernel_size=1,
+            dilation=1,
+            activation=activation,
+        )
+        self.se_block = SEBlock(out_channels, se_channels, out_channels)
+
+        self.shortcut = None
+        if in_channels != out_channels:
+            self.shortcut = Conv1d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=1,
+            )
+
+    def forward(self, x, lengths=None):
+        residual = x
+        if self.shortcut:
+            residual = self.shortcut(x)
+
+        x = self.tdnn1(x)
+        x = self.res2net_block(x)
+        x = self.tdnn2(x)
+        x = self.se_block(x, lengths)
+
+        return x + residual
+
+
+class ECAPA_TDNN(nn.Layer):
+    def __init__(
+            self,
+            input_size,
+            lin_neurons=192,
+            activation=nn.ReLU,
+            channels=[512, 512, 512, 512, 1536],
+            kernel_sizes=[5, 3, 3, 3, 1],
+            dilations=[1, 2, 3, 4, 1],
+            attention_channels=128,
+            res2net_scale=8,
+            se_channels=128,
+            global_context=True,
+    ):
+
+        super(ECAPA_TDNN, self).__init__()
+        assert len(channels) == len(kernel_sizes)
+        assert len(channels) == len(dilations)
+        self.channels = channels
+        self.blocks = nn.LayerList()
+        self.emb_size = lin_neurons
+
+        # The initial TDNN layer
+        self.blocks.append(TDNNBlock(
+            input_size,
+            channels[0],
+            kernel_sizes[0],
+            dilations[0],
+            activation,
+        ))
+
+        # SE-Res2Net layers
+        for i in range(1, len(channels) - 1):
+            self.blocks.append(
+                SERes2NetBlock(
+                    channels[i - 1],
+                    channels[i],
+                    res2net_scale=res2net_scale,
+                    se_channels=se_channels,
+                    kernel_size=kernel_sizes[i],
+                    dilation=dilations[i],
+                    activation=activation,
+                ))
+
+        # Multi-layer feature aggregation
+        self.mfa = TDNNBlock(
+            channels[-1],
+            channels[-1],
+            kernel_sizes[-1],
+            dilations[-1],
+            activation,
+        )
+
+        # Attentive Statistical Pooling
+        self.asp = AttentiveStatisticsPooling(
+            channels[-1],
+            attention_channels=attention_channels,
+            global_context=global_context,
+        )
+        self.asp_bn = BatchNorm1d(input_size=channels[-1] * 2)
+
+        # Final linear transformation
+        self.fc = Conv1d(
+            in_channels=channels[-1] * 2,
+            out_channels=self.emb_size,
+            kernel_size=1,
+        )
+
+    def forward(self, x, lengths=None):
+        xl = []
+        for layer in self.blocks:
+            try:
+                x = layer(x, lengths=lengths)
+            except TypeError:
+                x = layer(x)
+            xl.append(x)
+
+        # Multi-layer feature aggregation
+        x = paddle.concat(xl[1:], axis=1)
+        x = self.mfa(x)
+
+        # Attentive Statistical Pooling
+        x = self.asp(x, lengths=lengths)
+        x = self.asp_bn(x)
+
+        # Final linear transformation
+        x = self.fc(x)
+
+        return x
+
+
+class Classifier(nn.Layer):
+    def __init__(self, backbone, num_class, dtype=paddle.float32):
+        super(Classifier, self).__init__()
+        self.backbone = backbone
+        self.params = nn.ParameterList(
+            [paddle.create_parameter(shape=[num_class, self.backbone.emb_size], dtype=dtype)])
+
+    def forward(self, x):
+        emb = self.backbone(x.transpose([0, 2, 1])).transpose([0, 2, 1])
+        logits = F.linear(F.normalize(emb.squeeze(1)), F.normalize(self.params[0]).transpose([1, 0]))
+
+        return logits

modules/audio/language_identification/ecapa_tdnn_common_language/feature.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import paddle
+import paddleaudio
+from paddleaudio.features.spectrum import hz_to_mel
+from paddleaudio.features.spectrum import mel_to_hz
+from paddleaudio.features.spectrum import power_to_db
+from paddleaudio.features.spectrum import Spectrogram
+from paddleaudio.features.window import get_window
+
+
+def compute_fbank_matrix(sample_rate: int = 16000,
+                         n_fft: int = 400,
+                         n_mels: int = 80,
+                         f_min: int = 0.0,
+                         f_max: int = 8000.0):
+    mel = paddle.linspace(hz_to_mel(f_min, htk=True), hz_to_mel(f_max, htk=True), n_mels + 2, dtype=paddle.float32)
+    hz = mel_to_hz(mel, htk=True)
+
+    band = hz[1:] - hz[:-1]
+    band = band[:-1]
+    f_central = hz[1:-1]
+
+    n_stft = n_fft // 2 + 1
+    all_freqs = paddle.linspace(0, sample_rate // 2, n_stft)
+    all_freqs_mat = all_freqs.tile([f_central.shape[0], 1])
+
+    f_central_mat = f_central.tile([all_freqs_mat.shape[1], 1]).transpose([1, 0])
+    band_mat = band.tile([all_freqs_mat.shape[1], 1]).transpose([1, 0])
+
+    slope = (all_freqs_mat - f_central_mat) / band_mat
+    left_side = slope + 1.0
+    right_side = -slope + 1.0
+
+    fbank_matrix = paddle.maximum(paddle.zeros_like(left_side), paddle.minimum(left_side, right_side))
+
+    return fbank_matrix
+
+
+def compute_log_fbank(
+        x: paddle.Tensor,
+        sample_rate: int = 16000,
+        n_fft: int = 400,
+        hop_length: int = 160,
+        win_length: int = 400,
+        n_mels: int = 80,
+        window: str = 'hamming',
+        center: bool = True,
+        pad_mode: str = 'constant',
+        f_min: float = 0.0,
+        f_max: float = None,
+        top_db: float = 80.0,
+):
+
+    if f_max is None:
+        f_max = sample_rate / 2
+
+    spect = Spectrogram(
+        n_fft=n_fft, hop_length=hop_length, win_length=win_length, window=window, center=center, pad_mode=pad_mode)(x)
+
+    fbank_matrix = compute_fbank_matrix(
+        sample_rate=sample_rate,
+        n_fft=n_fft,
+        n_mels=n_mels,
+        f_min=f_min,
+        f_max=f_max,
+    )
+    fbank = paddle.matmul(fbank_matrix, spect)
+    log_fbank = power_to_db(fbank, top_db=top_db).transpose([0, 2, 1])
+    return log_fbank
+
+
+def compute_stats(x: paddle.Tensor, mean_norm: bool = True, std_norm: bool = False, eps: float = 1e-10):
+    if mean_norm:
+        current_mean = paddle.mean(x, axis=0)
+    else:
+        current_mean = paddle.to_tensor([0.0])
+
+    if std_norm:
+        current_std = paddle.std(x, axis=0)
+    else:
+        current_std = paddle.to_tensor([1.0])
+
+    current_std = paddle.maximum(current_std, eps * paddle.ones_like(current_std))
+
+    return current_mean, current_std
+
+
+def normalize(
+        x: paddle.Tensor,
+        global_mean: paddle.Tensor = None,
+        global_std: paddle.Tensor = None,
+):
+
+    for i in range(x.shape[0]):  # (B, ...)
+        if global_mean is None and global_std is None:
+            mean, std = compute_stats(x[i])
+            x[i] = (x[i] - mean) / std
+        else:
+            x[i] = (x[i] - global_mean) / global_std
+    return x

modules/audio/language_identification/ecapa_tdnn_common_language/module.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import re
+from typing import List
+from typing import Union
+
+import numpy as np
+import paddle
+import paddleaudio
+
+from .ecapa_tdnn import Classifier
+from .ecapa_tdnn import ECAPA_TDNN
+from .feature import compute_log_fbank
+from .feature import normalize
+from paddlehub.module.module import moduleinfo
+from paddlehub.utils.log import logger
+
+
+@moduleinfo(
+    name="ecapa_tdnn_common_language",
+    version="1.0.0",
+    summary="",
+    author="paddlepaddle",
+    author_email="",
+    type="audio/language_identification")
+class LanguageIdentification(paddle.nn.Layer):
+    def __init__(self):
+        super(LanguageIdentification, self).__init__()
+        ckpt_path = os.path.join(self.directory, 'assets', 'model.pdparams')
+        label_path = os.path.join(self.directory, 'assets', 'label.txt')
+
+        self.label_list = []
+        with open(label_path, 'r') as f:
+            for l in f:
+                self.label_list.append(l.strip())
+
+        self.sr = 16000
+        model_conf = {
+            'input_size': 80,
+            'channels': [1024, 1024, 1024, 1024, 3072],
+            'kernel_sizes': [5, 3, 3, 3, 1],
+            'dilations': [1, 2, 3, 4, 1],
+            'attention_channels': 128,
+            'lin_neurons': 192
+        }
+        self.model = Classifier(
+            backbone=ECAPA_TDNN(**model_conf),
+            num_class=45,
+        )
+        self.model.set_state_dict(paddle.load(ckpt_path))
+        self.model.eval()
+
+    def load_audio(self, wav):
+        wav = os.path.abspath(os.path.expanduser(wav))
+        assert os.path.isfile(wav), 'Please check wav file: {}'.format(wav)
+        waveform, _ = paddleaudio.load(wav, sr=self.sr, mono=True, normal=False)
+        return waveform
+
+    def language_identify(self, wav):
+        waveform = self.load_audio(wav)
+        logits = self(paddle.to_tensor(waveform)).reshape([-1])
+        idx = paddle.argmax(logits)
+        return logits[idx].numpy(), self.label_list[idx]
+
+    def forward(self, x):
+        if len(x.shape) == 1:
+            x = x.unsqueeze(0)
+
+        fbank = compute_log_fbank(x)  # x: waveform tensors with (B, T) shape
+        norm_fbank = normalize(fbank)
+        logits = self.model(norm_fbank).squeeze(1)
+
+        return logits

modules/audio/language_identification/ecapa_tdnn_common_language/requirements.txt

+paddleaudio==0.1.0

modules/audio/speaker_recognition/ecapa_tdnn_voxceleb/README.md

+# ecapa_tdnn_voxceleb
+
+|模型名称|ecapa_tdnn_voxceleb|
+| :--- | :---: |
+|类别|语音-声纹识别|
+|网络|ECAPA-TDNN|
+|数据集|VoxCeleb|
+|是否支持Fine-tuning|否|
+|模型大小|79MB|
+|最新更新日期|2021-12-30|
+|数据指标|EER 0.69%|
+
+## 一、模型基本信息
+
+### 模型介绍
+
+ecapa_tdnn_voxceleb采用了[ECAPA-TDNN](https://arxiv.org/abs/2005.07143)的模型结构，并在[VoxCeleb](http://www.robots.ox.ac.uk/~vgg/data/voxceleb/)数据集上进行了预训练，在VoxCeleb1的声纹识别测试集([veri_test.txt](https://www.robots.ox.ac.uk/~vgg/data/voxceleb/meta/veri_test.txt))上的测试结果为 EER 0.69%，达到了该数据集的SOTA。
+
+<p align="center">
+<img src="https://d3i71xaburhd42.cloudfront.net/9609f4817a7e769f5e3e07084db35e46696e82cd/3-Figure2-1.png" hspace='10' height="550"/> <br />
+</p>
+
+
+
+更多详情请参考
+- [VoxCeleb: a large-scale speaker identification dataset](https://www.robots.ox.ac.uk/~vgg/publications/2017/Nagrani17/nagrani17.pdf)
+- [ECAPA-TDNN: Emphasized Channel Attention, Propagation and Aggregation in TDNN Based Speaker Verification](https://arxiv.org/pdf/2005.07143.pdf)
+- [The SpeechBrain Toolkit](https://github.com/speechbrain/speechbrain)
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+  - paddlepaddle >= 2.2.0
+
+  - paddlehub >= 2.2.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+  - ```shell
+    $ hub install ecapa_tdnn_voxceleb
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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
+
+    model = hub.Module(
+        name='ecapa_tdnn_voxceleb',
+        threshold=0.25,
+        version='1.0.0')
+
+    # 通过下列链接可下载示例音频
+    # https://paddlehub.bj.bcebos.com/paddlehub_dev/sv1.wav
+    # https://paddlehub.bj.bcebos.com/paddlehub_dev/sv2.wav
+
+    # Speaker Embedding
+    embedding = model.speaker_embedding('sv1.wav')
+    print(embedding.shape)
+    # (192,)
+
+    # Speaker Verification
+    score, pred = model.speaker_verify('sv1.wav', 'sv2.wav')
+    print(score, pred)
+    # [0.16354457], [False]
+    ```
+
+- ### 2、API
+  - ```python
+    def __init__(
+        threshold: float,
+    )
+    ```
+    - 初始化声纹模型，确定判别阈值。
+
+    - **参数**
+
+      - `threshold`：设定模型判别声纹相似度的得分阈值，默认为 0.25。
+
+  - ```python
+    def speaker_embedding(
+        wav: os.PathLike,
+    )
+    ```
+    - 获取输入音频的声纹特征
+
+    - **参数**
+
+      - `wav`：输入的说话人的音频文件，格式为`*.wav`。
+
+    - **返回**
+
+      - 输出纬度为 (192,) 的声纹特征向量。
+
+  - ```python
+    def speaker_verify(
+        wav1: os.PathLike,
+        wav2: os.PathLike,
+    )
+    ```
+    - 对比两段音频，分别计算其声纹特征的相似度得分，并判断是否为同一说话人。
+
+    - **参数**
+
+      - `wav1`：输入的说话人1的音频文件，格式为`*.wav`。
+      - `wav2`：输入的说话人2的音频文件，格式为`*.wav`。
+
+    - **返回**
+
+      - 返回声纹相似度得分[-1, 1]和预测结果。
+
+
+## 四、更新历史
+
+* 1.0.0
+
+  初始发布
+
+  ```shell
+  $ hub install ecapa_tdnn_voxceleb
+  ```

modules/audio/speaker_recognition/ecapa_tdnn_voxceleb/__init__.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

modules/audio/speaker_recognition/ecapa_tdnn_voxceleb/ecapa_tdnn.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import math
+import os
+
+import paddle
+import paddle.nn as nn
+import paddle.nn.functional as F
+
+
+def length_to_mask(length, max_len=None, dtype=None):
+    assert len(length.shape) == 1
+
+    if max_len is None:
+        max_len = length.max().astype('int').item()  # using arange to generate mask
+    mask = paddle.arange(max_len, dtype=length.dtype).expand((len(length), max_len)) < length.unsqueeze(1)
+
+    if dtype is None:
+        dtype = length.dtype
+
+    mask = paddle.to_tensor(mask, dtype=dtype)
+    return mask
+
+
+class Conv1d(nn.Layer):
+    def __init__(
+            self,
+            in_channels,
+            out_channels,
+            kernel_size,
+            stride=1,
+            padding="same",
+            dilation=1,
+            groups=1,
+            bias=True,
+            padding_mode="reflect",
+    ):
+        super(Conv1d, self).__init__()
+
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.dilation = dilation
+        self.padding = padding
+        self.padding_mode = padding_mode
+
+        self.conv = nn.Conv1D(
+            in_channels,
+            out_channels,
+            self.kernel_size,
+            stride=self.stride,
+            padding=0,
+            dilation=self.dilation,
+            groups=groups,
+            bias_attr=bias,
+        )
+
+    def forward(self, x):
+        if self.padding == "same":
+            x = self._manage_padding(x, self.kernel_size, self.dilation, self.stride)
+        else:
+            raise ValueError("Padding must be 'same'. Got {self.padding}")
+
+        return self.conv(x)
+
+    def _manage_padding(self, x, kernel_size: int, dilation: int, stride: int):
+        L_in = x.shape[-1]  # Detecting input shape
+        padding = self._get_padding_elem(L_in, stride, kernel_size, dilation)  # Time padding
+        x = F.pad(x, padding, mode=self.padding_mode, data_format="NCL")  # Applying padding
+        return x
+
+    def _get_padding_elem(self, L_in: int, stride: int, kernel_size: int, dilation: int):
+        if stride > 1:
+            n_steps = math.ceil(((L_in - kernel_size * dilation) / stride) + 1)
+            L_out = stride * (n_steps - 1) + kernel_size * dilation
+            padding = [kernel_size // 2, kernel_size // 2]
+        else:
+            L_out = (L_in - dilation * (kernel_size - 1) - 1) // stride + 1
+
+            padding = [(L_in - L_out) // 2, (L_in - L_out) // 2]
+
+        return padding
+
+
+class BatchNorm1d(nn.Layer):
+    def __init__(
+            self,
+            input_size,
+            eps=1e-05,
+            momentum=0.9,
+            weight_attr=None,
+            bias_attr=None,
+            data_format='NCL',
+            use_global_stats=None,
+    ):
+        super(BatchNorm1d, self).__init__()
+
+        self.norm = nn.BatchNorm1D(
+            input_size,
+            epsilon=eps,
+            momentum=momentum,
+            weight_attr=weight_attr,
+            bias_attr=bias_attr,
+            data_format=data_format,
+            use_global_stats=use_global_stats,
+        )
+
+    def forward(self, x):
+        x_n = self.norm(x)
+        return x_n
+
+
+class TDNNBlock(nn.Layer):
+    def __init__(
+            self,
+            in_channels,
+            out_channels,
+            kernel_size,
+            dilation,
+            activation=nn.ReLU,
+    ):
+        super(TDNNBlock, self).__init__()
+        self.conv = Conv1d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            dilation=dilation,
+        )
+        self.activation = activation()
+        self.norm = BatchNorm1d(input_size=out_channels)
+
+    def forward(self, x):
+        return self.norm(self.activation(self.conv(x)))
+
+
+class Res2NetBlock(nn.Layer):
+    def __init__(self, in_channels, out_channels, scale=8, dilation=1):
+        super(Res2NetBlock, self).__init__()
+        assert in_channels % scale == 0
+        assert out_channels % scale == 0
+
+        in_channel = in_channels // scale
+        hidden_channel = out_channels // scale
+
+        self.blocks = nn.LayerList(
+            [TDNNBlock(in_channel, hidden_channel, kernel_size=3, dilation=dilation) for i in range(scale - 1)])
+        self.scale = scale
+
+    def forward(self, x):
+        y = []
+        for i, x_i in enumerate(paddle.chunk(x, self.scale, axis=1)):
+            if i == 0:
+                y_i = x_i
+            elif i == 1:
+                y_i = self.blocks[i - 1](x_i)
+            else:
+                y_i = self.blocks[i - 1](x_i + y_i)
+            y.append(y_i)
+        y = paddle.concat(y, axis=1)
+        return y
+
+
+class SEBlock(nn.Layer):
+    def __init__(self, in_channels, se_channels, out_channels):
+        super(SEBlock, self).__init__()
+
+        self.conv1 = Conv1d(in_channels=in_channels, out_channels=se_channels, kernel_size=1)
+        self.relu = paddle.nn.ReLU()
+        self.conv2 = Conv1d(in_channels=se_channels, out_channels=out_channels, kernel_size=1)
+        self.sigmoid = paddle.nn.Sigmoid()
+
+    def forward(self, x, lengths=None):
+        L = x.shape[-1]
+        if lengths is not None:
+            mask = length_to_mask(lengths * L, max_len=L)
+            mask = mask.unsqueeze(1)
+            total = mask.sum(axis=2, keepdim=True)
+            s = (x * mask).sum(axis=2, keepdim=True) / total
+        else:
+            s = x.mean(axis=2, keepdim=True)
+
+        s = self.relu(self.conv1(s))
+        s = self.sigmoid(self.conv2(s))
+
+        return s * x
+
+
+class AttentiveStatisticsPooling(nn.Layer):
+    def __init__(self, channels, attention_channels=128, global_context=True):
+        super().__init__()
+
+        self.eps = 1e-12
+        self.global_context = global_context
+        if global_context:
+            self.tdnn = TDNNBlock(channels * 3, attention_channels, 1, 1)
+        else:
+            self.tdnn = TDNNBlock(channels, attention_channels, 1, 1)
+        self.tanh = nn.Tanh()
+        self.conv = Conv1d(in_channels=attention_channels, out_channels=channels, kernel_size=1)
+
+    def forward(self, x, lengths=None):
+        C, L = x.shape[1], x.shape[2]  # KP: (N, C, L)
+
+        def _compute_statistics(x, m, axis=2, eps=self.eps):
+            mean = (m * x).sum(axis)
+            std = paddle.sqrt((m * (x - mean.unsqueeze(axis)).pow(2)).sum(axis).clip(eps))
+            return mean, std
+
+        if lengths is None:
+            lengths = paddle.ones([x.shape[0]])
+
+        # Make binary mask of shape [N, 1, L]
+        mask = length_to_mask(lengths * L, max_len=L)
+        mask = mask.unsqueeze(1)
+
+        # Expand the temporal context of the pooling layer by allowing the
+        # self-attention to look at global properties of the utterance.
+        if self.global_context:
+            total = mask.sum(axis=2, keepdim=True).astype('float32')
+            mean, std = _compute_statistics(x, mask / total)
+            mean = mean.unsqueeze(2).tile((1, 1, L))
+            std = std.unsqueeze(2).tile((1, 1, L))
+            attn = paddle.concat([x, mean, std], axis=1)
+        else:
+            attn = x
+
+        # Apply layers
+        attn = self.conv(self.tanh(self.tdnn(attn)))
+
+        # Filter out zero-paddings
+        attn = paddle.where(mask.tile((1, C, 1)) == 0, paddle.ones_like(attn) * float("-inf"), attn)
+
+        attn = F.softmax(attn, axis=2)
+        mean, std = _compute_statistics(x, attn)
+
+        # Append mean and std of the batch
+        pooled_stats = paddle.concat((mean, std), axis=1)
+        pooled_stats = pooled_stats.unsqueeze(2)
+
+        return pooled_stats
+
+
+class SERes2NetBlock(nn.Layer):
+    def __init__(
+            self,
+            in_channels,
+            out_channels,
+            res2net_scale=8,
+            se_channels=128,
+            kernel_size=1,
+            dilation=1,
+            activation=nn.ReLU,
+    ):
+        super(SERes2NetBlock, self).__init__()
+        self.out_channels = out_channels
+        self.tdnn1 = TDNNBlock(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            dilation=1,
+            activation=activation,
+        )
+        self.res2net_block = Res2NetBlock(out_channels, out_channels, res2net_scale, dilation)
+        self.tdnn2 = TDNNBlock(
+            out_channels,
+            out_channels,
+            kernel_size=1,
+            dilation=1,
+            activation=activation,
+        )
+        self.se_block = SEBlock(out_channels, se_channels, out_channels)
+
+        self.shortcut = None
+        if in_channels != out_channels:
+            self.shortcut = Conv1d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=1,
+            )
+
+    def forward(self, x, lengths=None):
+        residual = x
+        if self.shortcut:
+            residual = self.shortcut(x)
+
+        x = self.tdnn1(x)
+        x = self.res2net_block(x)
+        x = self.tdnn2(x)
+        x = self.se_block(x, lengths)
+
+        return x + residual
+
+
+class ECAPA_TDNN(nn.Layer):
+    def __init__(
+            self,
+            input_size,
+            lin_neurons=192,
+            activation=nn.ReLU,
+            channels=[512, 512, 512, 512, 1536],
+            kernel_sizes=[5, 3, 3, 3, 1],
+            dilations=[1, 2, 3, 4, 1],
+            attention_channels=128,
+            res2net_scale=8,
+            se_channels=128,
+            global_context=True,
+    ):
+
+        super(ECAPA_TDNN, self).__init__()
+        assert len(channels) == len(kernel_sizes)
+        assert len(channels) == len(dilations)
+        self.channels = channels
+        self.blocks = nn.LayerList()
+        self.emb_size = lin_neurons
+
+        # The initial TDNN layer
+        self.blocks.append(TDNNBlock(
+            input_size,
+            channels[0],
+            kernel_sizes[0],
+            dilations[0],
+            activation,
+        ))
+
+        # SE-Res2Net layers
+        for i in range(1, len(channels) - 1):
+            self.blocks.append(
+                SERes2NetBlock(
+                    channels[i - 1],
+                    channels[i],
+                    res2net_scale=res2net_scale,
+                    se_channels=se_channels,
+                    kernel_size=kernel_sizes[i],
+                    dilation=dilations[i],
+                    activation=activation,
+                ))
+
+        # Multi-layer feature aggregation
+        self.mfa = TDNNBlock(
+            channels[-1],
+            channels[-1],
+            kernel_sizes[-1],
+            dilations[-1],
+            activation,
+        )
+
+        # Attentive Statistical Pooling
+        self.asp = AttentiveStatisticsPooling(
+            channels[-1],
+            attention_channels=attention_channels,
+            global_context=global_context,
+        )
+        self.asp_bn = BatchNorm1d(input_size=channels[-1] * 2)
+
+        # Final linear transformation
+        self.fc = Conv1d(
+            in_channels=channels[-1] * 2,
+            out_channels=self.emb_size,
+            kernel_size=1,
+        )
+
+    def forward(self, x, lengths=None):
+        xl = []
+        for layer in self.blocks:
+            try:
+                x = layer(x, lengths=lengths)
+            except TypeError:
+                x = layer(x)
+            xl.append(x)
+
+        # Multi-layer feature aggregation
+        x = paddle.concat(xl[1:], axis=1)
+        x = self.mfa(x)
+
+        # Attentive Statistical Pooling
+        x = self.asp(x, lengths=lengths)
+        x = self.asp_bn(x)
+
+        # Final linear transformation
+        x = self.fc(x)
+
+        return x

modules/audio/speaker_recognition/ecapa_tdnn_voxceleb/feature.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import paddle
+import paddleaudio
+from paddleaudio.features.spectrum import hz_to_mel
+from paddleaudio.features.spectrum import mel_to_hz
+from paddleaudio.features.spectrum import power_to_db
+from paddleaudio.features.spectrum import Spectrogram
+from paddleaudio.features.window import get_window
+
+
+def compute_fbank_matrix(sample_rate: int = 16000,
+                         n_fft: int = 400,
+                         n_mels: int = 80,
+                         f_min: int = 0.0,
+                         f_max: int = 8000.0):
+    mel = paddle.linspace(hz_to_mel(f_min, htk=True), hz_to_mel(f_max, htk=True), n_mels + 2, dtype=paddle.float32)
+    hz = mel_to_hz(mel, htk=True)
+
+    band = hz[1:] - hz[:-1]
+    band = band[:-1]
+    f_central = hz[1:-1]
+
+    n_stft = n_fft // 2 + 1
+    all_freqs = paddle.linspace(0, sample_rate // 2, n_stft)
+    all_freqs_mat = all_freqs.tile([f_central.shape[0], 1])
+
+    f_central_mat = f_central.tile([all_freqs_mat.shape[1], 1]).transpose([1, 0])
+    band_mat = band.tile([all_freqs_mat.shape[1], 1]).transpose([1, 0])
+
+    slope = (all_freqs_mat - f_central_mat) / band_mat
+    left_side = slope + 1.0
+    right_side = -slope + 1.0
+
+    fbank_matrix = paddle.maximum(paddle.zeros_like(left_side), paddle.minimum(left_side, right_side))
+
+    return fbank_matrix
+
+
+def compute_log_fbank(
+        x: paddle.Tensor,
+        sample_rate: int = 16000,
+        n_fft: int = 400,
+        hop_length: int = 160,
+        win_length: int = 400,
+        n_mels: int = 80,
+        window: str = 'hamming',
+        center: bool = True,
+        pad_mode: str = 'constant',
+        f_min: float = 0.0,
+        f_max: float = None,
+        top_db: float = 80.0,
+):
+
+    if f_max is None:
+        f_max = sample_rate / 2
+
+    spect = Spectrogram(
+        n_fft=n_fft, hop_length=hop_length, win_length=win_length, window=window, center=center, pad_mode=pad_mode)(x)
+
+    fbank_matrix = compute_fbank_matrix(
+        sample_rate=sample_rate,
+        n_fft=n_fft,
+        n_mels=n_mels,
+        f_min=f_min,
+        f_max=f_max,
+    )
+    fbank = paddle.matmul(fbank_matrix, spect)
+    log_fbank = power_to_db(fbank, top_db=top_db).transpose([0, 2, 1])
+    return log_fbank
+
+
+def compute_stats(x: paddle.Tensor, mean_norm: bool = True, std_norm: bool = False, eps: float = 1e-10):
+    if mean_norm:
+        current_mean = paddle.mean(x, axis=0)
+    else:
+        current_mean = paddle.to_tensor([0.0])
+
+    if std_norm:
+        current_std = paddle.std(x, axis=0)
+    else:
+        current_std = paddle.to_tensor([1.0])
+
+    current_std = paddle.maximum(current_std, eps * paddle.ones_like(current_std))
+
+    return current_mean, current_std
+
+
+def normalize(
+        x: paddle.Tensor,
+        global_mean: paddle.Tensor = None,
+        global_std: paddle.Tensor = None,
+):
+
+    for i in range(x.shape[0]):  # (B, ...)
+        if global_mean is None and global_std is None:
+            mean, std = compute_stats(x[i])
+            x[i] = (x[i] - mean) / std
+        else:
+            x[i] = (x[i] - global_mean) / global_std
+    return x

modules/audio/speaker_recognition/ecapa_tdnn_voxceleb/module.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import re
+from typing import List
+from typing import Union
+
+import numpy as np
+import paddle
+import paddleaudio
+
+from .ecapa_tdnn import ECAPA_TDNN
+from .feature import compute_log_fbank
+from .feature import normalize
+from paddlehub.module.module import moduleinfo
+from paddlehub.utils.log import logger
+
+
+@moduleinfo(
+    name="ecapa_tdnn_voxceleb",
+    version="1.0.0",
+    summary="",
+    author="paddlepaddle",
+    author_email="",
+    type="audio/speaker_recognition")
+class SpeakerRecognition(paddle.nn.Layer):
+    def __init__(self, threshold=0.25):
+        super(SpeakerRecognition, self).__init__()
+        global_stats_path = os.path.join(self.directory, 'assets', 'global_embedding_stats.npy')
+        ckpt_path = os.path.join(self.directory, 'assets', 'model.pdparams')
+
+        self.sr = 16000
+        self.threshold = threshold
+        model_conf = {
+            'input_size': 80,
+            'channels': [1024, 1024, 1024, 1024, 3072],
+            'kernel_sizes': [5, 3, 3, 3, 1],
+            'dilations': [1, 2, 3, 4, 1],
+            'attention_channels': 128,
+            'lin_neurons': 192
+        }
+        self.model = ECAPA_TDNN(**model_conf)
+        self.model.set_state_dict(paddle.load(ckpt_path))
+        self.model.eval()
+
+        global_embedding_stats = np.load(global_stats_path, allow_pickle=True)
+        self.global_emb_mean = paddle.to_tensor(global_embedding_stats.item().get('global_emb_mean'))
+        self.global_emb_std = paddle.to_tensor(global_embedding_stats.item().get('global_emb_std'))
+
+        self.similarity = paddle.nn.CosineSimilarity(axis=-1, eps=1e-6)
+
+    def load_audio(self, wav):
+        wav = os.path.abspath(os.path.expanduser(wav))
+        assert os.path.isfile(wav), 'Please check wav file: {}'.format(wav)
+        waveform, _ = paddleaudio.load(wav, sr=self.sr, mono=True, normal=False)
+        return waveform
+
+    def speaker_embedding(self, wav):
+        waveform = self.load_audio(wav)
+        embedding = self(paddle.to_tensor(waveform)).reshape([-1])
+        return embedding.numpy()
+
+    def speaker_verify(self, wav1, wav2):
+        waveform1 = self.load_audio(wav1)
+        embedding1 = self(paddle.to_tensor(waveform1)).reshape([-1])
+
+        waveform2 = self.load_audio(wav2)
+        embedding2 = self(paddle.to_tensor(waveform2)).reshape([-1])
+
+        score = self.similarity(embedding1, embedding2).numpy()
+        return score, score > self.threshold
+
+    def forward(self, x):
+        if len(x.shape) == 1:
+            x = x.unsqueeze(0)
+
+        fbank = compute_log_fbank(x)  # x: waveform tensors with (B, T) shape
+        norm_fbank = normalize(fbank)
+        embedding = self.model(norm_fbank.transpose([0, 2, 1])).transpose([0, 2, 1])
+        norm_embedding = normalize(x=embedding, global_mean=self.global_emb_mean, global_std=self.global_emb_std)
+
+        return norm_embedding

modules/audio/speaker_recognition/ecapa_tdnn_voxceleb/requirements.txt

+paddleaudio==0.1.0

modules/image/Image_editing/colorization/deoldify/README.md

@@ -53,14 +53,14 @@
 
 
 ## 三、模型API预测
-  - ### 1、代码示例
+  - ### 1、预测代码示例
 
-    ```python
-    import paddlehub as hub
+       - ```python
+         import paddlehub as hub
 
-    model = hub.Module(name='deoldify')
-    model.predict('/PATH/TO/IMAGE/OR/VIDEO')
-    ```
+         model = hub.Module(name='deoldify')
+         model.predict('/PATH/TO/IMAGE/OR/VIDEO')
+         ```
 
   - ### 2、API
 

modules/image/Image_editing/colorization/deoldify/README_en.md

+# deoldify
+
+| Module Name |deoldify|
+| :--- | :---: | 
+|Category|Image editing|
+|Network |NoGAN|
+|Dataset|ILSVRC 2012|
+|Fine-tuning supported or not |No|
+|Module Size |834MB|
+|Data indicators|-|
+|Latest update date |2021-04-13|
+
+
+## I. Basic Information 
+
+- ### Application Effect Display
+  
+  - Sample results:
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/35907364/130886749-668dfa38-42ed-4a09-8d4a-b18af0475375.jpg" width = "450" height = "300" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130886685-76221736-839a-46a2-8415-e5e0dd3b345e.png" width = "450" height = "300" hspace='10'/>
+    </p>
+
+- ### Module Introduction
+
+  - Deoldify is a color rendering model for images and videos, which can restore color for black and white photos and videos.
+
+  - For more information, please refer to: [deoldify](https://github.com/jantic/DeOldify)
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+    - paddlepaddle >= 2.0.0
+
+    - paddlehub >= 2.0.0
+
+    - NOTE: This Module relies on ffmpeg, Please install ffmpeg before using this Module.
+
+        ```shell
+        $ conda install x264=='1!152.20180717' ffmpeg=4.0.2 -c conda-forge
+        ```
+
+
+- ### 2、Installation
+    - ```shell
+      $ hub install deoldify
+      ```
+      
+    - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+
+## III. Module API Prediction
+
+  - ### 1、Prediction Code Example
+
+    - ```python
+      import paddlehub as hub
+
+      model = hub.Module(name='deoldify')
+      model.predict('/PATH/TO/IMAGE/OR/VIDEO')
+      ```
+
+  - ### 2、API
+
+    - ```python
+        def predict(self, input):
+        ```
+
+        - Prediction API.
+
+        - **Parameter**
+
+            - input (str): Image path.
+
+        - **Return**
+
+            - If input is image path, the output is：
+              - pred_img(np.ndarray): image data, ndarray.shape is in the format [H, W, C], BGR.
+              - out_path(str): save path of images.
+
+            - If input is video path, the output is ：
+              - frame_pattern_combined(str): save path of frames from output video.
+              - vid_out_path(str): save path of output video.
+
+    - ```python
+      def run_image(self, img):
+      ```
+        - Prediction API for image.
+
+        - **Parameter**
+
+            - img (str｜np.ndarray): Image data,  str or ndarray. ndarray.shape is in the format [H, W, C], BGR.
+
+        - **Return**
+
+            - pred_img(np.ndarray): Ndarray.shape is in the format [H, W, C], BGR.
+
+    - ```python
+      def run_video(self, video):
+      ```
+       -  Prediction API for video.
+
+       - **Parameter**
+
+         - video(str): Video path.
+
+       - **Return**
+
+         - frame_pattern_combined(str): Save path of frames from output video.
+         - vid_out_path(str): Save path of output video.
+
+
+## IV. Server Deployment
+
+- PaddleHub Serving can deploy an online service of coloring old photos or videos.
+
+
+- ### Step 1: Start PaddleHub Serving
+
+    - Run the startup command:
+
+      - ```shell
+        $ hub serving start -m deoldify
+        ```
+
+    - 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 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
+
+        # Send an HTTP request
+        org_im = cv2.imread('/PATH/TO/ORIGIN/IMAGE')
+        data = {'images':cv2_to_base64(org_im)}
+        headers = {"Content-type": "application/json"}
+        url = "http://127.0.0.1:8866/predict/deoldify"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        img = base64_to_cv2(r.json()["results"])
+        cv2.imwrite('/PATH/TO/SAVE/IMAGE', img)
+        ```
+
+
+## V. Release Note
+
+- 1.0.0
+
+  First release
+
+- 1.0.1
+
+  Adapt to paddlehub2.0

modules/image/Image_editing/colorization/photo_restoration/README.md

@@ -51,17 +51,17 @@
 
 
 ## 三、模型API预测
-  - ### 1、代码示例
+  - ### 1、预测代码示例
 
-    ```python
-    import cv2
-    import paddlehub as hub
+    - ```python
+      import cv2
+      import paddlehub as hub
 
-    model = hub.Module(name='photo_restoration', visualization=True)
-    im = cv2.imread('/PATH/TO/IMAGE')
-    res = model.run_image(im)
+      model = hub.Module(name='photo_restoration', visualization=True)
+      im = cv2.imread('/PATH/TO/IMAGE')
+      res = model.run_image(im)
 
-    ```
+      ```
 - ### 2、API
 
 

modules/image/Image_editing/colorization/photo_restoration/README_en.md

+# photo_restoration
+
+|Module Name|photo_restoration|
+| :--- | :---: | 
+|Category|Image editing|
+|Network|deoldify and realsr|
+|Fine-tuning supported or not|No|
+|Module Size |64MB+834MB|
+|Data indicators|-|
+|Latest update date|2021-08-19|
+
+
+
+## I. Basic Information 
+
+- ### Application Effect Display
+
+  - Sample results:
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/35907364/130897828-d0c86b81-63d1-4e9a-8095-bc000b8c7ca8.jpg" width = "260" height = "400" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130897762-5c9fa711-62bc-4067-8d44-f8feff8c574c.png" width = "260" height = "400" hspace='10'/>
+    </p>
+
+
+
+- ### Module Introduction
+
+    - Photo_restoration can restore old photos. It mainly consists of two parts: coloring and super-resolution. The coloring model is deoldify
+     , and super resolution model is realsr. Therefore, when using this model, please install deoldify and realsr in advance.
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+    - paddlepaddle >= 2.0.0
+
+    - paddlehub >= 2.0.0
+
+    - NOTE: This Module relies on ffmpeg, Please install ffmpeg before using this Module.
+
+      ```shell
+      $ conda install x264=='1!152.20180717' ffmpeg=4.0.2 -c conda-forge
+      ```
+   
+- ### 2、Installation
+
+    - ```shell
+      $ hub install photo_restoration
+      ```
+      
+    - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+
+## III. Module API Prediction
+
+- ### 1、Prediction Code Example
+
+
+  - ```python
+    import cv2
+    import paddlehub as hub
+
+    model = hub.Module(name='photo_restoration', visualization=True)
+    im = cv2.imread('/PATH/TO/IMAGE')
+    res = model.run_image(im)
+
+    ```
+- ### 2、API
+
+
+  - ```python
+    def run_image(self,
+                  input,
+                  model_select= ['Colorization', 'SuperResolution'],
+                  save_path = 'photo_restoration'):
+    ```
+
+    - Predicition API,  produce repaired photos.
+
+    - **Parameter**
+
+        - input (numpy.ndarray｜str): Image data，numpy.ndarray or str. ndarray.shape is in the format [H, W, C], BGR.
+
+        - model_select (list\[str\]): Mode selection，\['Colorization'\] only colorize the input image， \['SuperResolution'\] only increase the image resolution；
+        default is \['Colorization', 'SuperResolution'\]。
+
+        - save_path (str): Save path, default is 'photo_restoration'.
+
+     - **Return**
+
+        - output (numpy.ndarray): Restoration result，ndarray.shape is in the format [H, W, C], BGR.
+
+
+## IV. Server Deployment
+
+- PaddleHub Serving can deploy an online service of photo restoration.
+
+- ### Step 1: Start PaddleHub Serving
+
+    - Run the startup command:
+
+        - ```shell
+          $ hub serving start -m photo_restoration
+          ```
+
+    - 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 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
+
+        # Send an HTTP request
+        org_im = cv2.imread('PATH/TO/IMAGE')
+        data = {'images':cv2_to_base64(org_im), 'model_select': ['Colorization', 'SuperResolution']}
+        headers = {"Content-type": "application/json"}
+        url = "http://127.0.0.1:8866/predict/photo_restoration"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        img = base64_to_cv2(r.json()["results"])
+        cv2.imwrite('PATH/TO/SAVE/IMAGE', img)
+        ```
+
+
+## V. Release Note
+
+- 1.0.0
+
+  First release
+
+- 1.0.1
+
+  Adapt to paddlehub2.0
+

modules/image/Image_editing/colorization/user_guided_colorization/README.md

@@ -22,7 +22,7 @@
     <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"的着色模型，该模型利用预先提供的着色块对图像进行着色。
+  - user_guided_colorization 是基于"Real-Time User-Guided Image Colorization with Learned Deep Priors"的着色模型，该模型利用预先提供的着色块对图像进行着色。
 
 
 ## 二、安装

modules/image/Image_editing/colorization/user_guided_colorization/README_en.md

+# user_guided_colorization
+
+|Module Name|user_guided_colorization|
+| :--- | :---: | 
+|Category |Image editing|
+|Network| Local and Global Hints Network |
+|Dataset|ILSVRC 2012|
+|Fine-tuning supported or notFine-tuning|Yes|
+|Module Size|131MB|
+|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/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>
+
+- ### Module Introduction
+
+  - User_guided_colorization is a colorization model based on "Real-Time User-Guided Image Colorization with Learned Deep Priors"，this model uses pre-supplied coloring blocks to color the gray image.
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+    - paddlepaddle >= 2.0.0
+
+    - paddlehub >= 2.0.0
+
+- ### 2、Installation
+
+    - ```shell
+      $ hub install user_guided_colorization
+      ```
+
+    - In case of any problems during installation, please refer to: [Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)   
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+    ```shell
+    $ hub run user_guided_colorization --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_en/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+    ```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 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 [Canvas](../../docs/reference/datasets.md#class-hubdatasetsCanvas) 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='NEAREST'),
+                       T.RandomPaddingCrop(crop_size=176),
+                       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.
+
+        - Step2: Download the dataset
+            - ```python
+              from paddlehub.datasets import Canvas
+
+              color_set = Canvas(transform=transform, mode='train')
+              ```
+
+                * `transforms`: Data preprocessing methods.
+                * `mode`: Select the data mode, the options are `train`, `test`, `val`. Default is `train`.
+                * `hub.datasets.Canvas()`: The dataset 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='user_guided_colorization', load_checkpoint=None)
+              model.set_config(classification=True, prob=1)
+              ```
+                * `name`: Model name.
+                * `load_checkpoint`: Whether to load the self-trained model, if it is None, load the provided parameters.
+                * `classification`: The model is trained by two mode. At the beginning, `classification` is set to True, which is used for shallow network training. In the later stage of training, set `classification` to False, which is used to train the output layer of the network.
+                * `prob`: The probability that a priori color block is not added to each input image, the default is 1, that is, no prior color block is added. For example, when `prob` is set to 0.9, the probability that there are two a priori color blocks on a picture is(1-0.9)*(1-0.9)*0.9=0.009.
+
+        - Step4: Optimization strategy
+
+            ```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)
+            ```
+
+
+            - 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='user_guided_colorization', load_checkpoint='/PATH/TO/CHECKPOINT')
+                  model.set_config(prob=0.1)
+                  result = model.predict(images=['/PATH/TO/IMAGE'])
+              ```
+
+
+            - **NOTE:** If you want to get the oil painting style, please download the parameter file [Canvas colorization](https://paddlehub.bj.bcebos.com/dygraph/models/canvas_rc.pdparams)
+
+## IV. Server Deployment
+
+- PaddleHub Serving can deploy an online service of colorization.
+
+- ### Step 1: Start PaddleHub Serving
+
+    - Run the startup command:
+
+      - ```shell
+        $ hub serving start -m user_guided_colorization
+        ```
+
+    - 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)]}
+        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)
+        ```
+
+
+## V. Release Note
+
+* 1.0.0
+
+  First release

modules/image/Image_editing/super_resolution/dcscn/README_en.md

+# dcscn
+
+|Module Name|dcscn|
+| :--- | :---: | 
+|Category |Image editing|
+|Network|dcscn|
+|Dataset|DIV2k|
+|Fine-tuning supported or not|No|
+|Module Size|260KB|
+|Data indicators|PSNR37.63|
+|Data indicators |2021-02-26|
+
+
+## I. Basic Information
+
+- ### Application Effect Display
+  
+  - Sample results:
+    <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>
+
+
+- ### Module Introduction
+
+  - DCSCN is a super resolution model based on 'Fast and Accurate Image Super Resolution by Deep CNN with Skip Connection and Network in Network'. The model uses residual structure and skip connections  to extract local and global features. It uses a parallel 1*1 convolutional network to learn detailed features to improve model performance. This model provides super resolution result with scale factor x2.
+
+  - For more information, please refer to: [dcscn](https://github.com/jiny2001/dcscn-super-resolution)
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 2.0.0
+
+  - paddlehub >= 2.0.0
+
+
+- ### 2、Installation
+
+    - ```shell
+      $ hub install dcscn
+      ```
+
+    - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```
+    $ hub run dcscn --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_en/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import cv2
+    import paddlehub as hub
+
+    sr_model = hub.Module(name='dcscn')
+    im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
+    res = sr_model.reconstruct(images=[im], visualization=True)
+    print(res[0]['data'])
+    sr_model.save_inference_model()
+    ```
+
+- ### 3、API
+
+  - ```python
+    def reconstruct(self,
+                   images=None,
+                   paths=None,
+                   use_gpu=False,
+                   visualization=False,
+                   output_dir="dcscn_output")
+    ```
+
+    - Prediction API.
+
+    - **Parameter**
+
+      * images (list\[numpy.ndarray\]): Image data，ndarray.shape is in the format \[H, W, C\]，BGR.
+      * paths (list\[str\]): image path.
+      * 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, "dcscn_output" by default.
+
+    - **Return**
+      * res (list\[dict\]): The list of model results, where each element is dict and each field is: 
+        * save\_path (str, optional): Save path of the result, save_path is '' if no image is saved.
+        * data (numpy.ndarray): Result of super resolution.
+
+  - ```python
+    def save_inference_model(self,
+                            dirname='dcscn_save_model',
+                            model_filename=None,
+                            params_filename=None,
+                            combined=False)
+    ```
+
+    - 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 super resolution.
+
+- ### Step 1: Start PaddleHub Serving
+
+    - Run the startup command:
+
+      - ```shell
+        $ hub serving start -m dcscn
+        ```
+
+    - 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 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
+
+
+      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")
+      ```
+
+## V. Release Note
+
+- 1.0.0
+
+  First release

modules/image/Image_editing/super_resolution/falsr_a/README_en.md

+# falsr_a
+
+|Module Name|falsr_a|
+| :--- | :---: | 
+|Category |Image editing|
+|Network |falsr_a|
+|Dataset|DIV2k|
+|Fine-tuning supported or not|No|
+|Module Size |8.9MB|
+|Data indicators|PSNR37.82|
+|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/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>
+
+
+- ### Module Introduction
+
+  - Falsr_a is a lightweight super-resolution model based on "Accurate and Lightweight Super-Resolution with Neural Architecture Search". The model uses a multi-objective approach to deal with the over-segmentation problem, and uses an elastic search strategy based on a hybrid controller to improve the performance of the model. This model provides super resolution result with scale factor x2.
+
+  - For more information, please refer to: [falsr_a](https://github.com/xiaomi-automl/FALSR)
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 2.0.0
+
+  - paddlehub >= 2.0.0
+
+
+- ### 2、Installation
+
+    - ```shell
+      $ hub install falsr_a
+      ```
+
+    - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```
+    $ hub run falsr_a --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_en/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import cv2
+    import paddlehub as hub
+
+    sr_model = hub.Module(name='falsr_a')
+    im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
+    res = sr_model.reconstruct(images=[im], visualization=True)
+    print(res[0]['data'])
+    sr_model.save_inference_model()
+    ```
+
+- ### 3、API
+
+  - ```python
+    def reconstruct(self,
+                   images=None,
+                   paths=None,
+                   use_gpu=False,
+                   visualization=False,
+                   output_dir="falsr_a_output")
+    ```
+
+    - Prediction API.
+
+    - **Parameter**
+
+      * images (list\[numpy.ndarray\]): image data，ndarray.shape is in the format \[H, W, C\]，BGR.
+      * paths (list\[str\]): image path.
+      * 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, "dcscn_output" by default.
+
+    - **Return**
+      * res (list\[dict\]): The list of model results, where each element is dict and each field is: 
+        * save\_path (str, optional): Save path of the result, save_path is '' if no image is saved.
+        * data (numpy.ndarray): result of super resolution.
+
+  - ```python
+    def save_inference_model(self,
+                            dirname='falsr_a_save_model',
+                            model_filename=None,
+                            params_filename=None,
+                            combined=False)
+    ```
+
+    - 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 super resolution.
+
+
+- ### Step 1: Start PaddleHub Serving
+
+    - Run the startup command:
+
+      - ```shell
+        $ hub serving start -m falsr_a
+        ```
+
+    - 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 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
+
+        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")
+        ```
+
+
+## V. Release Note
+
+- 1.0.0
+
+  First release
+
+
+

modules/image/Image_editing/super_resolution/falsr_b/README_en.md

+# falsr_b
+
+|Module Name|falsr_b|
+| :--- | :---: | 
+|Category |Image editing|
+|Network |falsr_b|
+|Dataset|DIV2k|
+|Fine-tuning supported or not|No|
+|Module Size |4MB|
+|Data indicators|PSNR37.61|
+|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/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>
+
+
+- ### Module Introduction
+
+  - Falsr_b is a lightweight super-resolution model based on "Accurate and Lightweight Super-Resolution with Neural Architecture Search". The model uses a multi-objective approach to deal with the over-segmentation problem, and uses an elastic search strategy based on a hybrid controller to improve the performance of the model. This model provides super resolution result with scale factor x2.
+
+  - For more information, please refer to:[falsr_b](https://github.com/xiaomi-automl/FALSR)
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 2.0.0
+
+  - paddlehub >= 2.0.0
+
+
+- ### 2、Installation
+
+    - ```shell
+      $ hub install falsr_b
+      ```
+
+    - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```
+    $ hub run falsr_b --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_en/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  ```python
+  import cv2
+  import paddlehub as hub
+
+  sr_model = hub.Module(name='falsr_b')
+  im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
+  res = sr_model.reconstruct(images=[im], visualization=True)
+  print(res[0]['data'])
+  sr_model.save_inference_model()
+  ```
+
+- ### 3、API
+
+  - ```python
+    def reconstruct(self,
+                   images=None,
+                   paths=None,
+                   use_gpu=False,
+                   visualization=False,
+                   output_dir="falsr_b_output")
+    ```
+
+    - Prediction API.
+
+    - **Parameter**
+
+      * images (list\[numpy.ndarray\]): Image data，ndarray.shape is in the format \[H, W, C\]，BGR.
+      * paths (list\[str\]): Image path.
+      * 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, "dcscn_output" by default.
+
+    - **Return**
+      * res (list\[dict\]): The list of model results, where each element is dict and each field is: 
+        * save\_path (str, optional): Save path of the result, save_path is '' if no image is saved.
+        * data (numpy.ndarray): Result of super resolution.
+
+  - ```python
+    def save_inference_model(self,
+                            dirname='falsr_b_save_model',
+                            model_filename=None,
+                            params_filename=None,
+                            combined=False)
+    ```
+
+    - 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 super resolution.
+
+
+- ### Step 1: Start PaddleHub Serving
+
+    - Run the startup command:
+
+      - ```shell
+        $ hub serving start -m falsr_b
+        ```
+
+    - 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 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
+
+        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")
+        ```
+
+
+## V. Release Note
+
+- 1.0.0
+
+  First release
+
+
+

modules/image/Image_editing/super_resolution/falsr_c/README.md

@@ -51,7 +51,7 @@
   - ```
     $ hub run falsr_c --input_path "/PATH/TO/IMAGE"
     ```
-- ### 代码示例
+- ### 2、预测代码示例
 
   ```python
   import cv2
@@ -65,7 +65,7 @@
   sr_model.save_inference_model()
   ```
 
-- ### 2、API
+- ### 3、API
 
   - ```python
     def reconstruct(self,

modules/image/Image_editing/super_resolution/falsr_c/README_en.md

+# falsr_c
+
+|Module Name|falsr_c|
+| :--- | :---: | 
+|Category |Image editing|
+|Network |falsr_c|
+|Dataset|DIV2k|
+|Fine-tuning supported or not|No|
+|Module Size |4.4MB|
+|Data indicators|PSNR37.66|
+|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/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>
+
+
+- ### Module Introduction
+
+  - Falsr_c is a lightweight super-resolution model based on "Accurate and Lightweight Super-Resolution with Neural Architecture Search". The model uses a multi-objective approach to deal with the over-segmentation problem, and uses an elastic search strategy based on a hybrid controller to improve the performance of the model. This model provides super resolution result with scale factor x2.
+
+  - For more information, please refer to:[falsr_c](https://github.com/xiaomi-automl/FALSR)
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 2.0.0
+
+  - paddlehub >= 2.0.0
+
+
+- ### 2、Installation
+
+    - ```shell
+      $ hub install falsr_c
+      ```
+
+    - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```
+    $ hub run falsr_c --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_en/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  ```python
+  import cv2
+  import paddlehub as hub
+
+  sr_model = hub.Module(name='falsr_c')
+  im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
+  res = sr_model.reconstruct(images=[im], visualization=True)
+  print(res[0]['data'])
+  sr_model.save_inference_model()
+  ```
+
+- ### 3、API
+
+  - ```python
+    def reconstruct(self,
+                   images=None,
+                   paths=None,
+                   use_gpu=False,
+                   visualization=False,
+                   output_dir="falsr_c_output")
+    ```
+
+    - Prediction API.
+
+    - **Parameter**
+
+      * images (list\[numpy.ndarray\]): Image data，ndarray.shape is in the format \[H, W, C\]，BGR.
+      * paths (list\[str\]): Image path.
+      * 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, "dcscn_output" by default.
+
+    - **Return**
+      * res (list\[dict\]): The list of model results, where each element is dict and each field is: 
+        * save\_path (str, optional): Save path of the result, save_path is '' if no image is saved.
+        * data (numpy.ndarray): Result of super resolution.
+
+  - ```python
+    def save_inference_model(self,
+                            dirname='falsr_c_save_model',
+                            model_filename=None,
+                            params_filename=None,
+                            combined=False)
+    ```
+
+    - 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 super resolution.
+
+
+- ### Step 1: Start PaddleHub Serving
+
+    - Run the startup command:
+
+      - ```shell
+        $ hub serving start -m falsr_c
+        ```
+
+    - 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 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
+
+        org_im = cv2.imread('/PATH/TO/IMAGE')
+        data = {'images':[cv2_to_base64(org_im)]}
+        headers = {"Content-type": "application/json"}
+        url = "http://127.0.0.1:8866/predict/falsr_c"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        sr = base64_to_cv2(r.json()["results"][0]['data'])
+        cv2.imwrite('falsr_c_X2.png', sr)
+        print("save image as falsr_c_X2.png")
+        ```
+
+
+## V. Release Note
+
+- 1.0.0
+
+  First release
+
+
+

modules/image/Image_editing/super_resolution/realsr/README.md

@@ -57,7 +57,7 @@
 
 ## 三、模型API预测
 
-  - ### 1、代码示例
+  - ### 1、预测代码示例
 
     ```python
     import paddlehub as hub

modules/image/Image_editing/super_resolution/realsr/README_en.md

+# realsr
+
+|Module Name |reasr|
+| :--- | :---: | 
+|Category |Image editing|
+|Network|LP-KPN|
+|Dataset |RealSR dataset|
+|Fine-tuning supported or not|No|
+|Module Size |64MB|
+|Latest update date|2021-02-26|
+|Data indicators |PSNR29.05|
+
+
+
+## I. Basic Information 
+
+- ### Application Effect Display
+
+  - Sample results:
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/35907364/133558583-0b7049db-ed1f-4a16-8676-f2141fcb3dee.png" width = "450" height = "300" hspace='10'/> <img src="https://user-images.githubusercontent.com/35907364/130789888-a0d4f78e-acd6-44c1-9570-7390e90ae8dc.png" width = "450" height = "300" hspace='10'/>
+    </p>
+
+- ### Module Introduction
+
+  - Realsr is a super resolution model for image and video based on "Toward Real-World Single Image Super-Resolution: A New Benchmark and A New Mode". This model provides super resolution result with scale factor x4.
+  
+  - For more information, please refer to: [realsr](https://github.com/csjcai/RealSR)
+  
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+    - paddlepaddle >= 2.0.0
+
+    - paddlehub >= 2.0.0
+
+    - **NOTE**: This Module relies on ffmpeg, Please install ffmpeg before using this Module.
+      ```shell
+      $ conda install x264=='1!152.20180717' ffmpeg=4.0.2 -c conda-forge
+      ```
+
+- ### 2、Installation
+
+    - ```shell
+      $ hub install realsr
+      ```
+      
+    - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+    
+
+## III. Module API Prediction
+
+  - ### 1、Prediction Code Example
+
+    - ```python
+      import paddlehub as hub
+
+      model = hub.Module(name='realsr')
+      model.predict('/PATH/TO/IMAGE/OR/VIDEO')
+      ```
+  - ### 2、API
+
+    - ```python
+      def predict(self, input):
+      ```
+
+      - Prediction API.
+
+      - **Parameter**
+
+          - input (str): image path.
+
+      - **Return**
+
+          - If input is image path, the output is：
+            - pred_img(np.ndarray): image data, ndarray.shape is in the format [H, W, C], BGR.
+            - out_path(str): save path of images.
+
+          - If input is video path, the output is ：
+            - frame_pattern_combined(str): save path of frames from output video.
+            - vid_out_path(str): save path of output video.
+
+    - ```python
+      def run_image(self, img):
+      ```
+      - Prediction API for images.
+
+      - **Parameter**
+
+          - img (str｜np.ndarray): Image data,  str or ndarray. ndarray.shape is in the format [H, W, C], BGR.
+
+      - **Return**
+
+          - pred_img(np.ndarray): Prediction result, ndarray.shape is in the format [H, W, C], BGR.
+
+    - ```python
+      def run_video(self, video):
+      ```
+       -  Prediction API for video.
+
+          - **Parameter**
+
+            - video(str): Video path.
+
+          - **Return**
+
+            - frame_pattern_combined(str): Save path of frames from output video.
+            - vid_out_path(str): Save path of output video.
+
+
+## IV. Server Deployment
+
+- PaddleHub Serving can deploy an online service of image super resolution.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command:
+
+    - ```shell
+      $ hub serving start -m realsr
+      ```
+
+  - 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 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
+
+
+        org_im = cv2.imread('/PATH/TO/IMAGE')
+        data = {'images':cv2_to_base64(org_im)}
+        headers = {"Content-type": "application/json"}
+        url = "http://127.0.0.1:8866/predict/realsr"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        img = base64_to_cv2(r.json()["results"])
+        cv2.imwrite('/PATH/TO/SAVE/IMAGE', img)
+
+        ```
+
+
+## V. Release Note
+
+
+- 1.0.0
+
+  First release
+
+* 1.0.1
+
+  Support paddlehub2.0
+

modules/image/Image_gan/attgan_celeba/README_en.md

+# attgan_celeba
+
+|Module Name|attgan_celeba|
+| :--- | :---: |
+|Category |image generation|
+|Network |AttGAN|
+|Dataset|Celeba|
+|Fine-tuning supported or not |No|
+|Module Size |167MB|
+|Latest update date|2021-02-26|
+|Data indicators |-|
+
+
+## I. Basic Information 
+
+- ### Application Effect Display
+  - Sample results:
+
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/35907364/137855667-43c5c40c-28f5-45d8-accc-028e185b988f.JPG" width=1200><br/>
+    The image attributes are: 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>
+
+
+- ### Module Introduction
+
+  - AttGAN is a Generative Adversarial Network, which uses classification loss and reconstruction loss to train the network. The PaddleHub Module is trained one Celeba dataset and currently supports attributes of "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged".
+
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 1.5.2 
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub](../../../../docs/docs_en/get_start/installation.rst)
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install attgan_celeba==1.0.0
+    ```
+
+  - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md).
+
+ 
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run attgan_celeba --image "/PATH/TO/IMAGE" --style "target_attribute" 
+    ```
+
+  - **Parameters**
+
+    - image: Input image path.
+
+    - style: Specify the attributes to be converted. The options are "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged". You can choose one of the options.
+
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_en/tutorial/cmd_usage.rst)
+
+
+
+- ### 2、Prediction Code Example
+
+  - ```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)
+    ```
+
+    - Style transfer API.
+
+    - **Parameter**
+
+      - data(list[dict]): Each element in the list is dict and each field is: 
+          - image (list\[str\])： Each element in the list is the path of the image to be converted.
+          - style (list\[str\])： Each element in the list is a string, fill in the face attributes to be converted.
+
+    - **Return**
+      - res (list\[str\]): Save path of the result.
+
+
+
+## IV. Release Note
+
+- 1.0.0
+
+  First release
+
+

modules/image/Image_gan/cyclegan_cityscapes/README_en.md

+# cyclegan_cityscapes
+
+|Module Name|cyclegan_cityscapes|
+| :--- | :---: |
+|Category |Image generation|
+|Network |CycleGAN|
+|Dataset|Cityscapes|
+|Fine-tuning supported or not |No|
+|Module Size |33MB|
+|Latest update date |2021-02-26|
+|Data indicators|-|
+
+
+## I. Basic Information 
+
+
+- ### Application Effect Display
+
+  - Sample results:
+
+    <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 />
+    Input image
+     <br />
+    <img src="https://user-images.githubusercontent.com/35907364/137839777-89fc705b-f0d7-4a93-94e2-76c0d3c5a0b0.png"  width = "450" height = "300" hspace='10'/>
+     <br />
+    Output image
+     <br />
+    </p>
+
+
+- ### Module Introduction
+
+  - CycleGAN belongs to Generative Adversarial Networks(GANs). Unlike traditional GANs that can only generate pictures in one direction, CycleGAN can simultaneously complete the style transfer of two domains. The PaddleHub Module is trained by Cityscapes dataset, and supports the conversion from real images to semantic segmentation results, and also supports conversion from semantic segmentation results to real images.
+
+
+## II. Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0
+
+  - paddlehub >= 1.1.0 
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install cyclegan_cityscapes==1.0.0
+    ```
+  - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+
+ 
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+  - ```shell
+    $ hub run cyclegan_cityscapes --input_path "/PATH/TO/IMAGE"
+    ```
+  
+    - **Parameters**
+
+      - input_path: image path
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_en/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```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)
+    ```
+
+    - Style transfer API.
+
+    - **Parameters**
+
+      - data(list[dict]): Each element in the list is dict and each field is:
+          - image (list\[str\])： Image path.
+
+    - **Return**
+      - res (list\[str\]): The list of style transfer results, where each element is dict and each field is: 
+          - origin: Original input path.
+          - generated: Save path of images.
+
+
+
+## IV. Release Note
+
+* 1.0.0
+
+  First release
+

modules/image/Image_gan/gan/photopen/README.md

+# photopen
+
+|模型名称|photopen|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|SPADEGenerator|
+|数据集|coco_stuff|
+|是否支持Fine-tuning|否|
+|模型大小|74MB|
+|最新更新日期|2021-12-14|
+|数据指标|-|
+
+
+## 一、模型基本信息  
+
+- ### 应用效果展示
+  - 样例结果示例：
+    <p align="center">
+    <img src="https://camo.githubusercontent.com/22e94b0c7278af08da8c475a3d968ba2f3cd565fcb2ad6b9a165c8a65f2d12f8/68747470733a2f2f61692d73747564696f2d7374617469632d6f6e6c696e652e63646e2e626365626f732e636f6d2f39343733313032336561623934623162393762396361383062643362333038333063393138636631363264303436626438383534306464613435303239356133"  width = "90%"  hspace='10'/>
+    <br />
+
+- ### 模型介绍
+
+  - 本模块采用一个像素风格迁移网络 Pix2PixHD，能够根据输入的语义分割标签生成照片风格的图片。为了解决模型归一化层导致标签语义信息丢失的问题，向 Pix2PixHD 的生成器网络中添加了 SPADE（Spatially-Adaptive
+      Normalization）空间自适应归一化模块，通过两个卷积层保留了归一化时训练的缩放与偏置参数的空间维度，以增强生成图片的质量。语义风格标签图像可以参考[coco_stuff数据集](https://github.com/nightrome/cocostuff)获取, 也可以通过[PaddleGAN repo中的该项目](https://github.com/PaddlePaddle/PaddleGAN/blob/87537ad9d4eeda17eaa5916c6a585534ab989ea8/docs/zh_CN/tutorials/photopen.md)来自定义生成图像进行体验。
+
+
+
+## 二、安装
+
+- ### 1、环境依赖  
+  - ppgan
+
+- ### 2、安装
+
+  - ```shell
+    $ hub install photopen
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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
+    # Read from a file
+    $ hub run photopen --input_path "/PATH/TO/IMAGE"
+    ```
+  - 通过命令行方式实现图像生成模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测代码示例
+
+  - ```python
+    import paddlehub as hub
+
+    module = hub.Module(name="photopen")
+    input_path = ["/PATH/TO/IMAGE"]
+    # Read from a file
+    module.photo_transfer(paths=input_path, output_dir='./transfer_result/', use_gpu=True)  
+    ```
+
+- ### 3、API
+
+  - ```python
+    photo_transfer(images=None, paths=None, output_dir='./transfer_result/', use_gpu=False, visualization=True):
+    ```
+    - 图像转换生成API。
+
+    - **参数**
+
+      - images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；<br/>
+      - paths (list\[str\]): 图片的路径；<br/>
+      - output\_dir (str): 结果保存的路径； <br/>
+      - use\_gpu (bool): 是否使用 GPU；<br/>
+      - visualization(bool): 是否保存结果到本地文件夹
+
+
+## 四、服务部署
+
+- PaddleHub Serving可以部署一个在线图像转换生成服务。
+
+- ### 第一步：启动PaddleHub Serving
+
+  - 运行启动命令：
+  - ```shell
+    $ hub serving start -m photopen
+    ```
+
+  - 这样就完成了一个图像转换生成的在线服务API的部署，默认端口号为8866。
+
+  - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+- ### 第二步：发送预测请求
+
+  - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+  - ```python
+    import requests
+    import json
+    import cv2
+    import base64
+
+
+    def cv2_to_base64(image):
+      data = cv2.imencode('.jpg', image)[1]
+      return base64.b64encode(data.tostring()).decode('utf8')
+
+    # 发送HTTP请求
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/photopen"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # 打印预测结果
+    print(r.json()["results"])
+
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布
+
+  - ```shell
+    $ hub install photopen==1.0.0
+    ```

modules/image/Image_gan/gan/photopen/model.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+
+import cv2
+import numpy as np
+import paddle
+from PIL import Image
+from PIL import ImageOps
+from ppgan.models.generators import SPADEGenerator
+from ppgan.utils.filesystem import load
+from ppgan.utils.photopen import data_onehot_pro
+
+
+class PhotoPenPredictor:
+    def __init__(self, weight_path, gen_cfg):
+
+        # 初始化模型
+        gen = SPADEGenerator(
+            gen_cfg.ngf,
+            gen_cfg.num_upsampling_layers,
+            gen_cfg.crop_size,
+            gen_cfg.aspect_ratio,
+            gen_cfg.norm_G,
+            gen_cfg.semantic_nc,
+            gen_cfg.use_vae,
+            gen_cfg.nef,
+        )
+        gen.eval()
+        para = load(weight_path)
+        if 'net_gen' in para:
+            gen.set_state_dict(para['net_gen'])
+        else:
+            gen.set_state_dict(para)
+
+        self.gen = gen
+        self.gen_cfg = gen_cfg
+
+    def run(self, image):
+        sem = Image.fromarray(image).convert('L')
+        sem = sem.resize((self.gen_cfg.crop_size, self.gen_cfg.crop_size), Image.NEAREST)
+        sem = np.array(sem).astype('float32')
+        sem = paddle.to_tensor(sem)
+        sem = sem.reshape([1, 1, self.gen_cfg.crop_size, self.gen_cfg.crop_size])
+
+        one_hot = data_onehot_pro(sem, self.gen_cfg)
+        predicted = self.gen(one_hot)
+        pic = predicted.numpy()[0].reshape((3, 256, 256)).transpose((1, 2, 0))
+        pic = ((pic + 1.) / 2. * 255).astype('uint8')
+
+        return pic

modules/image/Image_gan/gan/photopen/module.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import copy
+import os
+
+import cv2
+import numpy as np
+import paddle
+from ppgan.utils.config import get_config
+from skimage.io import imread
+from skimage.transform import rescale
+from skimage.transform import resize
+
+import paddlehub as hub
+from .model import PhotoPenPredictor
+from .util import base64_to_cv2
+from paddlehub.module.module import moduleinfo
+from paddlehub.module.module import runnable
+from paddlehub.module.module import serving
+
+
+@moduleinfo(
+    name="photopen", type="CV/style_transfer", author="paddlepaddle", author_email="", summary="", version="1.0.0")
+class Photopen:
+    def __init__(self):
+        self.pretrained_model = os.path.join(self.directory, "photopen.pdparams")
+        cfg = get_config(os.path.join(self.directory, "photopen.yaml"))
+        self.network = PhotoPenPredictor(weight_path=self.pretrained_model, gen_cfg=cfg.predict)
+
+    def photo_transfer(self,
+                       images: list = None,
+                       paths: list = None,
+                       output_dir: str = './transfer_result/',
+                       use_gpu: bool = False,
+                       visualization: bool = True):
+        '''
+        images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR(read by cv2).
+        paths (list[str]): paths to images
+
+        output_dir (str): the dir to save the results
+        use_gpu (bool): if True, use gpu to perform the computation, otherwise cpu.
+        visualization (bool): if True, save results in output_dir.
+        '''
+        results = []
+        paddle.disable_static()
+        place = 'gpu:0' if use_gpu else 'cpu'
+        place = paddle.set_device(place)
+        if images == None and paths == None:
+            print('No image provided. Please input an image or a image path.')
+            return
+
+        if images != None:
+            for image in images:
+                image = image[:, :, ::-1]
+                out = self.network.run(image)
+                results.append(out)
+
+        if paths != None:
+            for path in paths:
+                image = cv2.imread(path)[:, :, ::-1]
+                out = self.network.run(image)
+                results.append(out)
+
+        if visualization == True:
+            if not os.path.exists(output_dir):
+                os.makedirs(output_dir, exist_ok=True)
+            for i, out in enumerate(results):
+                if out is not None:
+                    cv2.imwrite(os.path.join(output_dir, 'output_{}.png'.format(i)), out[:, :, ::-1])
+
+        return results
+
+    @runnable
+    def run_cmd(self, argvs: list):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        self.args = self.parser.parse_args(argvs)
+        results = self.photo_transfer(
+            paths=[self.args.input_path],
+            output_dir=self.args.output_dir,
+            use_gpu=self.args.use_gpu,
+            visualization=self.args.visualization)
+        return results
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.photo_transfer(images=images_decode, **kwargs)
+        tolist = [result.tolist() for result in results]
+        return tolist
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument('--use_gpu', action='store_true', help="use GPU or not")
+
+        self.arg_config_group.add_argument(
+            '--output_dir', type=str, default='transfer_result', help='output directory for saving result.')
+        self.arg_config_group.add_argument('--visualization', type=bool, default=False, help='save results or not.')
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to input image.")

modules/image/Image_gan/gan/photopen/photopen.yaml

+total_iters: 1
+output_dir: output_dir
+checkpoints_dir: checkpoints
+
+model:
+  name: PhotoPenModel
+  generator:
+    name: SPADEGenerator
+    ngf: 24
+    num_upsampling_layers: normal
+    crop_size: 256
+    aspect_ratio: 1.0
+    norm_G: spectralspadebatch3x3
+    semantic_nc: 14
+    use_vae: False
+    nef: 16
+  discriminator:
+    name: MultiscaleDiscriminator
+    ndf: 128
+    num_D: 4
+    crop_size: 256
+    label_nc: 12
+    output_nc: 3
+    contain_dontcare_label: True
+    no_instance: False
+    n_layers_D: 6
+  criterion:
+    name: PhotoPenPerceptualLoss
+    crop_size: 224
+    lambda_vgg: 1.6
+  label_nc: 12
+  contain_dontcare_label: True
+  batchSize: 1
+  crop_size: 256
+  lambda_feat: 10.0
+
+dataset:
+  train:
+    name: PhotoPenDataset
+    content_root: test/coco_stuff
+    load_size: 286
+    crop_size: 256
+    num_workers: 0
+    batch_size: 1
+  test:
+    name: PhotoPenDataset_test
+    content_root: test/coco_stuff
+    load_size: 286
+    crop_size: 256
+    num_workers: 0
+    batch_size: 1
+
+lr_scheduler: # abundoned
+  name: LinearDecay
+  learning_rate: 0.0001
+  start_epoch: 99999
+  decay_epochs: 99999
+  # will get from real dataset
+  iters_per_epoch: 1
+
+optimizer:
+  lr: 0.0001
+  optimG:
+    name: Adam
+    net_names:
+      - net_gen
+    beta1: 0.9
+    beta2: 0.999
+  optimD:
+    name: Adam
+    net_names:
+      - net_des
+    beta1: 0.9
+    beta2: 0.999
+
+log_config:
+  interval: 1
+  visiual_interval: 1
+
+snapshot_config:
+  interval: 1
+
+predict:
+  name: SPADEGenerator
+  ngf: 24
+  num_upsampling_layers: normal
+  crop_size: 256
+  aspect_ratio: 1.0
+  norm_G: spectralspadebatch3x3
+  semantic_nc: 14
+  use_vae: False
+  nef: 16
+  contain_dontcare_label: True
+  label_nc: 12
+  batchSize: 1

modules/image/Image_gan/gan/photopen/requirements.txt

+ppgan

modules/image/Image_gan/gan/photopen/util.py

+import base64
+
+import cv2
+import numpy as np
+
+
+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

modules/image/Image_gan/gan/stgan_bald/README.md

@@ -25,8 +25,6 @@
 
 - ### 1、环境依赖  
 
-  - paddlepaddle >= 1.8.2  
-
   - paddlehub >= 1.8.0  | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
 
 - ### 2、安装
@@ -38,7 +36,7 @@
  | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/gan/stgan_bald/README_en.md

+# stgan_bald
+
+|Module Name|stgan_bald|
+| :--- | :---: |
+|Category|image generation|
+|Network|STGAN|
+|Dataset|CelebA|
+|Fine-tuning supported or not|No|
+|Module Size|287MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Please refer to this [link](https://aistudio.baidu.com/aistudio/projectdetail/1145381)
+
+- ### Module Introduction
+
+  - This module is based on STGAN model, trained on CelebA dataset, and can be used to predict bald appearance after 1, 3 and 5 years.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlehub >= 1.8.0  | [How to install PaddleHub](../../../../docs/docs_en/get_start/installation.rst)
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install stgan_bald
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md) | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)
+## III.Module API Prediction
+
+- ### 1、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    stgan_bald = hub.Module(name="stgan_bald")
+    result = stgan_bald.bald(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = stgan_bald.bald(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 2、API
+
+  - ```python
+    def bald(images=None,
+             paths=None,
+             use_gpu=False,
+             visualization=False,
+             output_dir="bald_output")
+    ```
+
+    - Bald appearance generation API.
+
+    - **Parameters**
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - 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 results as picture files;
+      - output_dir (str): save path of images;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[numpy.ndarray\]): result list，ndarray.shape is \[H, W, C\]
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of bald appearance generation.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m stgan_bald
+    ```
+
+  - 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/stgan_bald"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # save results
+    one_year =cv2.cvtColor(base64_to_cv2(r.json()["results"]['data_0']), cv2.COLOR_RGB2BGR)
+    three_year =cv2.cvtColor(base64_to_cv2(r.json()["results"]['data_1']), cv2.COLOR_RGB2BGR)
+    five_year =cv2.cvtColor(base64_to_cv2(r.json()["results"]['data_2']), cv2.COLOR_RGB2BGR)
+    cv2.imwrite("stgan_bald_server.png", one_year)
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install stgan_bald==1.0.0
+    ```

modules/image/Image_gan/gan/stgan_bald/requirements.txt

-paddlepaddle>=1.8.4
 paddlehub>=1.8.0

modules/image/Image_gan/gan/styleganv2_mixing/README.md

+# styleganv2_mixing
+
+|模型名称|styleganv2_mixing|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|StyleGAN V2|
+|数据集|-|
+|是否支持Fine-tuning|否|
+|模型大小|190MB|
+|最新更新日期|2021-12-23|
+|数据指标|-|
+
+
+## 一、模型基本信息  
+
+- ### 应用效果展示
+  - 样例结果示例：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/147241001-3babb1bd-98d4-4a9c-a61d-2298fca041e1.jpg"  width = "40%"  hspace='10'/>
+    <br />
+    输入图像1
+    <br />
+    <img src="https://user-images.githubusercontent.com/22424850/147241006-0bc2cda8-d271-4cfd-8a0d-e6feea7bf167.jpg"  width = "40%"  hspace='10'/>
+    <br />
+    输入图像2
+    <br />
+    <img src="https://user-images.githubusercontent.com/22424850/147241020-f4420729-c489-4661-b43f-c929c62c0ce7.png"  width = "40%"  hspace='10'/>
+    <br />
+    输出图像
+     <br />
+    </p>
+
+- ### 模型介绍
+
+  - StyleGAN V2 的任务是使用风格向量进行image generation，而Mixing模块则是利用其风格向量实现两张生成图像不同层次不同比例的混合。
+
+
+
+## 二、安装
+
+- ### 1、环境依赖  
+  - paddlepaddle >= 2.1.0
+  - paddlehub >= 2.1.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+  - ```shell
+    $ hub install styleganv2_mixing
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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
+    # Read from a file
+    $ hub run styleganv2_mixing --image1 "/PATH/TO/IMAGE1" --image2 "/PATH/TO/IMAGE2"
+    ```
+  - 通过命令行方式实现人脸融合模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测代码示例
+
+  - ```python
+    import paddlehub as hub
+
+    module = hub.Module(name="styleganv2_mixing")
+    input_path = ["/PATH/TO/IMAGE"]
+    # Read from a file
+    module.generate(paths=input_path, direction_name = 'age', direction_offset = 5, output_dir='./editing_result/', use_gpu=True)  
+    ```
+
+- ### 3、API
+
+  - ```python
+    generate(self, images=None, paths=None, weights = [0.5] * 18, output_dir='./mixing_result/', use_gpu=False, visualization=True)
+    ```
+    - 人脸融合生成API。
+
+    - **参数**
+      - images (list[dict]): data of images, 每一个元素都为一个 dict，有关键字 image1, image2, 相应取值为：
+          - image1 (numpy.ndarray): 待融合的图片1，shape 为 \[H, W, C\]，BGR格式；<br/>
+          - image2 (numpy.ndarray) : 待融合的图片2，shape为 \[H, W, C\]，BGR格式；<br/>
+      - paths (list[str]): paths to images, 每一个元素都为一个dict, 有关键字 image1, image2, 相应取值为：
+          - image1 (str): 待融合的图片1的路径；<br/>
+          - image2 (str) : 待融合的图片2的路径；<br/>
+      - weights (list(float)): 融合的权重
+      - images (list\[numpy.ndarray\]): 图片数据 <br/>
+      - paths (list\[str\]): 图片路径；<br/>
+      - output\_dir (str): 结果保存的路径； <br/>
+      - use\_gpu (bool): 是否使用 GPU；<br/>
+      - visualization(bool): 是否保存结果到本地文件夹
+
+
+## 四、服务部署
+
+- PaddleHub Serving可以部署一个在线人脸融合服务。
+
+- ### 第一步：启动PaddleHub Serving
+
+  - 运行启动命令：
+  - ```shell
+    $ hub serving start -m styleganv2_mixing
+    ```
+
+  - 这样就完成了一个人脸融合的在线服务API的部署，默认端口号为8866。
+
+  - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+- ### 第二步：发送预测请求
+
+  - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+  - ```python
+    import requests
+    import json
+    import cv2
+    import base64
+
+
+    def cv2_to_base64(image):
+      data = cv2.imencode('.jpg', image)[1]
+      return base64.b64encode(data.tostring()).decode('utf8')
+
+    # 发送HTTP请求
+    data = {'images':[{'image1': cv2_to_base64(cv2.imread("/PATH/TO/IMAGE1")),'image2': cv2_to_base64(cv2.imread("/PATH/TO/IMAGE2"))}]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/styleganv2_mixing"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # 打印预测结果
+    print(r.json()["results"])
+
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布
+
+  - ```shell
+    $ hub install styleganv2_mixing==1.0.0
+    ```

modules/image/Image_gan/gan/styleganv2_mixing/basemodel.py

+#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import random
+import numpy as np
+import paddle
+from ppgan.models.generators import StyleGANv2Generator
+from ppgan.utils.download import get_path_from_url
+from ppgan.utils.visual import make_grid, tensor2img, save_image
+
+model_cfgs = {
+    'ffhq-config-f': {
+        'model_urls': 'https://paddlegan.bj.bcebos.com/models/stylegan2-ffhq-config-f.pdparams',
+        'size': 1024,
+        'style_dim': 512,
+        'n_mlp': 8,
+        'channel_multiplier': 2
+    },
+    'animeface-512': {
+        'model_urls': 'https://paddlegan.bj.bcebos.com/models/stylegan2-animeface-512.pdparams',
+        'size': 512,
+        'style_dim': 512,
+        'n_mlp': 8,
+        'channel_multiplier': 2
+    }
+}
+
+
+@paddle.no_grad()
+def get_mean_style(generator):
+    mean_style = None
+
+    for i in range(10):
+        style = generator.mean_latent(1024)
+
+        if mean_style is None:
+            mean_style = style
+
+        else:
+            mean_style += style
+
+    mean_style /= 10
+    return mean_style
+
+
+@paddle.no_grad()
+def sample(generator, mean_style, n_sample):
+    image = generator(
+        [paddle.randn([n_sample, generator.style_dim])],
+        truncation=0.7,
+        truncation_latent=mean_style,
+    )[0]
+
+    return image
+
+
+@paddle.no_grad()
+def style_mixing(generator, mean_style, n_source, n_target):
+    source_code = paddle.randn([n_source, generator.style_dim])
+    target_code = paddle.randn([n_target, generator.style_dim])
+
+    resolution = 2**((generator.n_latent + 2) // 2)
+
+    images = [paddle.ones([1, 3, resolution, resolution]) * -1]
+
+    source_image = generator([source_code], truncation_latent=mean_style, truncation=0.7)[0]
+    target_image = generator([target_code], truncation_latent=mean_style, truncation=0.7)[0]
+
+    images.append(source_image)
+
+    for i in range(n_target):
+        image = generator(
+            [target_code[i].unsqueeze(0).tile([n_source, 1]), source_code],
+            truncation_latent=mean_style,
+            truncation=0.7,
+        )[0]
+        images.append(target_image[i].unsqueeze(0))
+        images.append(image)
+
+    images = paddle.concat(images, 0)
+
+    return images
+
+
+class StyleGANv2Predictor:
+    def __init__(self,
+                 output_path='output_dir',
+                 weight_path=None,
+                 model_type=None,
+                 seed=None,
+                 size=1024,
+                 style_dim=512,
+                 n_mlp=8,
+                 channel_multiplier=2):
+        self.output_path = output_path
+
+        if weight_path is None:
+            if model_type in model_cfgs.keys():
+                weight_path = get_path_from_url(model_cfgs[model_type]['model_urls'])
+                size = model_cfgs[model_type].get('size', size)
+                style_dim = model_cfgs[model_type].get('style_dim', style_dim)
+                n_mlp = model_cfgs[model_type].get('n_mlp', n_mlp)
+                channel_multiplier = model_cfgs[model_type].get('channel_multiplier', channel_multiplier)
+                checkpoint = paddle.load(weight_path)
+            else:
+                raise ValueError('Predictor need a weight path or a pretrained model type')
+        else:
+            checkpoint = paddle.load(weight_path)
+
+        self.generator = StyleGANv2Generator(size, style_dim, n_mlp, channel_multiplier)
+        self.generator.set_state_dict(checkpoint)
+        self.generator.eval()
+
+        if seed is not None:
+            paddle.seed(seed)
+            random.seed(seed)
+            np.random.seed(seed)
+
+    def run(self, n_row=3, n_col=5):
+        os.makedirs(self.output_path, exist_ok=True)
+        mean_style = get_mean_style(self.generator)
+
+        img = sample(self.generator, mean_style, n_row * n_col)
+        save_image(tensor2img(make_grid(img, nrow=n_col)), f'{self.output_path}/sample.png')
+
+        for j in range(2):
+            img = style_mixing(self.generator, mean_style, n_col, n_row)
+            save_image(tensor2img(make_grid(img, nrow=n_col + 1)), f'{self.output_path}/sample_mixing_{j}.png')

modules/image/Image_gan/gan/styleganv2_mixing/model.py

+#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import cv2
+import numpy as np
+import paddle
+
+from .basemodel import StyleGANv2Predictor
+
+
+def make_image(tensor):
+    return (((tensor.detach() + 1) / 2 * 255).clip(min=0, max=255).transpose((0, 2, 3, 1)).numpy().astype('uint8'))
+
+
+class StyleGANv2MixingPredictor(StyleGANv2Predictor):
+    @paddle.no_grad()
+    def run(self, latent1, latent2, weights=[0.5] * 18):
+
+        latent1 = paddle.to_tensor(latent1).unsqueeze(0)
+        latent2 = paddle.to_tensor(latent2).unsqueeze(0)
+        assert latent1.shape[1] == latent2.shape[1] == len(
+            weights), 'latents and their weights should have the same level nums.'
+        mix_latent = []
+        for i, weight in enumerate(weights):
+            mix_latent.append(latent1[:, i:i + 1] * weight + latent2[:, i:i + 1] * (1 - weight))
+        mix_latent = paddle.concat(mix_latent, 1)
+        latent_n = paddle.concat([latent1, latent2, mix_latent], 0)
+        generator = self.generator
+        img_gen, _ = generator([latent_n], input_is_latent=True, randomize_noise=False)
+        imgs = make_image(img_gen)
+        src_img1 = imgs[0]
+        src_img2 = imgs[1]
+        dst_img = imgs[2]
+
+        return src_img1, src_img2, dst_img

modules/image/Image_gan/gan/styleganv2_mixing/module.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import argparse
+import copy
+
+import paddle
+import paddlehub as hub
+from paddlehub.module.module import moduleinfo, runnable, serving
+import numpy as np
+import cv2
+from skimage.io import imread
+from skimage.transform import rescale, resize
+
+from .model import StyleGANv2MixingPredictor
+from .util import base64_to_cv2
+
+
+@moduleinfo(
+    name="styleganv2_mixing",
+    type="CV/style_transfer",
+    author="paddlepaddle",
+    author_email="",
+    summary="",
+    version="1.0.0")
+class styleganv2_mixing:
+    def __init__(self):
+        self.pretrained_model = os.path.join(self.directory, "stylegan2-ffhq-config-f.pdparams")
+        self.network = StyleGANv2MixingPredictor(weight_path=self.pretrained_model, model_type='ffhq-config-f')
+        self.pixel2style2pixel_module = hub.Module(name='pixel2style2pixel')
+
+    def generate(self,
+                 images=None,
+                 paths=None,
+                 weights=[0.5] * 18,
+                 output_dir='./mixing_result/',
+                 use_gpu=False,
+                 visualization=True):
+        '''
+        images (list[dict]): data of images, each element is a dict，the keys are as below：
+          - image1 (numpy.ndarray): image1 to be mixed，shape is \[H, W, C\]，BGR format；<br/>
+          - image2 (numpy.ndarray) : image2 to be mixed，shape is \[H, W, C\]，BGR format；<br/>
+        paths (list[str]): paths to images, each element is a dict，the keys are as below：
+          - image1 (str): path to image1；<br/>
+          - image2 (str) : path to image2；<br/>
+        weights (list(float)): weight for mixing
+        output_dir: the dir to save the results
+        use_gpu: if True, use gpu to perform the computation, otherwise cpu.
+        visualization: if True, save results in output_dir.
+        '''
+        results = []
+        paddle.disable_static()
+        place = 'gpu:0' if use_gpu else 'cpu'
+        place = paddle.set_device(place)
+        if images == None and paths == None:
+            print('No image provided. Please input an image or a image path.')
+            return
+        if images != None:
+            for image_dict in images:
+                image1 = image_dict['image1'][:, :, ::-1]
+                image2 = image_dict['image2'][:, :, ::-1]
+                _, latent1 = self.pixel2style2pixel_module.network.run(image1)
+                _, latent2 = self.pixel2style2pixel_module.network.run(image2)
+                results.append(self.network.run(latent1, latent2, weights))
+
+        if paths != None:
+            for path_dict in paths:
+                path1 = path_dict['image1']
+                path2 = path_dict['image2']
+                image1 = cv2.imread(path1)[:, :, ::-1]
+                image2 = cv2.imread(path2)[:, :, ::-1]
+                _, latent1 = self.pixel2style2pixel_module.network.run(image1)
+                _, latent2 = self.pixel2style2pixel_module.network.run(image2)
+                results.append(self.network.run(latent1, latent2, weights))
+
+        if visualization == True:
+            if not os.path.exists(output_dir):
+                os.makedirs(output_dir, exist_ok=True)
+            for i, out in enumerate(results):
+                if out is not None:
+                    cv2.imwrite(os.path.join(output_dir, 'src_{}_image1.png'.format(i)), out[0][:, :, ::-1])
+                    cv2.imwrite(os.path.join(output_dir, 'src_{}_image2.png'.format(i)), out[1][:, :, ::-1])
+                    cv2.imwrite(os.path.join(output_dir, 'dst_{}.png'.format(i)), out[2][:, :, ::-1])
+
+        return results
+
+    @runnable
+    def run_cmd(self, argvs: list):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        self.args = self.parser.parse_args(argvs)
+        results = self.generate(
+            paths=[{
+                'image1': self.args.image1,
+                'image2': self.args.image2
+            }],
+            weights=self.args.weights,
+            output_dir=self.args.output_dir,
+            use_gpu=self.args.use_gpu,
+            visualization=self.args.visualization)
+        return results
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = copy.deepcopy(images)
+        for image in images_decode:
+            image['image1'] = base64_to_cv2(image['image1'])
+            image['image2'] = base64_to_cv2(image['image2'])
+        results = self.generate(images_decode, **kwargs)
+        tolist = [result.tolist() for result in results]
+        return tolist
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument('--use_gpu', action='store_true', help="use GPU or not")
+
+        self.arg_config_group.add_argument(
+            '--output_dir', type=str, default='mixing_result', help='output directory for saving result.')
+        self.arg_config_group.add_argument('--visualization', type=bool, default=False, help='save results or not.')
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument('--image1', type=str, help="path to input image1.")
+        self.arg_input_group.add_argument('--image2', type=str, help="path to input image2.")
+        self.arg_input_group.add_argument(
+            "--weights",
+            type=float,
+            nargs="+",
+            default=[0.5] * 18,
+            help="different weights at each level of two latent codes")

modules/image/Image_gan/gan/styleganv2_mixing/requirements.txt

+ppgan

modules/image/Image_gan/gan/styleganv2_mixing/util.py

+import base64
+import cv2
+import numpy as np
+
+
+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

modules/image/Image_gan/stargan_celeba/README_en.md

+# stargan_celeba
+
+|Module Name|stargan_celeba|
+| :--- | :---: |
+|Category|image generation|
+|Network|STGAN|
+|Dataset|Celeba|
+|Fine-tuning supported or not|No|
+|Module Size |33MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I. Basic Information 
+
+- ### Application Effect Display
+  - Sample results:
+
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/35907364/137855887-f0abca76-2735-4275-b7ad-242decf31bb3.PNG" width=600><br/>
+     The image attributes are: origial image, Black_Hair, Blond_Hair, Brown_Hair, Male, Aged<br/>
+    </p>
+
+
+- ### Module Introduction
+
+  - STGAN takes the original attribute and the target attribute as input, and  proposes STUs (Selective transfer units) to select and modify features of the encoder. The PaddleHub Module is trained one Celeba dataset and currently supports attributes of  "Black_Hair", "Blond_Hair", "Brown_Hair", "Female", "Male", "Aged".
+
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 1.5.2 
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install stargan_celeba==1.0.0
+    ```
+  - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+ 
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+    - ```shell
+      $ hub run stargan_celeba --image "/PATH/TO/IMAGE" --style "target_attribute"
+      ```
+
+    - **Parameters**
+
+      - image: image path
+
+      - style: Specify the attributes to be converted. The options are "Black_Hair", "Blond_Hair", "Brown_Hair", "Female", "Male", "Aged". You can choose one of the options.
+
+    - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_en/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```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)
+    ```
+
+    - Style transfer API.
+
+    - **Parameter**
+
+      - data(list[dict]): each element in the list is dict and each field is: 
+          - image (list\[str\])： Each element in the list is the path of the image to be converted.
+          - style (list\[str\])： Each element in the list is a string, fill in the face attributes to be converted.
+
+    - **Return**
+      - res (list\[str\]): Save path of the result.
+
+## IV. Release Note
+
+- 1.0.0
+
+  First release

modules/image/Image_gan/stgan_celeba/README_en.md

+# stgan_celeba
+
+|Module Name|stgan_celeba|
+| :--- | :---: |
+|Category|image generation|
+|Network|STGAN|
+|Dataset|Celeba|
+|Fine-tuning supported or not|No|
+|Module Size |287MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I. Basic Information 
+
+- ### Application Effect Display
+  - Sample results:
+
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/35907364/137856070-2a43facd-cda0-473f-8935-e61f5dd583d8.JPG" width=1200><br/>
+    The image attributes are: 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>
+
+
+- ### Module Introduction
+
+  - STGAN takes the original attribute and the target attribute as input, and proposes STUs (Selective transfer units) to select and modify features of the encoder. The PaddleHub Module is trained one Celeba dataset and currently supports attributes of "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged".
+
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 1.5.2 
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install stgan_celeba==1.0.0
+    ```
+  - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+ 
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run stgan_celeba --image "/PATH/TO/IMAGE" --info "original_attributes" --style "target_attribute" 
+    ```
+    - **Parameters**
+
+      - image: Image path
+
+      - info: Attributes of original image, must fill in gender（ "Male" or "Female").The options are "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged". For example, the input picture is a girl with black hair, then fill in as "Female,Black_Hair". 
+    
+      - style: Specify the attributes to be converted. The options are "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged". You can choose one of the options.
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_en/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```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)
+    ```
+
+    - Style transfer API.
+
+    - **Parameter**
+
+      - data(list[dict]): Each element in the list is dict and each field is: 
+          - image (list\[str\])： Each element in the list is the path of the image to be converted.
+          - style (list\[str\])： Each element in the list is a string, fill in the face attributes to be converted.
+          - info (list\[str\])： Represents the face attributes of the original image. Different attributes are separated by commas.
+          
+
+    - **Return**
+      - res (list\[str\]): Save path of the result.
+
+## IV. Release Note
+
+- 1.0.0
+
+  First release

modules/image/Image_gan/style_transfer/ID_Photo_GEN/README_en.md

+# ID_Photo_GEN
+
+|Module Name |ID_Photo_GEN|
+| :--- | :---: |
+|Category|Image generation|
+|Network|HRNet_W18|
+|Dataset |-|
+|Fine-tuning supported or not |No|
+|Module Size|28KB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I. Basic Information 
+
+- ### Application Effect Display
+  - Sample results:
+    <p align="center">
+    <img src="https://img-blog.csdnimg.cn/20201224163307901.jpg" > 
+    </p>
+
+
+- ### Module Introduction
+
+  - This model is based on face_landmark_localization and FCN_HRNet_W18_Face_Seg. It can generate ID photos with white, red and blue background
+
+
+## II. Installation
+
+- ### 1、Environmental Dependence 
+
+  - paddlepaddle >= 2.0.0
+
+  - paddlehub >= 2.0.0
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install ID_Photo_GEN
+    ```
+
+  - In case of any problems during installation, please refer to:[Windows_Quickstart](../../../../docs/docs_en/get_start/windows_quickstart.md)
+    | [Linux_Quickstart](../../../../docs/docs_en/get_start/linux_quickstart.md) | [Mac_Quickstart](../../../../docs/docs_en/get_start/mac_quickstart.md)  
+ 
+ 
+## III. Module API Prediction
+
+- ### 1、Prediction Code Example
+
+  - ```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):
+    ```
+
+    - Prediction API, generating ID photos.
+
+    - **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 recognition results as picture files.
+        * use_gpu (bool): Use GPU or not. **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+
+        **NOTE:** Choose one of `paths` and `images` to provide input data.
+
+    - **Return**
+    
+      * results (list[dict{"write":np.ndarray,"blue":np.ndarray,"red":np.ndarray}]): The list of generation results.
+
+
+## IV. Release Note
+
+- 1.0.0
+
+  First release
\ No newline at end of file

modules/image/Image_gan/style_transfer/UGATIT_100w/README.md

@@ -50,7 +50,7 @@
 
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/animegan_v1_hayao_60/README.md

@@ -51,7 +51,7 @@
 
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/animegan_v2_hayao_64/README.md

@@ -49,7 +49,7 @@
 
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/animegan_v2_hayao_99/README.md

@@ -51,7 +51,7 @@
 ## 三、模型API预测
 
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/animegan_v2_paprika_74/README.md

@@ -50,7 +50,7 @@
 
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/animegan_v2_paprika_98/README.md

@@ -50,7 +50,7 @@
 
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/animegan_v2_shinkai_33/README.md

@@ -50,7 +50,7 @@
 
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/animegan_v2_shinkai_53/README.md

@@ -50,7 +50,7 @@
 
 ## 三、模型API预测
 
-- ### 1、代码示例
+- ### 1、预测代码示例
 
   - ```python
     import paddlehub as hub

modules/image/Image_gan/style_transfer/face_parse/requirements.txt

+ppgan
+dlib

modules/image/Image_gan/style_transfer/lapstyle_circuit/requirements.txt

+ppgan

modules/image/Image_gan/style_transfer/lapstyle_ocean/requirements.txt

+ppgan

modules/image/Image_gan/style_transfer/lapstyle_starrynew/requirements.txt

+ppgan

modules/image/Image_gan/style_transfer/lapstyle_stars/requirements.txt

+ppgan