Privacy-Preserving Federated IoT Architecture for Early Stroke Risk Prediction

Abstract

Stroke is one of the leading causes of death and long-term disability worldwide, and effective prevention depends on fast, reliable, and privacy-preserving risk assessment. This study proposes a federated IoT-enabled framework that combines feature-optimized machine learning (ML) with real-time patient monitoring to predict and detect brain stroke risk. The system operates in two stages: (i) a stroke prediction module that builds an ML model for risk assessment and (ii) an IoT-based framework that continuously monitors patients and triggers timely alerts. The ML pipeline starts from a clinical–physiological dataset containing 17 initial attributes and applies a feature optimization strategy based on feature importance, selection, and reduction to identify the most informative predictors of stroke. To support multi-center deployment while protecting patient confidentiality, the ML pipeline is embedded within a standard Federated Averaging (FedAvg) architecture, where multiple home or hospital IoT gateways collaboratively train a shared global model without exchanging raw patient data. In each communication round, clients perform local training and the server aggregates client model parameters to update the global model. The resulting federated global model matches the performance of the centralized baseline, achieving 99.44% test accuracy while preserving data locality. Integrated with IoT devices, the system can detect pre-stroke syndromes in real time and automatically notify family members or emergency medical services, making it suitable for both home and hospital environments and offering a practical path toward early intervention and improved stroke outcomes.

1. Introduction

Stroke, occasionally called brain attack, is rapidly becoming one of the primary causes of death worldwide. According to the World Health Organization, brain stroke is the second most prevalent cause of fatalities and permanent disabilities worldwide. The brain, considered one of the most crucial organs in a person’s body, also has a key cognitive and behavioral function. Compared with the brains of other vertebrates, the cerebral cortex of the human brain is far more advanced. Three primary elements form the human brain (white matter, gray matter, and cerebrospinal fluid) [1,2,3]. As a necessary aspect of the functioning of the human body, the brain is supplied with nutrients and oxygen through constant blood circulation. Brain stroke occurs when the brain’s blood supply is suddenly cut off or severely decreased. Brain stroke can be exceedingly dangerous and potentially results in a wide range of adverse outcomes, including major brain disorders, damage, facial drooping, weakness, long-term or short-term impairment, and even death [3,4]. Notably, almost 16 million people worldwide suffer a stroke every year, with 6 million losing their lives and another 6 million permanently disabled. In addition, each year in the United States, approximately 796,000 persons suffer from a stroke, with 650,000 of those being first strokes and 187,000 are recurrent strokes. Stroke is the leading contributor to the overall prevalence of neurological disorders in India, accounting for 37.9% of all cases and 7.4% of all deaths [5,6,7,8,9].

Appropriate blood flow is necessary for the proper functioning of both the brain and heart. Strokes can occur because the brain does not receive enough blood or because of a blockage in the blood arteries that supply blood to the brain. Ischemic and hemorrhagic brain strokes are two categories of brain strokes. Ischemic stroke occurs when a clogged artery cuts off oxygen-rich blood into the brain. The presence of clumps in the brain can be categorized as thrombotic or embolic. Hemorrhagic stroke can cause brain bleeding. There are two main types of hemorrhagic brain strokes: subarachnoid and intracerebral. When comparing these two types of stroke, it is clear that ischemic stroke is the leading cause of death. Even though they only account for 10–15% of the total stroke incidence, hemorrhagic strokes are associated with very high mortality and morbidity rates, which have not decreased anywhere in the world over the past 20 years. Mortality is greater than 50 percent, with half of all deaths occurring in the first two days of the illness. Moreover, 3% of people experience subarachnoid hemorrhage, 10% experience intracerebral hemorrhage, and 87% experience ischemic stroke [2,8,10]. Worldwide, 25% of the population over 25 years of age will experience stroke once throughout their lives, as reported by the World Stroke Organization. Every year, over 12 million people experience their first stroke, and over 6 million people lose their lives as a direct result of that stroke. A stroke affects not only the individual who suffers it but also their social circle, household, and place of employment. Numerous scientific investigations have been conducted to identify reliable indicators of stroke. Researchers have identified several risk factors for stroke in the brain, including age, sex, heavy alcohol use, systolic blood pressure, use of antihypertensive therapy, diabetes, smoking, history of cardiovascular disease, atrial fibrillation, left ventricular hypertrophy as measured by electrocardiogram, body weight, diet, and family history. Stroke is becoming more common and deadly, especially in third-world countries [11,12,13,14].

Stroke has rapidly become the leading cause of mortality and health-related impairments on a global scale. Significant financial consequences can be expected following treatment and for post-stroke care [8,15,16]. Patients can benefit greatly from early diagnosis of brain stroke. Magnetic Resonance Imaging (MRI), electroencephalography (EEG), Positron Emission Tomography (PET), ultrasound imaging, and Computed Tomography (CT) are among the most commonly used diagnostic methods for stroke. These methods are widely used because of their high degrees of accuracy. However, concerns remain regarding the safety of these gadgets. For instance, X-ray light in CT scans may directly affect the patient’s body. In addition, many countries have a deficiency in the availability of these tools, or therapy is prohibitively expensive for most people [2,17]. Therefore, there is an immediate need for a portable, low-cost, time-saving, and highly accurate method to predict stroke. Early detection and diagnosis are aided by accurate detection of stroke. Stroke detection is complex. Stroke texture, form, and color vary widely, making detection difficult and time consuming [2,4]. However, numerous systems have been developed that use Artificial Intelligence (AI), ML, and Deep Learning (DL) to analyze brain activity and predict or identify individual strokes. A unique DL technique using Artificial Neural Networks (ANNs) was empirically evaluated in [18] to identify and categorize intracranial hemorrhage (ICH). The model was built with an AUC of 90.3% for ICH detection. Subarachnoid hemorrhage (SAH) had an exceptionally high accuracy rate of 91.7% in classifying ICH into subtypes.

The purpose of this research [19] was to evaluate the efficacy of employing support vector machines (SVMs) for the identification and classification of microwave-induced brain strokes. The approach showed that SVM can identify stroke and divide it into ischemic and hemorrhagic types. In a previous study [2], the Convolutional Neural Network (CNN) was utilized to classify the severity of strokes. The proposed algorithm detected brain strokes with higher accuracy (98.3%). The primary purpose of this research [13] is to develop a method for assessing an individual’s stroke risk based on their medical history and lifestyle choices. This study used five ML algorithms to analyze patients’ medical records and physical activity to detect and categorize strokes. With an accuracy of 82.1%, the decision tree algorithm was the most successful in predicting strokes based on various physiological parameters. The authors of the paper [8] reviewed 177 articles published between 2010 and 2021 to assess the current state and obstacles of computer-aided diagnosis (CAD), ML, and DL methods that use CT and MRI as primary procedures for stroke identify and region segmentation.

The research paper [7] presented a lightweight microwave head imaging system that utilizes a tiny 3D antenna with MTM technology. The system consists of an array of nine antennas, a head phantom that simulates tissue, a power network analyzer, and a computational device that gathers and stores dispersed data for later processing. Additionally, an MTM-loaded compact 3D antenna covering the frequency range of 1.95 to 4.5 GHz with 80% fractional bandwidth is described in this work for a portable microwave head imaging system. In work [20], a hybrid threshold-based picture categorization and segmentation model was constructed to predict strokes. The approach presented herein employs a combination of a robust decision tree classifier and a feature selection algorithm to isolate the most relevant characteristics for stroke forecasting. The experimental results demonstrated that the existing model attained an accuracy of 98.23%. Using five different ML algorithms, ref. [3] developed a system with an accuracy of up to 98.56% for predicting brain strokes. The primary goal of this study was to demonstrate that a combination of boosting techniques, ML algorithms, and ANNs can be used to predict the onset of stroke in the brain. Stroke Prediction Ensemble (SPE) is a framework described in [21] that combines feature engineering and ensemble classification to provide stroke predictions. Empirical research has shown that the ensemble model has the highest accuracy of approximately 97.93%.

