二、语言模型

1 语言模型

语言模型的任务是判断一句话出现的概率（也就是说一句话是不是人说的），可以表示为：$P(W)=P(w_1,w_2,...w_n)$
使用链式法则求概率：
$P(W)=P(w_1,w_2,...w_n)={\prod }_{i}P(w_i|w_1,w_2,...w_{i-1})$

$P(w_i|w_1,w_2,...w_{i-1})$计算复杂度非常高。
在马尔科夫假设中，一个词出现的概率只与前一个词相关，那么$P(w_i|w_1,w_2,...w_{i-1})=P(w_i|w_{i-1})$
也有n=2，是2元模型

2 语言模型评价指标：Perplexity

句子概率越大，Perplexity越低。也就是说Perplexity低的，语言模型好。

详细信息阅读博客：https://www.cnblogs.com/shona/p/10827339.html

3 基于神经网络的语言模型

模型学习任务是：根据当前词，猜测下一个词。
用神经网络学习到概率P。

3.1 RNN

梯度消失和梯度爆炸问题：
1 在反向传播过程中有连续相乘的操作
2 如果相乘的值大于1，那么就可能发生梯度爆炸。解决：截断
3 如果相乘的值小于1，那么就可能发生梯度消失。解决：使用Relu(x) = max(0,x)
还有距离远的信息不容易被RNN保留。

3.2 LSTM

忘记门
输入门
更新门
输出门

3.3 GRU

GRU是LSTM的改进，参数量更少。

4 优化函数

交叉熵损失函数

5 模型代码

class RNNModel(nn.Module):
    '''一个简单的循环神经网络'''
    def __init__(self, rnn_type, vocab_size, embedding_size, hidden_size, nlayers, dropout=0.5):
        '''

        :param rnn_type: LSTM/GRU
        :param vocab_size: 词库大小
        :param embedding_size:
        :param hidden_size:
        :param nlayers: 纵向有多少层神经网络
        :param dropout:
        '''
        super(RNNModel, self).__init__()
        self.drop = nn.Dropout(dropout)
        self.embedding = nn.Embedding(vocab_size, embedding_size)
        if rnn_type in ['LSTM', 'GRU']:
            # getattr(nn, rnn_type) 相当于 nn.rnn_type
            self.rnn = getattr(nn, rnn_type)(embedding_size, hidden_size, nlayers, dropout=dropout)
        else:
            try:
                nonlinearity = {'RNN_TANH': 'tanh', 'RNN_RELU': 'relu'}[rnn_type]
            except KeyError:
                raise ValueError("""An invalid option for `--model` was supplied,
                                             options are ['LSTM', 'GRU', 'RNN_TANH' or 'RNN_RELU']""")
            self.rnn = nn.RNN(embedding_size, hidden_size, nlayers, nonlinearity=nonlinearity, dropout=dropout)
        # 全连接层
        self.decoder = nn.Linear(hidden_size, vocab_size)

        self.init_weights()
        self.rnn_type = rnn_type
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.nlayers = nlayers

    def init_weights(self):
        init_range = 0.1
        self.embedding.weight.data.uniform_(-init_range, init_range)
        self.decoder.bias.data.zero_()
        self.decoder.weight.data.uniform_(-init_range, init_range)

    def forward(self, input, hidden):
        '''
        一个神经网络
        :param input:一个序列的词，input.shape = seq_len*batch_size = 50*32
        :param hidden:hidden = (nlayers * 32 * hidden_size, nlayers * 32 * hidden_size)
        :return:
        '''
        # hidden是个元组，输入有两个参数，一个是刚开始的隐藏层h的维度，一个是刚开始的用于记忆的c的维度，
        # 这两个层的维度一样，并且需要先初始化，hidden_size的维度和上面nhid的维度一样 =100，我理解这两个是同一个东西。??
        embed = self.drop(self.embedding(input))  # emb.shape=torch.Size([seq_len, batch_size, hidden_size]) # 输入数据的维度
        # 还有一种接参数的方式是：output, (hidden,c_state) = self.rnn(embed, hidden)
        output, hidden = self.rnn(embed, hidden)  # output.shape = seq_len * batch_size * hidden_size # 最终输出数据的维度
        # hidden = (h层维度：nlayers * batch_size * hidden_size, c层维度：nlayers * batch_size * hidden_size)
        output = self.drop(output)
        # output最后的输出层一定要是二维的，只是为了能进行全连接层的运算。
        # 所以把前两个维度拼接在一起：（seq_len * batch_size） * hidden_size
        decoded = self.decoder(output.view(output.size(0) * output.size(1), output.size(2)))  # （seq_len * batch_size） * vocab_size
        # 我们需要知道每个位置预测的下一个单词是哪个，pred形状：seq_len * batch_size * vocab_size
        pred = decoded.view(output.size(0), output.size(1), decoded.size(1))
        return pred, hidden

    def init_hidden(self, bsz, requires_grad=True):
        # 初始化隐藏的参数
        weight = next(self.parameters())
        if self.rnn_type == 'LSTM':
            return (weight.new_zeros((self.nlayers, bsz, self.hidden_size), requires_grad=requires_grad),
                    weight.new_zeros((self.nlayers, bsz, self.hidden_size), requires_grad=requires_grad))
        else:
            return weight.new_zeros((self.nlayers, bsz, self.hidden_size), requires_grad=requires_grad)
            # GRU 神经网络把h层和c层合并了，所以这里只有一个参数

6 用途与评价

评价语言模型一个是使用perplexity指标。另外一个是使用模型生成一段文本，看下通畅度。