Skip to Content
Future InternetFuture Internet
  • Article
  • Open Access

21 November 2026

17 Pages

AsyncLiteNet: A Lightweight Asynchronous Federated Framework with Cluster Aggregation for Human Activity Recognition

,
,
,
and
1
Faculty of Information Science and Technology, Multimedia University, Jalan Ayer Keroh Lama, Bukit Beruang, Melaka 75450, Malaysia
2
Centre for Advanced Analytics, Centre of Excellence (CoE) for Artificial Intelligence, Multimedia University, Jalan Ayer Keroh Lama, Bukit Beruang, Melaka 75450, Malaysia
3
Infineon Technologies Sdn. Bhd., Free Trade Zone, Batu Berendam, Melaka 75350, Malaysia
*
Author to whom correspondence should be addressed.
Future Internet2026, 18(12), 646;https://doi.org/10.3390/fi18120646 
(registering DOI)
This article belongs to the Section Internet of Things

Abstract

Human Activity Recognition (HAR) using inertial sensor data has attracted increasing attention in various domains such as healthcare, fitness, and smart environments. However, developing efficient HAR models while coordinating distributed training in the presence of client delays remains challenging. This study proposes AsyncLiteNet, an asynchronous federated learning framework designed to improve model training efficiency while maintaining recognition performance. The proposed framework integrates a lightweight one-dimensional convolutional neural network (1D-CNN) with modified Squeeze-and-Excitation (SE) and Pyramid Pooling Module (PPM) components for feature extraction. At the federated learning level, a threshold-based aggregation strategy allows the central server to update the global model without waiting for every participating client. K-Means-based client selection and deviation-aware delta aggregation are further incorporated to support client coordination and model updating. Experiments on the WISDM and UCI-HAR human activity recognition dataset demonstrate the effectiveness of the proposed approach, achieving an accuracy of nearly 98%. In terms of efficiency, the proposed framework reduces training time by about 39% compared with the synchronous federated learning baselines on the WISDM dataset. These results indicate the potential of combining lightweight model design with asynchronous federated learning to improve the efficiency of distributed HAR.

1. Introduction

Human Activity Recognition (HAR) applications are widespread across fitness applications, healthcare support, and smart environments [1,2,3,4]. The rise of wearable technology, smartphones, and Internet of Things (IoT) devices provides opportunities for continuous observation and collection of data while enabling accurate and timely monitoring of human activities. Deep Learning is a key technique in the field of artificial intelligence, which helps with the enhancement of HAR through effective feature extraction, inertial pattern observation, and decision-making [5,6]. Deep learning exhibits promising results in classifying human activities; however, many challenges still lie ahead. One of the challenges is the complexity of deep learning models, resulting in high parameter counts, substantial memory usage, high latency, and increased energy consumption [7,8,9]. Therefore, there is a need for efficient and effective data modeling strategies.
In addition, traditional deep learning models are usually trained in a centralised mode based on a centralised dataset, where user information is collected and stored on a server. This can trigger a privacy problem because sensitive user information is aggregated on a central server [10,11]. The reliance on a single server introduces a single point of failure, where any attack can disrupt the overall data confidentiality. Thus, federated learning is proposed to allow collaborative model training without the exchange of user information [12,13,14]. Most existing federated learning systems rely on synchronous training, where model aggregation is only performed after all participating clients have completed their local updates. However, a drawback of this synchronous training is the straggler problem, as slower client updates can delay the overall training progress [15].
The above-mentioned limitations motivate the need for an asynchronous and data-private federated learning framework that enables efficient aggregation while supporting lightweight HAR models:
  • To develop an asynchronous federated learning framework for human activity recognition that enables collaborative model training without sharing raw sensor data.
  • To improve federated learning efficiency for HAR by coordinating client selection and aggregation based on local sample counts and training speeds, thereby reducing delays caused by slower clients.
In this work, we propose AsyncLiteNet, an asynchronous federated learning framework that integrates a lightweight 1D-CNN with strategies for coordinating distributed client updates. The framework combines threshold-based aggregation, K-Means-based client selection, and deviation-aware delta aggregation to investigate the trade-off between training efficiency and recognition performance. The local model incorporates modified Squeeze-and-Excitation (SE) and Pyramid Pooling Module (PPM) components to extract informative features from inertial sensor data. The overall architecture of AsyncLiteNet is illustrated in Figure 1.
Figure 1. Overview of the proposed AsyncLiteNet framework.
In summary, the contributions of this work are:
  • We introduce AsyncLiteNet, an asynchronous federated learning framework that combines deviation-aware delta aggregation with cluster-based client selection.
  • We propose a partial participation threshold-based update method that enables global aggregation after receiving updates from a predefined proportion of participating clients.
  • To enable efficient human activity recognition, we incorporate a lightweight 1D CNN architecture with SE and PPM components into the proposed asynchronous federated learning framework.

3. Methodology

