fastNLP.embeddings

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

class fastNLP.embeddings.Embedding(init_embed, word_dropout=0, dropout=0.0, unk_index=None)[源代码]

别名 fastNLP.embeddings.Embedding fastNLP.embeddings.embedding.Embedding

词向量嵌入,支持输入多种方式初始化. 可以通过self.num_embeddings获取词表大小; self.embedding_dim获取embedding的维度.

Example:

>>> import numpy as np
>>> from fastNLP.embeddings import Embedding
>>> init_embed = (2000, 100)
>>> embed = Embedding(init_embed)  # 随机初始化一个具有2000个词,每个词表示为100维的词向量
>>> init_embed = np.zeros((2000, 100))
>>> embed = Embedding(init_embed)  # 使用numpy.ndarray的值作为初始化值初始化一个Embedding
__init__(init_embed, word_dropout=0, dropout=0.0, unk_index=None)[源代码]
参数:
  • init_embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- 支持传入Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 或传入Tensor, Embedding, numpy.ndarray等则直接使用该值初始化Embedding;
  • word_dropout (float) -- 按照一定概率随机将word设置为unk_index,这样可以使得unk这个token得到足够的训练, 且会对网络有 一定的regularize的作用。设置该值时,必须同时设置unk_index
  • dropout (float) -- 对Embedding的输出的dropout。
  • unk_index (int) -- drop word时替换为的index。fastNLP的Vocabulary的unk_index默认为1。
forward(words)[源代码]
参数:words (torch.LongTensor) -- [batch, seq_len]
返回:torch.Tensor : [batch, seq_len, embed_dim]
requires_grad

Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许 :return:

class fastNLP.embeddings.TokenEmbedding(vocab, word_dropout=0.0, dropout=0.0)[源代码]

别名 fastNLP.embeddings.TokenEmbedding fastNLP.embeddings.embedding.TokenEmbedding

fastNLP中各种Embedding的基类

drop_word(words)[源代码]

按照设定随机将words设置为unknown_index。

参数:words (torch.LongTensor) -- batch_size x max_len
返回:
dropout(words)[源代码]

对embedding后的word表示进行drop。

参数:words (torch.FloatTensor) -- batch_size x max_len x embed_size
返回:
get_word_vocab()[源代码]

返回embedding的词典。

返回:Vocabulary
num_embeddings

这个值可能会大于实际的embedding矩阵的大小。 :return:

requires_grad

Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许 :return:

class fastNLP.embeddings.StaticEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: Optional[str] = 'en', embedding_dim=-1, requires_grad: bool = True, init_method=None, lower=False, dropout=0, word_dropout=0, normalize=False, min_freq=1, **kwargs)[源代码]

基类 fastNLP.embeddings.TokenEmbedding

别名 fastNLP.embeddings.StaticEmbedding fastNLP.embeddings.static_embedding.StaticEmbedding

StaticEmbedding组件. 给定预训练embedding的名称或路径,根据vocab从embedding中抽取相应的数据(只会将出现在vocab中的词抽取出来, 如果没有找到,则会随机初始化一个值(但如果该word是被标记为no_create_entry的话,则不会单独创建一个值,而是会被指向unk的index))。 当前支持自动下载的预训练vector有:

en: 实际为en-glove-840b-300d(常用)
en-glove-6b-50d: glove官方的50d向量
en-glove-6b-100d: glove官方的100d向量
en-glove-6b-200d: glove官方的200d向量
en-glove-6b-300d: glove官方的300d向量
en-glove-42b-300d: glove官方使用42B数据训练版本
en-glove-840b-300d:
en-glove-twitter-27b-25d:
en-glove-twitter-27b-50d:
en-glove-twitter-27b-100d:
en-glove-twitter-27b-200d:
en-word2vec-300d: word2vec官方发布的300d向量
en-fasttext-crawl: fasttext官方发布的300d英文预训练
cn-char-fastnlp-100d: fastNLP训练的100d的character embedding
cn-bi-fastnlp-100d: fastNLP训练的100d的bigram embedding
cn-tri-fastnlp-100d: fastNLP训练的100d的trigram embedding
cn-fasttext: fasttext官方发布的300d中文预训练embedding

Example:

>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import StaticEmbedding
>>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
>>> embed = StaticEmbedding(vocab, model_dir_or_name='en-glove-50d')

