Available online at www.sciencedirect.

com

Knowledge-Based Systems 21 (2008) 110–122

www.elsevier.com/locate/knosys

A new framework for detecting weighted sequential

patterns in large sequence databases
Unil Yun *

Computer Engineering Division, School of Electrical & Computer Engineering, Chungbuk National University, Korea

Received 29 August 2006; received in revised form 7 February 2007; accepted 9 April 2007
Available online 19 April 2007

Abstract

Sequential pattern mining is an essential research topic with broad applications which discovers the set of frequent subsequences sat-
isfying a support threshold in a sequence database. The major problems of mining sequential patterns are that a huge set of sequential
patterns are generated and the computation time is so high. Although efficient algorithms have been developed to tackle these problems,
the performance of the algorithms dramatically degrades in case of mining long sequential patterns in dense databases or using low min-
imum supports. In addition, the algorithms may reduce the number of patterns but unimportant patterns are still found in the result
patterns. It would be better if the unimportant patterns could be pruned first, resulting in fewer but important patterns after mining.
In this paper, we suggest a new framework for mining weighted frequent patterns in which weight constraints are deeply pushed in
sequential pattern mining. Previous sequential mining algorithms treat sequential patterns uniformly while real sequential patterns have
different importance. In our approach, the weights of items are given according to the priority or importance. During the mining process,
we consider not only supports but also weights of patterns. Based on the framework, we present a weighted sequential pattern mining
algorithm (WSpan). To our knowledge, this is the first work to mine weighted sequential patterns. The experimental results show that
WSpan detects fewer but important weighted sequential patterns in large sequence databases even with a low minimum threshold.
 2007 Elsevier B.V. All rights reserved.

Keywords: Data mining; Knowledge discovery; Weighted sequential pattern mining; Weighted support; Minimum weight

1. Introduction the anti-monotone property [1] has been mainly used to

Sequential pattern mining algorithms have been exten-
sively developed due to huge applications such as biologi-
cal sequence mining [7,20], incremental sequence mining
[5], sequence indexing [6], multi-dimensional sequence pat-
tern mining [15], approximate sequence mining in a noisy
environment [10,24], constraint-based sequential pattern
mining [8,11,13], closed sequential pattern mining [19,23],
graph mining [22] and so on. Sequential pattern mining is
to find the complete set of sequential patterns in a sequence
database with a minimum support threshold. Extensive
growth of data gives the motivation to find meaningful pat-
terns among the huge data. In sequential pattern mining,
*
Tel.: +1 979 693 0284.
E-mail address: yunei@cs.tamu.edu
prune infrequent sequential patterns. That is, if a sequen-
tial pattern is infrequent, all super patterns of the sequen-
tial pattern must be infrequent. Using this characteristic,
sequential pattern mining algorithms prune infrequent
sequential patterns earlier. However, following limitations
exist in the previous sequential pattern mining.
First, in the real world, some sequences are more impor-
tant and others are less important. However, previous
sequential pattern mining approaches do not consider this
characteristic and all items and sequences are treated uni-
formly. In the real world, there are several applications in
which specific sequences are more important or have more
priority than other sequences. For example, in real applica-
tions, when finding the traversal patterns in the World
Wide Web, each page has different importance. In DNA
and biomedical data analysis, some genes are more

0950-7051/$ - see front matter  2007 Elsevier B.V. All rights reserved.
doi:10.1016/j.knosys.2007.04.002
 U. Yun / Knowledge-Based Systems 21 (2008) 110–122
important than others in causing a particular disease, and
some genes are more effective than others in fighting dis-
eases. Second, sequential pattern mining algorithms
[2,4,28] have better performance as a minimum support is
high, the database is sparse and/or the length of the maxi-
mum sequential pattern is short. However, the perfor-
mance of the algorithms degrades dramatically when
using a low support threshold, or mining dense databases
with long sequences. The main problem of these algorithms
is that they generate an exponentially large number of
sequential patterns and the runtime increases dramatically
when a minimum support is lowered. In addition, irrespec-
tive of the minimum support, the unimportant patterns
with low weights can be detected. Even though efficient
algorithms [4,14] have been developed, unimportant
sequential patterns are still found in result sets.
Currently, no weighted sequential pattern mining algo-
rithm exists, although weights are important in the real
world. Let us give a motivating example for this work in
market basket data. In general sequential pattern mining,
a sequential pattern {(bread, milk) (diaper, beer)} can be
easily discovered with support threshold because the sup-
port (frequency) of the sequential pattern is relatively high.
Although we want to find valuable (important) itemset lists
or sequences such as {(gold ring, silver necklace) (car, cell
phone) (computer, television)}, the itemsets (the sequence)
cannot be mined with the previous sequential pattern min-
ing approach because the items within the sequence are so
expensive that the items have low frequencies (supports).
The itemsets or the sequence cannot be mined although
the minimum support is lowered. Instead, the following
itemsets or sequences can be discovered in previous
approach: (gold ring, hair pin, silver necklace), (car, sun-
glass, cell phone) and (computer, television, mouse pad).
That is, irrespective of the minimum support, items such
as ‘‘hair pin’’, ‘‘sunglass’’, or ‘‘mouse pad’’ with low
weights are included because these items have high sup-
ports (frequencies). However, these items are cheap and
give low profits, so they are not important items in terms
of prices (weights). In real business, marketing managers
or trend analyzers want to find the sequences with more
emphasis on some particular (important) products (items)
and less emphasis on other products. However, the previ-
ous sequential pattern mining cannot discover the impor-
tant sequences with low supports.
From the above motivation, in this paper, we propose a
new framework for detecting weighted sequential patterns.
It would be better if the unimportant patterns could be
pruned first, resulting in fewer patterns after mining. In
our approach, weights of items are assigned to reflect the
importance of sequential patterns, itemsets within the pat-
terns and items within the itemsets in the sequence database.
The main concern in weight based sequential pattern mining
is that the anti-monotone property [1] is broken when simply
applying weights. That is, although a sequential pattern is
weighted infrequent, super patterns of the sequential pattern
may be weighted frequent because super patterns of the
111
sequential pattern with a low weight can get a high weight
after adding other items or itemsets with higher weights.
Our main goal in this framework is to push weight con-
straints into the sequential pattern mining efficiently.
In our approach, the weight range is used to restrict
weight values of items and weights (prices) of items are nor-
malized within the weight range. During mining process, a
maximum weight within the items are used to efficiently
prune weighted infrequent sequential patterns. Addition-
ally, we use a minimum weight threshold to give balance
support and weight. An extensive performance study shows
that WSpan is efficient and scalable in weighted sequential
pattern mining.
The main contributions of this paper are: (1) introduc-
tion of the concept of weighted sequential patterns, (2) clas-
sification and incorporation of two key features, a weight
and a support, (3) description of weighted sequential pat-
tern mining by using two pruning conditions, (4) imple-
mentation of our algorithm, WSpan, and execution of an
extensive experimental study.
The remainder of the paper is organized as follows. In
Section 2, we describe previous work. In Section 3, we
develop WSpan. Section 4 shows extensive experimental
results. Finally, conclusion and future work are presented
in Section 5.
2. Previous work
Let I = {i1, i2 . . . in} be a unique set of items. A sequence
S is an ordered list of itemsets, denoted as Æs1, s2, . . ., smæ,
where sj is an itemset which is also called an element of the
sequence, and sj ˝ I. That is, S = Æs1, s2, . . ., smæ and sj is
(xj1, xj2, . . ., xjk), where xjt is an item in the itemset sj. The
brackets are omitted if an itemset has only one item. An item
can occur at most one time in an itemset of a sequence but it
can occur multiple times in different itemsets of a sequence.
The size |S| of a sequence is the number of itemsets in the
sequence. The length, l(S), is the total number of items in
the sequence. A sequence with length l is called an l-sequence.
A sequence database, SDB = {S1, S2, . . ., Sn}, is a set of
tuples Æsid, Sæ, where sid is a sequence identifier and Sk is
an input sequence. A sequence a = ÆX1, X2, . . . ,Xnæ is called
a subsequence (a v b) of another sequence b = ÆY1, Y2,
. . ., Ymæ (n 6 m), and b is called a super sequence of the
sequence a if there exist an integer 1 6 i1 <  < in 6 m such
that X1 ˝ Yi1, X2 ˝ Yi2,. . .,˝ Xn ˝ Yin. A tuple (sid, S) is said
to contain a sequence a if S is a super sequence of a (a v S).
The support of a sequence a in a sequence database SDB
(support (a) = j{<sid, S>j(<sid, S> 2 SDB) § (a v S)}|) is
the number of sequences in SDB that contain the sequence
a. Given a support threshold, min_sup, a sequence a is called
a frequent sequential pattern in the sequence database if the
support of the sequence a is no less than the minimum sup-
port threshold (support (a) P min_sup). The problem of
sequential pattern mining is to find the complete set of fre-
quent sequential patterns satisfying a minimum support in
the sequence database. Table 1 shows the input sequence
112 U. Yun / Knowledge-Based Systems 21 (2008) 110–122