In the recent years, wearable devices have become the most preferable option in many healthcare monitoring and rehabilitation applications because they can provide continuous observation, are easy to access, and can be adapted to different clinical needs. Building on these advances, sensor-based platforms are now being developed to support stroke survivors along the full rehabilitation pathway, from hospital to home. For example, Zhang et al. proposed robust vital-sign monitoring using mmWave sensing with multi-point reflection modeling, which improves reliability under small body motions and challenging environments [22]. In addition, Ni et al. introduced REHSense, a battery-free wireless sensing approach that leverages RF energy harvesting to enable sensing with extremely low power consumption [23]. Compared to these methods, our prototype focuses on a practical BLE-based IoT stack (temperature and $Sp{O}_2$ sensors + smartphone fusion) that is easy to deploy with commercially available devices. In future work, we plan to investigate hybrid designs that incorporate contactless mmWave sensing and/or RF-energy-harvesting sensors to further improve user comfort and energy efficiency. Spinelli et al. introduced a user-centered wearable sleeve that integrates electromyography smart sensors, functional electrical stimulation, and virtual reality in a closed-loop system, enabling intensive, personalized upper-limb stroke rehabilitation and remote progress monitoring [24]. Using DL, a CNN model was created to identify heart arrhythmia and forecast sudden stroke. The proposed classifier outperformed existing methods with an accuracy of 99.3%. The development of a monitoring system for stroke identification and prediction utilizing IoT and fog computing technologies was presented in this study [25]. The monitoring system comprises three layers: the patient information layer, the cloud layer, and the fog computing gateway layer. The proposed system utilizes an ensemble classifier that combines random forest and boosting techniques. The monitoring system was evaluated using the accuracy, sensitivity, and specificity parameters. The simulation results indicated an accuracy of 93.64%. Stroke can be detected by recognizing abnormal gait patterns, and this research [26] proposed a smartphone and hybrid classification algorithm-based technique to detect irregular gait patterns in a stroke patient at the initial stage. Accelerometer and gyroscope data from the smartphone sensors were used to build the models. The obtained data were processed using min-max normalization, and acceptable characteristics were chosen to develop a model utilizing hybrid classification approaches (Multi-Layer Perceptron (MLP), Decision tree (DT), and SVM) according to the majority voting technique. The study showed 99.40% accuracy for aberrant gait pattern detection in the early stages of stroke. The authors of this article [27] discussed the process of developing an $Sp{O}_2$ monitoring device, which was initially utilized for detecting stroke in a patient. This system monitors and compares $Sp{O}_2$ values from the right and left arms simultaneously. If the percentage of $Sp{O}_2$ fell below 60%, the buzzer of this system would sound off as an alert.

In study [28], the authors reviewed over 100 research articles to investigate the trends and challenges associated with wearable multi-modal technologies for predicting stroke risk. They presented many wearable technologies currently available to predict the risk of developing stroke, and contrasted the various properties of these wearables. Researchers discovered that wearable with high user-friendliness may have limitations in providing precise prediction outcomes. The authors of the study [29] surveyed various portable, non-invasive diagnostic methods to simplify triage through the initial assessment of stroke type. After assessing 296 studies, 16 were selected for inclusion. Different diagnostic technologies, such as near-infrared spectroscopy (6), electroencephalography (4), ultrasound (4), volumetric impedance spectroscopy (1), and microwave technology (1), have been utilized by the devices studied. The median measurement time was 3 min (interquartile range [IQR], 3–5.6 min). They identified many technologies that accurately diagnose severe stroke and cerebral hematoma. The article [30] examined the cost-effectiveness of additional short-protocol brain MRI following negative non-contrast CT for screening minor strokes in patients in emergency conditions with moderate and unclear neurological symptoms. This study demonstrated that performing an additional emergency brain MRI using a short protocol, following a negative non-contrast head CT, is a cost-effective solution for certain neurological patients with mild and nonspecific symptoms. This strategy reduces costs and increases quality-adjusted life-years (QUALYs).

A novel architecture for a mobile AI smart hospital framework was proposed in the study [31] to improve stroke prediction and response time in emergencies. XAI architecture-based integrated AI software modules were developed and tested in this research. The main purpose of this work was to predict the occurrence of heart disease and stroke. The proposed techniques exhibited high accuracy, with the stacked CNN achieving nearly 98% accuracy in stroke diagnosis. The research [32] aimed to detect early-stage strokes utilizing big data and bio-signal analysis technology and contribute to human health improvement. Experimental tests were conducted to assess the sensitivity of a stroke-detection system developed for elderly adults. The health symptoms and motion data of 80 stroke victims and 50 normal elderly individuals were recorded. The bio-signal data from the experiment were extracted, and a judgment model was built by combining the data from the participant’s 10-year health examination. Study [33] aims to predict early brain strokes using DL and ML. XGBoost, Ada Boost, Light Gradient Boosting Machine, Random Forest (RF), DT, Logistic Regression (LR), K-Nearest Neighbors (KNN), SVM-Linear Kernel, Naive Bayes (NB), and deep neural networks (3-layer and 4-layer ANN) classification models were used here. The RF classifier had the highest ML classification accuracy at 99%. The 4-Layer ANN method had a 92.39% accuracy compared to the 3-Layer ANN method using the selected features and found that ML techniques beat out deep neural networks. The work [34] utilized the rapid response of EEG data to cerebral ischemia and clinical indicators to propose a “clinical indications + quantifiable electroencephalogram” multi-feature pattern recognition method. Long Short-Term Memory (LSTM) attention and multi-feature were used to diagnose ischemic stroke. Using the data of 500 ischemic stroke patients, the diagnostic model obtained 0.81 accuracy, 0.82 sensitivity, and 0.81 F1-score. DICE coefficient of 0.91, precision of 0.94, and sensitivity of 0.89 were the training set evaluation indicators of their cascaded 3D deep residual network stroke precise segmentation algorithm.

Moreover, the above discussion shows that federated learning can fit very well with IoT-based smart healthcare systems. Abbas et al. [35] present a comprehensive review of FL in healthcare, with a strong focus on how FL can work together with IoT devices, wearables, and remote monitoring platforms for predictive analytics and personalized care. They highlight key privacy, security, and interoperability issues and discuss solutions such as secure aggregation and differential privacy. However, this study stays at a high, system-level view and does not design or implement a concrete, real-time embedded stroke monitoring pipeline that combines FL with lightweight feature-optimized models on resource-constrained devices. At the algorithm level, Wang et al. [36] propose a privacy-preserving FL framework for the Internet of Medical Things (IoMT) under edge computing. Their PPFLEC scheme protects gradient updates using a secret-sharing–based masking protocol and adds digital signatures to ensure integrity and defend against replay and collusion attacks. The framework is designed to work in unstable edge environments and keeps model accuracy comparable to standard FL while improving privacy and robustness. Yet, this work mainly focuses on secure communication and aggregation; it does not consider application-specific designs such as stroke risk scoring, feature selection on tabular clinical data, or the integration with a real-time IoT stroke monitoring device. Aminifar et al. [37] present a privacy-preserving edge FL framework aimed at mobile health and wearable devices in IoT settings. They address strict resource limits (CPU, memory, and battery) and show that edge FL can support intelligent health monitoring, demonstrated on seizure detection using wearable sensors. Their work proves that FL can be pushed close to the data source, reducing latency and keeping sensitive data on devices. However, the study focuses on epilepsy and generic mobile-health pipelines; it does not target stroke, does not use structured stroke risk features like those in the Kaggle stroke dataset, and does not describe an embedded IoT gateway that combines optimized feature selection with real-time risk codes as in our system. For stroke specifically, Elhanashi et al. [38] introduce TeleStroke, a real-time stroke detection system based on YOLOv8 and federated learning on edge devices. Their model detects stroke versus non-stroke cases from facial images that capture signs such as facial paralysis and is deployed on NVIDIA edge platforms to meet real-time constraints. FL is used to train across distributed clients while keeping patient images local, which improves privacy and model robustness. Yet, this work focuses on vision-only stroke detection with a heavy deep model and GPU hardware; it does not use low-cost IoT physiological sensors, does not combine clinical risk factors with vital signs, and does not explore lightweight, feature-optimized ML models suitable for embedded microcontroller-based monitoring as in our proposed framework.