>>> vocab = Vocabulary().add_word_lst(["The", 'the', "THE"])
>>> embed = StaticEmbedding(vocab, model_dir_or_name="en-glove-50d", lower=True)
>>> # "the", "The", "THE"它们共用一个vector,且将使用"the"在预训练词表中寻找它们的初始化表示。

>>> vocab = Vocabulary().add_word_lst(["The", "the", "THE"])
>>> embed = StaticEmbedding(vocab, model_dir_or_name=None, embedding_dim=5, lower=True)
>>> words = torch.LongTensor([[vocab.to_index(word) for word in ["The", "the", "THE"]]])
>>> embed(words)
>>> tensor([[[ 0.5773,  0.7251, -0.3104,  0.0777,  0.4849],
             [ 0.5773,  0.7251, -0.3104,  0.0777,  0.4849],
             [ 0.5773,  0.7251, -0.3104,  0.0777,  0.4849]]],
           grad_fn=<EmbeddingBackward>)  # 每种word的输出是一致的。
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: Optional[str] = 'en', embedding_dim=-1, requires_grad: bool = True, init_method=None, lower=False, dropout=0, word_dropout=0, normalize=False, min_freq=1, **kwargs)[源代码]
参数:
  • vocab -- Vocabulary. 若该项为None则会读取所有的embedding。
  • model_dir_or_name -- 可以有两种方式调用预训练好的static embedding:第一种是传入embedding文件夹(文件夹下应该只有一个 以.txt作为后缀的文件)或文件路径;第二种是传入embedding的名称,第二种情况将自动查看缓存中是否存在该模型,没有的话将自动下载。 如果输入为None则使用embedding_dim的维度随机初始化一个embedding。
  • embedding_dim (int) -- 随机初始化的embedding的维度,当该值为大于0的值时,将忽略model_dir_or_name。
  • requires_grad (bool) -- 是否需要gradient. 默认为True
  • init_method (callable) -- 如何初始化没有找到的值。可以使用torch.nn.init.*中各种方法, 传入的方法应该接受一个tensor,并 inplace地修改其值。
  • lower (bool) -- 是否将vocab中的词语小写后再和预训练的词表进行匹配。如果你的词表中包含大写的词语,或者就是需要单独 为大写的词语开辟一个vector表示,则将lower设置为False。
  • dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
  • word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
  • normalize (bool) -- 是否对vector进行normalize,使得每个vector的norm为1。
  • min_freq (int) -- Vocabulary词频数小于这个数量的word将被指向unk。
  • kwargs (dict) -- bool only_train_min_freq: 仅对train中的词语使用min_freq筛选; bool only_norm_found_vector: 默认为False, 是否仅对在预训练中找到的词语使用normalize; bool only_use_pretrain_word: 默认为False, 仅使用出现在pretrain词表中的词,如果该词没有在预训练的词表中出现则为unk。如果embedding不需要更新建议设置为True。
forward(words)[源代码]

传入words的index

参数:words -- torch.LongTensor, [batch_size, max_len]
返回:torch.FloatTensor, [batch_size, max_len, embed_size]
classmethod load(folder)[源代码]
参数:folder (str) -- 该folder下应该有以下三个文件vocab.txt, static_embed.txt, static_hyper.json
返回:
save(folder)[源代码]

将embedding存储到folder下,之后可以通过使用load方法读取

参数:folder (str) -- 会在该folder下生成三个文件, vocab.txt, static_embed_hyper.txt, static_embed_hyper.json. 其中vocab.txt可以用Vocabulary通过load读取; embedding.txt按照word2vec的方式存储,以空格的方式隔开元素, 第一行只有两个元素,剩下的行首先是word然后是各个维度的值; static_embed_hyper.json是StaticEmbedding的超参数
返回:
class fastNLP.embeddings.ElmoEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '2', requires_grad: bool = True, word_dropout=0.0, dropout=0.0, cache_word_reprs: bool = False)[源代码]

基类 fastNLP.embeddings.ContextualEmbedding

别名 fastNLP.embeddings.ElmoEmbedding fastNLP.embeddings.elmo_embedding.ElmoEmbedding

使用ELMo的embedding。初始化之后,只需要传入words就可以得到对应的embedding。 当前支持的使用名称初始化的模型:

en: 即en-medium hidden_size 1024; output_size 12
en-medium: hidden_size 2048; output_size 256
en-origial: hidden_size 4096; output_size 512
en-original-5.5b: hidden_size 4096; output_size 512
en-small: hidden_size 1024; output_size 128

Example:

>>> import torch
>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import ElmoEmbedding
>>> 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)
>>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]])
>>> outputs = embed(words)
>>> outputs.size()
>>> # torch.Size([1, 5, 2048])

