RNN实战-姓名分类

• 数据集下载地址：https://download.pytorch.org/tutorial/data.zip
• 本项目以 RNN 实战流程讲解为主，旨在快速入门上手.
• 本项目流程规范为作者个人理解，不做指导性建议，读者可根据个人理解梳理.

Step1-数据处理

• 在 names 文件夹中有 18个 txt 文件，且都是以某种语言名 .txt 命名。 每个 txt 文件中含有很多姓氏名，每个姓氏名独占一行，有些语言使用的是 Unicode 码（含有除了26 英文字母以外的其他字符），我们需要将其统一成 ASCII 码。
• 将Unicode码转换成标准的 ASCII 码 http://stackoverflow.com/a/518232/2809427

# string.ascii_letters 是大小写各26字母
all_letters = string.ascii_letters + " .,;'"
# 字符的种类数
n_letters = len(all_letters)

# 将Unicode码转换成标准的ASCII码 
def unicode_to_ascii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.category(c) != 'Mn'
        and c in all_letters
    )
print(n_letters) # 字符数为57个

• 构建语言类别-姓名映射字典，如：{language1: [name1, name2, ...], language2: [name1, name2, ...],}

all_filenames = glob.glob('data/*.txt')
category_names = {}
# 所有类别
all_categories = []
# 读取txt文件，返回 ascii 码的姓名 列表
def readNames(filename):
    names = open(filename).read().strip().split('\n')
    return [unicode_to_ascii(name) for name in names]

for filename in all_filenames:
    category = filename.split('/')[-1].split('.')[0]
    all_categories.append(category)
    names = readNames(filename)
    category_names[category] = names
# 语言种类数
n_categories = len(all_categories)
print('n_categories =', n_categories) 

• 将姓名转化为 Tensors 。为了表征单个的字符， 我们使用独热编码向量 one-hot vector， 该向量的尺寸为 1 * n_letters（每个字符是 2 维向量）。每个由多个字符(每个字符是 2 维)组成的姓名 转化为3维，尺寸为 name_length * 1 * n_letters。

# 将字符转化为 <1 *  n_letters> 的 Tensor
def letter_to_tensor(letter):
    tensor = torch.zeros(1, n_letters)
    letter_index = all_letters.find(letter)
    tensor[0][letter_index] = 1
    return tensor

# 将姓名转化成尺寸为<name_length * 1 * n_letters>的数据
# 使用的是 one-hot 编码方式转化
def name_to_tensor(name):
    tensor = torch.zeros(len(name), 1, n_letters)
    for ni, letter in enumerate(name):
        letter_index = all_letters.find(letter)
        tensor[ni][0][letter_index] = 1
    return tensor

print(letter_to_tensor('J'))
print(name_to_tensor('Jones'))

输出结果：

image.png

Step2 - 定义网络结构

定义网络结构之前我们需要先了解 RNN 的网络结构

image.png

上图中各个参数解释：

• input: 输入的数据
• hidden: 神经网络现有的参数矩阵
• combined： input 矩阵与 hidden 矩阵合并，两个矩阵的行数一致，input 和 hidden 分别位于新矩阵的左侧和右侧
• 12h：将输入的数据转化为 hidden 参数的计算过程
• i2o：对输入的数据转化为 output 的计算过程
• hidden：当前网络传递给下层网络的参数
• output：当前网络的输出

结合到我们的项目中，我们可以定义自己的 RNN :

• input: 字母的向量的特征数量（向量长度）57
• hidden: 隐藏层特征数量（列数）
• output_size: 语言数目，18
• i2h: 隐藏网络参数的计算过程。输入的数据尺寸为 input_size + hidden_size , 输出的尺寸为 hidden_size.
• i2o: 输出网络参数的计算过程。输入的数据尺寸为 input_size + hidden_size, 输出的尺寸为 output_size.

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

    def forward(self, input, hidden):
        #将input和之前的网络中的隐藏层参数合并。
        combined = torch.cat((input, hidden), 1)
        hidden = self.i2h(combined) #计算隐藏层参数
        output = self.i2o(combined) #计算网络输出的结果
        return output, hidden 

    def init_hidden(self):
        #初始化隐藏层参数hidden
        return torch.zeros(1, self.hidden_size)

• 测试我们定义好的网络

rnn = RNN(input_size=57,  #输入每个字母向量的长度（57个字符）
          hidden_size=128, #隐藏层向量的长度，神经元个数。这里可自行调整参数大小
          output_size=18)  #语言的种类数目

input = letter_to_tensor('A')
hidden = rnn.init_hidden()
output, next_hidden = rnn(input, hidden)
print('output.size =', output.size())
print(output)

运行结果：

image.png

• 现在我们使用 name_to_tensor 替换 letter_to_tensor 来构造输入的数据。注意在上面的例子中，给 RNN 网络一次输入一个姓名数据，但对该网络而言，是将姓名数据拆分成字母数组数据，逐次输入训练网络，直到这个姓名最后一个字母数组输入完成，才输出真正的预测结果（姓名所属的语言类别）。这里输入 RNN 神经网络的数据的粒度变细，不再是姓名数组数据（三维），而是组成姓名的字母的数组或矩阵（二维）。

• 准备训练 RNN 在训练前，我们把求所属语言类别的索引值方法封装成函数category_from_output。该函数输入: output ( RNN 网络输出的 output )。该函数输出：语言类别、语言类别索引值。

def category_from_output(output):
    _, top_i = output.data.topk(1) 
    category_i = top_i[0][0]
    return all_categories[category_i], category_i

category_from_output(output)

Step3 - 定义损失函数

criterion = nn.CrossEntropyLoss()

Step4 - 定义优化器

learning_rate = 0.005 
optimizer = torch.optim.SGD(rnn.parameters(),  #给优化器传入rnn网络参数
                            lr=learning_rate) #学习率

Step5 - 模型训练

每轮训练:

• 创建 input（name_tensor）和 input 对应的语言类别标签(category_tensor)
• 当输入姓名第一个字母时，需要初始化隐藏层参数。
• 读取姓名中的每个字母的数组信息，传入 rnn,并将网络输出的 hidden_state 和下一个字母数组信息传入之后的 RNN 网络中.
• 使用 criterion 比对 最终输出结果 与 姓名真实所属的语言标签 作比较
• 更新网络参数.

循环往复以上几步

def random_training_pair():   
    # 随机抽取了一种语言                                                                                                            
    category = random.choice(all_categories)
    # 在该语言中抽取一个姓名 
    name = random.choice(category_names[category])
    # 由于pytorch中训练过程中使用的都是tensor结构数据，其中的元素都是浮点型数值，所以这里我们使用LongTensor， 可以保证标签是整数。
    # 另外要注意的是，pytorch中运算的数据都是batch。所以我们要将所属语言的索引值放入一个list中，再将该list传入torch.LongTensor()中
    category_tensor = torch.LongTensor([all_categories.index(category)])
    name_tensor = name_to_tensor(name)
    return category, name, category_tensor, name_tensor


def train(category_tensor, name_tensor):
    rnn.zero_grad() #将rnn网络梯度清零
    hidden = rnn.init_hidden() #只对姓名的第一字母构建起hidden参数

    #对姓名的每一个字母逐次学习规律。每次循环的得到的hidden参数传入下次rnn网络中
    for i in range(name_tensor.size()[0]):
        output, hidden = rnn(name_tensor[i], hidden)

    #比较最终输出结果与 该姓名真实所属语言，计算训练误差
    loss = criterion(output, category_tensor)

    #将比较后的结果反向传播给整个网络
    loss.backward()

    #调整网络参数。有则改之无则加勉
    optimizer.step()

    #返回预测结果  和 训练误差
    return output, loss.item()

Step6 - 验证模型效果

• 现在我们可以使用一大堆姓名和语言数据来训练 RNN 网络，因为 train 函数会同时返回预测结果和训练误差， 我们可以打印并可视化这些信息。为了方便，我们每训练 5000 次（5000 个姓名），就打印一个姓名的预测结果，并查看该姓名是否预测正确。我们对每 1000 次的训练累计误差，最终将误差可视化出来。

import time
import math

n_epochs = 100000  # 训练100000次（可重复的从数据集中抽取100000姓名）
print_every = 5000 #每训练5000次，打印一次
plot_every = 1000  #每训练1000次，计算一次训练平均误差

current_loss = 0 #初始误差为0
all_losses = [] #记录平均误差

def time_since(since):
    #计算训练使用的时间
    now = time.time()
    s = now - since
    m = math.floor(s / 60)
    s -= m * 60
    return '%dm %ds' % (m, s)

#训练开始时间点
start = time.time()

for epoch in range(1, n_epochs + 1):
    # 随机的获取训练数据name和对应的language
    category, name, category_tensor, name_tensor = random_training_pair()
    output, loss = train(category_tensor, name_tensor)
    current_loss += loss

    #每训练5000次，预测一个姓名，并打印预测情况
    if epoch % print_every == 0:
        guess, guess_i = category_from_output(output)
        correct = '✓' if guess == category else '✗ (%s)' % category
        print('%d %d%% (%s) %.4f %s / %s %s' % (epoch, epoch / n_epochs * 100, time_since(start), loss, name, guess, correct))

    # 每训练5000次，计算一个训练平均误差，方便后面可视化误差曲线图
    if epoch % plot_every == 0:
        all_losses.append(current_loss / plot_every)
        current_loss = 0

• 绘制训练误差

import matplotlib.pyplot as plt
%matplotlib inline

plt.figure()
plt.plot(all_losses)

运行结果：

image.png image.png

从误差图中可以看出，随着训练轮数的增加，模型的每 1000 次训练的平均误差越来越小。

当然我们也可以手动调用模型，查看模型输出结果：

def predict(rnn, input_name, n_predictions=3):
    hidden = rnn.init_hidden()
    #name_tensor.size()[0] 名字的长度(字母的数目)
    for i in range(name_tensor.size()[0]):
        output, hidden = rnn(name_tensor[i], hidden)
    print('\n> %s' % input_name)

    # 得到该姓名预测结果中似然值中前n_predictions大的 似然值和所属语言
    topv, topi = output.data.topk(n_predictions, 1, True)
    for i in range(n_predictions):
        value = topv[0][i]
        category_index = topi[0][i]
        print('(%.2f) %s' % (value, all_categories[category_index]))

predict(rnn, 'Dovesky')
predict(rnn, 'Jackson')
predict(rnn, 'Satoshi')

• 文中具体代码细节，后续不定时补充