Lecture3

Report
频繁模式与关联规则挖掘
林琛
博士、副教授
数据挖掘领域的十大经典算法
• Apriori: Rakesh Agrawal and Ramakrishnan Srikant. Fast Algorithms
for Mining Association Rules. In VLDB ‘94.
– #4 (52 votes)
• FP-Tree: Han, J., Pei, J., and Yin, Y. 2000. Mining frequent patterns
without candidate generation. In SIGMOD '00.
– 他引超过3000次
• GSP: Srikant, R. and Agrawal, R. 1996. Mining Sequential Patterns:
Generalizations and Performance Improvements. In Proceedings of
the 5th International Conference on Extending Database Technology,
1996.
• PrefixSpan: J. Pei, J. Han, B. Mortazavi-Asl, H. Pinto, Q. Chen, U.
Dayal and M-C. Hsu. PrefixSpan: Mining Sequential Patterns
Efficiently by Prefix-Projected Pattern Growth. In ICDE '01.
• gSpan: Yan, X. and Han, J. 2002. gSpan: Graph-Based Substructure
Pattern Mining. In ICDM '02.
大纲
• 频繁项集与关联规则
–
–
–
–
–
形式定义
Apriori算法
FP-tree算法
关联规则挖掘
关联规则的评估
• 序列模式挖掘(简略)
– GSP
– PrefixSpan
• 频繁子图挖掘(简略)
– gSpan
频繁项集的形式定义
Tid
Items bought
10
Beer, Nuts, Diaper
20
Beer, Coffee, Diaper
30
Beer, Diaper, Eggs
40
Nuts, Eggs, Milk
50
Nuts, Coffee, Diaper, Eggs, Milk
Support({Beer})= 3/60%
Support({Nuts})=3/60%
Support({Diaper})=4/80%
Support({Eggs})=3/60%
Support({Beer, Diaper})=3/60%
Support({Nuts,Diaper})=2/40%
如果min_support=50%
• 项集: 项目的集合。
– k-项集 X = {x1, …, xk}
• 绝对支持度(支持度计数): 项集
X的出现次数(频率),即包含项
集的事务数
– 相对支持度, s:事务集中包含项集
的事务的百分比
• 频繁项集 :如果项集X的相对支
持度满足某个给定的阈值
频繁k项集 Lk
– 闭频繁项集X:如果不存在X的真超
频繁1项集–
集Y,具有和X相同的支持度计数
闭的,– 极大频繁项集X:如果X是频繁的,
闭的,且不存在频繁项集Y是X的超
非极大的
集
频繁2项集
不是闭的
极大频繁项集
4
关联规则的形式定义
Tid
Items bought
10
Beer, Nuts, Diaper
20
Beer, Coffee, Diaper
30
Beer, Diaper, Eggs
40
Nuts, Eggs, Milk
50
Nuts, Coffee, Diaper, Eggs, Milk
同时购买beer和diaper: 3/60%
• 关联规则是形如A → B的蕴涵式
– A,B是项集
– 具有支持度s
s=P(A B)
– 具有置信度c
c=P(B|A)
– 强规则:同时满足最小支持度阈值
和满足最小置信度阈值
给定 min_sup = 50%, min_conf = 50%
找出关联强规则
Beer  Diaper (60%, 100%)
Diaper  Beer (60%, 75%)
购买beer: 3/60%
购买diaper: 4/80%
5
关联规则的挖掘过程
• 找出所有的频繁项集
• 由频繁项集产生强关联规则
– 或者其他的有价值的关联规则
• 挖掘关联规则的性能由挖掘频繁项集决定
• 考虑一个简单枚举的算法
– 假设样本数(记录数)为N,维度(项目数)
为D,每条记录的长度为w
– 算法复杂度O(2dNw)
Apriori算法
Apriori性质
算法伪代码
• 频繁项集的所有非空子集
也必须是频繁的
Ck: Candidate itemset of size k//候选集
Lk : frequent itemset of size k//频繁项集
L1 = {frequent items};
//由底向上生成候选集
for (k = 1; Lk !=; k++) do
//产生步
Ck+1 = apriori_gen
//测试步
Lk+1 = count(Ck+1 )>= min_support
end
end
return k Lk;
ABCD
ABC
AB
ABD
AC
A
ACD
AD
BC
B
C
D
{}
Itemset lattice
BCD
BD
CD
Apriori算法的产生步
Ck+1 = apriori_gen
Ck+1 = join(L1…Lk);//连接步
Ck+1 =pruning(Ck+1 );//剪枝步
Apriori性质
Apriori算法的例子
购物篮记录 min_support = 2
Tid
Items
10
C1
A, C, D
20
B, C, E
30
A, B, C, E
40
B, E
扫描计数
Itemset
{A, C}
{B, C}
{B, E}
{C, E}
{A, B, C}
{B, C, A}
连接
{B, C, E}
{B, E, A}
{B, E, C}
{C, E, A}
{C, E, B}
C3
sup
{A}
2
{B}
3
{C}
3
{D}
1
{E}
3
L2
Itemset
{A, C, E}
Itemset
sup
2
2
3
2
剪枝
Itemset
sup
{A}
2
{B}
3
{C}
3
{E}
3
L1
C2
Itemset
{A, B}
{A, C}
{A, E}
{B, C}
{B, E}
{C, E}
连接+剪枝
sup
1
2
1
2
3
2
{B, C, E}
测试
{A, B}
{A, C}
C2
{A, E}
{B, C}
{B, E}
{C, E}
C3
Itemset
Itemset
扫描计数 L3
Itemset
sup
{B, C, E}
2
9
连接步策略
• 对项编码
– 项按字典序存储
– 项集中的项排序
•
Itemset
L1
Ck+1 = L1×Lk
– 一个频繁k项集和一个不属
于频繁k项集的频繁项
– 且频繁项比频繁k项集中的
所有项都大
• Ck+1 = Lk-1×Lk-1
– 一个频繁k项集和一个频繁
k项集
– 且两个频繁k项集的前k-1
项相等
• 哪一个策略产生的重复项集
多?
• 哪一个策略产生的不必要的
候选项集多?
sup
{A}
2
{B}
3
{C}
3
{E}
3
L2
sup
2
2
3
2
策略2
策略1
C3
Itemset
{A, C}
{B, C}
{B, E}
{C, E}
Itemset
Itemset
{A, C, E}
{B, C, E}
{B, C, E}
剪枝
Itemset
{B, C, E}
剪枝
Apriori算法的测试步
• Lk+1 = count(Ck+1 )>= min_support
– 策略1:比较每个记录与每个候选项集
– 策略2:枚举每个记录所包含的项集,与每个候
选项集比较
散列树的数据结构与构造
)
count(Ck+1
construct(HTree);
traversal(Htree,T)
struct HashTreeNode
{
bool leaf;
//叶节点标志
int level;
//该节点层级
itemset* candidate;
//指向候选项集
struct node * child[m];
//指向下一层子节点
}
Foreach (l in Ck+1) do //插入
current=root;
while(!current.leaf) do
k=current.level;
n=h(l[k]);
current=current.child[n];
end
current.candidate.insert(l);
if (current.candidate.size>max_leafsize) //分裂
current.leaf=false;
current.level=++k;
foreach (s in current.candidate) do
n=h(s[k]);
current.child[n].candidate.insert(s);
end
end
end
哈希函数
max_leafsize=3
3,6,9
1,4,7
2,5,8
散列树的构造:例子
C3
{124,125,136,145,159,234,345,356,357,367,368,457,458,567,689}
1
2
2
234
567
124
1 235
145
124
457
12
34
6
1
12
45
5
159
4 15 27 5
458
136
159
345
345
356
357
367
356
357
689
367
368
基于散列树的支持度计数
Input: data set T, k, HashTree
W-K+1
for t in T
Recursivetraverse (1,HashTree.root,t);
t:
1 2 3 5 6 10
end
Recursivetraverse (int level, HashTreeNode node, Transaction t)
Level=1
K-1
if (node.leaf)
compare(t,node.candidate);
t’=trim(t): 2 + 3 5 6 10
return;
else
for (int b=level~w-k+level) do
node=node.child[h(t[b])];
t=trim(t);
Recursivetraverse(level+1,node,t);
end
end
基于散列树的支持度计数:例子
哈希函数
3,6,9
1,4,7
t: 1 2 3 5 6
2,5,8
2+ 356
1+2356
3+ 56
234
567
13+56
145
136
12+356
124
457
比较5个叶子节点中的9个候选项集
而不需要比较总共15个候选项集
125
458
159
345
356
357
689
367
368
减少扫描代价的其他方法
• 数据压缩
– 已经得到频繁k项集
– 测试候选k+1项集
• 删除/标记不包含任何频繁k项集的记录
• 抽样
– 在原始数据的样本上挖掘频繁项集
– 牺牲精度
Apriori算法复杂度分析
• 影响Apriori算法效率的因素
–
–
–
–
支持度阈值
维度D
样本数N
平均记录长度w
• Apriori算法复杂度
– 频繁1项集(第一次扫描)O(Nw)
– 对于每个k
•
•
•
•
候选项集连接O(| Lk-1 | 2(k-2))
构造散列树k|Ck|
剪枝O((k-2)(k-1) |Ck|)
测试O(NCwk)
FP增长算法
• 不产生候选
• 有限的扫描次数
• 索引全数据集
– FP-tree
– 挖掘频繁项集在索引结构上进行
FP树构造
• 扫描数据集:第一次
– 频繁项支持度计数
– 频繁项排序
– 记录改写
Input: data set T
root=new FPnode;
foreach (Transaction t in T) do
insert(t[1],t-t[1],root);
end
insert (item m, itemset ms, FPnode node)
构造FP树
branch=node.children.seek(m)
if (!branch)
• 每个节点包含
count(branch)++;
–项
else
– 计数
branch=new Fpnode;
– 指向孩子节点的指针
count(branch)=1;
*itemtable[m].link=&branch;
构造项头表
end
insert (ms[1],ms-ms[1],branch);
• 扫描数据集:第二次
–
–
min_support = 3
1.
FP树构造
Tid
Items
Tid
Items
100
f, a, c, d, g, i, m, p
100
f, c, a, m, p
200
a, b, c, f, l, m, o
200
f, c, a, b, m
300
b, f, h, j, o, w
300
f, b
400
b, c, k, s, p
400
c, b, p
500
a, f, c, e, l, p, m, n
500
f, c, a, m, p
扫描第一遍
• 计算支持度计数
• 得到频繁1项集
• 按照支持度递减排序
• 重写记录,只包含频繁项并排序
频繁1项集
sup
f
4
c
4
a
3
b
3
m
3
p
3
2. 扫描第二遍
•
构造FP树的根节点
•
每条记录
•增加分支
•增加项头表
{}
f:1432
项头表
项
f
c
a
b
m
p
频率 指针
4
4
3
3
3
3
□
□
□
□
□
□
c:1
c:1
32 b:1 b:1
a:132
m:12 b:1
p:12
m:1
p:1
FP树挖掘频繁模式
• 从频繁1项集(初始后缀模式)开始由底向
上
– 分治地对后缀模式
• 生成条件FP树
–
–
–
–
删除不与后缀模式一起出现的分支
删除后缀
更新支持度计数
删除非频繁项
• 条件模式基
– FP树中的与后缀模式一起出现的前缀路径集
• 递归挖掘条件FP树
FP树挖掘频繁模式:例子
{}
min_support = 3
f:4
项头表
项
f
c
a
b
m
p
频率 指针
4
4
3
3
3
3
1,自底向上
□
□
□
□
□
□
c:3
2,以p为初始后缀模式
生成p的条件FP树
•删除不与后缀模式一起出现的分支
•删除后缀
•更新支持度计数
•删除非频繁项
c:1
b:1 b:1
a:3
p:1
m:2
b:1
p:2
m:1
•包含p
•不包含p,含m
•不包含p/m,含b
•不包含p/m/b,含a
•不包含p/m/b/a,含c
•只包含f
条件模式基
p
c:3
f:2
项头表
项
f
c
a
b
m
{}
频繁项集
cp
频率 指针
2
3
2
1
2
□
□
□
□
□
c:1
c:2
b:1
a:2
m:2
{}
c:3
FP树挖掘频繁模式:例子(2)
min_support = 3
f:4
项头表
项
f
c
a
b
m
p
频率 指针
4
4
3
3
3
3
c:3
•删除不与后缀模式一起出现的分支
•删除后缀
{}
•更新支持度计数
•删除非频繁项
c:1
b:1 b:1
f:3
项头表
a:3
p:1
m:2
b:1
p:2
m:1
f
c
a
b
c:3
频率 指针
□
□
□
□
3
3
3
1
{}
条
件
条
件
树
FP
f:3
am
条件模式基
m
fca:3
分治更长的后缀模式
fm, cm, am, fcm, fam,fcam
a:3
FP
•包含p
•不包含p,含m
•不包含p/m,含b
•不包含p/m/b,含a
•不包含p/m/b/a,含c
•只包含f
项
cm
1,自底向上
□
□
□
□
□
□
2,以p为初始后缀模式
生成p的条件FP树
{}
树
b:1
{}
f:3
c:3
关联规则
• 枚举的方法
– 给定频繁项集 L, 非空子集 f  L ,测试f  L – f
是否满足置信度 阈值
– 如果 {A,B,C,D} 是频繁的, 候选规则包括:
ABC D,
A BCD,
AB CD,
BD AC,
ABD C,
B ACD,
AC  BD,
CD AB,
ACD B,
C ABD,
AD  BC,
BCD A,
D ABC
BC AD,
– 对于频繁k项集 |L| = k, 有2k – 2 条候选规则 (即
忽略 L   and   L)
基于置信度的剪枝
ABCD=>{ }
BCD=>A
CD=>AB
BD=>AC
D=>ABC
ACD=>B
BC=>AD
C=>ABD
ABD=>C
AD=>BC
B=>ACD
ABC=>D
AC=>BD
AB=>CD
A=>BCD
如果形如X->Y-X的规则不满足置信度阈值,那么形如X’->Y-X’的规则也一定不满
足置信度阈值,其中X’是X的子集
关联规则产生算法
for (k=1~K) do
//频繁k项集
for (H1in Lk) do
//从1项后件开始
rulegen (H1,Lk);
end
end
rulegen (Hm ,L)
if (|L|>|Hm|)
apriori_gen (Hm+1);
foreach (hm+1 in Hm+1) do
if (conf>min_conf)
output “L-hm+1 hm+1”;
else
delete hm+1 from Hm+1;
end
end
rulegen (Hm+1 ,L);
end
数据挖掘的基本流程
数据
数据 挖掘
预处
数据 理
获取
模式
评估
用户
界面
兴趣度度量: 提升度
• 强关联规则不一定有趣
– 打篮球 吃麦片 [支持度40%, 置信度66.7%] 是一个误导的强关联规则
– 如果吃麦片占所有学生的75% (> 66.7%)
– 打篮球 与吃麦片负相关,即打篮球  不吃麦片 [20%, 33.3%]
• 扩充关联规则框架:A B [支持度,置信度,相关度]
P( A B)
lift 
P( A) P( B)
lift (篮球 , 麦片) 
2000 / 5000
 0.89
3000 / 5000 * 3750 / 5000
篮球
非篮球
Sum (row)
麦片
2000
1750
3750
非麦片
1000
250
1250
Sum(col.)
3000
2000
5000
打篮球 吃麦片 [支持度40%, 置信度66.7%,相关度0.89]
lift (篮球, 非麦片 ) 
1000 / 5000
 1.33
3000 / 5000 *1250 / 5000
打篮球  不吃麦片 [20%, 33.3%,1.33]
时间序列数据
股票
时间序列数据集由不同时间重复测量
得到的值或事件的序列组成。
序列数据集是由事件序列组成,不一
定有具体的时间概念。
GPS
网络点击流
序列模式的形式定义
• 事件=项集
• 序列=事件的有序列表
– 序列的长度是序列中包含的事件/项个数
• L-序列是序列中的项数目为l的序列
• 子序列和超序列
– 序列α=<a1a2an>是序列β=<b1b2…bm>的子序列, β 是α的超序
列 
– 如果存在整数1≤j1<j2…jn≤m,使得 a  b ,..a  b
1
j1
n
jm
• 序列数据集(库)S是序列的集合
• 序列模式=频繁序列
– 序列α在序列数据集S中的支持度=序列数据集中包含序列α的
记录数 |   s, s  S |
– 一个序列α是频繁的,如果α的支持度满足最小支持度阈值
序列模式的形式定义:例子
序列数据集S
SID
10
20
30
40
4,找到S中包含的所有频繁2-序列
sequence
<a(abc)(ac)d(cf)>
<(ad)c(bc)(ae)>
<(ef)(ab)(df)cb>
<eg(af)cbc>
1,说明序列10,20,30,40的事件数和项数?
5/9,4/7,5/8,6/7
2,<a(bc)dc> 是哪个序列的子序列
<a(abc)(ac)d(cf)>
3,给定min_sup = 2, <(ab)c>是序列模式吗?
是。因为<(ab)c>的支持度为2
<aa>,<ab>,<ac>,<ad>,<af>,
<ba>,<bc>,<bd>,<bf>,
<ca>,<cb>,<cc>,
<db>,<dc>,
<ea>,<eb>,<ec>,<ef>,
<fb>,<fc>,
<(ab)>
序列模式挖掘:GSP算法
• GSP算法(Generalized Sequential Patterns)
– 利用了Apriori性质,即任何序列模式的非空子
序列也是序列模式
– 算法框架
1. 扫描第一遍,得到频繁1项,即频繁1-序列
2. 扫描第k遍,得到频繁k-序列
1.
2.
3.
由频繁k-1-序列连接得到候选k-序列
剪枝得到更小的候选k-序列集合
计算支持度计数,得到频繁k-序列
产生
测试
候选产生的方法
• 首先,序列本身有序。事件无序,但按照
(字典)序对事件中的项目排序
• 候选k-序列s由合并两个频繁k-1序列s1和s2
– 当且仅当s1去掉第一个项后的子序列等于s2去掉
最后一个项之后的子序列
– 合并后等于s1加上
• 如果s2的最后一项在s2中是一个独立的事件,则作为
独立的一个事件加到s的最后
• 否则,在s中的最后一个事件里加上
候选产生的方法:例子
频繁3-序列
<1 5 3>
<5 (3 4)>
第一个序列去掉第一个项目,
第二个序列去掉最后一个项目
子序列
<5 3> = <5 3>
子序列
<2 3> = <2 3>
频繁3-序列
<1 2 3>
<2 3 4>
合并第一个序列与最后一个项目
如果最后一个项目
在第二个序列中
是独立事件
则作为独立事件加入
候选4-序列
<1 5 (3 4)>
否则,作为
最后一个事件的一项
加入
候选4-序列
<1 2 3 4>
这个方案是完备的吗?即,这样产生的候选k-序列没有遗漏任何可能的频繁k-序列吗?
PrefixSpan算法:形式定义
• 给定一个序列 α=<a1a2an>
序列:<a(abc)(ac)d(cf)>
– β= <b1b2…bm >是α的前缀,如果
前缀
<a>
• m≤n
• 对于所有的i <m,bi=ai
<aa>
• bm  am
<ab>
• am-bm的所有频繁项按字典序排在bm后
– γ= <rmrm+1…rn >是α关于前缀β的后缀
• rm=am-bm,如果rm不为空,一般写成(_...)
• 对于所有的i >m,ri=ai
关于前缀的后缀
<(abc)(ac)d(cf)>
<(_bc)(ac)d(cf)>
<(_c)(ac)d(cf)>
PrefixSpan算法思想
• 分治
– 以α为前缀的序列模式挖掘问题可以拆分为若
干个互不相交的以α β为前缀的序列模式挖掘问
题
• 扫描数据集,得到频繁1项
– 挖掘以频繁1项为前缀的序列模式
– 对于每个k前缀
• 递归的挖掘k+1前缀
PrefixSpan算法:例子
SID
10
20
30
40
sequence
<a(abc)(ac)d(cf)>
<(ad)c(bc)(ae)>
<(ef)(ab)(df)cb>
<eg(af)cbc>
序列数据集S
min_support =2
扫描,得到频繁1项集
L1
频率
a
4
b
4
c
4
d
2
E
3
f
3
g
1
分治
SID
10
20
30
40
sequence
<(abc)(ac)d(cf)>
<(_d)c(bc)(ae)>
<(_b)(df)cb>
<(_f)cbc>
前缀a的投影数据集
每条记录包含<a>
且是原记录中以<a>的第一次出现
为前缀的子序列
•挖掘前缀<a>序列模式
•挖掘前缀<b>序列模式
•…
•挖掘前缀<f>序列模式
扫描
局部
频繁
项
L1
频率
a
2
b
4
_b
2
c
4
_c
1
d
2
_d
1
e
1
_e
1
f
2
_f
1
递归挖掘前缀<aa>, <ab>, <(ab)>, <ac>, <ad>, <af>的序列模式
频繁子图挖掘的意义: AIDS
Compounds are active, inactive or moderately
active (CA, CI, CM)
频繁子图定义
• 给定一个图数据集D={G0,G1,…GN} ,其中每个图
是标号图,即图中各顶点和边带有标号
– 图g的支持度计数是 D中包含 g 为子图的图数目
– g是频繁[连通] 子图如果图数据集D中包含g作为子
图的图数目 support(g)≥minSup
–
–
–
分子结构图,节点V,点的标号N(V)={O,H,S,N…},边E,边的标号L(E)={-,=…}
–
min_support =2
频繁子图
Apriori算法
minSup=2
1. 从只包含1条边的子图开始
2. for
1. 由{K-1}-边频繁子图生成K-边子图候选集合
2. 剪枝
3. 计算支持度
end
同构
• 图G和G’同构
– 图 G和图 G′同构,如果存在双射f:V↔V’
(1)v V , N (v)  N ( f (v))
(2)(u, v)  E, L( E )  L(( f (u), f (v)))
• 子图同构
– G的子图和g同构
这两图一样吗?
gSpan算法基本思想
• 不产生候选
• 分治
– 递归
• 模式增长
– 子图同构检验是算法瓶颈
– DFS编码
DFS编码
• 对图进行深度优先遍历
– 所有节点根据发现时间排序
• 最后发现的节点叫做最右节点
• 从第一个节点到最右节点的直线路径叫做最右路径
– 所有边表示为五元组(i,j,ni,lij,nj)
• 前向边i<j
• 后向边i>j
• 边的排序:e1<e2, iff
–
–
–
–
同是前向边,且j1<j2
同是后向边,且i1<i2或者i1=i2&& j1<j2
e1是前向边,e2是后向边,且j1<=i2
e1是后向边,e2是前向边,且i1<j2
– 根据边的次序得到的边序列是图的DFS编码
DFS编码:例子
同一个图的不同DFS编码
确定唯一DFS code
• 一个图可能有多个DFS code
• 选择最小的DFS code=唯一编码
– 因为有label,所以考虑字典序
– 对于两个序列
边排序
• 序列a,长度为m v.s. 序列b,长度n
• a≤b
– 如果b比a长(n≥m),每个元素相等
• 如果有某个位置
– 这个位置之前的
较大点
较小的点
边label
最小DFS编码:例子
同一个图的不同DFS编码
次小
最小
最大
DFS 编码树
• 思想:用树结构的增长寻找/计数频繁同构
子图
– 树每个节点代表一个DFS编码
– 一棵树代表了所有可能的频繁子图
• DFS编码增长
– 最右节点+后向边
– 最右路径+前向边
– 考虑字典序
DFS编码树的剪枝
Min_support=2
红>绿>蓝
gSpan算法

similar documents