fastNLP.core package

core 模块里实现了 fastNLP 的核心框架,常用的功能都可以从 fastNLP 包中直接 import。当然你也同样可以从 core 模块的子模块中 import, 例如 DataSetIter 组件有两种 import 的方式:

# 直接从 fastNLP 中 import
from fastNLP import DataSetIter

# 从 core 模块的子模块 batch 中 import DataSetIter
from fastNLP.core.batch import DataSetIter

对于常用的功能,你只需要在 fastNLP 中查看即可。如果想了解各个子模块的具体作用,您可以在下面找到每个子模块的具体文档。

class fastNLP.core.DataSet(data=None)[源代码]

基类:object

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

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

__init__(data=None)[源代码]
参数

data – 如果为dict类型,则每个key的value应该为等长的list; 如果为list, 每个元素应该为具有相同field的 Instance

print_field_meta()[源代码]

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

+-------------+-------+-------+
| field_names |   x   |   y   |
+=============+=======+=======+
|   is_input  |  True | False |
|  is_target  | False | False |
| ignore_type | False |       |
|  pad_value  |   0   |       |
+-------------+-------+-------+

str field_names: DataSet中field的名称 bool is_input: field是否为input bool is_target: field是否为target bool ignore_type: 是否忽略该field的type, 一般仅在该field至少为input或target时才有意义 int pad_value: 该field的pad的值,仅在该field为input或target时有意义 :return:

append(instance)[源代码]

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

参数

instance (Instance) – 若DataSet不为空,则instance应该拥有和DataSet完全一样的field。

add_fieldarray(field_name, fieldarray)[源代码]

将fieldarray添加到DataSet中.

参数
  • field_name (str) – 新加入的field的名称

  • fieldarray (FieldArray) – 需要加入DataSet的field的内容

返回

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的类型检查

delete_instance(index)[源代码]

删除第index个instance

参数

index (int) – 需要删除的instance的index,序号从0开始。

delete_field(field_name)[源代码]

删除名为field_name的field

参数

field_name (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

has_field(field_name)[源代码]

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

参数

field_name (str) – field的名称

Return bool

表示是否有名为field_name这个field

get_field(field_name)[源代码]

获取field_name这个field

参数

field_name (str) – field的名称

返回

FieldArray

get_all_fields()[源代码]

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

Return dict

返回如上所述的字典

get_field_names() → list[源代码]

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

Return list

返回如上所述的列表

get_length()[源代码]

获取DataSet的元素数量

返回

int: DataSet中Instance的个数。

rename_field(field_name, new_field_name)[源代码]

将某个field重新命名.

参数
  • field_name (str) – 原来的field名称。

  • new_field_name (str) – 修改为new_name。

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该列是否所有数据都是同样的维度,同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。

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_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_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_pad_val(field_name, pad_val)[源代码]

为某个field设置对应的pad_val.

参数
  • field_name (str) – 修改该field的pad_val

  • pad_val (int) – 该field的padder会以pad_val作为padding index

get_input_name()[源代码]

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

Return list

里面的元素为被设置为input的field名称

get_target_name()[源代码]

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

Return list

里面的元素为被设置为target的field名称

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, 忽略其类型

    4. use_tqdm: bool, 是否使用tqdm显示预处理进度

    5. tqdm_desc: str, 当use_tqdm为True时,可以显示当前tqdm正在处理的名称

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, 忽略其类型

    4. use_tqdm: bool, 是否使用tqdm显示预处理进度

    5. tqdm_desc: str, 当use_tqdm为True时,可以显示当前tqdm正在处理的名称

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, 忽略其类型

    4. use_tqdm: bool, 是否使用tqdm显示预处理进度

    5. tqdm_desc: str, 当use_tqdm为True时,可以显示当前tqdm正在处理的名称

Return Dict[str: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, 忽略其类型

    4. use_tqdm: bool, 是否使用tqdm显示预处理进度

    5. tqdm_desc: str, 当use_tqdm为True时,可以显示当前tqdm正在处理的名称

Return List[Any]

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

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

返回

drop(func, inplace=True)[源代码]

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

参数
  • func (callable) – 接受一个Instance作为参数,返回bool值。为True时删除该instance

  • inplace (bool) – 是否在当前DataSet中直接删除instance;如果为False,将返回一个新的DataSet。

返回

DataSet

split(ratio, shuffle=True)[源代码]

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

参数
  • ratio (float) – 0<ratio<1, 返回的第一个DataSet拥有 (1-ratio) 这么多数据,第二个DataSet拥有`ratio`这么多数据

  • shuffle (bool) – 在split前是否shuffle一下

返回

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

save(path)[源代码]

保存DataSet.

参数

path (str) – 将DataSet存在哪个路径

static load(path)[源代码]

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

参数

path (str) – 从哪里读取DataSet

返回

读取后的 读取后的DataSet

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。

delete_collate_fn(name=None)[源代码]

删除某个collate_fn

参数

name (str,int) – 如果为None,则删除最近加入的collate_fn

返回

concat(dataset, inplace=True, field_mapping=None)[源代码]
将当前dataset与输入的dataset结合成一个更大的dataset,需要保证两个dataset都包含了相同的field。结合后的dataset的input,target

以及collate_fn以当前dataset为准。当dataset中包含的field多于当前的dataset,则多余的field会被忽略;若dataset中未包含所有 当前dataset含有field,则会报错。

参数
  • dataset (DataSet,) – 需要和当前dataset concat的dataset

  • inplace (bool,) – 是否直接将dataset组合到当前dataset中

  • field_mapping (dict,) – 当dataset中的field名称和当前dataset不一致时,需要通过field_mapping把输入的dataset中的field 名称映射到当前field. field_mapping为dict类型,key为dataset中的field名称,value是需要映射成的名称

返回

DataSet

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

基类:object

别名 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.core.Padder(pad_val=0, **kwargs)[源代码]

基类:object

别名 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.core.AutoPadder(pad_val=0)[源代码]

基类:fastNLP.core.field.Padder

基类 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.core.EngChar2DPadder(pad_val=0, pad_length=0)[源代码]

基类:fastNLP.core.field.Padder

基类 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.core.ConcatCollateFn(inputs, output, pad_val=0, max_len=0, is_input=True, is_target=False)[源代码]

基类:object

别名 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.core.Vocabulary(max_size=None, min_freq=None, padding='<pad>', unknown='<unk>')[源代码]

基类:object

别名 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>’

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

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

参数
  • word_lst (list) – a list of strings

  • no_create_entry (bool) – 如果词语来自于非训练集建议设置为True。在使用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, no_create_entry=False)[源代码]

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

参数
  • word (str) – 新词

  • no_create_entry (bool) – 如果词语来自于非训练集建议设置为True。在使用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) – 如果词语来自于非训练集建议设置为True。在使用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) – 如果词语来自于非训练集建议设置为True。在使用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_vocab()[源代码]

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

