1.軟件版本

matlab2021a

2.本算法理論知識

??? 長短時記憶模型LSTM是由Hochreiter等人在1997年首次提出的，其主要原理是通過一種特殊的神經元結構用來長時間存儲信息。LSTM網絡模型的基本結構如下圖所示：

圖1 LSTM網絡的基本結構

??? 從圖1的結構圖可知，LSMT網絡結構包括輸入層，記憶模塊以及輸出層三個部分，其中記憶模塊由輸入門（Input Gate）、遺忘門（Forget Gate）以及輸出門（Output Gate）。LSTM模型通過這三個控制門來控制神經網絡中所有的神經元的讀寫操作。

??? LSTM模型的基本原理是通過多個控制門來抑制RNN神經網絡梯度消失的缺陷。通過LSTM模型可以在較長的時間內保存梯度信息，延長信號的處理時間，因此LSTM模型適合處理各種頻率大小的信號以及高低頻混合信號。LSTM模型中的記憶單元中輸入門（Input Gate）、遺忘門（Forget Gate）以及輸出門（Output Gate）通過控制單元組成非線性求和單元。其中輸入門、遺忘門以及輸出門三個控制門的激活函數為Sigmoid函數，通過該函數實現控制門“開”和“關”狀態的改變。

??? 下圖為LSTM模型中記憶模塊的內部結構圖：

?

圖2 LSTM網絡的記憶單元內部結構

??? 從圖2的結構圖可知，LSTM的記憶單元的工作原理為，當輸入門進入”開“狀態，那么外部信息由記憶單元讀取信息，當輸入門進入“關”狀態，那么外部信息無法進入記憶單元。同理，遺忘門和輸出門也有著相似的控制功能。LSTM模型通過這三個控制門將各種梯度信息長久的保存在記憶單元中。當記憶單元進行信息的長時間保存的時候，其遺忘門處于“開”狀態，輸入門處于“關”狀態。

??? 當輸入門進入“開”狀態之后，記憶單元開始接受到外部信息并進行存儲。當輸入門進入“關”狀態之后，記憶單元暫停接受外部信息，同時，輸出門進入“開”狀態，記憶單元中保存的信息傳輸到后一層。而遺忘門的功能則是在必要的時候對神經元的狀態進行重置。

??? 對于LSTM網絡模型的前向傳播過程，其涉及到的各個數學原理如下：

?

?2.遺忘門計算過程如下所示：

? ? ? ?

?3.記憶單元計算過程如下所示：

?4.輸出門計算過程如下所示：

?5.記憶單元輸出計算過程如下所示：

對于LSTM網絡模型的反向傳播過程，其涉及到的各個數學原理如下：

?6.輸入門計算過程如下所示：

??? 基于LSTM網絡的視覺識別算法，其整體算法流程圖如下圖所示：

????????????????????????? ??????

?

圖3基于LSTM網絡的視覺識別算法流程圖

根據圖3的算法流程圖，本文所要研究的基于LSTM網絡的視覺識別算法步驟為：

??? 步驟一：圖像的采集，本文以人臉圖像為研究對象。

??? 步驟二：圖像預處理，根據本章2節的內容對所需要識別的視覺圖像進行預處理，獲得較為清晰的圖像。

??? 步驟三：圖像分割，將圖像進行分割，分割大小根據采集圖像的識別目標和整體場景大小關系進行確定，將原始的圖像分割為大小的子圖像。

??? 步驟四：子圖幾何元素提取，通過邊緣提取方法，獲得每個子圖中所包含的幾何元素，并將各個幾何元素構成句子信息。

??? 步驟五：將句子信息輸入到LSTM網絡，這個步驟也是核心環節，下面對LSTM網絡的識別過程進行介紹。首先，將句子信息通過LSTM的輸入層輸入到LSTM網絡中，基本結構圖如下圖所示：

圖3基于LSTM網絡的識別結構圖

??? 這里假設LSTM某一時刻的輸入特征信息和輸出結果為和，其記憶模塊中的輸入和輸出為和，和表示LSTM神經元的激活函數的輸出和隱含層的輸出，整個LSTM的訓練流程為：

3.核心代碼

---

