Approximate-Closed-Itemset Mining for Streaming Data Under Resource Constraint

TL;DR

This paper introduces a novel resource-constrained approximate closed-itemset mining algorithm for streaming data, effectively balancing memory usage and error bounds, and outperforming existing methods.

Contribution

It proposes a new condensed representation called Δ-covered set for resource-constrained streaming data mining, extending closedness compression with bounded error.

Findings

The proposed algorithm outperforms state-of-the-art methods in efficiency.

It effectively balances memory constraints and approximation accuracy.

Empirical results demonstrate significant improvements over existing approaches.

Abstract

Here, we present a novel algorithm for frequent itemset mining for streaming data (FIM-SD). For the past decade, various FIM-SD methods in one-pass approximation settings have been developed to approximate the frequency of each itemset. These approaches can be categorized into two approximation types: parameter-constrained (PC) mining and resource-constrained (RC) mining. PC methods control the maximum error that can be included in the frequency based on a pre-defined parameter. In contrast, RC methods limit the maximum memory consumption based on resource constraints. However, the existing PC methods can exponentially increase the memory consumption, while the existing RC methods can rapidly increase the maximum error. In this study, we address this problem by introducing the notion of a condensed representation, called a $\Delta$-covered set, to the RC approximation. This notion is regarded as an extension of the closedness compression and when $\Delta = 0$, the solution corresponds to an ordinary closed itemset. The algorithm searches for such approximate closed itemsets that can restore the frequent itemsets and their frequencies under resource constraint while the maximum error is bounded by an integer, $\Delta$. We first propose a one-pass approximation algorithm to find the condensed solution. Then, we improve the basic algorithm by introducing a unified PC-RC approximation approach. Finally, we empirically demonstrate that the proposed algorithm significantly outperforms the state-of-the-art PC and RC methods for FIM-SD.

Tables

Table 1. Table 1: Summary of online itemset mining methods

Method	Approach	Solution	Accuracy	Memory
CLAIM [28]	PC	Relaxed CFIs	High	Medium
StreamMining [15]	PC	FIs	High	Exhaustive
CloStream [33]	NC	Closed FIs	Exact	High
Skip LC-SS [32]	RC	FIs	Low	Constant
IncMine [8]	PC	SFCIs	High	Medium
PARASOL (this study)	Hybrid	$\Delta$-covered set	High	Constant

Table 2. Table 2: Characteristics of the used datasets

No	Datasets	$n$	$\left|I\right|$	$L$	$L_{ave}$
1	earthquake	16,764	1,228	73	2.5
2	weblog	19,465	9,958	106	18.2
3	retail	88,162	16,469	76	10.3
4	accidents	340,183	468	51	33.8
5	chess	3,196	75	37	37
6	connect	67,557	129	43	43
7	kosarak	990,002	41,270	2,498	8.1
8	pumsb	49,046	2,112	74	73.6
9	mushroom	8,124	119	23	23
10	hadoop	3,655,760	1,941,291	1,000	30.6

Table 3. Table 3: Skip LC-SS versus The baseline algorithm

	Skip LC-SS			Baseline algorithm
No	$\Delta \left(n\right)$	$\Delta \left(n\right)$/$n$	Time	$\Delta \left(n\right)$	$\Delta \left(n\right)$/$n$	Time
1	157	0.0094	0.15	20	0.0012	0.23
2	11,792	0.61	10	2,953	0.15	0.29
3	23,987	0.27	3.8	156	0.0018	1.20
4	340,182	1	16	179,683	0.53	1.40
5	3,196	1	20	2,434	0.76	4.50
6	67,556	1	18	62,736	0.93	2.10
7	113,143	0.11	1.8	2,681	0.0027	0.69
8	49,046	1	18	42,513	0.87	2.70
9	8,124	1	15	492	0.061	1.80

Table 4. Table 4: MOA-IncMine versus PARASOL

	MOA-IncMine		PARASOL with $\Delta$-compression
No	Time	#Num	$\Delta \left(n\right)/n$	Time	#Num ($k\left(n\right)$)
1	0.16 s	19	0.1	1.7 s	20 (23)
2	2 m, 46 s	16,270	0.1	12.92 s	182 (42,204)
3	0.68 s	58	0.1	3.02 s	30 (50)
4	OM	-	0.374	114 m, 7 s	4,194 (100k)
5	OM	-	0.611	9 m, 25 s	2,780 (100k)
6	TO	-	0.761	44 m, 32 s	3,833 (100k)
7	5.56 s	14	0.1	29.21 s	10 (15)
8	OM	-	0.779	29 m, 43 s	7,437 (100k)
9	2 m, 47 s	3,430	0.1	8.49 s	938 (6,290)

Table 5. Table 5: Pruning effects of using the weeping tree

	Visiting	Non-
No	ratio	empty	#Num-	#Num+	Time-	Time+
	(%)	ratio			(sec)	(sec)
1	38.4	5.0	5,129	3,895	2.23	0.89
2	4.8	13.3	345	138	1.05	0.00
3	68.6	22.6	9,367	6,503	4.39	3.36
4	19.9	52.0	2,010	626	1.49	0.07
5	41.8	55.1	1,468	446	1.63	0.05
6	42.9	62.9	3,418	535	1.48	0.16
7	32.6	15.0	5,589	3,258	2.17	0.74
8	44.4	57.9	6,004	1,267	2.26	0.7
9	36.4	12.5	4,417	2,251	3.33	0.75

Equations

$${\mathcal{C}}_i$$

$$c_r-{\Delta }_r\le sup(\alpha ,i)\le c_r.$$

$$\{y|y\in C(x)and\nexists y^{\prime }\in C(x)s.t.y\ne y^{\prime }andy\in C(y^{\prime })\}.$$

$${\mathcal{S}}_4^3=⟨\{1,2,3,5\},\{1,2,4\},\{2,3,4\},\{1,2,5\}⟩.$$

Full text

1 Introduction

Streaming data analysis is a central issue in many domains such as computer system monitoring [25], online text analysis [35, 34], financial and economic analyses [36, 37], and medical and health record data analysis [12, 17]. Streaming data is an infinite and continuous sequence of data, and, nowadays, is generated and collected rapidly. The sudden emergence of an intensive bursty event, called concept drift, in streaming data can make it difficult to extract meaningful information from such data. Therefore, there is a strong and growing need for powerful methods that are robust against concept drift in large-scale streaming data analysis.

Frequent itemset mining for streaming data (FIM-SD) [11] is the most fundamental and well-used task in streaming data analysis. It is used to find frequently occurring itemsets (in this study, sets of non-negative integers) in streaming data (in this study, a sequence of itemsets). FIM-SD must exhibit two important properties; (i) the real time property, which is the ability to process a huge volume of itemsets continuously arriving at high speed and simultaneously (on-the-fly) output the detected frequent itemsets (FIs); and (ii) memory efficiency, which is the ability to enumerate FIs while managing an exponential number of candidate FIs with limited memory. Concept drift suddenly introduces huge itemsets that must be processed, which demands a huge amount of memory. This makes it difficult to design scalable and efficient FIM-SD. Thus, the development of a space-efficient FIM-SD that is especially robust against concept drift is an important open challenge that must be solved to enable large-scale streaming data analysis.

Two major classes of solutions to compactly represent FIs in FIM-SD have been proposed: closed FIs, which have no frequent supersets with the same support, and maximal FIs, which are not contained in any other FI. Mining closed and maximal itemsets allows the number of solutions to be reduced by orders of magnitude compared with the mining of all FIs, which significantly reduces the memory consumed by FIM-SD. However, since an exponential number of closed or maximal itemsets may still exist, the risk of huge memory consumption by FIM-SD remains.

Recent research on FIM-SD [22, 15, 28, 19, 8, 27, 32, 26] has mainly pursued two directions: parameter constrained (PC) mining and resource constrained (RC) mining. In PC mining [29, 7, 8, 27, 26], an intermediate solution between closed and maximal itemsets, called a semi-frequent closed itemset (SFCI), is computed; a parameter, $\epsilon$, controls the maximum error that can be included in the restored frequencies. Although PC mining enables a huge memory reduction compared with closed and maximal itemset mining, it still consumes huge amounts of memory when processing concept drift [13, 3]. This is illustrated in Figure 1, which shows examples of the number of SFCIs mined by MOA-IncMine [26] which is the state-of-the-art PC method, in a dataset of a hadoop grid logs [30]. The results show that the number of SFCIs bursts when processing the 12th segment of transactions (which represents concept drift) in the case when $\epsilon$ is low (0.12), resulting in huge memory consumption.

On the other hand, RC mining is another approximation working under resource (i.e., memory) constraint; Skip LC-SS is a representative RC mining method [32]. RC mining works in a constant space based on a user-defined parameter and returns approximate solutions of FIs; this represents a significant advantage. However, a major disadvantage of RC mining is the large error in approximate solutions due to the strict space constraint, rendering some solutions in the output useless [32].

