fastNLP¶
fastNLP 由 core
、 io
、embeddings
、 modules
、
models
等子模块组成,你可以查看每个模块的文档。
core
是fastNLP 的核心模块,包括 DataSet、 Trainer、 Tester 等组件。详见文档fastNLP.core
io
是实现输入输出的模块,包括了数据集的读取,模型的存取等功能。详见文档fastNLP.io
embeddings
提供用于构建复杂网络模型所需的各种embedding。详见文档fastNLP.embeddings
modules
包含了用于搭建神经网络模型的诸多组件,可以帮助用户快速搭建自己所需的网络。详见文档fastNLP.modules
models
包含了一些使用 fastNLP 实现的完整网络模型,包括CNNText
、SeqLabeling
等常见模型。详见文档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))})
-
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.DataSetIter
fastNLP.core.batch.DataSetIter
- DataSetIter 用于从 DataSet 中按一定的顺序, 依次按
batch_size
的大小将数据取出,通过使用DataSetIter,可以不需要考虑 - 输入的padding(由DataSet中每列的Padder决定了)以及不需要考虑将数据转为tensor。
组成 x 和 y:
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 --
-
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这么多,是否就丢掉。
返回:
- DataSetIter 用于从 DataSet 中按一定的顺序, 依次按
-
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
返回:
-
-
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.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
用于构建, 存储和使用 str 到 int 的一一映射:
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>'
- max_size (int) -- Vocabulary 的最大大小, 即能存储词的最大数量
若为
-
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的。
-
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]) -- 可为
str
或List[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
orFalse
-
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')
参数:
-
padding_idx
¶ padding 对应的数字
-
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
-
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
- is_input: bool, 如果为True则将 new_field_name 的field设置为input
- is_target: bool, 如果为True则将 new_field_name 的field设置为target
- ignore_type: bool, 如果为True则将 new_field_name 的field的ignore_type设置为true, 忽略其类型
Return List[Any]: 里面的元素为func的返回值,所以list长度为DataSet的长度
- func (callable) -- 参数是
-
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
- is_input: bool, 如果为True则将名为 new_field_name 的field设置为input
- is_target: bool, 如果为True则将名为 new_field_name 的field设置为target
- 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_more
与apply_field
的区别参考apply_more()
中关于apply_more
与apply
区别的介绍。参数: - 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
- is_input: bool, 如果为True则将被修改的field设置为input
- is_target: bool, 如果为True则将被修改的field设置为target
- ignore_type: bool, 如果为True则将被修改的field的ignore_type设置为true, 忽略其类型
:return Dict[int:Field]: 返回一个字典
- func (callable) -- 参数是
-
apply_more
(func, modify_fields=True, **kwargs)[源代码]¶ 将
DataSet
中每个Instance
传入到func中,并获取它的返回值。func可以返回一个或多个 field 上的结果。注解
apply_more
与apply
的区别:apply_more
可以返回多个 field 的结果,apply
只可以返回一个field 的结果;apply_more
的返回值是一个字典,每个 key-value 对中的 key 表示 field 的名字,value 表示计算结果;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
- is_input: bool, 如果为True则将被修改的的field设置为input
- is_target: bool, 如果为True则将被修改的的field设置为target
- ignore_type: bool, 如果为True则将被修改的的field的ignore_type设置为true, 忽略其类型
:return Dict[int: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 返回:
-
drop
(func, inplace=True)[源代码]¶ func接受一个Instance,返回bool值。返回值为True时,该Instance会被移除或者不会包含在返回的DataSet中。
参数: - func (callable) -- 接受一个Instance作为参数,返回bool值。为True时删除该instance
- inplace (bool) -- 是否在当前DataSet中直接删除instance;如果为False,将返回一个新的DataSet。
返回: DataSet
-
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。
-
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该列是否所有数据都是同样的维度,同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。
-
-
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'¶
-
INPUT
= 'words'¶
-
INPUT_LEN
= 'seq_len'¶
-
LOSS
= 'loss'¶
-
OUTPUT
= 'pred'¶
-
RAW_CHAR
= 'raw_chars'¶
-
RAW_WORD
= 'raw_words'¶
-
TARGET
= '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中用于组织单任务的训练过程,可以避免用户在不同训练任务中重复撰写
- epoch循环;
- 将数据分成不同的Batch;
- 对Batch进行pad;
- 每个epoch结束或一定step后进行验证集验证;
- 保存获得更好验证性能的模型等。
详细的介绍参见
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中;
- torch.device:将模型装载到torch.device上。
- int: 将使用device_id为该值的gpu进行训练
- list(int):如果多于1个device,将使用torch.nn.DataParallel包裹model, 并使用传入的device。
- 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。
- train_data -- 训练集,
-
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)[源代码]¶ 别名
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)[源代码]¶ 参数: - 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不对模型 的计算位置进行管理。支持以下的输入:
- str: ['cpu', 'cuda', 'cuda:0', 'cuda:1', ...] 依次为'cpu'中, 可见的第一个GPU中,可见的第一个GPU中,可见的第二个GPU中;
- torch.device:将模型装载到torch.device上。
- int: 将使用device_id为该值的gpu进行训练
- list(int):如果多于1个device,将使用torch.nn.DataParallel包裹model, 并使用传入的device。
- None. 为None则不对模型进行任何处理,如果传入的model为torch.nn.DataParallel该值必须为None。
如果模型是通过predict()进行预测的话,那么将不能使用多卡(DataParallel)进行验证,只会使用第一张卡上的模型。
- verbose (int) -- 如果为0不输出任何信息; 如果为1,打印出验证结果。
- use_tqdm (bool) -- 是否使用tqdm来显示测试进度; 如果为False,则不会显示任何内容。
-
-
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打印在终端中。
- train_data -- 训练集,
-
is_master
¶ 是否是主进程
-
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_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_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.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.EarlyStopCallback
fastNLP.core.callback.EarlyStopCallback
多少个epoch没有变好就停止训练,相关类EarlyStopError
-
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=0, log_exception=False)[源代码]¶ -
别名
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=0, 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.EvaluateCallback
fastNLP.core.callback.EvaluateCallback
通过使用该Callback可以使得Trainer在evaluate dev之外还可以evaluate其它数据集,比如测试集。每一次验证dev之前都会先验证EvaluateCallback 中的数据。-
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.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.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.LRFinder
fastNLP.core.callback.LRFinder
用第一个 epoch 找最佳的学习率,从第二个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_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.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.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.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中捕获这个值。
-
with_traceback
()¶ Exception.with_traceback(tb) -- set self.__traceback__ to tb and return self.
-
-
exception
fastNLP.
EarlyStopError
(msg)[源代码]¶ -
别名
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):
-
-
class
fastNLP.
AutoPadder
(pad_val=0)[源代码]¶ -
别名
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.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
-
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_dict
和target_dict
中进行检查.pred_dict
是模型当中forward()
函数或者predict()
函数的返回值.target_dict
是DataSet当中的ground truth, 判定ground truth的条件是field的is_target
被设置为True.MetricBase
会进行以下的类型检测:- self.evaluate当中是否有varargs, 这是不支持的.
- self.evaluate当中所需要的参数是否既不在
pred_dict
也不在target_dict
. - self.evaluate当中所需要的参数是否既在
pred_dict
也在target_dict
.
除此以外,在参数被传入self.evaluate以前,这个函数会检测
pred_dict
和target_dict
当中没有被用到的参数 如果kwargs是self.evaluate的参数,则不会检测self.evaluate将计算一个批次(batch)的评价指标,并累计。 没有返回值 self.get_metric将统计当前的评价指标并返回评价结果, 返回值需要是一个dict, key是指标名称,value是指标的值
-
class
fastNLP.
AccuracyMetric
(pred=None, target=None, seq_len=None)[源代码]¶ -
别名
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.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) -- micro 或 macro . 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,则召回率权重高于精确率。
- tag_vocab -- 标签的
-
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_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.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.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) -- micro 或 macro . 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,则召回率权重高于精确率。
- tag_vocab -- 标签的
-
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.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
-
class
fastNLP.
SGD
(lr=0.001, momentum=0, model_params=None)[源代码]¶ -
别名
fastNLP.SGD
fastNLP.core.optimizer.SGD
SGD
-
class
fastNLP.
Adam
(lr=0.001, weight_decay=0, betas=(0.9, 0.999), eps=1e-08, amsgrad=False, model_params=None)[源代码]¶ -
别名
fastNLP.Adam
fastNLP.core.optimizer.Adam
Adam
-
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
()¶ Clears the gradients of all optimized
torch.Tensor
s.
-
-
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.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.BucketSampler
fastNLP.core.sampler.BucketSampler
带Bucket的 Random Sampler. 可以随机地取出长度相似的元素
-
class
fastNLP.
RandomSampler
[源代码]¶ -
别名
fastNLP.RandomSampler
fastNLP.core.sampler.RandomSampler
随机化取元素的 Sampler-
__init__
¶ Initialize self. See help(type(self)) for accurate signature.
-
-
class
fastNLP.
LossFunc
(func, key_map=None, **kwargs)[源代码]¶ -
别名
fastNLP.LossFunc
fastNLP.core.losses.LossFunc
提供给用户使用自定义损失函数的类
param func: 用户自行定义的损失函数,应当为一个函数或者callable(func)为True的ojbect param dict key_map: 参数映射表。键为Model/DataSet参数名,值为损失函数参数名。 fastNLP的trainer将在训练时从模型返回值或者训练数据DataSet的target=True的field中 找到相对应的参数名为value的参数,并传入func中作为参数名为key的参数 param kwargs: 除了参数映射表以外可以用key word args的方式设置参数映射关系 使用方法:
func = torch.nn.CrossEntropyLoss() loss_func = LossFunc(func, input="pred", target="label") # 这表示构建了一个损失函数类,由func计算损失函数,其中将从模型返回值或者DataSet的target=True的field # 当中找到一个参数名为`pred`的参数传入func一个参数名为`input`的参数;找到一个参数名为`label`的参数 # 传入func作为一个名为`target`的参数
-
class
fastNLP.
CrossEntropyLoss
(pred=None, target=None, seq_len=None, class_in_dim=-1, padding_idx=-100, reduction='mean')[源代码]¶ -
别名
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: 支持 mean ,sum 和 none . Example:
loss = CrossEntropyLoss(pred='pred', target='label', padding_idx=0)
-
class
fastNLP.
L1Loss
(pred=None, target=None, reduction='mean')[源代码]¶ -
别名
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.BCELoss
fastNLP.core.losses.BCELoss
二分类交叉熵损失函数
param pred: 参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred param target: 参数映射表中 target 的映射关系,None表示映射关系为 target -> target param str reduction: 支持 mean ,sum 和 none .
-
class
fastNLP.
NLLLoss
(pred=None, target=None, ignore_idx=-100, reduction='mean')[源代码]¶ -
别名
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) -- 支持 mean ,sum 和 none .
-
-
class
fastNLP.
LossInForward
(loss_key='loss')[源代码]¶ -
别名
fastNLP.LossInForward
fastNLP.core.losses.LossInForward
从forward()函数返回结果中获取loss
-
class
fastNLP.
LossBase
[源代码]¶ 别名
fastNLP.LossBase
fastNLP.core.losses.LossBase
所有loss的基类。如果想了解其中的原理,请查看源码。
-
class
fastNLP.
CMRC2018Loss
(target_start=None, target_end=None, context_len=None, pred_start=None, pred_end=None, reduction='mean')[源代码]¶ -
别名
fastNLP.CMRC2018Loss
fastNLP.core.losses.CMRC2018Loss
用于计算CMRC2018中文问答任务。
-
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的信息。
返回: