fastNLP

fastNLP 由 coreioembeddingsmodulesmodels 等子模块组成,你可以查看每个模块的文档。

  • core 是fastNLP 的核心模块,包括 DataSet、 Trainer、 Tester 等组件。详见文档 fastNLP.core
  • io 是实现输入输出的模块,包括了数据集的读取,模型的存取等功能。详见文档 fastNLP.io
  • embeddings 提供用于构建复杂网络模型所需的各种embedding。详见文档 fastNLP.embeddings
  • modules 包含了用于搭建神经网络模型的诸多组件,可以帮助用户快速搭建自己所需的网络。详见文档 fastNLP.modules
  • models 包含了一些使用 fastNLP 实现的完整网络模型,包括 CNNTextSeqLabeling 等常见模型。详见文档 fastNLP.models

fastNLP 中最常用的组件可以直接从 fastNLP 包中 import ,他们的文档如下:

class fastNLP.Instance(**fields)[源代码]

别名 fastNLP.Instance fastNLP.core.instance.Instance

Instance是fastNLP中对应一个sample的类。每个sample在fastNLP中是一个Instance对象。 Instance一般与 DataSet 一起使用, Instance的初始化如下面的Example所示:

>>>from fastNLP import Instance
>>>ins = Instance(field_1=[1, 1, 1], field_2=[2, 2, 2])
>>>ins["field_1"]
[1, 1, 1]
>>>ins.add_field("field_3", [3, 3, 3])
>>>ins = Instance(**{'x1': 1, 'x2':np.zeros((3, 4))})
add_field(field_name, field)[源代码]

向Instance中增加一个field

参数:
  • field_name (str) -- 新增field的名称
  • field (Any) -- 新增field的内容
items()[源代码]

返回一个迭代器,迭代器返回两个内容,第一个内容是field_name, 第二个内容是field_value

返回:一个迭代器
class fastNLP.DataSetIter(dataset, batch_size=1, sampler=None, as_numpy=False, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, batch_sampler=None)[源代码]

基类 fastNLP.BatchIter

别名 fastNLP.DataSetIter fastNLP.core.batch.DataSetIter

DataSetIter 用于从 DataSet 中按一定的顺序, 依次按 batch_size 的大小将数据取出,通过使用DataSetIter,可以不需要考虑
输入的padding(由DataSet中每列的Padder决定了)以及不需要考虑将数据转为tensor。

组成 xy:

batch = DataSetIter(data_set, batch_size=16, sampler=SequentialSampler())
num_batch = len(batch)
for batch_x, batch_y in batch:
    # do stuff ...
__init__(dataset, batch_size=1, sampler=None, as_numpy=False, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, batch_sampler=None)[源代码]
参数:
  • dataset -- DataSet 对象, 数据集
  • batch_size (int) -- 取出的batch大小
  • sampler --

    规定使用的 Sampler 方式. 若为 None , 使用 SequentialSampler.

    Default: None

  • as_numpy (bool) --

    若为 True , 输出batch为 numpy.array. 否则为 torch.Tensor.

    Default: False

  • num_workers (int) -- 使用多少个进程来预处理数据
  • pin_memory (bool) -- 是否将产生的tensor使用pin memory, 可能会加快速度。
  • drop_last (bool) -- 如果最后一个batch没有batch_size这么多sample,就扔掉最后一个
  • timeout -- 生成一个batch的timeout值
  • worker_init_fn -- 在每个worker启动时调用该函数,会传入一个值,该值是worker的index。
  • batch_sampler -- 当每次batch取出的数据数量不一致时,可以使用该sampler。batch_sampler每次iter应该输出一个list的index。 当batch_sampler不为None时,参数batch_size, sampler, drop_last会被忽略。
dataset

获取正在参与iterate的dataset

返回:
get_batch_indices()

获取最近输出的batch的index。用于溯源当前batch的数据

返回:
static get_num_batches(num_samples, batch_size, drop_last)

计算batch的数量。用于前端显示进度

参数:
  • num_samples (int) --
  • batch_size (int) --
  • drop_last (bool) -- 如果最后一个batch没有batch_size这么多,是否就丢掉。
返回:

class fastNLP.BatchIter(dataset, batch_size=1, sampler=None, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, collate_fn=None, batch_sampler=None)[源代码]

别名 fastNLP.BatchIter fastNLP.core.batch.BatchIter

Trainer用于迭代数据的类。继承该类,并实现get_num_batches(), get_batch_indices(), num_batches(), __iter__()方法以及dataset属性。

dataset

获取正在参与iterate的dataset

返回:
get_batch_indices()[源代码]

获取最近输出的batch的index。用于溯源当前batch的数据

返回:
static get_num_batches(num_samples, batch_size, drop_last)[源代码]

计算batch的数量。用于前端显示进度

参数:
  • num_samples (int) --
  • batch_size (int) --
  • drop_last (bool) -- 如果最后一个batch没有batch_size这么多,是否就丢掉。
返回:

class fastNLP.TorchLoaderIter(dataset, collate_fn, batch_size=1, sampler=None, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, batch_sampler=None)[源代码]

基类 fastNLP.BatchIter

别名 fastNLP.TorchLoaderIter fastNLP.core.batch.TorchLoaderIter

与DataSetIter类似,但可以用于非fastNLP的数据容器对象,以及可以实现完全自定义的生成batch的方式,然后与Trainer,Tester可以实现
与DataSetIter一样的对接。

需要保证传入的数据容器实现了实现了以下的方法

Example:

import random
from fastNLP import TorchLoaderIter
import torch
class UdfDataSet:
    def __init__(self, num_samples):
        self.num_samples = num_samples

    def __getitem__(self, idx):  # 必须实现的方法,输入参数是一个int,范围为[0, len(self))
        x = [random.random() for _ in range(3)]
        y = random.random()
        return x,y

    def __len__(self):  # 需要实现该方法返回值需要是一个int数据
        return self.num_samples

# 需要实现collact_fn将数据转换为tensor
def collate_fn(data_list):
    # [(x1,y1), (x2,y2), ...], 这里的输入实际上是将UdfDataSet的__getitem__输入结合为list
    xs, ys = [], []
    for l in data_list:
        x, y = l
        xs.append(x)
        ys.append(y)
    # 不需要转移到gpu,Trainer或Tester会将其转移到model所在的device
    x,y = torch.FloatTensor(xs), torch.FloatTensor(ys)
    return {'x':x, 'y':y}, {'y':y}  # 第一个dict中内容类似于DataSet中的input列,第二个dict的内容类似于target列

udf_dataset = UdfDataSet(10)
dataset = TorchLoaderIter(udf_dataset, collate_fn=collate_fn)
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(3, 1)
    def forward(self, x, y):
        return {'loss':torch.pow(self.fc(x).squeeze(-1)-y, 2).sum()}
    def predict(self, x):
        return {'pred':self.fc(x).squeeze(0)}
model = Model()
trainer = Trainer(train_data=dataset, model=model, loss=None, print_every=2, dev_data=dataset,
                  metrics=AccuracyMetric(target='y'), use_tqdm=False)
trainer.train(load_best_model=False)

除此之外,还可以通过该方法实现OnTheFly的训练,如下面的代码所示

Example:

import tempfile
import random
import torch
tmp_file_handler, tmp_file_path = tempfile.mkstemp(text=True)
try:
    num_samples, data = 10, []
    for _ in range(num_samples):
        x, y = [random.random() for _ in range(3)], random.random()
        data.append(x + [y])
    with open(tmp_file_path, 'w') as f:
        for d in data:
            f.write(' '.join(map(str, d)) + '\n')

    class FileDataSet:
        def __init__(self, tmp_file):
            num_samples = 0
            line_pos = [0]  # 对应idx是某一行对应的位置
            self.tmp_file_handler = open(tmp_file, 'r', encoding='utf-8')
            line = self.tmp_file_handler.readline()
            while line:
                if line.strip():
                    num_samples += 1
                    line_pos.append(self.tmp_file_handler.tell())
                line = self.tmp_file_handler.readline()
            self.tmp_file_handler.seek(0)
            self.num_samples = num_samples
            self.line_pos = line_pos

        def __getitem__(self, idx):
            line_start, line_end = self.line_pos[idx], self.line_pos[idx + 1]
            self.tmp_file_handler.seek(line_start)
            line = self.tmp_file_handler.read(line_end - line_start).strip()
            values = list(map(float, line.split()))
            x, y = values[:3], values[-1]
            return x, y

        def __len__(self):
            return self.num_samples

    def collate_fn(data_list):
        # [(x1,y1), (x2,y2), ...], 这里的输入实际上是将UdfDataSet的__getitem__输入结合为list
        xs, ys = [], []
        for l in data_list:
            x, y = l
            xs.append(x)
            ys.append(y)
        x, y = torch.FloatTensor(xs), torch.FloatTensor(ys)
        return {'x': x, 'y': y}, {'y': y}  # 第一个dict中内容类似于DataSet中的input列,第二个dict的内容类似于target列

    file_data = FileDataSet(tmp_file_path)
    dataset = TorchLoaderIter(file_data, collate_fn=collate_fn)

    class Model(nn.Module):
        def __init__(self):
            super().__init__()
            self.fc = nn.Linear(3, 1)

        def forward(self, x, y):
            return {'loss': torch.pow(self.fc(x).squeeze(-1) - y, 2).sum()}

        def predict(self, x):
            return {'pred': self.fc(x).squeeze(0)}

    model = Model()
    trainer = Trainer(train_data=dataset, model=model, loss=None, print_every=2, dev_data=dataset,
                      metrics=AccuracyMetric(target='y'), use_tqdm=False, n_epochs=2)
    trainer.train(load_best_model=False)

finally:
    import os
    if os.path.exists(tmp_file_path):
        os.remove(tmp_file_path)
__init__(dataset, collate_fn, batch_size=1, sampler=None, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, batch_sampler=None)[源代码]
参数:
  • dataset -- 实现了__getitem__和__len__方法的数据容器。
  • collate_fn (callable) -- 用于将样本组合成batch的函数。输入为[dataset[idx1], dataset[idx2], ...], 即dataset中 __getitem__返回值组成的list,返回值必须为两个dict,其中第一个dict会被认为是input,第二个dict中的内容被认为是target。 需要转换为tensor的数据,需要在collate_fn中转化,但不需要转移到对应device。
  • batch_size (int) -- 取出的batch大小
  • sampler -- 规定使用的 Sampler 方式. 若为 None , 使用 SequentialSampler. Default: None
  • num_workers (int) -- 使用多少个进程来预处理数据
  • pin_memory (bool) -- 是否将产生的tensor使用pin memory, 可能会加快速度。
  • drop_last (bool) -- 如果最后一个batch没有batch_size这么多sample,就扔掉最后一个
  • timeout -- 生成一个batch的timeout值
  • worker_init_fn -- 在每个worker启动时调用该函数,会传入一个值,该值是worker的index。
  • batch_sampler -- 当每次batch取出的数据数量不一致时,可以使用该sampler。batch_sampler每次iter应该输出一个list的index。 当batch_sampler不为None时,参数batch_size, sampler, drop_last会被忽略。
dataset

获取正在参与iterate的dataset

返回:
get_batch_indices()

获取最近输出的batch的index。用于溯源当前batch的数据

返回:
static get_num_batches(num_samples, batch_size, drop_last)

计算batch的数量。用于前端显示进度

参数:
  • num_samples (int) --
  • batch_size (int) --
  • drop_last (bool) -- 如果最后一个batch没有batch_size这么多,是否就丢掉。
返回:

class fastNLP.Vocabulary(max_size=None, min_freq=None, padding='<pad>', unknown='<unk>')[源代码]

别名 fastNLP.Vocabulary fastNLP.core.vocabulary.Vocabulary

用于构建, 存储和使用 strint 的一一映射:

vocab = Vocabulary()
word_list = "this is a word list".split()
vocab.update(word_list)
vocab["word"] # str to int
vocab.to_word(5) # int to str
__init__(max_size=None, min_freq=None, padding='<pad>', unknown='<unk>')[源代码]
参数:
  • max_size (int) -- Vocabulary 的最大大小, 即能存储词的最大数量 若为 None , 则不限制大小. Default: None
  • min_freq (int) -- 能被记录下的词在文本中的最小出现频率, 应大于或等于 1. 若小于该频率, 词语将被视为 unknown. 若为 None , 所有文本中的词都被记录. Default: None
  • optional padding (str) -- padding的字符. 如果设置为 None , 则vocabulary中不考虑padding, 也不计入词表大小,为 None 的情况多在为label建立Vocabulary的情况. Default: '<pad>'
  • optional unknown (str) -- unknown的字符,所有未被记录的词在转为 int 时将被视为unknown. 如果设置为 None ,则vocabulary中不考虑unknow, 也不计入词表大小. 为 None 的情况多在为label建立Vocabulary的情况. Default: '<unk>'