Contributions. In this study, we tackle the problem of approximation error in RC mining by introducing a novel condensed representation called a $\Delta$-covered set. The notion of $\Delta$-cover is regarded as an extension of closedness compression and allows the original FIs to be compressed while bounding the maximum error by an integer, $\Delta$.

First, we propose a new RC method to find this condensed solution. The approach involves two key techniques: incremental intersection, which is an incremental way to compute the closed itemsets [1, 33], and minimum entry deletion, which is a space-saving technique for the RC approximation [24, 32]. Consequently, the proposed method exhibits the following three characteristics:

On-the-fly manner:

it can process any transaction that has $L$ items in $O(k)$ space in almost $O(kL)$ time.

Anytime feature:

it can monitor the maximum error, $\Delta$, and return the output, $T$, at anytime.

Quality of output:

for every FI $\alpha$, $T$ contains some superset $\beta$ of $\alpha$ such that the difference between the frequencies of $\alpha$ and $\beta$ is at most $\Delta$.

Next, we present a modification of this baseline method. As shown in Figure 1, sudden and intensive memory consumption can be considered a temporary phenomenon. Indeed, normal PC approximation is sufficient except for within a brief period. From the viewpoint of memory efficiency, it is reasonable to switch between PC and RC approximations. Thus, in this study, we call such a “unified” approach PARASOL. In PARASOL, the memory consumption is generally controlled using an error parameter and an RC approximation using a size constant is taken only in certain scenarios. In addition, we present a post-processing technique called $\Delta$-compression to reduce the size of the raw output to yield a more concise $\Delta$-covered set. Moreover, we investigate a data structure to efficiently carry out the key operations in the proposed method. Finally, we empirically show that the proposed method outperforms the existing PC and RC methods when applied to various real datasets.

The remainder of the paper is organized as follows. Section 2 is a preliminary. Section 3 presents a brief review of the existing methods. Section 4 describes the baseline algorithm used to compute a $\Delta$-covered set, and Section 5 describes PARASOL and $\Delta$-compression. The utilized data structure is discussed in Section 6. The experimental results are summarized in Section 7, and we conclude in Section 8.

2 Notation and Terminology

Let $I=\{1,2,\ldots,N\}$ be the universal set of items. Itemset $t$ is a non-empty subset of $I$, i.e., $t\subset I$. Data stream ${\mathcal{S}}_{n}$ is the sequence of itemsets $\langle t_{1},t_{2},\ldots,t_{n}\rangle$ for which $t_{i}\subset I$ for $i=1,2,...,n$ where $n$ denotes the timestamp for which an output is requested by the user. Each $t_{i}$ is called transaction at timestamp $i$. The number of items in $t_{i}$ (i.e, the cardinality) is denoted as $|t_{i}|$ and is referred to as the length of $t_{i}$. $L$ denotes the maximum length of the transactions in ${\mathcal{S}}_{n}$. For itemset $\alpha\subset I$ and timestamp $i$, $tran(\alpha,i)$ denotes the family of itemsets that include $\alpha$ as a subset at timestamp $i$ (i.e., $tran(\alpha,i)=\{t_{j}~{}|~{}\alpha\subseteq t_{j},\ 1\leq j\leq i\})$. Support $sup(\alpha,i)$ of itemset $\alpha$ at timestamp $i$ is defined as $|tran(\alpha,i)|$. Given a minimum support threshold $\sigma$ ($0\leq\sigma\leq 1)$, if $sup(\alpha,n)>\sigma n$, then $\alpha$ is frequent with respect to $\sigma$ in ${\mathcal{S}}_{n}$. ${\cal F}_{n}$ denotes the family of FIs with respect to $\sigma$ at timestamp $n$ in ${\mathcal{S}}_{n}$, i.e., ${\cal F}_{n}=\{\alpha\subset I|\sup(\alpha,n)>\sigma n\}$. FI $\alpha$ is closed if there is no $\alpha$’s proper superset whose frequency is equal to $\alpha$’s frequency in ${\cal F}_{n}$. On the other hand, FI $\alpha$ is maximal if there is no $\alpha$’s proper superset in ${\cal F}_{n}$.

2.1 Problem setting

In this paper, to overcome the limitation of the state-of-the-art PC and RC methods, one key idea is to formalize a novel FIM-SD problem in which we seek a condensed representation of FIs with limited memory. This condensed representation is defined as follows:

Definition 1** ($\Delta$-cover)**

Let $\alpha$ and $\beta$ be two itemsets. If $\alpha\subseteq\beta$ and $sup(\alpha,i)\leq sup(\beta,i)+\Delta$ for a non-negative integer $\Delta$, then $\alpha$ is $\Delta$-covered by $\beta$ at timestamp $i$; this state is denoted by $\alpha\preceq_{\Delta}^{i}\beta$.

Definition 2** ($\Delta$-covered set)**

*Let $P$ and $Q$ be two families of itemsets. If $\forall\alpha\in P$ $\exists\beta\in Q$ such that $\alpha\preceq_{\Delta}^{i}\beta$ for a non-negative integer $\Delta$, then $Q$ is a $\Delta$-covered set of $P$ at timestamp $i$. *

Example 1

*Consider the family, $P$ of four itemsets $\alpha_{1}$, $\alpha_{2}$, $\alpha_{3}$, and $\alpha_{4}$, shown in Figure 2. For $Q_{0}=\{\alpha_{1},\alpha_{3},\alpha_{4}\}$, $Q_{1}=\{\alpha_{3},\alpha_{4}\}$ and $Q_{2}=\{\alpha_{4}\}$. Hence, $Q_{0}$, $Q_{1}$ and $Q_{2}$ are [math]-covered, $1$-covered and $2$-covered sets of $P$, respectively. *

A $\Delta$-covered set is a generalization of the closed itemsets. A [math]-covered set of the family ${\cal F}$ of FIs is equal to the closed itemsets of the same family ${\cal F}$. Furthermore, each FI and its frequency can be recovered from a $\Delta$-covered set with an error that is bounded by $\Delta$; this property is called $\Delta$-deficiency. Let us consider the 2-covered set $Q_{2}$, in Example 1. Given anti-monotonicity with respect to frequency, $sup(\alpha_{4},5)\leq sup(\alpha_{i},5)$ ($1\leq i\leq 3$) holds. Since $Q_{2}$ is a 2-covered set of $P$, $\alpha_{4}\preceq_{2}^{5}\alpha_{i}$ so $sup(\alpha_{i},5)\leq sup(\alpha_{4},5)+2$. Since both $3\leq sup(\alpha_{i},5)$ and $sup(\alpha_{i},5)\leq 5$ hold, the error is bounded by $2$.

The objective is to find a $\Delta$-covered set of ${\cal F}_{n}$ for a non-negative integer, $\Delta$, while processing each transaction $t_{i}$ ($1\leq i\leq n$) only once. As explained before, PC mining and RC mining approaches for FIM-SD have been established. PC mining controls $\Delta$ according to an error parameter, $\epsilon$, such that $\Delta\leq\epsilon n$; however, in the worst case, an exponential number of candidate itemsets must be stored with this approach. Indeed, it is not feasible for any PC method to solve this problem in $O(k)$ space for a constant $k$.

Hence, we aim to design an RC method by which $\Delta$ is kept as small as possible based on a given value of $k$, which bounds the memory consumption. Herein, we present a novel RC method to find a $\Delta$-covered set of ${\cal F}_{n}$ for a given $k$ in $O(kLn)$ time and $O(k)$ space, where $L$ is the maximum length of transactions and $n$ is the end timestamp.

3 Related work

Several methods have been proposed for mining condensed representations [29, 7, 28, 8, 2, 21]. In this section, we briefly review the state-of-the-art techniques.

3.1 Related work on offline mining methods

Boley et al. [2] proposed an offline algorithm to enumerate $\Delta$-closed sets from a transaction database. This method involves the use of a closure operator, in which each fixed point corresponds to a $\Delta$-closed set, to compute the frequent $\Delta$-closed sets, ${\cal F}_{\Delta}$. The computation time is $O(N^{2}n|{\cal F}_{n}|)$. Unlike $\Delta$-covered sets, ${\cal F}_{\Delta}$ does not satisfy the $\Delta$-deficiency requirement while ${\cal F}_{\Delta}$ is included in any $\Delta$-covered set; this limitation restricts the potential applications of this method. The appendix details the relationship between ${\cal F}_{\Delta}$ and any $\Delta$-covered set.

Xin et al. [29] introduced another relaxed metric, called the $\delta$-cluster, which is a $\Delta$-deficient condensed representation based on a relative error metric. In that study, NP-hardness was applied to find the minimum $\delta$-cluster covering the FIs. In addition, a two-pass algorithm, called RP-local, was introduced to construct a $\delta$-cluster based on a greedy strategy. Liu et al. [21] improved the efficiency for computing the $\delta$-cluster using a CFP-tree.

