Comparison of Artificial Neural Networks for Low-Power ECG-Classification System

2.1 Electrocardiogram

ECG is a prevalent method used in the medical field [3][4] for typical heart tests. Figure 2 shows the source of the ECG signal and a typical ECG waveform with distinct morphologies, namely P-wave, QRS complex, and T-wave.

Fig. 2.

Basic ECG signal [3,4].

P-wave indicates the depolarization of the left and right atrium. The wave height is less than 2.5 mm and 0.11 s in width. QRS complex starts before ventricular contraction and is the result of rapid succession. The measurement is 0.12–0.20 s and the amplitude is 5–30 mm. T-wave represents ventricular repolarization, which is after the QRS complex. It typically exhibits an amplitude of less than 10 mm in the case of limb leads.

In most previous studies, the QRS complex has been utilized to recognize arrhythmias and distinguish the strange ECG signals. QRS detection is difficult because it is subject to physiological variations owing to patients and different noise types [4]. ECG classification involves four steps: preprocessing, feature extraction, normalization, and classification. ECG preprocessing includes baseline wander, power line interference, and muscle artifact [5], which can be removed using discrete wavelet transform [6]. Feature extraction and classification is crucial. Several feature extraction methods have been applied, such as discrete Fourier transform, fast Fourier transform (FFT) [7], wavelet transform [8], higher-order statistics [9], and principal component analysis [10]. Various machine learning techniques are used as the classifier. Ubeyli [11] proposed an RNN classifier with an eigenvector-based feature extraction method and achieved 98.06% accuracy. Park et al. [12] proposed a K-NN classifier for detecting ECG arrhythmias, which resulted in 97.1% sensitivity and 98.9% specificity on average. In terms of existing algorithms, Kiranyaz et al. [13] introduced a one-dimensional CNN for ECG arrhythmia classification. Moreover, the 2D-CNN developed by Tae Joon Jun et al. [14] yielded an accuracy of 99.05%.

2.2 ANNs

Among the most widely used network topologies from ANNs, MLP is considered as the pioneer for classification purposes [15]. Figure 3 shows an MLP classifier with an input, hidden, and output layer for classifying four different arrhythmias.

Fig. 3.

Structure of MLP.

Another popular neural network is the CNN, which is a supervised method used for classification. It comprises an input and an output layer as well as multiple hidden layers. These layers are generally categorized into three types: CONV, POOL, and fully connected. In this paper, a 2D CNN was applied, which is illustrated in Figure 4. The CNN model handles two-dimensional image as an input data, ECG signals are transformed into ECG images during the pre-processing. Resultant images are augmented in order to improve the classification accuracy. The training and validation set is allotted by 80% and 20 % of the whole dataset respectively. In addition, the classification is performed on the ECG waveform images.

Fig. 4.

CNN architecture [14].

Recently, SNNs have been used to solve classification problems as an alternative to CNNs. SNNs are bio-inspired, event-driven, analog neural networks that, when mapped to dedicated neuromorphic hardware such as Loihi, CxQuad, and NeuCube, are highly energy and resource efficient compared with CNNs. This is primarily owing to a nondifferentiable discrete activation function in SNNs. Das et al., [16] proposed encoding ECG signals into a spike train (using temporal coding), and the network used was an unsupervised, liquid state machine. The approach demonstrates high classification accuracy and low power consumption for 23 distinct heartbeat classes. In this paper, a SNN architecture [17] is deployed to differentiate ECG arrhythmias. The network architecture is shown in Figure 5.

Fig. 5.

SNN architecture [17].

The ECG signal was split into several overlapping windows, which were subsequently encoded into spike trains. STDP represents spike-timing-dependent plasticity, where the weights are trained according to the respective timing of the spike signals. Therefore, the patterns from the spike trains are automatically extracted to the STDP layer, followed by a Gaussian layer and an inhibitory layer. Finally, an R-STDP layer was used to differentiate the extracted features. It is noteworthy that all the layers were performed in the spike domain; therefore, energy was reduced.

2.3 FPGA for Embedded AI

FPGAs have existed for decades. AI algorithms have been increasing in size and complexity, and GPU development has not been able to keep pace. An alternative is the FPGA, which is inherently parallel and hardware programmable. An FPGA was used in this paper owing to its flexibility, which is the most important aspect of FPGAs. The primary source of FPGAs is the configurable logic block, which uses lookup tables, flip flops, multiplexers, and switch matrices to perform a particular logic function. A typical FPGA-based neural network accelerator system is shown in Figure 6. The blue boxes denote the logic parts of the system. The workloads or commands of the FPGA logic part and the monitoring of the work status is handled by the host CPU. On the logic part of the FPGA, a controller (FSM/instruction decoder) is typically implemented to communicate with the host and generates control signals to other modules on the FPGA. The on-the-fly logic part is implemented for certain designs in case data are loaded from external memory. It can be a data arrangement module, data shifter, FFT module, etc. The green boxes represent the memory hierarchy of the system, which is categorized into three parts: host DDR, FPGA DDR, and on-chip block RAM [18].

Fig. 6.

FPGA-based NN accelerator.

In this paper, the PYNQ-Z2 board was used, which was designed to be used with the open-source framework, as shown in Figure 7.

Fig. 7.

PYNQ framework [19].