Table 1
A sequence database (SDB)
Sequence ID Sequence
10 <a (abc) (ac) d (cf)>
20 <(ad) c (bc) (ae) bc>
30 <(ef) (ab) (df) cb>
40 <eg (af) cbc>
50 <a (ab) (cd) egh>
60 <a (abd) bc>
database SDB in our running example. Assume that a mini-
mum support is 2. The SDB has eight unique items, and six
input sequences. A sequence Æa (abc) (ac) d (cf)æ in SDB
has five itemsets: a, (abc), (ac), d, (cf) where items ‘‘a’’ and
‘‘c’’ appear three times in different itemsets of the sequence.
The size of Æa (abc) (ac) d (cf)æ is 5 and the length of this
sequence is 9. Sequence Æa (bc) dæ is a sub sequence of
Æa (abc) (ac) d (cf)æ since a ˝ a, (bc) ˝ (abc) and d ˝ d. Addi-
tionally, the sequence <a(bc)d> is a frequent sequential
pattern because sequences 10 and 20 contain sub sequence
s = Æa (bc) dæ and the support (2) of the sequence is no less
than 2. Meanwhile, a sequential pattern <(ab)g> is not a fre-
quent pattern since the support (1) of the pattern is less than
the minimum support (2). Based on the anti-monotone prop-
erty, we can know that all super patterns of the sequential
pattern <ag> such as sequential patterns such as <a(ab)g>,
<a(ab)cg>, and <a(ab)(cd)g> are infrequent patterns.
2.1. Weight-based pattern mining
Weight based frequent pattern mining algorithms
[3,17,21,25–27] have been suggested. As shown in Table 2,
MINWAL (Mining association rules with weighted items)
[3] defined a weighted support which is calculated by multi-
plying a support of a pattern with an average weight of a pat-
tern. MINWAL used the k-support bound to maintain the
anti-monotone property. WAR (Weighted Association
Rules) [21] generates frequent items without considering
weights and then does post-processing during the rule gener-
ation step so the WAR algorithm did not consider weight
values while mining frequent patterns. In WARM (Weighted
Association Rule Mining) [17], the problem of breaking the
anti-monotone property is solved by using a weighted sup-
port and developing a weighted downward closure property.
However, weighted support of a pattern AB in WARM is the
ratio of the weight of the transactions containing both A and
B to the weight of all transactions so WARM does not con-
sider the support measure. Recently, in weighted frequent
pattern mining, the weight constraint have been combined
with other constraints [25,27] or measures [26] such as length
decreasing support constraints, correlation measure or the
closure property. Although there have been many studies
to find weighted frequent patterns, no sequential pattern
mining algorithms have considered weighted sequences.
Instead, all the sequential pattern mining algorithms sug-
gested so far have given the same importance to the
sequences and the itemsets in a sequence. However, it is
essential to distinguish significant sequences from a large
number of sequence patterns.
2.2. Sequential pattern mining
Efficient sequential pattern mining algorithms have been
developed such as constraint-based sequential pattern min-
ing [8,11,13], sequential pattern mining without using sup-
port thresholds [18] and closed sequential pattern mining
[19,23]. However, these approaches may reduce the number
of patterns but unimportant patterns are still mined
because they did not consider weights or priorities of the
patterns. In previous sequential pattern mining algorithms,
GSP [16] mines sequential patterns based on an apriori-like
approach [1] by generating all candidate sequences. To
overcome this limitation, the database projection growth
based approach, FreeSpan [9], was developed. Although
FreeSpan outperforms the apriori-based GSP algorithm,
FreeSpan may generate any substring combination in a

Table 2
Weight-based pattern mining algorithms
Mining algorithm Comparison
WSpan The first sequential pattern mining algorithm to detect weighted sequential patterns
Apply a minimum weight threshold to sequential pattern mining
Use the prefix projected sequential pattern growth method
MINWAL [3] Frequent pattern/association rule mining algorithm
Use k-support bound to maintain the anti-monotone property
WAR [21] Frequent pattern/association rule mining algorithm
Generate frequent items without considering weights and then use weight values to find association rules (post-
processing approach)
WARM [17] Frequent pattern/association rule mining algorithm
Solve the downward closure property by developing a weighted downward closure property
Use weight values but do not consider supports of patterns
WLPMiner [25]/WIP [26]/ Frequent pattern mining algorithm
WCloset [27]
Use the FP-tree structure in weight based frequent pattern mining
Combine the weight constraint with other constraints or measures such as length decreasing support constraints,
correlation measure or the closure property
 U. Yun / Knowledge-Based Systems 21 (2008) 110–122
