fastNLP.embeddings package

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)[源代码]

基类:torch.nn.modules.module.Module

别名 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)[源代码]

基类:torch.nn.modules.module.Module

别名 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.embedding.TokenEmbedding

基类 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.contextual_embedding.ContextualEmbedding

基类 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.contextual_embedding.ContextualEmbedding

基类 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)[源代码]

基类:torch.nn.modules.module.Module

别名 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.RobertaEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', 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.contextual_embedding.ContextualEmbedding

基类 fastNLP.embeddings.ContextualEmbedding

别名 fastNLP.embeddings.RobertaEmbedding fastNLP.embeddings.roberta_embedding.RobertaEmbedding

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

RobertaEmbedding可以支持自动下载权重,当前支持的模型:

en: roberta-base en-large: roberta-large

Example:

>>> import torch
>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import RobertaEmbedding
>>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
>>> embed = RobertaEmbedding(vocab, model_dir_or_name='en', 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', 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) – 模型所在目录或者模型的名称。当传入模型所在目录时,目录中应该包含一个词表文件 (以vocab.json作为后缀名), 权重文件(以.bin作为文件后缀名), 配置文件(以config.json作为后缀名)。

  • layers (str,list) – 输出embedding表示来自于哪些层,不同层的结果按照layers中的顺序在最后一维concat起来。以’,’隔开层数,层的序号是 从0开始,可以以负数去索引倒数几层。layer=0为embedding层(包括wordpiece embedding, position 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) – 返回的<s>是否使用预训练中的BertPool映射一下,仅在include_cls_sep时有效。如果下游任务只取<s>做预测, 一般该值为True。

  • requires_grad (bool) – 是否需要gradient以更新Bert的权重。

  • auto_truncate (bool) – 当句子words拆分为word pieces长度超过bert最大允许长度(一般为512), 自动截掉拆分后的超过510个 word pieces后的内容,并将第512个word piece置为</s>。超过长度的部分的encode结果直接全部置零。一般仅有只使用<s> 来进行分类的任务将auto_truncate置为True。

  • kwargs – int min_freq: 小于该次数的词会被unk代替, 默认为1

forward(words)[源代码]

计算words的roberta embedding表示。计算之前会在每句话的开始增加<s>在结束增加</s>, 并根据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)[源代码]

将roberta embedding保存到folder,保存之后包含三个文件vocab.txt, roberta_embed_hyper.txt, roberta_embed/,

参数

folder (str) – 保存地址

返回

classmethod load(folder)[源代码]

从folder中读取数据初始化RobertaEmbedding

参数

folder

返回

training: bool
class fastNLP.embeddings.RobertaWordPieceEncoder(model_dir_or_name: str = 'en', layers: str = '-1', pooled_cls: bool = False, word_dropout=0, dropout=0, requires_grad: bool = True, **kwargs)[源代码]

基类:torch.nn.modules.module.Module

别名 fastNLP.embeddings.RobertaWordPieceEncoder fastNLP.embeddings.roberta_embedding.RobertaWordPieceEncoder

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

RobertaWordPieceEncoder可以支持自动下载权重,当前支持的模型:

en: roberta-base en-large: roberta-large

__init__(model_dir_or_name: str = 'en', 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)

  • pooled_cls (bool) – 返回的句子开头的<s>是否使用预训练中的BertPool映射一下。如果下游任务取<s>做预测,一般该值为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, add_prefix_space=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) – 如果首尾不是<s>与</s>会在首尾额外加入<s>与</s>。

  • add_prefix_spance (bool) – 是否在句首添加额外的空格,RoBERTa预训练时该值为True

返回

forward(word_pieces, token_type_ids=None)[源代码]

计算words的bert embedding表示。传入的words中应该自行包含<s>与</s>>的tag。

参数
  • words – batch_size x max_len

  • token_type_ids – batch_size x 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

返回