Cheng et al. [7] introduced a condensed representation, called a $\delta$-tolerance closed set, and presented a two-pass algorithm to enumerate $\delta$-tolerance closed sets using an FP tree. Unlike $\delta$-clusters, the maximum error is not controlled by the value $\delta$.

3.2 Related work on online mining methods

Recently, several online algorithms for dealing with lossy condensed representations were proposed; several representative algorithms are summarized in Table 1.

Song et al. [28] presented the notion of relaxed closed itemsets which is a $\Delta$-deficient condensed representation. Given an error parameter, $\epsilon$, the frequency range of the itemsets is divided into $\lceil\frac{1}{\epsilon}\rceil$ intervals. Then, closed itemsets representing upper or lower bounds for each interval with respect to the inclusion relation were identified. By definition, these closed itemsets composed a $\Delta$-covered set. Thus, the notion of $\Delta$-covered sets is regarded as a generalization of the relaxed closed itemsets. This study also included the development of an online PC approximation algorithm called CLAIM, which incrementally updates relaxed closed itemsets by computing the drifted itemsets for each timestamp. However, CLAIM invokes a relatively complex updating process which makes it slow.

Cheng et al. [8] proposed an incremental method called IncMine to compute semi-frequent closed itemsets (SFCIs). IncMine incrementally maintains SCFIs for each segment (i.e., each set of transactions) in two steps: computing the SFCIs in the current segment followed by updating whole set of SFCIs based on the newly computed ones. Compared with CLAIM, IncMine utilizes various pruning techniques and efficient data structure. IncMine was implemented in a massive online analysis (MOA) platform which enables it widely distributed  [26]. However, the updating process used by IncMine still requires subsets to be enumerated for each SCFI, resulting in a large time delay in some cases. Even worse, it is unknown if the obtained SFCIs are $\Delta$-deficient.

StreamMining [15] is a PC approximation method that seeks FIs. Based on an error parameter, $\epsilon$, it deletes itemsets that are not promising as they have frequencies less than or equal to $\epsilon\times n$. The accuracy of the solution (i.e., the maximum error in the restored frequencies) can be directly controlled by $\epsilon$. However, this process involves a combinatorial explosion of the FIs causing huge memory consumption. CloStream [33] is a non-constrained (NC) online method that computes closed FIs exactly. Its solution is oriented to condensed representation of FIs, while memory efficiency is bounded by the limitation of lossless compression based on closedness.

To our knowledge, IncMine [8, 26] is the state-of-the-art PC method for condensed representation mining. Unlike IncMine, PARASOL takes RC approximation just in case for processing concept drifts. Then, it can tolerate any busty transaction without memory overflow. In usual, it takes the PC approximation to keep the accuracy of its solution high, provided that the solution ensures the $\Delta$-deficiency property.

Skip LC-SS [32] is an RC method that seeks FIs based on a space-saving technique [24]. Given a size constant $k$, it can process any transaction with length $L$ in $O(k)$ space and $O(kL)$ time, keeping the top-$k$ itemsets with respect to their frequencies. However, Skip LC-SS must increment $\Delta$ by one, whenever a transaction $t_{i}$ that satisfies $2^{|t_{i}|}>k$ is processed; hence, it suffers from a rapid increase in $\Delta$ in accordance with $k$.

To mitigate this issue, PARASOL introduces a lossy condensed representation of FIs and takes RC approximation only for processing concept drifts. Thus, it can tolerate bursty transactions without causing memory overflow. In most cases, however, PARASOL uses the PC approximation to keep the accuracy of the solution high provided that the solution exhibits $\Delta$-deficiency.

Compared with the previously developed techniques, the present approach is novel in that is combines PC and RC methods to mine a $\Delta$-deficient solution. Although several online algorithms for FIM-SD have been proposed so far, none offer both high accuracy and space efficiency. Unlike the alternative methods, PARASOL avoids sudden and intense memory consumption associated with concept drift.

4 Baseline algorithm for online $\Delta$-covered set mining

PARASOL mines a $\Delta$-deficient condensed solution based on one-pass approximation settings. PARASOL is built on two key techniques: incremental intersection and minimum entry deletion, which are described in detail in this section.

Incremental intersection [1, 33] is used for computing the closed itemsets. It is based on the following cumulative and incremental features of the closed itemsets. Let ${\cal C}_{i}$ be the family of closed itemsets in ${\cal S}_{i}$.

Theorem 1

[1, 33] Given ${\cal C}_{i}$ at timestamp $i$ and transaction $t_{i+1}$ at timestamp $i+1$, ${\cal C}_{i+1}$ is defined as follows:

[TABLE]

Theorem 1 ensures that ${\cal C}_{i+1}$ can be computed from the intersection of each itemset in ${\cal C}_{i}$ with $t_{i+1}$.

Example 2

Let $I=\{1,2,3,4,5\}$ and the stream ${\cal S}_{4}^{2}=\langle t_{1},t_{2},t_{3},t_{4}\rangle$ where $t_{i}=I-\{i\}$ for each $i$ $(1\leq i\leq 4)$. Figure 3 illustrates how ${\cal C}_{i}$ is incrementally generated until $i=3$. ${\cal C}_{1}$ consists of the first transaction. ${\cal C}_{2}$ newly contains $\alpha_{2}$ and $\alpha_{3}$, which correspond to the second transaction and its intersection with $\alpha_{1}$, respectively. Finally, ${\cal C}_{3}$ and ${\cal C}_{4}$ consist of the seven and fifteen closed itemsets, respectively.

An incremental intersection never unfolds a transaction to intermediate subsets. In this sense, it can simply but efficiently compute only the closed itemsets. On the other hand, lossless compression based on closedness cannot necessarily control an exponential increase in the number of closed itemsets; in the worst case, $\Omega(2^{L})$ closed itemsets can be generated. In Example 2, there is a total of fifteen closed itemsets from ${\cal S}_{4}^{2}$, which is almost the same as the $2^{L}$ closed itemsets that are attained for $L=4$.

Next, we introduce a space-saving technique  [24, 32] for RC approximation, called minimum entry deletion. Given a size constant, $k$, RC methods generally sweep the currently stored itemsets and keep only the top-$k$ itemsets; in other words, the itemset with the lowest frequency is deleted iteratively as long as the number of stored itemsets is greater than $k$. The maximum frequency of the deleted itemsets is maintained as the maximum error, $\Delta$.

PARASOL manages two types of information for each stored itemset: its estimated frequency and maximum error. They are represented as a tuple entry of the form $\langle\alpha,c,\Delta\rangle$, which represents the stored itemset, the frequency count, and the error count, respectively. The itemset, frequency count, and error count of an entry, $e$, are often denoted by $\alpha_{e}$, $c_{e}$, and $\Delta_{e}$, respectively.

Example 3

Consider ${\cal S}_{4}^{2}$ again. Let $k=3$. The number of ${\cal C}_{3}$ is beyond $k=3$ at timestamp $i=3$. As shown in Figure 4, we remove four closed itemsets in order of increasing frequency; the highest frequency of those that are removed is two. The next transaction, $t_{4}$, is stored in the entry $\langle t_{4},3,2\rangle$, meaning that the true frequency of $t_{4}$ is between one and three (i.e., $1\leq sup(t_{4},4)\leq 3$).

In the following, $T_{i}$ denotes the collection of entries used at timestamp $i$, $k(i)$ denotes the number of entries in $T_{i}$, and $\Delta(i)$ denotes the maximum error at timestamp $i$. A minimum entry in $T_{i}$ is an entry whose frequency count is the lowest of those in $T_{i}$. The baseline algorithm is described in Algorithm 1.

The updating process is composed of entry addition and entry deletion for each timestamp. The addition operation is carried out by the function $intersect(T_{i-1},t_{i})$, which performs the incremental intersection. The deletion operation is realized by the function $delete(T_{i})$, which performs the minimum entry deletion.

Example 4

Consider $T_{4}$ again as shown in Figure 4. $T_{4}$ corresponds to the output of Line 5 in Algorithm 1 at time $i=4$ for the input stream ${\cal S}_{4}^{2}$ and $k=3$. By the deletion process of Line 6, $\Delta(4)$ becomes three. Now, we assume that the top three entries in $T_{4}$ remain as shown in Figure 5. Next, let the transaction arriving at time $i=5$ be $t_{5}=\{1,3,5\}$. Then, by the addition process, we first add the entry $\langle t_{5},3,3\rangle$ to $T_{4}$, since there is no entry for $t_{5}$ in $T_{4}$. After that, the intersection of each itemset stored in $T_{4}$ with $t_{5}$ is computed and stored in $C$. In total, $C$ consists of three entries. Then, $T_{5}$ is obtained by updating $T_{4}$ with $C$ as shown in Lines 15-22 using the intersect function. Finally, one minimum entry, $\langle\{2,5\},3,0\rangle$, is deleted from $T_{5}$ to ensure that $k(5)\leq k$.

Next, we clarify the quality of the output.

Theorem 2

Algorithm 1 outputs a $\Delta(n)$-covered set of the FIs wrt $\sigma$, provided that $\Delta(n)\leq\sigma n$.

This implies that for every FI, $\alpha$, $T_{n}$ must contain an entry, $e$, in which $\alpha$ is $\Delta(n)$-covered by $\alpha_{e}$. To demonstrate this feature, we introduce the notion of a representative entry.

Definition 3

Let $\alpha$ be an itemset. Given $T_{i}$, $T_{i}^{\alpha}$ is used to denote the set of entries in $T_{i}$ that contains such an itemset $\beta$ that $\alpha\subseteq\beta$. If $T_{i}^{\alpha}$ is not empty, a representative entry, $r$, for $\alpha$ is defined as an entry that has the maximum frequency count of those in $T_{i}^{\alpha}$ (i.e., $r=argmax_{e\in T_{i}^{\alpha}}(c_{e})$).

Then, for every FI, $\alpha$, and a representative entry, $r$, of $\alpha$, we claim that $\alpha$ is $\Delta(n)$-covered by $\alpha_{r}$. This claim can be explained as shown in Figure 5: Since $\Delta(5)=3$, we set $\sigma=0.6$ to ensure that $\Delta(5)\leq\sigma\times 5$. There exist five FIs $\{1\},\{3\},\{5\},\{1,5\},\{3,5\}$ wrt $\sigma$ in ${\cal S}_{5}^{2}$. Let $\alpha$ be the FI $\{3,5\}$. $T_{5}^{\alpha}$ uniquely contains the entry $r=\langle\{1,3,5\},4,3\rangle$. Hence, $r$ is the representative entry of $\alpha$. Note that $\alpha=\{3,5\}$ is $1$-covered by $\alpha_{r}=\{1,3,5\}$, since $sup(\{1,3,5\},5)=3$ and $sup(\{3,5\},5)=4$.

First, we prove the following proposition and two lemmas.

Proposition 1

Let $e$ be an entry in $T_{i}$. Then, $e$ is a representative entry for $\alpha_{e}$.

Proof. Suppose that $e$ is not a representative entry. Then, there exists another entry, $e^{\prime}\in T_{i}$, such that $\alpha_{e}\subseteq\alpha_{e^{\prime}}$ and $c_{e}<c_{e^{\prime}}$. This contradicts the anti-monotonicity in $T_{i}$, which is proved by using the mathematical induction, following the below argument. First, since $T_{1}$ contains only one entry, $T_{1}$ satisfies the anti-monotonicity property. Assume that $T_{i}$ satisfies this property (i.e., for every two entries, $e$ and $e^{\prime}$, if $\alpha_{e}\subseteq\alpha_{e^{\prime}}$ then $c_{e}\geq c_{e^{\prime}}$ holds). Then, by the cumulative feature of the incremental intersection, the output of the function $intersect(T_{i},t_{i+1})$ also exhibits anti-monotonicity. Moreover, this property is preserved by the deletion process. Therefore, $T_{i+1}$ also exhibits the anti-monotonicity. $\Box$

Lemma 1

Let $\alpha$ be an itemset. Given $T_{i}$, if there exists a representative entry $r$ for $\alpha$ in $T_{i}$, then it holds that

[TABLE]

Proof. We use the mathematical induction. $T_{1}$ consists of only one entry, $\langle t_{1},1,0\rangle$. Since $k>0$, this entry is not deleted. Accordingly, this lemma is true in the case of $T_{1}$. Assume that $T_{i}$ satisfies the claim of the lemma. Let $\alpha$ be an itemset whose representative entry, $r_{i+1}$, exists in ${T_{i+1}}$. Now, we consider two cases for the existence of a representative entry $r_{i}$ for $\alpha$ in $T_{i}$.

Case 1: $r_{i}$ exists. Based on the assumption, we have $c_{r_{i}}-\Delta_{r_{i}}\leq sup(\alpha,i)\leq c_{r_{i}}$. If $\alpha\not\subseteq t_{i+1}$, then $c_{r_{i+1}}=c_{r_{i}}$ because $T_{i}^{\alpha}\supseteq T_{i+1}^{\alpha}$ and $T_{i+1}^{\alpha}\neq\emptyset$ (i.e., the maximum frequency count in $T_{i}^{\alpha}$ is preserved in $T_{i+1}^{\alpha}$ by the minimum entry deletion); thus, since $sup(\alpha,i+1)=sup(\alpha,i)$, $c_{r_{i+1}}-\Delta_{r_{i}}\leq sup(\alpha,i+1)\leq c_{r_{i+1}}$. Otherwise, since $\alpha\subseteq t_{i+1}$, $c_{r_{i+1}}=c_{r_{i}}+1$ holds because $T_{i+1}$ contains the entry for $\alpha_{r_{i}}\cap t_{i+1}$ which has a frequency count of $c_{r_{i}}+1$. Since $sup(\alpha,i+1)=sup(\alpha,i)+1$, $c_{r_{i+1}}-\Delta_{r_{i}}\leq sup(\alpha,i+1)\leq c_{r_{i+1}}$. Finally, since $\Delta_{r_{i}}\leq\Delta_{r_{i+1}}$, we have $c_{r_{i+1}}-\Delta_{r_{i+1}}\leq sup(\alpha,i+1)\leq c_{r_{i+1}}$.

Case 2: $r_{i}$ does not exist. This means that $\alpha$ or its supersets never appear or have been deleted before the time $i$. Hence, $sup(\alpha,i)$ is at most $\Delta(i)$, because $\Delta(i)$ is the upper bound of the frequencies of the deleted itemsets. Since $r_{i+1}$ exists but $r_{i}$ does not, $r_{i+1}$ corresponds to $\langle t_{i+1},1+\Delta(i),\Delta(i)\rangle$. Hence, $\alpha\subseteq t_{i+1}$ holds. Accordingly, $1\leq sup(\alpha,i+1)\ \leq 1+\Delta(i)$ holds. Since $c_{r_{i+1}}=1+\Delta(i)$ and $\Delta_{r_{i+1}}=\Delta(i)$, it holds that $c_{r_{i+1}}-\Delta_{r_{i+1}}\leq sup(\alpha,i+1)\leq c_{r_{i+1}}$.

In both cases, $T_{i+1}$ also satisfies the claim of the lemma. $\Box$

Lemma 2

For every itemset, $\alpha$, such that $sup(\alpha,i)>\Delta(i)$, there exists a representative entry $r\in T_{i}$ for $\alpha$.

Proof. We also use the mathematical induction. The lemma is obviously true in the case of $T_{1}$ since $\Delta(1)=0$ holds. Assume that $T_{i}$ satisfies the claim of this lemma; we show the induction step by contradiction. Assume that $\exists\alpha$ such that $sup(\alpha,i+1)>\Delta(i+1)$ but there is no representative entry for $\alpha$ in $T_{i+1}$. We can consider two cases: whether or not a representative entry, $r$, has existed in $T_{i+1}$ before the deletion operation (i.e., in the intermediate $T_{i+1}$ at the moment when the incremental intersection has been completed, as depicted in the middle $T_{i+1}$ in Figure 6).

Case 1: such an $r$ exists in $T_{i+1}$ but was deleted. By Lemma 1, we have $c_{r}-\Delta_{r}\leq sup(\alpha,i+1)\leq c_{r}$. Since $r$ was deleted, $c_{r}\leq\Delta(i+1)$ should hold. Thus, $sup(\alpha,i+1)\leq\Delta(i+1)$ also holds. However, this is a contradiction.

Case 2: such an $r$ does not exist in $T_{i+1}$. Here, $T_{i+1}$ captures the entry table before the deletion operation. Thus, $T_{i}^{\alpha}\subseteq T_{i+1}^{\alpha}$ holds. Since there is no representative entry for $\alpha$ in $T_{i+1}$, it holds that $T_{i+1}^{\alpha}=\emptyset$ and $T_{i}^{\alpha}=\emptyset$. Note that $T_{i+1}$ should contain the entry for $t_{i+1}$. Hence, $\alpha\not\subseteq t_{i+1}$ because $T_{i+1}^{\alpha}=\emptyset$. Therefore, $sup(\alpha,i)=sup(\alpha,i+1)$. Since $sup(\alpha,i+1)>\Delta(i+1)$ and $\Delta(i+1)\geq\Delta(i)$, it should hold that $sup(\alpha,i)>\Delta(i)$. Then, by the assumption for $T_{i}$, there should exist a representative entry for $\alpha$ in $T_{i}$. However, this contradicts the conclusion that $T_{i}^{\alpha}=\emptyset$.

In both cases, there is a contradiction. Therefore, for every $\alpha$ such that $sup(\alpha,i+1)>\Delta(i+1)$, there exists a representative entry for $\alpha$ in $T_{i+1}$. $\Box$

