序列模式挖掘

算法1-1 AprioriAll算法

输入：大项集阶段转换后的序列数据库DT

输出：所有最长序列

伪代码
（1） L1={large 1-sequences}；// 大项集阶段得到的结果
（2） FOR（k=2；Lk-1  ；k++） DO BEGIN
（3）    Ck=apriori-gen(Lk-1)； // Ck是从Lk-1中产生的新的候选者
（4）    FOR each customer-sequence c in DT DO  
	//对于在数据库中的每一个顾客序列c
（5）      Sum the count of all candidates in Ck that are contained in c； 
	//被包含于c中Ck内的所有候选者计数 （4、 5的意思是扫描数据库，得出每个Ck的支持度计数）
（6）   Lk = Candidates in Ck with minimum support 
	// Lk＝Ck中满足最小支持度的候选者
（7） END；
（8） Answer = Maximal Sequences in ∪kLk；

一对频繁(k-1)-序列合并，产生候选k-序列。 为了避免重复产生候选，传统的Apriori算法仅当前k-1项相同时才合并一对频繁k-项集。类似的方法可以用于序列。

 候选剪枝

反单调性质，所有频繁序列的子序列也必定是频繁序列 一个候选k-序列如果它的(k-1)-序列最少有一个是非频繁的将会被剪枝。 例如，假设<{1} {2} {3} {4}>是一个候选4-序列。我们需要检查<{1} {2} {4}>和<{1} {3} {4}>是否是频繁3-序列。由于它们都不是频繁的，因此可以删除候选<{1} {2} {3} {4}>。

剪枝

伪代码
for 所有cCk的序列 do
        for 所有c的(k-1)-子序列s do
	if(s !∈  Lk ) then
	          delete 来自于Ck的c;

支持度计数

在支持度计数期间，算法将枚举属于一个特定数据序列的所有候选k-序列。 计数之后，算法将识别出频繁k-序列，并可以丢弃其支持度计数小于最小支持度阈值minsup的候选。

 AprioriSome算法

可以看作是AprioriAll算法的改进,具体过程分为两个阶段：

前推阶段：此阶段用于找出指定长度的所有频繁序列。

回溯阶段：此阶段用于查找其他长度的所有频繁序列。

伪代码
算法1-2  AprioriSome算法
输入：大项集阶段转换后的序列数据库DT
输出：所有最长序列
// Forward Phase — 前推阶段；
（1） L1 = {large 1-sequences}；//大项目集阶段的结果；
（2） C1 = L1； 
（3） last = 1；             //最后计数的Clast 
（4） FOR（k =2；Ck-1   and Llast ；k++）DO BEGIN
（5）   IF （Lk-1 know） THEN Ck = New candidates generated from Lk-1；
//Ck＝产生于Lk-1新的候选集
（6）   ELSE Ck = New candidates generated from Ck-1； // Ck＝产生于Ck-1新的候选集
（7）   IF （k =next（last）） THEN BEGIN
（9）     FOR each customer-sequence c in the database DO   //对于在数据库中的每一个客户序列c
（10）      Sum the count of all candidates in Ck that are contained in c；
//求包含在c中的Ck的候选者的数目之和
（11）    Lk = Candidates in Ck with minimum support；      // Lk＝在Ck中满足最小支持度的候选者
（12）    last = k；
（13）  END；
（14）END；
// Backward Phase — 回溯阶段；
（15）FOR （k - - ； k > = 1； k - - ） DO
（16）IF （Lk not found in forward phase） THEN BEGIN   // Lk在前推阶段没有确定的情况
（17）  Delete all sequences in Ck contained in Some Li， i > k；
//删除所有在Ck中包含在Lk中的序列，i>k
（18）  FOR each customer-sequence c in DT  DO         //对于在DT中的每一个客户序列c
（19）   Sum the count of all candidates in Ck that are contained in c；
//对在Ck中包含在c中的所有的候选这的计数
（20）    Lk = Candidates in Ck with minimum support    // Lk =在Ck中满足最小支持度的候选者
（21）END；
（22）ELSE  Delete all sequences in Lk contained in Some Li，i > k；// Lk 已知
（23）Answer = ∪k Lk；       //从k到m求Lk的并集

 在前推阶段（forward phase）中，我们只对特定长度的序列进行计数。比如，前推阶段我们对长度为1、2、4和6的序列计数（计算支持度），而长度为3和5的序列则在回溯阶段中计数。next函数以上次遍历的序列长度作为输入，返回下次遍历中需要计数的序列长度。

算法1-3 
next（k: integer）
IF （hitk < 0.666）THEN return  k + 1；
ELSEIF （hit k < 0.75）THEN return  k + 2；
ELSEIF （hit k  < 0.80）THEN return  k + 3；
ELSEIF （hit k < 0.85）THEN return   k + 4；
ELSE THEN return  k + 5；

hitk被定义为大k-序列（large k-sequence）和候选k-序列（candidate k-sequence）的比率，即|Lk|/|Ck|。这个函数的功能是确定对哪些序列进行计数，在对非最大序列计数时间的浪费和计算扩展小候选序列之间作出权衡。

AprioriAll和AprioriSome比较

AprioriAll用Lk-1去算出所有的候选Ck，而AprioriSome(有时)会直接用Ck-1去算出所有的候选 Ck.，因为Ck-1包含Lk-1，所以AprioriSome会产生比较多的候选。 虽然AprioriSome跳跃式计算候选，但因为它所产生的候选比较多，可能在回溯阶段前就占满内存。 如果内存满了，AprioriSome就会被强迫去计算最后一组的候选，（即使原本是要跳过此项）。这样，会影响并减少已算好的两个候选间的跳跃距离，而使得AprioriSome会变的跟AprioriAll一样。

序列模式的时限约束

GSP

引入了各种时间约束，将约束作为剪枝的条件,和基于最小支持度剪枝过程结合起来。

apriori-gen 剪枝

计数阶段

伪代码
（1） L1 = {large 1-sequences}；// 大项集阶段得到的结果
（2） FOR （k = 2；Lk-1  ；k++） DO BEGIN
（3）    Ck = GSPgenerate(Lk-1)；
（4）    FOR each customer-sequence c in the database DT DO 
（5）       Increment the count of all candidates in Ck that are contained in c；
（6）    Lk = Candidates in Ck with minimum support；
（7） END；
（8） Answer = Maximal Sequences in ∪kLk；

参考图书：数据挖掘导论 范明 范宏建翻译

数据挖掘原理与算法(第二版)