关联规则与序列模式
关联规则挖掘的的目标是寻找达到某种程度联系的事物集合，再由其产生相关的关联规则。它并不考虑事物发生的先后顺序。
先作出下述定义：
I ={i1, i2, …, im}是若干项目集合，包含k个项目的集合称为k项集；T = (t1, t2, …, tn)是若干事务集合。其中ti ⊆ I。
一个关联规则可表述成如下蕴含式形式：
X → Y，其中X ⊂ I, Y ⊂ I且X ∩ Y = ∅。 X、Y被称作项集，X为前件，Y为后件。
如果ti ∈ T是X的一个超集，则称ti 包含X，T中包含X的事务总数被称作支持计数（support count），可表示为X.count。
针对先前定义的I和T，下面定义规则支持度和规则可信度（规则为X → Y）：
支持度（support）：
其中n为事物级T中的事务总数。
可信度（confidence）：
可信度表示在
项集X发生的前提下
项集Y发生的条件概率。可以由此推测在X出现的同时Y出现的可能性大小。
为了使获得的关联规则有价值，设置了最小支持度（minsup）和最小可信度（minconf），当某个关联规则
X → Y的支持度和可信度均不于
minsup和minconf时，则其为强关联规则。
关联规则挖掘则是找出当前事务集T中的全部强关联规则。当给定事务集T、minsup和minconf后，T中的全部强关联规则是唯一确定的。
注：minsup和minconf的值应可以根据经验设置
2.2 Apriori 算法
Apriori算法主要包含两个步骤，第一步生成全部频繁项集（支持度高于minsup的项集），第二步在频繁项集中生成所有的强关联规则（规则可信度不小于minconf）。
算法中出现的任一项集中项目按字典排序。
第一步
生成全部频繁项集算法如下：
Algorithm Apriori(T)
1 C1 ← init-pass(T);
2 F1 ← {f | f ∈ C1, f.count/n ≥ minsup};
3 for (k = 2; Fk−1 ≠ ∅; k++) do
4 Ck ← candidate-gen(Fk−1);
5 for each transaction t ∈ T do
6 for each candidate c ∈ Ck do
7 if c is contained in t then
8 c.count++;
9 endfor
10 endfor
11 Fk ← {c ∈ Ck | c.count/n ≥ minsup}
12 endfor
13 return F ← Uk Fk;
上述生成频繁集的算法需要逐级搜索（其中需要用到候选集生成函数candidate-gen生成候选集Ck）
1 C1 ← init-pass(T);
2 F1 ← {f | f ∈ C1, f.count/n ≥ minsup};
3 for (k = 2; Fk−1 ≠ ∅; k++) do
4 Ck ← candidate-gen(Fk−1);
5 for each transaction t ∈ T do
6 for each candidate c ∈ Ck do
7 if c is contained in t then
8 c.count++;
9 endfor
10 endfor
11 Fk ← {c ∈ Ck | c.count/n ≥ minsup}
12 endfor
13 return F ← Uk Fk;
上述生成频繁集的算法需要逐级搜索（其中需要用到候选集生成函数candidate-gen生成候选集Ck）
候选集和频繁集的生成顺序依次是C1 → F1→ C2→……→Fk ……直至Fk−1=∅。
其中C1和F1 先单独生成，5-10步筛选 Ck 中支持度不小于minsup的项集c加入Fk中（可以不用将所有数据一次性加入内存，每次仅加入一个事务集中的项集，使得该算法可以适应大规模数据集合，但同时也可能间接增加了I/O的次数，使得I/O负荷增大，处理时间增多），最后将所有生成的 Fk合并到F中 ，F即为T中全部频繁集的集合。
Function candidate-gen(Fk−1)
1 Ck ← ∅;
2 forall f1, f2 ∈ Fk−1
3 with f1 = {i1, … , ik−2, ik−1}
4 and f2 = {i1, … , ik−2, i’k−1}
5 and ik−1 < i’k−1 do
6 c ← {i1, …, ik−1, i’k−1};7 Ck ← Ck ∪ {c}; 8 for each (k−1)-subset s of c do9 if (s ∉ Fk−1) then10 delete c from Ck; 11 endfor12 endfor13 return Ck;候选集Ck 的生成利用了向下封闭属性（Downward Closure Property）进行筛选，先将Fk−1中的具有3、4、5步骤形式的项集对取出合并成c并加入 C k ，而后再用一个循环取出c中的所有 k-1 项子集，检测其是否在 F k−1中，如果不存在，则在Ck 中删除项集c。
1 Ck ← ∅;
2 forall f1, f2 ∈ Fk−1
3 with f1 = {i1, … , ik−2, ik−1}
4 and f2 = {i1, … , ik−2, i’k−1}
5 and ik−1 < i’k−1 do
6 c ← {i1, …, ik−1, i’k−1};7 Ck ← Ck ∪ {c}; 8 for each (k−1)-subset s of c do9 if (s ∉ Fk−1) then10 delete c from Ck; 11 endfor12 endfor13 return Ck;候选集Ck 的生成利用了向下封闭属性（Downward Closure Property）进行筛选，先将Fk−1中的具有3、4、5步骤形式的项集对取出合并成c并加入 C k ，而后再用一个循环取出c中的所有 k-1 项子集，检测其是否在 F k−1中，如果不存在，则在Ck 中删除项集c。
向下封闭属性：若一个项集是频繁的，则其所有非空子集也是频繁的。（由T中包含某频繁集的事物必包含此频繁集的子集可证）
故易知若一个项集不是频繁的，则其超集亦不是频繁的。此时即可将Ck 中不符合条件的项集删除。
（虽然应用了向下封闭属性，但如果频繁集的数目足够多，则生成的候选集中可能会含有大量的冗余非频繁项集）
当我们只对规模较小的频繁集感兴趣，如果网上商店货物推荐，某一商品下方列表只能列出很少数量的推荐物品（可以认为推荐物品与此商品同属于一个频繁集），一方面是由于网页大小限制，另一方面照顾顾客查看的便捷性。采用逐级搜索的方式可以将频繁集的搜素限制在某个规模范围内，可以节省时间和空间。
第二步根据频繁项集生成所有的强关联规则算法如下：
Algorithm genRules(F)
1 for each frequent k-itemset fk in F, k ≥ 2 do
2 output every 1-item consequent rule of fk with confidence ≥ minconf and
support ← fk.count / n
3 H1 ←{consequents of all 1-item consequent rules derived from fk above};
4 ap-genRules(fk, H1);
5 endfor
Procedure ap-genRules(fk, Hm)
1 if (k > m + 1) AND (Hm ≠ ∅) then
2 Hm+1 ← candidate-gen(Hm);
3 for each hm+1 in Hm+1 do
4 conf ← fk.count / (fk − hm+1).count;
5 if (conf ≥ minconf) then
6 output the rule (fk − hm+1) → hm+1 with confidence = conf and
support = fk.count / n;
7 else
8 delete hm+1 from Hm+1;
9 endfor
10 ap-genRules(fk, Hm+1);
11 endif
1 for each frequent k-itemset fk in F, k ≥ 2 do
2 output every 1-item consequent rule of fk with confidence ≥ minconf and
support ← fk.count / n
3 H1 ←{consequents of all 1-item consequent rules derived from fk above};
4 ap-genRules(fk, H1);
5 endfor
Procedure ap-genRules(fk, Hm)
1 if (k > m + 1) AND (Hm ≠ ∅) then
2 Hm+1 ← candidate-gen(Hm);
3 for each hm+1 in Hm+1 do
4 conf ← fk.count / (fk − hm+1).count;
5 if (conf ≥ minconf) then
6 output the rule (fk − hm+1) → hm+1 with confidence = conf and
support = fk.count / n;
7 else
8 delete hm+1 from Hm+1;
9 endfor
10 ap-genRules(fk, Hm+1);
11 endif
此算法主要部分是ap-genRules的递归，递归生成某个k-频繁集中的所有强关联规则。其中Hm是m-后件的集合（候选集），k>m+1是因为规则的前件不能为∅。
一个频繁项集X生成的强关联规则后件为a，前件为X-a，则a的任一非空子集b作后件，X-b作前件所构成的关联规则仍是强关联规则。（（X-b）.count不大于（X-a）.count，再由支持度和可信度公式易证）若b作后件，X-b作前件不可以构成强关联规则，则b的任一超集a作后件，X-a作后件依然不能构成强关联规则，此属性类似于向下封闭属性，故由此可以逐级搜索，采用类似的功能函数candidate-gen(Hm)生成Hm+1
递归部分的3-9步对
H
m+1
中的每个项集检测其是否满足minconf，满足则将其作为强关联规则输出，并记录其支持度和可信度。
Example 1:疾病之间存在一定的联系，随机抽查一家综合性医院中的9名病人得到如下数据库T。TID为病人标识，Itemset为病人所患疾病，可以找出此事务集T中的频繁集和强关联规则。设置最小支持度为30%，最小可信度为80%。
| TID |
Itemset |
|
| T01 |
中耳炎 扁桃体炎 败血症 |
|
| T02 |
哮喘 肺炎 |
|
| T03 |
中耳炎 扁桃体炎 高血压 |
|
| T04 |
鼻炎 哮喘 肺炎 |
|
| T05 |
哮喘 肺炎 败血症 风湿病 |
|
| T06 |
中耳炎 扁桃体炎 |
|
| T07 |
哮喘 肺炎 高血压 |
|
| T08 |
鼻炎 哮喘 肺炎 败血症 |
|
| T09 |
鼻炎 哮喘 肺炎 高血压 |
|
为方便起见，将疾病名称用标识符替换，形如｛疾病名称，标识符｝：
｛中耳炎，P1｝、｛扁桃体炎，P2｝、｛鼻炎，P3｝、｛哮喘，P4｝、｛肺炎，P5｝、｛败血症，P6｝、｛风湿病，P7｝、｛高血压，P8｝
｛中耳炎，P1｝、｛扁桃体炎，P2｝、｛鼻炎，P3｝、｛哮喘，P4｝、｛肺炎，P5｝、｛败血症，P6｝、｛风湿病，P7｝、｛高血压，P8｝
第一步：生成T中所有的频繁集
（1）扫描生成候选集C1=｛P1，P2，P3，P4，P5，P6，P7，P8｝并计算每种疾病在事务集T中的支持度如下：
｛（P1，3/9），（P2，3/9），（P3，3/9），（P4，6/9），（P5，6/9），（P6，3/9），（P7，1/9），（P8，3/9）｝。
删除P7，因为其支持度小于最小支持度。得到F1=｛
P1，P2，P3，P4，P5，P6，P8｝。
（2）由F1生成2-候选集C2=｛P1P2，P1P3，P1P4，P1P5，P1P6，P1P8，P2P3，P2P4，P2P5，P2P6，P2P8，P3P4，P3P5，P3P6，P3P8，P4P5，P4P6，P4P8，P5P6，P5P8，P6P8｝
计算候选集中各项集的支持度｛（P1P2，3/9），（P1P3，0），（P1P4，0），（P1P5，0），（P1P6，1/9）
，（P1P8，1/9），（P2P3，0），（P2P4，0），（P2P5，0），（P2P6，1/9），（P2P8，1/9），（P3P4，3/9），（P3P5，3/9），（P3P6，1/9），（P3P8，1/9），（P4P5，6/9），（P4P6，2/9），（P4P8，2/9），（P5P6，2/9），（P5P8，2/9），（P6P8，0）｝
删除支持度小于30%的项目生成F2=｛P1P2，P3P4，P3P5，P4P5｝
（3）由F2生成3-候选集C3=｛P3P4P5｝，无需剪枝，P3P4P5的支持度为3/9>30%，故由C3生成F3=｛P3P4P5｝
（4）由F3生成C5=
∅，F5=∅。算法停止
综之得到的所有频繁项目集F=｛P1，P2，P3，P4，P5，P6，P8，P1P2，P3P4，P3P5，P4P5，P3P4P5｝
第二步：由F生成全部强关联规则
k=2时，P1P2可以生成两个1-后件关联规则
规则1：P1 → P2 support：3/9 confidence：100%
规则2：P2→ P1 support：3/9 confidence：100%
均满足minconf，再次调用ap-genRules函数，k=2，m+1=2，不满足算法生成条件，由P1P2生成关联规则结束。
同理P3P4生成关联规则：
规则3：P3 → P4 support：3/9 confidence：100%
规则4：P4 → P3 support：3/9 confidence：50%
由minconf限制知规则4不是强关联规则。
P3P5生成关联规则：
规则5：P3 → P5 support：3/9 confidence：100%
规则6：P5 → P3 support：3/9 confidence：50%
由minconf限制知规则6不是强关联规则。
P4P5生成关联规则：
规则7：P4 → P5 support：6/9 confidence：100%
规则8：P5 → P4 support：6/9 confidence：100%
生成1-后件候选关联规则：
规则9 ：P3P4→ P5 support： 3/9 confidence：100%
规则9 ：P3P4→ P5 support： 3/9 confidence：100%
规则10：P3P5→ P4 support： 3/9 confidence：100%
规则11：P4P5→ P3 support： 3/9 confidence：50%
规则11不满足最小可信度，不是强关联规则。
H1=｛｛P4｝，｛P5｝｝，调用ap-genRules函数生成H2=｛｛P4P5｝｝。
生成2-后件关联规则
规则12：P3→ P4P5 support： 3/9 confidence：100%
满足minconf限制，为强关联规则，再次调用ap-genRules函数，k=3，m+1=3，不满足算法生成条件，由P3P4P5生成关联规则结束。
综之由由F生成的T中的全部关联规则为：规则1，规则2，规则3，规则5，规则7，规则8，规则9，规则10，规则12。
2.4多最小支持度关联规则挖掘
原因：在事物集T中，有些相关联的事物出现的频率很低，有些则非常高，如果设置统一的最小支持度，此minsup过高则会在筛选频繁集的过程中舍弃部分出现频率低的关联事物，但是此出现频率低的关联事物可能产生的价值很高，如果此minsup过低则有可能产生大量的频繁集，其中也可能会产生大量的冗余规则。可以通过对每个项目设置一个其特定的最小项目支持度（minimum item support MIS）解决这个问题。
相关定义：
规则最小支持度：一条规则的minsup是其所有项目中最低的MIS值。
支持度差别限制：maxi∈s{sup(i)} − mini∈s{sup(i)} ≤ ϕ 0 ≤ ϕ ≤ 1 ϕ为用户指定的最大支持度差别
挖掘算法也分两步：
挖掘算法也分两步：
第一步：找出事务集T中的所有频繁集
Algorithm MS-Apriori(T, MS, ϕ)
1 M ← sort(I, MS);
2 L ← init-pass(M, T);
3 F1 ← {{l} | l ∈ L, l.count/n ≥ MIS(l)};
4 for (k = 2; Fk−1 ≠ ∅; k++) do
5 if k = 2 then
6 Ck ← level2-candidate-gen(L, ϕ)
7 else Ck ← MScandidate-gen(Fk−1, ϕ)
8 endif;
9 for each transaction t ∈ T do
10 for each candidate c ∈ Ck do
11 if c is contained in t then
12 c.count++
13 if c – {c[1]} is contained in t then
14 (c – {c[1]}).count++
15 endfor
16 endfor
17 Fk ← {c ∈ Ck | c.count/n ≥ MIS(c[1])}
18 endfor
19 return F ← Uk Fk;
MS-Apriori algorithm
1.将全部无重复的项目集合I中的项目按照MIS的大小从小到大排列。
2.第一遍pass事务集T，记录每个项目的支持度计数。并按照以下方式生成L中的项目：
若M中项目i的支持度大于等于MIS(i)，则将其加入L中，遍历i之后的项目j，若j.count/n不小于MIS(i)，则将j加入L，n为事务集T的规模。
Algorithm MS-Apriori(T, MS, ϕ)
1 M ← sort(I, MS);
2 L ← init-pass(M, T);
3 F1 ← {{l} | l ∈ L, l.count/n ≥ MIS(l)};
4 for (k = 2; Fk−1 ≠ ∅; k++) do
5 if k = 2 then
6 Ck ← level2-candidate-gen(L, ϕ)
7 else Ck ← MScandidate-gen(Fk−1, ϕ)
8 endif;
9 for each transaction t ∈ T do
10 for each candidate c ∈ Ck do
11 if c is contained in t then
12 c.count++
13 if c – {c[1]} is contained in t then
14 (c – {c[1]}).count++
15 endfor
16 endfor
17 Fk ← {c ∈ Ck | c.count/n ≥ MIS(c[1])}
18 endfor
19 return F ← Uk Fk;
MS-Apriori algorithm
1.将全部无重复的项目集合I中的项目按照MIS的大小从小到大排列。
2.第一遍pass事务集T，记录每个项目的支持度计数。并按照以下方式生成L中的项目：
若M中项目i的支持度大于等于MIS(i)，则将其加入L中，遍历i之后的项目j，若j.count/n不小于MIS(i)，则将j加入L，n为事务集T的规模。
（L为候选集，j.count/n若不小于MIS(j)，则必定满足不小于MIS(i)，省去了对MIS(i)之后的每一个MIS(j)的遍历）
3.对L中的每个项目判断是否满足各自的最小项目支持度，满足则将项目添加至F1中。
4-18：k=2开始，由L生成C(2)，k>2时由C(k)生成F(k)，F(k-1)生成C(k)，F(k−1) = ∅时结束。
5.k=2情况特殊单独考虑。
6.利用level2-candidate-gen(L,ϕ),从L中的项目生成C(2)，其中ϕ是规定的最大支持度差别。
7.其它情况则利用MScandidate-gen(F(k-1),ϕ)生成C(k)。
9-16：对C(k)中的每一个项集c，计算其在事务集T中的支持度计数（同时记录c-｛c[1]｝的支持度计数，在关联规则生成时用到，c[1]为c的第一个项目）。
解释：由head-item问题可知若由频繁集生成的关系规则前件中含此频繁集的最小支持度项目，则其不会发生没有有记录前件支持度计数的情况，因为此时前件构成的项集一定也是频繁集。但是若后件包含某个频繁集的最小支持度计数，前件有可能不是频繁集，则前件的支持度计数可能未被记录（按照先前的Apriori算法），故需要在此处记录c-｛c[1]｝的支持度计数，方便后续可信度的计算。
17.判断C(k)中的每一个项集c的支持度是否满足各自的最小支持度计数MIS(c[1])，满足则将c添加至F(k)中。
19.合并生成的F(k)到集合F中。
3.对L中的每个项目判断是否满足各自的最小项目支持度，满足则将项目添加至F1中。
4-18：k=2开始，由L生成C(2)，k>2时由C(k)生成F(k)，F(k-1)生成C(k)，F(k−1) = ∅时结束。
5.k=2情况特殊单独考虑。
6.利用level2-candidate-gen(L,ϕ),从L中的项目生成C(2)，其中ϕ是规定的最大支持度差别。
7.其它情况则利用MScandidate-gen(F(k-1),ϕ)生成C(k)。
9-16：对C(k)中的每一个项集c，计算其在事务集T中的支持度计数（同时记录c-｛c[1]｝的支持度计数，在关联规则生成时用到，c[1]为c的第一个项目）。
解释：由head-item问题可知若由频繁集生成的关系规则前件中含此频繁集的最小支持度项目，则其不会发生没有有记录前件支持度计数的情况，因为此时前件构成的项集一定也是频繁集。但是若后件包含某个频繁集的最小支持度计数，前件有可能不是频繁集，则前件的支持度计数可能未被记录（按照先前的Apriori算法），故需要在此处记录c-｛c[1]｝的支持度计数，方便后续可信度的计算。
17.判断C(k)中的每一个项集c的支持度是否满足各自的最小支持度计数MIS(c[1])，满足则将c添加至F(k)中。
19.合并生成的F(k)到集合F中。
Function level2-candidate-gen(L, ϕ)
1 C2 ← ∅;
2 for each item l in L in the same order do
3 if l.count/n ≥ MIS(l) then
4 for each item h in L that is after l do
5 if h.count/n ≥ MIS(l) and |sup(h) − sup(l)| ≤ ϕ then
6 C2 ← C2 ∪ {{l, h}};
1 C2 ← ∅;
2 for each item l in L in the same order do
3 if l.count/n ≥ MIS(l) then
4 for each item h in L that is after l do
5 if h.count/n ≥ MIS(l) and |sup(h) − sup(l)| ≤ ϕ then
6 C2 ← C2 ∪ {{l, h}};
7 return C2;
level2-candidate-gen(L,ϕ)
1.将C(2)初始化为空集。
2-6.对L中的每一个项目l按照相同的顺序进行以下3-6操作：
3.如果l的自身支持度大于MIS(l),则进行4-6操作：
4.对每一个在集合L中l之后的项目h作5-6操作：
5.如果h.count/n不小于MIS(l)并且|sup(h)-sup(l)|不大于ϕ，则进行第6步操作：
6.将项集｛l,h｝加入C(2)中。
level2-candidate-gen(L,ϕ)
1.将C(2)初始化为空集。
2-6.对L中的每一个项目l按照相同的顺序进行以下3-6操作：
3.如果l的自身支持度大于MIS(l),则进行4-6操作：
4.对每一个在集合L中l之后的项目h作5-6操作：
5.如果h.count/n不小于MIS(l)并且|sup(h)-sup(l)|不大于ϕ，则进行第6步操作：
6.将项集｛l,h｝加入C(2)中。
Function MScandidate-gen(Fk−1, ϕ)
1 Ck ← ∅;
2 forall f1, f2 ∈ Fk
3 with f1 = {i1, … , ik−2, ik−1}
4 and f2 = {i1, … , ik−2, i’k−1}
5 and ik-1 < i’k−1 and |sup(ik-1) − sup(i’k−1)| ≤ ϕ do
6 c ← {i1, …, ik−1, i’k−1};
7 Ck ← Ck ∪ {c}; 8 for each (k−1)-subset s of c do9 if (c[1] ∈ s) or (MIS(c[2]) = MIS(c[1])) then10 if (s ∉ Fk−1) then11 delete c from Ck;12 endfor13 endfor14 return Ck;
1 Ck ← ∅;
2 forall f1, f2 ∈ Fk
3 with f1 = {i1, … , ik−2, ik−1}
4 and f2 = {i1, … , ik−2, i’k−1}
5 and ik-1 < i’k−1 and |sup(ik-1) − sup(i’k−1)| ≤ ϕ do
6 c ← {i1, …, ik−1, i’k−1};
7 Ck ← Ck ∪ {c}; 8 for each (k−1)-subset s of c do9 if (c[1] ∈ s) or (MIS(c[2]) = MIS(c[1])) then10 if (s ∉ Fk−1) then11 delete c from Ck;12 endfor13 endfor14 return Ck;
MScandidate-gen(F(k-1),ϕ)
1.将C(k)初始化为空集。
2.对于F(k)中所有的频繁集对f1，f2作3-13的操作。
3-5：若项集f1,f2满足除最后一个项目外各项目均相等（f1，f2均为k-1项集），且f1最后一个项目排序大小为与f2最后一个项目之后，同时满足|sup(i k−1)− sup(i’k−1)| ≤ ϕ，则作6-7步骤处理
6-7.将f1，f2合并成一个集合c并将其并入C(k)。
8.对c中的每一个k-1项子集作9-12步骤处理：
9-12：如果s依次满足(c[1] ∈ s) or (MIS(c[2]) = MIS(c[1])) 、s ∉ Fk−1则从C(k)中删去c。
14.返回C(k)。
2.对于F(k)中所有的频繁集对f1，f2作3-13的操作。
3-5：若项集f1,f2满足除最后一个项目外各项目均相等（f1，f2均为k-1项集），且f1最后一个项目排序大小为与f2最后一个项目之后，同时满足|sup(i k−1)− sup(i’k−1)| ≤ ϕ，则作6-7步骤处理
6-7.将f1，f2合并成一个集合c并将其并入C(k)。
8.对c中的每一个k-1项子集作9-12步骤处理：
9-12：如果s依次满足(c[1] ∈ s) or (MIS(c[2]) = MIS(c[1])) 、s ∉ Fk−1则从C(k)中删去c。
14.返回C(k)。
第二步：由所有频繁集的集合F生成全部的强关联规则
这个算法类似于Apriori算法中的genRules（）函数，从1-后件规则递归生成全部关联规则。
Example 2：冬季某品牌服饰店随机抽取7名消费者的购买情况形成如下数据库T，TID为各消费者标识，Itemset为各消费者购买的服饰。设置皮靴、羽绒服、短裤的MIS为10%，围巾、长裤、T恤的MIS为30%，棉衣的MIS为50%，最小可信度为60%，指定最大支持度差别为1，可以找出此事务集T中的频繁集和强关联规则。
| TID |
Itemset |
| T01 |
围巾 棉衣 |
| T02 |
皮靴 羽绒服 长裤 |
| T03 |
围巾 棉衣 长裤 |
| T04 |
皮靴 棉衣 短裤 |
| T05 |
围巾 羽绒服 |
| T06 |
围巾棉衣长裤 T恤 |
| T07 |
羽绒服 长裤 T恤 |
｛围巾，D1｝、｛皮靴，D2｝、｛棉衣，D3｝、｛羽绒服，D4｝、｛短裤，D5｝、｛长裤，D6｝、｛T恤，D7｝
D5D3生成关联规则
由minconf限制知规则
19
不是强关联规则。H1=｛｛D4｝，｛D6｝｝，生成H2=｛｛D4D6｝｝
则2-后件规则为
第一遍扫描s得到C1=｛3，
3，3，2，3，2，1，1 ｝,s每个序列后的数字为此序列的支持计数。由minsup为40%知支持计数需不小于才能不被删除。
第一步：生成T中所有的频繁集
根据各项目的MIS值排序得到M=｛D2，D4，D5，D1，D6，D7，D3｝，扫描事务集T计算各项支持度｛（D2，2/7），（D4，3/7），（D5，1/7），（D1，4/7），（D6，4/7），（D7，2/7），（D3，4/7）｝，按照相关规则生成L=｛D2，D4，D5，D1，D6，D7，D3｝
再由各自的MIS限制从L中生成F1=｛D2，D4，D5，D1，D6，D3｝
根据level2-candidate-gen函数由F1生成C2=｛D2D4，D2D5，D2D1，D2D6，D2D3，D4D5，D4D1，D4D6，D4D3，D5D1，D5D6，D5D3，D1D6，D1D3，D6D3｝
计算C2中的各项的支持度：｛（D2D4，1/7），（D2D5，1/7），（D2D1，0），（D2D6，1/7），（D2D3，1/7），（D4D5，0），（D4D1，1/7），（D4D6，2/7），（D4D3，0），（D5D1，0），（D5D6，0），（D5D3，1/7），（D1D6，2/7），（D1D3，3/7），（D6D3，2/7）｝从其中每一项选择首项MIS值与该项集支持度比较，此MIS值大于该项集支持度则删除该项集。
可以由上生成F2=｛D2D4，D2D5，D2D6，D2D3，D4D1，D4D6，D5D3，D1D3｝
由函数MScandidate-gen从F2生成C3=｛D2D4D6，D2D5D3，D2D6D3｝
其中的删除策略为MScandidate-gen函数8-12行，判断C3中每个元素的2-项子集，若子集都能在F2中找到则无需删除，若有不能找到的子集，且此子集中含有最小的MIS值对应的项目，或者此子集存在两个项目对应最小且相同的MIS值（按MIS排序好则可取最靠前两项进行检测），则删除此元素。
计算C3中元素的支持度｛（D2D4D6，1/7），（D2D5D3，1/7），（D2D6D3，0/7）｝
故可生成F3=｛D2D4D6，D2D5D3｝
而后再生成C4=∅，F4=∅，算法结束。
故全部频繁集的集合F=｛D2，D4，D5，D1，D6，D3，D2D4，D2D5，D2D6，D2D3，D4D1，D4D6，D5D3，D1D3，D2D4D6，D2D5D3｝
注：由于设置最大支持度差别为1，故在本例中可以认为不考虑支持度差别限制。
第二步：由F的元素生成全部的强关联规则
k=2时：
D2D4可以生成两个1-后件关联规则
规则1：D2 → D4 support：1/7 confidence：1/2
规则2：D4 → D3 support：1/7 confidence：1/3
由minconf限制知规则1和2均不是强关联规则。
同理D2D5生成关联规则
规则3：D2 → D5 support：1/7 confidence：1/2
规则4：D5 → D2 support：1/7 confidence：1
由minconf限制知规则3不是强关联规则。
D2D6生成关联规则
规则5：D2 → D6 support：1/7 confidence：1/2
规则6：D6 → D2 support：1/7 confidence：1/4
由minconf限制知规则5和6均不是强关联规则。
D2D3生成关联规则
规则7：D2 → D3 support：1/7 confidence：1/2
规则8：D3 → D2 support：1/7 confidence：1/4
由minconf限制知规则7和8均不是强关联规则。
D4D1生成关联规则
规则9 ：D4 → D1 support：1/7 confidence：1/3
规则10：D1 → D4 support：1/7 confidence：1/4
由minconf限制知规则9和10均不是强关联规则。
D4D6生成关联规则
规则11：D4 → D6 support：2/7 confidence：2/3
规则12：D6 → D4 support：2/7 confidence：2/4
由minconf限制知规则12不是强关联规则。
规则13：D5 → D3 support：1/7 confidence：1
规则14：D3 → D5 support：1/7 confidence：1/4
由minconf限制知规则14不是强关联规则。
D1D3生成关联规则
规则15：D1 → D3 support：3/7 confidence：3/4
规则16：D3 → D1 support：3/7 confidence：1
再次调用ap-genRules函数，k=2，m+1=2，不满足算法生成条件，生成关联规则结束。
k=3时：
D2D4D6生成1-后件规则
规则17：D2D4 → D6 support：1/7 confidence：1
规则18：D2D6 → D4 support：1/7 confidence：1
规则19：D4D6
→
D2 support：1/7 confidence：1/2
规则20：D2 → D4D6 support：1/7 confidence：1/2
由minconf限制知规则20不是强关联规则。
D2D5D3生成1-后件规则
规则21：D2D5 → D3 support：1/7 confidence：1
规则22：D2D3 → D5 support：1/7 confidence：1
规则23：D5D3
→
D2 support：1/7 confidence：1
H2=｛｛D2D5｝，｛D2D3｝，｛D5D3｝｝
生成2-后件规则
规则24：D3→ D2D5 support：1/7 confidence：1/4
规则25：D5→ D2D3 support：1/7 confidence：1
规则26：D2
→
D5D3 support：1/7 confidence：1/2
由minconf限制知规则24，26不是强关联规则。
再次递归k=3，m+1=3，不满足算法生成条件，
生成
关联规则结束。
综之可得全部强关联规则为：规则2，规则11，规则13，规则15，规则16，规则17，规则18，规则21，规则22，规则23，规则25。
2.5分类关联规则挖掘
分类关联规则挖掘是搜索T中后件固定的关联规则（满足minsup和minconf限制的全部CAR）
T是事物数据集，每个事物都有一个一个分类y，Y为全部分类y的集合，
I
∩ Y = ∅。
一个分类关联规则具有如下蕴含式形式：
X → y 其中X ⊆ I且 y ∈ Y.
支持度与可信度与之前定义相同。 挖掘算法不方便直接使用之前的Apriori算法然后再筛选适合的规则，这样可能会产生大量的冗余关联规则。
支持度与可信度与之前定义相同。 挖掘算法不方便直接使用之前的Apriori算法然后再筛选适合的规则，这样可能会产生大量的冗余关联规则。
定义规则项，形式为(condset, y)，
condset为I的子集，称为条件集，condsupCount为条件集支持计数（T中包含该条件的事物数量），rulesupCount为规则项支持计数（T中包含该规则项的事物数量）。(condset, y)生成一条规则condset → y。
Algorithm CAR-Apriori(T)
1 C1 ← init-pass(T); // the first pass over T
2 F1 ← {f | f ∈ C1, f. rulesupCount / n ≥ minsup};
3 CAR1 ← {f | f ∈ F1, f.rulesupCount / f.condsupCount ≥ minconf};
4 for (k = 2; Fk−1 ≠ ∅; k++) do
5 Ck ← CARcandidate-gen(Fk−1);
6 for each transaction t ∈ T do
7 for each candidate c ∈ Ck do
8 if c.condset is contained in t then // c is a subset of t
9 c.condsupCount++;
10 if t.class = c.class then
11 c.rulesupCount++
12 endfor
13 end-for
14 Fk ← {c ∈ Ck | c.rulesupCount / n ≥ minsup};
15 CARk ← {f | f ∈ Fk, f.rulesupCount / f.condsupCount ≥ minconf};
16 endfor
17 return CAR ← Uk CARk;
为方便起见，将标签名称用标识符替换，形如｛标签名称，标识符｝：
1 C1 ← init-pass(T); // the first pass over T
2 F1 ← {f | f ∈ C1, f. rulesupCount / n ≥ minsup};
3 CAR1 ← {f | f ∈ F1, f.rulesupCount / f.condsupCount ≥ minconf};
4 for (k = 2; Fk−1 ≠ ∅; k++) do
5 Ck ← CARcandidate-gen(Fk−1);
6 for each transaction t ∈ T do
7 for each candidate c ∈ Ck do
8 if c.condset is contained in t then // c is a subset of t
9 c.condsupCount++;
10 if t.class = c.class then
11 c.rulesupCount++
12 endfor
13 end-for
14 Fk ← {c ∈ Ck | c.rulesupCount / n ≥ minsup};
15 CARk ← {f | f ∈ Fk, f.rulesupCount / f.condsupCount ≥ minconf};
16 endfor
17 return CAR ← Uk CARk;
1.第一次pass中，对每一个condset中只含一个项目的规则项计算其支持计数，C1中每一规则项形式为{({i}, y) | i ∈ I, and y ∈ Y}。
2.判断此1-规则项是否为频繁规则项。是则将其加入F1。
3.判断前件只含一个项目的规则项是否满足最小置信度，满足则将其加入CAR(1)。
4-16：从k=2开始，由F（k-1）不断的逐级搜索生成CAR(k)（前件含k个项目的频繁规则项，且均满足最小置信度）。
5.由函数CARcandidate-gen(F(k-1))生成候选k-规则项集C(k)（类似于 candidate-gen，不同的是要将相同分类下的condset子集进行合并）
6-13：计算C(k)中每一个项集c在事务集T中的condSupCount和ruleSupCount。
14.将C(k)中满足最小支持度的c加入F(k)中，即其为频繁规则项。
15.从F(k)生成满足最小置信度的k项前件分类关联规则(CAR(k))。
2.判断此1-规则项是否为频繁规则项。是则将其加入F1。
3.判断前件只含一个项目的规则项是否满足最小置信度，满足则将其加入CAR(1)。
4-16：从k=2开始，由F（k-1）不断的逐级搜索生成CAR(k)（前件含k个项目的频繁规则项，且均满足最小置信度）。
5.由函数CARcandidate-gen(F(k-1))生成候选k-规则项集C(k)（类似于 candidate-gen，不同的是要将相同分类下的condset子集进行合并）
6-13：计算C(k)中每一个项集c在事务集T中的condSupCount和ruleSupCount。
14.将C(k)中满足最小支持度的c加入F(k)中，即其为频繁规则项。
15.从F(k)生成满足最小置信度的k项前件分类关联规则(CAR(k))。
Example 3：动画和小说都有各自标签，以表明其属于何种类型的动画或小说，如下事物数据集T选取了4部动画和3本小说并列出各自的标签，TID为各项标识符，设置最小支持度为10%，最小可信度为70%，可以找出T中的全部频繁规则项集和全部分类关联规则。
| TID |
Condset |
Class |
| T01 |
宫崎骏 短片 青春 |
动画 |
| T02 |
搞笑 新海诚 宫崎骏 |
动画 |
| T03 |
萌 短片 |
动画 |
| T04 |
新海诚 短片 |
动画 |
| T05 |
青春 玄幻 |
小说 |
| T06 |
搞笑 青春 励志 |
小说 |
| T07 |
新海诚 校园 生活 | 小说 |
｛生活，P0｝，
｛宫崎骏，P1｝，｛短片，P2｝，｛搞笑，P3｝，｛新海诚，P4｝，｛萌，P5｝，｛青春，P6｝，｛玄幻，P7｝，｛励志，P8｝，｛校园，P9｝ ， 同时用D1标识动画，D2标识小说。
生成C1=｛（P0，D1）0，（P1，D1）2，（P2，D1）3，（P3，D1）1，（P4，D1）2，（P5，D1）1，（P6，D1）1，（P7，D1）0，（P8，D1）0，（P9，D1）0，（P0，D2）1，（P1，D2）0，（P2，D2）0，（P3，D2）1，（P4，D2）1，（P5，D2）0，（P6，D2）2，（P7，D2）1，（P8，D2）1，（P9，D2）1｝其中括号后的数字为规则项的支持计数，计算出规则项支持度，若其不小于最小支持度则将其加入F1。
生成F1=｛｛P1，D1｝（2，2），｛P2，D1｝（3，3），｛P3，D1｝（2，1），｛P4，D1｝（3，2），｛P5，D1｝（1，1），｛P6，D1｝（3，1），｛P0，D2｝（1，1），｛P3，D2｝（2，1），｛P4，D2｝（3，1），｛P6，D2｝（3，2），｛P7，D2｝（1，1），｛P8，D2｝（1，1），｛P9，D2｝（1，1）}，括号中数字依次代表该规则项的condsupCount和rulesupCount。
计算各项的可信度根据最小可信度的限制生成CAR(1)：
规则1：P1 → D1 support：2/7 confidence：1
规则2：P2
→ D1 support：3/7 confidence：1
规则3：P5 → D1 support：1/7 confidence：1
规则4：P0 → D2 support：1/7 confidence：1
规则5：P7
→ D2 support：1/7 confidence：1
规则6：P8 → D2 support：1/7 confidence：1
规则7：P9 → D2 support：1/7 confidence：1
由F1可以生成C(2)=｛（P1P2，D1）1，（P1P5，D1）0，（P2P5，D1）1，（P0P7，D2）0，（P0P8，D2）1，（P0P9，D2）1，（P7P8，D2）0，（P7P9，D2）0，（P8P9，D2）0｝
将其各项支持度与最小支持度做比较生成F2=｛｛P1P2，D1｝（1，1），｛P2P5，D1｝（1，1），｛P0P9，D2｝（1，1）｝
计算各项可信度根据最小可信度限制生成CAR(2)：
规则8：P1P2 → D1 support：1/7 confidence：1
规则9：P2P5 → D1 support：1/7 confidence：1
规则10：P0P9 → D2 support：1/7 confidence：1
继续执行生成过程得C(3)=∅，F3=∅，规则生成过程结束。
故其得到满足minsup和minconf的全部分类关联规则为规则1~规则10。
2.6 序列模式
基本概念：序列s=
<
a1a2…ar>,ai为项集，也为s中一个元素，ai=｛x1，x2……，xk
｝，xi为I中的一个项目。s中每个元素的项目按字典顺序排列。
s中项集个数称作基数，总项目个数称作长度，k-序列指长度为k的s，s2包含s1则s1为s2子序列（s1中元素分属于s中各元素）。序列模式挖掘目标为找出序列数据库中满足minsup的所有s，此类s称作频繁序列或序列模式。
Algorithm GSP(S)
1 C1 ← init-pass(S);
2 F1 ← {<{f}>| f ∈ C1, f.count/n ≥ minsup};
3 for (k = 2; Fk−1 ≠ ∅; k++) do
4 Ck ← candidate-gen-SPM(Fk−1);
5 for each data sequence s ∈ S do
6 for each candidate c ∈ Ck do
7 if c is contained in s then
8 c.count++;
9 endfor
10 endfor
11 Fk ← {c ∈ Ck | c.count/n ≥ minsup}
12 endfor
13 return Uk Fk;
GSP算法类似于Apriori算法，采用逐级搜索的思想，不断生成序列模式及候选序列模式（如果原始数据足够多可能会产生大量候选序列模式），直至没有新的序列模式和候选序列模式产生为止，但其生成k-序列候选集C(k)的方式与Apriori不同，函数candidate-gen-SPM由合并和删除两部分组成，合并以s2最后一个项集是否为单项目集分为两种情形，若为单项目集，则以单独元素形式加入s1末尾，若不是则将其合并入s1最后一个元素，F1与F1的合并单独分开讨论，删除策略类似函数 candidate-gen的删除方式。
1 C1 ← init-pass(S);
2 F1 ← {<{f}>| f ∈ C1, f.count/n ≥ minsup};
3 for (k = 2; Fk−1 ≠ ∅; k++) do
4 Ck ← candidate-gen-SPM(Fk−1);
5 for each data sequence s ∈ S do
6 for each candidate c ∈ Ck do
7 if c is contained in s then
8 c.count++;
9 endfor
10 endfor
11 Fk ← {c ∈ Ck | c.count/n ≥ minsup}
12 endfor
13 return Uk Fk;
GSP算法类似于Apriori算法，采用逐级搜索的思想，不断生成序列模式及候选序列模式（如果原始数据足够多可能会产生大量候选序列模式），直至没有新的序列模式和候选序列模式产生为止，但其生成k-序列候选集C(k)的方式与Apriori不同，函数candidate-gen-SPM由合并和删除两部分组成，合并以s2最后一个项集是否为单项目集分为两种情形，若为单项目集，则以单独元素形式加入s1末尾，若不是则将其合并入s1最后一个元素，F1与F1的合并单独分开讨论，删除策略类似函数 candidate-gen的删除方式。
Example 4：很多疾病的发病都有关联顺序规律，随机抽取一家综合性医院的5名患者病例制成下列数据库T，TID为患者标号，Transaction Time为患病事件，Transaction为当时所患疾病。
| TID |
Transaction Time |
Transaction |
| 01 01 |
2015.03 |
痛风 |
| 2015.05 |
高血压 风湿病 |
|
| 02 02 02 |
2015.04 |
痛风 |
| 2015.05 |
糖尿病 |
|
| 2015.06 |
青光眼 冠心病 |
|
| 03 03 |
2015.06 |
高血压 糖尿病 肾结石 |
| 2015.08 |
青光眼 肺炎 |
|
| 04 04 |
2015.01 |
痛风 |
| 2015.05 |
高血压 肾结石 |
|
| 05 05 |
2015.06 |
糖尿病 |
| 2015.08 |
青光眼 冠心病 |
为方便起见，
将疾病名称用标识符替换，形如｛疾病名称，标识符｝：
｛痛风，P1｝，｛高血压，P2｝，｛糖尿病，P3｝，｛肾结石，P4｝，｛青光眼，P5｝，｛冠心病，P6｝，｛风湿病，P7｝，｛肺炎，P8｝
可以由上表生成如下序列数据库s，
指定最小支持度为40%，查找在s中的满足minsup的序列模式：
| TID |
Data Sequence |
| 01 |
<{P1},{P2,P3}> |
| 02 |
<{P1},{P3},{P5,P6}> |
| 03 |
<{P2,P3,P4},{P5,P8}> |
| 04 |
<{P1},{P2,P4}> |
| 05 |
<{P3},{P5,P6}> |
可由C1生成序列模式F1=
｛3，
3，3，2，3，2
｝，F1经过函数candidate-gen-SPM生成候选序列模式集合：
｛0，
2，<(P1，P2)>，1，<(P1，P3)>0，1，<(P1，P4)>0，1，<(P1，P5)>0，1，<(P1，P6)>0，0，0，0，<(P2，P3)>1，0，<(P2，P4)>2，1，<(P2，P5)>1，0，<(P2，P6)>0，0，0，0，0，<(P3，P4)>1，3，<(P3，P5)>0，2，<(P3，P6)>0，0，0，0，0，1，<(P4，P5)>0，0，<(P4，P6)>0，0，0，0，0，0，0，<(P5，P6)>2，0，0，0，0，0，0 ｝
根据计算出的支持计数删除冗余候选得到F2={2，
2，3，2，<(P5，P6)>2 }
F2合并成｛,｝ 检测其中每个元素的2-项子序列是否属于频繁序列，不属于则删除。最终得到C3=｛
支持计数为2满足条件，故F3=｛， ，，，，，， ，，，<(P5，P6)>， ｝。
考虑不同的序列模式出现频率的差异可能很大，导致设置统一的minsup过小则会产生大量的冗余序列模式，设置过大则可能会漏掉一些频率较小但有价值的序列模式，针对这种情形，可以由类似MS-Apriori算法的多最小支持度序列模式挖掘算法（MS-GSP）解决此类问题，依然采用逐级搜索的思想，相关的概念类似于之前的
定义
。
Algorithm
MS-GSP(S, MS)
1 M ← sort(I, MS);
2 L ← init-pass(M, S);
3 F1 ← {<{l}> | l ∈ L, l.count/n ≥ MIS(l)};
4 for (k = 2; Fk−1 ≠ ∅; k++) do
5 if k = 2 then
6 Ck ← level2-candidate-gen-SPM(L)
7 else Ck ← MScandidate-gen-SPM(Fk−1)
8 endif
9 for each data sequence s ∈ S do
10 for each candidate c ∈ Ck do
11 if c is contained in s then
12 c.count++
13 if c’ is contained in s, where c’ is c after an occurrence of
c.minMISItem is removed from c then
14 c.rest.count++
15 endfor
16 endfor
17 Fk ← {c ∈ Ck | c.count/n ≥ MIS(c.minMISItem)}
18 endfor
19 return F ← Uk Fk;
2 L ← init-pass(M, S);
3 F1 ← {<{l}> | l ∈ L, l.count/n ≥ MIS(l)};
4 for (k = 2; Fk−1 ≠ ∅; k++) do
5 if k = 2 then
6 Ck ← level2-candidate-gen-SPM(L)
7 else Ck ← MScandidate-gen-SPM(Fk−1)
8 endif
9 for each data sequence s ∈ S do
10 for each candidate c ∈ Ck do
11 if c is contained in s then
12 c.count++
13 if c’ is contained in s, where c’ is c after an occurrence of
c.minMISItem is removed from c then
14 c.rest.count++
15 endfor
16 endfor
17 Fk ← {c ∈ Ck | c.count/n ≥ MIS(c.minMISItem)}
18 endfor
19 return F ← Uk Fk;
序列中拥有最小MIS值的项目（c.minMISItem）不一定在序列首部
13-14行在生成序列规则时需要用到。
函数level2-candidate-gen-SPM生成C2采用GSP中candidate-gen-SPM合并两个F1的方式。
在MS-Apriori算法中，我们将最低MIS值的项目置放在每个项集的首部，但是，序列模式挖掘中，由于序列原先的顺序有实际意义，故不能把最低MIS值的项目作为序列的第一个项目，这样会造成一些问题：原先不是频繁序列可以作为子序列与另外的频繁序列生成频繁序列。函数MScandidate-gen-SPM采用了新的合并策略解决这个问题。
2.8基于PrefixSpan算法的序列模式挖掘
PrefixSpan算法无需产生候选序列模式，可以节省时间和空间。而且随着投影次数的增多，投影数据库的规模也会逐渐减小，直到无法生成新的序列模式时停止。
投影数据库的某个序列下划线表示前缀的末尾项集的项目与此序列的其他项目在同一个项集中。在新的投影数据库中逐步扩展前缀生成新的序列模式，
第一种可将项目x与前缀的末尾元素合并，第二种可以将x作为单独元素加入前缀。
Example 5：
采用与文章中相同的序列数据库T，生成余下的序列模式
| Customer ID |
Data Sequence |
| 1 |
<{30}{90}> |
| 2 |
<{10,20}{30}{10,40,60,70}> |
| 3 |
<{30,50,70,80}> |
| 4 |
<{30}{30,40,70,80}{90}> |
| 5 |
<{90}> |
最小支持度为25%，即需要支持计数至少为2，1-序列模式易知为<｛30｝>，<｛40｝>，<｛70｝>，<｛80｝>，<90> 。分别以上述序列为前缀扩展。
1）<｛30｝>的投影数据库为<{90}>，<{40, 70}>，<{_, 70, 80}>， <{30, 40, 70, 80}，{90}>
根据扩展规则可生成2-序列模式：<｛30，70｝>，<｛30，80｝>，<｛30｝，｛40｝>，<｛30｝，｛70｝>,<｛30｝，｛90｝>，再对其中每个序列模式生成对应的投影数据库：
<｛30，70｝>：<｛_，80｝>，<｛_，80｝｛90｝>生成3-序列模式<30，70，80>生成结束。
<｛30｝，｛70｝> :<｛_，80｝，｛90｝> 无新序列模式可生成，生成结束。
<｛30｝，｛40｝>：<｛_，70｝>，<｛_，70，80｝｛90｝>，可生成3-序列模式：<｛30｝，｛40，70｝>，投影结束。
<｛30，80｝>：<｛90｝>，无新序列模式生成，生成结束。
同理<｛40｝>的投影数据库为<｛_，70｝>，<｛_，70，80｝，｛90｝>，生成序列模式<｛40，70｝>，<｛40，70｝>投影数据库：<｛_，80｝，｛90｝>，无新序列模式生成，生成结束。
<｛70｝>的投影数据库为<｛_，80｝>，<｛_，80｝｛90｝>，生成2-序列模式<｛70，80｝>。<｛70，80｝>投影数据库为：<｛90｝>，无新序列生成，生成结束。
<｛80｝>投影数据库为:<｛90｝>，无新序列生成，生成结束。
综之可得生成的全部序列模式为：<｛30｝>，<｛40｝>，<｛70｝>，<｛80｝>，<90>， <｛30，70｝>，<｛30，80｝>，<｛30｝，｛40｝>，<｛30｝，｛70｝>,<｛30｝，｛90｝>，<30，70，80>，<｛30｝，｛40，70｝>，<｛40，70｝>，<｛70，80｝>。
2.9 序列模式的规则生成
序列规则（Sequential Rules）：可表述为蕴含式形式：
X
→ Y，X是Y的一个子序列，支持度和置信度类似先前定义。给定minsuo和minconf，可以从序列模式中得到序列规则。
标签序列规则（Label Sequential Rules）：可表述为蕴含式形式：X
→ Y ，X是将Y中部分项目替换成通配符得到的序列。替换掉的项目称作标签（Label）。
分类序列规则（Class Sequential Rules）：类似于CAR，可表述为蕴含式形式：X→ y，y为Y元素，X为序列，
Y为分类标记集合。