Search

Unified Virtual Memory (UVM) relieves the developers from the onus of maintaining complex data structures and explicit data migration by enabling on-demand data movement between CPU memory and GPU memory. However, on-demand paging soon becomes a performance bottleneck of UVM due to the high latency caused by page table walks and data migration over interconnect. Prefetching is considered a promising solution to this problem given its ability to leverage the locality of program memory access patterns. However, existing locality-based prefetching schemes can not handle all the situations. An ideal prefetcher should not only look at narrow regions of the requested address space but also capture global context to deliver a good prediction of the memory access pattern. This paper proposes a novel framework for page prefetching for UVM through deep learning. We first show that a powerful Transformer learning model can provide high accuracy for UVM page prefetching. We then perform analysis to interpret this Transformer model and derive several insights that allow us to design a simpler model to match the unconstrained model's accuracy with orders of magnitude lower cost. We use a pattern-based method to make the UVM page preditor general to different GPU workloads. We evaluate this framework on a set of 11 memory-intensive benchmarks from popular benchmark suites. Our solution outperforms the state-of-the-art (SOTA) UVM framework, improving the performance by 10.89%, improving the device memory page hit rate by 16.98% (89.02% vs. 76.10% for prior art), and reducing the CPU-GPU interconnect traffic by 11.05%. According to our proposed unified metric, which combines the accuracy, coverage, and page hit rate, our solution is approaching the ideal prefetching scheme more than the SOTA design (0.90 vs. 0.85, with the perfect prefetcher of 1.0). • The first framework for CPU-GPU UVM page prefetching using deep learning. • Revealing insights about UVM prefetching to derive lightweight page predictors. • Significantly improves IPC and memory page hit rate while reducing PCI-e usage. [ABSTRACT FROM AUTHOR]

In recent years many amazing deep learning models have been developed, but in the process of practical applications, people often find that these deep learning models have high requirements for hardware storage space and computing power. In Artificial Intelligent of Things (AIoT) scenario, the computing power of the edge or terminal side are relatively limited, therefore, most conventional deep learning models are difficult to be deployed into AIoT devices. It is significant to explore the different performance under different scales of deep learning models. In this paper, we mainly propose a method to analyze the impact of deep learning models with various sizes through various experiments. We employ slimmable network as a Neural Archtecture Search (NAS) tool to realize various model size freely, and evaluate them on the indicators of flops, robustness and accuracy. The experimental results show the variation of flops, robustness and accuracy with the various model sizes, which help understand the impact on performance of deep learning models with different scales in AIoT systems. • Interpreting robustness of deep learning models with different model complexity. • Employing slimmable network to compress neural network. • Understanding the relevance between robustness and accuracy of deep learning models. [ABSTRACT FROM AUTHOR]

• AMBLE is the scheme for heterogeneous devices in federated learning. • AMBLE adjusts local mini-batch and local epoch adaptively. • AMBLE solves the straggler problem caused by system heterogeneity. • AMBLE can add more computation while waiting time caused by stragglers. • AMBLE adopts learning rate scaling to improve performance. As data privacy becomes increasingly important, federated learning applied to the training of deep learning models while ensuring the data privacy of devices is entering the spotlight. Federated learning makes it possible to process all data at once while processing data independently from various devices without collecting distributed local data in a central server. However, there are still challenges to overcome for the system of devices in federated learning such as communication overheads and the heterogeneity of the system. In this paper, we propose the Adjusting Mini-Batch and Local Epoch (AMBLE) approach, which adaptively adjusts the local mini-batch and local epoch size for heterogeneous devices in federated learning and updates the parameters synchronously. With AMBLE, we enhance the computational efficiency by removing stragglers and scaling the local learning rate to improve the model convergence rate and accuracy. We verify that federated learning with AMBLE is a stably trained model with a faster convergence speed and higher accuracy than FedAvg and adaptive batch size scheme for both identically and independently distributed (IID) and non-IID cases. [ABSTRACT FROM AUTHOR]

