Graph edit distance (GED) is a general and versatile measure of graph similarity. Many combinatorial algorithms have been proposed for computing exact GED, but they suffer from the high computational cost due to the NP-hardness of GED computation. To address this challenge, approximate GED computation techniques have been extensively studied. These techniques are generally twofold: early work is based on combinatorial algorithms that restrict search space for efficient computation, while more recent approaches employ machine learning techniques to estimate GED. Although learning-based approaches generally achieve higher estimation accuracy than combinatorial approximations, they often rely on smoothed node embeddings to model node-to-node interactions, which may limit their ability to capture fine-grained structural differences. To alleviate this limitation, we exploit the insight that sequential variations in node interactions across GNN layers exhibit informative patterns. In this paper, we design a novel neural model, Grasp, that learns to extract and leverage these patterns to predict pairwise node matching probabilities and their associated costs. By aggregating these estimates from the perspectives of both input graphs, Grasp effectively and accurately computes an approximate GED. Experimental results on real-world datasets demonstrate that Grasp significantly improves estimation accuracy over existing approximate methods.

The age of pervasive computing has initiated a boom in the development of adaptive context-aware learning environments (ACALEs), i.e., systems that are capable of detecting a learner’s context and providing adaptive learning services based on this context. Many of the existing educational systems were developed as standalone applications for specific or a small range of adaptive educational scenarios. It would be extremely helpful for developers and educators to have a unified framework that provides an infrastructure for the development of ACALEs. In this study, we propose Lightlore—an adaptation framework that enables the development of different types of ACELEs for a wide range of learning scenarios in formal and informal settings. We first used scenario-based design (SBD) as the design methodology for creating a conceptual model of Lightlore. Educational scenarios were adopted from the results of a previous literature review. We then developed a proof-of-concept implementation of Lightlore, with a hypermedia system for learning data structures that uses the adaptation service of Lightlore. This implementation is essentially an adaptation infrastructure and a programming API for creating new (or transforming existing) adaptive and context-aware educational services. It exploits the experience API (xAPI), a modern e-learning standard and learning record store, thus making coupling with existing learning environments easier. We expect that diverse types of users will benefit from using Lightlore, such as learners, educators, learning environment developers, and researchers on educational technologies.

With the increase in IoT (Internet of Things) devices comes an inherent challenge of security.In the world today, privacy is the prime concern of every individual.Preserving one's privacy and keeping anonymity throughout the system is a desired functionality that does not come without inevitable trade-offs like scalability and increased complexity and is always exceedingly difficult to manage.The challenge is keeping confidentiality and continuing to make the person innominate throughout the system.To address this, we present our proposed architecture where we manage IoT devices using blockchain technology.Our proposed architecture works on and off blockchain integrated with the closed-circuit television (CCTV) security camera fixed at the rental property.In this framework, the CCTV security camera feed is redirected towards the owner and renter based on the smart contract conditions.One entity (owner or renter) can see the CCTV security camera feed at one time.There is no third-party dependence except for the CCTV security camera deployment phase.Our contributions include the proposition of framework architecture, a novel smart contract algorithm, and the modification to the ring signatures leveraging an existing cryptographic technique.Analyses are made based on different systems' security and key management areas.In an empirical study, our proposed algorithm performed better in key generation, proof generation, and verification times.By comparing similar existing schemes, we have shown the proposed architectures' advantages.Until now, we have developed this system for a specific area in the real world.However, this system is scalable and applicable to other areas like healthcare monitoring systems, which is part of our future work.

In this paper, we study the problem of graph edit distance (GED) computation. We empirically observe that real graph data contain many isomorphic substructures, which incur redundant computation. Based on this observation, we aim at reducing the cost of GED computation by avoiding redundant computation caused by isomorphic substructures. To detect isomorphic substructures, we precisely define a notion of vertex isomorphism and propose a dynamic programming algorithm that identifies isomorphic vertices in a graph. By taking advantage of isomorphic vertices, we develop an efficient GED computation algorithm. In experiments, we show that isomorphic vertices are effectively used in reducing the search space of GED computation, and as a result our approach improves the performance of GED computation.(c) 2023 Elsevier B.V. All rights reserved.

