A One-Phase Tree-Structure Method to Mine High Temporal Fuzzy Utility Itemsets

Abstract

Compared to fuzzy utility itemset mining (FUIM), temporal fuzzy utility itemset mining (TFUIM) has been proposed and paid attention to in recent years. It considers the characteristics of transaction time, sold quantities of items, unit profit, and transformed semantic terms as essential factors. In the past, a tree-structure method with two phases was previously presented to solve this problem. However, it spent much time because of the number of candidates generated. This paper thus proposes a one-phase tree-structure method to find the high temporal fuzzy utility itemsets in a temporal database. The tree was designed to maintain candidate 1-itemsets with their upper bound values meeting the defined threshold constraint. Besides, each node in this tree keeps the required data of a 1-itemset for mining. We also designed an algorithm to construct the tree and gave an example to illustrate the mining process in detail. Computational experiments were conducted to demonstrate the one-phase tree-structure method is better than the previous one regarding the execution time on three real datasets.

1. Introduction

Frequent itemset mining (FIM) is one of the most popular data-mining problems. It uses a pre-defined threshold to determine the important itemsets in a dataset [1,2,3]. With the mining procedure, useful and implicit information in a dataset is discovered to help managers make good decisions efficiently. It can also be further utilized to find other kinds of knowledge, such as association rules [4,5] and sequential patterns [6].

In business, frequent itemsets derived by FIM usually have low profits because cheap items are usually sold the most. However, the favorable itemsets may be the ones with high profits, but they often have small counts. For example, in a supermarket, television has a much higher gain than a piece of bread, even when the frequency of the former is much less than that of the latter. Therefore, the combinations of items that can obtain good total profits are more important than those of only high frequencies. Thus, in 2004, the utility itemset mining (UIM) problem was proposed to concern both the amounts of items sold and the unit profits of items while determining desired itemsets [7]. The problem uses a measure for itemsets, and those satisfying the utility threshold constraint are regarded as high utility itemsets. It, however, does not hold the downward-closure property and thus needs more processing time than association-rule mining.

In 2005, Liu et al. proposed a method with two phases to solve the UIM problem [8,9]. They presented an upper-bound measure to keep the anti-monotonic property in the searching process, thus reducing the search space and execution time. In the first phase, a database needs to be processed, and the upper-bound value of each itemset is calculated to decide whether it is a candidate. Thus, unpromising itemsets can be trimmed early. In the second phase, the candidate itemsets kept in phase 1 are checked for whether they are really high utility itemsets by the second scan of the database.

In addition to item amounts and profits, the transaction time is another critical factor to business strategy. Goods in a supermarket are registered with their exhibition time periods. In other words, different goods sold may be on the shelf at different time periods. If all items in a supermarket are considered to be of the same length as that in the whole database, the mined result may cause some biases. The temporal relationships among items sold are complicated and not strictly explained in UIM. Some studies claimed mining approaches to determine the orderly association among items with the temporal relationship. For example, the PPM (progressive partition miner) method suggested by Lee et al. is to find temporal patterns with the exhibition time of items [10]. The SPF (segmented progressive filter) method suggested by Chang et al. is to mine corresponding temporal rules. They considered that items had certain lifespans in which they were available for being purchased [11]. The SLMCM approach suggested by Weng viewed different products with their marked times [12]. He used the marked times for all items and presented a measuring method to mine relevant patterns for avoiding generating useless itemsets.

For helping humans to understand the knowledge easily, the fuzzy set theory [13] was applied to FUIM to interpret quantitative values as linguistic terms. Chen et al. suggested a method to derive fuzzy association rules with the temporal property [14]. They used the membership-function tuning mechanism to transform item quantities into fuzzy sets. Wu et al. introduced the LEFT2 algorithm to find fuzzy frequent itemsets [15]. In recent years, some FUIM approaches [16,17] were proposed to combine transformed fuzzy terms with UIM. They considered the fuzzy-set theory, quantitative information, and utility factor to find the itemsets with high fuzzy utility values. For example, Huang et al. introduced the TP-TFU method to solve it [16]. They also suggested a two-phase approach. In the first phase, based on their designed upper-bound model, candidate itemsets are found in level-wise processing. In the second phase, the method scans the database to ensure whether the candidates are truly high.

