Bi-GRU sequence classification使用不同池化/解码方式实现预测任务

诸神缄默不语-个人CSDN博文目录

本文介绍使用PyTorch的Bi-GRU模型实现sequence classification（在NLP中一般就是文本分类任务）时，对GRU输出以不同池化方式获得sequence表征，不同池化方式的写法和效果上的区别。

注意：建议使用不定长RNN，因为这样会加速RNN运行（相关原理以后再补）。

1. 最后一个有效时间步上的输出

1.1 定长RNN版

略，待补。

1.2 不定长RNN版

class GRUEncoder(nn.Module):
    def __init__(self,input_dim,hidden_dim,num_layers,dropout_rate,bias=True,bidirectional=True):
        super(GRUEncoder,self).__init__()

        self.embs=nn.Embedding(word_num,input_dim)
        self.embs.weight.data.copy_(embedding)
        self.embs.weight.requires_grad=False

        self.rnns=nn.GRU(input_size=input_dim,hidden_size=hidden_dim,num_layers=num_layers,bias=bias,dropout=dropout_rate,bidirectional=bidirectional,
                        batch_first=True)
        self.lin=nn.Linear(in_features=hidden_dim*2 if bidirectional else hidden_dim,out_features=label_num)

    def forward(self,x,sent_len):
	    """
		x: pad后的输入张量，维度为[batch_size,max_sequence_length]
		sent_len：列表，每一维是每个sequence的有效token数
		"""
        x=self.embs(x)
        #[batch_size,max_sequence_length,input_dim]
        packed_input=nn.utils.rnn.pack_padded_sequence(x,lengths=sent_len,batch_first=True,enforce_sorted=False)
        op,hn=self.rnns(packed_input)
        op,lens_unpacked=nn.utils.rnn.pad_packed_sequence(op,batch_first=True)

        #[batch_size,max_sequence_length,hidden_dim*num_directions]
        #取最后一个有效时间步上的表征，作为最终表征
        outputs=op[torch.arange(0,op.size()[0]).to(gpu_device),lens_unpacked-1]
        return self.lin(outputs)

 

  
 

2. 所有有效时间步上的输出的平均池化

2.1 定长RNN版

略，待补。

2.2 不定长RNN版

class GRUEncoder(nn.Module):
    def __init__(self,input_dim,hidden_dim,num_layers,dropout_rate,bias=True,bidirectional=True):
        super(GRUEncoder,self).__init__()

        self.embs=nn.Embedding(word_num,input_dim)
        self.embs.weight.data.copy_(embedding)
        self.embs.weight.requires_grad=False

        self.rnns=nn.GRU(input_size=input_dim,hidden_size=hidden_dim,num_layers=num_layers,bias=bias,dropout=dropout_rate,bidirectional=bidirectional,
                        batch_first=True)
        self.lin=nn.Linear(in_features=hidden_dim*2 if bidirectional else hidden_dim,out_features=label_num)

    def forward(self,x,sent_len):
        x=self.embs(x)
        packed_input=nn.utils.rnn.pack_padded_sequence(x,lengths=sent_len,batch_first=True,enforce_sorted=False)
        op,hn=self.rnns(packed_input)
        op,lens_unpacked=nn.utils.rnn.pad_packed_sequence(op,batch_first=True)

        #[batch_size,max_sequence_length,hidden_dim*num_directions]
        #取所有有效时间步的输出的平均值池化，作为最终表征
        outputs_sum=op.sum(axis=1)
        outputs=outputs_sum/(lens_unpacked.to(gpu_device).unsqueeze(1))  #lens_unpacked在CPU上
        return self.lin(outputs)

 

  
 

3. 所有有效时间步上的输出的加权求和（attention）

略，待补。

4. 最后2层隐藏层状态

略，待补。

5. 实验结果

略，待补。

转载：https://blog.csdn.net/PolarisRisingWar/article/details/128285326