>>> # 使用不同层的weighted sum。
>>> embed = ElmoEmbedding(vocab, model_dir_or_name='en', layers='mix', requires_grad=False)
>>> embed.set_mix_weights_requires_grad()  # 使得weighted的权重是可以学习的,但ELMO的LSTM部分是不更新
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '2', requires_grad: bool = True, word_dropout=0.0, dropout=0.0, cache_word_reprs: bool = False)[源代码]
参数:
  • vocab -- 词表
  • model_dir_or_name -- 可以有两种方式调用预训练好的ELMo embedding:第一种是传入ELMo所在文件夹,该文件夹下面应该有两个文件, 其中一个是以json为后缀的配置文件,另一个是以pkl为后缀的权重文件;第二种是传入ELMo版本的名称,将自动查看缓存中是否存在该模型, 没有的话将自动下载并缓存。
  • layers -- str, 指定返回的层数(从0开始), 以,隔开不同的层。如果要返回第二层的结果'2', 返回后两层的结果'1,2'。不同的层的结果 按照这个顺序concat起来,默认为'2'。'mix'会使用可学习的权重结合不同层的表示(权重是否可训练与requires_grad保持一致, 初始化权重对三层结果进行mean-pooling, 可以通过ElmoEmbedding.set_mix_weights_requires_grad()方法只将mix weights设置为可学习。)
  • requires_grad -- bool, 该层是否需要gradient, 默认为False.
  • word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
  • dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
  • cache_word_reprs -- 可以选择对word的表示进行cache; 设置为True的话,将在初始化的时候为每个word生成对应的embedding, 并删除character encoder,之后将直接使用cache的embedding。默认为False。
forward(words: torch.LongTensor)[源代码]

计算words的elmo embedding表示。根据elmo文章中介绍的ELMO实际上是有2L+1层结果,但是为了让结果比较容易拆分,token的 被重复了一次,使得实际上layer=0的结果是[token_embedding;token_embedding], 而layer=1的结果是[forward_hiddens; backward_hiddens].

参数:words -- batch_size x max_len
返回:torch.FloatTensor. batch_size x max_len x (512*len(self.layers))
set_mix_weights_requires_grad(flag=True)[源代码]

当初始化ElmoEmbedding时layers被设置为mix时,可以通过调用该方法设置mix weights是否可训练。如果layers不是mix,调用 该方法没有用。

参数:flag (bool) -- 混合不同层表示的结果是否可以训练。
返回:
class fastNLP.embeddings.BertEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pool_method: str = 'first', word_dropout=0, dropout=0, include_cls_sep: bool = False, pooled_cls=True, requires_grad: bool = True, auto_truncate: bool = False, **kwargs)[源代码]

基类 fastNLP.embeddings.ContextualEmbedding

别名 fastNLP.embeddings.BertEmbedding fastNLP.embeddings.bert_embedding.BertEmbedding

使用BERT对words进行编码的Embedding。建议将输入的words长度限制在430以内,而不要使用512(根据预训练模型参数,可能有变化)。这是由于 预训练的bert模型长度限制为512个token,而因为输入的word是未进行word piece分割的(word piece的分割有BertEmbedding在输入word 时切分),在分割之后长度可能会超过最大长度限制。

BertEmbedding可以支持自动下载权重,当前支持的模型:
en: base-cased en-base-uncased: en-large-cased-wwm: en-large-cased: en-large-uncased: en-large-uncased-wwm cn: 中文BERT wwm by HIT cn-base: 中文BERT base-chinese cn-wwm-ext: 中文BERT wwm by HIT with extra data pretrain. multi-base-cased: multilingual cased multi-base-uncased: multilingual uncased

Example:

