LSTM有关问题

详细解释LSTM的公式

LSTM结构如图所示：

LSTM公式如图所示：

这些公式是长短期记忆网络（LSTM）的核心计算公式。下面我将解释每个等式左边变量的尺寸，并通过一个简单的例子说明。

1. $i_t$、$f_t$、$o_t$、$g_t$、$c_t$、$h_t$的尺寸

假设：

• 输入特征的维度为 $d_x$。
• 隐藏层单元的数量为 $d_h$。
• 批次大小为 $N$。

则公式中各变量的尺寸如下：

1. $i_t$：输入门的激活值，尺寸为 $(N,d_h)$。
2. $f_t$：遗忘门的激活值，尺寸为 $(N,d_h)$。
3. $g_t$：候选记忆单元的值，尺寸为 $(N,d_h)$。
4. $o_t$：输出门的激活值，尺寸为 $(N,d_h)$。
5. $c_t$：记忆单元的值，尺寸为 $(N,d_h)$。
6. $h_t$：隐藏层状态，尺寸为 $(N,d_h)$。

2. 举例说明

假设我们有以下配置：

• 批次大小 $N=4$
• 输入特征维度 $d_x=3$
• 隐藏层单元数 $d_h=5$

那么每个变量的尺寸如下：

• $i_t$, $f_t$, $g_t$, $o_t$, $c_t$, $h_t$ 都将是 $(4,5)$ 的矩阵，表示每个时间步中，每个批次中的每个样本有5个隐藏单元的值。

3. LSTM公式中的权重和偏置尺寸

LSTM中的权重和偏置的尺寸如下：

• $W_{ix},W_{fx},W_{gx},W_{ox}$ 是输入到隐状态的权重矩阵，尺寸为 $(d_x,d_h)$。
• $W_{ih},W_{fh},W_{gh},W_{oh}$ 是隐状态到隐状态的权重矩阵，尺寸为 $(d_h,d_h)$。
• $b_{ii},b_{if},b_{ig},b_{io}$是偏置向量，尺寸为 $(d_h,)$。

4. 详细尺寸计算例子

以批次大小 $N=4$，输入维度 $d_x=3$，隐藏单元数 $d_h=5$ 为例：

• 输入 $x_t$ 的尺寸为 $(4,3)$。
• 隐藏状态 $h_{t-1}$ 的尺寸为 $(4,5)$。
• $W_{ii}$的尺寸为 $(3,5)$。
• $W_{hi}$ 的尺寸为 $(5,5)$。
• 偏置 $b_{ii},b_{hi}$ 的尺寸为 $(5,)$。
• 经过矩阵运算后，输入门的激活值 $i_t$ 的尺寸为 $(4,5)$。

每个公式右边的计算结果都会是 $(N,d_h)$，也就是 $(4,5)$ 的矩阵。

详细解释下 $c_t$ 的计算式

在LSTM（长短期记忆网络）中，$c_t$ 代表的是记忆单元（Cell State），它是LSTM的重要组成部分，用于存储长期信息。$c_t$ 的计算公式如下：

$$c_t=f_t\odot c_{t-1}+i_t\odot g_t$$

公式中每个符号的含义

• $c_t$：当前时间步 $t$ 的记忆单元状态。
• $f_t$：遗忘门的激活值，用于决定前一时间步的记忆单元状态 $c_{t-1}$ 中有多少信息保留到当前时间步。尺寸为 $(N,d_h)$。
• $c_{t-1}$：前一时间步 $t-1$ 的记忆单元状态。尺寸为 $(N,d_h)$。
• $i_t$：输入门的激活值，用于决定当前时间步的输入 $x_t$ 中有多少信息用于更新当前的记忆单元。尺寸为 $(N,d_h)$。
• $g_t$：候选记忆单元的值，它是当前输入 $x_t$ 和前一时间步隐藏状态 $h_{t-1}$ 的综合信息，通过一个 $tanh$ 非线性变换生成，尺寸为 $(N,d_h)$。
• $\odot$：逐元素相乘（Hadamard 乘积），用于对矩阵或向量中的对应位置元素进行乘法运算。

计算步骤详解

1. 遗忘门的作用 ($f_t\odot c_{t-1}$)：

   • 遗忘门 $f_t$ 的输出是一个值在 $[0,1]$ 之间的向量，每个值决定了前一时间步记忆单元 $c_{t-1}$ 中相应部分有多少信息应该保留。
   • 如果某个位置上的值接近 0，表示遗忘该部分的信息；如果接近 1，表示保留该部分的信息。
   • 逐元素相乘 $f_t\odot c_{t-1}$ 的结果是一个新的向量，表示保留了哪些记忆。

2. 输入门的作用 ($i_t\odot g_t$)：

   • 输入门 $i_t$ 控制了当前时间步的输入 $x_t$ 和前一时间步的隐藏状态 $h_{t-1}$ 所产生的新信息 $g_t$ 的影响程度。
   • $g_t$ 是通过当前输入 $x_t$ 和前一时间步隐藏状态 $h_{t-1}$ 经过加权求和后，再通过 $tanh$ 激活函数获得的。
   • 逐元素相乘 $i_t\odot g_t$ 的结果是一个新的向量，表示新的候选记忆信息。

