diff --git a/demo/sequence_labeling/README.md b/demo/sequence_labeling/README.md
index 04c3450a544caa4107e2bd635e79dff6c55b266a..5c8be25321dab809b0ebedd3f8dce6e0c5da6554 100644
--- a/demo/sequence_labeling/README.md
+++ b/demo/sequence_labeling/README.md
@@ -32,7 +32,7 @@ python train.py
 在命名实体识别的任务中，因不同的数据集标识实体的标签不同，评测的方式也有所差异。因此，在初始化模型的之前，需要先确定实际标签的形式，下方的`label_list`则是MSRA-NER数据集中使用的标签类别。  
 如果用户使用的实体识别的数据集的标签方式与MSRA-NER不同，则需要自行根据数据集确定。
 ```python
-label_list = ["B-PER", "I-PER", "B-ORG", "I-ORG", "B-LOC", "I-LOC", "O"]
+label_list = hub.datasets.MSRA_NER.label_list
 label_map = {
     idx: label for idx, label in enumerate(label_list)
 }
@@ -50,6 +50,7 @@ model = hub.Module(name='ernie_tiny', version='2.0.1', task='token-cls', label_m
 * `name`：模型名称，可以选择`ernie`，`ernie_tiny`，`bert-base-cased`， `bert-base-chinese`, `roberta-wwm-ext`，`roberta-wwm-ext-large`等。
 * `version`：module版本号
 * `task`：fine-tune任务。此处为`token-cls`，表示序列标注任务。
+* `label_map`：数据集中的标签信息，实体识别任务中需要根据不同标签种类对模型性能进行评价。
 
 PaddleHub还提供BERT等模型可供选择, 当前支持序列标注任务的模型对应的加载示例如下：
 
diff --git a/demo/sequence_labeling/train.py b/demo/sequence_labeling/train.py
index 3e26d20b835b2413fc4758bfbe250e1f916f2dcd..b9acbf0a9c3a38eeb618d11a4c7189e8a6ae71e5 100644
--- a/demo/sequence_labeling/train.py
+++ b/demo/sequence_labeling/train.py
@@ -32,7 +32,7 @@ args = parser.parse_args()
 
 
 if __name__ == '__main__':
-    label_list = ["B-PER", "I-PER", "B-ORG", "I-ORG", "B-LOC", "I-LOC", "O"]
+    label_list = MSRA_NER.label_list
     label_map = {
         idx: label for idx, label in enumerate(label_list)
     }
diff --git a/demo/text_classification/README.md b/demo/text_classification/README.md
index d624cd49083c4bf83748184e95d4932582a7927d..70113ccd72026b3715c738b0ae88c5640a229398 100644
--- a/demo/text_classification/README.md
+++ b/demo/text_classification/README.md
@@ -31,7 +31,7 @@ python train.py
 ```python
 import paddlehub as hub
 
