NLP之TextRNN(预测下一个单词)

TextRNN

1.基本概念

1.1 RNN和CNN的区别

并非刚性地记忆所有固定⻓度的序列，⽽是通过隐藏状态来存储之前时间步的信息

1.2 RNN的几种结构

一对一,一对多,多对一,多对多(长度相等/不等)

多个输入时,由a和x生成y和下一个a, 这一过程可以用nn.GRU和nn.LSTM模块表示,即可使用门控制单元或长短记忆模型,因此BiLSTM也可看作BiRNN+LSTM(编程时,双向和单向的不同就是在nn.LSTM()中添加一个bidirectional=True)

1.3 多对多的RNN

先输入零向量$a^{<0>}$,然后前向传播,先计算激活值$a^{<1>}$,然后计算$y^{<1>}$.

$a^{<1>}=g_1(W_{aa}{a}^{<0>}+W_{ax}{x}^{<1>}+b_a)$

$y^{<1>}=g_2(W_{ya}{a}^{<1>}+b_y)$

1.4 RNN的多对多结构

1.5 RNN的多对一结构

从1.2 RNN的几种结构可以看到多对一RNN和多对多RNN的不同之处,但是在训练中仍然把多对一RNN当作多对多RNN训练,只是不使用最后训练出的$y^{<1>}$~$y^{<t-1>}$

1.6 RNN的缺点

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

2.实验

2.1 实验步骤

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

2.2 算法模型

