A novel automated Parkinson’s disease identification approach using deep learning and EEG

Long short-term memory

LSTM is an RNN architecture intended to process and model sequential data. LSTM networks excel in collecting long-range relationships in time-series information, making them a good choice for sequence-based applications like voice recognition, NLP, and interval forecasting. The critical innovation of LSTM networks is shown in the Fig. 2 lies in their ability to maintain a memory state over time, allowing them to forget or retain information from previous time steps selectively. This is achieved through unique gating mechanisms that control the flow of information within the network.

Cell state (Ct) acts as the memory of the LSTM and runs along the entire sequence. It can selectively learn to recall or forget data over time. This continuity of information flow is what enables LSTMs to maintain long-range dependencies.

Hidden state (ht) at each time step acts as the LSTM cell’s output and serves as the input to the next time step. It carries relevant information learned from previous time steps. Input Gate (i), Forget Gate (f), and Output Gate (o) are utilized to manage how data enters and leaves the LSTM cell. There are three gates: the input gate, the forget gate, and the gate that outputs the result. The input gate supervises the amount of data supplied to the cell state, the forget gate decides what data is discarded from the cell state, and the output gate governs how much knowledge leaves and enters the hidden state.

The equations governing the LSTM cell are as follows: (4)${\displaystyle i\left(t\right)=sigmoid\left(Wi\ast \left[ht-1,xt\right]+bi\right)}$ (5)${\displaystyle f\left(t\right)=sigmoid\left(Wf\ast \left[ht-1,xt\right]+bf\right)}$ (6)${\displaystyle o\left(t\right)=sigmoid\left(Wo\ast \left[ht-1,xt\right]+bo\right)}$ (7)${\displaystyle \text{Ĉ}t=tanh\left(Wc\ast \left[ht-1,xt\right]+bc\right)}$ (8)${\displaystyle Ct=f\left(t\right)\ast Ct-1+i\left(t\right)\ast \text{Ĉ}t}$ (9)${\displaystyle ht=o\left(t\right)\ast tanh\left(Ct\right)}$

In these equations, xt  isthe input at time t, and the variables with ‘W’ and ‘b’ represent the learnable weights and biases of the LSTM cell. LSTMs have proven very effective in handling vanishing and exploding gradient problems, which are common issues in training traditional RNNs on long sequences. Using gating mechanisms, LSTMs can selectively retain important information and mitigate the vanishing gradient problem, making them a powerful tool for sequential data processing. Table 1 presents the layered architecture of the long short-term memory (LSTM) model employed in our research. This architecture comprises several key layers, each with distinct roles in the model’s overall functioning.

The first layer in our model is an LSTM layer. LSTM units are essential components of recurrent neural networks, known for their ability to capture long-range dependencies in sequential data. In this layer, the output shape is specified as (None, 1, 64), indicating that it generates sequences with a length of 1 and a feature dimension of 64. The parameter count for this layer is 668,928, reflecting the weights and biases learned during training. Following the LSTM layer, we have a dropout layer. Dropout is a regularization technique that helps prevent overfitting by randomly setting a fraction of input units to zero during each forward pass. The second LSTM layer, labeled as lstm₁, is designed to reduce the dimensionality of the sequence output. It transforms the sequence with a length of 1 into a single vector of 32. Like the previous dropoutlayer, dropout₁ is applied to the output of lstm₁. It maintains an output shape of (None, 32). The final layer in our LSTM model is a dense layer, which is a fully connected layer. It takes the output of the previous layer and produces a final prediction. In this case, the output shape is (None, 2), which outputs a vector of length 2.

Bi-directional LSTM

The LSTM has been expanded into the bi-directional LSTM (Bi-LSTM), which can process requests in both the forward and backward directions. This makes the Bi-LSTM more efficient in collecting contextual and relationships in historical data, as it can take into account details from both previous times and the near future.

The equations for a Bi-LSTM cell, as shown in Fig. 3, combine the forward LSTM and backward LSTM operations. For forwarding LSTM,

Input Gate (i_f): (10)${\displaystyle i_f\left(t\right)=sigmoid\left(W{i}_f\ast \left[h_f\left(t-1\right),x\left(t\right)\right]+b{i}_f\right)}$

Forget Gate (f_f): (11)${\displaystyle f_f\left(t\right)=sigmoid\left(W{f}_f\ast \left[h_f\left(t-1\right),x\left(t\right)\right]+b{f}_f\right)}$

Output Gate (o_f): (12)${\displaystyle o_f\left(t\right)=sigmoid\left(W{o}_f\ast \left[h_f\left(t-1\right),x\left(t\right)\right]+b{o}_f\right)}$

Candidate Cell State (Ĉ_f): (13)${\displaystyle {\text{Ĉ}}_f\left(t\right)=tanh\left(W{C}_f\ast \left[h_f\left(t-1\right),x\left(t\right)\right]+b{C}_f\right)}$