Large scale machine learning (ML) and deep learning (DL) platforms face challenges when integrated with deduplication enabled storage clusters. In the quest to achieve smart and efficient storage utilization, removal of duplicate data introduces bottlenecks, since deduplication alters the I/O transaction layout of the storage system. Therefore, it is critical to address such deduplication overhead for acceleration of ML/DL computation in deduplication storage. Existing state of the art ML/DL storage solutions such as Alluxio and AutoCache adopt non deduplication-aware caching mechanisms, which lacks the much needed performance boost when adopted in deduplication enabled ML/DL clusters. In this paper, we introduce Redup , which eliminates the performance drop caused by enabling deduplication in ML/DL storage clusters. At the core, is a Redup Caching Manager (RDCM), composed of a 2-tier deduplication layout-aware caching mechanism. The RDCM provides an abstraction of the underlying deduplication storage layout to ML/DL applications and provisions a decoupled acceleration of object reconstruction during ML/DL read operations. Our Redup evaluation shows negligible performance drop in ML/DL training performances as compared to a cluster without deduplication, whilst significantly outperforming Alluxio and AutoCache in terms of various performance metrics.

It is essential to identify similarity between graphs for various tasks in data mining, machine learning and pattern recognition. Graph edit distance (GED) is the most popular graph similarity measure thanks to its flexibility and versatility. In this paper, we study the problem of top- $k$ graph similarity search, which finds $k$ graphs most similar to a given query graph under the GED measure. We propose incremental GED computation algorithms that compute desired GED lower and upper bounds. Based on the algorithms, we develop novel search frameworks to address the top- $k$ search problem. Our frameworks are also designed to use a state-of-the art indexing technique to speed up top- $k$ search. By conducting extensive experiments on real datasets, we show that the proposed frameworks significantly improve the performance of top- $k$ graph similarity search.

Graph similarity search is to retrieve all graphs from a graph database whose graph edit distance (GED) to a query graph is within a given threshold. As GED computation is NP-hard, existing solutions adopt the filtering-and-verification framework, where the main focus is on the filtering phase to reduce the number of GED verifications. However, existing filtering techniques have inherently limited filtering capabilities, and suffer from a large number of GED verifications. To address the problem, in this paper, we propose a fundamentally different approach that utilizes pre-computed GEDs between data graphs in the filtering phase. Based on the approach, we develop a novel search framework Nass, which substantially reduces the verification workload. Because the efficiency of GED computation is essential in GED pre-computation, not to mention the verification of candidate graphs, we also propose an efficient GED computation algorithm as a part of Nass. We conduct extensive experiments on real datasets, and show Nass significantly outperforms the state-of-the art solutions.

In this paper, we study the problem of string similarity search to retrieve in a database all strings similar to a query string within a given threshold. To measure the similarity between strings, we use edit distance. Many algorithms have been proposed under a filtering-and-verification framework to solve the problem. To reduce the overhead of edit distance verification, it is crucial to efficiently generate a small number of candidates in the filtering phase. Recently, an index structure named HSTree has been proposed for efficiently generating candidate strings. To generate candidates, they select and utilize HSTree nodes at a specific level calculated from a given threshold. In this paper, we observe that there are many alternative ways to select HSTree nodes, and propose a novel technique that selects HSTree nodes in an optimized way based on the observation. We also propose a modified HSTree, named a threaded HSTree, which connects inverted lists of an HSTree node to inverted lists of its child nodes. With a threaded HSTree, we can reduce the overhead of index lookups in HSTree nodes while selecting optimal tree nodes. Experimental results show that the proposed technique significantly outperforms the existing technique using the HSTree.

Flash memory prevalence has reached greater extents with its performance and compactness capabilities. This enables it to be easily adopted as storage media in various portable devices which includes smart watches, cell-phones, drones, and in-vehicle infotainment systems to mention but a few. To support large flash storage in such portable devices, existing flash translation layers (FTLs) employ a cache mapping table (CMT), which contains a small portion of logical page number to physical page number (LPN-PPN) mappings. For robustness, it is of importance to consider the CMT reconstruction mechanisms during system recovery. Currently, existing approaches cannot overcome the performance penalty after experiencing unexpected power failure. This is due to the disregard of the delay caused by inconsistencies between the cached page-mapping entries in RAM and their corresponding mapping pages in flash storage. Furthermore, how to select proper pages for reconstructing the CMT when rebooting a device needs to be revisited. In this study we address these problems and propose a fault tolerant power-failure recovery mechanism (FTRM) for flash memory storage systems. Our empirical study shows that FTRM is an efficient recovery and robust protocol.

