将若干词向量转变为一个词向量的方法

文章目录

• • 题目
  • 前言
  • 问题来源
  • 思路
  • • 利用RNN的最终状态
    • • 代码实现
      • 运行结果
    • 利用CNN和池化
    • • 平均池化
      • • 代码实现
        • 运行结果
      • 最大池化
      • • 代码实现
        • 运行结果
      • 两者区别

题目

将若干词向量转变为一个词向量的方法

前言

在文本分词时，我们往往会将一个文本分为很多分词，每一个分词将会用一个词向量来表示。

假设一篇文章有n个分词，那么它将形成n个词向量，它们在经过全连接网络时会形成n个新维度向量，如果经过的是循环神经网络则会在n层隐藏状态。

问题来源

但是现实中我们往往需要对这些n维向量进行处理，如需要它们进行分类，此时我们就需要得到一个的向量来帮助我们分类，而不是需要n维向量。

那么我们如何将一个n维向量转化为一个1维向量呢？

思路

利用RNN的最终状态

在循环神经网络中，我们知道隐状态保留了最后一个时刻所有层的状态，其实它的状态就已经包含了所有的精华，它可以代表整段语句的向量。

代码实现

将一个文本向量划分为5分类向量

'''
Description: 利用RNN的最终状态来获取文本的单向量
Autor: 365JHWZGo
Date: 2021-12-21 16:26:25
LastEditors: 365JHWZGo
LastEditTime: 2021-12-21 16:59:06
'''
import torch
import torch.nn as nn

BATCH_SIZE = 3
HIDDEN_SIZE = 5
NUM_LAYER = 1
SEQ_LEN = 4
WORD_DIM = 6

class RNN(nn.Module):
    def __init__(self,word_dim,hidden_size,num_layer):
        super(RNN,self).__init__()
        
        self.rnn = nn.RNN(word_dim,hidden_size,num_layer)
        self.linear = nn.Linear(hidden_size,5)
    
    def forward(self,x):
        # rnn的输入维度为(SEQ_LEN,BATCH_SIZE,WORD_DIM)
        output,h_s = self.rnn(x)
        # output=(SEQ_LEN,BATCH_SIZE,HIDDEN_SIZE)
        # h_s=(NUM_LAYER,BATCH_SIZE,HIDDEN_SIZE)
        return self.linear(h_s[-1])
        
if __name__ == '__main__':
    inputSeq = torch.randn(SEQ_LEN,BATCH_SIZE,WORD_DIM)
    rnn = RNN(WORD_DIM,HIDDEN_SIZE,NUM_LAYER)
    h = rnn(inputSeq)
    # h的维度(BATCH_SIZE,5)
    print(h)	

运行结果

利用CNN和池化

在卷积神经网络中，我们可以借助过滤器啊(大小为window_size* word_dim) 来实现，得到一个文本向量(维度为batch_size*(seq_len-window+1)*m)【m为过滤器个数】
但是这样仍然有(seq_len-window+1)个文本向量，所以我们需要将(seq_len-window+1)个文本向量化为1个
该怎样实现呢？

平均池化

平均池化之后的维度为batch_size*m

代码实现

'''
Description: cnn利用平均池化来实现单一文本维度
Autor: 365JHWZGo
Date: 2021-12-21 18:04:17
LastEditors: 365JHWZGo
LastEditTime: 2021-12-21 18:44:45
'''
import torch 
import torch.nn as nn
import torch.nn.functional as F

OUT_CHANNELS = 4
WINDOW_SIZE = 3
WORD_DIM = 5
SEQ_LEN = 10
BATCH_SIZE = 3

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.cnn = nn.Conv2d(1,OUT_CHANNELS,(WINDOW_SIZE,WORD_DIM))
        self.maxPool = nn.AvgPool2d((1,SEQ_LEN-WINDOW_SIZE+1))
    def forward(self,x):
        x = x.unsqueeze(1)
        # cnn 输入维度BATCH_SIZE*IN_CHANNELS*SEQ_LEN*WORD_DIM
        output = self.cnn(x)
        # cnn 输出维度BATCH_SIZE*OUT_CHANNELS*(SEQ_LEN-WINDOW_SIZE+1)*1
        squeeze_opt = output.squeeze(3)
        # 最大池化
        res = self.maxPool(squeeze_opt)
        return res
    
if __name__ == '__main__':
    inputSeq = torch.randn(BATCH_SIZE,SEQ_LEN,WORD_DIM)
    cnn = CNN()
    output = cnn(inputSeq)
    print(output)

运行结果

最大池化

代码实现

'''
Description: cnn利用最大池化来实现单一文本维度
Autor: 365JHWZGo
Date: 2021-12-21 18:04:17
LastEditors: 365JHWZGo
LastEditTime: 2021-12-21 18:41:38
'''
import torch 
import torch.nn as nn
import torch.nn.functional as F

OUT_CHANNELS = 4
WINDOW_SIZE = 3
WORD_DIM = 5
SEQ_LEN = 10
BATCH_SIZE = 3

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.cnn = nn.Conv2d(1,OUT_CHANNELS,(WINDOW_SIZE,WORD_DIM))
        self.maxPool = nn.MaxPool2d((1,SEQ_LEN-WINDOW_SIZE+1))
    def forward(self,x):
        x = x.unsqueeze(1)
        # cnn 输入维度BATCH_SIZE*IN_CHANNELS*SEQ_LEN*WORD_DIM
        output = self.cnn(x)
        # cnn 输出维度BATCH_SIZE*OUT_CHANNELS*(SEQ_LEN-WINDOW_SIZE+1)*1
        squeeze_opt = output.squeeze(3)
        # 最大池化
        res = self.maxPool(squeeze_opt)
        return res
    
if __name__ == '__main__':
    inputSeq = torch.randn(BATCH_SIZE,SEQ_LEN,WORD_DIM)
    cnn = CNN()
    output = cnn(inputSeq)
    print(output)

运行结果

两者区别

• maxPooling：主要用于减少无用信息的影响；可以提取特征纹理
• avgPooling:主要用于获取全局上下文关系；可以保留背景信息

标签：__,SEQ,nn,self,向量,cnn,若干,转变,SIZE
来源： https://blog.csdn.net/qq_44833392/article/details/122052314