Now, we prove Theorem 2 as follows:

Proof of Theorem 2. Suppose that the condition of $\sigma$ (i.e., $\Delta(n)\leq\sigma n$) is satisfied. Then, by Lemma 2, for every FI $\alpha$ wrt $\sigma$, there exists a representative entry, $r$, in $T_{n}$ for $\alpha$. By Lemma 1, $c_{r}-\Delta_{r}\leq sup(\alpha,n)\leq c_{r}$ holds. By Proposition 1, $r$ is also a representative entry for $\alpha_{r}$. Thus, we have $c_{r}-\Delta_{r}\leq sup(\alpha_{r},n)\leq c_{r}$. Hence, $sup(\alpha,n)\leq sup(\alpha_{r},n)+\Delta_{r}$ holds. Since $\alpha_{r}\supseteq\alpha$, $\alpha$ is $\Delta_{r}$-covered by $\alpha_{r}$. Since $\Delta_{r}\leq\Delta(n)$, we can claim that for every FI $\alpha$, there exists an entry, $r$ , such that $\alpha$ is $\Delta(n)$-covered by $\alpha_{r}$. Note that $c_{r}>\sigma n$ holds because $sup(\alpha,n)>\sigma n$. Hence, $r$ is contained in the output because of Lines 9-11 in Algorithm 1. $\Box$

Next, we clarify the complexity of the baseline algorithm. Incremental intersection generates at most $k(i)+1$ new entries for the intersections of the entries in $T_{i}$ with $t_{i+1}$ as well as $t_{i+1}$ itself; these new entries are added to $C$ in Lines 5 and 10 of the $intersect$ function. Thus, the total number of stored entries is at most $2\times k(i)+1$, and $k(i)$ is always bounded by the size constant $k$. Hence, the complexity of the baseline algorithm can be described as follows:

Theorem 3

For a size constant $k$ and the maximum transaction length $L$, Algorithm 1 processes every transaction in $O(kL+k\log k)$ time and $O(k)$ space.

Proof. First, the number of stored entries is at most $2k+1$ for every time point. Thus, the space required to store them is $O(k)$. In addition, it takes at most $O(2L)$ time to compute the intersection of a stored itemset with a transaction. Thus, the incremental intersection is performed in $O(kL)$ time. It takes at most $O(\log k)$ time to delete a minimum entry and add a new entry by using a heap structure. Hence, the total time required to update the table is at most $O(kL+k\log k)$. $\Box$

Based on Theorems 2 and 3, Algorithm 1 can extract a $\Delta$-covered set of the FIs wrt $\sigma\geq\frac{\Delta}{n}$ for an integer $\Delta$ and can process each transaction in $O(kL)$ time and $O(k)$ space for a size constant $k$ ($k<2^{L}$). Therefore, Algorithm 1 satisfies the problem setting presented in Section 2.1.

5 Improvement of the baseline algorithm

In this section, we introduce two key improvements to the baseline algorithm.

5.1 Unifying PC and RC approximations

We observe in Figure 1 that a sudden and significant memory consumption may occur as a temporary phenomenon. In other words, the PC approximation is feasible unless all of the memory is consumed during this short period. Hence, it is reasonable to embed a size constant, $k$, into the PC approximation and normally perform the deletion operation using an error parameter, $\epsilon$, but switch to an RC approximation only when the number of used entries exceeds $k$. We call this unified approximation scheme PARASOL (an acronym for Parameter- and Resource-constrained Approximation for Soft and Lazy mining).

Unlike the existing PC approximation methods, PARASOL can process any bursty transactions in $O(kL)$ time without running out-of-memory. In contrast, PARASOL can process ordinary transactions without filling all $k$ possible entries while ensuring that the error ratio, $\frac{\Delta(n)}{n}$, is less than or equal to the error parameter, $\epsilon$. This is unlike to the baseline algorithm based on the RC approximation. Given $k$ and $\epsilon$, PARASOL can be realized just by replacing the $delete$ function in Algorithm 1 with the following function:

 

1:function parasol_delete($T_{i}$)

2:     $m:=getMin(T_{i})$ $\triangleright$ $m$ is a minimum entry in $T_{i}$

3:     while $k<k(i)$ or $c_{m}\leq\epsilon\times i$ do

4:         $\Delta(i):=c_{m}$ $\triangleright$ $c_{m}$ is the minimum frequency in $T_{i}$

5:         $deleteMin(T_{i})$ $\triangleright$ delete a minimum entry in $T_{i}$

6:         $m:=getMin(T_{i})$

7:     end while

8:     return $\Delta(i)$

9:end **function **

If there is no deletion for the RC approximation (i.e., $k(i)\leq k$ for every time $i$), PARASOL ensures that $\Delta(i)\leq\epsilon\times i$; otherwise, $\Delta(i)$ can become greater than $\epsilon\times i$. Even in this case, the error ratio, $\frac{\Delta(n)}{n}$ gradually converges to $\epsilon$ as the RC approximation is only required for a short period. This self-sustained recovery of the error ratio is a unique and advantageous characteristic of PARASOL and will be empirically demonstrated later.

5.2 $\Delta$-compression

Note that the solution to this problem setting is not unique: there can exist many $\Delta$-covered sets of ${\cal F}$. However, it is useful to extract a concise $\Delta$-covered set. Here, we propose a fast post-processing technique to reduce the original output to a more concise one based on the maximum error, $\Delta(n)$.

We explain the reasoning using $T_{5}$ (the right-most table in Figure 5) in Example 4. Since $\Delta(5)=3$, the three itemsets stored in $T_{5}$ compose a $3$-covered set of the FIs. Note that if $\{5\}$ was deleted, the two remaining itemsets still compose a $3$-covered set, since $\{5\}$ is $1$-covered by $\{1,5\}$. Hence, we can delete an entry for any such itemset that is $\Delta(n)$-covered by another in $T_{n}$. In exchange for deleting $\{5\}$, we update the entry for $\{1,5\}$ by $\langle\{1,5\},5,1\rangle$ (i.e., incrementing the frequency and error counts by one). In this way, the frequency of $\{5\}$ can be restored from the entry for $\{1,5\}$.

Note here that the frequency count of entry $e$ is not the exact frequency but rather an estimated one (i.e., $c_{e}$ is not necessarily equal to $sup(\alpha_{e},n)$). Therefore, it is difficult to identify all pairs of itemsets that satisfy the $\Delta(n)$-covering relationship in $T(n)$. However, some of them can be detected based on the following proposition:

Proposition 2

Let $e_{1}$ and $e_{2}$ be two entries in $T(n)$. Then, $\alpha_{e_{1}}$ is $\Delta(n)$-covered by $\alpha_{e_{2}}$ if it holds that $\alpha_{e_{1}}\subseteq\alpha_{e_{2}}$ and $c_{e_{1}}\leq c_{e_{2}}-\Delta_{e_{2}}+\Delta(n)$.

Proof. By Lemma 1, we have $sup(\alpha_{e_{1}},n)\leq c_{e_{1}}$ and $c_{e_{2}}-\Delta_{e_{2}}\leq sup(\alpha_{e_{2}},n)$. Since $c_{e_{1}}\leq c_{e_{2}}-\Delta_{e_{2}}+\Delta(n)$, it holds that $sup(\alpha_{e_{1}}n)\leq sup(\alpha_{e_{2}},n)+\Delta(n)$. $\Box$

Based on Proposition 2, we proposed a post-processing technique, called $\Delta$-compression, that incrementally deletes the entry for a $\Delta(n)$-covered itemset from $T(n)$, as described in Algorithm 2.

In exchange for deleting $e_{1}$, $\Delta_{e_{2}}$ is updated by increasing it by the difference between $c_{e_{1}}$ and $c_{e_{2}}$, and $c_{e_{2}}$ is updated to $c_{e_{1}}$ in Lines 4 and 5.

A simple implementation of Algorithm 2 is that for each entry $e_{1}$, we search $T(n)$ for a corresponding $e_{2}$. This can be achieved in $O(k^{2})$ time, since $|k(n)|\leq k$.

6 data structure

In this section, we address the issue of the data structure that is needed to efficiently realize the three key operations of the proposed algorithm: incremental intersection, deletion, and $\Delta$-compression. Of these, incremental intersection incurs the majority of the computational cost. This operation imposes the traverse of every entry, $e$, to compute its intersection with a transaction, $t_{i}$, for each time $i$. This computation is often redundant: for example, if $\alpha_{e}$ has no common items with $t_{i}$, it is redundant to compute the intersection of $\alpha_{e}$ with $t_{i}$.

Based on this observation, Yen et al [33] proposed an indexing data structure, called cid_list, corresponding to the vertical format of the stored itemsets: for each item, $x$, $cid\_list(x)$ maintains the indexes of the entries corresponding to the itemsets that contain $x$. Using $cid\_list$, we can focus only on the entries whose indexes are contained in $\bigcup_{x\in t_{i}}cid\_list(x)$ and compute their intersections with $t_{i}$. However, the computational cost of updating $cid\_list$ is relatively high: the entire $cid\_list$ is dynamically changed by addition and deletion operations. This overhead becomes especially high for dense datasets since most itemsets stored in $T_{i}$ have some of the same items as $t_{i}$.