PYNQ denotes Python productivity for ZYNQ. From the hardware architecture perspective, the core chip of PYNQ is a Xilinx ZYNQ Chip, which is a FPGA SOC platform combining a programmable logic and programmable system (PS).

3.1 PYNQ board setup

As shown in Figure 8, a red LED will illuminate immediately to indicate an ON state. Subsequently, after a few seconds, a yellow/green LED will illuminate to indicate that the Zynq device is operational.

Fig. 8.

PYNQ board booted successfully.

3.2 Development Tools

Vivado IDE: An integrated development environment used for creating the hardware base system. All aspects of the system’s hardware are handled here: PS configuration, interfaces, intellectual property (IP) cores, external connections, etc.

Vivado HLS: A design tool for the synthesis of digital hardware directly from a high-level algorithm description developed in C and C++.

Jupyter notebook: A server-client application that allows notebook documents to be edited and executed via a web browser.

3.3 ECG Dataset

The data were obtained from the widely known Massachusetts Institute of Technology arrhythmia database. It contains 48 half-hour two-channel ECG recordings, obtained from 47 participants. The recordings were digitized at 360 samples per second per channel with an 11-bit resolution over a 10 mV range. In this paper, ECG heartbeat signals were converted into 2D heartbeat images for analysis using ANNs.

3.4 Hardware Design Process

To classify the ECG data, a single hardware node is required that can interface with a software environment. Therefore, this node was created and packaged using Xilinx Vivado Design (2016.3 Edition). Figure 9 shows an example of a simple neuron for MLP with the C++ source and interface directives.

Table 1.

ECG datasets

Fig. 9.

C++source and interface directives, w sum = sl(sl_w) + pw(pw w), where w_sum is the weighted sum; sl, sl_w, pw, and pw_w are the ECG signal features.

3.4.2 Vivado and IP Integrator

Once the IP has been exported from the HLS, it can be added to the IP integrator catalog and instantiated on the block diagram illustrated in Figure 10.

Fig. 10.

Vivado IP integrator block for MLP.

Using Figure 10, two overlay files, mlp.tcl and mlp.bit, were generated; subsequently, they were deployed into the PYNQ board. The Jupyter notebook subsequently implemented the MLP and calculated the error using Equation 1.

$\[ e_i\left(n\right)=d_j\left(n\right)-y_j\left(n\right) \]$

(1)

, where Yi(n) is the system response at PE i at iteration n, and di(n) is the desired response for a given input pattern of instantaneous error e_i(n) .

The weight updating is expressed in Equation 2.

$\[ w_{ij}\left(n+1\right)=w_{ij}\left(n\right)+\eta {\delta }_i\left(n\right)x_j\left(n\right) \]$

(2)

, where the local error δ_i(n) can be directly computed from e_i(n) at the output PE or computed as a weighted sum of errors at internal PEs.

In the case of CNNs, Figure 11 shows the block of the single layer, and the convolution operation can be expressed as

$\[ X_l^f=f_c\left(V*w_l^f+b_l^f\right) \]$

(3)

Fig. 11.

Vivado IP integrator block for CNN.

Fig. 12.

Vivado IP integrator block for SNN.

where $$ X_l^f$$ represents the result of the convolution layer, $$ w_l^f$$ the weight of the convolution filter, l the number of layers, f the number of filters, $$ b_l^f$$ the biases of the filters, f_c the nonlinear activation function. Equation 4 describes the max pooling.

$\[ X=\mathit{max}\left\{X\right\}, \]$

(4)

where X is obtained by implementing a maximum pool method to select features.

Neuron model used: Leaky integrate-and-fire model. The differential equation describes the membrane potential of each neuron at time t as follows:

$\[ \tau \frac{d}{dt}{u}_j\left(t\right)=-\left(u_j\left(t\right)-u_{rest}\right)+\propto {\sum }_i{S}_i\left(t\right)w_{ij} \]$

(5)

, where u_j(t) is the membrane potential of neuron j.

Equation 6 expresses the weight updating:

(6)

, where a + and a − are learning rates, and τ is the time constant. It is noteworthy that a + and a − are positive and negative constant values, respectively.

4.1 Accuracy analysis

The accuracy of the MLP, CNN, and SNN are analyzed in Figures 13, 14, and 15, respectively. The CNN achieved the highest accuracy of approximately 95% and the loss decreased from 1.6 to 0.2. The SNN achieved an accuracy of 90%, with a decrease in error rate from 1.4 to 0.6 with 400 epochs.

Fig. 13.

(a) Training loss of MLP model, (b) Test accuracy of the MLP model.

Fig. 14.

(a) Training loss of the CNN model, (b) Test accuracy of the CNN model.

Fig. 15.

(a) Training loss of the SNN model, (b) Test accuracy of the SNN model.

4.2 Power Consumption

The power consumption of the three AI algorithms is shown in Figures 16, 17, and 18. The SNN outperforms the other two AI algorithms in terms of power. Table 2 shows the comparison of the three ANNs based on accuracy, time, and power. Among the three ANNs, the SNNs consumed the least power (0.226 W).

Fig. 16.

Vivado power report of MLP.

Fig. 17.

Vivado power report of CNN.

Fig. 18.

Vivado power report of SNN.

Table 2.

Comparison of artificial neural networks