注意

点击此处下载完整的示例代码

NLP 从零开始：使用字符级 RNN 生成名称¶

创建于：2017 年 3 月 24 日 | 最后更新：2024 年 10 月 21 日 | 最后验证：2024 年 11 月 05 日

本教程是三部分系列教程的一部分

这是我们关于“NLP 从零开始”的三个教程中的第二个。在第一个教程中，我们使用 RNN 将名称分类到其来源语言。这次我们将反过来，从语言生成名称。

> python sample.py Russian RUS
Rovakov
Uantov
Shavakov

> python sample.py German GER
Gerren
Ereng
Rosher

> python sample.py Spanish SPA
Salla
Parer
Allan

> python sample.py Chinese CHI
Chan
Hang
Iun

我们仍然在手工制作一个带有几个线性层的小型 RNN。最大的区别在于，我们不是在读取完名称的所有字母后预测类别，而是输入一个类别并一次输出一个字母。递归地预测字符以形成语言（这也可以用单词或其他更高阶的结构来完成）通常被称为“语言模型”。

推荐阅读

我假设您至少安装了 PyTorch，了解 Python，并且理解张量

https://pytorch.ac.cn/ 有关安装说明
PyTorch 深度学习：60 分钟速成教程以开始使用 PyTorch
通过示例学习 PyTorch 以获得广泛而深入的概述
面向以前的 Torch 用户的 PyTorch 如果您是以前的 Lua Torch 用户

了解 RNN 及其工作原理也很有用

循环神经网络的惊人有效性展示了许多真实生活中的例子
理解 LSTM 网络专门介绍 LSTM，但也对 RNN 有一般性的启发

我还建议阅读之前的教程，NLP 从零开始：使用字符级 RNN 对名称进行分类

准备数据¶

注意

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

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

from io import open
import glob
import os
import unicodedata
import string

all_letters = string.ascii_letters + " .,;'-"
n_letters = len(all_letters) + 1 # Plus EOS marker

def findFiles(path): return glob.glob(path)

# Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427
def unicodeToAscii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.category(c) != 'Mn'
        and c in all_letters
    )

# Read a file and split into lines
def readLines(filename):
    with open(filename, encoding='utf-8') as some_file:
        return [unicodeToAscii(line.strip()) for line in some_file]

# Build the category_lines dictionary, a list of lines per category
category_lines = {}
all_categories = []
for filename in findFiles('data/names/*.txt'):
    category = os.path.splitext(os.path.basename(filename))[0]
    all_categories.append(category)
    lines = readLines(filename)
    category_lines[category] = lines

n_categories = len(all_categories)

if n_categories == 0:
    raise RuntimeError('Data not found. Make sure that you downloaded data '
        'from https://download.pytorch.org/tutorial/data.zip and extract it to '
        'the current directory.')

print('# categories:', n_categories, all_categories)
print(unicodeToAscii("O'Néàl"))

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

创建网络¶

此网络扩展了上一个教程的 RNN，增加了一个用于类别张量的额外参数，该参数与其他参数连接在一起。类别张量是一个 one-hot 向量，就像字母输入一样。

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

我添加了第二个线性层 o2o（在组合隐藏层和输出层之后），使其具有更强大的处理能力。还有一个 dropout 层，它以给定的概率（此处为 0.1）随机将输入的部分置零，通常用于模糊输入以防止过拟合。在这里，我们在网络的末端使用它，目的是增加一些混乱并增加采样多样性。

import torch
import torch.nn as nn

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size

        self.i2h = nn.Linear(n_categories + input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(n_categories + input_size + hidden_size, output_size)
        self.o2o = nn.Linear(hidden_size + output_size, output_size)
        self.dropout = nn.Dropout(0.1)
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, category, input, hidden):
        input_combined = torch.cat((category, input, hidden), 1)
        hidden = self.i2h(input_combined)
        output = self.i2o(input_combined)
        output_combined = torch.cat((hidden, output), 1)
        output = self.o2o(output_combined)
        output = self.dropout(output)
        output = self.softmax(output)
        return output, hidden

    def initHidden(self):
        return torch.zeros(1, self.hidden_size)

训练¶

准备训练¶

首先，辅助函数用于获取 (类别, 行) 的随机对

import random

# Random item from a list
def randomChoice(l):
    return l[random.randint(0, len(l) - 1)]

# Get a random category and random line from that category
def randomTrainingPair():
    category = randomChoice(all_categories)
    line = randomChoice(category_lines[category])
    return category, line

对于每个时间步（即，对于训练单词中的每个字母），网络的输入将是 (类别, 当前字母, 隐藏状态)，输出将是 (下一个字母, 下一个隐藏状态)。因此，对于每个训练集，我们需要类别、一组输入字母和一组输出/目标字母。

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

类别张量是大小为 <1 x n_categories> 的 one-hot 张量。训练时，我们在每个时间步将其馈送到网络 - 这是一种设计选择，它可以作为初始隐藏状态的一部分或其他策略包括在内。

# One-hot vector for category
def categoryTensor(category):
    li = all_categories.index(category)
    tensor = torch.zeros(1, n_categories)
    tensor[0][li] = 1
    return tensor

# One-hot matrix of first to last letters (not including EOS) for input
def inputTensor(line):
    tensor = torch.zeros(len(line), 1, n_letters)
    for li in range(len(line)):
        letter = line[li]
        tensor[li][0][all_letters.find(letter)] = 1
    return tensor

# ``LongTensor`` of second letter to end (EOS) for target
def targetTensor(line):
    letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]
    letter_indexes.append(n_letters - 1) # EOS
    return torch.LongTensor(letter_indexes)

