0
0

自然语言处理系列（二）——使用RNN搭建字符级语言模型

目录

一、任务背景

本文的任务主要来源于PyTorch的官方教程，即给定各国人名的数据集，你需要训练出一个RNN，它能够根据输入的人名来判断这个人来自哪个国家（分类任务）。

数据集是一个 

  1. names

文件夹，里面包含了 

  1.     18
  2.    
  3.   
  4.   
  5.    18
  6.   
  7.  
  8. 18 个文本文档，均以 
  1. [Language].txt

命名。每个文本文档中，每一行都是该语种下的一个（常见）人名。

需要注意的是，官方给的数据集疑似存在错误（爬虫没爬干净） ，在 

  1. Russian.txt

文件中，第 

  1.     7941
  2.    
  3.    
  4.     ∼
  5.    
  6.    
  7.     7964
  8.    
  9.   
  10.   
  11.    7941\sim7964
  12.   
  13.  
  14. 7941∼7964 行出现了 
  1. To The First Page

字样，很显然这不是一个人名。此外，第 

  1.     4395
  2.    
  3.    
  4.     ,
  5.    
  6.    
  7.     5236
  8.    
  9.    
  10.     ,
  11.    
  12.    
  13.     5255
  14.    
  15.   
  16.   
  17.    4395,5236,5255
  18.   
  19.  
  20. 4395,5236,5255 行的人名均以 
  1. ,

结尾（我想俄罗斯人的名字应该不会以逗号结尾吧？）。

博主已经帮大家修正了这个数据集，下载地址（所需积分0）。

不同于官方教程，在本篇文章中，博主会根据自己的理解重构代码，使其变得通俗易懂。

二、数据预处理

首先，我们需要构造一个字典，它的格式为：

  1. {language: [names ...]}

。

因为人名均由Unicode字符组成，我们需要先将其转化为ASCII字符：

  1. import unicodedata
  2. import string
  4. # 转化后的人名由大小写字母和空格字符，单引号字符组成
  5. all_letters = string.ascii_letters +" '"defunicodeToAscii(s):return''.join(c for c in unicodedata.normalize('NFD', s)if unicodedata.category(c)!='Mn'and c in all_letters)print(unicodeToAscii('Ślusàrski'))# Slusarski

构造字典：

  1. import os
  3. filenames = os.listdir('names')
  4. data =dict()for filename in filenames:# 注意需要以utf-8格式打开withopen(f'names/{filename}', encoding='utf-8')as f:# 需要去掉filename中的.txt后缀
  5.         data[filename[:-4]]=[unicodeToAscii(name)for name in f.readlines()]
  7. all_categories =list(data.keys())print(all_categories)# ['Arabic', 'Chinese', 'Czech', 'Dutch', 'English', 'French', 'German', 'Greek', 'Irish', 'Italian', 'Japanese', 'Korean', 'Polish', 'Portuguese', 'Russian', 'Scottish', 'Spanish', 'Vietnamese']print(data['Arabic'][:6])# ['Khoury', 'Nahas', 'Daher', 'Gerges', 'Nazari', 'Maalouf']

从下面的输出结果可以看出，数据集一共有 18 类，并且每一类中的数据个数也都不同：

  1. print(len(all_categories))# 18print([len(data[category])for category in all_categories])# [2000, 268, 519, 297, 3668, 277, 724, 203, 232, 709, 991, 94, 139, 74, 9384, 100, 298, 73]

神经网络无法直接处理字母，因此我们需要先将字母转化成对应的 One-Hot 向量：

  1. import torch
  2. import torch.nn.functional as F
  4. defletterToTensor(letter):# 获取letter在all_letters中的索引
  5.     letter_idx = torch.tensor(all_letters.index(letter))return F.one_hot(letter_idx, num_classes=len(all_letters))
  7. r = letterToTensor("c")print(r)# tensor([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,#         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,#         0, 0, 0, 0, 0, 0])

向量长度为 54，这是因为有26个小写字母+26个大写字母+空格字符+单引号字符。

接下来我们需要将完整的单词（人名）编码成张量。单词中的每一个字母代表一个时间步，因此一个完整的单词可以看作是一个序列。由于单词的长度各不相同，因此我们把一个单词看作一个 batch，从而单词应是形状为 

  1. (sequence_length, batch_size, features) = (sequence_length, 1, 54)

的张量。

  1. defnameToTensor(name):
  2.     result = torch.zeros(len(name),len(all_letters))for i inrange(len(name)):
  3.         result[i]= letterToTensor(name[i])return result.unsqueeze(1)print(nameToTensor('ab'))# tensor([[[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,#           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,#           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,#           0., 0., 0.]],# #         [[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,#           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,#           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,#           0., 0., 0.]]])print(nameToTensor('abcd').size())# torch.Size([4, 1, 54])

因为我们已经将一个单词视为了一个batch，所以不再使用DataLoader去构造迭代器，而是采用随机采样的方法去抽取数据进行训练。

三、模型搭建与训练

我们使用PyTorch中的 

  1. nn.RNN

