Electrocardiograms (ECGs) are a non-invasive measurement used to observe the condition of the heart. Modern wearable devices can record ECGs, but typically provide fewer leads–signal outputs from electrodes–than the 12 in standard electrocardiograms. Consequently, data generated from these devices may be insufficient for accurately diagnosing more complex cardiac conditions. To bridge this gap, we propose ECGT2T, a deep generative model that synthesizes ten leads from an asynchronous Lead I and Lead II input to simulate a 12-lead ECG. Compared to the R-peaks of the original wave-forms, the generated signals had timing and amplitude errors under 15 milliseconds and 10%, respectively. Experiments on two widely used ECG datasets show classifiers trained on synthesized 12-lead electrocardiograms generated with ECGT2T outperforms models trained on one- or two-lead ECGs in detecting myocardial infarction and arrhythmia.

We present the taxonomy of data augmentation for electrocardiogram (ECG) after reviewing various ECG augmentation methods. On the basis of the taxonomy, we demonstrate the effect of augmentation methods on the ECG classification via extensive experiments. Initially, we examine the performance trend as the magnitude of distortion increases and identify the optimal distortion magnitude. Secondly, we investigate the synergistic combinations of the transformations and identify the pairs of transformations with the greatest positive effect. Finally, based on our experimental findings, we propose an efficient augmentation policy and demonstrate that it outperforms previous augmentation policies.

Graph engines have been used in many applications to handle big graphs efficiently. The majority of the research to improve their performance has focused primarily on the design of efficient graph processing. This paper claims,however,the focus should be given also to graph storage design. This is because good storage design can improve both CPU performance and I/O performance of graph engines. In this paper,we propose an efficient data layout for single-machine based graph engines. We identify the common node access pattern of the graph algorithms running on single-machine based graph engines. Based on this finding,we propose the breadth-first (BF) data layout which places the nodes processed together in the same or adjacent storage space so that they can be accessed together as much as possible. The experimental results show that the BF data layout improves both CPU and I/O performances significantly in all single-machine based graph engines.

In this demo, we present RealGraph Web , a web-based platform that provides various kinds of graph analysis services. RealGraph Web is based on RealGraph, a graph engine that addresses the problem of performance degradation in processing real-world big graphs, achieving great performance improvement up to 44 times over existing state-of-the-art graph engines. RealGraph Web runs on a single machine with a web-based interface, thereby allowing users to easily and conveniently enjoy graph analysis services and perform various graph algorithms anywhere on the web . In this demo, we present how a user can analyze a graph on RealGraph Web in three steps and get the analysis result quickly via a graphical user interface.

If we had the performance information of every application on every SSD, it would be very beneficial to both SSD users and SSD manufacturers. For SSD users, they can buy the SSD that is fastest for the most frequently using applications; for SSD manufacturers, they can figure out the strength and weakness of their SSD for every application. Toward this end, this article proposes a framework named${\sf FORESEE}$FORESEEthat estimates accurately the execution time of a given IO trace (i.e.,query IO trace) of a given application on a target SSDwithout its actual execution.${\sf FORESEE}$is developed based on the observation thatif two IO traces are similar to each other in their IO behavior, their execution times tend to be similar when they are executed on the same SSD. In${\sf FORESEE}$, the execution time of a query IO trace is estimated by using the execution times of the IO traces in a database similar to the query IO trace. Our technical contributions in${\sf FORESEE}$are as follows: (1) we propose a goodness function that efficiently evaluates the quality of sets of features that are used to measure the similarity of IO traces; (2) we propose a DB structure and a searching method for efficiently searching for similar IO traces to a query IO trace; (3) we propose an aggregation method that aggregates the execution times of similar IO traces to a query IO trace for accurately estimating the execution time of the query IO trace; and (4) we verify the effectiveness of${\sf FORESEE}$via extensive experiments by using real-world application IO traces. According to the results, the Pearson correlation coefficient (PCC) of the actual execution time and the estimated execution time by${\sf FORESEE}$is found to be 0.87, indicating${\sf FORESEE}$estimates the execution time accurately.

Sparse matrix multiplication (spGEMM) is widely used to analyze the sparse network data, and extract important information based on matrix representation. As it contains a high degree of data parallelism, many efficient implementations using data-parallel programming platforms such as CUDA and OpenCL have been introduced on graphic processing units (GPUs). Several well-known spGEMM techniques, such as cuS- PARSE and CUSP, often do not utilize the GPU resources fully, owing to the load imbalance between threads in the expansion process and high memory contention in the merge process. Furthermore, even though several outer-product-based spGEMM techniques are proposed to solve the load balancing problem on expansion, they still do not utilize the GPU resources fully, because severe computation load variations exist among the multiple thread blocks.To solve these challenges, this paper proposes a new optimization pass called Block Reorganizer, which balances the total computations of each computing unit on target GPUs, based on the outer-product-based expansion process, and reduces the memory pressure during the merge process. For expansion, it first identifies the actual computation amount for each block, and then performs two thread block transformation processes based on their characteristics: 1) B-Splitting to transform a heavy-computation blocks into multiple small blocks and 2) B- Gathering to aggregate multiple small-computation blocks to a larger block. While merging, it improves the overall performance by performing B-Limiting to limit the number of blocks on each computing unit. Experimental results show that it improves the total performance of kernel execution by 1.43x, on an average, when compared to the row-product-based spGEMM, for NVIDIA Titan Xp GPUs on real-world datasets.

As the size of real-world graphs has drastically increased in recent years, a wide variety of graph engines have been developed to deal with such big graphs efficiently. However, the majority of graph engines have been designed without considering the power-law degree distribution of real-world graphs seriously. Two problems have been observed when existing graph engines process real-world graphs: inefficient scanning of the sparse indicator and the delay in iteration progress due to uneven workload distribution. In this paper, we propose RealGraph, a single-machine based graph engine equipped with the hierarchical indicator and the block-based workload allocation. Experimental results on real-world datasets show that RealGraph significantly outperforms existing graph engines in terms of both speed and scalability.

With the NAND flash memory technology of solid-state drives (SSDs), the usage of SSDs is expanded to various devices. Due to the cost and time limitations of measuring the actual execution time of each application on SSDs, it is difficult for users to determine the best SSD for their most commonly used applications. In this paper, we propose a framework of estimating the execution time of an application IO trace (i.e., a query IO trace) on a target SSD without its real execution. Our framework is based on the observation that if two IO traces are similar in their IO behavior, their execution times tend to be similar when executed on the same SSD. The performance of the framework is evaluated through extensive experiments on real applications. The results show that our framework is accurate in estimating the execution time of an IO trace on SSDs.

Graphs are very widely used to represent datasets in various real-world applications. Many algorithms dealing with graphs represent them in the form of sparse matrices and process them through sparse matrix operations. Recently, as the size of a graph increases rapidly, a single-machine-based graph engine has emerged as a general framework for effectively performing large-scale sparse matrix operations. Sparse matrices multiplication (SpGEMM) is a core building block for developing a variety of graph algorithms such as all source shortest paths, betweenness centrality, breadth first search from multiple sources, subgraph indexing, and graph construction. This paper addresses how to perform two sparse matrices multiplication (SpGEMM) efficiently on a single-machine-based graph engine. To effectively perform the large-scale SpGEMM, we have two issues: (1) selecting an appropriate type of matrix products (i.e., inner products, outer products, and row-row products), and (2) allocating memory space to matrices according to different types of matrix products. We first formulate the cost models for the three matrix product types by reflecting their characteristics. We observed the commonality in the processes of the matrix multiplication and the join in a relational database. Based on this observation, we propose memory allocation schemes for three matrix products by borrowing the idea of memory allocation employed in join. Finally, we show the effectiveness of our approach via extensive experiments with real-life datasets.

The size of graphs has dramatically increased. Graph engines for a single machine have been emerged to process these graphs efficiently. However, existing engines have overlooked a data locality which is an imperative factor to improve the performance of these engines in the previous literature. In this paper, we show the importance of data locality with graph algorithms by running on graph engines based on a single machine.

As a number of social network services appear online recently, there have been many attempts to analyze social networks for extracting valuable information. Most existing methods first represent a social network as a quite sparse adjacency matrix, and then analyze it through matrix operations such as matrix multiplication. Due to the large scale and high complexity, efficient processing multiplications is an important issue in social network analysis. In this paper, we propose a GPU-based method for efficient sparse matrix multiplication through the parallel computing paradigm. The proposed method aims at balancing the amount of workload both at fine- and coarse-grained levels for maximizing the degree of parallelism in GPU. Through extensive experiments using synthetic and real-world datasets, we show that the proposed method outperforms previous methods by up to three orders-of-magnitude.