An Effective Prediction Model of Myocardial Infarction Using Convolution Kernel Weight Based Convolutional Neural Network

Globally, cardiovascular disease (CVD) is the primary cause of mortality, accounting for 31% of all fatalities each year. The number of reported CVD deaths is increasing, with 17.9 million deaths occurring annually [1, 2]. By 2030, it is anticipated that there will be more than 23.6 million CVD deaths annually because of the rapidly rising prevalence of diabetes, obesity, and other cardiovascular-related risk factors. (Acute) Myocardial infarctions account for the largest proportion of mortality among CVD in the United States and other nations. In the US, an MI affects one person every 40 years on average. Methods that use electrocardiogram (ECG) readings in conjunction with machine learning to identify abnormalities in the signal and, by extension, abnormalities associated with certain illnesses are included here [3].

By monitoring the potential bioelectric fluctuation of the human heart, an electrocardiogram (ECG) signal may identify abnormal states and malfunctions [4]. ECG signals present a difficult challenge when it comes to making an accurate diagnosis of the clinical state that they represent. Human MI diagnosis and identification take time and are not accurate. Therefore, before proposing a specific course of therapy, cardiologists must precisely forecast and identify the appropriate form of irregular cardiac ECG waves [5, 6]. For this, hour-long ECG recordings that need to be watched and analyzed may be necessary.

Because it is inexpensive and noninvasive, ECG is often used for clinical diagnosis. The absence of several comprehensive, publicly accessible datasets with a lengthy history of real-world ECG readings, as well as machine learning techniques with high precision (>89%) and a wide range of options, have presented difficulties [7]. Over the course of the most recent few years, a great number of different algorithms for detecting myocardial infarction (MI) have been presented. The four main steps in the implementation of these algorithms were denoising, segmentation, feature extraction, and MI classification. However, the heartbeat segmentation detector is essential for MI classification because mistakes made during ECG heartbeat identification might affect the final classification findings. The identification of the P-QRS-T waves is the primary component of the heartbeat segmentation process. However, the majority of methods include a preprocessing stage to obtain the signal ready. There are multiple noise levels in this form of the signal. When an ECG signal is acquired and transmitted, the noise is polluted. This makes manual and automated ECG signal analysis very difficult, and noise may be mistaken for abnormal cardiac problems [8]. Therefore, noise-free ECG readings are required for accurate cardiac diagnosis.

Manual ECG performance requires domain knowledge and is subject to interobserver fluctuations. In some cases, medical expertise such as emergency paramedics in remote locations may not be physically available. This has prompted more research into the use of ECG signals in computer-assisted myocardial infarction diagnosis using artificial intelligence (AI). Deep learning (DL) and feature extraction are two types of AI algorithms. On the other hand, the latter is fully automated and has gained popularity because of its convenience, reliable performance, and ability to train on large data sets.

The Empirical Mode Decomposition (EMD) is decomposing non-stationary signals into a series of Intrinsic Mode Functions (IMFs) [9]. Convolutional neural networks (CNNs), in particular, have recently received much attention for their use in forecasting MI and atrial fibrillation, which has limited the potential of alternative algorithms to perform better on deadlier acute myocardial infarction.

Existing research has presented several methods for autonomous detection and localization of MI. These methods include wavelet transform techniques, time-domain approaches, polynomial fitting methods, and supervised machine learning algorithms. Although these strategies have shown promise, they still face significant challenges in clinical applications. For instance, segmenting the heart to assess strain is a complex and labor-intensive process. In addition, the intricate spatiotemporal motion of the heart can lead to difficulties in its implementation. DL models have made rapid progress in recent years across a wide range of research fields, particularly in cardiac segmentation. Numerous studies have focused on detecting myocardial infarction (MI) using DL approaches; however, they still face significant challenges. One major issue is inadequate image preprocessing, which is required for DL models to accurately extract features. Another significant limitation is the scarcity of large high-quality datasets.

This study proposes the development of an automated detection approach for acute myocardial infarction with CKWCNN to address the limitations of previous research. This model presents notable advantages for predicting MI compared with other DL approaches. The CKWCNN is distinguished by its ability to autonomously learn intricate patterns and characteristics from ECG signals, which are essential for the early detection of myocardial infarction. Its convolutional layers effectively capture both local and global dependencies in ECG data. In contrast to conventional ML methods that depend on manual feature extraction, CKWCNN independently learns representations from the raw data. This reduces the necessity for specialized knowledge and increases adaptability to different datasets and conditions. Additionally, the CKWCNN's efficient parameter utilization and regularization methods enhance the model's generalization, ensuring consistent performance across various patient groups and healthcare environments. Overall, CKWCNN distinguishes itself in predicting myocardial infarction by utilizing its strengths in feature learning, spatial representation, and performance optimization, positioning it as a valuable tool for improving clinical decision-making and patient outcomes in cardiology.

Accurate denoising, identification, and categorization of cardiac arrhythmias has been suggested using a unique approach. The first approach for signal denoising is called Empirical Mode Decomposition with Fuzzy Weight Particle Swarm Optimization (EMD-FWPSO). The ECG waveform is then divided into P-QRS-T waves. The characteristics and outcomes of the automated diagnostics were then used for the Convolution Kernel Weight-Based CNN (CKWCNN) classifier. This method combines classification and feature extraction processes, automatically classifies single-lead myocardial infarction ECGs, and performs an extensive analysis.

The primary objective of the research work is listed as follows:

• The PTB dataset is a well-known benchmark dataset that has been used to analyze the efficiency of the CKWCNN approach and compare it with other existing classical models.
• In the preprocessing stage, Empirical Mode Decomposition with Fuzzy Weight Particle Swarm Optimization (EMD-FWPSO) is presented. The IMFs are optimized using the Fuzzy Weight Particle Swarm Optimization (FWPSO) algorithm. This simplifies the model, reduces the impact of noise on the electrocardiogram signal, and allows for faster diagnosis in clinical practice.
• In the segmentation stage, electrocardiogram segment characteristics are derived from the chosen electrocardiogram section using PCA, and morphological features are extracted from P-QRS-T waves.
• In the classification stage, a Convolution Kernel Weight-Based CNN (CKWCNN) classifier was utilized to classify the electrocardiogram signal to identify the myocardial infarction.
• MATLAB was used to implement the proposed CKWCNN. Compared with existing algorithms, the proposed CKWCNN algorithm has the highest precision, recall, specificity, accuracy, and F1 scoring performance.

The remainder of this study is structured as follows. Section II offers a concise summary of the relevant literature. Section III presents the major contents of the proposed algorithm. Section IV delineates the experimental outcomes and discussion. Finally, Section V concludes the study.

Initially, the input ECG data are acquired from the PTB database. Next, the image was preprocessed and filtered. The approach for signal noise removal used in this study is called Empirical Mode Decomposition with Fuzzy Weight Particle Swarm Optimization (EMD-FWPSO). IMFs' energy of the IMFs and Eigen period are used to produce EMD, Intrinsic Mode Functions (IMFs), which are performed using FWPSO. The clustering approach can identify the borders between IMFs with reduced sounds, high-frequency noise, and meaningful data. In addition, segmentation is performed with QRS complex detection, which improves segmentation accuracy.

Next, the features were mined using PCA. The QRS complex and P and T waves were detected to execute the heartbeat separation detectors. Third, ECG segmentation characteristics were obtained from the chosen ECG segment utilizing PCA. Finally, this selected feature is given to the CKWCNN classifier for classification, which gives the severity of the myocardial infarction. Finally, the results were evaluated using the performance evaluation metrics. Figure 1 shows the flowchart of the proposed MI categorization approach. Preprocessing, signal segmentation, feature extraction, categorization, and effectiveness assessment are the five processes that constitute this procedure.

1.png

Figure 1. Flowchart diagram of proposed system for MI classification

3.1 Dataset

Electrocardiogram data were sourced from the Physikalisch Technische Bundesanstalt (PTB-ECG) database. The dataset includes between one to five recordings per subject, with each record containing 15 leads-12 standard ECG leads and three Frank leads. The number of recordings per subject varies. The signals, sampled at a rate of 1000 Hz with a resolution of 0.5µV, have different durations depending on the individual. Tables 2 and 3 provide a detailed summary of the PTB dataset [25].

Table 2. Summary of PTB dataset

Table 3. Types of MI

3.2 Preprocessing

3.2.1 Signal denoising using EMD-FWPSO

EMD, or Empirical Mode Decomposition, is an adaptive signal-analysis technique developed by Huang et al. [26]. Unlike traditional signal-analysis methods, they do not rely on predefined basis functions. Instead, EMD divides the original signal into sub-signals of varying frequencies by analyzing its trends over characteristic timescales. This approach is adaptable and can be used for various signal analysis applications. The EMD process begins with smoothing the signal, which is then broken down into trends at various timescales. The resulting sequences, which correspond to these different time scales, are known as intrinsic mode functions (IMF).

Empirical Mode Decomposition (EMD) is a signal-processing technique that decomposes a complex signal into a finite set of Intrinsic Mode Functions (IMFs). Each IMF corresponds to an oscillatory mode within the signal arranged from high to low frequencies. This technique is especially useful for analyzing nonstationary and nonlinear signals, such as those found in heart disease datasets, by breaking them down into more manageable components. The FWPSO is an optimization technique that combines PSO and fuzzy logic. PSO is a stochastic optimization algorithm that mimics the social behavior of bird flocks and fish schools. It iteratively refines candidate solutions (particles) towards the optimal solution, considering their historical best performance as well as the best solutions identified by nearby particles. FWPSO improves this approach by incorporating fuzzy logic to address uncertainties and ambiguities in data or optimization parameters, thereby increasing the robustness and adaptability of the optimization process.

EMD-FWPSO employs EMD to decompose noisy heart signals into IMFs, effectively isolating noise and streamlining the data. Subsequently, FWPSO is used to automatically identify the optimal IMFs or establish the best parameters for denoising and feature extraction, ensuring that only the pertinent components of the signal are preserved for further analysis. In predicting heart disease, selecting the correct features (such as shape parameters) from the signal is vital for achieving an accurate classification or prediction. The EMD-FWPSO assists in identifying and selecting these shape parameters by optimizing their weights or contributions based on their relevance in differentiating between healthy and diseased states.

The signal being entered was used as the starting point for the signal-noise removal process. EMD is a method used to deconstruct non-linear and non-stationary time series into a group of IMFs and a residue. This method is adaptable. The IMF in EMD is designed to meet two requirements in the EMD algorithm [27, 28]: (a) for the entire period, the number of zero crossings and greater levels varies by no more than one; and (b) at any moment.

(1) Find all the local extremes of the ECG signal that is currently being examined, and then use a cubic spline approximation to link the local maximum and minimum values to build the upper and lower enclosures of the signal.

(2) Calculate the mean $m_{11}$ as the difference between the ECG signal x(t) and the upper and lower envelopes, and label this difference as the upper envelope $m_{11}(t)$ as new series $h_{11}(t)$. An equation may be used to explain it Eq. (1):

$x(t)-m_{11}(t)=h_{11}(t)$          (1)

If $h_{11}(t)$ meets the two requirements, then you should consider using it as the initial IMF. If not, you should take $h_{11}(t)$ since the initial signal and the procedures described previously are performed repeatedly until the $h_{1 k}(t)$ is an IMF and set the $h_{1 k}(t)$ as $c_1(t)$. An equation may be used to explain it Eq. (2):

$c_1(t)=h_{1 k}(t)$           (2)

In most cases, the Standard Deviation (SD) is used to analyze repetitiveness. When the Standard Deviation (SD) number is lower than a predetermined threshold, typically in the range of 0.2 and 0.3, the process of repeatedly subtracting will end. It is characterized by an Eq. (3):

