AI-Driven IoT Framework for Advanced Cardiac Monitoring and Analysis

Table 1. Comparison of deep learning models for cardiac signal analysis

Table 2. Key studies on CNN-LSTM and hybrid deep learning models in healthcare

The model is divided following phases:

• Data Acquisition
• Preprocessing
• Input Representation
• CNN-based Feature Extraction
•  LSTM-based Temporal modelling
• Model Training
• Deployment

4.1 Data acquisition

To assure complete representation and generalization, cardiovascular signals from multiple sources are gathered and aggregated during the data gathering phase. The MIT-BIH Arrhythmia Database, which provides comprehensive ECG recordings with appropriate diagnostic labels, is one example of an annotated dataset. Furthermore, IoT-enabled biomedical sensors—such as wearable and implantable devices—provide real-time data streams by gathering physiological signals from patients in clinical or mobile settings. The dataset is robust for training and testing intelligent models due to the integration of these sources, which assures that it reflects both typical and unconventional cardiac behavior under various conditions.

4.2 Preprocessing

In addition to technical constraints, patient movement, and environmental disturbances, raw cardiac signals from sensors are vulnerable to noise and irregularities. Preprocessing is therefore required for transforming noisy, unstructured inputs into clean, standardized data that can be used to train models.

4.2.1 Signal denoising

In an attempt to reduce unwanted noise while retaining clinically significant features, denoising is used. Baseline wander, powerline disruption, and muscle distortions are removed, and the frequency factors of interest are distinguished using methods like bandpass filtering, wavelet decomposition, and Empirical Mode Decomposition (EMD).

4.2.2 Normalization

Normalization methods like min-max scaling or z-score standardization are used to remove bias brought on by variances in signal amplitudes among sensors or subjects. This enhances efficiency and reliability during training by ensuring that the input signals received by the deep learning model fall within a consistent range.

4.2.3 Segmentation

In addition to the persistent nature of ECG signals, temporal analysis is made simpler by segmenting the data into distinct windows or cardiac cycles. Individual heartbeat segments can be extracted with the aid of techniques like peak detection-driven segmentation and predetermined-length windowing. Deep learning models then use these segments as units of input.

4.2.4 Artifact removal

Noise removal methods like threshold-based filters or Independent Component Analysis (ICA) are used to reduce non-cardiac noise and improve signal quality even more. Cleaner signal inputs enhance model precision and lower false alarms as a result.

These preprocessing methods work together to convert noisy, unstructured raw data into clean, standardized, and well-segmented inputs, which help deep learning algorithms detect and anticipate cardiac abnormalities. Therefore, the success of the intelligent IoT-enabled heart monitoring system recommended in this study depends critically on efficient preprocessing.

4.3 Input representation

After preprocessing, each ECG segment is formatted as a one-dimensional time-series vector:

$x=\left[x_1, x_2, \ldots, x_T\right], \cdots \cdots x \in R^T$             (1)

where, T denotes the number of time steps in a single segment. This representation serves as the input to the convolutional layers, capturing both local and global morphological features necessary for downstream classification.

4.4 CNN-based feature extraction

The initial stage of the deep learning pipeline involves Convolutional Neural Networks (CNNs) that extract spatial features from the input signal. CNNs are particularly effective in identifying morphological patterns in ECG signals, such as QRS complexes, P waves, and T wave irregularities.

4.4.1 Convolution operation

Convolutional filters slide across the input signal to detect local patterns:

$y_i=\sum_{j=1}^k w_j * x_{i+j}+b$            (2)

where, k is the kernel size, $w_j$ are the filter weights, and b is the bias.

4.4.2 Batch normalization and ReLU

Batch normalization is applied to stabilize learning, followed by a ReLU activation function:

$f(x)=\max (0, x)$            (3)

These steps improve model convergence and address vanishing gradient problems.

4.4.3 Max pooling and dropout

Max pooling downsamples the feature map, reducing computational load and emphasizing dominant features:

$y_i=\max \left(x_i, x_{i+1}, \ldots, x_{i+p}\right)$           (4)

Dropout regularization prevents overfitting by randomly disabling a fraction of neurons during training.

4.4.4 Fully connected layer

Extracted features are passed through a dense layer to consolidate local patterns into higher-order representations:

$y=w_x+b$          (5)

4.5 LSTM-based temporal modeling

The output of the CNN block is fed into Long Short-Term Memory (LSTM) layers to model the temporal dependencies between heartbeats across segments.

4.5.1 LSTM mechanics

