Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
大约 1 年 前同步成功

通知 282
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 7ee2f8a1 编写于 作者: K KP 提交者： GitHub
浏览文件
操作

Remove arg "batch_size" in get_embedding method (#1167) 

* update get_embedding
上级 713efd45
显示空白变更内容
内联 并排
Showing with 105 addition and 99 deletion
modules/text/language_model/bert-base-cased/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/bert-base-chinese/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/bert-base-multilingual-cased/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/bert-base-multilingual-uncased/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/bert-base-uncased/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/bert-large-cased/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/bert-large-uncased/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/chinese_bert_wwm/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/chinese_bert_wwm_ext/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/ernie/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/ernie_tiny/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/ernie_v2_eng_base/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/ernie_v2_eng_large/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/rbt3/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/rbtl3/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/roberta-wwm-ext-large/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
modules/text/language_model/roberta-wwm-ext/README.md
浏览文件 @ 7ee2f8a1
......@@ -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。
**返回**
......
paddlehub/module/nlp_module.py
浏览文件 @ 7ee2f8a1
......@@ -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
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或