build_reverse_vocab()[源代码]

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

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.

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

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

property unknown_idx

unknown 对应的数字.

property padding_idx

padding 对应的数字

to_word(idx)[源代码]

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

参数

idx (int) – the index

Return str word

the word

clear()[源代码]

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

返回

save(filepath)[源代码]
参数

filepath (str,io.StringIO) – Vocabulary的储存路径

返回

static load(filepath)[源代码]
参数

filepath (str,io.StringIO) – Vocabulary的读取路径

返回

Vocabulary

class fastNLP.core.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.core.batch.BatchIter

基类 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)[源代码]
参数
  • datasetDataSet 对象, 数据集

  • 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会被忽略。

class fastNLP.core.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)[源代码]

基类:object

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

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

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

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

参数
  • num_samples (int) –

  • batch_size (int) –

  • drop_last (bool) – 如果最后一个batch没有batch_size这么多,是否就丢掉。

返回

get_batch_indices()[源代码]

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

返回

property dataset

获取正在参与iterate的dataset

返回

class fastNLP.core.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.core.batch.BatchIter

基类 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会被忽略。

class fastNLP.core.Const[源代码]

基类:object

别名 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)
INPUT = 'words'
CHAR_INPUT = 'chars'
INPUT_LEN = 'seq_len'
OUTPUT = 'pred'
TARGET = 'target'
LOSS = 'loss'
RAW_WORD = 'raw_words'
RAW_CHAR = 'raw_chars'
static INPUTS(i)[源代码]

得到第 i 个 INPUT 的命名

static CHAR_INPUTS(i)[源代码]

得到第 i 个 CHAR_INPUT 的命名

static RAW_WORDS(i)[源代码]

得到第 i 个 RAW_WORDS 的命名

static RAW_CHARS(i)[源代码]

得到第 i 个 RAW_CHARS 的命名

static INPUT_LENS(i)[源代码]

得到第 i 个 INPUT_LEN 的命名

static OUTPUTS(i)[源代码]

得到第 i 个 OUTPUT 的命名

static TARGETS(i)[源代码]

得到第 i 个 TARGET 的命名

static LOSSES(i)[源代码]

得到第 i 个 LOSS 的命名

class fastNLP.core.Tester(data, model, metrics, batch_size=16, num_workers=0, device=None, verbose=1, use_tqdm=True, fp16=False, **kwargs)[源代码]