In order to solve the TFUIM (temporal fuzzy utility itemset mining) problem, a two-phase algorithm based on a tree structure was previously proposed to improve the performance efficiency in mining [18]. Its main goal is to reduce the number of candidates compared with that in [16]. The first phase is to hold candidate itemsets with the upper bounds satisfying the threshold in the tree. With traversing the tree, candidate itemsets can be found. They then need to be decided for being high itemsets in the second phase. However, generating the possible candidates in the first phase in [18] is also time-consuming. This study thus proposes a one-phase algorithm based on a tree structure with the array list to overcome the execution shortcoming without scanning the database in the second phase. The proposed tree structure holds all the required information. It needs additional memory to store mining information but can run faster than the previous one. The proposed mining approach based on the designed tree structure can find desired high itemsets without scanning the database again.

The rest of the paper is organized as follows. Section 2 presents relevant works related to the proposed approach; Section 3 explains the TFUIM problem and some terms; Section 4 describes the proposed approach and uses an example to illustrate the approach; Section 5 shows some experimental comparison on three real-life datasets; Lastly, a conclusion is provided in Section 6.

2. Related Works

FIM from a database is fundamental but important in knowledge discovery. Many approaches are proposed for FIM, and among them, the Apriori algorithm is a classical level-by-level processing method [1,2,3]. In Apriori, multiple database scans are used to find frequent itemsets and association rules; therefore, it spends a large amount of execution time in mining frequent itemsets. In order to overcome the problem, Han et al. presented the FP-tree (frequent pattern tree) strategy to store mining information in each node [19]. This strategy finds frequent itemsets by recursively building conditional FP-trees and traversing them. It only needs two database scans to find desired itemsets, much less than that required in Apriori.

Unlike FIM, the UIM problem [7] was proposed to avoid considering only frequencies in FIM. UIM is more complicated than FIM. It takes the following properties for each item: the amounts appearing in transactions and the unit profit. It defines the utility measure from the two property values and uses it to judge whether an item or itemset is useful based on a given utility threshold constraint. A high utility itemset thus means such a useful itemset. Several studies were developed to solve the UIM problem. For example, Dawar et al. applied a data structure to store mining information and then designed a tree-based method to reduce any candidates generated in mining [20]. Nawaz et al. used the concept of genetic algorithms to determine most of the high utility itemsets by using crossover operations [21] within a limited time. Besides, Singh et al. used transaction merging and dataset projection to find top-k utility itemsets [22].

However, UIM in the mining procedure does not have the anti-monotonic property. In other words, the utility value of an itemset is not certainly less than those of its subsets. Therefore, the search space in UIM is large, which results in expensive searching costs. In order to reduce the search space in UIM, the transaction weighted utilization (TWU) was proposed [9] as an upper-bound measure, and it was also adopted in some other methods [23,24]. The itemsets using the measure of TWU possess the anti-monotonic property, so Liu et al. designed a two-phase algorithm based on the measure [9]. In the first phase, this algorithm obtains the candidates with TWU values not less than the utility threshold. The algorithm then scans the database again in the second phase to find the actual utility values of the candidates and judge whether they satisfy the threshold constraint. However, this method consumes much execution time due to the level-wise processing. Some approaches combining the TWU and the FP-tree concepts were then proposed to improve the execution efficiency of UIM [25,26].

Fuzzy sets [13] were used to handle linguistic and uncertain situations in many domains, such as technology, economy, and business. They are easily comprehended and consistent with human perception and sense. Fuzzy sets can be thought of as an extension of crisp sets. When using fuzzy sets for FIM, item quantities in a quantitative dataset are first transformed into linguistic terms with membership values, and then the linguistic terms are processed by modifying the traditional mining procedures. Some quantitative FIM approaches were proposed. For example, Srikant and Agrawal introduced a method to derive quantitative association rules by dividing the quantitative values of items into some intervals [27]. Chen et al. considered fuzzy multi-level association-rule mining [28] and used the cumulative probability distribution to generate the number of intervals and build membership functions of all the items. Besides, practical applications about transformed linguistic terms from quantitative information were proposed. For example, Dhanaseelan and Jeyasutha improved and expanded the fuzzy mining approach to analyze and extract critical factors affecting breast cancer from the quantitative database for health information [29]. To carry out association broadcasting, realize visualization, and determine valuable information for a human resource management system, Wang and Wang used some techniques about fuzzy data mining to implement data partition [30]. They used an incremental mining approach to handle newly inserted data and a clustering approach to cluster larger amounts of data, respectively. Furthermore, Yavari et al. applied the patient profile (including age, gender, and medical condition) to generate fuzzy partitions and then presented a fuzzy pattern mining approach with three phases to find the combinations between risk factors and diseases [31].