3. 更新记忆单元 ($c_t$)：

   • 通过将遗忘门的输出 $f_t\odot c_{t-1}$ 和输入门的输出 $i_t\odot g_t$ 相加，得到当前时间步的记忆单元状态 $c_t$。
   • 这个加法操作将遗忘的旧记忆和新的候选记忆进行结合，形成了当前时间步的记忆单元状态 $c_t$。

举例说明

假设我们有以下值：

• $f_t=[0.8,0.1,0.5]$
• $c_{t-1}=[1.0,0.5,-0.5]$
• $i_t=[0.7,0.9,0.3]$
• $g_t=[0.2,-0.3,0.6]$

则：

• $f_t\odot c_{t-1}=[0.8\times 1.0,0.1\times 0.5,0.5\times -0.5]=[0.8,0.05,-0.25]$
• $i_t\odot g_t=[0.7\times 0.2,0.9\times -0.3,0.3\times 0.6]=[0.14,-0.27,0.18]$
• $c_t=[0.8+0.14,0.05-0.27,-0.25+0.18]=[0.94,-0.22,-0.07]$

最终的 $c_t$ 代表了当前时间步 $t$ 的记忆单元状态，结合了前一时间步的记忆信息和当前时间步的输入信息。这种设计使得 LSTM 能够在长时间序列中有效地保持或更新必要的信息，避免传统 RNN 中的梯度消失问题。

pytorch中的LSTM模块的参数含义以及用法

PyTorch 的 nn.LSTM 模块是一个实现长短期记忆网络（LSTM）的封装，它是循环神经网络（RNN）的一种改进版本，用于处理和预测基于时间序列的数据。下面详细解释 LSTM 模块的参数及其用法。

1. nn.LSTM 模块参数

torch.nn.LSTM(input_size, hidden_size, num_layers=1, bias=True, batch_first=False, dropout=0, bidirectional=False)

参数说明：

• input_size: 输入特征的维度，即输入数据的每个时间步的特征数量。如果输入是一个序列，每个时间步包含 input_size 个特征。

• hidden_size: 隐藏状态的维度。LSTM 层的每个时间步的输出维度为 hidden_size。

• num_layers: LSTM 堆叠的层数。默认为 1。若 num_layers > 1，则是一个多层的 LSTM，前一层的输出将作为下一层的输入。

• bias: 如果为 True，则在计算门控单元时添加偏置。默认为 True。

• batch_first: 如果为 True，输入和输出的张量形状为 (batch, seq_len, feature)，否则形状为 (seq_len, batch, feature)。默认为 False。

• dropout: 如果 num_layers > 1 且 dropout > 0，则会在每个 LSTM 层之间应用 dropout，以防止过拟合。默认为 0。

• bidirectional: 如果为 True，则使用双向 LSTM。即每个时间步都会有两个隐藏状态：一个正向，一个反向。默认为 False。

2. 使用示例

import torch
import torch.nn as nn

# 参数定义
input_size = 10   # 输入特征维度
hidden_size = 20  # 隐藏状态维度
num_layers = 2    # LSTM的层数
batch_size = 5    # 批大小
seq_len = 7       # 序列长度

# 创建LSTM模型
lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)

# 创建随机输入数据 (batch_size, seq_len, input_size)
inputs = torch.randn(batch_size, seq_len, input_size)

# 初始化隐藏状态 (num_layers, batch_size, hidden_size)
h0 = torch.zeros(num_layers, batch_size, hidden_size)

# 初始化细胞状态 (num_layers, batch_size, hidden_size)
c0 = torch.zeros(num_layers, batch_size, hidden_size)

# 前向传播
output, (hn, cn) = lstm(inputs, (h0, c0))

# output: (batch_size, seq_len, hidden_size)
# hn: (num_layers, batch_size, hidden_size)
# cn: (num_layers, batch_size, hidden_size)

3. 解释代码

• inputs: 输入数据的形状为 (batch_size, seq_len, input_size)，表示批大小为 batch_size，序列长度为 seq_len，每个时间步的输入维度为 input_size。

• h0 和 c0: 初始的隐藏状态和细胞状态，形状为 (num_layers, batch_size, hidden_size)。

• output: LSTM 的输出，形状为 (batch_size, seq_len, hidden_size)，表示每个时间步的输出。

• hn 和 cn: 最后一个时间步的隐藏状态和细胞状态，形状为 (num_layers, batch_size, hidden_size)。

4. 在 LSTM 后添加线性层进行分类

假设你要将 LSTM 的输出传递到一个线性层进行分类，例如类别数为 output_size。

output_size = 3  # 分类类别数量
linear = nn.Linear(hidden_size, output_size)

# 取最后一个时间步的输出
final_output = output[:, -1, :]  # 形状为 (batch_size, hidden_size)

# 通过线性层
pred = linear(final_output)  # 形状为 (batch_size, output_size)

5. 总结

• input_size 控制输入特征的维度。
• hidden_size 控制隐藏状态的维度。
• num_layers 控制 LSTM 层数。
• 你可以通过 batch_first=True 控制输入输出的维度顺序。
• 输出可以通过线性层连接实现分类任务。

这套代码提供了一个简单的 LSTM 模型实例及其使用方式，你可以在这个基础上根据任务需要进行扩展和调整。

参考文献

pytorch中LSTM参数详解（一张图帮你更好的理解每一个参数）
Understanding LSTM Networks