基类:object

别名 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, fp16=False, **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,则不会显示任何内容。

  • fp16 (bool) – 是否使用float16进行验证

  • kwargs – Sampler sampler: 支持传入sampler控制测试顺序

test()[源代码]

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

Return Dict[Dict]

dict的二层嵌套结构,dict的第一层是metric的名称; 第二层是这个metric的指标。一个AccuracyMetric的例子为{‘AccuracyMetric’: {‘acc’: 1.0}}。

class fastNLP.core.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, fp16=False, **kwargs)[源代码]

基类:object

别名 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, fp16=False, **kwargs)[源代码]
参数
  • train_data – 训练集, DataSet 类型或 BatchIter 的子类

  • model (nn.modules) – 待训练的模型

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

  • fp16 (bool) – 是否使用fp16进行训练。

  • kwargs

    支持配置可选参数 bool test_use_tqdm: 在dev上验证的时候是否开启tqdm Sampler test_sampler: 在evaluate的时候使用的sampler bool test_use_fp16: evalute的时候是否使用fp16测试,默认与fp16相同的取值。 bool set_grad_to_none: 在zero_grad的时候是否将gradient设置为None,而不是设置为zero GradScaler grad_scaler: 仅在fp16为True时有效,如果不使用torch.cuda.amp.GradScaler的初始化参数,可传入一个已经初始化后的

    grad_scaler。

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

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

param bool load_best_model

该参数只有在初始化提供了dev_data的情况下有效,如果True, trainer将在返回之前重新加载dev表现 最好的模型参数。

param str on_exception

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

参数

kwargs

int verbose: 为1时在发生异常时会打印异常发生时batch中的数据在dataset中的index

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)更新取得的最佳值

property is_master

是否是主进程

class fastNLP.core.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=False, use_tqdm=True, **kwargs)[源代码]

基类:object

别名 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=False, use_tqdm=True, **kwargs)[源代码]
参数
  • train_data – 训练集, DataSet 类型。

  • model (nn.modules) – 待训练的模型

  • optimizertorch.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 (bool) – 指定是否使用半精度训练。

  • use_tqdm (bool) – 是否使用tqdm来显示训练进度; 如果为False,则将loss打印在终端中。

  • kwargs – 支持配置可选参数 bool test_use_tqdm: 在dev上验证的时候是否开启tqdm Sampler test_sampler: 在evaluate的时候使用的sampler int dev_batch_size: 在evaluate时,使用的evaluate的batch大小 bool test_use_fp16: test时使用fp16 bool set_grad_to_none: zero_grad时将grad设为None而不是0 GradScaler gradscaler: 自定义的梯度 scaler

property 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)更新取得的最佳值
save_check_point(name=None, only_params=False)[源代码]

保存当前模型

close()[源代码]

关闭Trainer,销毁进程

fastNLP.core.get_local_rank()[源代码]

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

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

fastNLP.core.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的信息。

返回

fastNLP.core.seq_len_to_mask(seq_len, max_len=None)[源代码]

别名 fastNLP.seq_len_to_mask fastNLP.core.utils.seq_len_to_mask

将一个表示sequence length的一维数组转换为二维的mask,不包含的位置为0。 转变 1-d seq_len到2-d mask.

>>> seq_len = torch.arange(2, 16)
>>> mask = seq_len_to_mask(seq_len)
>>> print(mask.size())
torch.Size([14, 15])
>>> seq_len = np.arange(2, 16)
>>> mask = seq_len_to_mask(seq_len)
>>> print(mask.shape)
(14, 15)
>>> seq_len = torch.arange(2, 16)
>>> mask = seq_len_to_mask(seq_len, max_len=100)
>>>print(mask.size())
torch.Size([14, 100])
参数
  • seq_len (np.ndarray,torch.LongTensor) – shape将是(B,)

  • max_len (int) – 将长度pad到这个长度。默认(None)使用的是seq_len中最长的长度。但在nn.DataParallel的场景下可能不同卡的seq_len会有 区别,所以需要传入一个max_len使得mask的长度是pad到该长度。

返回

np.ndarray, torch.Tensor 。shape将是(B, max_length), 元素类似为bool或torch.uint8

fastNLP.core.get_seq_len(words, pad_value=0)[源代码]

别名 fastNLP.get_seq_len fastNLP.core.utils.get_seq_len

给定batch_size x max_len的words矩阵,返回句子长度

参数

words – batch_size x max_len

返回

(batch_size,)

class fastNLP.core.Callback[源代码]

基类:object

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

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

property trainer

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

property grad_scaler