sequence. The projection in FreeSpan must keep all
sequences in the original sequence database without length
reduction. A more efficient pattern growth algorithm, Pre-
fixSpan [12] was proposed which improves the mining pro-
cess. The main idea of PrefixSpan is to examine only the
prefix subsequences and project only their corresponding
suffix subsequences into projected databases. In each pro-
jected database, sequential patterns are grown by exploring
only local frequent patterns. In SPADE [28], a vertical id-
list data format was presented and the frequent sequence
enumeration was performed by a simple join on id-lists.
SPADE can be considered as an extension of vertical for-
mat-based sequential pattern mining. SPAM [2] utilizes
depth first traversal of the search space combined with a
vertical bitmap representation of each sequence. Before
SPAM, SPADE and PrefixSpan were two of the fastest
algorithms. According to performance evaluations [2],
SPAM outperforms SPADE on most datasets, and Prefix-
Span outperforms SPAM only slightly on very small data-
sets. Except for this case, SPAM outperforms PrefixSpan in
all cases. Therefore, WSpan is compared with SPAM for
the performance evaluation.
3. A framework for detecting weighted sequential patterns
In this section, we propose a new framework for detect-
ing weighted sequential pattern in which the weight con-
straint is pushed deeply into sequential pattern mining. In
our approach, we define weighted sequential patterns and
two pruning methods are suggested to detect weighted
sequential patterns. Based on the framework, we show a
mining example and an algorithm for detecting weighted
sequential patterns.
3.1. Basic concepts
To set up weights of items, an attribute value of the
retail items can be used. For example, prices (profits) of
items can be used as a weight factor in market basket data.
However, the real values of items are not suitable for
weight values because of the big variation.
Table 3 shows an example of a retail database. As shown
in Table 3, we can know that variation of items’ prices is so
big that the prices cannot be directly used as weights.
Therefore, the normalization process is needed which
adjusts for differences among data from varying sources
Table 3
An example of retail database
Bar code Item Price ($)
1 Laptop computer 1200
2 Desktop computer 700
3 Memory stick 200
4 Memory card 150
5 Hard disk 100
6 Mouse 40
7 Mouse pad 10
113
in order to create a common basis for comparison. Weights
of items are assigned with aw 6 weight 6 bw according to
items’ importance or priority. The weights with aw 6
weight 6 bw are normalized as minw 6 weight 6 maxw
and the normalized weights can be used in the mining pro-
cess. As shown in Table 3, attribute values as prices of
items in market basket data can be used as a weight factor
and the prices of items can be normalized within a specific
weight range. Based on the definition, items, itemsets and a
sequence have their own weights. From this example,
weights of items are given between 0.01 and 1.2 and the
maximum weight of items is the weight (1.2) of the item
‘‘laptop computer’’. In our approach, the weight range is
used for efficient mining.
Definition 3.1. Weight of a sequential pattern (sequence)
A weight of an item is a non-negative real number that
shows the importance of each item. Given a sequence SÆs1,
s2, . . ., smæ in which sj is (xj1, xj2, . . ., xjk), the weight of the
sequential pattern (sequence) is formally defined as
PLengthðs1 Þ PLengthðs Þ PLengthðs Þ
Weightðx1i Þ þ i¼1 2 Weightðx2i Þ þ ... þ i¼1 m Weightðxmi Þ
WeightðSÞ ¼ i¼1
lengthðs1 Þ þ lengthðs2 Þ þ . .. þ lengthðsm Þ
Table 4 shows example sets of items with different weights.
Given SDB in Table 1, WR2 in Table 4, and a minimum
support, 2, the set of items in the database, i.e., length-1
subsequences in the form of ‘‘<item>:support’’ is {<a>:
6, <b>: 6, <c>: 6, <d>: 5, <e>: 4, <f>: 3, <g>: 2, <h>:
1} and a weight list is {a: 0.9, b: 0.75, c: 0.8, d: 0.85, e:
0.75, f: 0.7, g: 0.85, h: 0.8}. When WR2 as normalized
weights of items within a sequence is used, the weight of
the sequence, <a (bc) (ac) d (cf)> is 0.8125 ((0.9 + 0.75 +
0.8 + 0.9 + 0.8 + 0.85 + 0.8 + 0.7)/8). Meanwhile, WR1
and WR3 are applied, the weights of the sequence, <a (bc)
(ac) d (cf)> is 1.0 ((1.2 + 1.0 + 0.9 +1.2 + 0.9 +
1.0 + 0.9 + 0.9)/8) and 0.4625 (0.5 + 0.2 + 0.6 +
0.5 + 0.6 + 0.4 + 0.6 + 0.3)/8), respectively. Additionally,
Maximum Weights (MaxW) of WR1, WR2, and WR3 are
1.3, 0.9 and 0.6 in this step.
Definition 3.2. Weighted support (WSupport) and mini-
mum weight threshold (min_weight)
A weighted support of a sequential pattern is defined as
the resultant value of multiplying the pattern’s support
with the weight of the pattern in which the weight of the
sequence (sequential pattern) is obtained by calculating
Support (frequency) Normalized weight
5000 1.2
3000 0.7
20,000 0.2
10,000 0.15
5000 0.1
80,000 0.04
100,000 0.01
114 U. Yun / Knowledge-Based Systems 21 (2008) 110–122

Table 4
The example sets of items with different normalized weights
Item <a> <b> <c> <d> <e> <f> <g> <h>
Support 6 6 6 5 4 3 2 1
WR1 (0.7 6 weight 6 1.3) 1.2 1.0 0.9 1.0 0.7 0.9 1.3 1.1
WR2 (0.7 6 weight 6 0.9) 0.9 0.75 0.8 0.85 0.75 0.7 0.85 0.8
WR3 (0.2 6 weight 6 0.6) 0.5 0.2 0.6 0.4 0.6 0.3 0.5 0.3

the average value of the weights in items of a sequence. A
weighted support is used to prune weighted infrequent
sequential patterns. Previous sequential pattern mining
has used only supports of patterns. However, in our
approach, support and weight of patterns are both consid-
ered simultaneously so the weighted support is defined as
the value of multiplying a sequential pattern’s weight by
the weight of the pattern and the weighted support (Weight
(S) * support (S)) of the pattern is compared with the min-
imum threshold. In addition, in WSpan, two measures of
weight and support are balanced by defining a minimum
weight threshold (min_weight) like a minimum support
(min_sup) to prune items with lower weights.
3.2. Weighted sequential pattern
Now, we define the weighted frequent sequential pattern
and analyze the two pruning conditions used in weighted
sequential pattern mining.
Definition 3.3. Weighted frequent sequential pattern
A pattern is called a weighted frequent sequential pat-
tern if and only if (1) the weighted support of the sequen-
tial pattern is no less than a minimum support and (2) the
support of the pattern is no less than a minimum support
or the weight of the pattern is no less than a minimum
weight.
In this definition of the weighed frequent sequential pat-
tern, first condition is to calculate the weighted support by
multiplying the weight with the support of a pattern, and
compare the weighted support with a minimum threshold.
Meanwhile, second condition is that the weight and the
support of the pattern are compared with the minimum
weight and the minimum support respectively. We show
two conditions (1) and (2) in Definition 3.3 have their
own pruning portions of weighted infrequent sequential
patterns.
3.2.1. Pruning condition 1: weighted support
(support * MaxW P min_sup)
The weighted support of a sequential pattern is no less
than the minimum support. In WSpan, the weighted sup-
port of multiplying the pattern’s support with MaxW in
the sequence database is no less than the minimum support
(A maximum weight (MaxW) is defined as a value of the
maximum weight of items in a sequence database or sub
sequence database during mining process).
Although a sequential pattern is weighted infrequent, super
patterns of the sequential pattern may be weighted frequent
sequential because a sequential pattern which has a low weight
can get a high weight after adding another item with a higher
weight. To prune weighted infrequent patterns earlier but
maintain the anti-monotone property, MaxW (instead of real
weight values) is used as an approximate maximum weight
when the weighted support of a sequential pattern is calcu-
lated. If a maximum weighted support (support (S) * MaxW)
of a sequential pattern S is less than the minimum support, any
super pattern cannot be a weighted frequent sequential
pattern so the pattern can be pruned now. During mining pro-
cess, weighted infrequent items are pruned and weights of the
weighted infrequent items in next step are not considered as
MaxW although weights of the items are high. By doing so,
the MaxW value is reduced and the approximate maximum
weighted support (support (S) * MaxW) becomes more accu-
rate. However, in final step, we need to check if the sequential
pattern is really weighted frequent sequential pattern (support
(S) * weight (S) P min_sup) because maximum weighed
support is an approximation value.
The columns in Table 5 show the set of sequences after
applying different weights. For example, when WR3 is
applied as normalized weights of items and a minimum
support is 2, an item f’s support is 3, and the weighted sup-
port (1.8) of multiplying the sequential pattern’s support
(3) with a MaxW (0.6) in the SDB is less than the minimum
support (2), so the item ‘‘f’’ in each sequence of the

