# Performance Evaluation of Sequential Rule Mining Algorithms
## 4 Experiments and Results
### Comparing the TNS Algorithm with the Other Two Algorithms  
We compared the TNS algorithm with the other two algorithms by setting the K parameter equal to the number of rules generated from each of the other algorithms, either with different window size constraints or different minSup values.  
The TNS algorithm stopped generating any rules with (BMSwebview1). That is because of the nature of this database's features: its items are rarely repeated.  
In the sign database, the TRuleGrowth algorithm generated sequential rules in less time than the TNS algorithm, as shown in Figure 16. The TNS achieved its efficiency in generating sequential rules faster than the NRD-DBV algorithm (see Figure 17), and NRD-DBV achieved good performance in memory usage at the maximum value of minSup as presented in Figure 18.  
Figure 14: Comparison between the No. of rules generated for the TRuleGrowth and the NRD-DBV for (BMS webview2) dataset.  
Figure 15: Memory usage for the BMS webview2 dataset with different minSup values and (minConf = 0.5).  
Figure 16: Comparison of the runtime of the TNS with the TRuleGrowth for (Sign) dataset.  
Figure 17: Comparison of the runtime of the TNS with the NRD-DBV for (Sign) dataset.  
Figure 18: Comparison of memory usage for the TNS with the TRuleGrowth algorithm for (Sign) dataset.  
As seen in Figures 19 and 20 in the Korsarak dataset, the TNS algorithm generated almost four times fewer sequential rules than the two other algorithms.  
In the BMSwebview2 dataset, rules were generated in half the time taken for generating rules with the NRD-DBV algorithm. Additionally, rules were generated in less or approximately close to the time taken for the TRuleGrowth algorithm, as shown in Figures 21 and 22.  
Regarding the memory usage for each algorithm, it makes sense that the amount of memory demanded increased with the lowering of the minSup value, since the number of sequential rules is growing. However, in all experiments, the NRD-DBV method was demonstrated to be more memory efficient than the TRuleGrowth and TNS algorithms. This is because it has the advantage of the DBV structure and prunes all prefix child nodes to remove unnecessary rules, as shown before in Figures 6, 9, 12, 15 and 18, and also the following Figures 23-27.  
Computational complexity has been measured for each algorithm; we found that both the TRuleGrowth and NRD-DBV algorithms are less complex. The complexity of the TRuleGrowth algorithm is linear regarding the number of sequential rules in the dataset; either one or two recursive calls are applied to expand the right and left sides.  
In the NRD-DBV, producing non-redundant rules has a complexity of o (n*c), where n is the number of nodes and c is the average number of child nodes. We must implement (n\(-\)1) procedures for validating and producing sequential rules such as k <<n for each sequence. As a result, NRD- DBV complexity is \(\approx\) o (n). TNS algorithm is efficient when setting the parameter k up to 2000 rules. Otherwise, it performs more complexity because of high computational expenses on mining sequential rules.  
Figure 25: Comparison of memory usage for the TNS with the NRD-DBV algorithm for (Koršarak) dataset.  
Figure 26: Comparison of memory usage for the TNS with the TRuleGrowth algorithm for (BMS webview2) dataset.