$S D=\sum_{t=0}^T\left(\frac{\left|h_{1(k-1)}(t)-h_{1 k}(t)\right|^2}{\left(h_{1(k-1)}(t)\right)^2}\right)$     (3)

(3) The remaining substance following the separation $c_1(t)x(t)$ is used in the equation that is derived from it Eq. (4):

$x(t)-c_1(t)=r_1(t)$       (4)

(4) Treat the residual $r_1(t)$ as the primary ECG signal, and further iterations of the aforementioned procedure, which will result in the acquisition of additional IMF $\mathrm{s} c_i(t), i=2, \ldots, n$. When the residual is reached, the EMD decomposition will be finished $r_n(t)$ transforms into a function that is monotone. The first ECG signal ever recorded $x(t)$ may be ultimately articulated in the form of an Eq. (5):

$x(t)=\sum_{i=1}^N c_i(t)+r_n(t)$           (5)

Therefore, the original ECG signal is broken down into N different intrinsic magnetic fields as well as a residual $r_n(t)$. By virtue of the repetitive filtration process, the envelope error propagates throughout the local mean and the entire signal, leading to inaccurate and inaccurate deconstruction.

The cubic spline lacks sufficient flexibility when fitting the local extreme values, which is the cause of overshoot and undershoot issues that often arise in the cubic spline. When up-sampling the maxima and minima envelopes during the EMD filtering process, cubic Hermit interpolation is often employed in lieu of cubic splines because it is just first-order smoothness, whereas cubic spline interpolation is of second-order smoothness. The method for cubic Hermit approximation was discovered to sometimes be overly flexible, and this might even result in blatant break points.

The rational Hermit interpolation features a shape determining parameter in contrast to the conventional cubic Hermit interpolation $\lambda$. Due to the parameter $\lambda$, by altering the parameter's value, it is possible to modify the way the rational Hermite constructs its spline curves $\lambda$. As a result, rational Hermit interpolation may be seen as an advancement over cubic Hermit interpolation, and its formulation of the basis function is shown below.

Given a series of discrete data $\left(x_i, y_i, d_i\right)(i=1,2, \ldots, N)$, the $y_i$ is the time-dependent local maximum and minimum $x_i$ and the $d_i$ wherever possible, is the first iteration $x_i\left(d_i=d y(t) / d x(t)\right)$. The goal was to interpolate the segments by fitting the two spots. Each of these may be used to generate the reasonable Hermite approximation $\left[x_k, x_{k+1}\right](k=0,1, \ldots, N-1)$ by Eq. (6):

$\begin{aligned} s_k(x)=F_i(t) y_i & +F_{i+1}(t) y_{i+1}+G_i(t) h_i d_i+G_{(i+1)} h_i d_{i+1}\end{aligned}$          (6)

where, $h_i=x_{i+1}-x_i, t=\frac{\left(x-x_i\right)}{h_i}, \lambda$ is the parameter that determines the form that the spline will take. $F_i(t), F_{i+1}(t), G_i(t)$ and $G_{i+1}(t)$ consist of the fundamental operations of the logical Hermite interpolation. In order to show how well the constant variable works $\lambda$, a portion of the synthetic ECG signal is subjected to the rational Hermite extrapolation. There is a parameter in the rational Hermite approximation equation $\lambda$ that allows filtering process users to choose the interpolation's form. Figure 2 illustrates the parameter-selection processes.

2.png

Figure 2. Input signal process

3.png

Figure 3. Flow chart of the shape parameter selection procedure with FWPSO algorithm