Table 5
weighted sequences (sequential patterns) with different WRs
SID Weighted sequences Weighted sequences Weighted sequences
(WR1: 0.7 6 weight 6 1.3) (WR2: 0.7 6 weight 6 0.9) (WR2: 0.2 6 weight 6 0.6)
10 <a(abc)(ac)d(cf)> <a(abc)(ac)d(cf)> <a(abc)(ac)dc>
20 <(ad)c(bc)(ae)bc> <(ad)c(bc)(ae)bc> <(ad)c(bc)(ae)bc>
30 <(ef)(ab)(df)cb> <(ef)(ab)(df)cb> <e(ab)dcb>
40 <eg(af)cbc> <e(af)cbc> <eacbc>
50 <a(ab)(cd)egh> <a(ab)(cd)e> <a(ab)(cd)e>
60 <a(abd)bc> <a(abd)bc> <a(abd)bc>
 U. Yun / Knowledge-Based Systems 21 (2008) 110–122
sequence database is removed. Meanwhile, the number of
weighted sequential patterns can be increased when WR1
is used as normalized weights of items. The support of
the item ‘‘g’’ in the sequence database is 2 but the weighted
support (2.6) of multiplying the item’s support (2) with
MaxW (1.3) is greater than the minimum support (2), so
the item ‘‘g’’ is not pruned in the sequences.
3.2.2. Pruning condition 2 (support P min_sup or
weight P min_weight)
The support of the pattern is no less than the minimum
support or the weight of the pattern is no less than the min-
imum weight.
If the support of the sequential pattern is less than a
minimum support (min_sup) and its weight is also less
than a minimum weight (min_weight), it is a useless
sequential pattern because the pattern has low frequency
and low importance (priority). To find and remove useless
sequential patterns, we apply the minimum weight thresh-
old. When a weight and a support are considered sepa-
rately, there are four cases for sequences: sequences with
a high support and a high weight, a high support and a
low weight, a low support and a high weight and then a
low support and a low weight. Sequences with a low sup-
port and a low weight are useless sequences so these
sequences are pruned. However, sequences having other
cases cannot be pruned since these sequences may have
higher priorities although the supports of the sequences
are low, or the sequences may have higher frequencies
even if the weights of the sequences are low. Note that
this pruning condition 2 can prune items which have
low support and weight in sequential patterns, so the
pruning condition can be used to reduce the scope of
result patterns. Let us show an example to show the effect
of the minimum weight. Given a sequence database in
Table 1, a minimum support of 3, and WR3 as weights
of items, the pruning condition 2 is applied as follows.
If a minimum weight is 0.6, items ‘‘g’’ and ‘‘h’’ in each
sequence are pruned because the supports of the items is
less than the minimum support and the weights of the items
is less than the minimum weight. If a minimum weight is 0.4,
the item ‘‘h’’ in each sequence is only pruned. Meanwhile, no
item in each sequence is pruned if a minimum weight is less
than 0.4. In a similar way, the number of weighted sequential
patterns can be adjusted by using the minimum weight. Now,
three Lemmas are shown to analyze two pruning conditions
in Definition 3.3.
3.3. Analysis of two pruning conditions for detecting
weighted sequential patterns
Lemma 3.1. When two pruning conditions in Definition 3.3
are applied to prune weighted infrequent sequential patterns,
the case where a sequential pattern is pruned by only the
pruning condition 2 but not by the pruning condition 1 is that
the MaxW of a sequence database should be greater than one
as a minimum requirement.
115
Proof. In this case, the pruning condition 1 is satisfied
but the pruning condition 2 is not satisfied. In other
words, the weighted support of multiplying the pattern’s
support with a MaxW of a sequential pattern is no less
than a minimum support in pruning condition 1, but the
support of the sequential pattern is less than a min_sup
and the weight of the sequential pattern is less than a
min_weight in the pruning condition 2. Therefore, we
can see that the following two constraints must be
satisfied.
Constraint 1 : (weighted support (support * MaxW)
P min_sup)
Constraint 2 : (support < min_sup)
In the two constraints, a support of a sequential pattern
and a minimum support (min_sup) are fixed. Therefore, it
is certain that MaxW of a sequence database must be
greater than one to satisfy above two constraints. h
Example 1. Suppose that a sequence database in Table 1
is used, WR1 in Table 4 is utilized as a weight list, a min-
imum support is 5 and a minimum weight is 1.1. Then, a
support of a sequential pattern ‘‘(ab)c’’ is 4, the weight of
the sequential pattern is 1.03 ((1.2 + 1.0 + 0.9)/3). With
MaxW of 1.3, the maximum weighted support 5.2 (4
* 1.3) is greater than the minimum support (5) so the
sequential pattern satisfies the pruning condition 1. How-
ever, the support (4) of the sequential pattern is less than
a min_sup (5) and the weight (1.03) of the sequential pat-
tern is less than a min_weight (1.1). As a result, the prun-
ing condition 1 is satisfied but the pruning condition 2 is
not satisfied. Therefore, the sequential pattern is pruned
by the pruning condition 2 but not by the pruning condi-
tion 1 in the Definition 3.3 when MaxW is greater than
one. Note that if a weight of a sequential pattern is no
less than the min_weight, the sequential pattern cannot
be pruned by the pruning condition 2 irrespective of the
MaxW value. Additionally, although MaxW is greater
than one, the weighted support (support * MaxW) of the
sequential pattern may be less than the minimum support.
That is, a sequential pattern may be also pruned by the
pruning condition 1 even though MaxW is greater than
one.
Lemma 3.2. Two pruning conditions 1 and 2 in the Definition
3.3 have different pruning portions and they can be used
together although the pruning condition 1 can be more
broadly applied rather than the pruning condition 2.
Proof. We need to see two cases: (1) a sequential pattern is
pruned by the pruning condition 1 but not the pruning con-
dition 2 and (2) a sequential pattern is pruned by both
pruning conditions 1 and 2.
The case (1): a sequential pattern is only pruned by the
pruning condition 1. In this case, the pattern must satisfies
the following constraints.
116 U. Yun / Knowledge-Based Systems 21 (2008) 110–122
Constraint 3 : (weighted support (support * MaxW)
< min_sup)
Constraint 4 : (support P min_sup or weight P
min_weight)
If a support of a sequential pattern is greater than or
equal to a minimum support in the constraint 4, MaxW
should be less than one to satisfy the constraint 3. From the
constraints 3 and 4, if MaxW is less than one, the
sequential pattern can satisfy the constraint 3. Recall that
the weighted support of the pattern can be greater than or
equal to the minimum support even though the MaxW is
less than one (if the support of the sequential pattern is
relatively high). However, in this case, the support of the
sequential pattern is no less than the minimum support,
and the pattern cannot be also pruned by the pruning
condition 2. Hence, we do not need to consider the case. If
a weight of the sequential pattern is no less than a
minimum weight but the support of a sequential pattern is
less than the minimum support, the pattern cannot be
pruned by the pruning condition 2. Meanwhile, the
sequential pattern may be pruned when MaxW is greater
than one by the pruning condition 1. Therefore, we can
know that in the case (1), the pruning condition 1 is more
broadly used to prune weighted infrequent sequential
patterns.
The case (2): a sequential pattern is pruned by both
pruning conditions 1 and 2.
In the case (2), the following constraints should be
satisfied.
Constraint 5 : (weighted support (support * MaxW)
< min_sup)
Constraint 6 : (support < min_sup and weight <
min_weight)
Let us think the case that a support of a sequential
pattern is less than a minimum support in the constraint 6.
If MaxW is less than or equal to one, definitely, the
constraint 5 is also satisfied. Therefore, the sequential
pattern is pruned by the pruning condition 1. Meanwhile,
even if the MaxW is greater than one, the weighted support
(support * MaxW) can be less than the minimum support
when the support of the pattern is relatively low. In other
words, if the support of the sequential pattern is less than
(min_sup/MaxW), the sequential pattern is pruned by the
pruning condition 1. In this case, the additional require-
ment is needed to prune the sequential pattern. However,
the second part (weight < min_weight) in the constraint 6
must be also satisfied to prune the pattern in the pruning
condition 2 although the support of the sequential pattern
is less than the minimum support. Finally, when MaxW is
less than or equal to one, we can say if a sequential pattern
is pruned by the pruning condition 2, the sequential pattern
must be always pruned by the pruning condition 1.
However, if MaxW is greater than one, we know that the
sequential pattern is pruned when the support of the
pattern is less than (min_sup/MaxW) in the pruning
condition 1. Meanwhile, two condition parts (sup-
port < min_sup and weight < min_weight) in the constraint
6 must be both satisfied so that the sequential pattern is
pruned by the pruning condition 2. As a result, two
pruning conditions have different pruning portions and
they can be used together but we can know that the
pruning condition 1 can be more broadly applied rather
than the pruning condition 2. h
Example 2. In the Lemma 3.2, we proved that two pruning
conditions have different pruning portions and the pruning
condition 1 can be used more broadly. In the Example 1,
we already checked an example of a sequential pattern
pruned by only the pruning condition 2 and in this exam-
ple, the reverse example is shown. As used in the Example
1, given SDB in Table 1, WR1 in Table 4, min_sup of 5 and
min_weight of 1.1, a support of a sequential pattern
‘‘a(ab)’’ is 3, the weight of the sequential pattern is 1.13.
With MaxW of 1.3, the weighted support 3.4 (3 * 1.13) is
less than the minimum support (5) so the sequential pattern
is pruned by the pruning condition 1. Note that the support
(3) of the sequential pattern ‘‘a(ab)’’ is less than a min_sup
(5) but the weight (1.13) of the sequential pattern is greater
than a min_weight (1.1). Thus, the pattern ‘‘a(ab)’’ satisfies
the pruning condition 2. Finally, the pattern ‘‘a(ab) is
pruned by the pruning condition 1 but not pruned by the
pruning condition 2. From this example, we can know that
a sequential pattern may be pruned by only either one of
two pruning conditions and the pruning conditions have
their own pruning ranges.
Lemma 3.3. Based on the pruning conditions, WSpan
prunes more patterns than the approach to use only a min-
imum support when MaxW of the sequence database is less
than one.
Proof. In the normal sequential pattern mining, every item,
itemset and sequence has the same importance. That is,
their weights are 1.0. If the pruning condition 1 in Defini-
tion 3.3 is considered, the approximate weighted supports
of sequential patterns are calculated by multiplying the
supports of the sequential patterns with MaxW which are
compared with support threshold. Given a minimum sup-
port threshold, the sequential patterns can be weighted fre-
quent or weighted infrequent according to the MaxW.
Although a support of a sequential pattern is no less than
the support threshold and the sequential pattern is fre-
quent, the pattern may be a weighted infrequent sequential
pattern if MaxW is less than one. More items or sequential
patterns are pruned when weights of items and patterns are
set as less than one. Note that the reverse case is not
occurred. In other words, given MaxW more than one, if
a pattern is weighted frequent sequential pattern, the pat-
tern is definitely frequent sequential pattern because
weighted support of the pattern is greater than support
of the pattern. h
 U. Yun / Knowledge-Based Systems 21 (2008) 110–122