add(word, no_create_entry=False)[源代码]

增加一个新词在词典中的出现频率

参数:
  • word (str) -- 新词
  • no_create_entry (bool) -- 在使用fastNLP.TokenEmbedding加载预训练模型时,没有从预训练词表中找到这个词的处理方式。 如果为True,则不会有这个词语创建一个单独的entry,它将一直被指向unk的表示; 如果为False,则为这个词创建一个单独 的entry。如果这个word来自于dev或者test,一般设置为True,如果来自与train一般设置为False。以下两种情况: 如果新 加入一个word,且no_create_entry为True,但这个词之前已经在Vocabulary中且并不是no_create_entry的,则还是会为这 个词创建一个单独的vector; 如果no_create_entry为False,但这个词之前已经在Vocabulary中且并不是no_create_entry的, 则这个词将认为是需要创建单独的vector的。
add_word(word, no_create_entry=False)[源代码]

增加一个新词在词典中的出现频率

参数:
  • word (str) -- 新词
  • no_create_entry (bool) -- 在使用fastNLP.TokenEmbedding加载预训练模型时,没有从预训练词表中找到这个词的处理方式。 如果为True,则不会有这个词语创建一个单独的entry,它将一直被指向unk的表示; 如果为False,则为这个词创建一个单独 的entry。如果这个word来自于dev或者test,一般设置为True,如果来自与train一般设置为False。以下两种情况: 如果新 加入一个word,且no_create_entry为True,但这个词之前已经在Vocabulary中且并不是no_create_entry的,则还是会为这 个词创建一个单独的vector; 如果no_create_entry为False,但这个词之前已经在Vocabulary中且并不是no_create_entry的, 则这个词将认为是需要创建单独的vector的。
add_word_lst(word_lst, no_create_entry=False)[源代码]

依次增加序列中词在词典中的出现频率

参数:
  • word_lst (list[str]) -- 词的序列
  • no_create_entry (bool) -- 在使用fastNLP.TokenEmbedding加载预训练模型时,没有从预训练词表中找到这个词的处理方式。 如果为True,则不会有这个词语创建一个单独的entry,它将一直被指向unk的表示; 如果为False,则为这个词创建一个单独 的entry。如果这个word来自于dev或者test,一般设置为True,如果来自与train一般设置为False。以下两种情况: 如果新 加入一个word,且no_create_entry为True,但这个词之前已经在Vocabulary中且并不是no_create_entry的,则还是会为这 个词创建一个单独的vector; 如果no_create_entry为False,但这个词之前已经在Vocabulary中且并不是no_create_entry的, 则这个词将认为是需要创建单独的vector的。
build_reverse_vocab()[源代码]

基于 word to index dict, 构建 index to word dict.

build_vocab()[源代码]

根据已经出现的词和出现频率构建词典. 注意: 重复构建可能会改变词典的大小, 但已经记录在词典中的词, 不会改变对应的 int

clear()[源代码]

删除Vocabulary中的词表数据。相当于重新初始化一下。

返回:
from_dataset(*datasets, field_name, no_create_entry_dataset=None)[源代码]

使用dataset的对应field中词构建词典:

# remember to use `field_name`
vocab.from_dataset(train_data1, train_data2, field_name='words')
参数:
  • datasets (DataSet,List[DataSet]) -- 需要转index的一个或多个数据集
  • field_name (str,List[str]) -- 可为 strList[str] . 构建词典所使用的 field(s), 支持一个或多个field,若有多个 DataSet, 每个DataSet都必须有这些field. 目前支持的field结构 : str , List[str]
  • no_create_entry_dataset -- 可以传入DataSet, List[DataSet]或者None(默认),该选项用在接下来的模型会使用pretrain 的embedding(包括glove, word2vec, elmo与bert)且会finetune的情况。如果仅使用来自于train的数据建立vocabulary,会导致test与dev 中的数据无法充分利用到来自于预训练embedding的信息,所以在建立词表的时候将test与dev考虑进来会使得最终的结果更好。 如果一个词出现在了train中,但是没在预训练模型中,embedding会为它用unk初始化,但它是单独的一个vector,如果 finetune embedding的话,这个词在更新之后可能会有更好的表示; 而如果这个词仅出现在了dev或test中,那么就不能为它们单独建立vector, 而应该让它指向unk这个vector的值。所以只位于no_create_entry_dataset中的token,将首先从预训练的词表中寻找它的表示, 如果找到了,就使用该表示; 如果没有找到,则认为该词的表示应该为unk的表示。
Return self:
has_word(w)[源代码]

检查词是否被记录:

has_abc = vocab.has_word('abc')
# equals to
has_abc = 'abc' in vocab
参数:item -- the word
返回:True or False
index_dataset(*datasets, field_name, new_field_name=None)[源代码]

将DataSet中对应field的词转为数字,Example:

# remember to use `field_name`
vocab.index_dataset(train_data, dev_data, test_data, field_name='words')
参数:
  • datasets (DataSet,List[DataSet]) -- 需要转index的一个或多个数据集
  • field_name (list,str) -- 需要转index的field, 若有多个 DataSet, 每个DataSet都必须有此 field. 目前支持 str , List[str]
  • new_field_name (list,str) -- 保存结果的field_name. 若为 None , 将覆盖原field. Default: None.
static load(filepath)[源代码]
参数:filepath (str,io.StringIO) -- Vocabulary的读取路径
返回:Vocabulary
padding_idx

padding 对应的数字

save(filepath)[源代码]
参数:filepath (str,io.StringIO) -- Vocabulary的储存路径
返回:
to_index(w)[源代码]

将词转为数字. 若词不再词典中被记录, 将视为 unknown, 若 unknown=None , 将抛出 ValueError

index = vocab.to_index('abc')
# equals to
index = vocab['abc']
参数:w (str) -- a word
Return int index:
 the number
to_word(idx)[源代码]

给定一个数字, 将其转为对应的词.

参数:idx (int) -- the index
Return str word:
 the word
unknown_idx

unknown 对应的数字.

update(word_lst, no_create_entry=False)[源代码]

依次增加序列中词在词典中的出现频率

参数:
  • word_lst (list) -- a list of strings
  • no_create_entry (bool) -- 在使用fastNLP.TokenEmbedding加载预训练模型时,没有从预训练词表中找到这个词的处理方式。 如果为True,则不会有这个词语创建一个单独的entry,它将一直被指向unk的表示; 如果为False,则为这个词创建一个单独 的entry。如果这个word来自于dev或者test,一般设置为True,如果来自与train一般设置为False。以下两种情况: 如果新 加入一个word,且no_create_entry为True,但这个词之前已经在Vocabulary中且并不是no_create_entry的,则还是会为这 个词创建一个单独的vector; 如果no_create_entry为False,但这个词之前已经在Vocabulary中且并不是no_create_entry的, 则这个词将认为是需要创建单独的vector的。
class fastNLP.DataSet(data=None)[源代码]

别名 fastNLP.DataSet fastNLP.core.dataset.DataSet

fastNLP的数据容器,详细的使用方法见文档 fastNLP.core.dataset

__init__(data=None)[源代码]
参数:data -- 如果为dict类型,则每个key的value应该为等长的list; 如果为list, 每个元素应该为具有相同field的 Instance
add_collate_fn(fn, name=None)[源代码]

添加 CollateFn,collate_fn允许在生成的batch的过程中动态生成一些数据(在DataSetIter作为迭代器的情况下有效,默认情况下就是用的 这个)。支持依次添加多个collate_fn, 如果相同的key,后面的collate_fn的结果覆盖前面的collate_fn的结果。

参数:
  • fn (callable) -- 传入一个可调用的function, 该function可接受的参数为List[(ind1, instance1), (ind2, instance2)] (某个batch被选中的所有的indice以及instance),其中ind1/ind2是该instance在dataset中的index,instance1/instance2是 这次batch取出来的数据,包含了所有的field。返回值需要为两个dict,第一个dict的值将被认为是input,第二个dict的值被认为是 target,返回的值至多允许一个空dict。若返回的dict中包含了被设置为input或target的field的名称,将覆盖dataset中的field。 fastNLP不会将collate_fn的返回结果pad和转换为tensor,需要在collate_fn中完成pad和转换为tensor(不需要将tensor移动到 gpu中,fastNLP会自动将其移动到特定gpu)。不要修改传入collate_fn中的数据,否则可能导致未知问题。
  • name (str,int) -- collate_fn的名称,如果不传入,默认使用自增长的数字作为key。相同的name会覆盖之前的collate_fn。
add_field(field_name, fields, padder=<fastNLP.core.field.AutoPadder object>, is_input=False, is_target=False, ignore_type=False)[源代码]

新增一个field

参数:
  • field_name (str) -- 新增的field的名称
  • fields (list) -- 需要新增的field的内容
  • padder (None,Padder) -- 如果为None,则不进行pad,默认使用 AutoPadder 自动判断是否需要做pad。
  • is_input (bool) -- 新加入的field是否是input
  • is_target (bool) -- 新加入的field是否是target
  • ignore_type (bool) -- 是否忽略对新加入的field的类型检查
add_fieldarray(field_name, fieldarray)[源代码]

将fieldarray添加到DataSet中.

参数:
  • field_name (str) -- 新加入的field的名称
  • fieldarray (FieldArray) -- 需要加入DataSet的field的内容
返回:

add_seq_len(field_name: str, new_field_name='seq_len')[源代码]

将使用len()直接对field_name中每个元素作用,将其结果作为sequence length, 并放入seq_len这个field。

参数:
  • field_name -- str.
  • new_field_name -- str. 新的field_name
返回:

append(instance)[源代码]

将一个instance对象append到DataSet后面。

参数:instance (Instance) -- 若DataSet不为空,则instance应该拥有和DataSet完全一样的field。
apply(func, new_field_name=None, **kwargs)[源代码]

将DataSet中每个instance传入到func中,并获取它的返回值.

参数:
  • func (callable) -- 参数是 DataSet 中的 Instance
  • new_field_name (None,str) -- 将func返回的内容放入到 new_field_name 这个field中,如果名称与已有的field相同,则覆 盖之前的field。如果为None则不创建新的field。
  • kwargs (optional) --

    支持输入is_input,is_target,ignore_type

    1. is_input: bool, 如果为True则将 new_field_name 的field设置为input
    2. is_target: bool, 如果为True则将 new_field_name 的field设置为target
    3. ignore_type: bool, 如果为True则将 new_field_name 的field的ignore_type设置为true, 忽略其类型
Return List[Any]:
 

里面的元素为func的返回值,所以list长度为DataSet的长度

apply_field(func, field_name, new_field_name=None, **kwargs)[源代码]

将DataSet中的每个instance中的名为 field_name 的field传给func,并获取它的返回值。

参数:
  • func (callable) -- input是instance中名为 field_name 的field的内容。
  • field_name (str) -- 传入func的是哪个field。
  • new_field_name (None,str) -- 将func返回的内容放入到 new_field_name 这个field中,如果名称与已有的field相同,则覆 盖之前的field。如果为None则不创建新的field。
  • kwargs (optional) --

    支持输入is_input,is_target,ignore_type

    1. is_input: bool, 如果为True则将名为 new_field_name 的field设置为input
    2. is_target: bool, 如果为True则将名为 new_field_name 的field设置为target
    3. ignore_type: bool, 如果为True则将名为 new_field_name 的field的ignore_type设置为true, 忽略其类型
Return List[Any]:
 

里面的元素为func的返回值,所以list长度为DataSet的长度

apply_field_more(func, field_name, modify_fields=True, **kwargs)[源代码]

DataSet 中的每个 Instance 中的名为 field_name 的field 传给 func,并获取它的返回值。 func 可以返回一个或多个 field 上的结果。

注解

apply_field_moreapply_field 的区别参考 apply_more() 中关于 apply_moreapply 区别的介绍。

参数:
  • func (callable) -- 参数是 DataSet 中的 Instance ,返回值是一个字典,key 是field 的名字,value 是对应的结果
  • field_name (str) -- 传入func的是哪个field。
  • modify_fields (bool) -- 是否用结果修改 DataSet 中的 Field, 默认为 True
  • kwargs (optional) --

    支持输入is_input,is_target,ignore_type

    1. is_input: bool, 如果为True则将被修改的field设置为input
    2. is_target: bool, 如果为True则将被修改的field设置为target
    3. ignore_type: bool, 如果为True则将被修改的field的ignore_type设置为true, 忽略其类型
Return Dict[str:Field]:
 