The mining results derived from the traditional UIM [8,9] lack quantitative information because they only find high utility itemsets without containing item amount information. The quantitative relationships of the items are not mined and displayed. As mentioned above, fuzzy FIM could find the semantic meaning for item quantity relationships. Thus, Lan et al. solved the fuzzy utility mining (FUM) problem to fit real applications [17]. They considered the item quantities, item unit profits, and semantic meaning to mine high fuzzy utility itemsets. The same as the linguistic conversion step in fuzzy FIM, their approach first converts the quantitative values into fuzzy terms and then mines high fuzzy utility linguistic patterns. Since UIM does not keep the downward-closure property, so does FUM. Therefore, they designed an upper-bound measure to hold the property in FUM. Hong et al. then adopted tree structures to mine fuzzy utility itemsets [32]. After that, Wan et al. also used a fuzzy list structure embedded in trees to improve the efficiency of Lan et al.’s approach [33]. Since the mining process in FUM consumed too much runtime in the mining process, Yang et al. proposed an evolutionary algorithm to reduce the computational cost [34]. Besides, to consider the on-shelf time of an item, Huang et al. presented a research issue to consider the time factor for an item in FUM [16]. They introduced the designed upper-bounds for reducing the search space in mining and presented the TP-TFU (two-phased temporal fuzzy utility mining) method to find high fuzzy temporal-based itemsets. Hong et al. then designed a two-phase tree-structure approach to improve the efficiency of TP-TFU [18]. In this paper, a one-phase approach will be proposed.

3. Problem Definition

Assume TQD denote a temporal quantitative transaction database. It may have: TQD = {T₁, T₂, …, T_z}, where z is the number of transactions. Let I be the set of items in TQD. Thus, I = {i₁, i₂, i₃, …, i_m}, where m is the number of items. Each transaction T_y in TQD has its identifier denoted TID. Each item i_m in a transaction T_y includes its quantity sold, denoted v_ym, and unit profit called the external utility and denoted s(i_m). There is a set of time periods in TQD, denoted P = {p₁, p₂, p₃, …, p_r}, where r is the number of time periods.

Table 1. An example of temporal quantitative transaction database.

Period	TID	Quantitative Items	Transformed Fuzzy Terms
P1	T1	{a:6}, {c:2}	$(1/a.M)$$,(0.67/c.L$)
	T2	{a:4}, {b:4}	$(0.67/b.L+0.33/b.M)$
P2	T3	{a:1}, {c:1}	$(0.33/c.L)$$,(0.33/a.L)$
	T4	{a:3}, {b:3}, {c:4}, {d:4}, {e:2}	$(1/a.L$$),(1/b.L+0.67/e.L$)
P3	T5	{a:3}, {b:6}, {e:2}	$(1/a.L$$),(1/b.M$$.),(0.67/e.L$. )
	T6	{a:3}, {d:4}, {e:2}	$(1/a.L+0.67/e.L$)

shows a database with five different items and three time periods. The unit profit values of the items are listed in

Table 2. Unit Profit values of Items.

Item	Profit
a	2
b	6
c	4
d	2
e	4

.

Given the temporal fuzzy utility threshold λ and the membership functions of each item, such as those in Figure 1, the problem is to find all the high temporal fuzzy utility itemsets from the temporal database. The following definitions [16] are first given to explain the mining problem.

Definition 1.

Let the h-th linguistic term of the item i_m be denoted R_mh. The fuzzy utility fu_ymh of the linguistic term R_mh in a transaction T_y is defined as:

$$f{u}_{ymh}=\ast v_{ym}\ast s\left(i_m\right)$$

(1)