-model = hub.Module(name='ernie_tiny', version='2.0.1', task='seq-cls')
+model = hub.Module(name='ernie_tiny', version='2.0.1', task='seq-cls', num_classes=2)
 ```
 
 其中，参数：
@@ -39,6 +39,29 @@ model = hub.Module(name='ernie_tiny', version='2.0.1', task='seq-cls')
 * `name`：模型名称，可以选择`ernie`，`ernie_tiny`，`bert-base-cased`， `bert-base-chinese`, `roberta-wwm-ext`，`roberta-wwm-ext-large`等。
 * `version`：module版本号
 * `task`：fine-tune任务。此处为`seq-cls`，表示文本分类任务。
+* `num_classes`：表示当前文本分类任务的类别数，根据具体使用的数据集确定，默认为2。
+
+PaddleHub还提供BERT等模型可供选择, 当前支持文本分类任务的模型对应的加载示例如下：
+
+模型名                           | PaddleHub Module
+---------------------------------- | :------:
+ERNIE, Chinese                     | `hub.Module(name='ernie')`
+ERNIE tiny, Chinese                | `hub.Module(name='ernie_tiny')`
+ERNIE 2.0 Base, English            | `hub.Module(name='ernie_v2_eng_base')`
+ERNIE 2.0 Large, English           | `hub.Module(name='ernie_v2_eng_large')`
+BERT-Base, Cased                   | `hub.Module(name='bert-base-cased')`
+BERT-Base, Uncased                 | `hub.Module(name='bert-base-uncased')`
+BERT-Large, Cased                  | `hub.Module(name='bert-large-cased')`
+BERT-Large, Uncased                | `hub.Module(name='bert-large-uncased')`
+BERT-Base, Multilingual Cased      | `hub.Module(nane='bert-base-multilingual-cased')`
+BERT-Base, Multilingual Uncased    | `hub.Module(nane='bert-base-multilingual-uncased')`
+BERT-Base, Chinese                 | `hub.Module(name='bert-base-chinese')`
+BERT-wwm, Chinese                  | `hub.Module(name='chinese-bert-wwm')`
+BERT-wwm-ext, Chinese              | `hub.Module(name='chinese-bert-wwm-ext')`
+RoBERTa-wwm-ext, Chinese           | `hub.Module(name='roberta-wwm-ext')`
+RoBERTa-wwm-ext-large, Chinese     | `hub.Module(name='roberta-wwm-ext-large')`
+RBT3, Chinese                      | `hub.Module(name='rbt3')`
+RBTL3, Chinese                     | `hub.Module(name='rbtl3')`
 
 通过以上的一行代码，`model`初始化为一个适用于文本分类任务的模型，为ERNIE Tiny的预训练模型后拼接上一个全连接网络（Full Connected）。
 ![](https://ai-studio-static-online.cdn.bcebos.com/f9e1bf9d56c6412d939960f2e3767c2f13b93eab30554d738b137ab2b98e328c)
@@ -49,9 +72,9 @@ model = hub.Module(name='ernie_tiny', version='2.0.1', task='seq-cls')
 
 ```python
 train_dataset = hub.datasets.ChnSentiCorp(
-    tokenizer=model.get_tokenizer(tokenize_chinese_chars=True), max_seq_len=128, mode='train')
+    tokenizer=model.get_tokenizer(), max_seq_len=128, mode='train')
 dev_dataset = hub.datasets.ChnSentiCorp(
-    tokenizer=model.get_tokenizer(tokenize_chinese_chars=True), max_seq_len=128, mode='dev')
+    tokenizer=model.get_tokenizer(), max_seq_len=128, mode='dev')
 ```
 
 * `tokenizer`：表示该module所需用到的tokenizer，其将对输入文本完成切词，并转化成module运行所需模型输入格式。
diff --git a/demo/text_classification/train.py b/demo/text_classification/train.py
index 3f1ec858b2adaca50238bec810cc3e75dedad51b..ad4075c3528d9074490d99ec8410ab0912c4531e 100644
--- a/demo/text_classification/train.py
+++ b/demo/text_classification/train.py
@@ -11,21 +11,43 @@
 # 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 paddlehub as hub
+from paddlehub.datasets import ChnSentiCorp
+
+import ast
+import argparse
+
+parser = argparse.ArgumentParser(__doc__)
+parser.add_argument("--num_epoch", type=int, default=3, help="Number of epoches for fine-tuning.")
+parser.add_argument("--use_gpu", type=ast.literal_eval, default=True, help="Whether use GPU for fine-tuning, input should be True or False")
+parser.add_argument("--learning_rate", type=float, default=5e-5, help="Learning rate used to train with warmup.")
+parser.add_argument("--max_seq_len", type=int, default=128, help="Number of words of the longest seqence.")
+parser.add_argument("--batch_size", type=int, default=32, help="Total examples' number in batch for training.")
+parser.add_argument("--checkpoint_dir", type=str, default='./checkpoint', help="Directory to model checkpoint")
+parser.add_argument("--save_interval", type=int, default=1, help="Save checkpoint every n epoch.")
+
+args = parser.parse_args()
 
 if __name__ == '__main__':
     model = hub.Module(name='ernie_tiny', version='2.0.1', task='seq-cls')
 
-    train_dataset = hub.datasets.ChnSentiCorp(
-        tokenizer=model.get_tokenizer(tokenize_chinese_chars=True), max_seq_len=128, mode='train')
-    dev_dataset = hub.datasets.ChnSentiCorp(
-        tokenizer=model.get_tokenizer(tokenize_chinese_chars=True), max_seq_len=128, mode='dev')
-    test_dataset = hub.datasets.ChnSentiCorp(
-        tokenizer=model.get_tokenizer(tokenize_chinese_chars=True), max_seq_len=128, mode='test')
-
-    optimizer = paddle.optimizer.AdamW(learning_rate=5e-5, parameters=model.parameters())
-    trainer = hub.Trainer(model, optimizer, checkpoint_dir='test_ernie_text_cls', use_gpu=True)
+    train_dataset = ChnSentiCorp(
+        tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='train')
+    dev_dataset = ChnSentiCorp(
+        tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='dev')
+    test_dataset = ChnSentiCorp(
+        tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='test')
 
-    trainer.train(train_dataset, epochs=3, batch_size=32, eval_dataset=dev_dataset, save_interval=1)
-    trainer.evaluate(test_dataset, batch_size=32)
+    optimizer = paddle.optimizer.AdamW(
+        learning_rate=args.learning_rate, parameters=model.parameters())
+    trainer = hub.Trainer(model, optimizer, checkpoint_dir=args.checkpoint_dir, use_gpu=args.use_gpu)
+    trainer.train(
+        train_dataset,
+        epochs=args.num_epoch,
+        batch_size=args.batch_size,
+        eval_dataset=dev_dataset,
+        save_interval=args.save_interval,
+    )
+    trainer.evaluate(test_dataset, batch_size=args.batch_size)
diff --git a/docs/docs_ch/tutorial/how_to_load_data.md b/docs/docs_ch/tutorial/how_to_load_data.md
index 7bb10669c2d05f4c7fe8608c050cdfb364c77abc..423825c535e4301137c150ebd4bf6ff064c5400b 100644
--- a/docs/docs_ch/tutorial/how_to_load_data.md
+++ b/docs/docs_ch/tutorial/how_to_load_data.md
@@ -175,3 +175,143 @@ ccolor_set = MiniCOCO(transforms, mode='train')
 ```
 * `transforms`: 数据预处理方式。
 * `mode`: 选择数据模式，可选项有 `train`, `test`, 默认为`train`。
