NLP之TextLSTM(预测单词下一个字母)

LSTM

1.理论

1.1 LSTM与RNN

1.1.1 RNN的缺点

如果训练非常深的神经网络,对这个网络做从左到右的前向传播和而从右到左的后向传播,会发现输出$y^{<t>}$很难传播回去,很难影响前面的权重,这样的梯度消失问题使得RNN常常出现局部效应,不擅长处理长期依赖的问题
和梯度爆炸不同的是,梯度爆炸会使得参数爆炸,很容易就发现大量的NaN参数,因此可以很快地进行梯度修剪;但是梯度消失不仅难以察觉,而且很难改正

1.1.2 LSTM

LSTM(还有GRU)改变了RNN的隐藏层,使其可以更好地捕捉深层链接,改善梯度消失的问题

1.2 LSTM基本结构

2.实验

2.1 实验步骤

1. 数据预处理,得到字典、样本数等基本数据
2. 构建LSTM模型,设置输入模型的嵌入向量维度,隐藏层α向量和记忆细胞c的维度
3. 训练
   1. 代入数据,设置每个样本的时间步长度
   2. 得到模型输出值,取其中最大值的索引,找到字典中对应的字母,即为模型预测的下一个字母.
   3. 把模型输出值和真实值相比,求得误差损失函数,运用Adam动量法梯度下降
4. 测试

2.2 算法模型

• 一个LSTM细胞单元有三个输入,分别是输入向量$x^{<t>}$、隐藏层向量$a^{<t-1>}$和记忆细胞$c^{<t-1>}$;
• 一个LSTM细胞单元有三个输出,分别是输出向量$y^{<t>}$、隐藏层向量$a^{<t>}$和记忆细胞$c^{<t>}$
• 本实验时间步长度n=3,即使用了三个LSTM细胞单元
  

"""
Task: 基于TextLSTM的单词字母预测
Author: ChengJunkai @github.com/Cheng0829
Email: chengjunkai829@gmail.com
Date: 2022/09/09
Reference: Tae Hwan Jung(Jeff Jung) @graykode
"""

import numpy as np
import torch, os, sys, time
import torch.nn as nn
import torch.optim as optim

'''1.数据预处理'''
def pre_process(seq_data):
    char_arr = [c for c in 'abcdefghijklmnopqrstuvwxyz']
    word_dict = {n:i for i, n in enumerate(char_arr)}
    number_dict = {i:w for i, w in enumerate(char_arr)}
    # 字母类别数:26,即嵌入向量维度
    n_class = len(word_dict)  # number of class(=number of vocab)
    return char_arr, word_dict, number_dict, n_class

'''根据句子数据,构建词元的嵌入向量及目标词索引'''
def make_batch(seq_data):
    input_batch, target_batch = [], []
    # 每个样本单词
    for seq in seq_data: 
        # e.g. input : ['m','a','k'] -> [num1, num2, num3]
        input = [word_dict[n] for n in seq[:-1]] 
        target = word_dict[seq[-1]] # e.g. 'e' is target
        input_batch.append(np.eye(n_class)[input])
        target_batch.append(target)
    '''input_batch : [batch_size(样本数), n_step(样本单词数), n_class] -> [10, 3, 26]'''
    input_batch = torch.FloatTensor(np.array(input_batch)) 
    # print(input_batch.shape)
    target_batch = torch.LongTensor(np.array(target_batch))
    input_batch = input_batch.to(device)
    target_batch = target_batch.to(device)
    return input_batch, target_batch