where v_ym is the quantitative value of the item i_m in the transaction T_y, u_ymh is the fuzzy value of v_ym in R_mh, and$s\left(i_m\right)$is the unit profit value of i_m.

Assume Figure 1 shows the three membership functions for item a. Its quantity in T₂ is 4, which is transformed into (0.67/a.L + 0.33/a.M). The fuzzy utility of R_a.L is thus 0.67 × 4 × 2, which is 5.36.

Definition 2.

The transactional fuzzy utilitytfu_y of a transaction T_yis the summation of the fuzzy utility values of all linguistic terms in T_y.

Definition 3.

A fuzzyitemset includes one or more linguistic terms with no terms derived from the same item.

Take transaction T₆ as an example. (a.L, d.L) is a valid fuzzy itemset with two fuzzy items, but (d.L, d.M) is not because it is derived from the same item d.

Definition 4.

Let X be a fuzzy itemset. The fuzzy utility of X in T_y, denoted fu_yX, is:

$$=\ast {\displaystyle \sum }_{R_{mh}\subseteq X}{v}_{ym}\ast s\left(i_m\right)$$

(2)

where the$\mu$_yX is the minimum scalar cardinality in R_mh in X.

Take the fuzzy itemset (a.L, d.L) in T₆ as an example. The fuzzy value of (a.L, d.L) in T₆ is 0.67 (=min(1, 0.67)). Thus, its $f{u}_{6, \left(a.L,d.L\right)}$ value is calculated as 0.67 × [(3 × 2) + (4 × 2)] = 9.38.

Definition 5.

The start transaction period (STP) of an item is its first appearing time period in TQD.

Definition 6.

The lastingtransaction periods of an itemset X, denoted as LTP_X, is the set of the periodsfromthelatestSTPamong theitemsinXtothe end of TQD.

Definition 7.

The maximal fuzzy utility mfu_ym of an item i_m in the transaction T_y is the maximum fuzzy utility value of all its linguistic terms.

Definition 8.

The maximal transactional fuzzy utility mtfu_y of a transaction T_y is the summation of the maximal fuzzy utility values of all the items in T_y.

Definition 9.

The start transaction period STP_all of all theitemsin TQDis the latest time period of all the items.

Definition 10.

Let LTP_all be the set of the periods from STP_all to the last time period in TQD. The temporal fuzzy utility upper-bound ratio of a fuzzy itemset X is defined as:

$$tfuub{r}_X={{\displaystyle \sum }}_{X\in T_y\cap T_y\in LT{P}_X}mtf{u}_{yX}/{{\displaystyle \sum }}_{T_y\in LT{P}_{all}}tf{u}_y.$$

(3)

Definition 11.

A fuzzy itemset X is a high temporal fuzzy utilityupper-bound itemset (HTFUUBI) iff tfuubr_X≥ λ.

Definition 12.

The temporal fuzzy utility ratio tfur_X of X is defined as:

$$tfu{r}_X={{\displaystyle \sum }}_{X\in Tran{s}_y\cap Tran{s}_y\in LT{P}_X}f{u}_{yX}/{{\displaystyle \sum }}_{Tran{s}_y\in LT{P}_X}tf{u}_y$$

(4)

Definition 13.

A fuzzy itemset X is calleda high temporal fuzzy utility itemset (HTFUI) iff tfur_X≥ λ.

4. The Proposed Algorithm

This section presents the proposed array-embedded tree algorithm for TFUIM, called the ATTFUM algorithm. In the past, a two-phase algorithm [18] was introduced to solve the temporal fuzzy utility mining problem. This study uses a one-phase method to find HTFUIs according to the upper bound model [16] and FP-tree [19]. First, the data-processing step needs to be processed. The item quantities in all the transactions are transformed into fuzzy sets based on the membership functions. If the tfuubr value of a linguistic term is not less than the specified threshold, it is treated as an HTFUUBI. Then, the linguistic terms which are not HTFUUBIs are deleted from the transformed database. The remaining terms are then sorted in descending counts. The sorted terms in each transaction are used to build the tree. Finally, a mining procedure similar to the FP-Growth in FIM is designed to find out potential candidates and determine whether they are HTFUIs. The details for the steps of the proposed method with examples are described in the following four subsections.

4.1. Transformed into a Fuzzy Database

