LSTM模型计算详解

LSTM

写在前面

本文记录笔者在学习LSTM时的记录，相信读者已经在网上看过许多的LSTM博客与视频，与其他博客不同的是，本文会从数学公式的角度，剖析LSTM模型中各个部分的模型输入输出等维度信息，帮助初学者在公式层面理解LSTM模型，并且给出了相关计算的例子代入股票预测场景，并给出参考代码。

模型结构

LSTM的模型结构如下图所示。它由若干个重复的LSTM单元组成，每个单元内部包含遗忘门、输入门和输出门，以及当前时刻的单元状态和输出状态。

模型输入

LSTM模型，通常是处理一个序列（比如文本序列或时间序列）$X=(x_1,x_2,\dots ,x_t,\dots {)}^T$ ，每个时间步的输入可以表示为$x_t$，我们使用滑动窗口将序列分为若干个窗口大小为$L$的窗口，步长为$step$，当数据划分到最后，若不足为$L$不能构成窗口时，缺少的数据使用pad填充，通常为0填充或使用最近数据填充。例如，假设我们有$29$个时间步骤的输入，即$\vec{x}=(x_0,x_1,\dots ,x_{28}{)}^T$，且假设窗口大小为$10$，步长$step$也为$10$我们将数据分成三个窗口，即分为
$$\overrightarrow{x_1}=(x_0,x_1,\dots ,x_9{)}^T$$
$$\overrightarrow{x_2}=(x_{10},x_{11},\dots ,x_{19}{)}^T$$
$$\overrightarrow{x_3}=(x_{20},x_{21},\dots ,x_{28},x_{29}{)}^T$$
由于$x_{29}$的值不存在，我们将其值设为$0$或者$x_{28}$的值，即$\overrightarrow{x_3}=(x_{20},x_{21},\dots ,x_{28},0{)}^T$或者$\overrightarrow{x_3}=(x_{20},x_{21},\dots ,x_{28},x_{28}{)}^T$。

当步长$step$为$1$时，通常不会出现上面的情况，这也是我们使用的最多的一种滑动窗口划分方案。
例如，对于一个时序序列 X = { x 1 , x 2 , … , x 10 } X = \{x_1, x_2, \ldots, x_{10}\} X={x1​,x2​,…,x10​}，窗口大小 $L=3$，滑动步长 $step=1$，滑动窗口划分结果为：
$$\begin{array}{rl}\overrightarrow{x_1}& =(x_1,x_2,x_3)\\ \overrightarrow{x_2}& =(x_2,x_3,x_4)\\ \overrightarrow{x_3}& =(x_3,x_4,x_5)\\ \overrightarrow{x_4}& =(x_4,x_5,x_6)\\ \overrightarrow{x_5}& =(x_5,x_6,x_7)\\ \overrightarrow{x_6}& =(x_6,x_7,x_8)\\ \overrightarrow{x_7}& =(x_7,x_8,x_9)\\ \overrightarrow{x_8}& =(x_8,x_9,x_{10})\end{array}$$

LSTM 单元的输入包含当前时刻的输入$\overrightarrow{x_t}$、上一时刻的输出状态$h_{t-1}$以及上一时刻的单元状态$c_{t-1}$。在进行运算第一层LSTM单元时，我们会手动初始化$h_0$、$c_0$，而在后面的LSTM的单元中$h_{t-1}$和$c_{t-1}$，都可以由上一次的LSTM单元获得。$\overrightarrow{x_t}$、$h_{t-1}$、$c_{t-1}$分别代表当前时刻的输入信息、上一时刻的输出信息以及上一时刻的记忆信息。其中，$\overrightarrow{x_t}\in {\mathbb{R}}^{m\times 1}$，$m$是输入序列处理后的窗口大小（长度），$h_{t-1}$上一时刻的输出状态，形状为$h_{t-1}\in {\mathbb{R}}^{d\times 1}$，$d$是LSTM单元的隐藏状态大小，$c_{t-1}$是上一时刻的单元状态，形状为$c_{t-1}\in {\mathbb{R}}^{d\times 1}$，与$h_{t-1}$具有相同的形状。

我们通常会把$h_{t-1}$和$\overrightarrow{x_t}$拼在一起形成更长的向量$\overrightarrow{y_t}$，我们通常竖着拼，即 $\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$ ，如公式下所示，然后$\overrightarrow{y_t}$会传入各个门。当采用多批次时，$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times n}$。

$$\overrightarrow{y_t}=[h_{t-1};\overrightarrow{x_t}]=\left[\begin{array}{c}{h}_{t-1}\\ \overrightarrow{x_t}\end{array}\right]$$

遗忘门

遗忘门的输入为我们在模型输入中处理得到的$X_t^{\prime }$。我们将$X_t^{\prime }$与遗忘门中的权重矩阵$W_f$相乘再加上置偏值$b_f$，得到结果$M_f$。然后对$M_f$取Sigmoid，得到遗忘门的输出$f_t$，其形状与单元状态$c_t$相同，即 $f_t\in {\mathbb{R}}^{d\times 1}$，表示遗忘的程度。具体的计算公式如(\ref{LSTME02})所示。
$$M_f=W_f\overrightarrow{y_t}+b_f$$
$$f_t=\sigma (M_f)=\frac{1}{1+e^{-(W_f\overrightarrow{y_t}+b_f)}}$$
其中，$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$，$W_f\in {\mathbb{R}}^{d\times (d+m)}$，$b_f\in {\mathbb{R}}^{d\times 1}$，$f_t\in {\mathbb{R}}^{d\times 1}$。

在LSTM的许多门中，都使用Sigmoid函数，Sigmoid函数的绝大部分的值的取值范围为$(0,1)$，这可以很有效的表示在Sigmoid函数的输入中哪些数据需要记忆，哪些数据需要遗忘的过程。当Sigmoid函数只越接近$0$时表示遗忘，当接近$1$时表示需要记忆。

输入门

输入门的输入为我们在模型输入中处理得到的$\overrightarrow{y_t}$，且$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$。我们将$\overrightarrow{y_t}$与输入门中的权重矩阵$W_i$相乘再加上置偏值$b_i$，得到结果$M_i$，然后对$M_i$取Sigmoid，得到输入门的输出$i_t$，表示输入的重要程度。具体的计算公式如下所示。
$$M_i=W_i\overrightarrow{y_t}+b_i$$
$$i_t=\sigma (M_i)=\frac{1}{1+e^{-(W_i\overrightarrow{y_t}+b_i)}}$$
其中，$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times n}$，$W_i\in {\mathbb{R}}^{d\times (d+m)}$，$b_i\in {\mathbb{R}}^{d\times 1}$，$i_t\in {\mathbb{R}}^{d\times 1}$。

输出门

输出门的输入为我们在模型输入中处理得到的$\overrightarrow{y_t}$，且$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$。我们将$\overrightarrow{y_t}$与输出门中的权重矩阵$W_o$相乘再加上置偏值$b_o$，得到结果$M_o$，然后对$M_o$取Sigmoid，得到输出门的输出$o_t$，具体的计算公式如下所示。

$$M_o=W_o\overrightarrow{y_t}+b_o$$
$$o_t=\sigma (M_o)=\frac{1}{1+e^{-(W_o\overrightarrow{y_t}+b_o)}}$$
其中，$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$，$W_o\in {\mathbb{R}}^{d\times (d+m)}$，$b_o\in {\mathbb{R}}^{d\times 1}$，$o_t\in {\mathbb{R}}^{d\times 1}$。
​

当前输入单元状态