+
+## 四、文本分类数据集
+
+利用PaddleHub进行文本分类任务使用自定义数据时，需要切分数据集，将数据集切分为训练集和测试集。
+
+### 数据准备
+
+#### 1. 设置数据集目录
+
+用户需要将数据集目录设定为如下格式：
+```shell
+├──data: 数据目录
+   ├── train.txt: 训练集数据
+   ├── dev.txt: 验证集数据
+   └── test.txt: 测试集数据
+```
+
+#### 2. 设置文件格式和内容
+
+训练/验证/测试集的数据文件的编码格式建议为utf8格式。内容的第一列是文本类别标签，第二列为文本内容，列与列之间以Tab键分隔。建议在数据集文件第一行填写列说明"label"和"text_a"，中间以Tab键分隔，示例如下：
+```shell
+label    text_a
+房产    昌平京基鹭府10月29日推别墅1200万套起享97折
+教育    贵州2011高考录取分数线发布理科一本448分
+社会    众多白领因集体户口面临结婚难题
+...
+```
+
+### 数据集加载
+
+加载文本分类的自定义数据集，用户仅需要继承基类TextClassificationDataset，修改数据集存放地址以及类别即可，具体可以参考如下代码：
+
+```python
+from paddlehub.datasets.base_nlp_dataset import TextClassificationDataset
+
+class MyDataset(TextClassificationDataset):
+    # 数据集存放目录
+    base_path = '/path/to/dataset'
+    # 数据集的标签列表
+    label_list=['体育', '科技', '社会', '娱乐', '股票', '房产', '教育', '时政', '财经', '星座', '游戏', '家居', '彩票', '时尚']
+    
+    def __init__(self, tokenizer, max_seq_len: int = 128, mode: str = 'train'):
+        if mode == 'train':
+            data_file = 'train.txt'
+        elif mode == 'test':
+            data_file = 'test.txt'
+        else:
+            data_file = 'dev.txt'
+        super().__init__(
+            base_path=self.base_path,
+            tokenizer=tokenizer,
+            max_seq_len=max_seq_len,
+            mode=mode,
+            data_file=data_file,
+            label_list=self.label_list,
+            is_file_with_header=True)
+
+        
+# 选择所需要的模型，获取对应的tokenizer
+import paddlehub as hub
+model = hub.Module(name='ernie_tiny', task='seq-cls', num_classes=len(MyDataset.label_list))
+tokenizer = model.get_tokenizer()
+
+# 实例化训练集
+train_dataset = MyDataset(tokenizer)
+```
+
+至此用户可以通过MyDataset实例化获取对应的数据集，可以通过hub.Trainer对预训练模型`model`完成文本分类任务，详情可参考[PaddleHub文本分类demo](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/text_classification)。
+
+## 五、序列标注数据集
+
+利用PaddleHub进行序列标注任务使用自定义数据时，需要切分数据集，将数据集切分为训练集和测试集。
+
+### 数据准备
+
+#### 1. 设置数据集目录
+
+用户需要将数据集目录设定为如下格式：
+```shell
+├──data: 数据目录
+   ├── train.txt: 训练集数据
+   ├── dev.txt: 验证集数据
+   └── test.txt: 测试集数据
+```
+
+#### 2. 设置文件格式和内容
+
+训练/验证/测试集的数据文件的编码格式建议为utf8格式。内容的第一列是文本内容, 第二列为文本中每个token对应的标签。需要注意的是，在文本和标签中，都需使用分隔符(该例子中使用的是斜杠`/`)隔开不同的token。  
+列与列之间以Tab键分隔。建议在数据集文件第一行填写列说明"label"和"text_a"，中间以Tab键分隔，示例如下：
+```shell
+text_a    label
+5/月/1/2/日/，/北/京/市/怀/柔/县/民/政/局/、/畜/牧/局/领/导/来/到/驻/守/在/偏/远/山/区/的/武/警/北/京/一/总/队/十/支/队/十/四/中/队/。    O/O/O/O/O/O/B-LOC/I-LOC/I-LOC/B-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/O/B-ORG/I-ORG/I-ORG/O/O/O/O/O/O/O/O/O/O/O/O/B-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/O
+他/每/年/还/为/河/北/农/业/大/学/扶/助/多/名/贫/困/学/生/。    O/O/O/O/O/B-ORG/I-ORG/I-ORG/I-ORG/I-ORG/I-ORG/O/O/O/O/O/O/O/O/O
+...
+```
+
+### 数据准备
+
+加载文本分类的自定义数据集，用户仅需要继承基类SeqLabelingDataset，修改数据集存放地址、类别信息和分隔符即可，具体可以参考如下代码：
+
+```python
+from paddlehub.datasets.base_nlp_dataset import SeqLabelingDataset
+
+class MyDataset(SeqLabelingDataset):
+    # 数据集存放目录
+    base_path = '/path/to/dataset'
+    # 数据集的标签列表
+    label_list = ["B-PER", "I-PER", "B-ORG", "I-ORG", "B-LOC", "I-LOC", "O"]
+    label_map = {idx: label for idx, label in enumerate(label_list)}
+    # 数据文件使用的分隔符
+    split_char = '/'
+    
+    def __init__(self, tokenizer, max_seq_len: int = 128, mode: str = 'train'):
+        if mode == 'train':
+            data_file = 'train.txt'
+        elif mode == 'test':
+            data_file = 'test.txt'
+        else:
+            data_file = 'dev.txt'
+        super().__init__(
+                    base_path=self.base_path,
+                    tokenizer=tokenizer,
+                    max_seq_len=max_seq_len,
+                    mode=mode,
+                    data_file=data_file,
+                    label_file=None,
+                    label_list=self.label_list,
+                    split_char=self.split_char,
+                    is_file_with_header=True)
+        
+# 选择所需要的模型，获取对应的tokenizer
+import paddlehub as hub
+model = hub.Module(name='ernie_tiny', task='token-cls', label_map=MyDataset.label_map)
+tokenizer = model.get_tokenizer()
+
+# 实例化训练集
+train_dataset = MyDataset(tokenizer)
+```
+
+至此用户可以通过MyDataset实例化获取对应的数据集，可以通过hub.Trainer对预训练模型`model`完成系列标注任务，详情可参考[PaddleHub序列标注demo](https://github.com/PaddlePaddle/PaddleHub/tree/release/v2.0.0-beta/demo/sequence_labeling)。
\ No newline at end of file
diff --git a/docs/imgs/joinus.PNG b/docs/imgs/joinus.PNG
index a1dba0e83ff9721fbf8b20209650d3eed356944d..721877f8bda6a52c9d5961c0bf6562b135d79859 100644
Binary files a/docs/imgs/joinus.PNG and b/docs/imgs/joinus.PNG differ
diff --git a/modules/text/language_model/bert-base-cased/README.md b/modules/text/language_model/bert-base-cased/README.md
index f75cfd720d63932c00be8dd05764ea3cb5a4bdfa..de01d9689393528bf9a21015a7f8a22933de098a 100644
--- a/modules/text/language_model/bert-base-cased/README.md
+++ b/modules/text/language_model/bert-base-cased/README.md
@@ -41,19 +41,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-    每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -63,8 +64,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/bert-base-chinese/README.md b/modules/text/language_model/bert-base-chinese/README.md
index 3d9d31ded2462c1684ce05c0246a3c26b22d7d74..41a8e0c125993ca53e49bd063bdfaebf314b15ca 100644
--- a/modules/text/language_model/bert-base-chinese/README.md
+++ b/modules/text/language_model/bert-base-chinese/README.md
@@ -29,7 +29,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -41,19 +40,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -63,8 +63,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/bert-base-multilingual-cased/README.md b/modules/text/language_model/bert-base-multilingual-cased/README.md
index a6881ca219d46dff973d656238870caab5b5c7d2..14a2def03909a4c12bb190cb7ae4a438e6f0eb51 100644
--- a/modules/text/language_model/bert-base-multilingual-cased/README.md
+++ b/modules/text/language_model/bert-base-multilingual-cased/README.md
@@ -29,7 +29,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -41,19 +40,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -63,8 +63,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/bert-base-multilingual-uncased/README.md b/modules/text/language_model/bert-base-multilingual-uncased/README.md
index 079b2a2b7f5345bcee61e3ae6c9ed4a4637ace16..3d07c2130a7f3381c63f8f40edadd62e8f0d661d 100644
--- a/modules/text/language_model/bert-base-multilingual-uncased/README.md
+++ b/modules/text/language_model/bert-base-multilingual-uncased/README.md
@@ -29,7 +29,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -41,19 +40,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -63,8 +63,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/bert-base-uncased/README.md b/modules/text/language_model/bert-base-uncased/README.md
index dfb5e8641c9d574cc4c6d0564df583dc3910936b..84867e57c002527ee33a8d821489faa445499244 100644
--- a/modules/text/language_model/bert-base-uncased/README.md
+++ b/modules/text/language_model/bert-base-uncased/README.md
@@ -29,7 +29,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -41,19 +40,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -63,8 +63,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/bert-large-cased/README.md b/modules/text/language_model/bert-large-cased/README.md
index 344d54419d93d77170d4444e312341dd17f3638f..1cd6285fca959172b524336ab2adbf9715982c83 100644
--- a/modules/text/language_model/bert-large-cased/README.md
+++ b/modules/text/language_model/bert-large-cased/README.md
@@ -29,7 +29,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -41,19 +40,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -63,8 +63,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/bert-large-uncased/README.md b/modules/text/language_model/bert-large-uncased/README.md
index e2964f85af34e5158a637f99445c61e326e94e00..1a40ce6a99c668e8531cc6f73c830bd3bfbdd29a 100644
--- a/modules/text/language_model/bert-large-uncased/README.md
+++ b/modules/text/language_model/bert-large-uncased/README.md
@@ -29,7 +29,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -41,19 +40,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -63,8 +63,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/chinese_bert_wwm/README.md b/modules/text/language_model/chinese_bert_wwm/README.md
index 6f0460c536d13e6e6657c3f000011eaab59b4dab..ca1e3aaee1c53bc798e7ef6f511c73e6f67eece4 100644
--- a/modules/text/language_model/chinese_bert_wwm/README.md
+++ b/modules/text/language_model/chinese_bert_wwm/README.md
@@ -27,7 +27,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -39,19 +38,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -61,8 +61,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/chinese_bert_wwm_ext/README.md b/modules/text/language_model/chinese_bert_wwm_ext/README.md
index 03357e3c1f82ad080a4e5845e8040355f555359a..45709dbe03e8ea4f07c89b897485a10514e571ab 100644
--- a/modules/text/language_model/chinese_bert_wwm_ext/README.md
+++ b/modules/text/language_model/chinese_bert_wwm_ext/README.md
@@ -27,7 +27,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -39,19 +38,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -61,8 +61,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/ernie/README.md b/modules/text/language_model/ernie/README.md
index 4ee91755eef6225e77319de6b75b16f6a4b0ae4c..1a42cc99e0f0b07f449105f98a5b5ce41c3a4596 100644
--- a/modules/text/language_model/ernie/README.md
+++ b/modules/text/language_model/ernie/README.md
@@ -50,19 +50,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-    每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -72,8 +73,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/ernie_tiny/README.md b/modules/text/language_model/ernie_tiny/README.md
index f02419a67440718d86deb18eb7720e698f5de9bf..04ace50ced480b26039fd7df1a39cff1e69452f5 100644
--- a/modules/text/language_model/ernie_tiny/README.md
+++ b/modules/text/language_model/ernie_tiny/README.md
@@ -50,19 +50,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-    每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -72,8 +73,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/ernie_v2_eng_base/README.md b/modules/text/language_model/ernie_v2_eng_base/README.md
index d5ece7a9593e09ba19e9b4363d8799f6c1b296f7..3f747302915c7565d2578e8a591967d891361e9d 100644
--- a/modules/text/language_model/ernie_v2_eng_base/README.md
+++ b/modules/text/language_model/ernie_v2_eng_base/README.md
@@ -46,19 +46,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-    每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -68,8 +69,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/ernie_v2_eng_large/README.md b/modules/text/language_model/ernie_v2_eng_large/README.md
index 680bc1be1f1d0db1b684c6d4233852bb2a1be503..08c100f15244c743f4bb5dd0caf883512a548b20 100644
--- a/modules/text/language_model/ernie_v2_eng_large/README.md
+++ b/modules/text/language_model/ernie_v2_eng_large/README.md
@@ -34,7 +34,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -46,19 +45,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -68,8 +68,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/rbt3/README.md b/modules/text/language_model/rbt3/README.md
index baf02dd1e2d9129766609ae75b49e8df9c12459f..0a41ed6d942f999127e9d66c411e9bc9f91314e1 100644
--- a/modules/text/language_model/rbt3/README.md
+++ b/modules/text/language_model/rbt3/README.md
@@ -27,7 +27,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -39,19 +38,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -61,8 +61,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/rbtl3/README.md b/modules/text/language_model/rbtl3/README.md
index f1dd9c433d914cb184b619430965981a7c0ee20b..5cdcdefee7406ca38a07f1fd479db56817b8e060 100644
--- a/modules/text/language_model/rbtl3/README.md
+++ b/modules/text/language_model/rbtl3/README.md
@@ -27,7 +27,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -39,19 +38,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -61,8 +61,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/roberta-wwm-ext-large/README.md b/modules/text/language_model/roberta-wwm-ext-large/README.md
index 4d19bf2b20358054d60fc99a187554204e599226..0b5f46cafb5e8c7f670fd236bad15d5b5d797141 100644
--- a/modules/text/language_model/roberta-wwm-ext-large/README.md
+++ b/modules/text/language_model/roberta-wwm-ext-large/README.md
@@ -28,7 +28,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -40,19 +39,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -62,8 +62,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/modules/text/language_model/roberta-wwm-ext/README.md b/modules/text/language_model/roberta-wwm-ext/README.md
index 9ee71b853c41b4ca668dbc45acb39dd2f4e6fcf0..2eedd7d3e5deffdf5a9d2eacf7c6919136269c84 100644
--- a/modules/text/language_model/roberta-wwm-ext/README.md
+++ b/modules/text/language_model/roberta-wwm-ext/README.md
@@ -28,7 +28,6 @@ def __init__(
 * `label_map`：预测时的类别映射表。
 * `num_classes`：分类任务的类别数，如果指定了`label_map`，此参数可不传，默认2分类。
 * `**kwargs`：用户额外指定的关键字字典类型的参数。
-
 ```python
 def predict(
     data,
@@ -40,19 +39,20 @@ def predict(
 
 **参数**
 
-* `data`： 待预测数据，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，
-  每个样例可以包含text\_a与text\_b。每个样例文本数量（1个或者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。
 
 **返回**
 
+* `results`：list类型，不同任务类型的返回结果如下
+  * 文本分类：列表里包含每个句子的预测标签，格式为\[label\_1, label\_2, …,\]
+  * 序列标注：列表里包含每个句子每个token的预测标签，格式为\[\[token\_1, token\_2, …,\], \[token\_1, token\_2, …,\], …,\]
+
 ```python
 def get_embedding(
     data,
-    max_seq_len=128,
-    batch_size=1,
     use_gpu=False
 )
 ```
@@ -62,8 +62,6 @@ def get_embedding(
 **参数**
 
 * `data`：输入文本列表，格式为\[\[sample\_a\_text\_a, sample\_a\_text\_b\], \[sample\_b\_text\_a, sample\_b\_text\_b\],…,\]，其中每个元素都是一个样例，每个样例可以包含text\_a与text\_b。
-* `max_seq_len`：模型处理文本的最大长度。
-* `batch_size`：模型批处理大小。
 * `use_gpu`：是否使用gpu，默认为False。对于GPU用户，建议开启use_gpu。
 
 **返回**
diff --git a/paddlehub/commands/serving.py b/paddlehub/commands/serving.py
index de9c9c01a6b79c6709f32128cf58587d42d97a9c..72a2e13d99a3a8099604778e127d27da8db99765 100644
--- a/paddlehub/commands/serving.py
+++ b/paddlehub/commands/serving.py
@@ -116,7 +116,10 @@ class ServingCommand:
         if platform.system() == "Windows":
             os.kill(pid, signal.SIGTERM)
         else:
-            os.killpg(pid, signal.SIGTERM)
+            try:
+                os.killpg(pid, signal.SIGTERM)
+            except ProcessLookupError:
+                os.kill(pid, signal.SIGTERM)
 
     @staticmethod
     def start_bert_serving(args):
diff --git a/paddlehub/datasets/msra_ner.py b/paddlehub/datasets/msra_ner.py
index 8440e7c0b2f70e362db37519d57591f68fd45fd9..e258b7414f37f5175c41bf3657003340c27ebaaf 100644
--- a/paddlehub/datasets/msra_ner.py
+++ b/paddlehub/datasets/msra_ner.py
@@ -31,6 +31,7 @@ class MSRA_NER(SeqLabelingDataset):
     for research purposes.  For more information please refer to
     https://www.microsoft.com/en-us/download/details.aspx?id=52531
     """
+    label_list = ["B-PER", "I-PER", "B-ORG", "I-ORG", "B-LOC", "I-LOC", "O"]
 
     def __init__(
             self,
@@ -39,7 +40,6 @@ class MSRA_NER(SeqLabelingDataset):
             mode: str = 'train',
     ):
         base_path = os.path.join(DATA_HOME, "msra_ner")
-        label_list = ["B-PER", "I-PER", "B-ORG", "I-ORG", "B-LOC", "I-LOC", "O"]
 
         if mode == 'train':
             data_file = 'train.tsv'
@@ -54,6 +54,6 @@ class MSRA_NER(SeqLabelingDataset):
             mode=mode,
             data_file=data_file,
             label_file=None,
-            label_list=label_list,
+            label_list=self.label_list,
             is_file_with_header=True,
         )
diff --git a/paddlehub/module/nlp_module.py b/paddlehub/module/nlp_module.py
index ddfd546ceeb7444431bdcbda95d861ee24ed1566..ebebed704c5d6139e626314ac006c26cb5525d19 100644
--- a/paddlehub/module/nlp_module.py
+++ b/paddlehub/module/nlp_module.py
@@ -390,11 +390,8 @@ class TextServing(object):
                 ]
             return results
         elif self.task is None:                 # embedding service
-            token_results, sentence_results = self.get_embedding(data, max_seq_len, batch_size, use_gpu)
-            token_results = [
-                token_embeddings[1:len(data[i][0])+1] for i, token_embeddings in enumerate(token_results)
-            ]
-            return token_results, sentence_results
+            results = self.get_embedding(data, use_gpu)
+            return results
         else:                                   # unknown service
             logger.error(
                 f'Unknown task {self.task}, current tasks supported:\n'
@@ -414,6 +411,17 @@ class TransformerModule(RunModule, TextServing):
         'token-cls',
     ]
 
+    def _convert_text_to_input(self, tokenizer, text: List[str], max_seq_len: int):
+        pad_to_max_seq_len = False if self.task is None else True
+        if len(text) == 1:
+            encoded_inputs = tokenizer.encode(text[0], text_pair=None, max_seq_len=max_seq_len, pad_to_max_seq_len=pad_to_max_seq_len)
+        elif len(text) == 2:
+            encoded_inputs = tokenizer.encode(text[0], text_pair=text[1], max_seq_len=max_seq_len, pad_to_max_seq_len=pad_to_max_seq_len)
+        else:
+            raise RuntimeError(
+                'The input text must have one or two sequence, but got %d. Please check your inputs.' % len(text))
+        return encoded_inputs
+
     def _batchify(self, data: List[List[str]], max_seq_len: int, batch_size: int):
         def _parse_batch(batch):
             input_ids = [entry[0] for entry in batch]
@@ -423,13 +431,7 @@ class TransformerModule(RunModule, TextServing):
         tokenizer = self.get_tokenizer()
         examples = []
         for text in data:
-            if len(text) == 1:
-                encoded_inputs = tokenizer.encode(text[0], text_pair=None, max_seq_len=max_seq_len)
-            elif len(text) == 2:
-                encoded_inputs = tokenizer.encode(text[0], text_pair=text[1], max_seq_len=max_seq_len)
-            else:
-                raise RuntimeError(
-                    'The input text must have one or two sequence, but got %d. Please check your inputs.' % len(text))
+            encoded_inputs = self._convert_text_to_input(tokenizer, text, max_seq_len)
             examples.append((encoded_inputs['input_ids'], encoded_inputs['segment_ids']))
 
         # Seperates data into some batches.
@@ -475,14 +477,11 @@ class TransformerModule(RunModule, TextServing):
             predictions, avg_loss, metric = self(input_ids=batch[0], token_type_ids=batch[1], seq_lengths=batch[2], labels=batch[3])
         return {'metrics': metric}
 
-    def get_embedding(self, data: List[List[str]], max_seq_len=128, batch_size=1, use_gpu=False):
+    def get_embedding(self, data: List[List[str]], use_gpu=False):
         """
         Get token level embeddings and sentence level embeddings from model.
         Args:
             data (obj:`List(List(str))`): The processed data whose each element is the list of a single text or a pair of texts.
-            max_seq_len (:obj:`int`, `optional`, defaults to :int:`None`):
-                If set to a number, will limit the total sequence returned so that it has a maximum length.
-            batch_size(obj:`int`, defaults to 1): The number of batch.
             use_gpu(obj:`bool`, defaults to `False`): Whether to use gpu to run or not.
 
         Returns:
@@ -493,8 +492,6 @@ class TransformerModule(RunModule, TextServing):
 
         return self.predict(
             data=data,
-            max_seq_len=max_seq_len,
-            batch_size=batch_size,
             use_gpu=use_gpu
         )
 
@@ -550,10 +547,10 @@ class TransformerModule(RunModule, TextServing):
                 token_labels = [[self.label_map[i] for i in token_ids] for token_ids in batch_ids]
                 results.extend(token_labels)
             elif self.task == None:
-                if not results:
-                    results = [[], []]
                 sequence_output, pooled_output = self(input_ids, segment_ids)
-                results[0].extend(sequence_output.numpy().tolist())  # token-level embedding
-                results[1].extend(pooled_output.numpy().tolist())    # sentence-level embedding
+                results.append([
+                    pooled_output.squeeze(0).numpy().tolist(),
+                    sequence_output.squeeze(0).numpy().tolist()
+                ])
 
         return results
diff --git a/paddlehub/utils/download.py b/paddlehub/utils/download.py
index 5f80e41f46ff13de765bd64189e67e9b0e8da2d4..d0d83a2e55bee85c0ebdca5e716327baf4d28861 100644
--- a/paddlehub/utils/download.py
+++ b/paddlehub/utils/download.py
@@ -25,17 +25,20 @@ from paddlehub.utils import log, utils, xarfile
 def download_data(url):
 
     def _wrapper(Dataset):
-        
-        def _download_dataset_from_url(*args, **kwargs):
+        def _check_download():
             save_name = os.path.basename(url).split('.')[0]
             output_path = os.path.join(hubenv.DATA_HOME, save_name)
             lock = filelock.FileLock(os.path.join(hubenv.TMP_HOME, save_name))
             with lock:
                 if not os.path.exists(output_path):
                     default_downloader.download_file_and_uncompress(url, hubenv.DATA_HOME, True)
-                    
-            return Dataset(*args, **kwargs)
-        return _download_dataset_from_url
+
+        class WrapperDataset(Dataset):
+            def __new__(cls, *args, **kwargs):
+                _check_download()
+                return super(WrapperDataset, cls).__new__(cls)
+
+        return WrapperDataset
 
     return _wrapper