目录

一.前言

二.准备数据

三.构造神经网络

四.训练

五.网络采样（预测）

---

一.前言

数据集为18个国家的姓氏，任务是根据训练得到的模型，在给定国家类别和首字母后，能得到一个与该国人名非常相似的一个人名。

> python sample.py Russian RUS
Rovakov
Uantov
Shavakov

> python sample.py German GER
Gerren
Ereng
Rosher

> python sample.py Spanish SPA
Salla
Parer
Allan

> python sample.py Chinese CHI
Chan
Hang
Iun

我们使用只有几层线性层的小型RNN。最大的区别在于，这里是输入一个类别之后在每一时刻 输出一个字母。循环预测字符以形成语言通常也被称为“语言模型”。（也可以将字符换成单词或更高级的结构进行这一过程）

二.准备数据

 测试os函数功能：

import os

filename="data/names\Arabic.txt"
#用于获取指定路径中的基本名称。此方法在内部使用os.path.split()方法将指定路径分为一对(头，尾)。
# os.path.basename()方法将指定的路径拆分为后返回尾部(头，尾)对。
print(os.path.basename(filename))
#将路径的文件名和后缀名分割。其中文件名只是名称。
print(os.path.splitext(os.path.basename(filename)))
print(os.path.splitext(os.path.basename(filename))[0])

输出：

Arabic.txt
('Arabic', '.txt')
Arabic

***************************************************************************************************

数据预处理代码：

点击这里下载数据并将其解压到当前文件夹。

有一些纯文本文件data/names/[Language].txt，它们的每行都有一个名字。 我们按行将文本按行分割得到一个数组，将Unicode编码转化为ASCII编码，最终得到{language: [names ...]}格式存储的字典变量。

dataPreprocessing.py:

from __future__ import unicode_literals, print_function, division
from io import open
import glob
import os
import unicodedata
import string

class DataPreprocessing:
    def __init__(self):
        self.all_letters = string.ascii_letters + " .,;'-"  # 注意还有空格
        print('string.ascii_letters：', string.ascii_letters)  # 大小写的26个字母
        print('all_letters：', self.all_letters)
        self.n_letters = len(self.all_letters) + 1  # Plus EOS marker
        print('总的字符数量：', self.n_letters)

    def findFiles(self,path):
        # glob.glob返回符合匹配条件的所有文件的路径，即路径中可以用正则表达式
        return glob.glob(path)

    # 将Unicode字符串转换为纯ASCII, 感谢https://stackoverflow.com/a/518232/2809427
    def unicodeToAscii(self,s):
        return ''.join(
            c for c in unicodedata.normalize('NFD', s)
            if unicodedata.category(c) != 'Mn'
            and c in self.all_letters
        )

    # 读取文件并分成几行
    def readLines(self,filename):
        # strip()返回删除前导和尾随空格的字符串副本
        lines = open(filename, encoding='utf-8').read().strip().split('\n')
        return [self.unicodeToAscii(line) for line in lines]

    def processing(self):
        # 构建category_lines字典，列表中的每行是一个类别
        category_lines = {}
        all_categories = []
        for filename in self.findFiles('data/names/*.txt'):
            # print(filename) filename是一个路径
            category = os.path.splitext(os.path.basename(filename))[0]
            all_categories.append(category)
            lines = self.readLines(filename)
            category_lines[category] = lines

        n_categories = len(all_categories)

        if n_categories == 0:
            raise RuntimeError('Data not found. Make sure that you downloaded data '
                               'from https://download.pytorch.org/tutorial/data.zip and extract it to '
                               'the current directory.')

        return category_lines,all_categories,n_categories,self.all_letters,self.n_letters;


data=DataPreprocessing()
category_lines,all_categories,n_categories,all_letters,n_letters=data.processing()

# if __name__=='__main__':
#     data=DataPreprocessing()
#     '''
#     返回值一是一个字典，各个类型及其对应的所有名字
#     返回值2是一个列表，所有类型的名字
#     返回值3是类型的数量
#     '''
#     category_lines,all_categories,n_categories=data.processing()
#     print('种类数量：', n_categories, '所有的种类：', all_categories)
#     print("O'Néàl(unicode类型)转换到ASCII类型后为：", data.unicodeToAscii("O'Néàl"))

三.构造神经网络

这个神经网络比上一个RNN教程 中的网络增加了额外的类别张量参数，该参数与其他输入连接在一起。类别可以像字母一样组成 one-hot 向量构成张量输入。

我们将输出作为下一个字母是什么的可能性。采样过程中，当前输出可能性最高的字母作为下一时刻输入字母。

在组合隐藏状态和输出之后我们增加了第二个linear层o2o，使模型的性能更好。当然还有一个dropout层，参考这篇论文随机将输入部分替换为0 给出的参数（dropout=0.1）来模糊处理输入防止过拟合。 我们将它添加到网络的末端，故意添加一些混乱使采样特征增加。

网络结构图：

buildModel.py:

import torch
import torch.nn as nn

#导入数据预处理之后的相关数据
from dataPreprocessing import n_categories

#*********************************** 参考这篇文章的图 https://www.cnblogs.com/lccxqk/p/14622532.html
class RNN(nn.Module):
    # rnn = RNN(n_letters, 128, n_letters)说明有多少字符就有多少种输入情况，也就有多少种输出情况，所以最后需要一个Softmax层进行多元分类
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size
        #其实是两层？只不过i2h和i2o其实可以看做一层，只不过传递的方向不一样
        self.i2h = nn.Linear(n_categories + input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(n_categories + input_size + hidden_size, output_size)
        self.o2o = nn.Linear(hidden_size + output_size, output_size)
        #防止过拟合
        self.dropout = nn.Dropout(0.1)
        #多元分类，# 对列做Softmax，最后得到的每行和为1；dim=0则每列和为1
        self.softmax = nn.LogSoftmax(dim=1)

    # 前向传播，三个参数都是行向量，且前俩是one-hot矩阵
    # 前向传播，三个参数都是行向量，结合这篇文章的前向传播那里的图进行分析 https://hanhan.blog.csdn.net/article/details/128062706
    # hidden就是图中的a,即向右传的激活值，
    # 一个单词的从左往右的所有字母依次进行前向传播，每次前向传播就对应图中的一列
    # 三个线性层其实是两层
    def forward(self, category, input, hidden):
        '''
        运行以下代码查看torch.cat的功能，即把这三个行向量连接起来
        category=torch.zeros(1, 3)
        print(category)
        input=torch.ones(1,2)
        print(input)
        hidden=torch.zeros(1,2)
        print(hidden)
        input_combined = torch.cat((category, input, hidden), 1)
        print(input_combined)
        '''
        input_combined = torch.cat((category, input, hidden), 1)
        #往右传
        hidden = self.i2h(input_combined)
        #往上传
        output = self.i2o(input_combined)
        output_combined = torch.cat((hidden, output), 1)
        output = self.o2o(output_combined)
        output = self.dropout(output)
        output = self.softmax(output)
        return output, hidden

    def initHidden(self):
        #行向量（2维，即一行2列的矩阵）
        return torch.zeros(1, self.hidden_size)

四.训练

myTrain.py:

import random

from torch import nn

from dataPreprocessing import category_lines,all_categories,n_categories,all_letters,n_letters
import torch
from buildModel import RNN

#**********************************************************3.1 训练准备
# 首先，构造一个可以随机获取成对训练数据(category, line)的函数。
# 列表中的随机项
def randomChoice(l):
    #某个类别里的随机的一个名字
    return l[random.randint(0, len(l) - 1)]

# 从所有类别中获取随机类别和该类别对应的一个名
def randomTrainingPair():
    #随机选一个类
    category = randomChoice(all_categories)
    # 上面选定的那个类里随机的一个名
    line = randomChoice(category_lines[category])
    return category, line

'''
对于每个时间步长（即，对于要训练单词中的每个字母），网络的输入将是“（类别，当前字母，隐藏状态）”，输出将是“（下一个字母，
下一个隐藏状态）”。因此，对于每个训练集，我们将需要类别、一组输入字母和一组输出/目标字母。

在每一个时间序列，我们使用当前字母预测下一个字母，所以训练用的字母对来自于一个单词。
例如 对于 "ABCD<EOS>"，我们将创建 (“A”，“B”)，（“B”，“C”），（“C”，“D”），（“D”，“EOS”））。

类别张量是一个<1 x n_categories>尺寸的one-hot张量。训练时，我们在每一个时间序列都将其提供给神经网络。
这是一种选择策略，也可选择将其作为初始隐藏状态的一部分，或者其他什么结构。
'''
# 类别的One-hot张量
def categoryTensor(category):
    #category是类别名，即一个字符串，list.index(元素值)返回对应元素的下标
    li = all_categories.index(category)
    #一行n_categories列的张量（可以看作二维矩阵）
    tensor = torch.zeros(1, n_categories)
    tensor[0][li] = 1
    #返回这个类别对应的one-hot矩阵
    return tensor

# 用于输入的从头到尾字母（不包括EOS）的one-hot矩阵，即单词的one-hot矩阵,即生成输入张量
def inputTensor(line):
    #line是一个单词
    '''
    对于张量而言，行向量其实就是个二维矩阵，所以一个三个元素的行向量就是一行3列的的2维矩阵，如下：
    tensor = torch.zeros(2, 1, 3)
    所以上面这句代码的1和3就代表一个三个元素的行向量就是一行3列的的2维矩阵
    然后那个2意思就是有俩一个三个元素的行向量就是一行3列的的2维矩阵
    综合起来看就像一个2行3列的矩阵一样，但其实是个三维的
    '''
    tensor = torch.zeros(len(line), 1, n_letters)
    #li是单词的每个组成字符对应的下标
    for li in range(len(line)):
        # 单词的每个组成字符
        letter = line[li]
        '''
        虽然是个三维矩阵，但是我们可以当作两维来看，第li行（对应第li个字母），0就对应第li行的那个行向量
        all_letters.find(letter)就代表这一行的这个字符对应的那一列
        '''
        tensor[li][0][all_letters.find(letter)] = 1
    #返回这个单词对应的one-hot矩阵
    return tensor

# 用于目标的第二个结束字母（EOS）的LongTensor,即生成输出张量
'''
下面这个函数的意思就是比如本来的的单词是book（最后还有一个结束符<EOS>没写上，因为单词长度是4），这是输入张量
然后经过下面的这个函数我们得到的目标张量为ook<EOS>，新旧张量的字符一一对应
b  o  o  k
o  o  k <EOS>
'''
def targetTensor(line):
    #all_letters.find(line[li])是字符在所有字符中对应的下标
    letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]
    letter_indexes.append(n_letters - 1) # EOS
    return torch.LongTensor(letter_indexes)

'''
为了方便训练，我们将创建一个randomTrainingExample函数，该函数随机获取（类别，行）的对并将它们转换为所需要的（类别，输入， 目标）格式张量。
'''
# 从随机(类别，行)对中创建类别，输入和目标张量
def randomTrainingExample():
    # 随机获取一个类别和该类别的一个名字
    category, line = randomTrainingPair()
    # 类别的one-hot矩阵
    category_tensor = categoryTensor(category)
    # 输入单词的one-hot矩阵
    input_line_tensor = inputTensor(line)
    # 目标的one-hot矩阵
    target_line_tensor = targetTensor(line)
    return category_tensor, input_line_tensor, target_line_tensor

#****************************************************************3.2 训练神经网络
'''
和只使用最后一个时刻输出的分类任务相比，这次我们每一个时间序列都会进行一次预测，所以每一个时间序列我们都会计算损失。
autograd 的神奇之处在于您可以在每一步中简单地累加这些损失，并在最后反向传播。
'''
#损失函数
criterion = nn.NLLLoss()
#学习率
learning_rate = 0.0005
#我们自己写的RNN模型的实例，n_letters是所有字符个数
rnn = RNN(n_letters, 128, n_letters)

def train(category_tensor, input_line_tensor, target_line_tensor):
    '''
    from dataPreprocessing import all_letters,n_letters

    def targetTensor(line):
        #all_letters.find(line[li])是字符在所有字符中对应的下标
        letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]
        letter_indexes.append(n_letters - 1) # EOS
        return torch.LongTensor(letter_indexes)

    print(targetTensor("apple"))
    print(targetTensor("apple").unsqueeze_(-1))
    '''
    #把上面的代码单独在一个文件执行一下理解.unsqueeze_(-1)在干嘛
    target_line_tensor.unsqueeze_(-1)
    hidden = rnn.initHidden()
    # 梯度清零
    rnn.zero_grad()
    #损失
    loss = 0
    #循环次数就是单词所含的字母个数
    '''
    tensor = torch.zeros(2, 1, 3)
    print(tensor.size(0)) 输出2
    即单词的one-hot矩阵每一行对应一个字母的one-hot
    '''
    for i in range(input_line_tensor.size(0)):
        #前向传播，三个参数都是行向量，结合这篇文章的前向传播那里的图进行分析 https://hanhan.blog.csdn.net/article/details/128062706
        #hidden就是图中的a,所以本次循环用的是上一次循环的hidden，即向右传激活值的过程；input_line_tensor[i]对应图中的x^<i>
        #一个单词的从左往右的所有字母依次进行前向传播，每次前向传播就是图中的一列
        #三个线性层其实是两层
        output, hidden = rnn(category_tensor, input_line_tensor[i], hidden)
        l = criterion(output, target_line_tensor[i])
        loss += l

    #反向传播，计算偏导
    loss.backward()

    #梯度下降
    #权重=权重-学习率*成本函数对此权重的偏导
    #训练过程和以前一样，要说的是这里没有用pytorch自带的优化器，而是用下面循环来参数更新，但是运行时会出现报警（但程序还是可以运行）
    for p in rnn.parameters():
        p.data.add_(-learning_rate, p.grad.data)

    return output, loss.item() / input_line_tensor.size(0)