在计算$c_t$之前，我们需要引入当前输入单元状态，并计算$\widetilde{c_t}$的值。$\widetilde{c_t}$是当前输入的单元状态，表示当前输入要保留多少内容到记忆中。我们将$\overrightarrow{y_t}$与当前时刻状态单元的权重矩阵$W_c$相乘再加上置偏值$b_c$，得到结果$M_c$，然后对$M_c$取tanh，得到的输出$\widetilde{c_t}$。$\widetilde{c_t}$的计算如公式下所示。
$$M_c=W_c\overrightarrow{y_t}+b_c$$
$$\widetilde{c_t}=\text{tanh}(M_c)=\frac{e^{M_c}-e^{-M_c}}{e^{M_c}+e^{-M_c}}=\frac{(e^{W_c\overrightarrow{y_t}+b_c)}-e^{-(W_c\overrightarrow{y_t}+b_c)}}{(e^{W_c\overrightarrow{y_t}+b_c)}+e^{-(W_c\overrightarrow{y_t}+b_c)}}$$
其中，$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$，$W_c\in {\mathbb{R}}^{d\times (d+m)}$，$b_c\in {\mathbb{R}}^{d\times 1}$，$\widetilde{c_t}\in {\mathbb{R}}^{d\times 1}$。

当前输入单元状态中，使用了tanh函数，tanh函数的取值范围为$(-1,1)$，当函数的值接近$-1$时代表着当前输入信息要被修正，当但函数值接近$1$时，代码当前输入信息要被加强。

当前时刻单元状态

接下来我们进行当前时刻单元状态$c_t$的计算。我们使用遗忘门和输入门得到的结果 $f_t$、$i_t$和上一时刻单元状态$c_{t-1}$来计算当前时刻单元状态$c_t$。我们分别将$f_t$、$c_{t-1}$按元素相乘，$i_t$和$\widetilde{c_t}$按元素相乘，然后再将两者相加得到我们的当前时刻单元状态$c_t$。具体计算如公式下所示。
$$c_t=f_t\circ c_{t-1}+i_t\circ \widetilde{c_t}$$
其中，$f_t\in {\mathbb{R}}^{d\times 1}$时遗忘门输出，$i_t\in {\mathbb{R}}^{d\times 1}$是输入门输出，$\widetilde{c_t}\in {\mathbb{R}}^{d\times 1}$是当前输入状态单元，$c_{t-1}\in {\mathbb{R}}^{d\times 1}$ 是上一时刻状态单元，$\circ$表示 按元素乘。

模型输出

模型的输出是$h_t$和当前时刻的单元状态$c_t$，而$h_t$由当前时刻的单元状态$c_t$​和输出门的输出$o_t$确定。我们将当前时刻的单元状态$c_t$取 tanh得到$d_t$，然后将 $d_t$ 与 $o_t$按元素相乘得到最后的$h_t$，计算公式如下所示。通常，$h_t$会进一步传递给模型的上层或者作为最终的预测结果。
$$d_t=\text{tanh}(c_t)=\frac{e^{c_t}-e^{-c_t}}{e^{c_t}+e^{-c_t}}$$
$$h_t=o_t\circ d_t$$
其中 $h_t\in {\mathbb{R}}^{d\times 1}$ 为当前层隐藏状态，$o_t\in {\mathbb{R}}^{d\times 1}$为输出门的输出，$c_t\in {\mathbb{R}}^{d\times 1}$为当前时刻状态单元。

日期	开盘价	收盘价	最高价	最低价
4月23日	3038.6118	3021.9775	3044.9438	3016.5168
4月24日	3029.4028	3044.8223	3045.6399	3019.1238
4月25日	3037.9272	3052.8999	3060.2634	3034.6499
4月26日	3054.9793	3088.6357	3092.4300	3054.9793

Table: SH000001

简单的LSTM例子

接下来我们根据上面的模型结构中的计算方法来简单计算一个LSTM的例子。

我们以取中国A股上证指数（SH000001）2024年4月23日-25日共3个交易日的数据为例，取开盘价、收盘价、最高价、最低价作为特征，具体数据如表格所示。使用LSTM模型计算预测2024年4月26日的开盘价、收盘价、最高价、最低价，损失函数使用MSE。我们取隐藏层状态$d$的大小为$4$，然后进行计算，预测下一天的数据。

我们把表格数据处理成$x_t$的形式，也就是把每天的$4$个特征，转换成$m\times 1$即$(4\times 1)$的向量，然后我们得到以$X$的结果。

$$X=(\overrightarrow{x_1},\overrightarrow{x_2},\overrightarrow{x_3})=\left[\begin{array}{ccc}3038.6118& 3029.4028& 3037.9272\\ 3021.9775& 3044.8223& 3052.8999\\ 3044.9438& 3045.6399& 3060.2634\\ 3016.5168& 3019.1238& 3034.6499\end{array}\right]$$

由于隐藏层大小为 $d=4$，所以 $h_0$、$c_0$的维度都是 $4\times 1$，我们将 $h_0$和$c_0$进行初始化为$\vec{0}$向量，即

$$h_0=[0,0,0,0{]}^T,c_0=[0,0,0,0{]}^T$$

随后我们初始化 $W_f$、$W_i$、$W_c$、$W_o$（维度为$d\times (d+m)$，即 $4\times 8$以及$b_f$、$b_i$、$b_c$、$b_o$，$W$的元素值 $\in [-0.0001,0.0001]$，W是随机矩阵，如下所示。
$$W_f=\left[\begin{array}{cccccccc}-0.0005& -0.0010& -0.0010& -0.0004& -0.0008& -0.0006& -0.0006& -0.0007\\ 0.0004& -0.0009& -0.0006& 0.0009& 0.0001& 0.0004& 0.0009& 0.0003\\ -0.0005& -0.0006& 0.0007& -0.0003& -0.0003& 0.0001& 0.0004& 0.0006\\ -0.0007& -0.0008& 0.0007& -0.0006& 0.0005& -0.0003& -0.0010& -0.0002\end{array}\right]$$

$$W_i=\left[\begin{array}{cccccccc}-0.0006& -0.0001& -0.0003& 0.0002& 0.0008& 0.0000& -0.0003& -0.0003\\ 0.0007& -0.0002& 0.0006& 0.0001& -0.0009& -0.0005& -0.0007& -0.0005\\ -0.0008& 0.0004& 0.0007& -0.0008& -0.0008& 0.0010& -0.0006& -0.0009\\ -0.0005& 0.0010& -0.0006& -0.0002& -0.0002& 0.0006& -0.0007& 0.0002\end{array}\right]$$

$$W_c=\left[\begin{array}{cccccccc}0.0001& 0.0004& 0.0000& -0.0006& -0.0006& -0.0002& 0.0003& 0.0005\\ -0.0002& -0.0006& 0.0005& -0.0009& 0.0002& -0.0008& -0.0003& -0.0009\\ 0.0002& 0.0004& 0.0000& 0.0009& 0.0003& 0.0003& 0.0006& -0.0008\\ -0.0007& -0.0008& 0.0009& -0.0007& 0.0002& -0.0010& -0.0006& -0.0003\end{array}\right]$$

$$W_o=\left[\begin{array}{cccccccc}-0.0009& -0.0005& 0.0000& 0.0001& -0.0001& -0.0004& -0.0005& -0.0007\\ 0.0009& -0.0005& 0.0008& -0.0009& 0.0001& 0.0004& -0.0002& 0.0004\\ -0.0005& -0.0004& 0.0007& -0.0008& -0.0006& 0.0008& 0.0006& 0.0010\\ -0.0002& 0.0008& 0.0008& -0.0002& 0.0008& -0.0004& 0.0008& -0.0002\end{array}\right]$$

$b$全部初始化为单位列向量即

$$b_f=b_i=b_c=b_o={\left[\begin{array}{c}1\\ 1\\ 1\\ 1\end{array}\right]}^T$$

然后我们将$h_0$与$x_1$拼在一起作为 $\overrightarrow{y_1}$，即
$$\overrightarrow{y_1}=[h_0;\overrightarrow{x_1}]={\left[\begin{array}{cccccccc}0& 0& 0& 0& 3038.6118& 3021.9775& 3044.9438& 3016.5168\end{array}\right]}^T$$

我们依次计算遗忘门$f_1$，输入门$i_1$，输出门$o_1$，即

$$f_1=\sigma (W_f\overrightarrow{y_1}+b_f)=\left[\begin{array}{c}0.0008\\ 0.9985\\ 0.9713\\ 0.1164\end{array}\right],i_1=\sigma (W_i\overrightarrow{y_1}+b_i)=\left[\begin{array}{c}0.8514\\ 0.0010\\ 0.0568\\ 0.6491\end{array}\right],o_1=\sigma (W_o\overrightarrow{y_1}+b_o)=\left[\begin{array}{c}0.0198\\ 0.9577\\ 0.9981\\ 0.9842\end{array}\right]$$