In this paper, we study the problem of graph similarity search with graph edit distance (GED) constraints. Due to the NP-hardness of GED computation, existing solutions to this problem adopt the filtering-and-verification framework with a main focus on the filtering phase to generate a small number of candidate graphs. However, they have a limitation that the number of candidates grows extremely rapidly as a GED threshold increases. To address the limitation, we propose a new approach that utilizes GED computation results in generating candidate graphs. The main idea is that whenever we identify a result graph of the query, we immediately regenerate candidate graphs using a subset of pre-computed graphs similar to the identified result graph. To speed up GED computation, we also develop a novel GED computation algorithm. The proposed algorithm reduces the search space for GED computation by utilizing a series of filtering techniques, which have been used to generate candidates in existing solutions. Experimental results on real datasets demonstrate the proposed approach significantly outperforms the state-of-the art techniques.

Graph edit distance (GED) is a measure for quantifying the similarity between two graphs. Because of its flexibility and versatility, GED is widely used in many real applications. However, the main disadvantage of GED is its high computational cost. Many solutions have been proposed to speed up GED computation, but most of them focus on developing serial algorithms and only very few solutions consider parallel computing. In this paper, we study a parallel GED computation to elaborate a fast and precise algorithm. Unlike existing solutions that utilize either a depth-first or a best-first search, we propose a hybrid approach that combines depth-first and best-first search paradigms. Our approach can quickly find tighter GED upper bounds, and effectively prune the search space using the upper bounds. Based on the approach, we develop an efficient parallel GED computation algorithm named HGED. To maximize thread utility, HGED is also equipped with a novel dynamic load balancing scheme whose main focus is on reducing the overhead of thread synchronization. Experimental results on widely used real datasets show that, on average, HGED outperforms the state-of-the art serial algorithm AStar(+)-LSa by 6 times and the state-of-the parallel algorithm PGED by 4 times.

We study the problem of graph similarity search with a graph edit distance (GED) constraint. Existing solutions adopt a filteringand-verification framework, with a focus on the filtering phase where a feature-based index is used to reduce the number of candidate graphs to be verified. These solutions suffer from a computationally expensive verification phase. In this paper, we develop a novel technique called Inves that can significantly reduce the time of verifying a candidate graph. Its main idea is to judiciously and incrementally partition a candidate graph based on the query graph, and use the results to compute a lower bound of their distance. If a full GED computation is needed, Inves utilizes the collected information, and uses novel methods and an A* algorithm to search in the space of possible vertex mappings between the graphs to compute their GED efficiently. A main advantage of Inves is that it can be adopted by a plethora of graph similarity search algorithms. Our extensive experiments on both real and synthetic datasets show that Inves can significantly improve the performance of existing techniques by an order of magnitude.

Recent advances in DNA sequencing have enabled a flood of sequencing-based applications for studying biology and medicine. A key requirement of these applications is to rapidly and accurately map DNA subsequences to a reference genome. This DNA subsequence mapping problem shares core technical challenges with the similarity query processing problem studied in the database research literature. To solve this problem, existing techniques first extract signatures from a query, then retrieve candidate mapping positions from an index using the extracted signatures, and finally verify the candidate positions. The efficiency of these techniques depends critically on signatures selected from queries, while signature selection relies on an indexing scheme of a reference genome. The q-gram inverted indexing, one of the most widely used indexing schemes, can discover candidate positions quickly, but has the limitation that signatures of queries are restricted to fixed-length q-grams. To address the problem, we propose a flexible way to generate variable-length signatures using a fixed-length q-gram index. The proposed technique groups a few q-grams into a variable-length signature, and generates candidate positions for the variable-length signature using the inverted lists of the q-grams. We also propose a novel dynamic programming algorithm to balance between the filtering power of signatures and the overhead of generating candidate positions for the signatures. Through extensive experiments on both simulated and real genomic data, we show that our technique substantially improves the performance of read mapping in terms of both mapping speed and accuracy.

유사 문자열 검색을 위해 기존의 기법들은 우선 후보 문자열 집합을 생성한 후에 후보 문자열을 검증하는 방법을 사용한다. 이때, 유사 문자열 검색의 성능을 결정짓는 가장 중요한 요소는 후보 생성방법이다. 기존의 기법들은 질의 문자열로부터 고정길이 q-그램들을 선택하고, 선택된 q-그램에 해당하는 역리스트를 이용해 후보 문자열을 생성한다. 본 논문에서는 질의 문자열 내의 가변길이 그램들을 사용하여 후보 문자열을 생성할 수 있는 기법과 질의 문자열로부터 최적의 가변길이 그램들의 조합을 선택하는 동적 프로그래밍 알고리즘을 제안한다. 실험을 통해 제안하는 기법이 기존의 기법들 보다 유사 문자열 검색의 성능을 향상시킴을 보인다.