training: bool
class fastNLP.embeddings.TransformersEmbedding(vocab, model, tokenizer, layers='-1', pool_method: str = 'first', word_dropout=0, dropout=0, requires_grad=True, include_cls_sep: bool = False, auto_truncate=True, **kwargs)[源代码]

基类:fastNLP.embeddings.contextual_embedding.ContextualEmbedding

基类 fastNLP.embeddings.ContextualEmbedding

别名 fastNLP.embeddings.TransformersEmbedding fastNLP.embeddings.transformers_embedding.TransformersEmbedding

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

Example:

>>> import torch
>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import TransformersEmbedding
>>> from transformers import ElectraModel, ElectraTokenizer
>>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
>>> model = ElectraModel.from_pretrained("google/electra-small-generator")
>>> tokenizer = ElectraTokenizer.from_pretrained("google/electra-small-generator")
>>> embed = TransformersEmbedding(vocab, model_dir_or_name='en', 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, model, tokenizer, layers='-1', pool_method: str = 'first', word_dropout=0, dropout=0, requires_grad=True, include_cls_sep: bool = False, auto_truncate=True, **kwargs)[源代码]
参数
  • vocab (Vocabulary) – 词表

  • tokenizer – transformers包中的PreTrainedTokenizer对象

  • layers (str,list) – 输出embedding表示来自于哪些层,不同层的结果按照layers中的顺序在最后一维concat起来。以’,’隔开层数,层的序号是 从0开始,可以以负数去索引倒数几层。layer=0为embedding层(包括wordpiece embedding, position 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) – 返回的<s>是否使用预训练中的BertPool映射一下,仅在include_cls_sep时有效。如果下游任务只取<s>做预测, 一般该值为True。

  • requires_grad (bool) – 是否需要gradient以更新Bert的权重。

  • auto_truncate (bool) – 当句子words拆分为word pieces长度超过bert最大允许长度(一般为512), 自动截掉拆分后的超过510个 word pieces后的内容,并将第512个word piece置为</s>。超过长度的部分的encode结果直接全部置零。一般仅有只使用<s> 来进行分类的任务将auto_truncate置为True。

  • kwargs

    int min_freq: 小于该次数的词会被unk代替, 默认为1 dict tokenizer_kwargs: 传递给tokenizer在调用tokenize()方法时所额外使用的参数,例如RoBERTaTokenizer需要传入

    {‘add_prefix_space’:True}

Model model

transformers包中的PreTrainedModel对象

forward(words)[源代码]

计算words的roberta embedding表示。计算之前会在每句话的开始增加<s>在结束增加</s>, 并根据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)[源代码]

保存tokenizer和model到folder文件夹。model保存在`folder/{model_name}`, tokenizer在`folder/{tokenizer_name}`下 :param str folder: 保存地址 :return:

training: bool
class fastNLP.embeddings.TransformersWordPieceEncoder(model, tokenizer, layers: str = '-1', word_dropout=0, dropout=0, requires_grad: bool = True, **kwargs)[源代码]

基类:torch.nn.modules.module.Module

别名 fastNLP.embeddings.TransformersWordPieceEncoder fastNLP.embeddings.transformers_embedding.TransformersWordPieceEncoder

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

RobertaWordPieceEncoder可以支持自动下载权重,当前支持的模型:

en: roberta-base en-large: roberta-large

__init__(model, tokenizer, layers: str = '-1', word_dropout=0, dropout=0, requires_grad: bool = True, **kwargs)[源代码]
参数
  • model – transformers的model

  • tokenizer – transformer的tokenizer

  • layers (str) – 最终结果中的表示。以’,’隔开层数,可以以负数去索引倒数几层。layer=0为embedding层(包括wordpiece embedding, position embedding)

  • word_dropout (float) – 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。

  • dropout (float) – 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。

  • requires_grad (bool) – 是否需要gradient。

index_datasets(*datasets, field_name, **kwargs)[源代码]

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

参数
  • datasets (DataSet) – DataSet对象

  • field_name (str) – 基于哪一列的内容生成word_pieces列。这一列中每个数据应该是raw_string的形式。

  • kwargs – 传递给tokenizer的参数