"""
Task: 基于TextRNN的单词预测
Author: ChengJunkai @github.com/Cheng0829
Email: chengjunkai829@gmail.com
Date: 2022/09/08
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(sentences):
    # 分词
    word_sequence = " ".join(sentences).split()
    # 去重
    word_list = []
    '''
    如果用list(set(word_sequence))来去重,得到的将是一个随机顺序的列表(因为set无序),
    这样得到的字典不同,保存的上一次训练的模型很有可能在这一次不能用
    (比如上一次的模型预测碰见i:0,love:1,就输出dog:2,但这次模型dog在字典3号位置,也就无法输出正确结果)
    '''
    for word in word_sequence:
        if word not in word_list:
            word_list.append(word)
    # 字典
    word_dict = {w:i for i, w in enumerate(word_list)}
    word_dict["''"] = len(word_dict)
    number_dict = {i:w for i, w in enumerate(word_list)}
    number_dict[len(number_dict)] = "''"
    word_list.append("''")
    num_words = len(word_dict) # 词库大小:8
    # 本实验不采用随机抽样,所以batch_size等于样本数
    batch_size = len(sentences) # 样本数:5
    # print(word_dict)
    # print(number_dict)
    # print(word_list)
    return word_sequence, word_list, word_dict, number_dict, num_words, batch_size 

'''根据句子数据,构建词元的嵌入向量及目标词索引'''
def make_batch(sentences,mode='train'):
    # 和Word2Vec的random_batch基本一致,区别在于不随机
    input_batch = []
    target_batch = []

    for sen in sentences:
        words = sen.split() # 分词
        for i in range(len(words)):
            if(words[i] not in word_list):
                words[i] = "''"

        if mode == 'train':        
            input = [word_dict[n] for n in words[:-1]] # 创建最后一个词之前所有词的序号列表
            input_batch.append(np.eye(num_words)[input]) # 最后一个词之前所有词的嵌入向量
            target = word_dict[words[-1]] # 每个目标词的序号
            target_batch.append(target) # 记录每个目标词的序号
        else:
            input = [word_dict[n] for n in words] # 创建所有词的序号列表
            input_batch.append(np.eye(num_words)[input]) # 所有词的嵌入向量
    input_batch = torch.FloatTensor(np.array(input_batch))
    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.构建模型:多对一RNN(本实验结构图详见笔记)'''
class TextRNN(nn.Module):
    def __init__(self):
        super().__init__()
        '''nn.RNN(input_size, hidden_size, num_layers=1, bidirectional=False)
        Args:
            input_size : 嵌入向量维度
            hidden_size : 隐藏层alpha维度(隐藏层的神经元个数)
            num_layers=1 : 循环层数.设置num_aayers=2将意味着将两个RNN堆叠在一起,
                其中第二个RNN接受第一个RNN的输出并计算最终结果(Default:1)
            bidirectional: If ``True``, becomes a bidirectional RNN.(Default:False)
        '''
        '''nn.RNN:[嵌入向量维度, 隐藏层alpha维度]'''
        # 即x的维度和α的维度
        self.rnn = nn.RNN(input_size=num_words, hidden_size=hidden_size) # (8,4)
        '''Weight:[隐藏层alpha维度, 嵌入向量维度]'''
        self.Weight = nn.Linear(hidden_size, num_words, bias=False) # (4,8)
        self.bias = nn.Parameter(torch.ones([num_words]))

    '''每个样本输入的单词数和模型的时间步长度相等'''
    def forward(self, X, hidden): # model(input_batch, hidden)
        '''transpose(~) 矩阵转置
        X(input_batch):[5,2,8] -> transpose -> [2,5,8]
        '''
        X = X.transpose(0,1) # 第0维和第1维转置
        # X : [n_step, batch_size, num_words]
        '''X:[输入序列长度(时间步长度),样本数,嵌入向量维度] -> [2,5,8]'''
        '''hidden即为alpha'''
        '''
        RNN:(8,4) X:(2,5,8) hidden:(1,5,4) -> alpha_outputs:(2,5,4) alpha_t:(1,5,4)
        alpha_t是最后一个时间步的输出 : [1,样本数,隐藏层alpha维度(隐藏层的神经元个数)] -> [1,5,4]
        alpha_outputs存储所有时间步的输出,所以alpha_outputs[-1]和alpha_t值一样(除了前者[5,4]后者[1,5,4])
        本实验为多对一,所以仅需alpha_t,若为多对多,则需要对alpha_outputs中每个alpha求y=W(alpha)+b
        '''
        alpha_outputs, alpha_t = self.rnn(X, hidden) # alpha_t:[batch_size, num_directions(=1)*hidden_size]
        alpha_outputs = alpha_outputs.to(device)
        # Weight:[隐藏层alpha维度, 嵌入向量维度] alpha_t:[1,样本数,隐藏层alpha维度]
        # Weight:[4,8] alpha_t:[1,5,4] Weight(alpha_t):[5,8]
        # Y_t:[样本数,各单词的概率] -> [5,8] 最大值所在索引即为预测的单词索引
        # alpha_t[0]==alpha_outputs[-1]
        '''既可以使用alpha_t[0],也可以使用alpha_outputs[-1]'''
        Y_t = alpha_outputs[-1] 
        Y_t = self.Weight(Y_t) + self.bias # self.bias:(num_words,) (8,)
        return Y_t

if __name__ == '__main__':
    hidden_size = 4 # 隐藏层alpha维度(隐藏层的神经元个数)
    device = ['cuda:0' if torch.cuda.is_available() else 'cpu'][0]
    sentences = ["i like dog", "i love coffee", "i love coffee", "you love cloud", "i hate milk"]
    
    '''1.数据预处理'''
    word_sequence, word_list, word_dict, number_dict, num_words, batch_size = pre_process(sentences)
    input_batch, target_batch = make_batch(sentences)

    '''2.构建模型'''
    model = TextRNN()
    model.to(device)
    criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
    optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam动量梯度下降法

    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() # 把梯度置零，即把loss关于weight的导数变成0

        # hidden : [num_layers(=1)*num_directions(=1), batch_size, hidden_size]
        '''hidden:[层数*网络方向,样本数,隐藏层的维度(隐藏层神经元个数)] -> [1,5,4]'''
        # α_0常以零向量输入
        hidden = torch.zeros(1, batch_size, hidden_size).to(device) # (1,5,4)
        '''input_batch:[样本数,输入序列长度(时间步长度), 嵌入向量维度] -> [5,2,8]'''
        output = model(input_batch, hidden) # [batch_size, num_words]
        loss = criterion(output, target_batch) # 将输出与真实目标值对比,得到损失值
        loss.backward() # 将损失loss向输入侧进行反向传播，梯度累计
        optimizer.step() # 根据优化器对W、b和WT、bT等参数进行更新(例如Adam和SGD)

        if loss >= 0.01: # 连续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))
    sentences = ["i like", "i hate", "you love", "you love my", "you"]
    for sen in sentences: # 每个样本逐次预测,避免长度不同
        hidden = torch.zeros(1, 1, hidden_size).to(device)
        input_batch, target_batch = make_batch([sen], mode='predict')
        
        # 代码功能时预测下一个单词,所以每个样本只生成一个单词
        predict = model(input_batch, hidden) # [1,10] [1,dict_size]
        predict = predict.data.max(1, keepdim=True)[1]  #[1,1]
        
        result = predict.squeeze().item() # tensor([[~]]) -> tensor(~) -> ~
        print(sen + ' -> ' + number_dict[result])

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

    实际上,模型并没有把时间步作为一个超参数,也就是时间步随输入样本而变化,在训练集中,n_step均为2,
    但是,在测试集中,三个单词都是分别作为样本集输入的,也就是时间步分别为2,2,2,3,1
    最后在self.rnn(X, hidden)中,模型会自动根据X的序列长度,分配时间步

    但由于是一次性输入一个样本集,所以样本集中各个样本长度必须一致,否则报错
    因此必须把预测的sentences中各个句子分别放进容量为1的样本集单独输入

    需要指出的是,由于模型训练的是根据2个单词找到最后以1个单词,训练的是2个时间步之间的权重,
    所以如果长度不匹配,即使单词在训练集中,也不能取得好的结果,比如"you"的预测结果不是训练集中的"love"
'''

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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189