>>> import torch
>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import BertEmbedding
>>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
>>> embed = BertEmbedding(vocab, model_dir_or_name='en-base-uncased', requires_grad=False, layers='4,-2,-1')
>>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]])
>>> outputs = embed(words)
>>> outputs.size()
>>> # torch.Size([1, 5, 2304])
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pool_method: str = 'first', word_dropout=0, dropout=0, include_cls_sep: bool = False, pooled_cls=True, requires_grad: bool = True, auto_truncate: bool = False, **kwargs)[源代码]
参数:
  • vocab (Vocabulary) -- 词表
  • model_dir_or_name (str) -- 模型所在目录或者模型的名称。当传入模型所在目录时,目录中应该包含一个词表文件(以.txt作为后缀名), 权重文件(以.bin作为文件后缀名), 配置文件(以.json作为后缀名)。
  • layers (str) -- 输出embedding表示来自于哪些层,不同层的结果按照layers中的顺序在最后一维concat起来。以','隔开层数,层的序号是 从0开始,可以以负数去索引倒数几层。 layer=0为embedding层(包括wordpiece embedding, position embedding和segment embedding)
  • pool_method (str) -- 因为在bert中,每个word会被表示为多个word pieces, 当获取一个word的表示的时候,怎样从它的word pieces 中计算得到它对应的表示。支持 last , first , avg , max
  • word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
  • dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
  • include_cls_sep (bool) -- bool,在bert计算句子的表示的时候,需要在前面加上[CLS]和[SEP], 是否在结果中保留这两个内容。 这样 会使得word embedding的结果比输入的结果长两个token。如果该值为True,则在使用 :class::StackEmbedding 可能会与其它类型的 embedding长度不匹配。
  • pooled_cls (bool) -- 返回的[CLS]是否使用预训练中的BertPool映射一下,仅在include_cls_sep时有效。如果下游任务只取[CLS]做预测, 一般该值为True。
  • requires_grad (bool) -- 是否需要gradient以更新Bert的权重。
  • auto_truncate (bool) -- 当句子words拆分为word pieces长度超过bert最大允许长度(一般为512), 自动截掉拆分后的超过510个 word pieces后的内容,并将第512个word piece置为[SEP]。超过长度的部分的encode结果直接全部置零。一般仅有只使用[CLS] 来进行分类的任务将auto_truncate置为True。
  • kwargs -- int min_freq: 小于该次数的词会被unk代替, 默认为1
drop_word(words)[源代码]

按照设定随机将words设置为unknown_index。

参数:words (torch.LongTensor) -- batch_size x max_len
返回:
forward(words)[源代码]
计算words的bert embedding表示。计算之前会在每句话的开始增加[CLS]在结束增加[SEP], 并根据include_cls_sep判断要不要
删除这两个token的表示。
参数:words (torch.LongTensor) -- [batch_size, max_len]
返回:torch.FloatTensor. batch_size x max_len x (768*len(self.layers))
classmethod load(folder)[源代码]

给定一个folder, 需要包含以下三个内容vocab.txt, bert_embed_hyper.txt, bert_embed/

参数:folder (str) --
返回:
save(folder)[源代码]
将embedding保存到folder这个目录下,将会保存三个文件vocab.txt, bert_embed_hyper.txt, bert_embed/, 其中bert_embed下包含
config.json,pytorch_model.bin,vocab.txt三个文件(该folder下的数据也可以直接被BERTModel读取)
参数:folder (str) --
返回:
class fastNLP.embeddings.BertWordPieceEncoder(model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pooled_cls: bool = False, word_dropout=0, dropout=0, requires_grad: bool = True, **kwargs)[源代码]

别名 fastNLP.embeddings.BertWordPieceEncoder fastNLP.embeddings.bert_embedding.BertWordPieceEncoder

读取bert模型,读取之后调用index_dataset方法在dataset中生成word_pieces这一列。

BertWordPieceEncoder可以支持自动下载权重,当前支持的模型:
en: base-cased en-large-cased-wwm: en-large-cased: en-large-uncased: en-large-uncased-wwm cn: 中文BERT wwm by HIT cn-base: 中文BERT base-chinese cn-wwm-ext: 中文BERT wwm by HIT with extra data pretrain. multi-base-cased: multilingual cased multi-base-uncased: multilingual uncased
__init__(model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pooled_cls: bool = False, word_dropout=0, dropout=0, requires_grad: bool = True, **kwargs)[源代码]
参数:
  • model_dir_or_name (str) -- 模型所在目录或者模型的名称。默认值为 en-base-uncased
  • layers (str) -- 最终结果中的表示。以','隔开层数,可以以负数去索引倒数几层。layer=0为embedding层(包括wordpiece embedding, position embedding和segment embedding)
  • pooled_cls (bool) -- 返回的句子开头的[CLS]是否使用预训练中的BertPool映射一下。如果下游任务取[CLS]做预测,一般该值为True。
  • word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
  • dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
  • requires_grad (bool) -- 是否需要gradient。
drop_word(words)[源代码]

按照设定随机将words设置为unknown_index。

参数:words (torch.LongTensor) -- batch_size x max_len
返回:
forward(word_pieces, token_type_ids=None)[源代码]

