pytorch实现LSTM+Attention文本分类

直接看模型部分代码。

class BiLSTM_Attention(nn.Module):
    def __init__(self, vocab_size, embedding_dim, num_hiddens, num_layers):
        super(BiLSTM_Attention, self).__init__()
        # embedding之后的shape: torch.Size([200, 8, 300])
        self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.word_embeddings = self.word_embeddings.from_pretrained(
            vectors, freeze=False)
        # bidirectional设为True即得到双向循环神经网络
        self.encoder = nn.LSTM(input_size=embedding_dim,
                               hidden_size=num_hiddens,
                               num_layers=num_layers,
                               batch_first=False,
                               bidirectional=True)
        # 初始时间步和最终时间步的隐藏状态作为全连接层输入
        self.w_omega = nn.Parameter(torch.Tensor(
            num_hiddens * 2, num_hiddens * 2))
        self.u_omega = nn.Parameter(torch.Tensor(num_hiddens * 2, 1))
        self.decoder = nn.Linear(2*num_hiddens, 2)

        nn.init.uniform_(self.w_omega, -0.1, 0.1)
        nn.init.uniform_(self.u_omega, -0.1, 0.1)

    def forward(self, inputs):
        # inputs的形状是(seq_len,batch_size)
        embeddings = self.word_embeddings(inputs)
        # 提取词特征，输出形状为(seq_len,batch_size,embedding_dim)
        # rnn.LSTM只返回最后一层的隐藏层在各时间步的隐藏状态。
        outputs, _ = self.encoder(embeddings)  # output, (h, c)
        # outputs形状是(seq_len,batch_size, 2 * num_hiddens)
        x = outputs.permute(1, 0, 2)
        # x形状是(batch_size, seq_len, 2 * num_hiddens)
        
        # Attention过程
        u = torch.tanh(torch.matmul(x, self.w_omega))
       # u形状是(batch_size, seq_len, 2 * num_hiddens)
        att = torch.matmul(u, self.u_omega)
       # att形状是(batch_size, seq_len, 1)
        att_score = F.softmax(att, dim=1)
       # att_score形状仍为(batch_size, seq_len, 1)
        scored_x = x * att_score
       # scored_x形状是(batch_size, seq_len, 2 * num_hiddens)
        # Attention过程结束
        
        feat = torch.sum(scored_x, dim=1)
       # feat形状是(batch_size, 2 * num_hiddens)
        outs = self.decoder(feat)
       # out形状是(batch_size, 2)
        return outs

LSTM部分

• input size为（seq_len，batch_size），LSTM默认将序列长度(seq_len)作为第一维（由torchtext得到的batch就seq_len就是在第一维的）。embeddinng后size为(seq_len，batch_size， embedding_dim)。
• 经过Bi-LSTM编码后，outputs size为(seq_len，batch_size， 2 * num_hiddens)。

Attention 部分
公式如下：

文本分类中的attention和标准的attention不同，因为没有源和目标的概念，所以是句子内部的self-attention。
首先将$h_{it}$（隐藏向量）输入到单层神经网络（代码中省略了$b_w$）得到$u_{it}$，然后让$u_{it}$的转置和$u_w$（context vector）相乘再经过$softmax$归一化得到权重${\alpha }_{it}$。最后让${\alpha }_{it}$和$h_{it}$相乘并求和得到句子向量$s_i$。
代码中的w_omega（$W_w$）和u_omega（$u_w$）都是随机初始化的。

完整代码在这里：
https://github.com/WHLYA/text-classification.
实验结果：
LSTM：

LSTM+Attention：

加了Attention后效果居然变差了，猜测可能是过拟合，因为训练集准确率已经非常高了。