In order to execute the ATTFUM method for mining HTFUIs, the pre-processing step is first executed. First, each transaction TID in a database is converted according to its sale time to a specific time period. The start time period of each item in the given database is then recorded. Next, the quantities of all the items in a database are fuzzified into linguistic terms based on the defined membership functions. In the transformation process, the fuzzy value of each transformed term can be obtained as well. For the TQD in Table 1, the start time periods (STPs) of all the items are shown in

Table 3. The STP of all items for the running example.

Item	a	b	c	d	e
STP	P1	P1	P1	P2	P2

.

Assume the five items in TQD use the same membership functions in Figure 1. The final fuzzified results are listed in the last column of Table 1. Then the upper-bound measure is utilized to generate the downward-closure property. The mtfu value of each transaction needs to be calculated. Thus, to calculate the upper-bound value of a transaction, the fu value of each linguistic term in the transformed database (the last column of Table 1) needs to be obtained. For example, for the linguistic term (a.L) with the value 0.66 in T₂, its fu_2,a.L is 5.36 (=0.67 × 4 × 2). The fu values of the other linguistic terms in T₂ are fu_2,a.M (2.64), fu_2,b.L (16.08), and fu_2,a.M (7.92), respectively. Thus, the mtfu and tfu values of T₂ are 21.44 (=5.36 + 16.08) and 32 (=5.36 + 2.64 + 16.08 + 7.92). The mtfu and tfu values for all the transactions are listed in

Table 4. The mtfu and tfu values for each transaction.

	TID
	T1	T2	T3	T4	T5	T6
tfu	17.36	32	1.98	53.34	47.36	26
mtfu	17.36	21.44	1.98	45.42	47.36	23.36

.

Next, the tfuubr value of each linguistic term is calculated. Take the linguistic term (a.L) in the last column of Table 1 as an example. It can be observed that the term (a.L) happens in T₂, T₃, T₄, T₅, and T₆, and their mtfu values are shown in Table 4. Besides, the STP_all derived from Table 3 is P₂. Assume the defined threshold is 40%. According to definition 10, the tfuubr value of the linguistic term (a.L) is first handled. The numerator is 139.56 (=21.44 + 1.98 + 45.42 + 47.36 + 23.36). Then, the denominator is calculated as 128.68 (=1.98 + 53.34 + 47.36 + 26), which depicts the tfu value from STP_all (P₂) to LTP_all (P₃). The tfuubr value of the linguistic term (a.L) is then 108.4% (=139.56/128.68), which is not less than the defined threshold. Therefore, the linguistic term (a.L) is an HTFUUBI. The same process is performed for the other terms, and the sorted results based on their occurrence frequency are displayed in

Table 5. The sorted linguistic terms satisfy the threshold constraint.

Linguistic Term	a.L	c.L	e.L	b.L	b.M	d.L	d.M
Total mtfu	139.56	64.76	116.14	66.86	68.8	68.78	68.78
Occurrence	5	3	3	2	2	2	2

.

The linguistic terms that are not HTFUUBIs are then deleted from the transformed database. The remaining linguistic terms in a transaction are sorted by descending counts and formed as a revised database. The resultant revised database is shown in

Table 6. The sorted revised database.

Period	TID	Transformed Fuzzy Linguistic Terms
P1	T1	$(0.67/c.L$)
	T2	$(0.67/a.L)$$,(0.67/b.L), (0.33/b.M)$
P2	T3	$(0.33/a.L)$$,(0.33/c.L)$
	T4	$(1/a.L),$$(0.67/c.L)$$,(0.67/e.L),$$(1/b.L),$$(0.67/d.L), (0.33/d.M)$
P3	T5	$(1/a.L$$),(0.67/e.L$$),(1/b.M$)
	T6	$(1/a.L$$),(0.67/e.L$$),(0.67/d.L),(0.33/d.M$)

.

The rearranged terms in each transaction are then used to be inserted into the tree sequentially. The process is described below.

4.2. Tree Structure Construction