The upper and lower envelopes' parameters should be independently and labeled as because the waveform and fluctuation trend of the maximum and minimum could be significantly distinct $\lambda_i$ and $\lambda_i$, respectively [29]. It is necessary for the parameter in the sifting process to be adjustable, because the waveform and fluctuating trend of the maxima and minima of the newly created time series. Consequently, the parameter of the logical Hermit is self-adaptively chosen for each sifting phase. In this work, parameter determinant criteria are established and considered as the fitness function to achieve the shape-regulating parameter automated selection using the FWPSO algorithm in each sifting process. The implementation criteria are a linear combination of the relative skewness of the estimated local mean and two indices, the first of which is the minimum range between the midpoint and local mean. The following is an expression for the shape-regulating parameter determinant criteria: Figure 3 shows the flowchart of the selection procedure with the FWPSO algorithm.

In PSO, the search space is scanned by a swarm of Np particles to determine the best solution [30]. The velocity and efficiency ratings are shared by all components. Depending on its own prior best placement and the prior best position of the swarm, each particle (i.e., a possible solution) advances in the search space at a certain speed. To obtain a better search region, the particles fly across the D-dimensional problem space throughout the search process. Two characteristics, namely the particle's present location ($X_{i, k}$) and velocity ($V_{i, k}$) on the search space, define particle I (I=1, 2,...,Np) [31]. The iteration counter may be found at the index k. The following relations determine how the particles in the initial population (k=0) move and place themselves first:

$X_{i, 0}^j=X_{M i n}+\operatorname{Random}\left(X_{M a x}-X_{M i n}\right)$         (7)

$V_{i, 0}^j=V_{{Min }}+\operatorname{Random}\left(V_{M a x}-V_{M i n}\right)$    (8)

where, $X_{i, 0}^j$ and $V_{i, 0}^j$ are, in relation to the jth (j=1,2,...,D) dimension, the ith (i=1,2,....Np) particle's location and velocity values, respectively. $X_{\text {Min }}, X_{\text {Max }}, V_{\text {Min }}$ and $V_{\text {Max }}$ are the user-defined boundaries, and Random is an evenly distributed random integer generated in (0,1). The following equations update the location and speed of each particle for the subsequent populations (k>0) for i=1, i=2, i=3, i=4,5, i=6, and i=Np:

$V_{i, k+1}=c_1 r_1\left(X_{i, k}^{p b e s t}-X_{i, k}\right)+c_2 r_2\left(X_{i, k}^{\text {gbest }}-X_{i, k}\right)+W_k V_{i, k}$   (9)

$X_{i . k+1}=X_{i . k}+V_{i . k+1}$           (10)

where, X_i,k is the situation of the ith particle at the kth iteration, $X_{i, k}^{p b e s t}$ is the role of the ith particle at the finest prior installment, $V_{i, k}$ is the velocity, $c_1$ and $c_2$ are referred to as perceptual and social correlations, $r_1$ and $r_2$ are unified random numbers in (0,1), and $X_{i, k}^{g b e s t}$ is the keep in mind that $c_1$ and $c_2$ are the positive constants that, correspondingly, indicate the attraction toward $X_{i, k}^{p b e s t}$, and $X_{i, k}^{g b e s t}$ [32]. W_k is the inertial weight that influences the new velocity by acting on the previous velocity.

The linear decreasing approach of fuzzy inertia weighting, in which $W_k$ is updated using the following formula, is one of the most often used techniques:

$W_i=W_{\text {Max }}-\frac{W_{ {Max }}-W_{ {Min }}}{{ Iter }_{{Max }}} \times \mathrm{k}$      (11)

where, $Iter _{{Max }}$ is the maximum number of iterations and $W_{{Max}}$ and $W_{{Min}}$ are the weighting coefficient's starting and ultimate levels, correspondingly. The fundamental PSO structure is as follows:

Step 1: Create the particle's starting population location and speed using Eqs. (7) and (8).

Step 2: Utilize relation (9) and update the location and speed of each particle (11).

Step 3: Calculate the relevant fitness values in accordance with the fitness function of the optimization problem after mapping the particle location to the solution space.

Step 4: Update $X_{i, k}^{ {pbest }}$ and $X_{i, k}^{ {gbest }}$.

Step 5: Proceed to Step 2 if the requirements for halting are not satisfied; otherwise, terminate the algorithm.