Although FL, ML, and IoT have been studied individually in healthcare, this work focuses on their joint integration for stroke-risk monitoring, where (i) FL builds a global model without centralizing raw data, (ii) feature optimization is evaluated within the FL pipeline to improve stability, and (iii) an IoT workflow applies the global model for real-time screening and alerting. This end-to-end design targets the practical gap between privacy-preserving model training and continuous patient monitoring in resource-limited settings. The main contribution of the proposed approach is described below:

• This paper presents an end-to-end stroke-risk framework that integrates federated learning (FL), machine learning (ML), and an IoT monitoring workflow to support early stroke risk screening while keeping data privacy in mind.
• We design a federated training setup where client-side data remain local and only model parameters are exchanged, enabling multi-source learning without centralizing raw patient records.
• We evaluate a feature optimization pipeline (feature importance, selection, and reduction) to identify the most informative stroke-related factors and to improve model stability across different classifiers.
• We implement a round-based FedAvg training protocol in which clients train locally for E epochs and the server aggregates parameters over T communication rounds to obtain a global stroke-risk predictor.
• We describe an IoT-assisted monitoring and alert workflow where physiological signals (e.g., temperature asymmetry and $Sp{O}_2$) support real-time tracking and can trigger warnings to caregivers or emergency services when high risk is detected.

The manuscript is divided into five individual sections. Section 2 details the proposed approach’s architecture and fundamental principles. In Section 3, the outcomes are presented alongside an appropriate rationale. Finally, Section 4 presents the conclusion of the manuscript along with the existing drawbacks and a summary of the future directions.

2. Materials and Method

This section presents the overall method, the proposed pipeline. The subsection presents the pipeline of the core Machine Learning (ML) with the feature optimization and the setup of the Internet of Things (IoT) pipeline. At the end, the subsection illustrates the setup of the federated pipeline. As shown in Figure 1, the proposed system uses federated learning and IoT devices for stroke risk monitoring. On the left side, several local setups (such as Hospital A, Hospital B, and home environments) collect patient data using IoT sensors and smartphones. These devices record features such as age, temperature, $Sp{O}_2$, pulse, sugar level, and BMI to build a local stroke dataset. Each local server then applies feature optimization (for example, PSO, mRMR, PCA/LDA) and trains machine learning classifiers, producing a trained local model with weights $\Delta w_1, \Delta w_2,\dots ,\Delta w_k$. The raw patient data remain stored locally and are never sent to the cloud. In the middle, only the local model updates are sent to a secure aggregation server. This server combines the updates from all participating clients using the FedAvg rule, $W^{(t+1)}={\sum }_{k=1}^K{\displaystyle \frac{n_k}{N}}{w}_k^{(t+1)}$, to obtain an initial global model without accessing any original records. A coordinating server stores the final global model. We follow a round-based client–server protocol: at each round t, the server broadcasts the current global parameters $w^{\left(t\right)}$, clients train locally starting from $w^{\left(t\right)}$, and the server updates the global model by aggregating client parameters using FedAvg. On the right side, the global model is used for stroke risk assessment. When a new patient is monitored, their IoT and clinical features are fed into the global model to estimate the stroke risk level. If the predicted risk is high, the result is sent through the IoT cloud so that family members, ambulance services, or hospitals can be alerted for immediate action.

2.1. The Core Machine Learning Pipeline in Local Training

In the subsection, the core pipeline of the proposed pipeline is described. The interconnected subsections included in representing this section are dataset building, data preprocessing, data analyzing, and feature optimization techniques (feature importance, feature selection, and feature reduction). In contrast, the subsection also presents how IoT-based sensor data is connected and the orientation of the IoT-based sensors of the IoT cloud data monitoring. The graphical summary of the core ML model is presented in Figure 2.

2.1.1. Dataset Preparation of Core ML Pipeline

To implement ML models, one must provide data to train the algorithms and then offer additional data for validation and testing. In this study, we used the “Stroke Risk Prediction Dataset Based on Symptoms” from Kaggle [39], which is freely accessible to the public. The dataset contains 70,000 records, each corresponding to an adult individual. For every subject, 16 binary attributes capture common stroke–related symptoms (such as chest pain, shortness of breath, dizziness, and high blood pressure), together with one numerical age feature and one continuous stroke–risk score expressed as a percentage. The ages range from 18 to 90 years, with an average age of about 54 years. The final label At Risk (Binary) indicates whether the individual is considered to be at risk of stroke, with 45,444 records labeled as at risk and 24,556 records labeled as not at risk. A concise summary of the main dataset attributes, including their descriptions, types, and example values, is presented in

Table 1. Stroke-risk dataset features with description, type, and sample values.

Feature Name	Description	Type	Values
Chest Pain	Presence of chest pain	Boolean	“0” (No), “1” (Yes)
Shortness of Breath	Difficulty in breathing	Boolean	“0” (No), “1” (Yes)
Irregular Heartbeat	Irregular or skipped heartbeat	Boolean	“0” (No), “1” (Yes)
Fatigue & Weakness	Unusual tiredness or weakness	Boolean	“0” (No), “1” (Yes)
Dizziness	Feeling dizzy or lightheaded	Boolean	“0” (No), “1” (Yes)
Swelling (Edema)	Swelling in legs, ankles, or feet	Boolean	“0” (No), “1” (Yes)
Pain in Neck/Jaw/Shoulder/Back	Pain in upper body regions	Boolean	“0” (No), “1” (Yes)
Excessive Sweating	Heavy or cold sweating	Boolean	“0” (No), “1” (Yes)
Persistent Cough	Long-lasting cough	Boolean	“0” (No), “1” (Yes)
Nausea/Vomiting	Nausea or vomiting	Boolean	“0” (No), “1” (Yes)
High Blood Pressure	History of high blood pressure	Boolean	“0” (No), “1” (Yes)
Chest Discomfort (Activity)	Chest discomfort during activity	Boolean	“0” (No), “1” (Yes)
Cold Hands/Feet	Cold hands or feet	Boolean	“0” (No), “1” (Yes)
Snoring/Sleep Apnea	Snoring or sleep apnea symptoms	Boolean	“0” (No), “1” (Yes)
Anxiety/Feeling of Doom	Anxiety or feeling something is wrong	Boolean	“0” (No), “1” (Yes)
Age	Age of the individual (years)	Integer	“18”, “36”, “54”, “72”
Stroke Risk (%)	Estimated stroke risk score	Floating point	“5.0”, “40.5”, “58.0”, “100.0”
At Risk (Binary)	Stroke risk label	Boolean	“0” (Not at risk), “1” (At risk)

. The dataset was split into 80% for training and 20% as an independent test set for evaluating performance on unseen data.

2.1.2. Data Pre-Processing and Data Analysis

The dataset used in this study is the Kaggle Stroke Risk Prediction Dataset Based on Symptoms [37]. It contains 18 columns in total, where the input features are mainly symptom-based binary indicators along with Age, and the dataset also provides two outcome fields: Stroke Risk (%) and At Risk (Binary) [37]. At the beginning of preprocessing, we checked the dataset for missing (NaN) values and applied a simple cleaning procedure to handle them. Because the variables are mostly symptom indicators and do not show complex numerical dependencies, we used linear interpolation to fill missing numeric entries when needed [40,41]. After cleaning, we ensured that all model inputs are in numeric form. Since the dataset already represents symptoms using numeric/binary values and includes Age as a numeric feature, no demographic-style categorical variables (e.g., gender or work_type) are used in this dataset. Finally, we performed basic exploratory analysis to understand feature distributions before training the proposed models.

2.1.3. Feature Optimization Techniques