The proposed algorithm begins building a tree structure after forming the fuzzified database. Each transaction is sequentially processed. The linguistic terms in each transaction are inserted to create nodes in the tree. Each node is attached with the total_mtfu field and the array-list data structure for storing mining information. The total_mtfu field stores the accumulated mtfu value. If the inserted linguistic term in a transaction belongs to this node, set total_mtfu = total_mtfu + mtfu_y. The array-list data structure includes three subfields: TID, fuzzy value, and utility value.

For example, the linguistic term c.L of transaction T₁ in Table 6 results in the first branch of the tree. The initial total_mtfu value of the node is the mtfu value of T₁, which is 17.36 in Table 4. Then, its array-list structure contains the transaction identifier T₁, the fuzzy value of the term c.L (=0.67) in Table 6, and its utility value (=2 × 4 = 8) derived from Table 1 and Table 2. The first inserted node is shown in Figure 2.

Next, the transaction T₂ is handled. It consists of three linguistic terms (a.L), (b.L), and (b.M). The mtfu value of T₂ is 21.44 in Table 4. The first linguistic term (a.L) is added to the tree. The node of the term (a.L) cannot share the same prefix (c.L) of the tree with the transaction T₁. Therefore, the second branch is grown to connect the node (a.L) and the root. The term (b.L) is then added to the tree as the child of the (a.L) node. The term (b.M) is handled in the same way. Thus, in this branch, there are three nodes inserted, all with the mtfu (21.44) value of T₂ attached. After T₂ is processed, the tree is shown in Figure 3. The complete tree for all the transactions is depicted in Figure 4.

4.3. The Tree-Constructing Algorithm

The details of the tree-construction method are given below.

The proposed Algorithm 1:

Algorithm 1: tree construction.
INPUT:	TQD, a temporal quantitative database;
	m, number of items in TQD;
	μ, membership functions;
	r, number of time periods;
	λ, minimum temporal fuzzy utility threshold.
OUTPUT:	a constructed tree.
STEP 1: According to the r time periods for TQD, find the corresponding time period of each transaction. STEP 2: For each item im in TQD, find its STPim and then derive STPall. STEP 3: For each transaction Ty in TQD, transform the quantity sold vym of each item im into linguistic items Rm1 to Rmh in a fuzzy set fym, with uym1 to uymh being their scalar cardinality values in fym based on the membership functions μ . Let RTQD denote the revised TQD. STEP 4: For each transaction Ty in a period pj in RTQD, conduct the following substeps: Step 4.1: Count the fuymh value of the h-th linguistic term Rmh in Ty. Step 4.2: Find the mfuym value of im in Ty. Step 4.3: Calculate the tfuy and mtfuy values of each Ty. STEP 5: Calculate LTPall. STEP 6: Build the upper-bound table as empty, with each tuple having the three fields: linguistic term, total mtfu, and count. STEP 7: For each linguistic term Rmh in RTQD, calculate its tfuubr value. If the value is not less than λ, set it as an HTFUUBI1. STEP 8: All the HTFUUBI1’s in RTQD are inserted into the upper-bound table, with their linguistic term, total mtfu value, and count. STEP 9: For each linguistic term Rmh in RTQD, if it has not existed in the upper-bound table, remove it. STEP 10: Resort the linguistic terms in the upper-bound table based on their descending counts. The upper-bound table acts as the Header_Table. STEP 11: Insert each transaction Ty in RTQD into the tree. If a linguistic term x in Ty has not been at the corresponding branch in the tree, add the term x to the end of the branch as the node x, and put the mtfu value of Ty and the array-list structure data (including TID of Ty, the fuzzy value of x and utility value of x) into the node. If a linguistic term x in Ty has been at the corresponding branch in the tree, just add the mtfu value of Ty to the total_mtfu field of the node x and put the related data of the term x in the transaction Ty into the end of the array-list structure. Until no transaction needs to be processed, the tree is constructed.

4.4. Mining HTFUIs from the Tree

When the tree is built, the candidate HTFUI itemsets can then be mined using a procedure similar to the FP-Growth approach [19]. The procedure is, however, more complicated than the FP-Growth due to the complex data kept in the nodes. It will check whether a candidate has its tfur value satisfying the defined threshold.

