NLP From Scratch：使用char-RNN生成姓氏

作者：Sean Robertson

译者：松鼠

校验：松鼠

这是我们关于“从零开始的NLP”的三个教程中的第二个。在第一个教程</ intermediate / char_rnn_classification_tutorial>中，我们使用了RNN将姓氏分类为它们的起源语言。这次，我们将从语言中生成姓氏。

  1.     > python sample.py Russian RUS
  2.     Rovakov
  3.     Uantov
  4.     Shavakov
  6.     > python sample.py German GER
  7.     Gerren
  8.     Ereng
  9.     Rosher
  11.     > python sample.py Spanish SPA
  12.     Salla
  13.     Parer
  14.     Allan
  16.     > python sample.py Chinese CHI
  17.     Chan
  18.     Hang
  19.     Iun

我们之前还在手撸带有一些线性层的小型RNN网络。现在和之前最大的区别在于，我们不再是读取一个姓氏的所有字母来预测是什么类别，而是输入一个类别并同时输出一个字母。这种循环预测出来自语言的字符模型(这也可以用单词或其他高阶结构来完成）通常称为“语言模型”。

建议：

假设你已经至少安装PyTorch，知道Python和理解张量：

下面这些是了解RNNs以及它们如何工作的相关联接：

我也建议浏览下前面的教程，NLP From Scratch：使用char-RNN对姓氏进行分类

准备数据

  • Note 从此处下载数据，并将其解压到当前目录。

有关此过程的更多详细信息，请参见上一教程。简而言之，有一堆纯文本文件data/names/[Language].txt，每行都有一个姓氏。我们将行拆分成一个数组，将Unicode转换为ASCII，最后得到一个dictionary{language: [names ...]}

  1.     from __future__ import unicode_literals, print_function, division
  2.     from io import open
  3.     import glob
  4.     import os
  5.     import unicodedata
  6.     import string
  8.     all_letters = string.ascii_letters + " .,;'-"
  9.     n_letters = len(all_letters) + 1 # Plus EOS marker
  11.     def findFiles(path): return glob.glob(path)
  13.     # Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427
  14.     def unicodeToAscii(s):
  15.         return ''.join(
  16.             c for c in unicodedata.normalize('NFD', s)
  17.             if unicodedata.category(c) != 'Mn'
  18.             and c in all_letters
  19.         )
  21.     # Read a file and split into lines
  22.     def readLines(filename):
  23.         lines = open(filename, encoding='utf-8').read().strip().split('\n')
  24.         return [unicodeToAscii(line) for line in lines]
  26.     # Build the category_lines dictionary, a list of lines per category
  27.     category_lines = {}
  28.     all_categories = []
  29.     for filename in findFiles('data/names/*.txt'):
  30.         category = os.path.splitext(os.path.basename(filename))[0]
  31.         all_categories.append(category)
  32.         lines = readLines(filename)
  33.         category_lines[category] = lines
  35.     n_categories = len(all_categories)
  37.     if n_categories == 0:
  38.         raise RuntimeError('Data not found. Make sure that you downloaded data '
  39.             'from https://download.pytorch.org/tutorial/data.zip and extract it to '
  40.             'the current directory.')
  42.     print('# categories:', n_categories, all_categories)
  43.     print(unicodeToAscii("O'Néàl"))

输出：

  1.     # categories: 18 ['French', 'Czech', 'Dutch', 'Polish', 'Scottish', 'Chinese', 'English', 'Italian', 'Portuguese', 'Japanese', 'German', 'Russian', 'Korean', 'Arabic', 'Greek', 'Vietnamese', 'Spanish', 'Irish']
  2.     O'Neal

创建网络

该网络 使用类别张量的额外参数扩展了上一教程的RNN，该参数与其他张量串联在一起。类别张量是一个独热向量，就像字母输入一样。

我们将输出解释为下一个字母的概率。采样时，最有可能的输出字母用作下一个输入字母。

我们添加了第二个线性层o2o(将隐藏和输出结合在一起之后），以使它具有更多的性能可以使用。还有一个drop层，它以给定的概率(此处为0.1）将输入的一部分随机归零，通常用于模糊输入以防止过拟合。在这里，我们在网络末端使用它来故意添加一些混乱并增加采样种类。

  1.     import torch
  2.     import torch.nn as nn
  4.     class RNN(nn.Module):
  5.         def __init__(self, input_size, hidden_size, output_size):
  6.             super(RNN, self).__init__()
  7.             self.hidden_size = hidden_size
  9.             self.i2h = nn.Linear(n_categories + input_size + hidden_size, hidden_size)
  10.             self.i2o = nn.Linear(n_categories + input_size + hidden_size, output_size)
  11.             self.o2o = nn.Linear(hidden_size + output_size, output_size)
  12.             self.dropout = nn.Dropout(0.1)
  13.             self.softmax = nn.LogSoftmax(dim=1)
  15.         def forward(self, category, input, hidden):
  16.             input_combined = torch.cat((category, input, hidden), 1)
  17.             hidden = self.i2h(input_combined)
  18.             output = self.i2o(input_combined)
  19.             output_combined = torch.cat((hidden, output), 1)
  20.             output = self.o2o(output_combined)
  21.             output = self.dropout(output)
  22.             output = self.softmax(output)
  23.             return output, hidden
  25.         def initHidden(self):
  26.             return torch.zeros(1, self.hidden_size)

训练

准备训练

先，helper函数获取随机对(类别，行）：

  1.     import random
  3.     # Random item from a list
  4.     def randomChoice(l):
  5.         return l[random.randint(0, len(l) - 1)]
  7.     # Get a random category and random line from that category
  8.     def randomTrainingPair():
  9.         category = randomChoice(all_categories)
  10.         line = randomChoice(category_lines[category])
  11.         return category, line

对于每个时间步长(即对于训练单词中的每个字母），网络的输入将为(category, current letter, hidden state) ，输出将为(next letter, next hidden state)。因此，对于每个训练集，我们都需要类别，一组输入字母和一组输出/目标字母。

由于我们正在预测每个时间步中当前字母的下一个字母，因此字母对是该行中连续的字母组,例如:"ABCD<EOS>"我们将创建(“ A”，“ B”），(“ B”，“ C” )，(“ C”，“ D”），(“ D”，“ EOS”）。

类别张量是大小为<1 x n_categories>的独热张量。训练时，我们会随时随地将其馈送到网络中。这是一种设计方式，它可能已作为初始隐藏状态或某些其他策略的一部分包含在内。

  1.     # One-hot vector for category
  2.     def categoryTensor(category):
  3.         li = all_categories.index(category)
  4.         tensor = torch.zeros(1, n_categories)
  5.         tensor[0][li] = 1
  6.         return tensor
  8.     # One-hot matrix of first to last letters (not including EOS) for input
  9.     def inputTensor(line):
  10.         tensor = torch.zeros(len(line), 1, n_letters)
  11.         for li in range(len(line)):
  12.             letter = line[li]
  13.             tensor[li][0][all_letters.find(letter)] = 1
  14.         return tensor
  16.     # LongTensor of second letter to end (EOS) for target
  17.     def targetTensor(line):
  18.         letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]
  19.         letter_indexes.append(n_letters - 1) # EOS
  20.         return torch.LongTensor(letter_indexes)

为了方便训练，我们将创建一个randomTrainingExample函数以获取随机(类别，行）对并将其转换为所需的(类别，输入，目标）张量。

  1.     # Make category, input, and target tensors from a random category, line pair
  2.     def randomTrainingExample():
  3.         category, line = randomTrainingPair()
  4.         category_tensor = categoryTensor(category)
  5.         input_line_tensor = inputTensor(line)
  6.         target_line_tensor = targetTensor(line)
  7.         return category_tensor, input_line_tensor, target_line_tensor

网络训练

与仅使用最后一个输出的分类相反，我们在每个步骤进行预测，因此在每个步骤都计算损失。

autograd使您可以简单地将每一步的损失相加，然后在末尾调用。

  2.     criterion = nn.NLLLoss()
  4.     learning_rate = 0.0005
  6.     def train(category_tensor, input_line_tensor, target_line_tensor):
  7.         target_line_tensor.unsqueeze_(-1)
  8.         hidden = rnn.initHidden()
  10.         rnn.zero_grad()
  12.         loss = 0
  14.         for i in range(input_line_tensor.size(0)):
  15.             output, hidden = rnn(category_tensor, input_line_tensor[i], hidden)
  16.             l = criterion(output, target_line_tensor[i])
  17.             loss += l
  19.         loss.backward()
  21.         for p in rnn.parameters():
  22.             p.data.add_(-learning_rate, p.grad.data)
  24.         return output, loss.item() / input_line_tensor.size(0)

为了跟踪训练需要多长时间，我添加了一个timeSince(timestamp)返回人类可读字符串的函数：

  2.     import time
  3.     import math
  5.     def timeSince(since):
  6.         now = time.time()
  7.         s = now - since
  8.         m = math.floor(s / 60)
  9.         s -= m * 60
  10.         return '%dm %ds' % (m, s)

训练通常会需要来回调用很多次，然后等待几分钟，打印每个print_every的当前时间和损失值，并保存每个样本的平均损失plot_every到all_losses供以后绘图用。

  2.     rnn = RNN(n_letters, 128, n_letters)
  4.     n_iters = 100000
  5.     print_every = 5000
  6.     plot_every = 500
  7.     all_losses = []
  8.     total_loss = 0 # Reset every plot_every iters
  10.     start = time.time()
  12.     for iter in range(1, n_iters + 1):
  13.         output, loss = train(*randomTrainingExample())
  14.         total_loss += loss
  16.         if iter % print_every == 0:
  17.             print('%s (%d %d%%) %.4f' % (timeSince(start), iter, iter / n_iters * 100, loss))
  19.         if iter % plot_every == 0:
  20.             all_losses.append(total_loss / plot_every)
  21.             total_loss = 0

Out:

  2.     0m 17s (5000 5%) 3.5187
  3.     0m 35s (10000 10%) 2.5492
  4.     0m 53s (15000 15%) 2.2320
  5.     1m 11s (20000 20%) 3.2664
  6.     1m 29s (25000 25%) 2.2973
  7.     1m 47s (30000 30%) 1.1620
  8.     2m 5s (35000 35%) 2.8624
  9.     2m 23s (40000 40%) 1.8314
  10.     2m 41s (45000 45%) 2.3952
  11.     2m 58s (50000 50%) 2.7142
  12.     3m 16s (55000 55%) 2.4662
  13.     3m 34s (60000 60%) 2.9410
  14.     3m 53s (65000 65%) 2.5558
  15.     4m 11s (70000 70%) 2.2629
  16.     4m 29s (75000 75%) 2.3106
  17.     4m 47s (80000 80%) 2.2239
  18.     5m 5s (85000 85%) 1.4803
  19.     5m 23s (90000 90%) 2.9525
  20.     5m 42s (95000 95%) 1.9797
  21.     6m 0s (100000 100%) 2.3567

绘制损失

绘制all_losses中的历史损失值展示网络学习：

  1.     import matplotlib.pyplot as plt
  2.     import matplotlib.ticker as ticker
  4.     plt.figure()
  5.     plt.plot(all_losses)

img/sphx_glr_char_rnn_generation_tutorial_001.png

采样网络

我们给网络一个字母，问下一个字母是什么，并将其作为下一个字母输入，并重复直到EOS标记。

  • 创建输入类别，首个字母，空的隐藏状态的张量
  • 创建一个以首字母开头的字符串output_name
  • 最大输出长度，
    • 喂入当前字母到网络
    • 从输出中获取最可能字母，和下一个隐藏层的状态
    • 如果当前输出是EOS标记，就停止循环
    • 如果是一个正常的字母，就添加到output_name中并继续
  • 返回的最终姓氏
  • Note 相比于给它起一个开始字母，另一种策略是在训练中包括一个“字符串开始”标记，并让网络选择自己的开始字母。
  1.     max_length = 20
  3.     # Sample from a category and starting letter
  4.     def sample(category, start_letter='A'):
  5.         with torch.no_grad():  # no need to track history in sampling
  6.             category_tensor = categoryTensor(category)
  7.             input = inputTensor(start_letter)
  8.             hidden = rnn.initHidden()
  10.             output_name = start_letter
  12.             for i in range(max_length):
  13.                 output, hidden = rnn(category_tensor, input[0], hidden)
  14.                 topv, topi = output.topk(1)
  15.                 topi = topi[0][0]
  16.                 if topi == n_letters - 1:
  17.                     break
  18.                 else:
  19.                     letter = all_letters[topi]
  20.                     output_name += letter
  21.                 input = inputTensor(letter)
  23.             return output_name
  25.     # Get multiple samples from one category and multiple starting letters
  26.     def samples(category, start_letters='ABC'):
  27.         for start_letter in start_letters:
  28.             print(sample(category, start_letter))
  30.     samples('Russian', 'RUS')
  32.     samples('German', 'GER')
  34.     samples('Spanish', 'SPA')
  36.     samples('Chinese', 'CHI')

输出:

  1.     Rovallov
  2.     Uanovakov
  3.     Sanovakov
  4.     Geller
  5.     Eringer
  6.     Raman
  7.     Salos
  8.     Para
  9.     Allan
  10.     Chan
  11.     Hang
  12.     Iun

练习

  • 尝试使用不同的数据集的category -> line，例如：
    • 虚构系列->角色名称
    • 词性->单词
    • 国家->城市
  • 使用“句子开头”标记，以便无需选择开始字母即可进行采样
  • 通过更大和/或结构更好的网络获得更好的结果
    • 尝试nn.LSTM和nn.GRU层
    • 将多个这些RNN合并为更高级别的网络

脚本的总运行时间： (6分钟0.536秒）