随后我们进行计算当前输入单元状态$\widetilde{c_1}$，即

$$\widetilde{c_1}=\text{tanh}(W_c\overrightarrow{y_1}+b_c)={\left[\begin{array}{cccc}0.7923& -0.9997& 0.9805& -0.9994\end{array}\right]}^T$$

接着我们计算当前时刻单元状态$c_1$，即

$$c_1=f_1\circ c_0+i_1\circ \widetilde{c_1}=\left[\begin{array}{c}0.0008\\ 0.9985\\ 0.9713\\ 0.1164\end{array}\right]\circ \left[\begin{array}{c}0\\ 0\\ 0\\ 0\end{array}\right]+\left[\begin{array}{c}0.8514\\ 0.0010\\ 0.0568\\ 0.6491\end{array}\right]\circ \left[\begin{array}{c}0.7923\\ -0.9997\\ 0.9805\\ -0.9994\end{array}\right]=\left[\begin{array}{c}0.6746\\ -0.001\\ 0.0557\\ -0.6488\end{array}\right]$$

最后我们计算当前层隐藏层输出 $h_1$，即

$$h_1=o_1\circ d_1=o_1\circ \text{tanh}(c_1)={\left[\begin{array}{cccc}0.0116& -0.001& 0.0556& -0.5618\end{array}\right]}^T$$

这样我们就完成了一次LSTM单元的正向传播计算，我们得到了 $h_1$和$c_1$，我们将其传入下一层。

同理我们可以进行接下来 第$2$个交易日 的计算。
我们将$h_1$与$\overrightarrow{x_2}$拼在一起作为 $\overrightarrow{y_2}$，即

$$\overrightarrow{y_2}=[h_1;\overrightarrow{x_2}]={\left[\begin{array}{cccccccc}0.0116& -0.001& 0.0556& -0.5618& 3029.4028& 3044.8223& 3045.6399& 3019.1238\end{array}\right]}^T$$

我们依次计算遗忘门$f_2$，输入门$i_2$，输出门$o_2$，即

$$f_2=\sigma (W_f\overrightarrow{y_2}+b_f)=\left[\begin{array}{c}0.0008\\ 0.9985\\ 0.9715\\ 0.1151\end{array}\right],i_2=\sigma (W_i\overrightarrow{y_2}+b_i)=\left[\begin{array}{c}0.8503\\ 0.0010\\ 0.0583\\ 0.6527\end{array}\right],o_2=\sigma (W_o\overrightarrow{y_2}+b_o)=\left[\begin{array}{c}0.0196\\ 0.9581\\ 0.9981\\ .9839\end{array}\right]$$

随后我们进行计算当前输入单元状态$\widetilde{c_2}$，即

$$\widetilde{c_2}=\text{tanh}(W_c\overrightarrow{y_2}+b_c)={\left[\begin{array}{cccc}0.7935& -0.9998& 0.9806& -0.9994\end{array}\right]}^T$$

接着我们计算当前时刻单元状态$c_2$，即

$$c_2=f_2\circ c_1+i_2\circ \widetilde{c_2}={\left[\begin{array}{cccc}0.6747& -0.0010& 0.0571& -0.6524\end{array}\right]}^T$$

最后我们计算当前层隐藏层输出 $h_2$，即

$$h_2=o_2\circ d_2=o_2\circ \text{tanh}(c_2)={\left[\begin{array}{cccc}0.0115& -0.0010& 0.0570& -0.5640\end{array}\right]}^T$$

同理我们可以进行接下来 第$3$个交易日 的计算。
我们将$h_2$与$\overrightarrow{x_3}$拼在一起作为 $\overrightarrow{y_3}$，即

$$\overrightarrow{y_3}=[h_2;\overrightarrow{x_3}]={\left[\begin{array}{cccccccc}0.0115& -0.0010& 0.0570& -0.5640& 3037.9272& 3052.8999& 3060.2634& 3034.6499\end{array}\right]}^T$$