For a developed tree such as that in Figure 4, the mining algorithm finds HTFUIs as follows. The Header_Table includes the sorted linguistic terms according to the order of descending counts. A conditional pattern tree is grown for each linguistic term in the Header_Table. These terms are processed bottom-up and one by one. The mtfu values of the generated candidate itemsets, including the processed linguistic term, are then recursively calculated. If their mtfu values are not less than the defined threshold, they are removed in the conditional pattern tree. In Section 4.3, each branch in the tree is built using the mtfu values of the linguistic terms in a transaction. Thus, the candidate fuzzy k-itemsets obtained by the total_mtfu field in the node can be found easily directly from the tree. If the tfur values of the candidate fuzzy k-itemsets are larger than or equal to the threshold by using the array-list data in the node, the k-itemsets are HTFUIs. Below is the mining algorithm.

The mining Algorithm 2:

Algorithm 2: mining HTFUIs from the tree.
INPUT:	r, the constructed tree;
	λ, minimum temporal fuzzy utility threshold.
OUTPUT:	All HTFUI itemsets.
For each linguistic term x bottom-up in the Header_Table, conduct the following steps: Step 1: From the constructed tree, form a conditional pattern tree of the node x by the link of x in the Header_Table. Step 2: Check each prefix node in the conditional pattern tree from the node x for whether the prefix node and x are originated from the same item. If yes, remove the prefix node. Step 3: Check the total_mtfu value for each prefix node in the conditional pattern tree from x for whether the value is not less than ${\displaystyle \sum }_{T_y\in LT{P}_{all}}tf{u}_y$*λ. If no, remove the prefix node. Step 4: Find candidate HTFUIs from the remaining conditional pattern tree from x. Step 5: Calculate the tfurz value from the node of each candidate z with the array-list structure using the intersection operation as the fuzzy operator. If tfurz is not less than λ, z is a HTFUI.

For example, take the linguistic term (d.M) in the Header_Table in Figure 4 as an example. Its conditional pattern tree is shown in Figure 5a. There are two branches derived from the linguistic term (d.M), as shown in Figure 5b.

Along with building the conditional pattern tree for the linguistic term (d.M), the combinations of the possible fuzzy candidate itemsets with (d.M) are then derived using the mining algorithm recursively. All the possible fuzzy itemsets are processed for checking whether the mtfu values of the candidates are not less than the threshold in the temporal fuzzy utility mining. The linguistic terms (d.L) and (d.M) are originated from the same item d, so the linguistic terms (d.L) in two branches of the conditional pattern tree are removed in Figure 5b. All the linguistic terms in Figure 5b are then processed for checking whether their mtfu values meet the threshold value. The total mtfu value of each fuzzy itemset, including (d.M), is then counted from individual branches. In this case, the fuzzy itemset (e.L, d.M) exist in two branches of Figure 5b. Thus, their mtfu value is 68.78 (=45.42 + 23.36). It is larger than the threshold value (=(1.98 + 53.34 + 47.36 + 26) × 40% = 51.472). As another example, the mtfu values of the linguistic terms (c.L) and (b.L), which are both 45.42 in the left branch, are less than the threshold value, so they are omitted in the two branches. The final result for the conditional pattern tree with the linguistic term (d.M) is shown in Figure 5c.

All the fuzzy itemsets derived from the conditional pattern tree can be obtained without rescanning the database. In this example, all the possible itemsets with d.M are [(d.M, e.L): 68.78], [(d.M, a.L): 68.78] and [(d.M, e.L, a.L): 68.78] derived from Figure 5c. Next, all the fuzzy itemsets are processed to check whether their tfur values satisfy the threshold. If yes, they are HTFUIs. Take [(d.M, e.L)] as an example. According to definition 12, the tfur value of the fuzzy itemsets [(d.M, e.L)] needs to be calculated. It can be known that the LTP_{[(d.M, e.L)]} range is from P₂ to P₄. Therefore, the tfu values of all the transactions in LTP_{[(d.M, e.L)]} are summed, and its value is 128.68 (=1.98 + 53.34 + 47.36 + 26), which is the denominator. Next, the fuzzy utility value of [(d.M, e.L)] is calculated. In Figure 5c, the array-list structure information of the nodes (d.M) and (e.L), including identifier transaction, fuzzy value, and utility value, can be obtained. Thus, the fuzzy values of (d.M) and (e.L) are both 0.33 and 0.67 from their array-list structure in T₄ and T₆. By using the intersection operation in the fuzzy sets, the fuzzy values of the fuzzy itemset [(d.M, e.L)] in T₄ and T₆ are 0.33 and 0.33, respectively. The fuzzy utility value of [(d.M, e.L)] is calculated as 0.33 × (8 + 8) + 0.33 × (8 + 8) = 11.88, and its tfur value is 9.23% (=11.88/128.68), which is less than the defined threshold (40%). It is not an HTFUI. The remaining itemsets are handled in the same way.