Example 3. Given SDB in Table 1, WR2 as weights of
items from Table 4, min_sup of 4, the weight list is
<a:0.9, b:0.75, c:0.8, d:0.85, e:0.75, f:0.7, g:0.85, h:0.8>,
and MaxW is 0.9. In the normal sequential pattern mining,
the sequential pattern ‘‘(ab)’’ is a frequent sequential pat-
tern and it is not pruned since the support (4) of the pattern
is equal to the minimum support (4). However, the sequen-
tial pattern is weighted infrequent because the approximate
weighted support (3.6 (4 * 0.9)) is less than the minimum
threshold (4). In weighted sequential pattern mining, the
pattern is relatively not important and it is pruned.
3.4. Mining weighted sequential patterns
On the framework, as a mining example, we develop the
WSpan algorithm to detect weighted sequential patterns.
In this mining example, based on the framework, the
weight constraint is pushed into the prefix projected
sequential pattern growth approach. A sequence database
is recursively projected into a set of smaller weighted pro-
jected databases and weighted sequential patterns are
grown in each weighted projected database. Given a
sequence a = <e1, e2, . . ., en> (in which each ei means a fre-
quent element in S), a sequence b < e01 ; e02 . . . e0m > ðm 6 nÞ
is called a prefix of the sequence a if (1) ei ¼ e0i for
(i 6 m  1), (2) e0m  em and (3) all the weighted frequent
items in ðem  e0m Þ are alphabetically listed after those in
e0m . Given a sequential pattern a in a sequence database,
a-projected database (S|a) is the collection of suffixes of
sequences in S about the prefix a. The support (supports|a
(b)) of a sequential pattern b in the a-projected database
(S|a) is the number of weighted sequences c in S|a.
WSpan algorithm: Weighted Sequential pattern mining
in large sequence databases.
Input: (1) A sequence database: SDB,
(2) The minimum support threshold: min_sup,
(3) The minimum weight threshold: min_weight,
Output: The complete set of weighted sequential
patterns.
Begin
1. Let WSP be the set of Weighted Sequential Pat-
terns. Initialize WSP ‹ {};
2. Scan SDB once, count the support of each item,
check the weight of each item and find each
weighted frequent item, b, in sequences satisfying
the following pruning conditions: b is a weighted
sequential item if the following pruning conditions
are satisfied.
Condition 1: (support * MaxW P min_sup)
Condition 2: (support P min_sup or
weight P min_weight)
3. For each weighted frequent item, b, in SDB
Call WSPan (WSP, <b>, 1, SDB)
End for
End
117
Procedure WSpan (WSP, a, L, S|a)
Parameter:
(1) a is a weighted sequential pattern.
(2) L is the length of a,
(3) S|a is the sequence database, SDB if a is null,
otherwise, it is the a-projected database.
1. Scan S|a once, count the support of each item, and
find each weighted frequent item, b in sequences: b is
a weighted sequential item if the following pruning
conditions are satisfied.
Condition 1: (weighted support (support *
MaxW) P min_sup)
Condition 2: (support P min_sup or weight
P min_weight)
(a) b can be assembled to the last itemset of a to form
a weighted sequential pattern or
(b) <b> can be appended to a to form a weighted
sequential pattern.
2. For each weighted frequent item b,
Add it to a to form a sequential pattern a 0 , and
output a 0 .
End for
3. For each a 0 ,
Construct a 0 -weighted projected database S| a 0 ;
Call WSpan (a 0 , L + 1, S| a 0 )
End for
After WSpan algorithm calls the procedure WSpan (WSP,
<b>, 0, SDB), WSpan (a 0 , L + 1, S| a 0 ) is called recursively
after a 0 projected database S|a 0 is constructed. Recall that
the approximate maximum weighted support (support
(S) * MaxW) is used. Therefore, in final step, we should
prune weighted infrequent sequential patterns which satisfy
this condition (support (S) * MaxW P min_sup).
Example 4. (Mining weighted sequential patterns) We
show how to mine weighted sequential patterns by using
a prefix-based projection approach. Given SDB in Table 1,
a minimum support, 2, and WR2 as normalized weights of
items in Table 4, weighted sequential patterns are mined by
the prefix projection approach as follows. (1) scan the
sequence database once, and find all the weighted frequent
items in sequences. The weighted infrequent items can be
removed according to pruning conditions. For instance,
items ‘‘g’’, and ‘‘h’’ in each itemset within sequences are
pruned because the weighted support (1.8) of multiplying
the item’s support (2) with MaxW (0.9) is less than the
minimum support (2). Length-1 weighted frequent sequen-
tial patterns are <a>: 6, <b>: 6, <c>: 6, <d>: 5, <e>: 4,
<f>: 3, and the weight list is <a: 0.9, b: 0.75, c: 0.8, d: 0.85,
e: 0.75, f: 0.7>. The complete set of weighted sequential
patterns can be partitioned into following six subsets
according to six prefixes: <a>, <b>, <c>, <d>, <e>, and
<f>. The subsets of weighted sequential patterns can be
mined by constructing the corresponding set of weighted
projected databases and mining them recursively. We only
collect the sequences which have the prefix <a>. Addition-
ally, in a sequence containing the prefix <a>, only the
118 U. Yun / Knowledge-Based Systems 21 (2008) 110–122
subsequence prefixed with the first occurrence of the prefix
<a> should be considered. The sequences in sequence
database containing the prefix <a> are projected with
regards to the prefix <a> to form the <a>-projected
database, which consists of six suffix sequences: <(abc) (ac)
d (cf)>, <(d) c (bc) (ae) bc>, <(b) (df) cb>, <(f)
cbc><(ab) (cd) e> and <(abd) bc>. By scanning the prefix
<a> projected database once, its local items are a:4, b:6,
c:6, d:4, e:2, f:2, (b):4, (d):1, (e):1 and (f):1.
Weighted infrequent local items are pruned and the
length-2 weighted sequential patterns prefixed with the
prefix <a> are: <aa>:4, <ab>:6, <ac>:6, <ad>:4, and
<(ab)>:4. Before constructing the next projected database,
pruning conditions are applied in order to check whether it
is a weighed sequential pattern. Recursively, all the
weighted sequential patterns with the prefix <a> can be
partitioned into four subsets: those prefixed with (1) the
prefix <aa>, (2) <ab>, (3) <ac>, (4) <ad>, and finally, (5)
<(ab)>. For example, the <aa> projected database consists
of four suffix subsequences prefixed with the prefix <aa>:
<(bc) (ac) dc)>, <bc>,<(b) (cd)>, and <(bd) bc>. By
scanning the <aa> projected database once, its local items
are a:1, b:2, c:4, d:2, (b):3, and (c):1 and weighted
infrequent items a:1, b:2, d:2 and (c):1 are pruned. Hence,
the <aa> projected database returns two weighted sequen-
tial patterns: <aac>:4, and <a(ab)>:3. As another example,
the <(ab)> projected database consists of four suffix
subsequences prefixed with the prefix <(ab)>: <(c) (ac)
dc>, <dcb>, <(cd)> and <(d) bc>. By scanning the
<(ab)> projected database once, its local items are a:1, b:2,
c:4, d:3, (c):1 and (d):1. Weighted infrequent items a:1,
b:2, (c):1 and (d):1 are pruned from pruning conditions.
Finally, the <(ab)> projected database returns weighted
sequential patterns <(ab)c>:4 and <(ab)d>:3. In this way,
WSpan finds weighted sequential patterns with the prefixes
<b>, <c>, <d>, <e>, and <f>, respectively.
4. Performance evaluation
In this section, we present our performance study over
various datasets. The WSpan is the first sequential pat-
tern mining algorithm to consider weights of sequences,
itemsets of the sequences and items of the itemsets. We
report our experimental results on the performance of
WSpan in comparison with a recently developed algo-
rithm, SPAM [2], which is currently the fastest algorithm
for mining sequential patterns. First, we show how the
number of weighted sequential patterns can be adjusted,
the efficiency in terms of runtime of the WSpan algo-
rithm, and the quality of weighted sequential patterns.
Second, we show that WSpan has good scalability
against the number of sequences. The IBM dataset gener-
ator (http://www.almaden.ibm.com/software/projects/
hdb/resources.shtml) is used to generate sequence data-
sets in this test. It accepts essential parameters such as
the number of sequences (customers), the average
number of itemsets (transactions) in each sequence, the
average number of items (products) in each itemset,
and the number of different items in the dataset. Table 6
shows parameters and their meanings in this sequential
dataset generation. More detail information can be
found in [1]. WSpan was written in C++ and experi-
ments were performed on a sparcv9 processor operating
at 1062 MHz, with 2048 MB of memory. All experiments
were performed on a Unix machine. In our experiments,
a random generation function was used to generate nor-
malized weights for each item.
4.1. Comparison of WSpan and SPAM
Our experiment shows that in most cases, WSpan out-
performs SPAM. In this test, different weight ranges with
normalized weights are applied but the minimum weight
is fixed as a minimum value within weight ranges to test
the effect of the weight range.
Figs. 1 and 2 show that WSpan generates fewer sequen-
tial patterns and runs faster than SPAM. Specifically, much
fewer sequential patterns are generated as the weight range
is decreased. Note that SPAM generates huge sequential
patterns and it is slower as the minimum support is
decreased. In SPAM, the number of sequential patterns
increases quickly when a minimum support is less than
10%. Moreover, the runtime becomes much slower as the
minimum support is less than 6%. Meanwhile, WSpan gen-
erates fewer patterns than SPAM by adjusting the weight
range. We can see that WSpan is faster than SPAM. In
addition, the number of patterns discovered by WSpan is
Table 6
Parameters for IBM quest data generator
Symbol Meaning
D Number of customers in the dataset
C Average number of transactions per customer
T Average number of items per transactions
S Average length of maximal sequences
I Average length of transactions within the maximal sequences
N Number of different items
50000
45000 SPAM
40000
Numberof patterns
WSpan (WR: 0.4 - 0.5)
35000 WSpan (WR: 0.3 - 0.4)
30000 WSpan (WR: 0.2 - 0.3)
25000
20000
15000
10000
5000
0
4 6 8 10
Minimum support
Fig. 1. Number of patterns.
 U. Yun / Knowledge-Based Systems 21 (2008) 110–122 119

