fastNLP 中文文档¶
fastNLP 是一款轻量级的自然语言处理（NLP）工具包。你既可以用它来快速地完成一个NLP任务， 也可以用它在研究中快速构建更复杂的模型。
fastNLP具有如下的特性：
- 统一的Tabular式数据容器，简化数据预处理过程;
- 内置多种数据集的
Loader和Pipe，省去预处理代码; - 各种方便的NLP工具，例如Embedding加载（包括
ElmoEmbedding和BertEmbedding）、中间数据cache等; - 部分 数据集与预训练模型 的自动下载;
- 提供多种神经网络组件以及复现模型（涵盖中文分词、命名实体识别、句法分析、文本分类、文本匹配、指代消解、摘要等任务）;
Trainer提供多种内置callback函数，方便实验记录、异常捕获等.
用户手册¶
安装指南¶
fastNLP 依赖如下包:
numpy>=1.14.2
torch>=1.0.0
tqdm>=4.28.1
nltk>=3.4.1
requests
spacy
prettytable>=0.7.2
其中torch的安装可能与操作系统及 CUDA 的版本相关，请参见 PyTorch 官网 。 在依赖包安装完成的情况，您可以在命令行执行如下指令完成安装
>>> pip install fastNLP
>>> python -m spacy download en
快速入门¶
如果你想用 fastNLP 来快速地解决某类 NLP 问题，你可以参考以下教程之一：
文本分类¶
文本分类(Text classification)任务是将一句话或一段话划分到某个具体的类别。比如垃圾邮件识别，文本情绪分类等。这篇教程可以带你从零开始了解 fastNLP 的使用
注解
本教程推荐使用 GPU 进行实验
1, 商务大床房，房间很大，床有2M宽，整体感觉经济实惠不错!
其中开头的1是只这条评论的标签，表示是正面的情绪。我们将使用到的数据可以通过 此链接 下载并解压，当然也可以通过fastNLP自动下载该数据。
数据中的内容如下图所示。接下来，我们将用fastNLP在这个数据上训练一个分类网络。
步骤¶
一共有以下的几个步骤:
(1) 读取数据¶
fastNLP提供多种数据的自动下载与自动加载功能，对于这里我们要用到的数据，我们可以用 Loader 自动下载并加载该数据。
更多有关Loader的使用可以参考 loader
from fastNLP.io import ChnSentiCorpLoader
loader = ChnSentiCorpLoader() # 初始化一个中文情感分类的loader
data_dir = loader.download() # 这一行代码将自动下载数据到默认的缓存地址, 并将该地址返回
data_bundle = loader.load(data_dir) # 这一行代码将从{data_dir}处读取数据至DataBundle
DataBundle的相关介绍，可以参考 DataBundle 。我们可以打印该data_bundle的基本信息。
print(data_bundle)
In total 3 datasets:
dev has 1200 instances.
train has 9600 instances.
test has 1200 instances.
In total 0 vocabs:
可以看出，该data_bundle中一个含有三个 DataSet 。通过下面的代码，我们可以查看DataSet的基本情况
print(data_bundle.get_dataset('train')[:2]) # 查看Train集前两个sample
+-----------------------------+--------+
| raw_chars | target |
+-----------------------------+--------+
| 选择珠江花园的原因就是方... | 1 |
| 15.4寸笔记本的键盘确实爽... | 1 |
+-----------------------------+--------+
(2) 预处理数据¶
在NLP任务中，预处理一般包括:
- 将一整句话切分成汉字或者词;
- 将文本转换为index
fastNLP中也提供了多种数据集的处理类，这里我们直接使用fastNLP的ChnSentiCorpPipe。更多关于Pipe的说明可以参考 pipe 。
from fastNLP.io import ChnSentiCorpPipe
pipe = ChnSentiCorpPipe()
data_bundle = pipe.process(data_bundle) # 所有的Pipe都实现了process()方法，且输入输出都为DataBundle类型
print(data_bundle) # 打印data_bundle，查看其变化
In total 3 datasets:
dev has 1200 instances.
train has 9600 instances.
test has 1200 instances.
In total 2 vocabs:
chars has 4409 entries.
target has 2 entries.
可以看到除了之前已经包含的3个 DataSet ,还新增了两个 Vocabulary 。我们可以打印DataSet中的内容
print(data_bundle.get_dataset('train')[:2])
+-----------------+--------+-----------------+---------+
| raw_chars | target | chars | seq_len |
+-----------------+--------+-----------------+---------+
| 选择珠江花园... | 0 | [338, 464, 1... | 106 |
| 15.4寸笔记本... | 0 | [50, 133, 20... | 56 |
+-----------------+--------+-----------------+---------+
新增了一列为数字列表的chars，以及变为数字的target列。可以看出这两列的名称和刚好与data_bundle中两个Vocabulary的名称是一致的，我们可以打印一下Vocabulary看一下里面的内容。
char_vocab = data_bundle.get_vocab('chars')
print(char_vocab)
Vocabulary(['选', '择', '珠', '江', '花']...)
Vocabulary是一个记录着词语与index之间映射关系的类，比如
index = char_vocab.to_index('选')
print("'选'的index是{}".format(index)) # 这个值与上面打印出来的第一个instance的chars的第一个index是一致的
print("index:{}对应的汉字是{}".format(index, char_vocab.to_word(index)))
'选'的index是338
index:338对应的汉字是选
(3) 选择预训练词向量¶
由于Word2vec, Glove, Elmo,
Bert等预训练模型可以增强模型的性能，所以在训练具体任务前，选择合适的预训练词向量非常重要。
在fastNLP中我们提供了多种Embedding使得加载这些预训练模型的过程变得更加便捷。
这里我们先给出一个使用word2vec的中文汉字预训练的示例，之后再给出一个使用Bert的文本分类。
这里使用的预训练词向量为'cn-fastnlp-100d'，fastNLP将自动下载该embedding至本地缓存，
fastNLP支持使用名字指定的Embedding以及相关说明可以参见 fastNLP.embeddings
from fastNLP.embeddings import StaticEmbedding
word2vec_embed = StaticEmbedding(char_vocab, model_dir_or_name='cn-char-fastnlp-100d')
Found 4321 out of 4409 compound in the pre-training embedding.
(4) 创建模型¶
from torch import nn
from fastNLP.modules import LSTM
import torch
# 定义模型
class BiLSTMMaxPoolCls(nn.Module):
def __init__(self, embed, num_classes, hidden_size=400, num_layers=1, dropout=0.3):
super().__init__()
self.embed = embed
self.lstm = LSTM(self.embed.embedding_dim, hidden_size=hidden_size//2, num_layers=num_layers,
batch_first=True, bidirectional=True)
self.dropout_layer = nn.Dropout(dropout)
self.fc = nn.Linear(hidden_size, num_classes)
def forward(self, chars, seq_len): # 这里的名称必须和DataSet中相应的field对应，比如之前我们DataSet中有chars，这里就必须为chars
# chars:[batch_size, max_len]
# seq_len: [batch_size, ]
chars = self.embed(chars)
outputs, _ = self.lstm(chars, seq_len)
outputs = self.dropout_layer(outputs)
outputs, _ = torch.max(outputs, dim=1)
outputs = self.fc(outputs)
return {'pred':outputs} # [batch_size,], 返回值必须是dict类型，且预测值的key建议设为pred
# 初始化模型
model = BiLSTMMaxPoolCls(word2vec_embed, len(data_bundle.get_vocab('target')))
(5) 训练模型¶
fastNLP提供了Trainer对象来组织训练过程，包括完成loss计算(所以在初始化Trainer的时候需要指定loss类型)，梯度更新(所以在初始化Trainer的时候需要提供优化器optimizer)以及在验证集上的性能验证(所以在初始化时需要提供一个Metric)
from fastNLP import Trainer
from fastNLP import CrossEntropyLoss
from torch.optim import Adam
from fastNLP import AccuracyMetric
loss = CrossEntropyLoss()
optimizer = Adam(model.parameters(), lr=0.001)
metric = AccuracyMetric()
device = 0 if torch.cuda.is_available() else 'cpu' # 如果有gpu的话在gpu上运行，训练速度会更快
trainer = Trainer(train_data=data_bundle.get_dataset('train'), model=model, loss=loss,
optimizer=optimizer, batch_size=32, dev_data=data_bundle.get_dataset('dev'),
metrics=metric, device=device)
trainer.train() # 开始训练，训练完成之后默认会加载在dev上表现最好的模型
# 在测试集上测试一下模型的性能
from fastNLP import Tester
print("Performance on test is:")
tester = Tester(data=data_bundle.get_dataset('test'), model=model, metrics=metric, batch_size=64, device=device)
tester.test()
input fields after batch(if batch size is 2):
target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
chars: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2, 106])
seq_len: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
target fields after batch(if batch size is 2):
target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
seq_len: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
Evaluate data in 0.01 seconds!
training epochs started 2019-09-03-23-57-10
Evaluate data in 0.43 seconds!
Evaluation on dev at Epoch 1/10. Step:300/3000:
AccuracyMetric: acc=0.81
Evaluate data in 0.44 seconds!
Evaluation on dev at Epoch 2/10. Step:600/3000:
AccuracyMetric: acc=0.8675
Evaluate data in 0.44 seconds!
Evaluation on dev at Epoch 3/10. Step:900/3000:
AccuracyMetric: acc=0.878333
....
Evaluate data in 0.48 seconds!
Evaluation on dev at Epoch 9/10. Step:2700/3000:
AccuracyMetric: acc=0.8875
Evaluate data in 0.43 seconds!
Evaluation on dev at Epoch 10/10. Step:3000/3000:
AccuracyMetric: acc=0.895833
In Epoch:7/Step:2100, got best dev performance:
AccuracyMetric: acc=0.8975
Reloaded the best model.
Evaluate data in 0.34 seconds!
[tester]
AccuracyMetric: acc=0.8975
{'AccuracyMetric': {'acc': 0.8975}}
使用Bert进行文本分类¶
# 只需要切换一下Embedding即可
from fastNLP.embeddings import BertEmbedding
# 这里为了演示一下效果，所以默认Bert不更新权重
bert_embed = BertEmbedding(char_vocab, model_dir_or_name='cn', auto_truncate=True, requires_grad=False)
model = BiLSTMMaxPoolCls(bert_embed, len(data_bundle.get_vocab('target')), )
import torch
from fastNLP import Trainer
from fastNLP import CrossEntropyLoss
from torch.optim import Adam
from fastNLP import AccuracyMetric
loss = CrossEntropyLoss()
optimizer = Adam(model.parameters(), lr=2e-5)
metric = AccuracyMetric()
device = 0 if torch.cuda.is_available() else 'cpu' # 如果有gpu的话在gpu上运行，训练速度会更快
trainer = Trainer(train_data=data_bundle.get_dataset('train'), model=model, loss=loss,
optimizer=optimizer, batch_size=16, dev_data=data_bundle.get_dataset('test'),
metrics=metric, device=device, n_epochs=3)
trainer.train() # 开始训练，训练完成之后默认会加载在dev上表现最好的模型
# 在测试集上测试一下模型的性能
from fastNLP import Tester
print("Performance on test is:")
tester = Tester(data=data_bundle.get_dataset('test'), model=model, metrics=metric, batch_size=64, device=device)
tester.test()
loading vocabulary file ~/.fastNLP/embedding/bert-chinese-wwm/vocab.txt
Load pre-trained BERT parameters from file ~/.fastNLP/embedding/bert-chinese-wwm/chinese_wwm_pytorch.bin.
Start to generating word pieces for word.
Found(Or segment into word pieces) 4286 words out of 4409.
input fields after batch(if batch size is 2):
target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
chars: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2, 106])
seq_len: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
target fields after batch(if batch size is 2):
target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
seq_len: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
Evaluate data in 0.05 seconds!
training epochs started 2019-09-04-00-02-37
Evaluate data in 15.89 seconds!
Evaluation on dev at Epoch 1/3. Step:1200/3600:
AccuracyMetric: acc=0.9
Evaluate data in 15.92 seconds!
Evaluation on dev at Epoch 2/3. Step:2400/3600:
AccuracyMetric: acc=0.904167
Evaluate data in 15.91 seconds!
Evaluation on dev at Epoch 3/3. Step:3600/3600:
AccuracyMetric: acc=0.918333
In Epoch:3/Step:3600, got best dev performance:
AccuracyMetric: acc=0.918333
Reloaded the best model.
Performance on test is:
Evaluate data in 29.24 seconds!
[tester]
AccuracyMetric: acc=0.919167
{'AccuracyMetric': {'acc': 0.919167}}
序列标注¶
这一部分的内容主要展示如何使用fastNLP实现序列标注(Sequence labeling)任务。您可以使用fastNLP的各个组件快捷，方便地完成序列标注任务，达到出色的效果。 在阅读这篇教程前，希望您已经熟悉了fastNLP的基础使用，尤其是数据的载入以及模型的构建。通过这个小任务，能让您进一步熟悉fastNLP的使用。
注解
本教程推荐使用 GPU 进行实验
命名实体识别(name entity recognition, NER)¶
命名实体识别任务是从文本中抽取出具有特殊意义或者指代性非常强的实体，通常包括人名、地名、机构名和时间等。 如下面的例子中
我来自复旦大学。
其中“复旦大学”就是一个机构名，命名实体识别就是要从中识别出“复旦大学”这四个字是一个整体，且属于机构名这个类别。这个问题在实际做的时候会被 转换为序列标注问题
针对"我来自复旦大学"这句话，我们的预测目标将是[O, O, O, B-ORG, I-ORG, I-ORG, I-ORG]，其中O表示out,即不是一个实体，B-ORG是ORG( organization的缩写)这个类别的开头(Begin)，I-ORG是ORG类别的中间(Inside)。
在本tutorial中我们将通过fastNLP尝试写出一个能够执行以上任务的模型。
载入数据¶
fastNLP的数据载入主要是由Loader与Pipe两个基类衔接完成的，您可以通过 使用Loader和Pipe处理数据 了解如何使用fastNLP提供的数据加载函数。下面我们以微博命名实体任务来演示一下在fastNLP进行序列标注任务。
from fastNLP.io import WeiboNERPipe
data_bundle = WeiboNERPipe().process_from_file()
print(data_bundle.get_dataset('train')[:2])
打印的数据如下
+-------------------------------------------------+------------------------------------------+------------------------------------------+---------+
| raw_chars | target | chars | seq_len |
+-------------------------------------------------+------------------------------------------+------------------------------------------+---------+
| ['一', '节', '课', '的', '时', '间', '真', '... | [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, ... | [8, 211, 775, 3, 49, 245, 89, 26, 101... | 16 |
| ['回', '复', '支', '持', '，', '赞', '成', '... | [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [116, 480, 127, 109, 2, 446, 134, 2, ... | 59 |
+-------------------------------------------------+------------------------------------------+------------------------------------------+---------+
模型构建¶
首先选择需要使用的Embedding类型。关于Embedding的相关说明可以参见 使用Embedding模块将文本转成向量 。 在这里我们使用通过word2vec预训练的中文汉字embedding。
from fastNLP.embeddings import StaticEmbedding
embed = StaticEmbedding(vocab=data_bundle.get_vocab('chars'), model_dir_or_name='cn-char-fastnlp-100d')
选择好Embedding之后，我们可以使用fastNLP中自带的 fastNLP.models.BiLSTMCRF 作为模型。
from fastNLP.models import BiLSTMCRF
data_bundle.rename_field('chars', 'words') # 这是由于BiLSTMCRF模型的forward函数接受的words，而不是chars，所以需要把这一列重新命名
model = BiLSTMCRF(embed=embed, num_classes=len(data_bundle.get_vocab('target')), num_layers=1, hidden_size=200, dropout=0.5,
target_vocab=data_bundle.get_vocab('target'))
进行训练¶
下面我们选择用来评估模型的metric，以及优化用到的优化函数。
from fastNLP import SpanFPreRecMetric
from torch.optim import Adam
from fastNLP import LossInForward
metric = SpanFPreRecMetric(tag_vocab=data_bundle.get_vocab('target'))
optimizer = Adam(model.parameters(), lr=1e-2)
loss = LossInForward()
使用Trainer进行训练, 您可以通过修改 device 的值来选择显卡。
from fastNLP import Trainer
import torch
device= 0 if torch.cuda.is_available() else 'cpu'
trainer = Trainer(data_bundle.get_dataset('train'), model, loss=loss, optimizer=optimizer,
dev_data=data_bundle.get_dataset('dev'), metrics=metric, device=device)
trainer.train()
训练过程输出为:
input fields after batch(if batch size is 2):
target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2, 26])
seq_len: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
words: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2, 26])
target fields after batch(if batch size is 2):
target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2, 26])
seq_len: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
training epochs started 2019-09-25-10-43-09
Evaluate data in 0.62 seconds!
Evaluation on dev at Epoch 1/10. Step:43/430:
SpanFPreRecMetric: f=0.070352, pre=0.100962, rec=0.053985
...
Evaluate data in 0.61 seconds!
Evaluation on dev at Epoch 10/10. Step:430/430:
SpanFPreRecMetric: f=0.51223, pre=0.581699, rec=0.457584
In Epoch:7/Step:301, got best dev performance:
SpanFPreRecMetric: f=0.515528, pre=0.65098, rec=0.426735
Reloaded the best model.
进行测试¶
训练结束之后过，可以通过 Tester 测试其在测试集上的性能
from fastNLP import Tester
tester = Tester(data_bundle.get_dataset('test'), model, metrics=metric)
tester.test()
输出为:
[tester]
SpanFPreRecMetric: f=0.482399, pre=0.530086, rec=0.442584
使用更强的Bert做序列标注¶
在fastNLP使用Bert进行任务，您只需要把 fastNLP.embeddings.StaticEmbedding 切换为 fastNLP.embeddings.BertEmbedding （可修改 device 选择显卡）。
from fastNLP.io import WeiboNERPipe
data_bundle = WeiboNERPipe().process_from_file()
data_bundle.rename_field('chars', 'words')
from fastNLP.embeddings import BertEmbedding
embed = BertEmbedding(vocab=data_bundle.get_vocab('words'), model_dir_or_name='cn')
model = BiLSTMCRF(embed=embed, num_classes=len(data_bundle.get_vocab('target')), num_layers=1, hidden_size=200, dropout=0.5,
target_vocab=data_bundle.get_vocab('target'))
from fastNLP import SpanFPreRecMetric
from torch.optim import Adam
from fastNLP import LossInForward
metric = SpanFPreRecMetric(tag_vocab=data_bundle.get_vocab('target'))
optimizer = Adam(model.parameters(), lr=2e-5)
loss = LossInForward()
from fastNLP import Trainer
import torch
device= 0 if torch.cuda.is_available() else 'cpu'
trainer = Trainer(data_bundle.get_dataset('train'), model, loss=loss, optimizer=optimizer, batch_size=12,
dev_data=data_bundle.get_dataset('dev'), metrics=metric, device=device)
trainer.train()
from fastNLP import Tester
tester = Tester(data_bundle.get_dataset('test'), model, metrics=metric)
tester.test()
输出为:
training epochs started 2019-09-25-07-15-43
Evaluate data in 2.02 seconds!
Evaluation on dev at Epoch 1/10. Step:113/1130:
SpanFPreRecMetric: f=0.0, pre=0.0, rec=0.0
...
Evaluate data in 2.17 seconds!
Evaluation on dev at Epoch 10/10. Step:1130/1130:
SpanFPreRecMetric: f=0.647332, pre=0.589852, rec=0.717224
In Epoch:6/Step:678, got best dev performance:
SpanFPreRecMetric: f=0.669963, pre=0.645238, rec=0.696658
Reloaded the best model.
Evaluate data in 1.82 seconds!
[tester]
SpanFPreRecMetric: f=0.641774, pre=0.626424, rec=0.657895
可以看出通过使用Bert，效果有明显的提升，从48.2提升到了64.1。
这些教程是简单地介绍了 fastNLP 的使用流程，其中文本分类相对简单，序列标注则较为复杂。更多的教程分析见 fastNLP 详细使用教程
fastNLP 详细使用教程¶
这里是更详细的使用教程。对于大部分的用户，我们建议你从第一篇开始顺序阅读；如果你只想了解其中的一部分，也可以进行选读。
fastNLP中的DataSet¶
DataSet 是fastNLP用于承载数据的类，一般训练集、验证集和测试集会被加载为三个单独的 DataSet 对象。
DataSet 中的数据组织形式类似一个表格，比如下面 DataSet 一共有3列，列在fastNLP中被称为field。
| raw_chars | chars | seq_len |
|---|---|---|
| 历任公司副总经理、总工程师， | [历 任 公 司 副 总 经 理 、 总 工 程 师 ，] | 6 |
| Third instance . | [Third, instance, .] | 3 |
| ... | [...] | ... |
每一行是一个instance (在fastNLP中被称为 Instance )，
每一列是一个field (在fastNLP中称为 FieldArray )。
DataSet的构建¶
我们使用传入字典的方式初始化一个DataSet，这是 DataSet 初始化的最基础的方式
from fastNLP import DataSet
data = {'raw_words':["This is the first instance .", "Second instance .", "Third instance ."],
'words': [['this', 'is', 'the', 'first', 'instance', '.'], ['Second', 'instance', '.'], ['Third', 'instance', '.']],
'seq_len': [6, 3, 3]}
dataset = DataSet(data)
# 传入的dict的每个key的value应该为具有相同长度的list
print(dataset)
输出为:
+------------------------------+------------------------------------------------+---------+
| raw_words | words | seq_len |
+------------------------------+------------------------------------------------+---------+
| This is the first instance . | ['this', 'is', 'the', 'first', 'instance', ... | 6 |
| Second instance . | ['Second', 'instance', '.'] | 3 |
| Third instance . | ['Third', 'instance', '.'] | 3 |
+------------------------------+------------------------------------------------+---------+
我们还可以使用 append() 方法向DataSet增加数据
from fastNLP import DataSet
from fastNLP import Instance
dataset = DataSet()
instance = Instance(raw_words="This is the first instance",
words=['this', 'is', 'the', 'first', 'instance', '.'],
seq_len=6)
dataset.append(instance)
# 可以继续append更多内容，但是append的instance应该和前面的instance拥有完全相同的field
另外，我们还可以用 Instance 数组的方式构建DataSet
from fastNLP import DataSet
from fastNLP import Instance
dataset = DataSet([
Instance(raw_words="This is the first instance",
words=['this', 'is', 'the', 'first', 'instance', '.'],
seq_len=6),
Instance(raw_words="Second instance .",
words=['Second', 'instance', '.'],
seq_len=3)
])
在初步构建完DataSet之后，我们可以通过 for 循环遍历 DataSet 中的内容。
for instance in dataset:
# do something
DataSet的删除¶
FastNLP 同样提供了多种删除数据的方法 drop() 、 delete_instance() 和 delete_field()
我们先用下面的代码生成一个只有两列的样例DataSet，第一列的值分别为 -5 ~ 4，第二列的值均为 0.
from fastNLP import DataSet
dataset = DataSet({'a': range(-5, 5), 'c': [0]*10})
然后我们使用三种方法进行删除，删除后的DataSet仅包含名为 c 的一列，包含4个值为0 的数据。
# 不改变dataset，生成一个删除了满足条件的instance的新 DataSet
dropped_dataset = dataset.drop(lambda ins:ins['a']<0, inplace=False)
# 在dataset中删除满足条件的instance
dataset.drop(lambda ins:ins['a']<0)
# 删除第3个instance
dataset.delete_instance(2)
# 删除名为'a'的field
dataset.delete_field('a')
简单的数据预处理¶
因为 fastNLP 中的数据是按列存储的，所以大部分的数据预处理操作是以列（ field ）为操作对象的。
首先，我们可以检查特定名称的 field 是否存在，并对其进行改名。
# 检查是否存在名为'a'的field
dataset.has_field('a') # 或 ('a' in dataset)
# 将名为'c'的field改名为'b'
dataset.rename_field('c', 'b')
# DataSet的长度
len(dataset)
其次，我们可以使用 apply() 或 apply_field() 进行数据预处理操作操作。
使用以上的两个方法需要传入一个函数，函数可以是 lambda 匿名函数，也可以是完整定义的函数，fastNLP将对DataSet遍历地应用该函数。
同时，你还可以用 new_field_name 参数指定函数返回值组成的新 field 的名称。
from fastNLP import DataSet
data = {'raw_words':["This is the first instance .", "Second instance .", "Third instance ."]}
dataset = DataSet(data)
# 将句子分成单词形式, 详见DataSet.apply()方法
dataset.apply(lambda ins: ins['raw_words'].split(), new_field_name='words')
# 或使用DataSet.apply_field()
dataset.apply_field(lambda sent:sent.split(), field_name='raw_words', new_field_name='words')
# 除了匿名函数，也可以定义函数传递进去
def get_words(instance):
sentence = instance['raw_words']
words = sentence.split()
return words
dataset.apply(get_words, new_field_name='words')
除了手动处理数据集之外，你还可以使用 fastNLP 提供的各种 Loader 和 Pipe 来进行数据处理。
详细请参考这篇教程 使用Loader和Pipe处理数据 。
fastNLP中field的命名习惯¶
在英文任务中，fastNLP常用的field名称有:
- raw_words: 表示的是原始的str。例如"This is a demo sentence ."。存在多个raw_words的情况，例如matching任务，它们会被定义为raw_words0, raw_words1。但在conll格式下，raw_words列也可能为["This", "is", "a", "demo", "sentence", "."]的形式。
- words: 表示的是已经tokenize后的词语。例如["This", "is", "a", "demo", "sentence"], 但由于str并不能直接被神经网络所使用，所以words中的内容往往被转换为int，如[3, 10, 4, 2, 7, ...]等。多列words的情况，会被命名为words0, words1
- target: 表示目标值。分类场景下，只有一个值；序列标注场景下是一个序列。
- seq_len: 一般用于表示words列的长度
在中文任务中，fastNLP常用的field名称有:
- raw_words: 如果原始汉字序列中已经包含了词语的边界，则该列称为raw_words。如"上海 浦东 开发 与 法制 建设 同步"。
- words: 表示单独的汉字词语序列。例如["上海", "", "浦东", "开发", "与", "法制", "建设", ...]或[2, 3, 4, ...]
- raw_chars: 表示的是原始的连续汉字序列。例如"这是一个示例。"
- chars: 表示已经切分为单独的汉字的序列。例如["这", "是", "一", "个", "示", "例", "。"]。但由于神经网络不能识别汉字，所以一般该列会被转为int形式，如[3, 4, 5, 6, ...]。
- target: 表示目标值。分类场景下，只有一个值；序列标注场景下是一个序列
- seq_len: 表示输入序列的长度
fastNLP中的Vocabulary¶
Vocabulary 是包含字或词与index关系的类，用于将文本转换为index。
构建Vocabulary¶
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst(['复', '旦', '大', '学']) # 加入新的字
vocab.add_word('上海') # `上海`会作为一个整体
vocab.to_index('复') # 应该会为3
vocab.to_index('我') # 会输出1，Vocabulary中默认pad的index为0, unk(没有找到的词)的index为1
# 在构建target的Vocabulary时，词表中应该用不上pad和unk，可以通过以下的初始化
vocab = Vocabulary(unknown=None, padding=None)
vocab.add_word_lst(['positive', 'negative'])
vocab.to_index('positive') # 输出0
vocab.to_index('neutral') # 会报错，因为没有unk这种情况
除了通过以上的方式建立词表，Vocabulary还可以通过使用下面的函数直接从 DataSet 中的某一列建立词表以及将该列转换为index
from fastNLP import Vocabulary
from fastNLP import DataSet
dataset = DataSet({'chars': [
['今', '天', '天', '气', '很', '好', '。'],
['被', '这', '部', '电', '影', '浪', '费', '了', '两', '个', '小', '时', '。']
],
'target': ['neutral', 'negative']
})
vocab = Vocabulary()
# 从该dataset中的chars列建立词表
vocab.from_dataset(dataset, field_name='chars')
# 使用vocabulary将chars列转换为index
vocab.index_dataset(dataset, field_name='chars')
target_vocab = Vocabulary(padding=None, unknown=None)
target_vocab.from_dataset(dataset, field_name='target')
target_vocab.index_dataset(dataset, field_name='target')
print(dataset)
输出内容为:
+---------------------------------------------------+--------+
| chars | target |
+---------------------------------------------------+--------+
| [4, 2, 2, 5, 6, 7, 3] | 0 |
| [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 3] | 1 |
+---------------------------------------------------+--------+
一些使用tips¶
在使用from_dataset()函数建立词表时，将测试集和验证集放入参数no_create_entry_dataset中，如下所示
from fastNLP import Vocabulary
from fastNLP import DataSet
tr_data = DataSet({'chars': [
['今', '天', '心', '情', '很', '好', '。'],
['被', '这', '部', '电', '影', '浪', '费', '了', '两', '个', '小', '时', '。']
],
'target': ['positive', 'negative']
})
dev_data = DataSet({'chars': [
['住', '宿', '条', '件', '还', '不', '错'],
['糟', '糕', '的', '天', '气', '，', '无', '法', '出', '行', '。']
],
'target': ['positive', 'negative']
})
vocab = Vocabulary()
# 将验证集或者测试集在建立词表是放入no_create_entry_dataset这个参数中。
vocab.from_dataset(tr_data, field_name='chars', no_create_entry_dataset=[dev_data])
Vocabulary 中的 no_create_entry , 建议在添加来自于测试集和验证集的词的时候将该参数置为True, 或将验证集和测试集
传入 no_create_entry_dataset 参数。它们的意义是在接下来的模型会使用pretrain的embedding(包括glove, word2vec, elmo与bert)且会finetune的
情况下，如果仅使用来自于train的数据建立vocabulary，会导致只出现在test与dev中的词语无法充分利用到来自于预训练embedding的信息(因为他们
会被认为是unk)，所以在建立词表的时候将test与dev考虑进来会使得最终的结果更好。
通过与fastNLP中的各种Embedding配合使用，会有如下的效果， 如果一个词出现在了train中，但是没在预训练模型中，embedding会为随机初始化，且它单独的一个vector，如果finetune embedding的话， 这个词在更新之后可能会有更好的表示; 而如果这个词仅出现在了dev或test中，那么就不能为它们单独建立vector，而应该让它指向unk这个vector的 值(当unk的值更新时，这个词也使用的是更新之后的vector)。所以被认为是no_create_entry的token，将首先从预训练的词表中寻找它的表示，如 果找到了，就使用该表示; 如果没有找到，则认为该词的表示应该为unk的表示。
下面我们结合部分 StaticEmbedding 的例子来说明下该值造成的影响，如果您对 StaticEmbedding 不太了解，您可以先参考 使用Embedding模块将文本转成向量 部分再来阅读该部分
import torch
from fastNLP.embeddings import StaticEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word('train')
vocab.add_word('only_in_train') # 仅在train出现，但肯定在预训练词表中不存在
vocab.add_word('test', no_create_entry=True) # 该词只在dev或test中出现
vocab.add_word('only_in_test', no_create_entry=True) # 这个词在预训练的词表中找不到
embed = StaticEmbedding(vocab, model_dir_or_name='en-glove-6b-50d')
print(embed(torch.LongTensor([vocab.to_index('train')])))
print(embed(torch.LongTensor([vocab.to_index('only_in_train')])))
print(embed(torch.LongTensor([vocab.to_index('test')])))
print(embed(torch.LongTensor([vocab.to_index('only_in_test')])))
print(embed(torch.LongTensor([vocab.unknown_idx])))
输出结果(只截取了部分vector):
tensor([[ 0.9497, 0.3433, 0.8450, -0.8852, ...]], grad_fn=<EmbeddingBackward>) # train，en-glove-6b-50d，找到了该词
tensor([[ 0.0540, -0.0557, -0.0514, -0.1688, ...]], grad_fn=<EmbeddingBackward>) # only_in_train，en-glove-6b-50d，使用了随机初始化
tensor([[ 0.1318, -0.2552, -0.0679, 0.2619, ...]], grad_fn=<EmbeddingBackward>) # test，在en-glove-6b-50d中找到了这个词
tensor([[0., 0., 0., 0., 0., ...]], grad_fn=<EmbeddingBackward>) # only_in_test, en-glove-6b-50d中找不到这个词，使用unk的vector
tensor([[0., 0., 0., 0., 0., ...]], grad_fn=<EmbeddingBackward>) # unk，使用zero初始化
首先train和test都能够从预训练中找到对应的vector，所以它们是各自的vector表示; only_in_train在预训练中找不到，StaticEmbedding为它 新建了一个entry，所以它有一个单独的vector; 而only_in_test在预训练中找不到改词，因此被指向了unk的值(fastNLP用零向量初始化unk)，与最后一行unk的 表示相同。
使用Embedding模块将文本转成向量¶
这一部分是一个关于在fastNLP当中使用embedding的教程。
教程目录：
Part I: embedding介绍¶
Embedding是一种词嵌入技术，可以将字或者词转换为实向量。目前使用较多的预训练词嵌入有word2vec, fasttext, glove, character embedding,
elmo以及bert。
但使用这些词嵌入方式的时候都需要做一些加载上的处理，比如预训练的word2vec, fasttext以及glove都有着超过几十万个词语的表示，但一般任务大概
只会用到其中的几万个词，如果直接加载所有的词汇，会导致内存占用变大以及训练速度变慢，需要从预训练文件中抽取本次实验的用到的词汇；而对于英文的
elmo和character embedding, 需要将word拆分成character才能使用；Bert的使用更是涉及到了Byte pair encoding(BPE)相关的内容。为了方便
大家的使用，fastNLP通过 Vocabulary 统一了不同embedding的使用。下面我们将讲述一些例子来说明一下
Part II: 使用预训练的静态embedding¶
在fastNLP中，加载预训练的word2vec, glove以及fasttext都使用的是 StaticEmbedding 。另外，为了方便大家的
使用，fastNLP提供了多种静态词向量的自动下载并缓存(默认缓存到~/.fastNLP/embeddings文件夹下)的功能，支持自动下载的预训练向量可以在
下载文档 查看。
import torch
from fastNLP.embeddings import StaticEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
embed = StaticEmbedding(vocab, model_dir_or_name='en-glove-6b-50d')
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo .".split()]]) # 将文本转为index
print(embed(words).size()) # StaticEmbedding的使用和pytorch的nn.Embedding是类似的
输出为:
torch.Size([1, 5, 50])
fastNLP的StaticEmbedding在初始化之后，就和pytorch中的Embedding是类似的了。 StaticEmbedding 的初始化
主要是从model_dir_or_name提供的词向量中抽取出 Vocabulary 中词语的vector。
除了可以通过使用预先提供的Embedding, StaticEmbedding 也支持加载本地的预训练词向量，glove, word2vec以及
fasttext格式的。通过将model_dir_or_name修改为本地的embedding文件路径，即可使用本地的embedding。
Part III: 使用随机初始化的embedding¶
有时候需要使用随机初始化的Embedding，也可以通过使用 StaticEmbedding 获得。只需要将model_dir_or_name
置为None，且传入embedding_dim，如下例所示
from fastNLP.embeddings import StaticEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
embed = StaticEmbedding(vocab, model_dir_or_name=None, embedding_dim=30)
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo .".split()]])
print(embed(words).size())
输出为:
torch.Size([1, 5, 30])
Part IV: ELMo Embedding¶
在fastNLP中，我们提供了ELMo和BERT的embedding： ElmoEmbedding
和 BertEmbedding 。可自动下载的ElmoEmbedding可以
从 下载文档 找到。
与静态embedding类似，ELMo的使用方法如下：
from fastNLP.embeddings import ElmoEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
embed = ElmoEmbedding(vocab, model_dir_or_name='en-small', requires_grad=False)
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo .".split()]])
print(embed(words).size())
输出为:
torch.Size([1, 5, 256])
也可以输出多层的ELMo结果，fastNLP将在不同层的结果在最后一维上拼接，下面的代码需要在上面的代码执行结束之后执行
embed = ElmoEmbedding(vocab, model_dir_or_name='en-small', requires_grad=False, layers='1,2')
print(embed(words).size())
输出为:
torch.Size([1, 5, 512])
另外，根据 Deep contextualized word representations ，不同层之间使用可学习的权重可以使得ELMo的效果更好，在fastNLP中可以通过以下的初始化 实现3层输出的结果通过可学习的权重进行加法融合。
embed = ElmoEmbedding(vocab, model_dir_or_name='en-small', requires_grad=True, layers='mix')
print(embed(words).size()) # 三层输出按照权重element-wise的加起来
输出为:
torch.Size([1, 5, 256])
Part V: Bert Embedding¶
虽然Bert并不算严格意义上的Embedding，但通过将Bert封装成Embedding的形式将极大减轻使用的复杂程度。可自动下载的Bert Embedding可以 从 下载文档 找到。我们将使用下面的例子讲述一下 BertEmbedding的使用
from fastNLP.embeddings import BertEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
embed = BertEmbedding(vocab, model_dir_or_name='en-base-cased')
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo .".split()]])
print(embed(words).size())
输出为:
torch.Size([1, 5, 768])
可以通过申明使用指定层数的output也可以使用多层的output，下面的代码需要在上面的代码执行结束之后执行
# 使用后面两层的输出
embed = BertEmbedding(vocab, model_dir_or_name='en-base-cased', layers='10,11')
print(embed(words).size()) # 结果将是在最后一维做拼接
输出为:
torch.Size([1, 5, 1536])
在Bert中还存在两个特殊的字符[CLS]和[SEP]，默认情况下这两个字符是自动加入并且在计算结束之后会自动删除，以使得输入的序列长度和输出的序列 长度是一致的，但是有些分类的情况，必须需要使用[CLS]的表示，这种情况可以通过在初始化时申明一下需要保留[CLS]的表示，如下例所示
embed = BertEmbedding(vocab, model_dir_or_name='en-base-cased', layers='-1', include_cls_sep=True)
print(embed(words).size()) # 结果将在序列维度上增加2
# 取出句子的cls表示
cls_reps = embed(words)[:, 0] # shape: [batch_size, 768]
输出为:
torch.Size([1, 7, 768])
在英文Bert模型中，一个英文单词可能会被切分为多个subword，例如"fairness"会被拆分为 ["fair", "##ness"] ，这样一个word对应的将有两个输出，
BertEmbedding 会使用pooling方法将一个word的subword的表示合并成一个vector，通过pool_method可以控制
该pooling方法，支持的有"first"(即使用fair的表示作为fairness的表示), "last"(使用##ness的表示作为fairness的表示), "max"(对fair和
##ness在每一维上做max),"avg"(对fair和##ness每一维做average)。
embed = BertEmbedding(vocab, model_dir_or_name='en-base-cased', layers='-1', pool_method='max')
print(embed(words).size())
输出为:
torch.Size([1, 5, 768])
另外，根据 BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding ， Bert在针对具有两句话的任务时（如matching，Q&A任务），句子之间通过[SEP]拼接起来，前一句话的token embedding为0， 后一句话的token embedding为1。BertEmbedding能够自动识别句子中间的[SEP]来正确设置对应的token_type_id的。
vocab = Vocabulary()
vocab.add_word_lst("this is a demo . [SEP] another sentence .".split())
embed = BertEmbedding(vocab, model_dir_or_name='en-base-cased', layers='-1', pool_method='max')
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo . [SEP] another sentence .".split()]])
print(embed(words).size())
输出为:
torch.Size([1, 9, 768])
在多个[SEP]的情况下，将会使token_type_id不断0，1循环。比如"first sentence [SEP] second sentence [SEP] third sentence", 它们的 token_type_id将是[0, 0, 0, 1, 1, 1, 0, 0]。但请注意[SEP]一定要大写的，不能是[sep]，否则无法识别。
更多 BertEmbedding 的使用，请参考 BertEmbedding的各种用法
Part VI: 使用character-level的embedding¶
除了预训练的embedding以外，fastNLP还提供了两种Character Embedding： CNNCharEmbedding 和
LSTMCharEmbedding 。一般在使用character embedding时，需要在预处理的时候将word拆分成character，这
会使得预处理过程变得非常繁琐。在fastNLP中，使用character embedding也只需要传入 Vocabulary 即可，而且该
Vocabulary与其它Embedding使用的Vocabulary是一致的，下面我们看两个例子。
CNNCharEmbedding的使用例子如下：
from fastNLP.embeddings import CNNCharEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
# character的embedding维度大小为50，返回的embedding结果维度大小为64。
embed = CNNCharEmbedding(vocab, embed_size=64, char_emb_size=50)
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo .".split()]])
print(embed(words).size())
输出为:
torch.Size([1, 5, 64])
与CNNCharEmbedding类似，LSTMCharEmbedding的使用例子如下：
from fastNLP.embeddings import LSTMCharEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
# character的embedding维度大小为50，返回的embedding结果维度大小为64。
embed = LSTMCharEmbedding(vocab, embed_size=64, char_emb_size=50)
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo .".split()]])
print(embed(words).size())
输出为:
torch.Size([1, 5, 64])
Part VII: 叠加使用多个embedding¶
单独使用Character Embedding往往效果并不是很好，需要同时结合word embedding。在fastNLP中可以通过 StackEmbedding
来叠加embedding，具体的例子如下所示
from fastNLP.embeddings import StaticEmbedding, StackEmbedding, CNNCharEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
word_embed = StaticEmbedding(vocab, model_dir_or_name='en-glove-6b-50d')
char_embed = CNNCharEmbedding(vocab, embed_size=64, char_emb_size=50)
embed = StackEmbedding([word_embed, char_embed])
words = torch.LongTensor([[vocab.to_index(word) for word in "this is a demo .".split()]])
print(embed(words).size()) # 输出embedding的维度为50+64=114
输出为:
torch.Size([1, 5, 114])
StaticEmbedding , ElmoEmbedding ,
CNNCharEmbedding , BertEmbedding 等都可以互相拼接。
StackEmbedding 的使用也是和其它Embedding是一致的，即输出index返回对应的表示。但能够拼接起来的Embedding
必须使用同样的 Vocabulary ，因为只有使用同样的 Vocabulary 才能保证同一个index指向的是同一个词或字
Part VIII: Embedding的其它说明¶
- 获取各种Embedding的dimension
from fastNLP.embeddings import *
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
static_embed = StaticEmbedding(vocab, model_dir_or_name='en-glove-6b-50d')
print(static_embed.embedding_dim) # 50
char_embed = CNNCharEmbedding(vocab, embed_size=30)
print(char_embed.embedding_dim) # 30
elmo_embed_1 = ElmoEmbedding(vocab, model_dir_or_name='en-small', layers='2')
print(elmo_embed_1.embedding_dim) # 256
elmo_embed_2 = ElmoEmbedding(vocab, model_dir_or_name='en-small', layers='1,2')
print(elmo_embed_2.embedding_dim) # 512
bert_embed_1 = BertEmbedding(vocab, layers='-1', model_dir_or_name='en-base-cased')
print(bert_embed_1.embedding_dim) # 768
bert_embed_2 = BertEmbedding(vocab, layers='2,-1', model_dir_or_name='en-base-cased')
print(bert_embed_2.embedding_dim) # 1536
stack_embed = StackEmbedding([static_embed, char_embed])
print(stack_embed.embedding_dim) # 80
- 设置Embedding的权重是否更新
from fastNLP.embeddings import *
vocab = Vocabulary()
vocab.add_word_lst("this is a demo .".split())
embed = BertEmbedding(vocab, model_dir_or_name='en-base-cased', requires_grad=True) # 初始化时设定为需要更新
embed.requires_grad = False # 修改BertEmbedding的权重为不更新
- 各种Embedding中word_dropout与dropout的说明
fastNLP中所有的Embedding都支持传入word_dropout和dropout参数，word_dropout指示的是以多大概率将输入的word置为unk的index，这样既可以 是的unk得到训练，也可以有一定的regularize效果; dropout参数是在获取到word的表示之后，以多大概率将一些维度的表示置为0。
如果使用 StackEmbedding 且需要用到word_dropout，建议将word_dropout设置在 StackEmbedding 上。
Part IX: StaticEmbedding的使用建议¶
在英文的命名实体识别(NER)任务中，由 Named Entity Recognition with Bidirectional LSTM-CNNs 指出，同时使用cnn character embedding和word embedding
会使得NER的效果有比较大的提升。正如你在上节中看到的那样，fastNLP支持将 CNNCharEmbedding
与 StaticEmbedding 拼成一个 StackEmbedding 。如果通过这种方式使用，需要
在预处理文本时，不要将词汇小写化(因为Character Embedding需要利用词语中的大小写信息)且不要将出现频次低于某个阈值的word设置为unk(因为
Character embedding需要利用字形信息)；但 StaticEmbedding 使用的某些预训练词嵌入的词汇表中只有小写的词
语, 且某些低频词并未在预训练中出现需要被剔除。即(1) character embedding需要保留大小写，而预训练词向量不需要保留大小写。(2)
character embedding需要保留所有的字形, 而static embedding需要设置一个最低阈值以学到更好的表示。
- fastNLP如何解决关于大小写的问题
fastNLP通过在 StaticEmbedding 增加了一个lower参数解决该问题。如下面的例子所示
from fastNLP.embeddings import StaticEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary().add_word_lst("The the a A".split())
# 下面用随机的StaticEmbedding演示，但与使用预训练词向量时效果是一致的
embed = StaticEmbedding(vocab, model_name_or_dir=None, embedding_dim=5)
print(embed(torch.LongTensor([vocab.to_index('The')])))
print(embed(torch.LongTensor([vocab.to_index('the')])))
输出为:
tensor([[-0.4685, 0.4572, 0.5159, -0.2618, -0.6871]], grad_fn=<EmbeddingBackward>)
tensor([[ 0.2615, 0.1490, -0.2491, 0.4009, -0.3842]], grad_fn=<EmbeddingBackward>)
可以看到"The"与"the"的vector是不一致的。但如果我们在初始化 StaticEmbedding 将lower设置为True，效果将
如下所示
from fastNLP.embeddings import StaticEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary().add_word_lst("The the a A".split())
# 下面用随机的StaticEmbedding演示，但与使用预训练时效果是一致的
embed = StaticEmbedding(vocab, model_name_or_dir=None, embedding_dim=5, lower=True)
print(embed(torch.LongTensor([vocab.to_index('The')])))
print(embed(torch.LongTensor([vocab.to_index('the')])))
输出为:
tensor([[-0.2237, 0.6825, -0.3459, -0.1795, 0.7516]], grad_fn=<EmbeddingBackward>)
tensor([[-0.2237, 0.6825, -0.3459, -0.1795, 0.7516]], grad_fn=<EmbeddingBackward>)
可以看到"The"与"the"的vector是一致的。他们实际上也是引用的同一个vector。通过将lower设置为True，可以在 StaticEmbedding
实现类似具备相同小写结果的词语引用同一个vector。
- fastNLP如何解决min_freq的问题
fastNLP通过在 StaticEmbedding 增加了一个min_freq参数解决该问题。如下面的例子所示
from fastNLP.embeddings import StaticEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary().add_word_lst("the the the a".split())
# 下面用随机的StaticEmbedding演示，但与使用预训练时效果是一致的
embed = StaticEmbedding(vocab, model_name_or_dir=None, embedding_dim=5, min_freq=2)
print(embed(torch.LongTensor([vocab.to_index('the')])))
print(embed(torch.LongTensor([vocab.to_index('a')])))
print(embed(torch.LongTensor([vocab.unknown_idx])))
输出为:
tensor([[ 0.0454, 0.3375, 0.6758, -0.2026, -0.4715]], grad_fn=<EmbeddingBackward>)
tensor([[-0.7602, 0.0149, 0.2733, 0.3974, 0.7371]], grad_fn=<EmbeddingBackward>)
tensor([[-0.7602, 0.0149, 0.2733, 0.3974, 0.7371]], grad_fn=<EmbeddingBackward>)
其中最后一行为unknown值的vector，可以看到a的vector表示与unknown是一样的，这是由于a的频次低于了2，所以被指向了unknown的表示；而the由于 词频超过了2次，所以它是单独的表示。
在计算min_freq时，也会考虑到lower的作用，比如
from fastNLP.embeddings import StaticEmbedding
from fastNLP import Vocabulary
vocab = Vocabulary().add_word_lst("the the the a A".split())
# 下面用随机的StaticEmbedding演示，但与使用预训练时效果是一致的
embed = StaticEmbedding(vocab, model_name_or_dir=None, embedding_dim=5, min_freq=2, lower=True)
print(embed(torch.LongTensor([vocab.to_index('the')])))
print(embed(torch.LongTensor([vocab.to_index('a')])))
print(embed(torch.LongTensor([vocab.to_index('A')])))
print(embed(torch.LongTensor([vocab.unknown_idx])))
输出为:
tensor([[-0.7453, -0.5542, 0.5039, 0.6195, -0.4723]], grad_fn=<EmbeddingBackward>) # the
tensor([[ 0.0170, -0.0995, -0.5743, -0.2469, -0.2095]], grad_fn=<EmbeddingBackward>) # a
tensor([[ 0.0170, -0.0995, -0.5743, -0.2469, -0.2095]], grad_fn=<EmbeddingBackward>) # A
tensor([[ 0.6707, -0.5786, -0.6967, 0.0111, 0.1209]], grad_fn=<EmbeddingBackward>) # unk
可以看到a不再和最后一行的unknown共享一个表示了，这是由于a与A都算入了a的词频，且A的表示也是a的表示。
使用Loader和Pipe加载并处理数据集¶
这一部分是关于如何加载数据集的教程
教程目录：
Part I: 数据集容器DataBundle¶
而由于对于同一个任务，训练集，验证集和测试集会共用同一个词表以及具有相同的目标值，所以在fastNLP中我们使用了 DataBundle
来承载同一个任务的多个数据集 DataSet 以及它们的词表 Vocabulary 。下面会有例子介绍 DataBundle
的相关使用。
DataBundle 在fastNLP中主要在各个 Loader 和 Pipe 中被使用。
下面我们先介绍一下 Loader 和 Pipe 。
Part II: 加载的各种数据集的Loader¶
在fastNLP中，所有的 Loader 都可以通过其文档判断其支持读取的数据格式，以及读取之后返回的 DataSet 的格式,
例如 ChnSentiCorpLoader 。
download() 函数：自动将该数据集下载到缓存地址，默认缓存地址为~/.fastNLP/datasets/。由于版权等原因，不是所有的Loader都实现了该方法。该方法会返回下载后文件所处的缓存地址。
_load() 函数：从一个数据文件中读取数据，返回一个
DataSet。返回的DataSet的格式可从Loader文档判断。load() 函数：从文件或者文件夹中读取数据为
DataSet并将它们组装成DataBundle。支持接受的参数类型有以下的几种
- None, 将尝试读取自动缓存的数据，仅支持提供了自动下载数据的Loader
- 文件夹路径, 默认将尝试在该文件夹下匹配文件名中含有 train , test , dev 的文件，如果有多个文件含有相同的关键字，将无法通过该方式读取
- dict, 例如{'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"}。
from fastNLP.io import CWSLoader
loader = CWSLoader(dataset_name='pku')
data_bundle = loader.load()
print(data_bundle)
输出内容为:
In total 3 datasets:
dev has 1831 instances.
train has 17223 instances.
test has 1944 instances.
这里表示一共有3个数据集。其中：
- 3个数据集的名称分别为train、dev、test，分别有17223、1831、1944个instance
也可以取出DataSet，并打印DataSet中的具体内容
tr_data = data_bundle.get_dataset('train')
print(tr_data[:2])
输出为:
+--------------------------------------------------------------------------------------+
| raw_words |
+--------------------------------------------------------------------------------------+
| 迈向 充满 希望 的 新 世纪 —— 一九九八年 新年 讲话 （ 附 图片 １ 张 ） |
| 中共中央 总书记 、 国家 主席 江 泽民 |
+--------------------------------------------------------------------------------------+
Part III: 使用Pipe对数据集进行预处理¶
通过 Loader 可以将文本数据读入，但并不能直接被神经网络使用，还需要进行一定的预处理。
在fastNLP中，我们使用 Pipe 的子类作为数据预处理的类， Loader 和 Pipe 一般具备一一对应的关系，该关系可以从其名称判断，
例如 CWSLoader 与 CWSPipe 是一一对应的。一般情况下Pipe处理包含以下的几个过程，(1)将raw_words或
raw_chars进行tokenize以切分成不同的词或字; (2) 再建立词或字的 Vocabulary , 并将词或字转换为index; (3)将target
列建立词表并将target列转为index;
所有的Pipe都可通过其文档查看该Pipe支持处理的 DataSet 以及返回的 DataBundle 中的Vocabulary的情况;
如 OntoNotesNERPipe
各种数据集的Pipe当中，都包含了以下的两个函数:
- process() 函数：对输入的
DataBundle进行处理, 然后返回处理之后的DataBundle。process函数的文档中包含了该Pipe支持处理的DataSet的格式。- process_from_file() 函数：输入数据集所在文件夹，使用对应的Loader读取数据(所以该函数支持的参数类型是由于其对应的Loader的load函数决定的)，然后调用相对应的process函数对数据进行预处理。相当于是把Load和process放在一个函数中执行。
接着上面 CWSLoader 的例子，我们展示一下 CWSPipe 的功能：
from fastNLP.io import CWSPipe
data_bundle = CWSPipe().process(data_bundle)
print(data_bundle)
输出内容为:
In total 3 datasets:
dev has 1831 instances.
train has 17223 instances.
test has 1944 instances.
In total 2 vocabs:
chars has 4777 entries.
target has 4 entries.
表示一共有3个数据集和2个词表。其中：
- 3个数据集的名称分别为train、dev、test，分别有17223、1831、1944个instance
- 2个词表分别为chars词表与target词表。其中chars词表为句子文本所构建的词表，一共有4777个不同的字；target词表为目标标签所构建的词表，一共有4种标签。
相较于之前CWSLoader读取的DataBundle，新增了两个Vocabulary。 我们可以打印一下处理之后的DataSet
tr_data = data_bundle.get_dataset('train')
print(tr_data[:2])
输出为:
+---------------------------------------------------+------------------------------------+------------------------------------+---------+
| raw_words | chars | target | seq_len |
+---------------------------------------------------+------------------------------------+------------------------------------+---------+
| 迈向 充满 希望 的 新 世纪 —— 一九九八年... | [1224, 178, 674, 544, 573, 435,... | [0, 1, 0, 1, 0, 1, 2, 2, 0, 1, ... | 29 |
| 中共中央 总书记 、 国家 主席 江 泽民 | [11, 212, 11, 335, 124, 256, 10... | [0, 3, 3, 1, 0, 3, 1, 2, 0, 1, ... | 15 |
+---------------------------------------------------+------------------------------------+------------------------------------+---------+
可以看到有两列为int的field: chars和target。这两列的名称同时也是DataBundle中的Vocabulary的名称。可以通过下列的代码获取并查看Vocabulary的 信息
vocab = data_bundle.get_vocab('target')
print(vocab)
输出为:
Vocabulary(['B', 'E', 'S', 'M']...)
Part V: 不同格式类型的基础Loader¶
除了上面提到的针对具体任务的Loader，我们还提供了CSV格式和JSON格式的Loader
CSVLoader 读取CSV类型的数据集文件。例子如下：
from fastNLP.io.loader import CSVLoader data_set_loader = CSVLoader( headers=('raw_words', 'target'), sep='\t' ) # 表示将CSV文件中每一行的第一项将填入'raw_words' field，第二项填入'target' field。 # 其中项之间由'\t'分割开来 data_set = data_set_loader._load('path/to/your/file')文件内容样例如下
But it does not leave you with much . 1 You could hate it for the same reason . 1 The performances are an absolute joy . 4读取之后的DataSet具有以下的field
raw_words target But it does not leave you with much . 1 You could hate it for the same reason . 1 The performances are an absolute joy . 4
JsonLoader 读取Json类型的数据集文件，数据必须按行存储，每行是一个包含各类属性的Json对象。例子如下：
from fastNLP.io.loader import JsonLoader loader = JsonLoader( fields={'sentence1': 'raw_words1', 'sentence2': 'raw_words2', 'gold_label': 'target'} ) # 表示将Json对象中'sentence1'、'sentence2'和'gold_label'对应的值赋给'raw_words1'、'raw_words2'、'target'这三个fields data_set = loader._load('path/to/your/file')数据集内容样例如下
{"annotator_labels": ["neutral"], "captionID": "3416050480.jpg#4", "gold_label": "neutral", "pairID": "3416050480.jpg#4r1n", "sentence1": "A person on a horse jumps over a broken down airplane.", "sentence1_binary_parse": "( ( ( A person ) ( on ( a horse ) ) ) ( ( jumps ( over ( a ( broken ( down airplane ) ) ) ) ) . ) )", "sentence1_parse": "(ROOT (S (NP (NP (DT A) (NN person)) (PP (IN on) (NP (DT a) (NN horse)))) (VP (VBZ jumps) (PP (IN over) (NP (DT a) (JJ broken) (JJ down) (NN airplane)))) (. .)))", "sentence2": "A person is training his horse for a competition.", "sentence2_binary_parse": "( ( A person ) ( ( is ( ( training ( his horse ) ) ( for ( a competition ) ) ) ) . ) )", "sentence2_parse": "(ROOT (S (NP (DT A) (NN person)) (VP (VBZ is) (VP (VBG training) (NP (PRP$ his) (NN horse)) (PP (IN for) (NP (DT a) (NN competition))))) (. .)))"} {"annotator_labels": ["contradiction"], "captionID": "3416050480.jpg#4", "gold_label": "contradiction", "pairID": "3416050480.jpg#4r1c", "sentence1": "A person on a horse jumps over a broken down airplane.", "sentence1_binary_parse": "( ( ( A person ) ( on ( a horse ) ) ) ( ( jumps ( over ( a ( broken ( down airplane ) ) ) ) ) . ) )", "sentence1_parse": "(ROOT (S (NP (NP (DT A) (NN person)) (PP (IN on) (NP (DT a) (NN horse)))) (VP (VBZ jumps) (PP (IN over) (NP (DT a) (JJ broken) (JJ down) (NN airplane)))) (. .)))", "sentence2": "A person is at a diner, ordering an omelette.", "sentence2_binary_parse": "( ( A person ) ( ( ( ( is ( at ( a diner ) ) ) , ) ( ordering ( an omelette ) ) ) . ) )", "sentence2_parse": "(ROOT (S (NP (DT A) (NN person)) (VP (VBZ is) (PP (IN at) (NP (DT a) (NN diner))) (, ,) (S (VP (VBG ordering) (NP (DT an) (NN omelette))))) (. .)))"} {"annotator_labels": ["entailment"], "captionID": "3416050480.jpg#4", "gold_label": "entailment", "pairID": "3416050480.jpg#4r1e", "sentence1": "A person on a horse jumps over a broken down airplane.", "sentence1_binary_parse": "( ( ( A person ) ( on ( a horse ) ) ) ( ( jumps ( over ( a ( broken ( down airplane ) ) ) ) ) . ) )", "sentence1_parse": "(ROOT (S (NP (NP (DT A) (NN person)) (PP (IN on) (NP (DT a) (NN horse)))) (VP (VBZ jumps) (PP (IN over) (NP (DT a) (JJ broken) (JJ down) (NN airplane)))) (. .)))", "sentence2": "A person is outdoors, on a horse.", "sentence2_binary_parse": "( ( A person ) ( ( ( ( is outdoors ) , ) ( on ( a horse ) ) ) . ) )", "sentence2_parse": "(ROOT (S (NP (DT A) (NN person)) (VP (VBZ is) (ADVP (RB outdoors)) (, ,) (PP (IN on) (NP (DT a) (NN horse)))) (. .)))"}读取之后的DataSet具有以下的field
raw_words0 raw_words1 target A person on a horse jumps over a broken down airplane. A person is training his horse for a competition. neutral A person on a horse jumps over a broken down airplane. A person is at a diner, ordering an omelette. contradiction A person on a horse jumps over a broken down airplane. A person is outdoors, on a horse. entailment
使用Trainer和Tester快速训练和测试¶
我们使用前面介绍过的 文本分类 任务来进行详细的介绍。这里我们把数据集换成了SST2，使用 Trainer 和 Tester 来进行快速训练和测试。
注解
本教程中的代码没有使用 GPU 。读者可以自行修改代码，扩大数据量并使用 GPU 进行训练。
数据读入和处理¶
- 数据读入
我们可以使用 fastNLP
fastNLP.io模块中的SST2Pipe类，轻松地读取以及预处理SST2数据集。SST2Pipe对象的process_from_file()方法能够对读入的SST2数据集进行数据的预处理，方法的参数为paths, 指要处理的文件所在目录，如果paths为None，则会自动下载数据集，函数默认paths值为None。 此函数返回一个DataBundle，包含SST2数据集的训练集、测试集、验证集以及source端和target端的字典。其训练、测试、验证数据集含有四个field：- raw_words: 原source句子
- target: 标签值
- words: index之后的raw_words
- seq_len: 句子长度
读入数据代码如下：
from fastNLP.io import SST2Pipe pipe = SST2Pipe() databundle = pipe.process_from_file() vocab = databundle.get_vocab('words') print(databundle) print(databundle.get_dataset('train')[0]) print(databundle.get_vocab('words'))
输出数据如下:
In total 3 datasets: test has 1821 instances. train has 67349 instances. dev has 872 instances. In total 2 vocabs: words has 16293 entries. target has 2 entries. +-------------------------------------------+--------+--------------------------------------+---------+ | raw_words | target | words | seq_len | +-------------------------------------------+--------+--------------------------------------+---------+ | hide new secretions from the parental ... | 1 | [4111, 98, 12010, 38, 2, 6844, 9042] | 7 | +-------------------------------------------+--------+--------------------------------------+---------+ Vocabulary(['hide', 'new', 'secretions', 'from', 'the']...)
除了可以对数据进行读入的Pipe类，fastNLP还提供了读入和下载数据的Loader类，不同数据集的Pipe和Loader及其用法详见 使用Loader和Pipe加载并处理数据集 。
- 数据集分割
由于SST2数据集的测试集并不带有标签数值，故我们分割出一部分训练集作为测试集。下面这段代码展示了
split()的使用方法， 为了能让读者快速运行完整个教程，我们只取了训练集的前5000个数据。train_data = databundle.get_dataset('train')[:5000] train_data, test_data = train_data.split(0.015) dev_data = databundle.get_dataset('dev') print(len(train_data),len(dev_data),len(test_data))
输出结果为:
4925 872 75
- 数据集
set_input()和set_target()函数 SST2Pipe类的process_from_file()方法在预处理过程中还将训练、测试、验证 集的 words 、seq_lenfield设定为input，同时将 targetfield设定 为target。我们可以通过Dataset类的print_field_meta()方法查看各个field的设定情况，代码如下：train_data.print_field_meta()
输出结果为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
其中is_input和is_target分别表示是否为input和target。ignore_type为true时指使用
DataSetIter取出batch数 据时fastNLP不会进行自动padding，pad_value指对应fieldpadding所用的值，这两者只有 当field设定为input或者target的时候才有存在的意义。is_input为true的
field在DataSetIter迭代取出的batch_x 中，而is_target为true 的field在DataSetIter迭代取出的 batch_y 中。 具体分析见 使用DataSetIter实现自定义训练过程 。
使用内置模型训练¶
- 模型定义和初始化
我们可以导入 fastNLP 内置的文本分类模型
CNNText来对模型进行定义，代码如下：from fastNLP.models import CNNText #词嵌入的维度 EMBED_DIM = 100 #使用CNNText的时候第一个参数输入一个tuple,作为模型定义embedding的参数 #还可以传入 kernel_nums, kernel_sizes, padding, dropout的自定义值 model_cnn = CNNText((len(vocab),EMBED_DIM), num_classes=2, dropout=0.1)
使用fastNLP快速搭建自己的模型详见 使用Modules和Models快速搭建自定义模型 。
- 评价指标
训练模型需要提供一个评价指标。这里使用准确率做为评价指标。
这里我们用
Const来辅助命名，如果你自己编写模型中 forward 方法的返回值或 数据集中field的名字与本例不同， 你可以把pred参数和target参数设定符合自己代码的值。代码如下：from fastNLP import AccuracyMetric from fastNLP import Const # metrics=AccuracyMetric() 在本例中与下面这行代码等价 metrics=AccuracyMetric(pred=Const.OUTPUT, target=Const.TARGET)
- 损失函数
训练模型需要提供一个损失函数 ,fastNLP中提供了直接可以导入使用的四种loss，分别为：
CrossEntropyLoss：包装了torch.nn.functional.cross_entropy()函数，返回交叉熵损失（可以运用于多分类场景）BCELoss：包装了torch.nn.functional.binary_cross_entropy()函数，返回二分类的交叉熵L1Loss：包装了torch.nn.functional.l1_loss()函数，返回L1 损失NLLLoss：包装了torch.nn.functional.nll_loss()函数，返回负对数似然损失
下面提供了一个在分类问题中常用的交叉熵损失。注意它的 初始化参数 。
这里我们用
Const来辅助命名，如果你自己编写模型中 forward 方法的返回值或 数据集中field的名字与本例不同， 你可以把pred参数和target参数设定符合自己代码的值。from fastNLP import CrossEntropyLoss # loss = CrossEntropyLoss() 在本例中与下面这行代码等价 loss = CrossEntropyLoss(pred=Const.OUTPUT, target=Const.TARGET)
除了使用fastNLP已经包装好的了损失函数，也可以通过fastNLP中的LossFunc类来构建自己的损失函数，方法如下：
# 这表示构建了一个损失函数类，由func计算损失函数，其中将从模型返回值或者DataSet的target=True的field # 当中找到一个参数名为`pred`的参数传入func一个参数名为`input`的参数；找到一个参数名为`label`的参数 # 传入func作为一个名为`target`的参数 #下面自己构建了一个交叉熵函数，和之后直接使用fastNLP中的交叉熵函数是一个效果 import torch from fastNLP import LossFunc func = torch.nn.functional.cross_entropy loss_func = LossFunc(func, input=Const.OUTPUT, target=Const.TARGET)
- 优化器
定义模型运行的时候使用的优化器，可以直接使用torch.optim.Optimizer中的优化器，并在实例化
Trainer类的时候传入优化器实参import torch.optim as optim #使用 torch.optim 定义优化器 optimizer=optim.RMSprop(model_cnn.parameters(), lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)
- 快速训练
现在我们对上面定义的模型使用
Trainer进行训练。 除了使用DataSetIter来编写自己的训练过程，具体见 使用DataSetIter实现自定义训练过程from fastNLP import Trainer #训练的轮数和batch size N_EPOCHS = 10 BATCH_SIZE = 16 #如果在定义trainer的时候没有传入optimizer参数，模型默认的优化器为torch.optim.Adam且learning rate为lr=4e-3 #这里只使用了loss作为损失函数输入，感兴趣可以尝试其他损失函数（如之前自定义的loss_func）作为输入 trainer = Trainer(model=model_cnn, train_data=train_data, dev_data=dev_data, loss=loss, metrics=metrics, optimizer=optimizer,n_epochs=N_EPOCHS, batch_size=BATCH_SIZE) trainer.train()
训练过程的输出如下:
input fields after batch(if batch size is 2): words: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2, 13]) seq_len: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2]) target fields after batch(if batch size is 2): target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2]) training epochs started 2020-02-26-16-45-40 Evaluate data in 0.5 seconds! Evaluation on dev at Epoch 1/10. Step:308/3080: AccuracyMetric: acc=0.677752 ...... Evaluate data in 0.44 seconds! Evaluation on dev at Epoch 10/10. Step:3080/3080: AccuracyMetric: acc=0.725917 In Epoch:5/Step:1540, got best dev performance: AccuracyMetric: acc=0.740826 Reloaded the best model.- 快速测试
与
Trainer对应，fastNLP 也提供了Tester用于快速测试，用法如下from fastNLP import Tester tester = Tester(test_data, model_cnn, metrics=AccuracyMetric()) tester.test()
训练过程输出如下:
Evaluate data in 0.43 seconds! [tester] AccuracyMetric: acc=0.773333
使用DataSetIter实现自定义训练过程¶
我们使用前面介绍过的 文本分类 任务来进行详细的介绍。这里我们把数据集换成了SST2，使用 DataSetIter 类来编写自己的训练过程。
DataSetIter初探之前的内容与 使用Trainer和Tester快速训练和测试 中的完全一样，如已经阅读过可以跳过。
注解
本教程中的代码没有使用 GPU 。读者可以自行修改代码，扩大数据量并使用 GPU 进行训练。
数据读入和预处理¶
- 数据读入
我们可以使用 fastNLP
fastNLP.io模块中的SST2Pipe类，轻松地读取以及预处理SST2数据集。SST2Pipe对象的process_from_file()方法能够对读入的SST2数据集进行数据的预处理，方法的参数为paths, 指要处理的文件所在目录，如果paths为None，则会自动下载数 据集，函数默认paths值为None。 此函数返回一个DataBundle，包含SST2数据集的训练集、测试集、验证集以及source端和target端的字典。其训练、测试、验证数据集含有四个field：- raw_words: 原source句子
- target: 标签值
- words: index之后的raw_words
- seq_len: 句子长度
读入数据代码如下：
from fastNLP.io import SST2Pipe pipe = SST2Pipe() databundle = pipe.process_from_file() vocab = databundle.vocabs['words'] print(databundle) print(databundle.datasets['train'][0]) print(databundle.vocabs['words'])
输出数据如下:
In total 3 datasets: test has 1821 instances. train has 67349 instances. dev has 872 instances. In total 2 vocabs: words has 16293 entries. target has 2 entries. +-------------------------------------------+--------+--------------------------------------+---------+ | raw_words | target | words | seq_len | +-------------------------------------------+--------+--------------------------------------+---------+ | hide new secretions from the parental ... | 1 | [4111, 98, 12010, 38, 2, 6844, 9042] | 7 | +-------------------------------------------+--------+--------------------------------------+---------+ Vocabulary(['hide', 'new', 'secretions', 'from', 'the']...)
除了可以对数据进行读入的Pipe类，fastNLP还提供了读入和下载数据的Loader类，不同数据集的Pipe和Loader及其用法详见 使用Loader和Pipe加载并处理数据集 。
- 数据集分割
由于SST2数据集的测试集并不带有标签数值，故我们分割出一部分训练集作为测试集。下面这段代码展示了
split()的使用方法， 为了能让读者快速运行完整个教程，我们只取了训练集的前5000个数据。train_data = databundle.get_dataset('train')[:5000] train_data, test_data = train_data.split(0.015) dev_data = databundle.get_dataset('dev') print(len(train_data),len(dev_data),len(test_data))
输出结果为:
4925 872 75
- 数据集
set_input()和set_target()函数 SST2Pipe类的process_from_file()方法在预处理过程中还将训练、测试、验证集 的 words 、seq_lenfield设定为input，同时将`target`field设定为target。 我们可以通过Dataset类的print_field_meta()方法查看各个field的设定情况，代码如下：train_data.print_field_meta()
输出结果为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
其中is_input和is_target分别表示是否为input和target。ignore_type为true时指使用
DataSetIter取出batch数 据时fastNLP不会进行自动padding，pad_value指对应fieldpadding所用的值，这两者只有当field设定为input或者target的时候才有存在的意义。is_input为true的
field在DataSetIter迭代取出的 batch_x 中， 而 is_target为true的field在DataSetIter迭代取出的 batch_y 中。 具体分析见下面DataSetIter的介绍过程。- 评价指标
训练模型需要提供一个评价指标。这里使用准确率做为评价指标。
这里我们用
Const来辅助命名，如果你自己编写模型中 forward 方法的返回值或 数据集中field的名字与本例不同， 你可以把pred参数和target参数设定符合自己代码的值。代码如下：from fastNLP import AccuracyMetric from fastNLP import Const # metrics=AccuracyMetric() 在本例中与下面这行代码等价 metrics=AccuracyMetric(pred=Const.OUTPUT, target=Const.TARGET)
DataSetIter初探¶
- DataSetIter
fastNLP定义的
DataSetIter类，用于定义一个batch，并实现batch的多种功能，在初始化时传入的参数有：- dataset:
DataSet对象, 数据集 - batch_size: 取出的batch大小
- sampler: 规定使用的
Sampler若为 None, 使用RandomSampler（Default: None） - as_numpy: 若为 True, 输出batch为 numpy.array. 否则为 torch.Tensor （Default: False）
- prefetch: 若为 True使用多进程预先取出下一batch. （Default: False）
- dataset:
- sampler
fastNLP 实现的采样器有：
BucketSampler可以随机地取出长度相似的元素 【初始化参数: num_buckets：bucket的数量； batch_size：batch大小； seq_len_field_name：dataset中对应序列长度的field的名字】- SequentialSampler： 顺序取出元素的采样器【无初始化参数】
- RandomSampler：随机化取元素的采样器【无初始化参数】
- Padder
- 在fastNLP里，pad是与一个
field绑定的。即不同的field可以使用不同的pad方式，比如在英文任务中word需要的pad和 character的pad方式往往是不同的。fastNLP是通过一个叫做Padder的子类来完成的。 默认情况下，所有field使用AutoPadder。大多数情况下直接使用AutoPadder就可以了。 如果AutoPadder或EngChar2DPadder无法满足需求， 也可以自己写一个Padder。 - DataSetIter自动padding
以下代码展示了DataSetIter的简单使用：
from fastNLP import BucketSampler from fastNLP import DataSetIter tmp_data = dev_data[:10] # 定义一个Batch，传入DataSet，规定batch_size和去batch的规则。 # 顺序（Sequential），随机（Random），相似长度组成一个batch（Bucket） sampler = BucketSampler(batch_size=2, seq_len_field_name='seq_len') batch = DataSetIter(batch_size=2, dataset=tmp_data, sampler=sampler) for batch_x, batch_y in batch: print("batch_x: ",batch_x) print("batch_y: ", batch_y)
输出结果如下:
batch_x: {'words': tensor([[ 13, 830, 7746, 174, 3, 47, 6, 83, 5752, 15, 2177, 15, 63, 57, 406, 84, 1009, 4973, 27, 17, 13785, 3, 533, 3687, 15623, 39, 375, 8, 15624, 8, 1323, 4398, 7], [ 1045, 11113, 16, 104, 5, 4, 176, 1824, 1704, 3, 2, 18, 11, 4, 1018, 432, 143, 33, 245, 308, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'seq_len': tensor([33, 21])} batch_y: {'target': tensor([1, 0])} batch_x: {'words': tensor([[ 14, 10, 4, 311, 5, 154, 1418, 609, 7], [ 14, 10, 437, 32, 78, 3, 78, 437, 7]]), 'seq_len': tensor([9, 9])} batch_y: {'target': tensor([0, 1])} batch_x: {'words': tensor([[ 4, 277, 685, 18, 7], [15618, 3204, 5, 1675, 0]]), 'seq_len': tensor([5, 4])} batch_y: {'target': tensor([1, 1])} batch_x: {'words': tensor([[ 2, 155, 3, 4426, 3, 239, 3, 739, 5, 1136, 41, 43, 2427, 736, 2, 648, 10, 15620, 2285, 7], [ 24, 95, 28, 46, 8, 336, 38, 239, 8, 2133, 2, 18, 10, 15622, 1421, 6, 61, 5, 387, 7]]), 'seq_len': tensor([20, 20])} batch_y: {'target': tensor([0, 0])} batch_x: {'words': tensor([[ 879, 96, 8, 1026, 12, 8067, 11, 13623, 8, 15619, 4, 673, 662, 15, 4, 1154, 240, 639, 417, 7], [ 45, 752, 327, 180, 10, 15621, 16, 72, 8904, 9, 1217, 7, 0, 0, 0, 0, 0, 0, 0, 0]]), 'seq_len': tensor([20, 12])} batch_y: {'target': tensor([0, 1])}
可以看到那些设定为input的
field都出现在batch_x中，而设定为target的field则出现在batch_y中。同时对于同一个batch_x中的两个数据，长度偏短的那个会被自动padding到和长度偏长的句子长度一致，默认的padding值为0。- Dataset改变padding值
可以通过
set_pad_val()方法修改默认的pad值，代码如下：tmp_data.set_pad_val('words',-1) batch = DataSetIter(batch_size=2, dataset=tmp_data, sampler=sampler) for batch_x, batch_y in batch: print("batch_x: ",batch_x) print("batch_y: ", batch_y)
输出结果如下:
batch_x: {'words': tensor([[ 13, 830, 7746, 174, 3, 47, 6, 83, 5752, 15, 2177, 15, 63, 57, 406, 84, 1009, 4973, 27, 17, 13785, 3, 533, 3687, 15623, 39, 375, 8, 15624, 8, 1323, 4398, 7], [ 1045, 11113, 16, 104, 5, 4, 176, 1824, 1704, 3, 2, 18, 11, 4, 1018, 432, 143, 33, 245, 308, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]]), 'seq_len': tensor([33, 21])} batch_y: {'target': tensor([1, 0])} batch_x: {'words': tensor([[ 14, 10, 4, 311, 5, 154, 1418, 609, 7], [ 14, 10, 437, 32, 78, 3, 78, 437, 7]]), 'seq_len': tensor([9, 9])} batch_y: {'target': tensor([0, 1])} batch_x: {'words': tensor([[ 2, 155, 3, 4426, 3, 239, 3, 739, 5, 1136, 41, 43, 2427, 736, 2, 648, 10, 15620, 2285, 7], [ 24, 95, 28, 46, 8, 336, 38, 239, 8, 2133, 2, 18, 10, 15622, 1421, 6, 61, 5, 387, 7]]), 'seq_len': tensor([20, 20])} batch_y: {'target': tensor([0, 0])} batch_x: {'words': tensor([[ 4, 277, 685, 18, 7], [15618, 3204, 5, 1675, -1]]), 'seq_len': tensor([5, 4])} batch_y: {'target': tensor([1, 1])} batch_x: {'words': tensor([[ 879, 96, 8, 1026, 12, 8067, 11, 13623, 8, 15619, 4, 673, 662, 15, 4, 1154, 240, 639, 417, 7], [ 45, 752, 327, 180, 10, 15621, 16, 72, 8904, 9, 1217, 7, -1, -1, -1, -1, -1, -1, -1, -1]]), 'seq_len': tensor([20, 12])} batch_y: {'target': tensor([0, 1])}
可以看到使用了-1进行padding。
- Dataset个性化padding
如果我们希望对某一些
field进行个性化padding，可以自己构造Padder类，并使用set_padder()函数修改padder来实现。下面通过构造一个将数据padding到固定长度的padder进行展示：from fastNLP.core.field import Padder import numpy as np class FixLengthPadder(Padder): def __init__(self, pad_val=0, length=None): super().__init__(pad_val=pad_val) self.length = length assert self.length is not None, "Creating FixLengthPadder with no specific length!" def __call__(self, contents, field_name, field_ele_dtype, dim): #计算当前contents中的最大长度 max_len = max(map(len, contents)) #如果当前contents中的最大长度大于指定的padder length的话就报错 assert max_len <= self.length, "Fixed padder length smaller than actual length! with length {}".format(max_len) array = np.full((len(contents), self.length), self.pad_val, dtype=field_ele_dtype) for i, content_i in enumerate(contents): array[i, :len(content_i)] = content_i return array #设定FixLengthPadder的固定长度为40 tmp_padder = FixLengthPadder(pad_val=0,length=40) #利用dataset的set_padder函数设定words field的padder tmp_data.set_padder('words',tmp_padder) batch = DataSetIter(batch_size=2, dataset=tmp_data, sampler=sampler) for batch_x, batch_y in batch: print("batch_x: ",batch_x) print("batch_y: ", batch_y)
输出结果如下:
batch_x: {'words': tensor([[ 45, 752, 327, 180, 10, 15621, 16, 72, 8904, 9, 1217, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 879, 96, 8, 1026, 12, 8067, 11, 13623, 8, 15619, 4, 673, 662, 15, 4, 1154, 240, 639, 417, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'seq_len': tensor([12, 20])} batch_y: {'target': tensor([1, 0])} batch_x: {'words': tensor([[ 13, 830, 7746, 174, 3, 47, 6, 83, 5752, 15, 2177, 15, 63, 57, 406, 84, 1009, 4973, 27, 17, 13785, 3, 533, 3687, 15623, 39, 375, 8, 15624, 8, 1323, 4398, 7, 0, 0, 0, 0, 0, 0, 0], [ 1045, 11113, 16, 104, 5, 4, 176, 1824, 1704, 3, 2, 18, 11, 4, 1018, 432, 143, 33, 245, 308, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'seq_len': tensor([33, 21])} batch_y: {'target': tensor([1, 0])} batch_x: {'words': tensor([[ 14, 10, 4, 311, 5, 154, 1418, 609, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 14, 10, 437, 32, 78, 3, 78, 437, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'seq_len': tensor([9, 9])} batch_y: {'target': tensor([0, 1])} batch_x: {'words': tensor([[ 2, 155, 3, 4426, 3, 239, 3, 739, 5, 1136, 41, 43, 2427, 736, 2, 648, 10, 15620, 2285, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 24, 95, 28, 46, 8, 336, 38, 239, 8, 2133, 2, 18, 10, 15622, 1421, 6, 61, 5, 387, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'seq_len': tensor([20, 20])} batch_y: {'target': tensor([0, 0])} batch_x: {'words': tensor([[ 4, 277, 685, 18, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [15618, 3204, 5, 1675, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'seq_len': tensor([5, 4])} batch_y: {'target': tensor([1, 1])}
在这里所有的 words 都被pad成了长度为40的list。
使用DataSetIter自己编写训练过程¶
如果你想用类似 PyTorch 的使用方法，自己编写训练过程，可以参考下面这段代码。 其中使用了 fastNLP 提供的
DataSetIter来获得小批量训练的小批量数据， 使用BucketSampler做为DataSetIter的参数来选择采样的方式。以下代码使用BucketSampler作为
DataSetIter初始化的输入，运用DataSetIter自己写训练程序from fastNLP import BucketSampler from fastNLP import DataSetIter from fastNLP.models import CNNText from fastNLP import Tester import torch import time embed_dim = 100 model = CNNText((len(vocab),embed_dim), num_classes=2, dropout=0.1) def train(epoch, data, devdata): optimizer = torch.optim.Adam(model.parameters(), lr=0.001) lossfunc = torch.nn.CrossEntropyLoss() batch_size = 32 # 定义一个Batch，传入DataSet，规定batch_size和去batch的规则。 # 顺序（Sequential），随机（Random），相似长度组成一个batch（Bucket） train_sampler = BucketSampler(batch_size=batch_size, seq_len_field_name='seq_len') train_batch = DataSetIter(batch_size=batch_size, dataset=data, sampler=train_sampler) start_time = time.time() print("-"*5+"start training"+"-"*5) for i in range(epoch): loss_list = [] for batch_x, batch_y in train_batch: optimizer.zero_grad() output = model(batch_x['words']) loss = lossfunc(output['pred'], batch_y['target']) loss.backward() optimizer.step() loss_list.append(loss.item()) #这里verbose如果为0，在调用Tester对象的test()函数时不输出任何信息，返回评估信息; 如果为1，打印出验证结果，返回评估信息 #在调用过Tester对象的test()函数后，调用其_format_eval_results(res)函数，结构化输出验证结果 tester_tmp = Tester(devdata, model, metrics=AccuracyMetric(), verbose=0) res=tester_tmp.test() print('Epoch {:d} Avg Loss: {:.2f}'.format(i, sum(loss_list) / len(loss_list)),end=" ") print(tester_tmp._format_eval_results(res),end=" ") print('{:d}ms'.format(round((time.time()-start_time)*1000))) loss_list.clear() train(10, train_data, dev_data) #使用tester进行快速测试 tester = Tester(test_data, model, metrics=AccuracyMetric()) tester.test()这段代码的输出如下:
-----start training----- Evaluate data in 2.68 seconds! Epoch 0 Avg Loss: 0.66 AccuracyMetric: acc=0.708716 29307ms Evaluate data in 0.38 seconds! Epoch 1 Avg Loss: 0.41 AccuracyMetric: acc=0.770642 52200ms Evaluate data in 0.51 seconds! Epoch 2 Avg Loss: 0.16 AccuracyMetric: acc=0.747706 70268ms Evaluate data in 0.96 seconds! Epoch 3 Avg Loss: 0.06 AccuracyMetric: acc=0.741972 90349ms Evaluate data in 1.04 seconds! Epoch 4 Avg Loss: 0.03 AccuracyMetric: acc=0.740826 114250ms Evaluate data in 0.8 seconds! Epoch 5 Avg Loss: 0.02 AccuracyMetric: acc=0.738532 134742ms Evaluate data in 0.65 seconds! Epoch 6 Avg Loss: 0.01 AccuracyMetric: acc=0.731651 154503ms Evaluate data in 0.8 seconds! Epoch 7 Avg Loss: 0.01 AccuracyMetric: acc=0.738532 175397ms Evaluate data in 0.36 seconds! Epoch 8 Avg Loss: 0.01 AccuracyMetric: acc=0.733945 192384ms Evaluate data in 0.84 seconds! Epoch 9 Avg Loss: 0.01 AccuracyMetric: acc=0.744266 214417ms Evaluate data in 0.04 seconds! [tester] AccuracyMetric: acc=0.786667
使用Metric快速评测你的模型¶
在进行训练时，fastNLP提供了各种各样的 metrics 。
如前面的教程中所介绍，AccuracyMetric 类的对象被直接传到 Trainer 中用于训练
trainer = Trainer(train_data=train_data, dev_data=dev_data, model=model,
loss=loss, device=device, metrics=metric)
trainer.train()
除了 AccuracyMetric 之外，SpanFPreRecMetric 也是一种非常见的评价指标，
例如在序列标注问题中，常以span的方式计算 F-measure, precision, recall。
另外，fastNLP 还实现了用于抽取式QA（如SQuAD）的metric ExtractiveQAMetric。
用户可以参考下面这个表格，点击第一列查看各个 metrics 的详细文档。
| 名称 | 介绍 |
|---|---|
MetricBase |
自定义metrics需继承的基类 |
AccuracyMetric |
简单的正确率metric |
SpanFPreRecMetric |
同时计算 F-measure, precision, recall 值的 metric |
ExtractiveQAMetric |
用于抽取式QA任务 的metric |
更多的 metrics 正在被添加到 fastNLP 当中，敬请期待。
定义自己的metrics¶
在定义自己的metrics类时需继承 fastNLP 的 MetricBase,
并覆盖写入 evaluate 和 get_metric 方法。
evaluate(xxx) 中传入一个批次的数据，将针对一个批次的预测结果做评价指标的累计
get_metric(xxx) 当所有数据处理完毕时调用该方法，它将根据 evaluate函数累计的评价指标统计量来计算最终的评价结果
以分类问题中，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中 target 这个 field 是需要预测的值，并且该 field 被设置为了 target 对应的 AccMetric 可以按如下的定义( Version 1, 只使用这一次):
from fastNLP import MetricBase
class AccMetric(MetricBase):
def __init__(self):
super().__init__()
# 根据你的情况自定义指标
self.total = 0
self.acc_count = 0
# evaluate的参数需要和DataSet 中 field 名以及模型输出的结果 field 名一致，不然找不到对应的value
# pred, target 的参数是 fastNLP 的默认配置
def evaluate(self, pred, target):
# dev或test时，每个batch结束会调用一次该方法，需要实现如何根据每个batch累加metric
self.total += target.size(0)
self.acc_count += target.eq(pred).sum().item()
def get_metric(self, reset=True): # 在这里定义如何计算metric
acc = self.acc_count/self.total
if reset: # 是否清零以便重新计算
self.acc_count = 0
self.total = 0
return {'acc': acc}
# 需要返回一个dict，key为该metric的名称，该名称会显示到Trainer的progress bar中
如果需要复用 metric，比如下一次使用 AccMetric 时，dataset中目标field不叫 target 而叫 y ，或者model的输出不是 pred (Version 2):
class AccMetric(MetricBase):
def __init__(self, pred=None, target=None):
"""
假设在另一场景使用时，目标field叫y，model给出的key为pred_y。则只需要在初始化AccMetric时，
acc_metric = AccMetric(pred='pred_y', target='y')即可。
当初始化为acc_metric = AccMetric() 时，fastNLP会直接使用 'pred', 'target' 作为key去索取对应的的值
"""
super().__init__()
# 如果没有注册该则效果与 Version 1 就是一样的
self._init_param_map(pred=pred, target=target) # 该方法会注册 pred 和 target . 仅需要注册evaluate()方法会用到的参数名即可
# 根据你的情况自定义指标
self.total = 0
self.acc_count = 0
# evaluate的参数需要和DataSet 中 field 名以及模型输出的结果 field 名一致，不然找不到对应的value
# pred, target 的参数是 fastNLP 的默认配置
def evaluate(self, pred, target):
# dev或test时，每个batch结束会调用一次该方法，需要实现如何根据每个batch累加metric
self.total += target.size(0)
self.acc_count += target.eq(pred).sum().item()
def get_metric(self, reset=True): # 在这里定义如何计算metric
acc = self.acc_count/self.total
if reset: # 是否清零以便重新计算
self.acc_count = 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是指标的值
使用Modules和Models快速搭建自定义模型¶
modules 和 models 用于构建 fastNLP 所需的神经网络模型，它可以和 torch.nn 中的模型一起使用。
下面我们会分三节介绍编写构建模型的具体方法。
使用 models 中的模型¶
fastNLP 在 models 模块中内置了如 CNNText 、
SeqLabeling 等完整的模型，以供用户直接使用。
以文本分类的任务为例，我们从 models 中导入 CNNText 模型，用它进行训练。
from fastNLP.models import CNNText
model_cnn = CNNText((len(vocab),100), num_classes=2, dropout=0.1)
trainer = Trainer(train_data=train_data, dev_data=dev_data, metrics=metric,
loss=loss, device=device, model=model_cnn)
trainer.train()
在 iPython 环境输入 model_cnn ，我们可以看到 model_cnn 的网络结构
CNNText(
(embed): Embedding(
(embed): Embedding(16292, 100)
(dropout): Dropout(p=0.0, inplace=False)
)
(conv_pool): ConvMaxpool(
(convs): ModuleList(
(0): Conv1d(100, 30, kernel_size=(1,), stride=(1,), bias=False)
(1): Conv1d(100, 40, kernel_size=(3,), stride=(1,), padding=(1,), bias=False)
(2): Conv1d(100, 50, kernel_size=(5,), stride=(1,), padding=(2,), bias=False)
)
)
(dropout): Dropout(p=0.1, inplace=False)
(fc): Linear(in_features=120, out_features=2, bias=True)
)
FastNLP 中内置的 models 如下表所示，您可以点击具体的名称查看详细的 API：
| 名称 | 介绍 |
|---|---|
CNNText |
使用 CNN 进行文本分类的模型 |
SeqLabeling |
简单的序列标注模型 |
AdvSeqLabel |
更大网络结构的序列标注模型 |
ESIM |
ESIM 模型的实现 |
StarTransEnc |
带 word-embedding的Star-Transformer模 型 |
STSeqLabel |
用于序列标注的 Star-Transformer 模型 |
STNLICls |
用于自然语言推断 (NLI) 的 Star-Transformer 模型 |
STSeqCls |
用于分类任务的 Star-Transformer 模型 |
BiaffineParser |
Biaffine 依存句法分析网络的实现 |
BiLSTMCRF |
使用BiLSTM与CRF进行序列标注 |
使用 nn.torch 编写模型¶
FastNLP 完全支持使用 pyTorch 编写的模型，但与 pyTorch 中编写模型的常见方法不同，
用于 fastNLP 的模型中 forward 函数需要返回一个字典，字典中至少需要包含 pred 这个字段。
下面是使用 pyTorch 中的 torch.nn 模块编写的文本分类，注意观察代码中标注的向量维度。 由于 pyTorch 使用了约定俗成的维度设置，使得 forward 中需要多次处理维度顺序
import torch
import torch.nn as nn
class LSTMText(nn.Module):
def __init__(self, vocab_size, embedding_dim, output_dim, hidden_dim=64, num_layers=2, dropout=0.5):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, bidirectional=True, dropout=dropout)
self.fc = nn.Linear(hidden_dim * 2, output_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, words):
# (input) words : (batch_size, seq_len)
words = words.permute(1,0)
# words : (seq_len, batch_size)
embedded = self.dropout(self.embedding(words))
# embedded : (seq_len, batch_size, embedding_dim)
output, (hidden, cell) = self.lstm(embedded)
# output: (seq_len, batch_size, hidden_dim * 2)
# hidden: (num_layers * 2, batch_size, hidden_dim)
# cell: (num_layers * 2, batch_size, hidden_dim)
hidden = torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1)
hidden = self.dropout(hidden)
# hidden: (batch_size, hidden_dim * 2)
pred = self.fc(hidden.squeeze(0))
# result: (batch_size, output_dim)
return {"pred":pred}
我们同样可以在 iPython 环境中查看这个模型的网络结构
LSTMText(
(embedding): Embedding(16292, 100)
(lstm): LSTM(100, 64, num_layers=2, dropout=0.5, bidirectional=True)
(fc): Linear(in_features=128, out_features=2, bias=True)
(dropout): Dropout(p=0.5, inplace=False)
)
使用 modules 编写模型¶
下面我们使用 fastNLP.modules 中的组件来构建同样的网络。由于 fastNLP 统一把 batch_size 放在第一维，
在编写代码的过程中会有一定的便利。
from fastNLP.modules import Embedding, LSTM, MLP
class MyText(nn.Module):
def __init__(self, vocab_size, embedding_dim, output_dim, hidden_dim=64, num_layers=2, dropout=0.5):
super().__init__()
self.embedding = Embedding((vocab_size, embedding_dim))
self.lstm = LSTM(embedding_dim, hidden_dim, num_layers=num_layers, bidirectional=True)
self.mlp = MLP([hidden_dim*2,output_dim], dropout=dropout)
def forward(self, words):
embedded = self.embedding(words)
_,(hidden,_) = self.lstm(embedded)
pred = self.mlp(torch.cat((hidden[-1],hidden[-2]),dim=1))
return {"pred":pred}
我们自己编写模型的网络结构如下
MyText(
(embedding): Embedding(
(embed): Embedding(16292, 100)
(dropout): Dropout(p=0.0, inplace=False)
)
(lstm): LSTM(
(lstm): LSTM(100, 64, num_layers=2, batch_first=True, bidirectional=True)
)
(mlp): MLP(
(hiddens): ModuleList()
(output): Linear(in_features=128, out_features=2, bias=True)
(dropout): Dropout(p=0.5, inplace=False)
)
)
FastNLP 中包含的各种模块如下表，您可以点击具体的名称查看详细的 API，也可以通过 fastNLP.modules 进行了解。
| 名称 | 介绍 | |
|---|---|---|
ConvolutionCharEncoder |
char级别的卷积 encoder | |
LSTMCharEncoder |
char级别基于LSTM的 encoder | |
ConvMaxpool |
结合了Convolution和Max-Pooling于一体的模块 | |
LSTM |
LSTM模块 | 轻量封装了PyTorch的LSTM |
StarTransformer |
Star-Transformer 的encoder部分 | |
TransformerEncoder |
Transformer的encoder模块，不包含embedding层 | |
VarRNN |
Variational Dropout RNN 模块 | |
VarLSTM |
Variational Dropout LSTM 模块 | |
VarGRU |
Variational Dropout GRU 模块 | |
MaxPool |
Max-pooling模块 | |
MaxPoolWithMask |
带mask矩阵的max pooling。在做 max-pooling的时候不会考虑mask值为0的位置。 | |
AvgPool |
Average-pooling模块 | |
AvgPoolWithMask |
带mask矩阵的average pooling。在做 average-pooling的时候不会考虑mask值为0的位置。 | |
MultiHeadAttention |
MultiHead Attention 模块 | |
MLP |
简单的多层感知器模块 | |
ConditionalRandomField |
条件随机场模块 | |
viterbi_decode |
给定一个特征矩阵以及转移分数矩阵，计算出最佳的路径以及对应的分数 （与 ConditionalRandomField 配合使用） |
|
allowed_transitions |
给定一个id到label的映射表，返回所有可以跳转的列表（与 ConditionalRandomField 配合使用） |
|
TimestepDropout |
简单包装过的Dropout 组件 |
使用 Callback 自定义你的训练过程¶
什么是Callback¶
Callback 是与 Trainer 紧密结合的模块，利用 Callback 可以在 Trainer 训练时，加入自定义的操作，比如梯度裁剪，学习率调节，测试模型的性能等。定义的 Callback 会在训练的特定阶段被调用。
fastNLP 中提供了很多常用的 Callback ，开箱即用。
使用 Callback¶
使用 Callback 很简单，将需要的 callback 按 list 存储，以对应参数 callbacks 传入对应的 Trainer。Trainer 在训练时就会自动执行这些 Callback 指定的操作了。
from fastNLP import (Callback, EarlyStopCallback,
Trainer, CrossEntropyLoss, AccuracyMetric)
from fastNLP.models import CNNText
import torch.cuda
# prepare data
def get_data():
from fastNLP.io import ChnSentiCorpPipe as pipe
data = pipe().process_from_file()
print(data)
data.rename_field('chars', 'words')
train_data = data.get_dataset('train')
dev_data = data.get_dataset('dev')
test_data = data.get_dataset('test')
vocab = data.get_vocab('words')
tgt_vocab = data.get_vocab('target')
return train_data, dev_data, test_data, vocab, tgt_vocab
# prepare model
train_data, dev_data, _, vocab, tgt_vocab = get_data()
device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
model = CNNText((len(vocab),50), num_classes=len(tgt_vocab))
# define callback
callbacks=[EarlyStopCallback(5)]
# pass callbacks to Trainer
def train_with_callback(cb_list):
trainer = Trainer(
device=device,
n_epochs=3,
model=model,
train_data=train_data,
dev_data=dev_data,
loss=CrossEntropyLoss(),
metrics=AccuracyMetric(),
callbacks=cb_list,
check_code_level=-1
)
trainer.train()
train_with_callback(callbacks)
fastNLP 中的 Callback¶
fastNLP 中提供了很多常用的 Callback，如梯度裁剪，训练时早停和测试验证集，fitlog 等等。具体 Callback 请参考 fastNLP.core.callback
from fastNLP import EarlyStopCallback, GradientClipCallback, EvaluateCallback
callbacks = [
EarlyStopCallback(5),
GradientClipCallback(clip_value=5, clip_type='value'),
EvaluateCallback(dev_data)
]
train_with_callback(callbacks)
自定义 Callback¶
这里我们以一个简单的 Callback作为例子，它的作用是打印每一个 Epoch 平均训练 loss。
创建 Callback
要自定义 Callback，我们要实现一个类，继承
Callback。这里我们定义MyCallBack，继承 fastNLP.Callback 。指定 Callback 调用的阶段
Callback 中所有以 on_ 开头的类方法会在 Trainer 的训练中在特定阶段调用。 如 on_train_begin() 会在训练开始时被调用，on_epoch_end() 会在每个 epoch 结束时调用。 具体有哪些类方法，参见
Callback文档。这里， MyCallBack 在求得loss时调用 on_backward_begin() 记录 当前 loss，在每一个 epoch 结束时调用 on_epoch_end() ，求当前 epoch 平均loss并输出。使用 Callback 的属性访问 Trainer 的内部信息
from fastNLP import Callback
from fastNLP import logger
class MyCallBack(Callback):
"""Print average loss in each epoch"""
def __init__(self):
super().__init__()
self.total_loss = 0
self.start_step = 0
def on_backward_begin(self, loss):
self.total_loss += loss.item()
def on_epoch_end(self):
n_steps = self.step - self.start_step
avg_loss = self.total_loss / n_steps
logger.info('Avg loss at epoch %d, %.6f', self.epoch, avg_loss)
self.start_step = self.step
callbacks = [MyCallBack()]
train_with_callback(callbacks)
BertEmbedding的各种用法¶
Bert自从在 BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding 中被提出后，因其性能卓越受到了极大的关注，在这里我们展示一下在fastNLP中如何使用Bert进行各类任务。其中中文Bert我们使用的模型的权重来自于 中文Bert预训练 。
为了方便大家的使用，fastNLP提供了预训练的Embedding权重及数据集的自动下载，支持自动下载的Embedding和数据集见 数据集 。或您可从 使用Embedding模块将文本转成向量 与 使用Loader和Pipe加载并处理数据集 了解更多相关信息。
中文任务¶
下面我们将介绍通过使用Bert来进行文本分类, 中文命名实体识别, 文本匹配, 中文问答。
注解
本教程必须使用 GPU 进行实验，并且会花费大量的时间
1. 使用Bert进行文本分类¶
文本分类是指给定一段文字，判定其所属的类别。例如下面的文本情感分类
1, 商务大床房，房间很大，床有2M宽，整体感觉经济实惠不错!
这里我们使用fastNLP提供自动下载的微博分类进行测试
from fastNLP.io import WeiboSenti100kPipe
from fastNLP.embeddings import BertEmbedding
from fastNLP.models import BertForSequenceClassification
from fastNLP import Trainer, CrossEntropyLoss, AccuracyMetric, Adam
import torch
data_bundle =WeiboSenti100kPipe().process_from_file()
data_bundle.rename_field('chars', 'words')
# 载入BertEmbedding
embed = BertEmbedding(data_bundle.get_vocab('words'), model_dir_or_name='cn-wwm', include_cls_sep=True)
# 载入模型
model = BertForSequenceClassification(embed, len(data_bundle.get_vocab('target')))
# 训练模型
device = 0 if torch.cuda.is_available() else 'cpu'
trainer = Trainer(data_bundle.get_dataset('train'), model,
optimizer=Adam(model_params=model.parameters(), lr=2e-5),
loss=CrossEntropyLoss(), device=device,
batch_size=8, dev_data=data_bundle.get_dataset('dev'),
metrics=AccuracyMetric(), n_epochs=2, print_every=1)
trainer.train()
# 测试结果
from fastNLP import Tester
tester = Tester(data_bundle.get_dataset('test'), model, batch_size=128, metrics=AccuracyMetric())
tester.test()
输出结果:
In Epoch:1/Step:12499, got best dev performance:
AccuracyMetric: acc=0.9838
Reloaded the best model.
Evaluate data in 63.84 seconds!
[tester]
AccuracyMetric: acc=0.9815
2. 使用Bert进行命名实体识别¶
命名实体识别是给定一句话，标记出其中的实体。一般序列标注的任务都使用conll格式，conll格式是至一行中通过制表符分隔不同的内容，使用空行分隔 两句话，例如下面的例子
中 B-ORG
共 I-ORG
中 I-ORG
央 I-ORG
致 O
中 B-ORG
国 I-ORG
致 I-ORG
公 I-ORG
党 I-ORG
十 I-ORG
一 I-ORG
大 I-ORG
的 O
贺 O
词 O
这部分内容请参考 序列标注
3. 使用Bert进行文本匹配¶
文本匹配任务是指给定两句话判断他们的关系。比如，给定两句话判断前一句是否和后一句具有因果关系或是否是矛盾关系；或者给定两句话判断两句话是否 具有相同的意思。这里我们使用
from fastNLP.io import CNXNLIBertPipe
from fastNLP.embeddings import BertEmbedding
from fastNLP.models import BertForSentenceMatching
from fastNLP import Trainer, CrossEntropyLoss, AccuracyMetric, Adam
from fastNLP.core.optimizer import AdamW
from fastNLP.core.callback import WarmupCallback
from fastNLP import Tester
import torch
data_bundle = CNXNLIBertPipe().process_from_file()
data_bundle.rename_field('chars', 'words')
print(data_bundle)
# 载入BertEmbedding
embed = BertEmbedding(data_bundle.get_vocab('words'), model_dir_or_name='cn-wwm', include_cls_sep=True)
# 载入模型
model = BertForSentenceMatching(embed, len(data_bundle.get_vocab('target')))
# 训练模型
callbacks = [WarmupCallback(warmup=0.1, schedule='linear'), ]
device = 0 if torch.cuda.is_available() else 'cpu'
trainer = Trainer(data_bundle.get_dataset('train'), model,
optimizer=AdamW(params=model.parameters(), lr=4e-5),
loss=CrossEntropyLoss(), device=device,
batch_size=8, dev_data=data_bundle.get_dataset('dev'),
metrics=AccuracyMetric(), n_epochs=5, print_every=1,
update_every=8, callbacks=callbacks)
trainer.train()
tester = Tester(data_bundle.get_dataset('test'), model, batch_size=8, metrics=AccuracyMetric())
tester.test()
运行结果:
In Epoch:3/Step:73632, got best dev performance:
AccuracyMetric: acc=0.781928
Reloaded the best model.
Evaluate data in 18.54 seconds!
[tester]
AccuracyMetric: acc=0.783633
4. 使用Bert进行中文问答¶
问答任务是给定一段内容，以及一个问题，需要从这段内容中找到答案。 例如:
"context": "锣鼓经是大陆传统器乐及戏曲里面常用的打击乐记谱方法，以中文字的声音模拟敲击乐的声音，纪录打击乐的各种不同的演奏方法。常
用的节奏型称为「锣鼓点」。而锣鼓是戏曲节奏的支柱，除了加强演员身段动作的节奏感，也作为音乐的引子和尾声，提示音乐的板式和速度，以及
作为唱腔和念白的伴奏，令诗句的韵律更加抑扬顿锉，段落分明。锣鼓的运用有约定俗成的程式，依照角色行当的身份、性格、情绪以及环境，配合
相应的锣鼓点。锣鼓亦可以模仿大自然的音响效果，如雷电、波浪等等。戏曲锣鼓所运用的敲击乐器主要分为鼓、锣、钹和板四类型：鼓类包括有单
皮鼓（板鼓）、大鼓、大堂鼓(唐鼓)、小堂鼓、怀鼓、花盆鼓等；锣类有大锣、小锣(手锣)、钲锣、筛锣、马锣、镗锣、云锣；钹类有铙钹、大
钹、小钹、水钹、齐钹、镲钹、铰子、碰钟等；打拍子用的檀板、木鱼、梆子等。因为京剧的锣鼓通常由四位乐师负责，又称为四大件，领奏的师
傅称为：「鼓佬」，其职责有如西方乐队的指挥，负责控制速度以及利用各种手势提示乐师演奏不同的锣鼓点。粤剧吸收了部份京剧的锣鼓，但以木鱼
和沙的代替了京剧的板和鼓，作为打拍子的主要乐器。以下是京剧、昆剧和粤剧锣鼓中乐器对应的口诀用字：",
"question": "锣鼓经是什么？",
"answers": [
{
"text": "大陆传统器乐及戏曲里面常用的打击乐记谱方法",
"answer_start": 4
},
{
"text": "大陆传统器乐及戏曲里面常用的打击乐记谱方法",
"answer_start": 4
},
{
"text": "大陆传统器乐及戏曲里面常用的打击乐记谱方法",
"answer_start": 4
}
]
您可以通过以下的代码训练 (原文代码：CMRC2018)
from fastNLP.embeddings import BertEmbedding
from fastNLP.models import BertForQuestionAnswering
from fastNLP.core.losses import CMRC2018Loss
from fastNLP.core.metrics import CMRC2018Metric
from fastNLP.io.pipe.qa import CMRC2018BertPipe
from fastNLP import Trainer, BucketSampler
from fastNLP import WarmupCallback, GradientClipCallback
from fastNLP.core.optimizer import AdamW
import torch
data_bundle = CMRC2018BertPipe().process_from_file()
data_bundle.rename_field('chars', 'words')
print(data_bundle)
embed = BertEmbedding(data_bundle.get_vocab('words'), model_dir_or_name='cn', requires_grad=True, include_cls_sep=False, auto_truncate=True,
dropout=0.5, word_dropout=0.01)
model = BertForQuestionAnswering(embed)
loss = CMRC2018Loss()
metric = CMRC2018Metric()
wm_callback = WarmupCallback(schedule='linear')
gc_callback = GradientClipCallback(clip_value=1, clip_type='norm')
callbacks = [wm_callback, gc_callback]
optimizer = AdamW(model.parameters(), lr=5e-5)
device = 0 if torch.cuda.is_available() else 'cpu'
trainer = Trainer(data_bundle.get_dataset('train'), model, loss=loss, optimizer=optimizer,
sampler=BucketSampler(seq_len_field_name='context_len'),
dev_data=data_bundle.get_dataset('dev'), metrics=metric,
callbacks=callbacks, device=device, batch_size=6, num_workers=2, n_epochs=2, print_every=1,
test_use_tqdm=False, update_every=10)
trainer.train(load_best_model=False)
训练结果(和原论文中报道的基本一致):
In Epoch:2/Step:1692, got best dev performance:
CMRC2018Metric: f1=85.61, em=66.08
使用fitlog 辅助 fastNLP 进行科研¶
本文介绍结合使用 fastNLP 和 fitlog 进行科研的方法。
首先，我们需要安装 fitlog 。你需要确认你的电脑中没有其它名为 fitlog 的命令。
我们从命令行中进入到一个文件夹，现在我们要在文件夹中创建我们的 fastNLP 项目。你可以在命令行输入 fitlog init test1 ， 然后你会看到如下提示:
Initialized empty Git repository in /Users/fdujyn/workspaces/test1/.git/
Auto commit by fitlog
Initialized empty Git repository in /Users/fdujyn/workspaces/test1/.git/
Fitlog project test1 is initialized.
这表明你已经创建成功了项目文件夹，并且在项目文件夹中已经初始化了 Git。如果你不想初始化 Git， 可以参考文档 命令行工具
现在我们进入你创建的项目文件夹 test1 中，可以看到有一个名为 logs 的文件夹，后面我们将会在里面存放你的实验记录。 同时也有一个名为 main.py 的文件，这是我们推荐你使用的训练入口文件。文件的内容如下:
import fitlog
fitlog.commit(__file__) # auto commit your codes
fitlog.add_hyper_in_file (__file__) # record your hyperparameters
"""
Your training code here, you may use these functions to log your result:
fitlog.add_hyper()
fitlog.add_loss()
fitlog.add_metric()
fitlog.add_best_metric()
......
"""
fitlog.finish() # finish the logging
我们推荐你保留除注释外的四行代码，它们有助于你的实验， 他们的具体用处参见文档 用户 API
我们假定你要进行前两个教程中的实验，并已经把数据复制到了项目根目录下的 tutorial_sample_dataset.csv 文件中。
现在我们编写如下的训练代码，使用 FitlogCallback 进行实验记录保存:
import fitlog
from fastNLP import Vocabulary, Trainer, CrossEntropyLoss, AccuracyMetric
from fastNLP.io import CSVLoader
from fastNLP.models import CNNText
from fastNLP.core.callback import FitlogCallback
fitlog.commit(__file__) # auto commit your codes
fitlog.add_hyper_in_file (__file__) # record your hyperparameters
############hyper
word_embed = 50
dropout = 0.1
############hyper
loader = CSVLoader(headers=('raw_sentence', 'label'), sep='\t')
dataset = loader.load("tutorial_sample_dataset.csv")
dataset.apply(lambda x: x['raw_sentence'].lower(), new_field_name='sentence')
dataset.apply(lambda x: x['sentence'].split(), new_field_name='words', is_input=True)
dataset.apply(lambda x: int(x['label']), new_field_name='target', is_target=True)
vocab = Vocabulary(min_freq=2).from_dataset(dataset, field_name='words')
vocab.index_dataset(dataset, field_name='words',new_field_name='words')
model = CNNText((len(vocab),word_embed), num_classes=5, padding=2, dropout=dropout)
train_dev_data, test_data = dataset.split(0.1)
train_data, dev_data = train_dev_data.split(0.1)
trainer = Trainer(model=model, train_data=train_data, dev_data=dev_data,
loss=CrossEntropyLoss(), metrics=AccuracyMetric(),
callbacks=[FitlogCallback(test_data)])
trainer.train()
fitlog.finish() # finish the logging
用命令行在项目目录下执行 python main.py 之后，输出结果如下:
Auto commit by fitlog
input fields after batch(if batch size is 2):
words: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2, 11])
target fields after batch(if batch size is 2):
target: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
training epochs started 2019-05-23-21-11-51
Evaluation at Epoch 1/10. Step:2/20. AccuracyMetric: acc=0.285714
Evaluation at Epoch 2/10. Step:4/20. AccuracyMetric: acc=0.285714
Evaluation at Epoch 3/10. Step:6/20. AccuracyMetric: acc=0.285714
Evaluation at Epoch 4/10. Step:8/20. AccuracyMetric: acc=0.428571
Evaluation at Epoch 5/10. Step:10/20. AccuracyMetric: acc=0.571429
Evaluation at Epoch 6/10. Step:12/20. AccuracyMetric: acc=0.571429
Evaluation at Epoch 7/10. Step:14/20. AccuracyMetric: acc=0.285714
Evaluation at Epoch 8/10. Step:16/20. AccuracyMetric: acc=0.142857
Evaluation at Epoch 9/10. Step:18/20. AccuracyMetric: acc=0.285714
Evaluation at Epoch 10/10. Step:20/20. AccuracyMetric: acc=0.571429
In Epoch:5/Step:10, got best dev performance:AccuracyMetric: acc=0.571429
Reloaded the best model.
现在，我们在项目目录下输入 fitlog log logs ，命令行会启动一个网页，默认 url 为 0.0.0.0:5000 。
我们在浏览器中打开网页，可以看到如下的统计表格:
如果我们点击action中的最后一个键钮，可以看到详细的 loss 图:
更多的教程还在编写中，敬请期待~
API 文档¶
除了用户手册之外，你还可以通过查阅 API 文档来找到你所需要的工具。
fastNLP¶
fastNLP 由 core 、 io 、embeddings 、 modules、
models 等子模块组成，你可以查看每个模块的文档。
core是fastNLP 的核心模块，包括 DataSet、 Trainer、 Tester 等组件。详见文档fastNLP.coreio是实现输入输出的模块，包括了数据集的读取，模型的存取等功能。详见文档fastNLP.ioembeddings提供用于构建复杂网络模型所需的各种embedding。详见文档fastNLP.embeddingsmodules包含了用于搭建神经网络模型的诸多组件，可以帮助用户快速搭建自己所需的网络。详见文档fastNLP.modulesmodels包含了一些使用 fastNLP 实现的完整网络模型，包括CNNText、SeqLabeling等常见模型。详见文档fastNLP.models
fastNLP 中最常用的组件可以直接从 fastNLP 包中 import ，他们的文档如下：
-
class
fastNLP.Instance(**fields)[源代码]¶ 别名
fastNLP.InstancefastNLP.core.instance.InstanceInstance是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, collate_fn=None)[源代码]¶ 基类
fastNLP.BatchIter别名
fastNLP.DataSetIterfastNLP.core.batch.DataSetIterDataSetIter 用于从 DataSet 中按一定的顺序, 依次按
batch_size的大小将数据取出， 组成 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, collate_fn=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。
- collate_fn -- 用于将样本组合成batch的函数
- dataset --
-
get_batch_indices()¶ 获取当前已经输出的batch的index。
返回:
-
static
get_num_batches(num_samples, batch_size, drop_last)¶ 计算batch的数量。
参数: - num_samples (int) --
- batch_size (int) --
- drop_last (bool) -- 如果最后一个batch没有batch_size这么多，是否就丢掉。
返回:
-
-
class
fastNLP.TorchLoaderIter(dataset, batch_size=1, sampler=None, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, collate_fn=None)[源代码]¶ 基类
fastNLP.BatchIter别名
fastNLP.TorchLoaderIterfastNLP.core.batch.TorchLoaderIter与DataSetIter类似，但用于pytorch的DataSet对象。 通过使用TorchLoaderIter封装pytorch的DataSet，然后将其传入到Trainer中。-
__init__(dataset, batch_size=1, sampler=None, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, collate_fn=None)[源代码]¶ 参数: - dataset --
DataSet对象, 数据集 - 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。
- collate_fn -- 用于将样本组合成batch的函数
- dataset --
-
get_batch_indices()¶ 获取当前已经输出的batch的index。
返回:
-
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.VocabularyfastNLP.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 返回: TrueorFalse
-
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, 将抛出ValueErrorindex = 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.DataSetfastNLP.core.dataset.DataSetfastNLP的数据容器，详细的使用方法见文档
fastNLP.core.dataset-
__init__(data=None)[源代码]¶ 参数: data -- 如果为dict类型，则每个key的value应该为等长的list; 如果为list， 每个元素应该为具有相同field的 Instance。
-
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的长度
-
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的长度
-
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
-
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。
参数: - 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.ConstfastNLP.core.const.ConstfastNLP中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.TrainerfastNLP.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类型。 - 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.TesterfastNLP.core.tester.TesterTester是在提供数据，模型以及metric的情况下进行性能测试的类。需要传入模型，数据以及metric进行验证。
-
__init__(data, model, metrics, batch_size=16, num_workers=0, device=None, verbose=1, use_tqdm=True)[源代码]¶ 参数: - data (DataSet) -- 需要测试的数据集
- 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.Callback[源代码]¶ 别名
fastNLP.CallbackfastNLP.core.callback.CallbackCallback是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.GradientClipCallbackfastNLP.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.EarlyStopCallbackfastNLP.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.FitlogCallbackfastNLP.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.EvaluateCallbackfastNLP.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.LRSchedulerfastNLP.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_all)[源代码]¶ -
别名
fastNLP.ControlCfastNLP.core.callback.ControlC检测到 control+C 时的反馈-
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.LRFinderfastNLP.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.TensorboardCallbackfastNLP.core.callback.TensorboardCallback接受以下一个或多个字符串作为参数： - "model" - "loss" - "metric"
警告
fastNLP 已停止对此功能的维护，请等待 fastNLP 兼容 PyTorch1.1 的下一个版本。 或者使用和 fastNLP 高度配合的 fitlog（参见 /tutorials/tutorial_11_fitlog ）。
-
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.WarmupCallbackfastNLP.core.callback.WarmupCallbacklearning 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.SaveModelCallbackfastNLP.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.CallbackExceptionfastNLP.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.EarlyStopErrorfastNLP.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.PadderfastNLP.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.AutoPadderfastNLP.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.EngChar2DPadderfastNLP.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.MetricBase[源代码]¶ 别名
fastNLP.MetricBasefastNLP.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.AccuracyMetricfastNLP.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.SpanFPreRecMetricfastNLP.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.CMRC2018MetricfastNLP.core.metrics.CMRC2018MetricCRMC2018任务的评价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.ClassifyFPreRecMetricfastNLP.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)[源代码]¶ param tag_vocab: 标签的 Vocabulary. 默认值为None。若为None则使用数字来作为标签内容，否则使用vocab来作为标签内容。param str pred: 用该key在evaluate()时从传入dict中取出prediction数据。 为None，则使用 pred 取数据 param str target: 用该key在evaluate()时从传入dict中取出target数据。 为None，则使用 target 取数据 param str seq_len: 用该key在evaluate()时从传入dict中取出sequence length数据。为None，则使用 seq_len 取数据。 param list ignore_labels: str 组成的list. 这个list中的class不会被用于计算。例如在POS tagging时传入['NN']，则不会计算'NN'个label param bool only_gross: 是否只计算总的f1, precision, recall的值；如果为False，不仅返回总的f1, pre, rec, 还会返回每个label的f1, pre, rec param str f_type: micro 或 macro . micro :通过先计算总体的TP，FN和FP的数量，再计算f, precision, recall; macro : 分布计算每个类别的f, precision, recall，然后做平均（各类别f的权重相同） param float beta: f_beta分数， :math:`f_{beta} = rac{(1 + {beta}^{2})*(pre*rec)}{({beta}^{2}*pre + rec)}` . 常用为 beta=0.5, 1, 2 若为0.5则精确率的权重高于召回率；若为1，则两者平等；若为2，则召回率权重高于精确率。
-
evaluate(pred, target, seq_len=None)[源代码]¶ evaluate函数将针对一个批次的预测结果做评价指标的累计
参数: - pred (torch.Tensor) -- 预测的tensor, tensor的形状可以是torch.Size([B,]), torch.Size([B, n_classes]), torch.Size([B, max_len]), 或者torch.Size([B, max_len, n_classes])
- target (torch.Tensor) -- 真实值的tensor, tensor的形状可以是Element's can be: torch.Size([B,]), torch.Size([B,]), torch.Size([B, max_len]), 或者torch.Size([B, max_len])
- seq_len (torch.Tensor) -- 序列长度标记, 标记的形状可以是None, None, torch.Size([B]), 或者torch.Size([B]). 如果mask也被传进来的话seq_len会被忽略.
-
get_metric(reset=True)[源代码]¶ get_metric函数将根据evaluate函数累计的评价指标统计量来计算最终的评价结果.
参数: reset (bool) -- 在调用完get_metric后是否清空评价指标统计量. Return dict evaluate_result: {"acc": float}
-
get_metric_name()¶ 返回metric的名称
返回:
-
set_metric_name(name: str)¶ 设置metric的名称，默认是Metric的class name.
参数: name (str) -- 返回: self
-
-
class
fastNLP.Optimizer(model_params, **kwargs)[源代码]¶ 别名
fastNLP.OptimizerfastNLP.core.optimizer.OptimizerOptimizer
-
class
fastNLP.SGD(lr=0.001, momentum=0, model_params=None)[源代码]¶ -
别名
fastNLP.SGDfastNLP.core.optimizer.SGDSGD
-
class
fastNLP.Adam(lr=0.001, weight_decay=0, betas=(0.9, 0.999), eps=1e-08, amsgrad=False, model_params=None)[源代码]¶ -
别名
fastNLP.AdamfastNLP.core.optimizer.AdamAdam
-
class
fastNLP.AdamW(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False)[源代码]¶ 别名
fastNLP.AdamWfastNLP.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
Optimizers param_groups.This can be useful when fine tuning a pre-trained network as frozen layers can be made trainable and added to the
Optimizeras 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.Tensors.
-
-
class
fastNLP.Sampler[源代码]¶ 别名
fastNLP.SamplerfastNLP.core.sampler.SamplerSampler 类的基类. 规定以何种顺序取出data中的元素
子类必须实现
__call__方法. 输入 DataSet 对象, 返回其中元素的下标序列-
__init__¶ Initialize self. See help(type(self)) for accurate signature.
-
-
class
fastNLP.SequentialSampler[源代码]¶ -
别名
fastNLP.SequentialSamplerfastNLP.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.BucketSamplerfastNLP.core.sampler.BucketSampler带Bucket的 Random Sampler. 可以随机地取出长度相似的元素
-
class
fastNLP.RandomSampler[源代码]¶ -
别名
fastNLP.RandomSamplerfastNLP.core.sampler.RandomSampler随机化取元素的 Sampler-
__init__¶ Initialize self. See help(type(self)) for accurate signature.
-
-
class
fastNLP.LossFunc(func, key_map=None, **kwargs)[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.LossFuncfastNLP.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.LossBase别名
fastNLP.CrossEntropyLossfastNLP.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.LossBase别名
fastNLP.L1LossfastNLP.core.losses.L1LossL1损失函数
param pred: 参数映射表中 pred 的映射关系，None表示映射关系为 pred -> pred param target: 参数映射表中 target 的映射关系，None表示映射关系为 target >`target` param str reduction: 支持'mean'，'sum'和'none'.
-
class
fastNLP.BCELoss(pred=None, target=None, reduction='mean')[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.BCELossfastNLP.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.LossBase别名
fastNLP.NLLLossfastNLP.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.LossBase别名
fastNLP.LossInForwardfastNLP.core.losses.LossInForward从forward()函数返回结果中获取loss
-
fastNLP.cache_results(_cache_fp, _refresh=False, _verbose=1)[源代码]¶ 别名
fastNLP.cache_resultsfastNLP.core.utils.cache_resultscache_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¶
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 中查看即可。如果想了解各个子模块的具体作用，您可以在下面找到每个子模块的具体文档。
子模块¶
batch 模块实现了 fastNLP 所需的 DataSetIter 类。
-
class
fastNLP.core.batch.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, collate_fn=None)[源代码]¶ 基类
fastNLP.BatchIter别名
fastNLP.DataSetIterfastNLP.core.batch.DataSetIterDataSetIter 用于从 DataSet 中按一定的顺序, 依次按
batch_size的大小将数据取出， 组成 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, collate_fn=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。
- collate_fn -- 用于将样本组合成batch的函数
- dataset --
-
get_batch_indices()¶ 获取当前已经输出的batch的index。
返回:
-
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.core.batch.TorchLoaderIter(dataset, batch_size=1, sampler=None, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, collate_fn=None)[源代码]¶ 基类
fastNLP.BatchIter别名
fastNLP.TorchLoaderIterfastNLP.core.batch.TorchLoaderIter与DataSetIter类似，但用于pytorch的DataSet对象。 通过使用TorchLoaderIter封装pytorch的DataSet，然后将其传入到Trainer中。-
__init__(dataset, batch_size=1, sampler=None, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, collate_fn=None)[源代码]¶ 参数: - dataset --
DataSet对象, 数据集 - 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。
- collate_fn -- 用于将样本组合成batch的函数
- dataset --
-
get_batch_indices()¶ 获取当前已经输出的batch的index。
返回:
-
static
get_num_batches(num_samples, batch_size, drop_last)¶ 计算batch的数量。
参数: - num_samples (int) --
- batch_size (int) --
- drop_last (bool) -- 如果最后一个batch没有batch_size这么多，是否就丢掉。
返回:
-
callback模块实现了 fastNLP 中的许多 callback 类，用于增强 Trainer 类。
虽然Trainer本身已经集成了一些功能，但仍然不足以囊括训练过程中可能需要到的功能，
比如负采样，learning rate decay 和 early stop等。
为了解决这个问题，fastNLP引入了callback的机制，Callback 是一种在Trainer训练过程中特定阶段会运行的函数集合。
关于 Trainer 的详细文档，请参见 trainer 模块
我们将 train() 这个函数内部分为以下的阶段，在对应阶段会触发相应的调用:
callback.on_train_begin() # 开始进行训练
for i in range(1, n_epochs+1):
callback.on_epoch_begin() # 开始新的epoch
for batch_x, batch_y in Batch:
callback.on_batch_begin(batch_x, batch_y, indices) # batch_x是设置为input的field，batch_y是设置为target的field
获取模型输出
callback.on_loss_begin()
计算loss
callback.on_backward_begin() # 可以进行一些检查，比如loss是否为None
反向梯度回传
callback.on_backward_end() # 进行梯度截断等
进行参数更新
callback.on_step_end()
callback.on_batch_end()
# 根据设置进行evaluation，比如这是本epoch最后一个batch或者达到一定step
if do evaluation:
callback.on_valid_begin()
进行dev data上的验证
callback.on_valid_end() # 可以进行在其它数据集上进行验证
callback.on_epoch_end() # epoch结束调用
callback.on_train_end() # 训练结束
callback.on_exception() # 这是一个特殊的步骤，在训练过程中遭遇exception会跳转到这里。
如下面的例子所示，我们可以使用内置的 callback 组件，或者继承 Callback
定义自己的 callback 组件:
from fastNLP import Callback, EarlyStopCallback, Trainer, CrossEntropyLoss, AccuracyMetric
from fastNLP.models import CNNText
start_time = time.time()
class MyCallback(Callback):
def on_epoch_end(self):
print('{:d}ms\n\n'.format(round((time.time()-start_time)*1000)))
model = CNNText((len(vocab),50), num_classes=5, padding=2, dropout=0.1)
trainer = Trainer(model=model, train_data=train_data, dev_data=dev_data, loss=CrossEntropyLoss(),
metrics=AccuracyMetric(), callbacks=[MyCallback(),EarlyStopCallback(10)])
trainer.train()
-
class
fastNLP.core.callback.Callback[源代码]¶ 别名
fastNLP.CallbackfastNLP.core.callback.CallbackCallback是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.core.callback.GradientClipCallback(parameters=None, clip_value=1, clip_type='norm')[源代码]¶ -
别名
fastNLP.GradientClipCallbackfastNLP.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.core.callback.EarlyStopCallback(patience)[源代码]¶ -
别名
fastNLP.EarlyStopCallbackfastNLP.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.core.callback.FitlogCallback(data=None, tester=None, log_loss_every=0, verbose=0, log_exception=False)[源代码]¶ -
别名
fastNLP.FitlogCallbackfastNLP.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.core.callback.EvaluateCallback(data=None, tester=None)[源代码]¶ -
别名
fastNLP.EvaluateCallbackfastNLP.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.core.callback.LRScheduler(lr_scheduler)[源代码]¶ -
别名
fastNLP.LRSchedulerfastNLP.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.core.callback.ControlC(quit_all)[源代码]¶ -
别名
fastNLP.ControlCfastNLP.core.callback.ControlC检测到 control+C 时的反馈-
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.core.callback.LRFinder(start_lr=1e-06, end_lr=10)[源代码]¶ -
别名
fastNLP.LRFinderfastNLP.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.core.callback.TensorboardCallback(*options)[源代码]¶ -
别名
fastNLP.TensorboardCallbackfastNLP.core.callback.TensorboardCallback接受以下一个或多个字符串作为参数： - "model" - "loss" - "metric"
警告
fastNLP 已停止对此功能的维护，请等待 fastNLP 兼容 PyTorch1.1 的下一个版本。 或者使用和 fastNLP 高度配合的 fitlog（参见 /tutorials/tutorial_11_fitlog ）。
-
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.core.callback.WarmupCallback(warmup=0.1, schedule='constant')[源代码]¶ -
别名
fastNLP.WarmupCallbackfastNLP.core.callback.WarmupCallbacklearning 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.core.callback.SaveModelCallback(save_dir, top=3, only_param=False, save_on_exception=False)[源代码]¶ -
别名
fastNLP.SaveModelCallbackfastNLP.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.core.callback.CallbackException(msg)[源代码]¶ 别名
fastNLP.CallbackExceptionfastNLP.core.callback.CallbackException当需要通过callback跳出训练的时候可以通过抛出CallbackException并在on_exception中捕获这个值。
-
with_traceback()¶ Exception.with_traceback(tb) -- set self.__traceback__ to tb and return self.
-
-
exception
fastNLP.core.callback.EarlyStopError(msg)[源代码]¶ -
别名
fastNLP.EarlyStopErrorfastNLP.core.callback.EarlyStopError用于EarlyStop时从Trainer训练循环中跳出。-
with_traceback()¶ Exception.with_traceback(tb) -- set self.__traceback__ to tb and return self.
-
fastNLP包当中的field命名均符合一定的规范，该规范由fastNLP.Const类进行定义。
-
class
fastNLP.core.const.Const[源代码]¶ 别名
fastNLP.ConstfastNLP.core.const.ConstfastNLP中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.
-
DataSet 是fastNLP中用于承载数据的容器。可以将DataSet看做是一个表格，
每一行是一个sample (在fastNLP中被称为 instance )，
每一列是一个feature (在fastNLP中称为 field )。
| sentence | words | seq_len |
|---|---|---|
| This is the first instance . | [This, is, the, first, instance, .] | 6 |
| Second instance . | [Second, instance, .] | 3 |
| Third instance . | [Third, instance, .] | 3 |
| ... | [...] | ... |
在fastNLP内部每一行是一个 Instance 对象； 每一列是一个 FieldArray 对象。
常见的预处理有如下几种
注解
直接读取特定数据集的数据请参考 使用Loader和Pipe加载并处理数据集
在目前深度学习的模型中，大都依赖于随机梯度下降法(SGD)进行模型的优化。随机梯度下降需要将数据切分成一个个的 batch， 一个batch进行一次前向计算(forward)与梯度后向传播(backward)。在自然语言处理的场景下，往往还需要对数据进行pad。这是 由于句子的长度一般是不同的，但是一次batch中的每个field都必须是一个tensor，所以需要将所有句子都补齐到相同的长度。
我们先看fastNLP中如何将数据分成一个一个的batch的例子, 这里我们使用随机生成的数据来模拟一个二分类文本分类任务， words和characters是输入，labels是文本类别
其中
DataSetIter是用于从DataSet中按照batch_size为大小取出batch的迭代器，SequentialSampler用于指示DataSetIter以怎样的 顺序从DataSet中取出instance以组成一个batch， 更详细的说明请参照DataSetIter和SequentialSampler文档。通过
DataSet.set_input('words', 'chars'), fastNLP将认为 words 和 chars 这两个field都是input，并将它们都放入迭代器 生成的第一个dict中;DataSet.set_target('labels'), fastNLP将认为 labels 这个field是target，并将其放入到迭代器的第 二个dict中。如上例中所打印结果。分为input和target的原因是由于它们在被Trainer所使用时会有所差异， 详见Trainer当把某个field设置为 target 或者 input 的时候(两者不是互斥的，可以同时设为两种)，fastNLP不仅仅只是将其放 置到不同的dict中，而还会对被设置为 input 或 target 的 field 进行类型检查。类型检查的目的是为了看能否把该 field 转为 pytorch的
torch.LongTensor或torch.FloatTensor类型 (也可以在DataSetIter中设置输出numpy类型，参考DataSetIter)。如上例所示，fastNLP已将 words ，chars 和 label 转为了
Tensor类型。 如果 field 在每个 instance 都拥有相同的维度(不能超过两维)，且最内层的元素都为相同的 type(int, float, np.int*, np.float*)， 则fastNLP默认将对该 field 进行pad。也支持全为str的field作为target和input，这种情况下，fastNLP默认不进行pad。 另外，当某个 field 已经被设置为了 target 或者 input 后，之后 append 的 instance 对应的 field 必须要和前面已有的内容一致，否则会报错。可以查看field的dtype:
from fastNLP import DataSet d = DataSet({'a': [0, 1, 3], 'b':[[1.0, 2.0], [0.1, 0.2], [3]]}) d.set_input('a', 'b') d.a.dtype >> numpy.int64 d.b.dtype >> numpy.float64 # 默认情况下'a'这个field将被转换为torch.LongTensor，但如果需要其为torch.FloatTensor可以手动修改dtype d.a.dtype = float # 请确保该field的确可以全部转换为float。如果某个field中出现了多种类型混合(比如一部分为str，一部分为int)的情况，fastNLP无法判断该field的类型，会报如下的 错误:
from fastNLP import DataSet d = DataSet({'data': [1, 'a']}) d.set_input('data') >> RuntimeError: Mixed data types in Field data: [<class 'str'>, <class 'int'>]可以通过设置以忽略对该field进行类型检查:
from fastNLP import DataSet d = DataSet({'data': [1, 'a']}) d.set_ignore_type('data') d.set_input('data')当某个field被设置为忽略type之后，fastNLP将不对其进行pad。
在fastNLP里，pad是与一个field绑定的。即不同的field可以使用不同的pad方式，比如在英文任务中word需要的pad和 character的pad方式往往是不同的。fastNLP是通过一个叫做Padder的子类来完成的。 默认情况下，所有field使用AutoPadder。可以通过使用以下方式设置Padder(如果将padder设置为None，则该field不会进行pad操作)。 大多数情况下直接使用AutoPadder就可以了。 如果AutoPadder或EngChar2DPadder无法满足需求， 也可以自己写一个Padder。
-
class
fastNLP.core.dataset.DataSet(data=None)[源代码]¶ 别名
fastNLP.DataSetfastNLP.core.dataset.DataSetfastNLP的数据容器，详细的使用方法见文档
fastNLP.core.dataset-
__init__(data=None)[源代码]¶ 参数: data -- 如果为dict类型，则每个key的value应该为等长的list; 如果为list， 每个元素应该为具有相同field的 Instance。
-
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的长度
-
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的长度
-
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
-
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。
参数: - 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.core.field.Padder(pad_val=0, **kwargs)[源代码]¶ 别名
fastNLP.PadderfastNLP.core.field.Padder所有padder都需要继承这个类，并覆盖__call__方法。 用于对batch进行padding操作。传入的element是inplace的，即直接修改element可能导致数据变化，建议inplace修改之前deepcopy一份。
-
__call__(self, contents, field_name, field_ele_dtype):
-
-
class
fastNLP.core.field.AutoPadder(pad_val=0)[源代码]¶ -
别名
fastNLP.AutoPadderfastNLP.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.field.EngChar2DPadder(pad_val=0, pad_length=0)[源代码]¶ -
别名
fastNLP.EngChar2DPadderfastNLP.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
instance 模块实现了Instance 类在fastNLP中对应sample。一个sample可以认为是一个Instance类型的对象。
便于理解的例子可以参考文档 fastNLP.core.dataset 中的表格
-
class
fastNLP.core.instance.Instance(**fields)[源代码]¶ 别名
fastNLP.InstancefastNLP.core.instance.InstanceInstance是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))})
losses 模块定义了 fastNLP 中所需的各种损失函数，一般做为 Trainer 的参数使用。
-
class
fastNLP.core.losses.LossFunc(func, key_map=None, **kwargs)[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.LossFuncfastNLP.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.core.losses.LossInForward(loss_key='loss')[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.LossInForwardfastNLP.core.losses.LossInForward从forward()函数返回结果中获取loss
-
class
fastNLP.core.losses.CrossEntropyLoss(pred=None, target=None, seq_len=None, class_in_dim=-1, padding_idx=-100, reduction='mean')[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.CrossEntropyLossfastNLP.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.core.losses.BCELoss(pred=None, target=None, reduction='mean')[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.BCELossfastNLP.core.losses.BCELoss二分类交叉熵损失函数
param pred: 参数映射表中 pred 的映射关系，None表示映射关系为 pred -> pred param target: 参数映射表中 target 的映射关系，None表示映射关系为 target -> target param str reduction: 支持 mean ，sum 和 none .
-
class
fastNLP.core.losses.L1Loss(pred=None, target=None, reduction='mean')[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.L1LossfastNLP.core.losses.L1LossL1损失函数
param pred: 参数映射表中 pred 的映射关系，None表示映射关系为 pred -> pred param target: 参数映射表中 target 的映射关系，None表示映射关系为 target >`target` param str reduction: 支持'mean'，'sum'和'none'.
-
class
fastNLP.core.losses.NLLLoss(pred=None, target=None, ignore_idx=-100, reduction='mean')[源代码]¶ 基类
fastNLP.LossBase别名
fastNLP.NLLLossfastNLP.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.core.losses.CMRC2018Loss(target_start=None, target_end=None, context_len=None, pred_start=None, pred_end=None, reduction='mean')[源代码]¶ 基类
fastNLP.core.LossBase别名
fastNLP.CMRC2018LossfastNLP.core.losses.CMRC2018Loss用于计算CMRC2018中文问答任务。
metrics 模块实现了 fastNLP 所需的各种常用衡量指标，一般做为 Trainer 的参数使用。
-
class
fastNLP.core.metrics.MetricBase[源代码]¶ 别名
fastNLP.MetricBasefastNLP.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.core.metrics.AccuracyMetric(pred=None, target=None, seq_len=None)[源代码]¶ -
别名
fastNLP.AccuracyMetricfastNLP.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.core.metrics.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.SpanFPreRecMetricfastNLP.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.core.metrics.CMRC2018Metric(answers=None, raw_chars=None, context_len=None, pred_start=None, pred_end=None)[源代码]¶ -
别名
fastNLP.CMRC2018MetricfastNLP.core.metrics.CMRC2018MetricCRMC2018任务的评价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.core.metrics.ClassifyFPreRecMetric(tag_vocab=None, pred=None, target=None, seq_len=None, ignore_labels=None, only_gross=True, f_type='micro', beta=1)[源代码]¶ -
别名
fastNLP.ClassifyFPreRecMetricfastNLP.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)[源代码]¶ param tag_vocab: 标签的 Vocabulary. 默认值为None。若为None则使用数字来作为标签内容，否则使用vocab来作为标签内容。param str pred: 用该key在evaluate()时从传入dict中取出prediction数据。 为None，则使用 pred 取数据 param str target: 用该key在evaluate()时从传入dict中取出target数据。 为None，则使用 target 取数据 param str seq_len: 用该key在evaluate()时从传入dict中取出sequence length数据。为None，则使用 seq_len 取数据。 param list ignore_labels: str 组成的list. 这个list中的class不会被用于计算。例如在POS tagging时传入['NN']，则不会计算'NN'个label param bool only_gross: 是否只计算总的f1, precision, recall的值；如果为False，不仅返回总的f1, pre, rec, 还会返回每个label的f1, pre, rec param str f_type: micro 或 macro . micro :通过先计算总体的TP，FN和FP的数量，再计算f, precision, recall; macro : 分布计算每个类别的f, precision, recall，然后做平均（各类别f的权重相同） param float beta: f_beta分数， :math:`f_{beta} = rac{(1 + {beta}^{2})*(pre*rec)}{({beta}^{2}*pre + rec)}` . 常用为 beta=0.5, 1, 2 若为0.5则精确率的权重高于召回率；若为1，则两者平等；若为2，则召回率权重高于精确率。
-
evaluate(pred, target, seq_len=None)[源代码]¶ evaluate函数将针对一个批次的预测结果做评价指标的累计
参数: - pred (torch.Tensor) -- 预测的tensor, tensor的形状可以是torch.Size([B,]), torch.Size([B, n_classes]), torch.Size([B, max_len]), 或者torch.Size([B, max_len, n_classes])
- target (torch.Tensor) -- 真实值的tensor, tensor的形状可以是Element's can be: torch.Size([B,]), torch.Size([B,]), torch.Size([B, max_len]), 或者torch.Size([B, max_len])
- seq_len (torch.Tensor) -- 序列长度标记, 标记的形状可以是None, None, torch.Size([B]), 或者torch.Size([B]). 如果mask也被传进来的话seq_len会被忽略.
-
get_metric(reset=True)[源代码]¶ get_metric函数将根据evaluate函数累计的评价指标统计量来计算最终的评价结果.
参数: reset (bool) -- 在调用完get_metric后是否清空评价指标统计量. Return dict evaluate_result: {"acc": float}
-
get_metric_name()¶ 返回metric的名称
返回:
-
set_metric_name(name: str)¶ 设置metric的名称，默认是Metric的class name.
参数: name (str) -- 返回: self
-
-
class
fastNLP.core.metrics.ConfusionMatrixMetric(vocab=None, pred=None, target=None, seq_len=None)[源代码]¶ 分类问题计算混淆矩阵的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)[源代码]¶ 参数: - vocab -- vocab词表类,要求有to_word()方法。
- 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, torch.Size([B]), 或者torch.Size([B]).
-
get_metric(reset=True)[源代码]¶ get_metric函数将根据evaluate函数累计的评价指标统计量来计算最终的评价结果.
参数: reset (bool) -- 在调用完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
-
optimizer 模块定义了 fastNLP 中所需的各种优化器，一般做为 Trainer 的参数使用。
-
class
fastNLP.core.optimizer.Optimizer(model_params, **kwargs)[源代码]¶ 别名
fastNLP.OptimizerfastNLP.core.optimizer.OptimizerOptimizer
-
class
fastNLP.core.optimizer.SGD(lr=0.001, momentum=0, model_params=None)[源代码]¶ -
别名
fastNLP.SGDfastNLP.core.optimizer.SGDSGD
-
class
fastNLP.core.optimizer.Adam(lr=0.001, weight_decay=0, betas=(0.9, 0.999), eps=1e-08, amsgrad=False, model_params=None)[源代码]¶ -
别名
fastNLP.AdamfastNLP.core.optimizer.AdamAdam
-
class
fastNLP.core.optimizer.AdamW(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False)[源代码]¶ 别名
fastNLP.AdamWfastNLP.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
Optimizers param_groups.This can be useful when fine tuning a pre-trained network as frozen layers can be made trainable and added to the
Optimizeras 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.Tensors.
-
sampler 子类实现了 fastNLP 所需的各种采样器。
-
class
fastNLP.core.sampler.Sampler[源代码]¶ 别名
fastNLP.SamplerfastNLP.core.sampler.SamplerSampler 类的基类. 规定以何种顺序取出data中的元素
子类必须实现
__call__方法. 输入 DataSet 对象, 返回其中元素的下标序列-
__init__¶ Initialize self. See help(type(self)) for accurate signature.
-
-
class
fastNLP.core.sampler.BucketSampler(num_buckets=10, batch_size=None, seq_len_field_name='seq_len')[源代码]¶ -
别名
fastNLP.BucketSamplerfastNLP.core.sampler.BucketSampler带Bucket的 Random Sampler. 可以随机地取出长度相似的元素
-
class
fastNLP.core.sampler.SequentialSampler[源代码]¶ -
别名
fastNLP.SequentialSamplerfastNLP.core.sampler.SequentialSampler顺序取出元素的 Sampler-
__init__¶ Initialize self. See help(type(self)) for accurate signature.
-
-
class
fastNLP.core.sampler.RandomSampler[源代码]¶ -
别名
fastNLP.RandomSamplerfastNLP.core.sampler.RandomSampler随机化取元素的 Sampler-
__init__¶ Initialize self. See help(type(self)) for accurate signature.
-
tester模块实现了 fastNLP 所需的Tester类，能在提供数据、模型以及metric的情况下进行性能测试。
这里Metric的映射规律是和 fastNLP.Trainer 中一致的，具体使用请参考 trainer 模块 的1.3部分。
Tester在验证进行之前会调用model.eval()提示当前进入了evaluation阶段，即会关闭nn.Dropout()等，在验证结束之后会调用model.train()恢复到训练状态。
-
class
fastNLP.core.tester.Tester(data, model, metrics, batch_size=16, num_workers=0, device=None, verbose=1, use_tqdm=True)[源代码]¶ 别名
fastNLP.TesterfastNLP.core.tester.TesterTester是在提供数据，模型以及metric的情况下进行性能测试的类。需要传入模型，数据以及metric进行验证。
-
__init__(data, model, metrics, batch_size=16, num_workers=0, device=None, verbose=1, use_tqdm=True)[源代码]¶ 参数: - data (DataSet) -- 需要测试的数据集
- 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，则不会显示任何内容。
-
Trainer在fastNLP中用于组织单任务的训练过程，可以避免用户在不同训练任务中重复撰以下步骤的代码
- epoch循环;
- 将数据分成不同的Batch;
- 对Batch进行pad;
- 每个epoch结束或一定step后进行验证集验证;
- 保存获得更好验证性能的模型。
下面的例子是使用神经网络来进行预测一个序列中是否有偶数个1。
import numpy as np
from torch import nn
import torch
import torch.nn.functional as F
from torch.optim import SGD
from fastNLP import DataSet
from fastNLP import Trainer
from fastNLP import CrossEntropyLoss
from fastNLP import AccuracyMetric
from fastNLP.modules.decoder import MLP
# 模型
class Model(nn.Module):
def __init__(self, input_num):
super().__init__()
self.fcs = MLP([input_num, 40, 40, 2], 'relu')
def forward(self, x):
x = self.fcs(x)
return {'pred': x}
model = Model(10)
# 生成数据
def generate_psedo_dataset(num_samples):
dataset = DataSet()
data = np.random.randint(2, size=(num_samples, 10))
label = np.sum(data, axis=1)%2
dataset = DataSet({'x':data.astype(float), 'label': label})
dataset.set_input('x')
dataset.set_target('label')
return dataset
tr_dataset = generate_psedo_dataset(1000)
dev_data = generate_psedo_dataset(100)
# 训练
trainer = Trainer(tr_dataset, model, loss=CrossEntropyLoss(target='label'),
optimizer=SGD(model.parameters(), lr=0.1),n_epochs=1000,
dev_data = dev_data, metrics=AccuracyMetric(target='label'))
trainer.train()
由上面的例子可以看出通过使用Trainer，可以使得训练部分的代码大幅减少。 使用Trainer需要满足以下几个条件:
1 模型的forward()的参数名需要与DataSet中的名字对应。实际上fastNLP在将DataSet中的数据传递给模型forward()时，是 通过匹配名称实现的。所以上例中，如果Model的forward函数修改为forward(self, data), 则DataSet中的'x'这个field就应该 改名为'data'。
2 传递给forward()的参数是DataSet中被设置为input的那些field。但如果forward()中没有对应的参数，则不会将数据传递 给forward()。例如，DataSet中'x1', 'x2'都是input，但是模型的函数为forward(self, x1), 那么'x2'不会传递给forward()。
3 模型的forward()返回值需要为一个dict。
fastNLP中的为了不限制forward函数的返回内容数量(比如一些复杂任务需要返回多个内容，如Dependency Parsing，
Loss 与 Metric 都使用了通过名称来匹配相应内容的策略。如上面的例子中
trainer = Trainer(tr_dataset, model, loss=CrossEntropyLoss(target='label'),
optimizer=SGD(model.parameters(), lr=0.1),n_epochs=1000,
dev_data = dev_data, metrics=AccuracyMetric(target='label'))
loss被设置为了 CrossEntropyLoss , 但在初始化的时候传入了target='label'这个参数，
CrossEntropyLoss 的初始化参数为(pred=None, target=None, padding_idx=-100)。
这里的两个参数分别为计算CrossEntropy时需要使用到的模型的预测值与真实值。
其中 pred 一般来自于模型forward()的返回结果，target 一般是来自于DataSet中被设置为target的field。
由于每个人对真实值或者model的返回值取名并不一样，所以fastNLP的 Loss 提供一种类似于映射的机制来匹配对应的值，
比如这里 CrossEntropyLoss 将尝试找到名为'label'的内容来作为真实值得到loss；
而pred=None, 则 CrossEntropyLoss 使用'pred'作为名称匹配预测值，
正好forward的返回值也叫pred，所以这里不需要申明pred。
尽管fastNLP使用了映射机制来使得loss的计算变得比较灵活，但有些情况下loss必须在模型中进行计算，比如使用了CRF的模型。
fastNLP中提供了 LossInForward 这个loss。
这个loss的原理是直接在forward()的返回结果中找到loss_key(默认寻找'loss')指定的那个tensor，并使用它作为loss。
如果Trainer初始化没有提供loss则默认使用 LossInForward 。
Metric 使用了与上述Loss一样的策略，即使用名称进行匹配。
AccuracyMetric(target='label')的情况与CrossEntropyLoss 是同理的。
在进行验证时，可能用到的计算与forward()中不太一致，没有办法直接从forward()的结果中得到预测值，这时模型可以提供一个predict()方法， 如果提供的模型具有predict方法，则在模型验证时将调用predict()方法获取预测结果， 传入到predict()的参数也是从DataSet中被设置为input的field中选择出来的; 与forward()一样，返回值需要为一个dict。
由于在fastNLP中采取了映射的机制，所以难免可能存在对应出错的情况。Trainer提供一种映射检查机制，可以通过check_code_level来进行控制 比如下面的例子中，由于各种原因产生的报错
import numpy as np
from torch import nn
import torch
from torch.optim import SGD
from fastNLP import Trainer
from fastNLP import DataSet
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(1, 1)
def forward(self, x, b):
loss = torch.mean((self.fc(x)-b)**2)
return {'loss': loss}
model = Model()
dataset = DataSet({'a': np.arange(10), 'b':np.arange(10)*2})
dataset.set_input('a', 'b')
trainer = Trainer(dataset, model, loss=None, optimizer=SGD(model.parameters(), lr=0.001))
trainer = Trainer(dataset, model, SGD(model.parameters()))
# 会报以下的错误
# input fields after batch(if batch size is 2):
# a: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
# b: (1)type:torch.Tensor (2)dtype:torch.int64, (3)shape:torch.Size([2])
# There is no target field.
# ....
# NameError:
# Problems occurred when calling Model.forward(self, x, b)
# missing param: ['x']
# unused field: ['a']
# Suggestion: You need to provide ['x'] in DataSet and set it as input.
这里就是由于在Trainer初始化的时候，fastNLP会尝试使用一个batch_size=2的batch去运行一遍forward()以及backward()。这里有两类 信息可以为你提供参考
1 'input fields after batch...'这部分显示的是train dataset经过Batch操作后，每个field对应的类型以及进行shape。这里 因为train dataset没有target所以没有显示。根据这里可以看出是否正确将需要的内容设置为了input或target。
2 NameError，NameError发生在映射出错的情况。这里报错的原因是由于尝试进行forward计算时(可以通过Model.forward(self, x, b)判断 出当前是在调取forward)，却没有获取到forward()函数中需要的'x'；在报错信息中同时指出了缺'x'，而'a'没有被使用，那么可能 就是由于field的名称不对。这里将dataset中'a'这个field的名称改为'x'，或者model的参数从'x'修改为'a'都可以解决问题。
下面的例子是由于loss计算的时候找不到需要的值
import numpy as np
from torch import nn
from torch.optim import SGD
from fastNLP import Trainer
from fastNLP import DataSet
from fastNLP import L1Loss
import torch
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(1, 1)
def forward(self, a):
return {'pred_b': self.fc(a.unsqueeze(1)).squeeze(1), 'No use':1}
model = Model()
dataset = DataSet({'a': np.arange(10, dtype=float), 'b':np.arange(10, dtype=float)*2})
dataset.set_input('a')
dataset.set_target('b')
trainer = Trainer(dataset, model, loss=L1Loss(target='label'), optimizer=SGD(model.parameters(), lr=0.001))
# 报错信息如下
# input fields after batch(if batch size is 2):
# a: (1)type:torch.Tensor (2)dtype:torch.float32, (3)shape:torch.Size([2])
# target fields after batch(if batch size is 2):
# b: (1)type:torch.Tensor (2)dtype:torch.float32, (3)shape:torch.Size([2])
# ....
# NameError:
# Problems occurred when calling L1Loss.get_loss(self, pred, target)
# missing param: ['pred(assign to `pred` in `L1Loss`)', 'label(assign to `target` in `L1Loss`)']
# unused field: ['b']
# unused param: ['pred_b', 'No use']
# target field: ['b']
# param from Model.forward(self, a): ['pred_b', 'No use']
# Suggestion: (1). Check key assignment for `target` when initialize L1Loss. Or provide `label` in DataSet or output of Model.forward(self, a).
# (2). Check key assignment for `pred` when initialize L1Loss. Or provide `pred` in DataSet or output of Model.forward(self, a).
报错信息也包含两部分:
1 第一部分与上面是一样的
2 这里报错的原因是由于计算loss的时候找不到相应的值(通过L1Loss.get_loss(self, pred, target)判断出来的)； 报错的原因是因为 pred 和 label (我们在初始化L1Loss时将target指定为了label)都没有找到。 这里'unused field'是DataSet中出现了，但却没有被设置为input或者target的field； 'unused param'是forward()中返回且没有被使用到的内容；'target field'是被设置为了target的field; 'param from Model.forward(self, a)'是forward()返回的所有key。"Suggestion"是关于当前错误处理的建议。
但是在一些情况下，比如forward()返回值只有一个，target也只有一个，fastNLP不会进行匹配，而直接将forward()的结果作为pred, 将DataSet中的target设置为target。上面的例子在返回值中加入了一个'No use'则只是为了使得Loss去匹配结果。
下面是带有dev dataset时如果出现错误会发生的报错，
import numpy as np
from torch import nn
from torch.optim import SGD
from fastNLP import Trainer
from fastNLP import DataSet
from fastNLP import AccuracyMetric
import torch
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(1, 1)
def forward(self, a, b):
loss = torch.mean((self.fc(a.float().unsqueeze(1))-b.float())**2)
return {'loss': loss}
def predict(self, a): # 使用predict()进行验证
return {'output':self.fc(a.float().unsqueeze(1))} #这里return的值不包含'pred'这个key
model = Model()
dataset = DataSet({'a': np.arange(10), 'b':np.arange(10)*2})
dev_data = DataSet({'a': np.arange(10, 20), 'b':np.arange(10, 20)*2})
dataset.set_input('a', 'b')
dev_data.set_input('a') # 这里没有设置target
trainer = Trainer(dataset, model, loss=None, optimizer=SGD(model.parameters(), lr=0.001),
dev_data=dev_data, metrics=AccuracyMetric())
# 报错信息
# ...
# NameError:
# Problems occurred when calling AccuracyMetric.evaluate(self, pred, target, seq_len=None)
# missing param: ['pred(assign to `pred` in `AccuracyMetric`)', 'target(assign to `target` in `AccuracyMetric`)']
# unused param: ['output']
# target field: []
# param from Model.predict(self, a): ['output']
# Suggestion: (1). Check key assignment for `pred` when initialize AccuracyMetric. Or provide `pred` in DataSet or output of Model.predict(self, a).
# (2). Check key assignment for `target` when initialize AccuracyMetric. Or provide `target` in DataSet or output of Model.predict(self, a).
报错信息和前面都是类似的，但是可以通过'AccuracyMetric.evaluate(self, pred, target, seq_len=None)'看出这里是evaluation 的时候发生了错误。这样避免了需要在完成一整个epoch的训练才能发现evaluation弄错的情况。这里的修改是通过在初始化metric的时候 指明通过'output'获取`pred`, 即AccuracyMetric(pred='output')。
可以通过check_code_level调节检查的强度。默认为0，即进行检查。
虽然Trainer本身已经集成了一些功能，但仍然不足以囊括训练过程中可能需要到的功能，比如负采样，learning rate decay, Early Stop等。
为了解决这个问题fastNLP引入了callback的机制，Callback 是一种在Trainer训练过程中特定阶段会运行的函数集合，
所有的 Callback 都具有on_*(比如on_train_start, on_backward_begin)等函数。
如果 Callback 实现了该函数，则Trainer运行至对应阶段，会进行调用，例如:
from fastNLP import Callback, EarlyStopCallback, Trainer, CrossEntropyLoss, AccuracyMetric
from fastNLP.models import CNNText
start_time = time.time()
class MyCallback(Callback):
def on_epoch_end(self):
print('{:d}ms\n\n'.format(round((time.time()-start_time)*1000)))
model = CNNText((len(vocab),50), num_classes=5, padding=2, dropout=0.1)
trainer = Trainer(model=model, train_data=train_data, dev_data=dev_data, loss=CrossEntropyLoss(),
metrics=AccuracyMetric(), callbacks=[MyCallback(),EarlyStopCallback(10)])
trainer.train()
这里，我们通过继承 Callback 类定义了自己的 callback 的，并和内置的 EarlyStopCallback
一起传给了 Trainer ，增强了 Trainer 的功能
fastNLP已经自带了很多callback函数供使用，可以参考 fastNLP.core.callback 。
-
class
fastNLP.core.trainer.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.TrainerfastNLP.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类型。 - 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)更新取得的最佳值
utils模块实现了 fastNLP 内部和外部所需的很多工具。其中用户可以使用的是 cache_results() 修饰器。
-
fastNLP.core.utils.cache_results(_cache_fp, _refresh=False, _verbose=1)[源代码]¶ 别名
fastNLP.cache_resultsfastNLP.core.utils.cache_resultscache_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.utils.seq_len_to_mask(seq_len, max_len=None)[源代码]¶ 别名
fastNLP.seq_len_to_maskfastNLP.core.utils.seq_len_to_mask将一个表示sequence length的一维数组转换为二维的mask，不包含的位置为0。 转变 1-d seq_len到2-d mask.
参数: - 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.utils.get_seq_len(words, pad_value=0)[源代码]¶ 别名
fastNLP.get_seq_lenfastNLP.core.utils.get_seq_len给定batch_size x max_len的words矩阵，返回句子长度
参数: words -- batch_size x max_len 返回: (batch_size,)
-
class
fastNLP.core.vocabulary.Vocabulary(max_size=None, min_freq=None, padding='<pad>', unknown='<unk>')[源代码]¶ 别名
fastNLP.VocabularyfastNLP.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 返回: TrueorFalse
-
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, 将抛出ValueErrorindex = 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的。
-
fastNLP.embeddings¶
embeddings 模块主要用于从各种预训练的模型中获取词语的分布式表示，目前支持的预训练模型包括word2vec, glove, ELMO, BERT等。这里所有
embedding的forward输入都是形状为 (batch_size, max_len) 的torch.LongTensor，输出都是 (batch_size, max_len, embedding_dim) 的
torch.FloatTensor。所有的embedding都可以使用 self.num_embedding 获取最大的输入index范围, 用 self.embeddig_dim 或 self.embed_size 获取embedding的
输出维度。
-
class
fastNLP.embeddings.Embedding(init_embed, word_dropout=0, dropout=0.0, unk_index=None)[源代码]¶ 别名
fastNLP.embeddings.EmbeddingfastNLP.embeddings.embedding.Embedding词向量嵌入，支持输入多种方式初始化. 可以通过self.num_embeddings获取词表大小; self.embedding_dim获取embedding的维度.
Example:
>>> import numpy as np >>> from fastNLP.embeddings import Embedding >>> init_embed = (2000, 100) >>> embed = Embedding(init_embed) # 随机初始化一个具有2000个词，每个词表示为100维的词向量 >>> init_embed = np.zeros((2000, 100)) >>> embed = Embedding(init_embed) # 使用numpy.ndarray的值作为初始化值初始化一个Embedding
-
__init__(init_embed, word_dropout=0, dropout=0.0, unk_index=None)[源代码]¶ 参数: - init_embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- 支持传入Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 或传入Tensor, Embedding, numpy.ndarray等则直接使用该值初始化Embedding;
- word_dropout (float) -- 按照一定概率随机将word设置为unk_index，这样可以使得unk这个token得到足够的训练, 且会对网络有 一定的regularize的作用。设置该值时，必须同时设置unk_index
- dropout (float) -- 对Embedding的输出的dropout。
- unk_index (int) -- drop word时替换为的index。fastNLP的Vocabulary的unk_index默认为1。
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch, seq_len] 返回: torch.Tensor : [batch, seq_len, embed_dim]
-
requires_grad¶ Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许 :return:
-
-
class
fastNLP.embeddings.TokenEmbedding(vocab, word_dropout=0.0, dropout=0.0)[源代码]¶ 别名
fastNLP.embeddings.TokenEmbeddingfastNLP.embeddings.embedding.TokenEmbeddingfastNLP中各种Embedding的基类
-
drop_word(words)[源代码]¶ 按照设定随机将words设置为unknown_index。
参数: words (torch.LongTensor) -- batch_size x max_len 返回:
-
dropout(words)[源代码]¶ 对embedding后的word表示进行drop。
参数: words (torch.FloatTensor) -- batch_size x max_len x embed_size 返回:
-
num_embedding¶ 这个值可能会大于实际的embedding矩阵的大小。 :return:
-
requires_grad¶ Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许 :return:
-
-
class
fastNLP.embeddings.StaticEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', embedding_dim=-1, requires_grad: bool = True, init_method=None, lower=False, dropout=0, word_dropout=0, normalize=False, min_freq=1, **kwargs)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.StaticEmbeddingfastNLP.embeddings.static_embedding.StaticEmbeddingStaticEmbedding组件. 给定预训练embedding的名称或路径，根据vocab从embedding中抽取相应的数据(只会将出现在vocab中的词抽取出来， 如果没有找到，则会随机初始化一个值(但如果该word是被标记为no_create_entry的话，则不会单独创建一个值，而是会被指向unk的index))。 当前支持自动下载的预训练vector有以下的几种(待补充);
Example:
>>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import StaticEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = StaticEmbedding(vocab, model_dir_or_name='en-glove-50d') >>> vocab = Vocabulary().add_word_lst(["The", 'the', "THE"]) >>> embed = StaticEmbedding(vocab, model_dir_or_name="en-glove-50d", lower=True) >>> # "the", "The", "THE"它们共用一个vector，且将使用"the"在预训练词表中寻找它们的初始化表示。 >>> vocab = Vocabulary().add_word_lst(["The", "the", "THE"]) >>> embed = StaticEmbedding(vocab, model_dir_or_name=None, embedding_dim=5, lower=True) >>> words = torch.LongTensor([[vocab.to_index(word) for word in ["The", "the", "THE"]]]) >>> embed(words) >>> tensor([[[ 0.5773, 0.7251, -0.3104, 0.0777, 0.4849], [ 0.5773, 0.7251, -0.3104, 0.0777, 0.4849], [ 0.5773, 0.7251, -0.3104, 0.0777, 0.4849]]], grad_fn=<EmbeddingBackward>) # 每种word的输出是一致的。
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', embedding_dim=-1, requires_grad: bool = True, init_method=None, lower=False, dropout=0, word_dropout=0, normalize=False, min_freq=1, **kwargs)[源代码]¶ 参数: - vocab -- Vocabulary. 若该项为None则会读取所有的embedding。
- model_dir_or_name -- 可以有两种方式调用预训练好的static embedding：第一种是传入embedding文件夹(文件夹下应该只有一个 以.txt作为后缀的文件)或文件路径；第二种是传入embedding的名称，第二种情况将自动查看缓存中是否存在该模型，没有的话将自动下载。 如果输入为None则使用embedding_dim的维度随机初始化一个embedding。
- embedding_dim (int) -- 随机初始化的embedding的维度，当该值为大于0的值时，将忽略model_dir_or_name。
- requires_grad (bool) -- 是否需要gradient. 默认为True
- init_method (callable) -- 如何初始化没有找到的值。可以使用torch.nn.init.*中各种方法, 传入的方法应该接受一个tensor，并 inplace地修改其值。
- lower (bool) -- 是否将vocab中的词语小写后再和预训练的词表进行匹配。如果你的词表中包含大写的词语，或者就是需要单独 为大写的词语开辟一个vector表示，则将lower设置为False。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- normalize (bool) -- 是否对vector进行normalize，使得每个vector的norm为1。
- min_freq (int) -- Vocabulary词频数小于这个数量的word将被指向unk。
- kwargs (dict) --
bool only_train_min_freq: 仅对train中的词语使用min_freq筛选; bool only_norm_found_vector: 是否仅对在预训练中找到的词语使用normalize; bool only_use_pretrain_word: 仅使用出现在pretrain词表中的词语。如果该词没有在预训练的词表中出现则为unk。如果词表
不需要更新设置为True。
-
-
class
fastNLP.embeddings.ElmoEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '2', requires_grad: bool = True, word_dropout=0.0, dropout=0.0, cache_word_reprs: bool = False)[源代码]¶ 基类
fastNLP.embeddings.ContextualEmbedding别名
fastNLP.embeddings.ElmoEmbeddingfastNLP.embeddings.elmo_embedding.ElmoEmbedding使用ELMo的embedding。初始化之后，只需要传入words就可以得到对应的embedding。当前支持的使用名称初始化的模型有以下的这些(待补充)
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import ElmoEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> # 使用不同层的concat的结果 >>> embed = ElmoEmbedding(vocab, model_dir_or_name='en', layers='1,2', requires_grad=False) >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5, 2048]) >>> # 使用不同层的weighted sum。 >>> embed = ElmoEmbedding(vocab, model_dir_or_name='en', layers='mix', requires_grad=False) >>> embed.set_mix_weights_requires_grad() # 使得weighted的权重是可以学习的，但ELMO的LSTM部分是不更新
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '2', requires_grad: bool = True, word_dropout=0.0, dropout=0.0, cache_word_reprs: bool = False)[源代码]¶ 参数: - vocab -- 词表
- model_dir_or_name -- 可以有两种方式调用预训练好的ELMo embedding：第一种是传入ELMo所在文件夹，该文件夹下面应该有两个文件， 其中一个是以json为后缀的配置文件，另一个是以pkl为后缀的权重文件；第二种是传入ELMo版本的名称，将自动查看缓存中是否存在该模型， 没有的话将自动下载并缓存。
- layers -- str, 指定返回的层数(从0开始), 以,隔开不同的层。如果要返回第二层的结果'2', 返回后两层的结果'1,2'。不同的层的结果 按照这个顺序concat起来，默认为'2'。'mix'会使用可学习的权重结合不同层的表示(权重是否可训练与requires_grad保持一致， 初始化权重对三层结果进行mean-pooling, 可以通过ElmoEmbedding.set_mix_weights_requires_grad()方法只将mix weights设置为可学习。)
- requires_grad -- bool, 该层是否需要gradient, 默认为False.
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- cache_word_reprs -- 可以选择对word的表示进行cache; 设置为True的话，将在初始化的时候为每个word生成对应的embedding， 并删除character encoder，之后将直接使用cache的embedding。默认为False。
-
forward(words: torch.LongTensor)[源代码]¶ 计算words的elmo embedding表示。根据elmo文章中介绍的ELMO实际上是有2L+1层结果，但是为了让结果比较容易拆分，token的 被重复了一次，使得实际上layer=0的结果是[token_embedding;token_embedding], 而layer=1的结果是[forward_hiddens; backward_hiddens].
参数: words -- batch_size x max_len 返回: torch.FloatTensor. batch_size x max_len x (512*len(self.layers))
-
-
class
fastNLP.embeddings.BertEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pool_method: str = 'first', word_dropout=0, dropout=0, include_cls_sep: bool = False, pooled_cls=True, requires_grad: bool = True, auto_truncate: bool = False)[源代码]¶ 基类
fastNLP.embeddings.ContextualEmbedding别名
fastNLP.embeddings.BertEmbeddingfastNLP.embeddings.bert_embedding.BertEmbedding使用BERT对words进行编码的Embedding。建议将输入的words长度限制在430以内，而不要使用512(根据预训练模型参数，可能有变化)。这是由于 预训练的bert模型长度限制为512个token，而因为输入的word是未进行word piece分割的(word piece的分割有BertEmbedding在输入word 时切分)，在分割之后长度可能会超过最大长度限制。
BertEmbedding可以支持自动下载权重，当前支持的模型有以下的几种(待补充):
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import BertEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = BertEmbedding(vocab, model_dir_or_name='en-base-uncased', requires_grad=False, layers='4,-2,-1') >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5, 2304])
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pool_method: str = 'first', word_dropout=0, dropout=0, include_cls_sep: bool = False, pooled_cls=True, requires_grad: bool = True, auto_truncate: bool = False)[源代码]¶ 参数: - vocab (Vocabulary) -- 词表
- model_dir_or_name (str) -- 模型所在目录或者模型的名称。当传入模型所在目录时，目录中应该包含一个词表文件(以.txt作为后缀名), 权重文件(以.bin作为文件后缀名), 配置文件(以.json作为后缀名)。
- layers (str) -- 输出embedding表示来自于哪些层，不同层的结果按照layers中的顺序在最后一维concat起来。以','隔开层数，层的序号是 从0开始，可以以负数去索引倒数几层。
- pool_method (str) -- 因为在bert中，每个word会被表示为多个word pieces, 当获取一个word的表示的时候，怎样从它的word pieces
中计算得到它对应的表示。支持
last,first,avg,max。 - word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- include_cls_sep (bool) -- bool，在bert计算句子的表示的时候，需要在前面加上[CLS]和[SEP], 是否在结果中保留这两个内容。 这样 会使得word embedding的结果比输入的结果长两个token。如果该值为True，则在使用 :class::StackEmbedding 可能会与其它类型的 embedding长度不匹配。
- pooled_cls (bool) -- 返回的[CLS]是否使用预训练中的BertPool映射一下，仅在include_cls_sep时有效。如果下游任务只取[CLS]做预测， 一般该值为True。
- requires_grad (bool) -- 是否需要gradient以更新Bert的权重。
- auto_truncate (bool) -- 当句子words拆分为word pieces长度超过bert最大允许长度(一般为512), 自动截掉拆分后的超过510个 word pieces后的内容，并将第512个word piece置为[SEP]。超过长度的部分的encode结果直接全部置零。一般仅有只使用[CLS] 来进行分类的任务将auto_truncate置为True。
-
-
class
fastNLP.embeddings.BertWordPieceEncoder(model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pooled_cls: bool = False, word_dropout=0, dropout=0, requires_grad: bool = True)[源代码]¶ 别名
fastNLP.embeddings.BertWordPieceEncoderfastNLP.embeddings.bert_embedding.BertWordPieceEncoder读取bert模型，读取之后调用index_dataset方法在dataset中生成word_pieces这一列。
-
__init__(model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pooled_cls: bool = False, word_dropout=0, dropout=0, requires_grad: bool = True)[源代码]¶ 参数: - model_dir_or_name (str) -- 模型所在目录或者模型的名称。默认值为
en-base-uncased - layers (str) -- 最终结果中的表示。以','隔开层数，可以以负数去索引倒数几层
- pooled_cls (bool) -- 返回的句子开头的[CLS]是否使用预训练中的BertPool映射一下。如果下游任务取[CLS]做预测，一般该值为True。
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- requires_grad (bool) -- 是否需要gradient。
- model_dir_or_name (str) -- 模型所在目录或者模型的名称。默认值为
-
drop_word(words)[源代码]¶ 按照设定随机将words设置为unknown_index。
参数: words (torch.LongTensor) -- batch_size x max_len 返回:
-
forward(word_pieces, token_type_ids=None)[源代码]¶ 计算words的bert embedding表示。传入的words中应该自行包含[CLS]与[SEP]的tag。
参数: - words -- batch_size x max_len
- token_type_ids -- batch_size x max_len, 用于区分前一句和后一句话. 如果不传入，则自动生成(大部分情况，都不需要输入), 第一个[SEP]及之前为0, 第二个[SEP]及到第一个[SEP]之间为1; 第三个[SEP]及到第二个[SEP]之间为0，依次往后推。
返回: torch.FloatTensor. batch_size x max_len x (768*len(self.layers))
-
index_datasets(*datasets, field_name, add_cls_sep=True)[源代码]¶ 使用bert的tokenizer新生成word_pieces列加入到datasets中，并将他们设置为input,且将word_pieces这一列的pad value设置为了 bert的pad value。
参数: - datasets (DataSet) -- DataSet对象
- field_name (str) -- 基于哪一列的内容生成word_pieces列。这一列中每个数据应该是List[str]的形式。
- add_cls_sep (bool) -- 如果首尾不是[CLS]与[SEP]会在首尾额外加入[CLS]与[SEP]。
返回:
-
-
class
fastNLP.embeddings.StackEmbedding(embeds: List[fastNLP.embeddings.embedding.TokenEmbedding], word_dropout=0, dropout=0)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.StackEmbeddingfastNLP.embeddings.stack_embedding.StackEmbedding支持将多个embedding集合成一个embedding。
Example:
>>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import StaticEmbedding, StackEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed_1 = StaticEmbedding(vocab, model_dir_or_name='en-glove-6b-50d', requires_grad=True) >>> embed_2 = StaticEmbedding(vocab, model_dir_or_name='en-word2vec-300', requires_grad=True) >>> embed = StackEmbedding([embed_1, embed_2])
-
__init__(embeds: List[fastNLP.embeddings.embedding.TokenEmbedding], word_dropout=0, dropout=0)[源代码]¶ 参数: - embeds -- 一个由若干个TokenEmbedding组成的list，要求每一个TokenEmbedding的词表都保持一致
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。不同embedidng会在相同的位置 被设置为unknown。如果这里设置了dropout，则组成的embedding就不要再设置dropout了。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
-
append(embed: fastNLP.embeddings.embedding.TokenEmbedding)[源代码]¶ 添加一个embedding到结尾。 :param embed: :return:
-
embed_size¶ 该Embedding输出的vector的最后一维的维度。 :return:
-
-
class
fastNLP.embeddings.LSTMCharEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, hidden_size=50, pool_method: str = 'max', activation='relu', min_char_freq: int = 2, bidirectional=True, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.LSTMCharEmbeddingfastNLP.embeddings.char_embedding.LSTMCharEmbedding使用LSTM的方式对character进行encode. embed(x) -> Dropout(x) -> LSTM(x) -> activation(x) -> pool -> Dropout
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import LSTMCharEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = LSTMCharEmbedding(vocab, embed_size=50) >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5，50])
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, hidden_size=50, pool_method: str = 'max', activation='relu', min_char_freq: int = 2, bidirectional=True, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 参数: - vocab -- 词表
- embed_size -- LSTMCharEmbedding的输出维度。默认值为50.
- char_emb_size -- character的embedding的维度。默认值为50.
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout -- 以多大概率drop character embedding的输出以及最终的word的输出。
- hidden_size -- LSTM的中间hidden的大小，如果为bidirectional的，hidden会除二，默认为50.
- pool_method -- 支持'max', 'avg'。
- activation -- 激活函数，支持'relu', 'sigmoid', 'tanh', 或者自定义函数.
- min_char_freq -- character的最小出现次数。默认值为2.
- bidirectional -- 是否使用双向的LSTM进行encode。默认值为True。
- pre_train_char_embed -- 可以有两种方式调用预训练好的character embedding：第一种是传入embedding文件夹 (文件夹下应该只有一个以.txt作为后缀的文件)或文件路径；第二种是传入embedding的名称，第二种情况将自动查看缓存中是否存在该模型， 没有的话将自动下载。如果输入为None则使用embedding_dim的维度随机初始化一个embedding.
- requires_grad -- 是否更新权重
- include_word_start_end -- 是否在每个word开始的character前和结束的character增加特殊标示符号；
-
-
class
fastNLP.embeddings.CNNCharEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, filter_nums: List[int] = (40, 30, 20), kernel_sizes: List[int] = (5, 3, 1), pool_method: str = 'max', activation='relu', min_char_freq: int = 2, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.CNNCharEmbeddingfastNLP.embeddings.char_embedding.CNNCharEmbedding使用CNN生成character embedding。CNN的结构为, embed(x) -> Dropout(x) -> CNN(x) -> activation(x) -> pool -> fc -> Dropout. 不同的kernel大小的fitler结果是concat起来然后通过一层fully connected layer, 然后输出word的表示。
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import CNNCharEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = CNNCharEmbedding(vocab, embed_size=50) >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5，50])
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, filter_nums: List[int] = (40, 30, 20), kernel_sizes: List[int] = (5, 3, 1), pool_method: str = 'max', activation='relu', min_char_freq: int = 2, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 参数: - vocab -- 词表
- embed_size -- 该CNNCharEmbedding的输出维度大小，默认值为50.
- char_emb_size -- character的embed的维度。character是从vocab中生成的。默认值为50.
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率drop分布式表示与char embedding的输出。
- filter_nums -- filter的数量. 长度需要和kernels一致。默认值为[40, 30, 20].
- kernel_sizes -- kernel的大小. 默认值为[5, 3, 1].
- pool_method -- character的表示在合成一个表示时所使用的pool方法，支持'avg', 'max'.
- activation -- CNN之后使用的激活方法，支持'relu', 'sigmoid', 'tanh' 或者自定义函数.
- min_char_freq -- character的最少出现次数。默认值为2.
- pre_train_char_embed -- 可以有两种方式调用预训练好的character embedding：第一种是传入embedding文件夹 (文件夹下应该只有一个以.txt作为后缀的文件)或文件路径；第二种是传入embedding的名称，第二种情况将自动查看缓存中是否存在该模型， 没有的话将自动下载。如果输入为None则使用embedding_dim的维度随机初始化一个embedding.
- requires_grad -- 是否更新权重
- include_word_start_end -- 是否在每个word开始的character前和结束的character增加特殊标示符号；
-
-
fastNLP.embeddings.get_embeddings(init_embed)[源代码]¶ 别名
fastNLP.embeddings.get_embeddingsfastNLP.embeddings.utils.get_embeddings根据输入的init_embed返回Embedding对象。如果输入是tuple, 则随机初始化一个nn.Embedding; 如果输入是numpy.ndarray, 则按照ndarray 的值将nn.Embedding初始化; 如果输入是torch.Tensor, 则按该值初始化nn.Embedding; 如果输入是fastNLP中的embedding将不做处理 返回原对象。
参数: init_embed -- 可以是 tuple:(num_embedings, embedding_dim), 即embedding的大小和每个词的维度;也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding; 传入np.ndarray也行，将使用传入的ndarray作为作为Embedding初始化; 传入torch.Tensor, 将使用传入的值作为Embedding初始化。 Return nn.Embedding: embeddings
子模块¶
-
class
fastNLP.embeddings.bert_embedding.BertEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pool_method: str = 'first', word_dropout=0, dropout=0, include_cls_sep: bool = False, pooled_cls=True, requires_grad: bool = True, auto_truncate: bool = False)[源代码]¶ 基类
fastNLP.embeddings.ContextualEmbedding别名
fastNLP.embeddings.BertEmbeddingfastNLP.embeddings.bert_embedding.BertEmbedding使用BERT对words进行编码的Embedding。建议将输入的words长度限制在430以内，而不要使用512(根据预训练模型参数，可能有变化)。这是由于 预训练的bert模型长度限制为512个token，而因为输入的word是未进行word piece分割的(word piece的分割有BertEmbedding在输入word 时切分)，在分割之后长度可能会超过最大长度限制。
BertEmbedding可以支持自动下载权重，当前支持的模型有以下的几种(待补充):
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import BertEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = BertEmbedding(vocab, model_dir_or_name='en-base-uncased', requires_grad=False, layers='4,-2,-1') >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5, 2304])
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pool_method: str = 'first', word_dropout=0, dropout=0, include_cls_sep: bool = False, pooled_cls=True, requires_grad: bool = True, auto_truncate: bool = False)[源代码]¶ 参数: - vocab (Vocabulary) -- 词表
- model_dir_or_name (str) -- 模型所在目录或者模型的名称。当传入模型所在目录时，目录中应该包含一个词表文件(以.txt作为后缀名), 权重文件(以.bin作为文件后缀名), 配置文件(以.json作为后缀名)。
- layers (str) -- 输出embedding表示来自于哪些层，不同层的结果按照layers中的顺序在最后一维concat起来。以','隔开层数，层的序号是 从0开始，可以以负数去索引倒数几层。
- pool_method (str) -- 因为在bert中，每个word会被表示为多个word pieces, 当获取一个word的表示的时候，怎样从它的word pieces
中计算得到它对应的表示。支持
last,first,avg,max。 - word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- include_cls_sep (bool) -- bool，在bert计算句子的表示的时候，需要在前面加上[CLS]和[SEP], 是否在结果中保留这两个内容。 这样 会使得word embedding的结果比输入的结果长两个token。如果该值为True，则在使用 :class::StackEmbedding 可能会与其它类型的 embedding长度不匹配。
- pooled_cls (bool) -- 返回的[CLS]是否使用预训练中的BertPool映射一下，仅在include_cls_sep时有效。如果下游任务只取[CLS]做预测， 一般该值为True。
- requires_grad (bool) -- 是否需要gradient以更新Bert的权重。
- auto_truncate (bool) -- 当句子words拆分为word pieces长度超过bert最大允许长度(一般为512), 自动截掉拆分后的超过510个 word pieces后的内容，并将第512个word piece置为[SEP]。超过长度的部分的encode结果直接全部置零。一般仅有只使用[CLS] 来进行分类的任务将auto_truncate置为True。
-
-
class
fastNLP.embeddings.bert_embedding.BertWordPieceEncoder(model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pooled_cls: bool = False, word_dropout=0, dropout=0, requires_grad: bool = True)[源代码]¶ 别名
fastNLP.embeddings.BertWordPieceEncoderfastNLP.embeddings.bert_embedding.BertWordPieceEncoder读取bert模型，读取之后调用index_dataset方法在dataset中生成word_pieces这一列。
-
__init__(model_dir_or_name: str = 'en-base-uncased', layers: str = '-1', pooled_cls: bool = False, word_dropout=0, dropout=0, requires_grad: bool = True)[源代码]¶ 参数: - model_dir_or_name (str) -- 模型所在目录或者模型的名称。默认值为
en-base-uncased - layers (str) -- 最终结果中的表示。以','隔开层数，可以以负数去索引倒数几层
- pooled_cls (bool) -- 返回的句子开头的[CLS]是否使用预训练中的BertPool映射一下。如果下游任务取[CLS]做预测，一般该值为True。
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- requires_grad (bool) -- 是否需要gradient。
- model_dir_or_name (str) -- 模型所在目录或者模型的名称。默认值为
-
drop_word(words)[源代码]¶ 按照设定随机将words设置为unknown_index。
参数: words (torch.LongTensor) -- batch_size x max_len 返回:
-
forward(word_pieces, token_type_ids=None)[源代码]¶ 计算words的bert embedding表示。传入的words中应该自行包含[CLS]与[SEP]的tag。
参数: - words -- batch_size x max_len
- token_type_ids -- batch_size x max_len, 用于区分前一句和后一句话. 如果不传入，则自动生成(大部分情况，都不需要输入), 第一个[SEP]及之前为0, 第二个[SEP]及到第一个[SEP]之间为1; 第三个[SEP]及到第二个[SEP]之间为0，依次往后推。
返回: torch.FloatTensor. batch_size x max_len x (768*len(self.layers))
-
index_datasets(*datasets, field_name, add_cls_sep=True)[源代码]¶ 使用bert的tokenizer新生成word_pieces列加入到datasets中，并将他们设置为input,且将word_pieces这一列的pad value设置为了 bert的pad value。
参数: - datasets (DataSet) -- DataSet对象
- field_name (str) -- 基于哪一列的内容生成word_pieces列。这一列中每个数据应该是List[str]的形式。
- add_cls_sep (bool) -- 如果首尾不是[CLS]与[SEP]会在首尾额外加入[CLS]与[SEP]。
返回:
-
该文件中主要包含的是character的Embedding，包括基于CNN与LSTM的character Embedding。与其它Embedding一样，这里的Embedding输入也是 词的index而不需要使用词语中的char的index来获取表达。
-
class
fastNLP.embeddings.char_embedding.CNNCharEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, filter_nums: List[int] = (40, 30, 20), kernel_sizes: List[int] = (5, 3, 1), pool_method: str = 'max', activation='relu', min_char_freq: int = 2, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.CNNCharEmbeddingfastNLP.embeddings.char_embedding.CNNCharEmbedding使用CNN生成character embedding。CNN的结构为, embed(x) -> Dropout(x) -> CNN(x) -> activation(x) -> pool -> fc -> Dropout. 不同的kernel大小的fitler结果是concat起来然后通过一层fully connected layer, 然后输出word的表示。
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import CNNCharEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = CNNCharEmbedding(vocab, embed_size=50) >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5，50])
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, filter_nums: List[int] = (40, 30, 20), kernel_sizes: List[int] = (5, 3, 1), pool_method: str = 'max', activation='relu', min_char_freq: int = 2, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 参数: - vocab -- 词表
- embed_size -- 该CNNCharEmbedding的输出维度大小，默认值为50.
- char_emb_size -- character的embed的维度。character是从vocab中生成的。默认值为50.
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率drop分布式表示与char embedding的输出。
- filter_nums -- filter的数量. 长度需要和kernels一致。默认值为[40, 30, 20].
- kernel_sizes -- kernel的大小. 默认值为[5, 3, 1].
- pool_method -- character的表示在合成一个表示时所使用的pool方法，支持'avg', 'max'.
- activation -- CNN之后使用的激活方法，支持'relu', 'sigmoid', 'tanh' 或者自定义函数.
- min_char_freq -- character的最少出现次数。默认值为2.
- pre_train_char_embed -- 可以有两种方式调用预训练好的character embedding：第一种是传入embedding文件夹 (文件夹下应该只有一个以.txt作为后缀的文件)或文件路径；第二种是传入embedding的名称，第二种情况将自动查看缓存中是否存在该模型， 没有的话将自动下载。如果输入为None则使用embedding_dim的维度随机初始化一个embedding.
- requires_grad -- 是否更新权重
- include_word_start_end -- 是否在每个word开始的character前和结束的character增加特殊标示符号；
-
-
class
fastNLP.embeddings.char_embedding.LSTMCharEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, hidden_size=50, pool_method: str = 'max', activation='relu', min_char_freq: int = 2, bidirectional=True, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.LSTMCharEmbeddingfastNLP.embeddings.char_embedding.LSTMCharEmbedding使用LSTM的方式对character进行encode. embed(x) -> Dropout(x) -> LSTM(x) -> activation(x) -> pool -> Dropout
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import LSTMCharEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = LSTMCharEmbedding(vocab, embed_size=50) >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5，50])
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, embed_size: int = 50, char_emb_size: int = 50, word_dropout: float = 0, dropout: float = 0, hidden_size=50, pool_method: str = 'max', activation='relu', min_char_freq: int = 2, bidirectional=True, pre_train_char_embed: str = None, requires_grad: bool = True, include_word_start_end: bool = True)[源代码]¶ 参数: - vocab -- 词表
- embed_size -- LSTMCharEmbedding的输出维度。默认值为50.
- char_emb_size -- character的embedding的维度。默认值为50.
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout -- 以多大概率drop character embedding的输出以及最终的word的输出。
- hidden_size -- LSTM的中间hidden的大小，如果为bidirectional的，hidden会除二，默认为50.
- pool_method -- 支持'max', 'avg'。
- activation -- 激活函数，支持'relu', 'sigmoid', 'tanh', 或者自定义函数.
- min_char_freq -- character的最小出现次数。默认值为2.
- bidirectional -- 是否使用双向的LSTM进行encode。默认值为True。
- pre_train_char_embed -- 可以有两种方式调用预训练好的character embedding：第一种是传入embedding文件夹 (文件夹下应该只有一个以.txt作为后缀的文件)或文件路径；第二种是传入embedding的名称，第二种情况将自动查看缓存中是否存在该模型， 没有的话将自动下载。如果输入为None则使用embedding_dim的维度随机初始化一个embedding.
- requires_grad -- 是否更新权重
- include_word_start_end -- 是否在每个word开始的character前和结束的character增加特殊标示符号；
-
-
class
fastNLP.embeddings.contextual_embedding.ContextualEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, word_dropout: float = 0.0, dropout: float = 0.0)[源代码]¶ ContextualEmbedding组件. BertEmbedding与ElmoEmbedding的基类
-
add_sentence_cache(*datasets, batch_size=32, device='cpu', delete_weights: bool = True)[源代码]¶ 由于动态embedding生成比较耗时，所以可以把每句话embedding缓存下来，这样就不需要每次都运行生成过程。
参数: - datasets -- DataSet对象
- batch_size -- int, 生成cache的sentence表示时使用的batch的大小
- device -- 参考 :class::fastNLP.Trainer 的device
- delete_weights -- 似乎在生成了cache之后删除权重，在不需要finetune动态模型的情况下，删除权重会大量减少内存占用。
返回:
-
-
class
fastNLP.embeddings.elmo_embedding.ElmoEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '2', requires_grad: bool = True, word_dropout=0.0, dropout=0.0, cache_word_reprs: bool = False)[源代码]¶ 基类
fastNLP.embeddings.ContextualEmbedding别名
fastNLP.embeddings.ElmoEmbeddingfastNLP.embeddings.elmo_embedding.ElmoEmbedding使用ELMo的embedding。初始化之后，只需要传入words就可以得到对应的embedding。当前支持的使用名称初始化的模型有以下的这些(待补充)
Example:
>>> import torch >>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import ElmoEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> # 使用不同层的concat的结果 >>> embed = ElmoEmbedding(vocab, model_dir_or_name='en', layers='1,2', requires_grad=False) >>> words = torch.LongTensor([[vocab.to_index(word) for word in "The whether is good .".split()]]) >>> outputs = embed(words) >>> outputs.size() >>> # torch.Size([1, 5, 2048]) >>> # 使用不同层的weighted sum。 >>> embed = ElmoEmbedding(vocab, model_dir_or_name='en', layers='mix', requires_grad=False) >>> embed.set_mix_weights_requires_grad() # 使得weighted的权重是可以学习的，但ELMO的LSTM部分是不更新
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', layers: str = '2', requires_grad: bool = True, word_dropout=0.0, dropout=0.0, cache_word_reprs: bool = False)[源代码]¶ 参数: - vocab -- 词表
- model_dir_or_name -- 可以有两种方式调用预训练好的ELMo embedding：第一种是传入ELMo所在文件夹，该文件夹下面应该有两个文件， 其中一个是以json为后缀的配置文件，另一个是以pkl为后缀的权重文件；第二种是传入ELMo版本的名称，将自动查看缓存中是否存在该模型， 没有的话将自动下载并缓存。
- layers -- str, 指定返回的层数(从0开始), 以,隔开不同的层。如果要返回第二层的结果'2', 返回后两层的结果'1,2'。不同的层的结果 按照这个顺序concat起来，默认为'2'。'mix'会使用可学习的权重结合不同层的表示(权重是否可训练与requires_grad保持一致， 初始化权重对三层结果进行mean-pooling, 可以通过ElmoEmbedding.set_mix_weights_requires_grad()方法只将mix weights设置为可学习。)
- requires_grad -- bool, 该层是否需要gradient, 默认为False.
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- cache_word_reprs -- 可以选择对word的表示进行cache; 设置为True的话，将在初始化的时候为每个word生成对应的embedding， 并删除character encoder，之后将直接使用cache的embedding。默认为False。
-
forward(words: torch.LongTensor)[源代码]¶ 计算words的elmo embedding表示。根据elmo文章中介绍的ELMO实际上是有2L+1层结果，但是为了让结果比较容易拆分，token的 被重复了一次，使得实际上layer=0的结果是[token_embedding;token_embedding], 而layer=1的结果是[forward_hiddens; backward_hiddens].
参数: words -- batch_size x max_len 返回: torch.FloatTensor. batch_size x max_len x (512*len(self.layers))
-
该模块中的Embedding主要用于随机初始化的embedding(更推荐使用 fastNLP.embeddings.StaticEmbedding )，或按照预训练权重初始化Embedding。
-
class
fastNLP.embeddings.embedding.Embedding(init_embed, word_dropout=0, dropout=0.0, unk_index=None)[源代码]¶ 别名
fastNLP.embeddings.EmbeddingfastNLP.embeddings.embedding.Embedding词向量嵌入，支持输入多种方式初始化. 可以通过self.num_embeddings获取词表大小; self.embedding_dim获取embedding的维度.
Example:
>>> import numpy as np >>> from fastNLP.embeddings import Embedding >>> init_embed = (2000, 100) >>> embed = Embedding(init_embed) # 随机初始化一个具有2000个词，每个词表示为100维的词向量 >>> init_embed = np.zeros((2000, 100)) >>> embed = Embedding(init_embed) # 使用numpy.ndarray的值作为初始化值初始化一个Embedding
-
__init__(init_embed, word_dropout=0, dropout=0.0, unk_index=None)[源代码]¶ 参数: - init_embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- 支持传入Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 或传入Tensor, Embedding, numpy.ndarray等则直接使用该值初始化Embedding;
- word_dropout (float) -- 按照一定概率随机将word设置为unk_index，这样可以使得unk这个token得到足够的训练, 且会对网络有 一定的regularize的作用。设置该值时，必须同时设置unk_index
- dropout (float) -- 对Embedding的输出的dropout。
- unk_index (int) -- drop word时替换为的index。fastNLP的Vocabulary的unk_index默认为1。
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch, seq_len] 返回: torch.Tensor : [batch, seq_len, embed_dim]
-
requires_grad¶ Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许 :return:
-
-
class
fastNLP.embeddings.embedding.TokenEmbedding(vocab, word_dropout=0.0, dropout=0.0)[源代码]¶ 别名
fastNLP.embeddings.TokenEmbeddingfastNLP.embeddings.embedding.TokenEmbeddingfastNLP中各种Embedding的基类
-
drop_word(words)[源代码]¶ 按照设定随机将words设置为unknown_index。
参数: words (torch.LongTensor) -- batch_size x max_len 返回:
-
dropout(words)[源代码]¶ 对embedding后的word表示进行drop。
参数: words (torch.FloatTensor) -- batch_size x max_len x embed_size 返回:
-
num_embedding¶ 这个值可能会大于实际的embedding矩阵的大小。 :return:
-
requires_grad¶ Embedding的参数是否允许优化。True: 所有参数运行优化; False: 所有参数不允许优化; None: 部分允许优化、部分不允许 :return:
-
-
class
fastNLP.embeddings.stack_embedding.StackEmbedding(embeds: List[fastNLP.embeddings.embedding.TokenEmbedding], word_dropout=0, dropout=0)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.StackEmbeddingfastNLP.embeddings.stack_embedding.StackEmbedding支持将多个embedding集合成一个embedding。
Example:
>>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import StaticEmbedding, StackEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed_1 = StaticEmbedding(vocab, model_dir_or_name='en-glove-6b-50d', requires_grad=True) >>> embed_2 = StaticEmbedding(vocab, model_dir_or_name='en-word2vec-300', requires_grad=True) >>> embed = StackEmbedding([embed_1, embed_2])
-
__init__(embeds: List[fastNLP.embeddings.embedding.TokenEmbedding], word_dropout=0, dropout=0)[源代码]¶ 参数: - embeds -- 一个由若干个TokenEmbedding组成的list，要求每一个TokenEmbedding的词表都保持一致
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。不同embedidng会在相同的位置 被设置为unknown。如果这里设置了dropout，则组成的embedding就不要再设置dropout了。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
-
append(embed: fastNLP.embeddings.embedding.TokenEmbedding)[源代码]¶ 添加一个embedding到结尾。 :param embed: :return:
-
embed_size¶ 该Embedding输出的vector的最后一维的维度。 :return:
-
-
class
fastNLP.embeddings.static_embedding.StaticEmbedding(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', embedding_dim=-1, requires_grad: bool = True, init_method=None, lower=False, dropout=0, word_dropout=0, normalize=False, min_freq=1, **kwargs)[源代码]¶ 基类
fastNLP.embeddings.TokenEmbedding别名
fastNLP.embeddings.StaticEmbeddingfastNLP.embeddings.static_embedding.StaticEmbeddingStaticEmbedding组件. 给定预训练embedding的名称或路径，根据vocab从embedding中抽取相应的数据(只会将出现在vocab中的词抽取出来， 如果没有找到，则会随机初始化一个值(但如果该word是被标记为no_create_entry的话，则不会单独创建一个值，而是会被指向unk的index))。 当前支持自动下载的预训练vector有以下的几种(待补充);
Example:
>>> from fastNLP import Vocabulary >>> from fastNLP.embeddings import StaticEmbedding >>> vocab = Vocabulary().add_word_lst("The whether is good .".split()) >>> embed = StaticEmbedding(vocab, model_dir_or_name='en-glove-50d') >>> vocab = Vocabulary().add_word_lst(["The", 'the', "THE"]) >>> embed = StaticEmbedding(vocab, model_dir_or_name="en-glove-50d", lower=True) >>> # "the", "The", "THE"它们共用一个vector，且将使用"the"在预训练词表中寻找它们的初始化表示。 >>> vocab = Vocabulary().add_word_lst(["The", "the", "THE"]) >>> embed = StaticEmbedding(vocab, model_dir_or_name=None, embedding_dim=5, lower=True) >>> words = torch.LongTensor([[vocab.to_index(word) for word in ["The", "the", "THE"]]]) >>> embed(words) >>> tensor([[[ 0.5773, 0.7251, -0.3104, 0.0777, 0.4849], [ 0.5773, 0.7251, -0.3104, 0.0777, 0.4849], [ 0.5773, 0.7251, -0.3104, 0.0777, 0.4849]]], grad_fn=<EmbeddingBackward>) # 每种word的输出是一致的。
-
__init__(vocab: fastNLP.core.vocabulary.Vocabulary, model_dir_or_name: str = 'en', embedding_dim=-1, requires_grad: bool = True, init_method=None, lower=False, dropout=0, word_dropout=0, normalize=False, min_freq=1, **kwargs)[源代码]¶ 参数: - vocab -- Vocabulary. 若该项为None则会读取所有的embedding。
- model_dir_or_name -- 可以有两种方式调用预训练好的static embedding：第一种是传入embedding文件夹(文件夹下应该只有一个 以.txt作为后缀的文件)或文件路径；第二种是传入embedding的名称，第二种情况将自动查看缓存中是否存在该模型，没有的话将自动下载。 如果输入为None则使用embedding_dim的维度随机初始化一个embedding。
- embedding_dim (int) -- 随机初始化的embedding的维度，当该值为大于0的值时，将忽略model_dir_or_name。
- requires_grad (bool) -- 是否需要gradient. 默认为True
- init_method (callable) -- 如何初始化没有找到的值。可以使用torch.nn.init.*中各种方法, 传入的方法应该接受一个tensor，并 inplace地修改其值。
- lower (bool) -- 是否将vocab中的词语小写后再和预训练的词表进行匹配。如果你的词表中包含大写的词语，或者就是需要单独 为大写的词语开辟一个vector表示，则将lower设置为False。
- dropout (float) -- 以多大的概率对embedding的表示进行Dropout。0.1即随机将10%的值置为0。
- word_dropout (float) -- 以多大的概率将一个词替换为unk。这样既可以训练unk也是一定的regularize。
- normalize (bool) -- 是否对vector进行normalize，使得每个vector的norm为1。
- min_freq (int) -- Vocabulary词频数小于这个数量的word将被指向unk。
- kwargs (dict) --
bool only_train_min_freq: 仅对train中的词语使用min_freq筛选; bool only_norm_found_vector: 是否仅对在预训练中找到的词语使用normalize; bool only_use_pretrain_word: 仅使用出现在pretrain词表中的词语。如果该词没有在预训练的词表中出现则为unk。如果词表
不需要更新设置为True。
-
-
fastNLP.embeddings.utils.get_embeddings(init_embed)[源代码]¶ 别名
fastNLP.embeddings.get_embeddingsfastNLP.embeddings.utils.get_embeddings根据输入的init_embed返回Embedding对象。如果输入是tuple, 则随机初始化一个nn.Embedding; 如果输入是numpy.ndarray, 则按照ndarray 的值将nn.Embedding初始化; 如果输入是torch.Tensor, 则按该值初始化nn.Embedding; 如果输入是fastNLP中的embedding将不做处理 返回原对象。
参数: init_embed -- 可以是 tuple:(num_embedings, embedding_dim), 即embedding的大小和每个词的维度;也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding; 传入np.ndarray也行，将使用传入的ndarray作为作为Embedding初始化; 传入torch.Tensor, 将使用传入的值作为Embedding初始化。 Return nn.Embedding: embeddings
fastNLP.io¶
用于IO的模块, 具体包括:
- 用于读入 embedding 的
EmbedLoader类, - 用于读入不同格式数据的
Loader类 - 用于处理读入数据的
Pipe类 - 用于保存和载入模型的类, 参考
model_io模块
这些类的使用方法如下:
-
class
fastNLP.io.DataBundle(vocabs: dict = None, datasets: dict = None)[源代码]¶ 别名
fastNLP.io.DataBundlefastNLP.io.data_bundle.DataBundle经过处理的数据信息，包括一系列数据集（比如：分开的训练集、验证集和测试集）以及各个field对应的vocabulary。该对象一般由fastNLP中各种 Loader的load函数生成，可以通过以下的方法获取里面的内容
Example:
data_bundle = YelpLoader().load({'train':'/path/to/train', 'dev': '/path/to/dev'}) train_vocabs = data_bundle.vocabs['train'] train_data = data_bundle.datasets['train'] dev_data = data_bundle.datasets['train']
-
__init__(vocabs: dict = None, datasets: dict = None)[源代码]¶ 参数: - vocabs -- 从名称(字符串)到
Vocabulary类型的dict - datasets -- 从名称(字符串)到
DataSet类型的dict
- vocabs -- 从名称(字符串)到
-
apply(func, new_field_name: str, **kwargs)[源代码]¶ 对DataBundle中所有的dataset使用apply方法
参数: - func (callable) -- input是instance中名为 field_name 的field的内容。
- new_field_name (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, 忽略其类型
-
apply_field(func, field_name: str, new_field_name: str, ignore_miss_dataset=True, **kwargs)[源代码]¶ 对DataBundle中所有的dataset使用apply_field方法
参数: - func (callable) -- input是instance中名为 field_name 的field的内容。
- field_name (str) -- 传入func的是哪个field。
- new_field_name (str) -- 将func返回的内容放入到 new_field_name 这个field中，如果名称与已有的field相同，则覆 盖之前的field。如果为None则不创建新的field。
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
- 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, 忽略其类型
-
copy_field(field_name, new_field_name, ignore_miss_dataset=True)[源代码]¶ 将DataBundle中所有的DataSet中名为field_name的Field复制一份并命名为叫new_field_name.
参数: - field_name (str) --
- new_field_name (str) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
delete_field(field_name, ignore_miss_dataset=True, delete_vocab=True)[源代码]¶ 将DataBundle中所有DataSet中名为field_name的field删除掉.
参数: - field_name (str) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
- delete_vocab (bool) -- 如果该field也在vocabs中存在，将该值也一并删除
返回: self
-
get_dataset(name: str) → fastNLP.core.dataset.DataSet[源代码]¶ 获取名为name的dataset
参数: name (str) -- dataset的名称，一般为'train', 'dev', 'test' 返回: DataSet
-
get_vocab(field_name: str) → fastNLP.core.vocabulary.Vocabulary[源代码]¶ 获取field名为field_name对应的vocab
参数: field_name (str) -- 名称 返回: Vocabulary
-
iter_datasets() → Union[str, fastNLP.core.dataset.DataSet][源代码]¶ 迭代data_bundle中的DataSet
Example:
for name, dataset in data_bundle.iter_datasets(): pass
返回:
-
iter_vocabs() → Union[str, fastNLP.core.vocabulary.Vocabulary][源代码]¶ 迭代data_bundle中的DataSet
Example:
- for field_name, vocab in data_bundle.iter_vocabs():
- pass
返回:
-
rename_field(field_name, new_field_name, ignore_miss_dataset=True, rename_vocab=True)[源代码]¶ 将DataBundle中所有DataSet中名为field_name的field重命名为new_field_name.
参数: - field_name (str) --
- new_field_name (str) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
- rename_vocab (bool) -- 如果该field同时也存在于vocabs中，会将该field的名称对应修改
返回: self
-
set_dataset(dataset, name: str)[源代码]¶ 参数: - dataset (DataSet) -- 传递给DataBundle的DataSet
- name (str) -- dataset的名称
返回: self
-
set_ignore_type(*field_names, flag=True, ignore_miss_dataset=True)[源代码]¶ 将DataBundle中所有的DataSet中名为*field_names的Field的ignore_type设置为flag状态
参数: - field_names (str) --
- flag (bool) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_input(*field_names, flag=True, use_1st_ins_infer_dim_type=True, ignore_miss_dataset=True)[源代码]¶ 将field_names中的field设置为input, 对data_bundle中所有的dataset执行该操作:
data_bundle.set_input('words', 'seq_len') # 将words和seq_len这两个field的input属性设置为True data_bundle.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该列是否所有数据都是同样的维度，同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_pad_val(field_name, pad_val, ignore_miss_dataset=True)[源代码]¶ 将DataBundle中所有的DataSet中名为field_name的Field的padding值设置为pad_val.
参数: - field_name (str) --
- pad_val (int) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_target(*field_names, flag=True, use_1st_ins_infer_dim_type=True, ignore_miss_dataset=True)[源代码]¶ 将field_names中的field设置为target, 对data_bundle中所有的dataset执行该操作:
data_bundle.set_target('target', 'seq_len') # 将words和target这两个field的input属性设置为True data_bundle.set_target('target', flag=False) # 将target这个field的input属性设置为False
参数: - field_names (str) -- field的名称
- flag (bool) -- 将field_name的target状态设置为flag
- use_1st_ins_infer_dim_type (bool) -- 如果为True，将不会check该列是否所有数据都是同样的维度，同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_vocab(vocab, field_name)[源代码]¶ 向DataBunlde中增加vocab
参数: - vocab (Vocabulary) -- 词表
- field_name (str) -- 这个vocab对应的field名称
返回: self
-
-
class
fastNLP.io.EmbedLoader[源代码]¶ 别名
fastNLP.io.EmbedLoaderfastNLP.io.embed_loader.EmbedLoader用于读取预训练的embedding, 读取结果可直接载入为模型参数。
-
static
load_with_vocab(embed_filepath, vocab, dtype=<class 'numpy.float32'>, padding='<pad>', unknown='<unk>', normalize=True, error='ignore', init_method=None)[源代码]¶ 从embed_filepath这个预训练的词向量中抽取出vocab这个词表的词的embedding。EmbedLoader将自动判断embed_filepath是 word2vec(第一行只有两个元素)还是glove格式的数据。
参数: - embed_filepath (str) -- 预训练的embedding的路径。
- vocab -- 词表
Vocabulary类型，读取出现在vocab中的词的embedding。 没有出现在vocab中的词的embedding将通过找到的词的embedding的正态分布采样出来，以使得整个Embedding是同分布的。 - dtype -- 读出的embedding的类型
- padding (str) -- 词表中padding的token
- unknown (str) -- 词表中unknown的token
- normalize (bool) -- 是否将每个vector归一化到norm为1
- error (str) -- ignore , strict ; 如果 ignore ，错误将自动跳过; 如果 strict , 错误将抛出。 这里主要可能出错的地方在于词表有空行或者词表出现了维度不一致。
- init_method (callable) -- 传入numpy.ndarray, 返回numpy.ndarray, 用以初始化embedding
Return numpy.ndarray: shape为 [len(vocab), dimension], dimension由pretrain的embedding决定。
-
static
load_without_vocab(embed_filepath, dtype=<class 'numpy.float32'>, padding='<pad>', unknown='<unk>', normalize=True, error='ignore')[源代码]¶ 从embed_filepath中读取预训练的word vector。根据预训练的词表读取embedding并生成一个对应的Vocabulary。
参数: - embed_filepath (str) -- 预训练的embedding的路径。
- dtype -- 读出的embedding的类型
- padding (str) -- 词表中的padding的token. 并以此用做vocab的padding。
- unknown (str) -- 词表中的unknown的token. 并以此用做vocab的unknown。
- normalize (bool) -- 是否将每个vector归一化到norm为1
- error (str) -- ignore , strict ; 如果 ignore ，错误将自动跳过; 如果 strict , 错误将抛出。这里主要可能出错的地 方在于词表有空行或者词表出现了维度不一致。
Return (numpy.ndarray, Vocabulary): Embedding的shape是[词表大小+x, 词表维度], "词表大小+x"是由于最终的大小还取决与 是否使用padding, 以及unknown有没有在词表中找到对应的词。 Vocabulary中的词的顺序与Embedding的顺序是一一对应的。
-
static
-
class
fastNLP.io.Loader[源代码]¶ 别名
fastNLP.io.LoaderfastNLP.io.loader.Loader各种数据 Loader 的基类，提供了 API 的参考. Loader支持以下的三个函数
- download() 函数：自动将该数据集下载到缓存地址，默认缓存地址为~/.fastNLP/datasets/。由于版权等原因，不是所有的Loader都实现了该方法。该方法会返回下载后文件所处的缓存地址。
- _load() 函数：从一个数据文件中读取数据，返回一个
DataSet。返回的DataSet的内容可以通过每个Loader的文档判断出。 - load() 函数：将文件分别读取为DataSet，然后将多个DataSet放入到一个DataBundle中并返回
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
class
fastNLP.io.CLSBaseLoader(sep=', ', has_header=False)[源代码]¶ -
别名
fastNLP.io.CLSBaseLoaderfastNLP.io.loader.CLSBaseLoader文本分类Loader的一个基类
原始数据中内容应该为, 每一行为一个sample，第一个逗号之前为target，第一个逗号之后为文本内容。
Example:
"1","I got 'new' tires from the..." "1","Don't waste your time..."
读取的DataSet将具备以下的数据结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... -
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.IMDBLoader[源代码]¶ -
别名
fastNLP.io.IMDBLoaderfastNLP.io.loader.IMDBLoader原始数据中内容应该为, 每一行为一个sample，制表符之前为target，制表符之后为文本内容。
Example:
neg Alan Rickman & Emma... neg I have seen this...
IMDBLoader读取后的数据将具有以下两列内容: raw_words: str, 需要分类的文本; target: str, 文本的标签 读取的DataSet具备以下的结构:
raw_words target Alan Rickman & Emma... neg I have seen this... neg ... ... -
download(dev_ratio: float = 0.0, re_download=False)[源代码]¶ 自动下载数据集，如果你使用了这个数据集，请引用以下的文章
http://www.aclweb.org/anthology/P11-1015
根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。下载完成后不从train中切分dev
参数: - dev_ratio (float) -- 如果路径中没有dev.txt。从train划分多少作为dev的数据. 如果为0，则不划分dev
- re_download (bool) -- 是否重新下载数据，以重新切分数据。
返回: str, 数据集的目录地址
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.SSTLoader[源代码]¶ -
别名
fastNLP.io.SSTLoaderfastNLP.io.loader.SSTLoader原始数据中内容应该为:
Example:
(2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)... (3 (3 (2 If) (3 (2 you) (3 (2 sometimes)...
读取之后的DataSet具有以下的结构
下面是使用SSTLoader读取的DataSet所具备的field¶ raw_words (2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)... (3 (3 (2 If) (3 (2 you) (3 (2 sometimes) ... ... raw_words列是str。
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.SST2Loader[源代码]¶ -
别名
fastNLP.io.SST2LoaderfastNLP.io.loader.SST2Loader原始数据中内容为：第一行为标题(具体内容会被忽略)，之后一行为一个sample，第一个制表符之前被认为是句子，第一个制表符之后认为是label
Example:
sentence label it 's a charming and often affecting journey . 1 unflinchingly bleak and desperate 0
读取之后DataSet将如下所示
raw_words target it 's a charming and often affecting journey . 1 unflinchingly bleak and desperate 0 ... test的DataSet没有target列。
-
download()[源代码]¶ 自动下载数据集，如果你使用了该数据集，请引用以下的文章 https://nlp.stanford.edu/pubs/SocherBauerManningNg_ACL2013.pdf :return:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.ChnSentiCorpLoader[源代码]¶ -
别名
fastNLP.io.ChnSentiCorpLoaderfastNLP.io.loader.ChnSentiCorpLoader支持读取的数据的格式为，第一行为标题(具体内容会被忽略)，之后一行为一个sample，第一个制表符之前被认为是label，第 一个制表符之后认为是句子
Example:
label text_a 1 基金痛所有投资项目一样，必须先要有所了解... 1 系统很好装，LED屏是不错，就是16比9的比例...
读取后的DataSet具有以下的field
raw_chars target 基金痛所有投资项目一样，必须先要有所了解... 1 系统很好装，LED屏是不错，就是16比9的比例... 1 ... -
download() → str[源代码]¶ 自动下载数据，该数据取自https://github.com/pengming617/bert_classification/tree/master/data，在 https://arxiv.org/pdf/1904.09223.pdf与https://arxiv.org/pdf/1906.08101.pdf有使用
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.THUCNewsLoader[源代码]¶ -
别名
fastNLP.io.THUCNewsLoaderfastNLP.io.loader.THUCNewsLoader数据集简介：document-level分类任务，新闻10分类 原始数据内容为：每行一个sample，第一个' '之前为target，第一个' '之后为raw_words
Example:
体育 调查-您如何评价热火客场胜绿军总分3-1夺赛点？...
读取后的Dataset将具有以下数据结构：
raw_words target 调查-您如何评价热火客场胜绿军总分3-1夺赛点？... 体育 ... ... -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.WeiboSenti100kLoader[源代码]¶ -
别名
fastNLP.io.WeiboSenti100kLoaderfastNLP.io.loader.WeiboSenti100kLoader别名： 数据集简介：微博sentiment classification，二分类
Example:
label text 1 多谢小莲，好运满满[爱你] 1 能在他乡遇老友真不赖，哈哈，珠儿，我也要用...
读取后的Dataset将具有以下数据结构：
raw_chars target 多谢小莲，好运满满[爱你] 1 能在他乡遇老友真不赖，哈哈，珠儿，我也要用... 1 ... ... -
download() → str[源代码]¶ 自动下载数据，该数据取自 https://github.com/SophonPlus/ChineseNlpCorpus/ 在 https://arxiv.org/abs/1906.08101 有使用 :return:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.ConllLoader(headers, indexes=None, dropna=True)[源代码]¶ -
别名
fastNLP.io.ConllLoaderfastNLP.io.loader.ConllLoaderConllLoader支持读取的数据格式: 以空行隔开两个sample，除了分割行，每一行用空格或者制表符隔开不同的元素。如下例所示:
Example:
# 文件中的内容 Nadim NNP B-NP B-PER Ladki NNP I-NP I-PER AL-AIN NNP B-NP B-LOC United NNP B-NP B-LOC Arab NNP I-NP I-LOC Emirates NNPS I-NP I-LOC 1996-12-06 CD I-NP O ... # 如果用以下的参数读取，返回的DataSet将包含raw_words和pos两个field, 这两个field的值分别取自于第0列与第1列 dataset = ConllLoader(headers=['raw_words', 'pos'], indexes=[0, 1])._load('/path/to/train.conll') # 如果用以下的参数读取，返回的DataSet将包含raw_words和ner两个field, 这两个field的值分别取自于第0列与第2列 dataset = ConllLoader(headers=['raw_words', 'ner'], indexes=[0, 3])._load('/path/to/train.conll') # 如果用以下的参数读取，返回的DataSet将包含raw_words, pos和ner三个field dataset = ConllLoader(headers=['raw_words', 'pos', 'ner'], indexes=[0, 1, 3])._load('/path/to/train.conll')
ConllLoader返回的DataSet的field由传入的headers确定。
数据中以"-DOCSTART-"开头的行将被忽略，因为该符号在conll 2003中被用为文档分割符。
-
__init__(headers, indexes=None, dropna=True)[源代码]¶ 参数: - headers (list) -- 每一列数据的名称，需为List or Tuple of str。
header与indexes一一对应 - indexes (list) -- 需要保留的数据列下标，从0开始。若为
None，则所有列都保留。Default:None - dropna (bool) -- 是否忽略非法数据，若
False，遇到非法数据时抛出ValueError。Default:True
- headers (list) -- 每一列数据的名称，需为List or Tuple of str。
-
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.Conll2003Loader[源代码]¶ -
别名
fastNLP.io.Conll2003LoaderfastNLP.io.loader.Conll2003Loader用于读取conll2003任务的数据。数据的内容应该类似与以下的内容, 第一列为raw_words, 第二列为pos, 第三列为chunking，第四列为ner。
Example:
Nadim NNP B-NP B-PER Ladki NNP I-NP I-PER AL-AIN NNP B-NP B-LOC United NNP B-NP B-LOC Arab NNP I-NP I-LOC Emirates NNPS I-NP I-LOC 1996-12-06 CD I-NP O ...
返回的DataSet的内容为
下面是Conll2003Loader加载后数据具备的结构。¶ raw_words pos chunk ner [Nadim, Ladki] [NNP, NNP] [B-NP, I-NP] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [NNP, NNP, NNP, ...] [B-NP, B-NP, I-NP, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] [...] [...] -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.Conll2003NERLoader[源代码]¶ -
别名
fastNLP.io.Conll2003NERLoaderfastNLP.io.loader.Conll2003NERLoader用于读取conll2003任务的NER数据。每一行有4列内容，空行意味着隔开两个句子
支持读取的内容如下 Example:
Nadim NNP B-NP B-PER Ladki NNP I-NP I-PER AL-AIN NNP B-NP B-LOC United NNP B-NP B-LOC Arab NNP I-NP I-LOC Emirates NNPS I-NP I-LOC 1996-12-06 CD I-NP O ...
返回的DataSet的内容为
下面是Conll2003Loader加载后数据具备的结构, target是BIO2编码¶ raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.OntoNotesNERLoader[源代码]¶ -
别名
fastNLP.io.OntoNotesNERLoaderfastNLP.io.loader.OntoNotesNERLoader用以读取OntoNotes的NER数据，同时也是Conll2012的NER任务数据。将OntoNote数据处理为conll格式的过程可以参考 https://github.com/yhcc/OntoNotes-5.0-NER。OntoNoteNERLoader将取第4列和第11列的内容。
读取的数据格式为：
Example:
bc/msnbc/00/msnbc_0000 0 0 Hi UH (TOP(FRAG(INTJ*) - - - Dan_Abrams * - bc/msnbc/00/msnbc_0000 0 1 everyone NN (NP*) - - - Dan_Abrams * - ...
返回的DataSet的内容为
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.CTBLoader[源代码]¶ -
别名
fastNLP.io.CTBLoaderfastNLP.io.loader.CTBLoader支持加载的数据应该具备以下格式, 其中第二列为词语，第四列为pos tag，第七列为依赖树的head，第八列为依赖树的label
Example:
1 印度 _ NR NR _ 3 nn _ _ 2 海军 _ NN NN _ 3 nn _ _ 3 参谋长 _ NN NN _ 5 nsubjpass _ _ 4 被 _ SB SB _ 5 pass _ _ 5 解职 _ VV VV _ 0 root _ _ 1 新华社 _ NR NR _ 7 dep _ _ 2 新德里 _ NR NR _ 7 dep _ _ 3 １２月 _ NT NT _ 7 dep _ _ ...
读取之后DataSet具备的格式为
raw_words pos dep_head dep_label [印度, 海军, ...] [NR, NN, SB, ...] [3, 3, ...] [nn, nn, ...] [新华社, 新德里, ...] [NR, NR, NT, ...] [7, 7, 7, ...] [dep, dep, dep, ...] [...] [...] [...] [...] -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://catalog.ldc.upenn.edu/LDC2013T21
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.MsraNERLoader[源代码]¶ 基类
fastNLP.io.CNNERLoader别名
fastNLP.io.MsraNERLoaderfastNLP.io.loader.MsraNERLoader读取MSRA-NER数据，数据中的格式应该类似与下列的内容
Example:
把 O 欧 B-LOC 美 B-LOC 、 O 港 B-LOC 台 B-LOC 流 O 行 O 的 O 食 O ...
读取后的DataSet包含以下的field
raw_chars target ['把', '欧'] ['O', 'B-LOC'] ['美', '、'] ['B-LOC', 'O'] [...] [...] -
download(dev_ratio: float = 0.1, re_download: bool = False) → str[源代码]¶ 自动下载MSAR-NER的数据，如果你使用该数据，请引用 Gina-Anne Levow, 2006, The Third International Chinese Language Processing Bakeoff: Word Segmentation and Named Entity Recognition.
根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。下载完成后在output_dir中有train.conll, test.conll, dev.conll三个文件。
参数: - dev_ratio (float) -- 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
- re_download (bool) -- 是否重新下载数据，以重新切分数据。
返回: str, 数据集的目录地址
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.WeiboNERLoader[源代码]¶ 基类
fastNLP.io.CNNERLoader别名
fastNLP.io.WeiboNERLoaderfastNLP.io.loader.WeiboNERLoader读取WeiboNER数据，数据中的格式应该类似与下列的内容
Example:
老 B-PER.NOM 百 I-PER.NOM 姓 I-PER.NOM 心 O ... 读取后的DataSet包含以下的field .. csv-table:: :header: "raw_chars", "target" "['老', '百', '姓']", "['B-PER.NOM', 'I-PER.NOM', 'I-PER.NOM']" "['心']", "['O']" "[...]", "[...]"
-
download() → str[源代码]¶ 自动下载Weibo-NER的数据，如果你使用了该数据，请引用 Nanyun Peng and Mark Dredze, 2015, Named Entity Recognition for Chinese Social Media with Jointly Trained Embeddings.
返回: str
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.PeopleDailyNERLoader[源代码]¶ 基类
fastNLP.io.CNNERLoader别名
fastNLP.io.PeopleDailyNERLoaderfastNLP.io.loader.PeopleDailyNERLoader支持加载的数据格式如下
Example:
中 B-ORG 共 I-ORG 中 I-ORG 央 I-ORG 致 O 中 B-ORG ...
读取后的DataSet包含以下的field
target列是基于BIO的编码方式¶ raw_chars target ['中', '共', '中', '央'] ['B-ORG', 'I-ORG', 'I-ORG', 'I-ORG'] [...] [...] -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.CSVLoader(headers=None, sep=', ', dropna=False)[源代码]¶ -
别名
fastNLP.io.CSVLoaderfastNLP.io.loader.CSVLoader读取CSV格式的数据集, 返回DataSet。-
__init__(headers=None, sep=', ', dropna=False)[源代码]¶ 参数: - headers (List[str]) -- CSV文件的文件头.定义每一列的属性名称,即返回的DataSet中`field`的名称
若为
None,则将读入文件的第一行视作headers. Default:None - sep (str) -- CSV文件中列与列之间的分隔符. Default: ","
- dropna (bool) -- 是否忽略非法数据,若
True则忽略,若False,在遇到非法数据时,抛出ValueError. Default:False
- headers (List[str]) -- CSV文件的文件头.定义每一列的属性名称,即返回的DataSet中`field`的名称
若为
-
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.JsonLoader(fields=None, dropna=False)[源代码]¶ -
别名
fastNLP.io.JsonLoaderfastNLP.io.loader.JsonLoader别名：
fastNLP.io.JsonLoaderfastNLP.io.loader.JsonLoader读取json格式数据.数据必须按行存储,每行是一个包含各类属性的json对象
param dict fields: 需要读入的json属性名称, 和读入后在DataSet中存储的field_name fields的 key 必须是json对象的属性名.fields的 value 为读入后在DataSet存储的 field_name , value 也可为None, 这时读入后的 field_name 与json对象对应属性同名fields可为None, 这时,json对象所有属性都保存在DataSet中. Default:Noneparam bool dropna: 是否忽略非法数据,若 True则忽略,若False,在遇到非法数据时,抛出ValueError. Default:False-
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.CWSLoader(dataset_name: str = None)[源代码]¶ -
别名
fastNLP.io.CWSLoaderfastNLP.io.loader.CWSLoaderCWSLoader支持的数据格式为，一行一句话，不同词之间用空格隔开, 例如：
Example:
上海 浦东 开发 与 法制 建设 同步 新华社 上海 二月 十日 电 （ 记者 谢金虎 、 张持坚 ） ...
该Loader读取后的DataSet具有如下的结构
raw_words 上海 浦东 开发 与 法制 建设 同步 新华社 上海 二月 十日 电 （ 记者 谢金虎 、 张持坚 ） ... -
__init__(dataset_name: str = None)[源代码]¶ 参数: dataset_name (str) -- data的名称，支持pku, msra, cityu(繁体), as(繁体), None
-
download(dev_ratio=0.1, re_download=False) → str[源代码]¶ 如果你使用了该数据集，请引用以下的文章:Thomas Emerson, The Second International Chinese Word Segmentation Bakeoff, 2005. 更多信息可以在http://sighan.cs.uchicago.edu/bakeoff2005/查看
参数: - dev_ratio (float) -- 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
- re_download (bool) -- 是否重新下载数据，以重新切分数据。
返回: str
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.MNLILoader[源代码]¶ -
别名
fastNLP.io.MNLILoaderfastNLP.io.loader.MNLILoader读取的数据格式为：
Example:
index promptID pairID genre sentence1_binary_parse sentence2_binary_parse sentence1_parse sentence2_parse sentence1 sentence2 label1 gold_label 0 31193 31193n government ( ( Conceptually ( cream skimming ) ) ... 1 101457 101457e telephone ( you ( ( know ( during ( ( ( the season ) and ) ( i guess ) ) )... ...
读取MNLI任务的数据，读取之后的DataSet中包含以下的内容，words0是sentence1, words1是sentence2, target是gold_label, 测试集中没 有target列。
raw_words1 raw_words2 target Conceptually cream ... Product and geography... neutral you know during the ... You lose the things to the... entailment ... ... ... -
download()[源代码]¶ 如果你使用了这个数据，请引用
https://www.nyu.edu/projects/bowman/multinli/paper.pdf :return:
-
-
class
fastNLP.io.QuoraLoader[源代码]¶ -
别名
fastNLP.io.QuoraLoaderfastNLP.io.loader.QuoraLoaderQuora matching任务的数据集Loader
支持读取的文件中的内容，应该有以下的形式, 以制表符分隔，且前三列的内容必须是：第一列是label，第二列和第三列是句子
Example:
1 How do I get funding for my web based startup idea ? How do I get seed funding pre product ? 327970 0 Is honey a viable alternative to sugar for diabetics ? How would you compare the United States ' euthanasia laws to Denmark ? 90348 ...
加载的DataSet将具备以下的field
raw_words1 raw_words2 target How do I get funding for my web based... How do I get seed funding... 1 Is honey a viable alternative ... How would you compare the United... 0 ... ... ... -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://www.kaggle.com/c/quora-question-pairs/data
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.SNLILoader[源代码]¶ -
别名
fastNLP.io.SNLILoaderfastNLP.io.loader.SNLILoader文件每一行是一个sample，每一行都为一个json对象，其数据格式为：
Example:
{"annotator_labels": ["neutral", "entailment", "neutral", "neutral", "neutral"], "captionID": "4705552913.jpg#2", "gold_label": "neutral", "pairID": "4705552913.jpg#2r1n", "sentence1": "Two women are embracing while holding to go packages.", "sentence1_binary_parse": "( ( Two women ) ( ( are ( embracing ( while ( holding ( to ( go packages ) ) ) ) ) ) . ) )", "sentence1_parse": "(ROOT (S (NP (CD Two) (NNS women)) (VP (VBP are) (VP (VBG embracing) (SBAR (IN while) (S (NP (VBG holding)) (VP (TO to) (VP (VB go) (NP (NNS packages)))))))) (. .)))", "sentence2": "The sisters are hugging goodbye while holding to go packages after just eating lunch.", "sentence2_binary_parse": "( ( The sisters ) ( ( are ( ( hugging goodbye ) ( while ( holding ( to ( ( go packages ) ( after ( just ( eating lunch ) ) ) ) ) ) ) ) ) . ) )", "sentence2_parse": "(ROOT (S (NP (DT The) (NNS sisters)) (VP (VBP are) (VP (VBG hugging) (NP (UH goodbye)) (PP (IN while) (S (VP (VBG holding) (S (VP (TO to) (VP (VB go) (NP (NNS packages)) (PP (IN after) (S (ADVP (RB just)) (VP (VBG eating) (NP (NN lunch))))))))))))) (. .)))" }
读取之后的DataSet中的field情况为
下面是使用SNLILoader加载的DataSet所具备的field¶ target raw_words1 raw_words2 neutral Two women are embracing while holding.. The sisters are hugging goodbye... entailment Two women are embracing while holding... Two woman are holding packages. ... ... ... -
download()[源代码]¶ 如果您的文章使用了这份数据，请引用
http://nlp.stanford.edu/pubs/snli_paper.pdf
返回: str
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。读取的field根据Loader初始化时传入的field决定。
参数: paths (str) -- 传入一个目录, 将在该目录下寻找snli_1.0_train.jsonl, snli_1.0_dev.jsonl 和snli_1.0_test.jsonl三个文件。 返回: 返回的 DataBundle
-
-
class
fastNLP.io.QNLILoader[源代码]¶ -
别名
fastNLP.io.QNLILoaderfastNLP.io.loader.QNLILoader第一行为标题(具体内容会被忽略)，之后每一行是一个sample，由index、问题、句子和标签构成（以制表符分割），数据结构如下：
Example:
index question sentence label 0 What came into force after the new constitution was herald? As of that day, the new constitution heralding the Second Republic came into force. entailment
QNLI数据集的Loader, 加载的DataSet将具备以下的field, raw_words1是question, raw_words2是sentence, target是label
raw_words1 raw_words2 target What came into force after the new... As of that day... entailment ... . test数据集没有target列
-
download()[源代码]¶ 如果您的实验使用到了该数据，请引用
https://arxiv.org/pdf/1809.05053.pdf
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.RTELoader[源代码]¶ -
别名
fastNLP.io.RTELoaderfastNLP.io.loader.RTELoader第一行为标题(具体内容会被忽略)，之后每一行是一个sample，由index、句子1、句子2和标签构成（以制表符分割），数据结构如下：
Example:
index sentence1 sentence2 label 0 Dana Reeve, the widow of the actor Christopher Reeve, has died of lung cancer at age 44, according to the Christopher Reeve Foundation. Christopher Reeve had an accident. not_entailment
RTE数据的loader 加载的DataSet将具备以下的field, raw_words1是sentence0，raw_words2是sentence1, target是label
raw_words1 raw_words2 target Dana Reeve, the widow of the actor... Christopher Reeve had an... not_entailment ... ... test数据集没有target列
-
download()[源代码]¶ 如果您的实验使用到了该数据，请引用GLUE Benchmark
https://openreview.net/pdf?id=rJ4km2R5t7
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.CNXNLILoader[源代码]¶ -
别名
fastNLP.io.CNXNLILoaderfastNLP.io.loader.CNXNLILoader数据集简介：中文句对NLI（本为multi-lingual的数据集，但是这里只取了中文的数据集）。原句子已被MOSES tokenizer处理，这里我们将其还原并重新按字tokenize 原始数据数据为：
Example:
premise hypo label 我们 家里 有 一个 但 我 没 找到 我 可以 用 的 时间 我们 家里 有 一个 但 我 从来 没有 时间 使用 它 . entailment
dev和test中的数据为csv或json格式，包括十多个field，这里只取与以上三个field中的数据 读取后的Dataset将具有以下数据结构：
raw_chars1 raw_chars2 target 我们 家里 有 一个 但 我 没 找到 我 可以 用 的 时间 我们 家里 有 一个 但 我 从来 没有 时间 使用 它 . 0 ... ... ... -
download() → str[源代码]¶ 自动下载数据，该数据取自 https://arxiv.org/abs/1809.05053 在 https://arxiv.org/pdf/1905.05526.pdf https://arxiv.org/pdf/1901.10125.pdf https://arxiv.org/pdf/1809.05053.pdf 有使用 :return:
-
-
class
fastNLP.io.BQCorpusLoader[源代码]¶ -
别名
fastNLP.io.BQCorpusLoaderfastNLP.io.loader.BQCorpusLoader别名： 数据集简介:句子对二分类任务（判断是否具有相同的语义） 原始数据结构为：
Example:
sentence1,sentence2,label 综合评分不足什么原因,综合评估的依据,0 什么时候我能使用微粒贷,你就赶快给我开通就行了,0
读取后的Dataset将具有以下数据结构：
raw_chars1 raw_chars2 target 综合评分不足什么原因 综合评估的依据 0 什么时候我能使用微粒贷 你就赶快给我开通就行了 0 ... ... ... -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://github.com/ymcui/Chinese-BERT-wwm
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.LCQMCLoader[源代码]¶ -
别名
fastNLP.io.LCQMCLoaderfastNLP.io.loader.LCQMCLoader数据集简介：句对匹配（question matching）
原始数据为：
Example:
喜欢打篮球的男生喜欢什么样的女生 爱打篮球的男生喜欢什么样的女生 1 你帮我设计小说的封面吧 谁能帮我给小说设计个封面？ 0
读取后的Dataset将具有以下的数据结构
raw_chars1 raw_chars2 target 喜欢打篮球的男生喜欢什么样的女生 爱打篮球的男生喜欢什么样的女生 1 你帮我设计小说的封面吧 妇可以戴耳机听音乐吗? 0 ... ... ... -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://github.com/ymcui/Chinese-BERT-wwm
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.CMRC2018Loader[源代码]¶ -
别名
fastNLP.io.CMRC2018LoaderfastNLP.io.loader.qa.CMRC2018Loader请直接使用从fastNLP下载的数据进行处理。该数据集未提供测试集，测试需要通过上传到对应的系统进行评测
读取之后训练集DataSet将具备以下的内容，每个问题的答案只有一个
:header:"title", "context", "question", "answers", "answer_starts", "id"¶ 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 范廷颂是什么时候被任为主教的？ ["1963年"] ["30"] TRAIN_186_QUERY_0 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 1990年，范廷颂担任什么职务？ ["1990年被擢升为天..."] ["41"] TRAIN_186_QUERY_1 ... ... ... ... . ... 其中title是文本的标题，多条记录可能是相同的title；id是该问题的id，具备唯一性
验证集DataSet将具备以下的内容，每个问题的答案可能有三个(有时候只是3个重复的答案)
其中answer_starts是从0开始的index。例如"我来自a复旦大学？"，其中"复"的开始index为4。另外"Russell评价说"中的说的index为9, 因为 英文和数字都直接按照character计量的。
-
download() → str[源代码]¶ 如果您使用了本数据，请引用A Span-Extraction Dataset for Chinese Machine Reading Comprehension. Yiming Cui, Ting Liu, etc.
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.Pipe[源代码]¶ 别名
fastNLP.io.PipefastNLP.io.pipe.PipePipe是fastNLP中用于处理DataBundle的类，但实际是处理DataBundle中的DataSet。所有Pipe都会在其process()函数的文档中指出该Pipe可处理的DataSet应该具备怎样的格式；在Pipe 文档中说明该Pipe返回后DataSet的格式以及其field的信息；以及新增的Vocabulary的信息。
一般情况下Pipe处理包含以下的几个过程，(1)将raw_words或raw_chars进行tokenize以切分成不同的词或字; (2) 再建立词或字的
Vocabulary, 并将词或字转换为index; (3)将target列建立词表并将target列转为index;Pipe中提供了两个方法
-process()函数，输入为DataBundle -process_from_file()函数，输入为对应Loader的load函数可接受的类型。
-
__init__¶ Initialize self. See help(type(self)) for accurate signature.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 对输入的DataBundle进行处理，然后返回该DataBundle。
参数: data_bundle (DataBundle) -- 需要处理的DataBundle对象 返回:
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：
fastNLP.io.Loader.load()参数: paths -- 返回: DataBundle
-
-
class
fastNLP.io.AGsNewsPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.AGsNewsPipefastNLP.io.pipe.AGsNewsPipe处理AG's News的数据, 处理之后DataSet中的内容如下
下面是使用AGsNewsPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.DBPediaPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.DBPediaPipefastNLP.io.pipe.DBPediaPipe处理DBPedia的数据, 处理之后DataSet中的内容如下
下面是使用DBPediaPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.YelpFullPipe(lower: bool = False, granularity=5, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.YelpFullPipefastNLP.io.pipe.YelpFullPipe处理YelpFull的数据, 处理之后DataSet中的内容如下
下面是使用YelpFullPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, granularity=5, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- granularity (int) -- 支持2, 3, 5。若为2, 则认为是2分类问题，将1、2归为1类，4、5归为一类，丢掉2；若为3, 则有3分类问题，将 1、2归为1类，3归为1类，4、5归为1类；若为5, 则有5分类问题。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
-
class
fastNLP.io.YelpPolarityPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.YelpPolarityPipefastNLP.io.pipe.YelpPolarityPipe处理YelpPolarity的数据, 处理之后DataSet中的内容如下
下面是使用YelpFullPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.SSTPipe(subtree=False, train_subtree=True, lower=False, granularity=5, tokenizer='spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.SSTPipefastNLP.io.pipe.SSTPipe经过该Pipe之后，DataSet中具备的field如下所示
下面是使用SSTPipe处理后的DataSet所具备的field¶ raw_words words target seq_len It 's a lovely film with lovely perfor... 1 [187, 6, 5, 132, 120, 70, 132, 188, 25... 13 No one goes unindicted here , which is... 0 [191, 126, 192, 193, 194, 4, 195, 17, ... 13 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(subtree=False, train_subtree=True, lower=False, granularity=5, tokenizer='spacy')[源代码]¶ 参数: - subtree (bool) -- 是否将train, test, dev数据展开为子树，扩充数据量。 Default:
False - train_subtree (bool) -- 是否将train集通过子树扩展数据。
- lower (bool) -- 是否对输入进行小写化。
- granularity (int) -- 支持2, 3, 5。若为2, 则认为是2分类问题，将0、1归为1类，3、4归为一类，丢掉2；若为3, 则有3分类问题，将 0、1归为1类，2归为1类，3、4归为1类；若为5, 则有5分类问题。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
- subtree (bool) -- 是否将train, test, dev数据展开为子树，扩充数据量。 Default:
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 对DataBundle中的数据进行预处理。输入的DataSet应该至少拥有raw_words这一列，且内容类似与
下面是使用SSTLoader读取的DataSet所具备的field¶ raw_words (2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)... (3 (3 (2 If) (3 (2 you) (3 (2 sometimes) ... ... 参数: data_bundle (DataBundle) -- 需要处理的DataBundle对象 返回:
-
-
class
fastNLP.io.SST2Pipe(lower=False, tokenizer='spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.SST2PipefastNLP.io.pipe.SST2Pipe加载SST2的数据, 处理完成之后DataSet将拥有以下的field
raw_words target words seq_len it 's a charming and often affecting j... 1 [19, 9, 6, 111, 5, 112, 113, 114, 3] 9 unflinchingly bleak and desperate 0 [115, 116, 5, 117] 4 ... ... . . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower=False, tokenizer='spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.IMDBPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.IMDBPipefastNLP.io.pipe.IMDBPipe经过本Pipe处理后DataSet将如下
输出DataSet的field¶ raw_words target words seq_len Bromwell High is a cartoon ... 0 [3, 5, 6, 9, ...] 20 Story of a man who has ... 1 [20, 43, 9, 10, ...] 31 ... . [...] . 其中raw_words为str类型，是原文; words是转换为index的输入; target是转换为index的目标值; words列被设置为input; target列被设置为target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否将words列的数据小写。
- tokenizer (str) -- 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 期待的DataBunlde中输入的DataSet应该类似于如下，有两个field，raw_words和target，且均为str类型
输入DataSet的field¶ raw_words target Bromwell High is a cartoon ... pos Story of a man who has ... neg ... ... 参数: data_bundle (DataBunlde) -- 传入的DataBundle中的DataSet必须包含raw_words和target两个field，且raw_words列应该为str, target列应该为str。 返回: DataBundle
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.ChnSentiCorpPipe(bigrams=False, trigrams=False)[源代码]¶ -
别名
fastNLP.io.ChnSentiCorpPipefastNLP.io.pipe.ChnSentiCorpPipe处理之后的DataSet有以下的结构
raw_chars target chars seq_len 這間酒店環境和服務態度亦算不錯,但房間空間太小~~ 1 [2, 3, 4, 5, ...] 31 <荐书> 推荐所有喜欢<红楼>... 1 [10, 21, ....] 25 ... 其中chars, seq_len是input，target是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(bigrams=False, trigrams=False)[源代码]¶ 参数: - bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 可以处理的DataSet应该具备以下的field
raw_chars target 這間酒店環境和服務態度亦算不錯,但房間空間太小~~ 1 <荐书> 推荐所有喜欢<红楼>... 1 ... 参数: data_bundle -- 返回:
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.THUCNewsPipe(bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.THUCNewsPipefastNLP.io.pipe.THUCNewsPipe处理之后的DataSet有以下的结构
raw_chars target chars seq_len 马晓旭意外受伤让国奥警惕 无奈大雨格外青睐殷家军记者傅亚雨沈阳报道... 0 [409, 1197, 2146, 213, ...] 746 ... 其中chars, seq_len是input，target是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
param bool bigrams: 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取. param bool trigrams: 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取. -
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 可处理的DataSet应具备如下的field
raw_words target 马晓旭意外受伤让国奥警惕 无奈大雨格外青睐殷家军记者傅亚雨沈阳报道 ... 体育 ... ... 参数: data_bundle -- 返回:
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.WeiboSenti100kPipe(bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.WeiboSenti100kPipefastNLP.io.pipe.WeiboSenti100kPipe处理之后的DataSet有以下的结构
raw_chars target chars seq_len 六一出生的？好讽刺…… //@祭春姬:他爸爸是外星人吧 //@面孔小高:现在的孩子都怎么了 [怒][怒][怒] 0 [0, 690, 18, ...] 56 ... 其中chars, seq_len是input，target是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
param bool bigrams: 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取. param bool trigrams: 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取. -
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 可处理的DataSet应具备以下的field
raw_chars target 六一出生的？好讽刺…… //@祭春姬:他爸爸是外星人吧 //@面孔小高:现在的孩子都怎么了 [怒][怒][怒] 0 ... ... 参数: data_bundle -- 返回:
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.Conll2003Pipe(chunk_encoding_type='bioes', ner_encoding_type='bioes', lower: bool = False)[源代码]¶ -
别名
fastNLP.io.Conll2003PipefastNLP.io.pipe.Conll2003Pipe经过该Pipe后，DataSet中的内容如下
raw_words pos chunk ner words seq_len [Nadim, Ladki] [0, 0] [1, 2] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [1, 2...] [3, 4...] [3, 4...] [4, 5, 6,...] 6 [...] [...] [...] [...] [...] . 其中words, seq_len是input; pos, chunk, ner, seq_len是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+-------+-------+-------+-------+---------+ | field_names | raw_words | pos | chunk | ner | words | seq_len | +-------------+-----------+-------+-------+-------+-------+---------+ | is_input | False | False | False | False | True | True | | is_target | False | True | True | True | False | True | | ignore_type | | False | False | False | False | False | | pad_value | | 0 | 0 | 0 | 0 | 0 | +-------------+-----------+-------+-------+-------+-------+---------+
-
__init__(chunk_encoding_type='bioes', ner_encoding_type='bioes', lower: bool = False)[源代码]¶ 参数: - chunk_encoding_type (str) -- 支持bioes, bio。
- ner_encoding_type (str) -- 支持bioes, bio。
- lower (bool) -- 是否将words列小写化后再建立词表
-
process(data_bundle) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 输入的DataSet应该类似于如下的形式
raw_words pos chunk ner [Nadim, Ladki] [NNP, NNP] [B-NP, I-NP] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [NNP, NNP...] [B-NP, B-NP, ...] [B-LOC, B-LOC,...] [...] [...] [...] [...] . 参数: data_bundle -- 返回: 传入的DataBundle
-
-
class
fastNLP.io.Conll2003NERPipe(encoding_type: str = 'bio', lower: bool = False)[源代码]¶ 基类
fastNLP.io._NERPipe别名
fastNLP.io.Conll2003NERPipefastNLP.io.pipe.Conll2003NERPipeConll2003的NER任务的处理Pipe, 该Pipe会（1）复制raw_words列，并命名为words; (2）在words, target列建立词表 (创建
fastNLP.Vocabulary对象，所以在返回的DataBundle中将有两个Vocabulary); (3）将words，target列根据相应的 Vocabulary转换为index。 经过该Pipe过后，DataSet中的内容如下所示Following is a demo layout of DataSet returned by Conll2003Loader¶ raw_words target words seq_len [Nadim, Ladki] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [3, 4,...] [4, 5, 6,...] 6 [...] [...] [...] . raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', lower: bool = False)¶ Param: str encoding_type: target列使用什么类型的encoding方式，支持bioes, bio两种。 参数: lower (bool) -- 是否将words小写化后再建立词表，绝大多数情况都不需要设置为True。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] 参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]在传入DataBundle基础上原位修改。 Return DataBundle:
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.ConllLoader的load函数。返回: DataBundle
-
-
class
fastNLP.io.OntoNotesNERPipe(encoding_type: str = 'bio', lower: bool = False)[源代码]¶ 基类
fastNLP.io._NERPipe别名
fastNLP.io.OntoNotesNERPipefastNLP.io.pipe.OntoNotesNERPipe处理OntoNotes的NER数据，处理之后DataSet中的field情况为
raw_words target words seq_len [Nadim, Ladki] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [3, 4] [4, 5, 6,...] 6 [...] [...] [...] . raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', lower: bool = False)¶ Param: str encoding_type: target列使用什么类型的encoding方式，支持bioes, bio两种。 参数: lower (bool) -- 是否将words小写化后再建立词表，绝大多数情况都不需要设置为True。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] 参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]在传入DataBundle基础上原位修改。 Return DataBundle:
-
-
class
fastNLP.io.MsraNERPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.MsraNERPipefastNLP.io.pipe.MsraNERPipe处理MSRA-NER的数据，处理之后的DataSet的field情况为
raw_chars target chars seq_len [相, 比, 之, 下,...] [0, 0, 0, 0, ...] [2, 3, 4, 5, ...] 11 [青, 岛, 海, 牛, 队, 和, ...] [1, 2, 3, ...] [10, 21, ....] 21 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False)¶ 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.PeopleDailyPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.PeopleDailyPipefastNLP.io.pipe.PeopleDailyPipe处理people daily的ner的数据，处理之后的DataSet的field情况为
raw_chars target chars seq_len [相, 比, 之, 下,...] [0, 0, 0, 0, ...] [2, 3, 4, 5, ...] 11 [青, 岛, 海, 牛, 队, 和, ...] [1, 2, 3, ...] [10, 21, ....] 21 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False)¶ 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.WeiboNERPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.WeiboNERPipefastNLP.io.pipe.WeiboNERPipe处理weibo的ner的数据，处理之后的DataSet的field情况为
raw_chars chars target seq_len ['老', '百', '姓'] [4, 3, 3] [38, 39, 40] 3 ['心'] [0] [41] 1 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False)¶ 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.CWSPipe(dataset_name=None, encoding_type='bmes', replace_num_alpha=True, bigrams=False, trigrams=False)[源代码]¶ -
别名
fastNLP.io.CWSPipefastNLP.io.pipe.CWSPipe对CWS数据进行预处理, 处理之后的数据，具备以下的结构
raw_words chars target seq_len 共同 创造 美好... [2, 3, 4...] [0, 2, 0, 2,...] 13 2001年 新年 钟声... [8, 9, 9, 7, ...] [0, 1, 1, 1, 2...] 20 ... [...] [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+-------+--------+---------+ | field_names | raw_words | chars | target | seq_len | +-------------+-----------+-------+--------+---------+ | is_input | False | True | True | True | | is_target | False | False | True | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+-------+--------+---------+
-
__init__(dataset_name=None, encoding_type='bmes', replace_num_alpha=True, bigrams=False, trigrams=False)[源代码]¶ 参数: - dataset_name (str,None) -- 支持'pku', 'msra', 'cityu', 'as', None
- encoding_type (str) -- 可以选择'bmes', 'segapp'两种。"我 来自 复旦大学...", bmes的tag为[S, B, E, B, M, M, E...]; segapp 的tag为[seg, app, seg, app, app, app, seg, ...]
- replace_num_alpha (bool) -- 是否将数字和字母用特殊字符替换。
- bigrams (bool) -- 是否增加一列bigram. bigram的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]
- trigrams (bool) -- 是否增加一列trigram. trigram的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]
-
-
class
fastNLP.io.Conll2003NERPipe(encoding_type: str = 'bio', lower: bool = False)[源代码] 基类
fastNLP.io._NERPipe别名
fastNLP.io.Conll2003NERPipefastNLP.io.pipe.Conll2003NERPipeConll2003的NER任务的处理Pipe, 该Pipe会（1）复制raw_words列，并命名为words; (2）在words, target列建立词表 (创建
fastNLP.Vocabulary对象，所以在返回的DataBundle中将有两个Vocabulary); (3）将words，target列根据相应的 Vocabulary转换为index。 经过该Pipe过后，DataSet中的内容如下所示Following is a demo layout of DataSet returned by Conll2003Loader¶ raw_words target words seq_len [Nadim, Ladki] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [3, 4,...] [4, 5, 6,...] 6 [...] [...] [...] . raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', lower: bool = False) Param: str encoding_type: target列使用什么类型的encoding方式，支持bioes, bio两种。 参数: lower (bool) -- 是否将words小写化后再建立词表，绝大多数情况都不需要设置为True。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle 支持的DataSet的field为
raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] 参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]在传入DataBundle基础上原位修改。 Return DataBundle:
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle[源代码] 参数: paths -- 支持路径类型参见 fastNLP.io.loader.ConllLoader的load函数。返回: DataBundle
-
-
class
fastNLP.io.OntoNotesNERPipe(encoding_type: str = 'bio', lower: bool = False)[源代码] 基类
fastNLP.io._NERPipe别名
fastNLP.io.OntoNotesNERPipefastNLP.io.pipe.OntoNotesNERPipe处理OntoNotes的NER数据，处理之后DataSet中的field情况为
raw_words target words seq_len [Nadim, Ladki] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [3, 4] [4, 5, 6,...] 6 [...] [...] [...] . raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', lower: bool = False) Param: str encoding_type: target列使用什么类型的encoding方式，支持bioes, bio两种。 参数: lower (bool) -- 是否将words小写化后再建立词表，绝大多数情况都不需要设置为True。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle 支持的DataSet的field为
raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] 参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]在传入DataBundle基础上原位修改。 Return DataBundle:
-
-
class
fastNLP.io.MsraNERPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码] 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.MsraNERPipefastNLP.io.pipe.MsraNERPipe处理MSRA-NER的数据，处理之后的DataSet的field情况为
raw_chars target chars seq_len [相, 比, 之, 下,...] [0, 0, 0, 0, ...] [2, 3, 4, 5, ...] 11 [青, 岛, 海, 牛, 队, 和, ...] [1, 2, 3, ...] [10, 21, ....] 21 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False) 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.WeiboNERPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码] 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.WeiboNERPipefastNLP.io.pipe.WeiboNERPipe处理weibo的ner的数据，处理之后的DataSet的field情况为
raw_chars chars target seq_len ['老', '百', '姓'] [4, 3, 3] [38, 39, 40] 3 ['心'] [0] [41] 1 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False) 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.PeopleDailyPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码] 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.PeopleDailyPipefastNLP.io.pipe.PeopleDailyPipe处理people daily的ner的数据，处理之后的DataSet的field情况为
raw_chars target chars seq_len [相, 比, 之, 下,...] [0, 0, 0, 0, ...] [2, 3, 4, 5, ...] 11 [青, 岛, 海, 牛, 队, 和, ...] [1, 2, 3, ...] [10, 21, ....] 21 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False) 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.Conll2003Pipe(chunk_encoding_type='bioes', ner_encoding_type='bioes', lower: bool = False)[源代码] -
别名
fastNLP.io.Conll2003PipefastNLP.io.pipe.Conll2003Pipe经过该Pipe后，DataSet中的内容如下
raw_words pos chunk ner words seq_len [Nadim, Ladki] [0, 0] [1, 2] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [1, 2...] [3, 4...] [3, 4...] [4, 5, 6,...] 6 [...] [...] [...] [...] [...] . 其中words, seq_len是input; pos, chunk, ner, seq_len是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+-------+-------+-------+-------+---------+ | field_names | raw_words | pos | chunk | ner | words | seq_len | +-------------+-----------+-------+-------+-------+-------+---------+ | is_input | False | False | False | False | True | True | | is_target | False | True | True | True | False | True | | ignore_type | | False | False | False | False | False | | pad_value | | 0 | 0 | 0 | 0 | 0 | +-------------+-----------+-------+-------+-------+-------+---------+
-
__init__(chunk_encoding_type='bioes', ner_encoding_type='bioes', lower: bool = False)[源代码] 参数: - chunk_encoding_type (str) -- 支持bioes, bio。
- ner_encoding_type (str) -- 支持bioes, bio。
- lower (bool) -- 是否将words列小写化后再建立词表
-
process(data_bundle) → fastNLP.io.data_bundle.DataBundle[源代码] 输入的DataSet应该类似于如下的形式
raw_words pos chunk ner [Nadim, Ladki] [NNP, NNP] [B-NP, I-NP] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [NNP, NNP...] [B-NP, B-NP, ...] [B-LOC, B-LOC,...] [...] [...] [...] [...] . 参数: data_bundle -- 返回: 传入的DataBundle
-
process_from_file(paths)[源代码] 参数: paths -- 返回:
-
-
class
fastNLP.io.MatchingBertPipe(lower=False, tokenizer: str = 'raw')[源代码]¶ -
别名
fastNLP.io.MatchingBertPipefastNLP.io.pipe.MatchingBertPipeMatching任务的Bert pipe，输出的DataSet将包含以下的field
raw_words1 raw_words2 target words seq_len The new rights are... Everyone really likes.. 1 [2, 3, 4, 5, ...] 10 This site includes a... The Government Executive... 0 [11, 12, 13,...] 5 ... ... . [...] . words列是将raw_words1(即premise), raw_words2(即hypothesis)使用"[SEP]"链接起来转换为index的。 words列被设置为input，target列被设置为target和input(设置为input以方便在forward函数中计算loss， 如果不在forward函数中计算loss也不影响，fastNLP将根据forward函数的形参名进行传参).
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+------------+------------+--------+-------+---------+ | field_names | raw_words1 | raw_words2 | target | words | seq_len | +-------------+------------+------------+--------+-------+---------+ | is_input | False | False | False | True | True | | is_target | False | False | True | False | False | | ignore_type | | | False | False | False | | pad_value | | | 0 | 0 | 0 | +-------------+------------+------------+--------+-------+---------+
-
__init__(lower=False, tokenizer: str = 'raw')[源代码]¶ 参数: - lower (bool) -- 是否将word小写化。
- tokenizer (str) -- 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-
process(data_bundle)[源代码]¶ 输入的data_bundle中的dataset需要具有以下结构：
raw_words1 raw_words2 target Dana Reeve, the widow of the actor... Christopher Reeve had an... not_entailment ... ... 参数: data_bundle -- 返回:
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle¶ 传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：
fastNLP.io.Loader.load()参数: paths -- 返回: DataBundle
-
-
class
fastNLP.io.MatchingPipe(lower=False, tokenizer: str = 'raw')[源代码]¶ -
别名
fastNLP.io.MatchingPipefastNLP.io.pipe.MatchingPipeMatching任务的Pipe。输出的DataSet将包含以下的field
raw_words1 raw_words2 target words1 words2 seq_len1 seq_len2 The new rights are... Everyone really likes.. 1 [2, 3, 4, 5, ...] [10, 20, 6] 10 13 This site includes a... The Government Executive... 0 [11, 12, 13,...] [2, 7, ...] 6 7 ... ... . [...] [...] . . words1是premise，words2是hypothesis。其中words1,words2,seq_len1,seq_len2被设置为input；target被设置为target 和input(设置为input以方便在forward函数中计算loss，如果不在forward函数中计算loss也不影响，fastNLP将根据forward函数 的形参名进行传参)。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+------------+------------+--------+--------+--------+----------+----------+ | field_names | raw_words1 | raw_words2 | target | words1 | words2 | seq_len1 | seq_len2 | +-------------+------------+------------+--------+--------+--------+----------+----------+ | is_input | False | False | False | True | True | True | True | | is_target | False | False | True | False | False | False | False | | ignore_type | | | False | False | False | False | False | | pad_value | | | 0 | 0 | 0 | 0 | 0 | +-------------+------------+------------+--------+--------+--------+----------+----------+
-
__init__(lower=False, tokenizer: str = 'raw')[源代码]¶ 参数: - lower (bool) -- 是否将所有raw_words转为小写。
- tokenizer (str) -- 将原始数据tokenize的方式。支持spacy, raw. spacy是使用spacy切分，raw就是用空格切分。
-
process(data_bundle)[源代码]¶ 接受的DataBundle中的DataSet应该具有以下的field, target列可以没有
raw_words1 raw_words2 target The new rights are... Everyone really likes.. entailment This site includes a... The Government Executive... not_entailment ... ... 参数: data_bundle (DataBundle) -- 通过loader读取得到的data_bundle，里面包含了数据集的原始数据内容 返回: data_bundle
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle¶ 传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：
fastNLP.io.Loader.load()参数: paths -- 返回: DataBundle
-
-
class
fastNLP.io.CMRC2018BertPipe(max_len=510)[源代码]¶ -
别名
fastNLP.io.CMRC2018BertPipefastNLP.io.pipe.qa.CMRC2018BertPipe处理之后的DataSet将新增以下的field(传入的field仍然保留)
:header: "context_len", "raw_chars", "target_start", "target_end", "chars" 492, ['范', '廷', '颂... ], 30, 34, [21, 25, ...] 491, ['范', '廷', '颂... ], 41, 61, [21, 25, ...]¶ . ... ... ... ... raw_words列是context与question拼起来的结果(连接的地方加入了[SEP])，words是转为index的值, target_start为答案start的index，target_end为答案end的index （闭区间）；context_len指示的是words列中context的长度。
- 其中各列的meta信息如下:
field_names context_len raw_chars target_start target_end chars answersFalse True True
0is_inputis_target
- ignore_type
- pad_value
- False
- True
- False
- 0
- False
True True
0
- False
- True
- False
- 0
- False
- True
- False
- 0
TrueFalse False
0
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 传入的DataSet应该具备以下的field
:header:"title", "context", "question", "answers", "answer_starts", "id"¶ 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 范廷颂是什么时候被任为主教的？ ["1963年"] ["30"] TRAIN_186_QUERY_0 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 1990年，范廷颂担任什么职务？ ["1990年被擢升为天..."] ["41"] TRAIN_186_QUERY_1 ... ... ... ... . ... 参数: data_bundle -- 返回:
-
class
fastNLP.io.ModelLoader[源代码]¶ 别名
fastNLP.io.ModelLoaderfastNLP.io.model_io.ModelLoader用于读取模型
-
class
fastNLP.io.ModelSaver(save_path)[源代码]¶ 别名
fastNLP.io.ModelSaverfastNLP.io.model_io.ModelSaver用于保存模型
Example:
saver = ModelSaver("./save/model_ckpt_100.pkl") saver.save_pytorch(model)
子模块¶
-
class
fastNLP.io.data_bundle.DataBundle(vocabs: dict = None, datasets: dict = None)[源代码]¶ 别名
fastNLP.io.DataBundlefastNLP.io.data_bundle.DataBundle经过处理的数据信息，包括一系列数据集（比如：分开的训练集、验证集和测试集）以及各个field对应的vocabulary。该对象一般由fastNLP中各种 Loader的load函数生成，可以通过以下的方法获取里面的内容
Example:
data_bundle = YelpLoader().load({'train':'/path/to/train', 'dev': '/path/to/dev'}) train_vocabs = data_bundle.vocabs['train'] train_data = data_bundle.datasets['train'] dev_data = data_bundle.datasets['train']
-
__init__(vocabs: dict = None, datasets: dict = None)[源代码]¶ 参数: - vocabs -- 从名称(字符串)到
Vocabulary类型的dict - datasets -- 从名称(字符串)到
DataSet类型的dict
- vocabs -- 从名称(字符串)到
-
apply(func, new_field_name: str, **kwargs)[源代码]¶ 对DataBundle中所有的dataset使用apply方法
参数: - func (callable) -- input是instance中名为 field_name 的field的内容。
- new_field_name (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, 忽略其类型
-
apply_field(func, field_name: str, new_field_name: str, ignore_miss_dataset=True, **kwargs)[源代码]¶ 对DataBundle中所有的dataset使用apply_field方法
参数: - func (callable) -- input是instance中名为 field_name 的field的内容。
- field_name (str) -- 传入func的是哪个field。
- new_field_name (str) -- 将func返回的内容放入到 new_field_name 这个field中，如果名称与已有的field相同，则覆 盖之前的field。如果为None则不创建新的field。
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
- 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, 忽略其类型
-
copy_field(field_name, new_field_name, ignore_miss_dataset=True)[源代码]¶ 将DataBundle中所有的DataSet中名为field_name的Field复制一份并命名为叫new_field_name.
参数: - field_name (str) --
- new_field_name (str) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
delete_field(field_name, ignore_miss_dataset=True, delete_vocab=True)[源代码]¶ 将DataBundle中所有DataSet中名为field_name的field删除掉.
参数: - field_name (str) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
- delete_vocab (bool) -- 如果该field也在vocabs中存在，将该值也一并删除
返回: self
-
get_dataset(name: str) → fastNLP.core.dataset.DataSet[源代码]¶ 获取名为name的dataset
参数: name (str) -- dataset的名称，一般为'train', 'dev', 'test' 返回: DataSet
-
get_vocab(field_name: str) → fastNLP.core.vocabulary.Vocabulary[源代码]¶ 获取field名为field_name对应的vocab
参数: field_name (str) -- 名称 返回: Vocabulary
-
iter_datasets() → Union[str, fastNLP.core.dataset.DataSet][源代码]¶ 迭代data_bundle中的DataSet
Example:
for name, dataset in data_bundle.iter_datasets(): pass
返回:
-
iter_vocabs() → Union[str, fastNLP.core.vocabulary.Vocabulary][源代码]¶ 迭代data_bundle中的DataSet
Example:
- for field_name, vocab in data_bundle.iter_vocabs():
- pass
返回:
-
rename_field(field_name, new_field_name, ignore_miss_dataset=True, rename_vocab=True)[源代码]¶ 将DataBundle中所有DataSet中名为field_name的field重命名为new_field_name.
参数: - field_name (str) --
- new_field_name (str) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
- rename_vocab (bool) -- 如果该field同时也存在于vocabs中，会将该field的名称对应修改
返回: self
-
set_dataset(dataset, name: str)[源代码]¶ 参数: - dataset (DataSet) -- 传递给DataBundle的DataSet
- name (str) -- dataset的名称
返回: self
-
set_ignore_type(*field_names, flag=True, ignore_miss_dataset=True)[源代码]¶ 将DataBundle中所有的DataSet中名为*field_names的Field的ignore_type设置为flag状态
参数: - field_names (str) --
- flag (bool) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_input(*field_names, flag=True, use_1st_ins_infer_dim_type=True, ignore_miss_dataset=True)[源代码]¶ 将field_names中的field设置为input, 对data_bundle中所有的dataset执行该操作:
data_bundle.set_input('words', 'seq_len') # 将words和seq_len这两个field的input属性设置为True data_bundle.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该列是否所有数据都是同样的维度，同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_pad_val(field_name, pad_val, ignore_miss_dataset=True)[源代码]¶ 将DataBundle中所有的DataSet中名为field_name的Field的padding值设置为pad_val.
参数: - field_name (str) --
- pad_val (int) --
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_target(*field_names, flag=True, use_1st_ins_infer_dim_type=True, ignore_miss_dataset=True)[源代码]¶ 将field_names中的field设置为target, 对data_bundle中所有的dataset执行该操作:
data_bundle.set_target('target', 'seq_len') # 将words和target这两个field的input属性设置为True data_bundle.set_target('target', flag=False) # 将target这个field的input属性设置为False
参数: - field_names (str) -- field的名称
- flag (bool) -- 将field_name的target状态设置为flag
- use_1st_ins_infer_dim_type (bool) -- 如果为True，将不会check该列是否所有数据都是同样的维度，同样的类型。将直接使用第一 行的数据进行类型和维度推断本列的数据的类型和维度。
- ignore_miss_dataset (bool) -- 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet; 如果为False，则报错
返回: self
-
set_vocab(vocab, field_name)[源代码]¶ 向DataBunlde中增加vocab
参数: - vocab (Vocabulary) -- 词表
- field_name (str) -- 这个vocab对应的field名称
返回: self
-
-
class
fastNLP.io.embed_loader.EmbedLoader[源代码]¶ 别名
fastNLP.io.EmbedLoaderfastNLP.io.embed_loader.EmbedLoader用于读取预训练的embedding, 读取结果可直接载入为模型参数。
-
static
load_with_vocab(embed_filepath, vocab, dtype=<class 'numpy.float32'>, padding='<pad>', unknown='<unk>', normalize=True, error='ignore', init_method=None)[源代码]¶ 从embed_filepath这个预训练的词向量中抽取出vocab这个词表的词的embedding。EmbedLoader将自动判断embed_filepath是 word2vec(第一行只有两个元素)还是glove格式的数据。
参数: - embed_filepath (str) -- 预训练的embedding的路径。
- vocab -- 词表
Vocabulary类型，读取出现在vocab中的词的embedding。 没有出现在vocab中的词的embedding将通过找到的词的embedding的正态分布采样出来，以使得整个Embedding是同分布的。 - dtype -- 读出的embedding的类型
- padding (str) -- 词表中padding的token
- unknown (str) -- 词表中unknown的token
- normalize (bool) -- 是否将每个vector归一化到norm为1
- error (str) -- ignore , strict ; 如果 ignore ，错误将自动跳过; 如果 strict , 错误将抛出。 这里主要可能出错的地方在于词表有空行或者词表出现了维度不一致。
- init_method (callable) -- 传入numpy.ndarray, 返回numpy.ndarray, 用以初始化embedding
Return numpy.ndarray: shape为 [len(vocab), dimension], dimension由pretrain的embedding决定。
-
static
load_without_vocab(embed_filepath, dtype=<class 'numpy.float32'>, padding='<pad>', unknown='<unk>', normalize=True, error='ignore')[源代码]¶ 从embed_filepath中读取预训练的word vector。根据预训练的词表读取embedding并生成一个对应的Vocabulary。
参数: - embed_filepath (str) -- 预训练的embedding的路径。
- dtype -- 读出的embedding的类型
- padding (str) -- 词表中的padding的token. 并以此用做vocab的padding。
- unknown (str) -- 词表中的unknown的token. 并以此用做vocab的unknown。
- normalize (bool) -- 是否将每个vector归一化到norm为1
- error (str) -- ignore , strict ; 如果 ignore ，错误将自动跳过; 如果 strict , 错误将抛出。这里主要可能出错的地 方在于词表有空行或者词表出现了维度不一致。
Return (numpy.ndarray, Vocabulary): Embedding的shape是[词表大小+x, 词表维度], "词表大小+x"是由于最终的大小还取决与 是否使用padding, 以及unknown有没有在词表中找到对应的词。 Vocabulary中的词的顺序与Embedding的顺序是一一对应的。
-
static
-
fastNLP.io.file_utils.cached_path(url_or_filename: str, cache_dir: str = None, name=None) → pathlib.Path[源代码]¶ 给定一个url，尝试通过url中的解析出来的文件名字filename到{cache_dir}/{name}/{filename}下寻找这个文件，
- 如果cache_dir=None, 则cache_dir=~/.fastNLP/; 否则cache_dir=cache_dir
- 如果name=None, 则没有中间的{name}这一层结构；否者中间结构就为{name}
如果有该文件，就直接返回路径
如果没有该文件，则尝试用传入的url下载
或者文件名(可以是具体的文件名，也可以是文件夹)，先在cache_dir下寻找该文件是否存在，如果不存在则去下载, 并 将文件放入到cache_dir中.
参数: - url_or_filename (str) -- 文件的下载url或者文件名称。
- cache_dir (str) -- 文件的缓存文件夹。如果为None，将使用"~/.fastNLP"这个默认路径
- name (str) -- 中间一层的名称。如embedding, dataset
返回:
-
fastNLP.io.file_utils.get_filepath(filepath)[源代码]¶ 如果filepath为文件夹，
如果内含多个文件, 返回filepath
如果只有一个文件, 返回filepath + filename
如果filepath为文件
返回filepath参数: filepath (str) -- 路径 返回:
-
fastNLP.io.file_utils.get_cache_path()[源代码]¶ 获取fastNLP默认cache的存放路径, 如果将FASTNLP_CACHE_PATH设置在了环境变量中，将使用环境变量的值，使得不用每个用户都去下载。
Return str: 存放路径
-
fastNLP.io.file_utils.split_filename_suffix(filepath)[源代码]¶ 给定filepath 返回对应的name和suffix. 如果后缀是多个点，仅支持.tar.gz类型
参数: filepath -- 文件路径 返回: filename, suffix
-
fastNLP.io.file_utils.get_from_cache(url: str, cache_dir: pathlib.Path = None) → pathlib.Path[源代码]¶ 尝试在cache_dir中寻找url定义的资源; 如果没有找到; 则从url下载并将结果放在cache_dir下，缓存的名称由url的结果推断而来。会将下载的 文件解压，将解压后的文件全部放在cache_dir文件夹中。
如果从url中下载的资源解压后有多个文件，则返回目录的路径; 如果只有一个资源文件，则返回具体的路径。
参数: - url -- 资源的 url
- cache_dir -- cache 目录
返回: 路径
Loader用于读取数据，并将内容读取到 DataSet 或者 DataBundle 中。所有的Loader都支持以下的
三个方法： __init__ ， _load , loads . 其中 __init__(...) 用于申明读取参数，以及说明该Loader支持的数据格式，
读取后 DataSet 中的 field ; _load(path) 方法传入文件路径读取单个文件，并返回 DataSet ;
load(paths) 用于读取文件夹下的文件，并返回 DataBundle 类型的对象 , load()方法支持以下几种类型的参数:
- 0.传入None
- 将尝试自动下载数据集并缓存。但不是所有的数据都可以直接下载。
- 1.传入一个文件的 path
- 返回的 data_bundle 包含一个名为 train 的 dataset ,可以通过
data_bundle.get_dataset('train')获取 - 2.传入一个文件夹目录
将读取的是这个文件夹下文件名中包含 train , test , dev 的文件，其它文件会被忽略。假设某个目录下的文件为:
| +-train.txt +-dev.txt +-test.txt +-other.txt
在 Loader().load('/path/to/dir') 返回的 data_bundle 中可以用
data_bundle.get_dataset('train'),data_bundle.get_dataset('dev'),data_bundle.get_dataset('test')获取对应的 dataset ，其中 other.txt 的内容会被忽略。假设某个目录下的文件为:| +-train.txt +-dev.txt
在 Loader().load('/path/to/dir') 返回的 data_bundle 中可以用
data_bundle.get_dataset('train'),data_bundle.get_dataset('dev')获取对应的 dataset。- 3.传入一个字典
字典的的 key 为 dataset 的名称，value 是该 dataset 的文件路径:
paths = {'train':'/path/to/train', 'dev': '/path/to/dev', 'test':'/path/to/test'}
在 Loader().load(paths) 返回的 data_bundle 中可以用
data_bundle.get_dataset('train'),data_bundle.get_dataset('dev'),data_bundle.get_dataset('test')来获取对应的 dataset
fastNLP 目前提供了如下的 Loader
-
class
fastNLP.io.loader.Loader[源代码]¶ 别名
fastNLP.io.LoaderfastNLP.io.loader.Loader各种数据 Loader 的基类，提供了 API 的参考. Loader支持以下的三个函数
- download() 函数：自动将该数据集下载到缓存地址，默认缓存地址为~/.fastNLP/datasets/。由于版权等原因，不是所有的Loader都实现了该方法。该方法会返回下载后文件所处的缓存地址。
- _load() 函数：从一个数据文件中读取数据，返回一个
DataSet。返回的DataSet的内容可以通过每个Loader的文档判断出。 - load() 函数：将文件分别读取为DataSet，然后将多个DataSet放入到一个DataBundle中并返回
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
class
fastNLP.io.loader.CLSBaseLoader(sep=', ', has_header=False)[源代码]¶ -
别名
fastNLP.io.CLSBaseLoaderfastNLP.io.loader.CLSBaseLoader文本分类Loader的一个基类
原始数据中内容应该为, 每一行为一个sample，第一个逗号之前为target，第一个逗号之后为文本内容。
Example:
"1","I got 'new' tires from the..." "1","Don't waste your time..."
读取的DataSet将具备以下的数据结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... -
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.IMDBLoader[源代码]¶ -
别名
fastNLP.io.IMDBLoaderfastNLP.io.loader.IMDBLoader原始数据中内容应该为, 每一行为一个sample，制表符之前为target，制表符之后为文本内容。
Example:
neg Alan Rickman & Emma... neg I have seen this...
IMDBLoader读取后的数据将具有以下两列内容: raw_words: str, 需要分类的文本; target: str, 文本的标签 读取的DataSet具备以下的结构:
raw_words target Alan Rickman & Emma... neg I have seen this... neg ... ... -
download(dev_ratio: float = 0.0, re_download=False)[源代码]¶ 自动下载数据集，如果你使用了这个数据集，请引用以下的文章
http://www.aclweb.org/anthology/P11-1015
根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。下载完成后不从train中切分dev
参数: - dev_ratio (float) -- 如果路径中没有dev.txt。从train划分多少作为dev的数据. 如果为0，则不划分dev
- re_download (bool) -- 是否重新下载数据，以重新切分数据。
返回: str, 数据集的目录地址
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.SSTLoader[源代码]¶ -
别名
fastNLP.io.SSTLoaderfastNLP.io.loader.SSTLoader原始数据中内容应该为:
Example:
(2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)... (3 (3 (2 If) (3 (2 you) (3 (2 sometimes)...
读取之后的DataSet具有以下的结构
下面是使用SSTLoader读取的DataSet所具备的field¶ raw_words (2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)... (3 (3 (2 If) (3 (2 you) (3 (2 sometimes) ... ... raw_words列是str。
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.SST2Loader[源代码]¶ -
别名
fastNLP.io.SST2LoaderfastNLP.io.loader.SST2Loader原始数据中内容为：第一行为标题(具体内容会被忽略)，之后一行为一个sample，第一个制表符之前被认为是句子，第一个制表符之后认为是label
Example:
sentence label it 's a charming and often affecting journey . 1 unflinchingly bleak and desperate 0
读取之后DataSet将如下所示
raw_words target it 's a charming and often affecting journey . 1 unflinchingly bleak and desperate 0 ... test的DataSet没有target列。
-
download()[源代码]¶ 自动下载数据集，如果你使用了该数据集，请引用以下的文章 https://nlp.stanford.edu/pubs/SocherBauerManningNg_ACL2013.pdf :return:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.ChnSentiCorpLoader[源代码]¶ -
别名
fastNLP.io.ChnSentiCorpLoaderfastNLP.io.loader.ChnSentiCorpLoader支持读取的数据的格式为，第一行为标题(具体内容会被忽略)，之后一行为一个sample，第一个制表符之前被认为是label，第 一个制表符之后认为是句子
Example:
label text_a 1 基金痛所有投资项目一样，必须先要有所了解... 1 系统很好装，LED屏是不错，就是16比9的比例...
读取后的DataSet具有以下的field
raw_chars target 基金痛所有投资项目一样，必须先要有所了解... 1 系统很好装，LED屏是不错，就是16比9的比例... 1 ... -
download() → str[源代码]¶ 自动下载数据，该数据取自https://github.com/pengming617/bert_classification/tree/master/data，在 https://arxiv.org/pdf/1904.09223.pdf与https://arxiv.org/pdf/1906.08101.pdf有使用
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.THUCNewsLoader[源代码]¶ -
别名
fastNLP.io.THUCNewsLoaderfastNLP.io.loader.THUCNewsLoader数据集简介：document-level分类任务，新闻10分类 原始数据内容为：每行一个sample，第一个' '之前为target，第一个' '之后为raw_words
Example:
体育 调查-您如何评价热火客场胜绿军总分3-1夺赛点？...
读取后的Dataset将具有以下数据结构：
raw_words target 调查-您如何评价热火客场胜绿军总分3-1夺赛点？... 体育 ... ... -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.WeiboSenti100kLoader[源代码]¶ -
别名
fastNLP.io.WeiboSenti100kLoaderfastNLP.io.loader.WeiboSenti100kLoader别名： 数据集简介：微博sentiment classification，二分类
Example:
label text 1 多谢小莲，好运满满[爱你] 1 能在他乡遇老友真不赖，哈哈，珠儿，我也要用...
读取后的Dataset将具有以下数据结构：
raw_chars target 多谢小莲，好运满满[爱你] 1 能在他乡遇老友真不赖，哈哈，珠儿，我也要用... 1 ... ... -
download() → str[源代码]¶ 自动下载数据，该数据取自 https://github.com/SophonPlus/ChineseNlpCorpus/ 在 https://arxiv.org/abs/1906.08101 有使用 :return:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.ConllLoader(headers, indexes=None, dropna=True)[源代码]¶ -
别名
fastNLP.io.ConllLoaderfastNLP.io.loader.ConllLoaderConllLoader支持读取的数据格式: 以空行隔开两个sample，除了分割行，每一行用空格或者制表符隔开不同的元素。如下例所示:
Example:
# 文件中的内容 Nadim NNP B-NP B-PER Ladki NNP I-NP I-PER AL-AIN NNP B-NP B-LOC United NNP B-NP B-LOC Arab NNP I-NP I-LOC Emirates NNPS I-NP I-LOC 1996-12-06 CD I-NP O ... # 如果用以下的参数读取，返回的DataSet将包含raw_words和pos两个field, 这两个field的值分别取自于第0列与第1列 dataset = ConllLoader(headers=['raw_words', 'pos'], indexes=[0, 1])._load('/path/to/train.conll') # 如果用以下的参数读取，返回的DataSet将包含raw_words和ner两个field, 这两个field的值分别取自于第0列与第2列 dataset = ConllLoader(headers=['raw_words', 'ner'], indexes=[0, 3])._load('/path/to/train.conll') # 如果用以下的参数读取，返回的DataSet将包含raw_words, pos和ner三个field dataset = ConllLoader(headers=['raw_words', 'pos', 'ner'], indexes=[0, 1, 3])._load('/path/to/train.conll')
ConllLoader返回的DataSet的field由传入的headers确定。
数据中以"-DOCSTART-"开头的行将被忽略，因为该符号在conll 2003中被用为文档分割符。
-
__init__(headers, indexes=None, dropna=True)[源代码]¶ 参数: - headers (list) -- 每一列数据的名称，需为List or Tuple of str。
header与indexes一一对应 - indexes (list) -- 需要保留的数据列下标，从0开始。若为
None，则所有列都保留。Default:None - dropna (bool) -- 是否忽略非法数据，若
False，遇到非法数据时抛出ValueError。Default:True
- headers (list) -- 每一列数据的名称，需为List or Tuple of str。
-
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.Conll2003Loader[源代码]¶ -
别名
fastNLP.io.Conll2003LoaderfastNLP.io.loader.Conll2003Loader用于读取conll2003任务的数据。数据的内容应该类似与以下的内容, 第一列为raw_words, 第二列为pos, 第三列为chunking，第四列为ner。
Example:
Nadim NNP B-NP B-PER Ladki NNP I-NP I-PER AL-AIN NNP B-NP B-LOC United NNP B-NP B-LOC Arab NNP I-NP I-LOC Emirates NNPS I-NP I-LOC 1996-12-06 CD I-NP O ...
返回的DataSet的内容为
下面是Conll2003Loader加载后数据具备的结构。¶ raw_words pos chunk ner [Nadim, Ladki] [NNP, NNP] [B-NP, I-NP] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [NNP, NNP, NNP, ...] [B-NP, B-NP, I-NP, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] [...] [...] -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.Conll2003NERLoader[源代码]¶ -
别名
fastNLP.io.Conll2003NERLoaderfastNLP.io.loader.Conll2003NERLoader用于读取conll2003任务的NER数据。每一行有4列内容，空行意味着隔开两个句子
支持读取的内容如下 Example:
Nadim NNP B-NP B-PER Ladki NNP I-NP I-PER AL-AIN NNP B-NP B-LOC United NNP B-NP B-LOC Arab NNP I-NP I-LOC Emirates NNPS I-NP I-LOC 1996-12-06 CD I-NP O ...
返回的DataSet的内容为
下面是Conll2003Loader加载后数据具备的结构, target是BIO2编码¶ raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.OntoNotesNERLoader[源代码]¶ -
别名
fastNLP.io.OntoNotesNERLoaderfastNLP.io.loader.OntoNotesNERLoader用以读取OntoNotes的NER数据，同时也是Conll2012的NER任务数据。将OntoNote数据处理为conll格式的过程可以参考 https://github.com/yhcc/OntoNotes-5.0-NER。OntoNoteNERLoader将取第4列和第11列的内容。
读取的数据格式为：
Example:
bc/msnbc/00/msnbc_0000 0 0 Hi UH (TOP(FRAG(INTJ*) - - - Dan_Abrams * - bc/msnbc/00/msnbc_0000 0 1 everyone NN (NP*) - - - Dan_Abrams * - ...
返回的DataSet的内容为
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.CTBLoader[源代码]¶ -
别名
fastNLP.io.CTBLoaderfastNLP.io.loader.CTBLoader支持加载的数据应该具备以下格式, 其中第二列为词语，第四列为pos tag，第七列为依赖树的head，第八列为依赖树的label
Example:
1 印度 _ NR NR _ 3 nn _ _ 2 海军 _ NN NN _ 3 nn _ _ 3 参谋长 _ NN NN _ 5 nsubjpass _ _ 4 被 _ SB SB _ 5 pass _ _ 5 解职 _ VV VV _ 0 root _ _ 1 新华社 _ NR NR _ 7 dep _ _ 2 新德里 _ NR NR _ 7 dep _ _ 3 １２月 _ NT NT _ 7 dep _ _ ...
读取之后DataSet具备的格式为
raw_words pos dep_head dep_label [印度, 海军, ...] [NR, NN, SB, ...] [3, 3, ...] [nn, nn, ...] [新华社, 新德里, ...] [NR, NR, NT, ...] [7, 7, 7, ...] [dep, dep, dep, ...] [...] [...] [...] [...] -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://catalog.ldc.upenn.edu/LDC2013T21
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.MsraNERLoader[源代码]¶ 基类
fastNLP.io.CNNERLoader别名
fastNLP.io.MsraNERLoaderfastNLP.io.loader.MsraNERLoader读取MSRA-NER数据，数据中的格式应该类似与下列的内容
Example:
把 O 欧 B-LOC 美 B-LOC 、 O 港 B-LOC 台 B-LOC 流 O 行 O 的 O 食 O ...
读取后的DataSet包含以下的field
raw_chars target ['把', '欧'] ['O', 'B-LOC'] ['美', '、'] ['B-LOC', 'O'] [...] [...] -
download(dev_ratio: float = 0.1, re_download: bool = False) → str[源代码]¶ 自动下载MSAR-NER的数据，如果你使用该数据，请引用 Gina-Anne Levow, 2006, The Third International Chinese Language Processing Bakeoff: Word Segmentation and Named Entity Recognition.
根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。下载完成后在output_dir中有train.conll, test.conll, dev.conll三个文件。
参数: - dev_ratio (float) -- 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
- re_download (bool) -- 是否重新下载数据，以重新切分数据。
返回: str, 数据集的目录地址
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.PeopleDailyNERLoader[源代码]¶ 基类
fastNLP.io.CNNERLoader别名
fastNLP.io.PeopleDailyNERLoaderfastNLP.io.loader.PeopleDailyNERLoader支持加载的数据格式如下
Example:
中 B-ORG 共 I-ORG 中 I-ORG 央 I-ORG 致 O 中 B-ORG ...
读取后的DataSet包含以下的field
target列是基于BIO的编码方式¶ raw_chars target ['中', '共', '中', '央'] ['B-ORG', 'I-ORG', 'I-ORG', 'I-ORG'] [...] [...] -
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.WeiboNERLoader[源代码]¶ 基类
fastNLP.io.CNNERLoader别名
fastNLP.io.WeiboNERLoaderfastNLP.io.loader.WeiboNERLoader读取WeiboNER数据，数据中的格式应该类似与下列的内容
Example:
老 B-PER.NOM 百 I-PER.NOM 姓 I-PER.NOM 心 O ... 读取后的DataSet包含以下的field .. csv-table:: :header: "raw_chars", "target" "['老', '百', '姓']", "['B-PER.NOM', 'I-PER.NOM', 'I-PER.NOM']" "['心']", "['O']" "[...]", "[...]"
-
download() → str[源代码]¶ 自动下载Weibo-NER的数据，如果你使用了该数据，请引用 Nanyun Peng and Mark Dredze, 2015, Named Entity Recognition for Chinese Social Media with Jointly Trained Embeddings.
返回: str
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.CSVLoader(headers=None, sep=', ', dropna=False)[源代码]¶ -
别名
fastNLP.io.CSVLoaderfastNLP.io.loader.CSVLoader读取CSV格式的数据集, 返回DataSet。-
__init__(headers=None, sep=', ', dropna=False)[源代码]¶ 参数: - headers (List[str]) -- CSV文件的文件头.定义每一列的属性名称,即返回的DataSet中`field`的名称
若为
None,则将读入文件的第一行视作headers. Default:None - sep (str) -- CSV文件中列与列之间的分隔符. Default: ","
- dropna (bool) -- 是否忽略非法数据,若
True则忽略,若False,在遇到非法数据时,抛出ValueError. Default:False
- headers (List[str]) -- CSV文件的文件头.定义每一列的属性名称,即返回的DataSet中`field`的名称
若为
-
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.JsonLoader(fields=None, dropna=False)[源代码]¶ -
别名
fastNLP.io.JsonLoaderfastNLP.io.loader.JsonLoader别名：
fastNLP.io.JsonLoaderfastNLP.io.loader.JsonLoader读取json格式数据.数据必须按行存储,每行是一个包含各类属性的json对象
param dict fields: 需要读入的json属性名称, 和读入后在DataSet中存储的field_name fields的 key 必须是json对象的属性名.fields的 value 为读入后在DataSet存储的 field_name , value 也可为None, 这时读入后的 field_name 与json对象对应属性同名fields可为None, 这时,json对象所有属性都保存在DataSet中. Default:Noneparam bool dropna: 是否忽略非法数据,若 True则忽略,若False,在遇到非法数据时,抛出ValueError. Default:False-
download() → str¶ 自动下载该数据集
返回: 下载后解压目录
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.CWSLoader(dataset_name: str = None)[源代码]¶ -
别名
fastNLP.io.CWSLoaderfastNLP.io.loader.CWSLoaderCWSLoader支持的数据格式为，一行一句话，不同词之间用空格隔开, 例如：
Example:
上海 浦东 开发 与 法制 建设 同步 新华社 上海 二月 十日 电 （ 记者 谢金虎 、 张持坚 ） ...
该Loader读取后的DataSet具有如下的结构
raw_words 上海 浦东 开发 与 法制 建设 同步 新华社 上海 二月 十日 电 （ 记者 谢金虎 、 张持坚 ） ... -
__init__(dataset_name: str = None)[源代码]¶ 参数: dataset_name (str) -- data的名称，支持pku, msra, cityu(繁体), as(繁体), None
-
download(dev_ratio=0.1, re_download=False) → str[源代码]¶ 如果你使用了该数据集，请引用以下的文章:Thomas Emerson, The Second International Chinese Word Segmentation Bakeoff, 2005. 更多信息可以在http://sighan.cs.uchicago.edu/bakeoff2005/查看
参数: - dev_ratio (float) -- 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
- re_download (bool) -- 是否重新下载数据，以重新切分数据。
返回: str
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.MNLILoader[源代码]¶ -
别名
fastNLP.io.MNLILoaderfastNLP.io.loader.MNLILoader读取的数据格式为：
Example:
index promptID pairID genre sentence1_binary_parse sentence2_binary_parse sentence1_parse sentence2_parse sentence1 sentence2 label1 gold_label 0 31193 31193n government ( ( Conceptually ( cream skimming ) ) ... 1 101457 101457e telephone ( you ( ( know ( during ( ( ( the season ) and ) ( i guess ) ) )... ...
读取MNLI任务的数据，读取之后的DataSet中包含以下的内容，words0是sentence1, words1是sentence2, target是gold_label, 测试集中没 有target列。
raw_words1 raw_words2 target Conceptually cream ... Product and geography... neutral you know during the ... You lose the things to the... entailment ... ... ... -
download()[源代码]¶ 如果你使用了这个数据，请引用
https://www.nyu.edu/projects/bowman/multinli/paper.pdf :return:
-
-
class
fastNLP.io.loader.QuoraLoader[源代码]¶ -
别名
fastNLP.io.QuoraLoaderfastNLP.io.loader.QuoraLoaderQuora matching任务的数据集Loader
支持读取的文件中的内容，应该有以下的形式, 以制表符分隔，且前三列的内容必须是：第一列是label，第二列和第三列是句子
Example:
1 How do I get funding for my web based startup idea ? How do I get seed funding pre product ? 327970 0 Is honey a viable alternative to sugar for diabetics ? How would you compare the United States ' euthanasia laws to Denmark ? 90348 ...
加载的DataSet将具备以下的field
raw_words1 raw_words2 target How do I get funding for my web based... How do I get seed funding... 1 Is honey a viable alternative ... How would you compare the United... 0 ... ... ... -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://www.kaggle.com/c/quora-question-pairs/data
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.SNLILoader[源代码]¶ -
别名
fastNLP.io.SNLILoaderfastNLP.io.loader.SNLILoader文件每一行是一个sample，每一行都为一个json对象，其数据格式为：
Example:
{"annotator_labels": ["neutral", "entailment", "neutral", "neutral", "neutral"], "captionID": "4705552913.jpg#2", "gold_label": "neutral", "pairID": "4705552913.jpg#2r1n", "sentence1": "Two women are embracing while holding to go packages.", "sentence1_binary_parse": "( ( Two women ) ( ( are ( embracing ( while ( holding ( to ( go packages ) ) ) ) ) ) . ) )", "sentence1_parse": "(ROOT (S (NP (CD Two) (NNS women)) (VP (VBP are) (VP (VBG embracing) (SBAR (IN while) (S (NP (VBG holding)) (VP (TO to) (VP (VB go) (NP (NNS packages)))))))) (. .)))", "sentence2": "The sisters are hugging goodbye while holding to go packages after just eating lunch.", "sentence2_binary_parse": "( ( The sisters ) ( ( are ( ( hugging goodbye ) ( while ( holding ( to ( ( go packages ) ( after ( just ( eating lunch ) ) ) ) ) ) ) ) ) . ) )", "sentence2_parse": "(ROOT (S (NP (DT The) (NNS sisters)) (VP (VBP are) (VP (VBG hugging) (NP (UH goodbye)) (PP (IN while) (S (VP (VBG holding) (S (VP (TO to) (VP (VB go) (NP (NNS packages)) (PP (IN after) (S (ADVP (RB just)) (VP (VBG eating) (NP (NN lunch))))))))))))) (. .)))" }
读取之后的DataSet中的field情况为
下面是使用SNLILoader加载的DataSet所具备的field¶ target raw_words1 raw_words2 neutral Two women are embracing while holding.. The sisters are hugging goodbye... entailment Two women are embracing while holding... Two woman are holding packages. ... ... ... -
download()[源代码]¶ 如果您的文章使用了这份数据，请引用
http://nlp.stanford.edu/pubs/snli_paper.pdf
返回: str
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。读取的field根据Loader初始化时传入的field决定。
参数: paths (str) -- 传入一个目录, 将在该目录下寻找snli_1.0_train.jsonl, snli_1.0_dev.jsonl 和snli_1.0_test.jsonl三个文件。 返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.QNLILoader[源代码]¶ -
别名
fastNLP.io.QNLILoaderfastNLP.io.loader.QNLILoader第一行为标题(具体内容会被忽略)，之后每一行是一个sample，由index、问题、句子和标签构成（以制表符分割），数据结构如下：
Example:
index question sentence label 0 What came into force after the new constitution was herald? As of that day, the new constitution heralding the Second Republic came into force. entailment
QNLI数据集的Loader, 加载的DataSet将具备以下的field, raw_words1是question, raw_words2是sentence, target是label
raw_words1 raw_words2 target What came into force after the new... As of that day... entailment ... . test数据集没有target列
-
download()[源代码]¶ 如果您的实验使用到了该数据，请引用
https://arxiv.org/pdf/1809.05053.pdf
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.RTELoader[源代码]¶ -
别名
fastNLP.io.RTELoaderfastNLP.io.loader.RTELoader第一行为标题(具体内容会被忽略)，之后每一行是一个sample，由index、句子1、句子2和标签构成（以制表符分割），数据结构如下：
Example:
index sentence1 sentence2 label 0 Dana Reeve, the widow of the actor Christopher Reeve, has died of lung cancer at age 44, according to the Christopher Reeve Foundation. Christopher Reeve had an accident. not_entailment
RTE数据的loader 加载的DataSet将具备以下的field, raw_words1是sentence0，raw_words2是sentence1, target是label
raw_words1 raw_words2 target Dana Reeve, the widow of the actor... Christopher Reeve had an... not_entailment ... ... test数据集没有target列
-
download()[源代码]¶ 如果您的实验使用到了该数据，请引用GLUE Benchmark
https://openreview.net/pdf?id=rJ4km2R5t7
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.CNXNLILoader[源代码]¶ -
别名
fastNLP.io.CNXNLILoaderfastNLP.io.loader.CNXNLILoader数据集简介：中文句对NLI（本为multi-lingual的数据集，但是这里只取了中文的数据集）。原句子已被MOSES tokenizer处理，这里我们将其还原并重新按字tokenize 原始数据数据为：
Example:
premise hypo label 我们 家里 有 一个 但 我 没 找到 我 可以 用 的 时间 我们 家里 有 一个 但 我 从来 没有 时间 使用 它 . entailment
dev和test中的数据为csv或json格式，包括十多个field，这里只取与以上三个field中的数据 读取后的Dataset将具有以下数据结构：
raw_chars1 raw_chars2 target 我们 家里 有 一个 但 我 没 找到 我 可以 用 的 时间 我们 家里 有 一个 但 我 从来 没有 时间 使用 它 . 0 ... ... ... -
download() → str[源代码]¶ 自动下载数据，该数据取自 https://arxiv.org/abs/1809.05053 在 https://arxiv.org/pdf/1905.05526.pdf https://arxiv.org/pdf/1901.10125.pdf https://arxiv.org/pdf/1809.05053.pdf 有使用 :return:
-
-
class
fastNLP.io.loader.BQCorpusLoader[源代码]¶ -
别名
fastNLP.io.BQCorpusLoaderfastNLP.io.loader.BQCorpusLoader别名： 数据集简介:句子对二分类任务（判断是否具有相同的语义） 原始数据结构为：
Example:
sentence1,sentence2,label 综合评分不足什么原因,综合评估的依据,0 什么时候我能使用微粒贷,你就赶快给我开通就行了,0
读取后的Dataset将具有以下数据结构：
raw_chars1 raw_chars2 target 综合评分不足什么原因 综合评估的依据 0 什么时候我能使用微粒贷 你就赶快给我开通就行了 0 ... ... ... -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://github.com/ymcui/Chinese-BERT-wwm
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.LCQMCLoader[源代码]¶ -
别名
fastNLP.io.LCQMCLoaderfastNLP.io.loader.LCQMCLoader数据集简介：句对匹配（question matching）
原始数据为：
Example:
喜欢打篮球的男生喜欢什么样的女生 爱打篮球的男生喜欢什么样的女生 1 你帮我设计小说的封面吧 谁能帮我给小说设计个封面？ 0
读取后的Dataset将具有以下的数据结构
raw_chars1 raw_chars2 target 喜欢打篮球的男生喜欢什么样的女生 爱打篮球的男生喜欢什么样的女生 1 你帮我设计小说的封面吧 妇可以戴耳机听音乐吗? 0 ... ... ... -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://github.com/ymcui/Chinese-BERT-wwm
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.CoReferenceLoader(fields=None, dropna=False)[源代码]¶ 基类
fastNLP.io.loader.JsonLoader别名
fastNLP.io.CoReferenceLoaderfastNLP.io.loader.CoReferenceLoader原始数据中内容应该为, 每一行为一个json对象,其中doc_key包含文章的种类信息，speakers包含每句话的说话者信息，cluster是指向现实中同一个事物的聚集，sentences是文本信息内容。
Example:
{"doc_key": "bc/cctv/00/cctv_0000_0", "speakers": [["Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1"], ["Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1"], ["Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1", "Speaker#1"]], "clusters": [[[70, 70], [485, 486], [500, 500], [73, 73], [55, 55], [153, 154], [366, 366]]], "sentences": [["In", "the", "summer", "of", "2005", ",", "a", "picture", "that", "people", "have", "long", "been", "looking", "forward", "to", "started", "emerging", "with", "frequency", "in", "various", "major", "Hong", "Kong", "media", "."], ["With", "their", "unique", "charm", ",", "these", "well", "-", "known", "cartoon", "images", "once", "again", "caused", "Hong", "Kong", "to", "be", "a", "focus", "of", "worldwide", "attention", "."]] }
读取预处理好的Conll2012数据,数据结构如下：
raw_words1 raw_words2 raw_words3 raw_words4 bc/cctv/00/cctv_0000_0 [['Speaker#1', 'Speaker#1', 'Speaker#1... [[[70, 70], [485, 486], [500, 500], [7... [['In', 'the', 'summer', 'of', '2005',... ... ... ... ... -
download()[源代码]¶ 由于版权限制，不能提供自动下载功能。可参考
https://www.aclweb.org/anthology/W12-4501
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
-
class
fastNLP.io.loader.CMRC2018Loader[源代码]¶ -
别名
fastNLP.io.CMRC2018LoaderfastNLP.io.loader.qa.CMRC2018Loader请直接使用从fastNLP下载的数据进行处理。该数据集未提供测试集，测试需要通过上传到对应的系统进行评测
读取之后训练集DataSet将具备以下的内容，每个问题的答案只有一个
:header:"title", "context", "question", "answers", "answer_starts", "id"¶ 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 范廷颂是什么时候被任为主教的？ ["1963年"] ["30"] TRAIN_186_QUERY_0 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 1990年，范廷颂担任什么职务？ ["1990年被擢升为天..."] ["41"] TRAIN_186_QUERY_1 ... ... ... ... . ... 其中title是文本的标题，多条记录可能是相同的title；id是该问题的id，具备唯一性
验证集DataSet将具备以下的内容，每个问题的答案可能有三个(有时候只是3个重复的答案)
其中answer_starts是从0开始的index。例如"我来自a复旦大学？"，其中"复"的开始index为4。另外"Russell评价说"中的说的index为9, 因为 英文和数字都直接按照character计量的。
-
download() → str[源代码]¶ 如果您使用了本数据，请引用A Span-Extraction Dataset for Chinese Machine Reading Comprehension. Yiming Cui, Ting Liu, etc.
返回:
-
load(paths: Union[str, Dict[str, str]] = None) → fastNLP.io.data_bundle.DataBundle¶ 从指定一个或多个路径中的文件中读取数据，返回
DataBundle。参数: Dict[str, str]] paths (Union[str,) -- 支持以下的几种输入方式：
0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错:
data_bundle = xxxLoader().load('/path/to/dir') # 返回的DataBundle中datasets根据目录下是否检测到train # dev、 test等有所变化，可以通过以下的方式取出DataSet tr_data = data_bundle.get_dataset('train') te_data = data_bundle.get_dataset('test') # 如果目录下有文件包含test这个字段
2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test:
paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"} data_bundle = xxxLoader().load(paths) # 返回的DataBundle中的dataset中包含"train", "dev", "test" dev_data = data_bundle.get_dataset('dev')
3.传入文件路径:
data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train' tr_data = data_bundle.get_dataset('train') # 取出DataSet
返回: 返回的 DataBundle
-
用于载入和保存模型
-
class
fastNLP.io.model_io.ModelLoader[源代码]¶ 别名
fastNLP.io.ModelLoaderfastNLP.io.model_io.ModelLoader用于读取模型
-
class
fastNLP.io.model_io.ModelSaver(save_path)[源代码]¶ 别名
fastNLP.io.ModelSaverfastNLP.io.model_io.ModelSaver用于保存模型
Example:
saver = ModelSaver("./save/model_ckpt_100.pkl") saver.save_pytorch(model)
Pipe用于处理通过 Loader 读取的数据，所有的 Pipe 都包含 process 和 process_from_file 两种方法。
process(data_bundle) 传入一个 DataBundle 类型的对象, 在传入的 data_bundle 上进行原位修改，并将其返回；
process_from_file(paths) 传入的文件路径，返回一个 DataBundle 类型的对象。
process(data_bundle) 或者 process_from_file(paths) 的返回 data_bundle 中的 DataSet
一般都包含原文与转换为index的输入以及转换为index的target；除了 DataSet 之外，
data_bundle 还会包含将field转为index时所建立的词表。
-
class
fastNLP.io.pipe.Pipe[源代码]¶ 别名
fastNLP.io.PipefastNLP.io.pipe.PipePipe是fastNLP中用于处理DataBundle的类，但实际是处理DataBundle中的DataSet。所有Pipe都会在其process()函数的文档中指出该Pipe可处理的DataSet应该具备怎样的格式；在Pipe 文档中说明该Pipe返回后DataSet的格式以及其field的信息；以及新增的Vocabulary的信息。
一般情况下Pipe处理包含以下的几个过程，(1)将raw_words或raw_chars进行tokenize以切分成不同的词或字; (2) 再建立词或字的
Vocabulary, 并将词或字转换为index; (3)将target列建立词表并将target列转为index;Pipe中提供了两个方法
-process()函数，输入为DataBundle -process_from_file()函数，输入为对应Loader的load函数可接受的类型。
-
__init__¶ Initialize self. See help(type(self)) for accurate signature.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 对输入的DataBundle进行处理，然后返回该DataBundle。
参数: data_bundle (DataBundle) -- 需要处理的DataBundle对象 返回:
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：
fastNLP.io.Loader.load()参数: paths -- 返回: DataBundle
-
-
class
fastNLP.io.pipe.CWSPipe(dataset_name=None, encoding_type='bmes', replace_num_alpha=True, bigrams=False, trigrams=False)[源代码]¶ -
别名
fastNLP.io.CWSPipefastNLP.io.pipe.CWSPipe对CWS数据进行预处理, 处理之后的数据，具备以下的结构
raw_words chars target seq_len 共同 创造 美好... [2, 3, 4...] [0, 2, 0, 2,...] 13 2001年 新年 钟声... [8, 9, 9, 7, ...] [0, 1, 1, 1, 2...] 20 ... [...] [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+-------+--------+---------+ | field_names | raw_words | chars | target | seq_len | +-------------+-----------+-------+--------+---------+ | is_input | False | True | True | True | | is_target | False | False | True | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+-------+--------+---------+
-
__init__(dataset_name=None, encoding_type='bmes', replace_num_alpha=True, bigrams=False, trigrams=False)[源代码]¶ 参数: - dataset_name (str,None) -- 支持'pku', 'msra', 'cityu', 'as', None
- encoding_type (str) -- 可以选择'bmes', 'segapp'两种。"我 来自 复旦大学...", bmes的tag为[S, B, E, B, M, M, E...]; segapp 的tag为[seg, app, seg, app, app, app, seg, ...]
- replace_num_alpha (bool) -- 是否将数字和字母用特殊字符替换。
- bigrams (bool) -- 是否增加一列bigram. bigram的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]
- trigrams (bool) -- 是否增加一列trigram. trigram的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]
-
-
class
fastNLP.io.pipe.AGsNewsPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.AGsNewsPipefastNLP.io.pipe.AGsNewsPipe处理AG's News的数据, 处理之后DataSet中的内容如下
下面是使用AGsNewsPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.pipe.DBPediaPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.DBPediaPipefastNLP.io.pipe.DBPediaPipe处理DBPedia的数据, 处理之后DataSet中的内容如下
下面是使用DBPediaPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.pipe.YelpFullPipe(lower: bool = False, granularity=5, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.YelpFullPipefastNLP.io.pipe.YelpFullPipe处理YelpFull的数据, 处理之后DataSet中的内容如下
下面是使用YelpFullPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, granularity=5, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- granularity (int) -- 支持2, 3, 5。若为2, 则认为是2分类问题，将1、2归为1类，4、5归为一类，丢掉2；若为3, 则有3分类问题，将 1、2归为1类，3归为1类，4、5归为1类；若为5, 则有5分类问题。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
-
class
fastNLP.io.pipe.YelpPolarityPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.YelpPolarityPipefastNLP.io.pipe.YelpPolarityPipe处理YelpPolarity的数据, 处理之后DataSet中的内容如下
下面是使用YelpFullPipe处理后的DataSet所具备的field¶ raw_words target words seq_len I got 'new' tires from them and within... 0 [7, 110, 22, 107, 22, 499, 59, 140, 3,...] 160 Don't waste your time. We had two dif...0 [277, 17, 278, 38, 30, 112, 24, 85, 27... 40 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.pipe.SSTPipe(subtree=False, train_subtree=True, lower=False, granularity=5, tokenizer='spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.SSTPipefastNLP.io.pipe.SSTPipe经过该Pipe之后，DataSet中具备的field如下所示
下面是使用SSTPipe处理后的DataSet所具备的field¶ raw_words words target seq_len It 's a lovely film with lovely perfor... 1 [187, 6, 5, 132, 120, 70, 132, 188, 25... 13 No one goes unindicted here , which is... 0 [191, 126, 192, 193, 194, 4, 195, 17, ... 13 ... . [...] . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(subtree=False, train_subtree=True, lower=False, granularity=5, tokenizer='spacy')[源代码]¶ 参数: - subtree (bool) -- 是否将train, test, dev数据展开为子树，扩充数据量。 Default:
False - train_subtree (bool) -- 是否将train集通过子树扩展数据。
- lower (bool) -- 是否对输入进行小写化。
- granularity (int) -- 支持2, 3, 5。若为2, 则认为是2分类问题，将0、1归为1类，3、4归为一类，丢掉2；若为3, 则有3分类问题，将 0、1归为1类，2归为1类，3、4归为1类；若为5, 则有5分类问题。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
- subtree (bool) -- 是否将train, test, dev数据展开为子树，扩充数据量。 Default:
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 对DataBundle中的数据进行预处理。输入的DataSet应该至少拥有raw_words这一列，且内容类似与
下面是使用SSTLoader读取的DataSet所具备的field¶ raw_words (2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)... (3 (3 (2 If) (3 (2 you) (3 (2 sometimes) ... ... 参数: data_bundle (DataBundle) -- 需要处理的DataBundle对象 返回:
-
-
class
fastNLP.io.pipe.SST2Pipe(lower=False, tokenizer='spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.SST2PipefastNLP.io.pipe.SST2Pipe加载SST2的数据, 处理完成之后DataSet将拥有以下的field
raw_words target words seq_len it 's a charming and often affecting j... 1 [19, 9, 6, 111, 5, 112, 113, 114, 3] 9 unflinchingly bleak and desperate 0 [115, 116, 5, 117] 4 ... ... . . dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower=False, tokenizer='spacy')[源代码]¶ 参数: - lower (bool) -- 是否对输入进行小写化。
- tokenizer (str) -- 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)¶ 传入的DataSet应该具备如下的结构
raw_words target I got 'new' tires from them and... 1 Don't waste your time. We had two... 1 ... ... 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.pipe.IMDBPipe(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.IMDBPipefastNLP.io.pipe.IMDBPipe经过本Pipe处理后DataSet将如下
输出DataSet的field¶ raw_words target words seq_len Bromwell High is a cartoon ... 0 [3, 5, 6, 9, ...] 20 Story of a man who has ... 1 [20, 43, 9, 10, ...] 31 ... . [...] . 其中raw_words为str类型，是原文; words是转换为index的输入; target是转换为index的目标值; words列被设置为input; target列被设置为target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | False | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(lower: bool = False, tokenizer: str = 'spacy')[源代码]¶ 参数: - lower (bool) -- 是否将words列的数据小写。
- tokenizer (str) -- 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 期待的DataBunlde中输入的DataSet应该类似于如下，有两个field，raw_words和target，且均为str类型
输入DataSet的field¶ raw_words target Bromwell High is a cartoon ... pos Story of a man who has ... neg ... ... 参数: data_bundle (DataBunlde) -- 传入的DataBundle中的DataSet必须包含raw_words和target两个field，且raw_words列应该为str, target列应该为str。 返回: DataBundle
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.pipe.ChnSentiCorpPipe(bigrams=False, trigrams=False)[源代码]¶ -
别名
fastNLP.io.ChnSentiCorpPipefastNLP.io.pipe.ChnSentiCorpPipe处理之后的DataSet有以下的结构
raw_chars target chars seq_len 這間酒店環境和服務態度亦算不錯,但房間空間太小~~ 1 [2, 3, 4, 5, ...] 31 <荐书> 推荐所有喜欢<红楼>... 1 [10, 21, ....] 25 ... 其中chars, seq_len是input，target是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(bigrams=False, trigrams=False)[源代码]¶ 参数: - bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 可以处理的DataSet应该具备以下的field
raw_chars target 這間酒店環境和服務態度亦算不錯,但房間空間太小~~ 1 <荐书> 推荐所有喜欢<红楼>... 1 ... 参数: data_bundle -- 返回:
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.pipe.THUCNewsPipe(bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.THUCNewsPipefastNLP.io.pipe.THUCNewsPipe处理之后的DataSet有以下的结构
raw_chars target chars seq_len 马晓旭意外受伤让国奥警惕 无奈大雨格外青睐殷家军记者傅亚雨沈阳报道... 0 [409, 1197, 2146, 213, ...] 746 ... 其中chars, seq_len是input，target是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
param bool bigrams: 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取. param bool trigrams: 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取. -
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 可处理的DataSet应具备如下的field
raw_words target 马晓旭意外受伤让国奥警惕 无奈大雨格外青睐殷家军记者傅亚雨沈阳报道 ... 体育 ... ... 参数: data_bundle -- 返回:
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.pipe.WeiboSenti100kPipe(bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io.CLSBasePipe别名
fastNLP.io.WeiboSenti100kPipefastNLP.io.pipe.WeiboSenti100kPipe处理之后的DataSet有以下的结构
raw_chars target chars seq_len 六一出生的？好讽刺…… //@祭春姬:他爸爸是外星人吧 //@面孔小高:现在的孩子都怎么了 [怒][怒][怒] 0 [0, 690, 18, ...] 56 ... 其中chars, seq_len是input，target是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | False | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
param bool bigrams: 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取. param bool trigrams: 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取. -
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 可处理的DataSet应具备以下的field
raw_chars target 六一出生的？好讽刺…… //@祭春姬:他爸爸是外星人吧 //@面孔小高:现在的孩子都怎么了 [怒][怒][怒] 0 ... ... 参数: data_bundle -- 返回:
-
process_from_file(paths=None)[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.Loader的load函数。返回: DataBundle
-
-
class
fastNLP.io.pipe.Conll2003NERPipe(encoding_type: str = 'bio', lower: bool = False)[源代码]¶ 基类
fastNLP.io._NERPipe别名
fastNLP.io.Conll2003NERPipefastNLP.io.pipe.Conll2003NERPipeConll2003的NER任务的处理Pipe, 该Pipe会（1）复制raw_words列，并命名为words; (2）在words, target列建立词表 (创建
fastNLP.Vocabulary对象，所以在返回的DataBundle中将有两个Vocabulary); (3）将words，target列根据相应的 Vocabulary转换为index。 经过该Pipe过后，DataSet中的内容如下所示Following is a demo layout of DataSet returned by Conll2003Loader¶ raw_words target words seq_len [Nadim, Ladki] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [3, 4,...] [4, 5, 6,...] 6 [...] [...] [...] . raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', lower: bool = False)¶ Param: str encoding_type: target列使用什么类型的encoding方式，支持bioes, bio两种。 参数: lower (bool) -- 是否将words小写化后再建立词表，绝大多数情况都不需要设置为True。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] 参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]在传入DataBundle基础上原位修改。 Return DataBundle:
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 参数: paths -- 支持路径类型参见 fastNLP.io.loader.ConllLoader的load函数。返回: DataBundle
-
-
class
fastNLP.io.pipe.OntoNotesNERPipe(encoding_type: str = 'bio', lower: bool = False)[源代码]¶ 基类
fastNLP.io._NERPipe别名
fastNLP.io.OntoNotesNERPipefastNLP.io.pipe.OntoNotesNERPipe处理OntoNotes的NER数据，处理之后DataSet中的field情况为
raw_words target words seq_len [Nadim, Ladki] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [3, 4] [4, 5, 6,...] 6 [...] [...] [...] . raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_words | target | words | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', lower: bool = False)¶ Param: str encoding_type: target列使用什么类型的encoding方式，支持bioes, bio两种。 参数: lower (bool) -- 是否将words小写化后再建立词表，绝大多数情况都不需要设置为True。
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_words target [Nadim, Ladki] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [B-LOC, B-LOC, I-LOC, ...] [...] [...] 参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]在传入DataBundle基础上原位修改。 Return DataBundle:
-
-
class
fastNLP.io.pipe.MsraNERPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.MsraNERPipefastNLP.io.pipe.MsraNERPipe处理MSRA-NER的数据，处理之后的DataSet的field情况为
raw_chars target chars seq_len [相, 比, 之, 下,...] [0, 0, 0, 0, ...] [2, 3, 4, 5, ...] 11 [青, 岛, 海, 牛, 队, 和, ...] [1, 2, 3, ...] [10, 21, ....] 21 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False)¶ 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.pipe.WeiboNERPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.WeiboNERPipefastNLP.io.pipe.WeiboNERPipe处理weibo的ner的数据，处理之后的DataSet的field情况为
raw_chars chars target seq_len ['老', '百', '姓'] [4, 3, 3] [38, 39, 40] 3 ['心'] [0] [41] 1 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False)¶ 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.pipe.PeopleDailyPipe(encoding_type: str = 'bio', bigrams=False, trigrams=False)[源代码]¶ 基类
fastNLP.io._CNNERPipe别名
fastNLP.io.PeopleDailyPipefastNLP.io.pipe.PeopleDailyPipe处理people daily的ner的数据，处理之后的DataSet的field情况为
raw_chars target chars seq_len [相, 比, 之, 下,...] [0, 0, 0, 0, ...] [2, 3, 4, 5, ...] 11 [青, 岛, 海, 牛, 队, 和, ...] [1, 2, 3, ...] [10, 21, ....] 21 [...] [...] [...] . raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的 target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
__init__(encoding_type: str = 'bio', bigrams=False, trigrams=False)¶ 参数: - encoding_type (str) -- target列使用什么类型的encoding方式，支持bioes, bio两种。
- bigrams (bool) -- 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果 设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('bigrams')获取.
- trigrams (bool) -- 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...] 。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过 data_bundle.get_vocab('trigrams')获取.
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle¶ 支持的DataSet的field为
raw_chars target [相, 比, 之, 下,...] [O, O, O, O, ...] [青, 岛, 海, 牛, 队, 和, ...] [B-ORG, I-ORG, I-ORG, ...] [...] [...] raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]， 是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
参数: data_bundle (DataBundle) -- 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。 返回: DataBundle
-
-
class
fastNLP.io.pipe.Conll2003Pipe(chunk_encoding_type='bioes', ner_encoding_type='bioes', lower: bool = False)[源代码]¶ -
别名
fastNLP.io.Conll2003PipefastNLP.io.pipe.Conll2003Pipe经过该Pipe后，DataSet中的内容如下
raw_words pos chunk ner words seq_len [Nadim, Ladki] [0, 0] [1, 2] [1, 2] [2, 3] 2 [AL-AIN, United, Arab, ...] [1, 2...] [3, 4...] [3, 4...] [4, 5, 6,...] 6 [...] [...] [...] [...] [...] . 其中words, seq_len是input; pos, chunk, ner, seq_len是target dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+-------+-------+-------+-------+---------+ | field_names | raw_words | pos | chunk | ner | words | seq_len | +-------------+-----------+-------+-------+-------+-------+---------+ | is_input | False | False | False | False | True | True | | is_target | False | True | True | True | False | True | | ignore_type | | False | False | False | False | False | | pad_value | | 0 | 0 | 0 | 0 | 0 | +-------------+-----------+-------+-------+-------+-------+---------+
-
__init__(chunk_encoding_type='bioes', ner_encoding_type='bioes', lower: bool = False)[源代码]¶ 参数: - chunk_encoding_type (str) -- 支持bioes, bio。
- ner_encoding_type (str) -- 支持bioes, bio。
- lower (bool) -- 是否将words列小写化后再建立词表
-
process(data_bundle) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 输入的DataSet应该类似于如下的形式
raw_words pos chunk ner [Nadim, Ladki] [NNP, NNP] [B-NP, I-NP] [B-PER, I-PER] [AL-AIN, United, Arab, ...] [NNP, NNP...] [B-NP, B-NP, ...] [B-LOC, B-LOC,...] [...] [...] [...] [...] . 参数: data_bundle -- 返回: 传入的DataBundle
-
-
class
fastNLP.io.pipe.MatchingBertPipe(lower=False, tokenizer: str = 'raw')[源代码]¶ -
别名
fastNLP.io.MatchingBertPipefastNLP.io.pipe.MatchingBertPipeMatching任务的Bert pipe，输出的DataSet将包含以下的field
raw_words1 raw_words2 target words seq_len The new rights are... Everyone really likes.. 1 [2, 3, 4, 5, ...] 10 This site includes a... The Government Executive... 0 [11, 12, 13,...] 5 ... ... . [...] . words列是将raw_words1(即premise), raw_words2(即hypothesis)使用"[SEP]"链接起来转换为index的。 words列被设置为input，target列被设置为target和input(设置为input以方便在forward函数中计算loss， 如果不在forward函数中计算loss也不影响，fastNLP将根据forward函数的形参名进行传参).
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+------------+------------+--------+-------+---------+ | field_names | raw_words1 | raw_words2 | target | words | seq_len | +-------------+------------+------------+--------+-------+---------+ | is_input | False | False | False | True | True | | is_target | False | False | True | False | False | | ignore_type | | | False | False | False | | pad_value | | | 0 | 0 | 0 | +-------------+------------+------------+--------+-------+---------+
-
__init__(lower=False, tokenizer: str = 'raw')[源代码]¶ 参数: - lower (bool) -- 是否将word小写化。
- tokenizer (str) -- 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-
process(data_bundle)[源代码]¶ 输入的data_bundle中的dataset需要具有以下结构：
raw_words1 raw_words2 target Dana Reeve, the widow of the actor... Christopher Reeve had an... not_entailment ... ... 参数: data_bundle -- 返回:
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle¶ 传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：
fastNLP.io.Loader.load()参数: paths -- 返回: DataBundle
-
-
class
fastNLP.io.pipe.MatchingPipe(lower=False, tokenizer: str = 'raw')[源代码]¶ -
别名
fastNLP.io.MatchingPipefastNLP.io.pipe.MatchingPipeMatching任务的Pipe。输出的DataSet将包含以下的field
raw_words1 raw_words2 target words1 words2 seq_len1 seq_len2 The new rights are... Everyone really likes.. 1 [2, 3, 4, 5, ...] [10, 20, 6] 10 13 This site includes a... The Government Executive... 0 [11, 12, 13,...] [2, 7, ...] 6 7 ... ... . [...] [...] . . words1是premise，words2是hypothesis。其中words1,words2,seq_len1,seq_len2被设置为input；target被设置为target 和input(设置为input以方便在forward函数中计算loss，如果不在forward函数中计算loss也不影响，fastNLP将根据forward函数 的形参名进行传参)。
dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+------------+------------+--------+--------+--------+----------+----------+ | field_names | raw_words1 | raw_words2 | target | words1 | words2 | seq_len1 | seq_len2 | +-------------+------------+------------+--------+--------+--------+----------+----------+ | is_input | False | False | False | True | True | True | True | | is_target | False | False | True | False | False | False | False | | ignore_type | | | False | False | False | False | False | | pad_value | | | 0 | 0 | 0 | 0 | 0 | +-------------+------------+------------+--------+--------+--------+----------+----------+
-
__init__(lower=False, tokenizer: str = 'raw')[源代码]¶ 参数: - lower (bool) -- 是否将所有raw_words转为小写。
- tokenizer (str) -- 将原始数据tokenize的方式。支持spacy, raw. spacy是使用spacy切分，raw就是用空格切分。
-
process(data_bundle)[源代码]¶ 接受的DataBundle中的DataSet应该具有以下的field, target列可以没有
raw_words1 raw_words2 target The new rights are... Everyone really likes.. entailment This site includes a... The Government Executive... not_entailment ... ... 参数: data_bundle (DataBundle) -- 通过loader读取得到的data_bundle，里面包含了数据集的原始数据内容 返回: data_bundle
-
process_from_file(paths) → fastNLP.io.data_bundle.DataBundle¶ 传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：
fastNLP.io.Loader.load()参数: paths -- 返回: DataBundle
-
-
class
fastNLP.io.pipe.CoReferencePipe(config)[源代码]¶ -
别名
fastNLP.io.CoReferencePipefastNLP.io.pipe.CoReferencePipe对Coreference resolution问题进行处理，得到文章种类/说话者/字符级信息/序列长度。
处理完成后数据包含文章类别、speaker信息、句子信息、句子对应的index、char、句子长度、target：
words1 words2 words3 words4 chars seq_len target bc [[0,0],[1,1]] [['I','am'],[]] [[1,2],[]] [[[1],[2,3]],[]] [2,3] [[[2,3],[6,7]],[[10,12],[20,22]]] [...] [...] [...] [...] [...] [...] [...] dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为:
+-------------+-----------+--------+-------+---------+ | field_names | raw_chars | target | chars | seq_len | +-------------+-----------+--------+-------+---------+ | is_input | False | True | True | True | | is_target | False | True | False | True | | ignore_type | | False | False | False | | pad_value | | 0 | 0 | 0 | +-------------+-----------+--------+-------+---------+
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle)[源代码]¶ 对load进来的数据进一步处理原始数据包含：raw_key,raw_speaker,raw_words,raw_clusters
raw_key raw_speaker raw_words raw_clusters bc/cctv/00/cctv_0000_0 [[Speaker#1, Speaker#1],[]] [['I','am'],[]] [[[2,3],[6,7]],[[10,12],[20,22]]] bc/cctv/00/cctv_0000_1 [['Speaker#1', 'peaker#1'],[]] [['He','is'],[]] [[[2,3],[6,7]],[[10,12],[20,22]]] [...] [...] [...] [...] 参数: data_bundle -- 返回:
-
-
class
fastNLP.io.pipe.CMRC2018BertPipe(max_len=510)[源代码]¶ -
别名
fastNLP.io.CMRC2018BertPipefastNLP.io.pipe.qa.CMRC2018BertPipe处理之后的DataSet将新增以下的field(传入的field仍然保留)
:header: "context_len", "raw_chars", "target_start", "target_end", "chars" 492, ['范', '廷', '颂... ], 30, 34, [21, 25, ...] 491, ['范', '廷', '颂... ], 41, 61, [21, 25, ...]¶ . ... ... ... ... raw_words列是context与question拼起来的结果(连接的地方加入了[SEP])，words是转为index的值, target_start为答案start的index，target_end为答案end的index （闭区间）；context_len指示的是words列中context的长度。
- 其中各列的meta信息如下:
field_names context_len raw_chars target_start target_end chars answersFalse True True
0is_inputis_target
- ignore_type
- pad_value
- False
- True
- False
- 0
- False
True True
0
- False
- True
- False
- 0
- False
- True
- False
- 0
TrueFalse False
0
-
process(data_bundle: fastNLP.io.data_bundle.DataBundle) → fastNLP.io.data_bundle.DataBundle[源代码]¶ 传入的DataSet应该具备以下的field
:header:"title", "context", "question", "answers", "answer_starts", "id"¶ 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 范廷颂是什么时候被任为主教的？ ["1963年"] ["30"] TRAIN_186_QUERY_0 范廷颂 范廷颂枢机（，），圣名保禄·若瑟（）... 1990年，范廷颂担任什么职务？ ["1990年被擢升为天..."] ["41"] TRAIN_186_QUERY_1 ... ... ... ... . ... 参数: data_bundle -- 返回:
-
fastNLP.io.utils.check_loader_paths(paths: Union[str, Dict[str, str]]) → Dict[str, str][源代码]¶ 检查传入dataloader的文件的合法性。如果为合法路径，将返回至少包含'train'这个key的dict。类似于下面的结果:
{ 'train': '/some/path/to/', # 一定包含，建词表应该在这上面建立，剩下的其它文件应该只需要处理并index。 'test': 'xxx' # 可能有，也可能没有 ... }
如果paths为不合法的，将直接进行raise相应的错误. 如果paths内不包含train也会报错。
参数: paths (str) -- 路径. 可以为一个文件路径(则认为该文件就是train的文件); 可以为一个文件目录，将在该目录下寻找包含train(文件名 中包含train这个字段), test, dev这三个字段的文件或文件夹; 可以为一个dict, 则key是用户自定义的某个文件的名称，value是这个文件的路径。 返回:
fastNLP.models¶
fastNLP 在 models 模块中内置了如 CNNText 、
SeqLabeling 等完整的模型，以供用户直接使用。
-
class
fastNLP.models.CNNText(embed, num_classes, kernel_nums=(30, 40, 50), kernel_sizes=(1, 3, 5), dropout=0.5)[源代码]¶ 别名
fastNLP.models.CNNTextfastNLP.models.cnn_text_classification.CNNText使用CNN进行文本分类的模型 'Yoon Kim. 2014. Convolution Neural Networks for Sentence Classification.'
-
__init__(embed, num_classes, kernel_nums=(30, 40, 50), kernel_sizes=(1, 3, 5), dropout=0.5)[源代码]¶ 参数: - embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 如果为Tensor, Embedding, ndarray等则直接使用该值初始化Embedding
- num_classes (int) -- 一共有多少类
- kernel_sizes (int,tuple(int)) -- 输出channel的kernel大小。
- dropout (float) -- Dropout的大小
-
-
class
fastNLP.models.SeqLabeling(embed, hidden_size, num_classes)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.SeqLabelingfastNLP.models.sequence_labeling.SeqLabeling一个基础的Sequence labeling的模型。 用于做sequence labeling的基础类。结构包含一层Embedding，一层LSTM(单向，一层)，一层FC，以及一层CRF。-
__init__(embed, hidden_size, num_classes)[源代码]¶ 参数: - embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 如果为Tensor, embedding, ndarray等则直接使用该值初始化Embedding
- hidden_size (int) -- LSTM隐藏层的大小
- num_classes (int) -- 一共有多少类
-
forward(words, seq_len, target)[源代码]¶ 参数: - words (torch.LongTensor) -- [batch_size, max_len]，序列的index
- seq_len (torch.LongTensor) -- [batch_size,], 这个序列的长度
- target (torch.LongTensor) -- [batch_size, max_len], 序列的目标值
Return y: If truth is None, return list of [decode path(list)]. Used in testing and predicting. If truth is not None, return loss, a scalar. Used in training.
-
-
class
fastNLP.models.AdvSeqLabel(embed, hidden_size, num_classes, dropout=0.3, id2words=None, encoding_type='bmes')[源代码]¶ 别名
fastNLP.models.AdvSeqLabelfastNLP.models.sequence_labeling.AdvSeqLabel更复杂的Sequence Labelling模型。结构为Embedding, LayerNorm, 双向LSTM(两层)，FC，LayerNorm，DropOut，FC，CRF。
-
__init__(embed, hidden_size, num_classes, dropout=0.3, id2words=None, encoding_type='bmes')[源代码]¶ 参数: - embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 如果为Tensor, Embedding, ndarray等则直接使用该值初始化Embedding
- hidden_size (int) -- LSTM的隐层大小
- num_classes (int) -- 有多少个类
- dropout (float) -- LSTM中以及DropOut层的drop概率
- id2words (dict) -- tag id转为其tag word的表。用于在CRF解码时防止解出非法的顺序，比如'BMES'这个标签规范中，'S' 不能出现在'B'之后。这里也支持类似与'B-NN'，即'-'前为标签类型的指示，后面为具体的tag的情况。这里不但会保证 'B-NN'后面不为'S-NN'还会保证'B-NN'后面不会出现'M-xx'(任何非'M-NN'和'E-NN'的情况。)
- encoding_type (str) -- 支持"BIO", "BMES", "BEMSO", 只有在id2words不为None的情况有用。
-
-
class
fastNLP.models.ESIM(embed, hidden_size=None, num_labels=3, dropout_rate=0.3, dropout_embed=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.ESIMfastNLP.models.snli.ESIMESIM model的一个PyTorch实现 论文参见： https://arxiv.org/pdf/1609.06038.pdf
-
class
fastNLP.models.StarTransEnc(embed, hidden_size, num_layers, num_head, head_dim, max_len, emb_dropout, dropout)[源代码]¶ 别名
fastNLP.models.StarTransEncfastNLP.models.star_transformer.StarTransEnc带word embedding的Star-Transformer Encoder
-
__init__(embed, hidden_size, num_layers, num_head, head_dim, max_len, emb_dropout, dropout)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象,此时就以传入的对象作为embedding
- hidden_size -- 模型中特征维度.
- num_layers -- 模型层数.
- num_head -- 模型中multi-head的head个数.
- head_dim -- 模型中multi-head中每个head特征维度.
- max_len -- 模型能接受的最大输入长度.
- emb_dropout -- 词嵌入的dropout概率.
- dropout -- 模型除词嵌入外的dropout概率.
-
-
class
fastNLP.models.STSeqLabel(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 别名
fastNLP.models.STSeqLabelfastNLP.models.star_transformer.STSeqLabel用于序列标注的Star-Transformer模型
-
__init__(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- num_cls -- 输出类别个数
- hidden_size -- 模型中特征维度. Default: 300
- num_layers -- 模型层数. Default: 4
- num_head -- 模型中multi-head的head个数. Default: 8
- head_dim -- 模型中multi-head中每个head特征维度. Default: 32
- max_len -- 模型能接受的最大输入长度. Default: 512
- cls_hidden_size -- 分类器隐层维度. Default: 600
- emb_dropout -- 词嵌入的dropout概率. Default: 0.1
- dropout -- 模型除词嵌入外的dropout概率. Default: 0.1
-
-
class
fastNLP.models.STNLICls(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 别名
fastNLP.models.STNLIClsfastNLP.models.star_transformer.STNLICls用于自然语言推断(NLI)的Star-Transformer
-
__init__(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- num_cls -- 输出类别个数
- hidden_size -- 模型中特征维度. Default: 300
- num_layers -- 模型层数. Default: 4
- num_head -- 模型中multi-head的head个数. Default: 8
- head_dim -- 模型中multi-head中每个head特征维度. Default: 32
- max_len -- 模型能接受的最大输入长度. Default: 512
- cls_hidden_size -- 分类器隐层维度. Default: 600
- emb_dropout -- 词嵌入的dropout概率. Default: 0.1
- dropout -- 模型除词嵌入外的dropout概率. Default: 0.1
-
-
class
fastNLP.models.STSeqCls(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 别名
fastNLP.models.STSeqClsfastNLP.models.star_transformer.STSeqCls用于分类任务的Star-Transformer
-
__init__(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- num_cls -- 输出类别个数
- hidden_size -- 模型中特征维度. Default: 300
- num_layers -- 模型层数. Default: 4
- num_head -- 模型中multi-head的head个数. Default: 8
- head_dim -- 模型中multi-head中每个head特征维度. Default: 32
- max_len -- 模型能接受的最大输入长度. Default: 512
- cls_hidden_size -- 分类器隐层维度. Default: 600
- emb_dropout -- 词嵌入的dropout概率. Default: 0.1
- dropout -- 模型除词嵌入外的dropout概率. Default: 0.1
-
-
class
fastNLP.models.BiaffineParser(embed, pos_vocab_size, pos_emb_dim, num_label, rnn_layers=1, rnn_hidden_size=200, arc_mlp_size=100, label_mlp_size=100, dropout=0.3, encoder='lstm', use_greedy_infer=False)[源代码]¶ -
别名
fastNLP.models.BiaffineParserfastNLP.models.biaffine_parser.BiaffineParserBiaffine Dependency Parser 实现. 论文参考 Deep Biaffine Attention for Neural Dependency Parsing (Dozat and Manning, 2016) .-
__init__(embed, pos_vocab_size, pos_emb_dim, num_label, rnn_layers=1, rnn_hidden_size=200, arc_mlp_size=100, label_mlp_size=100, dropout=0.3, encoder='lstm', use_greedy_infer=False)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- pos_vocab_size -- part-of-speech 词典大小
- pos_emb_dim -- part-of-speech 向量维度
- num_label -- 边的类别个数
- rnn_layers -- rnn encoder的层数
- rnn_hidden_size -- rnn encoder 的隐状态维度
- arc_mlp_size -- 边预测的MLP维度
- label_mlp_size -- 类别预测的MLP维度
- dropout -- dropout概率.
- encoder -- encoder类别, 可选 ('lstm', 'var-lstm', 'transformer'). Default: lstm
- use_greedy_infer -- 是否在inference时使用贪心算法.
若
False, 使用更加精确但相对缓慢的MST算法. Default:False
-
forward(words1, words2, seq_len, target1=None)[源代码]¶ 模型forward阶段
参数: - words1 -- [batch_size, seq_len] 输入word序列
- words2 -- [batch_size, seq_len] 输入pos序列
- seq_len -- [batch_size, seq_len] 输入序列长度
- target1 -- [batch_size, seq_len] 输入真实标注的heads, 仅在训练阶段有效,
用于训练label分类器. 若为
None, 使用预测的heads输入到label分类器 Default:None
Return dict: parsing 结果:
pred1: [batch_size, seq_len, seq_len] 边预测logits pred2: [batch_size, seq_len, num_label] label预测logits pred3: [batch_size, seq_len] heads的预测结果, 在 ``target1=None`` 时预测
-
static
loss(pred1, pred2, target1, target2, seq_len)[源代码]¶ 计算parser的loss
参数: - pred1 -- [batch_size, seq_len, seq_len] 边预测logits
- pred2 -- [batch_size, seq_len, num_label] label预测logits
- target1 -- [batch_size, seq_len] 真实边的标注
- target2 -- [batch_size, seq_len] 真实类别的标注
- seq_len -- [batch_size, seq_len] 真实目标的长度
Return loss: scalar
-
-
class
fastNLP.models.GraphParser[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.GraphParserfastNLP.models.biaffine_parser.GraphParser基于图的parser base class, 支持贪婪解码和最大生成树解码
-
class
fastNLP.models.BertForSequenceClassification(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForSequenceClassificationfastNLP.models.bert.BertForSequenceClassificationBERT model for classification.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- 文本分类类别数目，默认值为2.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.Tensor [batch_size, num_labels]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size]
-
-
class
fastNLP.models.BertForSentenceMatching(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForSentenceMatchingfastNLP.models.bert.BertForSentenceMatchingBERT model for sentence matching.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- Matching任务类别数目，默认值为2.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.Tensor [batch_size, num_labels]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size]
-
-
class
fastNLP.models.BertForMultipleChoice(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_choices=2, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForMultipleChoicefastNLP.models.bert.BertForMultipleChoiceBERT model for multiple choice.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_choices=2, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_choices (int) -- 多选任务选项数目，默认值为2.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, num_choices, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size, num_choices]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, num_choices, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size]
-
-
class
fastNLP.models.BertForTokenClassification(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForTokenClassificationfastNLP.models.bert.BertForTokenClassificationBERT model for token classification.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- 序列标注标签数目，无默认值.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.Tensor [batch_size, seq_len, num_labels]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size, seq_len]
-
-
class
fastNLP.models.BertForQuestionAnswering(embed: fastNLP.embeddings.bert_embedding.BertEmbedding)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForQuestionAnsweringfastNLP.models.bert.BertForQuestionAnswering用于做Q&A的Bert模型，如果是Squad2.0请将BertEmbedding的include_cls_sep设置为True，Squad1.0或CMRC则设置为False-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- 抽取式QA列数，默认值为2(即第一列为start_span, 第二列为end_span).
-
子模块¶
fastNLP提供了BERT应用到五个下游任务的模型代码，可以直接调用。这五个任务分别为
- 文本分类任务：
BertForSequenceClassification- Matching任务：
BertForSentenceMatching- 多选任务：
BertForMultipleChoice- 序列标注任务：
BertForTokenClassification- 抽取式QA任务：
BertForQuestionAnswering
每一个模型必须要传入一个名字为 embed 的 fastNLP.embeddings.BertEmbedding ，这个参数包含了
fastNLP.modules.encoder.BertModel ，是下游模型的编码器(encoder)。
除此以外，还需要传入一个数字，这个数字在不同下游任务模型上的意义如下:
下游任务模型 参数名称 含义
BertForSequenceClassification num_labels 文本分类类别数目，默认值为2
BertForSentenceMatching num_labels Matching任务类别数目，默认值为2
BertForMultipleChoice num_choices 多选任务选项数目，默认值为2
BertForTokenClassification num_labels 序列标注标签数目，无默认值
BertForQuestionAnswering num_labels 抽取式QA列数，默认值为2(即第一列为start_span, 第二列为end_span)
最后还可以传入dropout的大小，默认值为0.1。
-
class
fastNLP.models.bert.BertForSequenceClassification(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForSequenceClassificationfastNLP.models.bert.BertForSequenceClassificationBERT model for classification.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- 文本分类类别数目，默认值为2.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.Tensor [batch_size, num_labels]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size]
-
-
class
fastNLP.models.bert.BertForSentenceMatching(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForSentenceMatchingfastNLP.models.bert.BertForSentenceMatchingBERT model for sentence matching.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels: int = 2, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- Matching任务类别数目，默认值为2.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.Tensor [batch_size, num_labels]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size]
-
-
class
fastNLP.models.bert.BertForMultipleChoice(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_choices=2, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForMultipleChoicefastNLP.models.bert.BertForMultipleChoiceBERT model for multiple choice.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_choices=2, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_choices (int) -- 多选任务选项数目，默认值为2.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, num_choices, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size, num_choices]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, num_choices, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size]
-
-
class
fastNLP.models.bert.BertForTokenClassification(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels, dropout=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForTokenClassificationfastNLP.models.bert.BertForTokenClassificationBERT model for token classification.-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding, num_labels, dropout=0.1)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- 序列标注标签数目，无默认值.
- dropout (float) -- dropout的大小，默认值为0.1.
-
forward(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.Tensor [batch_size, seq_len, num_labels]
-
predict(words)[源代码]¶ 参数: words (torch.LongTensor) -- [batch_size, seq_len] 返回: { fastNLP.Const.OUTPUT: logits}: torch.LongTensor [batch_size, seq_len]
-
-
class
fastNLP.models.bert.BertForQuestionAnswering(embed: fastNLP.embeddings.bert_embedding.BertEmbedding)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BertForQuestionAnsweringfastNLP.models.bert.BertForQuestionAnswering用于做Q&A的Bert模型，如果是Squad2.0请将BertEmbedding的include_cls_sep设置为True，Squad1.0或CMRC则设置为False-
__init__(embed: fastNLP.embeddings.bert_embedding.BertEmbedding)[源代码]¶ 参数: - embed (fastNLP.embeddings.BertEmbedding) -- 下游模型的编码器(encoder).
- num_labels (int) -- 抽取式QA列数，默认值为2(即第一列为start_span, 第二列为end_span).
-
Biaffine Dependency Parser 的 Pytorch 实现.
-
class
fastNLP.models.biaffine_parser.BiaffineParser(embed, pos_vocab_size, pos_emb_dim, num_label, rnn_layers=1, rnn_hidden_size=200, arc_mlp_size=100, label_mlp_size=100, dropout=0.3, encoder='lstm', use_greedy_infer=False)[源代码]¶ -
别名
fastNLP.models.BiaffineParserfastNLP.models.biaffine_parser.BiaffineParserBiaffine Dependency Parser 实现. 论文参考 Deep Biaffine Attention for Neural Dependency Parsing (Dozat and Manning, 2016) .-
__init__(embed, pos_vocab_size, pos_emb_dim, num_label, rnn_layers=1, rnn_hidden_size=200, arc_mlp_size=100, label_mlp_size=100, dropout=0.3, encoder='lstm', use_greedy_infer=False)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- pos_vocab_size -- part-of-speech 词典大小
- pos_emb_dim -- part-of-speech 向量维度
- num_label -- 边的类别个数
- rnn_layers -- rnn encoder的层数
- rnn_hidden_size -- rnn encoder 的隐状态维度
- arc_mlp_size -- 边预测的MLP维度
- label_mlp_size -- 类别预测的MLP维度
- dropout -- dropout概率.
- encoder -- encoder类别, 可选 ('lstm', 'var-lstm', 'transformer'). Default: lstm
- use_greedy_infer -- 是否在inference时使用贪心算法.
若
False, 使用更加精确但相对缓慢的MST算法. Default:False
-
forward(words1, words2, seq_len, target1=None)[源代码]¶ 模型forward阶段
参数: - words1 -- [batch_size, seq_len] 输入word序列
- words2 -- [batch_size, seq_len] 输入pos序列
- seq_len -- [batch_size, seq_len] 输入序列长度
- target1 -- [batch_size, seq_len] 输入真实标注的heads, 仅在训练阶段有效,
用于训练label分类器. 若为
None, 使用预测的heads输入到label分类器 Default:None
Return dict: parsing 结果:
pred1: [batch_size, seq_len, seq_len] 边预测logits pred2: [batch_size, seq_len, num_label] label预测logits pred3: [batch_size, seq_len] heads的预测结果, 在 ``target1=None`` 时预测
-
static
loss(pred1, pred2, target1, target2, seq_len)[源代码]¶ 计算parser的loss
参数: - pred1 -- [batch_size, seq_len, seq_len] 边预测logits
- pred2 -- [batch_size, seq_len, num_label] label预测logits
- target1 -- [batch_size, seq_len] 真实边的标注
- target2 -- [batch_size, seq_len] 真实类别的标注
- seq_len -- [batch_size, seq_len] 真实目标的长度
Return loss: scalar
-
-
class
fastNLP.models.biaffine_parser.GraphParser[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.GraphParserfastNLP.models.biaffine_parser.GraphParser基于图的parser base class, 支持贪婪解码和最大生成树解码
-
class
fastNLP.models.cnn_text_classification.CNNText(embed, num_classes, kernel_nums=(30, 40, 50), kernel_sizes=(1, 3, 5), dropout=0.5)[源代码]¶ 别名
fastNLP.models.CNNTextfastNLP.models.cnn_text_classification.CNNText使用CNN进行文本分类的模型 'Yoon Kim. 2014. Convolution Neural Networks for Sentence Classification.'
-
__init__(embed, num_classes, kernel_nums=(30, 40, 50), kernel_sizes=(1, 3, 5), dropout=0.5)[源代码]¶ 参数: - embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 如果为Tensor, Embedding, ndarray等则直接使用该值初始化Embedding
- num_classes (int) -- 一共有多少类
- kernel_sizes (int,tuple(int)) -- 输出channel的kernel大小。
- dropout (float) -- Dropout的大小
-
本模块实现了几种序列标注模型
-
class
fastNLP.models.sequence_labeling.SeqLabeling(embed, hidden_size, num_classes)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.SeqLabelingfastNLP.models.sequence_labeling.SeqLabeling一个基础的Sequence labeling的模型。 用于做sequence labeling的基础类。结构包含一层Embedding，一层LSTM(单向，一层)，一层FC，以及一层CRF。-
__init__(embed, hidden_size, num_classes)[源代码]¶ 参数: - embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 如果为Tensor, embedding, ndarray等则直接使用该值初始化Embedding
- hidden_size (int) -- LSTM隐藏层的大小
- num_classes (int) -- 一共有多少类
-
forward(words, seq_len, target)[源代码]¶ 参数: - words (torch.LongTensor) -- [batch_size, max_len]，序列的index
- seq_len (torch.LongTensor) -- [batch_size,], 这个序列的长度
- target (torch.LongTensor) -- [batch_size, max_len], 序列的目标值
Return y: If truth is None, return list of [decode path(list)]. Used in testing and predicting. If truth is not None, return loss, a scalar. Used in training.
-
-
class
fastNLP.models.sequence_labeling.AdvSeqLabel(embed, hidden_size, num_classes, dropout=0.3, id2words=None, encoding_type='bmes')[源代码]¶ 别名
fastNLP.models.AdvSeqLabelfastNLP.models.sequence_labeling.AdvSeqLabel更复杂的Sequence Labelling模型。结构为Embedding, LayerNorm, 双向LSTM(两层)，FC，LayerNorm，DropOut，FC，CRF。
-
__init__(embed, hidden_size, num_classes, dropout=0.3, id2words=None, encoding_type='bmes')[源代码]¶ 参数: - embed (tuple(int,int),torch.FloatTensor,nn.Embedding,numpy.ndarray) -- Embedding的大小(传入tuple(int, int), 第一个int为vocab_zie, 第二个int为embed_dim); 如果为Tensor, Embedding, ndarray等则直接使用该值初始化Embedding
- hidden_size (int) -- LSTM的隐层大小
- num_classes (int) -- 有多少个类
- dropout (float) -- LSTM中以及DropOut层的drop概率
- id2words (dict) -- tag id转为其tag word的表。用于在CRF解码时防止解出非法的顺序，比如'BMES'这个标签规范中，'S' 不能出现在'B'之后。这里也支持类似与'B-NN'，即'-'前为标签类型的指示，后面为具体的tag的情况。这里不但会保证 'B-NN'后面不为'S-NN'还会保证'B-NN'后面不会出现'M-xx'(任何非'M-NN'和'E-NN'的情况。)
- encoding_type (str) -- 支持"BIO", "BMES", "BEMSO", 只有在id2words不为None的情况有用。
-
-
class
fastNLP.models.sequence_labeling.BiLSTMCRF(embed, num_classes, num_layers=1, hidden_size=100, dropout=0.5, target_vocab=None)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.BiLSTMCRFfastNLP.models.sequence_labeling.BiLSTMCRF结构为embedding + BiLSTM + FC + Dropout + CRF.-
__init__(embed, num_classes, num_layers=1, hidden_size=100, dropout=0.5, target_vocab=None)[源代码]¶ 参数: - embed -- 支持(1)fastNLP的各种Embedding, (2) tuple, 指明num_embedding, dimension, 如(1000, 100)
- num_classes -- 一共多少个类
- num_layers -- BiLSTM的层数
- hidden_size -- BiLSTM的hidden_size，实际hidden size为该值的两倍(前向、后向)
- dropout -- dropout的概率，0为不dropout
- target_vocab -- Vocabulary对象，target与index的对应关系。如果传入该值，将自动避免非法的解码序列。
-
-
class
fastNLP.models.snli.ESIM(embed, hidden_size=None, num_labels=3, dropout_rate=0.3, dropout_embed=0.1)[源代码]¶ 基类
fastNLP.models.BaseModel别名
fastNLP.models.ESIMfastNLP.models.snli.ESIMESIM model的一个PyTorch实现 论文参见： https://arxiv.org/pdf/1609.06038.pdf
Star-Transformer 的 Pytorch 实现。
-
class
fastNLP.models.star_transformer.StarTransEnc(embed, hidden_size, num_layers, num_head, head_dim, max_len, emb_dropout, dropout)[源代码]¶ 别名
fastNLP.models.StarTransEncfastNLP.models.star_transformer.StarTransEnc带word embedding的Star-Transformer Encoder
-
__init__(embed, hidden_size, num_layers, num_head, head_dim, max_len, emb_dropout, dropout)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象,此时就以传入的对象作为embedding
- hidden_size -- 模型中特征维度.
- num_layers -- 模型层数.
- num_head -- 模型中multi-head的head个数.
- head_dim -- 模型中multi-head中每个head特征维度.
- max_len -- 模型能接受的最大输入长度.
- emb_dropout -- 词嵌入的dropout概率.
- dropout -- 模型除词嵌入外的dropout概率.
-
-
class
fastNLP.models.star_transformer.STNLICls(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 别名
fastNLP.models.STNLIClsfastNLP.models.star_transformer.STNLICls用于自然语言推断(NLI)的Star-Transformer
-
__init__(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- num_cls -- 输出类别个数
- hidden_size -- 模型中特征维度. Default: 300
- num_layers -- 模型层数. Default: 4
- num_head -- 模型中multi-head的head个数. Default: 8
- head_dim -- 模型中multi-head中每个head特征维度. Default: 32
- max_len -- 模型能接受的最大输入长度. Default: 512
- cls_hidden_size -- 分类器隐层维度. Default: 600
- emb_dropout -- 词嵌入的dropout概率. Default: 0.1
- dropout -- 模型除词嵌入外的dropout概率. Default: 0.1
-
-
class
fastNLP.models.star_transformer.STSeqCls(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 别名
fastNLP.models.STSeqClsfastNLP.models.star_transformer.STSeqCls用于分类任务的Star-Transformer
-
__init__(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- num_cls -- 输出类别个数
- hidden_size -- 模型中特征维度. Default: 300
- num_layers -- 模型层数. Default: 4
- num_head -- 模型中multi-head的head个数. Default: 8
- head_dim -- 模型中multi-head中每个head特征维度. Default: 32
- max_len -- 模型能接受的最大输入长度. Default: 512
- cls_hidden_size -- 分类器隐层维度. Default: 600
- emb_dropout -- 词嵌入的dropout概率. Default: 0.1
- dropout -- 模型除词嵌入外的dropout概率. Default: 0.1
-
-
class
fastNLP.models.star_transformer.STSeqLabel(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 别名
fastNLP.models.STSeqLabelfastNLP.models.star_transformer.STSeqLabel用于序列标注的Star-Transformer模型
-
__init__(embed, num_cls, hidden_size=300, num_layers=4, num_head=8, head_dim=32, max_len=512, cls_hidden_size=600, emb_dropout=0.1, dropout=0.1)[源代码]¶ 参数: - embed -- 单词词典, 可以是 tuple, 包括(num_embedings, embedding_dim), 即 embedding的大小和每个词的维度. 也可以传入 nn.Embedding 对象, 此时就以传入的对象作为embedding
- num_cls -- 输出类别个数
- hidden_size -- 模型中特征维度. Default: 300
- num_layers -- 模型层数. Default: 4
- num_head -- 模型中multi-head的head个数. Default: 8
- head_dim -- 模型中multi-head中每个head特征维度. Default: 32
- max_len -- 模型能接受的最大输入长度. Default: 512
- cls_hidden_size -- 分类器隐层维度. Default: 600
- emb_dropout -- 词嵌入的dropout概率. Default: 0.1
- dropout -- 模型除词嵌入外的dropout概率. Default: 0.1
-
fastNLP.modules¶
大部分用于的 NLP 任务神经网络都可以看做由 embedding 、 encoder 、
decoder 三种模块组成。 本模块中实现了 fastNLP 提供的诸多模块组件，
可以帮助用户快速搭建自己所需的网络。几种模块的功能和常见组件如下:
| 类型 | 功能 | 常见组件 |
|---|---|---|
| embedding | 参见 /fastNLP.embeddings |
Elmo, Bert |
| encoder | 将输入编码为具有表示能力的向量 | CNN, LSTM, Transformer |
| decoder | 将具有某种表示意义的向量解码为需要的输出形式 | MLP, CRF |
| 其它 | 配合其它组件使用的组件 | Dropout |
-
class
fastNLP.modules.ConvolutionCharEncoder(char_emb_size=50, feature_maps=(40, 30, 30), kernels=(1, 3, 5), initial_method=None)[源代码]¶ 别名
fastNLP.modules.ConvolutionCharEncoderfastNLP.modules.encoder.ConvolutionCharEncoderchar级别的卷积编码器.
-
__init__(char_emb_size=50, feature_maps=(40, 30, 30), kernels=(1, 3, 5), initial_method=None)[源代码]¶ 参数: - char_emb_size (int) -- char级别embedding的维度. Default: 50 :例: 有26个字符, 每一个的embedding是一个50维的向量, 所以输入的向量维度为50.
- feature_maps (tuple) -- 一个由int组成的tuple. tuple的长度是char级别卷积操作的数目, 第`i`个int表示第`i`个卷积操作的filter.
- kernels (tuple) -- 一个由int组成的tuple. tuple的长度是char级别卷积操作的数目, 第`i`个int表示第`i`个卷积操作的卷积核.
- initial_method -- 初始化参数的方式, 默认为`xavier normal`
-
-
class
fastNLP.modules.LSTMCharEncoder(char_emb_size=50, hidden_size=None, initial_method=None)[源代码]¶ 别名
fastNLP.modules.LSTMCharEncoderfastNLP.modules.encoder.LSTMCharEncoderchar级别基于LSTM的encoder.
-
class
fastNLP.modules.ConvMaxpool(in_channels, out_channels, kernel_sizes, activation='relu')[源代码]¶ 别名
fastNLP.modules.ConvMaxpoolfastNLP.modules.encoder.ConvMaxpool集合了Convolution和Max-Pooling于一体的层。给定一个batch_size x max_len x input_size的输入，返回batch_size x sum(output_channels) 大小的matrix。在内部，是先使用CNN给输入做卷积，然后经过activation激活层，在通过在长度(max_len) 这一维进行max_pooling。最后得到每个sample的一个向量表示。
-
__init__(in_channels, out_channels, kernel_sizes, activation='relu')[源代码]¶ 参数: - in_channels (int) -- 输入channel的大小，一般是embedding的维度; 或encoder的output维度
- out_channels (int,tuple(int)) -- 输出channel的数量。如果为list，则需要与kernel_sizes的数量保持一致
- kernel_sizes (int,tuple(int)) -- 输出channel的kernel大小。
- activation (str) -- Convolution后的结果将通过该activation后再经过max-pooling。支持relu, sigmoid, tanh
-
-
class
fastNLP.modules.LSTM(input_size, hidden_size=100, num_layers=1, dropout=0.0, batch_first=True, bidirectional=False, bias=True)[源代码]¶ 别名
fastNLP.modules.LSTMfastNLP.modules.encoder.LSTMLSTM 模块, 轻量封装的Pytorch LSTM. 在提供seq_len的情况下，将自动使用pack_padded_sequence; 同时默认将forget gate的bias初始化 为1; 且可以应对DataParallel中LSTM的使用问题。
-
__init__(input_size, hidden_size=100, num_layers=1, dropout=0.0, batch_first=True, bidirectional=False, bias=True)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度.
- num_layers -- rnn的层数. Default: 1
- dropout -- 层间dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的RNN. Default:False - batch_first -- 若为
True, 输入和输出Tensor形状为 :(batch, seq, feature). Default:False - bias -- 如果为
False, 模型将不会使用bias. Default:True
-
forward(x, seq_len=None, h0=None, c0=None)[源代码]¶ 参数: - x -- [batch, seq_len, input_size] 输入序列
- seq_len -- [batch, ] 序列长度, 若为
None, 所有输入看做一样长. Default:None - h0 -- [batch, hidden_size] 初始隐状态, 若为
None, 设为全0向量. Default:None - c0 -- [batch, hidden_size] 初始Cell状态, 若为
None, 设为全0向量. Default:None
Return (output, (ht, ct)): output: [batch, seq_len, hidden_size*num_direction] 输出序列 和 ht,ct: [num_layers*num_direction, batch, hidden_size] 最后时刻隐状态.
-
-
class
fastNLP.modules.StarTransformer(hidden_size, num_layers, num_head, head_dim, dropout=0.1, max_len=None)[源代码]¶ 别名
fastNLP.modules.StarTransformerfastNLP.modules.encoder.StarTransformerStar-Transformer 的encoder部分。 输入3d的文本输入, 返回相同长度的文本编码
paper: https://arxiv.org/abs/1902.09113
-
__init__(hidden_size, num_layers, num_head, head_dim, dropout=0.1, max_len=None)[源代码]¶ 参数: - hidden_size (int) -- 输入维度的大小。同时也是输出维度的大小。
- num_layers (int) -- star-transformer的层数
- num_head (int) -- head的数量。
- head_dim (int) -- 每个head的维度大小。
- dropout (float) -- dropout 概率. Default: 0.1
- max_len (int) -- int or None, 如果为int，输入序列的最大长度， 模型会为输入序列加上position embedding。 若为`None`，忽略加上position embedding的步骤. Default: None
-
-
class
fastNLP.modules.TransformerEncoder(num_layers, **kargs)[源代码]¶ 别名
fastNLP.modules.TransformerEncoderfastNLP.modules.encoder.TransformerEncodertransformer的encoder模块，不包含embedding层
-
class
fastNLP.modules.VarRNN(*args, **kwargs)[源代码]¶ 基类
fastNLP.modules.VarRNNBase别名
fastNLP.modules.VarRNNfastNLP.modules.encoder.VarRNNVariational Dropout RNN. 相关论文参考：A Theoretically Grounded Application of Dropout in Recurrent Neural Networks (Yarin Gal and Zoubin Ghahramani, 2016)-
__init__(*args, **kwargs)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度
- num_layers -- rnn的层数. Default: 1
- bias -- 如果为
False, 模型将不会使用bias. Default:True - batch_first -- 若为
True, 输入和输出Tensor形状为 (batch, seq, feature). Default:False - input_dropout -- 对输入的dropout概率. Default: 0
- hidden_dropout -- 对每个隐状态的dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的RNN. Default:False
-
-
class
fastNLP.modules.VarLSTM(*args, **kwargs)[源代码]¶ 基类
fastNLP.modules.VarRNNBase别名
fastNLP.modules.VarLSTMfastNLP.modules.encoder.VarLSTMVariational Dropout LSTM. 相关论文参考：A Theoretically Grounded Application of Dropout in Recurrent Neural Networks (Yarin Gal and Zoubin Ghahramani, 2016)-
__init__(*args, **kwargs)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度
- num_layers -- rnn的层数. Default: 1
- bias -- 如果为
False, 模型将不会使用bias. Default:True - batch_first -- 若为
True, 输入和输出Tensor形状为 (batch, seq, feature). Default:False - input_dropout -- 对输入的dropout概率. Default: 0
- hidden_dropout -- 对每个隐状态的dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的LSTM. Default:False
-
-
class
fastNLP.modules.VarGRU(*args, **kwargs)[源代码]¶ 基类
fastNLP.modules.VarRNNBase别名
fastNLP.modules.VarGRUfastNLP.modules.encoder.VarGRUVariational Dropout GRU. 相关论文参考：A Theoretically Grounded Application of Dropout in Recurrent Neural Networks (Yarin Gal and Zoubin Ghahramani, 2016)-
__init__(*args, **kwargs)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度
- num_layers -- rnn的层数. Default: 1
- bias -- 如果为
False, 模型将不会使用bias. Default:True - batch_first -- 若为
True, 输入和输出Tensor形状为 (batch, seq, feature). Default:False - input_dropout -- 对输入的dropout概率. Default: 0
- hidden_dropout -- 对每个隐状态的dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的GRU. Default:False
-
-
class
fastNLP.modules.MaxPool(stride=None, padding=0, dilation=1, dimension=1, kernel_size=None, ceil_mode=False)[源代码]¶ 别名
fastNLP.modules.MaxPoolfastNLP.modules.encoder.MaxPoolMax-pooling模块。
-
class
fastNLP.modules.MaxPoolWithMask[源代码]¶ 别名
fastNLP.modules.MaxPoolWithMaskfastNLP.modules.encoder.MaxPoolWithMask带mask矩阵的max pooling。在做max-pooling的时候不会考虑mask值为0的位置。
-
class
fastNLP.modules.KMaxPool(k=1)[源代码]¶ 别名
fastNLP.modules.KMaxPoolfastNLP.modules.encoder.KMaxPoolK max-pooling module.
-
class
fastNLP.modules.AvgPool(stride=None, padding=0)[源代码]¶ 别名
fastNLP.modules.AvgPoolfastNLP.modules.encoder.AvgPool给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size]
-
class
fastNLP.modules.AvgPoolWithMask[源代码]¶ 别名
fastNLP.modules.AvgPoolWithMaskfastNLP.modules.encoder.AvgPoolWithMask给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size], pooling 的时候只会考虑mask为1的位置
-
class
fastNLP.modules.MultiHeadAttention(input_size, key_size, value_size, num_head, dropout=0.1)[源代码]¶ 别名
fastNLP.modules.MultiHeadAttentionfastNLP.modules.encoder.MultiHeadAttentionTransformer当中的MultiHeadAttention
-
class
fastNLP.modules.MLP(size_layer, activation='relu', output_activation=None, initial_method=None, dropout=0.0)[源代码]¶ 别名
fastNLP.modules.MLPfastNLP.modules.decoder.MLP多层感知器
注解
隐藏层的激活函数通过activation定义。一个str/function或者一个str/function的list可以被传入activation。 如果只传入了一个str/function，那么所有隐藏层的激活函数都由这个str/function定义； 如果传入了一个str/function的list，那么每一个隐藏层的激活函数由这个list中对应的元素定义，其中list的长度为隐藏层数。 输出层的激活函数由output_activation定义，默认值为None，此时输出层没有激活函数。
Examples:
>>> net1 = MLP([5, 10, 5]) >>> net2 = MLP([5, 10, 5], 'tanh') >>> net3 = MLP([5, 6, 7, 8, 5], 'tanh') >>> net4 = MLP([5, 6, 7, 8, 5], 'relu', output_activation='tanh') >>> net5 = MLP([5, 6, 7, 8, 5], ['tanh', 'relu', 'tanh'], 'tanh') >>> for net in [net1, net2, net3, net4, net5]: >>> x = torch.randn(5, 5) >>> y = net(x) >>> print(x) >>> print(y)
-
__init__(size_layer, activation='relu', output_activation=None, initial_method=None, dropout=0.0)[源代码]¶ 参数: - size_layer (List[int]) -- 一个int的列表，用来定义MLP的层数，列表中的数字为每一层是hidden数目。MLP的层数为 len(size_layer) - 1
- activation (Union[str,func,List[str]]) -- 一个字符串或者函数的列表，用来定义每一个隐层的激活函数，字符串包括relu，tanh和 sigmoid，默认值为relu
- output_activation (Union[str,func]) -- 字符串或者函数，用来定义输出层的激活函数，默认值为None，表示输出层没有激活函数
- initial_method (str) -- 参数初始化方式
- dropout (float) -- dropout概率，默认值为0
-
-
class
fastNLP.modules.ConditionalRandomField(num_tags, include_start_end_trans=False, allowed_transitions=None, initial_method=None)[源代码]¶ 别名
fastNLP.modules.ConditionalRandomFieldfastNLP.modules.decoder.ConditionalRandomField条件随机场。提供forward()以及viterbi_decode()两个方法，分别用于训练与inference。
-
__init__(num_tags, include_start_end_trans=False, allowed_transitions=None, initial_method=None)[源代码]¶ 参数: - num_tags (int) -- 标签的数量
- include_start_end_trans (bool) -- 是否考虑各个tag作为开始以及结尾的分数。
- to_tag_id(int)]] allowed_transitions (List[Tuple[from_tag_id(int),) -- 内部的Tuple[from_tag_id(int), to_tag_id(int)]视为允许发生的跃迁，其他没有包含的跃迁认为是禁止跃迁，可以通过 allowed_transitions()函数得到；如果为None，则所有跃迁均为合法
- initial_method (str) -- 初始化方法。见initial_parameter
-
forward(feats, tags, mask)[源代码]¶ 用于计算CRF的前向loss，返回值为一个batch_size的FloatTensor，可能需要mean()求得loss。
参数: - feats (torch.FloatTensor) -- batch_size x max_len x num_tags，特征矩阵。
- tags (torch.LongTensor) -- batch_size x max_len，标签矩阵。
- mask (torch.ByteTensor) -- batch_size x max_len，为0的位置认为是padding。
返回: torch.FloatTensor, (batch_size,)
-
viterbi_decode(logits, mask, unpad=False)[源代码]¶ 给定一个特征矩阵以及转移分数矩阵，计算出最佳的路径以及对应的分数
参数: - logits (torch.FloatTensor) -- batch_size x max_len x num_tags，特征矩阵。
- mask (torch.ByteTensor) -- batch_size x max_len, 为0的位置认为是pad；如果为None，则认为没有padding。
- unpad (bool) -- 是否将结果删去padding。False, 返回的是batch_size x max_len的tensor; True，返回的是 List[List[int]], 内部的List[int]为每个sequence的label，已经除去pad部分，即每个List[int]的长度是这 个sample的有效长度。
返回: 返回 (paths, scores)。 paths: 是解码后的路径, 其值参照unpad参数. scores: torch.FloatTensor, size为(batch_size,), 对应每个最优路径的分数。
-
-
fastNLP.modules.viterbi_decode(logits, transitions, mask=None, unpad=False)[源代码]¶ 别名
fastNLP.modules.viterbi_decodefastNLP.modules.decoder.viterbi_decode给定一个特征矩阵以及转移分数矩阵，计算出最佳的路径以及对应的分数
参数: - logits (torch.FloatTensor) -- batch_size x max_len x num_tags，特征矩阵。
- transitions (torch.FloatTensor) -- n_tags x n_tags，[i, j]位置的值认为是从tag i到tag j的转换; 或者(n_tags+2) x (n_tags+2), 其中n_tag是start的index, n_tags+1是end的index;
- mask (torch.ByteTensor) -- batch_size x max_len, 为0的位置认为是pad；如果为None，则认为没有padding。
- unpad (bool) -- 是否将结果删去padding。False, 返回的是batch_size x max_len的tensor; True，返回的是 List[List[int]], 内部的List[int]为每个sequence的label，已经除去pad部分，即每个List[int]的长度是这 个sample的有效长度。
返回: 返回 (paths, scores)。 paths: 是解码后的路径, 其值参照unpad参数. scores: torch.FloatTensor, size为(batch_size,), 对应每个最优路径的分数。
-
fastNLP.modules.allowed_transitions(tag_vocab: Union[fastNLP.core.vocabulary.Vocabulary, dict], encoding_type=None, include_start_end=False)[源代码]¶ 别名
fastNLP.modules.allowed_transitionsfastNLP.modules.decoder.allowed_transitions给定一个id到label的映射表，返回所有可以跳转的(from_tag_id, to_tag_id)列表。
参数: - tag_vocab (Vocabulary,dict) -- 支持类型为tag或tag-label。只有tag的,比如"B", "M"; 也可以是"B-NN", "M-NN", tag和label之间一定要用"-"隔开。如果传入dict，格式需要形如{0:"O", 1:"B-tag1"}，即index在前，tag在后。
- encoding_type (str) -- 支持"bio", "bmes", "bmeso", "bioes"。默认为None，通过vocab自动推断
- include_start_end (bool) -- 是否包含开始与结尾的转换。比如在bio中，b/o可以在开头，但是i不能在开头； 为True，返回的结果中会包含(start_idx, b_idx), (start_idx, o_idx), 但是不包含(start_idx, i_idx); start_idx=len(id2label), end_idx=len(id2label)+1。为False, 返回的结果中不含与开始结尾相关的内容
返回: List[Tuple(int, int)]], 内部的Tuple是可以进行跳转的(from_tag_id, to_tag_id)。
-
class
fastNLP.modules.TimestepDropout(p=0.5, inplace=False)[源代码]¶ 传入参数的shape为
(batch_size, num_timesteps, embedding_dim)使用同一个shape为(batch_size, embedding_dim)的mask在每个timestamp上做dropout。
子模块¶
-
class
fastNLP.modules.decoder.MLP(size_layer, activation='relu', output_activation=None, initial_method=None, dropout=0.0)[源代码]¶ 别名
fastNLP.modules.MLPfastNLP.modules.decoder.MLP多层感知器
注解
隐藏层的激活函数通过activation定义。一个str/function或者一个str/function的list可以被传入activation。 如果只传入了一个str/function，那么所有隐藏层的激活函数都由这个str/function定义； 如果传入了一个str/function的list，那么每一个隐藏层的激活函数由这个list中对应的元素定义，其中list的长度为隐藏层数。 输出层的激活函数由output_activation定义，默认值为None，此时输出层没有激活函数。
Examples:
>>> net1 = MLP([5, 10, 5]) >>> net2 = MLP([5, 10, 5], 'tanh') >>> net3 = MLP([5, 6, 7, 8, 5], 'tanh') >>> net4 = MLP([5, 6, 7, 8, 5], 'relu', output_activation='tanh') >>> net5 = MLP([5, 6, 7, 8, 5], ['tanh', 'relu', 'tanh'], 'tanh') >>> for net in [net1, net2, net3, net4, net5]: >>> x = torch.randn(5, 5) >>> y = net(x) >>> print(x) >>> print(y)
-
__init__(size_layer, activation='relu', output_activation=None, initial_method=None, dropout=0.0)[源代码]¶ 参数: - size_layer (List[int]) -- 一个int的列表，用来定义MLP的层数，列表中的数字为每一层是hidden数目。MLP的层数为 len(size_layer) - 1
- activation (Union[str,func,List[str]]) -- 一个字符串或者函数的列表，用来定义每一个隐层的激活函数，字符串包括relu，tanh和 sigmoid，默认值为relu
- output_activation (Union[str,func]) -- 字符串或者函数，用来定义输出层的激活函数，默认值为None，表示输出层没有激活函数
- initial_method (str) -- 参数初始化方式
- dropout (float) -- dropout概率，默认值为0
-
-
class
fastNLP.modules.decoder.ConditionalRandomField(num_tags, include_start_end_trans=False, allowed_transitions=None, initial_method=None)[源代码]¶ 别名
fastNLP.modules.ConditionalRandomFieldfastNLP.modules.decoder.ConditionalRandomField条件随机场。提供forward()以及viterbi_decode()两个方法，分别用于训练与inference。
-
__init__(num_tags, include_start_end_trans=False, allowed_transitions=None, initial_method=None)[源代码]¶ 参数: - num_tags (int) -- 标签的数量
- include_start_end_trans (bool) -- 是否考虑各个tag作为开始以及结尾的分数。
- to_tag_id(int)]] allowed_transitions (List[Tuple[from_tag_id(int),) -- 内部的Tuple[from_tag_id(int), to_tag_id(int)]视为允许发生的跃迁，其他没有包含的跃迁认为是禁止跃迁，可以通过 allowed_transitions()函数得到；如果为None，则所有跃迁均为合法
- initial_method (str) -- 初始化方法。见initial_parameter
-
forward(feats, tags, mask)[源代码]¶ 用于计算CRF的前向loss，返回值为一个batch_size的FloatTensor，可能需要mean()求得loss。
参数: - feats (torch.FloatTensor) -- batch_size x max_len x num_tags，特征矩阵。
- tags (torch.LongTensor) -- batch_size x max_len，标签矩阵。
- mask (torch.ByteTensor) -- batch_size x max_len，为0的位置认为是padding。
返回: torch.FloatTensor, (batch_size,)
-
viterbi_decode(logits, mask, unpad=False)[源代码]¶ 给定一个特征矩阵以及转移分数矩阵，计算出最佳的路径以及对应的分数
参数: - logits (torch.FloatTensor) -- batch_size x max_len x num_tags，特征矩阵。
- mask (torch.ByteTensor) -- batch_size x max_len, 为0的位置认为是pad；如果为None，则认为没有padding。
- unpad (bool) -- 是否将结果删去padding。False, 返回的是batch_size x max_len的tensor; True，返回的是 List[List[int]], 内部的List[int]为每个sequence的label，已经除去pad部分，即每个List[int]的长度是这 个sample的有效长度。
返回: 返回 (paths, scores)。 paths: 是解码后的路径, 其值参照unpad参数. scores: torch.FloatTensor, size为(batch_size,), 对应每个最优路径的分数。
-
-
fastNLP.modules.decoder.viterbi_decode(logits, transitions, mask=None, unpad=False)[源代码]¶ 别名
fastNLP.modules.viterbi_decodefastNLP.modules.decoder.viterbi_decode给定一个特征矩阵以及转移分数矩阵，计算出最佳的路径以及对应的分数
参数: - logits (torch.FloatTensor) -- batch_size x max_len x num_tags，特征矩阵。
- transitions (torch.FloatTensor) -- n_tags x n_tags，[i, j]位置的值认为是从tag i到tag j的转换; 或者(n_tags+2) x (n_tags+2), 其中n_tag是start的index, n_tags+1是end的index;
- mask (torch.ByteTensor) -- batch_size x max_len, 为0的位置认为是pad；如果为None，则认为没有padding。
- unpad (bool) -- 是否将结果删去padding。False, 返回的是batch_size x max_len的tensor; True，返回的是 List[List[int]], 内部的List[int]为每个sequence的label，已经除去pad部分，即每个List[int]的长度是这 个sample的有效长度。
返回: 返回 (paths, scores)。 paths: 是解码后的路径, 其值参照unpad参数. scores: torch.FloatTensor, size为(batch_size,), 对应每个最优路径的分数。
-
fastNLP.modules.decoder.allowed_transitions(tag_vocab: Union[fastNLP.core.vocabulary.Vocabulary, dict], encoding_type=None, include_start_end=False)[源代码]¶ 别名
fastNLP.modules.allowed_transitionsfastNLP.modules.decoder.allowed_transitions给定一个id到label的映射表，返回所有可以跳转的(from_tag_id, to_tag_id)列表。
参数: - tag_vocab (Vocabulary,dict) -- 支持类型为tag或tag-label。只有tag的,比如"B", "M"; 也可以是"B-NN", "M-NN", tag和label之间一定要用"-"隔开。如果传入dict，格式需要形如{0:"O", 1:"B-tag1"}，即index在前，tag在后。
- encoding_type (str) -- 支持"bio", "bmes", "bmeso", "bioes"。默认为None，通过vocab自动推断
- include_start_end (bool) -- 是否包含开始与结尾的转换。比如在bio中，b/o可以在开头，但是i不能在开头； 为True，返回的结果中会包含(start_idx, b_idx), (start_idx, o_idx), 但是不包含(start_idx, i_idx); start_idx=len(id2label), end_idx=len(id2label)+1。为False, 返回的结果中不含与开始结尾相关的内容
返回: List[Tuple(int, int)]], 内部的Tuple是可以进行跳转的(from_tag_id, to_tag_id)。
-
class
fastNLP.modules.encoder.ConvolutionCharEncoder(char_emb_size=50, feature_maps=(40, 30, 30), kernels=(1, 3, 5), initial_method=None)[源代码]¶ 别名
fastNLP.modules.ConvolutionCharEncoderfastNLP.modules.encoder.ConvolutionCharEncoderchar级别的卷积编码器.
-
__init__(char_emb_size=50, feature_maps=(40, 30, 30), kernels=(1, 3, 5), initial_method=None)[源代码]¶ 参数: - char_emb_size (int) -- char级别embedding的维度. Default: 50 :例: 有26个字符, 每一个的embedding是一个50维的向量, 所以输入的向量维度为50.
- feature_maps (tuple) -- 一个由int组成的tuple. tuple的长度是char级别卷积操作的数目, 第`i`个int表示第`i`个卷积操作的filter.
- kernels (tuple) -- 一个由int组成的tuple. tuple的长度是char级别卷积操作的数目, 第`i`个int表示第`i`个卷积操作的卷积核.
- initial_method -- 初始化参数的方式, 默认为`xavier normal`
-
-
class
fastNLP.modules.encoder.LSTMCharEncoder(char_emb_size=50, hidden_size=None, initial_method=None)[源代码]¶ 别名
fastNLP.modules.LSTMCharEncoderfastNLP.modules.encoder.LSTMCharEncoderchar级别基于LSTM的encoder.
-
class
fastNLP.modules.encoder.ConvMaxpool(in_channels, out_channels, kernel_sizes, activation='relu')[源代码]¶ 别名
fastNLP.modules.ConvMaxpoolfastNLP.modules.encoder.ConvMaxpool集合了Convolution和Max-Pooling于一体的层。给定一个batch_size x max_len x input_size的输入，返回batch_size x sum(output_channels) 大小的matrix。在内部，是先使用CNN给输入做卷积，然后经过activation激活层，在通过在长度(max_len) 这一维进行max_pooling。最后得到每个sample的一个向量表示。
-
__init__(in_channels, out_channels, kernel_sizes, activation='relu')[源代码]¶ 参数: - in_channels (int) -- 输入channel的大小，一般是embedding的维度; 或encoder的output维度
- out_channels (int,tuple(int)) -- 输出channel的数量。如果为list，则需要与kernel_sizes的数量保持一致
- kernel_sizes (int,tuple(int)) -- 输出channel的kernel大小。
- activation (str) -- Convolution后的结果将通过该activation后再经过max-pooling。支持relu, sigmoid, tanh
-
-
class
fastNLP.modules.encoder.LSTM(input_size, hidden_size=100, num_layers=1, dropout=0.0, batch_first=True, bidirectional=False, bias=True)[源代码]¶ 别名
fastNLP.modules.LSTMfastNLP.modules.encoder.LSTMLSTM 模块, 轻量封装的Pytorch LSTM. 在提供seq_len的情况下，将自动使用pack_padded_sequence; 同时默认将forget gate的bias初始化 为1; 且可以应对DataParallel中LSTM的使用问题。
-
__init__(input_size, hidden_size=100, num_layers=1, dropout=0.0, batch_first=True, bidirectional=False, bias=True)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度.
- num_layers -- rnn的层数. Default: 1
- dropout -- 层间dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的RNN. Default:False - batch_first -- 若为
True, 输入和输出Tensor形状为 :(batch, seq, feature). Default:False - bias -- 如果为
False, 模型将不会使用bias. Default:True
-
forward(x, seq_len=None, h0=None, c0=None)[源代码]¶ 参数: - x -- [batch, seq_len, input_size] 输入序列
- seq_len -- [batch, ] 序列长度, 若为
None, 所有输入看做一样长. Default:None - h0 -- [batch, hidden_size] 初始隐状态, 若为
None, 设为全0向量. Default:None - c0 -- [batch, hidden_size] 初始Cell状态, 若为
None, 设为全0向量. Default:None
Return (output, (ht, ct)): output: [batch, seq_len, hidden_size*num_direction] 输出序列 和 ht,ct: [num_layers*num_direction, batch, hidden_size] 最后时刻隐状态.
-
-
class
fastNLP.modules.encoder.StarTransformer(hidden_size, num_layers, num_head, head_dim, dropout=0.1, max_len=None)[源代码]¶ 别名
fastNLP.modules.StarTransformerfastNLP.modules.encoder.StarTransformerStar-Transformer 的encoder部分。 输入3d的文本输入, 返回相同长度的文本编码
paper: https://arxiv.org/abs/1902.09113
-
__init__(hidden_size, num_layers, num_head, head_dim, dropout=0.1, max_len=None)[源代码]¶ 参数: - hidden_size (int) -- 输入维度的大小。同时也是输出维度的大小。
- num_layers (int) -- star-transformer的层数
- num_head (int) -- head的数量。
- head_dim (int) -- 每个head的维度大小。
- dropout (float) -- dropout 概率. Default: 0.1
- max_len (int) -- int or None, 如果为int，输入序列的最大长度， 模型会为输入序列加上position embedding。 若为`None`，忽略加上position embedding的步骤. Default: None
-
-
class
fastNLP.modules.encoder.TransformerEncoder(num_layers, **kargs)[源代码]¶ 别名
fastNLP.modules.TransformerEncoderfastNLP.modules.encoder.TransformerEncodertransformer的encoder模块，不包含embedding层
-
class
fastNLP.modules.encoder.VarRNN(*args, **kwargs)[源代码]¶ 基类
fastNLP.modules.VarRNNBase别名
fastNLP.modules.VarRNNfastNLP.modules.encoder.VarRNNVariational Dropout RNN. 相关论文参考：A Theoretically Grounded Application of Dropout in Recurrent Neural Networks (Yarin Gal and Zoubin Ghahramani, 2016)-
__init__(*args, **kwargs)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度
- num_layers -- rnn的层数. Default: 1
- bias -- 如果为
False, 模型将不会使用bias. Default:True - batch_first -- 若为
True, 输入和输出Tensor形状为 (batch, seq, feature). Default:False - input_dropout -- 对输入的dropout概率. Default: 0
- hidden_dropout -- 对每个隐状态的dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的RNN. Default:False
-
-
class
fastNLP.modules.encoder.VarLSTM(*args, **kwargs)[源代码]¶ 基类
fastNLP.modules.VarRNNBase别名
fastNLP.modules.VarLSTMfastNLP.modules.encoder.VarLSTMVariational Dropout LSTM. 相关论文参考：A Theoretically Grounded Application of Dropout in Recurrent Neural Networks (Yarin Gal and Zoubin Ghahramani, 2016)-
__init__(*args, **kwargs)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度
- num_layers -- rnn的层数. Default: 1
- bias -- 如果为
False, 模型将不会使用bias. Default:True - batch_first -- 若为
True, 输入和输出Tensor形状为 (batch, seq, feature). Default:False - input_dropout -- 对输入的dropout概率. Default: 0
- hidden_dropout -- 对每个隐状态的dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的LSTM. Default:False
-
-
class
fastNLP.modules.encoder.VarGRU(*args, **kwargs)[源代码]¶ 基类
fastNLP.modules.VarRNNBase别名
fastNLP.modules.VarGRUfastNLP.modules.encoder.VarGRUVariational Dropout GRU. 相关论文参考：A Theoretically Grounded Application of Dropout in Recurrent Neural Networks (Yarin Gal and Zoubin Ghahramani, 2016)-
__init__(*args, **kwargs)[源代码]¶ 参数: - input_size -- 输入 x 的特征维度
- hidden_size -- 隐状态 h 的特征维度
- num_layers -- rnn的层数. Default: 1
- bias -- 如果为
False, 模型将不会使用bias. Default:True - batch_first -- 若为
True, 输入和输出Tensor形状为 (batch, seq, feature). Default:False - input_dropout -- 对输入的dropout概率. Default: 0
- hidden_dropout -- 对每个隐状态的dropout概率. Default: 0
- bidirectional -- 若为
True, 使用双向的GRU. Default:False
-
-
class
fastNLP.modules.encoder.MaxPool(stride=None, padding=0, dilation=1, dimension=1, kernel_size=None, ceil_mode=False)[源代码]¶ 别名
fastNLP.modules.MaxPoolfastNLP.modules.encoder.MaxPoolMax-pooling模块。
-
class
fastNLP.modules.encoder.MaxPoolWithMask[源代码]¶ 别名
fastNLP.modules.MaxPoolWithMaskfastNLP.modules.encoder.MaxPoolWithMask带mask矩阵的max pooling。在做max-pooling的时候不会考虑mask值为0的位置。
-
class
fastNLP.modules.encoder.KMaxPool(k=1)[源代码]¶ 别名
fastNLP.modules.KMaxPoolfastNLP.modules.encoder.KMaxPoolK max-pooling module.
-
class
fastNLP.modules.encoder.AvgPool(stride=None, padding=0)[源代码]¶ 别名
fastNLP.modules.AvgPoolfastNLP.modules.encoder.AvgPool给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size]
-
class
fastNLP.modules.encoder.AvgPoolWithMask[源代码]¶ 别名
fastNLP.modules.AvgPoolWithMaskfastNLP.modules.encoder.AvgPoolWithMask给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size], pooling 的时候只会考虑mask为1的位置
-
class
fastNLP.modules.encoder.MultiHeadAttention(input_size, key_size, value_size, num_head, dropout=0.1)[源代码]¶ 别名
fastNLP.modules.MultiHeadAttentionfastNLP.modules.encoder.MultiHeadAttentionTransformer当中的MultiHeadAttention
-
class
fastNLP.modules.encoder.BiAttention[源代码]¶ 别名
fastNLP.modules.BiAttentionfastNLP.modules.encoder.BiAttentionBi Attention module
对于给定的两个向量序列 \(a_i\) 和 \(b_j\) , BiAttention模块将通过以下的公式来计算attention结果
\[\begin{split}\begin{array}{ll} \\ e_{ij} = {a}^{\mathrm{T}}_{i}{b}_{j} \\ {\hat{a}}_{i} = \sum_{j=1}^{\mathcal{l}_{b}}{\frac{\mathrm{exp}(e_{ij})}{\sum_{k=1}^{\mathcal{l}_{b}}{\mathrm{exp}(e_{ik})}}}{b}_{j} \\ {\hat{b}}_{j} = \sum_{i=1}^{\mathcal{l}_{a}}{\frac{\mathrm{exp}(e_{ij})}{\sum_{k=1}^{\mathcal{l}_{a}}{\mathrm{exp}(e_{ik})}}}{a}_{i} \\ \end{array}\end{split}\]-
forward(premise_batch, premise_mask, hypothesis_batch, hypothesis_mask)[源代码]¶ 参数: - premise_batch (torch.Tensor) -- [batch_size, a_seq_len, hidden_size]
- premise_mask (torch.Tensor) -- [batch_size, a_seq_len]
- hypothesis_batch (torch.Tensor) -- [batch_size, b_seq_len, hidden_size]
- hypothesis_mask (torch.Tensor) -- [batch_size, b_seq_len]
返回: torch.Tensor attended_premises: [batch_size, a_seq_len, hidden_size] torch.Tensor attended_hypotheses: [batch_size, b_seq_len, hidden_size]
-
-
class
fastNLP.modules.encoder.SelfAttention(input_size, attention_unit=300, attention_hops=10, drop=0.5, initial_method=None)[源代码]¶ 别名
fastNLP.modules.SelfAttentionfastNLP.modules.encoder.SelfAttention这是一个基于论文 A structured self-attentive sentence embedding 的Self Attention Module.
-
__init__(input_size, attention_unit=300, attention_hops=10, drop=0.5, initial_method=None)[源代码]¶ 参数: - input_size (int) -- 输入tensor的hidden维度
- attention_unit (int) -- 输出tensor的hidden维度
- attention_hops (int) --
- drop (float) -- dropout概率，默认值为0.5
- initial_method (str) -- 初始化参数方法
-
forward(input, input_origin)[源代码]¶ 参数: - input (torch.Tensor) -- [batch_size, seq_len, hidden_size] 要做attention的矩阵
- input_origin (torch.Tensor) -- [batch_size, seq_len] 原始token的index组成的矩阵，含有pad部分内容
Return torch.Tensor output1: [batch_size, multi-head, hidden_size] 经过attention操作后输入矩阵的结果
Return torch.Tensor output2: [1] attention惩罚项，是一个标量
-
-
fastNLP.modules.utils.initial_parameter(net, initial_method=None)[源代码]¶ A method used to initialize the weights of PyTorch models.
参数: - net -- a PyTorch model
- initial_method (str) --
one of the following initializations.
- xavier_uniform
- xavier_normal (default)
- kaiming_normal, or msra
- kaiming_uniform
- orthogonal
- sparse
- normal
- uniform
-
fastNLP.modules.utils.summary(model: torch.nn.modules.module.Module)[源代码]¶ 别名
fastNLP.modules.summaryfastNLP.modules.utils.summary得到模型的总参数量
Params model: Pytorch 模型 Return tuple: 包含总参数量，可训练参数量，不可训练参数量