Skip to content

P
PaddleHub

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

通知 285
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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='fasttext_crawl_target_word-word_dim300_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='fasttext_crawl_target_word-word_dim300_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m fasttext_crawl_target_word-word_dim300_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m fasttext_crawl_target_word-word_dim300_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='fasttext_wiki-news_target_word-word_dim300_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='fasttext_wiki-news_target_word-word_dim300_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m fasttext_wiki-news_target_word-word_dim300_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m fasttext_wiki-news_target_word-word_dim300_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim100_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='glove_twitter_target_word-word_dim100_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m glove_twitter_target_word-word_dim100_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m glove_twitter_target_word-word_dim100_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim200_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='glove_twitter_target_word-word_dim200_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m glove_twitter_target_word-word_dim200_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m glove_twitter_target_word-word_dim200_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim25_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='glove_twitter_target_word-word_dim25_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m glove_twitter_target_word-word_dim25_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m glove_twitter_target_word-word_dim25_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_twitter_target_word-word_dim50_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='glove_twitter_target_word-word_dim50_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m glove_twitter_target_word-word_dim50_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m glove_twitter_target_word-word_dim50_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim100_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim100_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim100_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim100_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim200_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim200_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim200_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim200_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim300_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
* `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。
- **参数**
- `word_a`： 需要计算余弦相似度的单词a。
- `word_b`： 需要计算余弦相似度的单词b。
```python
def dot( - ```python
def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
- 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
```python - **参数**
def get_vocab_path() - `word_a`： 需要计算内积的单词a。
``` - `word_b`： 需要计算内积的单词b。
获取本地词表文件的路径信息。
```python - ```python
def get_tokenizer(*args, **kwargs) def get_vocab_path()
``` ```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - 获取本地词表文件的路径信息。
* `*args`： 额外传递的列表形式的参数。
* `**kwargs`： 额外传递的字典形式的参数。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_tokenizer(*args, **kwargs)
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
## 代码示例 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
```python - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim300_en')
# 获取单词的embedding - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 ## 四、部署服务
### Step1: 启动PaddleHub Serving - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
运行启动命令： - ### Step1: 启动PaddleHub Serving
```shell - 运行启动命令：
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim300_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim300_en
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
### Step2: 发送预测请求 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ### 第二步: 发送预测请求
```python - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - ```python
word_pairs = [["中国", "美国"], ["今天", "明天"]] import requests
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 import json
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)) # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]]
print(r.json()) 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())
```
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings
## 依赖 ## 五、更新历史
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
## 更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim50_en')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim50_en') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim50_en
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim50_en
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-1_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-1_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-1_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-1_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-2_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-2_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-4_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-4_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-4_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-4_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordLR_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordLR_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordLR_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordLR_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ 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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordPosition_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordPosition_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordPosition_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordPosition_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
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)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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
```
modules/text/embedding/w2v_baidu_encyclopedia_context_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_context_word-word_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-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|677.74MB|
|词表大小|635952|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_context_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_context_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_context_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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-word_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|679.29MB|
|词表大小|635976|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-1_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-character_char1-1_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|679.15MB|
|词表大小|636038|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-1_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-1_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-1_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-1_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-character_char1-1_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-character_char1-1_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-2_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-character_char1-2_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|679.30MB|
|词表大小|636038|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-2_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-2_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-character_char1-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-character_char1-2_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-4_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-character_char1-4_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|679.51MB|
|词表大小|636038|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-4_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-4_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-4_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-4_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-character_char1-4_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-character_char1-4_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-ngram_1-2_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|679.48MB|
|词表大小|635977|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-ngram_1-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-ngram_1-2_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-ngram_1-3_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|671.27MB|
|词表大小|628669|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-ngram_1-3_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-ngram_1-3_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-ngram_2-2_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|7.28GB|
|词表大小|6969069|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-ngram_2-2_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-ngram_2-2_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordLR_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-wordLR_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|678.22MB|
|词表大小|635958|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordLR_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordLR_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-wordLR_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-wordLR_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-wordLR_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-wordLR_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordPosition_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_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_target_word-wordPosition_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|679.32MB|
|词表大小|636038|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordPosition_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordPosition_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-wordPosition_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-wordPosition_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_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())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-wordPosition_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-wordPosition_dim300==1.0.1
```
modules/text/embedding/w2v_baidu_encyclopedia_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_baidu_encyclopedia_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_baidu_encyclopedia_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|baidu_encyclopedia|
|是否支持Fine-tuning|否|
|文件大小|678.21MB|
|词表大小|635965|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_baidu_encyclopedia_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_baidu_encyclopedia_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_baidu_encyclopedia_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_financial_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_financial_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_financial_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|financial|
|是否支持Fine-tuning|否|
|文件大小|499.52MB|
|词表大小|467163|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_financial_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_financial_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_financial_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_financial_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_financial_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_financial_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_financial_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_financial_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_financial_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_financial_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_financial_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|financial|
|是否支持Fine-tuning|否|
|文件大小|499.54MB|
|词表大小|467331|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_financial_target_word-bigram_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_financial_target_word-bigram_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_financial_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_financial_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_financial_target_word-bigram_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_financial_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_financial_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_financial_target_word-bigram_dim300==1.0.1
```
modules/text/embedding/w2v_financial_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_financial_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_financial_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|financial|
|是否支持Fine-tuning|否|
|文件大小|499.17MB|
|词表大小|467343|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_financial_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_financial_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_financial_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_financial_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_financial_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_financial_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_financial_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_financial_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_financial_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_financial_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_financial_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|financial|
|是否支持Fine-tuning|否|
|文件大小|498.94MB|
|词表大小|467324|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_financial_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_financial_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_financial_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_financial_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_financial_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_financial_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_financial_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_financial_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_literature_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_literature_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_literature_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|literature|
|是否支持Fine-tuning|否|
|文件大小|200.69MB|
|词表大小|187975|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_literature_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_literature_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_literature_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_literature_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_literature_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_literature_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_literature_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_literature_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_literature_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_literature_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_literature_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|literature|
|是否支持Fine-tuning|否|
|文件大小|200.59MB|
|词表大小|187962|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_literature_target_word-bigram_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_literature_target_word-bigram_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_literature_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_literature_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_literature_target_word-bigram_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_literature_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_literature_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_literature_target_word-bigram_dim300==1.0.1
```
modules/text/embedding/w2v_literature_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_literature_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_literature_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|literature|
|是否支持Fine-tuning|否|
|文件大小|200.44MB|
|词表大小|187980|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_literature_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_literature_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_literature_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_literature_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_literature_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_literature_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_literature_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_literature_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_literature_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_literature_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_literature_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|literature|
|是否支持Fine-tuning|否|
|文件大小|200.28MB|
|词表大小|187961|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_literature_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_literature_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_literature_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_literature_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_literature_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_literature_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_literature_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_literature_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_mixed-large_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_mixed-large_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_mixed-large_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|mixed|
|是否支持Fine-tuning|否|
|文件大小|1.35GB|
|词表大小|1292552|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_mixed-large_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_mixed-large_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_mixed-large_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_mixed-large_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_mixed-large_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_mixed-large_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_mixed-large_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_mixed-large_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_mixed-large_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_mixed-large_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_mixed-large_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|mixed|
|是否支持Fine-tuning|否|
|文件大小|1.35GB|
|词表大小|1292483|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_mixed-large_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_mixed-large_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_mixed-large_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_mixed-large_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_mixed-large_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_mixed-large_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_mixed-large_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_mixed-large_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_people_daily_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_people_daily_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_people_daily_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|people_daily|
|是否支持Fine-tuning|否|
|文件大小|379.96MB|
|词表大小|356055|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_people_daily_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_people_daily_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_people_daily_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_people_daily_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_people_daily_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_people_daily_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_people_daily_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_people_daily_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_people_daily_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_people_daily_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_people_daily_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|people_daily|
|是否支持Fine-tuning|否|
|文件大小|379.68MB|
|词表大小|355991|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_people_daily_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_people_daily_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_people_daily_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_people_daily_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_people_daily_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_people_daily_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_people_daily_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_people_daily_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_people_daily_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_people_daily_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_people_daily_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|people_daily|
|是否支持Fine-tuning|否|
|文件大小|379.45MB|
|词表大小|355998|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_people_daily_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_people_daily_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_people_daily_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_people_daily_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_people_daily_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_people_daily_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_people_daily_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_people_daily_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_people_daily_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_people_daily_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_people_daily_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|people_daily|
|是否支持Fine-tuning|否|
|文件大小|378.93MB|
|词表大小|355989|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_people_daily_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_people_daily_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_people_daily_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_people_daily_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_people_daily_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_people_daily_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_people_daily_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_people_daily_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_sikuquanshu_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_sikuquanshu_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_sikuquanshu_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|sikuquanshu|
|是否支持Fine-tuning|否|
|文件大小|20.77MB|
|词表大小|19529|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_sikuquanshu_target_word-bigram_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_sikuquanshu_target_word-bigram_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_sikuquanshu_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_sikuquanshu_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_sikuquanshu_target_word-bigram_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_sikuquanshu_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_sikuquanshu_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_sikuquanshu_target_word-bigram_dim300==1.0.1
```
modules/text/embedding/w2v_sikuquanshu_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_sikuquanshu_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_sikuquanshu_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|sikuquanshu|
|是否支持Fine-tuning|否|
|文件大小|20.70MB|
|词表大小|19529|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_sikuquanshu_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_sikuquanshu_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_sikuquanshu_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_sikuquanshu_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_sikuquanshu_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_sikuquanshu_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_sikuquanshu_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_sikuquanshu_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_sogou_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_sogou_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_sogou_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|sogou|
|是否支持Fine-tuning|否|
|文件大小|389.81MB|
|词表大小|365112|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_sogou_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_sogou_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_sogou_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_sogou_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_sogou_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_sogou_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_sogou_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_sogou_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_sogou_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_sogou_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_sogou_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|sogou|
|是否支持Fine-tuning|否|
|文件大小|388.66MB|
|词表大小|364994|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_sogou_target_word-bigram_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_sogou_target_word-bigram_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_sogou_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_sogou_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_sogou_target_word-bigram_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_sogou_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_sogou_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_sogou_target_word-bigram_dim300==1.0.1
```
modules/text/embedding/w2v_sogou_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_sogou_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_sogou_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|sogou|
|是否支持Fine-tuning|否|
|文件大小|389.89MB|
|词表大小|365078|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_sogou_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_sogou_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_sogou_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_sogou_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_sogou_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_sogou_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_sogou_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_sogou_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_sogou_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_sogou_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_sogou_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|sogou|
|是否支持Fine-tuning|否|
|文件大小|388.66MB|
|词表大小|364992|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_sogou_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_sogou_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_sogou_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_sogou_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_sogou_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_sogou_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_sogou_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_sogou_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_weibo_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_weibo_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_weibo_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|weibo|
|是否支持Fine-tuning|否|
|文件大小|208.24MB|
|词表大小|195199|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_weibo_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_weibo_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_weibo_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_weibo_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_weibo_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_weibo_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_weibo_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_weibo_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_weibo_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_weibo_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_weibo_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|weibo|
|是否支持Fine-tuning|否|
|文件大小|208.19MB|
|词表大小|195204|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_weibo_target_word-bigram_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_weibo_target_word-bigram_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_weibo_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_weibo_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_weibo_target_word-bigram_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_weibo_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_weibo_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_weibo_target_word-bigram_dim300==1.0.1
```
modules/text/embedding/w2v_weibo_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_weibo_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_weibo_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|weibo|
|是否支持Fine-tuning|否|
|文件大小|208.03MB|
|词表大小|195204|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_weibo_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_weibo_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_weibo_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_weibo_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_weibo_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_weibo_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_weibo_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_weibo_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_weibo_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_weibo_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_weibo_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|weibo|
|是否支持Fine-tuning|否|
|文件大小|207.94MB|
|词表大小|195204|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_weibo_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_weibo_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_weibo_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_weibo_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_weibo_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_weibo_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_weibo_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_weibo_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_wiki_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_wiki_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_wiki_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|wiki|
|是否支持Fine-tuning|否|
|文件大小|375.98MB|
|词表大小|352274|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_wiki_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_wiki_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_wiki_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_wiki_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_wiki_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_wiki_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_wiki_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_wiki_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_wiki_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_wiki_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_wiki_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|wiki|
|是否支持Fine-tuning|否|
|文件大小|375.72MB|
|词表大小|352219|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_wiki_target_word-bigram_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_wiki_target_word-bigram_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_wiki_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_wiki_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_wiki_target_word-bigram_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_wiki_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_wiki_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_wiki_target_word-bigram_dim300==1.0.1
```
modules/text/embedding/w2v_wiki_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_wiki_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_wiki_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|wiki|
|是否支持Fine-tuning|否|
|文件大小|375.52MB|
|词表大小|352223|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_wiki_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_wiki_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_wiki_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_wiki_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_wiki_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_wiki_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_wiki_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_wiki_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_wiki_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_wiki_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_wiki_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|wiki|
|是否支持Fine-tuning|否|
|文件大小|374.95MB|
|词表大小|352219|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_wiki_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_wiki_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_wiki_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_wiki_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_wiki_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_wiki_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_wiki_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_wiki_target_word-word_dim300==1.0.1
```
modules/text/embedding/w2v_zhihu_target_bigram-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_zhihu_target_bigram-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_zhihu_target_bigram-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|zhihu|
|是否支持Fine-tuning|否|
|文件大小|277.35MB|
|词表大小|259755|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_zhihu_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_zhihu_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_zhihu_target_bigram-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_zhihu_target_bigram-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_zhihu_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_zhihu_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_zhihu_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_zhihu_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_zhihu_target_word-bigram_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_zhihu_target_word-bigram_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_zhihu_target_word-bigram_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|zhihu|
|是否支持Fine-tuning|否|
|文件大小|277.53MB|
|词表大小|259885|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_zhihu_target_bigram-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_zhihu_target_bigram-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_zhihu_target_word-bigram_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_zhihu_target_word-bigram_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_zhihu_target_bigram-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_zhihu_target_word-bigram_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_zhihu_target_bigram-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_zhihu_target_bigram-char_dim300==1.0.1
```
modules/text/embedding/w2v_zhihu_target_word-char_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_zhihu_target_word-char_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_zhihu_target_word-char_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|zhihu|
|是否支持Fine-tuning|否|
|文件大小|277.40MB|
|词表大小|259940|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_zhihu_target_word-char_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_zhihu_target_word-char_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_zhihu_target_word-char_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_zhihu_target_word-char_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_zhihu_target_word-char_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_zhihu_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_zhihu_target_word-char_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_zhihu_target_word-char_dim300==1.0.1
```
modules/text/embedding/w2v_zhihu_target_word-word_dim300/README.md
浏览文件 @ d920f3aa
## 概述 # w2v_zhihu_target_word-word_dim300
PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) |模型名称|w2v_zhihu_target_word-word_dim300|
| :--- | :---: |
|类别|文本-词嵌入|
|网络|w2v|
|数据集|zhihu|
|是否支持Fine-tuning|否|
|文件大小|276.98MB|
|词表大小|259871|
|最新更新日期|2021-04-28|
|数据指标|-|
## API ## 一、模型基本信息
```python - ### 模型介绍
def __init__(
- PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md)
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 2.0.0
- paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install w2v_zhihu_target_word-word_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
- ### 1、预测代码示例
- ```python
import paddlehub as hub
embedding = hub.Module(name='w2v_zhihu_target_word-word_dim300')
# 获取单词的embedding
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
- ### 2、API
- ```python
def __init__(
*args, *args,
**kwargs **kwargs
) )
``` ```
创建一个Embedding Module对象，默认无需参数。 - 创建一个Embedding Module对象，默认无需参数。
**参数** - **参数**
* `*args`： 用户额外指定的列表类型的参数。 - `*args`： 用户额外指定的列表类型的参数。
* `**kwargs`：用户额外指定的关键字字典类型的参数。 - `**kwargs`：用户额外指定的关键字字典类型的参数。
关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
```python - ```python
def search( def search(
words: Union[List[str], str, int], words: Union[List[str], str, int],
) )
``` ```
获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。
**参数** - **参数**
* `words`： 需要获取的词向量的词、词列表或者词编号。 - `words`： 需要获取的词向量的词、词列表或者词编号。
```python - ```python
def cosine_sim( def cosine_sim(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
- 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。
**参数** - **参数**
* `word_a`： 需要计算余弦相似度的单词a。 - `word_a`： 需要计算余弦相似度的单词a。
* `word_b`： 需要计算余弦相似度的单词b。 - `word_b`： 需要计算余弦相似度的单词b。
```python - ```python
def dot( def dot(
word_a: str, word_a: str,
word_b: str, word_b: str,
) )
``` ```
计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
**参数**
* `word_a`： 需要计算内积的单词a。
* `word_b`： 需要计算内积的单词b。
```python
def get_vocab_path()
```
获取本地词表文件的路径信息。
```python - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。
def get_tokenizer(*args, **kwargs)
```
获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
**参数** - **参数**
* `*args`： 额外传递的列表形式的参数。 - `word_a`： 需要计算内积的单词a。
* `**kwargs`： 额外传递的字典形式的参数。 - `word_b`： 需要计算内积的单词b。
关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py)
- ```python
def get_vocab_path()
```
更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) - 获取本地词表文件的路径信息。
## 代码示例
```python - ```python
import paddlehub as hub def get_tokenizer(*args, **kwargs)
embedding = hub.Module(name='w2v_zhihu_target_word-word_dim300') ```
# 获取单词的embedding - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。
embedding.search("中国")
# 计算两个词向量的余弦相似度
embedding.cosine_sim("中国", "美国")
# 计算两个词向量的内积
embedding.dot("中国", "美国")
```
## 部署服务 - **参数**
- `*args`： 额外传递的列表形式的参数。
- `**kwargs`： 额外传递的字典形式的参数。
通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py)
### Step1: 启动PaddleHub Serving - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings)
运行启动命令：
```shell ## 四、部署服务
$ hub serving start -m w2v_zhihu_target_word-word_dim300
```
这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 - 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ### Step1: 启动PaddleHub Serving
### Step2: 发送预测请求 - 运行启动命令：
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ```shell
$ hub serving start -m w2v_zhihu_target_word-word_dim300
```
```python - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。
import requests
import json
# 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
word_pairs = [["中国", "美国"], ["今天", "明天"]]
# 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算
data = {"data": word_pairs}
# 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip
url = "http://10.12.121.132:8866/predict/w2v_zhihu_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
r = requests.post(url=url, headers=headers, data=json.dumps(data)) - ### 第二步: 发送预测请求
print(r.json())
```
## 查看代码 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings - ```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_zhihu_target_word-word_dim300"
# 指定post请求的headers为application/json方式
headers = {"Content-Type": "application/json"}
paddlepaddle >= 2.0.0 r = requests.post(url=url, headers=headers, data=json.dumps(data))
print(r.json())
```
paddlehub >= 2.0.0
## 更新历史 ## 五、更新历史
* 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_zhihu_target_word-word_dim300==1.0.1
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或