hummingbird
/
fastNLP
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

修改tutorial

tags/v0.4.10
zide05 5 years ago
parent
8d3cab5f7d
commit
5c602ef83c
5 changed files with 670 additions and 527 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -253
      docs/source/tutorials/tutorial_5_datasetiter.rst
  2. +262
    -0
      docs/source/tutorials/tutorial_5_loss_optimizer.rst
  3. +405
    -0
      docs/source/tutorials/tutorial_6_datasetiter.rst
  4. +0
    -271
      docs/source/tutorials/tutorial_6_loss_optimizer.rst
  5. +3
    -3
      docs/source/user/tutorials.rst

+ 0
- 253
docs/source/tutorials/tutorial_5_datasetiter.rst View File

@@ -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



+ 262
- 0
docs/source/tutorials/tutorial_5_loss_optimizer.rst View File

@@ -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

+ 405
- 0
docs/source/tutorials/tutorial_6_datasetiter.rst View File

@@ -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



+ 0
- 271
docs/source/tutorials/tutorial_6_loss_optimizer.rst View File

@@ -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

+ 3
- 3
docs/source/user/tutorials.rst View File

@@ -1,4 +1,4 @@
========================
========================
fastNLP 详细使用教程 fastNLP 详细使用教程
======================== ========================


@@ -11,8 +11,8 @@ fastNLP 详细使用教程
使用Vocabulary转换文本与index </tutorials/tutorial_2_vocabulary> 使用Vocabulary转换文本与index </tutorials/tutorial_2_vocabulary>
使用Embedding模块将文本转成向量 </tutorials/tutorial_3_embedding> 使用Embedding模块将文本转成向量 </tutorials/tutorial_3_embedding>
使用Loader和Pipe加载并处理数据集 </tutorials/tutorial_4_load_dataset> 使用Loader和Pipe加载并处理数据集 </tutorials/tutorial_4_load_dataset>
动手实现一个文本分类器II-使用DataSetIter实现自定义训练过程 </tutorials/tutorial_5_datasetiter>
动手实现一个文本分类器I-使用Trainer和Tester快速训练和测试 </tutorials/tutorial_6_loss_optimizer>
动手实现一个文本分类器I-使用Trainer和Tester快速训练和测试 </tutorials/tutorial_5_loss_optimizer>
动手实现一个文本分类器II-使用DataSetIter实现自定义训练过程 </tutorials/tutorial_6_datasetiter>
使用Metric快速评测你的模型 </tutorials/tutorial_7_metrics> 使用Metric快速评测你的模型 </tutorials/tutorial_7_metrics>
使用Modules和Models快速搭建自定义模型 </tutorials/tutorial_8_modules_models> 使用Modules和Models快速搭建自定义模型 </tutorials/tutorial_8_modules_models>
快速实现序列标注模型 </tutorials/tutorial_9_seq_labeling> 快速实现序列标注模型 </tutorials/tutorial_9_seq_labeling>


Write Preview
Loading…
Cancel
Save