A new approach to mine frequent patterns using item-transformation methods

Abstract

Mining frequent patterns is a fundamental and crucial task in data-mining problems. The algorithms reported in the literature for mining frequent patterns can be classified into two approaches: the candidate generation-and-test approach (for example, the Apriori algorithm) and the pattern-growth approach (such as the FP-growth algorithm). The approaches both suffered from the problems that their speed is slow for large databases. This paper proposes a novel and simple approach, which does not belong to the above two approaches. This approach treats the database as a stream of data and finds frequent patterns by scanning the database only once. In addition, the approach can incrementally mine frequent patterns if the database is updated or inserted subsequently. Three versions of the approach (i.e., mapping-table, transformation-function, and logic-circuit) are provided. The logic-circuit version is the first one that mines frequent patterns by simple logic gates, and the modeling of this version shows its speed is thousands of times faster than that of the FP-growth algorithm. Analyses and simulations of the approach are also performed. Analyses show that the transformation-function version is much better than the Apriori and FP-growth ones in storage complexity. Simulation results show that the mapping-table version is comparable to the FP-growth algorithm in execution time.

Introduction

Data mining has become more important than ever since it can discover valuable but hidden knowledge from databases. The applications of data mining can be found in many areas such as evaluating risks of financial investment, detection of credit-card fraud, and healthcare research on the population [1], [2], [3], [4]. A pattern is a specific itemset in a database, which consists of the items in the database. A pattern is called a frequent pattern if its frequency of occurrence is larger than or equal to a predefined threshold (called the minimum support threshold).

Mining frequent patterns is a fundamental and crucial step used to solve the problems in the areas such as association rules [5], [6], correlations [7], sequential patterns [8], [9], classification [10], maximal frequent patterns [11], [12], [13], and frequent closed patterns [14], [15], [16]. According to the literature [3], [17], the algorithms for mining frequent patterns can be classified into two approaches, namely, candidate generation-and-test and pattern-growth. The representative algorithm of the first approach is the Apriori algorithm [5]. The Apriori and the Apriori-like algorithms [4], [18], [19], [20], [21] all need to generate a candidate set from the database and then evaluate each candidate in the set to check whether the candidate is a frequent pattern. In evaluating these candidates, the approach needs to scan databases as many times as the maximal length of the patterns. Although the approach is simple, it is time-consuming when databases are large. The second approach, also including a lot of algorithms [4], [6], [14], [22], [23], [24], is proposed to increase the speed of mining process by reducing the times of the scans of databases. The FP-growth algorithm [6], the most famous one of the approach, uses a compact data structure, called an FP-tree, to store the transaction information of the database. Instead of scanning the database, the algorithm scans the FP-tree to find frequent patterns. Compared to the first approach, the second approach is more efficient but needs more space to store the intermediate data structure.

In enterprises, new data is produced continuously, and the influence of the obsolete data should be decreased. Managers need to periodically mine databases to reflect the current state of transactions and tune their marketing strategies subsequently. For mining the newest databases, the candidate generation-and-test approach needs to run the entire mining process again, while the pattern-growth approach needs to re-build the intermediate data structure (such as the FP-tree) and then performs the pattern-growth operation again [6].

This paper proposes a simple and new approach that does not belong to the above two approaches. It uses a simple method to transform the transactions from databases into their corresponding patterns and accumulates the frequency of occurrence of these patterns. After scanning all the transactions, the approach can immediately find frequent patterns. In addition, the approach can incrementally mine databases if some transactions are inserted, deleted, or updated subsequently. Three versions of this approach are proposed: one is developed upon a mapping table, another is upon a transformation function, and the other is implemented by logic circuit. As we knew from the literature, the third version is the first one to mine the frequent patterns by logic circuit. The execution time of the logic-circuit version, as expected, is much faster than those of all the other algorithms. The simulations show that the transformation-function version performs a little inferior than the FP-growth algorithm [6], but the transformation-table version performs better than the FP-growth algorithm under the condition that the number of the items is not large.