diff --git a/docs/source/tutorials/tutorial_5_datasetiter.rst b/docs/source/tutorials/tutorial_5_datasetiter.rst deleted file mode 100644 index 6076214f..00000000 --- a/docs/source/tutorials/tutorial_5_datasetiter.rst +++ /dev/null @@ -1,253 +0,0 @@ -============================================================================== -动手实现一个文本分类器II-使用DataSetIter实现自定义训练过程 -============================================================================== - -我们使用和 :doc:`/user/quickstart` 中一样的任务来进行详细的介绍。给出一段评价性文字，预测其情感倾向是积极（label=1）、 -消极（label=0）还是中性（label=2），使用 :class:`~fastNLP.DataSetIter` 类来编写自己的训练过程。 -自己编写训练过程之前的内容与 :doc:`/tutorials/tutorial_6_loss_optimizer` 中的完全一样，如已经阅读过可以跳过。 - --------------- -数据处理 --------------- - -数据读入 - 我们可以使用 fastNLP :mod:`fastNLP.io` 模块中的 :class:`~fastNLP.io.SSTLoader` 类，轻松地读取SST数据集（数据来源：https://nlp.stanford.edu/sentiment/trainDevTestTrees_PTB.zip）。 - 这里的 dataset 是 fastNLP 中 :class:`~fastNLP.DataSet` 类的对象。 - - .. code-block:: python - - from fastNLP.io import SSTLoader - - loader = SSTLoader() - #这里的all.txt是下载好数据后train.txt、dev.txt、test.txt的组合 - #loader.load(path)会首先判断path是否为none，若是则自动从网站下载数据，若不是则读入数据并返回databundle - databundle_ = loader.load("./trainDevTestTrees_PTB/trees/all.txt") - dataset = databundle_.datasets['train'] - print(dataset[0]) - - 输出数据如下:: - - {'words': ['It', "'s", 'a', 'lovely', 'film', 'with', 'lovely', 'performances', 'by', 'Buy', 'and', 'Accorsi', '.'] type=list, - 'target': positive type=str} - - 除了读取数据外，fastNLP 还提供了读取其它文件类型的 Loader 类、读取 Embedding的 Loader 等。详见 :doc:`/fastNLP.io` 。 - - -数据处理 - 可以使用事先定义的 :class:`~fastNLP.io.SSTPipe` 类对数据进行基本预处理，这里我们手动进行处理。 - 我们使用 :class:`~fastNLP.DataSet` 类的 :meth:`~fastNLP.DataSet.apply` 方法将 ``target`` :mod:`~fastNLP.core.field` 转化为整数。 - - .. code-block:: python - - def label_to_int(x): - if x['target']=="positive": - return 1 - elif x['target']=="negative": - return 0 - else: - return 2 - - # 将label转为整数 - dataset.apply(lambda x: label_to_int(x), new_field_name='target') - - ``words`` 和 ``target`` 已经足够用于 :class:`~fastNLP.models.CNNText` 的训练了，但我们从其文档 - :class:`~fastNLP.models.CNNText` 中看到，在 :meth:`~fastNLP.models.CNNText.forward` 的时候，还可以传入可选参数 ``seq_len`` 。 - 所以，我们再使用 :meth:`~fastNLP.DataSet.apply_field` 方法增加一个名为 ``seq_len`` 的 :mod:`~fastNLP.core.field` 。 - - .. code-block:: python - - # 增加长度信息 - dataset.apply_field(lambda x: len(x), field_name='words', new_field_name='seq_len') - - 观察可知： :meth:`~fastNLP.DataSet.apply_field` 与 :meth:`~fastNLP.DataSet.apply` 类似， - 但所传入的 `lambda` 函数是针对一个 :class:`~fastNLP.Instance` 中的一个 :mod:`~fastNLP.core.field` 的； - 而 :meth:`~fastNLP.DataSet.apply` 所传入的 `lambda` 函数是针对整个 :class:`~fastNLP.Instance` 的。 - - .. note:: - `lambda` 函数即匿名函数，是 Python 的重要特性。 ``lambda x: len(x)`` 和下面的这个函数的作用相同:: - - def func_lambda(x): - return len(x) - - 你也可以编写复杂的函数做为 :meth:`~fastNLP.DataSet.apply_field` 与 :meth:`~fastNLP.DataSet.apply` 的参数 - -Vocabulary 的使用 - 我们再用 :class:`~fastNLP.Vocabulary` 类来统计数据中出现的单词，并使用 :meth:`~fastNLP.Vocabulary.index_dataset` - 将单词序列转化为训练可用的数字序列。 - - .. code-block:: python - - from fastNLP import Vocabulary - - # 使用Vocabulary类统计单词，并将单词序列转化为数字序列 - vocab = Vocabulary(min_freq=2).from_dataset(dataset, field_name='words') - vocab.index_dataset(dataset, field_name='words',new_field_name='words') - print(dataset[0]) - - 输出数据如下:: - - {'words': [27, 9, 6, 913, 16, 18, 913, 124, 31, 5715, 5, 1, 2] type=list, - 'target': 1 type=int, - 'seq_len': 13 type=int} - - ---------------------- -使用内置模型训练 ---------------------- - -内置模型的输入输出命名 - fastNLP内置了一些完整的神经网络模型，详见 :doc:`/fastNLP.models` , 我们使用其中的 :class:`~fastNLP.models.CNNText` 模型进行训练。 - 为了使用内置的 :class:`~fastNLP.models.CNNText`，我们必须修改 :class:`~fastNLP.DataSet` 中 :mod:`~fastNLP.core.field` 的名称。 - 在这个例子中模型输入 (forward方法的参数) 为 ``words`` 和 ``seq_len`` ; 预测输出为 ``pred`` ;标准答案为 ``target`` 。 - 具体的命名规范可以参考 :doc:`/fastNLP.core.const` 。 - - 如果不想查看文档，您也可以使用 :class:`~fastNLP.Const` 类进行命名。下面的代码展示了给 :class:`~fastNLP.DataSet` 中 - :mod:`~fastNLP.core.field` 改名的 :meth:`~fastNLP.DataSet.rename_field` 方法，以及 :class:`~fastNLP.Const` 类的使用方法。 - - .. code-block:: python - - from fastNLP import Const - - dataset.rename_field('words', Const.INPUT) - dataset.rename_field('seq_len', Const.INPUT_LEN) - dataset.rename_field('target', Const.TARGET) - - print(Const.INPUT) - print(Const.INPUT_LEN) - print(Const.TARGET) - print(Const.OUTPUT) - - 输出结果为:: - - words - seq_len - target - pred - - 在给 :class:`~fastNLP.DataSet` 中 :mod:`~fastNLP.core.field` 改名后，我们还需要设置训练所需的输入和目标，这里使用的是 - :meth:`~fastNLP.DataSet.set_input` 和 :meth:`~fastNLP.DataSet.set_target` 两个函数。 - - .. code-block:: python - - #使用dataset的 set_input 和 set_target函数，告诉模型dataset中那些数据是输入，那些数据是标签（目标输出） - dataset.set_input(Const.INPUT, Const.INPUT_LEN) - dataset.set_target(Const.TARGET) - -数据集分割 - 除了修改 :mod:`~fastNLP.core.field` 之外，我们还可以对 :class:`~fastNLP.DataSet` 进行分割，以供训练、开发和测试使用。 - 下面这段代码展示了 :meth:`~fastNLP.DataSet.split` 的使用方法 - - .. code-block:: python - - train_dev_data, test_data = dataset.split(0.1) - train_data, dev_data = train_dev_data.split(0.1) - print(len(train_data), len(dev_data), len(test_data)) - - 输出结果为:: - - 9603 1067 1185 - -评价指标 - 训练模型需要提供一个评价指标。这里使用准确率做为评价指标。参数的 `命名规则` 跟上面类似。 - ``pred`` 参数对应的是模型的 forward 方法返回的 dict 中的一个 key 的名字。 - ``target`` 参数对应的是 :class:`~fastNLP.DataSet` 中作为标签的 :mod:`~fastNLP.core.field` 的名字。 - - .. code-block:: python - - from fastNLP import AccuracyMetric - - # metrics=AccuracyMetric() 在本例中与下面这行代码等价 - metrics=AccuracyMetric(pred=Const.OUTPUT, target=Const.TARGET) - - --------------------------- -自己编写训练过程 --------------------------- - 如果你想用类似 PyTorch 的使用方法，自己编写训练过程，你可以参考下面这段代码。 - 其中使用了 fastNLP 提供的 :class:`~fastNLP.DataSetIter` 来获得小批量训练的小批量数据， - 使用 :class:`~fastNLP.BucketSampler` 做为 :class:`~fastNLP.DataSetIter` 的参数来选择采样的方式。 - -DataSetIter - fastNLP定义的 :class:`~fastNLP.DataSetIter` 类，用于定义一个batch，并实现batch的多种功能，在初始化时传入的参数有： - - * dataset: :class:`~fastNLP.DataSet` 对象, 数据集 - * batch_size: 取出的batch大小 - * sampler: 规定使用的 :class:`~fastNLP.Sampler` 若为 None, 使用 :class:`~fastNLP.RandomSampler` （Default: None） - * as_numpy: 若为 True, 输出batch为 `numpy.array`. 否则为 `torch.Tensor` （Default: False） - * prefetch: 若为 True使用多进程预先取出下一batch. （Default: False） - -sampler - fastNLP 实现的采样器有： - - * :class:`~fastNLP.BucketSampler` 可以随机地取出长度相似的元素 【初始化参数: num_buckets：bucket的数量； batch_size：batch大小； seq_len_field_name：dataset中对应序列长度的 :mod:`~fastNLP.core.field` 的名字】 - * SequentialSampler： 顺序取出元素的采样器【无初始化参数】 - * RandomSampler：随机化取元素的采样器【无初始化参数】 - - 以下代码使用BucketSampler作为 :class:`~fastNLP.DataSetIter` 初始化的输入，运用 :class:`~fastNLP.DataSetIter` 自己写训练程序 - - .. code-block:: python - - 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=3, 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._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----- - Epoch 0 Avg Loss: 1.09 AccuracyMetric: acc=0.480787 58989ms - Epoch 1 Avg Loss: 1.00 AccuracyMetric: acc=0.500469 118348ms - Epoch 2 Avg Loss: 0.93 AccuracyMetric: acc=0.536082 176220ms - Epoch 3 Avg Loss: 0.87 AccuracyMetric: acc=0.556701 236032ms - Epoch 4 Avg Loss: 0.78 AccuracyMetric: acc=0.562324 294351ms - Epoch 5 Avg Loss: 0.69 AccuracyMetric: acc=0.58388 353673ms - Epoch 6 Avg Loss: 0.60 AccuracyMetric: acc=0.574508 412106ms - Epoch 7 Avg Loss: 0.51 AccuracyMetric: acc=0.589503 471097ms - Epoch 8 Avg Loss: 0.44 AccuracyMetric: acc=0.581068 529174ms - Epoch 9 Avg Loss: 0.39 AccuracyMetric: acc=0.572634 586216ms - [tester] - AccuracyMetric: acc=0.527426 - - diff --git a/docs/source/tutorials/tutorial_5_loss_optimizer.rst b/docs/source/tutorials/tutorial_5_loss_optimizer.rst new file mode 100644 index 00000000..a8116224 --- /dev/null +++ b/docs/source/tutorials/tutorial_5_loss_optimizer.rst @@ -0,0 +1,262 @@ +============================================================================== +动手实现一个文本分类器I-使用Trainer和Tester快速训练和测试 +============================================================================== + +我们使用和 :doc:`/user/quickstart` 中一样的任务来进行详细的介绍。给出一段评价性文字，预测其情感倾向是积极的（label=0）、 +还是消极的（label=1），使用 :class:`~fastNLP.Trainer` 和 :class:`~fastNLP.Tester` 来进行快速训练和测试。 + +----------------- +数据读入和处理 +----------------- + +数据读入 + 我们可以使用 fastNLP :mod:`fastNLP.io` 模块中的 :class:`~fastNLP.io.SST2Pipe` 类，轻松地读取以及预处理SST2数据集。:class:`~fastNLP.io.SST2Pipe` 对象的 + :meth:`~fastNLP.io.SST2Pipe.process_from_file` 方法能够对读入的SST2数据集进行数据的预处理，方法的参数为paths, 指要处理的文件所在目录，如果paths为None，则会自动下载数 据集，函数默认paths值为None。 + 此函数返回一个 :class:`~fastNLP.io.DataBundle`，包含SST2数据集的训练集、测试集、验证集以及source端和target端的字典。其训练、测试、验证数据集含有四个 :mod:`~fastNLP.core.field` ： + + * raw_words: 原source句子 + * target: 标签值 + * words: index之后的raw_words + * seq_len: 句子长度 + + 读入数据代码如下： + + .. code-block:: python + + 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及其用法详见 :doc:`/tutorials/tutorial_4_load_dataset` 。 + +数据集分割 + 由于SST2数据集的测试集并不带有标签数值，故我们分割出一部分训练集作为测试集。下面这段代码展示了 :meth:`~fastNLP.DataSet.split` 的使用方法 + + .. code-block:: python + + train_data = databundle.datasets['train'] + train_data, test_data = train_data.split(0.015) + dev_data = databundle.datasets['dev'] + print(len(train_data),len(dev_data),len(test_data)) + + 输出结果为:: + + 66339 872 1010 + +数据集 :meth:`~fastNLP.DataSet.set_input` 和 :meth:`~fastNLP.DataSet.set_target` 函数 + :class:`~fastNLP.io.SST2Pipe` 类的 :meth:`~fastNLP.io.SST2Pipe.process_from_file` 方法在预处理过程中还将训练、测试、验证集的 `words` 、`seq_len` :mod:`~fastNLP.core.field` 设定为input，同时将 `target` :mod:`~fastNLP.core.field` 设定为target。我们可以通过 :class:`~fastNLP.core.Dataset` 类的 :meth:`~fastNLP.core.Dataset.print_field_meta` 方法查看各个 :mod:`~fastNLP.core.field` 的设定情况，代码如下： + + .. code-block:: python + + 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时指使用 :class:`~fastNLP.DataSetIter` 取出batch数据时fastNLP不会进行自动padding，pad_value指对应 :mod:`~fastNLP.core.field` padding所用的值，这两者只有当 :mod:`~fastNLP.core.field` 设定为input或者target的时候才有存在的意义。 + + is_input为true的 :mod:`~fastNLP.core.field` 在 :class:`~fastNLP.DataSetIter` 迭代取出的 batch_x 中，而 is_target为true的 :mod:`~fastNLP.core.field` 在 :class:`~fastNLP.DataSetIter` 迭代取出的 batch_y 中。具体分析见 :doc:`/tutorials/tutorial_6_datasetiter` 的DataSetIter初探。 + +--------------------- +使用内置模型训练 +--------------------- +模型定义和初始化 + 我们可以导入 fastNLP 内置的文本分类模型 :class:`~fastNLP.models.CNNText` 来对模型进行定义，代码如下： + + .. code-block:: python + + 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快速搭建自己的模型详见 :doc:`/tutorials/tutorial_8_modules_models` 。 + +评价指标 + 训练模型需要提供一个评价指标。这里使用准确率做为评价指标。 + + * ``pred`` 参数对应的是模型的 forward 方法返回的 dict 中的一个 key 的名字。 + * ``target`` 参数对应的是 :class:`~fastNLP.DataSet` 中作为标签的 :mod:`~fastNLP.core.field` 的名字。 + + 这里我们用 :class:`~fastNLP.Const` 来辅助命名，如果你自己编写模型中 forward 方法的返回值或 + 数据集中 :mod:`~fastNLP.core.field` 的名字与本例不同， 你可以把 ``pred`` 参数和 ``target`` 参数设定符合自己代码的值。代码如下： + + .. code-block:: python + + from fastNLP import AccuracyMetric + from fastNLP import Const + + # metrics=AccuracyMetric() 在本例中与下面这行代码等价 + metrics=AccuracyMetric(pred=Const.OUTPUT, target=Const.TARGET) + + +损失函数 + 训练模型需要提供一个损失函数 + ,fastNLP中提供了直接可以导入使用的四种loss，分别为： + + * :class:`~fastNLP.CrossEntropyLoss`：包装了torch.nn.functional.cross_entropy()函数，返回交叉熵损失（可以运用于多分类场景） + * :class:`~fastNLP.BCELoss`：包装了torch.nn.functional.binary_cross_entropy()函数，返回二分类的交叉熵 + * :class:`~fastNLP.L1Loss`：包装了torch.nn.functional.l1_loss()函数，返回L1 损失 + * :class:`~fastNLP.NLLLoss`：包装了torch.nn.functional.nll_loss()函数，返回负对数似然损失 + + 下面提供了一个在分类问题中常用的交叉熵损失。注意它的 **初始化参数** 。 + + * ``pred`` 参数对应的是模型的 forward 方法返回的 dict 中的一个 key 的名字。 + * ``target`` 参数对应的是 :class:`~fastNLP.DataSet` 中作为标签的 :mod:`~fastNLP.core.field` 的名字。 + + 这里我们用 :class:`~fastNLP.Const` 来辅助命名，如果你自己编写模型中 forward 方法的返回值或 + 数据集中 :mod:`~fastNLP.core.field` 的名字与本例不同， 你可以把 ``pred`` 参数和 ``target`` 参数设定符合自己代码的值。 + + .. code-block:: python + + from fastNLP import CrossEntropyLoss + + # loss = CrossEntropyLoss() 在本例中与下面这行代码等价 + loss = CrossEntropyLoss(pred=Const.OUTPUT, target=Const.TARGET) + + 除了使用fastNLP已经包装好的了损失函数，也可以通过fastNLP中的LossFunc类来构建自己的损失函数，方法如下： + + .. code-block:: python + + # 这表示构建了一个损失函数类，由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中的优化器，并在实例化 :class:`~fastNLP.Trainer` 类的时候传入优化器实参 + + .. code-block:: python + + 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) + +快速训练 + 现在我们对上面定义的模型使用 :class:`~fastNLP.Trainer` 进行训练。 + 除了使用 :class:`~fastNLP.Trainer`进行训练，我们也可以通过使用 :class:`~fastNLP.DataSetIter` 来编写自己的训练过程，具体见 :doc:`/tutorials/tutorial_6_datasetiter` + + .. code-block:: python + + 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, 16]) + 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 2019-09-17-14-29-00 + + Evaluate data in 0.11 seconds! + Evaluation on dev at Epoch 1/10. Step:4147/41470: + AccuracyMetric: acc=0.762615 + + Evaluate data in 0.19 seconds! + Evaluation on dev at Epoch 2/10. Step:8294/41470: + AccuracyMetric: acc=0.800459 + + Evaluate data in 0.16 seconds! + Evaluation on dev at Epoch 3/10. Step:12441/41470: + AccuracyMetric: acc=0.777523 + + Evaluate data in 0.11 seconds! + Evaluation on dev at Epoch 4/10. Step:16588/41470: + AccuracyMetric: acc=0.634174 + + Evaluate data in 0.11 seconds! + Evaluation on dev at Epoch 5/10. Step:20735/41470: + AccuracyMetric: acc=0.791284 + + Evaluate data in 0.15 seconds! + Evaluation on dev at Epoch 6/10. Step:24882/41470: + AccuracyMetric: acc=0.573394 + + Evaluate data in 0.18 seconds! + Evaluation on dev at Epoch 7/10. Step:29029/41470: + AccuracyMetric: acc=0.759174 + + Evaluate data in 0.17 seconds! + Evaluation on dev at Epoch 8/10. Step:33176/41470: + AccuracyMetric: acc=0.776376 + + Evaluate data in 0.18 seconds! + Evaluation on dev at Epoch 9/10. Step:37323/41470: + AccuracyMetric: acc=0.740826 + + Evaluate data in 0.2 seconds! + Evaluation on dev at Epoch 10/10. Step:41470/41470: + AccuracyMetric: acc=0.769495 + + In Epoch:2/Step:8294, got best dev performance: + AccuracyMetric: acc=0.800459 + Reloaded the best model. + +快速测试 + 与 :class:`~fastNLP.Trainer` 对应，fastNLP 也提供了 :class:`~fastNLP.Tester` 用于快速测试，用法如下 + + .. code-block:: python + + from fastNLP import Tester + + tester = Tester(test_data, model_cnn, metrics=AccuracyMetric()) + tester.test() + + 训练过程输出如下:: + + Evaluate data in 0.19 seconds! + [tester] + AccuracyMetric: acc=0.889109 diff --git a/docs/source/tutorials/tutorial_6_datasetiter.rst b/docs/source/tutorials/tutorial_6_datasetiter.rst new file mode 100644 index 00000000..d5318ac7 --- /dev/null +++ b/docs/source/tutorials/tutorial_6_datasetiter.rst @@ -0,0 +1,405 @@ +============================================================================== +动手实现一个文本分类器II-使用DataSetIter实现自定义训练过程 +============================================================================== + +我们使用和 :doc:`/user/quickstart` 中一样的任务来进行详细的介绍。给出一段评价性文字，预测其情感倾向是积极的（label=0）、 +还是消极的（label=1），使用 :class:`~fastNLP.DataSetIter` 类来编写自己的训练过程。 +DataSetIter初探之前的内容与 :doc:`/tutorials/tutorial_5_loss_optimizer` 中的完全一样，如已经阅读过可以跳过。 + +-------------------- +数据读入和预处理 +-------------------- + +数据读入 + 我们可以使用 fastNLP :mod:`fastNLP.io` 模块中的 :class:`~fastNLP.io.SST2Pipe` 类，轻松地读取以及预处理SST2数据集。:class:`~fastNLP.io.SST2Pipe` 对象的 + :meth:`~fastNLP.io.SST2Pipe.process_from_file` 方法能够对读入的SST2数据集进行数据的预处理，方法的参数为paths, 指要处理的文件所在目录，如果paths为None，则会自动下载数 据集，函数默认paths值为None。 + 此函数返回一个 :class:`~fastNLP.io.DataBundle`，包含SST2数据集的训练集、测试集、验证集以及source端和target端的字典。其训练、测试、验证数据集含有四个 :mod:`~fastNLP.core.field` ： + + * raw_words: 原source句子 + * target: 标签值 + * words: index之后的raw_words + * seq_len: 句子长度 + + 读入数据代码如下： + + .. code-block:: python + + 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及其用法详见 :doc:`/tutorials/tutorial_4_load_dataset` 。 + +数据集分割 + 由于SST2数据集的测试集并不带有标签数值，故我们分割出一部分训练集作为测试集。下面这段代码展示了 :meth:`~fastNLP.DataSet.split` 的使用方法 + + .. code-block:: python + + train_data = databundle.datasets['train'] + train_data, test_data = train_data.split(0.015) + dev_data = databundle.datasets['dev'] + print(len(train_data),len(dev_data),len(test_data)) + + 输出结果为:: + + 66339 872 1010 + +数据集 :meth:`~fastNLP.DataSet.set_input` 和 :meth:`~fastNLP.DataSet.set_target` 函数 + :class:`~fastNLP.io.SST2Pipe` 类的 :meth:`~fastNLP.io.SST2Pipe.process_from_file` 方法在预处理过程中还将训练、测试、验证集的 `words` 、`seq_len` :mod:`~fastNLP.core.field` 设定为input，同时将`target` :mod:`~fastNLP.core.field` 设定为target。我们可以通过 :class:`~fastNLP.core.Dataset` 类的 :meth:`~fastNLP.core.Dataset.print_field_meta` 方法查看各个 :mod:`~fastNLP.core.field` 的设定情况，代码如下： + + .. code-block:: python + + 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时指使用 :class:`~fastNLP.DataSetIter` 取出batch数据时fastNLP不会进行自动padding，pad_value指对应 :mod:`~fastNLP.core.field` padding所用的值，这两者只有当 :mod:`~fastNLP.core.field` 设定为input或者target的时候才有存在的意义。 + + is_input为true的 :mod:`~fastNLP.core.field` 在 :class:`~fastNLP.DataSetIter` 迭代取出的 batch_x 中，而 is_target为true的 :mod:`~fastNLP.core.field` 在 :class:`~fastNLP.DataSetIter` 迭代取出的 batch_y 中。具体分析见下面DataSetIter的介绍过程。 + + +评价指标 + 训练模型需要提供一个评价指标。这里使用准确率做为评价指标。 + + * ``pred`` 参数对应的是模型的 forward 方法返回的 dict 中的一个 key 的名字。 + * ``target`` 参数对应的是 :class:`~fastNLP.DataSet` 中作为标签的 :mod:`~fastNLP.core.field` 的名字。 + + 这里我们用 :class:`~fastNLP.Const` 来辅助命名，如果你自己编写模型中 forward 方法的返回值或 + 数据集中 :mod:`~fastNLP.core.field` 的名字与本例不同， 你可以把 ``pred`` 参数和 ``target`` 参数设定符合自己代码的值。代码如下： + + .. code-block:: python + + from fastNLP import AccuracyMetric + from fastNLP import Const + + # metrics=AccuracyMetric() 在本例中与下面这行代码等价 + metrics=AccuracyMetric(pred=Const.OUTPUT, target=Const.TARGET) + +-------------------------- +DataSetIter初探 +-------------------------- +DataSetIter + fastNLP定义的 :class:`~fastNLP.DataSetIter` 类，用于定义一个batch，并实现batch的多种功能，在初始化时传入的参数有： + + * dataset: :class:`~fastNLP.DataSet` 对象, 数据集 + * batch_size: 取出的batch大小 + * sampler: 规定使用的 :class:`~fastNLP.Sampler` 若为 None, 使用 :class:`~fastNLP.RandomSampler` （Default: None） + * as_numpy: 若为 True, 输出batch为 `numpy.array`. 否则为 `torch.Tensor` （Default: False） + * prefetch: 若为 True使用多进程预先取出下一batch. （Default: False） + +sampler + fastNLP 实现的采样器有： + + * :class:`~fastNLP.BucketSampler` 可以随机地取出长度相似的元素 【初始化参数: num_buckets：bucket的数量； batch_size：batch大小； seq_len_field_name：dataset中对应序列长度的 :mod:`~fastNLP.core.field` 的名字】 + * SequentialSampler： 顺序取出元素的采样器【无初始化参数】 + * RandomSampler：随机化取元素的采样器【无初始化参数】 + +Padder + 在fastNLP里，pad是与一个 :mod:`~fastNLP.core.field` 绑定的。即不同的 :mod:`~fastNLP.core.field` 可以使用不同的pad方式，比如在英文任务中word需要的pad和 + character的pad方式往往是不同的。fastNLP是通过一个叫做 :class:`~fastNLP.Padder` 的子类来完成的。 + 默认情况下，所有field使用 :class:`~fastNLP.AutoPadder` + 。大多数情况下直接使用 :class:`~fastNLP.AutoPadder` 就可以了。 + 如果 :class:`~fastNLP.AutoPadder` 或 :class:`~fastNLP.EngChar2DPadder` 无法满足需求， + 也可以自己写一个 :class:`~fastNLP.Padder` 。 + +DataSetIter自动padding + 以下代码展示了DataSetIter的简单使用： + + .. code-block:: python + + 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([[ 4, 278, 686, 18, 7], + [15619, 3205, 5, 1676, 0]]), 'seq_len': tensor([5, 4])} + batch_y: {'target': tensor([1, 1])} + batch_x: {'words': tensor([[ 44, 753, 328, 181, 10, 15622, 16, 71, 8905, 9, + 1218, 7, 0, 0, 0, 0, 0, 0, 0, 0], + [ 880, 97, 8, 1027, 12, 8068, 11, 13624, 8, 15620, + 4, 674, 663, 15, 4, 1155, 241, 640, 418, 7]]), 'seq_len': tensor([12, 20])} + batch_y: {'target': tensor([1, 0])} + batch_x: {'words': tensor([[ 1046, 11114, 16, 105, 5, 4, 177, 1825, 1705, 3, + 2, 18, 11, 4, 1019, 433, 144, 32, 246, 309, + 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0], + [ 13, 831, 7747, 175, 3, 46, 6, 84, 5753, 15, + 2178, 15, 62, 56, 407, 85, 1010, 4974, 26, 17, + 13786, 3, 534, 3688, 15624, 38, 376, 8, 15625, 8, + 1324, 4399, 7]]), 'seq_len': tensor([21, 33])} + batch_y: {'target': tensor([0, 1])} + batch_x: {'words': tensor([[ 14, 10, 438, 31, 78, 3, 78, 438, 7], + [ 14, 10, 4, 312, 5, 155, 1419, 610, 7]]), 'seq_len': tensor([9, 9])} + batch_y: {'target': tensor([1, 0])} + batch_x: {'words': tensor([[ 24, 96, 27, 45, 8, 337, 37, 240, 8, 2134, + 2, 18, 10, 15623, 1422, 6, 60, 5, 388, 7], + [ 2, 156, 3, 4427, 3, 240, 3, 740, 5, 1137, + 40, 42, 2428, 737, 2, 649, 10, 15621, 2286, 7]]), 'seq_len': tensor([20, 20])} + batch_y: {'target': tensor([0, 0])} + + 可以看到那些设定为input的 :mod:`~fastNLP.core.field` 都出现在batch_x中，而设定为target的 :mod:`~fastNLP.core.field` 则出现在batch_y中。同时对于同一个batch_x中的两个数 据，长度偏短的那个会被自动padding到和长度偏长的句子长度一致，默认的padding值为0。 + +Dataset改变padding值 + 可以通过 :meth:`~fastNLP.core.Dataset.set_pad_val` 方法修改默认的pad值，代码如下： + + .. code-block:: python + + 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([[15619, 3205, 5, 1676, -1], + [ 4, 278, 686, 18, 7]]), 'seq_len': tensor([4, 5])} + batch_y: {'target': tensor([1, 1])} + batch_x: {'words': tensor([[ 1046, 11114, 16, 105, 5, 4, 177, 1825, 1705, 3, + 2, 18, 11, 4, 1019, 433, 144, 32, 246, 309, + 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1], + [ 13, 831, 7747, 175, 3, 46, 6, 84, 5753, 15, + 2178, 15, 62, 56, 407, 85, 1010, 4974, 26, 17, + 13786, 3, 534, 3688, 15624, 38, 376, 8, 15625, 8, + 1324, 4399, 7]]), 'seq_len': tensor([21, 33])} + batch_y: {'target': tensor([0, 1])} + batch_x: {'words': tensor([[ 14, 10, 4, 312, 5, 155, 1419, 610, 7], + [ 14, 10, 438, 31, 78, 3, 78, 438, 7]]), 'seq_len': tensor([9, 9])} + batch_y: {'target': tensor([0, 1])} + batch_x: {'words': tensor([[ 2, 156, 3, 4427, 3, 240, 3, 740, 5, 1137, + 40, 42, 2428, 737, 2, 649, 10, 15621, 2286, 7], + [ 24, 96, 27, 45, 8, 337, 37, 240, 8, 2134, + 2, 18, 10, 15623, 1422, 6, 60, 5, 388, 7]]), 'seq_len': tensor([20, 20])} + batch_y: {'target': tensor([0, 0])} + batch_x: {'words': tensor([[ 44, 753, 328, 181, 10, 15622, 16, 71, 8905, 9, + 1218, 7, -1, -1, -1, -1, -1, -1, -1, -1], + [ 880, 97, 8, 1027, 12, 8068, 11, 13624, 8, 15620, + 4, 674, 663, 15, 4, 1155, 241, 640, 418, 7]]), 'seq_len': tensor([12, 20])} + batch_y: {'target': tensor([1, 0])} + + 可以看到使用了-1进行padding。 + +Dataset个性化padding + 如果我们希望对某一些 :mod:`~fastNLP.core.field` 进行个性化padding，可以自己构造Padder类，并使用 :meth:`~fastNLP.core.Dataset.set_padder` 函数修改padder来实现。下面通 过构造一个将数据padding到固定长度的padder进行展示： + + .. code-block:: python + + 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([[ 4, 278, 686, 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], + [15619, 3205, 5, 1676, 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])} + batch_x: {'words': tensor([[ 2, 156, 3, 4427, 3, 240, 3, 740, 5, 1137, + 40, 42, 2428, 737, 2, 649, 10, 15621, 2286, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [ 24, 96, 27, 45, 8, 337, 37, 240, 8, 2134, + 2, 18, 10, 15623, 1422, 6, 60, 5, 388, 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([[ 13, 831, 7747, 175, 3, 46, 6, 84, 5753, 15, + 2178, 15, 62, 56, 407, 85, 1010, 4974, 26, 17, + 13786, 3, 534, 3688, 15624, 38, 376, 8, 15625, 8, + 1324, 4399, 7, 0, 0, 0, 0, 0, 0, 0], + [ 1046, 11114, 16, 105, 5, 4, 177, 1825, 1705, 3, + 2, 18, 11, 4, 1019, 433, 144, 32, 246, 309, + 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, 312, 5, 155, 1419, 610, 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, 438, 31, 78, 3, 78, 438, 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([[ 44, 753, 328, 181, 10, 15622, 16, 71, 8905, 9, + 1218, 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], + [ 880, 97, 8, 1027, 12, 8068, 11, 13624, 8, 15620, + 4, 674, 663, 15, 4, 1155, 241, 640, 418, 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])} + + 在这里所有的`words`都被pad成了长度为40的list。 + +------------------------------------ +使用DataSetIter自己编写训练过程 +------------------------------------ + 如果你想用类似 PyTorch 的使用方法，自己编写训练过程，可以参考下面这段代码。 + 其中使用了 fastNLP 提供的 :class:`~fastNLP.DataSetIter` 来获得小批量训练的小批量数据， + 使用 :class:`~fastNLP.BucketSampler` 做为 :class:`~fastNLP.DataSetIter` 的参数来选择采样的方式。 + + 以下代码使用BucketSampler作为 :class:`~fastNLP.DataSetIter` 初始化的输入，运用 :class:`~fastNLP.DataSetIter` 自己写训练程序 + + .. code-block:: python + + 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 0.2 seconds! + Epoch 0 Avg Loss: 0.33 AccuracyMetric: acc=0.825688 48895ms + + Evaluate data in 0.19 seconds! + Epoch 1 Avg Loss: 0.16 AccuracyMetric: acc=0.829128 102081ms + + Evaluate data in 0.18 seconds! + Epoch 2 Avg Loss: 0.10 AccuracyMetric: acc=0.822248 152853ms + + Evaluate data in 0.17 seconds! + Epoch 3 Avg Loss: 0.08 AccuracyMetric: acc=0.821101 200184ms + + Evaluate data in 0.17 seconds! + Epoch 4 Avg Loss: 0.06 AccuracyMetric: acc=0.827982 253097ms + + Evaluate data in 0.27 seconds! + Epoch 5 Avg Loss: 0.05 AccuracyMetric: acc=0.806193 303883ms + + Evaluate data in 0.26 seconds! + Epoch 6 Avg Loss: 0.04 AccuracyMetric: acc=0.803899 392315ms + + Evaluate data in 0.36 seconds! + Epoch 7 Avg Loss: 0.04 AccuracyMetric: acc=0.802752 527211ms + + Evaluate data in 0.15 seconds! + Epoch 8 Avg Loss: 0.03 AccuracyMetric: acc=0.809633 661533ms + + Evaluate data in 0.31 seconds! + Epoch 9 Avg Loss: 0.03 AccuracyMetric: acc=0.797018 812232ms + + Evaluate data in 0.25 seconds! + [tester] + AccuracyMetric: acc=0.917822 + + + diff --git a/docs/source/tutorials/tutorial_6_loss_optimizer.rst b/docs/source/tutorials/tutorial_6_loss_optimizer.rst deleted file mode 100644 index a53ef89b..00000000 --- a/docs/source/tutorials/tutorial_6_loss_optimizer.rst +++ /dev/null @@ -1,271 +0,0 @@ -============================================================================== -动手实现一个文本分类器I-使用Trainer和Tester快速训练和测试 -============================================================================== - -我们使用和 :doc:`/user/quickstart` 中一样的任务来进行详细的介绍。给出一段评价性文字，预测其情感倾向是积极（label=1）、 -消极（label=0）还是中性（label=2），使用 :class:`~fastNLP.Trainer` 和 :class:`~fastNLP.Tester` 来进行快速训练和测试。 - --------------- -数据处理 --------------- - -数据读入 - 我们可以使用 fastNLP :mod:`fastNLP.io` 模块中的 :class:`~fastNLP.io.SSTLoader` 类，轻松地读取SST数据集（数据来源：https://nlp.stanford.edu/sentiment/trainDevTestTrees_PTB.zip）。 - 这里的 dataset 是 fastNLP 中 :class:`~fastNLP.DataSet` 类的对象。 - - .. code-block:: python - - from fastNLP.io import SSTLoader - - loader = SSTLoader() - #这里的all.txt是下载好数据后train.txt、dev.txt、test.txt的组合 - #loader.load(path)会首先判断path是否为none，若是则自动从网站下载数据，若不是则读入数据并返回databundle - databundle_ = loader.load("./trainDevTestTrees_PTB/trees/all.txt") - dataset = databundle_.datasets['train'] - print(dataset[0]) - - 输出数据如下:: - - {'words': ['It', "'s", 'a', 'lovely', 'film', 'with', 'lovely', 'performances', 'by', 'Buy', 'and', 'Accorsi', '.'] type=list, - 'target': positive type=str} - - 除了读取数据外，fastNLP 还提供了读取其它文件类型的 Loader 类、读取 Embedding的 Loader 等。详见 :doc:`/fastNLP.io` 。 - - -数据处理 - 可以使用事先定义的 :class:`~fastNLP.io.SSTPipe` 类对数据进行基本预处理，这里我们手动进行处理。 - 我们使用 :class:`~fastNLP.DataSet` 类的 :meth:`~fastNLP.DataSet.apply` 方法将 ``target`` :mod:`~fastNLP.core.field` 转化为整数。 - - .. code-block:: python - - def label_to_int(x): - if x['target']=="positive": - return 1 - elif x['target']=="negative": - return 0 - else: - return 2 - - # 将label转为整数 - dataset.apply(lambda x: label_to_int(x), new_field_name='target') - - ``words`` 和 ``target`` 已经足够用于 :class:`~fastNLP.models.CNNText` 的训练了，但我们从其文档 - :class:`~fastNLP.models.CNNText` 中看到，在 :meth:`~fastNLP.models.CNNText.forward` 的时候，还可以传入可选参数 ``seq_len`` 。 - 所以，我们再使用 :meth:`~fastNLP.DataSet.apply_field` 方法增加一个名为 ``seq_len`` 的 :mod:`~fastNLP.core.field` 。 - - .. code-block:: python - - # 增加长度信息 - dataset.apply_field(lambda x: len(x), field_name='words', new_field_name='seq_len') - - 观察可知： :meth:`~fastNLP.DataSet.apply_field` 与 :meth:`~fastNLP.DataSet.apply` 类似， - 但所传入的 `lambda` 函数是针对一个 :class:`~fastNLP.Instance` 中的一个 :mod:`~fastNLP.core.field` 的； - 而 :meth:`~fastNLP.DataSet.apply` 所传入的 `lambda` 函数是针对整个 :class:`~fastNLP.Instance` 的。 - - .. note:: - `lambda` 函数即匿名函数，是 Python 的重要特性。 ``lambda x: len(x)`` 和下面的这个函数的作用相同:: - - def func_lambda(x): - return len(x) - - 你也可以编写复杂的函数做为 :meth:`~fastNLP.DataSet.apply_field` 与 :meth:`~fastNLP.DataSet.apply` 的参数 - -Vocabulary 的使用 - 我们再用 :class:`~fastNLP.Vocabulary` 类来统计数据中出现的单词，并使用 :meth:`~fastNLP.Vocabulary.index_dataset` - 将单词序列转化为训练可用的数字序列。 - - .. code-block:: python - - from fastNLP import Vocabulary - - # 使用Vocabulary类统计单词，并将单词序列转化为数字序列 - vocab = Vocabulary(min_freq=2).from_dataset(dataset, field_name='words') - vocab.index_dataset(dataset, field_name='words',new_field_name='words') - print(dataset[0]) - - 输出数据如下:: - - {'words': [27, 9, 6, 913, 16, 18, 913, 124, 31, 5715, 5, 1, 2] type=list, - 'target': 1 type=int, - 'seq_len': 13 type=int} - - ---------------------- -使用内置模型训练 ---------------------- - -内置模型的输入输出命名 - fastNLP内置了一些完整的神经网络模型，详见 :doc:`/fastNLP.models` , 我们使用其中的 :class:`~fastNLP.models.CNNText` 模型进行训练。 - 为了使用内置的 :class:`~fastNLP.models.CNNText`，我们必须修改 :class:`~fastNLP.DataSet` 中 :mod:`~fastNLP.core.field` 的名称。 - 在这个例子中模型输入 (forward方法的参数) 为 ``words`` 和 ``seq_len`` ; 预测输出为 ``pred`` ;标准答案为 ``target`` 。 - 具体的命名规范可以参考 :doc:`/fastNLP.core.const` 。 - - 如果不想查看文档，您也可以使用 :class:`~fastNLP.Const` 类进行命名。下面的代码展示了给 :class:`~fastNLP.DataSet` 中 - :mod:`~fastNLP.core.field` 改名的 :meth:`~fastNLP.DataSet.rename_field` 方法，以及 :class:`~fastNLP.Const` 类的使用方法。 - - .. code-block:: python - - from fastNLP import Const - - dataset.rename_field('words', Const.INPUT) - dataset.rename_field('seq_len', Const.INPUT_LEN) - dataset.rename_field('target', Const.TARGET) - - print(Const.INPUT) - print(Const.INPUT_LEN) - print(Const.TARGET) - print(Const.OUTPUT) - - 输出结果为:: - - words - seq_len - target - pred - - 在给 :class:`~fastNLP.DataSet` 中 :mod:`~fastNLP.core.field` 改名后，我们还需要设置训练所需的输入和目标，这里使用的是 - :meth:`~fastNLP.DataSet.set_input` 和 :meth:`~fastNLP.DataSet.set_target` 两个函数。 - - .. code-block:: python - - #使用dataset的 set_input 和 set_target函数，告诉模型dataset中那些数据是输入，那些数据是标签（目标输出） - dataset.set_input(Const.INPUT, Const.INPUT_LEN) - dataset.set_target(Const.TARGET) - -数据集分割 - 除了修改 :mod:`~fastNLP.core.field` 之外，我们还可以对 :class:`~fastNLP.DataSet` 进行分割，以供训练、开发和测试使用。 - 下面这段代码展示了 :meth:`~fastNLP.DataSet.split` 的使用方法 - - .. code-block:: python - - train_dev_data, test_data = dataset.split(0.1) - train_data, dev_data = train_dev_data.split(0.1) - print(len(train_data), len(dev_data), len(test_data)) - - 输出结果为:: - - 9603 1067 1185 - -评价指标 - 训练模型需要提供一个评价指标。这里使用准确率做为评价指标。参数的 `命名规则` 跟上面类似。 - ``pred`` 参数对应的是模型的 forward 方法返回的 dict 中的一个 key 的名字。 - ``target`` 参数对应的是 :class:`~fastNLP.DataSet` 中作为标签的 :mod:`~fastNLP.core.field` 的名字。 - - .. code-block:: python - - from fastNLP import AccuracyMetric - - # metrics=AccuracyMetric() 在本例中与下面这行代码等价 - metrics=AccuracyMetric(pred=Const.OUTPUT, target=Const.TARGET) - -损失函数 - 训练模型需要提供一个损失函数 - ,fastNLP中提供了直接可以导入使用的四种loss，分别为： - - * :class:`~fastNLP.CrossEntropyLoss`：包装了torch.nn.functional.cross_entropy()函数，返回交叉熵损失（可以运用于多分类场景） - * :class:`~fastNLP.BCELoss`：包装了torch.nn.functional.binary_cross_entropy()函数，返回二分类的交叉熵 - * :class:`~fastNLP.L1Loss`：包装了torch.nn.functional.l1_loss()函数，返回L1 损失 - * :class:`~fastNLP.NLLLoss`：包装了torch.nn.functional.nll_loss()函数，返回负对数似然损失 - - 下面提供了一个在分类问题中常用的交叉熵损失。注意它的 **初始化参数** 。 - ``pred`` 参数对应的是模型的 forward 方法返回的 dict 中的一个 key 的名字。 - ``target`` 参数对应的是 :class:`~fastNLP.DataSet` 中作为标签的 :mod:`~fastNLP.core.field` 的名字。 - 这里我们用 :class:`~fastNLP.Const` 来辅助命名，如果你自己编写模型中 forward 方法的返回值或 - 数据集中 :mod:`~fastNLP.core.field` 的名字与本例不同， 你可以把 ``pred`` 参数和 ``target`` 参数设定符合自己代码的值。 - - .. code-block:: python - - from fastNLP import CrossEntropyLoss - - # loss = CrossEntropyLoss() 在本例中与下面这行代码等价 - loss = CrossEntropyLoss(pred=Const.OUTPUT, target=Const.TARGET) - -优化器 - 定义模型运行的时候使用的优化器，可以使用fastNLP包装好的优化器： - - * :class:`~fastNLP.SGD` ：包装了torch.optim.SGD优化器 - * :class:`~fastNLP.Adam` ：包装了torch.optim.Adam优化器 - - 也可以直接使用torch.optim.Optimizer中的优化器，并在实例化 :class:`~fastNLP.Trainer` 类的时候传入优化器实参 - - .. code-block:: python - - import torch.optim as optim - from fastNLP import Adam - - #使用 torch.optim 定义优化器 - optimizer_1=optim.RMSprop(model_cnn.parameters(), lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False) - #使用fastNLP中包装的 Adam 定义优化器 - optimizer_2=Adam(lr=4e-3, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, model_params=model_cnn.parameters()) - -快速训练 - 现在我们可以导入 fastNLP 内置的文本分类模型 :class:`~fastNLP.models.CNNText` ，并使用 :class:`~fastNLP.Trainer` 进行训练， - 除了使用 :class:`~fastNLP.Trainer`进行训练，我们也可以通过使用 :class:`~fastNLP.DataSetIter` 来编写自己的训练过程，具体见 :doc:`/tutorials/tutorial_5_datasetiter` - - .. code-block:: python - - from fastNLP.models import CNNText - - #词嵌入的维度、训练的轮数和batch size - EMBED_DIM = 100 - N_EPOCHS = 10 - BATCH_SIZE = 16 - - #使用CNNText的时候第一个参数输入一个tuple,作为模型定义embedding的参数 - #还可以传入 kernel_nums, kernel_sizes, padding, dropout的自定义值 - model_cnn = CNNText((len(vocab),EMBED_DIM), num_classes=3, dropout=0.1) - - #如果在定义trainer的时候没有传入optimizer参数，模型默认的优化器为torch.optim.Adam且learning rate为lr=4e-3 - #这里只使用了optimizer_1作为优化器输入，感兴趣可以尝试optimizer_2或者其他优化器作为输入 - #这里只使用了loss作为损失函数输入，感兴趣可以尝试其他损失函数输入 - trainer = Trainer(model=model_cnn, train_data=train_data, dev_data=dev_data, loss=loss, metrics=metrics, - optimizer=optimizer_1,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, 40]) - 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 2019-07-08-15-44-48 - Evaluation at Epoch 1/10. Step:601/6010. AccuracyMetric: acc=0.59044 - - Evaluation at Epoch 2/10. Step:1202/6010. AccuracyMetric: acc=0.599813 - - Evaluation at Epoch 3/10. Step:1803/6010. AccuracyMetric: acc=0.508903 - - Evaluation at Epoch 4/10. Step:2404/6010. AccuracyMetric: acc=0.596064 - - Evaluation at Epoch 5/10. Step:3005/6010. AccuracyMetric: acc=0.47985 - - Evaluation at Epoch 6/10. Step:3606/6010. AccuracyMetric: acc=0.589503 - - Evaluation at Epoch 7/10. Step:4207/6010. AccuracyMetric: acc=0.311153 - - Evaluation at Epoch 8/10. Step:4808/6010. AccuracyMetric: acc=0.549203 - - Evaluation at Epoch 9/10. Step:5409/6010. AccuracyMetric: acc=0.581068 - - Evaluation at Epoch 10/10. Step:6010/6010. AccuracyMetric: acc=0.523899 - - - In Epoch:2/Step:1202, got best dev performance:AccuracyMetric: acc=0.599813 - Reloaded the best model. - -快速测试 - 与 :class:`~fastNLP.Trainer` 对应，fastNLP 也提供了 :class:`~fastNLP.Tester` 用于快速测试，用法如下 - - .. code-block:: python - - from fastNLP import Tester - - tester = Tester(test_data, model_cnn, metrics=AccuracyMetric()) - tester.test() - - 训练过程输出如下:: - - [tester] - AccuracyMetric: acc=0.565401 diff --git a/docs/source/user/tutorials.rst b/docs/source/user/tutorials.rst index e19f252b..85049463 100644 --- a/docs/source/user/tutorials.rst +++ b/docs/source/user/tutorials.rst @@ -1,4 +1,4 @@ -======================== +======================== fastNLP 详细使用教程 ======================== @@ -11,8 +11,8 @@ fastNLP 详细使用教程 使用Vocabulary转换文本与index 使用Embedding模块将文本转成向量 使用Loader和Pipe加载并处理数据集 - 动手实现一个文本分类器II-使用DataSetIter实现自定义训练过程 - 动手实现一个文本分类器I-使用Trainer和Tester快速训练和测试 + 动手实现一个文本分类器I-使用Trainer和Tester快速训练和测试 + 动手实现一个文本分类器II-使用DataSetIter实现自定义训练过程 使用Metric快速评测你的模型 使用Modules和Models快速搭建自定义模型 快速实现序列标注模型