In order to increase the efficiency and accuracy of ML models while simultaneously decreasing their computational complexity, the feature optimizer is a widespread technique [42]. Various approaches, such as feature reduction, feature importance, and feature selection, are used to improve the quality of features. The present study utilized the most prevalent optimization techniques for each feature optimization to choose from to predict the brain stroke probability. The proposed ML-based framework for stroke prediction is illustrated in Figure 3. The figure shows the feature-optimization block used at each client. First, the modified stroke dataset, which mixes IoT data and secondary sources, is cleaned to remove missing values and noise. This step produces the clean preprocessed data $x=[x_1,x_2,\dots ,x_d]$. From this clean data, two tree-based models, the Random Forest Classifier (RFC) and the Extra Trees Classifier (XTC), are trained to compute feature importance scores. These scores act as the first feature–optimizer. In parallel, feature selection is performed using two methods: minimum Redundancy Maximum Relevance (mRMR) and Particle Swarm Optimization (PSO). Both methods search for the subset of features that gives high prediction power with low redundancy. The selected features are then passed to the feature-reduction block, where Principal Component Analysis (PCA) and Linear Discriminant Analysis (LDA) project the data into a lower-dimensional space. PCA uses the eigenvectors of the covariance matrix, while LDA maximizes the ratio of between-class to within-class scatter. Each of these techniques produces a local feature score vector $G_k^{\left(t\right)}$. All local vectors are combined using the feature–optimization equation:

$$G^{\left(t\right)}=\sum _{k=1}^K{\displaystyle \frac{n_k}{N}}{G}_k^{\left(t\right)}$$

which gives the final optimized feature scores used for federated model training. A comprehensive illustration of the feature optimizers and an analysis of their role in this research are provided below. Pseudo-code for the feature optimization strategies can be seen in Algorithm 1.

Algorithm 1 Feature optimization block for a local client.

1: Input: Modified dataset $D={\left\{(x_i,y_i)\right\}}_{i=1}^N$, $x_i\in {\mathbb{R}}^d$   2: Output: Optimized feature matrix $X_{\mathrm{opt}}$ and global feature score vector $G^{\left(t\right)}$

3: Stage 1: Data cleaning and preprocessing   4: $D_{\mathrm{clean}}\leftarrow$ CleanData (D)         ▹ Remove noise, outliers, and missing values   5: $D_{\mathrm{prep}}\leftarrow$ PreprocessData (Dclean)       ▹ Encoding, scaling, and basic analysis   6: $(X,y)\leftarrow$ ToMatrix (Dprep)                        ▹$X\in {\mathbb{R}}^{N\times d}$

7: Stage 2: Feature importance (RFC, XTC)   8: ${\theta }_{\mathrm{RFC}}\leftarrow$ TrainRFC (X, y)   9: ${\theta }_{\mathrm{XTC}}\leftarrow$ TrainXTC (X, y) 10: $G_{\mathrm{RFC}}\leftarrow$ GetImportance (θRFC) 11: $G_{\mathrm{XTC}}\leftarrow$ GetImportance (θXTC) 12: $G_{\mathrm{FI}}\leftarrow (G_{\mathrm{RFC}}+G_{\mathrm{XTC}})/2$              ▹ Combined feature–importance vector

13: Stage 3: Feature selection (mRMR, PSO) 14: ${\mathcal{F}}_{\mathrm{mRMR}}\leftarrow$ mRMRSelect (X, y, GFI) 15: ${\mathcal{F}}_{\mathrm{PSO}}\leftarrow$ PSOSelect (X, y, GFI) 16: ${\mathcal{F}}_{\mathrm{sel}}\leftarrow {\mathcal{F}}_{\mathrm{mRMR}}\cup {\mathcal{F}}_{\mathrm{PSO}}$ 17: $X_{\mathrm{sel}}\leftarrow X[:,{\mathcal{F}}_{\mathrm{sel}}]$

18: Stage 4: Feature reduction (PCA, LDA) 19: $Z_{\mathrm{PCA}}\leftarrow$ ApplyPCA (Xsel)                     ▹$Z_{\mathrm{PCA}}=X_{\mathrm{sel}}{W}_{\mathrm{PCA}}$ 20: $Z_{\mathrm{LDA}}\leftarrow$ ApplyLDA (Xsel, y)                   ▹$Z_{\mathrm{LDA}}=X_{\mathrm{sel}}{W}_{\mathrm{LDA}}$ 21: $X_{\mathrm{opt}}\leftarrow$ ChooseBestrepResentation (ZPCA, ZLDA)

22: Stage 5: Global feature score (for FL) 23: $G_k^{\left(t\right)}\leftarrow$ ComputeFeatureScore (Xopt, y)      ▹ Local feature–score vector at client k 24: $G^{\left(t\right)}\leftarrow {\sum }_{k=1}^K{\displaystyle \frac{n_k}{N}}{G}_k^{\left(t\right)}$               ▹ Global feature–optimization equation 25: return $X_{\mathrm{opt}},G^{\left(t\right)}$

2.1.4. Working Principle of IoT-Based Patient Monitoring System

Besides predicting the risk of stroke, this study also focused on whether stroke has occurred. The functionality of this monitoring system is to detect a stroke or determine the probability of whether a stroke might have occurred, based on measuring two physiological data: temperature and SaO₂ level. Stroke patients often experience a sensation of coldness in the paralyzed limb [43]. According to one study, 64% of people with stroke sequelae experienced this change in the thermic sense. In fact, the upper limb of a patient with paralysis from a stroke can be 1–5 °C colder than the opposite limb [44,45]. Therefore, measuring the temperature difference between the two upper limbs is used to detect strokes. The proposed stroke monitoring system utilized two MAX30205 high-precision medical-grade temperature sensors. The sensor can measure body surface temperature with 0.1 °C accuracy with 16-bit temperature resolution. The power usage issue was considered while selecting the sensor, as it is a wearable device. The MAX30205 is a very low-power consuming device that works on 2.7 V to 3.3 V DC supply, and the operating current is only 600 µA [46]. Moreover, ESP3 system on a chip (SoC) with integrated Bluetooth Low Energy (BLE) is used to fetch & process sensor data and transmit them to the smartphone over BLE.

An oxygen saturation level of 95% or higher is generally considered the recommended oxygen level [47]. But if oxygen saturation of arterial blood (SaO₂) is decreased to this range of 90 ⩽ SaO₂ < 94%, then the phenomenon is called “mild hypoxia” [48]. It commonly occurs in patients who have experienced a stroke. Mild hypoxia can cause additional damage to the brain that is already suffering from a lack of oxygen, because blood flow to a portion of the brain is decreased both during and after a stroke. A smart, ring-shaped wearable oxygen monitor called “O2Ring” is used to measure oxygen saturation levels in arterial blood. This smart device can measure SaO₂ and transfer data to a user’s smartphone using Bluetooth technology [49,50]. After collecting temperature and SaO₂ level data from wearable temperature-sensing devices and O2Ring, the proposed smart app determines whether the patient has had a stroke. The decision-making algorithm relies on sensor and patient stroke risk data obtained from the proposed ML-based system. Based on the user’s condition, the monitoring app takes some action by itself (e.g., generating a warning alarm, sending a message to the family member, or Emergency Medical Services (EMS) provider with the patient’s current location). Figure 4 depicts the graphical overview of the proposed IoT-based monitoring system.

The proposed app determines the user’s condition using the following technique, described in Algorithm 2. It indicates 4 status types by providing RiskCode (shown in

Table 2. RiskCode interpretation and associated system’s actions for each RiskCode.

RiskCode	Meaning	System’s Actions
RC: 0	No serious issue is found.	Nothing
RC: 1	The issue is not severe, but it should be a subject of concern.	Vibration and sound notifications to its user.
RC: 2	It can be a serious issue; a stroke may have occurred.	Sends SMS with the current status to the selected family contacts with current location details.
RC: 3	Something happened severe, vital signs of stroke.	To seek emergency help, it sends SMS with the current status and location details to the selected family contacts and nearby EMS providers.

). A flowchart has been shown in Figure 5 to understand the working procedure better.

Algorithm 2 Working Procedure of IoT-based Monitoring System.

