Search

The latest High Efficiency Video Coding standard achieves twice the coding efficiency of the H264 standard through a complex rate-distortion optimization (RDO). The coded bit-streams are produced with context adaptive binary arithmetic coding (CABAC). CABAC itself is a very time-consuming process that includes binarization, context modeling, interval subdivision, renormalization, outstanding bit handling, and context updating. The aim of this research is to speed up the CABAC process through several simplifications. First, we approximate three parts of the CABAC, i.e., interval subdivision, renormalization, and outstanding bit handling, with a piecewise-linear function that is very friendly to hardware implementation. In order to achieve better hardware parallelism, we also improve the coding process at the sub-block level. The context of syntax elements in a sub-block is redistributed to skip the complex calculation of context indexing. We perform context updating at the granularity of sub-blocks so that the data dependency of the context updating is removed completely, and the original serial encoding process is changed to a parallel encoding process. At the same time, we make another simplification for the context modeling of cu_skip_flag. Based on these simplifications, we build a parallel hardware architecture for the rate estimation of the RDO process. This architecture completes the bit estimation of a 32×32 coding tree unit (CTU) in 220.8 nano-seconds, whereas the Bjxntegaard Delta rate increases by only 2.225%. We believe that the proposed architecture can meet the requirements of 8K@120 fps ultra-high-definition videos. This is the first study to simplify the hardware design of rate estimation by changing the context allocation and updating rules.

Recently, edge-cloud has attracted much attention by its promising prospect in terms of facilitating the benefits of edge and cloud together. It is promising for urban video systems that require efficient and effective processing for their intelligent monitoring drives on various ends, like sky drones and land cameras. For instance, to support crowd recognition for public safety, the tasks to crowd recognition need to be placed into all processing nodes in the video systems for processing effectively. This is a challenging problem to facilitate the edge-cloud orchestrated scenarios. However, the variability of tasks based on their complexities is not considered fully in existing strategies. In this regard, we model and analyse task placement for crowd recognition in edge-cloud intelligent video systems. Then, our strategies are proposed which are referred to Node-Graph based Task Placement (NGTP) and Cluster-Graph based Task Placement (CGTP). Specifically, with the help of data dependencies, NGTP utilises the greedy approach with node graphs in the centralised way for general scenarios. Comparatively, CGTP utilises data dependency and similarity for task placing in the decentralised way for emergency scenarios. The experiments demonstrate the superior and effectiveness performance in forming tasks cost and running time of our proposed approaches.

Scientific workflows have been an increasingly important research area of distributed systems (such as cloud computing). Researchers have shown an increased interest in the automated processing scientific applications such as workflows. Recently, Function as a Service (FaaS) has emerged as a novel distributed systems platform for processing non-interactive applications. FaaS has limitations in resource use (e.g., CPU and RAM) as well as state management. In spite of these, initial studies have already demonstrated using FaaS for processing scientific workflows. DEWE v3 executes workflows in this fashion, but it often suffers from duplicate data transfers while using FaaS. This behaviour is due to the handling of intermediate data dependencies after and before each function invocation. These data dependencies could fill the temporary storage of the function environment. Our approach alters the job dispatch algorithm of DEWE v3 to reduce data dependency transfers. The proposed algorithm schedules jobs with precedence requirements to primarily run in the same function invocation. We evaluate our proposed algorithm and the original algorithm with small- and large-scale Montage workflows. Our results show that the improved system can reduce the total workflow execution time of scientific workflows over DEWE v3 by about 10\% when using AWS Lambda.

In recent years, intelligent condition-based monitoring of rotary machinery systems has become a major research focus of machine fault diagnosis. In condition-based monitoring, it is challenging to form a large-scale well-annotated dataset due to the expense of data acquisition and costly annotation. The generated data have a large number of redundant features which degraded the performance of the machine learning models. To overcome this, we have utilized the advantages of minimum redundancy maximum relevance ( mRMR ) and transfer learning with a deep learning model. In this work, mRMR is combined with deep learning and deep transfer learning framework to improve the fault diagnostics performance in terms of accuracy and computational complexity. The mRMR reduces the redundant information from data and increases the deep learning performance, whereas transfer learning, reduces a large amount of data dependency for training the model. In the proposed work, two frameworks, i.e., mRMR with deep learning and mRMR with deep transfer learning, have explored and validated on CWRU and IMS rolling element bearings datasets. The analysis shows that the proposed frameworks can obtain better diagnostic accuracy compared to existing methods and can handle the data with a large number of features more quickly.

Scientific computations with a wide range of applications in domains such as developing vaccines, forecasting the weather, predicting natural disasters, simulating aerodynamics of spacecraft, and exploring oil resources, create the main workloads of supercomputers. The key integration of such scientific computations is modeling physical phenomena that are done with the aid of partial differential equations (PDEs). Solving PDEs on supercomputers, even with those equipped with GPUs, consumes a large amount of power and yet is not as fast as desired. The main reason behind such slow processing is data dependency. The key challenge is that software techniques cannot resolve these dependencies, therefore, such applications cannot benefit from the parallelism provided by processors such as GPUs. Our key insight to address this challenge is that although we cannot resolve the dependencies, we can reduce their negative impacts by using hardware/software co-optimization. To this end, we propose breaking down the data-dependent operations into two groups of operations: a majority of parallelizable and the minority of data-dependent operations. We execute these two groups in the desired order: first, we put together all parallelizable operations and execute them all, subsequently; then, we switch to execute the small data-dependent part. As long as the data-dependent part is small, we can accelerate them by using fast hardware mechanisms. Besides, our proposed hardware mechanisms guarantee quickly switching between the two groups of operations. To follow the same order of execution, dictated by our software mechanism, and implemented in hardware, we also propose a new low-overhead compression format – sparsity is another attribute of PDEs that require compression. Furthermore, the core generic architecture of our proposed hardware allows the execution of other applications including sparse matrix-vector multiplication (SpMV) and graph algorithms. The key feature of the proposed hardware is partial reconfigurability, which on one hand, facilitates the execution of data-dependent computations, and on the other hand, allows executing broad application without changing the entire configuration. Our evaluations show that compared to GPUs, we achieve an average speedup of 15.6× for scientific computations while consuming 14× less energy.