In this study, we consider a federated learning setting for human activity recognition (HAR), where clients collaboratively train a global model on a central server while keeping raw sensor data locally. A lightweight federated learning framework, called AsyncLiteNet, is devised. AsyncLiteNet is built on a lightweight 1D Convolutional Neural Network (CNN) as the backbone of the model architecture to model local temporal dependencies in inertial data. Nevertheless, conventional CNNs are suboptimal in capturing multi-scale long-range temporal patterns. Therefore, the framework incorporates Squeeze-and-Excitation (SE) and Pyramid Pooling Module (PPM) components to facilitate channel-wise feature recalibration and enhance multi-scale pattern representation, respectively. To reduce the impact of straggler clients, an asynchronous aggregation strategy is implemented, allowing the global server to aggregate model updates received from a subset of participants without waiting for all clients to complete their local training. Additionally, the system incorporates cluster-based client selection based on local sample counts and training speeds, along with deviation-aware delta aggregation, to enable efficient client participation, improve aggregation efficiency, and reduce overall training time while maintaining competitive recognition performance.

3.1. AsyncLiteNet Framework Architecture

The proposed framework operates through a pipeline in which a central server broadcasts the global model to participating clients. Next, the clients perform local model training using their local data and send back the generated model updates along with the number of samples used. Due to the asynchronous aggregation strategy, client updates can be received by the central server at different times. A weighted aggregation strategy is performed where the server assigns larger weights to model updates with smaller update deviations and larger data volumes. This is to suppress the effects of potentially noisy and unstable updates. When the aggregation threshold is reached, the server aggregates the weighted updates to generate an updated global model. Figure 2 illustrates the overall architecture of AsyncLiteNet.
Figure 2. Overall architecture of AsyncLiteNet.

3.2. Model Architecture

In this work, a 1D Convolutional Neural Network (CNN) is employed as the backbone of the model architecture due to its capability to effectively extract local patterns of inertial data [25,26]. Nevertheless, CNNs primarily focus on local feature extraction and may have limited ability to capture multi-scale contextual information. Therefore, we incorporate the SE block and PPM into the model. The SE block performs channel-wise attention to improve feature quality, and the PPM captures multi-scale features to extract meaningful patterns across resolutions.
As shown in Figure 3, the initial stage uses a 1D convolutional layer with 16 filters and a 7-kernel size to extract discriminative motion patterns from the input sensor signals. The resulting feature maps are processed by a squeeze-and-excitation (SE) block with a reduction ratio of 3 to enhance channel-wise feature representation. The SE block has three main operations: squeeze, excitation, and channel-wise scaling, with a residual connection. During the squeeze operation, global average pooling generates a compact descriptor for each channel. These descriptors then pass through three fully connected transformations, with Gaussian Error Linear Unit (GELU) activations in the intermediate layers and a sigmoid activation to produce channel-wise weights. The recalibrated features are combined with the original feature maps through a residual connection. Following the SE block, max pooling is applied to downsample the feature representations. The pyramid pooling module (PPM) then extracts multi-scale temporal features using parallel adaptive average pooling operations with output sizes of 1 and 2. The pooled features are resized using nearest-neighbor interpolation and concatenated along the channel dimension to combine temporal information at different scales. The concatenated feature maps are subsequently passed through an adaptive average pooling layer to reduce the temporal dimension before being flattened and passed to the fully connected classification layers.
Figure 3. Convolution-based model architecture.

3.3. Asynchronous Aggregation

In the AsyncLiteNet framework, an asynchronous aggregation technique is implemented to facilitate more flexible and efficient model weight aggregation in the central server. Unlike traditional synchronous approaches, which require all clients to complete their local model training and update their model weights for aggregation, AsyncLiteNet allows the participating clients to transmit their updates independently after completing local training. The global model can then be updated once a predefined number of selected clients have submitted their updates, reducing the need to wait for all selected clients before performing aggregation.
To maintain balanced participation and further improve the efficiency of client selection, a clustering-based client selection strategy is implemented in the proposed AsyncLiteNet framework. Specifically, all participating clients are clustered using the K-Means algorithm based on their training sample counts and training speeds [27]. Then, a subset of clients from each cluster is selected to help reduce the dominance of any client group during global model updates.
In the proposed framework, aggregation occurs when a predefined threshold of selected clients has submitted their model updates. Alternatively, aggregation can be triggered when a predefined time threshold is exceeded, providing another way to control the waiting time for client updates. Upon receiving a client update, each client’s update is compared with the corresponding base global model, and a deviation, i.e., delta, is computed using the L2 norm. The update is then scaled in proportion to the client’s number of training samples and inversely proportional to the delta magnitude. With this weighting strategy, updates from clients with more training samples and smaller deviations are assigned greater weights. It also provides a configurable option to control the client-waiting behaviour during aggregation. When disabled, the server applies the initial aggregated update once the predefined threshold is reached, allowing subsequent client updates to be incorporated into the global model without waiting for all selected clients. When enabled, aggregation proceeds after all selected clients have completed their local training. To mitigate the effect of stale client updates, the framework reduces the contribution of late-arriving updates based on their staleness, allowing more recent updates to have a greater influence on the global model. For evaluation, the current implementation waits for active client training threads to finish before calculating the performance metrics. The pseudocode of AsyncLiteNet is presented in Algorithm 1.
Algorithm 1 Pseudocode for AsyncLiteNet
1.    /* Initialize FedAsyncAttn */
2.    Set up clients and server
3.    Initialize locks (update_lock, model_lock) and condition variable
4.    Initialize tracking variables (client_busy, received_updates,
completed_clients, current_round, round_states, metrics)
5.    def train():
6.            for round_idx in range(global_rounds + 1):
7.                    current_round = round_idx
8.                    selected_clients = clustered_client_selection()
9.                    Mark selected clients as busy
10.                  threshold = max(1, ceil(len(selected_clients) * agg_ratio))
11.                  base_params = deepcopy(global_model parameters)
12.                  Send global_model to selected_clients
13.                  Initialize round_states[current_round] with:
base_params, zero accumulator, total_weight = 0,
update_count = 0, threshold, applied = False
14.                  Clear received_updates[current_round]
15.                  Launch asynchronous threads for selected clients:
16.                          for client in selected_clients:
17.                                  start async_client_train(client, current_round)
18.                  with condition:
19.                          if wait_all is True:
20.                                  wait until all selected clients complete training
21.                          else:
22.                                  wait until update_count >= threshold
or time_taken >= threshold_time
or all selected clients complete training
23.                  finalize_round(current_round)
24.                  Record round_time and average training loss
25.                  if round_idx % eval_gap == 0:
26.                          wait_for_active_training()
27.                          evaluate()
28.          Join remaining client threads
29.          Summarize and plot training results
30. def async_client_train(client, round_idx):
31.          loss = client.train()
32.          client_model = deepcopy(client.model)
33.          weight = client.train_samples
34.          if weight <= 0:
35.                  return
36.          with update_lock:
37.                  if client already submitted an update for round_idx:
38.                          return
39.                  Record client update in received_updates[round_idx]
40.                  aggregate_update(client_model, weight, round_idx)
41.          Finally:
42.                  Mark client as not busy
43.                  Add client to completed_clients[round_idx]
44.                  Notify condition variable
45. def aggregate_update(client_model, weight, round_idx):
46.          state = round_states[round_idx]
47.          Calculate client model deviation from base_params
48.          delta_norm = L2 norm of the model parameter differences
49.          if delta_norm is finite and greater than zero:
50.                  effective_weight = weight/delta_norm
51.          else:
52.                  Skip invalid update
53.          if state.applied is False:
54.                  Accumulate weighted parameter differences
55.                  Update total_weight and update_count
56.                  if wait_all is False and update_count >= threshold:
57.                          _apply_round_aggregate(round_idx)
58.          else:
59.                  Calculate staleness = max(0, current_round − round_idx)
60.                  Calculate late-update scale using alpha0, client weight,
model deviation, and staleness
61.                  Apply the late client update to global_model
62. def _apply_round_aggregate(round_idx):
63.          Normalize accumulated parameter differences by total_weight
64.          Add normalized differences to global_model
65.          Mark round_states[round_idx].applied = True
66. def finalize_round(round_idx):
if the round aggregate has not been applied
67.                  and update_count > 0:
68.                  _apply_round_aggregate(round_idx)
69. def wait_for_active_training():
70.          while any client is marked busy:
71.                  Wait until all active client training threads finish
72. def evaluate():
73.          Collect predictions and labels from evaluation clients
74.          Calculate accuracy, macro precision, macro recall,
and macro F1-score
75. def clustered_client_selection():
76.          Extract features for each available client:
[train_samples, average_train_speed]
77.          Apply KMeans clustering to client features
78.          Randomly select up to 3 clients from each cluster
79.          return selected_clients

4. Experimental Results and Discussion

All experiments in the current study are carried out on a machine running Windows, with an 11th Gen Intel Core i5-1135G7 processor, Intel Iris Xe Graphics, 24 GB of RAM, and a 475 GB SSD. A publicly available dataset is considered in this work, and the chosen dataset is the Wireless Sensor Data Mining (WISDM) dataset [28], available at http://www.cis.fordham.edu/wisdm/dataset.php (accessed on 25 January 2025) It has 1,098,207 sensor data samples from 36 people, with each sample corresponding to a particular activity. Each sample has a sampling rate of 20 Hz, collected using the built-in smartphone accelerometer. There are six classes: walking, jogging, walking upstairs, walking downstairs, sitting, and standing. To prepare the data for model training, several preprocessing steps are applied: missing accelerometer values are handled using linear interpolation followed by forward and backwards filling and the continuous sensor signals are segmented into fixed-length sliding windows of 200 samples with 50% overlap. Categorical labels corresponding to activities are converted to integer class indices. Z-score normalisation is applied separately for each user to achieve a zero mean and unit standard deviation. The WISDM dataset is partitioned on a subject-wise basis, with each client representing an individual participant. This partitioning preserves variations in activity distributions across participants and reflects a heterogeneous federated learning setting. Client-level activity distributions are analyzed to characterize the resulting label heterogeneity.
The UCI-HAR dataset is a publicly available dataset used for human activity recognition research [29]. It contains sensor data collected from 30 volunteers performing six activities: walking, walking upstairs, walking downstairs, sitting, standing, and lying down. The data were collected using a smartphone’s accelerometer and gyroscope at a sampling rate of 50 Hz. Each input sample contains 128 time steps from nine sensor signals. The UCI-HAR dataset was partitioned by subject, resulting in 30 subject-specific client datasets. The activity labels were converted to zero-based indices ranging from 0 to 5, corresponding to the six activity classes. The preprocessed sensor data were then stored separately for each client to support local model training and federated aggregation without directly sharing raw sensor data between clients.
The split ratio used for this experiment for both datasets is 75% for training and 25% for testing. A random seed of 42 is used during data preprocessing to support reproducibility of the dataset partitioning. Each communication round includes 10 clients, and each performs one local training epoch per round, over 500 global rounds. The local models are trained using Stochastic Gradient Descent (SGD) with a learning rate of 0.005 and a batch size of 10. Under the asynchronous federated learning configuration, client updates are aggregated by the global server without waiting for full participation. This approach aims to mitigate the straggler effect and improve training efficiency. The weights of the convolutional and fully connected layers are initialized using Xavier uniform initialization, while their biases are initialized to zero where applicable.
In this study, accuracy and Macro F1-score are used to assess the performance of the proposed model. Accuracy measures the overall ratio of correctly identified activities across all activity samples,
Acc = 1 N ∑ i = 1 N I { y ^ i = y i }
where N is the total number of activity samples, 0 ≤ Acc ≤ 1, and I{} is the indicator function, which takes a value of 1 if  y ^ i = y i and 0 otherwise.
The macro F1-score computes the average F1-scores of all classes and assigns equal weight to each class, preventing dominance of majority classes. Here Pi is precision and Ri is recall, where K is the total number of classes. It is formulated as
Macro   F 1 − score = 1 K ∑ i = 1 K 2 P i × R i P i + R i

4.1. Ablation Study

4.1.1. Performance Evaluation of Asynchronous Aggregation

Table 1 presents an ablation study evaluating the performance of AsyncLiteNet in terms of recognition accuracy and training time. The basic AsyncLiteNet (without deviation scaling and clustering) achieves an accuracy of 98.09% with a training time of 379.71 s. After incorporating deviation scaling, the accuracy increases to 98.21%, representing an improvement of 0.12 percentage points. However, the training time increases to 423.87 s. These results indicate that deviation scaling provides a slight improvement in recognition accuracy but introduces additional training time.
Table 1. Ablation Study of AsyncLiteNet on the WISDM dataset.
Next, K-means clustering is implemented to improve aggregation efficiency. Table 2 presents the impact of the number of clients selected from each cluster on recognition accuracy and training time. Among the three configurations tested (1, 3, and 5 clients per cluster), selecting 1 client achieves an accuracy of 97.49% with a training time of 138.83 s. Increasing the number to 3 clients increases the accuracy to 97.97%, while the training time increases to 272.91 s. When 5 clients are selected per cluster, the accuracy reaches 98.33%, with the highest training time of 404.72 s. Although selecting 5 clients per cluster achieves the highest accuracy, the improvement over selecting 3 clients is only 0.36 percentage points, while the training time increases by 131.81 s, with approximately a 48% rise. Therefore, selecting 3 clients per cluster was chosen because it offers a more favourable trade-off between recognition accuracy and training time. Additionally, from Table 1, we can notice that deviation scaling improves accuracy from 98.09% to 98.21% when clustering is not applied. However, when clustering is introduced, the accuracy of the 3-client configuration decreases slightly to 97.97%, while training time decreases from 423.87 s to 272.91 s, which is about a 36% reduction. This suggests that the client-selection strategy may influence the effectiveness of deviation scaling, resulting in a small performance deterioration while significantly improving training efficiency.
Table 2. Effect of the number of clients per cluster on accuracy and training time of AsyncLiteNet on the WISDM dataset.
Table 3 compares synchronous and asynchronous aggregation methods. Waiting for all clients ensures that the server receives every selected client’s update before aggregation. However, this can increase training time because the server must wait for slower clients. In contrast, our asynchronous approach uses a 50% update threshold, allowing aggregation to start once half of the selected clients have submitted their updates, without waiting for the remaining clients. Updates from late-arriving clients are not discarded but are subsequently applied to the global model using a staleness-adjusted weighting mechanism. Before evaluation, the server waits for outstanding client-training processes to finish calculating the performance metrics. As a result, our approach reduces training time by approximately 30% while maintaining similar recognition accuracy.
Table 3. Comparison with synchronous and asynchronous aggregation methods on the WISDM dataset.

4.1.2. Performance Comparison with Baseline Models

To evaluate the performance of the proposed AsyncLiteNet framework, a performance comparison of AsyncLiteNet with several baseline models is presented. The baseline models include a conventional 1D-CNN with synchronous aggregation using FedAvg, a convolution-based model incorporating SE and PPM with synchronous aggregation using FedAvg, and the convolution-based model (SE and PPM) with the proposed asynchronous framework, i.e., AsyncLiteNet.
As shown in Table 4, the conventional 1D-CNN with synchronous Aggregation using FedAvg possesses the highest number of model parameters (203,782), requiring a high training time of 485.95 s, with an accuracy of 98.44% and a Macro F1-score of 97.84%. On the other hand, a convolution-based model incorporating SE and PPM with synchronous Aggregation using FedAvg reduces model complexity to 6943 while obtaining comparable accuracy and Macro F1-score of 98.21% and 97.79%, respectively.
Table 4. Performance comparison of proposed AsyncLiteNet and baseline models on the WISDM dataset.
To further improve training efficiency, an asynchronous federated learning strategy is implemented. The proposed AsyncLiteNet reduces the training time to 272.91 s, with a mild performance degradation to 97.97% accuracy and 97.47% Macro F1-score, respectively. These results suggest that the proposed framework provides a trade-off between model performance and computational efficiency.

4.1.3. Evaluation Under Controlled Non-IID Data Distribution

To evaluate the framework under heterogeneous client data distributions, we conducted an additional experiment using a controlled non-IID partition of the WISDM dataset. The training and testing sets were generated separately for each subject using a stratified split, with 75% of the samples allocated for training and 25% for testing. For the non-IID experiment, the training windows from all subjects were pooled and redistributed using a Dirichlet distribution with a concentration parameter of α = 0.5 and a random seed of 42. The partitioning was performed separately for each of the six activity classes, allowing clients to have different proportions of activity samples. A smaller Dirichlet concentration parameter generally produces greater variation in class proportions across clients. The test files were retained unchanged for evaluation. Therefore, this experiment investigates the effect of controlled label-distribution heterogeneity.
Table 5 presents the performance comparison of the synchronous aggregation baseline and three asynchronous aggregation configurations under the controlled non-IID data distribution. The convolutional model incorporating SE and PPM with synchronous FedAvg achieves an accuracy of 87.14%, with a training time of 2168.69 s. The basic AsyncLiteNet (without deviation scaling and clustering) method attains similar accuracy of 87.53% and reducing training time to 1249.03 s. When deviation scaling is incorporated, the accuracy increases to 91.27%, although the training time increases slightly to 1255.49 s compared with the basic asynchronous method.
Table 5. Performance comparison of proposed AsyncLiteNet and baseline models under controlled non-IID data distribution on the WISDM dataset.
The complete AsyncLiteNet framework achieves an accuracy of 90.85% with a training time of 535.40 s. Compared with the synchronous FedAvg baseline, AsyncLiteNet reduces the training time by approximately 75.3%, while achieving an accuracy that is 3.71 percentage points higher. Compared with the basic asynchronous method, it reduces the training time by approximately 57% and improves accuracy by 3.32 percentage points. Although the deviation-only configuration achieves the highest accuracy of 91.27%, the complete AsyncLiteNet framework provides a substantially shorter training time with only a 0.42-percentage-point reduction in accuracy. These results demonstrate that the proposed framework can maintain competitive recognition performance while considerably reducing the training time under controlled non-IID data distributions.

4.2. Performance Comparison with Other State-of-the-Art Approaches

From the analysis of the performance metrics of the model, it is evident that the proposed AsyncLiteNet achieves competitive recognition performance on the WISDM dataset, as shown in Figure 4. In the context of centralised approaches, PQ-CNN [23] and Lightweight RNN-LSTM Model [30] attained competitive accuracies of 95.1% and 95.78% with F1-scores of 94.38% and 95.73%, respectively. Nevertheless, their centralised data aggregation raises concerns with respect to data privacy, which is a major issue in the IoT environment. Transferring and storing sensitive personal data on a central server increases the risk of data breaches. It may create a single point of failure, resulting in a large amount of data being exposed to cyberattacks or unauthorized access.
Figure 4. Performance comparison with other existing methods on WISDM.
On the contrary, the proposed AsyncLiteNet is implemented within a federated learning framework, where raw sensor data remains with the participating clients while achieving competitive performance. Compared with other federated learning approaches, DCBFL [31] achieves 91.35% accuracy and an F1-score of 89.24%, while DC-PFL [32] achieves 95.67% accuracy using the APF feature. EGTCN with the FL setting, i.e., FLS-EGTCN [33], reaches an F1-score of 99.37% through personalized settings, whereas the proposed AsyncLiteNet attains a satisfactory 97.97% accuracy and an F1-score of 97.47%. Although the proposed framework does not achieve the highest performance compared with existing methods, it demonstrates the potential of lightweight convolutional architecture and scale-aware feature extraction to capture diverse activity patterns with lower computational requirements, with a training time of only 272.91s.
Besides WISDM, the proposed AsyncLiteNet achieves satisfactory recognition performance on the UCI-HAR dataset, as shown in Figure 5. Among the synchronous federated learning frameworks, FedSynHAR [34], PP-FPRF [35], and the Hybrid LSTM-GRU [36] achieve accuracies of 94.91%, 93%, and 95.6% under the federated learning settings, respectively, and Hybrid LSTM-GRU attains an F1-score of 94%. Synchronous methods often suffer from high latency and training bottlenecks in real-world IoT environments because they must wait for straggler clients to complete their updates.
Figure 5. Performance comparison with other existing methods on UCI-HAR.
Semi-asynchronous SAFI [37] proposes a clustering-based FL approach that combines in-cluster synchronous and out-cluster asynchronous aggregation to mitigate straggler effects and improve training efficiency. In its evaluation on the UCI-HAR dataset, SAFI achieves 92.5% accuracy. On the other hand, the proposed AsyncLiteNet achieves an accuracy of 97.82% and an F1-score of 97.79%, demonstrating competitive recognition performance compared with the synchronous benchmark. This result highlights the potential of AsyncLiteNet to maintain competitive recognition performance within an asynchronous federated learning setting. These findings suggest that AsyncLiteNet offers a balance between recognition performance and training efficiency.

5. Limitations and Future Work

Although the proposed AsyncLiteNet framework demonstrates competitive recognition performance and improved training efficiency, several limitations remain. First, the deviation-aware aggregation mechanism adjusts client contributions based on the L2 norm of model updates and local sample counts. However, its handling of stale updates remains relatively simple. In asynchronous federated learning, updates generated from earlier global model versions may affect the stability and convergence of subsequent global model updates. Future research could investigate more advanced staleness-aware aggregation strategies and theoretically analyse their convergence properties. In addition, the current client-selection mechanism considers training speed and local sample counts when grouping clients rather than explicitly considering the similarity of their local data distributions. Future research could explore data-aware or adaptive client-selection strategies that incorporate data-distribution characteristics while maintaining training efficiency.
Second, the current evaluation is limited to the WISDM and UCI-HAR datasets. Although an additional controlled non-IID experiment was conducted using Dirichlet partitioning (α = 0.5) across 36 clients to investigate label-distribution heterogeneity, this setting represents only one configuration of non-IID data distribution. Future research could extend the evaluation to more diverse heterogeneous data distributions, different levels of data heterogeneity, alternative non-IID partitioning strategies, and larger client populations to further investigate the robustness, scalability, and generalizability of the proposed framework. Furthermore, comparisons with a broader range of recent asynchronous and personalized federated learning approaches could provide further insights into its effectiveness. Practical deployment on real-world edge devices could also be explored to examine the framework’s performance under actual computational, communication, and resource constraints.

6. Conclusions

In this work, an asynchronous federated learning framework, AsyncLiteNet, is proposed for smartphone human activity recognition. The proposed framework adopts a lightweight local neural network by leveraging 1D convolution, SE, and PPM blocks to extract multi-scale features. Additionally, the proposed AsyncLiteNet introduces an asynchronous aggregation strategy on the server side, integrating cluster-based client sampling and deviation-aware delta weighting to improve aggregation efficiency and manage client-update variations. Based on the experimental results, it becomes evident that AsyncLiteNet achieves competitive recognition performance on the WISDM dataset. AsyncLiteNet achieves approximately 98% accuracy with only 6,943 parameters, compared with 98.44% accuracy achieved by the synchronous 1D-CNN baseline with 203,782 parameters. Although AsyncLiteNet achieves slightly lower accuracy, it reduces the training time from 447.20 s to 272.91 s, representing a reduction of approximately 39%. These results demonstrate a trade-off between recognition performance and computational efficiency. The findings indicate the potential of AsyncLiteNet for HAR applications in areas such as healthcare, fitness training, and smart living, where limiting the sharing of raw sensor data may be beneficial.

Author Contributions

Conceptualization, X.W.T., Y.H.P., S.Y.O. and Z.Y.L.; methodology, X.W.T., Y.H.P. and F.S.H.; writing—original draft preparation, X.W.T.; writing—review and editing, X.W.T. and Y.H.P.; visualization, X.W.T. and F.S.H.; supervision, Y.H.P., S.Y.O. and Z.Y.L.; project administration, Y.H.P. and S.Y.O. All authors have read and agreed to the published version of the manuscript.

Funding

This research received no external funding.

Data Availability Statement

The following supporting information can be downloaded at https://www.cis.fordham.edu/wisdm/dataset.php (accessed on 25 January 2025) and https://archive.ics.uci.edu/dataset/240/human+activity+recognition+using+smartphones (accessed on 5 August 2024).

Acknowledgments

The authors acknowledge the editors and reviewers for their valuable comments and suggestions.

Conflicts of Interest

Author Hiew Fu San was employed by Infineon Technologies Sdn. Bhd. The remaining authors declare that the research was conducted in the absence of any commercial or financial relationships that could be construed as a potential conflict of interest.

Abbreviations

The following abbreviations are used in this manuscript:
HARHuman Activity Recognition
CNNsConvolutional Neural Networks
DLDeep Learning
FLFederated Learning

References

  1. Arshad, M.H.; Bilal, M.; Gani, A. Human Activity Recognition: Review, Taxonomy and Open Challenges. Sensors 2022, 22, 6463. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  2. Islam, M.M.; Nooruddin, S.; Karray, F.; Muhammad, G. Human Activity Recognition Using Tools of Convolutional Neural Networks: A State of the Art Review, Data Sets, Challenges, and Future Prospects. Comput. Biol. Med. 2022, 149, 106060. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  3. Kulsoom, F.; Narejo, S.; Mehmood, Z.; Chaudhry, H.N.; Butt, A.; Bashir, A.K. A Review of Machine Learning-Based Human Activity Recognition for Diverse Applications. Neural Comput. Applic 2022, 34, 18289–18324. [Google Scholar] [CrossRef] [Scilit]
  4. Kumar, P.; Chauhan, S.; Awasthi, L.K. Human Activity Recognition (HAR) Using Deep Learning: Review, Methodologies, Progress and Future Research Directions. Arch. Comput. Methods Eng. 2024, 31, 179–219. [Google Scholar] [CrossRef] [Scilit]
  5. Gupta, S. Deep Learning Based Human Activity Recognition (HAR) Using Wearable Sensor Data. Int. J. Inf. Manag. Data Insights 2021, 1, 100046. [Google Scholar] [CrossRef] [Scilit]
  6. Zhang, S.; Li, Y.; Zhang, S.; Shahabi, F.; Xia, S.; Deng, Y.; Alshurafa, N. Deep Learning in Human Activity Recognition with Wearable Sensors: A Review on Advances. Sensors 2022, 22, 1476. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  7. Zhou, H.; Zhang, X.; Feng, Y.; Zhang, T.; Xiong, L. Efficient Human Activity Recognition on Edge Devices Using DeepConv LSTM Architectures. Sci. Rep. 2025, 15, 13830. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  8. Rashid, N.; Demirel, B.U.; Abdullah Al Faruque, M. AHAR: Adaptive CNN for Energy-Efficient Human Activity Recognition in Low-Power Edge Devices. IEEE Internet Things J. 2022, 9, 13041–13051. [Google Scholar] [CrossRef] [Scilit]
  9. Trotta, A.; Montori, F.; Ciabattini, L.; Billi, G.; Bononi, L.; Di Felice, M. Edge Human Activity Recognition Using Federated Learning on Constrained Devices. Pervasive Mob. Comput. 2024, 104, 101972. [Google Scholar] [CrossRef] [Scilit]
  10. Liu, Z.; Guo, J.; Yang, W.; Fan, J.; Lam, K.-Y.; Zhao, J. Privacy-Preserving Aggregation in Federated Learning: A Survey. IEEE Trans. Big Data 2022, 1–20. [Google Scholar] [CrossRef] [Scilit]
  11. Aouedi, O.; Sacco, A.; Khan, L.U.; Nguyen, D.C.; Guizani, M. Federated Learning for Human Activity Recognition: Overview, Advances, and Challenges. IEEE Open J. Commun. Soc. 2024, 5, 7341–7367. [Google Scholar] [CrossRef] [Scilit]
  12. Nguyen, J.; Malik, K.; Zhan, H.; Yousefpour, A.; Rabbat, M.; Malek, M.; Huba, D. Federated learning with buffered asynchronous aggregation. In Proceedings of the International Conference on Artificial Intelligence and Statistics, Virtual Event, 28–30 March 2022; pp. 3581–3607. [Google Scholar]
  13. Zhang, J.; Cheng, X.; Wang, C.; Wang, Y.; Shi, Z.; Jin, J.; Song, A.; Zhao, W.; Wen, L.; Zhang, T. FedAda: Fast-Convergent Adaptive Federated Learning in Heterogeneous Mobile Edge Computing Environment. World Wide Web 2022, 25, 1971–1998. [Google Scholar] [CrossRef] [Scilit]
  14. Cheng, D.; Zhang, L.; Bu, C.; Wang, X.; Wu, H.; Song, A. ProtoHAR: Prototype Guided Personalized Federated Learning for Human Activity Recognition. IEEE J. Biomed. Health Inform. 2023, 27, 3900–3911. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  15. Liu, S.; Xu, Y.; Zhou, Z.; Li, X.; Wu, W.; Guo, B.; Yu, Z. AdaCLP: Efficient Federated Learning for Asynchronous Mobile Devices with Temporally Imbalanced Data. IEEE Trans. Mob. Comput. 2026, 25, 7814–7830. [Google Scholar] [CrossRef] [Scilit]
  16. Bu, C.; Zhang, L.; Cui, H.; Cheng, D.; Wu, H.; Song, A. Learn From Others and Be Yourself in Federated Human Activity Recognition via Attention-Based Pairwise Collaborations. IEEE Trans. Instrum. Meas. 2024, 73, 2506415. [Google Scholar] [CrossRef] [Scilit]
  17. Yang, Y.; Hu, P.; Shen, J.; Cheng, H.; An, Z.; Liu, X. Privacy-Preserving Human Activity Sensing: A Survey. High-Confid. Comput. 2024, 4, 100204. [Google Scholar] [CrossRef] [Scilit]
  18. Yan, G.; Li, J.; Du, W. fedstep: Asynchronous and Staleness-Aware Personalization for Efficient Federated Learning. In Proceedings of the 34th ACM International Conference on Information and Knowledge Management; ACM: Seoul, Republic of Korea, 2025; pp. 3740–3750. [Google Scholar]
  19. Zhou, X.; Liang, W.; Ma, J.; Yan, Z.; Wang, K.I.-K. 2D Federated Learning for Personalized Human Activity Recognition in Cyber-Physical-Social Systems. IEEE Trans. Netw. Sci. Eng. 2022, 9, 3934–3944. [Google Scholar] [CrossRef] [Scilit]
  20. Sarkar, A.; Sen, T.; Roy, A.K. GraFeHTy: Graph Neural Network Using Federated Learning for Human Activity Recognition. In 2021 20th IEEE International Conference on Machine Learning and Applications (ICMLA); IEEE: Pasadena, CA, USA, 2021; pp. 1124–1129. [Google Scholar] [CrossRef] [Scilit]
  21. Shen, Q.; Feng, H.; Song, R.; Teso, S.; Giunchiglia, F.; Xu, H. Federated multi-task attention for cross-individual human activity recognition. In Proceedings of the 31st International Joint Conference on Artificial Intelligence (IJCAI); International Joint Conferences on Artificial Intelligence: Vienna, Austria, 2022; pp. 3423–3429. [Google Scholar]
  22. Bursa, S.Ö.; Durmaz İncel, Ö.; Işıklar Alptekin, G. Building Lightweight Deep Learning Models with TensorFlow Lite for Human Activity Recognition on Mobile Devices. Ann. Telecommun. 2023, 78, 687–702. [Google Scholar] [CrossRef] [Scilit]
  23. Yi, M.-K.; Lee, W.-K.; Hwang, S.O. A Human Activity Recognition Method Based on Lightweight Feature Extraction Combined With Pruned and Quantized CNN for Wearable Device. IEEE Trans. Consum. Electron. 2023, 69, 657–670. [Google Scholar] [CrossRef] [Scilit]
  24. Wong, Y.J.; Tham, M.-L.; Kwan, B.-H.; Chang, Y.C.; Mokraoui, A.; Ke, F. Efficient Client Selection for Asynchronous Federated Learning for Adaptive Bitrate Streaming. ACM Trans. Multimed. Comput. Commun. Appl. 2025, 21, 1–22. [Google Scholar] [CrossRef] [Scilit]
  25. Yi, M.-K.; Hwang, S.O. Smartphone Based Human Activity Recognition Using 1D Lightweight Convolutional Neural Network. In 2022 International Conference on Electronics, Information, and Communication (ICEIC); IEEE: Jeju, Republic of Korea, 2022; pp. 1–3. [Google Scholar] [CrossRef] [Scilit]
  26. Ige, A.O.; Sibiya, M. State-of-the-Art in 1D Convolutional Neural Networks: A Survey. IEEE Access 2024, 12, 144082–144105. [Google Scholar] [CrossRef] [Scilit]
  27. MacQueen, J.B. Some methods of classification and analysis of multivariate observations. In Proceedings of the Fifth Berkeley Symposium on Mathematical Statistics and Probability; University of California Press: Berkeley, CA, USA, 1967; pp. 281–297. [Google Scholar]
  28. Kwapisz, J.R.; Weiss, G.M.; Moore, S.A. Activity recognition using cell phone accelerometers. ACM SIGKDD Explor. Newsl. 2011, 12, 74–82. [Google Scholar] [CrossRef] [Scilit]
  29. Anguita, D.; Ghio, A.; Oneto, L.; Parra, X.; Reyes-Ortiz, J.L. A Public Domain Dataset for Human Activity Recognition Using Smartphones. In Proceedings of the 21st European Symposium on Artificial Neural Networks, Computational Intelligence and Machine Learning, Bruges, Belgium, 24–26 April 2013; pp. 437–442. [Google Scholar]
  30. Agarwal, P.; Alam, M. A Lightweight Deep Learning Model for Human Activity Recognition on Edge Devices. Procedia Comput. Sci. 2020, 167, 2364–2373. [Google Scholar] [CrossRef] [Scilit]
  31. Zhao, Y.; Hu, C.; Yang, X.; Yuan, L.; Tian, X.; Gao, T.; Chen, Y. A Data Contribution-Based Adaptive Federated Learning Approach for Wearable Activity Recognition. In Proceedings of the 2025 28th International Conference on Computer Supported Cooperative Work in Design (CSCWD); IEEE: Compiegne, France, 2025; pp. 552–557. [Google Scholar]
  32. Wen, X.; Wang, Y.; Yuan, M.; Wang, A.; Zheng, G.; Yu, H.; Meng, L. DC-PFL: A Dynamic Clustering-Based Personalized Federated Learning Method for Human Activity Recognition. Eng. Sci. Technol. Int. J. 2025, 72, 102230. [Google Scholar] [CrossRef] [Scilit]
  33. Yussif, S.B.; Xie, N.; Yang, Y.; Huang, Y.; Wang, G.; Du, Z. EGTCN: An Efficient Graph and Temporal Convolution Network for Sensor-Based Human Activity Recognition in Federated Learning. IEEE Sens. J. 2024, 24, 34892–34906. [Google Scholar] [CrossRef] [Scilit]
  34. Wang, C.; Fan, R. FedSynHAR: A Framework Based on Feature-Enhanced Adaptive Pruning-Mutual Distillation for Federated Human Activity Recognition. Sci. Rep. 2026, 16, 19764. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  35. Liu, S.; Wang, J.; Zhang, W. Federated Personalized Random Forest for Human Activity Recognition. Math. Biosci. Eng. 2022, 19, 953–971. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  36. Albogamy, F.R. Federated Learning for IoMT-Enhanced Human Activity Recognition with Hybrid LSTM-GRU Networks. Sensors 2025, 25, 907. [Google Scholar] [CrossRef] [Scilit] [PubMed]
  37. Fan, B.; Su, X.; Tarkoma, S.; Hui, P. Behave Differently When Clustering: A Semi-Asynchronous Federated Learning Approach for IoT. ACM Trans. Sen. Netw. 2024, 20, 1–28. [Google Scholar] [CrossRef] [Scilit]
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Article Metrics

Citations

Article Access Statistics

Multiple requests from the same IP address are counted as one view.