返回

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

返回

training: bool
class fastNLP.embeddings.GPT2Embedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '-1', pool_method: str = 'first', dropout=0, requires_grad: bool = True, auto_truncate: bool = False, language_model: bool = False, **kwargs)[源代码]

基类:fastNLP.embeddings.contextual_embedding.ContextualEmbedding

基类 fastNLP.embeddings.ContextualEmbedding

别名 fastNLP.embeddings.GPT2Embedding fastNLP.embeddings.gpt2_embedding.GPT2Embedding

使用GPT2对words进行编码的Embedding。

GPT2Embedding可以支持自动下载权重,当前支持的模型:

en: gpt2 en-medium: gpt2-medium

Example:

>>> import torch
>>> from fastNLP import Vocabulary
>>> from fastNLP.embeddings import BertEmbedding
>>> vocab = Vocabulary().add_word_lst("The whether is good .".split())
>>> embed = GPT2Embedding(vocab, model_dir_or_name='en-small', 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, 3096])
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '-1', pool_method: str = 'first', dropout=0, requires_grad: bool = True, auto_truncate: bool = False, language_model: bool = False, **kwargs)[源代码]
参数
  • vocab (Vocabulary) – 词表

  • model_dir_or_name (str) – 模型所在目录或者模型的名称。当传入模型所在目录时,目录中应该包含一个词表文件(以.txt作为后缀名), 权重文件(以.bin作为文件后缀名), 配置文件(以.json作为后缀名)。

  • layers (str) – 输出embedding表示来自于哪些层,不同层的结果按照layers中的顺序在最后一维concat起来。以’,’隔开层数,层的序号是 从0开始,可以以负数去索引倒数几层。

  • pool_method (str) – 因为在bert中,每个word会被表示为多个word pieces, 当获取一个word的表示的时候,怎样从它的word pieces 中计算得到它对应的表示。支持 last , first , avg , max

  • dropout (float) – 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。

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

  • language_model (bool) – 是否计算gpt2的lm loss,可以通过get_loss()获取,输入一个batch之后的get_loss调用即为batch的language model的loss

  • **kwargs

    bool only_use_pretrain_bpe: 仅使用出现在pretrain词表中的bpe,如果该词没法tokenize则使用unk。如果embedding不需要更新

    建议设置为True。

    int min_freq: 仅在only_use_pretrain_bpe为False有效,大于等于该次数的词会被新加入GPT2的BPE词表中 bool truncate_embed: 是否仅保留用到的bpe(这样会减内存占用和加快速度)

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 (torch.LongTensor) – batch_size x max_len

返回

get_lm_loss(release=True)[源代码]

当language_model=True时,可以通过该接口获取当前batch的language model loss的大小

参数

release (bool) – 如果为True,获取了lm_loss后在下一次forward完成之前都无法获取lm_loss了

返回

torch.FloatTensor([])

training: bool
class fastNLP.embeddings.GPT2WordPieceEncoder(model_dir_or_name: str = 'en', layers: str = '-1', word_dropout=0, dropout=0, requires_grad: bool = True, language_model: bool = False)[源代码]

基类:torch.nn.modules.module.Module

别名 fastNLP.embeddings.GPT2WordPieceEncoder fastNLP.embeddings.gpt2_embedding.GPT2WordPieceEncoder

GPT2模型,使用时先使用本模型对应的Tokenizer对数据进行tokenize GPT2WordPieceEncoder可以支持自动下载权重,当前支持的模型:

en: gpt2 en-medium: gpt2-medium

__init__(model_dir_or_name: str = 'en', layers: str = '-1', word_dropout=0, dropout=0, requires_grad: bool = True, language_model: bool = False)[源代码]
参数
  • model_dir_or_name (str) – 模型所在目录或者模型的名称。

  • layers (str,list) – 最终结果中的表示。以’,’隔开层数,可以以负数去索引倒数几层

  • word_dropout (float) – 多大概率将word piece置为<|endoftext|>

  • dropout (float) – 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。

  • language_model (bool) – 是否使用language model

  • requires_grad (bool) – 是否需要gradient。