返回一个字典

apply_more(func, modify_fields=True, **kwargs)[源代码]

DataSet 中每个 Instance 传入到func中,并获取它的返回值。func可以返回一个或多个 field 上的结果。

注解

apply_moreapply 的区别:

  1. apply_more 可以返回多个 field 的结果, apply 只可以返回一个field 的结果;
  2. apply_more 的返回值是一个字典,每个 key-value 对中的 key 表示 field 的名字,value 表示计算结果;
  3. apply_more 默认修改 DataSet 中的 field ,apply 默认不修改。
参数:
  • func (callable) -- 参数是 DataSet 中的 Instance ,返回值是一个字典,key 是field 的名字,value 是对应的结果
  • modify_fields (bool) -- 是否用结果修改 DataSet 中的 Field , 默认为 True
  • kwargs (optional) --

    支持输入is_input,is_target,ignore_type

    1. is_input: bool, 如果为True则将被修改的的field设置为input
    2. is_target: bool, 如果为True则将被修改的的field设置为target
    3. ignore_type: bool, 如果为True则将被修改的的field的ignore_type设置为true, 忽略其类型
Return Dict[str:Field]:
 

返回一个字典

copy_field(field_name, new_field_name)[源代码]

深度copy名为field_name的field到new_field_name

参数:
  • field_name (str) -- 需要copy的field。
  • new_field_name (str) -- copy生成的field名称
返回:

self

delete_collate_fn(name=None)[源代码]

删除某个collate_fn

参数:name (str,int) -- 如果为None,则删除最近加入的collate_fn
返回:
delete_field(field_name)[源代码]

删除名为field_name的field

参数:field_name (str) -- 需要删除的field的名称.
delete_instance(index)[源代码]

删除第index个instance

参数:index (int) -- 需要删除的instance的index,序号从0开始。
drop(func, inplace=True)[源代码]

func接受一个Instance,返回bool值。返回值为True时,该Instance会被移除或者不会包含在返回的DataSet中。

参数:
  • func (callable) -- 接受一个Instance作为参数,返回bool值。为True时删除该instance
  • inplace (bool) -- 是否在当前DataSet中直接删除instance;如果为False,将返回一个新的DataSet。
返回:

DataSet

get_all_fields()[源代码]

返回一个dict,key为field_name, value为对应的 FieldArray

Return dict:返回如上所述的字典
get_field(field_name)[源代码]

获取field_name这个field

参数:field_name (str) -- field的名称
返回:FieldArray
get_field_names() → list[源代码]

返回一个list,包含所有 field 的名字

Return list:返回如上所述的列表
get_input_name()[源代码]

返回所有is_input被设置为True的field名称

Return list:里面的元素为被设置为input的field名称
get_length()[源代码]

获取DataSet的元素数量

返回:int: DataSet中Instance的个数。
get_target_name()[源代码]

返回所有is_target被设置为True的field名称

Return list:里面的元素为被设置为target的field名称
has_field(field_name)[源代码]

判断DataSet中是否有名为field_name这个field

参数:field_name (str) -- field的名称
Return bool:表示是否有名为field_name这个field
static load(path)[源代码]

从保存的DataSet pickle文件的路径中读取DataSet

参数:path (str) -- 从哪里读取DataSet
返回:读取后的 读取后的DataSet
print_field_meta()[源代码]

输出当前field的meta信息, 形似下列的输出:

+-------------+-------+-------+
| field_names |   x   |   y   |
+=============+=======+=======+
|   is_input  |  True | False |
|  is_target  | False | False |
| ignore_type | False |       |
|  pad_value  |   0   |       |
+-------------+-------+-------+
参数:
  • field_names -- DataSet中field的名称
  • is_input -- field是否为input
  • is_target -- field是否为target
  • ignore_type -- 是否忽略该field的type, 一般仅在该field至少为input或target时才有意义
  • pad_value -- 该field的pad的值,仅在该field为input或target时有意义
返回:

rename_field(field_name, new_field_name)[源代码]

将某个field重新命名.

参数:
  • field_name (str) -- 原来的field名称。
  • new_field_name (str) -- 修改为new_name。
save(path)[源代码]

保存DataSet.

参数:path (str) -- 将DataSet存在哪个路径
set_ignore_type(*field_names, flag=True)[源代码]

将field设置为忽略类型状态。当某个field被设置了ignore_type, 则在被设置为target或者input时将不进行类型检查, 默认情况下也不进行pad。如果仍需要pad该field,可通过自定义Padder实现,若该field需要转换为tensor,需要在padder 中转换,但不需要在padder中移动到gpu。

参数:
  • field_names (str) -- field的名称
  • flag (bool) -- 将field_name的ignore_type状态设置为flag
返回:

set_input(*field_names, flag=True, use_1st_ins_infer_dim_type=True)[源代码]

将field_names的field设置为input:

dataset.set_input('words', 'seq_len')   # 将words和seq_len这两个field的input属性设置为True
dataset.set_input('words', flag=False)  # 将words这个field的input属性设置为False
参数:
  • field_names (str) -- field的名称
  • flag (bool) -- 将field_name的input状态设置为flag
  • use_1st_ins_infer_dim_type (bool) -- 如果为True,将不会check该列是否所有数据都是同样的维度,同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。
set_pad_val(field_name, pad_val)[源代码]

为某个field设置对应的pad_val.

参数:
  • field_name (str) -- 修改该field的pad_val
  • pad_val (int) -- 该field的padder会以pad_val作为padding index
set_padder(field_name, padder)[源代码]

为field_name设置padder:

from fastNLP import EngChar2DPadder
padder = EngChar2DPadder()
dataset.set_padder('chars', padder)  # 则chars这个field会使用EngChar2DPadder进行pad操作
参数:
  • field_name (str) -- 设置field的padding方式为padder
  • padder (None,Padder) -- 设置为None即删除padder, 即对该field不进行pad操作。
set_target(*field_names, flag=True, use_1st_ins_infer_dim_type=True)[源代码]

将field_names的field设置为target

Example:

dataset.set_target('labels', 'seq_len')  # 将labels和seq_len这两个field的target属性设置为True
dataset.set_target('labels', 'seq_lens', flag=False) # 将labels和seq_len的target属性设置为False
参数:
  • field_names (str) -- field的名称
  • flag (bool) -- 将field_name的target状态设置为flag
  • use_1st_ins_infer_dim_type (bool) -- 如果为True,将不会check该列是否所有数据都是同样的维度,同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。
split(ratio, shuffle=True)[源代码]

将DataSet按照ratio的比例拆分,返回两个DataSet

参数:
  • ratio (float) -- 0<ratio<1, 返回的第一个DataSet拥有 (1-ratio) 这么多数据,第二个DataSet拥有`ratio`这么多数据
  • shuffle (bool) -- 在split前是否shuffle一下
返回:

[ 读取后的DataSet , 读取后的DataSet ]

class fastNLP.Const[源代码]

别名 fastNLP.Const fastNLP.core.const.Const

fastNLP中field命名常量。

具体列表:

INPUT       模型的序列输入      words(具有多列words时,依次使用words1, words2, )
CHAR_INPUT  模型character输入  chars(具有多列chars时,依次使用chars1, chars2)
INPUT_LEN   序列长度           seq_len(具有多列seq_len时,依次使用seq_len1,seq_len2)
OUTPUT      模型输出           pred(具有多列pred时,依次使用pred1, pred2)
TARGET      真实目标           target(具有多列target时,依次使用target1,target2)
LOSS        损失函数           loss (具有多列loss时,依次使用loss1,loss2)
RAW_WORD    原文的词           raw_words  (具有多列raw_words时,依次使用raw_words1, raw_words2)
RAW_CHAR    原文的字           raw_chars  (具有多列raw_chars时,依次使用raw_chars1, raw_chars2)
CHAR_INPUT = 'chars'
static CHAR_INPUTS(i)[源代码]

得到第 i 个 CHAR_INPUT 的命名

INPUT = 'words'
static INPUTS(i)[源代码]

得到第 i 个 INPUT 的命名

INPUT_LEN = 'seq_len'
static INPUT_LENS(i)[源代码]

得到第 i 个 INPUT_LEN 的命名

LOSS = 'loss'
static LOSSES(i)[源代码]

得到第 i 个 LOSS 的命名

OUTPUT = 'pred'
static OUTPUTS(i)[源代码]

得到第 i 个 OUTPUT 的命名

RAW_CHAR = 'raw_chars'
static RAW_CHARS(i)[源代码]

得到第 i 个 RAW_CHARS 的命名

RAW_WORD = 'raw_words'
static RAW_WORDS(i)[源代码]

得到第 i 个 RAW_WORDS 的命名

TARGET = 'target'
static TARGETS(i)[源代码]

得到第 i 个 TARGET 的命名

__init__

Initialize self. See help(type(self)) for accurate signature.

class fastNLP.Trainer(train_data, model, optimizer=None, loss=None, batch_size=32, sampler=None, drop_last=False, update_every=1, num_workers=0, n_epochs=10, print_every=5, dev_data=None, metrics=None, metric_key=None, validate_every=-1, save_path=None, use_tqdm=True, device=None, callbacks=None, check_code_level=0, **kwargs)[源代码]

别名 fastNLP.Trainer fastNLP.core.trainer.Trainer

Trainer在fastNLP中用于组织单任务的训练过程,可以避免用户在不同训练任务中重复撰写
  1. epoch循环;
  2. 将数据分成不同的Batch;
  3. 对Batch进行pad;
  4. 每个epoch结束或一定step后进行验证集验证;
  5. 保存获得更好验证性能的模型等。

详细的介绍参见 fastNLP.core.trainer

__init__(train_data, model, optimizer=None, loss=None, batch_size=32, sampler=None, drop_last=False, update_every=1, num_workers=0, n_epochs=10, print_every=5, dev_data=None, metrics=None, metric_key=None, validate_every=-1, save_path=None, use_tqdm=True, device=None, callbacks=None, check_code_level=0, **kwargs)[源代码]
参数:
  • train_data -- 训练集, DataSet 类型或 BatchIter 的子类
  • model (nn.modules) -- 待训练的模型
  • optimizer -- torch.optim.Optimizer 优化器。如果为None,则Trainer使用默认的Adam(model.parameters(), lr=4e-3)这个优化器
  • batch_size (int) -- 训练和验证的时候的batch大小。
  • loss -- 使用的 LossBase 对象。当为None时,默认使用 LossInForward
  • sampler -- Batch数据生成的顺序, Sampler 类型。如果为None,默认使用 RandomSampler
  • drop_last -- 如果最后一个batch没有正好为batch_size这么多数据,就扔掉最后一个batch
  • num_workers -- int, 有多少个线程来进行数据pad处理。
  • update_every -- int, 多少步更新一次梯度。用于希望累计梯度的场景,比如需要128的batch_size, 但是直接设为128 会导致内存不足,通过设置batch_size=32, update_every=4达到目的。当optimizer为None时,该参数无效。
  • n_epochs (int) -- 需要优化迭代多少次。
  • print_every (int) -- 多少次反向传播更新tqdm显示的loss; 如果use_tqdm=False, 则多少次反向传播打印loss。
  • dev_data -- 用于做验证的DataSet, DataSet 类型。
  • metrics -- 验证的评估函数。可以只使用一个 Metric , 也可以使用多个 Metric ,通过列表传入。 如验证时取得了更好的验证结果(如果有多个Metric,以列表中第一个Metric为准),且save_path不为None, 则保存当前模型。Metric种类详见 metrics模块 。仅在传入dev_data时有效。
  • metric_key (str,None) -- Metric 有时会有多个指标, 比如 SpanFPreRecMetric 中包含了'f', 'pre', 'rec'。此时需 要指定以哪个指标为准。另外有些指标是越小效果越好,比如语言模型的困惑度,这种情况下,在key前面增加一个'-'来表 明验证时,值越小越好(比如: "-ppl")。仅在传入dev_data时有效。
  • validate_every (int) -- 多少个step在验证集上验证一次; 如果为-1,则每个epoch结束验证一次。仅在传入dev_data时有效。
  • save_path (str,None) -- 将模型保存路径,如果路径不存在,将自动创建文件夹。如果为None,则不保存模型。如果dev_data为None,则保存 最后一次迭代的模型。保存的时候不仅保存了参数,还保存了模型结构。即便使用DataParallel,这里也只保存模型。
  • use_tqdm (bool) -- 是否使用tqdm来显示训练进度; 如果为False,则将loss打印在终端中。
  • device (str,int,torch.device,list(int)) --

    将模型load到哪个设备。默认为None,即Trainer不对模型 的计算位置进行管理。支持以下的输入:

    1. str: ['cpu', 'cuda', 'cuda:0', 'cuda:1', ...] 依次为'cpu'中, 可见的第一个GPU中, 可见的第一个GPU中, 可见的第二个GPU中;

    1. torch.device:将模型装载到torch.device上。
    2. int: 将使用device_id为该值的gpu进行训练
    3. list(int):如果多于1个device,将使用torch.nn.DataParallel包裹model, 并使用传入的device。
    4. None. 为None则不对模型进行任何处理,如果传入的model为torch.nn.DataParallel该值必须为None。

    已知可能会出现的问题:Adagrad优化器可能无法正常使用这个参数,请手动管理模型位置。

  • callbacks (list(callbacks)) -- 用于在train过程中起调节作用的回调函数。比如early stop,negative sampling等可以 通过callback机制实现。 可使用的callback参见 callback模块
  • check_code_level (int) -- 模型检查等级. -1: 不进行检查; 0: 仅出现错误时停止; 1: 如果有field没有被使用, 报告警告信息; 2: 有任何field没有被使用都报错. 检查的原理是通过使用很小的batch(默认2个sample)来运行代码,但是 这个过程理论上不会修改任何参数,只是会检查能否运行。但如果(1)模型中存在将batch_size写为某个固定值的情况; (2)模型中存在累加前向计算次数的,可能会多计算1次。以上情况建议将check_code_level设置为-1。
  • kwargs -- 支持配置可选参数 bool test_use_tqdm: 在dev上验证的时候是否开启tqdm Sampler test_sampler: 在evaluate的时候使用的sampler