To overcome the limitation of standalone edge cloud in terms of computing power and resource, a concept of distributed edge cloud has been introduced, where application tasks are distributed to multiple edge clouds for collaborative processing. To maximize the effectiveness of the distributed edge cloud, we formulate an optimization problem of task allocation to minimize the application completion time. To mitigate high complexity overhead in the formulated problem, we devise a low-complexity heuristic algorithm called dependency-aware task allocation (DATA) algorithm. Evaluation results demonstrate that DATA can reduce the application completion time up to by 15%–32% compared to conventional dependency-unaware task allocation schemes.

The state-of-the-art convolutional neural network (CNN) structures present growing irregularity in the sense of layer connections, which derives from the innovative manual designs and the recently proposed neural architecture searching approaches. Such irregular structures improve recognition accuracy, but also bring challenges for hardware deployment, especially on CNN accelerators with regular architectures: 1) the complicated data dependency makes it nontrivial to decide the data reuse strategy between layers and 2) since the execution order of each network is not unique, the choice of layer scheduling, memory allocating, and loop tiling strategies greatly impact the hardware performance. These challenges cannot be solved by the existing CNN schedulers, which mainly focuses on the dataflow of a single layer. In this work, we propose a comprehensive framework to analyze and solve the mapping of an arbitrarily connected CNN network to specific hardware accelerators. We propose: 1) a dynamic programming and node-clustering-based DAG partitioning approach to efficiently exploit interlayer data reuse and 2) a subgraph scheduling and on-chip memory allocating strategy to find the optimal execution order. With the modeling of CNN accelerators, we also propose a loop tiling approach for fused layers. An automated framework is established to generate binary machine codes from original CNN models produced by mainstream deep learning frameworks, which can process large-scale CNNs with more than 1000 layers in only a few minutes. Experiments based on state-of-the-art accelerators (e.g., NVDLA) show that our techniques greatly reduce the external data transfer of interlayer dependencies and bring significant performance improvement over existing approaches.

Machine learning over graphs has been emerging as powerful learning tools for graph data. However, it is challenging for industrial communities to leverage the techniques, such as graph neural networks (GNNs), and solve real-world problems at scale because of inherent data dependency in the graphs. As such, we cannot simply train a GNN with classic learning systems, for instance, parameter server that assumes data parallelism. Existing systems store the graph data in-memory for fast accesses either in a single machine or graph stores from remote. The major drawbacks are three-fold. First, they cannot scale because of the limitations on the volume of the memories, or the bandwidth between graph stores and workers. Second, they require extra development of graph stores without well exploiting mature infrastructures such as MapReduce that guarantee good system properties. Third, they focus on training but ignore optimizing the performance of inference over graphs, thus makes them an unintegrated system. In this paper, we design AGL, a scalable and integrated system, with fully-functional training and inference for GNNs. Our system design follows the message passing scheme underlying the computations of GNNs. We design to generate the K -hop neighborhood, an information-complete subgraph for each node, as well as do the inference simply by merging values from in-edge neighbors and propagating values to out-edge neighbors via MapReduce. In addition, the K -hop neighborhood contains information-complete subgraphs for each node, thus we simply do the training on parameter servers due to data independence. Our system AGL, implemented on mature infrastructures, can finish the training of a 2-layer GNN on a graph with billions of nodes and hundred billions of edges in 14 hours, and complete the inference in 1.2 hours.

The paper presents an algorithm for the worst case response time (WCRT) estimation for multiprocessor systems with fixed-priority preemptive schedulers and the interval uncertainty of tasks execution times. Each task has a unique priority within its processor, a period, an execution time interval [BCET, WCET] and can have data dependency on other tasks. If a decrease in the execution time of the task A can lead to an increase in the response time of the another task B, then task A is called an anomalous task for task B. According to the chosen approach, in order to estimate a task’s WCRT, two steps should be performed. The first one is to construct a set of anomalous tasks using the proposed algorithm for the given task. The paper provides the algorithm and the proof of its correctness. The second one is to find the WCRT estimation using a genetic algorithm. The proposed approach has been implemented software as a program in Python3. A set of experiments have been carried out in order to compare the proposed method in terms of precision and speed with two well-known WCRT estimating methods: the method that does not take into account interval uncertainty (assuming that the execution time of a given task is equal to WCET) and the brute force method. The results of the experiments have shown that, in contrast to the brute force method, the proposed method is applicable to the analysis of the real scale computing systems and also allows to achieve greater precision than the method that does not take into account interval uncertainty.

Atrial fibrillation (AF) is an arrhythmia that can cause blood clot and may lead to stroke and heart failure. To detect AF, deep learning-based detection algorithms have recently been developed. However, deep learning models were often trained with limited datasets and were evaluated within the same datasets, which makes their performance generally drops on the external datasets, known as data dependency. For this study, three different databases from PhysioNet were used to investigate the data dependency of deep learning-based AF detection algorithm using the residual neural network (Resnet). Resnet 18, 34, 50 and 152 model were trained with raw electrocardiogram (ECG) signal extracted from independent database. The highest accuracy was about 98–99% which is evaluation results of test dataset from the own database. On the other hand, the lowest accuracy was about 53–92% which was evaluation results of the external dataset extracted from different source. There are data dependency according to the train dataset and the test dataset. However, the data dependency decreased as a large amount of train data.

Newly introduced Iris recognition systems (IRSs) run on serial processors. In this paper, an alternative method has been introduced for parallel processing on Graphic processing unit (GPU) with Compute unified device architecture (CUDA) in order to increase the speed of the system. The IRS has two main parallel processing criteria, which include the division of computations into hundreds of independent units and the time of calculation more than the time of transferring from the GPU. The IRS is divided into six stages including imaging, pre-processing, segmentation, normalization, feature extraction, and matching. In order to increase speed and accuracy, two stages of iris segmentation and matching play an important role in the IRS. In this paper parallel execution of an identical algorithm for these two stages has been used. The reason for paralleling the iris segmentation stage and their low speed matching is due to a great amount of information in the iris database, plenty of calculations and lack of data dependency in these two stages. For parallelism at the segmentation stage, for each radius, the Hough transform (HT) is a processor, and in the matching stage two parts are considered: The first part consists of 32 actions comparing the input code with the database code in parallel and in the second part 2048 bits with the use of threads on each processor is performed in two sub-sections in pairs of bits and in parallel with each other. Finally, the two-way coding is achieved. In compare of existing methods, this method has rather more accurate and is also superior in terms of processing time on the GPU with CUDA. The results of the implementation of the above method on the images in UBIRIS, BATH, CASIA and MMUI databases show that the proposed method has a precision accuracy of 99.12%, 97.98%, 98.80% and 98.34%, respectively, and the average speedup for parallel processing of images in the database in the proposed method on the GPU with CUDA are 18.8, 14.7, 18, and 19 times, respectively.

Wearable sensors have been explored as an alternative for real-time monitoring of cattle feeding behavior in grazing systems. To evaluate the performance of predictive models such as machine learning (ML) techniques, data cross-validation (CV) approaches are often employed. However, due to data dependencies and confounding effects, poorly performed validation strategies may significantly inflate the prediction quality. In this context, our objective was to evaluate the effect of different CV strategies on the prediction of grazing activities in cattle using wearable sensor (accelerometer) data and ML algorithms. Six Nellore bulls (average live weight of 345 ± 21 kg) had their behavior visually classified as grazing or not-grazing for a period of 15 d. Elastic Net Generalized Linear Model (GLM), Random Forest (RF), and Artificial Neural Network (ANN) were employed to predict grazing activity (grazing or not-grazing) using 3-axis accelerometer data. For each analytical method, three CV strategies were evaluated: holdout, leave-one-animal-out (LOAO), and leave-one-day-out (LODO). Algorithms were trained using similar dataset sizes (holdout: n = 57,862; LOAO: n = 56,786; LODO: n = 56,672). Overall, GLM delivered the worst prediction accuracy (53%) compared with the ML techniques (65% for both RF and ANN), and ANN performed slightly better than RF for LOAO (73%) and LODO (64%) across CV strategies. The holdout yielded the highest nominal accuracy values for all three ML approaches (GLM: 59%, RF: 76%, and ANN: 74%), followed by LODO (GLM: 49%, RF: 61%, and ANN: 63%) and LOAO (GLM: 52%, RF: 57%, and ANN: 57%). With a larger dataset (i.e., more animals and grazing management scenarios), it is expected that accuracy could be increased. Most importantly, the greater prediction accuracy observed for holdout CV may simply indicate a lack of data independence and the presence of carry-over effects from animals and grazing management. Our results suggest that generalizing predictive models to unknown (not used for training) animals or grazing management may incur poor prediction quality. The results highlight the need for using management knowledge to define the validation strategy that is closer to the real-life situation, i.e., the intended application of the predictive model.

Admission chance prediction helps in many ways for candidates such as estimation of results, saving time and effort for higher acceptance chance, selecting the right school and making a good training plan. Admission chance prediction is also very valuable to prepare a good training plan since the physical ability test is one of the most important criteria for admission. Among many Machine Learning approaches, we only used Support Vector Machine (SVM), Single Decision Tree (SDT). In this study, these approaches were applied to train models on the dataset of 403 candidates who applied in 2018. These models were compared to each other for better accuracy and will be used them in the following years. The results were analyzed with K-fold cross-validation to decrease data dependency and increase reliability.

Atrial fibrillation (AF) is an arrhythmia that can cause blood clot and may lead to stroke and heart failure. To detect AF, deep learning-based detection algorithms have recently been developed. However, deep learning models were often trained with limited datasets and were evaluated within the same datasets, which makes their performance generally drops on the external datasets, known as data dependency. For this study, three different databases from PhysioNet were used to investigate the data dependency of deep learning-based AF detection algorithm using the residual neural network (Resnet). Resnet 18, 34, 50 and 152 model were trained with raw electrocardiogram (ECG) signal extracted from independent database. The highest accuracy was about 98–99% which is evaluation results of test dataset from the own database. On the other hand, the lowest accuracy was about 53–92% which was evaluation results of the external dataset extracted from different source. There are data dependency according to the train dataset and the test dataset. However, the data dependency decreased as a large amount of train data.

This paper presents a reconfigurable LDPC decoder implementation fully compliant with all the configurations in the 5G NR standard. Based on the row-based layered normalized Min-Sum (NMS) algorithm, the optimization approaches are proposed to solve the data dependency hazard in the pipeline process. The proposed instruction-level reordering diminishes the redundant latency of our pipelined decoder architecture. Moreover, the proposed data-level rescheduling optimizes the decoding sequence to remove the remaining pipeline stalls in the high- throughput design without decoding performance degradation. Evaluated in Xilinx VCU1525 FPGA, our design achieves a throughput of 6.7 Gbps per iteration. Implemented in TSMC 28nm CMOS process at the post-layout stage, a 33.2 Gbps, in one iteration, throughput can be achieved at a clock rate 556 MHz with the core area 1.97 mm2.

Video captioning is the core technology to drive the development of many important multidisciplinary applications, such as AI-assisted medical diagnosis, storytelling through videos, video question answering, lip-reading, just to name a few. Video captioning employs a hybrid CNN+RNN neural network model to translate video scenes into natural language descriptions. For deep learning inference, a typical approach is running both the CNN and the RNN on a GPU. Such a GPU-only approach often suffers long inference time due to underutilization of the computing power offered by the CPU+GPU heterogeneous system architecture, which is a common architecture in modern computers.This work is an early effort to tackle the performance issue of performing deep learning inference using a hybrid CNN+RNN model on a heterogeneous system with a CPU and a GPU. This is a challenging task because of (1) CNN and RNN exhibit very different computing behaviors. This raises the question of how to split the two models into computing tasks and properly assign the tasks to the CPU and the GPU to minimize the inference time for a video frame, and (2) Data dependency exists between the CNN and the RNN within a video frame, as well as between the adjacent RNNs across two video frames. These data dependencies prohibit full parallelization of the hybrid model. To solve these two problems, we propose two optimizations: a fine-grained scheduling scheme for mapping computation and devices within a video frame, and a pipeline scheduling scheme to exploit maximum parallelism between the execution of the video frames. To facilitate our optimizations, we also develop an accurate regression-based cost model to predict the computation time of CNN/RNN operations and the communication time for moving data between CPU and GPU. Experimental results show that our optimization improves the performance of video captioning by up to 3.24× on the CPU+GPU system, compared with the GPU-only execution.

The security of transmitting information from one point to another through different media is an important issue in the modern digital society. Researchers have consistently developed and proposed modern data transfer systems in order to transfer data in a safe manner. DNA (deoxyribonucleic acid) based encryption technology is a new encryption model used to protect data during transmission. Current systems that use DNA technology to encrypt Arabic texts are virtually non-existent and intended to hide data rather than encrypting it (i.e., steganography). In this research, an asymmetric DNA encryption technology is offered to encrypt and decrypt simple Arabic scripts. This technology depends on the integrity between asymmetric cryptography (i.e. RSA algorithm), dynamic encoding, and data dependency with the scope of DNA computing technology. Asymmetric cryptosystem is used only to begin the process of encryption and decryption, which is then processed fully using DNA computing. The idea of the proposed algorithm aims to generate a dynamic DNA table that depend on plain text, that aims to generate a dynamically generating 14 circular keys based on a multi-level security. Here, JAVA platform is used to implement the proposed work, and the randomization and avalanche effect are used to prove the efficiency of the proposed algorithm. This technique provides a significant change in the encoded text with an average of 53% of the avalanche characteristic.

Vulnerabilities threaten the security of information systems. It is crucial to detect and patch vulnerabilities before attacks happen. However, existing vulnerability detection methods suffer from long-term dependency, out of vocabulary, bias towards global features or local features, and coarse detection granularity. This paper proposes an automatic vulnerability detection framework in source code based on a hybrid neural network. First, the inputs are transformed into an intermediate representation with explicit structure information using lower level virtual machine intermediate representation (LLVM IR) and backward program slicing. After the transformation, the size of samples and the size of vocabulary are significantly reduced. A hybrid neural network model is then applied to extract high-level features of vulnerability, which learns features both from convolutional neural networks (CNNs) and recurrent neural networks (RNNs). The former is applied to learn local vulnerability features, such as buffer size. Furthermore, the latter is utilized to learn global features, such as data dependency. The extracted features are made up of concatenated outputs of CNN and RNN. Experiments are performed to validate our vulnerability detection method. The results show that our proposed method achieves excellent results with F1-scores of 98.6% and accuracy of 99.0% on the SARD dataset. It outperforms state-of-the-art methods.

Smart contracts are Turing-complete programs that are executed across a blockchain. Unlike traditional programs, once deployed, they cannot be modified. As smart contracts carry more value, they become more of an exciting target for attackers. Over the last years, they suffered from exploits costing millions of dollars due to simple programming mistakes. As a result, a variety of tools for detecting bugs have been proposed. Most of these tools rely on symbolic execution, which may yield false positives due to over-approximation. Recently, many fuzzers have been proposed to detect bugs in smart contracts. However, these tend to be more effective in finding shallow bugs and less effective in finding bugs that lie deep in the execution, therefore achieving low code coverage and many false negatives. An alternative that has proven to achieve good results in traditional programs is hybrid fuzzing, a combination of symbolic execution and fuzzing. In this work, we study hybrid fuzzing on smart contracts and present ConFuzzius, the first hybrid fuzzer for smart contracts. ConFuzzius uses evolutionary fuzzing to exercise shallow parts of a smart contract and constraint solving to generate inputs that satisfy complex conditions that prevent evolutionary fuzzing from exploring deeper parts. Moreover, ConFuzzius leverages dynamic data dependency analysis to efficiently generate sequences of transactions that are more likely to result in contract states in which bugs may be hidden. We evaluate the effectiveness of ConFuzzius by comparing it with state-of-the-art symbolic execution tools and fuzzers for smart contracts. Our evaluation on a curated dataset of 128 contracts and a dataset of 21K real-world contracts shows that our hybrid approach detects more bugs than state-of-the-art tools (up to 23%) and that it outperforms existing tools in terms of code coverage (up to 69%). We also demonstrate that data dependency analysis can boost bug detection up to 18%.

Scientific workflows are increasingly important for complex scientific applications. Recently, Function as a Service (FaaS) has emerged as a platform for processing non-interactive tasks. FaaS (such as AWS Lambda and Google Cloud Functions) can play an important role in processing scientific workflows. A number of works have demonstrated their ability to process these workflows. However, some issues were identified when workflows executed on cloud functions due to their limits (e.g., stateless behaviour). A major issue is the additional data transfer during the execution between object storage and the FaaS invocation environment. This leads to increased communication costs. DEWE v3 is one of the Workflow Management Systems (WMSs) that already had foundations for processing workflows with cloud functions. In this paper, we have modified the job dispatch algorithm of DEWE v3 on a function environment to reduce data dependency transfers. Our modified algorithm schedules jobs with precedence constraints to be executed in a single function invocation. Therefore, later jobs can utilise output files generated from their predecessor job in the same invocation. This reduces the makespan of workflow execution. We have evaluated the improved scheduling algorithm and the original with small- and large-scale Montage workflows. The experimental results show that our algorithm can reduce the overall makespan in contrast to the original DEWE v3 by about 10%.

Aspect-based Sentiment Analysis (ABSA) aims to extract significant aspects of an item or product from reviews and predict the sentiment of each aspect. Previous similarity methods tend to extract aspect categories at the word level by combining Language Models (LM) in their models. A drawback for the LM model is its dependence on a large amount of labelled data for a specific domain to function well. This work proposes a mechanism to address labelled data dependency by a one-step approach experimenting to decide the best combinatory architectures of recurrent-based LM and the best semantic similarity measures for fostering a new aspect category detection model. The proposed model addresses drawbacks of previous aspect category detection models in an implicit manner. The datasets of this study, S1 and S2, are from standard SemEval online competition. The proposed model outperforms the previous baseline models in terms of the F1-score of aspect category detection. This study finds more relevant aspect categories by creating a more stable and robust model. The F1 score of our best model for aspect category detection is 79.03% in the restaurant domain for the S1 dataset. In dataset S2, the F1-score is 72.65% in the laptop domain and 75.11% in the restaurant domain.

From the back-end data system point of view, the primary personal information protection mechanism is to block the direct accessing of sensitive data. The possibility that sensitive data may be indirectly inferenced by public information, have not been addressed. In United States, there are cases and discussions about "Mosaic theory". And responsibilities of data holders were legally stated. But no known researches were invested to create a responsible mechanism. This research explores the functional dependencies, and compute risky column sets based on them. We can then process users’ queries and initiate protection operation if risky data are involved.

Research on Traffic Light Recognition (TLR) has grown in recent years, primarily driven by the growing interest in autonomous vehicles development. Machine Learning algorithms have been widely used to that purpose. Mainstream approaches, however, require large amount of data and a lot of computational resources. In this paper we propose the use of Expert Instruction (EI) to reduce the amount of data required to provide accurate ML models for TLR. Given an image of the exterior scene taken from the inside of a vehicle, we stand the hypothesis that the picture of a traffic light is more likely to appear in the central and upper regions of the image. Frequency Maps of traffic light locations were thus constructed to confirm this hypothesis. Results show increased accuracies for two different benchmarks, by at least 15%. The inclusion of EI in the PCANet achieved a precision of 83% and recall of 73% against 75.3% and 51.1% of its counterpart. We finally presents a prototype of a TLR Device with such EI model to assist drivers. To show the feasibility of the apparatus, a dataset was obtained in real time usage and tested in an AdaBSF and SVM algorithms to detect and recognize traffic lights. Results show precision of 100% and recall of 90.9%.

As the deep learning techniques develop, the Recurrent Neural Networks are widely used, especially in speech recognition and natural language processing applications. However, the data dependency and low data reuse make RNNs hard to process on low power platforms. In this paper, we designed a voltage-scalable Low power Accelerator for SparsE RNN named LASER. Firstly, the sparse-RNN is analyzed and the processing array is designed after the network compression approach. Due to the imbalanced workload of sparse-RNN, we introduced the voltage-scaling method to keep the architecture with low power and high throughput. As the methods applied to EESEN, the system power efficiency can be improved significantly.

Performance has a major impact on the overall quality of software projects. Performance bugs---bugs that substantially decrease run-time---have long been studied in software engineering, and yet they remain incredibly difficult for developers to handle. Because these bugs do not cause fail-stop errors, they are both harder to discover and to fix. As a result, techniques to help programmers detect and reason about performance are needed for managing performance bugs. Here we propose a static, probabilistic embedding technique to provide developers with useful information about potential performance bugs at the statement level. Using Leetcode samples scraped from real algorithms challenges, we use DeepWalk to embed data dependency graphs in Euclidean space. We then describe how these graph embeddings can be used to detect which statements in code are likely to contribute to performance bugs.

Recently, Long Short-Term Memory (LSTM), a type of recurrent neural network, has been widely employed in realtime applications, such as speech recognition, word segmentation, machine translation, etc. While existing works demonstrate that LSTM can be efficiently deployed in cloud platforms, the high communication latency between cloud and edge will drastically reduce its efficiency. Therefore, efficient LSTM accelerators at the edge are highly demanded. The limited resource in edge devices and the heterogeneous operations in LSTM (e.g., LSTM gates) bring challenges for the LSTM accelerator design. It seems straightforward to implement each operation as a specific hardware kernel. However, the data dependency among gates leads to significant running stalls in the existing heterogeneous-kernel accelerator, resulting in low parallelism and low resource utilization. To overcome the above challenges, this work proposes a novel generic LSTM accelerator design for Field-programmable Gate Array (FPGA) and Application-specific Integrated Circuit (ASIC) platforms, where two fundamental computing patterns (i.e., element-wise multiplication and addition) are incorporated in a unified computing kernel to execute operations in all LSTM gates simultaneously. Thus, the running stalls caused by heterogeneous kernels can be eliminated, achieving full parallelism in LSTM. The proposed technique and architecture are validated on Xilinx PYNQ-Z1 FPGA which can fully utilize the available resource, achieving 10x faster in inference time and 15.2x improvement in computing power efficiency compared with the state-of-the-art LSTM accelerator.

The variability of the wind resource is the primary challenge associated with the introduction of large scale wind power onto electricity networks. In addressing uncertainties associated with wind power, probabilistic power flow analysis (PPF) is often used in resolving current or future system states. These simulations are informed by input scenarios - i.e. time series that represent conditions being simulated. Thereby defining appropriate input scenarios is a critically important part of the process. This study proposes a novel methodology for clustering wind power time series based on the dominant concurrent atmospheric circulation patterns. These patterns are classified into generalized architypes using Self Organizing Maps. Thereby the probabilistic properties and data dependency structures of wind farms are approximated at the hand of the causative weather phenomena. It was found that this methodology resulted in significant variations in the probabilistic properties of wind power time series and the correlations between wind generators. It is anticipated that this methodology could be effectively applied in defining the input characteristics into operational scenarios within a PPF analysis, and inform correlations between wind farms in spatiotemporal probabilistic forecasts.

While deep learning systems have provided breakthroughs in several tasks in the medical domain, they are still limited by the problem of dependency on the availability of training data. To counter this limitation, there is active research ongoing in few shot learning. Few shot learning algorithms aim to overcome the data dependency by exploiting the information available from a very small amount of data. In medical imaging, due to the rare occurrence of some diseases, there is often a limitation on the available data, as a result, to which the success of few shot learning algorithms can prove to be a significant advancement. In this chapter, the background and working of few shot learning algorithms are explained. The problem statement for few shot classification and segmentation is described. There is then a detailed study of the problems faced in medical imaging related to the availability of limited data. After establishing context, the recent advances in the application of few shot learning to medical imaging tasks such as classification and segmentation are explored. The results of these applications are examined with a discussion on its future scope.

Binary similarity has been widely used in function recognition and vulnerability detection. How to define a proper similarity is the key element in implementing a fast detection method. We proposed a scalable method to detect binary vulnerabilities based on similarity. Procedures lifted from binaries are divided into several comparable strands by data dependency, and those strands are transformed into a normalized form by our tool named VulneraBin, so that similarity can be determined between two procedures through a hash value comparison. The low computational complexity allows semantically equivalent code to be identified in binaries compiled from million lines of source code in a fast and accurate way.

Symbolic execution is a powerful technique for systematically exploring program paths, but scaling symbolic execution to practical programs remains challenging. State-of-the-art techniques face the challenge to efficiently explore incremental behaviors, especially for highly coupled programs with complex control and data dependency. In this paper, we present a novel approach for incremental symbolic execution based on an iteration loop between path exploration and path suffixes summarization. On one hand, the explored paths are summarized to enable more precise identification of affected paths; on the other hand, the summary guides path exploration to prune paths that have no incremental behaviors. We implemented the prototype of our approach and conducted experiments on a set of real-world applications. The results show that it is efficient and effective in exploring incremental behaviors.

Since business processes are important assets of enterprises, thousands of business processes are modeled. After modeling business process models, a problem arises here is how to improve the efficiency of these models? In this paper, we propose a novel approach to refactor business process models with process fragments substitution for efficiency improvement. First, we propose a process model smell for identifying inefficient process fragments in business process models based on a sequence relation matrix and a data dependency matrix. Second, we propose a refactoring technique to replace inefficient process fragments in business process models with efficient process fragments. After refactoring, concurrent execution of business tasks in efficient process fragments can be maximized, so the efficiency of business process models can be improved. Experiments show our approach can improve efficiency of business process models effectively.

BackgroundCompartmental models dominate epidemic modeling. Estimations of transmission parameters between compartments are typically done through stochastic parameterization processes that depend upon detailed statistics on transmission characteristics, which are economically and resource-wide expensive to collect. We apply deep learning techniques as a lower data dependency alternative to estimate transmission parameters of a customized compartmental model, for the purposes of simulating the dynamics of the US COVID-19 epidemics and projecting its further development.MethodsWe construct a compartmental model. We develop a multistep deep learning methodology to estimate the model’s transmission parameters. We then feed the estimated transmission parameters to the model to predict the development of the US COVID-19 epidemics for 35 and 42 days. Epidemics are considered suppressed when the basic reproduction number (R0) becomes less than one.ResultsThe deep learning-enhanced compartmental model predicts that R0 will become less than one around June 19 to July 3, 2020, at which point the epidemics will effectively start to die out, and that the US “Infected” population will peak round June 18 to July 2, 2020 between 1·34 million and 1·41 million individual cases. The models also predict that the number of accumulative confirmed cases will cross the 2 million mark around June 10 to 11, 2020.ConclusionsCurrent compartmental models require stochastic parameterization to estimate the transmission parameters. These models’ effectiveness depends upon detailed statistics on transmission characteristics. As an alternative, deep learning techniques are effective in estimating these stochastic parameters with greatly reduced dependency on data particularity.

Software-Defined Networking (SDN) is an emerging network architecture that provides programmable networking through a logically centralized controller. As SDN becomes more prominent, its security vulnerabilities become more evident than ever. Serving as the "brain" of a software-defined network, how the control plane (of the network) is exposed to external inputs (i.e., data plane messages) is directly correlated with how secure the network is. Fortunately, due to some unique SDN design choices (e.g., control plane and data plane separation), attackers often struggle to find a reachable path to those vulnerable logic hidden deeply within the control plane.In this paper, we demonstrate that it is possible for a weak adversary who only controls a commodity network device (host or switch) to attack previously unreachable control plane components by maliciously increasing reachability in the control plane. We introduce D2C2 (data dependency creation and chaining) attack, which leverages some widely-used SDN protocol features (e.g., custom fields) to create and chain unexpected data dependencies in order to achieve greater reachability. We have developed a novel tool, SVHunter, which can effectively identify D2C2 vulnerabilities. Till now we have evaluated SVHunter on three mainstream open-source SDN controllers (i.e., ONOS, Floodlight, and Opendaylight) as well as one security-enhanced controller (i.e., SE-Floodlight). SVHunter detects 18 previously unknown vulnerabilities, all of which can be exploited remotely to launch serious attacks such as executing arbitrary commands, exfiltrating confidential files, and crashing SDN services.

The maximum common subgraph of two graphs is the largest possible common subgraph, i.e., the common subgraph with as many vertices as possible. Even if this problem is very challenging, as it has been long proven NP-hard, its countless practical applications still motivates searching for exact solutions. This work discusses the possibility to extend an existing, very effective branch-and-bound procedure on parallel multi-core and many-core architectures. We analyze a parallel multi-core implementation that exploits a divide-and-conquer approach based on a thread pool, which does not deteriorate the original algorithmic efficiency and it minimizes data structure repetitions. We also extend the original algorithm to parallel many-core GPU architectures adopting the CUDA programming framework, and we show how to handle the heavily workload-unbalance and the massive data dependency. Then, we suggest new heuristics to reorder the adjacency matrix, to deal with &ldquo, dead-ends&rdquo, and to randomize the search with automatic restarts. These heuristics can achieve significant speed-ups on specific instances, even if they may not be competitive with the original strategy on average. Finally, we propose a portfolio approach, which integrates all the different local search algorithms as component tools, such portfolio, rather than choosing the best tool for a given instance up-front, takes the decision on-line. The proposed approach drastically limits memory bandwidth constraints and avoids other typical portfolio fragility as CPU and GPU versions often show a complementary efficiency and run on separated platforms. Experimental results support the claims and motivate further research to better exploit GPUs in embedded task-intensive and multi-engine parallel applications.

Vulnerabilities in OS kernel are more severe than those in user space because they allow attackers to access a system with full privileges. Fuzzing is an efficient technique to detect vulnerabilities though little fuzzing efforts aim to kernels. On one hand, by hooking the kernel, passive fuzzing can satisfy the dependencies among system calls but get no feedback, and thus fails to generate test cases for a resulted crash. On the other hand, guided with run-time feedback, active fuzzing can easily reproduce the crash with generated test cases, but cannot find bugs in deeper code path due to lacking of data dependency or control dependency. In this paper, we propose a novel approach for fuzzing kernel which combines passive fuzzing and active fuzzing and therefore gain their advantages. We implement the approach in a prototype called X-AFL which currently aims to test the Android kernel. Preliminary evaluation results show that X-AFL is an effective kernel fuzzer and can indeed find kernel vulnerabilities.

While programmable switches provide operators with much-needed control over the network, they also increase the potential sources of packet-processing errors. Bugs can happen anywhere: in the P4 program, the controller installing rules into tables, or the compiler that maps the P4 program into the resource-constrained switch pipelines. Most of these bugs manifest themselves after certain sequences of packets with certain combinations of rules in the tables. Tracking each packet's execution path through the P4 program, i.e., the sequence of tables hit and the actions applied, directly in the data plane is useful in localizing such bugs as they occur in real time. The fact that programmable data planes require P4 programs to be loop-free and can perform simple integer arithmetic operations makes them amenable to Ball-Larus encoding, a well-known technique in profiling execution paths in software programs that can efficiently encode all N paths in a single [log(N)]-bit variable. However, for real-world P4 programs, the path variable can get quite large, making it inefficient for integer arithmetic at line rate. Moreover, the encoding could require a subset of tables, that would otherwise have no data dependency, to update the same variable. By carefully breaking up the P4 program into disjoint partitions and tracking each partition's execution path separately, we show how to minimally augment P4 programs to track the execution path of each packet.

Blur detection, a task to determine whether an image is blurred or not, is very helpful in various applications of image processing and computer vision. In this paper, we propose a novel method to accelerate blur detection algorithms based on Haar wavelet transform. The method decouples data dependency to gain fast 3-level Haar wavelet transform. With the obtained independence, the blur detection steps can be performed in parallel using native GPU thread blocks. We evaluated our proposed method on embedded devices, desktop and server. Our experiments show that on desktop and server, the proposed method obtains a huge performance speedup. On embedded devices, our GPU-based 3-level Haar wavelet transform is up to 4.9 times better performance and 4.3 times better power efficiency than CPU-based blur detection algorithms.

With the intensive use of the internet, patient centric healthcare systems shifted away from paper-based records towards a computerized format. Electronic patient centric healthcare databases contain information about patients that should be kept available for further reference. Healthcare databases contain potential data that makes them a goal for attackers. Hacking into these systems and publishing their contents online exposes them to a challenge that affects their continuity. Any denial of this service will not be tolerated since we cannot know when we need to retrieve a patient’s record. Denial of service affects the continuity of the healthcare system which in turn threatens patients’ lives, decreases the efficiency of the healthcare system and increases the operating costs of the attacked healthcare organization. Although there are many defensive security methods that have been devised, nonetheless malicious transactions may find a way to penetrate the secured safeguard and then modify critical data of healthcare databases. When a malicious transaction modifies a patient record in a database, the damage may spread to other records through valid transactions. Therefore, recovery techniques are required. The efficiency of the data recovery algorithm is substantial for e-healthcare systems. A patient cannot wait too long for his/her medical history to be recovered so that the correct medication be prescribed. Nevertheless, in order to have fast data recovery, an efficient damage assessment process should precede the recovery stage. The damage assessment must be performed as the intrusion detection system detects the malicious activity. The execution time of the recovery process is a crucial factor for measuring the performance because it is directly proportional to the denial of service time of any healthcare system. This paper presents a high performance damage assessment and recovery algorithm for e-healthcare systems. The algorithm provides fast damage assessment after an attack by a malicious transaction to keep the availability of the e-healthcare database. Reducing the execution time of recovery is the key target of our algorithm. The proposed algorithm outperforms the existing algorithm. It is about six times faster than the most recent proposed algorithm. In the worst case, the proposed algorithm takes 8.81 ms to discover the damaged part of the database; however, the fastest recent algorithm requires 50.91 ms. In the best case, the proposed algorithm requires 0.43 ms, which is 86 times faster than the fastest recent work. This is a significant reduction of execution time compared with other available approaches. Saving the damage assessment time means shorter denial of service periods, which in turn guarantees the continuity of the patient centric healthcare system.

Cloud computing enables end-users to outsource their dataset and data management needs to a third-party service provider. One of the major security concerns of the outsourcing paradigm is how to protect sensitive information in the outsourced dataset. In some applications, only partial values are considered sensitive. In general, the sensitive information can be protected by encryption. However, data dependency constraints (together with the unencrypted data) in the outsourced data may serve as adversary knowledge and bring security vulnerabilities to the encrypted data. In this paper, we focus on functional dependency (FD), an important type of data dependency constraints, and study the security threats by the adversarial FDs. We design a practical scheme that can defend against the FD attack by encrypting a small amount of non-sensitive data (encryption overhead). We prove that finding the scheme that leads to the optimal encryption overhead is NP-complete, and design efficient heuristic algorithms, under the presence of one or multiple FDs. We design a secure query rewriting scheme that enables the service provider to answer various types of queries on the encrypted data with provable security guarantee. We extend our study to enforce security when there are conditional functional dependencies (CFDs) and data updates. We conduct an extensive set of experiments on two real-world datasets. The experiment results show that our heuristic approach brings small amounts of encryption overhead (at most 1% more than the optimal overhead), and enjoys a 10-time speedup compared with the optimal solution. Besides, our approach can reduce up to 90% of the encryption overhead of state-of-the-art solution.

A data dependency similarity measure called mp-dissimilarity has been recently proposed. Unlike lp-norm distance which is widely used in calculating the similarity between vectors, mp-dissimilarity takes into account the relative positions of the two vectors with respect to the rest of the data. This paper investigates the potential of mp-dissimilarity in matching local image descriptors. Moreover, three new matching strategies are proposed by considering both lp-norm distance and mp-dissimilarity. Our proposed matching strategies are extensively evaluated against lp-norm distance and mp-dissimilarity on a few benchmark datasets. Experimental results show that mp-dissimilarity is a promising alternative to lp-norm distance in matching local descriptors. The proposed matching strategies outperform both lp-norm distance and mp-dissimilarity in matching accuracy. One of our proposed matching strategies is comparable to lp-norm distance in terms of recall vs 1-precision.

Due to the increasing demand on secure image transmission, image encryption has emerged as an active research field in recent years. Many of the proposed image encryption schemes are designed based on chaotic maps with permutation–diffusion architecture. While most of these schemes reported good statistical properties, they are slow in execution speed due to inherent data dependency of the proposed schemes. Some of these schemes are designed based on complex chaotic systems that require significant computational resources to obtain the keystream for encryption. In this paper, we propose SPRING, a novel image encryption scheme designed based on lightweight chaotic maps and simple logical and arithmetic operations, which is also highly optimized for massively parallel architecture (e.g. GPU). The extensive experimental results show that SPRING is not only secure but also able to achieve high encryption speed in single-core CPU, multi-core CPU and many-core GPU. Encrypting a 512 $$\times $$ 512 grayscale image in serial takes 0.9126 ms which is 220% faster than state-of-the-art ARX-based image encryption scheme proposed by Choi et al. SPRING can be implemented in parallel to encrypt the same image in 0.0862 ms by exploiting many-core GPU, which is 10 $$\times $$ faster than the serial version implemented using CPU.

Recently, data-driven fault detection and diagnosis (FDD) technologies have been studied extensively to detect the fault status early and maintain the health of building automation systems (BASs). Among the various algorithms for building FDD systems, an autoencoder (AE) is widely used as an unsupervised deep-learning method. Conventional AE-based FDD methods can use two types of information generated from the novel structure of the AE: (1) residual matrix (REM) and (2) latent space matrix (LSM). However, fundamental discussions about AE structures are rare, and the uses of the REM and LSM for building FDD models have seldom been compared. In this study, AE-based FDD methods are suggested. Quantitative comparisons were conducted under the designed fault conditions and real operational faults (hunting). AE-based fault detection models were designed using the AE latent space dimensionality. For fault diagnosis models, REM- and LSM-based models were used. Each model was then subdivided by the AE latent space dimensions. The detection model performances showed no meaningful differences according to the designed cases. However, for the diagnosis models, the performance of the LSM-based models was 14.4% better than that of the REM-based models. Additionally, the dimensions of the latent space caused the model performance to vary as much as 21.5%. Two main issues—training data dependency and latent space dimensionality—were found and investigated to improve the performance of AE-based FDD. Modeling guidelines are suggested based on the findings. These are valuable for successful FDD application with limited working sensors and datasets in real BASs.

Incremental feature extraction algorithms are designed to analyze large-scale data streams. Many of them suffer from high computational cost, time complexity, and data dependency, which adversely affects the processing of the data stream. With this motivation, this paper presents a novel incremental feature extraction approach based on the Discrete Cosine Transform (DCT) for the data stream. The proposed approach is separated into initial and sequential phases, and each phase uses a fixed-size windowing technique for processing the current samples. The initial phase is performed only on the first window to construct the initial model as a baseline. In this phase, normalization and DCT are applied to each sample in the window. Subsequently, the efficient feature subset is determined by a particle swarm optimization-based method. With the construction of the initial model, the sequential phase begins. The normalization and DCT processes are likewise applied to each sample. Afterward, the feature subset is selected according to the initial model. Finally, the k-nearest neighbor classifier is employed for classification. The approach is tested on the well-known streaming data sets and compared with state-of-the-art incremental feature extraction algorithms. The experimental studies demonstrate the proposed approach’s success in terms of recognition accuracy and learning time.

Compartmental models dominate epidemic modeling. Estimations of transmission parameters between compartments are typically done through stochastic parameterization processes that depend upon detailed statistics on transmission characteristics, which are economically and resource-wide expensive to collect. We apply deep learning techniques as a lower data dependency alternative to estimating transmission parameters of a customized compartmental model, for the purposes of projecting further development of the US COVID-19 epidemics. The deep learning-enhanced compartment model predicts that the basic reproduction rate (R0 ) will become less than one around June 22–27, 2020, and that the infection transmission parameter will drop to virtually zero around July 14, 2020, implying that the total number of confirmed cases will likely become stabilized around that timeframe (projected at 2·4 million). Funding Statement: None. Declaration of Interests: Authors declare no competing interests.

More and more organizations plan to migrate their legacy systems to cloud so as to improve the efficiency of data processing. In order to take full advantage of the parallel virtue of cloud computing, legacy system need to be refactored according to the cloud computing program model. Before that, the parallelizability analysis is the first thing to do. This paper first proposes Distributed parallelizability of legacy code in the process of refactoring from Legacy code to Mapreduce code (DPLM), and then derives four parallel-determinable features according to the rule: data dependency, continuous dependency, non-homology and randomness. Then algorithms are developed to detect parallel-determinable features. Only the legacy code which is not satisfied with all the four-point features can be refactored to parallelizable MapReduce code. However, through practice, the situation is discovered that there are some type of legacy codes can't take advantage of the parallelism of MapReduce. To solve this problem, parallel-determinable features is divided into strong and weak features. Weak features can be resolved by reorganizing source input file. Partial strong features can be resolved by iterative grading. Finally, the experiments show the validity of DPLM and optimization method, parallel-determinable features and optimization methods.

Reverse execution and coredump analysis have long been used to diagnose the root cause of software crashes. Each of these techniques, however, face inherent challenges, such as insufficient capability when handling memory aliases. Recent works have used hypothesis testing to address this drawback, albeit with high computational complexity, making them impractical for real world applications. To address this issue, we propose a new deep neural architecture, which could significantly improve memory alias resolution. At the high level, our approach employs a recurrent neural network (RNN) to learn the binary code pattern pertaining to memory accesses. It then infers the memory region accessed by memory references. Since memory references to different regions naturally indicate a non-alias relationship, our neural architecture can greatly reduce the burden of doing hypothesis testing to track down non-alias relation in binary code. Different from previous researches that have utilized deep learning for other binary analysis tasks, the neural network proposed in this work is fundamentally novel. Instead of simply using off-the-shelf neural networks, we designed a new recurrent neural architecture that could capture the data dependency between machine code segments. To demonstrate the utility of our deep neural architecture, we implement it as RENN, a neural network-assisted reverse execution system. We utilize this tool to analyze software crashes corresponding to 40 memory corruption vulnerabilities from the real world. Our experiments show that RENN can significantly improve the efficiency of locating the root cause for the crashes. Compared to a state-of-the-art technique, RENN has 36.25% faster execution time on average, detects an average of 21.35% more non-alias pairs, and successfully identified the root cause of 12.5% more cases.

Future vehicular applications require sufficient computing and storage resources. Actual on-board resources are limited and inadequate to deal with steadily increasing requirements. In order to overcome the computational limitation in vehicles, computing intensive functions can be offloaded to a cloud. The so-called cloud-based vehicle functions run in the cloud and utilize cloud capability instead of vehicle's on-board resources. The suitability of the vehicle functions for outsourcing to the cloud should be ensured in an early stage of development. Otherwise, shifting improper functions can lead to serious consequences for the vehicle control system. By the suitability analysis several criteria like functional safety, data dependency and response time should be considered. In this paper, we focus on the criterion response time and present a framework to predict the response time along a sample route.

In this paper, we tried to model parallel version of Data Encryption Standard (DES) by means of the modified mode of operation. Block size specifications followed by DES have been adopted too. Design configuration has shown serialized intermediate key generation and parallelized operations on plaintext blocks, which indicate faster encryption as compared to the standard one. We have performed various statistical tests suggested in the literature for conforming security of the proposed model. Also, case studies on potential vulnerabilities have been shown. Comparative analysis with the standard DES has revealed that the proposed parallel DES is more secure due to inter-block data dependency of keys and serialized decryption besides faster encryption. We have concluded our work with future directives.