'''2.构建模型:LSTM(本实验结构图详见笔记)'''
class TextLSTM(nn.Module):
    def __init__(self):
        super().__init__()
        # n_class是字母类别数(26),即嵌入向量维度
        self.lstm = nn.LSTM(input_size=n_class, hidden_size=hidden_size)
        self.W = nn.Linear(hidden_size, n_class, bias=False)
        self.b = nn.Parameter(torch.ones([n_class]))

    '''每个样本输入的单词数和模型的时间步长度相等'''
    def forward(self, X):
        # X : [batch_size, n_step, n_class] [10, 3, 26] 
        # input : [n_step, batch_size, n_class] [3, 10, 26]
        # input : [输入序列长度(时间步长度),样本数,嵌入向量维度]
        '''transpose转置: [10, 3, 26] -> [3, 10, 26]'''
        input = X.transpose(0, 1)
        # hidden_state:[num_layers*num_directions, batch_size, hidden_size]
        # hidden_state:[层数*网络方向,样本数,隐藏层的维度(隐藏层神经元个数)]
        hidden_state = torch.zeros(1, len(X), hidden_size)  
        hidden_state = hidden_state.to(device)
        # cell_state:[num_layers*num_directions, batch_size, hidden_size]
        # cell_state:[层数*网络方向,样本数,隐藏层的维度(隐藏层神经元个数)]
        cell_state = torch.zeros(1, len(X), hidden_size)     
        cell_state = cell_state.to(device)
        '''
        一个LSTM细胞单元有三个输入,分别是$输入向量x^{<t>}、隐藏层向量a^{<t-1>}
        和记忆细胞c^{<t-1>}$;一个LSTM细胞单元有三个输出,分别是$输出向量y^{<t>}、
        隐藏层向量a^{<t>}和记忆细胞c^{<t>}$
        '''
        # outputs:[3,10,128] final_hidden_state:[1,10,128] final_cell_state:[1,10,128])
        outputs, (final_hidden_state, final_cell_state) = self.lstm(input, (hidden_state, cell_state))
        outputs = outputs.to(device)
        '''取最后一个单元的隐藏层激活状态输出值'''
        '''既可以用outputs[-1],也可以用final_hidden_state[0]'''
        final_output = outputs[-1]  # [batch_size, hidden_size]
        Y_t = self.W(final_output) + self.b  # Y_t : [batch_size, n_class]
        return Y_t


if __name__ == '__main__':
    hidden_size = 128 # number of hidden units in one cell
    device = ['cuda:0' if torch.cuda.is_available() else 'cpu'][0]
    seq_data = ['make', 'need', 'coal', 'word', 'love', 'hate', 'live', 'home', 'hash', 'star']

    '''1.数据预处理'''
    char_arr, word_dict, number_dict, n_class = pre_process(seq_data)
    input_batch, target_batch = make_batch(seq_data)

    '''2.构建模型'''
    model = TextLSTM()
    model.to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    if os.path.exists('model_param.pt') == True:
        # 加载模型参数到模型结构
        model.load_state_dict(torch.load('model_param.pt', map_location=device))

    '''3.训练'''
    print('{}\nTrain\n{}'.format('*'*30, '*'*30))
    loss_record = []
    for epoch in range(1000):
        optimizer.zero_grad()
        # X : [batch_size, n_step, n_class]
        output = model(input_batch)
        output = output.to(device)
        loss = criterion(output, target_batch)
        loss.backward()
        optimizer.step()    
        if loss >= 0.001: # 连续30轮loss小于0.01则提前结束训练
            loss_record = []
        else:
            loss_record.append(loss.item())
            if len(loss_record) == 30:
                torch.save(model.state_dict(), 'model_param.pt')
                break    

        if ((epoch+1) % 100 == 0):
            print('Epoch:', '%04d' % (epoch + 1), 'Loss = {:.6f}'.format(loss))
            torch.save(model.state_dict(), 'model_param.pt')

    '''4.预测'''
    print('{}\nTest\n{}'.format('*'*30, '*'*30))
    inputs = ['mak','ma','look'] # make look
    for input in inputs: # 每个样本逐次预测,避免长度不同
        input_batch, target_batch = make_batch([input])
        predict = model(input_batch).data.max(1, keepdim=True)[1]
        print(input + ' -> ' + input + number_dict[predict.item()])

'''
为什么训练集输入字母数都是3,但是测试集可以不是?
make_batch的input_batch维度是[batch_size(样本数), n_step(样本单词数),n_class(26)]
n_step是输入序列长度,之前疑惑为什么只有3个lstm单元,却可以输入其他个数的字母?

    实际上,模型并没有把时间步作为一个超参数,也就是时间步随输入样本而变化,在训练集中,n_step均为3,
    但是,在测试集中,三个单词都是分别作为样本集输入的,也就是时间步分别为3,2,4,
    最后在self.lstm(input, (hidden_state, cell_state))中,模型会自动根据input的序列长度,分配时间步
    
    但由于是一次性输入一个样本集,所以样本集中各个样本长度必须一致,否则报错
    因此必须把预测的inputs中各个单词分别放进容量为1的样本集单独输入

    需要指出的是,由于模型训练的是根据3个字母找到最后以1个字母,
    所以如果长度不匹配,即使单词在训练集中,
    也不能取得好的结果,比如"ma"的预测结果并不一定是训练集中的"mak"
'''