is_master

是否是主进程

train(load_best_model=True, on_exception='auto')[源代码]

使用该函数使Trainer开始训练。

参数:
  • load_best_model (bool) -- 该参数只有在初始化提供了dev_data的情况下有效,如果True, trainer将在返回之前重新加载dev表现 最好的模型参数。
  • on_exception (str) -- 在训练过程遭遇exception,并被 :py:class:Callback 的on_exception()处理后,是否继续抛出异常。 支持'ignore','raise', 'auto': 'ignore'将捕获异常,写在Trainer.train()后面的代码将继续运行; 'raise'将异常抛出; 'auto'将ignore以下两种Exception: CallbackException与KeyboardInterrupt, raise其它exception.
Return dict:

返回一个字典类型的数据, 内含以下内容:

seconds: float, 表示训练时长
以下三个内容只有在提供了dev_data的情况下会有。
best_eval: Dict of Dict, 表示evaluation的结果。第一层的key为Metric的名称,
            第二层的key为具体的Metric
best_epoch: int,在第几个epoch取得的最佳值
best_step: int, 在第几个step(batch)更新取得的最佳值
class fastNLP.Tester(data, model, metrics, batch_size=16, num_workers=0, device=None, verbose=1, use_tqdm=True, **kwargs)[源代码]

别名 fastNLP.Tester fastNLP.core.tester.Tester

Tester是在提供数据,模型以及metric的情况下进行性能测试的类。需要传入模型,数据以及metric进行验证。

__init__(data, model, metrics, batch_size=16, num_workers=0, device=None, verbose=1, use_tqdm=True, **kwargs)[源代码]
参数:
  • data (DataSet,BatchIter) -- 需要测试的数据集
  • model (torch.nn.Module) -- 使用的模型
  • metrics (MetricBase,List[MetricBase]) -- 测试时使用的metrics
  • batch_size (int) -- evaluation时使用的batch_size有多大。
  • device (str,int,torch.device,list(int)) --

    将模型load到哪个设备。默认为None,即Trainer不对模型 的计算位置进行管理。支持以下的输入:

    1. str: ['cpu', 'cuda', 'cuda:0', 'cuda:1', ...] 依次为'cpu'中, 可见的第一个GPU中,可见的第一个GPU中,可见的第二个GPU中;
    2. torch.device:将模型装载到torch.device上。
    3. int: 将使用device_id为该值的gpu进行训练
    4. list(int):如果多于1个device,将使用torch.nn.DataParallel包裹model, 并使用传入的device。
    5. None. 为None则不对模型进行任何处理,如果传入的model为torch.nn.DataParallel该值必须为None。

    如果模型是通过predict()进行预测的话,那么将不能使用多卡(DataParallel)进行验证,只会使用第一张卡上的模型。

  • verbose (int) -- 如果为0不输出任何信息; 如果为1,打印出验证结果。
  • use_tqdm (bool) -- 是否使用tqdm来显示测试进度; 如果为False,则不会显示任何内容。
  • kwargs -- 支持传入sampler控制测试顺序
test()[源代码]

开始进行验证,并返回验证结果。

Return Dict[Dict]:
 dict的二层嵌套结构,dict的第一层是metric的名称; 第二层是这个metric的指标。一个AccuracyMetric的例子为{'AccuracyMetric': {'acc': 1.0}}。
class fastNLP.DistTrainer(train_data, model, optimizer=None, loss=None, callbacks_all=None, callbacks_master=None, batch_size_per_gpu=8, n_epochs=1, num_workers=1, drop_last=False, dev_data=None, metrics=None, metric_key=None, update_every=1, print_every=10, validate_every=-1, save_path=None, device='auto', fp16='', use_tqdm=True)[源代码]

别名 fastNLP.DistTrainer fastNLP.core.dist_trainer.DistTrainer

分布式的 Trainer,支持分布式训练和混合精度的训练。具体实现原理请阅读 pytorch 官方文档。

Note: 使用分布式 Trainer 时会同时有多个进程执行训练代码。因此将单进程的训练代码改为多进程之前, 请仔细检查,确保训练代码中的同步和互斥操作能正确执行(如模型保持,打印日志等)

__init__(train_data, model, optimizer=None, loss=None, callbacks_all=None, callbacks_master=None, batch_size_per_gpu=8, n_epochs=1, num_workers=1, drop_last=False, dev_data=None, metrics=None, metric_key=None, update_every=1, print_every=10, validate_every=-1, save_path=None, device='auto', fp16='', use_tqdm=True)[源代码]
参数:
  • train_data -- 训练集, DataSet 类型。
  • model (nn.modules) -- 待训练的模型
  • optimizer -- torch.optim.Optimizer 优化器。如果为None,则Trainer使用默认的Adam(model.parameters(), lr=4e-3)这个优化器
  • loss -- 使用的 LossBase 对象。当为None时,默认使用 LossInForward
  • callbacks_all (list) -- 用于在train过程中起调节作用的回调函数,作用于所有训练进程中。 可使用的callback参见 callback模块
  • callbacks_master (list) -- 用于在train过程中起调节作用的回调函数,只作用于其中一个进程( Master 进程)。 可使用的callback参见 callback模块
  • batch_size_per_gpu (int) -- 训练时,每个进程的 batch 大小。
  • n_epochs (int) -- 需要优化迭代多少次。
  • num_workers -- int, 有多少个线程来进行数据pad处理。
  • drop_last -- 如果最后一个batch没有正好为batch_size这么多数据,就扔掉最后一个batch
  • dev_data -- 用于做验证的DataSet, DataSet 类型。
  • metrics -- 验证的评估函数。可以只使用一个 Metric , 也可以使用多个 Metric ,通过列表传入。 如验证时取得了更好的验证结果(如果有多个Metric,以列表中第一个Metric为准),且save_path不为None, 则保存当前模型。Metric种类详见 metrics模块 。仅在传入dev_data时有效。
  • metric_key (str,None) -- Metric 有时会有多个指标, 比如 SpanFPreRecMetric 中包含了'f', 'pre', 'rec'。此时需 要指定以哪个指标为准。另外有些指标是越小效果越好,比如语言模型的困惑度,这种情况下,在key前面增加一个'-'来表 明验证时,值越小越好(比如: "-ppl")。仅在传入dev_data时有效。
  • update_every -- int, 多少步更新一次梯度。用于希望累计梯度的场景,比如需要128的batch_size, 但是直接设为128 会导致内存不足,通过设置batch_size=32, update_every=4达到目的。当optimizer为None时,该参数无效。
  • print_every (int) -- 多少次反向传播更新tqdm显示的loss; 如果use_tqdm=False, 则多少次反向传播打印loss。
  • validate_every (int) -- 多少个step在验证集上验证一次; 如果为-1,则每个epoch结束验证一次。仅在传入dev_data时有效。
  • save_path (str,None) -- 将模型保存路径,如果路径不存在,将自动创建文件夹。如果为None,则不保存模型。如果dev_data为None,则保存 最后一次迭代的模型。保存的时候不仅保存了参数,还保存了模型结构。即便使用DataParallel,这里也只保存模型。
  • device (str) -- 指定 device,可以是 gpu,cpu 或 auto
  • fp16 (str) -- 指定半精度训练的优化等级,可为 O1,O2 或 O3,若为空字符串则不使用半精度。
  • use_tqdm (bool) -- 是否使用tqdm来显示训练进度; 如果为False,则将loss打印在终端中。
close()[源代码]

关闭Trainer,销毁进程

is_master

是否是主进程

save_check_point(name=None, only_params=False)[源代码]

保存当前模型

train(load_best_model=True, on_exception='auto')[源代码]

使用该函数使Trainer开始训练。

参数:

on_exception (str) -- 在训练过程遭遇exception,并被 :py:class:Callback 的on_exception()处理后,是否继续抛出异常。 支持'ignore','raise', 'auto': 'ignore'将捕获异常,写在Trainer.train()后面的代码将继续运行; 'raise'将异常抛出; 'auto'将ignore以下两种Exception: CallbackException与KeyboardInterrupt, raise其它exception.

Return dict:

返回一个字典类型的数据, 内含以下内容:

seconds: float, 表示训练时长
以下三个内容只有在提供了dev_data的情况下会有。
best_eval: Dict of Dict, 表示evaluation的结果。第一层的key为Metric的名称,
            第二层的key为具体的Metric
best_epoch: int,在第几个epoch取得的最佳值
best_step: int, 在第几个step(batch)更新取得的最佳值
fastNLP.get_local_rank()[源代码]

别名 fastNLP.get_local_rank fastNLP.core.dist_trainer.get_local_rank

返回当前进程的 local rank, 0 到 N-1 ,N为当前分布式总进程数

class fastNLP.Callback[源代码]

别名 fastNLP.Callback fastNLP.core.callback.Callback

Callback是fastNLP中被设计用于增强 Trainer 的类。 如果Callback被传递给了 Trainer , 则 Trainer 会在对应的阶段调用Callback的函数, 具体调用时机可以通过 trainer 模块 查看。 这是Callback的基类,所有的callback必须继承自这个类

batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)[源代码]

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_backward_end()[源代码]

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)[源代码]

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()[源代码]

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()[源代码]

在每个epoch开始之前调用一次

返回:
on_epoch_end()[源代码]

每个epoch结束将会调用该方法

on_exception(exception)[源代码]

当训练过程出现异常,会触发该方法 :param exception: 某种类型的Exception,比如KeyboardInterrupt等

on_loss_begin(batch_y, predict_y)[源代码]

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()[源代码]

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_begin()[源代码]

在Train过程开始之前调用。

返回:
on_train_end()[源代码]

训练结束,调用该方法

on_valid_begin()[源代码]

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
on_valid_end(eval_result, metric_key, optimizer, is_better_eval)[源代码]

每次执行验证集的evaluation后会调用。

参数:
  • Dict[str -- Dict[str: float]] eval_result: , evaluation的结果。一个例子为{'AccuracyMetric':{'acc':1.0}},即 传入的dict是有两层,第一层是metric的名称,第二层是metric的具体指标。
  • metric_key (str) -- 初始化Trainer时传入的metric_key。
  • optimizer (torch.Optimizer) -- Trainer中使用的优化器。
  • is_better_eval (bool) -- 当前dev结果是否比之前的好。
返回:

optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.GradientClipCallback(parameters=None, clip_value=1, clip_type='norm')[源代码]

基类 fastNLP.Callback

别名 fastNLP.GradientClipCallback fastNLP.core.callback.GradientClipCallback

每次backward前,将parameter的gradient clip到某个范围。
__init__(parameters=None, clip_value=1, clip_type='norm')[源代码]
参数:
  • parameters (None,torch.Tensor,List[torch.Tensor]) -- 一般通过model.parameters()获得。 如果为None则默认对Trainer的model中所有参数进行clip
  • clip_value (float) -- 将gradient 限制到[-clip_value, clip_value]。clip_value应该为正数
  • clip_type (str) --

    支持'norm', 'value' 两种:

    1 'norm', 将gradient的norm rescale到[-clip_value, clip_value]
    
    2 'value', 将gradient限制在[-clip_value, clip_value],
        小于-clip_value的gradient被赋值为-clip_value;
        大于clip_value的gradient被赋值为clip_value.
    
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_exception(exception)

