The HALF framework: a privacy-preserving federated learning approach for scalable and secure AI applications

The concept of FL was formally introduced by McMahan et al. (2017) with the development of the federated averaging (FedAvg) algorithm, which set the stage for collaborative machine learning without centralizing data. The main idea is to train models on client devices locally and then combine the model parameters instead of the raw data. This method has been the subject of extensive research and refinement over the last decade. Li et al. (2020) conducted a comprehensive survey of FL systems, pinpointing significant challenges such as statistical and system heterogeneity, privacy concerns, and communication efficiency. FL represents a decentralized approach to machine learning, facilitating collaborative model training across multiple distributed clients without necessitating the centralization of sensitive data. The process initiates with the dissemination of a global model to all participating clients, who subsequently engage in local training on their respective datasets. Upon completion of training, each client transmits only the updated model parameters, excluding the raw data, back to a central server, where these parameters are aggregated to enhance the global model. This cycle of distribution, local training, and parameter aggregation is iteratively repeated until the model converges to an optimal state, thereby ensuring both data privacy and model efficacy. Their research underscored the importance of adaptive strategies that can manage diverse client capabilities and data distributions.

Differential privacy has become the standard for maintaining privacy in machine learning. Dwork and Roth (2014) established the theoretical basis for differential privacy, while Abadi et al. (2016) demonstrated its practical application in deep learning by creating differentially private stochastic gradient descent (DP-SGD). Additionally, secure multi-party computation (SMC) and homomorphic encryption (HE) have been explored for privacy-preserving FL. Bonawitz et al. (2017) developed secure aggregation protocols that allow for privacy-preserving parameter aggregation in federated settings.

Recent research has delved into hierarchical approaches to FL to address issues of scalability and communication efficiency. Liu et al. (2021) proposed a hierarchical FL framework that uses edge servers as intermediate aggregators, thereby reducing communication overhead and enhancing convergence speed. Zhao et al. (2022) explored adaptive hierarchical structures that adjust dynamically based on network conditions and client capabilities, demonstrating improved performance in heterogeneous environments.

The rapid growth of data generated by IoT devices, smart sensors, and distributed systems has caused significant challenges in data processing, privacy, and scalability. Traditional centralized machine learning approaches are unable to handle the volume and heterogeneity of data while also facing issues such as latency, bandwidth constraints, and privacy issues. FL has emerged as a promising solution for decentralized model training; however, it faces its own challenges, including communication overhead, non-independent and identically distributed (IID) data, and the need for robust privacy-preserving mechanisms. The integration of Cloud and Edge Computing provides a viable solution, but comprehensive frameworks that effectively combine their strengths to address these challenges are lacking. This study explores the hybrid adaptive learning framework (HALF) framework as a transformative approach for overcoming these constraints and enabling efficient, secure, and scalable distributed machine learning [7].

This study is significant because it focuses on the increasing need for privacy-preserving, scalable, and low-latency machine learning solutions in the era of IoT and distributed systems. By examining the HALF framework, this study provides effective insights into overcoming the limitations of traditional FL approaches and highlights the potential of integrating Cloud and Edge Computing. The findings have broad implications for critical sectors such as healthcare, where patient data confidentiality is paramount; smart cities, where real-time data processing is essential; and autonomous systems, where low-latency and scalable machine learning is crucial for safe and reliable operations. Furthermore, this study identifies research gaps and proposes future directions, resulting in the development of secure and efficient distributed machine learning frameworks.

This study examines the hybrid adaptive learning framework (HALF) framework as a groundbreaking approach to distributed machine learning, focusing on its ability to address key challenges, such as privacy preservation, scalability, and latency. By integrating Cloud and Edge Computing, HALF utilizes adaptive aggregation techniques and robust communication protocols to enhance the efficiency and accuracy of FL models, even in complex non-IID data environments. This study examines the framework’s performance, outlines its applications in critical sectors, and identifies research gaps for future exploration. This comprehensive analysis aims to advance the field of secure and scalable FL frameworks, paving the way for intelligent decentralized learning systems that meet the demands of modern computing [10].

The rapid expansion of IoT devices and edge computing technologies has significantly altered the domain of distributed artificial intelligence, necessitating the development of novel architectures that effectively balance computational efficiency, data privacy, and model accuracy. The hybrid adaptive learning framework (HALF) Framework addresses these requirements by integrating edge intelligence with cloud-based processing in a manner that is both privacy-conscious and resource-efficient. This architecture facilitates collaborative model training across decentralized devices while mitigating privacy risks and computational constraints. By employing FL principles, the HALF Framework ensures that sensitive data remains localized, with only encrypted parameters being transmitted to the cloud for aggregation and model enhancement. The hybrid adaptive learning framework (HALF) framework presents a transformative solution in the realm of privacy-preserving distributed machine learning, specifically designed for large-scale, real-time AI applications. By incorporating both cloud and edge computing paradigms, the HALF framework ensures that data remains at its source, thereby minimizing security risks while enabling decentralized training. This hybrid model empowers devices to engage in FL without exposing sensitive information, representing a crucial advancement in sectors such as healthcare, smart cities, and autonomous systems. Engineered to manage non-IID (non-independent and identically distributed) data and adapt to real-time network variability, HALF is poised to redefine scalable AI training with strict adherence to privacy standards.

Figure 2 shows that the HALF framework is designed with a multilayered architecture based on three essential principles: a privacy-first approach, a hybrid computing model, and adaptive intelligence. It includes an edge computing layer that allows devices, such as IoT nodes, to perform model training locally, ensuring that raw data remains secure and on the device. Additionally, a cloud layer gathers encrypted model updates to develop a globally optimized model, utilizing secure communication channels and advanced aggregation algorithms. The system operates through a five-step process: beginning with initialization, followed by adaptive device selection, privacy-protected local training, secure aggregation, and concluding with comprehensive evaluation. This systematic approach ensures efficient model training with privacy guarantees (ε ≤ 2.3), strong device coordination, and effective performance assessment across various network conditions.

Figure 2:

HALF Architecture. HALF, hybrid adaptive learning framework; IoT, Internet of things.

Within the HALF framework, the edge computing layer plays a pivotal role in enabling decentralized learning directly at the device level, facilitating real-time data processing and ensuring privacy-preserving computations. Devices within the IoT ecosystem, including smart sensors and mobile devices, are responsible for generating data locally and initiating neural network training on the device itself, thereby eliminating the need to transfer raw data to the cloud. This methodology not only minimizes latency but also ensures that sensitive information remains at its source. The process of local model training incorporates privacy-enhanced gradient computations. The privacy protection module is designed to employ differential privacy (ε ≤ 2.3), which involves adding noise to model parameters and implementing validation checks to protect user data. Additionally, adaptive device selection mechanisms are in place to assess network conditions and energy constraints, determining which devices should actively participate in the training process, thus fostering an efficient and responsive edge ecosystem. A secure communication module serves as the bridge between the edge and cloud layers, a crucial element of FL within the HALF framework. This module is responsible for the transmission of encrypted model updates, as opposed to raw data, between devices and central servers. It leverages hybrid encryption techniques and robust privacy-preserving protocols to maintain the integrity and confidentiality of model parameters during transmission. Upon receiving encrypted updates from multiple devices, these updates are aggregated and refined into a global model, which is then securely redistributed to edge devices. This bidirectional flow ensures synchronization across the distributed learning network, allowing devices to leverage collective intelligence while maintaining data sovereignty and reducing bandwidth consumption.

The cloud computing layer plays a crucial role in global model aggregation by combining weighted parameters through an advanced computational system designed to handle extensive and intricate tasks. It supports adaptive aggregation by tackling non-IID (non-independent and identically distributed) data with dynamic weight modifications and tailored model updates. The framework’s reliability and robustness are bolstered by incorporating secure multiparty computation, key management protocols, and cryptographic verification. Furthermore, performance optimization strategies—such as load balancing algorithms, smart resource allocation, and convergence acceleration—ensure that the learning process remains scalable and efficient. This multi-layered and cooperative approach empowers HALF to provide high-performing, privacy-conscious AI solutions across varied, distributed settings. A notable innovation in HALF is its multi-layered privacy-preserving strategies, which encompass differential privacy, secure multiparty computation, and hybrid encryption protocols, safeguarding both data confidentiality and system integrity. The framework excels in dynamic scalability, utilizing adaptive load balancing and elastic cloud integration to effectively manage resource distribution across devices. Its potential applications span numerous fields—enabling hospitals to develop predictive healthcare models without disclosing patient data, optimizing traffic and energy systems in smart cities, and enhancing real-time decision-making in autonomous vehicles. In robotics and industrial automation, HALF supports collaborative learning while maintaining proprietary data and operational privacy, representing a significant advancement in federated AI deployment. HALF achieves outstanding results with model accuracy of ≥89.7% and reduced training times (approximately 142 min), all while upholding stringent privacy standards. Compared to traditional centralized or edge-only solutions, it offers superior performance, improved resource efficiency, and better management of heterogeneous and non-IID data. Looking forward, the framework’s roadmap includes the integration of HE for secure computation on encrypted data, blockchain-based audit mechanisms for decentralized trust, and intelligent adaptation techniques for real-time processing. These developments will enable HALF to expand across extensive IoT deployments and support increasingly complex AI applications. As global industries face growing demands for secure, privacy-compliant AI systems, HALF stands as a foundational framework guiding the next generation of reliable, federated intelligence.

Table 1 provides a comparative assessment of the hybrid adaptive learning framework (HALF) framework in relation to existing FL models across critical dimensions. HALF introduces significant enhancements by employing advanced privacy techniques such as DP-SGD and HE, which deliver strong privacy assurances without diminishing model accuracy. The framework effectively curtails communication overhead through dynamic aggregation and compression, enhances scalability with a hybrid edge-cloud orchestration approach, and sustains performance in non-IID data environments through adaptive personalization strategies. Moreover, HALF addresses latency issues with efficient routing protocols and localized processing, adapts to evolving system conditions through resource-aware optimization, and validates its practical utility with successful implementations in healthcare, smart cities, and autonomous systems. In summary, the framework consistently achieves high performance across multiple metrics—accuracy, energy efficiency, privacy, and responsiveness—underscoring its potential for scalable, secure, and real-time FL in varied landscapes.

HE facilitates the execution of computations on encrypted data without requiring decryption, acting as a potent privacy-preserving mechanism for FL frameworks such as HALF. In a prospective future iteration of HALF, HE would permit edge devices to acquire an encrypted global model, carry out local training with encrypted gradients and updates, and then relay encrypted model updates back to the server. The server would then integrate these encrypted updates using homomorphic operations like addition and multiplication, all while refraining from accessing any raw data or decrypted model parameters. This strategy ensures that both the data and model remain confidential throughout the learning process, significantly bolstering privacy. Nonetheless, it necessitates substantial computational resources and specialized encryption libraries (e.g., CKKS, BFV), rendering it more of an aspirational objective at this time rather than a feature currently realized in the HALF framework.

Pseudocode: HE Workflow in HALF Framework

• 1.   Initialize:

• 2.   Global model G0 (encrypted using HE scheme)

• 3.   HE_Params = {KeyGen(), Encrypt(), Decrypt(), Add(), Multiply()}

• 4.   For round r = 1 to R do:

• 5.   Device Selection:

• 6.   Select subset Sr of edge devices with HE capability

• 7.   Broadcast:

• 8.   Server encrypts current global model G(r-1) using HE.Encrypt()

• 9.   Send encrypted model to devices in Sr

• 10.   Local Encrypted Training:

• 11.   For each device i in Sr:

• 12.   For epoch = 1 to E:

• 13.   For each batch b in local encrypted data Di:

• 14.   EncryptedGradients = HE.Gradient(Gi, b)

• 15.   Gi = HE.UpdateModel(Gi, EncryptedGradients)// using HE.Add(), HE.Multiply()

• 16.   Encrypted Aggregation:

• 17.   Each device sends encrypted update ΔGi to server

• 18.   Server computes G(r) = HE.Aggregate({ΔGi}) using HE.Add() (no decryption)

• 19.   Decryption (Optional for Evaluation):

• 20.   If required, the server decrypts G(r) using HE. Decrypt() for accuracy evaluation

• 21.   Return:

• 22.   Final encrypted global model G(R)

The integration of quantum computing into the hybrid adaptive learning framework (HALF) framework marks a revolutionary shift by merging traditional FL with quantum-enhanced techniques for optimization, encryption, and model generalization. Unlike conventional federated systems, the expanded quantum-enhanced HALF (HALF-Q) architecture utilizes quantum neural networks (QNNs) and parameterized quantum circuits (PQCs) at edge nodes that support quantum computation, facilitating quicker convergence on non-IID data and enabling more complex learning patterns. Privacy and communication security are redefined through quantum key distribution (QKD), providing theoretically unbreakable cryptographic exchanges. Additionally, quantum approximate optimization algorithms (QAOA) are employed at the server level to refine global model parameters and optimize hyperparameters, surpassing classical optimization efficiency limits. This innovative integration creates a hybrid quantum-classical federated pipeline, laying the groundwork for scalable, secure, and future-ready AI systems capable of functioning in adversarial, resource-limited, and dynamically distributed environments.

• 1.   Initialize:

• 2.   Global model G0 (classical or hybrid quantum-classical)

• 3.   QuantumToolkit = {QAOA, QNN, PQC, QKD, QuantumMeasurement}

• 4.   SystemResources = HALF stack + access to quantum runtime

• 5.   For each communication round r = 1 to R do:

• 6.   Adaptive Device Selection:

• 7.   Identify devices with quantum support (quantum-classical partitioning)

• 8.   Sr ← Subset of participating devices with capability labels

• 9.   Secure Initialization via QKD:

• 10.   For each quantum device in Sr:

• 11.   Establish symmetric session keys using Quantum Key Distribution (QKD)

• 12.   Encrypt G(r-1) using QKD-based keys

• 13.   Federated Broadcast:

• 14.   Server sends encrypted G(r-1) to all selected devices Sr

• 15.   Quantum and classical nodes receive the model in a suitable form

• 16.   Local Model Training:

• 17.   For each device i in Sr:

• 18.   If quantum-capable:

• 19.   Construct a Parameterized Quantum Circuit (PQC)

• 20.   Perform training using QNN or variational quantum algorithms (e.g., VQE)

• 21.   Else:

• 22.   Perform standard DP-SGD training with privacy budget ε_i

• 23.   Update Aggregation:

• 24.   Devices send ΔGi to the server:

• 25.   Quantum updates are measured and converted to classical tensors

• 26.   Server aggregates updates using weighted average or hybrid fusion logic

• 27.   Quantum-assisted global optimization (optional):

• 28.   Apply QAOA or quantum annealing to refine global parameters or hyperparameters

• 29.   Return:

• 30.   Optimized global model G(R) incorporating quantum and classical contributions

In hybrid adaptive learning framework (HALF) frameworks, secure enclaves utilize trusted execution environments (TEEs) to establish isolated, hardware-protected zones within memory and CPU. These zones ensure the integrity and confidentiality of data and machine learning models during computation. TEEs, such as Intel’s Software Guard Extensions (SGX), facilitate the secure execution of FL tasks by encrypting both code and data, thereby protecting them from unauthorized access, including from privileged system software. This capability enables the secure processing of sensitive client-side local training and server-side model aggregation tasks, effectively preventing tampering and data leakage throughout the FL process. By integrating secure enclaves, HALF frameworks can dynamically adjust key components of the FL pipeline, such as client participation, aggregation strategies, and privacy-preserving mechanisms, in response to current system constraints and security requirements. This adaptive capability enhances the flexibility and resilience of FL systems, particularly in resource-constrained or heterogeneous environments like the IoT. The comprehensive protection provided by secure enclaves ensures that model parameters, gradients, and other sensitive components remain confidential and tamper-proof throughout the entire lifecycle of FL.

Pseudocode: Secure Enclave-based FL Algorithm

• 1.   Initialization Phase

• 2.   FUNCTION Initialize()

• 3.    FOR each client i in N_clients:

• 4.     Initialize local_model_i

• 5.     Setup TEE/SGX enclave_i

• 6.     Generate encryption keys (pub_key_i, priv_key_i)

• 7.     Register with aggregation server

• 8.    END FOR

• 9.     Setup central TEE enclave at aggregation server

• 10.    Initialize global_model

• 11.    Set convergence_threshold

• 12.   END FUNCTION

• 13.   Main training loop

• 14.   FUNCTION FederatedTraining()

• 15.    FOR round t = 1 to max_rounds:

• 16.     // Client Selection & Adaptation

• 17.     selected_clients = AdaptiveClientSelection (N_clients, system_constraints)

• 18.

• 19.     // Local training in secure enclaves

• 20.     PARALLEL FOR each client i in selected_clients:

• 21.      ENTER_ENCLAVE(enclave_i):

• 22.       local_data_i = SecureLoad(encrypted_data_i)

• 23.       local_model_i = global_model // Download current global model

• 24.           // Local training with privacy protection

• 25.       FOR local_epoch in local_epochs:

• 26.        gradients = ComputeGradients (local_model_i, local_data_i)

• 27.        local_model_i = UpdateModel(local_model_i, gradients)

• 28.       END FOR

• 29.           // Differential privacy noise addition (optional)

• 30.       IF privacy_level == HIGH:

• 31.        local_model_i = AddDifferential PrivacyNoise(local_model_i)

• 32.       END IF

• 33.           // Encrypt model updates before transmission

• 34.       encrypted_update_i = Encrypt(local_model_i - global_model, pub_key_server)

• 35.      EXIT_ENCLAVE

• 36.         // Send encrypted updates to server

• 37.      Send(encrypted_update_i, client_metadata_i)

• 38.      END PARALLEL FOR

• 39.         // Secure Aggregation in Server TEE

• 40.      ENTER_ENCLAVE(server_enclave):

• 41.       decrypted_updates = []

• 42.       FOR each received encrypted_update_i:

• 43.        update_i = Decrypt(encrypted_update_i, priv_key_server)

• 44.           // Verification and validation

• 45.        IF VerifyIntegrity(update_i) AND Validate Update(update_i):

• 46.         decrypted_updates.append(update_i)

• 47.        END IF

• 48.       END FOR

• 49.         // Adaptive weighted aggregation

• 50.       weights = ComputeAdaptiveWeights (client_metadata, performance_history)

• 51.       global_model = WeightedAverage (decrypted_updates, weights)

• 52.         // Model quality assessment

• 53.       model_quality = EvaluateModel (global_model, validation_data)

• 54.         // Adaptive learning rate adjustment

• 55.       IF model_quality < quality_threshold:

• 56.        AdjustLearningParameters()

• 57.       END IF

• 58.      EXIT_ENCLAVE

• 59.         // Convergence check

• 60.      IF CheckConvergence(global_model, previous_model, convergence_threshold):

• 61.       BREAK

• 62.      END IF

• 63.         // Broadcast updated global model

• 64.      BroadcastModel(global_model, selected_clients)

• 65.       END FOR

• 66.   END FUNCTION

• 67.   // Adaptive Client Selection

• 68.   FUNCTION AdaptiveClientSelection(clients, constraints)

• 69.    client_scores = []

• 70.    FOR each client i:

• 71.     score_i = ComputeScore(data_quality_i, computational_capacity_i,

• 72.         network_reliability_i, privacy_requirements_i)

• 73.     client_scores.append((client_i, score_i))

• 74.    END FOR

• 75.     // Select top-k clients based on adaptive criteria

• 76.    selected = SelectTopK(client_scores, k, fairness_constraints)

• 77.    RETURN selected

• 78.   END FUNCTION

• 79.   // TEE Security Functions

• 80.   FUNCTION ENTER_ENCLAVE(enclave):

• 81.    // Establish secure execution context

• 82.    // All operations within enclave are protected from external access

• 83.    // Memory encryption and attestation active

• 84.   END FUNCTION

• 85.   FUNCTION EXIT_ENCLAVE():

• 86.    // Secure cleanup of sensitive data

• 87.    // Zero out temporary variables

• 88.    // Return to normal execution context

• 89.   END FUNCTION

• 90.   // Adaptive Weighted Aggregation

• 91.   FUNCTION WeightedAverage(updates, weights):

• 92.    global_update = ZeroTensor()

• 93.    total_weight = sum(weights)

• 94.     FOR i in range(len(updates)):

• 95.     global_update += (weights[i] / total_weight) * updates[i]

• 96.    END FOR

• 97.     RETURN global_update

• 98.   END FUNCTION

• 99.   // Privacy-Preserving Mechanisms

• 100.  FUNCTION AddDifferentialPrivacyNoise(model):

• 101.   FOR each parameter p in model:

• 102.    noise = GaussianNoise(mean=0, std=privacy_epsilon)

• 103.    p += noise

• 104.   END FOR

• 105.   RETURN model

• 106. END FUNCTION

• 107. // Main Execution

• 108. MAIN:

• 109.  Initialize()

• 110.  FederatedTraining()

• 111.  FinalizeModel()

• 112. END MAIN

One of the most pressing concerns in distributed machine learning is ensuring the privacy and security of the sensitive data. Traditional centralized methods require data transfer to a central server, which increases the risk of data breaches and privacy violations. HALF addresses this issue by enabling local model training on edge devices, ensuring that raw data are never left at its source. The framework uses advanced privacy techniques such as differential privacy and secure multiparty computation to improve data security. HALF is particularly suitable for healthcare applications, where patient data confidentiality is crucial, and in smart cities, sensitive information about citizens must be protected.

The exponential growth of data generated by IoT devices and distributed systems has made scalability a crucial requirement for modern machine learning systems. HALF tackles this challenge by using the computational power of the cloud for global model aggregation, while using edge devices for local processing. This hybrid approach reduces the burden on centralized servers and communication overhead, resulting in a more efficient system. For example, in autonomous systems, HALF allows real-time decision-making by processing data locally on edge devices, reducing latency, and improving system response.

A common challenge in FL is the treatment of non-IID (non-independent and equally distributed) data, which can lead to model inaccuracies and inefficiencies. HALF addresses this issue through adaptive aggregation techniques that dynamically adjust data distributions across devices. By incorporating mechanisms such as weighted aggregation and personalized model updates, HALF ensures high model accuracy, even in complex, non-IID applications. This capability is valuable in applications such as personalized healthcare, where patient data can vary significantly across individuals.

The HALF framework has far-reaching implications across various sectors, including healthcare, smart cities, and autonomous systems. In healthcare, HALF enables the development of privacy-preserving machine-learning models for disease prediction, diagnosis, and treatment planning. In smart cities, the framework provides real-time data processing for traffic management, energy optimization, and public safety. In autonomous systems, HALF provides low-latency and scalable machine learning, which is essential for secure and reliable operations. These applications demonstrate the societal impact of HALF, highlighting its potential for addressing real-world challenges while adhering to privacy and scalability standards.

Although HALF provides numerous benefits, there are still challenges and research gaps that must be addressed. A key area for future research is the development of dynamic optimization algorithms that can adapt to changing network conditions and device capabilities. Additionally, large-scale real-world deployments of HALF are necessary to evaluate their effectiveness and scalability in various scenarios. Another promising approach is the integration of advanced technologies such as blockchain for enhanced data security and transparency. By addressing these challenges, researchers can unlock the full potential of HALF, enabling intelligent, decentralized learning systems that are secure, scalable, and efficient.

The HALF framework is a transformative approach to distributed machine learning that addresses significant challenges in terms of privacy, scalability, and latency by integrating cloud and edge computing. Its applications in critical sectors such as healthcare, smart cities, and autonomous systems highlight its social relevance and potential for widespread adoption. However, more research is required to overcome the existing limitations and realize HALF’s potential of HALF in enabling intelligent, decentralized learning systems. By consolidating the current knowledge and highlighting research gaps, this discussion provides valuable insights for advancing the field of secure and scalable FL frameworks.

Figure 3 shows the hybrid adaptive learning framework (HALF) framework, a distributed machine-learning approach designed for privacy preservation, scalability, and low-latency processing, along with its workflow and various applications. The process begins with data generation by IoT devices, which then undergo localization on the edge devices. This edge processing is essential for low-latency and privacy-preserving model training because it prevents the need to transfer raw data to a central server. The cloud component of the HALF framework is responsible for global model aggregation, leveraging its computational power and scalability to combine the model updates received from numerous edge devices. FL is essential to this process, enabling decentralized model training in which edge devices collaborate on a shared model without transferring sensitive raw data. The “Adaptive Aggregation Half Framework” focuses on challenges posed by non-IID data and optimizes communication efficiency between edge devices and the cloud. This framework delivers key benefits, including “Privacy Resilience, Adaptability & Productivity,” and “real-time processing,” making it suitable for a range of applications. These applications span “Smart Health Applications,” where patient data privacy is paramount; “Digital Urban Innovations,” where real-time data processing is essential for smart city management; and “Autonomous Systems,” where low latency and scalable machine learning are critical for safe operation [12]. Overall, the diagram encapsulates the complete functionality of the HALF framework, from initial data generation and local edge processing to global cloud aggregation and its practical implementation across various sectors, emphasizing its contribution to distributed machine learning.

Figure 3:

The HALF framework: enabling privacy-preserving distributed machine learning. HALF Framework, High-performance adaptive learning framework.

Table 2 shows the evaluation of the HALF framework against both traditional and contemporary FL methods, it becomes evident that HALF offers significant advantages across various dimensions. Unlike baseline models such as FedAvg, Edge-only FL, or Cloud-based FL, which encounter issues with privacy, scalability, and the management of non-IID data, HALF integrates state-of-the-art privacy-preserving techniques like differential privacy and HE. It also utilizes adaptive aggregation and dynamic resource-aware device selection to ensure robust performance in diverse environments. This framework effectively reduces communication overhead by 40% or more, boosts model accuracy in non-IID scenarios to at least 89.7%, and achieves low latency and energy efficiency with consumption capped at 53.2% or less. These attributes make it particularly well-suited for practical applications in sectors such as healthcare and smart cities. Additionally, its comprehensive security stack, featuring TLS 1.3, AES-256, and SHA-256, along with its real-time adaptability, sets it apart from other adaptive FL frameworks. Consequently, HALF emerges as a privacy-resilient, scalable, and deployment-ready solution for the future of distributed machine learning.

In Table 3 shows the hybrid adaptive learning framework (HALF) framework is engineered to provide a FL solution that emphasizes privacy, scalability, and resource efficiency for distributed AI applications across sectors such as healthcare, smart cities, and autonomous systems. It tackles significant challenges like data confidentiality, communication overhead, device heterogeneity, and latency by integrating features such as adaptive device selection, dynamic privacy budgeting (ε ≤ 2.3), secure multiparty computation, and a hybrid edge-cloud architecture. The framework’s workflow encompasses the entire process from initialization to evaluation, ensuring privacy through differential privacy, HE, and secure aggregation. Utilizing a weighted FedAvg strategy bolstered by device reliability scoring, the framework adeptly handles non-IID data (Dirichlet α = 0.5) and achieves impressive performance (≥89.7% accuracy, ≥40% reduced communication overhead). Developed using Python 3.8+ and tools like PyTorch, TensorFlow Privacy, and Flower FL, it operates on modest edge and cloud hardware. Security protocols include TLS 1.3, AES-256, and device authentication, with evaluations conducted through simulations (MNIST, CIFAR-10) and qualitative methods. The framework shows a 7.4% accuracy improvement over standard FL and 45.45% resource savings, though it still faces challenges in real-time validation, cross-silo scalability, and encryption costs. Future work aims to address these issues through HE, model drift adaptation, and automated privacy-risk assessment.

The theoretical foundation of this study is rooted in the principles of FL, cloud computing, and edge computing. FL enables decentralized model training by allowing devices to collaboratively learn a shared model while keeping the data localized. Cloud computing provides scalable computational resources for global model aggregation, whereas edge computing brings data processing closer to the source, reducing latency and bandwidth usage. The HALF framework builds on these principles by introducing adaptive aggregation techniques, robust communication protocols, and the efficient management of heterogeneous devices. This theoretical framework provides a basis for understanding how HALF addresses the limitations of traditional FL and uses the strengths of cloud-edge collaboration to enable privacy, scalability, and low-latency machine learning.

Empirical studies on FL and cloud-edge collaboration have shown the potential of hybrid frameworks to overcome the challenges of traditional approaches. For instance, research has shown that adaptive aggregation techniques can significantly reduce communication overhead and improve model accuracy in non-IID environments. Studies have also highlighted the importance of privacy mechanisms such as differential privacy and secure multiparty computation in ensuring data security. However, existing frameworks often lack the ability to adapt to dynamic network conditions and device capabilities, thereby limiting their effectiveness and efficiency. The HALF framework addresses these limitations by incorporating dynamic optimization algorithms and real-time adaptation strategies, as demonstrated by recent studies showing a 40% reduction in communication overhead and improved privacy preservation. This section examines empirical studies in order to provide a comprehensive overview of the performance and potential of the HALF framework.

The conceptual framework of this study was based on the integration of FL, Cloud Computing, and Edge Computing within the HALF framework. The framework consists of three main components.

• Data Generation and Local Processing: IoT devices generate data processed locally on edge devices to ensure privacy and reduce latency.

• Adaptive Aggregation and Global Model Updates: The cloud collects model updates from edge devices using adaptive techniques to process non-IID data and optimize communication.

• The HALF framework has been utilized in healthcare, smart cities, and autonomous systems, demonstrating its societal impact and real-world relevance.

• This conceptual framework provides a structured approach to how HALF addresses privacy, scalability, and latency challenges in distributed machine learning.

To evaluate the performance of the HALF framework, the following variables are operationalized:

• Privacy Preservation: The Implementation of privacy-preserving techniques such as differential privacy and SMC.

• Communication Overhead: The reduction in data transmission between edge devices and the cloud, with a potential improvement of up to 40%.

• Model Accuracy: The accuracy of models trained using HALF is compared to those trained using traditional FL frameworks, particularly in non-IID data environments.

• Latency: Evaluated by measuring the time taken for data processing and model updates in edge devices compared to central approaches.

• The framework’s ability to handle increasing device and data volumes without compromising performance.

These variables provide a basis for determining the effectiveness of the HALF framework in addressing distributed machine-learning challenges.

This section examines the literature on FL, cloud-edge collaboration, and adaptive learning techniques, highlighting the gaps that the HALF framework aims to address. Theoretical and conceptual frameworks provide the basis for understanding how HALF integrates the strengths of FL, Cloud Computing, and Edge Computing to enable privacy-preserving, scalable, and low-latency machine learning. The empirical analysis and operationalization of variables provide a structured approach to evaluate the framework’s performance and potential applications. By addressing the limitations of traditional FL frameworks, HALF represents a significant improvement in distributed machine learning, with significant implications for critical sectors such as healthcare, smart cities, and autonomous systems [13].

Primary Insights from Table 4 Meta-Analysis:

• Privacy Preservation: Techniques such as differential privacy and secure aggregation are critical for ensuring data security in FL frameworks.

• Scalability and Latency: Cloud-edge collaboration improves scalability; however, edge devices face computational power and bandwidth limitations.

• Non-IID Data Handling: Adaptive aggregation techniques in the HALF framework effectively address the challenges associated with non-IID data.

• Real-World Applications: HALF provides a comprehensive overview of healthcare, smart cities, and autonomous systems but requires further real-world validation.

• Future Directions: Dynamic optimization algorithms, lightweight implementations, and real-world testing are essential for advancing FL models.

Figure 4 presents a comprehensive review of literature on cloud services and distributed machine learning, concentrating on three key areas: research challenges, technological advancements, and theoretical underpinnings. The research challenges identified in the literature mainly concern data security, resource limitations, and transmission overhead issues that the HALF framework aims to tackle. Data security poses a major hurdle, which is addressed by employing cryptographic protocols and data masking techniques within HALF. Likewise, resource limitations are managed by implementing resource-efficient architectures and algorithms that emphasize lightweight processing at the edge. Additionally, HALF minimizes transmission overhead by using optimized communication protocols that facilitate quicker and more efficient data exchange. Technological advancements are also crucial, with innovations such as cloud computing frameworks enabling centralized coordination and distributed system architectures supporting collaborative processing between cloud servers and edge devices. FL is central to the HALF architecture, allowing for decentralized model training while preserving data privacy. Another emerging trend, IoT-enabled machine learning, is potentially integrated within HALF for real-time data collection and on-device inference. Theoretical research underpins these innovations through foundational work in FL, which HALF is built upon, and in the design of energy-efficient algorithms, a fundamental aspect of HALF’s adaptive architecture.

Figure 4:

Literature survey on cloud services and distributed machine learning.

The evolution of cloud computing has profoundly transformed the deployment landscape of machine learning, offering scalable and on-demand computational resources. The literature in this field categorizes cloud services into three primary models: Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS), each providing distinct capabilities for machine learning applications. Studies by Zhang et al. (2023) and Kumar & Patel (2024) indicate that leading IaaS providers such as Amazon Web Services (AWS), Microsoft Azure, and Google Cloud facilitate the elastic scaling of machine learning workloads through the dynamic provisioning of virtual machines and containers. This elasticity supports the high-performance training of complex machine learning models that would otherwise be impractical on traditional computing setups. Furthermore, the inherent support for horizontal scaling within cloud infrastructure enables machine learning algorithms to operate in parallel, thereby enhancing computational efficiency and training throughput. These service models are particularly advantageous for cost-effective machine learning deployments, as their pricing schemes align with usage patterns, offering flexibility for both developers and researchers. The integration of such cloud-native services into frameworks like HALF allows for the seamless orchestration of distributed machine learning tasks, where centralized oversight and distributed execution function collaboratively.

Significant advancements have been achieved in distributed machine learning architectures, which are crucial for managing large-scale, real-world datasets. The literature delineates several architectures, including parameter server-based models, wherein gradient computations are executed by worker nodes while parameter updates are centrally managed. This design is comprehensively articulated in recent works by Chen et al. (2024) and Rodriguez & Kim (2023). Additionally, contemporary frameworks such as Apache Spark MLlib, TensorFlow Distributed, and PyTorch Distributed have simplified the complexities of distributed computing, thereby enhancing accessibility for researchers and practitioners. The emergence of FL represents a shift toward decentralized model training, facilitating privacy-preserving learning across distributed nodes without data centralization. Researchers such as Thompson & Liu (2024) underscore the significance of orchestration platforms like Kubernetes in managing the lifecycle of these workloads, ensuring reliability, fault tolerance, and efficient resource utilization. Despite these advancements, the literature continues to emphasize challenges related to scalability and performance. Communication overhead between distributed nodes can impede training efficiency, although gradient compression and asynchronous communication protocols have been demonstrated to alleviate these issues. Furthermore, heterogeneity in computational resources, network variability, and fault-prone nodes necessitate adaptive scheduling and checkpoint-based recovery systems to sustain system robustness.

As distributed machine learning increasingly utilizes cloud infrastructure, security and privacy concerns become more pronounced, particularly in multi-tenant and edge-cloud hybrid environments. Studies by Johnson et al. (2024) and Patel & Singh (2023) explore privacy-preserving techniques such as HE and SMC, which are essential for safeguarding sensitive data during collaborative learning. HALF incorporates such techniques to uphold robust privacy guarantees while facilitating scalable FL. Furthermore, the literature indicates a growing trend in hybrid architectures where edge devices conduct initial data processing before securely transmitting results to cloud nodes for aggregation. This approach enhances privacy and reduces communication latency. Future research is advancing toward sophisticated paradigms such as serverless machine learning, where infrastructure management is fully abstracted and ML models scale automatically based on real-time demand. Other promising directions include the integration of quantum computing for accelerated ML workloads, AutoML frameworks embedded within cloud platforms for automated model tuning, and specialized hardware accelerators (such as GPUs and TPUs) optimized for distributed training. Comprehensive reviews, such as those by Lee & Wang (2024), envision a future where intelligent, secure, and energy-efficient distributed learning systems will become the norm, driven by advances in both theory and technology.

In Table 5 shows the enhanced meta-analysis table offers a comprehensive synthesis of recent studies on FL, cloud-edge collaboration, and adaptive techniques, elucidating both advancements and persistent challenges. Key findings indicate that while FL effectively preserves privacy and reduces communication overhead, it encounters difficulties with non-IID data and latency issues. Cloud-based approaches enhance scalability but raise privacy concerns, whereas edge computing facilitates low-latency processing but is constrained by device capability and bandwidth. Hybrid adaptive learning framework (HALF) emerges as a promising framework, addressing these gaps through adaptive aggregation, dynamic optimization, and cloud-edge integration. Despite demonstrating improved communication efficiency, model accuracy, and applicability in healthcare and autonomous systems, HALF still necessitates real-world validation and optimized resource management. Limitations across studies include high computational complexity, privacy-accuracy tradeoffs, and reliance on robust cloud infrastructure, suggesting that future research should focus on lightweight models, privacy-preserving mechanisms, and real-time adaptability for dynamic environments. The meta-analysis demonstrates that FL frameworks derive considerable benefits from privacy-preserving strategies like differential privacy and secure aggregation, albeit often at the expense of model precision. The integration of cloud and edge computing enhances scalability but can introduce latency, underscoring the necessity for real-time optimization. HALF addresses this issue by implementing adaptive aggregation methods that adeptly manage non-IID data and enable real-time, low-latency processing in dynamic environments such as autonomous systems. Despite these advancements, numerous studies still lack comprehensive real-world validation, large-scale scalability assessments, and energy-efficiency evaluations. The HALF framework offers a unique, adaptive architecture that effectively balances privacy, scalability, and latency, establishing it as a transformative solution within the FL ecosystem.

This study utilized a combination of quantitative and qualitative approaches to comprehensively evaluate the HALF framework. The research is divided into three phases: the exploratory phase, which involves a literature review and theoretical analysis to identify key challenges in FL and the potential of HALF to address them; the experimental phase, which includes quantitative experiments to measure HALF’s performance in terms of privacy preservation, communication efficiency, and model accuracy; and the Validation Phase, which employs qualitative methods, such as expert interviews and case studies, to assess HALF’s real-world applicability in sectors such as healthcare, smart cities, and autonomous systems. This design ensures a comprehensive understanding of the HALF by combining empirical data with theoretical insights.

The sampling strategy was tailored to the objectives of this study. For quantitative sampling, a sample of 50 edge devices (e.g., IoT sensors and smartphones) was selected to simulate real-world conditions, and publicly available datasets (e.g., CIFAR-10, MNIST, and synthetic non-IID datasets) were used for model training and evaluation. For qualitative sampling, a purposive sample of 10 experts in FL, cloud computing, and edge computing was selected for semi-structured interviews, and three case studies were conducted in healthcare, smart cities, and autonomous systems to validate HALF’s real-world applicability of HALF [16]. Data collection methods include simulation experiments to measure HALF performance metrics (e.g., latency, bandwidth utilization, accuracy, and benchmarking) in order to compare HALF with traditional FL frameworks. Qualitative data can be obtained through expert reviews and case studies to provide insight into HALF’s strengths, weaknesses, and potential improvements of HALF.

Quantitative data were analyzed using statistical analysis (e.g., mean and standard deviation) and comparative analysis (e.g., to assess HALF’s performance against traditional FL frameworks). Qualitative data were analyzed through theme analysis to identify recurring themes and content analysis to categorize insights from interviews and case studies. Ethical considerations included safeguarding privacy and confidentiality by anonymizing data, obtaining informed consent from participants, and obtaining data through encryption and restricted access. These measures ensured the ethical integrity of the study while safeguarding participants’ rights and data.

This study has several limitations, such as the inability of a simulated environment to fully replicate real-world conditions, a small sample size for qualitative interviews, and resource constraints that may limit the scale of experiments. The study focuses on HALF’s applications in healthcare, smart cities, and autonomous systems, excluding other potential use cases and the limited period for data collection and analysis. Despite these limitations, the methodology provides a robust framework for assessing HALF by combining quantitative and qualitative approaches to ensure comprehensive analysis. By addressing ethical considerations and acknowledging limitations, this study ensures the credibility and reliability of its findings, resulting in the development of secure, scalable, and efficient distributed machine-learning systems.

Figure 5 illustrates the architecture of the HALF framework, including its layered structure and intercomponent interactions. The Edge Computing Layer utilizes localized model optimization, confidential data processing, and adaptive resource allocation at the edge devices. The edge gateway layer is an intermediary, facilitating distributed model integration, optimizing data transfer, and performing edge-level processing [17]. The Cloud Integration Layer interacts with the cloud to manage global algorithm updates, performance analytics, and threat governance. Finally, the Core System Interaction Layer facilitates the progressive learning model development and real-time model enhancement. This layered approach allows HALF to effectively balance edge autonomy and cloud coordination, thereby enabling efficient and secure collaborative machine learning across distributed edge devices and clouds.

Figure 5:

HALF framework. HALF Framework, High-performance adaptive learning framework.

In Table 6 shows the hybrid adaptive learning framework (HALF) framework presents an innovative integration of adaptive device selection and system-aware federated orchestration, distinguishing it markedly from existing FL architectures. In contrast to conventional methods that allocate training tasks statically, HALF dynamically evaluates each edge device’s computational capacity—assessing CPU availability, memory load, battery life, and network bandwidth—before permitting participation in a training round. This real-time resource profiling ensures that only capable devices engage in local training, thereby minimizing energy consumption and enhancing system-wide efficiency. By continuously optimizing device involvement in learning and balancing workloads accordingly, HALF achieves robust fault tolerance and operational scalability in heterogeneous environments, such as IoT networks and mobile systems. Furthermore, the framework employs a Dirichlet-distribution-based non-IID partitioning scheme, simulating highly skewed data scenarios that reflect real-world edge device environments. Unlike existing studies that often overlook the operational challenges posed by non-IID distributions, this research uniquely combines non-IID simulation with a dynamic privacy budgeting mechanism. Each communication round is monitored to ensure that cumulative privacy loss (ε) does not exceed a predefined threshold, introducing a context-aware tradeoff between privacy guarantees and model utility. This continuous privacy auditing is coupled with calibrated noise injection, where the level of differential privacy noise scales with data sensitivity and device communication frequency, offering a fine-grained control mechanism that dynamically balances privacy and accuracy—a novel approach not widely implemented in current FL systems. The HALF framework also innovates through its hybrid aggregation technique, which extends traditional FedAvg by incorporating a resource-weighted contribution model. This technique considers not only the size of local data but also integrates a reputation score based on device reliability and prior participation success. Combined with secure model checkpointing and automated rollback mechanisms, this feature ensures that unstable or low-quality updates do not compromise the global model. By assigning differential influence to clients based on both quality and trustworthiness, HALF creates a more resilient and fault-tolerant learning pipeline. This aspect of hybrid aggregation, integrating performance-based weighting and cryptographic integrity checks, adds a security-conscious layer to the FL process, enhancing both robustness and convergence stability. Finally, this study transcends conventional FL evaluation by incorporating a multi-dimensional validation strategy. HALF is assessed not only through quantitative simulations but also via cross-sectoral case studies and expert interviews in domains such as healthcare, smart cities, and autonomous systems. These qualitative insights enable the framework to be examined through the lens of regulatory compliance, infrastructure diversity, and operational deployment, offering a more realistic and deployable perspective. Additionally, penetration testing and attack simulations are employed to estimate exposure risks, a methodological feature rarely integrated into FL performance analyses. By bridging technical performance metrics with real-world implementation conditions, the HALF framework emerges as a context-sensitive, privacy-resilient, and deployment-ready FL solution tailored for critical, data-sensitive domains.

The experimental setup for the HALF framework, as summarized in Table 1, involves training on non-IID MNIST and CIFAR-10 datasets using 50 edge devices with local epochs set to 10 and 100 global communication rounds. Key configurations include differential privacy via DP-SGD (ε ≤ 2.3), weighted FedAvg for aggregation, and secure communication using TLS 1.3 with AES-256 and SHA-256. The system targets ≥89.7% model accuracy and achieves ≥40% communication overhead reduction within ≤142 min of training time. It operates on modest edge hardware (≥2 GB RAM, 1.5 GHz CPU) and robust cloud infrastructure, evaluated using metrics such as accuracy, loss, resource usage, and privacy exposure within an emulated 5 G/Wi-Fi environment.

The initialization phase establishes the foundational infrastructure and protocols necessary to launch a secure, privately aware FL ecosystem. It begins with the system setup, where the global machine learning model architecture is defined (e.g., neural network layers and activation functions), and hyperparameters such as learning rate, batch size, and optimization algorithms (e.g., Adam, SGD) are configured [20]. Secure communication protocols (e.g., HTTP/2 and MQTT) are implemented to regulate interactions between edge devices and the cloud, while X.509 certificates and AES-256 encryption keys are employed to authenticate devices and encrypt data. During device registration, edge devices undergo biometric or hardware-based authentication, and their capabilities (e.g., GPU support and RAM capacity) are determined to determine their suitability for training purposes. Network topology mapping optimizes data routing by identifying device locations and connection pathways, whereas initial resource profiling captures the baseline metrics for CPU, memory, and battery usage. The privacy framework is then activated, allocating a differential privacy budget (ε = 2.0) to limit data exposure risk. Noise injection mechanisms (e.g., Gaussian or Laplace noise) are calibrated to protect updates, and secure communication channels (TLS 1.3), and HE protocols are used to ensure end-to-end privacy during data transmission and processing [21].

This phase identifies and prioritizes edge devices suitable for training tasks while balancing resource constraints. Active device detection involves real-time monitoring of device availability through periodic pings and latency checks <100 ms), coupled with health assessments to verify OS stability and firmware compliance [22]. Devices that failed to meet the eligibility criteria (e.g., outdated software and GDPR non-compliance) were excluded. During resource assessment, devices were filtered based on predefined thresholds: only those with ≥62.4% available CPU, ≤48.7% of memory utilization, 20% battery life, and 1 Mbps network bandwidth were selected. Task distribution employs workload-balancing algorithms (e.g., round-robin and least-connections) to allocate training tasks effectively, prioritizing high-resource devices for critical updates. Priority queues manage urgent tasks, whereas failover mechanisms reroute workloads to backup devices if failures occur during training, ensuring non-stop operations.

The Training Phase executes localized model updates on edge devices, while enforcing strict privacy guarantees. Edge processing started with local dataset preparation, where the on-device data were normalized, sanitized, and split into mini-batches of 32 samples. The devices trained the model for 10 epochs using gradient clipping (max norm = 1.0) to prevent explosive gradients, followed by DP-SGD to generate privacy-preserving updates [23]. In parallel, cloud processing aggregates encrypted updates from devices via FedAvg, merges them into a global model, and optimizes the parameters using stochastic optimization techniques. The updated model is then distributed to devices via content delivery networks (CDNs) or peer-to-peer networks. Privacy preservation is maintained through dynamic noise calibration (scaling noise based on data sensitivity) and strict tracking of the privacy budget (ε ≤ 2.3) to prevent a cumulative leakage. Secure aggregation protocols ensure that raw data never leaves devices, whereas encrypted channels shield updates during transmission.

This phase transforms the device updates into a cohesive global model while ensuring integrity and stability. Update collection involves gathering encrypted updates from devices, verifying their integrity through SHA-256 hashes to detect tampering, and decompressing them using algorithms such as LZ4 or Zstandard. During weighted aggregation, contributions are assigned weights based on device resource availability and data quality, ensuring that high-performance devices can significantly influence the global model [24]. The updates were normalized to maintain numerical stability and merged into a unified model. Model integration applies aggregated updates to the global model, managed through version control systems (e.g., Git-like tagging) to track iterations. Checkpoints are created at defined intervals, and automated rollback mechanisms return to stable versions if the precision falls below 85%, thereby ensuring system resilience.

The final phase assesses the framework’s performance, efficiency, and compliance with privacy standards. The performance assessment measures accuracy (target ≥89.7%, cross-entropy loss, and convergence rates), ensuring that the training is completed within 142 min [25]. Resource efficiency is evaluated by tracking the communication overhead (reduced by ≥40% via compression), energy consumption (≤53.2% of baseline), and memory utilization (≤48.7%). Privacy analysis audits the cumulative privacy budget (ε ≤ 2.3), simulates attack scenarios to validate a ≤ 0.12 data exposure risk, and verifies compliance with regulations such as GDPR and HIPAA. Penetration testing identifies vulnerabilities in the attack surface, whereas real-time monitoring tools (e.g., Prometheus and SIEM systems) monitor anomalies and enforce security policies.

The HALF framework requires edge devices with 2 GB RAM and 1.5 GHz CPUs, cloud servers with 16 GB RAM and 8-core processors, and 5 G/Wi-Fi networks (10 Mbps) with edge devices. The software stack includes Python 3.8+, PyTorch/TensorFlow, OpenSSL, and privacy toolkits, such as TensorFlow Privacy. Security relies on TLS 1.3, secure enclaves (e.g., Intel SGX and end-to-end encryption). Success was quantified using performance metrics (accuracy ≥89.7%, training time ≤142 min), resource efficiency (CPU/memory reduction ≥37.6%/48.7%), and privacy metrics (ε ≤ 2.3, attack prevention ≥98.2%). Together, these phases create a resilient and adaptive cybersecurity architecture that enhances AI-driven insights with quantum-ready privacy safeguards.

Inputs

Device Configuration, Training Data, Model Configuration, Privacy Settings

Outputs

Training Metrics, Device Performance, Model Updates, Performance Summary, System Logs

• 1.   Global Parameters

• 2.   Class_GlobalParameters:

• 3.   E = 10     # Number of local epochs

• 4.   B = 32     # Batch size

• 5.   η = 0.01     # Learning rate

• 6.   τ = 0.8     # Communication threshold

• 7.   ε = 2.0     # Privacy budget

• 8.   R = 100     # Maximum rounds

• 9.   K = 50     # Number of edge devices

• 10.   Main HALF Algorithm

• 11.   def HALF_Framework():

• 12.   Initialize

• 13.   global_model = initialize_model()

• 14.   edge_devices = initialize_edge_devices(K)

• 15.   cloud_server = initialize_cloud_server()

• 16.   for round in range(R):

• 17.   Device Selection and Resource Assessment

• 18.   active_devices = select_active_devices(edge_devices)

• 19.   device_resources = assess_resources(active_devices)

• 20.   Adaptive Task Allocation

• 21.   for device in active_devices:

• 22.   if device_resources[device] >= τ:

• 23.   Edge Processing

• 24.   local_training(device, global_model)

• 25.   else:

• 26.   Cloud Offloading

• 27.   cloud_training(device, cloud_server)

• 28.   Privacy-Preserving Model Updates

• 29.   aggregated_updates = []

• 30.   for device in active_devices:

• 31.   Apply differential privacy

• 32.   noisy_update = apply_differential_privacy(device.local_update, ε)

• 33.   aggregated_updates. append(noisy_update)

• 34.   Hybrid Model Aggregation

• 35.   global_model = hybrid_aggregation(aggregated_updates, device_resources)

• 36.   Convergence Check

• 37.   if check_convergence(global_model):

• 38.   break

• 39.   return global_model

• 40.   Device Selection and Resource Assessment

• 41.   def select_active_devices(devices):

• 42.   active_devices = []

• 43.   for device in devices:

• 44.   if device.is_available():

• 45.   active_devices. append(device)

• 46.   return active_devices

• 47.   def assess_resources(devices):

• 48.   resources = {}

• 49.   for device in devices:

• 50.   cpu = device.get_cpu_availability()

• 51.   memory = device.get_memory_availability()

• 52.   battery = device.get_battery_level()

• 53.   network = device.get_network_quality()

• 54.   Compute resource score

• 55.   resource_score = compute_resource_score(cpu, memory, battery, network)

• 56.   resources[device] = resource_score

• 57.   return resources

• 58.   Local Training Process

• 59.   def local_training(device, global_model):

• 60.   local_model = global_model.copy()

• 61.   local_data = device.get_local_data()

• 62.   for epoch in range(E):

• 63.   for batch in create_batches(local_data, B):

• 64.   Update local model

• 65.   gradients = compute_gradients(local_model, batch)

• 66.   local_model = update_model(local_model, gradients, η)

• 67.   return local_model

• 68.   Cloud Training Process

• 69.   def cloud_training(device, cloud_server):

• 70.   Secure data transfer to cloud

• 71.   encrypted_data = encrypt_data(device.get_local_data())

• 72.   cloud_server. receive data(encrypted_data)

• 73.   Cloud-based training

• 74.   cloud_model = cloud_server.train_model (encrypted_data)

• 75.   return cloud_model

• 76.   Privacy-Preserving Mechanisms

• 77.   def apply_differential_privacy(model_update, privacy_budget):

• 78.   Add calibrated noise to model updates

• 79.   sensitivity = compute_sensitivity(model_update)

• 80.   noise_scale = sensitivity / privacy_budget

• 81.   noisy_update = add_gaussian_noise(model_update, noise_scale)

• 82.   return noisy_update

• 83.   Hybrid Aggregation Strategy

• 84.   def hybrid_aggregation(updates, resources):

• 85.   aggregated_model = {}

• 86.   weights = compute_adaptive_weights (resources)

• 87.   for layer in model_layers:

• 88.   layer_updates = []

• 89.   for update, weight in zip (updates, weights):

• 90.   weighted_update = update[layer] * weight

• 91.   layer_updates. append(weighted_update)

• 92.   Aggregate layer updates

• 93.   aggregated_model[layer] = sum(layer_updates)

• 94.   return aggregated_model

• 95.   Convergence Check

• 96.   def check_convergence(global_model):

• 97.   accuracy = evaluate_model(global_model)

• 98.   delta = compute_improvement(accuracy)

• 99.   if delta < convergence_threshold:

• 100.  return True

• 101.  return False

• 102.  Utility Functions

• 103.  def compute_resource_score(cpu, memory, battery, network):

• 104.  Weighted scoring of device resources

• 105.  score = (0.3 * cpu + 0.2 * memory +

• 106.  0.2 * battery + 0.3 * network)

• 107.  return score

• 108.  def compute_adaptive_weights(resources):

• 109.  total_resources = sum(resources.values())

• 110.  weights = [r/total_resources for r in resources, values ()],

• 111.  return weights

• 112.  def create_batches(data, batch_size):

• 113.  Create mini batches from local data

• 114.  batches = []

• 115.  for i in the range (0, len(data), batch_size).

• 116.  batch = data[i:i + batch_size]

• 117.  batches. append(batch)

• 118.  return batches

The hybrid adaptive learning framework (HALF) framework is a privacy-aware distributed machine learning approach that optimizes resource utilization and convergence efficiency across edge and cloud environments [26]. The framework begins by initializing a global model and selecting active edge devices based on availability, followed by a resource assessment that determines CPU, memory, battery, and network conditions. Using a communication threshold (τ), devices with sufficient resources perform local training with configurable epochs (E), batch size (B), and learning rate (η), whereas resource-constrained devices offload the encrypted data to the cloud for secure training. Local and cloud-derived model updates are protected through differential privacy, where Gaussian noise is scaled by a privacy budget () and update sensitivity is applied to mitigate data leakage [27]. A hybrid aggregation strategy then incorporates these updates using adaptive weights proportional to the device resource scores, ensuring that the contributions from more capable devices are prioritized. The global model utilized a maximum of R rounds, with convergence checked by accuracy improvements against a predefined threshold. Key innovations include dynamic edge-cloud task allocation, resource-aware device weighting, and privacy-preserving mechanisms, all of which are aimed at balancing computational efficiency, scalability (across K devices), and data confidentiality in heterogeneous IoT environments. The framework provides training metrics, performance summaries, and system logs, enabling robust distributed learning while allowing diverse edge-device constraints [28].

Figure 6 shows the HALF Framework Implementation process. The HALF framework’s implementation is centered on three fundamental components: Experimental Design, Performance Indicators, and Comparative Review. The objective of Experimental Design is to create a controlled and robust testing environment. This involves using an Emulation Platform to replicate real-world scenarios, establishing the IoT Device Network and setting up individual devices, considering Operational Constraints such as resource limitations, employing Adaptive Bandwidth allocation, and specifying Network Topologies for optimized communication. These elements ensure thorough testing of the framework under realistic conditions, enabling accurate evaluation and improvement.

Figure 6:

HALF framework implementation process. HALF Framework, High-performance adaptive learning framework; IoT, Internet of things.

Performance indicators serve as indicators to gauge the success of the HALF framework. These metrics encompass various aspects, including predictive performance (model accuracy and effectiveness), effective analysis (framework efficiency and scalability), bandwidth utilization and network throughput (communication resource optimization), data confidentiality and confidential risk (data security and privacy), data visualization (data flow monitoring and analysis), and system analytics (overall performance monitoring). By evaluating these indicators, the framework’s performance can be quantitatively assessed and areas for enhancement identified.

The Comparative Review component examines the HALF framework by combining it with existing approaches. This involves benchmarking against Virtualized Learning and Conventional Models, comparing it with other Edge Optimized Learning and FL frameworks, assessing performance in hybrid system environments, and conducting a direct self-evaluation of HALF framework performance. This comparative analysis examines the strengths and weaknesses of the HALF framework in relation to state-of-the-art approaches, highlighting its contributions and demonstrating its potential impact. These three interconnected areas experimental design, performance indicators, and comparative review, provide the HALF framework’s implementation.

Figure 14 compares the resource utilization of the comparison between the HALF framework and traditional FL, revealing a significant advantage for the HALF framework in terms of efficiency and sustainability. The chart shows that traditional FL (represented by purple bars) has much higher resource consumption across all measured categories, including CPU usage, memory, energy, and bandwidth. This indicates that traditional FL is computationally intensive and requires greater memory, greater power consumption, and greater network capacity. By contrast, the HALF framework, depicted by the green bars, demonstrates a significant reduction in resource utilization across these key metrics. The HALF framework’s optimized architecture and efficient resource management enable it to operate with far fewer computational resources, making it more efficient and environmentally friendly owing to its lower energy consumption. In addition, its reduced bandwidth requirements make it suitable for environments with limited network capabilities. The improved resource efficiency enhances the capacity of the HALF framework for scalable, sustainable, and cost-effective deployment, particularly in resource-constrained environments. The reduced resource load does not compromise the ability to safeguard privacy, which is a key feature of the HALF framework. The HALF framework offers a more practical solution for large-scale AI applications by striking a balance between privacy protection and optimized resource consumption, particularly in decentralized settings, where both high performance and low resource consumption are critical. This makes the HALF framework more efficient, sustainable, and viable for FL, particularly in real-world deployments where resources are limited.

Figure 14:

Comparison of tradition FL & HALF. FL, federated learning.

Figure 15 shows that the HALF framework demonstrates remarkable versatility and effectiveness across various application domains, as demonstrated by its high implementation success rate. The data highlight the framework’s successful deployment in three major sectors: health care, smart cities, and autonomous systems. In the Healthcare sector, the HALF framework has achieved an impressive 92% success rate, highlighting its potential for secure and privacy-preserving data analysis in sensitive medical environments. In Smart City initiatives, the framework achieved an 88% success rate, resulting in its ability to handle the complexities of large-scale decentralized data processing essential for urban systems. The autonomous systems sector achieved the highest success rate of 94%, indicating the robustness and reliability of the framework in real-time decision-making scenarios where data security and privacy are crucial. These consistently high success rates across various application areas highlight the adaptability and effectiveness of the HALF framework as a privacy-preserving FL approach capable of constructing scalable and secure AI applications. Robust performance across these key sectors demonstrates the broad impact of the framework and its potential to lead innovation in multiple industries.

Figure 15:

Evaluation of the HALF framework success rates. HALF Framework, High-performance adaptive learning framework.

Key Performance Highlights

• Overall accuracy improvement: 7.4%

• Average resource utilization reduction: 45.45%

• Average implementation success rate: 91.3%