30 140
SPAM SPAM
Runtime in seconds 120

Runtime in seconds
25 WSpan (WR: 0.4 - 0.5) WSpan (WR:0.4 - 0.5)
WSpan (WR: 0.3 - 0.4)
100
20 WSpan (WR:0.3 - 0.4)
WSpan (WR: 0.2 - 0.3) 80
15
60
10 40
5 20
0 0
4 6 8 10 2.5 3 3.5 4 4.5 5 5.5 6
Minimum support (in %) Minimum support (in %)

Fig. 2. Runtime. Fig. 4. Runtime.

several orders of magnitude fewer than the number of

sequential patterns found by SPAM with the same mini- 10000
SPAM
9000
mum supports. WSpan (WR: 0.8 - 0.85)

Number of patterns
8000
Figs. 3 and 4 demonstrate the results of performance test 7000
WSpan (WR: 0.75 - 0.8)
WSpan (WR: 0.7 - 0.75)
using the D7C7T7S7I7 dataset by setting normalized 6000
WSpan (WR: 0.65 - 0.7)
weights of items from 0.2 to 0.5. In this dataset, WSpan 5000 WSpan (WR: 0.6 - 0.65)
shows better performance than SPAM and the perfor- 4000
3000
mance difference becomes larger when the support thresh-
2000
old is lowered. In Fig. 3, the number of sequential 1000
patterns is increased as the minimum support is decreased, 0
but the number of sequential patterns in SPAM is substan- 40 45 50
Minimum support (in %)
55
tially increased as the minimum support becomes lower.
Although SPAM can reduce the number of patterns by Fig. 5. Number of patterns.
increasing the minimum support, unimportant patterns
are discovered in the result sets. Meanwhile, in WSpan, 2000
the unimportant patterns are pruned first during mining SPAM
WSpan (WR: 0.8 - 0.85)
process, resulting in concise but significant patterns. In
Runtime in seconds