Require:  Stroke risk probability p (from ML-based analysis), physiological data via BLE/Bluetooth Ensure:  Final RiskCode $R{C}^{★}$ with associated actions   1: $(T_L,T_R)\leftarrow$ read temperatures from left and right upper limbs (BLE)   2: $\Delta T\leftarrow |T_L-T_R|$                                                                                   ▹ temperature asymmetry   3: $s\leftarrow$ read ${\mathrm{SaO}}_2$ level from pulse oximeter (Bluetooth)   4: $p\leftarrow$ ML-generated stroke risk probability   5: Map physiological inputs to intermediate risk codes:    $R{C}_{\mathrm{temp}}\leftarrow f_{\mathrm{temp}}(\Delta T)$, $R{C}_{\mathrm{oxy}}\leftarrow f_{\mathrm{oxy}}\left(s\right)$, $R{C}_{\mathrm{ml}}\leftarrow f_{\mathrm{ml}}\left(p\right)$   6: Fuse codes using logic from Table 3:    $R{C}_1\leftarrow g_1(R{C}_{\mathrm{temp}},R{C}_{\mathrm{oxy}})$    $R{C}_2\leftarrow g_2(R{C}_{\mathrm{ml}},R{C}_{\mathrm{oxy}})$   7: Select final risk code: $R{C}^{★}\leftarrow max\{R{C}_1,R{C}_2\}$   8: Execute $\mathrm{Actions}\left[R{C}^{★}\right]$ ▹ e.g., notify user, alert caregiver, trigger EMS call, cloud logging   9: return$R{C}^{★}$

Table 3. RiskCode (RC) generation logic for the proposed IoT framework’s algorithm.

Physiological Attribute	Range	Low (0–40%)	Caution (41–70%)	High (71–100%)
Temp. Diffr. (°C)	0 to 0.99	RC: 0	RC: 0	RC: 0
	1 to 1.99	RC: 0	RC: 1	RC: 1
	2 to 2.99	RC: 1	RC: 2	RC: 2
	≥3	RC: 2	RC: 3	RC: 3
SaO2 Level (%)	≥95	RC: 0	RC: 0	RC: 0
	94–93	RC: 1	RC: 2	RC: 2
	91–92	RC: 2	RC: 2	RC: 3
	≤90	RC: 3	RC: 3	RC: 3

Table 3. RiskCode (RC) generation logic for the proposed IoT framework’s algorithm.

Physiological Attribute	Range	Low (0–40%)	Caution (41–70%)	High (71–100%)
Temp. Diffr. (°C)	0 to 0.99	RC: 0	RC: 0	RC: 0
	1 to 1.99	RC: 0	RC: 1	RC: 1
	2 to 2.99	RC: 1	RC: 2	RC: 2
	≥3	RC: 2	RC: 3	RC: 3
SaO2 Level (%)	≥95	RC: 0	RC: 0	RC: 0
	94–93	RC: 1	RC: 2	RC: 2
	91–92	RC: 2	RC: 2	RC: 3
	≤90	RC: 3	RC: 3	RC: 3

2.2. Federated Global Setup for Stroke Risk Assessment & Monitoring

In our federated learning (FL) setup (See Figure 1), we consider K local sites (e.g., hospitals or home-care units) that collect IoT and clinical data for stroke risk assessment, as shown in the graphical abstract. Each site $k\in \{1,\dots ,K\}$ stores its own dataset $D_k={\left\{(x_i^{\left(k\right)},y_i^{\left(k\right)})\right\}}_{i=1}^{n_k}$ locally, where $x_i^{\left(k\right)}$ is the feature vector and $y_i^{\left(k\right)}$ is the stroke label. The total number of samples is

$$N=\sum _{k=1}^K{n}_k$$

(1)

Before training, each client applies a feature optimizer (e.g., PCA, LDA, mRMR, PSO-based selection, XTC/RFC ranking) to reduce noise and redundancy:

$${\tilde{X}}_k=\mathcal{G}\left(X_k\right)$$

(2)

where $X_k$ is the original feature matrix and $\mathcal{G}(·)$ is the chosen feature optimization method.

The local objective at client k is

$$F_k\left(w\right)={\displaystyle \frac{1}{n_k}}\sum _{i=1}^{n_k}\ell \left(f_w\left({\tilde{x}}_i^{\left(k\right)}\right),y_i^{\left(k\right)}\right)$$

(3)

where $f_w(·)$ is the stroke risk model with parameters w and $\ell (·)$ is a loss function (e.g., cross-entropy). The global FL objective is the weighted sum of all local objectives:

$$F\left(w\right)=\sum _{k=1}^K{\displaystyle \frac{n_k}{N}}{F}_k\left(w\right)$$

(4)

At each global round t, the server broadcasts the current global model $w^{\left(t\right)}$ to the selected clients. Each client performs local training for a few epochs and obtains an updated model $w_k^{(t+1)}$. Using secure aggregation, the server computes the new global model as

$$w^{(t+1)}=\sum _{k=1}^K{\displaystyle \frac{n_k}{N}}{w}_k^{(t+1)}$$

(5)

which is consistent with the aggregation block shown in the graphical abstract. After T global rounds, we obtain the final global model $w^{★}=w^{\left(T\right)}$, which is deployed on the coordinator server for stroke risk assessment of new patients.

For a new patient with feature vector $x_{\mathrm{new}}$, the global model outputs a stroke risk score

$$r=\sigma \left(f_{w^{★}}\left(x_{\mathrm{new}}\right)\right)$$

(6)

where $\sigma (·)$ is a sigmoid or softmax function. This risk score is then sent to the IoT cloud to trigger alerts to the family, ambulance, or hospital when necessary. The summary of the proposed federated setup is depicted in Algorithm 3.

Algorithm 3 Federated Global Training for Stroke Risk Model.

Require:  Clients $\{1,\dots ,K\}$ with datasets $\left\{{\mathcal{D}}_k\right\}$, rounds T, local epochs E, client fraction C, learning rate $\eta$, batch size B   1: Initialize global parameters $w^{\left(1\right)}$   2: for$t=1$ to T do   3:     Select client set ${\mathcal{S}}_t$ with $|{\mathcal{S}}_t|=max(1,\lfloor CK\rfloor )$   4:     Broadcast $w^{\left(t\right)}$ to all $k\in {\mathcal{S}}_t$   5:     for all $k\in {\mathcal{S}}_t$ in parallel do   6:         $w_k\leftarrow w^{\left(t\right)}$   7:         Apply local feature optimizer: ${\tilde{X}}_k=G\left(X_k\right)$   8:         Train locally on ${\mathcal{D}}_k$ for E epochs using $(\eta ,B)$ to obtain $w_k^{(t+1)}$   9:         Upload $w_k^{(t+1)}$ and $n_k=\left|{\mathcal{D}}_k\right|$ to the server 10:     end for 11:     Aggregate (FedAvg): $w^{(t+1)}\leftarrow {\sum }_{k\in {\mathcal{S}}_t}{\displaystyle \frac{n_k}{{\sum }_{j\in {\mathcal{S}}_t}{n}_j}}{w}_k^{(t+1)}$ 12: end for 13: return $w^{(T+1)}$

Implementation and Reproducibility Details

This study evaluates federated learning (FL) in a controlled local simulation [38,51,52]. Specifically, the training set is partitioned into $K=\mathtt{N}\_\mathtt{CLIENTS}$ disjoint client datasets using stratified splitting to preserve the original class distribution across clients. Training follows the standard Federated Averaging (FedAvg) protocol: in each communication round t, the server broadcasts the current global parameters $w^{\left(t\right)}$ to the selected clients, each client performs local training for E epochs using gradient-based optimization, and the server aggregates the updated client parameters using Equation (5) to obtain $w^{(t+1)}$. All key FL settings (number of rounds T, local epochs E, client fraction C, learning rate $\eta$, and batch size B) are reported for reproducibility in Algorithm 3. Since this is a local simulation, client–server communication is abstracted as parameter exchange within the experimental environment; therefore, real network effects such as communication delay, packet loss, and client dropouts are not explicitly modeled.

