Hierarchical Federated Learning (HFL) has emerged as a popular federated learning method by introducing additional aggregation levels using intermediate edge servers. The performance of HFL approaches is contingent upon the aggregation frequency and the number of intermediate aggregation rounds. Existing approaches mainly focus on optimizing the aggregation frequency only, neglecting the impact of intermediate aggregation rounds on training performance. On the other hand, these methods also fail to consider the multidimensional effects of aggregation frequency, consequently focusing only on the performance accuracy while overlooking the detrimental effects on both the communication costs and training latency. This paper introduces HFL-PBRL, a novel HFL framework that employs a bi-level reinforcement learning (RL)-based algorithm to jointly optimize aggregation frequencies and rounds across edge servers. This algorithm is accompanied by a Pareto-efficient multi-objective optimization approach to strike an optimal trade-off among model accuracy, communication cost and convergence time. The varied aggregation frequencies and rounds might introduce inconsistencies; therefore, we employ a hierarchical pullback mechanism that iteratively pulls the client models toward a synchronized anchor model, ensuring effective divergence control. Furthermore, we devise a harmonic weight assignment strategy that dynamically adjusts the aggregation weights of each model based on their current, historical, and anticipated divergence, addressing the model fluctuations and asynchrony. Extensive evaluations demonstrate that HFL-PBRL consistently achieves high model accuracy and faster convergence with minimal communication costs compared to baselines and SOTA.

Federated learning (FL) enables collaborative model training across multiple clients while preserving privacy. In practical situations, the heterogeneous and unbalanced distribution of the data has a significant impact on the performance of the model. Although some work has been carried out to address this issue, such as adding regularization terms, employing specific server aggregation strategies, and utilizing deep generative models to augment the training data, there is still a lack of efficient approaches to derive intrinsic representation of the local data to improve the global model without compromising client privacy. Through our careful observations and analysis, we found that incorporating pre-training and calibrating of the global model using virtual data and virtual features that are generated based on the client data distribution can improve model generalization. In this work, we propose Virtual Data Augmented Federated Learning (FedVDA) to resolve this problem. Specifically, FedVDA combines unsupervised pre-training with Augmented Fractal (AF) virtual images and Gaussian Mixture Model (GMM) virtual feature calibration. By integrating color tone transformations into the virtual data generated by fractals, we bridge the gap between virtual and client data distributions. Multi-modal feature modeling using variances on each client allows the server to efficiently calibrate the classifier with balanced sampled virtual features, reducing both computational and communication overhead. Compared to other data augmentation methods, our method directly calibrates model features, significantly improving model performance in scenarios with data heterogeneity and imbalance, while minimizing additional computational and communication costs. Our experiments demonstrate that FedVDA outperforms existing federated learning methods and can seamlessly integrate with other algorithms.

Federated learning (FL) is a distributed machine learning framework where multiple clients collaboratively train a model without sharing their data. Despite advancements, traditional FL methods encounter challenges including communication overhead, extended latency, and slow convergence. To address these issues, this paper introduces Anchor-HHFL, a novel approach that combines the strengths of synchronous and asynchronous FL. Anchor-HHFL employs multi-tier edge servers which conduct partial model aggregation and reduce the frequency of communication with the central server. Anchor-HHFL implements a novel divergence control method through hierarchical pullback. It orchestrates the sequence of each client's stochastic gradient descent (SGD) updates to pull the locally trained models towards an anchor model, ensuring alignment and minimizing divergence. Simultaneously, a secondary process collects client models without disrupting their ongoing local computations and transmits them to edge servers, thereby overlapping computation with communication, substantially enhancing the training speed. Additionally, to effectively handle asynchronous updates across clusters, Anchor-HHFL uses a heuristic weight assignment for global aggregation, weighting clients’ updates based on the degree of their divergence from the global model. Extensive experiments on MNIST and CIFAR-10 datasets demonstrate Anchor-HHFL's superiority, achieving up to$3 \times$faster convergence and higher test accuracy compared to the baselines.

Federated Learning is particularly challenging in IoT environments, where edge and cloud nodes have imbalanced computation capacity and networking bandwidth. The main scalability barrier in distributed stochastic gradient descent-based machine learning frameworks is the communication overhead from frequent model parameter exchanges between workers and the central server. One way to reduce this overhead is by employing constant and periodic averaging, which sends model parameters to the server after a few iterations of local updates from workers. However, investigations have shown that the optimal communication period for balancing communication and convergence is not constant. Although some studies have explored the effectiveness of federated learning with a constant period, dynamically adjusting the period for optimal convergence remains under-explored. To address this, we investigate the impact of the period on global model convergence and propose an adaptive period control mechanism (AdaPC). This mechanism adaptively adjusts the aggregation period of the federated learning framework to achieve fast convergence with minimal communication. Our theoretical and empirical findings demonstrate that our proposed solution achieves faster convergence, lower final training loss, and minimized communication overhead compared to the constant period averaging strategy and other existing solutions.

We address privacy and latency issues in edge-cloud computing environments where the neural network training is centralized. This paper considers the scenario where the edge devices are the only data sources for the deep learning model to be trained on the central server. Improper access to the massive amounts of data generated by edge devices could lead to privacy concerns. As a result, existing solutions for preserving privacy and reducing network latency in the edge environment rely on auxiliary datasets with no privacy risks or pre-trained models to build the client side feature extractor. However, finding auxiliary datasets or pre-trained models is not always guaranteed and may be challenging. To bridge this gap and eliminate the reliance on auxiliary datasets or pre-trained models of existing solutions, this paper presents DeepGuess, a privacy-preserving and latency-aware deep-learning framework. DeepGuess introduces a new learning mechanism enabled by the AutoEncoder architecture: inductive learning. With inductive learning, sensitive data stays on devices and is not explicitly sent to the central server to engage in back-propagations. To further enhance privacy, we propose a new local differential privacy algorithm that allows edge devices to apply random noise to features extracted from their sensitive data before being transferred to the non-trusted central server. The experimental evaluation of DeepGuess with various datasets and in a real-world scenario shows that our solution achieves comparable or even higher accuracy than existing solutions while reducing data transfer over the network by more than 50%.

Edge intelligence is an emerging technology that integrates edge computing and deep learning to bring AI to the network’s edge. It has gained wide attention for its lower network latency and better privacy preservation abilities. However, the inference of deep neural networks is computationally demanding and results in poor real-time performance, making it challenging for resource-constrained edge devices. In this paper, we propose a hierarchical deep learning model based on TreeNet to reduce the computational cost for edge devices. Based on the similarity of the classification categories, we decompose a given task into disjoint sub-tasks to reduce the complexity of the required model. Then a lightweight binary classifier is proposed for evaluating the sub-task inference result. If the inference result of a sub-task is unreliable, our system will forward the input samples to the cloud server for further processing. We also proposed a new strategy for finding and sharing common features across sub-tasks to improve training speed and accuracy. The experimental results on several popular datasets demonstrate the effectiveness of our approach in speeding up inferences while processing most of the input data with a low error rate.

Edge computing has recently evolved that offers to execute jobs efficiently by pushing cloud capabilities to edge of the network, this improves the quality of services to latency-oriented Internet of Things (IoT) applications when compared with cloud computing. By using current smart devices as edge nodes, edge computing can provide elastic resources that allow distributed data processing in a decentralized way. Still these smart devices are resource constrained in nature and tends to face a high failure rate than traditional distributed systems, the implementation of a fault-tolerant system that ensures the reliability and application availability becomes a key requirement. In this article, we propose a fault-tolerance methodology based on checkpointing and replication for the edge computing. Our proposed system uses a smart checkpointing for the IoT application tasks executing in a distributed edge network, and by replicating the checkpoint files on alternative edge nodes in the vicinity allowed to increase the system reliability. The experimental results show that our approach is effective in terms of reliability and availability of tasks executing in the edge network along with meeting deadlines of an IoT application.

Given the limited bandwidth available in distributed camera systems, it is nearly impossible for cameras to transmit their entire feed to the server in real time. Furthermore, as the number of camera units increases, the processing overheads on the server also increase, resulting in excessive latencies. This article introduces SmartFilter, a new Edge-to-Cloud filtering solution for video analytics. SmartFilter exploits the feedbacks from the running server-side application to filter directly on the camera, frames that are likely to produce the same application result as the previously offloaded ones. Because of its unique filtering mechanism, SmartFilter improves the system’s throughput, latency, and network usage and reduces the server’s processing overhead while maintaining the overall accuracy. SmartFilter is typically a fast and lightweight binary classifier that examines changes within frames to decide when these changes are significant enough to alter the application output. Experiments with various video data sets and in a real-world scenario demonstrate that our solution can achieve 40 FPS on a commodity camera while delivering a filtering efficiency of more than 90%.

Different from the existing train delay studies that had strived to explore sophisticated algorithms, this paper focuses on finding the bound of improvements on predicting multi-scenario train delays with different machine learning methods. Motivated by the observation of deep learning methods failing to improve the prediction performance if the delay occurs rarely, we present a novel augmented machine learning approach to improve the overall prediction accuracy further. Our solution proposes a rule-driven automation (RDA) method, including a delay status labeling (DSL) algorithm, and the resilience of section (RSE) and resilience of station (RST) indicators to generate the forecast for train delays. The experiment results demonstrate that the Random Forest based implementation of our RDA method (RF-RDA) can significantly improve the generalization ability of multivariate multi-step forecast models for multi-scenario train delay prediction. The proposed solution surpasses state-of-art baselines based on real-world traffic datasets, which treat various real-time delays differently. Even when the predictability of conventional deep learning methods decreases, the performance of our method is still acceptable for practical use to provide accurate forecasts.

Deep learning has achieved remarkable successes in various areas such as computer vision and natural language processing. Many sophisticated models have been proposed to improve performance by designing a significant number of layers of neurons. As an emerging research area, edge intelligence tries to bring intelligence to the network edge by integrating edge computing and AI technologies and it has gained wide attention for its lower latency and better privacy preservation features. Nevertheless, training and inferencing deep neural networks require intensive computation power and time, making it quite challenging to run the models on the resource-constrained edge devices. In this paper, we propose a deep learning model, namely TreeNet, based on task decomposition. After obtaining a task, we would not fit the entire task but decompose the task into disjoint sub-tasks to reduce the complexity of the required deep learning model (it could be divided multiple times if necessary). We first fit the original dataset mapping to different sub-tasks and then fit the mapping of each sub-task to the category of the original dataset that it contains. During the running of the model, we dynamically call the low-level classifier based on the inference result of the high-level classifier. When the inference result of the high-level classifier is unreliable, we send the input sample to the cloud server for processing. We use several popular datasets to study the TreeNet architecture and show that it can process most of the input data while achieving high inference accuracy and significantly decreasing the total amount of calculation.

The Internet of Vehicles (IoV) is one important application scenarios for the development of the Internet of things. The software-defined network (SDN) and fog computing could effectively improve the IoV network dynamics, which enables the application to achieve better performance by offloading some tasks to fog node or cloud center. Current computation offloading approaches for IoV and fog computing mostly focus on resource utilization. However, the energy-aware offloading has not been adequately addressed, especially for IoV systems with many battery-powered roadside units (RSU) and electric vehicles (EV). In this paper, we study the offloading problem in SDN and fog computing-based IoV systems. An energy-aware dynamic offloading scheme is proposed to prolong the running time of the IoV system by leveraging available battery power to execute more applications. The remaining battery power is defined as a dynamic weight factor in the execution cost model to adjust the optimization objective. Meanwhile, the dependence between applications is also taken into consideration in the cost model. A heuristic optimization algorithm is designed to solve the optimization problem. We conducted comprehensive experiments and results have shown that the offloading scheme could execute more applications with the available battery power under the constraints of application dependence.

Big Data has shown lots of potential in numerous domain and becomes one of the emerging technologies that are bringing revolution in some real world industry. It has the power to provide insights into the unseen aspects of immense volume of data. Some applications are processing the data using a store-then-process paradigm, whereas other applications, like telecommunications and large-scale sensor networks, have to analyze continuous data flow online. Stream Processing Engines(SPEs) are designed to support applications which require timely analysis of high volume data streams. The dynamic nature of data stream requires SPEs to have high scalability. However, current SPEs mostly adopt a static configuration and can not scale out/in flexibly along with the changing of the data stream. In this paper, we proposed a fuzzy logic based runtime bottleneck operator detection approach to improve the scalability of SPEs by providing resources in the cloud environment. Our experimental results show that the fuzzy logic component developed in this work could detect bottleneck operators efficiently. Compared with other bottleneck detection methods, the decision results generated by our approach is more flexible and will not scale out/in the system when the workload change instantly.

Big data processing is receiving significant amount of interest as an important technology to reveal the information behind the data, such as trends, characteristics, etc. MapReduce is considered as the most efficient distributed parallel data processing framework. However, some high-end applications, especially some scientific analyses have both data-intensive and computation-intensive features. Current big data processing techniques like Hadoop are not designed for computation-intensive applications, thus have insufficient computation power. In this paper, we presented Lit, a high performance massive data computing framework based on CPU/GPU cluster. Lit integrated GPU with Hadoop to improve the computational power of each node in the cluster. Since the architecture and programming model of GPU is different from CPU, Lit provided an annotation based approach to automatically generate CUDA codes from Hadoop codes. Lit hided the complexity of programming on CPU/GPU cluster by providing extended compiler and optimizer. To utilize the simplified programming, scalability and fault tolerance benefits of Hadoop and combine them with the high performance computation power of GPU, Lit extended the Hadoop by applying a GPUClassloader to detect the GPU, generate and compile CUDA codes, and invoke the shared library. Our experimental results show that Lit can achieve an average speedup of 1x to 3x on three typical applications over Hadoop.

Service processes in SOA are composed dynamically by services from different service providers. At run-time, some services may become faulty and cause a service process to violate its end-to-end quality of service (QoS) constraints. We propose an effective approach for replacing only faulty services and some of their neighboring services to maintain the original end-to-end QoS constraints. We use an iterative algorithm to search for a reconfiguration region that has replaceable services to meet the original QoS constraint for the region. Services in reconfiguration regions may be replaced using one-to-one, one-to-many, or many-to-one service mappings. By replacing only services in reconfiguration regions rather than the whole service process, reconfiguration overheads are lowered and service disruptions may be reduced. We have implemented the Adaptation Manager in the Llama ESB middleware. Performance study shows that our approach may efficiently repair service processes.

In SOA, services may become volatile and fail to deliver the quality of service as requested by users. In this paper, we present an approach for repairing failed services by replacing them with new services and ensuring the new service process still meets the user specified end-to-end QoS constraints. An iterative structural inspection algorithm is designed to produce reconfiguration regions that include one or more failed service. By reconfiguring only services in the selected regions, the business process will not be affected significantly. The algorithm may also utilize those available QoS constraints to relax the original constraints of a reconfiguration region and to provide more effective reconfiguration solutions. We also present the middleware components to support the service reconfiguration in the LLAMA framework.

Process-based Web service composition is receiving significant momentum as an important strategy to allow enterprise collaboration. However the current Web service composition solutions are rather restricted and inflexible as they use a pre-defined model of the process environment. These solutions have assumed that the information in the models and consequently the compositions remain static and accurate throughout the service composition life cycle. The reflective framework presented here aims to improve the adaptability of BPEL based Web service composition. A meta-model was defined to represent the control and data flow of the composition model. To ensure the correctness of dynamic adaptation, a set of constrains and a verification algorithm were defined. A prototype adaptive service composition environment has been developed to implement our solution and demonstrate its effectiveness. In summary, it is stated that the reflective framework provides an considerable solution to the adaptive service composition without causing any control or dataflow errors.