function nn = func_LSTM(train_x,train_y,test_x,test_y);binary_dim = 8; largest_number = 2^binary_dim - 1; binary = cell(largest_number, 1);for i = 1:largest_number + 1binary{i} = dec2bin(i-1, binary_dim);int2binary{i} = binary{i}; end%input variables alpha = 0.000001; input_dim = 2; hidden_dim = 32; output_dim = 1;%initialize neural network weights %in_gate = sigmoid(X(t) * U_i + H(t-1) * W_i) U_i = 2 * rand(input_dim, hidden_dim) - 1; W_i = 2 * rand(hidden_dim, hidden_dim) - 1; U_i_update = zeros(size(U_i)); W_i_update = zeros(size(W_i));%forget_gate = sigmoid(X(t) * U_f + H(t-1) * W_f) U_f = 2 * rand(input_dim, hidden_dim) - 1; W_f = 2 * rand(hidden_dim, hidden_dim) - 1; U_f_update = zeros(size(U_f)); W_f_update = zeros(size(W_f));%out_gate = sigmoid(X(t) * U_o + H(t-1) * W_o) U_o = 2 * rand(input_dim, hidden_dim) - 1; W_o = 2 * rand(hidden_dim, hidden_dim) - 1; U_o_update = zeros(size(U_o)); W_o_update = zeros(size(W_o));%g_gate = tanh(X(t) * U_g + H(t-1) * W_g) U_g = 2 * rand(input_dim, hidden_dim) - 1; W_g = 2 * rand(hidden_dim, hidden_dim) - 1; U_g_update = zeros(size(U_g)); W_g_update = zeros(size(W_g));out_para = 2 * zeros(hidden_dim, output_dim) ; out_para_update = zeros(size(out_para)); % C(t) = C(t-1) .* forget_gate + g_gate .* in_gate % S(t) = tanh(C(t)) .* out_gate % Out = sigmoid(S(t) * out_para) %train iter = 9999; % training iterations for j = 1:iter% generate a simple addition problem (a + b = c)a_int = randi(round(largest_number/2)); % int versiona = int2binary{a_int+1}; % binary encodingb_int = randi(floor(largest_number/2)); % int versionb = int2binary{b_int+1}; % binary encoding% true answerc_int = a_int + b_int; % int versionc = int2binary{c_int+1}; % binary encoding% where we'll store our best guess (binary encoded)d = zeros(size(c));% total erroroverallError = 0;% difference in output layer, i.e., (target - out)output_deltas = [];% values of hidden layer, i.e., S(t)hidden_layer_values = [];cell_gate_values = [];% initialize S(0) as a zero-vectorhidden_layer_values = [hidden_layer_values; zeros(1, hidden_dim)];cell_gate_values = [cell_gate_values; zeros(1, hidden_dim)];% initialize memory gate% hidden layerH = [];H = [H; zeros(1, hidden_dim)];% cell gateC = [];C = [C; zeros(1, hidden_dim)];% in gateI = [];% forget gateF = [];% out gateO = [];% g gateG = [];% start to process a sequence, i.e., a forward pass% Note: the output of a LSTM cell is the hidden_layer, and you need to for position = 0:binary_dim-1% X ------> input, size: 1 x input_dimX = [a(binary_dim - position)-'0' b(binary_dim - position)-'0'];% y ------> label, size: 1 x output_dimy = [c(binary_dim - position)-'0']';% use equations (1)-(7) in a forward pass. here we do not use biasin_gate = sigmoid(X * U_i + H(end, :) * W_i); % equation (1)forget_gate = sigmoid(X * U_f + H(end, :) * W_f); % equation (2)out_gate = sigmoid(X * U_o + H(end, :) * W_o); % equation (3)g_gate = tanh(X * U_g + H(end, :) * W_g); % equation (4)C_t = C(end, :) .* forget_gate + g_gate .* in_gate; % equation (5)H_t = tanh(C_t) .* out_gate; % equation (6)% store these memory gatesI = [I; in_gate];F = [F; forget_gate];O = [O; out_gate];G = [G; g_gate];C = [C; C_t];H = [H; H_t];% compute predict outputpred_out = sigmoid(H_t * out_para);% compute error in output layeroutput_error = y - pred_out;% compute difference in output layer using derivative% output_diff = output_error * sigmoid_output_to_derivative(pred_out);output_deltas = [output_deltas; output_error];% compute total erroroverallError = overallError + abs(output_error(1));% decode estimate so we can print it outd(binary_dim - position) = round(pred_out);end% from the last LSTM cell, you need a initial hidden layer differencefuture_H_diff = zeros(1, hidden_dim);% stare back-propagation, i.e., a backward pass% the goal is to compute differences and use them to update weights% start from the last LSTM cellfor position = 0:binary_dim-1X = [a(position+1)-'0' b(position+1)-'0'];% hidden layerH_t = H(end-position, :); % H(t)% previous hidden layerH_t_1 = H(end-position-1, :); % H(t-1)C_t = C(end-position, :); % C(t)C_t_1 = C(end-position-1, :); % C(t-1)O_t = O(end-position, :);F_t = F(end-position, :);G_t = G(end-position, :);I_t = I(end-position, :);% output layer differenceoutput_diff = output_deltas(end-position, :); % H_t_diff = (future_H_diff * (W_i' + W_o' + W_f' + W_g') + output_diff * out_para') ... % .* sigmoid_output_to_derivative(H_t);% H_t_diff = output_diff * (out_para') .* sigmoid_output_to_derivative(H_t);H_t_diff = output_diff * (out_para') .* sigmoid_output_to_derivative(H_t);% out_para_diff = output_diff * (H_t) * sigmoid_output_to_derivative(out_para);out_para_diff = (H_t') * output_diff;% out_gate diferenceO_t_diff = H_t_diff .* tanh(C_t) .* sigmoid_output_to_derivative(O_t);% C_t differenceC_t_diff = H_t_diff .* O_t .* tan_h_output_to_derivative(C_t);% forget_gate_diffeenceF_t_diff = C_t_diff .* C_t_1 .* sigmoid_output_to_derivative(F_t);% in_gate differenceI_t_diff = C_t_diff .* G_t .* sigmoid_output_to_derivative(I_t);% g_gate differenceG_t_diff = C_t_diff .* I_t .* tan_h_output_to_derivative(G_t);% differences of U_i and W_iU_i_diff = X' * I_t_diff .* sigmoid_output_to_derivative(U_i);W_i_diff = (H_t_1)' * I_t_diff .* sigmoid_output_to_derivative(W_i);% differences of U_o and W_oU_o_diff = X' * O_t_diff .* sigmoid_output_to_derivative(U_o);W_o_diff = (H_t_1)' * O_t_diff .* sigmoid_output_to_derivative(W_o);% differences of U_o and W_oU_f_diff = X' * F_t_diff .* sigmoid_output_to_derivative(U_f);W_f_diff = (H_t_1)' * F_t_diff .* sigmoid_output_to_derivative(W_f);% differences of U_o and W_oU_g_diff = X' * G_t_diff .* tan_h_output_to_derivative(U_g);W_g_diff = (H_t_1)' * G_t_diff .* tan_h_output_to_derivative(W_g);% updateU_i_update = U_i_update + U_i_diff;W_i_update = W_i_update + W_i_diff;U_o_update = U_o_update + U_o_diff;W_o_update = W_o_update + W_o_diff;U_f_update = U_f_update + U_f_diff;W_f_update = W_f_update + W_f_diff;U_g_update = U_g_update + U_g_diff;W_g_update = W_g_update + W_g_diff;out_para_update = out_para_update + out_para_diff;endU_i = U_i + U_i_update * alpha; W_i = W_i + W_i_update * alpha;U_o = U_o + U_o_update * alpha; W_o = W_o + W_o_update * alpha;U_f = U_f + U_f_update * alpha; W_f = W_f + W_f_update * alpha;U_g = U_g + U_g_update * alpha; W_g = W_g + W_g_update * alpha;out_para = out_para + out_para_update * alpha;U_i_update = U_i_update * 0; W_i_update = W_i_update * 0;U_o_update = U_o_update * 0; W_o_update = W_o_update * 0;U_f_update = U_f_update * 0; W_f_update = W_f_update * 0;U_g_update = U_g_update * 0; W_g_update = W_g_update * 0;out_para_update = out_para_update * 0;endnn = newgrnn(train_x',train_y(:,1)',mean(mean(abs(out_para)))/2);

