Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
接近 2 年 前同步成功

通知 284
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 d920f3aa 编写于 作者: L linjieccc 提交者： GitHub
浏览文件
操作

Update nlp docs (#1676) 

* fix dependencies (#1636)

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md
Co-authored-by: Nchenjian <chenjian26@baidu.com>
Co-authored-by: Nwuzewu <wuzewu@baidu.com>
上级 deadba2c
展开全部 隐藏空白更改
内联 并排
Showing with 7870 addition and 5978 deletion
modules/text/embedding/fasttext_crawl_target_word-word_dim300_en/README.md
浏览文件 @ d920f3aa
## 概述 # fasttext_crawl_target_word-word_dim300_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|fasttext_crawl_target_word-word_dim300_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|fasttext|
|数据集|crawl|
|是否支持Fine-tuning|否|
|文件大小|1.19GB|
|词表大小|2000002|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install fasttext_crawl_target_word-word_dim300_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='fasttext_crawl_target_word-word_dim300_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='fasttext_crawl_target_word-word_dim300_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m fasttext_crawl_target_word-word_dim300_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
url = "http://10.12.121.132:8866/predict/fasttext_crawl_target_word-word_dim300_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
print(r.json())
```
## 查看代码
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings ## 四、部署服务
## 依赖 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlepaddle >= 2.0.0 - ### Step1: 启动PaddleHub Serving
paddlehub >= 2.0.0 - 运行启动命令：
## 更新历史 - ```shell
$ hub serving start -m fasttext_crawl_target_word-word_dim300_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/fasttext_crawl_target_word-word_dim300_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install fasttext_crawl_target_word-word_dim300_en==1.0.1
```
modules/text/embedding/fasttext_wiki-news_target_word-word_dim300_en/README.md
浏览文件 @ d920f3aa
## 概述 # fasttext_wiki-news_target_word-word_dim300_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|fasttext_wiki-news_target_word-word_dim300_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|fasttext|
|数据集|wiki-news|
|是否支持Fine-tuning|否|
|文件大小|541.63MB|
|词表大小|999996|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install fasttext_wiki-news_target_word-word_dim300_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='fasttext_wiki-news_target_word-word_dim300_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='fasttext_wiki-news_target_word-word_dim300_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m fasttext_wiki-news_target_word-word_dim300_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/fasttext_wiki-news_target_word-word_dim300_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m fasttext_wiki-news_target_word-word_dim300_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/fasttext_wiki-news_target_word-word_dim300_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install fasttext_wiki-news_target_word-word_dim300_en==1.0.1
```
modules/text/embedding/glove_twitter_target_word-word_dim100_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_twitter_target_word-word_dim100_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_twitter_target_word-word_dim100_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|glove|
|数据集|crawl|
|是否支持Fine-tuning|否|
|文件大小|431.08MB|
|词表大小|1193516|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_twitter_target_word-word_dim100_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_twitter_target_word-word_dim100_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim100_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_twitter_target_word-word_dim100_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim100_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_twitter_target_word-word_dim100_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim100_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_twitter_target_word-word_dim100_en==1.0.1
```
modules/text/embedding/glove_twitter_target_word-word_dim200_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_twitter_target_word-word_dim200_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_twitter_target_word-word_dim200_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|fasttext|
|数据集|twitter|
|是否支持Fine-tuning|否|
|文件大小|848.56MB|
|词表大小|1193516|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_twitter_target_word-word_dim200_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_twitter_target_word-word_dim200_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim200_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_twitter_target_word-word_dim200_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim200_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_twitter_target_word-word_dim200_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim200_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_twitter_target_word-word_dim200_en==1.0.1
```
modules/text/embedding/glove_twitter_target_word-word_dim25_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_twitter_target_word-word_dim25_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_twitter_target_word-word_dim25_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|glove|
|数据集|twitter|
|是否支持Fine-tuning|否|
|文件大小|116.92MB|
|词表大小|1193516|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_twitter_target_word-word_dim25_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_twitter_target_word-word_dim25_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim25_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_twitter_target_word-word_dim25_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim25_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_twitter_target_word-word_dim25_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim25_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_twitter_target_word-word_dim25_en==1.0.1
```
modules/text/embedding/glove_twitter_target_word-word_dim50_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_twitter_target_word-word_dim50_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_twitter_target_word-word_dim50_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|glove|
|数据集|twitter|
|是否支持Fine-tuning|否|
|文件大小|221.64MB|
|词表大小|1193516|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_twitter_target_word-word_dim50_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_twitter_target_word-word_dim50_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim50_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_twitter_target_word-word_dim50_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim50_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_twitter_target_word-word_dim50_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim50_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_twitter_target_word-word_dim50_en==1.0.1
```
modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim100_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_wiki2014-gigaword_target_word-word_dim100_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_wiki2014-gigaword_target_word-word_dim100_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|glove|
|数据集|wiki2014-gigaword|
|是否支持Fine-tuning|否|
|文件大小|143.30MB|
|词表大小|400002|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_wiki2014-gigaword_target_word-word_dim100_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim100_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim100_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim100_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim100_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim100_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim100_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_wiki2014-gigaword_target_word-word_dim50_en==1.0.1
```
modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim200_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_wiki2014-gigaword_target_word-word_dim200_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_wiki2014-gigaword_target_word-word_dim200_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|glove|
|数据集|wiki2014-gigaword|
|是否支持Fine-tuning|否|
|文件大小|282.97MB|
|词表大小|400002|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_wiki2014-gigaword_target_word-word_dim200_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim200_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim200_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim200_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim200_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim200_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim200_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_wiki2014-gigaword_target_word-word_dim200_en==1.0.1
```
modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim300_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_wiki2014-gigaword_target_word-word_dim300_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_wiki2014-gigaword_target_word-word_dim300_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|glove|
|数据集|wiki2014-gigaword|
|是否支持Fine-tuning|否|
|文件大小|422.83MB|
|词表大小|400002|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_wiki2014-gigaword_target_word-word_dim300_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim300_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim300_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim300_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim300_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim300_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim300_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,8 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,8 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_wiki2014-gigaword_target_word-word_dim300_en==1.0.1
```
\ No newline at end of file
modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim50_en/README.md
浏览文件 @ d920f3aa
## 概述 # glove_wiki2014-gigaword_target_word-word_dim50_en
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|glove_wiki2014-gigaword_target_word-word_dim50_en|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|glove|
|数据集|wiki2014-gigaword|
|是否支持Fine-tuning|否|
|文件大小|73.45MB|
|词表大小|400002|
|最新更新日期|2021-02-26|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install glove_wiki2014-gigaword_target_word-word_dim50_en
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim50_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim50_en')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim50_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim50_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim50_en
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim50_en"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install glove_wiki2014-gigaword_target_word-word_dim50_en==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-character_char1-1_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-character_char1-1_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|678.65MB|
|词表大小|636200|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-character_char1-1_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-1_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-1_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-1_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-1_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-character_char1-1_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-character_char1-2_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-character_char1-2_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|844.23MB|
|词表大小|792631|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-character_char1-2_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-2_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-2_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-character_char1-2_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-character_char1-4_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-character_char1-4_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|1.16GB|
|词表大小|1117461|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-character_char1-4_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-4_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-4_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-4_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-4_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-character_char1-4_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|7.25GB|
|词表大小|6967598|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|5.21GB|
|词表大小|5000001|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|7.26GB|
|词表大小|6968998|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordLR_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-wordLR_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-wordLR_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|1.32GB|
|词表大小|1271031|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-wordLR_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordLR_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordLR_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordLR_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-wordLR_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
```
## 查看代码 - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 四、部署服务
paddlepaddle >= 2.0.0 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlehub >= 2.0.0 - ### Step1: 启动PaddleHub Serving
## 更新历史 - 运行启动命令：
- ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordLR_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-wordLR_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-wordLR_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordPosition_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-wordPosition_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_context_word-wordPosition_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|679.32MB|
|词表大小|636038|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
*args,
**kwargs
)
```
创建一个Embedding Module对象，默认无需参数。 - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
**参数** ## 二、安装
* `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - ### 1、环境依赖
- paddlepaddle >= 2.0.0
```python - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
def search(
words: Union[List[str], str, int],
)
```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - ### 2、安装
**参数** - ```shell
* `words`： 需要获取的词向量的词、词列表或者词编号。 $ hub install w2v_baidu_encyclopedia_context_word-wordPosition_dim300
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 三、模型API
```python - ### 1、预测代码示例
def cosine_sim(
word_a: str,
word_b: str,
)
```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - ```python
* `word_a`： 需要计算余弦相似度的单词a。 import paddlehub as hub
* `word_b`： 需要计算余弦相似度的单词b。 embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordPosition_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
```python - ### 2、API
def dot(
word_a: str,
word_b: str,
)
```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数** - ```python
* `word_a`： 需要计算内积的单词a。 def __init__(
* `word_b`： 需要计算内积的单词b。 *args,
**kwargs
)
```
- 创建一个Embedding Module对象，默认无需参数。
```python - **参数**
def get_vocab_path() - `*args`： 用户额外指定的列表类型的参数。
``` - `**kwargs`：用户额外指定的关键字字典类型的参数。
获取本地词表文件的路径信息。
- 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - ```python
* `*args`： 额外传递的列表形式的参数。 def search(
* `**kwargs`： 额外传递的字典形式的参数。 words: Union[List[str], str, int],
)
```
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
- **参数**
- `words`： 需要获取的词向量的词、词列表或者词编号。
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 代码示例 - ```python
def cosine_sim(
word_a: str,
word_b: str,
)
```
```python - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordPosition_dim300')
# 获取单词的embedding - **参数**
embedding.search("中国") - `word_a`： 需要计算余弦相似度的单词a。
# 计算两个词向量的余弦相似度 - `word_b`： 需要计算余弦相似度的单词b。
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - ```python
def dot(
word_a: str,
word_b: str,
)
```
### Step1: 启动PaddleHub Serving - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
运行启动命令： - **参数**
- `word_a`： 需要计算内积的单词a。
- `word_b`： 需要计算内积的单词b。
```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordPosition_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```python
def get_vocab_path()
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 获取本地词表文件的路径信息。
### Step2: 发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```python
def get_tokenizer(*args, **kwargs)
```
```python - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **参数**
word_pairs = [["中国", "美国"], ["今天", "明天"]] - `*args`： 额外传递的列表形式的参数。
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 - `**kwargs`： 额外传递的字典形式的参数。
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-wordPosition_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
print(r.json())
``` - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
## 查看代码
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings ## 四、部署服务
## 依赖 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
paddlepaddle >= 2.0.0 - ### Step1: 启动PaddleHub Serving
paddlehub >= 2.0.0 - 运行启动命令：
## 更新历史 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordPosition_dim300
```
- 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
- ### 第二步: 发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-wordPosition_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
## 五、更新历史
* 1.0.0 * 1.0.0
...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0 ...@@ -146,4 +174,7 @@ paddlehub >= 2.0.0
* 1.0.1 * 1.0.1
支持基于embedding的文本分类和序列标注finetune任务 优化模型
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-wordPosition_dim300==1.0.1
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或