LSTM原理与前向代码实现

心已赠人 2022-03-14 08:40 234阅读 0赞

# 1. LSTM原理 #

LSTM是对序列数据进行处理的网络，首先这里给出LSTM的结构图，先知道它长什么样子吧。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fYnVkZHk_size_16_color_FFFFFF_t_70]  
网上很多的介绍给出LSTM有四个门，一个细胞状态，这里从程序编写的较多多了一个 g \_ t g\\\_t g\_t。那么对于这些的数学表达式怎么表述的呢？看下面的公式，下面这些公式代表了在实际运算过程中矩阵的运算关系，理解这个公式后面编写相关代码就容易多了，其中 σ \\sigma σ代表 s i g m o i d sigmoid sigmoid激活函数。  
对于输入门：  
 i \_ t : = σ \[ W h i ∗ h t − 1 + W x i ∗ x t + b i \] i\\\_t := \\sigma \[ W\_\{hi\} \* h\_\{t-1\} + W\_\{xi\} \* x\_t + b\_i \] i\_t:=σ\[Whi∗ht−1\+Wxi∗xt\+bi\]  
对于遗忘门：  
 f \_ t : = σ \[ W h f ∗ h t − 1 + W x f ∗ x t + b f \] f\\\_t := \\sigma \[ W\_\{hf\} \* h\_\{t-1\} + W\_\{xf\} \* x\_t + b\_f \] f\_t:=σ\[Whf∗ht−1\+Wxf∗xt\+bf\]  
对于输出门：  
 o \_ t : = σ \[ W h o ∗ h t − 1 + W x o ∗ x t + b o \] o\\\_t := \\sigma \[ W\_\{ho\} \* h\_\{t-1\} + W\_\{xo\} \* x\_t + b\_o \] o\_t:=σ\[Who∗ht−1\+Wxo∗xt\+bo\]  
对于 g t g\_t gt  
 g \_ t : = tanh ⁡ \[ W h g ∗ h t − 1 + W x g ∗ x t + b g \] g\\\_t := \\tanh\[ W\_\{hg\} \* h\_\{t-1\} + W\_\{xg\} \* x\_t + b\_g \] g\_t:=tanh\[Whg∗ht−1\+Wxg∗xt\+bg\]  
对于cell\_state：  
 c \_ t : = ( f \_ t . ∗ c t − 1 ) + ( i t . ∗ g \_ t ) c\\\_t := (f\\\_t .\* c\_\{t-1\}) + (i\_t .\* g\\\_t) c\_t:=(f\_t.∗ct−1)\+(it.∗g\_t)  
隐状态更新：  
 h \_ t : = o \_ t . ∗ tanh ⁡ \[ c t \] h\\\_t := o\\\_t .\* \\tanh\[c\_t\] h\_t:=o\_t.∗tanh\[ct\]

# 2. 代码实现 #

这里讲解的代码来自于[ncnn][]中的LSTM层，由于其是展开的形式因而较好理解，但是ncnn中的LSTM层是存在错误的，运算的时候是不会报错的，但是结果会不对，这里对其将其指出（后面分析之后并不是之前指出的问题，可能是激活函数不一样造成的）。  
首先，来看参数的载入吧，这里在于了偏置参数、与输入数据相关参数与隐状态相关参数：

int LSTM::load_model(const ModelBin& mb)
    { 
        int size = weight_data_size / num_output / 4;	//这里的size和输入数据
    
        // raw weight data
    	// 与输入数据x相关的权重，维度：[size, num_output*4]
        weight_xc_data = mb.load(size, num_output * 4, 0);
        if (weight_xc_data.empty())
            return -100;
    
    	// 四个门的偏置权重，维度：[4, num_output]
        bias_c_data = mb.load(4, num_output, 0);
        if (bias_c_data.empty())
            return -100;
    	
    	// 与隐状态相关的权重，维度：[num_output, num_output*4]
        weight_hc_data = mb.load(num_output, num_output * 4, 0);
        if (weight_hc_data.empty())
            return -100;
    
        return 0;
    }

接下来就是LSTM的前向运算部分了，上面的参数size与这里每帧数据的长度是一样的。

