只是教程的搬运工-.-
Field的使用
Torchtext采用声明式方法加载数据，需要先声明一个Field对象，这个Field对象指定你想要怎么处理某个数据,each Field has its own Vocab class。
-
tokenize传入一个函数，表示如何将文本str变成token -
sequential表示是否切分数据，如果数据已经是序列化的了而且是数字类型的，则应该传递参数use_vocab = False和sequential = False
除了上面提到的关键字参数之外，Field类还允许用户指定特殊标记（用于标记词典外词语的unk_token，用于填充的pad_token，用于句子结尾的eos_token以及用于句子开头的可选的init_token）。设置将第一维是batch还是sequence（第一维默认是sequence），并选择是否允许在运行时决定序列长度还是预先就决定好，Field类的文档
from torchtext.data import Field
tokenize = lambda x: x.split()
TEXT = Field(sequential=True, tokenize=tokenize, lower=True)
LABEL = Field(sequential=False, use_vocab=False)
使用spacy进行tokenizer，
import spacy
spacy_en = spacy.load('en')
def tokenizer(text): # create a tokenizer function
return [tok.text for tok in spacy_en.tokenizer(text)]
TEXT = data.Field(sequential=True, tokenize=tokenizer, lower=True)
LABEL = data.Field(sequential=False, use_vocab=False)
构建Dataset
Fields知道怎么处理原始数据，现在我们需要告诉Fields去处理哪些数据。这就是我们需要用到Dataset的地方。Torchtext中有各种内置Dataset，用于处理常见的数据格式。 对于csv/tsv文件，TabularDataset类很方便。 以下是我们如何使用TabularDataset从csv文件读取数据的示例：
from torchtext.data import TabularDataset
tv_datafields = [("id", None), # 我们不会需要id，所以我们传入的filed是None
("comment_text", TEXT), ("toxic", LABEL),
("severe_toxic", LABEL), ("threat", LABEL),
("obscene", LABEL), ("insult", LABEL),
("identity_hate", LABEL)]
trn, vld = TabularDataset.splits(
path="data", # 数据存放的根目录
train='train.csv', validation="valid.csv",
format='csv',
skip_header=True, # 如果你的csv有表头, 确保这个表头不会作为数据处理
fields=tv_datafields)
tst_datafields = [("id", None), # 我们不会需要id，所以我们传入的filed是None
("comment_text", TEXT)]
tst = TabularDataset(
path="data/test.csv", # 文件路径
format='csv',
skip_header=True, # 如果你的csv有表头, 确保这个表头不会作为数据处理
fields=tst_datafields)
- 我们传入（name，field）对的列表作为fields参数。我们传入的fields必须与列的顺序相同。对于我们不使用的列，我们在fields的位置传入一个None。
- splits方法通过应用相同的处理为训练数据和验证数据创建Dataset。 它也可以处理测试数据，但由于测试数据与训练数据和验证数据有不同的格式，因此我们创建了不同的Dataset。
- 数据集大多可以和list一样去处理。 为了理解这一点，我们看看Dataset内部是怎么样的。 数据集可以像list一样进行索引和迭代，所以让我们看看第一个元素是什么样的：
>>> trn[0]
>>> trn[0].__dict__.keys()
dict_keys(['comment_text', 'toxic', 'severe_toxic', 'threat', 'obscene', 'insult', 'identity_hate'])
>>> trn[0].comment_text[:3]
['explanation', 'why', 'the']
在一个TabularDataset里面直接指定train,test,validation，好像更为方便一些。
from torchtext import data
train, val, test = data.TabularDataset.splits(
path='./data/', train='train.tsv',
validation='val.tsv', test='test.tsv', format='tsv',
fields=[('Text', TEXT), ('Label', LABEL)])
词表
Torchtext将单词映射为整数，但必须告诉它应该处理的全部单词。 在我们的例子中，我们可能只想在训练集上建立词汇表，所以我们运行代码：TEXT.build_vocab(trn)。这使得torchtext遍历训练集中的所有元素，检查TEXT字段的内容，并将其添加到其词汇表中。Torchtext有自己的Vocab类来处理词汇。Vocab类在stoi属性中包含从word到id的映射，并在其itos属性中包含反向映射。 除此之外，它可以为word2vec等预训练的embedding自动构建embedding矩阵。Vocab类还可以使用像max_size和min_freq这样的选项来表示词汇表中有多少单词或单词出现的次数。未包含在词汇表中的单词将被转换成
TEXT.build_vocab(train, vectors="glove.6B.100d"),可以给vectors直接传入一个字符串类型的，那么会自动下载你需要的词向量，存放的位置是./.vector_cache 的文件夹下，或者可以使用类vocab.Vectors指定你自己的词向量。
Note you can directly pass in a string and it will download pre-trained word vectors and load them for you. You can also use your own vectors by using this class vocab.Vectors. The downloaded word embeddings will stay at ./.vector_cache folder. I have not yet discovered a way to specify a custom location to store the downloaded vectors (there should be a way right?).
将预训练的词向量加载到模型中。
from torchtext import data
TEXT.build_vocab(train, vectors="glove.6B.100d")
vocab = TEXT.vocab
self.embed = nn.Embedding(len(vocab), emb_dim)
self.embed.weight.data.copy_(vocab.vectors)
从词表变回单词
先安装工具,先从 GitHub上git clone代码然后进入目录安装，因为pip安装的不是最新版本
cd revtok/
python setup.py install
使用时候只需要使用可翻转的Field代替原来的Field就可以创建双向的转换的Vocb了。
from torchtext import data
TEXT = data.ReversibleField(sequential=True, lower=True, include_lengths=True)
...
for data in valid_iter:
(x, x_lengths), y = data.Text, data.Description
orig_text = TEXT.reverse(x.data)
对于预训练单词表中没有的单词我们可以随机进行初始化。
- 在构建
Field的时候设置include_lengths字段为True可以在返回minibatch的时候同时返回一个表示每个句子长度的list。
include_lengths: Whether to return a tuple of a padded minibatch and
a list containing the lengths of each examples, or just a padded
minibatch. Default: False.
随机初始化未知单词。
def init_emb(vocab, init="randn", num_special_toks=2):
emb_vectors = vocab.vectors
sweep_range = len(vocab)
running_norm = 0.
num_non_zero = 0
total_words = 0
for i in range(num_special_toks, sweep_range):
if len(emb_vectors[i, :].nonzero()) == 0:
# std = 0.05 is based on the norm of average GloVE 100-dim word vectors
if init == "randn":
torch.nn.init.normal(emb_vectors[i], mean=0, std=0.05)
else:
num_non_zero += 1
running_norm += torch.norm(emb_vectors[i])
total_words += 1
logger.info("average GloVE norm is {}, number of known words are {}, total number of words are {}".format(
running_norm / num_non_zero, num_non_zero, total_words))
构建迭代器
在torchvision和PyTorch中，数据的处理和批处理由DataLoaders处理。 出于某种原因，torchtext相同的东西又命名成了Iterators。 基本功能是一样的，但我们将会看到，Iterators具有一些NLP特有的便捷功能。
- 对于验证集和训练集合使用
BucketIterator.splits(),目的是自动进行shuffle和padding，并且为了训练效率期间，尽量把句子长度相似的shuffle在一起。 - 对于测试集用
Iterator，因为不用sort。 -
sort是对全体数据按照升序顺序进行排序，而sort_within_batch仅仅对一个batch内部的数据进行排序。 -
sort_within_batch参数设置为True时，按照sort_key按降序对每个小批次内的数据进行降序排序。当你想对padded序列使用pack_padded_sequence转换为PackedSequence对象时，这是必需的。 - 注意
sort和shuffle默认只是对train=True字段进行的，但是train字段默认是True。所以测试集合可以这么写testIter = Iterator(tst, batch_size = 64, device =-1, train=False)写法等价于下面的一长串写法。 -
repeat是否连续的训练无数个batch ,默认是False -
device可以是torch.device
from torchtext.data import Iterator, BucketIterator
train_iter, val_iter = BucketIterator.splits((trn, vld),
# 我们把Iterator希望抽取的Dataset传递进去
batch_sizes=(25, 25),
device=-1,
# 如果要用GPU，这里指定GPU的编号
sort_key=lambda x: len(x.comment_text),
# BucketIterator 依据什么对数据分组
sort_within_batch=False,
repeat=False)
# repeat设置为False，因为我们想要包装这个迭代器层。
test_iter = Iterator(tst, batch_size=64,
device=-1,
sort=False,
sort_within_batch=False,
repeat=False)
BucketIterator是torchtext最强大的功能之一。它会自动将输入序列进行shuffle并做bucket。这个功能强大的原因是——正如我前面提到的——我们需要填充输入序列使得长度相同才能批处理。 例如，序列
[ [3, 15, 2, 7],
[4, 1],
[5, 5, 6, 8, 1] ]
会需要pad成
[ [3, 15, 2, 7, 0],
[4, 1, 0, 0, 0],
[5, 5, 6, 8, 1] ]
填充量由batch中最长的序列决定。因此，当序列长度相似时，填充效率最高。BucketIterator会在在后台执行这些操作。需要注意的是，你需要告诉BucketIterator你想在哪个数据属性上做bucket。在我们的例子中，我们希望根据comment_text字段的长度进行bucket处理，因此我们将其作为关键字参数传入sort_key = lambda x: len(x.comment_text)
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), sort_key=lambda x: len(x.Text),
batch_sizes=(32, 256, 1), device=-1)
BucketIterator和Iterator的区别是，BucketIterator尽可能的把长度相似的句子放在一个batch里面。
Defines an iterator that batches examples of similar lengths together
封装迭代器
目前，迭代器返回一个名为torchtext.data.Batch的自定义数据类型。Batch类具有与Example类相似的API，将来自每个字段的一批数据作为属性。
>>> train_iter
[torchtext.data.batch.Batch of size 25]
[.comment_text]:[torch.LongTensor of size 494x25]
[.toxic]:[torch.LongTensor of size 25]
[.severe_toxic]:[torch.LongTensor of size 25]
[.threat]:[torch.LongTensor of size 25]
[.obscene]:[torch.LongTensor of size 25]
[.insult]:[torch.LongTensor of size 25]
[.identity_hate]:[torch.LongTensor of size 25]
>>> train_iter.__dict__.keys()
dict_keys(['batch_size', 'dataset', 'fields', 'comment_text', 'toxic', 'severe_toxic', 'threat', 'obscene', 'insult', 'identity_hate'])
>>> train_iter.comment_text
tensor([[ 15, 606, 280, ..., 15, 63, 15],
[ 360, 693, 18, ..., 29, 4, 2],
[ 45, 584, 14, ..., 21, 664, 645],
...,
[ 1, 1, 1, ..., 84, 1, 1],
[ 1, 1, 1, ..., 118, 1, 1],
[ 1, 1, 1, ..., 15, 1, 1]])
>>> train_iter.toxic
tensor([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0])
不幸的是，这种自定义数据类型使得代码重用变得困难（因为每次列名发生变化时，我们都需要修改代码），并且使torchtext在某些情况（如torchsample和fastai）下很难与其他库一起使用。
我希望这可以在未来得到优化（我正在考虑提交PR，如果我可以决定API应该是什么样的话），但同时，我们使用简单的封装来使batch易于使用。
具体来说，我们将把batch转换为形式为（x，y）的元组，其中x是自变量（模型的输入），y是因变量（标签数据）。 代码如下：
class BatchWrapper:
def __init__(self, dl, x_var, y_vars):
self.dl, self.x_var, self.y_vars = dl, x_var, y_vars # 传入自变量x列表和因变量y列表
def __iter__(self):
for batch in self.dl:
x = getattr(batch, self.x_var) # 在这个封装中只有一个自变量
if self.y_vars is not None: # 把所有因变量cat成一个向量
temp = [getattr(batch, feat).unsqueeze(1) for feat in self.y_vars]
y = torch.cat(temp, dim=1).float()
else:
y = torch.zeros((1))
yield (x, y)
def __len__(self):
return len(self.dl)
train_dl = BatchWrapper(train_iter, "comment_text", ["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"])
valid_dl = BatchWrapper(val_iter, "comment_text", ["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"])
test_dl = BatchWrapper(test_iter, "comment_text", None)
我们在这里所做的是将Batch对象转换为输入和输出的元组。
>>> next(train_dl.__iter__())
(tensor([[ 15, 15, 15, ..., 375, 354, 44],
[ 601, 657, 360, ..., 27, 63, 739],
[ 242, 22, 45, ..., 526, 4, 3],
...,
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]]),
tensor([[ 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0.],
[ 1., 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., 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., 0., 0., 0., 0., 0.],
[ 1., 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.],
[ 1., 1., 0., 1., 1., 0.],
[ 0., 0., 0., 0., 0., 0.]]))
训练模型
我们将使用一个简单的LSTM来演示如何根据我们构建的数据来训练文本分类器：
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
class SimpleLSTMBaseline(nn.Module):
def __init__(self, hidden_dim, emb_dim=300, num_linear=1):
super().__init__()
# 词汇量是 len(TEXT.vocab)
self.embedding = nn.Embedding(len(TEXT.vocab), emb_dim)
self.encoder = nn.LSTM(emb_dim, hidden_dim, num_layers=1)
self.linear_layers = []
# 中间fc层
for _ in range(num_linear - 1):
self.linear_layers.append(nn.Linear(hidden_dim, hidden_dim))
self.linear_layers = nn.ModuleList(self.linear_layers)
# 输出层
self.predictor = nn.Linear(hidden_dim, 6)
def forward(self, seq):
hdn, _ = self.encoder(self.embedding(seq))
feature = hdn[-1, :, :] # 选择最后一个output
for layer in self.linear_layers:
feature = layer(feature)
preds = self.predictor(feature)
return preds
em_sz = 100
nh = 500
model = SimpleBiLSTMBaseline(nh, emb_dim=em_sz)
现在，我们将编写训练循环。 多亏我们所有的预处理，让这变得非常简单非常简单。我们可以使用我们包装的Iterator进行迭代，并且数据在移动到GPU和适当数字化后将自动传递给我们。
import tqdm
opt = optim.Adam(model.parameters(), lr=1e-2)
loss_func = nn.BCEWithLogitsLoss()
epochs = 2
for epoch in range(1, epochs + 1):
running_loss = 0.0
running_corrects = 0
model.train() # 训练模式
for x, y in tqdm.tqdm(train_dl): # 由于我们的封装，我们可以直接对数据进行迭代
opt.zero_grad()
preds = model(x)
loss = loss_func(y, preds)
loss.backward()
opt.step()
running_loss += loss.data[0] * x.size(0)
epoch_loss = running_loss / len(trn)
# 计算验证数据的误差
val_loss = 0.0
model.eval() # 评估模式
for x, y in valid_dl:
preds = model(x)
loss = loss_func(y, preds)
val_loss += loss.data[0] * x.size(0)
val_loss /= len(vld)
print('Epoch: {}, Training Loss: {:.4f}, Validation Loss: {:.4f}'.format(epoch, epoch_loss, val_loss))
这就只是一个标准的训练循环。 现在来产生我们的预测
test_preds = []
for x, y in tqdm.tqdm(test_dl):
preds = model(x)
preds = preds.data.numpy()
# 模型的实际输出是logit，所以再经过一个sigmoid函数
preds = 1 / (1 + np.exp(-preds))
test_preds.append(preds)
test_preds = np.hstack(test_preds)
最后，我们可以将我们的预测写入一个csv文件。
import pandas as pd
df = pd.read_csv("data/test.csv")
for i, col in enumerate(["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]):
df[col] = test_preds[:, i]
df.drop("comment_text", axis=1).to_csv("submission.csv", index=False)
对于mask的数据的支持
RNN需要将PyTorch 变量打包成一个padded 序列。
-
sort_within_batch=True，如果想使用PyTorch里面的pack_padded sequence时候必须要设置为TRUE -
sort_key是对数据集合在一个batch的的排序函数。 -
repeat是否使用多个epoch。
repeat – Whether to repeat the iterator for multiple epochs. Default: False.
TEXT = data.ReversibleField(sequential=True, lower=True, include_lengths=True)
train, val, test = data.TabularDataset.splits(
path='./data/', train='train.tsv',
validation='val.tsv', test='test.tsv', format='tsv',
fields=[('Text', TEXT), ('Label', LABEL)])
train_iter, val_iter, test_iter = data.Iterator.splits(
(train, val, test), sort_key=lambda x: len(x.Text),
batch_sizes=(32, 256, 256), device=args.gpu,
sort_within_batch=True, repeat=False)
在模型中这么使用
def forward(self, input, lengths=None):
embed_input = self.embed(input)
packed_emb = embed_input
if lengths is not None:
lengths = lengths.view(-1).tolist()
packed_emb = nn.utils.rnn.pack_padded_sequence(embed_input, lengths)
output, hidden = self.encoder(packed_emb) # embed_input
if lengths is not None:
output,_=nn.utils.rnn.pad_packed_sequence(output)
在主循环中可以以这样的方式传递数据，未打包之前。
# Note this loop will go on FOREVER
for val_i, data in enumerate(train_iter):
(x, x_lengths), y = data.Text, data.Description
output = model(x, x_lengths)
# terminate condition, when loss converges or it reaches 50000 iterations
if loss converges or val_i == 50000:
break
如果我们想训练一定的epoch，我们可以设置，repeat=False,这样我们的数据会训练10个epoch然后停止下来。
# Note this loop will stop when training data is traversed once
epochs = 10
for epoch in range(epochs):
for data in train_iter:
(x, x_lengths), y = data.Text, data.Description
# model running...
如果我们提前不知道应该在多少个epoch的时候停止，比如当精度达到某个值的时候停止，我们就可以设置repeat = True,然后在代码里面break.