备注
点击 此处 下载完整示例代码
从头开始的 NLP：使用字符级 RNN 分类姓名¶
Created On: Mar 24, 2017 | Last Updated: Mar 14, 2025 | Last Verified: Nov 05, 2024
作者: Sean Robertson
本教程是一个三部分系列教程的一部分：
我们将构建并训练一个基本的字符级循环神经网络（RNN）来对单词进行分类。本教程，以及另外两个有关自然语言处理（NLP）的“从头开始”的教程 从零开始的 NLP：使用字符级 RNN 生成名称 和 从零开始的NLP：使用序列到序列网络和注意力进行翻译，展示了如何为 NLP 对数据进行预处理建模。特别是，这些教程展示了 NLP 的低级别预处理建模过程。
一个字符级 RNN 将单词读取为一系列字符——在每一步输出一个预测和“隐藏状态”，并在每一步中将其前一个隐藏状态传递到下一个步骤。我们将最终的预测视为输出，即单词所属的类别。
具体来说，我们将以来自 18 种语言的数千个姓氏作为训练数据，根据拼写预测姓名的来源语言。
推荐的准备工作¶
在开始本教程之前，建议您安装 PyTorch，并对 Python 编程语言和张量有基本的了解：
有关安装说明，请访问 https://pytorch.org/
使用 PyTorch 进行深度学习：60 分钟闪电教程 快速入门 PyTorch 并学习张量基础知识
通过示例学习PyTorch 浏览广泛且深入的概述
给前Torch用户的PyTorch教程 如果您是前 Lua Torch 用户
了解 RNN 是如何工作的也会对学习有帮助：
循环神经网络的惊人效果 中展示了大量实际案例
理解 LSTM 网络 专门介绍了 LSTM，但同时也对 RNN 有 general 方面的重要信息。
准备 Torch¶
设置 Torch 默认使用正确的设备，根据硬件（CPU 或 CUDA）利用 GPU 加速。
import torch
# Check if CUDA is available
device = torch.device('cpu')
if torch.cuda.is_available():
device = torch.device('cuda')
torch.set_default_device(device)
print(f"Using device = {torch.get_default_device()}")
准备数据¶
从 此处 下载数据并将其解压到当前目录下。
data/names 目录包含 18 个以 [语言].txt 命名的文本文件。每个文件包含一堆名字，每行一个名字，大部分已经罗马化了（但我们仍然需要将 Unicode 转换为 ASCII）。
第一步是定义并清理数据。最初，我们需要将 Unicode 转换为普通 ASCII 来限制 RNN 输入层。这是通过将 Unicode 字符串转换为 ASCII 并仅允许一小部分允许字符集来实现的。
import string
import unicodedata
# We can use "_" to represent an out-of-vocabulary character, that is, any character we are not handling in our model
allowed_characters = string.ascii_letters + " .,;'" + "_"
n_letters = len(allowed_characters)
# 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 allowed_characters
)
以下是将 Unicode 字母表名转换为普通 ASCII 的一个示例。这简化了输入层。
print (f"converting 'Ślusàrski' to {unicodeToAscii('Ślusàrski')}")
将姓名转换为张量¶
现在我们已经将所有姓名进行了整理，我们需要将它们转换为张量以便使用。
为了表示单个字母，我们使用一个大小为 <1 x n_letters> 的“独热向量”。一个独热向量中除了当前字母索引处为 1，其他均为 0，例如："b" = <0 1 0 0 0 ...>。
要表示一个单词，我们将这些转化为一个二维矩阵 <line_length x 1 x n_letters>。
额外的 1 维度是因为 PyTorch 假设一切都在批次中——在这里我们只是使用批次大小为 1。
# Find letter index from all_letters, e.g. "a" = 0
def letterToIndex(letter):
# return our out-of-vocabulary character if we encounter a letter unknown to our model
if letter not in allowed_characters:
return allowed_characters.find("_")
else:
return allowed_characters.find(letter)
# Turn a line into a <line_length x 1 x n_letters>,
# or an array of one-hot letter vectors
def lineToTensor(line):
tensor = torch.zeros(len(line), 1, n_letters)
for li, letter in enumerate(line):
tensor[li][0][letterToIndex(letter)] = 1
return tensor
以下是如何使用 lineToTensor() 处理单个和多个字符字符串的一些示例。
print (f"The letter 'a' becomes {lineToTensor('a')}") #notice that the first position in the tensor = 1
print (f"The name 'Ahn' becomes {lineToTensor('Ahn')}") #notice 'A' sets the 27th index to 1
恭喜，您已经为此学习任务构建了基础张量对象！您可以为其他包含文本的 RNN 任务使用类似的方法。
接下来，我们需要将所有示例组合到一个数据集中，这样我们就可以训练、测试和验证我们的模型。为此，我们将使用 Dataset 和 DataLoader 类来保存我们的数据集。每个 Dataset 都需要实现三个函数：__init__、__len__ 和 __getitem__。
from io import open
import glob
import os
import time
import torch
from torch.utils.data import Dataset
class NamesDataset(Dataset):
def __init__(self, data_dir):
self.data_dir = data_dir #for provenance of the dataset
self.load_time = time.localtime #for provenance of the dataset
labels_set = set() #set of all classes
self.data = []
self.data_tensors = []
self.labels = []
self.labels_tensors = []
#read all the ``.txt`` files in the specified directory
text_files = glob.glob(os.path.join(data_dir, '*.txt'))
for filename in text_files:
label = os.path.splitext(os.path.basename(filename))[0]
labels_set.add(label)
lines = open(filename, encoding='utf-8').read().strip().split('\n')
for name in lines:
self.data.append(name)
self.data_tensors.append(lineToTensor(name))
self.labels.append(label)
#Cache the tensor representation of the labels
self.labels_uniq = list(labels_set)
for idx in range(len(self.labels)):
temp_tensor = torch.tensor([self.labels_uniq.index(self.labels[idx])], dtype=torch.long)
self.labels_tensors.append(temp_tensor)
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
data_item = self.data[idx]
data_label = self.labels[idx]
data_tensor = self.data_tensors[idx]
label_tensor = self.labels_tensors[idx]
return label_tensor, data_tensor, data_label, data_item
在这里我们将示例数据加载到 NamesDataset
alldata = NamesDataset("data/names")
print(f"loaded {len(alldata)} items of data")
print(f"example = {alldata[0]}")
- 使用数据集对象允许我们轻松将数据分为训练集和测试集。在此我们创建一个 80/20
的分割，但
torch.utils.data中有更多实用工具。这里我们指定一个生成器，因为我们需要与上方 PyTorch 默认设备一致。
现在我们有一个包含 20074 个示例的基本数据集，其中每个示例是一个标签和姓名的配对。同时，我们已经将数据集分为训练集和测试集，以便验证我们构建的模型。
train_set, test_set = torch.utils.data.random_split(alldata, [.85, .15], generator=torch.Generator(device=device).manual_seed(2024))
print(f"train examples = {len(train_set)}, validation examples = {len(test_set)}")
创建网络
在自动求导之前，用 Torch 创建循环神经网络需要在多个时间步克隆一个层的参数。层保留了隐藏状态和梯度，而现在这些完全由图所处理。这意味着您可以以一种非常“纯”的方式实现 RNN，就像常规的前馈层一样。¶
此 CharRNN 类实现了一个包含三个组件的 RNN。首先，我们使用 nn.RNN 实现。接下来，我们定义一个将 RNN 隐藏层映射到我们输出的层。最后，我们应用一个 softmax 函数。使用 nn.RNN 带来了显著的性能改进，例如基于 cuDNN 的加速内核，而不是将每层实现为 nn.Linear。此外，它还简化了 forward() 中的实现。
然后我们可以创建一个 RNN，其中有 58 个输入节点、128 个隐藏节点和 18 个输出：
import torch.nn as nn
import torch.nn.functional as F
class CharRNN(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(CharRNN, self).__init__()
self.rnn = nn.RNN(input_size, hidden_size)
self.h2o = nn.Linear(hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim=1)
def forward(self, line_tensor):
rnn_out, hidden = self.rnn(line_tensor)
output = self.h2o(hidden[0])
output = self.softmax(output)
return output
之后我们可以将张量传递给 RNN 以获得预测输出。随后，我们使用帮助函数 label_from_output 来为类别得出文本标签。
n_hidden = 128
rnn = CharRNN(n_letters, n_hidden, len(alldata.labels_uniq))
print(rnn)
训练
def label_from_output(output, output_labels):
top_n, top_i = output.topk(1)
label_i = top_i[0].item()
return output_labels[label_i], label_i
input = lineToTensor('Albert')
output = rnn(input) #this is equivalent to ``output = rnn.forward(input)``
print(output)
print(label_from_output(output, alldata.labels_uniq))
训练网络¶
现在训练这个网络只需要向它展示大量示例，让它进行猜测，并告诉它结果是否错误。¶
我们通过定义一个 train() 函数，在给定数据集上使用小批量训练来训练模型。RNNs 的训练与其他网络相似。因此，为了完整性，我们在这里包含了一种分批训练方法。循环（for i in batch）计算批中每个项目的损失，然后调整权重。该操作会一直重复，直到达到指定的训练次数。
现在我们可以用小批量数据集训练一个指定的次数。在此示例中，降低了训练次数以加速构建。您可以通过调整参数获得更好的结果。
import random
import numpy as np
def train(rnn, training_data, n_epoch = 10, n_batch_size = 64, report_every = 50, learning_rate = 0.2, criterion = nn.NLLLoss()):
"""
Learn on a batch of training_data for a specified number of iterations and reporting thresholds
"""
# Keep track of losses for plotting
current_loss = 0
all_losses = []
rnn.train()
optimizer = torch.optim.SGD(rnn.parameters(), lr=learning_rate)
start = time.time()
print(f"training on data set with n = {len(training_data)}")
for iter in range(1, n_epoch + 1):
rnn.zero_grad() # clear the gradients
# create some minibatches
# we cannot use dataloaders because each of our names is a different length
batches = list(range(len(training_data)))
random.shuffle(batches)
batches = np.array_split(batches, len(batches) //n_batch_size )
for idx, batch in enumerate(batches):
batch_loss = 0
for i in batch: #for each example in this batch
(label_tensor, text_tensor, label, text) = training_data[i]
output = rnn.forward(text_tensor)
loss = criterion(output, label_tensor)
batch_loss += loss
# optimize parameters
batch_loss.backward()
nn.utils.clip_grad_norm_(rnn.parameters(), 3)
optimizer.step()
optimizer.zero_grad()
current_loss += batch_loss.item() / len(batch)
all_losses.append(current_loss / len(batches) )
if iter % report_every == 0:
print(f"{iter} ({iter / n_epoch:.0%}): \t average batch loss = {all_losses[-1]}")
current_loss = 0
return all_losses
We can now train a dataset with minibatches for a specified number of epochs. The number of epochs for this example is reduced to speed up the build. You can get better results with different parameters.
start = time.time()
all_losses = train(rnn, train_set, n_epoch=27, learning_rate=0.15, report_every=5)
end = time.time()
print(f"training took {end-start}s")
绘制结果图¶
从 all_losses 绘制的历史损失显示了网络的学习过程：
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
plt.figure()
plt.plot(all_losses)
plt.show()
评估结果¶
为了查看网络对不同类别的表现，我们将创建一个混淆矩阵，表示每种实际语言（行）与网络猜测的语言（列）。为了计算混淆矩阵，使用 evaluate() 运行一组样本，这与 train() 类似，但不进行反向传播。
def evaluate(rnn, testing_data, classes):
confusion = torch.zeros(len(classes), len(classes))
rnn.eval() #set to eval mode
with torch.no_grad(): # do not record the gradients during eval phase
for i in range(len(testing_data)):
(label_tensor, text_tensor, label, text) = testing_data[i]
output = rnn(text_tensor)
guess, guess_i = label_from_output(output, classes)
label_i = classes.index(label)
confusion[label_i][guess_i] += 1
# Normalize by dividing every row by its sum
for i in range(len(classes)):
denom = confusion[i].sum()
if denom > 0:
confusion[i] = confusion[i] / denom
# Set up plot
fig = plt.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(confusion.cpu().numpy()) #numpy uses cpu here so we need to use a cpu version
fig.colorbar(cax)
# Set up axes
ax.set_xticks(np.arange(len(classes)), labels=classes, rotation=90)
ax.set_yticks(np.arange(len(classes)), labels=classes)
# Force label at every tick
ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
# sphinx_gallery_thumbnail_number = 2
plt.show()
evaluate(rnn, test_set, classes=alldata.labels_uniq)
你可以挑选出偏离主轴的亮点，看看网络在哪些语言上猜错了，例如将韩语误认为是中文，将意大利语误认为是西班牙语。网络在希腊语上的表现非常好，而在英语上的表现则很差（可能是由于与其他语言的重叠）。
练习¶
通过更大或形状更佳的网络获得更好的结果
调整超参数以提升性能，例如改变训练轮数、批量大小和学习率
尝试
nn.LSTM和nn.GRU层修改层的大小，例如增加或减少隐藏节点数量或增加额外的线性层
将多个这些 RNN 组合为高级网络
尝试使用不同的行 -> 标签数据集，例如：
任何单词 -> 语言
名字 -> 性别
角色名称 -> 作家
页面标题 -> 博客或子版块
