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^{}、隐藏层向量a^{}
        和记忆细胞c^{}$;一个LSTM细胞单元有三个输出,分别是$输出向量y^{}、
        隐藏层向量a^{}和记忆细胞c^{}$
        '''
        # 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"
'''

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146