check了 embeddings 的文档

docs/source/fastNLP.embeddings.contextual_embedding.rst

@@ -1,7 +0,0 @@
-fastNLP.embeddings.contextual\_embedding
-========================================
-
-.. automodule:: fastNLP.embeddings.contextual_embedding
-   :members:
-   :undoc-members:
-   :show-inheritance:

docs/source/fastNLP.embeddings.rst

@@ -14,7 +14,6 @@ fastNLP.embeddings
 
    fastNLP.embeddings.bert_embedding
    fastNLP.embeddings.char_embedding
-   fastNLP.embeddings.contextual_embedding
    fastNLP.embeddings.elmo_embedding
    fastNLP.embeddings.embedding
    fastNLP.embeddings.stack_embedding

fastNLP/embeddings/__init__.py

@@ -1,7 +1,7 @@
 """
 embeddings 模块主要用于从各种预训练的模型中获取词语的分布式表示，目前支持的预训练模型包括word2vec, glove, ELMO, BERT等。这里所有
-embedding的forward输入都是形状为(batch_size, max_len)的torch.LongTensor，输出都是(batch_size, max_len, embedding_dim)的
-torch.FloatTensor。所有的embedding都可以使用num_embedding获取最大的输入index范围, 用embedding_dim或embed_size获取embedding的
+embedding的forward输入都是形状为 ``(batch_size, max_len)`` 的torch.LongTensor，输出都是 ``(batch_size, max_len, embedding_dim)`` 的
+torch.FloatTensor。所有的embedding都可以使用 `self.num_embedding` 获取最大的输入index范围, 用 `self.embeddig_dim` 或 `self.embed_size` 获取embedding的
 输出维度。
 """
 

fastNLP/embeddings/bert_embedding.py

@@ -18,8 +18,8 @@ class BertEmbedding(ContextualEmbedding):
     别名：:class:`fastNLP.embeddings.BertEmbedding`   :class:`fastNLP.embeddings.bert_embedding.BertEmbedding`
 
     使用BERT对words进行编码的Embedding。建议将输入的words长度限制在430以内，而不要使用512(根据预训练模型参数，可能有变化)。这是由于
-        预训练的bert模型长度限制为512个token，而因为输入的word是未进行word piece分割的(word piece的分割有BertEmbedding在输入word
-        时切分)，在分割之后长度可能会超过最大长度限制。
+    预训练的bert模型长度限制为512个token，而因为输入的word是未进行word piece分割的(word piece的分割有BertEmbedding在输入word
+    时切分)，在分割之后长度可能会超过最大长度限制。
 
     BertEmbedding可以支持自动下载权重，当前支持的模型有以下的几种(待补充):
 
@@ -34,13 +34,13 @@ class BertEmbedding(ContextualEmbedding):
         >>> outputs.size()
         >>> # torch.Size([1, 5, 2304])
 
-    :param fastNLP.Vocabulary vocab: 词表
+    :param ~fastNLP.Vocabulary vocab: 词表
     :param str model_dir_or_name: 模型所在目录或者模型的名称。当传入模型所在目录时，目录中应该包含一个词表文件(以.txt作为后缀名),
         权重文件(以.bin作为文件后缀名), 配置文件(以.json作为后缀名)。
-    :param str layers:输出embedding表示来自于哪些层，不同层的结果按照layers中的顺序在最后一维concat起来。以','隔开层数，可以以负数
+    :param str layers: 输出embedding表示来自于哪些层，不同层的结果按照layers中的顺序在最后一维concat起来。以','隔开层数，可以以负数
         去索引倒数几层。
     :param str pool_method: 因为在bert中，每个word会被表示为多个word pieces, 当获取一个word的表示的时候，怎样从它的word pieces
-        中计算得到它对应的表示。支持``last``, ``first``, ``avg``, ``max``。
+        中计算得到它对应的表示。支持 ``last`` , ``first`` , ``avg`` , ``max``。
     :param float word_dropout: 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
     :param float dropout: 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
     :param bool include_cls_sep: bool，在bert计算句子的表示的时候，需要在前面加上[CLS]和[SEP], 是否在结果中保留这两个内容。 这样