4.操作步驟與仿真結論

??? 通過本文的LSTM網絡識別算法，對不同干擾大小采集得到的人臉進行識別，其識別正確率曲線如下圖所示：

?

??? 從圖2的仿真結果可知，隨著對采集圖像干擾的減少，本文所研究的LSTM識別算法具有最好的識別準確率，RNN神經網絡與基于卷積的深度神經網絡，其識別率相當，普通的神經網絡，其識別率性能明顯較差。具體的識別率大小如下表所示：

表1 四種對比算法的識別率

算法	-15db	-10db	-5db	0db	5db	10db	15db
NN	17.5250	30.9500	45.0000	52.6000	55.4750	57.5750	57.6000
RBM	19.4000	40.4500	58.4750	67.9500	70.4000	72.2750	71.8750
RNN	20.6750	41.1500	60.0750	68.6000	72.5500	73.3500	73.3500
LSTM	23.1000	46.3500	65.0250	72.9500	75.6000	76.1000	76.3250

5.參考文獻

[01]米良川,楊子夫,李德升等.自動機器人視覺控制系統[J].工業控制計算機.2003.3.

[02]Or1ando,Fla.Digital Image Processing Techniques.Academic Pr,Inc.1984

[03]K.Fukushima.A neural network model for selective attention in visual pattern recognition. Biological Cybernetics[J]October 1986?55(1):5-15.

[04]T.H.Hidebrandt Optimal Training of Thresholded Linear Correlation Classifiers[J]. IEEE Transaction Neural Networks.1991?2(6):577-588.

[05]Van Ooyen B.Nienhuis Pattern Recognition in the Neocognitron Is Improved by Neural Adaption[J].Biological Cybernetics.1993,70:47-53.

[06]Bao Qing Li BaoXinLi. Building pattern classifiers using convolutional neural networks[J]. Neural.Networks?vol.5(3): 3081-3085.

[07]E S ackinger?,B boser,Y lecun?,L jaclel. Application of the ANNA Neural Network Chip to High Speed Character Recognition[J]. IEEE Transactions on Neural Networks 1992.3:498-505.

A05-40

6.完整源碼獲得方式

方式1：微信或者QQ聯系博主

方式2：訂閱MATLAB/FPGA教程，免費獲得教程案例以及任意2份完整源碼

總結

以上是生活随笔為你收集整理的【LSTM】基于LSTM网络的人脸识别算法的MATLAB仿真的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。