当训练过程出现异常,会触发该方法 :param exception: 某种类型的Exception,比如KeyboardInterrupt等

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_begin()

在Train过程开始之前调用。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
on_valid_end(eval_result, metric_key, optimizer, is_better_eval)

每次执行验证集的evaluation后会调用。

参数:
  • Dict[str -- Dict[str: float]] eval_result: , evaluation的结果。一个例子为{'AccuracyMetric':{'acc':1.0}},即 传入的dict是有两层,第一层是metric的名称,第二层是metric的具体指标。
  • metric_key (str) -- 初始化Trainer时传入的metric_key。
  • optimizer (torch.Optimizer) -- Trainer中使用的优化器。
  • is_better_eval (bool) -- 当前dev结果是否比之前的好。
返回:

optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.EarlyStopCallback(patience)[源代码]

基类 fastNLP.Callback

别名 fastNLP.EarlyStopCallback fastNLP.core.callback.EarlyStopCallback

多少个epoch没有变好就停止训练,相关类 EarlyStopError
__init__(patience)[源代码]
参数:patience (int) -- epoch的数量
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_begin()

在Train过程开始之前调用。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.FitlogCallback(data=None, tester=None, log_loss_every=0, verbose=1, log_exception=False)[源代码]

基类 fastNLP.Callback

别名 fastNLP.FitlogCallback fastNLP.core.callback.FitlogCallback

该callback可将loss和progress写入到fitlog中; 如果Trainer有dev的数据,将自动把dev的结果写入到log中; 同时还支持传入 一个(或多个)test数据集进行测试(只有在trainer具有dev时才能使用),每次在dev上evaluate之后会在这些数据集上验证一下。 并将验证结果写入到fitlog中。这些数据集的结果是根据dev上最好的结果报道的,即如果dev在第3个epoch取得了最佳,则 fitlog中记录的关于这些数据集的结果就是来自第三个epoch的结果。
__init__(data=None, tester=None, log_loss_every=0, verbose=1, log_exception=False)[源代码]
参数:
  • data (DataSet,Dict[DataSet]) -- 传入DataSet对象,会使用多个Trainer中的metric对数据进行验证。如果需要 传入多个DataSet请通过dict的方式传入,dict的key将作为对应dataset的name传递给fitlog。data的结果的名称以'data'开头。
  • tester (Tester,Dict[Tester]) -- Tester对象,将在on_valid_end时调用。tester的结果的名称以'tester'开头
  • log_loss_every (int) -- 多少个step记录一次loss(记录的是这几个batch的loss平均值),如果数据集较大建议将该值设置得 大一些,不然会导致log文件巨大。默认为0, 即不要记录loss。
  • verbose (int) -- 是否在终端打印evaluation的结果,0不打印。
  • log_exception (bool) -- fitlog是否记录发生的exception信息
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.EvaluateCallback(data=None, tester=None)[源代码]

基类 fastNLP.Callback

别名 fastNLP.EvaluateCallback fastNLP.core.callback.EvaluateCallback

通过使用该Callback可以使得Trainer在evaluate dev之外还可以evaluate其它数据集,比如测试集。每一次验证dev之前都会先验证EvaluateCallback 中的数据。
__init__(data=None, tester=None)[源代码]
参数:
  • data (DataSet,Dict[DataSet]) -- 传入DataSet对象,会使用Trainer中的metric对数据进行验证。如果需要传入多个 DataSet请通过dict的方式传入。
  • tester (Tester,Dict[DataSet]) -- Tester对象, 通过使用Tester对象,可以使得验证的metric与Trainer中 的metric不一样。
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_exception(exception)

当训练过程出现异常,会触发该方法 :param exception: 某种类型的Exception,比如KeyboardInterrupt等

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.LRScheduler(lr_scheduler)[源代码]

基类 fastNLP.Callback

别名 fastNLP.LRScheduler fastNLP.core.callback.LRScheduler

对PyTorch LR Scheduler的包装以使得其可以被Trainer所使用
__init__(lr_scheduler)[源代码]
参数:lr_scheduler (torch.optim.lr_scheduler._LRScheduler) -- PyTorch的lr_scheduler
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_exception(exception)

当训练过程出现异常,会触发该方法 :param exception: 某种类型的Exception,比如KeyboardInterrupt等

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_begin()

在Train过程开始之前调用。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
on_valid_end(eval_result, metric_key, optimizer, is_better_eval)

每次执行验证集的evaluation后会调用。

参数:
  • Dict[str -- Dict[str: float]] eval_result: , evaluation的结果。一个例子为{'AccuracyMetric':{'acc':1.0}},即 传入的dict是有两层,第一层是metric的名称,第二层是metric的具体指标。
  • metric_key (str) -- 初始化Trainer时传入的metric_key。
  • optimizer (torch.Optimizer) -- Trainer中使用的优化器。
  • is_better_eval (bool) -- 当前dev结果是否比之前的好。
返回:

optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.ControlC(quit_and_do, action=<staticmethod object>)[源代码]

基类 fastNLP.Callback

别名 fastNLP.ControlC fastNLP.core.callback.ControlC

检测到 control+C 时的反馈
__init__(quit_and_do, action=<staticmethod object>)[源代码]
参数:quit_and_do (bool) -- 若为True,则检测到control+C 进行后续操作(默认值为:直接退出程序);否则只退出Trainer。
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_begin()

在Train过程开始之前调用。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
on_valid_end(eval_result, metric_key, optimizer, is_better_eval)

每次执行验证集的evaluation后会调用。

参数:
  • Dict[str -- Dict[str: float]] eval_result: , evaluation的结果。一个例子为{'AccuracyMetric':{'acc':1.0}},即 传入的dict是有两层,第一层是metric的名称,第二层是metric的具体指标。
  • metric_key (str) -- 初始化Trainer时传入的metric_key。
  • optimizer (torch.Optimizer) -- Trainer中使用的优化器。
  • is_better_eval (bool) -- 当前dev结果是否比之前的好。
返回:

optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.LRFinder(start_lr=1e-06, end_lr=10)[源代码]

基类 fastNLP.Callback

别名 fastNLP.LRFinder fastNLP.core.callback.LRFinder

用第一个 epoch 找最佳的学习率,从第二个epoch开始应用它
__init__(start_lr=1e-06, end_lr=10)[源代码]
参数:
  • start_lr (float) -- 学习率下界
  • end_lr (float) -- 学习率上界
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_exception(exception)

当训练过程出现异常,会触发该方法 :param exception: 某种类型的Exception,比如KeyboardInterrupt等

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_begin()

在Train过程开始之前调用。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
on_valid_end(eval_result, metric_key, optimizer, is_better_eval)

每次执行验证集的evaluation后会调用。

参数:
  • Dict[str -- Dict[str: float]] eval_result: , evaluation的结果。一个例子为{'AccuracyMetric':{'acc':1.0}},即 传入的dict是有两层,第一层是metric的名称,第二层是metric的具体指标。
  • metric_key (str) -- 初始化Trainer时传入的metric_key。
  • optimizer (torch.Optimizer) -- Trainer中使用的优化器。
  • is_better_eval (bool) -- 当前dev结果是否比之前的好。
返回:

optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.TensorboardCallback(*options)[源代码]

基类 fastNLP.Callback

别名 fastNLP.TensorboardCallback fastNLP.core.callback.TensorboardCallback

接受以下一个或多个字符串作为参数: - "model" - "loss" - "metric"

警告

fastNLP 已停止对此功能的维护,请等待 fastNLP 兼容 PyTorch1.1 的下一个版本。 或者使用和 fastNLP 高度配合的 fitlog(参见 使用fitlog 辅助 fastNLP 进行科研 )。

batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.WarmupCallback(warmup=0.1, schedule='constant')[源代码]

基类 fastNLP.Callback

别名 fastNLP.WarmupCallback fastNLP.core.callback.WarmupCallback

learning rate按照一定的速率从0上升到设置的learning rate。
__init__(warmup=0.1, schedule='constant')[源代码]
参数:
  • warmup (int,float) -- 如果warmup为int,则在该step之前,learning rate根据schedule的策略变化; 如果warmup为float, 如0.1, 则前10%的step是按照schedule策略调整learning rate。
  • schedule (str) -- 以哪种方式调整。 linear: 前warmup的step上升到指定的learning rate(从Trainer中的optimizer处获取的), 后warmup的step下降到0; constant前warmup的step上升到指定learning rate,后面的step保持learning rate.
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_exception(exception)

当训练过程出现异常,会触发该方法 :param exception: 某种类型的Exception,比如KeyboardInterrupt等

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
on_valid_end(eval_result, metric_key, optimizer, is_better_eval)

每次执行验证集的evaluation后会调用。

参数:
  • Dict[str -- Dict[str: float]] eval_result: , evaluation的结果。一个例子为{'AccuracyMetric':{'acc':1.0}},即 传入的dict是有两层,第一层是metric的名称,第二层是metric的具体指标。
  • metric_key (str) -- 初始化Trainer时传入的metric_key。
  • optimizer (torch.Optimizer) -- Trainer中使用的优化器。
  • is_better_eval (bool) -- 当前dev结果是否比之前的好。
返回:

optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

class fastNLP.SaveModelCallback(save_dir, top=3, only_param=False, save_on_exception=False)[源代码]

基类 fastNLP.Callback

别名 fastNLP.SaveModelCallback fastNLP.core.callback.SaveModelCallback

由于Trainer在训练过程中只会保存最佳的模型, 该callback可实现多种方式的结果存储。 会根据训练开始的时间戳在save_dir下建立文件夹,再在文件夹下存放多个模型:

-save_dir
    -2019-07-03-15-06-36
        -epoch:0_step:20_{metric_key}:{evaluate_performance}.pt   # metric是给定的metric_key, evaluate_performance是性能
        -epoch:1_step:40_{metric_key}:{evaluate_performance}.pt
    -2019-07-03-15-10-00
        -epoch:0_step:20_{metric_key}:{evaluate_performance}.pt   # metric是给定的metric_key, evaluate_perfomance是性能
__init__(save_dir, top=3, only_param=False, save_on_exception=False)[源代码]
参数:
  • save_dir (str) -- 将模型存放在哪个目录下,会在该目录下创建以时间戳命名的目录,并存放模型。如果save_dir不存在将自动创建
  • top (int) -- 保存dev表现top多少模型。-1为保存所有模型。
  • only_param (bool) -- 是否只保存模型的权重。
  • save_on_exception -- 发生exception时,是否保存一份发生exception的模型。模型名称为epoch:x_step:x_Exception:{exception_name}.
batch_per_epoch

每个epoch一共有多少个batch,只有在on_epoch_begin之后才能调用该属性。

batch_size

train和evaluate时的batch_size为多大

epoch

当前运行的epoch数,范围是[1, self.n_epochs+1)

model

正在被Trainer训练的模型

n_epochs

一共会运行多少个epoch

n_steps

Trainer一共会采多少个batch。当Trainer中update_every设置为非1的值时,该值不等于update的次数

on_backward_begin(loss)

在loss得到之后,但在反向传播之前。可能可以进行loss是否为NaN的检查。

参数:loss (torch.Tensor) -- 计算得到的loss值
返回:
on_backward_end()

反向梯度传播已完成,但由于update_every的设置,可能并不是每一次调用都有梯度。到这一步,还没有更新参数。

返回:
on_batch_begin(batch_x, batch_y, indices)

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作

参数:
  • batch_x (dict) -- DataSet中被设置为input的field的batch。
  • batch_y (dict) -- DataSet中被设置为target的field的batch。
  • indices (list(int)) -- 这次采样使用到的indices,可以通过DataSet[indices]获取出这个batch采出的Instance,在一些 情况下可以帮助定位是哪个Sample导致了错误。仅当num_workers=0时有效。
返回:

on_batch_end()

这一步与on_step_end是紧接着的。只是为了对称性加上了这一步。

on_epoch_begin()

在每个epoch开始之前调用一次

返回:
on_epoch_end()

每个epoch结束将会调用该方法

on_loss_begin(batch_y, predict_y)

在计算loss前调用,即这里修改batch_y或predict_y的值是可以影响到loss计算的。

参数:
  • batch_y (dict) -- 在DataSet中被设置为target的field的batch集合。
  • predict_y (dict) -- 模型的forward()返回的结果。
返回:

on_step_end()

到这里模型的参数已经按照梯度更新。但可能受update_every影响,并不是每次都更新了。

返回:
on_train_end()

训练结束,调用该方法

on_valid_begin()

如果Trainer中设置了验证,则发生验证前会调用该函数

