From 7ee2f8a1f34c949dda4c56d4c41d1179e36bdfd1 Mon Sep 17 00:00:00 2001 From: KP <109694228@qq.com> Date: Tue, 5 Jan 2021 20:28:07 +0800 Subject: [PATCH] Remove arg "batch_size" in get_embedding method (#1167) * update get_embedding --- .../language_model/bert-base-cased/README.md | 9 +++-- .../bert-base-chinese/README.md | 10 ++--- .../bert-base-multilingual-cased/README.md | 10 ++--- .../bert-base-multilingual-uncased/README.md | 10 ++--- .../bert-base-uncased/README.md | 10 ++--- .../language_model/bert-large-cased/README.md | 10 ++--- .../bert-large-uncased/README.md | 10 ++--- .../language_model/chinese_bert_wwm/README.md | 10 ++--- .../chinese_bert_wwm_ext/README.md | 10 ++--- modules/text/language_model/ernie/README.md | 9 +++-- .../text/language_model/ernie_tiny/README.md | 9 +++-- .../ernie_v2_eng_base/README.md | 9 +++-- .../ernie_v2_eng_large/README.md | 10 ++--- modules/text/language_model/rbt3/README.md | 10 ++--- modules/text/language_model/rbtl3/README.md | 10 ++--- .../roberta-wwm-ext-large/README.md | 10 ++--- .../language_model/roberta-wwm-ext/README.md | 10 ++--- paddlehub/module/nlp_module.py | 38 ++++++++++--------- 18 files changed, 105 insertions(+), 99 deletions(-) diff --git a/modules/text/language_model/bert-base-cased/README.md b/modules/text/language_model/bert-base-cased/README.md index f75cfd72..fe7010a3 100644 --- a/modules/text/language_model/bert-base-cased/README.md +++ b/modules/text/language_model/bert-base-cased/README.md @@ -41,19 +41,21 @@ 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 ) ``` @@ -64,7 +66,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 3d9d31de..4150d351 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,21 @@ 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 ) ``` @@ -64,7 +65,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 a6881ca2..da82d1c7 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,21 @@ 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 ) ``` @@ -64,7 +65,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 079b2a2b..ede4b271 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,21 @@ 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 ) ``` @@ -64,7 +65,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 dfb5e864..ecc63df0 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,21 @@ 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 ) ``` @@ -64,7 +65,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 344d5441..89006ec1 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,21 @@ 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 ) ``` @@ -64,7 +65,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 e2964f85..482314dd 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,21 @@ 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 ) ``` @@ -64,7 +65,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 6f0460c5..a51f325e 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,21 @@ 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,7 +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_ext/README.md b/modules/text/language_model/chinese_bert_wwm_ext/README.md index 03357e3c..5e058538 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,21 @@ 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,7 +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/ernie/README.md b/modules/text/language_model/ernie/README.md index 4ee91755..90fc231e 100644 --- a/modules/text/language_model/ernie/README.md +++ b/modules/text/language_model/ernie/README.md @@ -50,19 +50,21 @@ 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 ) ``` @@ -73,7 +75,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 f02419a6..3d940bb0 100644 --- a/modules/text/language_model/ernie_tiny/README.md +++ b/modules/text/language_model/ernie_tiny/README.md @@ -50,19 +50,21 @@ 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 ) ``` @@ -73,7 +75,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 d5ece7a9..2427c1c3 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,21 @@ 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 ) ``` @@ -69,7 +71,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 680bc1be..46c46cd1 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,21 @@ 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 ) ``` @@ -69,7 +70,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 baf02dd1..705270d0 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,21 @@ 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,7 +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/rbtl3/README.md b/modules/text/language_model/rbtl3/README.md index f1dd9c43..b24f20fc 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,21 @@ 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,7 +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/roberta-wwm-ext-large/README.md b/modules/text/language_model/roberta-wwm-ext-large/README.md index 4d19bf2b..ecdeb781 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,21 @@ 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,7 +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/roberta-wwm-ext/README.md b/modules/text/language_model/roberta-wwm-ext/README.md index 9ee71b85..1899057d 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,21 @@ 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,7 +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/paddlehub/module/nlp_module.py b/paddlehub/module/nlp_module.py index ddfd546c..bacc9eb8 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, max_seq_len, 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,7 +477,7 @@ 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]], max_seq_len=128, use_gpu=False): """ Get token level embeddings and sentence level embeddings from model. Args: @@ -494,7 +496,7 @@ class TransformerModule(RunModule, TextServing): return self.predict( data=data, max_seq_len=max_seq_len, - batch_size=batch_size, + batch_size=1, use_gpu=use_gpu ) @@ -550,10 +552,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 -- GitLab