Cell State (C_f) Update: (14)${\displaystyle C_f\left(t\right)=f_f\left(t\right)\ast C_f\left(t-1\right)+i_f\left(t\right)\ast {\text{Ĉ}}_f\left(t\right)}$

Hidden State (h_f): (15)${\displaystyle h_f\left(t\right)=o_f\left(t\right)\ast tanh\left(C_f\left(t\right)\right)}$ where h_f(t)  is the hidden state of the forward LSTM at time step t, x(t) is the input at time t, and the variables with ‘W’ and ‘b’ represent the learnable weights and biases of the forward LSTM. For backward LSTM,

Input Gate (i_b): (16)${\displaystyle i_b\left(t\right)=sigmoid\left(W{i}_b\ast \left[h_b\left(t+1\right),x\left(t\right)\right]+b{i}_b\right)}$ Forget Gate (f_b): (17)${\displaystyle f_b\left(t\right)=sigmoid\left(W{f}_b\ast \left[h_b\left(t+1\right),x\left(t\right)\right]+b{f}_b\right)}$

Output Gate (o_b): (18)${\displaystyle o_b\left(t\right)=sigmoid\left(W{o}_b\ast \left[h_b\left(t+1\right),x\left(t\right)\right]+b{o}_b\right)}$

Candidate Cell State (Ĉ_b): (19)${\displaystyle {\text{Ĉ}}_b\left(t\right)=tanh\left(W{c}_b\ast \left[h_b\left(t+1\right),x\left(t\right)\right]+b{c}_b\right)}$

Cell State (C_b) Update: (20)${\displaystyle C_b\left(t\right)=f_b\left(t\right)\ast C_b\left(t+1\right)+i_b\left(t\right)\ast {\text{Ĉ}}_b\left(t\right)}$

Hidden State (h_b): (21)${\displaystyle h_b\left(t\right)=o_b\left(t\right)\ast tanh\left(C_b\left(t\right)\right)}$

where h_b(t)  is the hidden state of the backward LSTM at time step t,  x(t) is the input at time t, and the variables with ‘W’ and ‘b’ represent the learnable weights and biases of the backward LSTM. Bi-LSTMs often combine forward and reverse hidden states into a single output at each time step t: (22)${\displaystyle h_{b}i\left(t\right)=\left[h_f\left(t\right),h_b\left(t\right)\right]}$

The architecture of the neural network model, as shown in Table 2, is delineated through a series of interconnected layers, each with specific characteristics. The input layer (inputs_lstm) serves as the point of entry, specifying the input data’s expected shape, consisting of sequences with a length of 178 and a feature dimension of 1. Subsequently, the dense layer (Dense) applies a linear transformation to the input, generating an output sequence with sizes (None, 178, 32). This transformation involves 64 trainable parameters. The bidirectional layer (Bidirectional) is a pivotal component, enveloping two LSTM layers to capture bidirectional dependencies within the input data. As a result, it yields an output vector of dimension 256, embedding 164, 864 trainable parameters. To prevent overfitting, the dropout layer (Dropout) is employed, randomly setting a portion of input units to zero during forward passes without any trainable parameters. The batch normalization layer (batch_normalization) comes into play, normalizing activations to enhance training stability, with 1, 024 trainable parameters for scaling and shifting. Following this, the dense layer (dense₁) further reduces the data’s dimensionality to 64 dimensions, incorporating 16, 448 trainable parameters. Subsequently, the dropout layer (dropout₂) reprises its role in regularization, with no trainable parameters, and is succeeded by the batch normalization layer (batch_normalization₁) with 256 trainable parameters for scaling and shifting. Lastly, the final output is generated by the dense layer (dense₃), producing a vector of length 2, signifying the model’s ultimate prediction. This layer comprises 130 trainable parameters. These layers constitute a complex neural network architecture designed to process sequential data, capture bidirectional information, and produce meaningful predictions while mitigating overfitting through dropout and stabilizing training with batch normalization.

Densely linked Bi-LSTM

We present an early version of the densely-connected LSTM network here, which is based on the idea of densely linked networks. Incorporating skip connections into the densely linked network nodes is fundamental to our method. Figure 4 depicts this architecture, with d_lt standing for the densely linked hidden unit of the l^th layer at the t^th time step. In this research, the strongly interconnected layers show the skip-connections between them. Connecting and integrating data between the many tiers of a network is what these lines are for. In contrast to the element-wise additive operation used by the residual learning framework, the concatenation operation is used here. This replacement counteracts the performance drop that might occur with direct gradient backpropagation. Densely-Linked Bidirectional LSTM (DLBLSTM) networks are an innovative method for modeling temporal patterns that benefit from densely linked construction and bi-directional temporal features.