我们依次计算遗忘门$f_3$，输入门$i_3$，输出门$o_3$。

$$f_3=\sigma (W_f\overrightarrow{y_3}+b_f)=\left[\begin{array}{c}0.0008\\ 0.9985\\ 0.9719\\ 0.1135\end{array}\right],i_3=\sigma (W_i\overrightarrow{y_3}+b_i)=\left[\begin{array}{c}0.8501\\ 0.0010\\ 0.0572\\ 0.6518\end{array}\right],o_3=\sigma (W_o\overrightarrow{y_3}+b_o)=\left[\begin{array}{c}0.0192\\ 0.9584\\ 0.9982\\ 0.9841\end{array}\right]$$

随后我们进行计算当前输入单元状态$\widetilde{c_3}$，即

$$\widetilde{c_3}=\text{tanh}(W_c\overrightarrow{y_3}+b_c)={\left[\begin{array}{cccc}0.7956& -0.9998& 0.9807& -0.9994\end{array}\right]}^T$$

接着我们计算当前时刻单元状态$c_3$，即

$$c_3=f_3\circ c_2+i_3\circ \widetilde{c_3}={\left[\begin{array}{cccc}0.6763& -0.0010& 0.0561& -0.6515\end{array}\right]}^T$$

最后我们计算当前层隐藏层输出 $h_3$，即

$$h_3=o_3\circ d_3=o_3\circ \text{tanh}(c_3)={\left[\begin{array}{cccc}0.0113& -0.0010& 0.0559& -0.5636\end{array}\right]}^T$$

得到了 $h_3$之后，我们可以简单将$h_3$的结果作为预测的结果，然后使用MSE进行计算损失，MSE的计算公式如下所示。
$$\text{MSE}=\frac{1}{n}\sum _{i=1}^n(\widehat{y_i}-y_i{)}^2$$

$$\begin{gathered} \text{MSE}=\frac{1}{4}[(3054.9793-0.0113{)}^2+(3088.6357+0.0010{)}^2+(3092.43-0.0559{)}^2+(3054.9793+0.5636{)}^2] \\ =9437756.3022 \end{gathered}$$
然后我们就得到我们的损失为 $9437756.3022$。

以上就完成了一次将LSTM用于预测的计算。可以看到误差很大，实际应用中会先将数据输入到LSTM前，会进行一次归一化，在LSTM的输出后，会将隐藏层的结果进行一层线性映射，然后使用逆归一化，这样得到结果会比较接近我们的指数。

小结

LSTM模型的具体训练步骤如下：

1.LSTM 单元的输入包含当前时刻的输入$vec{x}_t$、上一时刻的输出状态$h_{t-1}$以及上一时刻的单元状态$c_{t-1}$。在进行运算第一层LSTM单元时，我们会手动初始化$h_0$、$c_0$，而在后面的LSTM的单元中$h_{t-1}$和$c_{t-1}$，都可以由上一次的LSTM单元获得。其中，$\overrightarrow{x_t}\in {\mathbb{R}}^{m\times 1}$，$m$是输入特征的维度，$h_{t-1}$上一时刻的输出状态，形状为$h_{t-1}\in {\mathbb{R}}^{d\times 1}$，$d$是LSTM单元的隐藏状态大小，$c_{t-1}$是上一时刻的单元状态，形状为$c_{t-1}\in {\mathbb{R}}^{d\times 1}$。

我们通常会把$h_{t-1}$和$\overrightarrow{x_t}$拼在一起形成更长的向量$\overrightarrow{y_t}$，我们通常竖着拼，即 $\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$ ，然后$\overrightarrow{y_t}$会传入各个门。
$$\overrightarrow{y_t}=[h_{t-1};\overrightarrow{x_t}]=\left[\begin{array}{c}{h}_{t-1}\\ \overrightarrow{x_t}\end{array}\right]$$

2.随后是计算各个门的输出，各个门的输入是$\overrightarrow{y_t}$。我们将$\overrightarrow{y_t}$与门中的权重矩阵$W$相乘再加上置偏值$b$，得到中间结果$M$。然后对$M$取Sigmoid，得到门的输出$g_t$，其形状与单元状态$c_t$相同，即 $g_t\in {\mathbb{R}}^{d\times 1}$。