Borgelt et al [1] proposed a fast two-pass FIM method, called ISTA, based on incremental intersection. In this implementation, the prefix tree (as well as patricia) was introduced to efficiently maintain $T(i)$ and perform the incremental intersection. Although it is reasonable to represent $T(i)$ with such a concise data structure, it is not directly applicable in the one-pass approximation setting that is used here. For example, we cannot use the item frequency as static information, while it is available in the transactional database that allows multi-pass scanning. This information is crucial to constructing a compact trie by sorting items in a pre-processing step. Note that the trie size can be directly affected by the order of (sorted) transactions. Indeed, ISTA constructs the trie with 306 nodes by treating it as a retail problem (No. 3 in Table 2), compared to 244,938 nodes when the pre-processing technique is not applied. Besides, in the context of the SD that emerges concept drift, it is not appropriate to assume a static distribution.

Thus, we consider a novel data structure that is more suitable for our proposed algorithm: it is designed to prune redundant computations in incremental intersections and quickly access the minimum entries and $\Delta$-covered entries as required for PARASOL deletion and $\Delta$-compression.

6.1 Weeping tree

In this paper, we propose a variation of the binomial spanning tree [16, 6], called weeping tree, in which a collection of entries, $T(n)$, can be represented in a binary $n$-cube as follows: Let $e$ be an entry in $T(n)$. By Theorem 1, $\alpha_{e}$ corresponds to the intersection of a certain set $S$ of transactions. This set can be represented as a binary address $(x_{1},x_{2},\ldots,x_{n})$ where each $x_{j}$ is one if $S$ contains $t_{j}$ and zero otherwise. Every $\alpha_{e}$ has its own binary address. Thus, $T(n)$ can be represented as a set of binary addresses, denoted by $V(n)$, each of which identifies $\alpha_{e}$ for each entry $e\in T(n)$. Each binary address can be described by an integer, $x=\Sigma_{j=1}^{n}(x_{j}\times 2^{n-j})$. Then, $V(n)$ corresponds to a subset of $\{1,\ldots,2^{n}-1\}$.

Let $x$ and $y$ be two integers ($1\leq x,y\leq 2^{n}-1$) with the addresses $(x_{1},x_{2},\ldots,x_{n})$ and $(y_{1},y_{2},\ldots,y_{n})$, respectively. $p(x)$ is the position in $x$ that satisfies two conditions: $x_{p(x)}=1$ and $x_{j}=0$ for each $j$ $(p(x)+1\leq j\leq n)$. In other words, $p(x)$ is the least significant set bit of $x$. We say that $x$* covers $y$* if $y_{j}=x_{j}$ for each $j$ where $1\leq j\leq p(x)$. For example, if $x=12$ and $y=15$ in $4$-cube with addresses $(1100)$ and $(1111)$ then, $p(x)=2$, $y_{1}=x_{1}$, and $y_{2}=x_{2}$ so $x$ covers $y$. We assume that zero covers every integer.

Now, we define the binomial spanning tree of $V(n)$, following the notion in the literature [6].

Definition 4** (Binomial spanning tree)**

Let $V(n)$ be a subset of $\{1,\ldots,2^{n}-1\}$, $x$ be an integer such that $0\leq x\leq 2^{n}-1$, and $C(x)$ be the set of integers in $V(n)$ each of which is covered by $x$. The binomial spanning tree of $V(n)$ is the tree in which the root node, $r$, is zero and the other nodes are $V(n)$. The children of each node, $x$, correspond to the following set:

[TABLE]

The siblings $y^{(1)},y^{(2)},\ldots,y^{(m)}$ are sorted in the descending order (i.e., $y^{(j)}$ is the left sibling of $y^{(j+1)}$). We say that a non-root node, $y$, is a descendant of node $x$ if $y\in C(x)$, a precursor of $x$ if $y\not\in C(x)$ and $y>x$, and a successor of $x$ if $y<x$. The precursors and successors of $x$ are denoted at $P(x)$ and $S(x)$, respectively.

The weeping tree at time $n$, denoted by $W(n)$, is the binomial spanning tree of $V(n)$ obtained by associating each node, $x$, with its corresponding entry $e$ (i.e., $\alpha_{e}$ is the intersection of the transactions indicated by the address $x$).

Example 5

Consider again the stream ${\cal S}_{4}^{2}$ in Example 2. Let $\epsilon$ and $k$ be 0.2 and 15, respectively. PARASOL uses the 15 entries in $T(4)$ for all closed itemsets (i.e., $V(4)=\{1,2,\ldots,15\}$). The corresponding weeping tree, $W(4)$, is described in Figure 7. Each node, $x$, is associated with its own entry, $e$. For example, the node $x=6$ $(0110)$ corresponds to the entry for $\alpha=t_{2}\cap t_{3}$, i.e., $\alpha=\{1,4,5\}$. Note also that $C(6)=\{7\}$, $P(6)=\{8,9,\ldots,15\}$ and $S(6)=\{1,2,\ldots,5\}$.

One crucial feature of the weeping tree is that it captures inclusion relationships among the stored itemsets in $T(n)$.

Proposition 3

Let two nodes $x$ and $y$ associated with two entries $e_{x}$ and $e_{y}$. If $x$ covers $y$, then $\alpha_{e_{y}}\subseteq\alpha_{e_{x}}$

Proof. Since $x$ covers $y$, the address of $y$ can be written as $(x_{1},\ldots,x_{p(x)},y_{p(x)+1},\ldots,y_{n})$. Accordingly, $\alpha_{e_{y}}$ is written as $(\bigcap_{x_{j}=1,1\leq j\leq p(x)}t_{j})\ \cap\ I$ where $I=\bigcap_{y_{j}=1,p(x)+1\leq j\leq n}t_{j}$. Since $p(x)$ is the position of the least significant set bit, $\alpha_{e_{x}}=\bigcap_{x_{j}=1,1\leq j\leq p(x)}t_{j}$ holds, followed by $\alpha_{e_{y}}=\alpha_{e_{x}}\cap I$. $\Box$

Proposition 3 has three useful implications. First, it is applicable for pruning the intersection computations. Suppose that during the updating process at time $i$, an entry, $e$, is found such that $\alpha_{e}\subseteq t_{i}$. Since every descendant of $e$ must be included in $t_{i}$, it is not necessary to compute the intersections for these descendants. Proposition 3 also implies that every minimum entry must be located in the shallowest layer in the tree due to the anti-monotonicity of $T(i)$. This feature is useful for the minimum entry deletion (in practice, it is reasonable to use min-heap for the shallowest layer).

Finally, Proposition 3 is applicable to the pairwise checking involved in $\Delta$-compression. Suppose that we found a parent entry, $e_{p}$, and its child entry, $e_{c}$ such that $C_{e_{c}}\leq C_{e_{p}}-\Delta_{e_{p}}+\Delta(n)$. Then, $\alpha_{e_{c}}$ must be $\Delta(n)$-covered by $\alpha_{e_{p}}$ according to Proposition 2. Hence, a quick check can be done to determine if each child is $\Delta(n)$-covered by its parent. Note that a brute-force approach requires $O(k^{2})$ time for $\Delta$-compression while the quick pairwise checking can be completed in $O(k)$ time. Thus, it is useful as a pre-processing step preceding $\Delta$-compression.

6.2 Weeping tree updating

Here, we explain how to incrementally update $W(i)$ at each time $i$. Suppose that an itemset, $\alpha$, is newly stored in $W(i+1)$. An address $(x_{1},\ldots,x_{i},1)$ is then assigned to $\alpha$, where $(x_{1},\ldots,x_{i})$ is the address of the node, $r$, in $W(i)$ that corresponds to a representative entry of $\alpha$ if such an $r$ exists; if there is no such node, $r$ is the root node. Thus, the entry for $\alpha$ is newly located as a child of node $r$.

Example 6

Consider Example 5 again. Now, let $\alpha$ be the itemset $\{2,5\}$ that is newly added in $W(4)$. There exists a representative entry $r=\langle\{2,4,5\},2,0\rangle$, for $\alpha$ (see Figure 4) in $T(3)$. Since $r$ is given the address $(101)$ at time $i=3$, the address of $\alpha$ becomes $(1011)$, and the entry for $\alpha$ is located as a child of $r$.

Now, we interpret the meaning of the address assigned to each entry. Let $e$ be an entry of node $x$ with the address $(x_{1},\ldots,x_{n})$. We denote the least and greatest significant bit sets of $x$ as $p(x)$ and $q(x)$, respectively. Then, $e$ is written as $\langle\alpha,\Delta(q(x)-1)+B,\Delta(q(x)-1)\rangle$, where $\alpha=\bigcap_{x_{j}=1,q(x)\leq j\leq p(x)}t_{j}$, $\Delta(q(x)-1)$ is the maximum error at time $q(x)-1$ and $B$ is the bit count of $x$ (See Figure 8). This observation leads to the following proposition:

Proposition 4

Consider two nodes, $x$ and $y$, of entries $e_{x}$ and $e_{y}$, respectively, in a weeping tree. If $\alpha_{e_{y}}\subseteq\alpha_{e_{x}}$, then $y$ is either a descendant or a precursor of $x$.

Proof. We derive a contradiction in the case that $\alpha_{e_{y}}\subseteq\alpha_{e_{x}}$ and $y<x$. Let $v$ be the address obtained by the bitwise OR operation between $x$ and $y$. Since $y<x$ and $x\leq v$, $y<v$. We write $v$ as $(v_{1},\ldots,v_{n})$ and denote by $\alpha_{v}$ the intersection $\bigcap_{v_{j}=1,1\leq j\leq n}t_{j}$. Since $\alpha_{e_{y}}\subseteq\alpha_{e_{x}}$, we have $\alpha_{v}=\alpha_{e_{y}}$. Thus, node $v$ should not appear in the tree, since its duplicate never occurs in $T(n)$. Without losing generality, this implies that $v$ has been deleted at some time, which is referred to as time $m$. Accordingly, the tree never contains such a node, $u$, with an address $(u_{1},\ldots,u_{n})$ such that $q(u)=q(v)$; moreover, the bit count of the $m$-prefix $(u_{1},\ldots,u_{m})$ is lower than the bit count of the $m$-prefix $(v_{1},\ldots,v_{m})$. This is because every node with such an address has been deleted at time $m$, along with $v$ (i.e., $u$ has a lower frequency count than $v$). Hence, no node can have an address in which the $m$-prefix matches $(u_{1},\ldots,u_{m})$ or $(v_{1},\ldots,v_{m})$. Next, we consider the address of node $x$. Since $y<x$ and $v$ is obtained by a bitwise OR operation between $x$ and $y$, we have $q(x)=q(v)$. In addition, $(x_{1},\ldots,x_{m})$ is either equal to $(v_{1},\ldots,v_{m})$ or has a lower bit count than $(v_{1},\ldots,v_{m})$. Hence, $x$ should not appear in the tree. This is a contradiction. $\Box$

For example, consider node $6$ for the itemset $\{1,4,5\}$ as shown in Figure 7. There are three nodes $7,14,15$ that have subsets of this itemset and each of these nodes is either a descendant or a precursor of the node $6$.

Proposition 4 is useful for pruning the computation for incremental intersection. Suppose that for some entry $C$, $t_{i}\subset\alpha_{C}$ holds. Thus, the intersection computations for every successor of $C$ with $t_{i}$ can be skipped as they do not store any subset of $t_{i}$.

The weeping tree can be used to perform the incremental intersection by traversing the weeping tree in a depth-first, left-to-right manner. Algorithm 3 sketches the process for updating a node $x$ in $W(i)$ with an itemset $E$. Note that $E$ is initially a transaction.

In the algorithm, a node, $x$, is identified with its associated entry, $e_{x}$. Here, $\alpha_{x}$, $c_{x}$ and $\Delta_{x}$ are the itemset, frequency, and error count of $e_{x}$, respectively. Given the transaction $t_{i+1}$ and $W(i)$, the next tree, $W(i+1)$, is obtained by calling the function $update(root,t_{i+1},W(i))$. Note that $W(0)$ is defined as the initial tree consisting of the $root$ node.

A few characteristics of the $update(x,E,W(i))$ algorithm should be noted:

• •

Line 4 means that $\alpha_{y}\subseteq E$. By Proposition 3, the descendants of $y$ are included by $E$. Thus, the frequency count of each node, $z\in C(y)$, can be simply incremented without computing the intersection except for $\alpha_{y}$ itself. This is called descendant-intersect-skipping (DIS).

• •

In Line 9, we continue the updating process. In the recursive call, the intersection, $I$, is used instead of the original itemset, $E$. It follows that $\alpha_{y^{\prime}}\cap E=\alpha_{y^{\prime}}\cap I$ for each child $y^{\prime}$ of $y$ since $I=\alpha_{y}\cap E$. By reducing $E$ to $I$ (i.e., $I$ is a subset of $E$), the computational cost of the recursive call after Line 9 is reduced. This pruning technique is called masking.

• •

If $I=\emptyset$, every descendant of $y$ has no items in common $E$ so the descendants need not be updated. This is called descendant-update-skipping (DUS).

• •

Line 11 checks if $E\subseteq\alpha_{y}$ or not. If so, every right sibling of $y$ need not be updated. This follows from the observation in Proposition 4 that the entry for any subset of $E$ to be updated never appears in the successors of $y$. This is called successor-update-skipping (SUS).

• •

Finally, if there is no entry for $E$ in $W(i)$, the new entry for $E$ is added as the right-most child of $x$. Note that if $x$ is the root node, we set $c_{x}=0$ and $\Delta_{x}=\Delta(i)$.

Example 7

We explain how Algorithm 3 works using

[TABLE]

$W(3)$* corresponds to the left tree in Figure 10. The function $update(root,t_{4},W(3))$ is called to derive $W(4)$ from $W(3)$. For the left-most child $e_{1}$, the intersection, $I_{1}=\{1,2,5\}$ of $e_{1}$ with $t_{4}$ is computed. Since $I_{1}\neq\emptyset$, we call $update(e_{1},I_{1},W(3))$ as shown in Line 9. For the left-most child, $e_{2}$, of $e_{1}$, the intersection $I_{2}=\{1,2\}$ of $e_{2}$ with $I_{1}$ is computed using $I_{1}$ by masking. Since $I_{2}=\alpha_{e_{2}}$, DIS is applied in Lines 5-7. Then, $c_{e_{5}}$ is simply incremented by one. Moving to the right sibling, $e_{4}$, the intersection $I_{4}=\{2\}$ of $e_{4}$ with $I_{2}$ is computed. Since $I_{4}\neq\emptyset$, $update(e_{4},I_{4},W(3))$ is called. Since $e_{4}$ does not have any children, the algorithm checks if there exists the entry for $I_{4}$ then backtrack to the second call (i.e., $update(e_{1},I_{1},W(3))$). Since there is no sibling of $e_{4}$, the algorithm returns to Line 15 and a new entry, $e_{7}$, for $I_{1}$ is added as the right most child of $e_{1}$. After backtracking to the first call, $SUS$ is applied in Line 11 since $I_{1}=t_{4}$. Thus, the updating of the two right-most sibling nodes, $e_{3}$ and $e_{6}$, is skipped and the algorithm proceeds to Line 15. Since an entry for $t_{4}$ exists, the updated tree, $W(4)$, is returned as the output.*

In this way, the $update$ function realizes the incremental intersection. Note that every node in $W(i)$ is visited at most once, which implies that Algorithm 3 efficiently runs $update(root,t_{i+1},W(i))$ to return $W(i+1)$ in $O(kL)$ time.

Next, we show how PARASOL realizes the minimum entry deletion in the weeping tree. As explained before, the minimum entries to be deleted are allocated in the shallowest layer relative to the root. Recall Example 5, in which $\epsilon$ was set to 0.25 and PARASOL was used to delete the entries with frequency counts of one at time $i=4$. These minimum entries can be quickly accessed by applying min-heap to the shallowest layer. The reduced weeping tree is obtained by reconnecting the children of the deleted nodes with the root as shown in Figure 11).

Finally, the weeping tree is used as a pre-processing step to prepare for the $\Delta$-compression (i.e., seeking the tree for such a node that is $\Delta(n)$-covered by the parent). Figure 11 shows the reduced tree obtained by traversing the weeping tree $W(4)$ in a bottom up manner from the left-most leaf to the root; this process results in the removal of four nodes ($7$, $11$, $13$, and $15$). Note that $\Delta$-compression requires $O(k^{2})$ time to completely check every pair of nodes. Thus, it is reasonable to carry out the $\Delta$-compression in a two-step procedure; first checking the parent-child $\Delta(n)$-covering to remove the $\Delta(n)$-covered children in a one-time traversal and subsequently performing the brute-force search of the remaining nodes.

7 Experiment

