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 0dd8bd27346fbc3f636f1a4f189a001fa48edbdc..4f8d0c293c895b3c4ec66eb32c0d4a4053bb0ab0 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 dd1edcb69c446c7eb552c9a2c1058c48e997fad3..9bba94ff64ebd09faf794ab8c7af17fab55ec120 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 30c61f55aa457a72ecb9e1f5044af6e30c8d7e10..3e9b300ba0d989b1cdd9255565a6b31d3680ac88 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 a1f31284b35cbe9f19c8525e3eccc38ee5a15fba..b80d1d7d316794c451ad3c02ae60e21efefcf65c 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 ab60490600457b6fa8c0a83775f21ec69efd0041..6baea2fd59fd599fd14586a57a64bbbab762d8bd 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 6770c0d3423273836a91c49a9b06233d704a44a1..029baf8d1a4c5fc8611e334d9d18493175baf9b4 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 cbe1760caa2f14f669da5eba67317b98f7ef9b8e..b3eedc46acb4744c9299c885e583d39a82d88fef 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 ea8e7872e3bd4928e856735be6fe02e98e2c52a5..68c5ecd57d4d72b7f8b7059c952d689bfaf9f4dc 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 a8e67d620b8d51c472055b75467dc60fcf19f32b..f92fe8948a5f9cfa31e6bbfc7f3fb52a8cca73fb 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 ee25f85bab1f1823b4a93141b266eec663f3341c..edba1569e0beeca32b7a1b4378ea417e07cb7d08 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 3b712b12dfd7f088ff82a88321600382619ee4c2..c5fab77a062e711149a3d1d5cf9646782797f3cc 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 77911202e7666a926adae1b0781b9352d5bd79a9..f88623c0342cd2972a43ef318c3a40a2ee186485 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 863f5932586b323681cb8814d9aaea215e9b294e..bbf8ec37bf3a631bde6ae3427b08fdf7c2e85b3d 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 2936f5e0554403558919d2003e6fe826a3b9b829..efaf4cdb57392c48466d75f6b5d7352a921b37a8 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 3f5461c8aa67023cd4cc1ff846c46dd608868219..489fba9be22c41f99a96853ad25dcb3d5d97d7d6 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 676ac10828de44f34b92783f6a884315542c1701..ecd24c40dcef0ae19b2d77d9f0c1050a7cfa1c9c 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 4f5c2465dc1877eec7969d539cd8d3e961fbb8a0..d0fee96ffca7a5d09f8829bfcca24e3b615637f0 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 a04bd1391dd83de6b0c67bcf737dd25cf9a0d85d..6c91b7c1110c3db811bc79b3130b288aaa32b51a 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 b1bf197cd8d4888f5650c52cbba942aea57c8749..2bf5e93cda0f20288e3198dc1658078a9f15fd77 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 f42d628d494b406ab1bc7ad856b364f1abe58980..09467ef670cbe7557f7d0be68881d1c1dab02718 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 6c0714d1c21978c32f9aea1fed31d5b3907ec6b7..cbf664f3b916c9cb144ad0ddbd6d55a8c7d4dd43 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 384ef04cd167fca9a829e1c8cbc83cd82993c9d4..1358567413cc9e71b15641cdd0ce6e708c6a9d66 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 bdfe3a70580798c74518afff6ae1f3aa1c2fffe5..8471592a07491f0fdf2d8329afcd388cb2946ed2 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 cce2987b1d4a031e09a6087af44843e75ce425f7..b6d1429b633ce52e6f329929d3a60ac0b5916640 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 5da791f7c7a88e388f648a3c27c55daec232dd56..b50eee0cbd86dc13fe1025c02c00de4c9f2b8005 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 5d60020e062cc7a3db4b2277f7473d7b9e227d8c..e6b48044a171809d394008e6213e20140728d9a2 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 3ce088360ae8e72116be2a6459f00f23fbfd41da..7cd37e6a31b9d8fe7cc144c203460caa691e26db 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 756a3bc4d5e08a86c6b9d16616d0e669a94ce3bc..8a02ec85aed7be1968f43cb5c844666ba75eb20e 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 9e37a31fd5935793dbd374b700bf574c5d8b6a3c..68b4e3f2b2814308f8080f4ac2f663e81ee8f957 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 0b14e5461c787e241acafeb0670bcd36a05d3dcd..8a80e7193cad58e5774a302b4b2b595f10d03d7b 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 b979aea164f2191368e391fdaf84ac98db848bde..2a136a52a1dd3b94924aa5432560866f55b437c0 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 f32a61e4d82e7f654882039491a142ce063d6198..0eb2271b30efe20c94fb94af69c2a51b9e6ad816 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 b23097319bfa2e872e9a10871a6086ff835b5d17..81d7528489d1c00866e99936ffd9fc2562a0e81a 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 07e8cc252723f199a88512728e9b7f25e5b9fa37..f05cd2d63e4db4b791af1755161970971d561fb2 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 ef9fd0ff968b9b79c5f437dee2eda0d826f84630..2c7f7155f705ee4a63cea06d471677cfa3853e89 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 6a0432315e5b1d88113f1f95a082e6975c9a21ae..ae45d41740384aa1afd9812ed43eee280f4c0d1e 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 67032fbb3c23365f1e4846889c1c136efdf04e02..3e9e7c6197af65052157bf8c7bfe565b34a13948 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 c0fa143c038dd844bcc326c36854c5d824267233..02e1c7e1d91270c54b6123f38c02e82b3613e7e6 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 3f5812c6249b25a9bd91296bdfb6f20a8bceaf30..ed987eb670bbb4264a8d0ba91faa5200d2d47900 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 171c362ad04560e26b414e474d945cc20e660a66..c3fcc7226610be97196f8609fbde66aacc91730f 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 e2c5d4d6e492e4379379bbebd5aaaa7553147f8e..6f450cde7ef6621181f50f8e1c5b18ac5af1013b 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 97cb9491876b9e520caf7927e40c6672fc391ffe..249f683cbbd8500c4c0f4b976601151efaf42fcf 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 9df53cd4f63da779b8519f5d3dcc453324ba82a4..ab23fd7b2b724436e707c6fc2e3d2e059cd81ed4 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 d2d00c45d1856d30096311673e7a1d9095da5576..c8983808b189e059b441229fb372c89e4158d3c0 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 5595323223664601a541d6cd8e2cc704f36dd5ef..32a5b6df8d95cae1d2cc924ccde6e2a31a71c8e2 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 b47d51bd1312eeea11fb5ca8c3f06b073f27b532..9e984821d5ce7a7110167af1cff10cf481b41f40 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 48695c354cbe36aee204f92f6298045dc394a553..728221d2d28de4126184cdeaa90ba6ba0f09a09d 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 fcb06ce9e478529e219e64c105ba9f405534e4dd..575f6acde662dc71f70b9bb6d4075a1a9d1ec1af 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 bc264a7280c7a8195742b428e37dfa73de3a92ca..f1d86bea2512b79535d9e52d702aace58ab99596 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 fc4262a138624e3efe7655dce765ae415cfcdd56..8c7cff9fdee886deb434566859f34cd5790e72b8 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 f20eaceeaa3d5ab5f75138e0f0a9d424fecd6c46..75e8defba0978722a4e67fd33bb39676edd235f6 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 d6393e34a5519521bd59dc2d4e090b9444abbac0..bac3d11a807309353138e4ac3a5932b3cf8b7ac0 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 ea1f5971831cdc2a4adc8f583fff712fc86ff1f6..eed0224a7df26470fd6eb5db387a59c7740f34ce 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 007012f4145180baf874d25c36e84ab5800fc936..b655a0384196134bf9f9d0e6092c8b5f776c119b 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 53bd2c35901b5bd808d58976a91b6eea60341cdf..1c9eb46750652d8087243fe7bfa3c0f411dbd193 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 0c8d321ffa9b2f7ac43cf0078b2bda0468472755..0c203ab9e8be286ccbc544ddbebfdc256ab52c06 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 9d8b9204abf1ffe3dcd296d16aa62b57e5f79b17..3b8bed093910506e64d55c18cc8b3dce891b32ca 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 5dceb66ac6a25dd6fecf9e50e63a36d2e029504d..edb05155462bec1ca774aaf57b31fb47774d18da 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 5a3226bf7f2dbe9bee6dd68eb445f5f31fa216b5..5f0613f7b75b75b2c8b3b97f2135e96e7342db6e 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 e41c6c8ce646878a13e4df9d78aee64196b5c3cc..b07c6dddae8a12b482935b1380ae271d55019480 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 c4b3370417df369a00070ebde93fe1e5cd88e022..c95a42f34516355bae7eccee5e52954096ca7b89 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
+    ```