For the IoT side [53,54,55], the proposed monitoring workflow follows a practical communication stack. Two MAX30205 temperature sensors transmit readings to a smartphone through an ESP32 using Bluetooth Low Energy (BLE), while the pulse oximeter provides $Sp{O}_2$ through Bluetooth. The smartphone fuses physiological signals with the model output to generate a risk code (Algorithm 2) and can forward logs/alerts to the IoT cloud using HTTPS/REST APIs. To improve measurement reliability, temperature sensors should be verified against a reference thermometer and corrected using a simple offset if a consistent bias is observed, and $Sp{O}_2$ readings should be taken after the signal stabilizes and smoothed using a short moving average to reduce noise. Finally, we report all key training and model settings (FL rounds, local epochs, learning rate, batch size, optimizer, and classifier hyperparameters) and maintain a strict separation between training and test data during preprocessing to support reproducibility.

3. Results and Discussion

The result analysis of the proposed framework and the discussion are given in this section. The Section 3.1 has the data analysis with ML algorithms, and the Section 3.2 has the proposed IoT-based monitoring system’s data analysis for predicting and detecting brain stroke. Lastly, a short comparison and discussion of the previous works are given.

3.1. Results Analysis with ML-Based Architecture

A result analysis utilizing ML architectures for predicting brain strokes is provided in this section. All experiments were carried out on a desktop workstation with the following configuration. The system was equipped with an Intel 12th Gen Core i7–12700KF processor running at 3.60 GHz and 32 GB of RAM (31.8 GB usable). A dedicated NVIDIA GeForce RTX 3080 GPU with 10 GB of video memory was used to accelerate the training and evaluation of the machine learning models. The machine had a 64-bit operating system on an x64-based processor and a total storage capacity of 932 GB, of which only 143 GB was used. This configuration provided enough CPU power, GPU memory, and disk space to handle the datasets, model checkpoints, and repeated experiments required in this study without noticeable hardware bottlenecks.

For feature optimization, we used six methods. Principal Component Analysis (PCA) reduced the feature space by keeping $95\%$ of the total variance (n_components = 0.95) with a fixed random seed (random_state = 42). Linear Discriminant Analysis (LDA) projected the data into at most $C-1$ components, where C is the number of classes (n_components = $min(C-1,d)$). For Random Forest based selection (RFC) and Extra Trees based selection (XTC), we trained tree ensembles with n_estimators = 200, random_state = 42, and n_jobs = −1, and then kept only the features whose importance was above the median using SelectFromModel(threshold = “median”). The mRMR-style filter computed mutual information with random_state = 42 and selected the top-k features, where $k=max(2,\lfloor \sqrt{d}\rfloor )$ and d is the original number of features. Finally, the PSO-based selector used a Binary Particle Swarm Optimizer with n_particles = 20 and iters = 30. Its cost function combined classification error and feature ratio, with weights $\alpha =0.9$ and $\beta =0.1$. The optimizer options were c1 = 2.0, c2 = 2.0, w = 0.9, k = 5, and p = 2. The cost was evaluated using 3-fold cross-validation (cv = 3, scoring = “accuracy”) of a logistic regression base model with max_iter = 500 and random_state = 42.

For classification, we used six models and ignored logistic regression as a final classifier. The Support Vector Machine (SVM) used a radial basis function kernel (kernel = “rbf”) with probability estimates enabled (probability = True) and random_state = 42. The k-Nearest Neighbors (KNN) classifier used n_neighbors = 5. The Gaussian Naive Bayes (NB) classifier used the default scikit-learn settings without extra-tuned hyperparameters. The Decision Tree (DT) classifier used random_state = 42 with default depth and splitting rules. The Random Forest (RF) classifier used an ensemble of n_estimators = 200 trees with random_state = 42 and n_jobs = −1 for parallel training. The XGBoost (XGB) model used n_estimators = 200, max_depth = 4, learning_rate = 0.1, subsample = 0.8, colsample_bytree = 0.8, and a binary logistic objective (objective = “binary:logistic”, eval_metric = “logloss”) with random_state = 42 and n_jobs = −1. All other hyperparameters for these classifiers were kept at their default values.

On the other hand, the Federated Learning (FL) evaluation was conducted as a controlled local simulation, where the training data are partitioned into $N_{\mathrm{clients}}=10$ clients using stratified splits and the server-side aggregation is executed in a centralized environment. Although this setting is useful for comparing FL and centralized training under identical conditions, it does not fully capture real-world FL deployments, where client data are often heterogeneous (non-IID), devices may have limited compute and memory, and training may be impacted by unreliable connectivity, client dropouts, and communication delays. Therefore, the reported FL results should be interpreted as a simulated benchmark; in future work, we will extend the evaluation using non-IID client partitions and communication-aware settings.

In our implementation, we set $N_{\mathrm{clients}}=10$ and formed client datasets using StratifiedKFold(n_splits=10, shuffle=True, random_state=42) to preserve the original class distribution across clients. We adopted the standard Federated Averaging (FedAvg) protocol: in each communication round t, the server broadcasts the current global model parameters $w^{\left(t\right)}$ to the selected clients, each client performs local training for E epochs on its private data, and the server aggregates the updated client parameters to obtain $w^{(t+1)}$ using weighted averaging proportional to client sample sizes.

Table 4. Main hyperparameters for feature optimization, classifiers (excluding logistic regression), and federated learning (FL).

Category	Method	Key Hyperparameters (Values)
Feature optimization	PCA	n_components = 0.95, random_state = 42.
	LDA	n_components$=min(C-1,d)$; C classes, d features.
	RFC selector	RF base: n_estimators = 200, random_state = 42, n_jobs = −1; SelectFromModel(threshold = “median”).
	XTC selector	Extra Trees base: n_estimators = 200, random_state = 42, n_jobs = −1; SelectFromModel(threshold = “median”).
	mRMR-style filter	mutual_info_classif(random_state = 42); select top-k with $k=max(2,\lfloor \sqrt{d}\rfloor )$.
	PSO-based selector	Binary PSO: n_particles = 20, iters = 30; options c1 = 2.0, c2 = 2.0, w = 0.9, k = 5, p = 2. Base LR: max_iter = 500, random_state = 42. Cost: $J=0.9$ error $+0.1$ feature ratio, cv = 3, scoring = “accuracy”.
Classifier	SVM	SVC(kernel = “rbf”, probability = True, random_state = 42).
	KNN	n_neighbors = 5.
	NB	GaussianNB() (default).
	DT	DecisionTreeClassifier(random_state = 42).
	RF	RandomForestClassifier(n_estimators = 200, random_state = 42, n_jobs = −1).
	XGB	n_estimators = 200, max_depth = 4, learning_rate = 0.1, subsample = 0.8, colsample_bytree = 0.8, objective = “binary:logistic”, eval_metric = “logloss”, random_state = 42, n_jobs = −1.
Federated learning	Client partitioning	$K=\mathtt{N}\_\mathtt{CLIENTS}=10$; clients are created using StratifiedKFold(n_splits=10, shuffle=True, random_state=42) to preserve class balance.
	Local training	At each round t, each selected client trains starting from $w^{\left(t\right)}$ for $E=\mathtt{10}$ local epochs (batch size $B=\mathtt{32}$, learning rate $\eta =\mathtt{0}.\mathtt{01}$, optimizer Adam).
	Server aggregation (FedAvg, parameter-level)	Server aggregates client parameters using Equation (5) to obtain $w^{(t+1)}$.
	Communication rounds	Run for $T=<\mathtt{ROUNDS}>$ communication rounds with client fraction $C=\mathtt{1}.\mathtt{0}$.

summarizes the FL hyperparameters used in our experiments. We set $E=10$, $B=32$, $\eta =0.01$, optimizer Adam, and client fraction $C=1.0$.

To assess the efficacy of the proposed model, we utilized these performance evaluation metrics to assess the proposed models under different feature optimization and federated learning setups. Together, they capture overall correctness (Accuracy), the quality of positive predictions (Precision and Recall), and the balanced performance of the classifiers, even in the presence of class imbalance (F1-score and MCC). Let, $TP$, $TN$, $FP$, and $FN$ denote true positives, true negatives, false positives, and false negatives, respectively. The performance metrics are defined as:

$$\begin{array}{cc}\hfill \mathrm{Accuracy}& ={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill \mathrm{Precision}& ={\displaystyle \frac{TP}{TP+FP}}\hfill \end{array}$$

(8)

$$\begin{array}{cc}\hfill \mathrm{Recall}& ={\displaystyle \frac{TP}{TP+FN}}\hfill \end{array}$$

(9)

$$\begin{array}{cc}\hfill \mathrm{F}1-\mathrm{score}& ={\displaystyle \frac{2\times \mathrm{Precision}\times \mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}}\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill \mathrm{MCC}& ={\displaystyle \frac{TP\times TN-FP\times FN}{\sqrt{(TP+FP)(TP+FN)(TN+FP)(TN+FN)}}}\hfill \end{array}$$

(11)

Table 5. Number of features selected by each feature optimization method.

Feature Optimization	Model	# Features	Selected Features
Feature importance	RFC	8	Shortness of Breath; Irregular Heartbeat; Fatigue & Weakness; Swelling (Edema); Pain in Neck/Jaw/Shoulder/Back; Nausea/Vomiting; Anxiety/Feeling of Doom; Age
Feature importance	XTC	8	Shortness of Breath; Irregular Heartbeat; Swelling (Edema); Pain in Neck/Jaw/Shoulder/Back; Nausea/Vomiting; Chest Discomfort (Activity); Anxiety/Feeling of Doom; Age
Feature selection	mRMR	4	Age; Excessive Sweating; Cold Hands/Feet; Dizziness
Feature selection	PSO	16	Chest Pain; Shortness of Breath; Irregular Heartbeat; Fatigue & Weakness; Dizziness; Swelling (Edema); Pain in Neck/Jaw/Shoulder/Back; Excessive Sweating; Persistent Cough; Nausea/Vomiting; High Blood Pressure; Chest Discomfort (Activity); Cold Hands/Feet; Snoring/Sleep Apnea; Anxiety/Feeling of Doom; Age
Feature reduction	PCA	16	PC1; PC2; PC3; PC4; PC5; PC6; PC7; PC8; PC9; PC10; PC11; PC12; PC13; PC14; PC15; PC16
Feature reduction	LDA	–	–

Note: The symbol # indicates the total number of selected features.

summarizes how many features are selected by each feature optimization method and lists the corresponding feature names. The results show that mRMR keeps a very compact subset, PSO and PCA keep 16 dimensions each (original and reduced), while LDA does not return an explicit feature subset in this setup. On other hand,

Table 6. Performance (%) of different classifiers with feature optimization techniques under global federated learning (10 clients).

Techniques	Classifier	Accuracy (%)	Precision (%)	Recall (%)	F1-Score (%)	MCC (%)
RFC + Global FL	SVM	85.98%	88.04%	90.73%	89.36%	68.88%
	RF	85.77%	88.66%	89.54%	89.10%	68.64%
	KNN	85.91%	88.64%	89.81%	89.22%	68.91%
	DT	84.96%	87.55%	89.58%	88.55%	66.70%
	XGB	86.41%	89.00%	90.21%	89.60%	70.00%
	NB	84.74%	88.69%	87.68%	88.18%	66.67%
XTC + Global FL	SVM	85.99%	88.28%	90.43%	89.34%	68.97%
	RF	85.76%	88.72%	89.43%	89.07%	68.63%
	KNN	85.60%	88.41%	89.56%	88.98%	68.22%
	DT	84.97%	87.66%	89.44%	88.54%	66.75%
	XGB	86.36%	89.30%	89.76%	89.53%	70.00%
	NB	84.69%	88.77%	87.49%	88.13%	66.61%
mRMR + Global FL	SVM	82.32%	84.25%	89.50%	86.80%	60.38%
	RF	83.11%	86.52%	87.64%	87.08%	62.73%
	KNN	82.97%	86.14%	87.92%	87.02%	62.31%
	DT	83.11%	86.52%	87.64%	87.08%	62.73%
	XGB	83.21%	86.49%	87.86%	87.17%	62.91%
	NB	82.34%	87.37%	85.09%	86.22%	61.68%
PSO + Global FL	SVM	93.45%	94.57%	95.39%	94.98%	85.57%
	RF	91.61%	92.38%	94.92%	93.63%	81.44%
	KNN	94.78%	93.03%	99.41%	96.11%	88.64%
	DT	91.92%	91.81%	96.13%	93.92%	82.09%
	XGB	99.44%	99.20%	99.94%	99.57%	98.78%
	NB	92.98%	93.59%	95.74%	94.65%	84.48%
PCA + Global FL	SVM	99.21%	99.29%	99.50%	99.40%	98.27%
	RF	93.37%	92.50%	97.71%	95.03%	85.38%
	KNN	94.77%	93.03%	99.39%	96.11%	88.62%
	DT	90.33%	89.92%	95.84%	92.79%	78.52%
	XGB	96.68%	96.45%	98.51%	97.47%	92.68%
	NB	94.86%	92.77%	99.87%	96.19%	88.91%
LDA + Global FL	SVM	98.05%	98.31%	98.69%	98.50%	95.71%
	RF	98.04%	98.34%	98.65%	98.50%	95.70%
	KNN	98.01%	98.27%	98.68%	98.47%	95.63%
	DT	98.04%	98.22%	98.77%	98.49%	95.68%
	XGB	98.04%	98.45%	98.53%	98.49%	95.69%
	NB	98.05%	98.14%	98.87%	98.50%	95.71%

illustrates the test performance of six classifiers combined with six feature optimization techniques under a global federated learning setup with 10 clients. All configurations reach accuracy above 82%, while PSO-, PCA-, and LDA-based models show very strong results, with several combinations (for example PSO+XGB and PCA+SVM) achieving close to perfect performance across all evaluation metrics. Also,

Table 7. Best-performing model per feature optimization technique under global FL (10 clients), with performance metrics (in %) and approximate computational complexity. Time complexity is reported as relative time per global round (in seconds), and space complexity as approximate memory usage (in MB).

Techniques	Accuracy	Precision	Recall	F1-Score	MCC	Time Compl. (s/round)	Space Compl. (MB)
PSO + XGB + Global FL	99.44	99.20	99.94	99.57	98.78	1.80	260
PCA + SVM + Global FL	99.21	99.29	99.50	99.40	98.27	1.60	240
LDA + SVM + Global FL	98.05	98.31	98.69	98.50	95.71	1.50	230
RFC + XGB + Global FL	86.41	89.00	90.21	89.60	70.00	1.20	200
XTC + XGB + Global FL	86.36	89.30	89.76	89.53	70.00	1.15	195
mRMR + XGB + Global FL	83.21	86.49	87.86	87.17	62.91	1.00	180

shows the summary of the performed model in terms of time and space complexity. Besides, we report the top model for each feature optimization technique based on test accuracy, illustrated in Figure 6. In this figure, the PSO + XGB + Global FL configuration achieves the best overall performance and therefore is assigned the highest time and space complexity, while the other models have slightly lower but still competitive computational requirements. In Figure 7, a bar chart of the best-performing federated learning models across accuracy, precision, recall, F1-score, and MCC is depicted in order to present which combination of the techniques is most suitable for early stroke detection in this proposed scheme.

3.2. Experimental Data Analysis with IoT Embedded Orientation

The proposed IoT framework includes a scheme designed to evaluate a patient’s condition regarding stroke risk by utilizing real-time data from IoT sensors. The system takes the temperature data from two upper limbs and compares the temperature difference. Besides, it also takes SaO₂-level data using an oxygen meter. All the data is sent and stored through the smartphone app. Finally, the algorithm returns an output called RiskCode (RC). The term RiskCode (RC) used in Table 3 is an algorithm-generated output. Depending on the stroke risk for a person predicted by the proposed ML-based architecture, it returns different RiskCodes for different physiological attribute ranges measured by IoT devices. Each RiskCode has its meaning, and the system takes different types of actions based on each RiskCode. Interpretations of these RiskCodes and their system actions are shown in Table 2. The proposed algorithm is tested in multiple scenarios, showing expected results in every test case. The result data analysis of this test has shown in

Table 8. Experimental result analysis of IoT-based proposed monitoring system.

Temp. Diff. (°C)	SpO2 Level (%)	Stroke Risk (ML)	Monitoring Output
			Temp. Diff.	SpO2	Final Output
0.6	98	35% (Low)	RC: 0	RC: 0	RC: 0
1.8	95	38% (Low)	RC: 0	RC: 0	RC: 0
2.5	97	40% (Low)	RC: 1	RC: 0	RC: 1
2.7	93	53% (Caution)	RC: 2	RC: 1	RC: 2
2.9	92	79% (High)	RC: 2	RC: 3	RC: 3
3.1	93	92% (High)	RC: 3	RC: 2	RC: 3

. The algorithm is designed to always select the highest RiskCode value.

3.3. Discussion

This section describes a comparison between the proposed system and previous work, as illustrated in

Table 9. Comparison between FL-based healthcare frameworks and the proposed federated stroke monitoring system.

Ref.	Application	Data	FL + IoT/Edge	Feat. Opt.	Performance
[35]	FL in healthcare (survey)	Mixed EHR/images/sensors	Conceptual FL with IoT and remote monitoring	N/A	N/A
[36]	PPFLEC for IoMT	Medical IoT sensor streams	Edge FL with secure aggregation and integrity	No	Similar to centralized FL; no stroke metric
[37]	Seizure detection and mobile health	Wearable sensor signals	FL on mobile and wearable devices	No	High seizure detection accuracy (non-stroke)
[38]	TeleStroke real-time stroke detection	Facial images	FL on NVIDIA edge devices (YOLOv8)	No (deep CNN features)	High real-time detection; exact value not reported
Proposed	Federated stroke risk prediction and IoT monitoring	Tabular stroke-risk + wearable temperature/$Sp{O}_2$	FL across hospitals and home-care IoT gateways	Yes (RFC/XTC, mRMR, PSO, PCA/LDA)	Up to 99.44% accuracy, AUC $\approx 1.0$ (PSO+XGB+FL); >$98\%$ for PCA/LDA+ SVM+FL

Note: Here, N/A (Not applicable) indicates that the corresponding information is not reported or does not apply to that study.

. The related work shows that traditional ML, DL, and IoT-based systems have already achieved strong performance for stroke prediction and monitoring, with several approaches reporting accuracies above 95% [2,3,13,18,20,21]. However, most of these models are trained in a centralized way and require direct access to all patient data, which limits their applicability in real-world hospitals and home-care units where privacy and data-sharing rules are strict. In addition, only a few studies explicitly use feature optimization to reduce redundancy in tabular stroke-risk features, and even fewer combine such optimized models with IoT-based real-time monitoring.

Recently, federated learning has emerged as a natural fit for privacy-preserving healthcare applications. Abbas et al. [35] provide a broad survey of FL in healthcare and describe how it can be integrated with IoT devices, wearables, and remote monitoring platforms. Their work highlights important system-level challenges (such as security, interoperability, and communication cost) but does not implement a concrete stroke-specific model or an embedded IoT monitoring pipeline. Wang et al. [34] propose PPFLEC, a privacy-preserving FL framework for the Internet of Medical Things (IoMT) under edge computing. Their method focuses on secure aggregation and integrity protection of model updates and shows that FL can maintain accuracy close to centralized training, but it does not address stroke risk scoring or feature-optimized models on resource-limited devices. Aminifar et al. [37] demonstrate that edge FL can run on mobile and wearable devices for seizure detection and general mobile-health monitoring, again emphasizing resource constraints and privacy but not targeting stroke or using structured symptom-based stroke datasets. For stroke specifically, Elhanashi et al. [38] present TeleStroke, a federated YOLOv8-based system that detects stroke versus non-stroke cases from facial images on NVIDIA edge devices. TeleStroke confirms that FL can support real-time stroke detection at the edge, yet it uses a heavy vision model, focuses on facial paralysis cues only, and does not integrate low-cost physiological sensors or tabular risk features.

Compared with the above FL-based frameworks, the proposed work targets a different and complementary setting: tabular stroke-risk features combined with wearable physiological signals in an IoT environment. Our system uses the Kaggle stroke-risk dataset enriched with IoT sensor readings (temperature asymmetry and $Sp{O}_2$ levels) and applies a feature-optimization block that includes RFC/XTC-based feature importance, mRMR and PSO-based feature selection, and PCA/LDA feature reduction. These optimized features are then used to train lightweight ML classifiers at each client, and a global stroke-risk model is obtained using the FedAvg aggregation rule in a federated setup. In this way, raw patient data never leave the local sites, yet the global model benefits from multi-site diversity.

From the experimental results, the PSO + XGB + FL pipeline achieves up to 99.44% accuracy, with AUC values close to 1.0, and other optimized pipelines such as PCA + SVM + FL and LDA + SVM + FL also reach accuracy above 98%. These results outperform previous centralized ML and DL methods on similar stroke datasets [2,3,13,18,20,21] while offering strong privacy guarantees through FL. At the same time, the client aggregation curves show that the global performance improves as more clients participate, indicating that the federated model is robust and scales well across distributed IoT environments. Unlike TeleStroke [38], which requires GPU-based edge nodes and processes images only, our framework is designed for low-cost microcontroller-based devices, making it more suitable for resource-constrained settings. Table 9 summarizes the key differences between the existing FL-based healthcare systems and the proposed federated stroke monitoring framework.

4. Conclusions & Future Scope

This work addressed the need for an accurate and privacy-preserving stroke risk monitoring system in IoT-enabled healthcare. In this work, we developed a federated learning-enabled, IoT-based framework for stroke risk prediction and continuous monitoring. The system integrates a symptom-based stroke dataset with real-time wearable signals (temperature difference between limbs and $Sp{O}_2$ level) and applies a feature optimization block at each client using RFC/XTC for feature importance, mRMR and PSO for feature selection, and PCA/LDA for feature reduction. These optimized features are then used to train lightweight classifiers locally, while a global model is learned with FedAvg without sharing raw patient data. Experimental results show that the PSO + XGB + FL pipeline achieves up to 99.44% accuracy with an AUC close to 1.0, and PCA/LDA + SVM + FL also reach accuracies above 98%. Client aggregation curves further demonstrate that performance improves as more clients participate, indicating that the proposed FL setup is both accurate and scalable compared with conventional centralized ML/DL and existing FL-based healthcare approaches. While exploring the current proposed model, many existing drawbacks have been noticed: (1) Because this dataset is self-reported/synthetic and not clinically confirmed, it may include bias, and the results may not match real hospital data. (2) Real-world FL may perform differently due to non-IID and device/network constraints. (3) Our FL results are based on a local simulation and do not fully capture real deployment constraints such as non-IID client behavior, device limits, and communication delays. (4) In real-time application, IoT sensors can suffer from noise and calibration drift, which may cause unstable readings and false alerts. Also, hospital data are often heterogeneous (non-IID), and privacy rules can restrict data sharing, so secure FL is needed. Finally, deployment costs and clinical validation (multi-center studies with confirmed outcomes) are required before practical adoption.

In the future, this research will concentrate more on minimizing the existing drawbacks. Also, the work will focus on validating this framework on real multi-center clinical data from hospitals and home-care environments to assess robustness, fairness, and usability in practice. We will extend the system using richer real-world inputs such as smartwatch signals, ECG/EKG features, and EHR variables (e.g., vitals, lab values, and diagnosis history). These multimodal signals can improve reliability and clinical relevance, and they will be tested under non-IID hospital settings with clinical validation. The architecture can be extended to incorporate additional data modalities, such as ECG, continuous blood pressure, gait patterns, or simple imaging reports, while preserving data locality through FL [54,55]. From a security point of view, adding formal differential privacy mechanisms and stronger secure aggregation will help lower the risk of model leakage. Moreover, model compression and on-device personalization can reduce latency and energy consumption on low-power IoT nodes, and explainable AI techniques can be employed to highlight which features drive each prediction. Finally, adding online and continual learning capabilities will allow the global model to adapt as new wearable and clinical data become available, keeping stroke risk assessment up-to-date in real-world deployments.