1600 WSpan (WR: 0.75 - 0.8)

Fig. 4, WSpan is faster than SPAM and the difference WSpan (WR: 0.7 - 0.75)
1200 WSpan (WR: 0.65 - 0.7)
becomes bigger as the minimum support is lowered. WSpan (WR: 0.6 - 0.65)
In Figs. 5 and 6, we report the evaluation results for 800
D15C15T15S15I15 dataset. The main performance differ-
ence between WSpan and SPAM algorithms results from 400

using a weight range. By decreasing the support threshold, 0

the number of sequential patterns of WSpan is increased 40 45 50 55
but the number of SPAM is extremely increased. In Minimum support (in %)
Fig. 5, we could not show the number of sequential pat- Fig. 6. Runtime.
terns of SPAM, because the number of sequential patterns
mined by SPAM is huge with the minimum support of less
than 55%. For example, the numbers of sequential patterns
in SPAM are 449,403 with a minimum support of 55%,
1,365,328 with a minimum support of 50%, 44,062,294 with
a minimum support of 45%, and so on. In Fig. 6, WSpan is
80000 faster than SPAM. Our above experiments show that
70000 SPAM WSpan can generate fewer but important frequent sequen-
Number of patterns

60000 WSpan (WR: 0.4 - 0.5) tial patterns with various weight ranges in several datasets.
50000 WSpan (WR: 0.3 - 0.4) It may be not surprising that the number of patterns and
40000 the runtime are reduced. The number of patterns can be
30000 decreased by increasing the minimum support in previous
20000 sequential pattern mining. However, by increasing the min-
10000 imum support in previous mining algorithms, important
0 patterns with high weights can be also removed but unim-
2.5 3 3.5 4 4.5 5 5.5 6
portant patterns (with low weights) are still found. It is dif-
Minimum support (in %)
ficult to detect important sequential patterns by using the
Fig. 3. Number of patterns. minimum support. Constraint-based sequential pattern
120 U. Yun / Knowledge-Based Systems 21 (2008) 110–122

mining [8,11,13] can be applied to reduce the number of
patterns but previous constraints do not provide a way to
find important patterns but prune unimportant patterns.
WSpan discovers important patterns by using weights of
items, itemsets of the items, and sequences of the itemsets.
4.2. Effect of the minimum weight
of these sequential patterns are more than the minimum
support but the weights of the patterns are relatively less
low. The result patterns of WSpan are different from those
of general sequential pattern mining even though the num-
ber of patterns of WSpan and SPAM can be reduced by
using the minimum support.

We perform this test to show the effect of the minimum
weight. In this test, D7C7T7S7I7 dataset is used. Table 5
lists the number of Weighted Sequential Patterns (WSP)
with various minimum weights by WSpan and Sequential
Patterns (SP) generated by SPAM.
From Table 7, WSpan generates fewer WSP by using
different minimum weight thresholds. For example, the
numbers of sequential patterns are 63,207. Meanwhile,
the number of WSP at a minimum support: 6%, a WR:
0.8–1.2 and a minimum weight: 0.8 is 48,827, the number
of WSP can be reduced to 36,156 with a minimum weight:
1.0 and can be further reduced to 27,826 with a minimum
weight, 1.2. By increasing the minimum weight, the pat-
4.4. Scalability test
The DxC2.5T5S4I2.5 dataset is used to test scalability
with the number of sequences in the sequence database.
From the performance test, both WSpan and SPAM
show linear scalability with the number of sequences from
20K to 100K but WSpan is much more scalable than
SPAM.
In Figs. 7 and 8, the difference between WSpan and
SPAM becomes clear. WSpan has much better scalability
1000
900
SPAM

terns with relatively low weights are first pruned. In this WSpan (WR: 0.4 - 0.5)

Runtime in seconds
800
WSpan (WR: 0.3 - 0.4)
way, the proper number of weighted sequential patterns 700
600 WSpan (WR: 0.2 - 0.3)
can be found by adjusting the minimum weight.
500
400
4.3. Quality of weighted sequential patterns 300
200
In the previous tests, we showed the efficiency in terms 100
0
of the number of patterns and runtime. In all datasets, 20K 40K 60K 80K 100K
items are expressed as integer values. In this test, the Databasesize (sequences)
D7C7T5S4I2.5 dataset is used to illustrate the quality of
Fig. 7. Scalability test (Min_sup = 0.4%).
weighted frequent sequential patterns. We compare the
patterns mined by WSpan with those found by SPAM
(general sequential pattern mining) and show that the
result sets of two approaches are different in spite of using 600
SPAM
the same minimum support. For example, sequential pat- 500 WSpan (WR: 0.5 - 0.6)
Runtime in seconds

terns (<pattern>:support) <(17, 45) (91) (70) (91)>:22 WSpan (WR: 0.4 - 0.5)
400 WSpan (WR: 0.3 - 0.4)
and <(45) (27, 91) (70)>:21 are mined by SPAM with the
minimum support, 3%. However, these sequential patterns 300
are pruned by WSpan with the weight range, 0.3–0.4 200
because these patterns are weighted infrequent sequential
100
patterns. Second, although the minimum support is
increased from 3% to 5%, weighted infrequent sequential 0
20K 40K 60K 80K 100K
patterns such as <(17, 45) (91) (70) (91)>:22 and <(45) Database size (sequences)
(27, 91) (70)>:21 are found by SPAM. Meanwhile, the pat-
terns are pruned by WSpan. In other words, the supports Fig. 8. Scalability test (Min_sup = 0.5%).

Table 7
The effect of the minimum weight threshold (min_weight)
Minimum support (%) Number of W.S.P Number of W.S.P Number of W.S.P Number of S.P
WR: 0.8–1.2 WR : 0.8–1.2 WR : 0.8–1.2
min_weight : 1.2 min_weight: 1.0 min_weight: 0.8
5 56,897 79,320 1,13,712 1,24,728
5.5 36,475 48,356 66,825 81,792
6 27,826 36,156 48,827 63,207
6.5 19,394 26,204 36,475 44,262
 U. Yun / Knowledge-Based Systems 21 (2008) 110–122