int LSTM::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
    { 
        // size x T
        const Mat& input_blob = bottom_blobs[0];
    
        size_t elemsize = input_blob.elemsize;
    
        // T, 0 or 1 each
    	//隐状态标志 维度：[T, 1]，为1的时候考虑隐状态
    	//但是都初始化为0了-_-||，这个参数没啥存在的必要
        const Mat& cont_blob = bottom_blobs[1];	
    
        int T = input_blob.h;		//LSTM输入数据的帧数
        int size = input_blob.w;	//LSTM输入数据每一帧的长度
    
        // initial hidden state 维度：[num_output, 1]
        Mat hidden(num_output, 4u, opt.workspace_allocator);
        if (hidden.empty())
            return -100;
        hidden.fill(0.f);
    
        // internal cell state 维度：[num_output, 1]
        Mat cell(num_output, 4u, opt.workspace_allocator);
        if (cell.empty())
            return -100;
        // 4 x num_output 维度：[4, num_output]
        Mat gates(4, num_output, 4u, opt.workspace_allocator);
        if (gates.empty())
            return -100;
    
        Mat& top_blob = top_blobs[0];
        top_blob.create(num_output, T, elemsize, opt.blob_allocator);  //维度：[num_output, T]
        if (top_blob.empty())
            return -100;
    
        // unroll
        for (int t=0; t<T; t++)
        { 
            // clip hidden by continuation indicator
            // h_cont_{t-1} = cont_t * h_{t-1}
            // h_cont_{t-1} = h_{t-1} if cont_t == 1
            // 0 otherwise
            // calculate hidden
            // gate_input_t := W_hc * h_conted_{t-1} + W_xc * x_t + b_c
            const int cont = ((const int*)cont_blob)[t];
            const float* x = input_blob.row(t);
            for (int q=0; q<num_output; q++)
            { 
                //float h_cont = cont ? hidden[q] : 0.f;
    			//得到偏置参数的地址
                const float* I_bias_c_data_ptr = (const float*)bias_c_data;	//维度：[num_output, 1]
                const float* F_bias_c_data_ptr = (const float*)bias_c_data + num_output;
                const float* O_bias_c_data_ptr = (const float*)bias_c_data + 2 * num_output;
                const float* G_bias_c_data_ptr = (const float*)bias_c_data + 3 * num_output;
    
                //const float* bias_c_data_ptr = (const float*)bias_c_data + 4 * q;
    			//得到四个门输出在num_output为q处的地址
                float* gates_data = (float*)gates + 4 * q;	//维度：[4, 1]
    
                // gate I F O G
    			//得到四个门输入参数在num_output为q处的地址
                const float* weight_hc_data_I = (const float*)weight_hc_data + weight_hc_data.w * q;	//维度：[num_output, num_output]
                const float* weight_xc_data_I = (const float*)weight_xc_data + weight_xc_data.w * q;	//维度：[size, num_output] weight_xc_data.w=size
                const float* weight_hc_data_F = (const float*)weight_hc_data + weight_hc_data.w * q + num_output * num_output;
                const float* weight_xc_data_F = (const float*)weight_xc_data + weight_xc_data.w * q + num_output * size;
                const float* weight_hc_data_O = (const float*)weight_hc_data + weight_hc_data.w * q + num_output * num_output * 2;
                const float* weight_xc_data_O = (const float*)weight_xc_data + weight_xc_data.w * q + num_output * size * 2;
                const float* weight_hc_data_G = (const float*)weight_hc_data + weight_hc_data.w * q + num_output * num_output * 3;
                const float* weight_xc_data_G = (const float*)weight_xc_data + weight_xc_data.w * q + num_output * size * 3;
    
                float I = I_bias_c_data_ptr[q];
                float F = F_bias_c_data_ptr[q];
                float O = O_bias_c_data_ptr[q];
                float G = G_bias_c_data_ptr[q];
    
    			//得到四个门权值参数（与输入x相关）与输入数据x=input_blob[t,:]相乘的结果
                for (int i=0; i<size; i++)
                { 
                    I += weight_xc_data_I[i] * x[i];	
                    F += weight_xc_data_F[i] * x[i];
                    O += weight_xc_data_O[i] * x[i];
                    G += weight_xc_data_G[i] * x[i];
                }
    			//得到四个门权值参数（与隐状态相关）与输入数据x=input_blob[t,:]相乘的结果
                for (int i=0; i<num_output; ++i){ 
                    I += weight_hc_data_I[i] * (cont == 0? 0: hidden[i]);
                    F += weight_hc_data_F[i] * (cont == 0? 0: hidden[i]);
                    O += weight_hc_data_O[i] * (cont == 0? 0: hidden[i]);
                    G += weight_hc_data_G[i] * (cont == 0? 0: hidden[i]);
                }
    			//保存四个门在当前num_ouput位置为q处的输出
                gates_data[0] = I;
                gates_data[1] = F;
                gates_data[2] = O;
                gates_data[3] = G;
            }
    
            // lstm unit
            // sigmoid(I)
            // sigmoid(F)
            // sigmoid(O)
            // tanh(G)
            // c_t := f_t .* c_{t-1} + i_t .* g_t
            // h_t := o_t .* tanh[c_t]
    		// 上面得到了四个门的输入，接下来就是计算通过激活函数之后门的输出
    		// 更新cell和hidden的状态，计算当前当前时刻t的输出num_output
            float* output_data = top_blob.row(t);
            for (int q=0; q<num_output; q++)
            { 
                float* gates_data = (float*)gates + 4 * q;
    
                float I = gates_data[0];
                float F = gates_data[1];
                float O = gates_data[2];
                float G = gates_data[3];
    	    
                I = 1.f / (1.f + exp(-I));
                F = cont ? 1.f / (1.f + exp(-F)) : 0.f;
                O = 1.f / (1.f + exp(-O));
                G = tanh(G);
    
                //cell[q] is not initialized and so might be nan, and 0*nan evals to nan
                float cell2 = cont ? F * cell[q] + I * G  : I * G;
                float H = O * tanh(cell2);
                cell[q] = cell2;
                hidden[q] = H;
                output_data[q] = H;
            }
    
            // no cell output here
        }
        return 0;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fYnVkZHk_size_16_color_FFFFFF_t_70]: /images/20220313/9907a33ddf9f4ae0acee0fce60912218.png
[ncnn]: https://github.com/Tencent/ncnn