计算words的bert embedding表示。传入的words中应该自行包含[CLS]与[SEP]的tag。

参数:
  • words -- batch_size x max_len
  • token_type_ids -- batch_size x max_len, 用于区分前一句和后一句话. 如果不传入,则自动生成(大部分情况,都不需要输入), 第一个[SEP]及之前为0, 第二个[SEP]及到第一个[SEP]之间为1; 第三个[SEP]及到第二个[SEP]之间为0,依次往后推。
返回:

torch.FloatTensor. batch_size x max_len x (768*len(self.layers))

index_datasets(*datasets, field_name, add_cls_sep=True)[源代码]

使用bert的tokenizer新生成word_pieces列加入到datasets中,并将他们设置为input,且将word_pieces这一列的pad value设置为了 bert的pad value。

参数:
  • datasets (DataSet) -- DataSet对象
  • field_name (str) -- 基于哪一列的内容生成word_pieces列。这一列中每个数据应该是List[str]的形式。
  • add_cls_sep (bool) -- 如果首尾不是[CLS]与[SEP]会在首尾额外加入[CLS]与[SEP]。
返回:

classmethod load(folder)[源代码]

会在folder下创建两个文件bert_encoder_hyper.json与bert_encoder/, bert_encoder下包含三个文件

参数:folder --
返回:
save(folder)[源代码]
会在folder下创建两个文件bert_encoder_hyper.json与bert_encoder/, bert_encoder下包含三个文件config.json,
pytorch_model.bin,vocab.txt三个文件(该folder下的数据也可以直接被BERTModel读取)
参数:folder (str) --
返回:
class fastNLP.embeddings.StackEmbedding(embeds: List[fastNLP.embeddings.embedding.TokenEmbedding], word_dropout=0, dropout=0)[源代码]

基类 fastNLP.embeddings.TokenEmbedding

别名 fastNLP.embeddings.StackEmbedding fastNLP.embeddings.stack_embedding.StackEmbedding

支持将多个embedding集合成一个embedding。

Example:

>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import StaticEmbedding, StackEmbedding
>>> vocab =  Vocabulary().add_word_lst("The whether is good .".split())
>>> embed_1 = StaticEmbedding(vocab, model_dir_or_name='en-glove-6b-50d', requires_grad=True)
>>> embed_2 = StaticEmbedding(vocab, model_dir_or_name='en-word2vec-300', requires_grad=True)
>>> embed = StackEmbedding([embed_1, embed_2])
__init__(embeds: List[fastNLP.embeddings.embedding.TokenEmbedding], word_dropout=0, dropout=0)[源代码]
参数:
  • embeds -- 一个由若干个TokenEmbedding组成的list,要求每一个TokenEmbedding的词表都保持一致
  • word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。不同embedidng会在相同的位置 被设置为unknown。如果这里设置了dropout,则组成的embedding就不要再设置dropout了。
  • dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
append(embed: fastNLP.embeddings.embedding.TokenEmbedding)[源代码]

添加一个embedding到结尾。 :param embed: :return:

embed_size

该Embedding输出的vector的最后一维的维度。 :return:

forward(words)[源代码]

得到多个embedding的结果,并把结果按照顺序concat起来。

参数:words -- batch_size x max_len
返回:返回的shape和当前这个stack embedding中embedding的组成有关
pop()[源代码]

弹出最后一个embed :return:

class fastNLP.embeddings.LSTMCharEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, hidden_size=50, pool_method: str = 'max', activation='relu', min_char_freq: int = 2, bidirectional=True, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]

基类 fastNLP.embeddings.TokenEmbedding

别名 fastNLP.embeddings.LSTMCharEmbedding fastNLP.embeddings.char_embedding.LSTMCharEmbedding

使用LSTM的方式对character进行encode. embed(x) -> Dropout(x) -> LSTM(x) -> activation(x) -> pool -> Dropout

Example:

