当前位置：首页 > news >正文

循环神经网络实现文本情感分类案例

news 2025/10/30 15:09:12

循环神经网络实现文本情感分类

目标

知道LSTM和GRU的使用方法及输入输出的格式
能够应用LSTM和GRU实现文本情感分类

1. Pytorch中 LSTM和GRU模块使用

1.1 LSTM介绍

LSTM 和 GRU都是由torch.nn提供。

通过观察文档，可知LSTM的参数，

torch.nn.LSTM(input_size,hidden_size,num_layers,batch_first,dropout,bidirectional)

input_size ：输入数据的形状，即embedding_dim
hidden_size：隐藏层神经元的数量，即每一层有多少个LSTM单元
num_layer ：即RNN的中LSTM单元的层数
batch_first：默认值为False，输入的数据需要[seq_len,batch,feature],如果为True，则为[batch,seq_len,feature]
dropout:dropout的比例，默认值为0。dropout是一种训练过程中让部分参数随机失活的一种方式，能够提高训练速度，同时能够解决过拟合的问题。这里是在LSTM的最后一层，对每个输出进行dropout
bidirectional：是否使用双向LSTM，默认是False

实例化LSTM对象之后, 不仅需要传入数据，还需要前一次的 h_0 (前一次的隐藏状态) 和 c_0（前一次memory）

即：lstm(input,(h_0,c_0))

LSTM的默认输出为output, (h_n, c_n)

num_directions : 这个参数表示LSTM是单向的还是双向的

output：(seq_len, batch, num_directions * hidden_size) —> batch_first = False
h_n:(num_layers * num_directions, batch, hidden_size)
c_n: (num_layers * num_directions, batch, hidden_size)

1.2 LSTM使用示例

假设数据输入为 input, 形状是[10,20]，假设embedding的形状是[100,30]

则LSTM使用示例如下：