The following is an explanation of the proposed FWPSO approach:

1) Perform the calculations necessary to determine the local maxima and minima of the IMF.

2) When compared with the adaptable thresholds, the actual numbers of the local maximum and minimum were examined by λ distinct determinations made using the FWPSO algorithm. Produce a partially analyzed IMF by setting the maxima with values lower than the threshold to zero.

3) Perform the calculations necessary to determine all the local maxima and minima of the IMF that were obtained in Step 2.

4) Step 3 involves performing a comparison between the actual numbers of the local maximum and minimum using the same threshold λ, zero out the extremes whose absolute values are lower than the threshold, and obtaining another IMF that has been partially analyzed.

5) Repeat Steps 3 and 4 as many times as necessary until there are no more local maxima and minima that need to be reset to zero.

The proposed approach can save all QRS information. This is accomplished by continually filtering peaks that are lower than the threshold. The Signal-to-Noise Ratio (SNR) is a quantitative evaluation of the performance of the approach. The SNR is the ratio of the amount of usable energy to the amount of noise energy. The equation below describes the definition of signal-to-noise ratio Eq. (12):

$S N R=10 \log \left(\frac{\sum_{n=1}^N s^2(n)}{\sum_{n=1}^N n^2(n)}\right)$     (12)

where, s(n) denotes the signal that existed before the introduction of any noise and n(n) refers to the noise that has been incorporated into the signal. Their connections are represented by the equation in the following phrase Eq. (13):

$x(n)=s(n)+n(n)$          (13)

where, x(n) represents the erratic signal. The effectiveness of the denoising algorithms was evaluated by examining the increase in the SNR. This equation describes how the SNR improvement is defined Eq. (14):

$SN R_{{imp }}=S N R_{{denoised }}-S N R_{{original }}$          (14)

A metric for assessing the efficiency considering the energy perspective is the SNR increase. The EMD signal is shown in Figure 4.

4.png

Figure 4. Empirical mode decomposition

3.3 Segmentation

The three components of the heartbeat segmentation process are the detection of P and T waves and the QRS complex.

QRS complex detection: The Pan Tompkins approach identifies the QRS complex on denoised ECG data. The method can be broken down into four steps: derivation, quadratic distinctions, shifting integral, and threshold operations.

Finding a steep slope is one of the steps in the separation process, which is utilized to isolate the QRS complex from other electrocardiogram waveforms. Subsequently, point-to-point squaring of the slope is performed, which is an essential step because it highlights the higher values that mostly arise as a result of the QRS complex. Subsequently, moving-window integration will disclose other information, including the QRS onset, offset, and breadth. Additionally, amplitude thresholds were used to locate the R peaks.

5.png

Figure 5. QRS signal

P-and T Waves delineation: Following the identification of the QRS complex, the QRS complex serves as a guide for establishing the boundaries of two search windows that are utilized to simultaneously detect P- and T-waves. The average integral nucleus was located at the P-wave peak. The local minimum and maximum were compared to the corresponding thresholds in the search window, and the T-waves were then calculated [33]. Figure 5 shows the QRS signal.

3.4 Feature extraction

The extracted ECG segments were analyzed using PCA. PCA is to isolate unimportant factors from a large set of important elements. The retrieved ECG segment was subjected to PCA, and the first five columns of the Y variables were considered the five characteristics for further categorization [34].

Reducing the ECG dataset dimensionality with PCA improved the performance of the CKWCNN classifier. PCA effectively reduces noise and emphasizes the most informative features by converting the original high-dimensional data into lower-dimensional space. This results in enhanced computational efficiency and faster training times, while preserving the key characteristics of the ECG signals. Additionally, morphological features offer valuable insights into the structural aspects of ECG signals, including the shapes, peaks, and intervals that are indicative of myocardial infarction. Incorporating these features enables the CKWCNN classifier to detect subtle patterns in the data that are crucial for an accurate classification. This added layer of information strengthens the robustness of the model and enhances its overall accuracy in identifying myocardial infarction. The combination of PCA and morphological features created a more effective feature set, which significantly improved the classification accuracy of the CKWCNN. By integrating these techniques, the model achieved better performance metrics than when using raw ECG data alone, resulting in improved detection rates and fewer false positives. When relying solely on raw ECG data, the model may find it challenging to identify relevant patterns owing to the high dimensionality and noise. In contrast, the integration of PCA and morphological features facilitates a more targeted analysis, leading to increased classification accuracy and a lower false-positive rate.