>>> import torch
>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import LSTMCharEmbedding
>>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
>>> embed = LSTMCharEmbedding(vocab, embed_size=50)
>>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]])
>>> outputs = embed(words)
>>> outputs.size()
>>> # torch.Size([1, 5,50])
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, hidden_size=50, pool_method: str = 'max', activation='relu', min_char_freq: int = 2, bidirectional=True, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]
参数:
  • vocab -- 词表
  • embed_size -- LSTMCharEmbedding的输出维度。默认值为50.
  • char_emb_size -- character的embedding的维度。默认值为50.
  • word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
  • dropout -- 以多大概率drop character embedding的输出以及最终的word的输出。
  • hidden_size -- LSTM的中间hidden的大小,如果为bidirectional的,hidden会除二,默认为50.
  • pool_method -- 支持'max', 'avg'。
  • activation -- 激活函数,支持'relu', 'sigmoid', 'tanh', 或者自定义函数.
  • min_char_freq -- character的最小出现次数。默认值为2.
  • bidirectional -- 是否使用双向的LSTM进行encode。默认值为True。
  • pre_train_char_embed -- 可以有两种方式调用预训练好的character embedding:第一种是传入embedding文件夹 (文件夹下应该只有一个以.txt作为后缀的文件)或文件路径;第二种是传入embedding的名称,第二种情况将自动查看缓存中是否存在该模型, 没有的话将自动下载。如果输入为None则使用embedding_dim的维度随机初始化一个embedding.
  • requires_grad -- 是否更新权重
  • include_word_start_end -- 是否在每个word开始的character前和结束的character增加特殊标示符号;
forward(words)[源代码]

输入words的index后,生成对应的words的表示。

参数:words -- [batch_size, max_len]
返回:[batch_size, max_len, embed_size]
class fastNLP.embeddings.CNNCharEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, filter_nums: List[int] = (40, 30, 20), kernel_sizes: List[int] = (5, 3, 1), pool_method: str = 'max', activation='relu', min_char_freq: int = 2, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]

基类 fastNLP.embeddings.TokenEmbedding

别名 fastNLP.embeddings.CNNCharEmbedding 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的表示。

Example:

>>> import torch
>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import CNNCharEmbedding
>>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
>>> embed = CNNCharEmbedding(vocab, embed_size=50)
>>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]])
>>> outputs = embed(words)
>>> outputs.size()
>>> # torch.Size([1, 5,50])
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, filter_nums: List[int] = (40, 30, 20), kernel_sizes: List[int] = (5, 3, 1), pool_method: str = 'max', activation='relu', min_char_freq: int = 2, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]
参数:
  • vocab -- 词表
  • embed_size -- 该CNNCharEmbedding的输出维度大小,默认值为50.
  • char_emb_size -- character的embed的维度。character是从vocab中生成的。默认值为50.
  • word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
  • dropout (float) -- 以多大的概率drop分布式表示与char embedding的输出。
  • filter_nums -- filter的数量. 长度需要和kernels一致。默认值为[40, 30, 20].
  • kernel_sizes -- kernel的大小. 默认值为[5, 3, 1].
  • pool_method -- character的表示在合成一个表示时所使用的pool方法,支持'avg', 'max'.
  • activation -- CNN之后使用的激活方法,支持'relu', 'sigmoid', 'tanh' 或者自定义函数.
  • min_char_freq -- character的最少出现次数。默认值为2.
  • pre_train_char_embed -- 可以有两种方式调用预训练好的character embedding:第一种是传入embedding文件夹 (文件夹下应该只有一个以.txt作为后缀的文件)或文件路径;第二种是传入embedding的名称,第二种情况将自动查看缓存中是否存在该模型, 没有的话将自动下载。如果输入为None则使用embedding_dim的维度随机初始化一个embedding.
  • requires_grad -- 是否更新权重
  • include_word_start_end -- 是否在每个word开始的character前和结束的character增加特殊标示符号;
forward(words)[源代码]

输入words的index后,生成对应的words的表示。

参数:words -- [batch_size, max_len]
返回:[batch_size, max_len, embed_size]
fastNLP.embeddings.get_embeddings(init_embed, padding_idx=None)[源代码]

别名 fastNLP.embeddings.get_embeddings fastNLP.embeddings.utils.get_embeddings

根据输入的init_embed返回Embedding对象。如果输入是tuple, 则随机初始化一个nn.Embedding; 如果输入是numpy.ndarray, 则按照ndarray 的值将nn.Embedding初始化; 如果输入是torch.Tensor, 则按该值初始化nn.Embedding; 如果输入是fastNLP中的embedding将不做处理 返回原对象。

参数:
  • init_embed -- 可以是 tuple:(num_embedings, embedding_dim), 即embedding的大小和每个词的维度;也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding; 传入np.ndarray也行,将使用传入的ndarray作为作为Embedding初始化; 传入torch.Tensor, 将使用传入的值作为Embedding初始化。
  • padding_idx -- 当传入tuple时,padding_idx有效
Return nn.Embedding:
 

embeddings