返回:
optimizer

初始化Trainer时传递的Optimizer

pbar

如果在Callback中需要打印内容,请使用self.pbar.write(str)。否则可能出现命令行显示效果不太好的问题。在 on_train_begin(), on_train_end(), on_exception()中请不要使用该属性,通过print输出即可。

step

当前运行到的step, 范围为[1, self.n_steps+1)

trainer

该属性可以通过self.trainer获取到,一般情况下不需要使用这个属性。

update_every

Trainer中的模型多少次反向传播才进行一次梯度更新,在Trainer初始化时传入的。

exception fastNLP.CallbackException(msg)[源代码]

别名 fastNLP.CallbackException fastNLP.core.callback.CallbackException

当需要通过callback跳出训练的时候可以通过抛出CallbackException并在on_exception中捕获这个值。

__init__(msg)[源代码]
参数:msg (str) -- Exception的信息。
with_traceback()

Exception.with_traceback(tb) -- set self.__traceback__ to tb and return self.

exception fastNLP.EarlyStopError(msg)[源代码]

基类 fastNLP.CallbackException

别名 fastNLP.EarlyStopError fastNLP.core.callback.EarlyStopError

用于EarlyStop时从Trainer训练循环中跳出。
with_traceback()

Exception.with_traceback(tb) -- set self.__traceback__ to tb and return self.

class fastNLP.Padder(pad_val=0, **kwargs)[源代码]

别名 fastNLP.Padder fastNLP.core.field.Padder

所有padder都需要继承这个类,并覆盖__call__方法。 用于对batch进行padding操作。传入的element是inplace的,即直接修改element可能导致数据变化,建议inplace修改之前deepcopy一份。

__call__(self, contents, field_name, field_ele_dtype):
__init__(pad_val=0, **kwargs)[源代码]
参数:
  • contents (List[Any]) -- 传入的element是inplace的,即直接修改element可能导致数据变化,建议inplace修改之前 deepcopy一份。
  • field_name (str,) -- field的名称。
  • field_ele_dtype (np.int64,np.float64,np.str,None,) -- 该field的内层元素的类型。如果该field的ignore_type为True,该这个值为None。
返回:

np.array([padded_element])

class fastNLP.AutoPadder(pad_val=0)[源代码]

基类 fastNLP.Padder

别名 fastNLP.AutoPadder fastNLP.core.field.AutoPadder

根据contents的数据自动判定是否需要做padding。

1 如果元素类型(元素类型是指field中最里层元素的数据类型, 可以通过FieldArray.dtype查看,比如['This', 'is', ...]的元素类 型为str, [[1,2], ...]的元素类型为int)的数据不为数值类型则不会进行pad

2 如果元素类型为数值类型,比如np.int64, np.float64, int, float, torch.int64等

2.1 如果该field的内容为数值类型(包括int, float等),比如为seq_len, 则不进行padding

2.2 如果该field的内容等价于一维list, 那么会将Batch中的List pad为一样长。

2.3 如果该field的内容等价于二维list,那么会按照英语character padding的方式进行padding。如果是character padding建议使用
class:fastNLP.EngChar2DPadder.
2.4 如果该field的内容等价于三维list,则如果每个instance在每个维度上相等,会组成一个batch的tensor返回,这种情况应该是为图片
的情况。

3 其它情况不进行处理,返回一个np.array类型。

class fastNLP.EngChar2DPadder(pad_val=0, pad_length=0)[源代码]

基类 fastNLP.Padder

别名 fastNLP.EngChar2DPadder fastNLP.core.field.EngChar2DPadder

用于为英语执行character级别的2D padding操作。对应的field内容应该类似[['T', 'h', 'i', 's'], ['a'], ['d', 'e', 'm', 'o']], 但这个Padder只能处理index为int的情况。

padded过后的batch内容,形状为(batch_size, max_sentence_length, max_word_length). max_sentence_length为这个batch中最大句 子长度;max_word_length为这个batch中最长的word的长度:

from fastNLP import DataSet
from fastNLP import EngChar2DPadder
from fastNLP import Vocabulary
dataset = DataSet({'sent': ['This is the first demo', 'This is the second demo']})
dataset.apply(lambda ins:[list(word) for word in ins['sent'].split()], new_field_name='chars')
vocab = Vocabulary()
vocab.from_dataset(dataset, field_name='chars')
vocab.index_dataset(dataset, field_name='chars')
dataset.set_input('chars')
padder = EngChar2DPadder()
dataset.set_padder('chars', padder)  # chars这个field的设置为了EnChar2DPadder
__init__(pad_val=0, pad_length=0)[源代码]
参数:
  • pad_val -- int, pad的位置使用该index
  • pad_length -- int, 如果为0则取一个batch中最大的单词长度作为padding长度。如果为大于0的数,则将所有单词的长度 都pad或截取到该长度.
class fastNLP.ConcatCollateFn(inputs, output, pad_val=0, max_len=0, is_input=True, is_target=False)[源代码]

别名 fastNLP.ConcatCollateFn fastNLP.core.ConcatCollateFn

field拼接collate_fn,将不同field按序拼接后,padding产生数据。

参数:
  • inputs (List[str]) -- 将哪些field的数据拼接起来, 目前仅支持1d的field
  • output (str) -- 拼接后的field名称
  • pad_val -- padding的数值
  • max_len -- 拼接后最大长度
  • is_input -- 是否将生成的output设置为input
  • is_target -- 是否将生成的output设置为target
class fastNLP.MetricBase[源代码]

别名 fastNLP.MetricBase fastNLP.core.metrics.MetricBase

所有metrics的基类,所有的传入到Trainer, Tester的Metric需要继承自该对象,需要覆盖写入evaluate(), get_metric()方法。

evaluate(xxx)中传入的是一个batch的数据。

get_metric(xxx)当所有数据处理完毕,调用该方法得到最终的metric值

以分类问题中,Accuracy计算为例 假设model的forward返回dict中包含 pred 这个key, 并且该key需要用于Accuracy:

class Model(nn.Module):
    def __init__(xxx):
        # do something
    def forward(self, xxx):
        # do something
        return {'pred': pred, 'other_keys':xxx} # pred's shape: batch_size x num_classes

假设dataset中 label 这个field是需要预测的值,并且该field被设置为了target 对应的AccMetric可以按如下的定义, version1, 只使用这一次:

class AccMetric(MetricBase):
    def __init__(self):
        super().__init__()

        # 根据你的情况自定义指标
        self.corr_num = 0
        self.total = 0

    def evaluate(self, label, pred): # 这里的名称需要和dataset中target field与model返回的key是一样的,不然找不到对应的value
        # dev或test时,每个batch结束会调用一次该方法,需要实现如何根据每个batch累加metric
        self.total += label.size(0)
        self.corr_num += label.eq(pred).sum().item()

    def get_metric(self, reset=True): # 在这里定义如何计算metric
        acc = self.corr_num/self.total
        if reset: # 是否清零以便重新计算
            self.corr_num = 0
            self.total = 0
        return {'acc': acc} # 需要返回一个dict,key为该metric的名称,该名称会显示到Trainer的progress bar中

version2,如果需要复用Metric,比如下一次使用AccMetric时,dataset中目标field不叫label而叫y,或者model的输出不是pred:

class AccMetric(MetricBase):
    def __init__(self, label=None, pred=None):
        # 假设在另一场景使用时,目标field叫y,model给出的key为pred_y。则只需要在初始化AccMetric时,
        #   acc_metric = AccMetric(label='y', pred='pred_y')即可。
        # 当初始化为acc_metric = AccMetric(),即label=None, pred=None, fastNLP会直接使用'label', 'pred'作为key去索取对
        #   应的的值
        super().__init__()
        self._init_param_map(label=label, pred=pred) # 该方法会注册label和pred. 仅需要注册evaluate()方法会用到的参数名即可
        # 如果没有注册该则效果与version1就是一样的

        # 根据你的情况自定义指标
        self.corr_num = 0
        self.total = 0

    def evaluate(self, label, pred): # 这里的参数名称需要和self._init_param_map()注册时一致。
        # dev或test时,每个batch结束会调用一次该方法,需要实现如何根据每个batch累加metric
        self.total += label.size(0)
        self.corr_num += label.eq(pred).sum().item()

    def get_metric(self, reset=True): # 在这里定义如何计算metric
        acc = self.corr_num/self.total
        if reset: # 是否清零以便重新计算
            self.corr_num = 0
            self.total = 0
        return {'acc': acc} # 需要返回一个dict,key为该metric的名称,该名称会显示到Trainer的progress bar中

MetricBase 将会在输入的字典 pred_dicttarget_dict 中进行检查. pred_dict 是模型当中 forward() 函数或者 predict() 函数的返回值. target_dict 是DataSet当中的ground truth, 判定ground truth的条件是field的 is_target 被设置为True.

MetricBase 会进行以下的类型检测:

  1. self.evaluate当中是否有varargs, 这是不支持的.
  2. self.evaluate当中所需要的参数是否既不在 pred_dict 也不在 target_dict .
  3. self.evaluate当中所需要的参数是否既在 pred_dict 也在 target_dict .

除此以外,在参数被传入self.evaluate以前,这个函数会检测 pred_dicttarget_dict 当中没有被用到的参数 如果kwargs是self.evaluate的参数,则不会检测

self.evaluate将计算一个批次(batch)的评价指标,并累计。 没有返回值 self.get_metric将统计当前的评价指标并返回评价结果, 返回值需要是一个dict, key是指标名称,value是指标的值

get_metric_name()[源代码]

返回metric的名称

返回:
set_metric_name(name: str)[源代码]

设置metric的名称,默认是Metric的class name.

参数:name (str) --
返回:self
class fastNLP.AccuracyMetric(pred=None, target=None, seq_len=None)[源代码]

基类 fastNLP.MetricBase

别名 fastNLP.AccuracyMetric fastNLP.core.metrics.AccuracyMetric