The issue of low-dimensional feature modeling is outlined below.

Let $\mathrm{X}=\left(x_1, x_2, \ldots, x_n\right)$ each x_i is an ECG feature vector of size n, and represents the n by N data matrix.

3.4.1 Computing the scatter matrix

The scatter matrix is computed as follows:

$\mathrm{S}=\sum_{k=1}^n\left(x_k-m\right)\left(x_k-m\right)^T$      (15)

where, m represents the mean vector.

The recommended approach calculates the mean values for increasing the dimension reduction probability.

$\mathrm{m}=n p$       (16)

where, the beats observed are indicated by the number n. p is the probability of success.

3.4.2 Computing eigenvectors and corresponding eigenvalues

When we extracted the component using covariance, the eigenvectors were multiplied by it. Let us verify that the equation is satisfied and that the eigenvector-eigenvalue computation is accurate.

$\sum v=\lambda v$          (17)

where, $\sum$-covariancematrix, v- Eigen vector and $\lambda$-Eigen value.

It is recommended to eliminate the eigenvalues with the lowest eigenvalues because they reveal the least information regarding the data distribution [35]. The usual method is to choose the top k eigenvectors by ranking the eigenvectors according to their associated eigenvalues from highest to lowest. Creating our dk-dimensional eigenvector matrix in this case requires merging the two eigenvectors with the highest eigenvalues $W^T$.

The samples are transformed onto the new subspace using the equation in the last step using the 23-dimensional matrix W that the system just generated $\mathrm{y}=W^T \times \mathrm{x}$. Following are the steps:

1) Consider the entire collection of information composed of examples with d dimensions.

2) Calculate the mean vector across all the dimensions.

3) The overall correlation matrix of the information set is created.

4) Compute eigenvectors ($e_1, e_2, \ldots, e_d$) eigenvalues that relate to the various variables ($\lambda_1, \lambda_2, \ldots, \lambda_d$).

5) To create a matrix with dimensions d×k, the eigenvectors are arranged in descending order of their eigenvalues, and then choose the k eigenvectors that have the highest eigenvalues W.