in terms of number of sequences in the database and
becomes faster as a weight range is decreased. In SPAM,
the runtime increases dramatically as the number of
sequences becomes larger.
5. Conclusions and future work
In this paper, we described a framework of mining
weighted sequential patterns and developed WSpan algo-
rithm based on the prefix projected sequential pattern
growth approach. We suggested a new approach to detect
more important sequential patterns. The extensive perfor-
mance analysis shows that WSpan is efficient and scalable
in weighted sequential pattern mining. This framework of
mining weighted sequential patterns can be applied in sev-
eral areas. In application domains such as financial data
analysis, retail industry and telecommunication industry,
the weighted sequential patterns mining can be used to
detect unusual access such as sequences related to finan-
cial crimes, fraudulent telecommunication activities, and
purchase of expensive items within a short time. In this
case, the high weights are given to previously found
fraudulent patterns (items within the patterns) and dis-
cover the suspicious patterns. As future research, to set
up weights of items, prices of items can be used as a
weight factor in market basket data. However, we should
think of ways to assign weights to items in other types of
datasets such as web log data, biomedical data, DNA
data and data used in other applications. Second, we need
to have more research and experiment to give guidance of
how efficiently to set up the thresholds. Effective settings
of thresholds are essential although it is the common
problem of all threshold-based mining algorithms. As fur-
ther extension, based on the framework, the weighted
sequential pattern mining algorithm can be implemented
using vertical bitmap representation. In addition, WSpan
can be extended and optimized by mining weighted closed
sequential patterns.
References
[1] R. Agrawal, R. Srikant, Mining Sequential Patterns, in: Proc. the
Eleventh International Conference on Data Engineering, March 1995,
1995, pp. 3–14.
[2] J. Ayres, J. Gehrke, T. Yiu, J. Flannick, Sequential Pattern Mining
Using a Bitmap Representation, in: Proc. the Eighth ACM SIGKDD
International Conference on Knowledge Discovery and Data Mining,
July 2002, 2002, pp. 429–435.
[3] C.H. Cai, A.W. Fu, C.H. Cheng, W.W. Kwong, Mining association
rules with weighted items, in: Proc. International Database Engineer-
ing and Applications Symposium, IDEAS 98, Cardiff, Wales, U.K.,
1998, pp. 68–77.
[4] D. Chiu, Y. Wu, A.L. Chen, An efficient algorithm for mining
frequent sequences by a new strategy without support counting, in:
Proc. the Twentieth International Conference on Data Engineering,
March/April 2004, 2004, pp. 375–386.
[5] H. Cheng, X. Yan, J. Han, IncSpan: incremental mining of sequential
patterns in large databases, in: Proc. the Tenth ACM SIGKDD
International Conference on Knowledge Discovery and Data Mining,
Aug. 2004, pp. 527–532.
121
[6] H. Chung, X. Yan, J. Han, SeqIndex: indexing sequences by
sequential pattern analysis, in: Proc. the Fifth SIAM Interna-
tional Conference on Data Mining, April 2005, 2005, pp. 601–
605.
[7] M. Ester, A top–down method for mining most specific frequent
patterns in biological sequence data, in: Proc. the Fourth SIAM
International Conference on Data Mining, April 2004, 2004, pp. 90–
101.
[8] M. Garofalakis, R. Rastogi, K. Shim, SPIRIT: Sequential pattern
mining with regular expression constraints, in: Proc. the Twenty-fifth
International Conference on Very Large Data Bases, (VLDB’99),
September 1999, 1999, pp. 223–234.
[9] J. Han, J. Pei, B.M. Asi, Q. Chen, U. Dayal, M.C. Hsu,
FreeSpan: frequent pattern-projected sequential pattern mining, in:
Proc. the Sixth ACM SIGKDD International Conference on
Knowledge Discovery and Data Mining, August 2000, 2000, pp.
355–359.
[10] H.C. Kum, J. Pei, W. Wang, D. Duncan, ApproxMAP: approximate
mining of consensus sequential patterns, in: Proc. the Third SIAM
International Conference on Data Mining, May 2003, 2003, pp. 311–
315.
[11] H. Albert-Lorincz, J.F. Boulicaut, Mining frequent sequential
patterns under regular expressions: a highly adaptive strategy for
pushing constraints, in: Proc. the Third SIAM International Confer-
ence on Data Mining, May 2003, pp. 316–320.
[12] J. Pei, J. Han, B.M. Asi, H. Pino, PrefixSpan: mining sequential
patterns efficiently by prefix-projected pattern growth, in: Proc. the
Seventeenth International Conference on Data Engineering, April
2001, 2001, pp. 215–224.
[13] J. Pei, J. Han, W. Wang, Mining sequential patterns with constraints
in large databases, in: Proc. the 2002 ACM CIKM International
Conference on Information and Knowledge Management, November
2002, 2002, pp. 18–25.
[14] J. Pei, J. Han, B.M. Asi, J. Wang, Q. Chen, Mining Sequential Patterns
by Pattern-Growth: The PrefixSpan Approach, IEEE Transactions on
Knowledge and Data Engineering 16 (2004) 1424–1440.
[15] H. Pinto, J. Han, J. Pei, K. Wang, Multi-dimensional sequence
pattern mining, in: Proc. the 2001 ACM CIKM International
Conference on Information and Knowledge Management, November
2001, 2001, pp. 474–481.
[16] R. Srikant, R. Agrawal, Mining sequential patterns: generalizations
and performance improvements, in: Proc. the Fifth International
Conference on Extending Database Technology, March 1996, 1996,
pp. 3–17.
[17] F. Tao, Weighted association rule mining using weighted support and
significant framework, in: Proc. the Ninth ACM SIGKDD Interna-
tional Conference on Knowledge Discovery and Data Mining,
August 2003, 2003, pp. 661–666.
[18] P. Tzvetkov, X. Yan, J. Han, TSP: Mining top-K closed sequential
patterns, in: Proc. the Third IEEE International Conference on Data
Mining (ICDM 2003), December 2003, 2003, pp. 347–354.
[19] J. Wang, J. Han, BIDE: Efficient mining of frequent closed sequences,
in: Proc. the Twentieth International Conference on Data Engineer-
ing, March/April 2004, 2004, pp. 79–90.
[20] K. Wang, Y. Xu, J.X. Yu, Scalable Sequential Pattern Mining for
Biological Sequences, in: Proc. the 2004 ACM CIKM International
Conference on Information and Knowledge Management, November
2004, 2004, pp. 178–187.
[21] W. Wang, J. Yang, P.S. Yu, Efficient mining of weighted association
rules (WAR), in: Proc. the Sixth ACM SIGKDD International
Conference on Knowledge Discovery and Data Mining, August 2000,
2000, pp. 270–274.
[22] X. Yan, J. Han, gSpan: Graph-based substructure pattern mining, in:
Proc. the 2002 IEEE International Conference on Data Mining
(ICDM 2002), pp. 721-724, December. 2002.
[23] X. Yan, J. Han, R. Afshar, CloSpan: Mining Closed Sequential
Patterns in Large Datasets, the Third SIAM International Conference
on Data Mining, May 2003.
122 U. Yun / Knowledge-Based Systems 21 (2008) 110–122

[24] J. Yang, P.S. Yu, W. Wang, J. Han, Mining Long Sequential Patterns in
a Noisy Environment, in: Proc. the 2002 ACM SIGMOD International
Conference on Management of Data, pp. 406-417, June 2002.
[25] U. Yun, J.J. Leggett, WLPMiner: Weighted Frequent Pattern Mining
with Length decreasing support constraints, in: Proc. the Ninth
Pacific-Asia Conference on Knowledge Discovery and Data Mining,
Hanoi, Vietnam, pp. 555-567, May 2005.
[26] U. Yun, Efficient Mining of Weighted Interesting Patterns with a
strong weight and/or support affinity, Information Sciences
(2007).
[27] U. Yun, Mining lossless closed frequent patterns with weight
constraints, Knowledge based systems 210 (2007) 86–97.
[28] M.J. Zaki, SPADE: An Efficient Algorithm for Mining Frequent
Sequences, Machine Learning 42 (2001) 31–60.