float16的gradient scaler

property auto_cast

float16用的auto cast环境

property step

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

property n_steps

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

property batch_size

train和evaluate时的batch_size为多大

property epoch

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

property n_epochs

一共会运行多少个epoch

property optimizer

初始化Trainer时传递的Optimizer

property model

正在被Trainer训练的模型

property pbar

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

property update_every

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

property batch_per_epoch

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

on_train_begin()[源代码]

在Train过程开始之前调用。

返回

on_epoch_begin()[源代码]

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

返回

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

每次采集到一个batch的数据则调用一次。这里对batch_x或batch_y删除添加内容是可以影响到Trainer中内容的。所以在这一步 可以进行一些负采样之类的操作。batch_x和batch_y中的tensor已经被放置到了模型所在的设备上。

参数
  • 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_loss_begin(batch_y, predict_y)[源代码]

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

参数
  • batch_y (dict) – 在DataSet中被设置为target的field的batch集合。

  • predict_y (dict) – 模型的forward()返回的结果。

返回

on_backward_begin(loss)[源代码]

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

参数

loss (torch.Tensor) – 计算得到的loss值

返回

on_backward_end()[源代码]

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

返回

on_step_end()[源代码]

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

返回

on_batch_end()[源代码]

这一步与on_step_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结果是否比之前的好。

返回

on_epoch_end()[源代码]

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

on_train_end()[源代码]

训练结束,调用该方法

on_exception(exception)[源代码]

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

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

基类:fastNLP.core.callback.Callback

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

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

基类:fastNLP.core.callback.Callback

基类 fastNLP.Callback

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

多少个epoch没有变好就停止训练,相关类 EarlyStopError

__init__(patience)[源代码]
参数

patience (int) – epoch的数量

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

基类:fastNLP.core.callback.Callback

基类 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信息

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

基类:fastNLP.core.callback.Callback

基类 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不一样。

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

基类:fastNLP.core.callback.Callback

基类 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

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

基类:fastNLP.core.callback.Callback

基类 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。

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

基类:fastNLP.core.callback.Callback

基类 fastNLP.Callback

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

用第一个 epoch 找最佳的学习率,从第二个epoch开始应用它

__init__(start_lr=1e-06, end_lr=10)[源代码]
参数
  • start_lr (float) – 学习率下界

  • end_lr (float) – 学习率上界

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

基类:fastNLP.core.callback.Callback

基类 fastNLP.Callback

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

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

警告

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

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

基类:fastNLP.core.callback.Callback

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

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

基类:fastNLP.core.callback.Callback

基类 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}.

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

基类:BaseException

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

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

__init__(msg)[源代码]
参数

msg (str) – Exception的信息。

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

基类:fastNLP.core.callback.CallbackException

基类 fastNLP.CallbackException

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

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

class fastNLP.core.LossFunc(func, key_map=None, **kwargs)[源代码]

基类:fastNLP.core.losses.LossBase