$$f_t=\sigma (W_f{\overrightarrow{y_t}}^{\prime }+b_f)=\frac{1}{1+e^{-(W_f\overrightarrow{y_t}+b_f)}}$$
$$i_t=\sigma (W_i\overrightarrow{y_t}+b_i)=\frac{1}{1+e^{-(W_i\overrightarrow{y_t}+b_i)}}$$
$$o_t=\sigma (W_o\overrightarrow{y_t}+b_o)=\frac{1}{1+e^{-(W_f\overrightarrow{y_t}+b_o)}}$$
其中，$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$，$W_f、W_i、W_o\in {\mathbb{R}}^{d\times (d+m)}$，$b_f、b_i、b_o\in {\mathbb{R}}^{d\times 1}$，$f_t、i_t、o_t\in {\mathbb{R}}^{d\times 1}$。

​

3.计算当前输入单元状态$\widetilde{c_t}$的值，表示当前输入要保留多少内容到记忆中。我们将$\overrightarrow{y_t}$与当前时刻状态单元的权重矩阵$W_c$相乘再加上置偏值$b_c$，得到中间结果$M_c$，然后对$M_c$取tanh，得到输出$\widetilde{c_t}$。
$$\widetilde{c_t}=\text{tanh}(W_c\overrightarrow{y_t}+b_c)=\frac{e^{(W_c\overrightarrow{y_t}+b_c)}-e^{-(W_c\overrightarrow{y_t}+b_c)}}{e^{(W_c\overrightarrow{y_t}+b_c)}+e^{-(W_c\overrightarrow{y_t}+b_c)}}$$

其中，$\overrightarrow{y_t}\in {\mathbb{R}}^{(d+m)\times 1}$，$W_c\in {\mathbb{R}}^{d\times (d+m)}$，$b_c\in {\mathbb{R}}^{d\times 1}$，$\widetilde{c_t}\in {\mathbb{R}}^{d\times 1}$。

4.接下来我们进行当前时刻单元状态$c_t$的计算。我们使用遗忘门和输入门得到的结果 $f_t$、$i_t$和上一时刻单元状态$c_{t-1}$来计算当前时刻单元状态$c_t$。我们分别将$f_t$、$c_{t-1}$按元素相乘，$i_t$和$\widetilde{c_t}$按元素相乘，然后再将两者相加得到我们的但钱时刻单元状态$c_t$。
$$c_t=f_t\circ c_{t-1}+i_t\circ \widetilde{c_t}$$
其中，$f_t\in {\mathbb{R}}^{d\times 1}$时遗忘门输出，$i_t\in {\mathbb{R}}^{d\times 1}$是输入门输出，$\widetilde{c_t}\in {\mathbb{R}}^{d\times 1}$是当前输入状态单元，$c_{t-1}\in {\mathbb{R}}^{d\times 1}$ 是上一时刻状态单元，$\circ$表示 按元素乘。