模块来搭建单隐层单向RNN：

  1. import torch.nn as nn
  3. classRNN(nn.Module):def__init__(self):super().__init__()
  4.         self.rnn = nn.RNN(
  5.             input_size=54,# 128是随便选的，也可以选择其他数值
  6.             hidden_size=128,)# 18分类任务，所以最后一层有18个神经元
  7.         self.out = nn.Linear(128,18)defforward(self, x):# None代表全零初始化隐状态
  8.         output, h_n = self.rnn(x,None)# output[-1]是最后时刻输出的隐状态，等同于h_n[0]return self.out(output[-1])

考虑到不同类别的样本个数不同（相差较大），并且我们已经将一个单词视为了一个batch，因此使用DataLoader会显得较为困难。这里保持和官方教程一样的做法，即每次随机从数据集 

  1. data

中抽取一个 

  1. category

，再从 

  1. category

中随机抽取一个 

  1. name

投喂到RNN中。

  1. import random
  3. defrandom_sample():
  4.     category = random.choice(all_categories)
  5.     name = random.choice(data[category])return category, name
  7. print(random_sample())# ('Irish', "O'Kane")

我们选择在GPU上进行训练，选择交叉熵损失和SGD优化器：

  1. LR =1e-3# 学习率
  2. N_ITERS =10**5# 训练多少个iteration
  4. device ='cuda'if torch.cuda.is_available()else'cpu'
  5. rnn = RNN()
  6. rnn.to(device)
  8. criterion = nn.CrossEntropyLoss()
  9. optimizer = torch.optim.SGD(rnn.parameters(), lr=LR, momentum=0.9)
  10. train_loss =[]deftrain(model, criterion, optimizer):
  11.     model.train()
  12.     avg_loss =0for iteration inrange(N_ITERS):
  13.         category, name = random_sample()# 将name转化成数字
  14.         X = nameToTensor(name).to(device)# 因为output的形状是(1,18)，所以target的形状必须为(1,)而非标量
  15.         target = torch.tensor([all_categories.index(category)]).to(device)# 正向传播
  16.         output = model(X)
  17.         loss = criterion(output, target)
  18.         avg_loss += loss
  20.         # 反向传播
  21.         optimizer.zero_grad()
  22.         loss.backward()
  23.         optimizer.step()# 每隔1000个iteration输出一次平均loss并保存if(iteration +1)%1000==0:
  24.             avg_loss /=1000
  25.             train_loss.append(avg_loss.item())print(f"Iteration: [{iteration +1}/{N_ITERS}] | Train Loss: {avg_loss:.4f}")
  26.             avg_loss =0

训练完成后，绘制损失函数的曲线：

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  4. plt.plot(np.arange(1, N_ITERS +1,1000), train_loss)
  5. plt.ylabel('Train Loss')
  6. plt.xlabel('Iteration')
  7. plt.show()

为了保证结果的可复现性，我们需要设置全局种子：

  1. defsetup_seed(seed):
  2.     random.seed(seed)# 为random库设置种子
  3.     np.random.seed(seed)# 为numpy库设置种子
  4.     torch.manual_seed(seed)# 为Pytorch-CPU设置种子
  5.     torch.cuda.manual_seed(seed)# 为当前GPU设置种子
  6.     torch.cuda.manual_seed_all(seed)# 为所有GPU设置种子

设置种子为 42，损失曲线变化图如下：

在这里插入图片描述

从上图可以看出，模型损失在第 

  1.     70000
  2.    
  3.   
  4.   
  5.    70000
  6.   
  7.  
  8. 70000 个 iteration 左右时达到了最小。不过这里为了方便起见，我们采用最后得到的模型用来测试。

四、模型测试

在训练过程中，我们一共训练了 

  1.     100000
  2.    
  3.   
  4.   
  5.    100000
  6.   
  7.  
  8. 100000 个 Iteration，每个 Iteration 中只有一个样本。在测试阶段，我们随机抽取 
  10.  
  11.   
  12.    
  13.     10000
  14.    
  15.   
  16.   
  17.    10000
  18.   
  19.  
  20. 10000 个样本来绘制混淆矩阵：
  1. from sklearn.metrics import ConfusionMatrixDisplay
  3. deftest(model):
  4.     model.eval()
  5.     y_true, y_pred =[],[]for _ inrange(10000):
  6.         category, name = random_sample()# 获取该样本的真实标签对应的下标
  7.         true_idx = all_categories.index(category)
  8.         y_true.append(true_idx)# 获取预测标签对应的下标
  9.         X = nameToTensor(name).to(device)
  10.         output = model(X)
  11.         y_pred.append(output.argmax().item())# 绘制混淆矩阵
  12.     ConfusionMatrixDisplay.from_predictions(y_true,
  13.                                             y_pred,
  14.                                             labels=np.arange(18),
  15.                                             display_labels=all_categories,
  16.                                             xticks_rotation='vertical',
  17.                                             normalize='true',
  18.                                             include_values=False)
  19.     plt.show()

最终结果：