batch_size =10 # 句子的数量
seq_len = 20   # 每个句子的长度
embedding_dim = 30 # 每个词语使用多长的向量表示
word_vocab = 100 # 词典中词语的总数
hidden_size = 18 # 隐层中lstm的个数
num_layer = 2  #多少个隐藏层#准备输入数据
'''
功能：生成一个 随机整数张量，模拟文本序列的词索引。
范围：整数值在 [0,100)，即词表大小 word_vocab=100。
张量形状：(batch_size, seq_len) = (10, 20)
10 表示一个 batch 里有 10 个句子
20 表示每个句子长度是 20 个词（即序列长度）
'''
input = torch.randint(low = 0,high = 100,size = (batch_size,seq_len))#准备embedding,创建一个 词嵌入层，将每个词索引映射到一个稠密向量。
# word_vocab词表大小为100，每个词的 embedding向量维度为30
embedding  = torch.nn.Embedding(word_vocab,embedding_dim)lstm = torch.nn.LSTM(embedding_dim,hidden_size,num_layer)#进行embed操作，嵌入操作：将input的词索引输入到embedding层，得到对应的向量。
#解释：10 个句子 × 每个句子 20 个词 × 每个词 30 维向量。
embed = embedding(input) #[10,20,30]# 转化数据为batch_first=False
# 用来重新排列张量的维度顺序
'''
原来：[batch, seq_len, feature] = [10, 20, 30]
调整后：[seq_len, batch, feature] = [20, 10, 30]
这是因为 PyTorch 的 RNN/LSTM 默认要求输入是 [seq_len, batch_size, input_size] 格式（除非设置 batch_first=True）。
所以这里是为了适配 nn.LSTM 的输入。
'''
embed = embed.permute(1,0,2) #[20,10,30]#初始化状态， 如果不初始化，torch默认初始值为全0
# 初始化h_0隐藏层状态，形状：[num_layers, batch_size, hidden_size]，即[2, 10, 18],
# 2层LSTM，每个batch有10个样本，每个隐藏层维度是 18h_0 = torch.rand(num_layer,batch_size,hidden_size)
#初始化细胞状态，形状也是[2, 10, 18]
c_0 = torch.rand(num_layer,batch_size,hidden_size)
#输入 embed（形状 [20,10,30]）和初始状态 (h_0, c_0) 到 LSTM。'''
返回两个部分：
output: [seq_len, batch_size, hidden_size] = [20,10,18]
表示每个时间步、每个样本的输出向量。
(h_1, c_1):
h_1: [num_layers, batch_size, hidden_size] = [2,10,18]
最后一个时间步的隐藏状态（每层都有）。
c_1: [2,10,18]
最后一个时间步的细胞状态（每层都有）。
'''
output,(h_1,c_1) = lstm(embed,(h_0,c_0))
#output [20,10,1*18]
#h_1 [2,10,18]
#c_1 [2,10,18]

输出如下

In [122]: output.size()
Out[122]: torch.Size([20, 10, 18])In [123]: h_1.size()
Out[123]: torch.Size([2, 10, 18])In [124]: c_1.size()
Out[124]: torch.Size([2, 10, 18])

通过前面的学习，我们知道，最后一次的h_1应该和output的最后一个time step的输出是一样的。

通过下面的代码，我们来验证一下：

output: [seq_len, batch_size, hidden_size]

h_1 和 c_1:

[num_layers, batch_size, hidden_size]

In [179]: a = output[-1,:,:]In [180]: a.size()
Out[180]: torch.Size([10, 18])In [183]: b.size()
Out[183]: torch.Size([10, 18])
In [184]: a == b
Out[184]:
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],dtype=torch.uint8)

1.3 GRU的使用示例

GRU模块 torch.nn.GRU ，和LSTM的参数相同，含义相同，具体可参考文档。

但是输入只剩下 gru(input,h_0)，输出为output, h_n。

其形状为：

output:(seq_len, batch, num_directions * hidden_size)
h_n:(num_layers * num_directions, batch, hidden_size)

大家可以使用上述代码，观察GRU的输出形式。

1.4 双向LSTM

如果需要使用双向LSTM，则在实例化LSTM的过程中，需要把LSTM中的bidirectional设置为True，同时h_0和c_0使用num_layer*2

观察效果，输出为：

batch_size =10 #句子的数量
seq_len = 20  #每个句子的长度
embedding_dim = 30  #每个词语使用多长的向量表示
word_vocab = 100  #词典中词语的总数
hidden_size = 18  #隐层中lstm的个数
num_layer = 2  #多少个隐藏层input = torch.randint(low=0,high=100,size = (batch_size,seq_len))
embedding  = torch.nn.Embedding(word_vocab,embedding_dim)
lstm = torch.nn.LSTM(embedding_dim,hidden_size,num_layer,bidirectional=True)embed = embedding(input) #[10,20,30]#转化数据为batch_first=False
embed = embed.permute(1,0,2) #[20,10,30]
h_0 = torch.rand(num_layer*2,batch_size,hidden_size)
c_0 = torch.rand(num_layer*2,batch_size,hidden_size)
output,(h_1,c_1) = lstm(embed,(h_0,c_0))In [135]: output.size()
Out[135]: torch.Size([20, 10, 36])In [136]: h_1.size()
Out[136]: torch.Size([4, 10, 18])In [137]: c_1.size()
Out[137]: torch.Size([4, 10, 18])

在单向LSTM中，最后一个 time step 的输出的前 hidden_size 个和最后一层隐藏状态h_1 的输出相同，那么双向LSTM呢？

双向LSTM中：

output：按照正反计算的结果顺序在第2个维度进行拼接，正向第一个拼接，反向的最后一个输出。

hidden state: 按照得到的结果在第0个维度进行拼接，正向第一个之后接着是反向第一个。

前向的LSTM中，最后一个time step的输出的前hidden_size个和最后一层向前传播h_1的输出相同。

示例：

#-1是前向LSTM的最后一个，前18是前hidden_size个
In [188]: a = output[-1,:,:18]  #前项LSTM中最后一个time step的outputIn [189]: b = h_1[-2,:,:]  #倒数第二个为前向In [190]: a.size()
Out[190]: torch.Size([10, 18])In [191]: b.size()
Out[191]: torch.Size([10, 18])In [192]: a == b
Out[192]:
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],dtype=torch.uint8)

后向LSTM中，最后一个time step的输出的后hidden_size个和最后一层后向传播的h_1的输出相同

示例

#0 是反向LSTM的最后一个，后18是后hidden_size个
In [196]: c = output[0,:,18:]  #后向LSTM中的最后一个输出In [197]: d = h_1[-1,:,:] #后向LSTM中的最后一个隐藏层状态In [198]: c == d
Out[198]:
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],dtype=torch.uint8)

1.4 LSTM和GRU的使用注意点

第一次调用之前，需要初始化隐藏状态，如果不初始化，默认创建全为0的隐藏状态。
往往会使用LSTM or GRU 的输出的最后一维的结果，来代表LSTM、GRU对文本处理的结果，其形状为[batch, num_directions*hidden_size]。
1. 并不是所有模型都会使用最后一维的结果
2. 如果实例化LSTM的过程中，batch_first=False,则output[-1] or output[-1,:,:]可以获取最后一维
3. 如果实例化LSTM的过程中，batch_first=True,则output[:,-1,:]可以获取最后一维
如果结果是(seq_len, batch_size, num_directions * hidden_size), 需要把它转化为(batch_size,seq_len, num_directions * hidden_size)的形状，不能够不是view等变形的方法，需要使用output.permute(1,0,2)，即交换0和1轴，实现上述效果
使用双向LSTM的时候，往往会分别使用每个方向最后一次的output，作为当前数据经过双向LSTM的结果
- 即：torch.cat([h_1[-2,:,:],h_1[-1,:,:]],dim=-1)
- 最后的表示的size是[batch_size,hidden_size*2]
上述内容在GRU中同理

2. 使用LSTM完成文本情感分类

在前面，我们使用了word embedding去实现了toy级别的文本情感分类，那么现在我们在这个模型中添加上LSTM层，观察分类效果。

为了达到更好的效果，对之前的模型做如下修改

MAX_LEN = 200
构建dataset的过程，把数据转化为2分类的问题，pos（positive积极的）为1，neg（negative消极的）为0，否则25000个样本完成10个类别的划分数据量是不够的。
在实例化LSTM的时候，使用dropout=0.5，在model.eval()的过程中，dropout自动会为0

2.1 修改模型

#定义一个继承 nn.Module 的模型类，并正确初始化父类。
class IMDBLstmmodel(nn.Module):def __init__(self):super(IMDBLstmmodel,self).__init__()self.hidden_size = 64self.embedding_dim = 200self.num_layer = 2self.bidirectional = Trueself.bi_num = 2 if self.bidirectional else 1self.dropout = 0.5#以上部分为超参数，可以自行修改self.embedding = nn.Embedding(len(ws),self.embedding_dim,padding_idx=ws.PAD) #[N,300]self.lstm = nn.LSTM(self.embedding_dim,self.hidden_size,self.num_layer,bidirectional=True,dropout=self.dropout)#使用两个全连接层，中间使用relu激活函数self.fc = nn.Linear(self.hidden_size*self.bi_num,20)self.fc2 = nn.Linear(20,2)def forward(self, x):x = self.embedding(x)x = x.permute(1,0,2) #进行轴交换h_0,c_0 = self.init_hidden_state(x.size(1))_,(h_n,c_n) = self.lstm(x,(h_0,c_0))#只要最后一个lstm单元处理的结果，这里多去的hidden state#这里的cat是对两个tensor张量的拼接操作out = torch.cat([h_n[-2, :, :], h_n[-1, :, :]], dim=-1)out = self.fc(out)out = F.relu(out)out = self.fc2(out)return F.log_softmax(out,dim=-1)def init_hidden_state(self,batch_size):h_0 = torch.rand(self.num_layer * self.bi_num, batch_size, self.hidden_size).to(device)c_0 = torch.rand(self.num_layer * self.bi_num, batch_size, self.hidden_size).to(device)return h_0,c_0

forward

    def forward(self, x):x = self.embedding(x)

输入 x 的形状常见为 [batch, seq_len]（每个元素是词ID）。
通过 embedding 后变为 [batch, seq_len, embedding_dim] = [B, T, 200]。

        x = x.permute(1, 0, 2)  # 进行轴交换

PyTorch 的 nn.LSTM 默认 batch_first=False，期望输入 [seq_len, batch, input_size]。
这步把 [B, T, E] 变成 [T, B, E]。

        h_0, c_0 = self.init_hidden_state(x.size(1))

x.size(1) 是 batch。初始化初始隐状态/细胞状态。
注意：你在 init_hidden_state 里用了 torch.rand 随机初始化，训练中更常见是 zeros。随机也可以，但会引入额外噪声。

        _, (h_n, c_n) = self.lstm(x, (h_0, c_0))

经过 LSTM：
- output（这里丢弃了，用 _）形状为 [T, B, hidden*directions] = [T, B, 128]。
- h_n 形状为 [num_layers * num_directions, B, hidden]。本例是 [2*2, B, 64] = [4, B, 64]。
- c_n 同形状 [4, B, 64]。

关键点：h_n 的排布顺序（PyTorch 约定）
对双向多层：按层堆叠，每层包含 先前向再后向。

索引：
- 第 0 维（层×方向）= [layer0_forward, layer0_backward, layer1_forward, layer1_backward]
- 所以：h_n[-2] 是 最后一层的前向，h_n[-1] 是 最后一层的后向。

        # 只要最后一个 LSTM 单元处理的结果，这里取 hidden stateout = torch.cat([h_n[-2, :, :], h_n[-1, :, :]], dim=-1)

这句就是你问的重点。
含义：从 h_n 里取 最后一层 的 前向最终隐状态（h_n[-2]，形状 [B, 64]）和 后向最终隐状态（h_n[-1]，形状 [B, 64]），在最后一个维度拼起来。
dim=-1 表示在特征维拼接，得到形状 [B, 128]。
直观理解：双向 LSTM 把「从左到右」看完整个句子的摘要（前向）和「从右到左」看完整个句子的摘要（后向）拼在一起，作为句子表示。

对比：如果用 output[-1]，那只取了前向最后时刻的输出（对双向会是拼接，但更常见/更稳妥的是直接从 h_n 按层和方向取最后的两个向量）。

        out = self.fc(out)out = F.relu(out)out = self.fc2(out)return F.log_softmax(out, dim=-1)

全连接 → ReLU → 全连接到 2 类 → log_softmax 得到对数概率（便于后面配 NLLLoss）。

2.2 完成训练和测试代码

为了提高程序的运行速度，可以考虑把模型放在gup上运行，那么此时需要处理一下几点：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
除了上述修改外，涉及计算的所有tensor都需要转化为CUDA的tensor
1. 初始化的h_0,c_0
2. 训练集和测试集的input,traget
在最后可以通过tensor.cpu()转化为torch的普通tensor

train_batch_size = 64
test_batch_size = 5000
# imdb_model = IMDBModel(MAX_LEN) #基础model
imdb_model = IMDBLstmmodel().to(device) #在gpu上运行，提高运行速度
# imdb_model.load_state_dict(torch.load("model/mnist_net.pkl"))
optimizer = optim.Adam(imdb_model.parameters())
criterion = nn.CrossEntropyLoss()def train(epoch):mode = Trueimdb_model.train(mode)train_dataloader = get_dataloader(mode,train_batch_size)for idx,(target,input,input_lenght) in enumerate(train_dataloader):target = target.to(device)input = input.to(device)optimizer.zero_grad()output = imdb_model(input)loss = F.nll_loss(output,target) #traget需要是[0,9]，不能是[1-10]loss.backward()optimizer.step()if idx %10 == 0:pred = torch.max(output, dim=-1, keepdim=False)[-1]acc = pred.eq(target.data).cpu().numpy().mean()*100.print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\t ACC: {:.6f}'.format(epoch, idx * len(input), len(train_dataloader.dataset),100. * idx / len(train_dataloader), loss.item(),acc))torch.save(imdb_model.state_dict(), "model/mnist_net.pkl")torch.save(optimizer.state_dict(), 'model/mnist_optimizer.pkl')def test():mode = Falseimdb_model.eval()test_dataloader = get_dataloader(mode, test_batch_size)with torch.no_grad():for idx,(target, input, input_lenght) in enumerate(test_dataloader):target = target.to(device)input = input.to(device)output = imdb_model(input)test_loss  = F.nll_loss(output, target,reduction="mean")pred = torch.max(output,dim=-1,keepdim=False)[-1]correct = pred.eq(target.data).sum()acc = 100. * pred.eq(target.data).cpu().numpy().mean()print('idx: {} Test set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(idx,test_loss, correct, target.size(0),acc))if __name__ == "__main__":test()for i in range(10):train(i)test()

2.3 模型训练的最终输出

...
Train Epoch: 9 [20480/25000 (82%)]	Loss: 0.017165	 ACC: 100.000000
Train Epoch: 9 [21120/25000 (84%)]	Loss: 0.021572	 ACC: 98.437500
Train Epoch: 9 [21760/25000 (87%)]	Loss: 0.058546	 ACC: 98.437500
Train Epoch: 9 [22400/25000 (90%)]	Loss: 0.045248	 ACC: 98.437500
Train Epoch: 9 [23040/25000 (92%)]	Loss: 0.027622	 ACC: 98.437500
Train Epoch: 9 [23680/25000 (95%)]	Loss: 0.097722	 ACC: 95.312500
Train Epoch: 9 [24320/25000 (97%)]	Loss: 0.026713	 ACC: 98.437500
Train Epoch: 9 [15600/25000 (100%)]	Loss: 0.006082	 ACC: 100.000000
idx: 0 Test set: Avg. loss: 0.8794, Accuracy: 4053/5000 (81.06%)
idx: 1 Test set: Avg. loss: 0.8791, Accuracy: 4018/5000 (80.36%)
idx: 2 Test set: Avg. loss: 0.8250, Accuracy: 4087/5000 (81.74%)
idx: 3 Test set: Avg. loss: 0.8380, Accuracy: 4074/5000 (81.48%)
idx: 4 Test set: Avg. loss: 0.8696, Accuracy: 4027/5000 (80.54%)

可以看到模型的测试准确率稳定在81%左右。

大家可以把上述代码改为GRU，或者多层LSTM继续尝试，观察效果。

上述代码问题探讨？

1.在单向的LSTM中，如果batch_size每批次为10个句子，每个句子为20个单词，总共2层神经网络，每层神经网络有隐藏层18个，也就是有18个LSTM单元。

那么为什么最后一次的 h_1 应该和output的最后一个time step的输出是一样的？a = output[-1,:,:] 这里的a的形状为什么是[10, 18], 为什么是二维的，不应该是三维的吗？不应该是[seq_len, batch_size, hidden_size]，也就是[20,10,18]吗？

对于你的问题，我会逐一进行解答。

1.为什么最后一次的 h_1 应该和 output 的最后一个 time step 的输出是一样的？

在LSTM（或RNN）模型中，output 和 h_1 都是LSTM网络的输出，但它们有不同的含义：

output: 是LSTM对整个序列每个时间步的输出，形状是 (seq_len, batch_size, hidden_size)（如果 batch_first=False）。
- 这是LSTM在每个时间步生成的隐藏状态（或输出），它会对每个词语的输入生成一个向量表示。
- 对于双向LSTM，output 的第三维大小会是 hidden_size * 2，因为会拼接正向和反向的输出。
h_1: 是LSTM的最后一个隐藏状态，形状为 (num_layers * num_directions, batch_size, hidden_size)。
- h_1[-1] 是最后一层LSTM的最终隐藏状态，表示LSTM对整个序列的“理解”。
- 如果是双向LSTM，h_1[-1] 就是最后一层的反向LSTM的输出，而 h_1[-2] 是正向LSTM的输出。

2. 为什么 a = output[-1,:,:] 这里的 a 的形状是 [10, 18]，而不是三维的 [seq_len, batch_size, hidden_size]？

这个问题的关键在于我们选取的是 output[-1,:,:]。让我们再分析一下这里的操作：

output 的形状是 (seq_len, batch_size, hidden_size)。在你给出的例子中，seq_len=20，batch_size=10，hidden_size=18。
- 所以，output 的形状应该是 [20, 10, 18]。
output[-1,:,:] 的意思是获取 output 的最后一个时间步的输出（即第20个时间步的输出），其形状为 [10, 18]。
- 这就是你看到的 a 的形状。你选取了 output 中第20个时间步的所有样本的输出，所以 a 就是一个二维的张量，包含了每个样本在第20个时间步的隐藏状态（每个样本的隐藏状态大小是 18）。

3.为什么 output[-1,:,:] 不是 [seq_len, batch_size, hidden_size]？

output[-1,:,:] 的目的是获取最后一个时间步的输出，而不是所有时间步的输出。因此，它是从 output 中取出第 seq_len（也就是第20个时间步）时的结果，所以它只有两个维度：

batch_size: 10（表示10个句子）
hidden_size: 18（表示每个样本的隐藏状态大小）

output 里有 seq_len（20）个时间步的数据，而你只关心最后一个时间步的数据，因此 output[-1,:,:] 的形状是 [10, 18]。

举例说明

例子:
比如每批次2个句子，每个句子3个单词，第一个句子“你好呀”，第二个句子“我爱你”，然后隐藏层为4层，也就是4个LSTM单元，神经网络2层，每个单词用30维度的向量表示词向量。
那么最终output最后一个时间步的输出的张量是什么形状的？h_1什么形状的？

让我们通过一个具体的例子来演示如何在LSTM中理解 output 和 h_1 的形状。假设我们有如下情况：

批次大小 (batch_size)：2（即一次处理2个句子）
每个句子包含的单词数 (seq_len)：3（即每个句子由3个单词组成）
隐藏层维度 (hidden_size)：4（即LSTM的每个隐藏层维度是4）
LSTM层数 (num_layers)：2（即LSTM有2层）
每个单词的词向量维度 (embedding_dim)：30（即每个单词会用30维度的词向量表示）

句子：

第一个句子：“你好呀” -> 对应的单词索引（假设已经转换为数字索引）：[1, 2, 3]
第二个句子：“我爱你” -> 对应的单词索引（假设已经转换为数字索引）：[4, 5, 6]

目标：

使用LSTM处理这些句子，了解 output 和 h_1 的形状。
演示 output[-1,:,:] 和 h_1 的关系。

1. 准备输入

为了简化，我们假设词向量已经通过词嵌入（embedding）层获得。每个句子的词向量是30维的，所以句子长度为3时，每个句子就是一个 3x30 的张量。

假设每个词的词向量如下（只是举例，不是实际计算的结果）：

“你好呀” 对应的词向量为：

[[0.1, 0.2, 0.3, ..., 0.30],[0.4, 0.5, 0.6, ..., 0.60],[0.7, 0.8, 0.9, ..., 0.90]]

“我爱你” 对应的词向量为：

[[0.1, 0.2, 0.3, ..., 0.30],[0.4, 0.5, 0.6, ..., 0.60],[0.7, 0.8, 0.9, ..., 0.90]]

所以在 embedding 层后，每个句子的嵌入会变成一个形状为 (3, 30) 的张量（3个单词，每个单词的词向量是30维）。

2. LSTM模型的构建

假设我们用2层LSTM，其中每一层的隐藏状态维度是4。我们设置LSTM为单向（bidirectional=False）。

在PyTorch中，LSTM 模块接受的输入数据格式是 [seq_len, batch_size, input_size]。我们要将每个句子的词向量（形状为 [batch_size, seq_len, embedding_dim]）调整为 [seq_len, batch_size, embedding_dim]，适配LSTM的输入要求。

这里的调整就是embed = embed.permute(1,0,2) #[20,10,30]

3. LSTM的处理

LSTM的输出：

output: 每个时间步的隐藏状态，形状为 [seq_len, batch_size, hidden_size]。
h_1: 最后一层LSTM的隐藏状态，形状为 [num_layers, batch_size, hidden_size]。

输入和处理：

输入：一个批次包含2个句子，每个句子3个单词，所以输入是形状为 [3, 2, 30] 的张量（3个时间步、2个句子、30维的词向量）。
LSTM的隐藏层维度：4，所以输出的每个隐藏状态向量的维度是4。
LSTM的层数：2层。

输出的形状：

output: 最终的 output 形状是 [seq_len, batch_size, hidden_size] = [3, 2, 4]。
- 对于每个时间步，每个句子的输出是一个4维的向量。
h_1: 最后一层的隐藏状态，形状是 [num_layers, batch_size, hidden_size] = [2, 2, 4]。
- 第一个维度是2，表示LSTM有2层，第二个维度是2，表示每批次有2个句子，第三个维度是4，表示每个隐藏状态是4维的。

4. LSTM输出示例

假设我们用output 和 h_1 来执行一次前向传播，得到如下：

import torch
import torch.nn as nn# 超参数
batch_size = 2
seq_len = 3
embedding_dim = 30
hidden_size = 4
num_layers = 2# 创建一个LSTM
lstm = nn.LSTM(embedding_dim, hidden_size, num_layers)# 假设每个词用30维向量表示，2个句子，每个句子3个单词
# 生成随机输入数据，假设已经通过embedding转换为词向量
input = torch.randn(seq_len, batch_size, embedding_dim)  # [3, 2, 30]# 初始化隐藏状态
h_0 = torch.zeros(num_layers, batch_size, hidden_size)  # [2, 2, 4]
c_0 = torch.zeros(num_layers, batch_size, hidden_size)  # [2, 2, 4]# 通过LSTM前向传播
output, (h_n, c_n) = lstm(input, (h_0, c_0))print("output shape:", output.shape)  # [3, 2, 4]
print("h_n shape:", h_n.shape)        # [2, 2, 4]
print("c_n shape:", c_n.shape)        # [2, 2, 4]

输出解释：

output 的形状是 [3, 2, 4]，表示LSTM对于每个时间步输出的隐藏状态。对于每个时间步（3个时间步），每个句子的输出是一个4维的向量（hidden_size=4）。
- output[0,:,:] 是第一个时间步所有句子的隐藏状态，形状为 [2, 4]（2个句子，每个句子的隐藏状态是4维）。
- output[1,:,:] 是第二个时间步所有句子的隐藏状态，形状为 [2, 4]。
- output[2,:,:] 是第三个时间步所有句子的隐藏状态，形状为 [2, 4]。
h_n 的形状是 [2, 2, 4]，表示LSTM最后一层（第2层）每个句子的隐藏状态。
- h_n[0,:,:] 是第一层（正向传播）的最后一个隐藏状态，形状为 [2, 4]。
- h_n[1,:,:] 是第二层（正向传播）的最后一个隐藏状态，形状为 [2, 4]。
c_n 的形状也是 [2, 2, 4]，表示LSTM最后一层（第2层）每个句子的细胞状态。

5. 为什么 `output[-1,:,:]` 是 `[2, 4]`

当我们选择 output[-1,:,:] 时，意味着我们选择了 最后一个时间步（第3个时间步）的所有样本的隐藏状态（hidden_size=4）。因此，output[-1,:,:] 的形状是 [batch_size, hidden_size] = [2, 4]。

总结

output 的形状是 [seq_len, batch_size, hidden_size]，表示每个时间步的所有样本的隐藏状态。
output[-1,:,:] 是 output 中最后一个时间步（seq_len 对应的时间步）的输出，其形状是 [batch_size, hidden_size]，即每个样本在最后一个时间步的隐藏状态。
h_n 是最后一层LSTM的最终隐藏状态，形状是 [num_layers, batch_size, hidden_size]。

通过这个具体的例子，你可以看到 output 和 h_n 如何与时间步和批次大小的维度相对应，并且为什么 output[-1,:,:] 是二维的，而不是三维的。

查看全文

http://www.dtcms.com/a/546556.html