Malicious traffic detection is one of the most important parts of cyber security. The approaches of using the flow as the detection object are recognized as effective. Benefiting from the development of deep learning techniques, raw traffic can be directly used as a feature to detect malicious traffic. Most existing work usually converts raw traffic into images or long sequences to express a flow and then uses deep learning technology to extract features and classify them, but the generated features contain much redundant or even useless information, especially for encrypted traffic. The packet header field contains most of the packet characteristics except the payload content, and it is also an important element of the flow. In this paper, we only use the fields of the packet header in the raw traffic to construct the characteristic representation of the traffic and propose a novel flow-vector generation approach for malicious traffic detection. The preprocessed header fields are embedded as field vectors, and then a two-layer attention network is used to progressively generate the packet vectors and the flow vector containing context information. The flow vector is regarded as the abstraction of the raw traffic and is used to classify. The experiment results illustrate that the accuracy rate can reach up to 99.48% in the binary classification task and the average of AUC-ROC can reach 0.9988 in the multi-classification task. • We proposed an approach to gradually construct flow vectors from the field vector. • Extract information irrelevant to the payload from the raw traffic as input. • Unique field value representation makes the embedded vector more effective. • The adjustable number of packets in-flow makes the model more flexible. [ABSTRACT FROM AUTHOR]

Communication overhead is the key challenge for distributed training. Gradient compression is a widely used approach to reduce communication traffic. When combined with a parallel communication mechanism method like pipeline, gradient compression technique can greatly alleviate the impact of communication overhead. However, there exist two problems of gradient compression technique to be solved. Firstly, gradient compression brings in extra computation cost, which will delay the next training iteration. Secondly, gradient compression usually leads to a decrease in convergence accuracy. In this paper, we combine parallel mechanism with gradient quantization and periodic full-gradient compensation, and propose a new distributed optimization method named CP-SGD, which can hide the overhead of gradient compression, overlap part of the communication and obtain high convergence accuracy. The local update operation in CP-SGD allows the next iteration to be launched quickly without waiting for the completion of gradient compression and the current communication process. Besides, the accuracy loss caused by gradient compression is solved by k-step correction method introduced in CP-SGD, which provides a gradient correction every k iterations. We prove that CP-SGD has a convergence guarantee and it achieves at least O (1 K + 1 K) convergence rate, where K is the number of iterations. We conduct extensive experiments on MXNet to verify the convergence properties and scaling performance of CP-SGD. Experimental results on a 32-GPU cluster show that convergence accuracy of CP-SGD is close to or even slightly better than that of S-SGD, and its end-to-end time is 30% less than 2-bit gradient compression under a 56Gbps bandwidth environment. In addition, we analyze the performance of CP-SGD when training on 8, 16 and 32 GPUs. It is found that CP-SGD is suitable for most compression-supported update algorithms, and its scalability is approximately linear. • CP-SGD: Distributed Stochastic Gradient Descent with Compression and Periodic Compensation. • CP-SGD help distributed deep learning train with high-accuracy and friendly-communication simultaneously. • Combining the advantages of parallel mechanism and gradient compression. • K-step correction technique makes CP-SGD achieve codesign optimizations and improve compression-based methods greatly. • CP-SGD suits most compression-supported update algorithms and gradient compression strategies. [ABSTRACT FROM AUTHOR]

Edge computing has been considered as a leading paradigm to satisfy the low latency demand for some computation-intensive or data-intensive applications, especially for IIoT applications such as automatic line scheduling of the Internet of Vehicles, time-sensitive supply-chain supervision, and smart control of complex industrial processes. In the edge computing environment, app vendors prefer to cache their app data on edge servers to ensure low latency service. However, it is frequently a challenge in practice, because cache spaces on edge servers are limited and expensive. In view of this challenge, a d eep l earning-based e dge c aching o ptimization method, named DLECO, is proposed to reduce the cost during the cache planning process. In this paper, the edge app data caching problem is formulated as a constrained optimization problem. Then, the specific design of DLECO with a deep learning model is shown, which aims to minimize the overall system cost with lower service latency. The performance of DLECO is analyzed theoretically and experimentally with a collection of data from the real world. The experimental results show its superior performance through comparison with three representative methods. • The edge app data caching (EADC) problem is modeled formally, and the problem is proved to be NP-hard. • The deep learning-based edge caching optimization method, named DLECO, is proposed to solve the EADC problem. • DLECO is analyzed theoretically and evaluated against three representative methods through experiments to show its superior performance. [ABSTRACT FROM AUTHOR]

• We propose a federated deep learning-based IDS for mitigating cyberattacks. • We investigate the use of three deep learning classifiers, DNN, CNN, and RNN. • The performance of each classifier is evaluated using three recent real datasets. • The results show that the FELIDS system outperforms the centralized versions. • The proposed FELIDS model achieves the highest accuracy in detecting attacks. In this paper, we propose a federated learning-based intrusion detection system, named FELIDS, for securing agricultural-IoT infrastructures. Specifically, the FELIDS system protects data privacy through local learning, where devices benefit from the knowledge of their peers by sharing only updates from their model with an aggregation server that produces an improved detection model. In order to prevent Agricultural IoTs attacks, the FELIDS system employs three deep learning classifiers, namely, deep neural networks, convolutional neural networks, and recurrent neural networks. We study the performance of the proposed IDS on three different sources, including, CSE-CIC-IDS2018, MQTTset, and InSDN. The results demonstrate that the FELIDS system outperforms the classic/centralized versions of machine learning (non-federated learning) in protecting the privacy of IoT devices data and achieves the highest accuracy in detecting attacks. [ABSTRACT FROM AUTHOR]

Driver identification has emerged as an active field of study to further personalize the integrated advanced driver-assistance systems into intelligent vehicles, provide security and safety for ride-hailing services, and prevent auto theft. Several studies, within recent years, have investigated non-intrusive identification approaches, focusing on driving behavior analysis to characterize drivers' driving behavior, in which a considerable volume of labeled data is required. This paper develops a deep learning architecture, namely DriverRep, to extract the latent representations associated with each individual, called driver embeddings. These embeddings represent the unique driving characteristics of drivers. To this aim, we introduce a fully unsupervised triplet loss that selects triplet samples from data in an unsupervised manner and extracts the embeddings using our proposed stacked encoder architecture. Dilated causal convolutions are used to make residual blocks of the encoder. To perform the task of driver identification, we leverage the classification accuracy of SVM on top of the obtained driver embeddings. The evaluation results over two datasets, each of which contains ten drivers, reveal that the DriverRep can successfully capture the underlying features within the data and outperform benchmark driver identification schemes, obtaining an average accuracy of 94.7% and 96% for two-way and three-way identification, respectively. We also investigate the ability of the DriverRep in handling sparsely labeled data. The results represent substantial improvements in comparison with the supervised approaches when applied to highly sparsely labeled data. • A novel driver identification method is proposed based on driver embeddings. • A novel strategy is introduced for unsupervised latent representation learning. • A novel encoder architecture based on stacked of dilated causal convolutions is designed to extract driver embeddings. • The proposed method outperforms existing driver identification schemes. • The proposed method outperforms time series classification models applied on highly sparsely labeled data. [ABSTRACT FROM AUTHOR]

Synchronous SGD with data parallelism, the most popular parallelization strategy for CNN training, suffers from the expensive communication cost of averaging gradients among all workers. The iterative parameter updates of SGD cause frequent communications and it becomes the performance bottleneck. In this paper, we propose a lazy parameter update algorithm that adaptively adjusts the parameter update frequency to address the expensive communication cost issue. Our algorithm accumulates the gradients if the difference of the accumulated gradients and the latest gradients is sufficiently small. The less frequent parameter updates reduce the per-iteration communication cost while maintaining the model accuracy. Our experimental results demonstrate that the lazy update method remarkably improves the scalability while maintaining the model accuracy. For ResNet50 training on ImageNet, the proposed algorithm achieves a significantly higher speedup (739.6 on 2048 Cori KNL nodes) as compared to the vanilla synchronous SGD (276.6) while the model accuracy is almost not affected (<0.2% difference). • Adaptive parameter update frequency control for scalable parallel deep learning. • Allowing gradient accumulation considering the direction of the gradients. • Reducing per-iteration communication cost at the input side model layers. • Overlapping gradient communications with backpropagation computations. [ABSTRACT FROM AUTHOR]

This paper explores Google's Edge TPU for implementing a practical network intrusion detection system (NIDS) at the edge of IoT, based on a deep learning approach. While a significant number of related works explore machine learning-based NIDS for the IoT edge, they generally lack considering the issue of the required computational and energy resources. The focus of this paper is the exploration of deep learning-based NIDS at the edge of IoT, and in particular, the computational and energy efficiency. In particular, the paper studies Google's Edge TPU as a hardware platform and considers the following three key metrics: computation (inference) time, energy efficiency and traffic classification performance. Various scaled model sizes of two major deep neural network architectures are used to investigate these three metrics. The performance of the Edge TPU-based implementation is compared with that of an energy-efficient embedded CPU (quad-core ARM Cortex-A53). • This is the first paper that explores Edge TPU for NIDS in IoT, to the best of our knowledge. • This paper investigates various feed-forward and convolutional neural network structures, with different hyperparameters, on Edge TPU and the quad-core ARM cortex-A53 hardware platforms. • The performance is compared on the hardware platforms, across multiple performance metrics including the attack detection/classification performance, the inference time, and energy efficiency. • This study evaluated the energy efficiency of explored neural network structures versus the model size on Edge TPU and Cortex-A53 platforms. [ABSTRACT FROM AUTHOR]

Cyber–physical system (CPS) is the incorporation of physical processes with processing and data transmission. Cybersecurity is a primary and challenging issue in healthcare due to the legal and ethical perspective of the patient's medical data. Therefore, the design of CPS model for healthcare applications requires special attention for ensuring data security. To resolve this issue, this paper proposes a secure intrusion, detection with blockchain based data transmission with classification model for CPS in healthcare sector. The presented model performs data acquisition process using sensor devices and intrusion detection takes place using deep belief network (DBN) model. In addition, the presented model uses a multiple share creation (MSC) model for the generation of multiple shares of the captured image, and thereby achieves privacy and security. Besides, the blockchain technology is applied for secure data transmission to the cloud server, which executes the residual network (ResNet) based classification model to identify the presence of the disease. The experimental validation of the presented model takes place using NSL-KDD 2015, CIDDS-001 and ISIC dataset. The simulation outcome pointed out the effective outcome of the presented model. • Secure intrusion detection with blockchain in the healthcare sector is proposed. • It involves a series of cyber–physical system and deep learning processes. • The presented model takes place on NSL-KDD 2015, CIDDS-001, and ISIC dataset. • Presented DBN model has achieved a detection rate of 98.95% and 98.94% on the applied datasets. • Effective classification performance with ResNet 101 model achieving maximum sensitivity. [ABSTRACT FROM AUTHOR]

The bi-directional flow of energy and information in the smart grid makes it possible to record and analyze the electricity consumption profiles of consumers. Because of the increasing rate of inflation over the past few years, people started looking for means to use electricity illegally, termed as electricity theft. Many data analytics techniques are proposed in the literature for electricity theft detection (ETD). These techniques help in the detection of suspected illegal consumers. However, the existing approaches have a low ETD rate either due to improper handling of the imbalanced class problem in a dataset or the selection of inappropriate classifier. In this paper, a robust big data analytics technique is proposed to resolve the aforementioned concerns. Firstly, adaptive synthesis (ADASYN) is applied to handle the imbalanced class problem of data. Secondly convolutional neural network (CNN) and long-short term memory (LSTM) integrated deep siamese network (DSN) are proposed to discriminate the features of both honest and fraudulent consumers. Specifically, the task of feature extraction from weekly energy consumption profiles is handed over to the CNN module while the LSTM module performs the sequence learning. Finally, the DSN contemplates on the shared features provided by the CNN-LSTM and applies final judgment. The data analytics is performed on different train–test ratios of the real-time smart meters' data. The simulation results validate the proposed model's effectiveness in terms of high area under the curve, F 1 -Score, precision and recall. • A robust big data analytic technique for electricity theft detection in smart grid is proposed. • We propose an adaptive synthesis to handle imbalanced class problem. • A deep siamese network with underpinned integrated networks of convolution neural network and long-short term memory is proposed to discriminate both features of fair and fraud consumers. • Simulation results validate the proposed model in terms of high area under the curve, low false positive rate and low false negative rate. [ABSTRACT FROM AUTHOR]

Distributed deep learning frameworks facilitate large deep learning workloads. These frameworks support sharing one GPU device among multiple jobs to improve resource utilization. Modern deep learning training jobs consume a large amount of GPU memory. Despite that, sharing GPU memory among jobs is still possible because a training job has iterative steps that its memory usage fluctuates over time. However, resource sharing also introduces the risk of job performance degradation. Co-located jobs sharing a GPU device may suffer from different levels of interference, mainly caused by memory oversharing. How to improve resource utilization while maintaining good job performance is a novel challenge for job placement strategies. This paper studies the job placement problem. We propose an opportunistic memory sharing model to describe the time-varying job memory requirements. Based on this model, we introduce an Opportunistic Job Placement Problem (OJPP) for shared GPU clusters that seek job placement configurations using a minimum number of GPU devices and guarantee user-defined performance requirements at the same time. We propose a greedy algorithm and a heuristic algorithm with computational complexities of O (n log ⁡ n) and O (n 2 log ⁡ n) , respectively, to solve the problem. We also propose an online adjustment algorithm with the computational complexity of O (n log ⁡ n) to perform updates to job placement configurations in runtime. A machine-learning-based interference prediction method is used to prepare accurate interference estimations. Extensive experiments are conducted on a GPU cluster to verify the correctness and effectiveness of our algorithms. Compared with standalone training jobs on dedicated clusters, the proposed approach reduces resource consumption by 46% in a shared cluster, while guaranteeing over 92.97% of the job performance, in terms of average job completion time. • Introduce a stochastic model to describe memory oversharing of deep learning jobs on a shared GPU device. • Introduce a novel interference-aware Opportunistic Job Placement Problem for shared distributed deep learning clusters. • Propose algorithms to handle both offline job placement and online adjustment problems. • Illustrate extensive experimental results to verify the correctness and effectiveness of the approaches. [ABSTRACT FROM AUTHOR]

Code clone detection is a crucial task in software development and maintenance. While deep learning-based methods have been proposed to tackle this problem, most of them neglect the time and memory consumption issues which can be significant when working with limited computational resources. Given the inability of recurrent neural networks to train in a parallel manner, this paper presents a parallel code clone detection model based on temporal convolutional networks. The proposed method splits the corresponding abstract syntax tree into a set of code statement sequences, utilizes a temporal convolutional neural network to generate representations containing complexity features found in the source code, and finally measures the distance between these representations. The proposed method is evaluated on a real-world dataset for code clone detection, and the experimental results demonstrate that it performs comparably to state-of-the-art methods while requiring significantly less time and memory costs. • Temporal convolutional network achieves similar code clone detection results to sequence neural network with less time and memory costs. • The performance of code clone detection task will increase while the length of token embeddings is increasing. • The recursive structure in the statement encoder can be simplified as a feedforward neural network. [ABSTRACT FROM AUTHOR]