From 65738e77fa378fb28dd8236ab0188996c8ca7eff Mon Sep 17 00:00:00 2001 From: PaddlePaddle-Gardener Date: Fri, 7 Jan 2022 10:44:46 +0800 Subject: [PATCH] mirgate_1676 --- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 228 ++++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- .../README.md | 227 +++++++++-------- 61 files changed, 7870 insertions(+), 5978 deletions(-) diff --git a/modules/text/embedding/fasttext_crawl_target_word-word_dim300_en/README.md b/modules/text/embedding/fasttext_crawl_target_word-word_dim300_en/README.md index 0dd8bd27..4f8d0c29 100644 --- a/modules/text/embedding/fasttext_crawl_target_word-word_dim300_en/README.md +++ b/modules/text/embedding/fasttext_crawl_target_word-word_dim300_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|fasttext| +|数据集|crawl| +|是否支持Fine-tuning|否| +|文件大小|1.19GB| +|词表大小|2000002| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='fasttext_crawl_target_word-word_dim300_en') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='fasttext_crawl_target_word-word_dim300_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m fasttext_crawl_target_word-word_dim300_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/fasttext_crawl_target_word-word_dim300_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 + + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 查看代码 -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings +## 四、部署服务 -## 依赖 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlepaddle >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -paddlehub >= 2.0.0 + - 运行启动命令： -## 更新历史 + - ```shell + $ hub serving start -m fasttext_crawl_target_word-word_dim300_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/fasttext_crawl_target_word-word_dim300_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install fasttext_crawl_target_word-word_dim300_en==1.0.1 + ``` diff --git a/modules/text/embedding/fasttext_wiki-news_target_word-word_dim300_en/README.md b/modules/text/embedding/fasttext_wiki-news_target_word-word_dim300_en/README.md index dd1edcb6..9bba94ff 100644 --- a/modules/text/embedding/fasttext_wiki-news_target_word-word_dim300_en/README.md +++ b/modules/text/embedding/fasttext_wiki-news_target_word-word_dim300_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|fasttext| +|数据集|wiki-news| +|是否支持Fine-tuning|否| +|文件大小|541.63MB| +|词表大小|999996| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='fasttext_wiki-news_target_word-word_dim300_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m fasttext_wiki-news_target_word-word_dim300_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/fasttext_wiki-news_target_word-word_dim300_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m fasttext_wiki-news_target_word-word_dim300_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/fasttext_wiki-news_target_word-word_dim300_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install fasttext_wiki-news_target_word-word_dim300_en==1.0.1 + ``` diff --git a/modules/text/embedding/glove_twitter_target_word-word_dim100_en/README.md b/modules/text/embedding/glove_twitter_target_word-word_dim100_en/README.md index 30c61f55..3e9b300b 100644 --- a/modules/text/embedding/glove_twitter_target_word-word_dim100_en/README.md +++ b/modules/text/embedding/glove_twitter_target_word-word_dim100_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_twitter_target_word-word_dim100_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|glove| +|数据集|crawl| +|是否支持Fine-tuning|否| +|文件大小|431.08MB| +|词表大小|1193516| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='glove_twitter_target_word-word_dim100_en') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_twitter_target_word-word_dim100_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_twitter_target_word-word_dim100_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim100_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_twitter_target_word-word_dim100_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim100_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install glove_twitter_target_word-word_dim100_en==1.0.1 + ``` diff --git a/modules/text/embedding/glove_twitter_target_word-word_dim200_en/README.md b/modules/text/embedding/glove_twitter_target_word-word_dim200_en/README.md index a1f31284..b80d1d7d 100644 --- a/modules/text/embedding/glove_twitter_target_word-word_dim200_en/README.md +++ b/modules/text/embedding/glove_twitter_target_word-word_dim200_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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 +|模型名称|glove_twitter_target_word-word_dim200_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|fasttext| +|数据集|twitter| +|是否支持Fine-tuning|否| +|文件大小|848.56MB| +|词表大小|1193516| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='glove_twitter_target_word-word_dim200_en') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_twitter_target_word-word_dim200_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_twitter_target_word-word_dim200_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim200_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_twitter_target_word-word_dim200_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim200_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install glove_twitter_target_word-word_dim200_en==1.0.1 + ``` diff --git a/modules/text/embedding/glove_twitter_target_word-word_dim25_en/README.md b/modules/text/embedding/glove_twitter_target_word-word_dim25_en/README.md index ab604906..6baea2fd 100644 --- a/modules/text/embedding/glove_twitter_target_word-word_dim25_en/README.md +++ b/modules/text/embedding/glove_twitter_target_word-word_dim25_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim25_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|glove| +|数据集|twitter| +|是否支持Fine-tuning|否| +|文件大小|116.92MB| +|词表大小|1193516| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='glove_twitter_target_word-word_dim25_en') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_twitter_target_word-word_dim25_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_twitter_target_word-word_dim25_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim25_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_twitter_target_word-word_dim25_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim25_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install glove_twitter_target_word-word_dim25_en==1.0.1 + ``` diff --git a/modules/text/embedding/glove_twitter_target_word-word_dim50_en/README.md b/modules/text/embedding/glove_twitter_target_word-word_dim50_en/README.md index 6770c0d3..029baf8d 100644 --- a/modules/text/embedding/glove_twitter_target_word-word_dim50_en/README.md +++ b/modules/text/embedding/glove_twitter_target_word-word_dim50_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim50_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|glove| +|数据集|twitter| +|是否支持Fine-tuning|否| +|文件大小|221.64MB| +|词表大小|1193516| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='glove_twitter_target_word-word_dim50_en') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_twitter_target_word-word_dim50_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_twitter_target_word-word_dim50_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_twitter_target_word-word_dim50_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_twitter_target_word-word_dim50_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_twitter_target_word-word_dim50_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install glove_twitter_target_word-word_dim50_en==1.0.1 + ``` diff --git a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim100_en/README.md b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim100_en/README.md index cbe1760c..b3eedc46 100644 --- a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim100_en/README.md +++ b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim100_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim100_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|glove| +|数据集|wiki2014-gigaword| +|是否支持Fine-tuning|否| +|文件大小|143.30MB| +|词表大小|400002| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim100_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim100_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim100_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim100_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim100_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install glove_wiki2014-gigaword_target_word-word_dim50_en==1.0.1 + ``` diff --git a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim200_en/README.md b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim200_en/README.md index ea8e7872..68c5ecd5 100644 --- a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim200_en/README.md +++ b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim200_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim200_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|glove| +|数据集|wiki2014-gigaword| +|是否支持Fine-tuning|否| +|文件大小|282.97MB| +|词表大小|400002| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim200_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim200_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim200_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim200_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim200_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install glove_wiki2014-gigaword_target_word-word_dim200_en==1.0.1 + ``` diff --git a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim300_en/README.md b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim300_en/README.md index a8e67d62..f92fe894 100644 --- a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim300_en/README.md +++ b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim300_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|glove| +|数据集|wiki2014-gigaword| +|是否支持Fine-tuning|否| +|文件大小|422.83MB| +|词表大小|400002| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim300_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim300_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim300_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim300_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim300_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,8 @@ paddlehub >= 2.0.0 * 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 diff --git a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim50_en/README.md b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim50_en/README.md index ee25f85b..edba1569 100644 --- a/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim50_en/README.md +++ b/modules/text/embedding/glove_wiki2014-gigaword_target_word-word_dim50_en/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim50_en| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|glove| +|数据集|wiki2014-gigaword| +|是否支持Fine-tuning|否| +|文件大小|73.45MB| +|词表大小|400002| +|最新更新日期|2021-02-26| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='glove_wiki2014-gigaword_target_word-word_dim50_en') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim50_en -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/glove_wiki2014-gigaword_target_word-word_dim50_en" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m glove_wiki2014-gigaword_target_word-word_dim50_en + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/glove_wiki2014-gigaword_target_word-word_dim50_en" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install glove_wiki2014-gigaword_target_word-word_dim50_en==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300/README.md index 3b712b12..c5fab77a 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-character_char1-1_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|678.65MB| +|词表大小|636200| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-1_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-1_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-1_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-1_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-character_char1-1_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300/README.md index 77911202..f88623c0 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-character_char1-2_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|844.23MB| +|词表大小|792631| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-2_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-2_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-2_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-2_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-character_char1-2_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300/README.md index 863f5932..bbf8ec37 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-character_char1-4_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|1.16GB| +|词表大小|1117461| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-character_char1-4_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-4_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-character_char1-4_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-character_char1-4_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-character_char1-4_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300/README.md index 2936f5e0..efaf4cdb 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-ngram_1-2_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|7.25GB| +|词表大小|6967598| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-ngram_1-2_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300/README.md index 3f5461c8..489fba9b 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-ngram_1-3_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|5.21GB| +|词表大小|5000001| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-ngram_1-3_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300/README.md index 676ac108..ecd24c40 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-ngram_2-2_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|7.26GB| +|词表大小|6968998| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-ngram_2-2_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordLR_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordLR_dim300/README.md index 4f5c2465..d0fee96f 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordLR_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordLR_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-wordLR_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|1.32GB| +|词表大小|1271031| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordLR_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordLR_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordLR_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-wordLR_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-wordLR_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-wordLR_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-wordLR_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordPosition_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordPosition_dim300/README.md index a04bd139..6c91b7c1 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordPosition_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-wordPosition_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-wordPosition_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|679.32MB| +|词表大小|636038| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordPosition_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-wordPosition_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-wordPosition_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-wordPosition_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) + + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 查看代码 -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings +## 四、部署服务 -## 依赖 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlepaddle >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -paddlehub >= 2.0.0 + - 运行启动命令： -## 更新历史 + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-wordPosition_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-wordPosition_dim300" + # 指定post请求的headers为application/json方式 + headers = {"Content-Type": "application/json"} + + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + print(r.json()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-wordPosition_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-word_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-word_dim300/README.md index b1bf197c..2bf5e93c 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_context_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_context_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_context_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|677.74MB| +|词表大小|635952| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_context_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_context_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_context_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_context_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_context_word-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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_context_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_bigram-char_dim300/README.md index f42d628d..09467ef6 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|679.29MB| +|词表大小|635976| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_baidu_encyclopedia_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-1_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-1_dim300/README.md index 6c0714d1..cbf664f3 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-1_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-1_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-character_char1-1_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|679.15MB| +|词表大小|636038| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-1_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-1_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-character_char1-1_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-1_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-character_char1-1_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-2_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-2_dim300/README.md index 384ef04c..13585674 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-2_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-2_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-character_char1-2_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|679.30MB| +|词表大小|636038| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-2_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-2_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-character_char1-2_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-2_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-character_char1-2_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-4_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-4_dim300/README.md index bdfe3a70..8471592a 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-4_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-character_char1-4_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-character_char1-4_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|679.51MB| +|词表大小|636038| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-character_char1-4_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-4_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-character_char1-4_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-character_char1-4_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-character_char1-4_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300/README.md index cce2987b..b6d1429b 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-ngram_1-2_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|679.48MB| +|词表大小|635977| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-ngram_1-2_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300/README.md index 5da791f7..b50eee0c 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-ngram_1-3_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|671.27MB| +|词表大小|628669| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-ngram_1-3_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300/README.md index 5d60020e..e6b48044 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-ngram_2-2_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|7.28GB| +|词表大小|6969069| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```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("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-ngram_2-2_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordLR_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordLR_dim300/README.md index 3ce08836..7cd37e6a 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordLR_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordLR_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-wordLR_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|678.22MB| +|词表大小|635958| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordLR_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordLR_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-wordLR_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-wordLR_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-wordLR_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-wordLR_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordPosition_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordPosition_dim300/README.md index 756a3bc4..8a02ec85 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordPosition_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-wordPosition_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-wordPosition_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|679.32MB| +|词表大小|636038| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordPosition_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-wordPosition_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-wordPosition_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-wordPosition_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-wordPosition_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-wordPosition_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-word_dim300/README.md b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-word_dim300/README.md index 9e37a31f..68b4e3f2 100644 --- a/modules/text/embedding/w2v_baidu_encyclopedia_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_baidu_encyclopedia_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|baidu_encyclopedia| +|是否支持Fine-tuning|否| +|文件大小|678.21MB| +|词表大小|635965| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_baidu_encyclopedia_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_baidu_encyclopedia_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_baidu_encyclopedia_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_baidu_encyclopedia_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_baidu_encyclopedia_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_baidu_encyclopedia_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_financial_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_financial_target_bigram-char_dim300/README.md index 0b14e546..8a80e719 100644 --- a/modules/text/embedding/w2v_financial_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_financial_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|financial| +|是否支持Fine-tuning|否| +|文件大小|499.52MB| +|词表大小|467163| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_financial_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_financial_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_financial_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_financial_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_financial_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_financial_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_financial_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_financial_target_word-bigram_dim300/README.md index b979aea1..2a136a52 100644 --- a/modules/text/embedding/w2v_financial_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_financial_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|financial| +|是否支持Fine-tuning|否| +|文件大小|499.54MB| +|词表大小|467331| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_financial_target_word-bigram_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_financial_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_financial_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_financial_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_financial_target_word-bigram_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_financial_target_word-bigram_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_financial_target_word-char_dim300/README.md b/modules/text/embedding/w2v_financial_target_word-char_dim300/README.md index f32a61e4..0eb2271b 100644 --- a/modules/text/embedding/w2v_financial_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_financial_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|financial| +|是否支持Fine-tuning|否| +|文件大小|499.17MB| +|词表大小|467343| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_financial_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_financial_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_financial_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_financial_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_financial_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_financial_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_financial_target_word-word_dim300/README.md b/modules/text/embedding/w2v_financial_target_word-word_dim300/README.md index b2309731..81d75284 100644 --- a/modules/text/embedding/w2v_financial_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_financial_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|financial| +|是否支持Fine-tuning|否| +|文件大小|498.94MB| +|词表大小|467324| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_financial_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_financial_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_financial_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_financial_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_financial_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_financial_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_literature_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_literature_target_bigram-char_dim300/README.md index 07e8cc25..f05cd2d6 100644 --- a/modules/text/embedding/w2v_literature_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_literature_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|literature| +|是否支持Fine-tuning|否| +|文件大小|200.69MB| +|词表大小|187975| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_literature_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_literature_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_literature_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_literature_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_literature_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_literature_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_literature_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_literature_target_word-bigram_dim300/README.md index ef9fd0ff..2c7f7155 100644 --- a/modules/text/embedding/w2v_literature_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_literature_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|literature| +|是否支持Fine-tuning|否| +|文件大小|200.59MB| +|词表大小|187962| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_literature_target_word-bigram_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_literature_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_literature_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_literature_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_literature_target_word-bigram_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_literature_target_word-bigram_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_literature_target_word-char_dim300/README.md b/modules/text/embedding/w2v_literature_target_word-char_dim300/README.md index 6a043231..ae45d417 100644 --- a/modules/text/embedding/w2v_literature_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_literature_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|literature| +|是否支持Fine-tuning|否| +|文件大小|200.44MB| +|词表大小|187980| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_literature_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_literature_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_literature_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_literature_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_literature_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_literature_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_literature_target_word-word_dim300/README.md b/modules/text/embedding/w2v_literature_target_word-word_dim300/README.md index 67032fbb..3e9e7c61 100644 --- a/modules/text/embedding/w2v_literature_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_literature_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|literature| +|是否支持Fine-tuning|否| +|文件大小|200.28MB| +|词表大小|187961| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_literature_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_literature_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_literature_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_literature_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_literature_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_literature_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_mixed-large_target_word-char_dim300/README.md b/modules/text/embedding/w2v_mixed-large_target_word-char_dim300/README.md index c0fa143c..02e1c7e1 100644 --- a/modules/text/embedding/w2v_mixed-large_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_mixed-large_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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-large_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|mixed| +|是否支持Fine-tuning|否| +|文件大小|1.35GB| +|词表大小|1292552| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_mixed-large_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_mixed-large_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_mixed-large_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_mixed-large_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_mixed-large_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_mixed-large_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_mixed-large_target_word-word_dim300/README.md b/modules/text/embedding/w2v_mixed-large_target_word-word_dim300/README.md index 3f5812c6..ed987eb6 100644 --- a/modules/text/embedding/w2v_mixed-large_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_mixed-large_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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-large_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|mixed| +|是否支持Fine-tuning|否| +|文件大小|1.35GB| +|词表大小|1292483| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_mixed-large_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_mixed-large_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_mixed-large_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_mixed-large_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_mixed-large_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_mixed-large_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_people_daily_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_people_daily_target_bigram-char_dim300/README.md index 171c362a..c3fcc722 100644 --- a/modules/text/embedding/w2v_people_daily_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_people_daily_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|people_daily| +|是否支持Fine-tuning|否| +|文件大小|379.96MB| +|词表大小|356055| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_people_daily_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_people_daily_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_people_daily_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_people_daily_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_people_daily_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_people_daily_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_people_daily_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_people_daily_target_word-bigram_dim300/README.md index e2c5d4d6..6f450cde 100644 --- a/modules/text/embedding/w2v_people_daily_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_people_daily_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|people_daily| +|是否支持Fine-tuning|否| +|文件大小|379.68MB| +|词表大小|355991| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_people_daily_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_people_daily_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_people_daily_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_people_daily_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_people_daily_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_people_daily_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_people_daily_target_word-char_dim300/README.md b/modules/text/embedding/w2v_people_daily_target_word-char_dim300/README.md index 97cb9491..249f683c 100644 --- a/modules/text/embedding/w2v_people_daily_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_people_daily_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|people_daily| +|是否支持Fine-tuning|否| +|文件大小|379.45MB| +|词表大小|355998| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_people_daily_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_people_daily_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_people_daily_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_people_daily_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_people_daily_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_people_daily_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_people_daily_target_word-word_dim300/README.md b/modules/text/embedding/w2v_people_daily_target_word-word_dim300/README.md index 9df53cd4..ab23fd7b 100644 --- a/modules/text/embedding/w2v_people_daily_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_people_daily_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|people_daily| +|是否支持Fine-tuning|否| +|文件大小|378.93MB| +|词表大小|355989| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_people_daily_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_people_daily_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_people_daily_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_people_daily_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_people_daily_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_people_daily_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_sikuquanshu_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_sikuquanshu_target_word-bigram_dim300/README.md index d2d00c45..c8983808 100644 --- a/modules/text/embedding/w2v_sikuquanshu_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_sikuquanshu_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|sikuquanshu| +|是否支持Fine-tuning|否| +|文件大小|20.77MB| +|词表大小|19529| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_sikuquanshu_target_word-bigram_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_sikuquanshu_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_sikuquanshu_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_sikuquanshu_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_sikuquanshu_target_word-bigram_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_sikuquanshu_target_word-bigram_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_sikuquanshu_target_word-word_dim300/README.md b/modules/text/embedding/w2v_sikuquanshu_target_word-word_dim300/README.md index 55953232..32a5b6df 100644 --- a/modules/text/embedding/w2v_sikuquanshu_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_sikuquanshu_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|sikuquanshu| +|是否支持Fine-tuning|否| +|文件大小|20.70MB| +|词表大小|19529| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_sikuquanshu_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_sikuquanshu_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_sikuquanshu_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_sikuquanshu_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_sikuquanshu_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_sikuquanshu_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_sogou_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_sogou_target_bigram-char_dim300/README.md index b47d51bd..9e984821 100644 --- a/modules/text/embedding/w2v_sogou_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_sogou_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|sogou| +|是否支持Fine-tuning|否| +|文件大小|389.81MB| +|词表大小|365112| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_sogou_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_sogou_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_sogou_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_sogou_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_sogou_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_sogou_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_sogou_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_sogou_target_word-bigram_dim300/README.md index 48695c35..728221d2 100644 --- a/modules/text/embedding/w2v_sogou_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_sogou_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|sogou| +|是否支持Fine-tuning|否| +|文件大小|388.66MB| +|词表大小|364994| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_sogou_target_word-bigram_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_sogou_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_sogou_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_sogou_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_sogou_target_word-bigram_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_sogou_target_word-bigram_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_sogou_target_word-char_dim300/README.md b/modules/text/embedding/w2v_sogou_target_word-char_dim300/README.md index fcb06ce9..575f6acd 100644 --- a/modules/text/embedding/w2v_sogou_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_sogou_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|sogou| +|是否支持Fine-tuning|否| +|文件大小|389.89MB| +|词表大小|365078| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_sogou_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_sogou_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_sogou_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_sogou_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_sogou_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_sogou_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_sogou_target_word-word_dim300/README.md b/modules/text/embedding/w2v_sogou_target_word-word_dim300/README.md index bc264a72..f1d86bea 100644 --- a/modules/text/embedding/w2v_sogou_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_sogou_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|sogou| +|是否支持Fine-tuning|否| +|文件大小|388.66MB| +|词表大小|364992| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_sogou_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_sogou_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_sogou_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_sogou_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_sogou_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_sogou_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_weibo_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_weibo_target_bigram-char_dim300/README.md index fc4262a1..8c7cff9f 100644 --- a/modules/text/embedding/w2v_weibo_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_weibo_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|weibo| +|是否支持Fine-tuning|否| +|文件大小|208.24MB| +|词表大小|195199| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_weibo_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_weibo_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_weibo_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_weibo_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_weibo_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_weibo_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_weibo_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_weibo_target_word-bigram_dim300/README.md index f20eacee..75e8defb 100644 --- a/modules/text/embedding/w2v_weibo_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_weibo_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|weibo| +|是否支持Fine-tuning|否| +|文件大小|208.19MB| +|词表大小|195204| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_weibo_target_word-bigram_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_weibo_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_weibo_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_weibo_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_weibo_target_word-bigram_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_weibo_target_word-bigram_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_weibo_target_word-char_dim300/README.md b/modules/text/embedding/w2v_weibo_target_word-char_dim300/README.md index d6393e34..bac3d11a 100644 --- a/modules/text/embedding/w2v_weibo_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_weibo_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|weibo| +|是否支持Fine-tuning|否| +|文件大小|208.03MB| +|词表大小|195204| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_weibo_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_weibo_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_weibo_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_weibo_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_weibo_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_weibo_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_weibo_target_word-word_dim300/README.md b/modules/text/embedding/w2v_weibo_target_word-word_dim300/README.md index ea1f5971..eed0224a 100644 --- a/modules/text/embedding/w2v_weibo_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_weibo_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|weibo| +|是否支持Fine-tuning|否| +|文件大小|207.94MB| +|词表大小|195204| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_weibo_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_weibo_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_weibo_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_weibo_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_weibo_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_weibo_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_wiki_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_wiki_target_bigram-char_dim300/README.md index 007012f4..b655a038 100644 --- a/modules/text/embedding/w2v_wiki_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_wiki_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|wiki| +|是否支持Fine-tuning|否| +|文件大小|375.98MB| +|词表大小|352274| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_wiki_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_wiki_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_wiki_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_wiki_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_wiki_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_wiki_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_wiki_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_wiki_target_word-bigram_dim300/README.md index 53bd2c35..1c9eb467 100644 --- a/modules/text/embedding/w2v_wiki_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_wiki_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|wiki| +|是否支持Fine-tuning|否| +|文件大小|375.72MB| +|词表大小|352219| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_wiki_target_word-bigram_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_wiki_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_wiki_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_wiki_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_wiki_target_word-bigram_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_wiki_target_word-bigram_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_wiki_target_word-char_dim300/README.md b/modules/text/embedding/w2v_wiki_target_word-char_dim300/README.md index 0c8d321f..0c203ab9 100644 --- a/modules/text/embedding/w2v_wiki_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_wiki_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|wiki| +|是否支持Fine-tuning|否| +|文件大小|375.52MB| +|词表大小|352223| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_wiki_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_wiki_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_wiki_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_wiki_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_wiki_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_wiki_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_wiki_target_word-word_dim300/README.md b/modules/text/embedding/w2v_wiki_target_word-word_dim300/README.md index 9d8b9204..3b8bed09 100644 --- a/modules/text/embedding/w2v_wiki_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_wiki_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|wiki| +|是否支持Fine-tuning|否| +|文件大小|374.95MB| +|词表大小|352219| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_wiki_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_wiki_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_wiki_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_wiki_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_wiki_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_wiki_target_word-word_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_zhihu_target_bigram-char_dim300/README.md b/modules/text/embedding/w2v_zhihu_target_bigram-char_dim300/README.md index 5dceb66a..edb05155 100644 --- a/modules/text/embedding/w2v_zhihu_target_bigram-char_dim300/README.md +++ b/modules/text/embedding/w2v_zhihu_target_bigram-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_bigram-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|zhihu| +|是否支持Fine-tuning|否| +|文件大小|277.35MB| +|词表大小|259755| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_zhihu_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_zhihu_target_bigram-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_zhihu_target_bigram-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_zhihu_target_bigram-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_zhihu_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_zhihu_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_zhihu_target_word-bigram_dim300/README.md b/modules/text/embedding/w2v_zhihu_target_word-bigram_dim300/README.md index 5a3226bf..5f0613f7 100644 --- a/modules/text/embedding/w2v_zhihu_target_word-bigram_dim300/README.md +++ b/modules/text/embedding/w2v_zhihu_target_word-bigram_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-bigram_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|zhihu| +|是否支持Fine-tuning|否| +|文件大小|277.53MB| +|词表大小|259885| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_zhihu_target_bigram-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_zhihu_target_word-bigram_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_zhihu_target_word-bigram_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_zhihu_target_word-bigram_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_zhihu_target_bigram-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_zhihu_target_bigram-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_zhihu_target_word-char_dim300/README.md b/modules/text/embedding/w2v_zhihu_target_word-char_dim300/README.md index e41c6c8c..b07c6ddd 100644 --- a/modules/text/embedding/w2v_zhihu_target_word-char_dim300/README.md +++ b/modules/text/embedding/w2v_zhihu_target_word-char_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-char_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|zhihu| +|是否支持Fine-tuning|否| +|文件大小|277.40MB| +|词表大小|259940| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_zhihu_target_word-char_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_zhihu_target_word-char_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_zhihu_target_word-char_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_zhihu_target_word-char_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_zhihu_target_word-char_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_zhihu_target_word-char_dim300==1.0.1 + ``` diff --git a/modules/text/embedding/w2v_zhihu_target_word-word_dim300/README.md b/modules/text/embedding/w2v_zhihu_target_word-word_dim300/README.md index c4b33704..c95a42f3 100644 --- a/modules/text/embedding/w2v_zhihu_target_word-word_dim300/README.md +++ b/modules/text/embedding/w2v_zhihu_target_word-word_dim300/README.md @@ -1,144 +1,172 @@ -## 概述 -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_target_word-word_dim300| +| :--- | :---: | +|类别|文本-词嵌入| +|网络|w2v| +|数据集|zhihu| +|是否支持Fine-tuning|否| +|文件大小|276.98MB| +|词表大小|259871| +|最新更新日期|2021-04-28| +|数据指标|-| -## API +## 一、模型基本信息 -```python -def __init__( - *args, - **kwargs -) -``` +- ### 模型介绍 -创建一个Embedding Module对象，默认无需参数。 + - PaddleHub提供多个开源的预训练Embedding模型。这些Embedding模型可根据不同语料、不同训练方式和不同的维度进行区分，关于模型的具体信息可参考PaddleNLP的文档：[Embedding模型汇总](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/docs/embeddings.md) -**参数** -* `*args`： 用户额外指定的列表类型的参数。 -* `**kwargs`：用户额外指定的关键字字典类型的参数。 +## 二、安装 -关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) +- ### 1、环境依赖 + - paddlepaddle >= 2.0.0 -```python -def search( - words: Union[List[str], str, int], -) -``` + - paddlehub >= 2.0.0 | [如何安装PaddleHub](../../../../docs/docs_ch/get_start/installation.rst) -获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 +- ### 2、安装 -**参数** -* `words`： 需要获取的词向量的词、词列表或者词编号。 + - ```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 -```python -def cosine_sim( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 +- ### 1、预测代码示例 -**参数** -* `word_a`： 需要计算余弦相似度的单词a。 -* `word_b`： 需要计算余弦相似度的单词b。 + - ```python + import paddlehub as hub + embedding = hub.Module(name='w2v_zhihu_target_word-word_dim300') + # 获取单词的embedding + embedding.search("中国") + # 计算两个词向量的余弦相似度 + embedding.cosine_sim("中国", "美国") + # 计算两个词向量的内积 + embedding.dot("中国", "美国") + ``` -```python -def dot( - word_a: str, - word_b: str, -) -``` -计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 +- ### 2、API -**参数** -* `word_a`： 需要计算内积的单词a。 -* `word_b`： 需要计算内积的单词b。 + - ```python + def __init__( + *args, + **kwargs + ) + ``` + - 创建一个Embedding Module对象，默认无需参数。 -```python -def get_vocab_path() -``` -获取本地词表文件的路径信息。 + - **参数** + - `*args`： 用户额外指定的列表类型的参数。 + - `**kwargs`：用户额外指定的关键字字典类型的参数。 + - 关于额外参数的详情可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -```python -def get_tokenizer(*args, **kwargs) -``` -获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -**参数** -* `*args`： 额外传递的列表形式的参数。 -* `**kwargs`： 额外传递的字典形式的参数。 + - ```python + def search( + words: Union[List[str], str, int], + ) + ``` -关于额外参数的详情，可查看[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/develop/PaddleNLP/paddlenlp/data/tokenizer.py) + - 获取一个或多个词的embedding。输入可以是`str`、`List[str]`和`int`类型，分别代表获取一个词，多个词和指定词编号的embedding，词的编号和模型的词典相关，词典可通过模型实例的`vocab`属性获取。 + - **参数** + - `words`： 需要获取的词向量的词、词列表或者词编号。 -更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -## 代码示例 + - ```python + def cosine_sim( + word_a: str, + word_b: str, + ) + ``` -```python -import paddlehub as hub -embedding = hub.Module(name='w2v_zhihu_target_word-word_dim300') + - 计算两个词embedding的余弦相似度。需要注意的是`word_a`和`word_b`都需要是词典里的单词，否则将会被认为是OOV(Out-Of-Vocabulary)，同时被替换为`unknown_token`。 -# 获取单词的embedding -embedding.search("中国") -# 计算两个词向量的余弦相似度 -embedding.cosine_sim("中国", "美国") -# 计算两个词向量的内积 -embedding.dot("中国", "美国") -``` + - **参数** + - `word_a`： 需要计算余弦相似度的单词a。 + - `word_b`： 需要计算余弦相似度的单词b。 -## 部署服务 -通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 + - ```python + def dot( + word_a: str, + word_b: str, + ) + ``` -### Step1: 启动PaddleHub Serving + - 计算两个词embedding的内积。对于输入单词同样需要注意OOV问题。 -运行启动命令： + - **参数** + - `word_a`： 需要计算内积的单词a。 + - `word_b`： 需要计算内积的单词b。 -```shell -$ hub serving start -m w2v_zhihu_target_word-word_dim300 -``` -这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + - ```python + def get_vocab_path() + ``` -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + - 获取本地词表文件的路径信息。 -### Step2: 发送预测请求 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + - ```python + def get_tokenizer(*args, **kwargs) + ``` -```python -import requests -import json + - 获取当前模型的tokenizer，返回一个JiebaTokenizer的实例，当前只支持中文embedding模型。 -# 指定用于计算余弦相似度的单词对[[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://10.12.121.132:8866/predict/w2v_zhihu_target_word-word_dim300" -# 指定post请求的headers为application/json方式 -headers = {"Content-Type": "application/json"} + - **参数** + - `*args`： 额外传递的列表形式的参数。 + - `**kwargs`： 额外传递的字典形式的参数。 -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -print(r.json()) -``` + - 关于额外参数的详情可参考[paddlenlp.data.tokenizer.JiebaTokenizer](https://github.com/PaddlePaddle/models/blob/release/2.0-beta/PaddleNLP/paddlenlp/data/tokenizer.py) -## 查看代码 + - 更多api详情和用法可参考[paddlenlp.embeddings](https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings) -https://github.com/PaddlePaddle/models/tree/release/2.0-beta/PaddleNLP/paddlenlp/embeddings -## 依赖 +## 四、部署服务 -paddlepaddle >= 2.0.0 +- 通过PaddleHub Serving，可以部署一个在线获取两个词向量的余弦相似度的服务。 -paddlehub >= 2.0.0 +- ### Step1: 启动PaddleHub Serving -## 更新历史 + - 运行启动命令： + + - ```shell + $ hub serving start -m w2v_zhihu_target_word-word_dim300 + ``` + + - 这样就完成了一个获取词向量的余弦相似度服务化API的部署，默认端口号为8866。 + + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 + +- ### 第二步: 发送预测请求 + + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + + - ```python + import requests + import json + + # 指定用于计算余弦相似度的单词对[[word_a, word_b], [word_a, word_b], ... ]] + word_pairs = [["中国", "美国"], ["今天", "明天"]] + # 以key的方式指定word_pairs传入预测方法的时的参数，此例中为"data"，对于每一对单词，调用cosine_sim进行余弦相似度的计算 + data = {"data": word_pairs} + # 发送post请求，content-type类型应指定json方式，url中的ip地址需改为对应机器的ip + url = "http://127.0.0.1:8866/predict/w2v_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()) + ``` + + +## 五、更新历史 * 1.0.0 @@ -146,4 +174,7 @@ paddlehub >= 2.0.0 * 1.0.1 - 支持基于embedding的文本分类和序列标注finetune任务 + 优化模型 + - ```shell + $ hub install w2v_zhihu_target_word-word_dim300==1.0.1 + ``` -- Gitee