# 为了跟踪训练耗费的时间，我添加一个timeSince（timestamp）函数，它返回一个人类可读的字符串：
import time
import math

def timeSince(since):
    now = time.time()
    s = now - since
    m = math.floor(s / 60)
    s -= m * 60
    return '%dm %ds' % (m, s)

#***************************************************     待训练完成，模型保存之后，将下列代码注释掉
'''
训练过程和平时一样。多次运行训练，等待几分钟，每print_every次打印当前时间和损失。
在all_losses中保留每plot_every次的平均损失，以便稍后进行绘图。
'''
#迭代十万次
n_iters = 100000
print_every = 5000
plot_every = 500
all_losses = []
total_loss = 0 # Reset every plot_every iters

start = time.time()

for iter in range(1, n_iters + 1):
    #星号的作用是将元组变为一个一个的值
    '''
    def fun():
        return 'a',1,"apple";
    print(fun()) #('a', 1, 'apple')
    print(*fun()) #a 1 apple
    '''
    output, loss = train(*randomTrainingExample())
    total_loss += loss

    if iter % print_every == 0:
        print('%s (%d %d%%) %.4f' % (timeSince(start), iter, iter / n_iters * 100, loss))

    if iter % plot_every == 0:
        #最近plot_every次的平均损失（加入到记录损失的列表）
        all_losses.append(total_loss / plot_every)
        total_loss = 0

#******************************************************* 3.3 损失数据作图
# 从all_losses得到历史损失记录，反映了神经网络的学习情况：
import matplotlib.pyplot as plt

plt.figure()
plt.plot(all_losses)
plt.show()

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

可以看到训练完成之后，相应目录下已经保存了模型的参数文件：

五.网络采样（预测）

我们每次给网络提供一个字母并预测下一个字母是什么，将预测到的字母继续输入，直到得到EOS字符结束循环。

• 用输入类别、起始字母和空隐藏状态创建输入张量。

• 用起始字母构建一个字符串变量 output_name

• 得到最大输出长度，
    * 将当前字母传入神经网络
    * 从前一层得到下一个字母和下一个隐藏状态
    * 如果字母是EOS，在这里停止
    * 如果是一个普通的字母，添加到output_name变量并继续循环

• 返回最终得到的名字单词

另一种策略是，不必给网络一个起始字母，而是在训练中提供一个“字符串开始”的标记，并让网络自己选择起始的字母。

predict.py：

import torch
from myTrain import categoryTensor,inputTensor
from dataPreprocessing import n_letters,all_letters
from buildModel import RNN

#***********************************************************  4.网络采样（即预测）
#我们自己写的RNN模型的实例，n_letters是所有字符个数
rnn = RNN(n_letters, 128, n_letters)
#加载已经训练好的模型参数
rnn.load_state_dict(torch.load('./model/myRNN.pth'))
#eval函数（一定用！！！）的作用请参考 https://blog.csdn.net/lgzlgz3102/article/details/115987271
rnn.eval()

max_length = 20

# 来自类别和首字母的样本
def sample(category, start_letter='A'):
    #表明当前计算不需要反向传播，使用with torch.no_grad()之后，强制后边的内容不进行计算图的构建
    #一般计算网络结果（预测）时，不需要反向传播，所以就就用with torch.no_grad()
    with torch.no_grad():  # no need to track history in sampling
        category_tensor = categoryTensor(category)
        input = inputTensor(start_letter)
        hidden = rnn.initHidden()

        output_name = start_letter

        for i in range(max_length):
            output, hidden = rnn(category_tensor, input[0], hidden)
            topv, topi = output.topk(1)
            if i==0:
                print('topv：',topv)
                print('topi',topi)
            topi = topi[0][0]
            #即topi是<EOS>的下标时，就可以结束了
            if topi == n_letters - 1:
                break
            else:
                letter = all_letters[topi]
                output_name += letter
            #上一个单元预测出的字符作为下一个单元的输入
            input = inputTensor(letter)

        return output_name

# 从一个类别和多个起始字母中获取多个样本
def samples(category, start_letters='ABC'):
    for start_letter in start_letters:
        print(sample(category, start_letter))

samples('Russian', 'RUS')

samples('German', 'GER')

samples('Spanish', 'SPA')

samples('Chinese', 'CHI')

输出：

Rovakov
Uakovakov
Shakovak
Garter
Erenger
Romer
Santer
Parez
Allan
Chang
Han
Iua