基类 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`的参数
class fastNLP.core.CrossEntropyLoss(pred=None, target=None, seq_len=None, class_in_dim=- 1, ignore_idx=- 100, reduction='mean', **kwargs)[源代码]

基类:fastNLP.core.losses.LossBase

基类 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 ignore_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.core.L1Loss(pred=None, target=None, reduction='mean')[源代码]

基类:fastNLP.core.losses.LossBase

基类 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.core.BCELoss(pred=None, target=None, reduction='mean')[源代码]

基类:fastNLP.core.losses.LossBase

基类 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.core.BCEWithLogits(pred=None, target=None, class_in_dim=- 1, reduction='mean')[源代码]

基类:fastNLP.core.losses.LossBase

基类 fastNLP.core.LossBase

别名 fastNLP.BCEWithLogits fastNLP.core.losses.BCEWithLogits

二分类交叉熵损失函数, 传入数据之前不需要做sigmoid操作

param pred

参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred

param target

参数映射表中 target 的映射关系,None表示映射关系为 target -> target

param int class_in_dim

在序列标注的场景中,pred可能的shape为(batch_size, max_len, num_classes)

或(batch_size, num_classes, max_len), BCEWithLogits需要知道哪一维是class的维度以计算loss。如果为-1,就根据pred的第 二维是否等于target的第二维来判断是否需要交换pred的第二维和第三维,因为target的第二维是length的维度,如果这一维度上和pred相等, 那么pred可能第二维也是长度维(存在误判的可能,如果有误判的情况,请显示设置该值)。其它大于0的值则认为该维度是class的维度。 :param str reduction: 支持 meansumnone .

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

基类:fastNLP.core.losses.LossBase

基类 fastNLP.LossBase

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

负对数似然损失函数

__init__(pred=None, target=None, seq_len=None, class_in_dim=- 1, ignore_idx=- 100, reduction='mean')[源代码]
参数
  • pred – 参数映射表中 pred 的映射关系,None表示映射关系为 pred -> pred

  • target – 参数映射表中 target 的映射关系,None表示映射关系为 target -> target

  • seq_len – 句子的长度, 长度之外的token不会计算loss。仅在输出为3d时需要

  • class_in_dim (int) – 在序列标注的场景中,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 ignore_idx: ignore的index,在计算loss时将忽略target中标号为ignore_idx的内容, 可以通过该值代替

传入seq_len.

参数

reduction (str) – 支持 meansumnone .

class fastNLP.core.LossInForward(loss_key='loss')[源代码]

基类:fastNLP.core.losses.LossBase

基类 fastNLP.LossBase

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

从forward()函数返回结果中获取loss

__init__(loss_key='loss')[源代码]
参数

loss_key (str) – 在forward函数中loss的键名,默认为loss

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

基类:fastNLP.core.losses.LossBase

基类 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

返回

class fastNLP.core.MSELoss(pred=None, target=None, reduction='mean')[源代码]

基类:fastNLP.core.losses.LossBase

基类 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.core.LossBase[源代码]

基类:object

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

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

get_loss(*args, **kwargs)[源代码]
参数
  • args

  • kwargs

返回

torch.Tensor

class fastNLP.core.MetricBase[源代码]

基类:object

别名 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是指标的值

set_metric_name(name: str)[源代码]

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

参数

name (str) –

返回

self

get_metric_name()[源代码]

返回metric的名称

返回

class fastNLP.core.AccuracyMetric(pred=None, target=None, seq_len=None)[源代码]

基类:fastNLP.core.metrics.MetricBase

基类 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}

class fastNLP.core.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.core.metrics.MetricBase

基类 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函数累计的评价指标统计量来计算最终的评价结果.

class fastNLP.core.CMRC2018Metric(answers=None, raw_chars=None, context_len=None, pred_start=None, pred_end=None)[源代码]

基类:fastNLP.core.metrics.MetricBase

基类 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

返回

class fastNLP.core.ClassifyFPreRecMetric(tag_vocab=None, pred=None, target=None, seq_len=None, ignore_labels=None, only_gross=True, f_type='micro', beta=1)[源代码]

基类:fastNLP.core.metrics.MetricBase

基类 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}

class fastNLP.core.ConfusionMatrixMetric(vocab=None, pred=None, target=None, seq_len=None, print_ratio=False)[源代码]

基类:fastNLP.core.metrics.MetricBase

基类 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}

class fastNLP.core.Optimizer(model_params, **kwargs)[源代码]

基类:object

别名 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.core.SGD(lr=0.001, momentum=0, model_params=None)[源代码]

基类:fastNLP.core.optimizer.Optimizer

基类 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.core.Adam(lr=0.001, weight_decay=0, betas=0.9, 0.999, eps=1e-08, amsgrad=False, model_params=None)[源代码]

基类:fastNLP.core.optimizer.Optimizer

基类 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.core.AdamW(params, lr=0.001, betas=0.9, 0.999, eps=1e-08, weight_decay=0.01, amsgrad=False)[源代码]

基类:torch.optim.optimizer.Optimizer

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

step(closure=None)[源代码]

Performs a single optimization step.

参数

closure – (callable, optional) A closure that reevaluates the model and returns the loss.

class fastNLP.core.SequentialSampler[源代码]

基类:fastNLP.core.sampler.Sampler

基类 fastNLP.Sampler

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

顺序取出元素的 Sampler

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

基类:fastNLP.core.sampler.Sampler

基类 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.core.RandomSampler[源代码]

基类:fastNLP.core.sampler.Sampler

基类 fastNLP.Sampler

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

随机化取元素的 Sampler

class fastNLP.core.Sampler[源代码]

基类:object

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

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

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

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

基类:fastNLP.core.sampler.Sampler

基类 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进行排序。如果传入的field是数字,则直接按照该数字大小排序;如果传入的field不是 数字,则使用该field的长度进行排序

  • descending (bool) – 是否降序排列

class fastNLP.core.ConstantTokenNumSampler(seq_len, max_token=4096, max_sentence=- 1, need_be_multiple_of=1, num_bucket=- 1)[源代码]

基类:object

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

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

使用示例 >>> # 假设已经有了tr_data并有一个field叫做seq_len保存了每个instance的token数量 >>> from fastNLP import DataSetIter, Trainer >>> sampler = ConstantTokenNumSampler(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。