5. Performance Evaluation

Three real datasets, mushroom [35], retail [35], and foodmart [36], were used to compare the proposed ATTFUM and the previous FHTFUP [18] algorithms. These two methods were run on a desktop computer with a Dual-Core Processor of 3.3 GHz and 16 GB of RAM. The programming language is JAVA. The quantitative value for each item in mushroom, retail, and foodmart datasets was assigned from 1 to 10 randomly. The profits for items were randomly set within 1 to 1000. In the experiments, the three datasets were transformed into three linguistic terms according to the pre-defined membership functions in Figure 1. The number of time periods is assigned 2.

The running time and the memory consumption for the two methods in different thresholds were evaluated. The results are shown in Figure 6 and Figure 7.

Figure 6 shows the comparison results on the three different datasets under varying thresholds. Obviously, the proposed ATTFUM method has better performance in terms of computation time when compared to the FHTFUP method. The two algorithms derive the same HTFUIs, but ATTFUM needs less running time compared to the other one. Along with the threshold set at a lower value, ATTFUM has better performance than FHTFUP. This is because the HTFUIs derived by the ATTFUM method is processed by each node with the array-list structure information, but those derived from the FHTFUP method are mined by performing database rescans. For the three different datasets, when the threshold decreased, the proposed approach ran slower.

Figure 7 shows the memory consumption for the two approaches on three different datasets under varying thresholds. Along with the threshold decreasing in the three different datasets, the memory space used for ATTFUM is more than that for FHTFUP. This main reason is that each node in the proposed algorithm needs to keep the array-list data for mining information of the same linguistic term in different transactions. Besides, it can be observed that the proposed method required more memory consumption when the threshold decreased.

In summary, the proposed ATTFUM method with each node, including the array-list information, requires less running time when compared to the two-phase FHTFUP method. Although the proposed method uses the array list to store mining information in each node, it does not need to rescan the database to determine HTFUIs when compared with the FHTFUP method. Thus, the computation time is significantly reduced.

6. Conclusions

In this paper, to solve the problem of mining HTFUIs in determining temporal knowledge, the ATTFUM algorithm is proposed. The proposed method is used to handle linguistic terms in each transaction for a temporal database using the concepts of the FP-tree and the upper-bound model for downward closure property. Each node in the proposed tree has the upper-bound value and the array-list information, keeping the information in different transactions. Therefore, the upper-bound values are used to derive the potential candidates from the conditional pattern trees in the mining process. Along with each node in a conditional pattern tree, the HTFUIs can be completely obtained using the array-list information in nodes.

Compared with the non-temporal fuzzy utility mining, the proposed approach can provide a more flexible consideration to real applications. When the number of time periods is one, the temporal fuzzy utility mining degenerates to the fuzzy utility mining. Thus, the former can be thought of as a generalization of the latter. Besides, compared to the previous temporal fuzzy utility mining approach, the experimental results on the three real databases showed that the proposed ATTFUM algorithm is superior to the FHTFUP algorithm in temporal fuzzy utility mining problems in terms of the execution time. Furthermore, by adopting the array-list structure to store mining information in each node, the proposed ATTFUM can efficiently mine HTFUIs, although it uses more memory usage than FHTFUP. The proposed ATTFUM can reduce the execution time due to the avoidance of the database rescan in the second phase when compared with the previous FHTFUP approach.

For further research issues, different tree structures and other data structures could be designed to improve the performance of the ATTFUM algorithm. Besides, the scenario of inserting new transactions into a database may be considered, and different maintenance problems of the TFUIM may be handled. How to process different exhibition time periods of items in fuzzy mining is also an interesting challenge. Some variants, such as mining with multiple minimum thresholds, can also be designed based on the proposed architecture.