LSTM networks capture long-term dependencies using gates and memory cells. The core operations include:

Forget gate:

$f_t=\sigma\left(W_{f\left[h_{t-1}, x_t\right]}+b_f\right)$           (6)

Input gate:

$\begin{aligned} i_t=\sigma\left(W_{i\left[h_{t-1}, x_t\right]}\right. & \left.+b_i\right), \cdots C_t^{\sim} \\ & =\tanh \left(W_c\left[h_{t-1}, x_t\right]+b_c\right.\end{aligned}$            (7)

Cell state update:

$C_t=f_t * C_{t-1}+i_t * C_t^{\sim}$          (8)

These mechanisms allow the model to retain clinically important temporal dynamics that span across multiple cardiac cycles.

4.5.2 Final dense and softmax layers

The LSTM output is passed through one or more fully connected layers, followed by a softmax layer:

$P\left(y_i\right)=\frac{e^{z_i}}{\sum_{j=1}^N e^{z_j}}, y=\operatorname{argmax} P\left(y_i\right)$           (9)

This produces the class probabilities, allowing the model to predict heart conditions such as normal rhythm, arrhythmia, or other cardiac abnormalities.

4.6 Customized CNN–LSTM for ECG signal processing

To address ECG-specific characteristics and ensure robust detection of arrhythmias and related anomalies, we introduce a customized CNN–LSTM model that combines spatial and temporal feature learning with physiological constraints. Unlike generic CNN and LSTM formulations, this design incorporates beat-synchronous segmentation, multi-scale convolutions matched to ECG wave durations, morphology-aware regularization, RR-interval conditioning, and a temporally consistent early-alarm loss. The proposed model processes ECG signals as follows:

4.6.1 Beat-synchronous input representation

Each ECG segment is extracted around R-peak positions to ensure alignment with cardiac cycles:

$x_t=\Pi\left(X,\left[r_t-|W / 2|, r_t+|W / 2|\right]\right) \in \mathbb{R}^{L \times W}$          (10)

where, X is the multi-lead ECG input, rtr_trt is the R-peak index for beat t, L is the number of leads, and W is the window length in samples.

4.6.2 Lead-attention fusion

Physiologically important leads (e.g., V1, V2 for QRS morphology) are adaptively weighted:

$x_t^{\sim}(\tau)=\sum_{l=1}^L x_t^{(l)}(T), \quad \alpha_{\ell}=\frac{\exp \left(\alpha_{\ell}\right)}{\sum_{j=1}^L \exp \left(\alpha_j\right)}$          (11)

where, $\alpha_{\ell}$ are attention scores for each lead.

4.6.3 Multi-scale dilated convolutions

To capture P-wave, QRS, and T-wave patterns, we use multiple convolution kernels with physiologically tuned receptive fields:

$\begin{gathered}f_t^{(m)}(T)=\sigma\left(b_m+\sum_{k=0}^{K_m-1} w_k^{(m)} x_t^{\sim}\left(T+d_m k\right)\right) \\ m=1, \ldots, M\end{gathered}$         (12)

where, $d_m$ controls dilation (spacing) and $K_m$ is the kernel size.

4.6.4 Morphology regularization for QRS complex

To enforce sharp, near-symmetric QRS detection, we regularize CNN kernels:

$\begin{aligned} R_{\text {morph }}=\lambda_{\text {sym }} & \cdot \sum_{m \in Q} \sum_k\left(w_k^{(m)}+w_{K_m-1-k}^m\right)^2 \\ & +\lambda_{t v} \sum_{m \in Q} \sum_k\left(w_{k+1}^{(m)}-w_{K_{m+1}}^{(m)}\right. \\ & \left.-w_k^{(m)}\right)^2\end{aligned}$         (13)

where, Q is the set of QRS-focused kernels.

4.6.5 RR-interval conditioning

Rhythm variability is encoded by concatenating RR intervals with CNN features:

$s_t=\varphi\left(G A P\left(f_t\right) \| z_t\right)$          (14)

where, $z_t$ represents a short RR history and GAP is global average pooling.

4.6.6 LSTM temporal modeling

$\begin{gathered}i_t=\sigma\left(W_i s_t+U_i h_{t-1}+b_i\right), \\ f_t=\sigma\left(W_f s_t+U_f h_{t-1}+b_f\right), \\ \tilde{c}_t=\tanh \left(W_c s_t+U_c h_{t-1}+b_c\right), \\ o_t=\sigma\left(W_o s_t+U_o h_{t-1}+b_o\right), \\ c_t=f_t \odot c_{t-1}+i_t \odot \tilde{c}_t, \\ h_t=o_t \odot \tanh \left(c_t\right)\end{gathered}$            (15)

4.6.7 Early-alarm prediction & loss

To encourage early detection, predictions are made h beats ahead:

$p_{t+h}=\operatorname{softmax}\left(V h_t+b\right)$           (16)

The overall loss combines class-weighted cross-entropy, temporal consistency, early-alarm emphasis, and morphology regularization:

$\begin{aligned} J=L_{C E} & +\lambda_{\text {temp }} L_{\text {temp }}+\lambda_{\text {early }} L_{\text {early }} \\ & +\lambda_{\text {morph }} R_{\text {morph }}+\lambda_2 \Sigma| | \Theta| |^2\end{aligned}$           (17)

where, Θ denotes all learnable parameters.

4.7 Model training

The training process for the proposed CNN-LSTM model involves leveraging annotated cardiovascular signal datasets, where each signal segment is labeled to indicate specific heart conditions such as normal rhythm, arrhythmias, or other abnormalities. Initially, the preprocessed data—consisting of clean, normalized, and segmented heart signal windows—is fed into the Convolutional Neural Network (CNN) component. The CNN automatically extracts spatial features, such as morphological patterns in the heartbeats, by applying a series of filters across the signal. These high-level features are then passed to the Long Short-Term Memory (LSTM) layers, which are responsible for learning the temporal dependencies and sequential dynamics present in cardiac signals over time. The model undergoes supervised learning, where the predicted outputs are compared to ground truth labels, and the error is minimized through backpropagation and optimization algorithms such as Adam or RMSprop. To enhance generalization and robustness, techniques like dropout, early stopping, and batch normalization are employed during training. Furthermore, the trained model is validated using a separate set of real-time or unseen input data to evaluate its accuracy, sensitivity, specificity, and overall performance in detecting cardiac anomalies. This ensures the model's reliability and readiness for deployment in real-world, IoT-enabled heart monitoring systems.

The CNN-LSTM model was trained using the MIT-BIH Arrhythmia dataset and real-time ECG segments. The training process involved supervised learning with categorical cross-entropy as the loss function, optimized using the Adam optimizer with an initial learning rate of 0.001. Hyperparameters were tuned through a grid search over learning rates [0.0001, 0.001, 0.01][0.0001, 0.001, 0.01][0.0001,0.001,0.01], batch sizes [32,64,128][32, 64, 128][32,64,128], and dropout rates [0.2,0.5][0.2, 0.5][0.2,0.5]. The final configuration employed a batch size of 64, dropout of 0.3, and early stopping with a patience of 10 epochs to prevent overfitting. The model was trained for 50 epochs, with an 80:10:10 split for training, validation, and testing. Regularization was achieved through L2 weight decay (λ = 0.0001) and dropout layers.

4.8 Deployment

Once the deep learning model (e.g., CNN or LSTM) is trained and validated using preprocessed cardiac data, it is deployed to a cloud-based server environment. This cloud infrastructure provides the scalability, processing power, and storage capacity required to handle continuous streams of data from multiple IoT-enabled wearable or implantable sensors. The model is integrated into a backend system that supports real-time inference, allowing it to analyze incoming heart signals and detect anomalies on the fly. To ensure accessibility and usability, the system is connected to a user-facing mobile or web application. This application serves as the interface through which patients, caregivers, or healthcare professionals can monitor heart activity in real time, receive alerts about irregular patterns, and access historical health data. The deployment not only ensures 24/7 availability and seamless access but also facilitates remote healthcare by bridging the gap between real-time data acquisition and clinical decision-making. Security and privacy measures, such as encryption and authentication protocols, are implemented to safeguard sensitive health data during transmission and storage. The methodology is illustrated in Figure 2.

2.png

Figure 2. CNN-LSTM model architecture

The integration of IoT and AI-driven deep learning provides a transformative approach for continuous, real-time cardiac monitoring. By leveraging wearable devices for data acquisition and a hybrid CNN–LSTM model for spatial and temporal feature analysis, the proposed framework enhances diagnostic accuracy and enables proactive interventions. Cloud integration further ensures scalability, secure data access, and seamless connectivity for remote healthcare applications. Experimental results validate its robustness, with the hybrid model achieving 96.5% accuracy, 95.2% precision, and an F1-score of 94.9%, outperforming standalone CNN and LSTM models. This work demonstrates a practical, intelligent solution for early detection and management of cardiac anomalies, bridging the gap between algorithmic innovation and real-world deployment.