index_datasets(*datasets, field_name, add_endoftext=False, add_prefix_space=True)[源代码]

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

参数
  • datasets (DataSet) – DataSet对象

  • field_name (list[str]) – 基于哪一列的内容生成word_pieces列。这一列中每个数据应该是List[str]的形式。

  • add_endoftext (bool) – 在句子开头加入<|endofline|>。

  • add_prefix_space (bool) – 是否在句首增加空格

返回

forward(word_pieces, token_type_ids=None)[源代码]

计算words的bert embedding表示。传入的words中应该在开头包含<|endofline|>。

参数
  • word_pieces – batch_size x max_len

  • token_type_ids – batch_size x max_len,

返回

torch.FloatTensor.

drop_word(words)[源代码]
参数

words (torch.LongTensor) – batch_size x max_len

返回

generate_from_str(text='', max_len=40, do_sample=True, num_beams=1, temperature=1, top_k=50, top_p=1.0, repetition_penalty=1.0, length_penalty=1.0)[源代码]
参数
  • text (str) – 故事的开头

  • max_len (int) – 生成多长的句子

  • do_sample (bool) – 是否使用采样的方式生成,如果使用采样,相同的参数可能出现不同的句子。

  • num_beams (int) – 使用多大的beam size

  • temperature (float) – 用以调节采样分布的

  • top_k (int) – 只保留此表中top_k个词进行生成。范围1-infinity

  • top_p (float) – 保留概率累积为top_p的词汇,范围0-1.

  • repetition_penalty (float) – 对重复token的惩罚

  • length_penalty (float) – 惩罚过长的句子

返回

list[str]

generate(word_pieces=None, max_len=40, do_sample=True, num_beams=1, temperature=1, top_k=50, top_p=1.0, repetition_penalty=1.0, length_penalty=1.0)[源代码]
参数
  • word_pieces (torch.LongTensor,None) – 如果传入tensor,shape应该为batch_size x start_len; 如果传入None,会随机生成。

  • max_len (int) – 生成多长的句子

  • do_sample (bool) – 是否使用采样的方式生成,如果使用采样,相同的参数可能出现不同的句子。

  • num_beams (int) – 使用多大的beam size

  • temperature (float) – 用以调节采样分布的

  • top_k (int) – 只保留此表中top_k个词进行生成。范围1-infinity

  • top_p (float) – 保留概率累积为top_p的词汇,范围0-1.

  • repetition_penalty (float) – 对重复token的惩罚

  • length_penalty (float) – 惩罚过长的句子

返回

get_lm_loss(release=True)[源代码]

当language_model=True时,可以通过该接口获取当前batch的language model loss的大小

参数

release (bool) – 如果为True,获取了lm_loss后在下一次forward完成之前都无法获取lm_loss了

返回

torch.FloatTensor([])

training: bool
class fastNLP.embeddings.StackEmbedding(embeds: List[fastNLP.embeddings.embedding.TokenEmbedding], word_dropout=0, dropout=0)[源代码]

基类:fastNLP.embeddings.embedding.TokenEmbedding

基类 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.embedding.TokenEmbedding

基类 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.embedding.TokenEmbedding

基类 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.get_sinusoid_encoding_table(n_position, d_hid, padding_idx=None)[源代码]

别名 fastNLP.embeddings.get_sinusoid_encoding_table fastNLP.embeddings.utils.get_sinusoid_encoding_table

sinusoid的embedding,其中position的表示中,偶数维(0,2,4,…)是sin, 奇数(1,3,5…)是cos

参数
  • n_position (int) – 一共多少个position

  • d_hid (int) – 多少维度,需要为偶数

  • padding_idx

返回

torch.FloatTensor, shape为n_position x d_hid