6) To convert the samples into a new subspace, the dk eigenvector matrix may be used. The mathematical equation may be used to provide a concise summary of this: $\mathrm{y}=W^T \times \mathrm{x}$ (where x is ad×1-One sample is represented by a one-dimensional vector, and the converted k-by-one-dimensional sample in the new subspace is represented by y.

3.5 Classification

3.5.1 Convolution weight based CNN (CWCNN) classifier

This research aimed to categorize myocardial infarction via a Convolution Kernel Weight-Based Convolutional Neural Network (CWCNN). This network primarily comprises convolutional, subsampling or pooling, and fully linked layers [36]. This network architecture has an input layer that receives the selected characteristics, an output layer that produces the trained results, and several intermediary layers referred to as hidden layers as shown in Figure 6.

6.png

Figure 6. Convolutional neural network (CNN)

Convolution Layer

A convolutional neural network (CNN) commences with a convolutional layer as its initial component. This layer executes convolution by utilizing a kernel (or filter) for the input characteristics.

To provide the output [37], each characteristic of the input matrix underwent convolution with the kernel. The output is represented as n and is obtained by convolutionating the input and the kernel. The kernel of a convolution matrix is commonly termed a filter, and the output generated from applying this filter to the input is referred to as a feature map, which possesses dimensions i*i.

In the subsequent convolutional layers of the network, the inputs and outputs consist of feature vectors. Each convolutional layer utilized a collection of n filters. The input undergoes convolution with these filters and the depth of the resultant feature maps (n) correlates with the number of filters employed. Each filter map denotes a distinct feature that is derived from a specific input area.

The output of the l^th convolution layer is denoted by the symbol $C_i^{(l)}$ is derived as follows:

$C_i^{(l)}=B_i^{(l)}+\sum_{j=1}^{a_i^{(l-1)}} K_{i, j}^{(l-1)} * C_j^{(l)}$          (18)

where, $B_i^{(l)}$ represents the bias matrix $K_{i, j}^{(l-1)}$ through a convolution filter from the preceding layer (l - 1) incorporating the ith feature map alongside the others. The results of the work $C_i^{(l)}$ constitutes the feature maps of the layer in question. In Eq. (18), the intial layer of CNN network $C_i^{(l-1)}$ is a place for input, which is $C_i^{(0)}=X_i$.

The kernel then generates a feature map. After applying the convolution layer:

$Y_i^{(l)}=Y\left(C_i^{(l)}\right)$          (19)

where, $Y_i^{(l)}$ represents the activating factor and $C_i^{(l)}$ denotes the data that is inputted into it.

The three most commonly adopted activation functions are sigmoid, tanh, and rectified linear units (ReLUs). The research occasionally refers to weighted ReLUs is $Y_i^{(1)}=w \cdot \max \left(0, Y_i^{(1)}\right)$. The activation function is frequently used in deep learning models because of its efficacy in mitigating the detrimental impacts of interactions and nonlinearity and is essential for improving model performance. In this case, we employ a Rectified Linear Unit (ReLU) activation function [38]. For negative inputs, the ReLU outputs 0 and maintains the input value for positive inputs. This function is helpful because it accelerates learning by fixing the vanishing gradient problem. In the saturation zones, the gradient becomes much smaller, which means that the training weights do not change significantly.

We integrated the feature weights to enhance the performance. We calculate the convolution kernel weights based on the significance of the features instead of assigning them randomly. The primary benefit of using these convolution weights is that they reduce classification mistakes by considering the significance of the features derived from the data. Thus, the kernel recognizes the features to obtain weights (Figure 7).

7.png

Figure 7. Convolution Kernel Weight Based CNN (CKWCNN) classifier

Pooling Layer

Following the convolutional layer, the subsampling layer aims to reduce the spatial dimensions of the map features from the previous convolutional layer [39]. We accomplished this reduction by partitioning the feature maps into 2×2 blocks and calculating the average value for each block. The subsampling layer maintains the relative information among the features instead of their precise relationships. Incorporating a subsampling layer improves the resilience of the convolutional layer to translation and rotation in the input data.

Fully Connected Layer

The output layer uses softmax activation:

$Y_i^{(l)}=f\left(z_i^{(l)}\right)$            (20)

where, $z_i^{(l)}=\sum_{i=1}^{m_i^{(l-1)}} w_{i, j}^{(l)} y_i^{(l-1)}$.

where, $w_{i, j}^{(l)}$ denotes the completely linked layer must alter weight values to reflect each class, and f represents the transfer function, which denotes nonlinearity.

Pseudo code algorithm: Convolutional Kernel Weight based CNN classifier

Input: Selected features x₁, x2, x3....x_n, target label T (y₁....y_T), Number of convolutional masks size, Number of epochs for Forward Propagation and Backward Propagation

Output: Predicted Labels

Steps:

1: Start

2: sf(Xi) ← Get selected features

3: Normalize the feature data

4: regularization feature data

5: Repeat every epoch

6: Perform forward propagation until epochs

7: cd ← Convolution (sf sf(Xi))

8: mp ← pooling (cd)

9: fc ← fully _connected (mp)

10: calculate weight w_i using Convolution kernel till convergence completed

11: class label ← Soft_max (fc)

12: Do Backward Propagation till R

13: Conduct backward propagation

14: Obtain the output predicted labels Yi

15: End.