@@ -95,6 +95,7 @@ class BertEmbedding(ContextualEmbedding):
     def requires_grad(self):
         """
         Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许
+        
         :return:
         """
         requires_grads = set([param.requires_grad for name, param in self.named_parameters()
@@ -116,8 +117,8 @@ class BertWordPieceEncoder(nn.Module):
     """
     读取bert模型，读取之后调用index_dataset方法在dataset中生成word_pieces这一列。
 
-    :param str model_dir_or_name: 模型所在目录或者模型的名称。默认值为``en-base-uncased``
-    :param str layers:最终结果中的表示。以','隔开层数，可以以负数去索引倒数几层
+    :param str model_dir_or_name: 模型所在目录或者模型的名称。默认值为 ``en-base-uncased``
+    :param str layers: 最终结果中的表示。以','隔开层数，可以以负数去索引倒数几层
     :param bool requires_grad: 是否需要gradient。
     """
     def __init__(self, model_dir_or_name: str='en-base-uncased', layers: str='-1',

fastNLP/embeddings/char_embedding.py

@@ -20,7 +20,7 @@ class CNNCharEmbedding(TokenEmbedding):
     别名：:class:`fastNLP.embeddings.CNNCharEmbedding`   :class:`fastNLP.embeddings.char_embedding.CNNCharEmbedding`
 
     使用CNN生成character embedding。CNN的结构为, embed(x) -> Dropout(x) -> CNN(x) -> activation(x) -> pool -> fc -> Dropout.
-        不同的kernel大小的fitler结果是concat起来然后通过一层fully connected layer, 然后输出word的表示。
+    不同的kernel大小的fitler结果是concat起来然后通过一层fully connected layer, 然后输出word的表示。
 
     Example::
 
@@ -274,6 +274,7 @@ class LSTMCharEmbedding(TokenEmbedding):
     def requires_grad(self):
         """
         Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许
+        
         :return:
         """
         params = []

fastNLP/embeddings/elmo_embedding.py

@@ -15,11 +15,12 @@ from .contextual_embedding import ContextualEmbedding
 
 class ElmoEmbedding(ContextualEmbedding):
     """
-    别名：:class:`fastNLP.modules.ElmoEmbedding`   :class:`fastNLP.modules.encoder.embedding.ElmoEmbedding`
+    别名：:class:`fastNLP.embeddings.ElmoEmbedding`   :class:`fastNLP.embeddings.elmo_embedding.ElmoEmbedding`
 
     使用ELMo的embedding。初始化之后，只需要传入words就可以得到对应的embedding。当前支持的使用名称初始化的模型有以下的这些(待补充)
 
     Example::
+    
         >>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
         >>> # 使用不同层的concat的结果
         >>> embed = ElmoEmbedding(vocab, model_dir_or_name='en', layers='1,2', requires_grad=False)
@@ -91,6 +92,7 @@ class ElmoEmbedding(ContextualEmbedding):
         """
         当初始化ElmoEmbedding时layers被设置为mix时，可以通过调用该方法设置mix weights是否可训练。如果layers不是mix，调用
         该方法没有用。
+        
         :param bool flag: 混合不同层表示的结果是否可以训练。
         :return:
         """
@@ -109,8 +111,8 @@ class ElmoEmbedding(ContextualEmbedding):
     def forward(self, words: torch.LongTensor):
         """
         计算words的elmo embedding表示。根据elmo文章中介绍的ELMO实际上是有2L+1层结果，但是为了让结果比较容易拆分，token的
-            被重复了一次，使得实际上layer=0的结果是[token_embedding;token_embedding], 而layer=1的结果是[forward_hiddens;
-            backward_hiddens].
+        被重复了一次，使得实际上layer=0的结果是[token_embedding;token_embedding], 而layer=1的结果是[forward_hiddens;
+        backward_hiddens].
 
         :param words: batch_size x max_len
         :return: torch.FloatTensor. batch_size x max_len x (512*len(self.layers))

fastNLP/embeddings/embedding.py

@@ -1,5 +1,5 @@
 """
-该模块中的Embedding主要用于随机初始化的embedding(更推荐使用 :class: StaticEmbedding)，或按照预训练权重初始化Embedding。
+该模块中的Embedding主要用于随机初始化的embedding(更推荐使用 :class:`fastNLP.embeddings.StaticEmbedding` )，或按照预训练权重初始化Embedding。
 
 """
 

fastNLP/embeddings/static_embedding.py

@@ -16,8 +16,8 @@ class StaticEmbedding(TokenEmbedding):
     别名：:class:`fastNLP.embeddings.StaticEmbedding`   :class:`fastNLP.embeddings.static_embedding.StaticEmbedding`
 
     StaticEmbedding组件. 给定预训练embedding的名称或路径，根据vocab从embedding中抽取相应的数据(只会将出现在vocab中的词抽取出来，
-        如果没有找到，则会随机初始化一个值(但如果该word是被标记为no_create_entry的话，则不会单独创建一个值，而是会被指向unk的index))。
-        当前支持自动下载的预训练vector有以下的几种(待补充);
+    如果没有找到，则会随机初始化一个值(但如果该word是被标记为no_create_entry的话，则不会单独创建一个值，而是会被指向unk的index))。
+    当前支持自动下载的预训练vector有以下的几种(待补充);
 
     Example::
 
@@ -141,6 +141,7 @@ class StaticEmbedding(TokenEmbedding):
     def requires_grad(self):
         """
         Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许
+        
         :return:
         """
         requires_grads = set([param.requires_grad for name, param in self.named_parameters()

fastNLP/embeddings/utils.py

@@ -25,12 +25,12 @@ def _construct_char_vocab_from_vocab(vocab:Vocabulary, min_freq:int=1):
 def get_embeddings(init_embed):
     """
     根据输入的init_embed返回Embedding对象。如果输入是tuple, 则随机初始化一个nn.Embedding; 如果输入是numpy.ndarray, 则按照ndarray
-        的值将nn.Embedding初始化; 如果输入是torch.Tensor, 则按该值初始化nn.Embedding; 如果输入是fastNLP中的embedding将不做处理
-        返回原对象。
+    的值将nn.Embedding初始化; 如果输入是torch.Tensor, 则按该值初始化nn.Embedding; 如果输入是fastNLP中的embedding将不做处理
+    返回原对象。
 
     :param init_embed: 可以是 tuple:(num_embedings, embedding_dim), 即embedding的大小和每个词的维度;也可以传入
-        nn.Embedding 对象, 此时就以传入的对象作为embedding; 传入np.ndarray也行，将使用传入的ndarray作为作为Embedding初始
-        化; 传入orch.Tensor, 将使用传入的值作为Embedding初始化。
+        nn.Embedding 对象, 此时就以传入的对象作为embedding; 传入np.ndarray也行，将使用传入的ndarray作为作为Embedding初始化;
+        传入torch.Tensor, 将使用传入的值作为Embedding初始化。
     :return nn.Embedding embeddings:
     """
     if isinstance(init_embed, tuple):