在这里插入图片描述

从混淆矩阵的结果可以看出：

  • Korean 容易被误判成 Chinese，Czech 容易被误判成 Polish，German 容易被误判成 Dutch；
  • English、German、Czech 不容易被识别.

附录：完整代码

运行环境：

  • 系统：Ubuntu 20.04
  • GPU：RTX 3090
  • PyTorch版本：1.10
  • Python版本：3.8
  • Cuda：11.3

需要注意的是，在 Linux 系统中，

  1. os.listdir()

的返回结果与 Windows 系统不同，因此即使随机种子相同，也有可能产生不同的实验结果。

  1. import os
  2. import string
  3. import random
  4. import unicodedata
  6. import torch
  7. import torch.nn as nn
  8. import torch.nn.functional as F
  10. import numpy as np
  11. import matplotlib.pyplot as plt
  12. from sklearn.metrics import ConfusionMatrixDisplay
  14. classRNN(nn.Module):def__init__(self):super().__init__()
  15.         self.rnn = nn.RNN(input_size=54, hidden_size=128)
  16.         self.out = nn.Linear(128,18)defforward(self, x):
  17.         output, h_n = self.rnn(x,None)return self.out(output[-1])defunicodeToAscii(s):return''.join(c for c in unicodedata.normalize('NFD', s)if unicodedata.category(c)!='Mn'and c in all_letters)defletterToTensor(letter):
  18.     letter_idx = torch.tensor(all_letters.index(letter))return F.one_hot(letter_idx, num_classes=len(all_letters))defnameToTensor(name):
  19.     result = torch.zeros(len(name),len(all_letters))for i inrange(len(name)):
  20.         result[i]= letterToTensor(name[i])return result.unsqueeze(1)defrandom_sample():
  21.     category = random.choice(all_categories)
  22.     name = random.choice(data[category])return category, name
  24. deftrain(model, critertion, optimizer):
  25.     model.train()
  26.     avg_loss =0for iteration inrange(N_ITERS):
  27.         category, name = random_sample()
  28.         X = nameToTensor(name).to(device)
  29.         target = torch.tensor([all_categories.index(category)]).to(device)
  31.         output = model(X)
  32.         loss = criterion(output, target)
  33.         avg_loss += loss
  35.         optimizer.zero_grad()
  36.         loss.backward()
  37.         optimizer.step()if(iteration +1)%1000==0:
  38.             avg_loss /=1000
  39.             train_loss.append(avg_loss.item())print(f"Iteration: [{iteration +1}/{N_ITERS}] | Train Loss: {avg_loss:.4f}")
  40.             avg_loss =0deftest(model):
  41.     model.eval()
  42.     y_true, y_pred =[],[]for _ inrange(10000):
  43.         category, name = random_sample()
  45.         true_idx = all_categories.index(category)
  46.         y_true.append(true_idx)
  48.         X = nameToTensor(name).to(device)
  49.         output = model(X)
  50.         y_pred.append(output.argmax().item())
  52.     ConfusionMatrixDisplay.from_predictions(y_true,
  53.                                             y_pred,
  54.                                             labels=np.arange(18),
  55.                                             display_labels=all_categories,
  56.                                             xticks_rotation='vertical',
  57.                                             normalize='true',
  58.                                             include_values=False)
  59.     plt.show()defsetup_seed(seed):
  60.     random.seed(seed)
  61.     np.random.seed(seed)
  62.     torch.manual_seed(seed)
  63.     torch.cuda.manual_seed(seed)
  64.     torch.cuda.manual_seed_all(seed)""" Data preprocessing """
  66. all_letters = string.ascii_letters +" '"
  67. filenames = os.listdir('names')
  68. data =dict()for filename in filenames:withopen(f'names/{filename}', encoding='utf-8')as f:
  69.         data[filename[:-4]]=[unicodeToAscii(name)for name in f.readlines()]
  71. all_categories =list(data.keys())""" Model building and training """
  73. setup_seed(42)
  75. LR =1e-3
  76. N_ITERS =10**5
  78. device ='cuda'if torch.cuda.is_available()else'cpu'
  79. rnn = RNN()
  80. rnn.to(device)
  82. criterion = nn.CrossEntropyLoss()
  83. optimizer = torch.optim.SGD(rnn.parameters(), lr=LR, momentum=0.9)
  84. train_loss =[]
  86. train(rnn, criterion, optimizer)
  88. plt.plot(np.arange(1, N_ITERS +1,1000), train_loss)
  89. plt.ylabel('Train Loss')
  90. plt.xlabel('Iteration')
  91. plt.show()""" Testing """
  93. test(rnn)

如果这篇文章有帮助到你还请麻烦你点一个免费的赞，这将是我创作的最大动力！

标签： rnn 自然语言处理 语言模型
本文转载自: https://blog.csdn.net/raelum/article/details/125381732
版权归原作者 raelum 所有， 如有侵权，请联系我们删除。
登录后发布评论

“自然语言处理系列（二）——使用RNN搭建字符级语言模型”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？