5.最后模型的输出是$h_t$和当前时刻的单元状态$c_t$，而$h_t$由当前时刻的单元状态$c_t$​和输出门的输出$o_t$确定。我们将当前时刻的单元状态$c_t$取 tanh得到$d_t$，然后将 $d_t$ 与 $o_t$按元素相乘得到最后的$h_t$。
$$h_t=o_t\circ d_t=o_t\circ \text{tanh}(c_t)=\frac{e^{c_t}-e^{-c_t}}{e^{c_t}+e^{-c_t}}$$
其中 $h_t\in {\mathbb{R}}^{d\times 1}$ 为当前层隐藏状态，$o_t\in {\mathbb{R}}^{d\times 1}$为输出门的输出，$c_t\in {\mathbb{R}}^{d\times 1}$为当前时刻状态单元。

	import torch
	import torch.nn as nn
	import numpy as np
	import pandas as pd
	import matplotlib.pyplot as plt
	from sklearn.preprocessing import MinMaxScaler
	
	
	# 读取数据
	df = pd.read_csv('sh_data.csv')
	df = df.iloc[-30:, [2, 5, 3, 4]]
	df1 = df[25:28].reset_index(drop=True)
	df2 = df1.reset_index(drop=True)		
	
	data = df[['open', 'close', 'high', 'low']].values.astype(float)
	
	# 标准化数据
	scaler = MinMaxScaler(feature_range=(0, 1))
	data = scaler.fit_transform(data)
	
	# 创建时间序列数据
	def create_sequences(data, time_step=1):
		X, y = [], []
		for i in range(len(data) - time_step):
			X.append(data[i:(i + time_step)])
			y.append(data[i + time_step])
			return np.array(X), np.array(y)
	
	time_step = 2  # 时间步长设置为2天
	X, y = create_sequences(data, time_step)
	
	# 转换为PyTorch张量
	X = torch.FloatTensor(X)
	y = torch.FloatTensor(y)
	
	class LSTM(nn.Module):
		def __init__(self, input_size, hidden_layer_size, output_size):
			super(LSTM, self).__init__()
			self.hidden_layer_size = hidden_layer_size
			self.lstm = nn.LSTM(input_size, hidden_layer_size)
			self.linear = nn.Linear(hidden_layer_size, output_size)
			self.hidden_cell = (torch.zeros(1, 1, self.hidden_layer_size),
			torch.zeros(1, 1, self.hidden_layer_size))
	
		def forward(self, input_seq):
			lstm_out, self.hidden_cell = self.lstm(input_seq.view(len(input_seq), 1, -1), self.hidden_cell)
			predictions = self.linear(lstm_out.view(len(input_seq), -1))
			return predictions[-1]
	
	
	input_size = 4  # 输入特征数量
	hidden_layer_size = 4
	output_size = 4  # 输出特征数量
	
	model = LSTM(input_size=input_size, hidden_layer_size=hidden_layer_size, output_size=output_size)
	loss_function = nn.MSELoss()
	optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
	
	# epochs = 1
	# for i in range(epochs):
	#     for seq, labels in zip(X, y):
	#         optimizer.zero_grad()
	#         model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
	#                              torch.zeros(1, 1, model.hidden_layer_size))
	#         y_pred = model(seq)
	
	#         single_loss = loss_function(y_pred, labels)
	#         single_loss.backward()
	#         optimizer.step()
	
	#     if i % 10 == 0:
	#         print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')
	
	# 只进行一次训练
	seq, labels = X[0], y[0]
	optimizer.zero_grad()
	model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
	torch.zeros(1, 1, model.hidden_layer_size))
	y_pred = model(seq)
	single_loss = loss_function(y_pred, labels)
	single_loss.backward()
	optimizer.step()
	
	print(f'Single training loss: {single_loss.item():10.8f}')
	
	model.eval()
	
	# 预测下一天的四个特征
	with torch.no_grad():
		seq = torch.FloatTensor(data[-time_step:])
		model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
		torch.zeros(1, 1, model.hidden_layer_size))
		next_day = model(seq).numpy()
	
	# 将预测结果逆归一化
	next_day = scaler.inverse_transform(next_day.reshape(-1, output_size))
	
	print(f'Predicted features for the next day: open={next_day[0][0]}, close={next_day[0][1]}, high={next_day[0][2]}, low={next_day[0][3]}')
	
	
	# 获取训练集的预测值
	train_predict = []
	for seq in X:
		with torch.no_grad():
		model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
		torch.zeros(1, 1, model.hidden_layer_size))
		train_predict.append(model(seq).numpy())
	
	# 将预测结果逆归一化
	train_predict = scaler.inverse_transform(np.array(train_predict).reshape(-1, output_size))
	actual = scaler.inverse_transform(data)
	
	# 绘制图形
	plt.figure(figsize=(10, 6))
	
	for i, col in enumerate(['open', 'close', 'high', 'low']):
		plt.subplot(2, 2, i+1)
		plt.plot(actual[:, i], label=f'Actual {col}')
		plt.plot(range(time_step, time_step + len(train_predict)), train_predict[:, i], label=f'Train Predict {col}')
		plt.legend()
	
	plt.tight_layout()
	plt.show()