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_dim 或 self.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]

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

training: bool¶

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
返回

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

training: bool¶

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

get_word_vocab()[源代码]¶

返回embedding的词典。

返回: Vocabulary

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) -- 词表. StaticEmbedding只会加载包含在词表中的词的词向量，在预训练向量中没找到的使用随机初始化
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]

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的超参数
返回

classmethod load(folder)[源代码]¶

参数: folder (str) -- 该folder下应该有以下三个文件vocab.txt, static_embed.txt, static_hyper.json
返回

training: bool¶

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。

set_mix_weights_requires_grad(flag=True)[源代码]¶

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

参数: flag (bool) -- 混合不同层表示的结果是否可以训练。
返回

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))

training: 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

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))

drop_word(words)[源代码]¶

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

参数: words (torch.LongTensor) -- batch_size x max_len
返回

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) --
返回

classmethod load(folder)[源代码]¶

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

参数: folder (str) --
返回

training: bool¶

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。

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]。

返回

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))

drop_word(words)[源代码]¶

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

参数: words (torch.LongTensor) -- batch_size x max_len
返回

save(folder)[源代码]¶

会在folder下创建两个文件bert_encoder_hyper.json与bert_encoder/, bert_encoder下包含三个文件config.json,: pytorch_model.bin,vocab.txt三个文件(该folder下的数据也可以直接被BERTModel读取)

参数: folder (str) --
返回

classmethod load(folder)[源代码]¶

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

参数: folder --
返回

training: bool¶

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:

pop()[源代码]¶: 弹出最后一个embed :return:

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

forward(words)[源代码]¶

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

参数: words -- batch_size x max_len
返回: 返回的shape和当前这个stack embedding中embedding的组成有关

training: bool¶

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增加特殊标示符号；

training: bool¶

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]

training: bool¶

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

fastNLP.embeddings¶

子模块¶