Now, we empirically evaluate the performances of the baseline algorithm, PARASOL, and $\Delta$-compression, respectively. They have been implemented with the weeping tree (in C language111available from https://github.com/yoshi-3/vldb2019.git). Ten real datasets were collected from [32] (Nos. 1-2), the FIMI repository [9] (Nos. 3-9), and a new benchmark (No. 10) created from the Yahoo! Hadoop grid logs dataset [30] as shown in Table 2. Note that $n$, $|I|$, $L$, and $L_{ave}$ are the end time, the number of different types of items, the maximum transaction length, and the average transaction length, respectively.

First, the baseline algorithm was compared with the state-of-the-art RC method, Skip LC-SS [32], on the existing real datasets (Nos. 1-9). Then, the scalability of the baseline algorithm was demonstrated on the synthesized datasets generated by the IBM market basket generator. Next, the performance of PARASOL was compared with those of the baseline algorithm and the state-of-the-art PC method, MOA-IncMine [26], when applied to the large-scale dataset (No. 10). Finally, we evaluated the effectiveness of $\Delta$-compression in reducing the output.

Table 3 describes the overall improvement that has been realized by the baseline algorithm, compared with Skip LC-SS, for each dataset in terms of the maximum error, $\Delta(n)$, the error ratio, $\frac{\Delta(n)}{n}$, and the average updating time (msec). In this experiment, the size constant, $k$, was fixed as 12,000. The results show that the baseline algorithm drastically reducd the error. Notably, in datasets 4, 5, 6, 8, and 9, the error ratio with Skip LC-SS reached one, meaning that the FIs could not be found for any $\sigma$ ($0<\sigma<1$), while the baseline provided a $\Delta(n)$-covered set of the FIs for which $\Delta(n)\leq\sigma n$. Moreover, the updating time of the baseline algorithm was lower than the one of Skip LC-SS.

Skip LC-SS was compared with the baseline algorithm with a range of size constants for the dataset 7, on which Skip LC-SS performed the best in terms of the error ratio. The results are summarized in Figure 12(a). The data shows that the baseline algorithm (bold lines) performed better than Skip LC-SS in terms of maximum error and execution time for all values of $k$. Moreover, the execution time decreased linearly and $\Delta(n)$ increased as $k$ was decreased.

Next, the scalability of the baseline algorithm was evaluated by varying the maximum transaction length, $L$, as it is applied to the synthesis data. This dataset was generated by the IBM market basket generator; its stream size, $n$, was 10,000 and the number of types of items, $|I|$, was about 24,000. Figure 12(b) describes the average updating time and the error ratio, $\frac{\Delta(n)}{n}$, as functions of $L$. As the time complexity for the updating process is $O(kL)$, the execution time linearly increased as $L$ was increased. In an ordinary problem setting, we need to focus the solution space on $2^{L}$ itemsets for $L$, resulting in a rapid increase in the error count. In contrast, the proposed solution can tolerate such large transactions that always contain 5,000 items.

In addition, the change in the error ratio as a function of $k$ in the range of 1,000,000 to 7,000,000 was evaluated with the dataset 6, for which the error ratio achieved by the baseline algorithm was the largest. The results are shown in Figure 12(c). Then, the error ratio linearly decreased while the execution time increased as k was increased. Note that a simple open MP parallelization was used for this computation. Such a parallelization scheme can be used in RC approximation with a fixed memory resource [31] but the issue of efficient implementation of such a scheme is beyond the scope of this paper.

Next, we compare PARASOL with the baseline algorithm and MOA-IncMine using the hadoop dataset (No. 10). Figures 14 and 14 show the time series changes of the number of used entries, $k(i)$, and the error ratio, $\frac{\Delta(i)}{i}$, respectively, while $k=10,000$ and $\epsilon=0.015$. The results show that PARASOL violates the set $\epsilon$ value due to the RC approximation that was applied earlier in the time series period but, after this period, the error ratio recovers to $\epsilon$, this autonomous recover of $\epsilon$ is characteristic of PARASOL. Moreover, $k(i)$ became smaller than $k$ due to the PC approximation in PARASOL. Note that PARASOL composes $T(n)$ of 1,626 entries whike the baseline algorithm always uses the 10,000 entries. In contrast, MOA-IncMine generates 770,995 SFCIs for some intermediate segment when $\epsilon=0.1$ and a segment size of $w=1,000$; thus, it could not finish updating the SFCIs (this was true for other values of $w$, as well). The drastic decrease in performance due to streaming transactions (or segments) is characteristic of existing PC methods. PARASOL avoids this drawback and remains sustainable by switching between PC and RC approximations.

Table 4 compares the performance of MOA-IncMine with that of PARASOL with $\Delta$-compression when applied to the other datasets in terms of execution time and number of entries in the output. Given $\epsilon=0.1$, MOA-IncMine was run with a 1 GB Java heap size for six hours (the segment size was fixed as the default (1,000)). PARASOL was run with $k=100,000$ and $\epsilon=0.1$.

The results show that MOA-IncMine results in out-of-memory (OM) and time-out (TO) exceptions when applied to datasets 4, 5, 6, and 8. On the other hand, PARASOL successfully processes all of these datasets although the error ratio, that MOA-IncMine causes the out-of-memory (abbreviated by OM) and time-out (abbreviated by TO) exceptions in No. 4, 5, 8 and No. 6 datasets. PARASOL processes all, however the error ratio ($\frac{\Delta(n)}{n}$), exceeded the initial value of $\epsilon$. In datasets, 1, 3, 7, MOA-IncMine was faster than PARASOL; this is because these datasets were relatively sparse, implying that PARASOL tends to be more powerful for dense datasets, although the speed also depends on the segment size and size constant. The output of PARASOL was generally smaller than that of MOA-IncMine due to $\Delta$-compression as shown by number of used entries, $k(n)$.

Table 5 shows the pruning effect of using the weeping tree structure while k = 12,000 and $\epsilon=0$. The average ratio between traversing nodes and total nodes for each time and the average ratio between nodes that have non-empty intersections and total nodes for each time are shown. The results show that the use of the weeping tree structure is superior for pruning the search space in dense datasets (Nos. 2, 4, 5, 6, and 8) and does not impose any additional maintenance cost compared with the standard indexing technique. The #Num*-* and #Num*+* columns show the number of entries after pre-processing and number of entries that were output by the $\Delta$-compression, respectively. For example in dataset 6, the ordinal 12,000 entries were reduced to 3,418 by pre-processing and 535 of these entries remained in the output after the second filtering step. The Time*-* and Time*+* columns show the execution time of the $\Delta$-compression with and without the pre-processing step, respectively.

8 Concluding remarks

In this study, we have proposed a novel solution for FIM-SD that involves seeking a $\Delta$-deficient condensed representation, from which every FI and its frequency can be restored, while bounding the maximum error by an integer, $\Delta$. While the existing FIM-SD methods are limited to strictly PC and RC methods, we have mitigated the drawbacks of each approach by introducing a unified PC and RC-approximation scheme called PARASOL. We furthermore introduce a post-filtering technique called $\Delta$-compression and a novel data structure called the weeping tree. Experimental trials on ten datasets show that the proposed technique outperforms the existing FIM-SD methods. Moreover, the proposed algorithm is scalable in terms of the transactional length; in other words, it can tolerate any bursty transaction without running into an OM exception. This feature is favorable for analyzing large volumes of streaming transactions that consistently contain many items. Such large streaming transactions are often encountered in surveillance domains of sensor networks and cloud servers. In addition, along with the recent success achieved with deep learning, it is now necessary to analyze the cognitive correlations among mid-level objects for explanatory domains. We believe that integrating modern online learning with the solution presented here will give rise to a new methodology for streaming data analysis. From a technical standpoint, it will be important to introduce novel parallel-processing techniques to further improve the scalability of this technique. In addition, it will be fruitful to study how such techniques can be efficiently embedded into the proposed weeping tree structure.

Appendix

The $\Delta$-covered set has an interesting relationship with the so-called $\Delta$-closed set [2], which is known as a condensed representation for FIs. An itemset $\alpha$ is $\Delta$-closed if there exists no itemset $\beta$ such that $\beta\succeq_{\Delta}^{n}\alpha$. Let ${\cal F}_{\Delta}$ denote the family of $\Delta$-closed FIs. ${\cal F}_{\Delta}$ is uniquely determined but does not have the $\Delta$-deficiency property. Consider again Example 1 and assume that every $\alpha_{i}\in P$ is frequent by setting $\sigma$ as 0.5. Thus, we have ${\cal F}_{1}=\{\alpha_{4}\}$, since $\alpha_{i}$ ($1\leq i\leq 3$) is not 1-closed. Accordingly, ${\cal F}_{1}$ is no longer a $1$-covered set of ${\cal F}$, since the frequency of $\alpha_{1}$ cannot be restored from $\alpha_{4}$ within the error range below one.

Proposition 5

Let $\cal F$ be the family of FIs and $\Delta$ an integer. Then, ${\cal F}_{\Delta}$ is included by any $\Delta$-covered set of ${\cal F}$.

Proof. Assume that there exist a $\Delta$-closed FI $\alpha$ such that $\alpha\not\in T$ for some $\Delta$-covered set $T$ of ${\cal F}$. Since $\alpha$ is a FI but is not included in $T$, there should exist a $\beta\in T$ such that $\beta\succeq_{\Delta}^{n}\alpha$. However, this contradicts that $\alpha$ is $\Delta$-closed. $\Box$