The DLBLSTM architecture is unique in deep learning in that it features connections between neighboring layers and levels that are physically separated from one another. Because of its one-of-a-kind topology, the network’s many groups may exchange data and communicate more efficiently. Multiple disciplines of study have documented and investigated information transmission phenomena in both directions simultaneously. The possible ramifications of this quality, bidirectional information flow, have garnered much interest. Authors have studied the mechanics and characteristics of two-way communication. The two-way transmission of information has been investigated through experiments and theoretical models. It has been shown that DBLSTM’s architecture eliminates gradient vanishing, boosts feature transmission, promotes the reuse of features, and significantly lowers the number of variables. It improves the representation of spatial and short-term temporal features. Two LSTM networks are used to create the DB-LSTM model’s two-layer architecture. Densely interwoven skip-connections link together these LSTM networks. LSTM connections, one running forward and one running reversed, can simulate the long-term temporal trends in operations. All of the results from each iteration are merged into one final result. Each DB-LSTM unit is definite as follows: (23)${\displaystyle \overleftrightarrow{d_t}=\left[\stackrel{⃖}{d_t},\overrightarrow{d_t}\right]}$ where $\overleftrightarrow{d_t}$ is the t-th result from DB-LSTM. When LSTM networks are paired with dense skip-connections, the forward and backward directional outputs at the tth time step are denoted by $\overrightarrow{d_t}$ and $\stackrel{⃖}{d_t}$, correspondingly. Concatenation is represented by the letter $\left[,\right]$. The directions ← and → of the output d are indicative of the forward and backward directions of the input patterns. The following defines the influence of preceding layers on the output of the lth layer of the LSTM block $d_t^l$ at the tth time step: (24)${\displaystyle d_t^l=\left[h_t^l\left(\mathrm{ }\left[d_t^0,d_t^2,\dots ...d_t^{l-1}\right]\right),x_t\right]}$ where $\left[d_t^0,d_t^2,\dots ...d_t^{l-1}\right]$ is the sum of the characteristics retrieved from the preceding levels.

The LSTM layer’s input is X, and it receives features from the previous  t time steps. ${\displaystyle \left[h_t^l\left(\mathrm{ }\left[d_t^0,d_t^2,......d_t^{l-1}\right]\right),x_t\right]}$ represents the output of the previous LSTM layer plus the input feature x_t at the t^th time step. The lth LSTM layer, during the tenth time step, is denoted by $h_t^l$. The cross-entropy formula is used to determine the amount of damage. (25)${\displaystyle \psi \left(y,\phi \right)=-\sum _{k=1}^N{y}_i\left({\phi }_i-log\sum _{k=1}^{N}exp{\phi }_i\right)}$ where N is the total number of categories and y_i is the ith video’s label. The fusion layer now includes the scores generated by long-term temporal modeling. A multi-scale sliding window combines the scores at the end of each time step. (26)${\displaystyle w_q=\frac{1}{\left(T-p\right)p}\sum _{n=1}^{N-p}\sum _{m=n}^{n+p}{E}_t^{bi}}$ where T is the total number of time steps (also known as segments), and n is the initial time step at which the sliding window will begin to operate. The typical synthesis of multi-scale sliding windows addresses the issue of events occurring at various times.

Table 3 is mentioned about the layered architecture of Bi-LSTM. The architectural composition of the DLBLSTM model is delineated through a sequence of interconnected layers, each serving a specific purpose within the neural network’s framework. The initial layer, the input layer (inputs_lstm), acts as the point of entry for the model, anticipating input data structured as sequences with a length of 178 and a feature dimension of 1. Following this, the dense layer (dense) undertakes a linear transformation of the input data, resulting in an output shape of (None, 178, 32) and contributing 64 trainable parameters to the model. The subsequent bidirectional layer is the centerpiece of the architecture, encapsulating two LSTM layers that process input sequences bidirectionally. This operation yields an output shape of (None, 178, 64) and encompasses 16, 640 trainable parameters.

The dropout layer (dropout) promotes model generalization, randomly deactivating a fraction of input units during each forward pass. Importantly, it introduces no trainable parameters. The ensuing dense layer (dense₁) reduces feature dimensionality to (None, 178, 32) while incorporating 2, 080 trainable parameters. The second bidirectional layer (bidirectional₁) mirrors the operation of its predecessor, processing data bidirectionally and yielding an output shape of (None, 178, 64). This layer adds another 16, 640 trainable parameters to the model.

A second dropout layer (dropout₁) follows, enhancing regularization without introducing trainable parameters. To stabilize training and facilitate convergence, the batch normalization layer (batch_normalization) is incorporated, normalizing activations from the prior layer and enhancing training stability by introducing 256 trainable parameters for scaling and shifting.

Lastly, the final dense layer (dense₂) generates the model’s output, producing a sequence of length 178 with two features, denoted as (None, 178, 2). This layer encompasses 130 trainable parameters. This DLBLSTM architecture is meticulously designed to effectively process sequential data, capturing past and future context through bidirectional LSTM layers while maintaining regularization and stability through dropout and batch normalization layers, ultimately leading to meaningful predictions based on input sequences.

In Table 4, each hyperparameter is listed. The “Values to Try” column specifies the different values or options you can experiment with during hyperparameter tuning. The “Best Value” column indicates the best-performing value or setting for each hyperparameter based on your validation results.