一、LSTM 与 BiLSTM对比
1.1、LSTM
LSTM（长短期记忆网络） 是一种改进的循环神经网络（RNN），专门解决传统RNN难以学习长期依赖的问题。它通过遗忘门、输入门和输出门来控制信息的流动，保留重要信息并丢弃无关内容，从而有效处理长序列数据。LSTM的核心是细胞状态，它像一条传送带，允许信息在不同时间步之间稳定传递，避免梯度消失或爆炸，适用于时间序列预测、语音识别等任务。
1.2、BiLSTM
BiLSTM（双向长短期记忆网络） 在LSTM的基础上增加反向处理层，同时捕捉过去和未来的上下文信息。前向LSTM按时间顺序处理序列，后向LSTM逆序处理，最终结合两个方向的输出，增强模型对全局上下文的理解。BiLSTM在自然语言处理任务（如机器翻译、命名实体识别）中表现优异，但计算成本更高。它特别适合需要双向信息交互的场景，如语义理解、情感分析等。
BiLSTM结构包含两个方向的LSTM网络：一个正向（forward）LSTM和一 个反向（backward）LSTM。
这两个方向的LSTM在模型训练过程中分别处理输入序列，最后的隐藏状态 由这两个方向的LSTM拼接而成。这样的结构使得模型能够同时考虑到输入 序列中每个位置的过去和未来信息，更全面地捕捉序列中的上下文信息。
如下面这个情感分类的例子，正向的LSTM按照从左到右的顺序处理“我”、 “爱”、“你”，反向的LSTM按照从右到左的顺序处理“你”、“爱”、“我”，然后 将两个LSTM的最后一个隐藏层拼接起来再经过softmax等处理得到分类结果。
举一个例子，如一句话“我今天很开心，因为我考试考了 100 分”要做情感 分类，LSTM只能从左到右的看，因此在看到“很开心”这个关键词时它获得 的只有上文的信息，而BiLSTM是双向的因此也能看到“因为我考试考了 100 分”这一部分，而这一部分对应最终结果是否准确有很大的帮助。
| 特征 | LSTM | BiLSTM |
|---|---|---|
| 方向性 | 单向(仅过去信息) | 双向(过去和未来信息) |
| 计算复杂度 | 较低 | 较高(约2倍) |
| 典型应用 | 时间序列预测、语言模型 | 文本分类、序列标注、机器翻译 |
| 内存需求 | 较少 | 较多 |
13、优势
BiLSTM相对于单向LSTM具有以下优势：
能够捕捉到输入序列中每个位置的过去和未来信息，更全面地捕捉序列 中的上下文信息。
可以更好地处理长距离的依赖关系。
在许多自然语言处理任务中都取得了良好的效果。
二、库函数-LSTM
torch.nn.LSTM(input_size, hidden_size, num_layers=1, bias=True, batch_first=False, dropout=0.0, bidirectional=False, proj_size=0, device=None, dtype=None)LSTM — PyTorch 2.7 documentation
| 参数 | 描述 |
| input_size | 输入 x 中预期特征的数量 |
| hidden_size | 处于隐藏状态 h 的特征数量 |
| num_layers | 循环层数。例如，设置意味着将两个 LSTM 堆叠在一起以形成一个堆叠的 LSTM。 第二个 LSTM 接收第一个 LSTM 的输出，并且 计算最终结果。默认值：1num_layers=2 |
| bias | 偏置如果 ，则层不使用 b_ih 和 b_hh 的偏差权重。 违约：FalseTrue |
| batch_first | 如果 ，则提供输入和输出张量 作为 （batch， seq， feature） 而不是 （seq， batch， feature）。 请注意，这不适用于隐藏状态或单元格状态。请参阅 Inputs/Outputs 部分了解详细信息。违约：TrueFalse |
| dropout | 如果为非零，则在每个 除最后一层外的 LSTM 层，其 dropout 概率等于 。默认值：0dropout |
| bidirectional | 如果 ，则变为双向 LSTM。违约：
|
| proj_size | 如果 ，将使用 LSTM 和相应大小的投影。默认值：0 |
import torch
import numpy as np
from torch import nn
# 1.字符输入
text = "In Beijing Sarah bought a basket of apples In Guangzhou Sarah bought a basket of bananas"
torch.manual_seed(1)
# 3.数据集划分
input_seq = [text[:-1]]
output_seq = [text[1:]]
print("input_seq:", input_seq)
# print("output_seq:", output_seq)
# 4.数据编码：one-hot
chars = set(text)
chars = sorted(chars)
# print("chars:", chars)
# {" ":0, "a":1 }
char2int = {char: ind for ind, char in enumerate(chars)}
# print("char2int:", char2int)
# {0:" ", 1: "a"}
int2char = dict(enumerate(chars))
# 将字符转成数字编码
input_seq = [[char2int[char] for char in seq] for seq in input_seq]
# print("input_seq:", input_seq)
output_seq = [[char2int[char] for char in seq] for seq in output_seq]
# one-hot 编码，pytorch的RNN的输入张量的填充
def one_hot_encode(seq, bs, seq_len, size):
features = np.zeros((bs, seq_len, size), dtype=np.float32)
for i in range(bs):
for u in range(seq_len):
features[i, u, seq[i][u]] = 1.0
return torch.tensor(features, dtype=torch.float32)
input_seq = one_hot_encode(input_seq, 1, len(text)-1, len(chars))
output_seq = torch.tensor(output_seq, dtype=torch.long).view(-1)
print("output_seq:", output_seq)
# 5.定义前向模型
class Model(nn.Module):
def __init__(self, input_size, hidden_size, out_size):
super(Model, self).__init__()
self.hidden_size = hidden_size
self.bilstm1 = nn.LSTM(input_size, hidden_size, num_layers=1, batch_first=True, bidirectional=True)
self.fc1 = nn.Linear(hidden_size * 2, out_size)
def forward(self, x):
out, hidden = self.bilstm1(x)
x = out.contiguous().view(-1, self.hidden_size * 2)
x = self.fc1(x)
return x, hidden
model = Model(len(chars), 32, len(chars))
# 6.定义损失函数和优化器
cri = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
# 7.开始迭代
epochs = 1000
for epoch in range(1, epochs+1):
output, hidden = model(input_seq)
loss = cri(output, output_seq)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 8.显示频率设置
if epoch == 0 or epoch % 50 == 0:
print(f"Epoch [{epoch}/{epochs}], Loss {loss:.4f}")
# print("input_seq.shape:", input_seq.shape)
# print("hidden.shape:", hidden.shape)
# print("output.shape:", output.shape)
# print("input_w:", model.rnn1.weight_ih_l0.shape)
# 预测下面几个字符
input_text = "In Beijing Sarah bought a basket of" # re
to_be_pre_len = 20
for i in range(to_be_pre_len):
chars = [char for char in input_text]
# print(chars)
character = np.array([[char2int[c] for c in chars]])
character = one_hot_encode(character, 1, character.shape[1], 23)
character = torch.tensor(character, dtype=torch.float32)
out, hidden = model(character)
char_index = torch.argmax(out[-1]).item()
input_text += int2char[char_index]
print("预测到的:", input_text)
