fix a bug, embedding result is a tensor, unpacking error (#1910)

* fix a bug, embedding result is a tensor, unpacking error

* fix a bug, embedding result is a tensor, unpacking error.

* doc format

* fix chinese_electra_small README.md

* fix electra model version case
Co-authored-by: Nwuzewu <wuzewu@baidu.com>

modules/text/language_model/chinese_electra_base/README.md

-```shell
-$ hub install chinese-electra-base==2.0.1
-```
+# chinese-electra-base
+|模型名称|chinese-electra-base|
+| :--- | :---: |
+|类别|文本-语义模型|
+|网络|ELECTRA|
+|数据集|中文维基+通用数据|
+|是否支持Fine-tuning|是|
+|模型大小|390MB|
+|最新更新日期|2022-02-08|
+|数据指标|-|
+
+## 一、模型基本信息
+
+- ### 模型介绍
 
 <p align="center">
 <img src="http://bj.bcebos.com/ibox-thumbnail98/1a5578bfbe1ad629035f7ad1eb3d0bce?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-03-31T06%3A45%3A51Z%2F1800%2F%2F02b8749292f8ba1c606410d0e4e5dbabdf1d367d80da395887775d36424ac13e"  hspace='10'/> <br />
@@ -8,71 +19,26 @@ $ hub install chinese-electra-base==2.0.1
 
 更多详情请参考[ELECTRA论文](https://openreview.net/pdf?id=r1xMH1BtvB)
 
-## API
-```python
-def __init__(
-        task=None,
-        load_checkpoint=None,
-        label_map=None,
-        num_classes=2,
-        suffix=False,
-        **kwargs,
-)
-```
-
-创建Module对象（动态图组网版本）。
+## 二、安装
 
-**参数**
-
-* `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
-* `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
-* `label_map`：预测时的类别映射表。
-* `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
-* `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
-* `**kwargs`：用户额外指定的关键字字典类型的参数。
-
-```python
-def predict(
-    data,
-    max_seq_len=128,
-    batch_size=1,
-    use_gpu=False
-)
-```
-
-**参数**
-
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
-* `max_seq_len`：模型处理文本的最大长度
-* `batch_size`：模型批处理大小
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
-
-**返回**
-
-* `results`：list类型，不同任务类型的返回结果如下
-  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
-  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
-
-```python
-def get_embedding(
-    data,
-    use_gpu=False
-)
-```
+- ### 1、环境依赖
 
-用于获取输入文本的句子粒度特征与字粒度特征
+  - paddlepaddle >= 2.0.0
 
-**参数**
+  - paddlehub >= 2.0.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
 
-* `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
+- ### 2、安装
 
-**返回**
+  - ```shell
+    $ hub install chinese-electra-base==2.0.2
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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)
 
-* `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
 
+## 三、模型API预测  
 
-**代码示例**
+- ### 1、预测代码示例
 
 ```python
 import paddlehub as hub
@@ -96,59 +62,110 @@ for idx, text in enumerate(data):
 ```
 
 详情可参考PaddleHub示例：
-- [文本分类](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/text_classification)
-- [序列标注](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/sequence_labeling)
+- [文本分类](../../../../demo/text_classification)
+- [序列标注](../../../../demo/sequence_labeling)
 
-## 服务部署
+- ### 2、API
+  - ```python
+    def __init__(
+        task=None,
+        load_checkpoint=None,
+        label_map=None,
+        num_classes=2,
+        suffix=False,
+        **kwargs,
+    )
+    ```
 
-PaddleHub Serving可以部署一个在线获取预训练词向量。
+    - 创建Module对象（动态图组网版本）。
 
-### Step1: 启动PaddleHub Serving
+    - **参数**
 
-运行启动命令：
+      - `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
+      - `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
+      - `label_map`：预测时的类别映射表。
+      - `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
+      - `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
+      - `**kwargs`：用户额外指定的关键字字典类型的参数。
 
-```shell
-$ hub serving start -m chinese-electra-base
-```
+  - ```python
+    def predict(
+        data,
+        max_seq_len=128,
+        batch_size=1,
+        use_gpu=False
+    )
+    ```
 
-这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+    - **参数**
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+      - `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
+      - `max_seq_len`：模型处理文本的最大长度
+      - `batch_size`：模型批处理大小
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
-### Step2: 发送预测请求
+    - **返回**
 
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+    - `results`：list类型，不同任务类型的返回结果如下
+      - 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+      - 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
 
-```python
-import requests
-import json
-
-# 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
-text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
-# 以key的方式指定text传入预测方法的时的参数，此例中为"data"
-# 对应本地部署，则为module.get_embedding(data=text)
-data = {"data": text}
-# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
-url = "http://127.0.0.1:8866/predict/chinese-electra-base"
-# 指定post请求的headers为application/json方式
-headers = {"Content-Type": "application/json"}
-
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-print(r.json())
-```
+  - ```python
+    def get_embedding(
+        data,
+        use_gpu=False
+    )
+    ```
+
+    - 用于获取输入文本的句子粒度特征与字粒度特征
+
+    - **参数**
 
-##   查看代码
+      - `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
-https://github.com/ymcui/Chinese-ELECTRA
+    - **返回**
 
+      - `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
 
-## 依赖
 
-paddlepaddle >= 2.0.0
+## 四、服务部署
 
-paddlehub >= 2.0.0
+- PaddleHub Serving可以部署一个在线获取预训练词向量。
 
-## 更新历史
+- ### 第一步：启动PaddleHub Serving
+
+  - ```shell
+    $ hub serving start -m chinese-electra-base
+    ```
+
+  - 这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+
+  - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+- ### 第二步：发送预测请求
+
+  - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+  - ```python
+    import requests
+    import json
+
+    # 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
+    text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
+    # 以key的方式指定text传入预测方法的时的参数，此例中为"data"
+    # 对应本地部署，则为module.get_embedding(data=text)
+    data = {"data": text}
+    # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
+    url = "http://127.0.0.1:8866/predict/chinese-electra-base"
+    # 指定post请求的headers为application/json方式
+    headers = {"Content-Type": "application/json"}
+
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+    print(r.json())
+    ```
+
+## 五、更新历史
 
 * 1.0.0
 
@@ -161,3 +178,7 @@ paddlehub >= 2.0.0
 * 2.0.1
 
   增加文本匹配任务`text-matching`
+
+* 2.0.2
+
+  修复词嵌入模型预测的问题

modules/text/language_model/chinese_electra_base/module.py

@@ -28,7 +28,7 @@ from paddlehub.utils.log import logger
 
 @moduleinfo(
     name="chinese-electra-base",
-    version="2.0.1",
+    version="2.0.2",
     summary=
     "chinese-electra-base, 12-layer, 768-hidden, 12-heads, 102M parameters. The module is executed as paddle.dygraph.",
     author="ymcui",
@@ -163,8 +163,7 @@ class Electra(nn.Layer):
                 return probs, loss, {'acc': acc}
             return probs
         else:
-            sequence_output, pooled_output = result
-            return sequence_output, pooled_output
+            return result
 
     @staticmethod
     def get_tokenizer(*args, **kwargs):

modules/text/language_model/chinese_electra_small/README.md

-```shell
-$ hub install chinese-electra-small==2.0.1
-```
+# chinese-electra-small
+|模型名称|chinese-electra-small|
+| :--- | :---: |
+|类别|文本-语义模型|
+|网络|ELECTRA|
+|数据集|中文维基+通用数据|
+|是否支持Fine-tuning|是|
+|模型大小|47MB|
+|最新更新日期|2022-02-08|
+|数据指标|-|
+
+
+## 一、模型基本信息
 
+- ### 模型介绍
 <p align="center">
 <img src="http://bj.bcebos.com/ibox-thumbnail98/1a5578bfbe1ad629035f7ad1eb3d0bce?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-03-31T06%3A45%3A51Z%2F1800%2F%2F02b8749292f8ba1c606410d0e4e5dbabdf1d367d80da395887775d36424ac13e"  hspace='10'/> <br />
 </p>
 
 更多详情请参考[ELECTRA论文](https://openreview.net/pdf?id=r1xMH1BtvB)
 
-## API
-```python
-def __init__(
-        task=None,
-        load_checkpoint=None,
-        label_map=None,
-        num_classes=2,
-        suffix=False,
-        **kwargs,
-)
-```
-
-创建Module对象（动态图组网版本）。
-
-**参数**
-
-* `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
-* `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
-* `label_map`：预测时的类别映射表。
-* `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
-* `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
-* `**kwargs`：用户额外指定的关键字字典类型的参数。
-
-```python
-def predict(
-    data,
-    max_seq_len=128,
-    batch_size=1,
-    use_gpu=False
-)
-```
-
-**参数**
-
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
-* `max_seq_len`：模型处理文本的最大长度
-* `batch_size`：模型批处理大小
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
-
-**返回**
-
-* `results`：list类型，不同任务类型的返回结果如下
-  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
-  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
-
-```python
-def get_embedding(
-    data,
-    use_gpu=False
-)
-```
-
-用于获取输入文本的句子粒度特征与字粒度特征
+## 二、安装
+- ### 1、环境依赖
 
-**参数**
+  - paddlepaddle >= 2.0.0
 
-* `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
+  - paddlehub >= 2.0.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
 
-**返回**
+- ### 2、安装
 
-* `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
+  - ```shell
+    $ hub install chinese-electra-small==2.0.2
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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
@@ -96,59 +60,109 @@ for idx, text in enumerate(data):
 ```
 
 详情可参考PaddleHub示例：
-- [文本分类](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/text_classification)
-- [序列标注](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/sequence_labeling)
+- [文本分类](../../../../demo/text_classification)
+- [序列标注](../../../../demo/sequence_labeling)
+
+- ### 2、API
+  - ```python
+    def __init__(
+        task=None,
+        load_checkpoint=None,
+        label_map=None,
+        num_classes=2,
+        suffix=False,
+        **kwargs,
+    )
+    ```
 
-## 服务部署
+    - 创建Module对象（动态图组网版本）。
 
-PaddleHub Serving可以部署一个在线获取预训练词向量。
+    - **参数**
 
-### Step1: 启动PaddleHub Serving
+      - `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
+      - `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
+      - `label_map`：预测时的类别映射表。
+      - `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
+      - `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
+      - `**kwargs`：用户额外指定的关键字字典类型的参数。
 
-运行启动命令：
+  - ```python
+    def predict(
+        data,
+        max_seq_len=128,
+        batch_size=1,
+        use_gpu=False
+    )
+    ```
 
-```shell
-$ hub serving start -m chinese-electra-small
-```
+    - **参数**
 
-这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+      - `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
+      - `max_seq_len`：模型处理文本的最大长度
+      - `batch_size`：模型批处理大小
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - **返回**
 
-### Step2: 发送预测请求
+      - `results`：list类型，不同任务类型的返回结果如下
+        - 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+        - 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
 
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+  - ```python
+    def get_embedding(
+        data,
+        use_gpu=False
+    )
+    ```
 
-```python
-import requests
-import json
-
-# 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
-text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
-# 以key的方式指定text传入预测方法的时的参数，此例中为"data"
-# 对应本地部署，则为module.get_embedding(data=text)
-data = {"data": text}
-# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
-url = "http://127.0.0.1:8866/predict/chinese-electra-small"
-# 指定post请求的headers为application/json方式
-headers = {"Content-Type": "application/json"}
-
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-print(r.json())
-```
+    - 用于获取输入文本的句子粒度特征与字粒度特征
 
-##   查看代码
+    - **参数**
 
-https://github.com/ymcui/Chinese-ELECTRA
+      - `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
+    - **返回**
 
-## 依赖
+      -  `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
 
-paddlepaddle >= 2.0.0
+## 四、服务部署
 
-paddlehub >= 2.0.0
+- PaddleHub Serving可以部署一个在线获取预训练词向量。
 
-## 更新历史
+- ### 第一步：启动PaddleHub Serving
+
+  - ```shell
+    $ hub serving start -m chinese-electra-small
+    ```
+
+  - 这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+
+  - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+- ### 第二步：发送预测请求
+
+  - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+  - ```python
+    import requests
+    import json
+
+    # 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
+    text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
+    # 以key的方式指定text传入预测方法的时的参数，此例中为"data"
+    # 对应本地部署，则为module.get_embedding(data=text)
+    data = {"data": text}
+    # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
+    url = "http://127.0.0.1:8866/predict/chinese-electra-small"
+    # 指定post请求的headers为application/json方式
+    headers = {"Content-Type": "application/json"}
+
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+    print(r.json())
+    ```
+
+## 五、更新历史
 
 * 1.0.0
 
@@ -161,3 +175,7 @@ paddlehub >= 2.0.0
 * 2.0.1
 
   增加文本匹配任务`text-matching`
+
+* 2.0.2
+
+  修复词嵌入模型预测的问题

modules/text/language_model/chinese_electra_small/module.py

@@ -28,7 +28,7 @@ from paddlehub.utils.log import logger
 
 @moduleinfo(
     name="chinese-electra-small",
-    version="2.0.1",
+    version="2.0.2",
     summary=
     "chinese-electra-small, 12-layer, 256-hidden, 4-heads, 12M parameters. The module is executed as paddle.dygraph.",
     author="ymcui",
@@ -163,8 +163,7 @@ class Electra(nn.Layer):
                 return probs, loss, {'acc': acc}
             return probs
         else:
-            sequence_output, pooled_output = result
-            return sequence_output, pooled_output
+            return result
 
     @staticmethod
     def get_tokenizer(*args, **kwargs):

modules/text/language_model/electra_base/README.md

-```shell
-$ hub install electra-base==1.0.1
-```
+# electra-base
+|模型名称|electra-base|
+| :--- | :---: |
+|类别|文本-语义模型|
+|网络|ELECTRA|
+|数据集|英文维基百科|
+|是否支持Fine-tuning|是|
+|模型大小|630MB|
+|最新更新日期|2022-02-08|
+|数据指标|-|
+
+## 一、模型基本信息
+
+- ### 模型介绍
 
 <p align="center">
 <img src="http://bj.bcebos.com/ibox-thumbnail98/1a5578bfbe1ad629035f7ad1eb3d0bce?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-03-31T06%3A45%3A51Z%2F1800%2F%2F02b8749292f8ba1c606410d0e4e5dbabdf1d367d80da395887775d36424ac13e"  hspace='10'/> <br />
@@ -8,71 +19,25 @@ $ hub install electra-base==1.0.1
 
 更多详情请参考[ELECTRA论文](https://openreview.net/pdf?id=r1xMH1BtvB)
 
-## API
-```python
-def __init__(
-        task=None,
-        load_checkpoint=None,
-        label_map=None,
-        num_classes=2,
-        suffix=False,
-        **kwargs,
-)
-```
-
-创建Module对象（动态图组网版本）。
-
-**参数**
-
-* `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
-* `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
-* `label_map`：预测时的类别映射表。
-* `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
-* `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
-* `**kwargs`：用户额外指定的关键字字典类型的参数。
-
-```python
-def predict(
-    data,
-    max_seq_len=128,
-    batch_size=1,
-    use_gpu=False
-)
-```
-
-**参数**
-
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
-* `max_seq_len`：模型处理文本的最大长度
-* `batch_size`：模型批处理大小
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
-
-**返回**
-
-* `results`：list类型，不同任务类型的返回结果如下
-  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
-  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
-
-```python
-def get_embedding(
-    data,
-    use_gpu=False
-)
-```
+## 二、安装
 
-用于获取输入文本的句子粒度特征与字粒度特征
+- ### 1、环境依赖
 
-**参数**
+  - paddlepaddle >= 2.0.0
 
-* `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
+  - paddlehub >= 2.0.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
 
-**返回**
+- ### 2、安装
 
-* `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
+  - ```shell
+  $ hub install electra-base==1.0.2
+  ```
+  - 如您安装时遇到问题，可参考：[零基础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
@@ -99,56 +64,108 @@ for idx, text in enumerate(data):
 - [文本分类](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/text_classification)
 - [序列标注](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/sequence_labeling)
 
-## 服务部署
+- ### 2、API
+  - ```python
+    def __init__(
+            task=None,
+            load_checkpoint=None,
+            label_map=None,
+            num_classes=2,
+            suffix=False,
+            **kwargs,
+    )
+    ```
 
-PaddleHub Serving可以部署一个在线获取预训练词向量。
+    - 创建Module对象（动态图组网版本）。
 
-### Step1: 启动PaddleHub Serving
+    - **参数**
 
-运行启动命令：
+      - `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
+      - `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
+      - `label_map`：预测时的类别映射表。
+      - `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
+      - `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
+      *- `**kwargs`：用户额外指定的关键字字典类型的参数。
 
-```shell
-$ hub serving start -m electra-base
-```
+  - ```python
+    def predict(
+        data,
+        max_seq_len=128,
+        batch_size=1,
+        use_gpu=False
+    )
+    ```
 
-这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+    - **参数**
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+      - `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
+      - `max_seq_len`：模型处理文本的最大长度
+      - `batch_size`：模型批处理大小
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
-### Step2: 发送预测请求
+    - **返回**
 
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+      - `results`：list类型，不同任务类型的返回结果如下
+        - 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+        - 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
+  - ```python
+    def get_embedding(
+        data,
+        use_gpu=False
+    )
+    ```
+
+    - 用于获取输入文本的句子粒度特征与字粒度特征
+
+    - **参数**
+
+      - `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
+
+    - **返回**
+
+      - `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
 
-```python
-import requests
-import json
-
-# 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
-text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
-# 以key的方式指定text传入预测方法的时的参数，此例中为"data"
-# 对应本地部署，则为module.get_embedding(data=text)
-data = {"data": text}
-# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
-url = "http://127.0.0.1:8866/predict/electra-base"
-# 指定post请求的headers为application/json方式
-headers = {"Content-Type": "application/json"}
-
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-print(r.json())
-```
 
-##   查看代码
+## 四、服务部署
 
-https://github.com/google-research/electra
+- PaddleHub Serving可以部署一个在线获取预训练词向量。
 
+- ### 第一步：启动PaddleHub Serving
 
-## 依赖
+  - ```shell
+    $ hub serving start -m electra-base
+    ```
 
-paddlepaddle >= 2.0.0
+  - 这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
 
-paddlehub >= 2.0.0
+  - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
 
-## 更新历史
+- ### 第二步：发送预测请求
+
+  - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+  - ```python
+    import requests
+    import json
+
+    # 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
+    text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
+    # 以key的方式指定text传入预测方法的时的参数，此例中为"data"
+    # 对应本地部署，则为module.get_embedding(data=text)
+    data = {"data": text}
+    # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
+    url = "http://127.0.0.1:8866/predict/electra-base"
+    # 指定post请求的headers为application/json方式
+    headers = {"Content-Type": "application/json"}
+
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+    print(r.json())
+    ```
+
+
+## 五、更新历史
 
 * 1.0.0
 
@@ -157,3 +174,7 @@ paddlehub >= 2.0.0
 * 1.0.1
 
   增加文本匹配任务`text-matching`
+
+* 1.0.2
+
+  修复词嵌入模型预测的问题

modules/text/language_model/electra_base/module.py

@@ -28,7 +28,7 @@ from paddlehub.utils.log import logger
 
 @moduleinfo(
     name="electra-base",
-    version="1.0.1",
+    version="1.0.2",
     summary="electra-base, 12-layer, 768-hidden, 12-heads, 110M parameters. The module is executed as paddle.dygraph.",
     author="paddlepaddle",
     author_email="",
@@ -162,8 +162,7 @@ class Electra(nn.Layer):
                 return probs, loss, {'acc': acc}
             return probs
         else:
-            sequence_output, pooled_output = result
-            return sequence_output, pooled_output
+            return result
 
     @staticmethod
     def get_tokenizer(*args, **kwargs):

modules/text/language_model/electra_large/README.md

-```shell
-$ hub install electra-large==1.0.1
-```
+# electra-large
+|模型名称|electra-large|
+| :--- | :---: |
+|类别|文本-语义模型|
+|网络|ELECTRA|
+|数据集|英文维基百科|
+|是否支持Fine-tuning|是|
+|模型大小|1.9GB|
+|最新更新日期|2022-02-08|
+|数据指标|-|
+
+## 一、模型基本信息
+
+- ### 模型介绍
 
 <p align="center">
 <img src="http://bj.bcebos.com/ibox-thumbnail98/1a5578bfbe1ad629035f7ad1eb3d0bce?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-03-31T06%3A45%3A51Z%2F1800%2F%2F02b8749292f8ba1c606410d0e4e5dbabdf1d367d80da395887775d36424ac13e"  hspace='10'/> <br />
@@ -8,72 +19,25 @@ $ hub install electra-large==1.0.1
 
 更多详情请参考[ELECTRA论文](https://openreview.net/pdf?id=r1xMH1BtvB)
 
-## API
-```python
-def __init__(
-        task=None,
-        load_checkpoint=None,
-        label_map=None,
-        num_classes=2,
-        suffix=False,
-        **kwargs,
-)
-```
-
-创建Module对象（动态图组网版本）。
-
-**参数**
-
-* `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
-* `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
-* `label_map`：预测时的类别映射表。
-* `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
-* `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
-* `**kwargs`：用户额外指定的关键字字典类型的参数。
-
-```python
-def predict(
-    data,
-    max_seq_len=128,
-    batch_size=1,
-    use_gpu=False
-)
-```
-
-**参数**
-
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
-* `max_seq_len`：模型处理文本的最大长度
-* `batch_size`：模型批处理大小
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
-
-**返回**
-
-* `results`：list类型，不同任务类型的返回结果如下
-  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
-  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
-
-```python
-def get_embedding(
-    data,
-    use_gpu=False
-)
-```
-
-用于获取输入文本的句子粒度特征与字粒度特征
-
-**参数**
+## 二、安装
 
-* `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
+- ### 1、环境依赖
+  
+  - paddlepaddle >= 2.0.0
 
-**返回**
+  - paddlehub >= 2.0.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
 
-* `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
+- ### 2、安装
 
+  - ```shell
+    $ hub install electra-large==1.0.2
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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
 
@@ -96,59 +60,110 @@ for idx, text in enumerate(data):
 ```
 
 详情可参考PaddleHub示例：
-- [文本分类](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/text_classification)
-- [序列标注](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/sequence_labeling)
+- [文本分类](../../../../demo/text_classification)
+- [序列标注](../../../../demo/sequence_labeling)
+
+- ### 2、API
+  - ```python
+    def __init__(
+        task=None,
+        load_checkpoint=None,
+        label_map=None,
+        num_classes=2,
+        suffix=False,
+        **kwargs,
+    )
+    ```
 
-## 服务部署
+    - 创建Module对象（动态图组网版本）。
 
-PaddleHub Serving可以部署一个在线获取预训练词向量。
+    - **参数**
 
-### Step1: 启动PaddleHub Serving
+      - `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
+      - `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
+      - `label_map`：预测时的类别映射表。
+      - `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
+      - `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
+      - `**kwargs`：用户额外指定的关键字字典类型的参数。
 
-运行启动命令：
+  - ```python
+    def predict(
+        data,
+        max_seq_len=128,
+        batch_size=1,
+        use_gpu=False
+    )
+    ```
 
-```shell
-$ hub serving start -m electra-large
-```
+    - **参数**
 
-这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+      - `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
+      - `max_seq_len`：模型处理文本的最大长度
+      - `batch_size`：模型批处理大小
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - **返回**
 
-### Step2: 发送预测请求
+      - `results`：list类型，不同任务类型的返回结果如下
+        - 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+        - 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
 
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+  - ```python
+    def get_embedding(
+        data,
+        use_gpu=False
+    )
+    ```
 
-```python
-import requests
-import json
-
-# 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
-text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
-# 以key的方式指定text传入预测方法的时的参数，此例中为"data"
-# 对应本地部署，则为module.get_embedding(data=text)
-data = {"data": text}
-# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
-url = "http://127.0.0.1:8866/predict/electra-large"
-# 指定post请求的headers为application/json方式
-headers = {"Content-Type": "application/json"}
-
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-print(r.json())
-```
+    - 用于获取输入文本的句子粒度特征与字粒度特征
 
-##   查看代码
+    - **参数**
 
-https://github.com/google-research/electra
+      - `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
+    - **返回**
 
-## 依赖
+      - `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
 
-paddlepaddle >= 2.0.0
 
-paddlehub >= 2.0.0
+## 四、服务部署
 
-## 更新历史
+- PaddleHub Serving可以部署一个在线获取预训练词向量。
+
+- ### 第一步：启动PaddleHub Serving
+
+  - ```shell
+    $ hub serving start -m electra-large
+    ```
+
+  - 这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+
+  - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+- ### 第二步：发送预测请求
+
+  - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+  - ```python
+    import requests
+    import json
+
+    # 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
+    text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
+    # 以key的方式指定text传入预测方法的时的参数，此例中为"data"
+    # 对应本地部署，则为module.get_embedding(data=text)
+    data = {"data": text}
+    # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
+    url = "http://127.0.0.1:8866/predict/electra-large"
+    # 指定post请求的headers为application/json方式
+    headers = {"Content-Type": "application/json"}
+
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+    print(r.json())
+    ```
+
+## 五、更新历史
 
 * 1.0.0
 
@@ -157,3 +172,7 @@ paddlehub >= 2.0.0
 * 1.0.1
 
   增加文本匹配任务`text-matching`
+
+* 1.0.2
+
+  修复词嵌入模型预测的问题

modules/text/language_model/electra_large/module.py

@@ -28,7 +28,7 @@ from paddlehub.utils.log import logger
 
 @moduleinfo(
     name="electra-large",
-    version="1.0.1",
+    version="1.0.2",
     summary="electra-large, 24-layer, 1024-hidden, 16-heads, 335M parameters. The module is executed as paddle.dygraph.",
     author="paddlepaddle",
     author_email="",
@@ -162,8 +162,7 @@ class Electra(nn.Layer):
                 return probs, loss, {'acc': acc}
             return probs
         else:
-            sequence_output, pooled_output = result
-            return sequence_output, pooled_output
+            return result
 
     @staticmethod
     def get_tokenizer(*args, **kwargs):

modules/text/language_model/electra_small/README.md

-```shell
-$ hub install electra-small==1.0.1
-```
-
+# electra-small
+|模型名称|electra-small|
+| :--- | :---: |
+|类别|文本-语义模型|
+|网络|ELECTRA|
+|数据集|英文维基百科|
+|是否支持Fine-tuning|是|
+|模型大小|78MB|
+|最新更新日期|2022-02-08|
+|数据指标|-|
+
+## 一、模型基本信息
+
+- ### 模型介绍
 <p align="center">
 <img src="http://bj.bcebos.com/ibox-thumbnail98/1a5578bfbe1ad629035f7ad1eb3d0bce?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-03-31T06%3A45%3A51Z%2F1800%2F%2F02b8749292f8ba1c606410d0e4e5dbabdf1d367d80da395887775d36424ac13e"  hspace='10'/> <br />
 </p>
 
 更多详情请参考[ELECTRA论文](https://openreview.net/pdf?id=r1xMH1BtvB)
 
-## API
-```python
-def __init__(
-        task=None,
-        load_checkpoint=None,
-        label_map=None,
-        num_classes=2,
-        suffix=False,
-        **kwargs,
-)
-```
-
-创建Module对象（动态图组网版本）。
+## 二、安装
 
-**参数**
+- ### 1、环境依赖
 
-* `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
-* `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
-* `label_map`：预测时的类别映射表。
-* `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
-* `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
-* `**kwargs`：用户额外指定的关键字字典类型的参数。
+  - paddlepaddle >= 2.0.0
 
-```python
-def predict(
-    data,
-    max_seq_len=128,
-    batch_size=1,
-    use_gpu=False
-)
-```
+  - paddlehub >= 2.0.0    | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
 
-**参数**
+- ### 2、安装
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
-* `max_seq_len`：模型处理文本的最大长度
-* `batch_size`：模型批处理大小
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
+  - ```shell
+    $ hub install electra-small==1.0.2
+    ```
+  - 如您安装时遇到问题，可参考：[零基础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预测
 
-* `results`：list类型，不同任务类型的返回结果如下
-  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
-  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
-
-```python
-def get_embedding(
-    data,
-    use_gpu=False
-)
-```
-
-用于获取输入文本的句子粒度特征与字粒度特征
-
-**参数**
-
-* `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
-
-**返回**
-
-* `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
-
-
-**代码示例**
+- ### 1、预测代码示例
 
 ```python
 import paddlehub as hub
@@ -96,60 +60,109 @@ for idx, text in enumerate(data):
 ```
 
 详情可参考PaddleHub示例：
-- [文本分类](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/text_classification)
-- [序列标注](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/sequence_labeling)
+- [文本分类](../../../../demo/text_classification)
+- [序列标注](../../../../demo/sequence_labeling)
 
-## 服务部署
+- ### 2、API
 
-PaddleHub Serving可以部署一个在线获取预训练词向量。
+  - ```python
+    def __init__(
+        task=None,
+        load_checkpoint=None,
+        label_map=None,
+        num_classes=2,
+        suffix=False,
+        **kwargs,
+    )
+    ```
 
-### Step1: 启动PaddleHub Serving
+    - 创建Module对象（动态图组网版本）。
 
-运行启动命令：
+    - **参数**
 
-```shell
-$ hub serving start -m electra-small
-```
+      - `task`： 任务名称，可为`seq-cls`(文本分类任务，原来的`sequence_classification`在未来会被弃用)或`token-cls`(序列标注任务)。
+      - `load_checkpoint`：使用PaddleHub Fine-tune api训练保存的模型参数文件路径。
+      - `label_map`：预测时的类别映射表。
+      - `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
+      - `suffix`: 序列标注任务的标签格式，如果设定为`True`，标签以'-B', '-I', '-E' 或者 '-S'为结尾，此参数默认为`False`。
+      - `**kwargs`：用户额外指定的关键字字典类型的参数。
 
-这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+  - ```python
+    def predict(
+        data,
+        max_seq_len=128,
+        batch_size=1,
+        use_gpu=False
+    )
+    ```
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - **参数**
 
-### Step2: 发送预测请求
+      - `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者2个）需和训练时保持一致。
+      - `max_seq_len`：模型处理文本的最大长度
+      - `batch_size`：模型批处理大小
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+    - **返回**
 
-```python
-import requests
-import json
-
-# 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
-text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
-# 以key的方式指定text传入预测方法的时的参数，此例中为"data"
-# 对应本地部署，则为module.get_embedding(data=text)
-data = {"data": text}
-# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
-url = "http://127.0.0.1:8866/predict/electra-small"
-# 指定post请求的headers为application/json方式
-headers = {"Content-Type": "application/json"}
-
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-print(r.json())
-```
+      - `results`：list类型，不同任务类型的返回结果如下
+        - 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+        - 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
+  - ```python
+    def get_embedding(
+        data,
+        use_gpu=False
+    )
+    ```
 
-##   查看代码
+    - 用于获取输入文本的句子粒度特征与字粒度特征
 
-https://github.com/google-research/electra
+    - **参数**
 
+      - `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
+      - `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
-## 依赖
+    - **返回**
 
-paddlepaddle >= 2.0.0
+      - `results`：list类型，格式为\[\[sample\_a\_pooled\_feature, sample\_a\_seq\_feature\], \[sample\_b\_pooled\_feature, sample\_b\_seq\_feature\],…,\]，其中每个元素都是对应样例的特征输出，每个样例都有句子粒度特征pooled\_feature与字粒度特征seq\_feature。
 
-paddlehub >= 2.0.0
+## 四、服务部署
 
-## 更新历史
+- PaddleHub Serving可以部署一个在线获取预训练词向量。
 
+- ### 第一步：启动PaddleHub Serving
+
+  - ```shell
+  $ hub serving start -m electra-small
+  ```
+  - 这样就完成了一个获取预训练词向量服务化API的部署，默认端口号为8866。
+
+  - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+- ### 第二步：发送预测请求
+
+  - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+  - ```python
+    import requests
+    import json
+
+    # 指定用于获取embedding的文本[[text_1], [text_2], ... ]}
+    text = [["今天是个好日子"], ["天气预报说今天要下雨"]]
+    # 以key的方式指定text传入预测方法的时的参数，此例中为"data"
+    # 对应本地部署，则为module.get_embedding(data=text)
+    data = {"data": text}
+    # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
+    url = "http://127.0.0.1:8866/predict/electra-small"
+    # 指定post请求的headers为application/json方式
+    headers = {"Content-Type": "application/json"}
+
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+    print(r.json())
+    ```
+
+## 五、更新历史
 * 1.0.0
 
   初始发布，动态图版本模型，支持文本分类`seq-cls`和序列标注`token-cls`任务的fine-tune
@@ -157,3 +170,7 @@ paddlehub >= 2.0.0
 * 1.0.1
 
   增加文本匹配任务`text-matching`
+
+* 1.0.2
+
+  修复词嵌入模型预测的问题

modules/text/language_model/electra_small/module.py

@@ -28,7 +28,7 @@ from paddlehub.utils.log import logger
 
 @moduleinfo(
     name="electra-small",
-    version="1.0.1",
+    version="1.0.2",
     summary="electra-small, 12-layer, 256-hidden, 4-heads, 14M parameters. The module is executed as paddle.dygraph.",
     author="paddlepaddle",
     author_email="",
@@ -162,8 +162,7 @@ class Electra(nn.Layer):
                 return probs, loss, {'acc': acc}
             return probs
         else:
-            sequence_output, pooled_output = result
-            return sequence_output, pooled_output
+            return result
 
     @staticmethod
     def get_tokenizer(*args, **kwargs):

paddlehub/module/nlp_module.py

@@ -607,10 +607,14 @@ class TransformerModule(RunModule, TextServing):
                     # token labels
                     labels = [[self.label_map[i] for i in token_ids] for token_ids in batch_ids]
                 elif self.task == None:
-                    sequence_output, pooled_output = self(input_ids, segment_ids)
-                    results.append(
-                        [pooled_output.squeeze(0).numpy().tolist(),
-                         sequence_output.squeeze(0).numpy().tolist()])
+                    output = self(input_ids, segment_ids)
+                    if len(output) == 1:
+                        results.append(output.squeeze(0).numpy().tolist())
+                    else:
+                        sequence_output, pooled_output = output
+                        results.append(
+                            [pooled_output.squeeze(0).numpy().tolist(),
+                             sequence_output.squeeze(0).numpy().tolist()])
             if self.task:
                 # save probs only when return prob
                 if return_prob: