• Journal of KIISE
• /
• v.43 no.3
• /
• pp.380-388
• /
• 2016

Graph clustering is widely used to analyze a graph and identify the properties of a graph by generating clusters consisting of similar vertices. Recently, large graph data is generated in diverse applications such as Social Network Services (SNS), the World Wide Web (WWW), and telephone networks. Therefore, the importance of graph clustering algorithms that process large graph data efficiently becomes increased. In this paper, we propose an effective clustering algorithm which generates clusters for large graph data efficiently. Our proposed algorithm effectively estimates similarities between clusters in graph data using Min-Hash and constructs clusters according to the computed similarities. In our experiment with real-world data sets, we demonstrate the efficiency of our proposed algorithm by comparing with existing algorithms.

• ETRI Journal
• /
• v.44 no.5
• /
• pp.780-793
• /
• 2022

Large-scale ontology management is one of the main issues when using ontology data practically. Although many approaches have been proposed in relational database management systems (RDBMSs) or object-oriented DBMSs (OODBMSs) to develop large-scale ontology management systems, they have several limitations because ontology data structures are intrinsically different from traditional data structures in RDBMSs or OODBMSs. In addition, users have difficulty using ontology data because many terminologies (ontology nodes) in large-scale ontology data match with a given string keyword. Therefore, in this study, we propose a (graph database-based ontology management system (GOMS) to efficiently manage large-scale ontology data. GOMS uses a graph DBMS and provides new query templates to help users find key concepts or instances. Furthermore, to run queries with multiple joins and path conditions efficiently, we propose GOMS encoding as a filtering tool and develop hash-based join processing algorithms in the graph DBMS. Finally, we experimentally show that GOMS can process various types of queries efficiently.

• The KIPS Transactions:PartD
• /
• v.15D no.1
• /
• pp.15-22
• /
• 2008

In this paper, we propose an efficient algorithm using only one-time database scan. The proposed algorithm creates the bipartite graph which indicates relationship of large items and transactions including the large items. And then we can find large itemsets using the bipartite graph. The bipartite graph is generated when database is scanned to find large items. We can't easily find transactions which include large items in the large database. In the bipartite graph, large items and transactions are linked each other. So, we can trace the transactions which include large items through the link information. Therefore the bipartite graph is a indexed database which indicates inclusion relationship of large items and transactions. We can fast find large itemsets because proposed method conducts only one-time database scan and scans indexed the bipartite graph. Also, it don't generate candidate itemsets.

• Journal of the military operations research society of Korea
• /
• v.16 no.2
• /
• pp.56-74
• /
• 1990

Programming-in-the-Large refers to software development environment and includes the organization and representation of a system structure, module decomposition, component dependence analysis, seperate compilation, subsystem and composition identification. The most intricate problem in this environment is the mastery of the structural complexity of large software systems. Ada programming language is tailored to the needs for building of large, integrated software systems from many program units. The visibility graph generating model presented in this paper transforms Ada source program into a visibility graph with nodes for program units and edges for visibility relations among program units. The system description in terms of program units and their visibility relations produced by this model can be utilized for some apects of Programming-in-the-Large environment and also assists designeers, programmers, integrators and maintainers in defining, understanding and exploring the structure of evolving software systems. The model designed and implemented in Ada programming language runs on PCs and will remain useful both in practice and as experimental tool.

• Journal of KIISE
• /
• v.44 no.7
• /
• pp.710-718
• /
• 2017

As graphs are becoming increasingly large, the costs for storing and managing data are increasing continuously. Shortest path discovery over a large graph requires long running time due to frequent disk I/Os and high complexity of the graph data. Recently, graph summarization techniques have been studied, which reduce the size of graph data and disk I/Os by representing highly dense subgraphs as a single super-node. Decompressing should be minimized for efficient shortest path discovery over the summarized graph. In this paper, we analyze the decompression performance of a summarized graph and propose an approximate technique that discovers the shortest path quickly with a minimum error ratio. We also propose an exact technique that efficiently discovered the shortest path by exploiting an index built on paths containing super-nodes. In our experiments, we showed that the proposed technique based on the summarized graph can reduce the running time by up to 70% compared with the existing techniques performed on the original graph.

• The Journal of the Korea Contents Association
• /
• v.22 no.8
• /
• pp.81-93
• /
• 2022

Recently, research on processing a large-capacity graph using GPUs has been conducting. In order to process a large-capacity graph in a GPU with limited memory, the graph must be divided into subgraphs and then processed by scheduling subgraphs. In this paper, we propose an efficient graph algorithm processing scheme in GPU environments with limited memory and performance evaluation. The proposed scheme consists of a graph differential subgraph scheduling method and a graph segmentation method. The bulk graph segmentation method determines how a large-capacity graph can be segmented into subgraphs so that it can be processed efficiently by the GPU. The differential subgraph scheduling method schedule subgraphs processed by GPUs to reduce redundant transmission of the repeatedly used data between HOST-GPUs. It shows the superiority of the proposed scheme by performing various performance evaluations.

• The Bulletin of The Korean Astronomical Society
• /
• v.43 no.2
• /
• pp.36.3-37
• /
• 2018

By utilizing large-scale graph analytic tools in the modern Big Data platform, Apache Spark, we investigate the topological structures of five different multiverses produced by cosmological n-body simulations with various cosmological initial conditions: (1) one standard universe, (2) two different dark energy states, and (3) two different dark matter densities. For the Big Data calculations, we use a custom build of stand-alone Spark cluster at KIAS and Dataproc Compute Engine in Google Cloud Platform with the sample sizes ranging from 7 millions to 200 millions. Among many graph statistics, we find that three simple graph measurements, denoted by (1) $n_\k$, (2) $\tau_\Delta$, and (3) $n_{S\ge5}$, can efficiently discern different topology in discrete point distributions. We denote this set of three graph diagnostics by kT5+. These kT5+ statistics provide a quick look of various orders of n-points correlation functions in a computationally cheap way: (1) $n = 2$ by $n_k$, (2) $n = 3$ by $\tau_\Delta$, and (3) $n \ge 5$ by $n_{S\ge5}$.

• Journal of KIISE:Databases
• /
• v.29 no.5
• /
• pp.347-357
• /
• 2002

Graphs have provided a powerful methodology to solve a lot of real-world problems, and therefore there have been many proposals on the graph representations and algorithms. But, because most of them considered only memory-based graphs, there are still difficulties to apply them to large-scale problems. To cope with the difficulties, this paper proposes a graph representation and graph algorithms based on the well-developed relational database theory. Graphs are represented in the form of relations which can be visualized as relational tables. Each vertex and edge of a graph is represented as a tuple in the tables. Graph algorithms are also defined in terms of relational algebraic operations such as projection, selection, and join. They can be implemented with the database language such as SQL. We also developed a library of basic graph operations for the management of graphs and the development of graph applications. This database approach provides an efficient methodology to deal with very large- scale graphs, and the graph library supports the development of graph applications. Furthermore, it has many advantages such as the concurrent graph sharing among users by virtue of the capability of database.

• Journal of Internet Computing and Services
• /
• v.15 no.6
• /
• pp.125-132
• /
• 2014

Since frequent pattern mining was proposed in order to search for hidden, useful pattern information from large-scale databases, various types of mining approaches and applications have been researched. Especially, frequent graph pattern mining was suggested to effectively deal with recent data that have been complicated continually, and a variety of efficient graph mining algorithms have been studied. Graph patterns obtained from graph databases have their own importance and characteristics different from one another according to the elements composing them and their lengths. However, traditional frequent graph pattern mining approaches have the limitations that do not consider such problems. That is, the existing methods consider only one minimum support threshold regardless of the lengths of graph patterns extracted from their mining operations and do not use any of the patterns' weight factors; therefore, a large number of actually useless graph patterns may be generated. Small graph patterns with a few vertices and edges tend to be interesting when their weighted supports are relatively high, while large ones with many elements can be useful even if their weighted supports are relatively low. For this reason, we propose a weight-based frequent graph pattern mining algorithm considering length-decreasing support constraints. Comprehensive experimental results provided in this paper show that the proposed method guarantees more outstanding performance compared to a state-of-the-art graph mining algorithm in terms of pattern generation, runtime, and memory usage.

• Journal of the Korean Institute of Telematics and Electronics B
• /
• v.32B no.1
• /
• pp.11-20
• /
• 1995

A new graph problem is formulated to limit the maximum path length of a general directed graph when a minimal set of vertices together with their incident edges are removed from the graph. An optimal algorithm and a heuristic algorithm are proposed and the proposed heuristic algorithm is shown to be effective through experiments using a collection of graphs obtained from large sequential circuits. The heuristic algorithm is based on a feedback vertex set algorithm based on graph reduction.