Recently, flash memory is widely used as a non-volatile storage for embedded applications such as smart phones, MP3 players, digital cameras and so on. The software layer called flash translation layer (FTL) becomes more important since it is a key factor in the overall flash memory system performance. Many researchers have proposed FTL algorithms for small block flash memory in which the size of a physical page of flash memory is equivalent to the size of a data sector of the file system. However, major flash vendors have now produced large block flash memory in which the size of a physical page is larger than the file system's data sector size. Since large block flash memory has new features, designing FTL algorithms specialized to large block flash memory is a challenging issue. In this paper, we provide an efficient FTL named LSTAFF* for large block flash memory. LSTAFF* is designed to achieve better performance by using characteristics of large block flash memory and to provide safety by abiding by restrictions of large block flash memory. Experimental results show that LSTAFF* outperforms existing algorithms on a large block flash memory.

An inverted index structure is widely used for efficient string similarity search. One of the main requirements of similarity search is a fast response time; to this end, most techniques use an in-memory index structure. Since the size of an inverted index structure usually very large, however, it is not practical to assume that an index structure will fit into the main memory. To alleviate this problem, we propose a novel technique that reduces the size of an inverted index. In order to reduce the size of an index, the proposed technique rearranges data strings so that the data strings containing the same q-grams can be placed close to one other. Then, the technique encodes those multiple strings into a range. Through an experimental study using real data sets, we show that our technique significantly reduces the size of an inverted index without sacrificing query processing time.

BACKGROUND:Next-generation sequencing (NGS) enables rapid production of billions of bases at a relatively low cost. Mapping reads from next-generation sequencers to a given reference genome is an important first step in many sequencing applications. Popular read mappers, such as Bowtie and BWA, are optimized to return top one or a few candidate locations of each read. However, identifying all mapping locations of each read, instead of just one or a few, is also important in some sequencing applications such as ChIP-seq for discovering binding sites in repeat regions, and RNA-seq for transcript abundance estimation.RESULTS:Here we present Hobbes2, a software package designed for fast and accurate alignment of NGS reads and specialized in identifying all mapping locations of each read. Hobbes2 efficiently identifies all mapping locations of reads using a novel technique that utilizes additional prefix q-grams to improve filtering. We extensively compare Hobbes2 with state-of-the-art read mappers, and show that Hobbes2 can be an order of magnitude faster than other read mappers while consuming less memory space and achieving similar accuracy.CONCLUSIONS:We propose Hobbes2 to improve the accuracy of read mapping, specialized in identifying all mapping locations of each read. Hobbes2 is implemented in C++, and the source code is freely available for download at http://hobbes.ics.uci.edu.

Recently developed query processors for complex events filter data streams to match specific patterns and transform streaming data into meaningful information. To specify the patterns to be matched, complex event processing languages adopt a negation to present an event that should not appear at a specific position. A negation engenders more expressive query forms; however, the indexes must be looked up for each result sequence. In this paper, we review an efficient processing technique for a negation and propose the consecutive event processing in negations (CEPIN) for processing consecutive events in a query with negations. The key component of this proposal is the investigation as to whether the present event type is identical to a previous event type. If it is identical, a calculation to determine the resulting sequence range is not necessary; moreover, the time required for the processing of a negation and the reverse order of a link can be saved. Our experiment shows a reduction in the number of processes and calculations required per event.

In this paper, we study edit similarity query processing to find strings similar to a query string from a collection of strings. To solve the problem, many algorithms have been proposed under a filter-and-verification framework, where candidate strings are generated and refined using a few filters and then verified to find true matches. A major focus of those algorithms has been on generating candidates as small as possible in an early stage of the query processing. A typical approach to generate candidates is to extract some signatures from a query and take union of string ids in the inverted lists of the extracted signatures. However, the number of candidates generated from existing techniques is extremely larger than the number of answer strings and costs for refinement and verification are expensive. To address the problem, we propose an intersection-based candidate generation scheme, which generates a substantially smaller number of candidates. Given some signatures of a query, the proposed scheme first categorizes signatures into several groups. Then, it takes intersection of string ids in the inverted lists of the signatures in each group. Finally, it takes union of the intersections to generate candidates. To minimize the number of candidates under our scheme, we propose a novel algorithm which judiciously selects an optimal signature group. We show through experiments that our technique is very effective in reducing the number of candidates and significantly improves the performance. HighlightsWe develop an intersection based candidate generation scheme.We prove that candidates can be generated using a DNF of inverted lists.We propose a dynamic programming algorithm to select an optimal generation plan.We experimentally show that the proposed technique outperforms existing techniques.