准确率Metric(其它的Metric参见 fastNLP.core.metrics
__init__(pred=None, target=None, seq_len=None)[源代码]
参数:
  • pred -- 参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred
  • target -- 参数映射表中 target 的映射关系,None表示映射关系为 target -> target
  • seq_len -- 参数映射表中 seq_len 的映射关系,None表示映射关系为 seq_len -> seq_len
evaluate(pred, target, seq_len=None)[源代码]

evaluate函数将针对一个批次的预测结果做评价指标的累计

参数:
  • pred (torch.Tensor) -- 预测的tensor, tensor的形状可以是torch.Size([B,]), torch.Size([B, n_classes]), torch.Size([B, max_len]), 或者torch.Size([B, max_len, n_classes])
  • target (torch.Tensor) -- 真实值的tensor, tensor的形状可以是Element's can be: torch.Size([B,]), torch.Size([B,]), torch.Size([B, max_len]), 或者torch.Size([B, max_len])
  • seq_len (torch.Tensor) -- 序列长度标记, 标记的形状可以是None, None, torch.Size([B]), 或者torch.Size([B]). 如果mask也被传进来的话seq_len会被忽略.
get_metric(reset=True)[源代码]

get_metric函数将根据evaluate函数累计的评价指标统计量来计算最终的评价结果.

参数:reset (bool) -- 在调用完get_metric后是否清空评价指标统计量.
Return dict evaluate_result:
 {"acc": float}
get_metric_name()

返回metric的名称

返回:
set_metric_name(name: str)

设置metric的名称,默认是Metric的class name.

参数:name (str) --
返回:self
class fastNLP.SpanFPreRecMetric(tag_vocab, pred=None, target=None, seq_len=None, encoding_type=None, ignore_labels=None, only_gross=True, f_type='micro', beta=1)[源代码]

基类 fastNLP.MetricBase

别名 fastNLP.SpanFPreRecMetric fastNLP.core.metrics.SpanFPreRecMetric

在序列标注问题中,以span的方式计算F, pre, rec. 比如中文Part of speech中,会以character的方式进行标注,句子 中国在亚洲 对应的POS可能为(以BMES为例) ['B-NN', 'E-NN', 'S-DET', 'B-NN', 'E-NN']。该metric就是为类似情况下的F1计算。 最后得到的metric结果为:

{
    'f': xxx, # 这里使用f考虑以后可以计算f_beta值
    'pre': xxx,
    'rec':xxx
}

若only_gross=False, 即还会返回各个label的metric统计值:

{
    'f': xxx,
    'pre': xxx,
    'rec':xxx,
    'f-label': xxx,
    'pre-label': xxx,
    'rec-label':xxx,
    ...
}
__init__(tag_vocab, pred=None, target=None, seq_len=None, encoding_type=None, ignore_labels=None, only_gross=True, f_type='micro', beta=1)[源代码]
参数:
  • tag_vocab -- 标签的 Vocabulary 。支持的标签为"B"(没有label);或"B-xxx"(xxx为某种label,比如POS中的NN), 在解码时,会将相同xxx的认为是同一个label,比如['B-NN', 'E-NN']会被合并为一个'NN'.
  • pred (str) -- 用该key在evaluate()时从传入dict中取出prediction数据。 为None,则使用 pred 取数据
  • target (str) -- 用该key在evaluate()时从传入dict中取出target数据。 为None,则使用 target 取数据
  • seq_len (str) -- 用该key在evaluate()时从传入dict中取出sequence length数据。为None,则使用 seq_len 取数据。
  • encoding_type (str) -- 目前支持bio, bmes, bmeso, bioes。默认为None,通过tag_vocab自动判断.
  • ignore_labels (list) -- str 组成的list. 这个list中的class不会被用于计算。例如在POS tagging时传入['NN'],则不会计算'NN'个label
  • only_gross (bool) -- 是否只计算总的f1, precision, recall的值;如果为False,不仅返回总的f1, pre, rec, 还会返回每个label的f1, pre, rec
  • f_type (str) -- micromacro . micro :通过先计算总体的TP,FN和FP的数量,再计算f, precision, recall; macro : 分布计算每个类别的f, precision, recall,然后做平均(各类别f的权重相同)
  • beta (float) -- f_beta分数, \(f_{beta} = \frac{(1 + {beta}^{2})*(pre*rec)}{({beta}^{2}*pre + rec)}\) . 常用为 beta=0.5, 1, 2 若为0.5则精确率的权重高于召回率;若为1,则两者平等;若为2,则召回率权重高于精确率。
evaluate(pred, target, seq_len)[源代码]

evaluate函数将针对一个批次的预测结果做评价指标的累计

参数:
  • pred -- [batch, seq_len] 或者 [batch, seq_len, len(tag_vocab)], 预测的结果
  • target -- [batch, seq_len], 真实值
  • seq_len -- [batch] 文本长度标记
返回:

get_metric(reset=True)[源代码]

get_metric函数将根据evaluate函数累计的评价指标统计量来计算最终的评价结果.

get_metric_name()

返回metric的名称

返回:
set_metric_name(name: str)

设置metric的名称,默认是Metric的class name.

参数:name (str) --
返回:self
class fastNLP.CMRC2018Metric(answers=None, raw_chars=None, context_len=None, pred_start=None, pred_end=None)[源代码]

基类 fastNLP.MetricBase

别名 fastNLP.CMRC2018Metric fastNLP.core.metrics.CMRC2018Metric

CRMC2018任务的评价metric
evaluate(answers, raw_chars, pred_start, pred_end, context_len=None)[源代码]
参数:
  • answers (list[str]) -- 如[["答案1", "答案2", "答案3"], [...], ...]
  • raw_chars (list[str]) -- [["这", "是", ...], [...]]
  • pred_start (tensor) -- batch_size x length 或 batch_size,
  • pred_end (tensor) -- batch_size x length 或 batch_size(是闭区间,包含end位置),
  • context_len (tensor) -- context长度, batch_size
返回:

get_metric_name()

返回metric的名称

返回:
set_metric_name(name: str)

设置metric的名称,默认是Metric的class name.

参数:name (str) --
返回:self
class fastNLP.ClassifyFPreRecMetric(tag_vocab=None, pred=None, target=None, seq_len=None, ignore_labels=None, only_gross=True, f_type='micro', beta=1)[源代码]

基类 fastNLP.MetricBase

别名 fastNLP.ClassifyFPreRecMetric fastNLP.core.metrics.ClassifyFPreRecMetric

分类问题计算FPR值的Metric(其它的Metric参见 fastNLP.core.metrics

最后得到的metric结果为:

{
    'f': xxx, # 这里使用f考虑以后可以计算f_beta值
    'pre': xxx,
    'rec':xxx
}

若only_gross=False, 即还会返回各个label的metric统计值:

{
    'f': xxx,
    'pre': xxx,
    'rec':xxx,
    'f-label': xxx,
    'pre-label': xxx,
    'rec-label':xxx,
    ...
}
__init__(tag_vocab=None, pred=None, target=None, seq_len=None, ignore_labels=None, only_gross=True, f_type='micro', beta=1)[源代码]
参数:
  • tag_vocab -- 标签的 Vocabulary . 默认值为None。若为None则使用数字来作为标签内容,否则使用vocab来作为标签内容。
  • pred (str) -- 用该key在evaluate()时从传入dict中取出prediction数据。 为None,则使用 pred 取数据
  • target (str) -- 用该key在evaluate()时从传入dict中取出target数据。 为None,则使用 target 取数据
  • seq_len (str) -- 用该key在evaluate()时从传入dict中取出sequence length数据。为None,则使用 seq_len 取数据。
  • ignore_labels (list) -- str 组成的list. 这个list中的class不会被用于计算。例如在POS tagging时传入['NN'],则不会计算'NN'个label
  • only_gross (bool) -- 是否只计算总的f1, precision, recall的值;如果为False,不仅返回总的f1, pre, rec, 还会返回每个label的f1, pre, rec
  • f_type (str) -- micromacro . micro :通过先计算总体的TP,FN和FP的数量,再计算f, precision, recall; macro : 分布计算每个类别的f, precision, recall,然后做平均(各类别f的权重相同)
  • beta (float) -- f_beta分数, \(f_{beta} = \frac{(1 + {beta}^{2})*(pre*rec)}{({beta}^{2}*pre + rec)}\) . 常用为 beta=0.5, 1, 2 若为0.5则精确率的权重高于召回率;若为1,则两者平等;若为2,则召回率权重高于精确率。
evaluate(pred, target, seq_len=None)[源代码]

evaluate函数将针对一个批次的预测结果做评价指标的累计

参数:
  • pred (torch.Tensor) -- 预测的tensor, tensor的形状可以是torch.Size([B,]), torch.Size([B, n_classes]), torch.Size([B, max_len]), 或者torch.Size([B, max_len, n_classes])
  • target (torch.Tensor) -- 真实值的tensor, tensor的形状可以是Element's can be: torch.Size([B,]), torch.Size([B,]), torch.Size([B, max_len]), 或者torch.Size([B, max_len])
  • seq_len (torch.Tensor) -- 序列长度标记, 标记的形状可以是None, None, torch.Size([B]), 或者torch.Size([B]). 如果mask也被传进来的话seq_len会被忽略.
get_metric(reset=True)[源代码]

get_metric函数将根据evaluate函数累计的评价指标统计量来计算最终的评价结果.

参数:reset (bool) -- 在调用完get_metric后是否清空评价指标统计量.
Return dict evaluate_result:
 {"acc": float}
get_metric_name()

返回metric的名称

返回:
set_metric_name(name: str)

设置metric的名称,默认是Metric的class name.

参数:name (str) --
返回:self
class fastNLP.ConfusionMatrixMetric(vocab=None, pred=None, target=None, seq_len=None, print_ratio=False)[源代码]

基类 fastNLP.MetricBase

别名 fastNLP.ConfusionMatrixMetric fastNLP.core.metrics.ConfusionMatrixMetric

分类问题计算混淆矩阵的Metric(其它的Metric参见 fastNLP.core.metrics ) 最后返回结果为:

dict,{'confusion_matrix': ConfusionMatrix实例}

ConfusionMatrix实例的print()函数将输出矩阵字符串。

pred_dict = {"pred": torch.Tensor([2,1,3])}
target_dict = {'target': torch.Tensor([2,2,1])}
metric = ConfusionMatrixMetric()
metric(pred_dict=pred_dict, target_dict=target_dict, )
print(metric.get_metric())
{'confusion_matrix':
 target  1.0     2.0     3.0     all
   pred
    1.0    0       1       0       1
    2.0    0       1       0       1
    3.0    1       0       0       1
    all    1       2       0       3
}
__init__(vocab=None, pred=None, target=None, seq_len=None, print_ratio=False)[源代码]
参数:
  • vocab -- vocab词表类,要求有to_word()方法。
  • pred -- 参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred
  • target -- 参数映射表中 target 的映射关系,None表示映射关系为 target -> target
  • seq_len -- 参数映射表中 seq_len 的映射关系,None表示映射关系为 seq_len -> seq_len
  • print_ratio -- 限制print的输出,false only for result, true for result, percent(dim=0), percent(dim = 1)
evaluate(pred, target, seq_len=None)[源代码]

evaluate函数将针对一个批次的预测结果做评价指标的累计

参数:
  • pred (torch.Tensor) -- 预测的tensor, tensor的形状可以是torch.Size([B,]), torch.Size([B, n_classes]), torch.Size([B, max_len]), 或者torch.Size([B, max_len, n_classes])
  • target (torch.Tensor) -- 真实值的tensor, tensor的形状可以是Element's can be: torch.Size([B,]), torch.Size([B,]), torch.Size([B, max_len]), 或者torch.Size([B, max_len])
  • seq_len (torch.Tensor) -- 序列长度标记, 标记的形状可以是None, torch.Size([B]), 或者torch.Size([B]).
get_metric(reset=True)[源代码]

get_metric函数将根据evaluate函数累计的评价指标统计量来计算最终的评价结果. :param bool reset: 在调用完get_metric后是否清空评价指标统计量. :return dict evaluate_result: {"confusion_matrix": ConfusionMatrix}

get_metric_name()

返回metric的名称

返回:
set_metric_name(name: str)

设置metric的名称,默认是Metric的class name.

参数:name (str) --
返回:self
class fastNLP.Optimizer(model_params, **kwargs)[源代码]

别名 fastNLP.Optimizer fastNLP.core.optimizer.Optimizer

Optimizer

__init__(model_params, **kwargs)[源代码]
参数:
  • model_params -- a generator. E.g. model.parameters() for PyTorch models.
  • kwargs -- additional parameters.
class fastNLP.SGD(lr=0.001, momentum=0, model_params=None)[源代码]

基类 fastNLP.Optimizer

别名 fastNLP.SGD fastNLP.core.optimizer.SGD

SGD
__init__(lr=0.001, momentum=0, model_params=None)[源代码]
参数:
  • lr (float) -- learning rate. Default: 0.01
  • momentum (float) -- momentum. Default: 0
  • model_params -- a generator. E.g. model.parameters() for PyTorch models.
class fastNLP.Adam(lr=0.001, weight_decay=0, betas=(0.9, 0.999), eps=1e-08, amsgrad=False, model_params=None)[源代码]

基类 fastNLP.Optimizer

别名 fastNLP.Adam fastNLP.core.optimizer.Adam

Adam
__init__(lr=0.001, weight_decay=0, betas=(0.9, 0.999), eps=1e-08, amsgrad=False, model_params=None)[源代码]
参数:
  • lr (float) -- learning rate
  • weight_decay (float) --
  • eps --
  • amsgrad --
  • model_params -- a generator. E.g. model.parameters() for PyTorch models.
class fastNLP.AdamW(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False)[源代码]

别名 fastNLP.AdamW fastNLP.core.optimizer.AdamW

对AdamW的实现,该实现在pytorch 1.2.0版本中已经出现,https://github.com/pytorch/pytorch/pull/21250。 这里加入以适配低版本的pytorch

The original Adam algorithm was proposed in Adam: A Method for Stochastic Optimization. The AdamW variant was proposed in Decoupled Weight Decay Regularization.

__init__(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False)[源代码]
参数:
  • (iterable) (params) -- iterable of parameters to optimize or dicts defining parameter groups
  • (float, optional) (weight_decay) -- learning rate (default: 1e-3)
  • (Tuple[float, float], optional) (betas) -- coefficients used for computing running averages of gradient and its square (default: (0.9, 0.99))
  • (float, optional) -- term added to the denominator to improve numerical stability (default: 1e-8)
  • (float, optional) -- weight decay coefficient (default: 1e-2) algorithm from the paper On the Convergence of Adam and Beyond (default: False)
add_param_group(param_group)

Add a param group to the Optimizer s param_groups.

This can be useful when fine tuning a pre-trained network as frozen layers can be made trainable and added to the Optimizer as training progresses.

Arguments:
param_group (dict): Specifies what Tensors should be optimized along with group specific optimization options.
load_state_dict(state_dict)

Loads the optimizer state.

Arguments:
state_dict (dict): optimizer state. Should be an object returned
from a call to state_dict().
state_dict()

Returns the state of the optimizer as a dict.

It contains two entries:

  • state - a dict holding current optimization state. Its content
    differs between optimizer classes.
  • param_groups - a dict containing all parameter groups
step(closure=None)[源代码]

Performs a single optimization step.

参数:closure -- (callable, optional) A closure that reevaluates the model and returns the loss.
zero_grad(set_to_none: bool = False)

Sets the gradients of all optimized torch.Tensor s to zero.

Arguments:
set_to_none (bool): instead of setting to zero, set the grads to None.
This is will in general have lower memory footprint, and can modestly improve performance. However, it changes certain behaviors. For example: 1. When the user tries to access a gradient and perform manual ops on it, a None attribute or a Tensor full of 0s will behave differently. 2. If the user requests zero_grad(set_to_none=True) followed by a backward pass, .grads are guaranteed to be None for params that did not receive a gradient. 3. torch.optim optimizers have a different behavior if the gradient is 0 or None (in one case it does the step with a gradient of 0 and in the other it skips the step altogether).
class fastNLP.Sampler[源代码]

别名 fastNLP.Sampler fastNLP.core.sampler.Sampler

Sampler 类的基类. 规定以何种顺序取出data中的元素

子类必须实现 __call__ 方法. 输入 DataSet 对象, 返回其中元素的下标序列

__init__

Initialize self. See help(type(self)) for accurate signature.

class fastNLP.SequentialSampler[源代码]

基类 fastNLP.Sampler

别名 fastNLP.SequentialSampler fastNLP.core.sampler.SequentialSampler

顺序取出元素的 Sampler
__init__

Initialize self. See help(type(self)) for accurate signature.

class fastNLP.BucketSampler(num_buckets=10, batch_size=None, seq_len_field_name='seq_len')[源代码]

基类 fastNLP.Sampler

别名 fastNLP.BucketSampler fastNLP.core.sampler.BucketSampler

带Bucket的 Random Sampler. 可以随机地取出长度相似的元素
__init__(num_buckets=10, batch_size=None, seq_len_field_name='seq_len')[源代码]
参数:
  • num_buckets (int) -- bucket的数量
  • batch_size (int) -- batch的大小. 默认为None,Trainer/Tester在调用BucketSampler时,会将该值正确设置,如果是非 Trainer/Tester场景使用,需要显示传递该值
  • seq_len_field_name (str) -- 对应序列长度的 field 的名字
set_batch_size(batch_size)[源代码]
参数:batch_size (int) -- 每个batch的大小
返回:
class fastNLP.RandomSampler[源代码]

基类 fastNLP.Sampler

别名 fastNLP.RandomSampler fastNLP.core.sampler.RandomSampler

随机化取元素的 Sampler
__init__

Initialize self. See help(type(self)) for accurate signature.

class fastNLP.SortedSampler(seq_len_field_name='seq_len', descending=True)[源代码]

基类 fastNLP.Sampler

别名 fastNLP.SortedSampler fastNLP.core.sampler.SortedSampler

按照sample的长度进行排序,主要在测试的时候使用,可以加速测试(因为减少了padding)
__init__(seq_len_field_name='seq_len', descending=True)[源代码]
参数:
  • seq_len_field_name (str) -- 对应序列长度的 field 的名字
  • descending (bool) -- 是否降序排列
class fastNLP.ConstantTokenNumSampler(seq_len, max_token=4096, max_sentence=-1, need_be_multiple_of=1, num_bucket=-1)[源代码]

别名 fastNLP.ConstantTokenNumSampler fastNLP.core.sampler.ConstantTokenNumSampler

尽量保证每个batch的输入token数量是接近的。

使用示例 >>> # 假设已经有了tr_data并有一个field叫做seq_len保存了每个instance的token数量 >>> from fastNLP import DataSetIter, Trainer >>> sampler = BatchSampler(tr_data.get_field('seq_len').content, max_token=4096) >>> tr_iter = DataSetIter(tr_data, >>> batch_size=1, sampler=None, as_numpy=False, num_workers=0, pin_memory=False, >>> drop_last=False, timeout=0, worker_init_fn=None, >>> batch_sampler=sampler) >>> >>> # 直接将tr_iter传入Trainer中,此时batch_size参数的值会被忽略 >>> trainer = Trainer(tr_iter, model, optimizer=optimizer, loss=TranslationLoss(), >>> batch_size=1, sampler=None, drop_last=False, update_every=1)

__init__(seq_len, max_token=4096, max_sentence=-1, need_be_multiple_of=1, num_bucket=-1)[源代码]
参数:
  • seq_len (List[int]) -- list[int], 是每个sample的长度。一般可以通过dataset.get_field('seq_len').content传入
  • max_token (int) -- 每个batch的最大的token数量
  • max_sentence (int) -- 每个batch最多多少个instance, -1表示根据max_token决定
  • need_be_multiple_of (int) -- 生成的batch的instance的数量需要是几的倍数,在DataParallel场景下会用到
  • num_bucket (int) -- 将数据按长度拆分为num_bucket个bucket,batch中的sample尽量在bucket之中进行组合,这样可以减少padding。
class fastNLP.LossFunc(func, key_map=None, **kwargs)[源代码]

基类 fastNLP.LossBase

别名 fastNLP.LossFunc fastNLP.core.losses.LossFunc

提供给用户使用自定义损失函数的类

param func:用户自行定义的损失函数,应当为一个函数。
param dict key_map:
 参数映射表。键为Model/DataSet参数名,值为损失函数参数名。 fastNLP的trainer将在训练时从模型返回值或者训练数据DataSet的target=True的field中 找到相对应的参数名为value的参数,并传入func中作为参数名为key的参数
param kwargs:除了参数映射表以外可以用key word args的方式设置参数映射关系

使用方法:

import torch.nn.functional as F
loss_func = LossFunc(F.cross_entropy, input="pred", target="label")
# 这表示构建了一个损失函数类,由func计算损失函数,其中将从模型返回值或者DataSet的target=True的field
# 当中找到一个参数名为`pred`的参数传入func一个参数名为`input`的参数;找到一个参数名为`label`的参数
# 传入func作为一个名为`target`的参数
get_loss(*args, **kwargs)
参数:
  • args --
  • kwargs --
返回:

torch.Tensor

class fastNLP.CrossEntropyLoss(pred=None, target=None, seq_len=None, class_in_dim=-1, padding_idx=-100, reduction='mean')[源代码]

基类 fastNLP.LossBase

别名 fastNLP.CrossEntropyLoss fastNLP.core.losses.CrossEntropyLoss

交叉熵损失函数

param pred:参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred
param target:参数映射表中 target 的映射关系,None表示映射关系为 target -> target
param seq_len:句子的长度, 长度之外的token不会计算loss。
param int class_in_dim:
 在序列标注的场景中,pred可能的shape为(batch_size, max_len, num_classes) 或(batch_size, num_classes, max_len), CrossEntropyLoss需要知道哪一维是class的维度以计算loss。如果为-1,就根据pred的第 二维是否等于target的第二维来判断是否需要交换pred的第二维和第三维,因为target的第二维是length的维度,如果这一维度上和pred相等, 那么pred可能第二维也是长度维(存在误判的可能,如果有误判的情况,请显示设置该值)。其它大于0的值则认为该维度是class的维度。
param padding_idx:
 padding的index,在计算loss时将忽略target中标号为padding_idx的内容, 可以通过该值代替 传入seq_len.
param str reduction:
 支持 meansumnone .

Example:

loss = CrossEntropyLoss(pred='pred', target='label', padding_idx=0)
class fastNLP.MSELoss(pred=None, target=None, reduction='mean')[源代码]

基类 fastNLP.LossBase

别名 fastNLP.MSELoss fastNLP.core.losses.MSELoss

MSE损失函数

param pred:参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred
param target:参数映射表中 target 的映射关系,None表示映射关系为 target >`target`
param str reduction:
 支持'mean','sum'和'none'.
class fastNLP.L1Loss(pred=None, target=None, reduction='mean')[源代码]

基类 fastNLP.LossBase

别名 fastNLP.L1Loss fastNLP.core.losses.L1Loss

L1损失函数

param pred:参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred
param target:参数映射表中 target 的映射关系,None表示映射关系为 target >`target`
param str reduction:
 支持'mean','sum'和'none'.
class fastNLP.BCELoss(pred=None, target=None, reduction='mean')[源代码]

基类 fastNLP.LossBase

别名 fastNLP.BCELoss fastNLP.core.losses.BCELoss

二分类交叉熵损失函数

param pred:参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred
param target:参数映射表中 target 的映射关系,None表示映射关系为 target -> target
param str reduction:
 支持 meansumnone .
class fastNLP.NLLLoss(pred=None, target=None, ignore_idx=-100, reduction='mean')[源代码]

基类 fastNLP.LossBase

别名 fastNLP.NLLLoss fastNLP.core.losses.NLLLoss

负对数似然损失函数
__init__(pred=None, target=None, ignore_idx=-100, reduction='mean')[源代码]
参数:
  • pred -- 参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred
  • target -- 参数映射表中 target 的映射关系,None表示映射关系为 target -> target
  • ignore_idx -- ignore的index,在计算loss时将忽略target中标号为ignore_idx的内容, 可以通过该值代替 传入seq_len.
  • reduction (str) -- 支持 meansumnone .
class fastNLP.LossInForward(loss_key='loss')[源代码]

基类 fastNLP.LossBase

别名 fastNLP.LossInForward fastNLP.core.losses.LossInForward

从forward()函数返回结果中获取loss
__init__(loss_key='loss')[源代码]
参数:loss_key (str) -- 在forward函数中loss的键名,默认为loss
class fastNLP.LossBase[源代码]

别名 fastNLP.LossBase fastNLP.core.losses.LossBase

所有loss的基类。如果需要结合到Trainer之中需要实现get_loss方法

get_loss(*args, **kwargs)[源代码]
参数:
  • args --
  • kwargs --
返回:

torch.Tensor

class fastNLP.CMRC2018Loss(target_start=None, target_end=None, context_len=None, pred_start=None, pred_end=None, reduction='mean')[源代码]

基类 fastNLP.LossBase

别名 fastNLP.CMRC2018Loss fastNLP.core.losses.CMRC2018Loss

用于计算CMRC2018中文问答任务。
get_loss(target_start, target_end, context_len, pred_start, pred_end)[源代码]
参数:
  • target_start -- batch_size
  • target_end -- batch_size
  • context_len -- batch_size
  • pred_start -- batch_size x max_len
  • pred_end -- batch_size x max_len
返回:

fastNLP.cache_results(_cache_fp, _refresh=False, _verbose=1)[源代码]

别名 fastNLP.cache_results fastNLP.core.utils.cache_results

cache_results是fastNLP中用于cache数据的装饰器。通过下面的例子看一下如何使用:

import time
import numpy as np
from fastNLP import cache_results

@cache_results('cache.pkl')
def process_data():
    # 一些比较耗时的工作,比如读取数据,预处理数据等,这里用time.sleep()代替耗时
    time.sleep(1)
    return np.random.randint(10, size=(5,))

start_time = time.time()
print("res =",process_data())
print(time.time() - start_time)

start_time = time.time()
print("res =",process_data())
print(time.time() - start_time)

# 输出内容如下,可以看到两次结果相同,且第二次几乎没有花费时间
# Save cache to cache.pkl.
# res = [5 4 9 1 8]
# 1.0042750835418701
# Read cache from cache.pkl.
# res = [5 4 9 1 8]
# 0.0040721893310546875

可以看到第二次运行的时候,只用了0.0001s左右,是由于第二次运行将直接从cache.pkl这个文件读取数据,而不会经过再次预处理:

# 还是以上面的例子为例,如果需要重新生成另一个cache,比如另一个数据集的内容,通过如下的方式调用即可
process_data(_cache_fp='cache2.pkl')  # 完全不影响之前的‘cache.pkl'

上面的_cache_fp是cache_results会识别的参数,它将从'cache2.pkl'这里缓存/读取数据,即这里的'cache2.pkl'覆盖默认的 'cache.pkl'。如果在你的函数前面加上了@cache_results()则你的函数会增加三个参数[_cache_fp, _refresh, _verbose]。 上面的例子即为使用_cache_fp的情况,这三个参数不会传入到你的函数中,当然你写的函数参数名也不可能包含这三个名称:

process_data(_cache_fp='cache2.pkl', _refresh=True)  # 这里强制重新生成一份对预处理的cache。
#  _verbose是用于控制输出信息的,如果为0,则不输出任何内容;如果为1,则会提醒当前步骤是读取的cache还是生成了新的cache
参数:
  • _cache_fp (str) -- 将返回结果缓存到什么位置;或从什么位置读取缓存。如果为None,cache_results没有任何效用,除非在 函数调用的时候传入_cache_fp这个参数。
  • _refresh (bool) -- 是否重新生成cache。
  • _verbose (int) -- 是否打印cache的信息。
返回: