RNN经典案例-构建人名分类器

• 前言
• Step1 - 数据处理
• Step2 - 定义网络结构
• Step3 - 定义损失函数
• Step4 - 定义优化器
• Step5 - 模型训练
• Step6 - 验证模型效果
• Step7 - 模型保存
• Step8 - 结果展示
• Step9 - 模型加载
• Step10 - 完整代码

前言

• 数据集下载地址：https://download.pytorch.org/tutorial/data.zip

• 本项目以 RNN 实战流程讲解为主，旨在快速入门上手.
• 本项目流程规范为作者个人理解，不做指导性建议，读者可根据个人理解梳理.

Step1 - 数据处理

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

输出结果：

Step2 - 定义网络结构

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

上图中各个参数解释：

• 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)

运行结果：

现在我们使用 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)

运行结果：

从误差图中可以看出，随着训练轮数的增加，模型的每 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')

Step7 - 模型保存

# 模型保存
torch.save(rnn.state_dict(), './model/model_NameClassification.pth')

Step8 - 结果展示

5000 5% (0m 9s) 2.4735 Rivera / names\Japanese ✗ (names\Spanish)
10000 10% (0m 18s) 1.5551 Jiang / names\Chinese ✓
15000 15% (0m 27s) 2.3822 Eagle / names\Spanish ✗ (names\English)
20000 20% (0m 36s) 2.5122 Nitta / names\Czech ✗ (names\Japanese)
25000 25% (0m 44s) 2.6742 Shalhoub / names\Irish ✗ (names\Arabic)
30000 30% (0m 52s) 2.8427 Lennon / names\Scottish ✗ (names\Irish)
35000 35% (1m 1s) 3.0767 Hino / names\Chinese ✗ (names\Japanese)
40000 40% (1m 9s) 3.2493 Jeong / names\German ✗ (names\Korean)
45000 45% (1m 18s) 0.3656 Affini / names\Italian ✓
50000 50% (1m 26s) 2.1092 Vives / names\Portuguese ✗ (names\Spanish)
55000 55% (1m 34s) 3.7014 Macclelland / names\German ✗ (names\Irish)
60000 60% (1m 43s) 1.8525 Senft / names\German ✓
65000 65% (1m 52s) 0.0594 O'Connell / names\Irish ✓
70000 70% (2m 0s) 0.2395 Dinh / names\Vietnamese ✓
75000 75% (2m 9s) 0.2573 Mcgregor / names\Scottish ✓
80000 80% (2m 17s) 0.3321 Quyen / names\Vietnamese ✓
85000 85% (2m 25s) 3.3420 Diderihs / names\Greek ✗ (names\Russian)
90000 90% (2m 33s) 0.3715 Tieu / names\Vietnamese ✓
95000 95% (2m 41s) 2.3140 Gurin / names\German ✗ (names\French)
100000 100% (2m 49s) 3.7298 Fergus / names\French ✗ (names\Irish)

> Shang
(6.12) names\Chinese
(4.44) names\Vietnamese
(4.00) names\Korean

> Jackson
(5.97) names\Scottish
(4.61) names\English
(3.65) names\Dutch

> ZHU
(4.03) names\Chinese
(4.01) names\Korean
(3.08) names\Vietnamese

Shang & Zhu 均是中国姓氏，可见模型预测的效果还可以！

Step9 - 模型加载

# 加载模型
# 首先实例化模型的类对象
# net = Net()
# 加载训练阶段保存好的模型的状态字典
rnn.load_state_dict(torch.load('./model/model_NameClassification.pth'))

# 利用模型对图片进行预测
# outputs = net(images)

# 共有10个类别, 采用模型计算出的概率最大的作为预测的类别
# _, predicted = torch.max(outputs, 1)

# 打印预测标签的结果
# print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
# 模型测试
predict(rnn, 'Shang')
predict(rnn, 'Wang')
predict(rnn, 'ZHU')

> Shang
(6.12) names\Chinese
(4.44) names\Vietnamese
(4.00) names\Korean

> Wang
(4.72) names\Chinese
(4.68) names\Korean
(2.60) names\Scottish

> ZHU
(4.03) names\Chinese
(4.01) names\Korean
(3.08) names\Vietnamese

Step10 - 完整代码

# 人名分类器
from io import open
import glob
import string
import unicodedata
import random
import time
import math
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 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个

all_filenames = glob.glob('./data/names/*.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)

# 将字符转化为 <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'))


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)


# 测试模型
# input = letter_to_tensor('A')
# hidden = rnn.init_hidden()
# output, next_hidden = rnn(input, hidden)
# print('output.size =', output.size())
# print(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


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()


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


def predict(rnn, input_name, n_predictions=3):
    """模型预测"""
    hidden = rnn.init_hidden()
    # name_tensor.size()[0] 名字的长度(字母的数目)
    name_tensor = name_to_tensor(input_name)
    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]))


if __name__ == '__main__':
    # 初始化模型
    rnn = RNN(input_size=57,  # 输入每个字母向量的长度（57个字符）
              hidden_size=128,  # 隐藏层向量的长度，神经元个数。这里可自行调整参数大小
              output_size=18)  # 语言的种类数目
    # 损失函数
    criterion = nn.CrossEntropyLoss()
    # 定义优化器
    learning_rate = 0.005
    optimizer = torch.optim.SGD(rnn.parameters(),  # 给优化器传入rnn网络参数
                                lr=learning_rate)  # 学习率

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

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

    # 训练开始时间点
    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 = 'True' if guess == category else 'False (%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

    # 损失绘图
    plt.figure()
    plt.plot(all_losses)
    plt.show()

    # 预测模型
    predict(rnn, 'Shang')
    predict(rnn, 'Jackson')
    predict(rnn, 'ZHU')

    # 模型保存
    torch.save(rnn.state_dict(), './model/model_NameClassification.pth')
    
    # 加载模型与测试
	# 首先实例化模型的类对象
	# net = Net()
	# 加载训练阶段保存好的模型的状态字典
	rnn.load_state_dict(torch.load('./model/model_NameClassification.pth'))
	
	# 利用模型对图片进行预测
	# outputs = net(images)
	
	# 共有10个类别, 采用模型计算出的概率最大的作为预测的类别
	# _, predicted = torch.max(outputs, 1)
	
	# 打印预测标签的结果
	# print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
	# 模型测试
	predict(rnn, 'Shang')
	predict(rnn, 'Wang')
	predict(rnn, 'ZHU')
	

参考：Link

---

加油!

感谢!

努力!