为了在训练期间方便起见，我们将创建一个 randomTrainingExample 函数，该函数获取随机 (类别, 行) 对，并将它们转换为所需的 (类别, 输入, 目标) 张量。

# Make category, input, and target tensors from a random category, line pair
def randomTrainingExample():
    category, line = randomTrainingPair()
    category_tensor = categoryTensor(category)
    input_line_tensor = inputTensor(line)
    target_line_tensor = targetTensor(line)
    return category_tensor, input_line_tensor, target_line_tensor

训练网络¶

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

autograd 的魔力使您可以简单地将每一步的这些损失相加，并在最后调用 backward。

criterion = nn.NLLLoss()

learning_rate = 0.0005

def train(category_tensor, input_line_tensor, target_line_tensor):
    target_line_tensor.unsqueeze_(-1)
    hidden = rnn.initHidden()

    rnn.zero_grad()

    loss = torch.Tensor([0]) # you can also just simply use ``loss = 0``

    for i in range(input_line_tensor.size(0)):
        output, hidden = rnn(category_tensor, input_line_tensor[i], hidden)
        l = criterion(output, target_line_tensor[i])
        loss += l

    loss.backward()

    for p in rnn.parameters():
        p.data.add_(p.grad.data, alpha=-learning_rate)

    return output, loss.item() / input_line_tensor.size(0)

为了跟踪训练花费的时间，我添加了一个 timeSince(timestamp) 函数，该函数返回人类可读的字符串

import time
import math

def timeSince(since):
    now = time.time()
    s = now - since
    m = math.floor(s / 60)
    s -= m * 60
    return '%dm %ds' % (m, s)

训练与往常一样 - 多次调用 train 并等待几分钟，每 print_every 个示例打印当前时间和损失，并在 plot_every 个示例中保留每个示例的平均损失存储在 all_losses 中，以便稍后绘制。

rnn = RNN(n_letters, 128, n_letters)

n_iters = 100000
print_every = 5000
plot_every = 500
all_losses = []
total_loss = 0 # Reset every ``plot_every`` ``iters``

start = time.time()

for iter in range(1, n_iters + 1):
    output, loss = train(*randomTrainingExample())
    total_loss += loss

    if iter % print_every == 0:
        print('%s (%d %d%%) %.4f' % (timeSince(start), iter, iter / n_iters * 100, loss))

    if iter % plot_every == 0:
        all_losses.append(total_loss / plot_every)
        total_loss = 0

0m 29s (5000 5%) 3.1506
1m 0s (10000 10%) 2.5070
1m 31s (15000 15%) 3.3047
2m 1s (20000 20%) 2.4247
2m 31s (25000 25%) 2.6406
3m 1s (30000 30%) 2.0266
3m 31s (35000 35%) 2.6520
4m 0s (40000 40%) 2.4261
4m 31s (45000 45%) 2.2302
5m 1s (50000 50%) 1.6496
5m 31s (55000 55%) 2.7101
6m 0s (60000 60%) 2.5396
6m 31s (65000 65%) 2.5978
7m 1s (70000 70%) 1.6029
7m 30s (75000 75%) 0.9634
8m 0s (80000 80%) 3.0950
8m 29s (85000 85%) 2.0512
8m 59s (90000 90%) 2.5302
9m 29s (95000 95%) 3.2365
9m 59s (100000 100%) 1.7113

绘制损失¶

绘制来自 all_losses 的历史损失显示了网络的学习过程

import matplotlib.pyplot as plt

plt.figure()
plt.plot(all_losses)

[<matplotlib.lines.Line2D object at 0x7f976704c3d0>]

采样网络¶

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

为输入类别、起始字母和空隐藏状态创建张量
使用起始字母创建字符串 output_name
直到最大输出长度，
- 将当前字母馈送到网络
- 从最高输出中获取下一个字母和下一个隐藏状态
- 如果字母是 EOS，则在此处停止
- 如果是常规字母，则添加到 output_name 并继续
返回最终名称

注意

另一种策略是，不必给出起始字母，而是可以在训练中包含“字符串开始”标记，并让网络选择自己的起始字母。

max_length = 20

# Sample from a category and starting letter
def sample(category, start_letter='A'):
    with torch.no_grad():  # no need to track history in sampling
        category_tensor = categoryTensor(category)
        input = inputTensor(start_letter)
        hidden = rnn.initHidden()

        output_name = start_letter

        for i in range(max_length):
            output, hidden = rnn(category_tensor, input[0], hidden)
            topv, topi = output.topk(1)
            topi = topi[0][0]
            if topi == n_letters - 1:
                break
            else:
                letter = all_letters[topi]
                output_name += letter
            input = inputTensor(letter)

        return output_name

# Get multiple samples from one category and multiple starting letters
def samples(category, start_letters='ABC'):
    for start_letter in start_letters:
        print(sample(category, start_letter))

samples('Russian', 'RUS')

samples('German', 'GER')

samples('Spanish', 'SPA')

samples('Chinese', 'CHI')

Rovaki
Uarinovev
Shinan
Gerter
Eeren
Roune
Santera
Paneraz
Allan
Chin
Han
Ion

练习¶

尝试使用不同的类别 -> 行数据集，例如
- 虚构系列 -> 角色名称
- 词性 -> 单词
- 国家 -> 城市
使用“句子开始”标记，以便可以在不选择起始字母的情况下进行采样
使用更大和/或形状更好的网络获得更好的结果
- 尝试 nn.LSTM 和 nn.GRU 层
- 将这些 RNN 中的多个组合为更高级别的网络

脚本的总运行时间： ( 9 分钟 59.492 秒)

由 Sphinx-Gallery 生成的图库