备注
点击此处下载完整示例代码
从零开始的自然语言处理：使用字符级 RNN 进行姓名分类
创建于：2025 年 4 月 1 日 | 最后更新：2025 年 4 月 1 日 | 最后验证：2024 年 11 月 5 日
作者：Sean Robertson
本教程是三个部分系列的一部分：
我们将构建和训练一个基本的字符级循环神经网络（RNN）以对单词进行分类。本教程，以及另外两个自然语言处理（NLP）“从零开始”教程《从零开始 NLP：使用字符级 RNN 生成名字》和《从零开始 NLP：使用序列到序列网络和注意力机制进行翻译》，展示了如何对数据进行预处理以用于 NLP 模型。特别是，这些教程展示了如何从底层工作来对 NLP 进行预处理。
字符级 RNN 将单词读取为一系列字符 - 在每个步骤中输出预测和“隐藏状态”，并将其前一个隐藏状态输入到每个下一个步骤中。我们将最终预测视为输出，即单词属于哪个类别。
具体来说，我们将使用来自 18 种不同语言的几千个姓氏进行训练，并基于拼写预测名字的来源语言。
建议的准备工作 ¶
在开始本教程之前，建议您已安装 PyTorch，并具备 Python 编程语言和张量基础知识：
https://maskerprc.github.io/ 安装说明
使用 PyTorch 进行深度学习：60 分钟快速入门，了解 PyTorch 的基本用法和张量基础
通过实例学习 PyTorch，全面深入的了解
PyTorch 面向前 Torch 用户，如果您是前 Lua Torch 用户
了解 RNN 及其工作原理也将很有帮助：
《循环神经网络的不合理有效性》展示了大量真实生活中的例子
理解 LSTM 网络主要关于 LSTM，但也对循环神经网络有一般性的说明
准备火炬 ¶
设置火炬以默认使用正确的设备，根据您的硬件（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 个文本文件，命名为 [Language].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 ...> 。
要形成一个单词，我们将这些向量组合成一个 2D 矩阵 <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 的分割，但@0#有更多有用的工具。这里我们指定了一个生成器，因为我们需要使用
数据集对象允许我们轻松地将数据分为训练集和测试集。这里我们创建了一个 80/20 的分割，但torch.utils.data有更多有用的工具。这里我们指定了一个生成器，因为我们需要使用
与 PyTorch 默认相同的设备。
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)}")
现在我们有一个包含 20074 个示例的基本数据集，每个示例都是一个标签和名称的配对。我们还把数据集分成了训练集和测试集，以便验证我们构建的模型。
创建网络
在 autograd 之前，在 Torch 中创建循环神经网络需要跨多个时间步克隆层的参数。层保留了隐藏状态和梯度，这些现在完全由图本身处理。这意味着你可以以非常“纯粹”的方式实现 RNN，就像常规的前馈层一样。
这个 CharRNN 类实现了具有三个组件的 RNN。首先，我们使用 nn.RNN 实现。接下来，我们定义一个将 RNN 隐藏层映射到我们输出的层。最后，我们应用一个 softmax 函数。使用 nn.RNN 可以显著提高性能，例如使用 cuDNN 加速内核，与将每个层作为 nn.Linear 实现相比。它还简化了 forward() 的实现。
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
然后，我们可以创建一个具有 58 个输入节点、128 个隐藏节点和 18 个输出的 RNN：
n_hidden = 128
rnn = CharRNN(n_letters, n_hidden, len(alldata.labels_uniq))
print(rnn)
之后，我们可以将我们的 Tensor 传递给 RNN 以获得预测输出。随后，我们使用一个辅助函数 label_from_output ，为该类推导出文本标签。
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() 函数，在给定数据集上使用小批量训练模型。循环（ for i in batch ）在调整权重之前计算批处理中每个项目的损失。这个操作会重复进行，直到达到指定的 epoch 数。
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
现在我们可以使用小批量对数据集进行指定 epoch 数的训练。为了加快构建速度，这个示例中的 epoch 数被减少了。你可以通过不同的参数获得更好的结果。
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 组合成一个高级网络
尝试使用不同的数据集，例如：行 -> 标签
任何单词 -> 语言
首字母 -> 性别
角色名 -> 作者
页面标题 -> 博客或 subreddit
脚本总运行时间：（0 分钟 0.000 秒）
