一、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。违约：TrueFalse   weight_ih_l[k]_reverse – 类似于 weight_ih_l[k] 的相反方向。 仅当 时存在。bidirectional=True weight_hh_l[k]_reverse – 类似于 weight_hh_l[k] 的相反方向。 仅当 时存在。bidirectional=True bias_ih_l[k]_reverse – 类似于 bias_ih_l[k] 的相反方向。 仅当 时存在。bidirectional=True bias_hh_l[k]_reverse – 类似于 bias_hh_l[k] 的相反方向。 仅当 时存在。bidirectional=True
proj_size	如果 ，将使用 LSTM 和相应大小的投影。默认值：0> 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.0return 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_sizeself.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, hiddenmodel = 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 = 20for 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)