大型数据库分析-关联式规则(Associaton-Rules)-1

引言

目的：是找到所有的关联式规则(Association-Rules)，而不是检测一个关联式规则是否存在。

下面会讲到的内容：

1.Association-Rules的基本概念

2.Apriori-Algorithmus

3.优化Apriori

4.FP-trees

5.Finden häufiger Muster in Zeitreihen//暂时不知是干嘛用得

6.有约束条件的Association Rules(Constraint-basierte Association Rules)

7.多层Association-Rules(Multi-Level Association Rules)

Association Rule

就像名字说得一样，他表达的是不同事物之间的关系。举个例子，商店购物车分析：通过分析客户的购物清单，可以找出客户购物时，不同物品之间的关系。比如去超市购买牛奶时一般会顺便购买鸡蛋。

基本概念：

item:单个元素(einzelnes Element)

itemset:Item的集合(Menge von Items)

Transaction(Transaktion)：清单，有两种表达结构

1.关系结构(Relationsale Struktur):<Tid,item>

e.g.<1,item1><1,item2><2,item3>

2.紧凑结构(Kompakte Struktur): <Tid,itemset>

e.g.<1,{item1,item2}><2,{item3}>

在购物车分析中item就是指物品，transaction就是指单次购物买得东西。他和数据库里的概念木有关系

Support:itemset I的Support是指包含有I得Transaction的数量

Minimum Support σ\sigma:Support的阀值

Frequent itemset: 指Support大于σ\sigma的items

例子

TransactionID1234ItemsMilch,ObstMilch,Obst,GemüseMilchObst,Brot
\begin{array}{c|c}
\hline
Transaction ID&Items\\
\hline
1&Milch,Obst\\
\hline
2&Milch,Obst,Gemüse\\
\hline
3&Milch\\
\hline
4&Obst,Brot\\
\hline
\end{array}

Support({Milch})=3(75%)

Support({Obst})=3

Support({Milch,Obst})=2(50%)

假设σ=60\sigma=60%,那么就有：

{Milch}和{Obst}是frequent,{Milch,Obst}则不是

maximal：

我们说Frequent itemset 是最大的(maximal)，当且不存在任何一集合，同时满足1.它属于这个集合的子集，2.这个集合也是frequent。

(Es reicht, die maximalen Frequent Itemsets explizit zu erzeugen, um die Frequent itemset zu kennen //不知啥意思？？？)

闭合性(Closedness):

一个itemset是闭合的(closed)，当不存在任何一个超集和拥有相同的Support。

Association Rules选择的标准

//插图看a⊂b和b⊂aa \subset b和b \subset a的不同

举个例子，对比一下下面两种说法的不同：

1.买可乐的人，一般会顺便买薯片

2.可乐和薯片经常一起被卖出

第一种说法的说服力明显比较强//不觉得？？把第一种说法里的薯片和可乐倒过来就觉得了

A⇒B[s,c]:A \Rightarrow B[s,c]:

其中A和B为itemset

s = A⇒BA \Rightarrow B的support = support(A∪BA \cup B)=p(A∪BA \cup B)

//注这里不是指或，而是指同时存在

c = A⇒BA \Rightarrow B的confidence = support(A∪BA \cup B)/support(A)=p(B|A)=p(A \land B)/P(A)

Regel选择的标准：

Minimum Support：σ\sigma

Minimum Confidence：γ\gamma

我们希望的Regel应该满足：s>=σ,c>=γs >= \sigma, c >= \gamma

//那么σ和γ\sigma和\gamma选高或者选太低了会怎么样呢？？？？

Apriori

1.从含一个元素的集合(1-Sets)开始：简单的数数

2.通过含k-1个元素的集合((k-1)-Sets)推出含k个元素的集合(k-Sets),分三个步骤：

Join Step：通过join从(k-1)-Sets中推出候选的k-Sets

Prune-Step：删除所有不符合要求的候选(Kandidaten)(比如把所有含有不在k-1Sets中出现子集的候选都删了)

Support Counting：就数了，不符合的都删了

//当k=2时，不用进行Prune.为什么？？？

L_1={large 1-itemsets};
for(k=2;L_k-1!=null;k++)do begin{
C_k = appriori-gen(L_k-1);
forall transactions t in D do begin{
C_t = subset(C_k,t);
forall candidates c in C_t do{
c.count++;
}
}
L_k = {c in C_k|c.count >= minsup};
}
Answer += L_k;

//上面的程序好像没有看到剪枝啊

//用hash树可以快速的查找一个itemset是否在Transaction中。

//怎么做呢？？？S30-S31

多维Association Rules(Multidimensionale Association Rules)

寻找的是不同属性的的值之间的关系(Beziehungen zwischen Werten verschiedener Attribute)

CID123456nationalityItalianFrenceFrenceItalianItalianFrenchage504030504535incomelowhighhighmediumhighhigh
\begin{array}{c|c|c|c}
\hline
CID&nationality&age&income\\
\hline
1&Italian&50&low\\
\hline
2&Frence&40&high\\
\hline
3&Frence&30&high\\
\hline
4&Italian&50&medium\\
\hline
5&Italian&45&high\\
\hline
6&French&35&high\\
\hline
\end{array}

Regel:

nationality=French⇒income=high[50nationality=French \Rightarrow income=high[50%,100%]

income=high⇒nationality=French[50income = high \Rightarrow nationality=French[50%,75%]

对于求多维Association Rules可以先把多维换成一维：

<1,Italian,50,low>⇒<1,Italian,50,low> \Rightarrow <1,{nat/Ita,age/50,inc/low}>

<2,French,45,high>⇒<2,French,45,high> \Rightarrow<2,{nat/Fre,age/45,inc/high}>

这样就可方便使用Apriori了

多层Association Rules(Multi-Level Association Rules)

举个例子，面包其实是一个泛称，他还可以分为白面包啊全麦面吧啊等等，而白面包之下可能还能分为其他具体类别。因此存在多个层次。

Level-Crossing Association Rules：

这种Association Rules规则规定在产生候选集的时候，允许把不同的层次的itemsets分配一起。比如：白面包⇒牛奶白面包 \Rightarrow 牛奶

(Für Mixed-Level Kandidaten kann man als Minimum Support den des unterenLevels nehmen.？？？？？？)

一般情况下只有在高层概念之间有比较高的Support，但同样的层级越高，我们的兴趣反而越小。比如：吃得⇒喝的吃得 \Rightarrow 喝的

Naheliegender Ansatz：

items的集合是混合的，各层的东西都有(Menge der Items enthält auch die Kategorien)。比如：{全麦面包，面包，营养品，牛奶}

但是在生成候选集合的时候，不允许同种类别之间进行混合，比如下面这个rule是不行的：全麦面包⇒面包全麦面包 \Rightarrow 面包

(Vorgehen-wie bisherige Verfahren,bis auf dass Items, die hierarchische Beziehun haben, nicht kombiniert werden.????)

悲剧后果：

Frequent Itemset的数量会随着层数的增加呈指数增长

而且会产生许多相识的Association Rules

使用经过编码的TA表格(kodierte TA-Tabelle)

我们为各种Item进行编码，举个例子我分把牛奶编号为1，那么相应的全牛奶我们可以编码为12，恒牛奶则编码为11.以此类推，用数字表示种类，用数字的个数表示深度(这样好像有个数限制，就10个数字？？)。那么我们可以得到一个编码后的TA(Transaction)表:

TIDT1T2T3T4T5T6T7Items111,121,211,221111,211,222,323112,122,221,411111,121111,122,211,221,413211,323,524323,411,524,713
\begin{array}{c|c}
\hline
TID&Items\\
\hline
T_1&111,121,211,221\\
\hline
T_2&111,211,222,323\\
\hline
T_3&112,122,221,411\\
\hline
T_4&111,121\\
\hline
T_5&111,122,211,221,413\\
\hline
T_6&211,323,524\\
\hline
T_7&323,411,524,713\\
\hline
\end{array}

在此之前我们得到的都只是一维的表·LkL_k,现在我们得到的是二维的L[i,j]

//插图 这个其实还是有点晕

提高识别Frequent Itemsets的效率(Schnelles Identifizieren von Frequent Itemsets)

主要介绍一下一下方法：

1.直接hash并剪枝(Pruning)

2.Sampling

3.Bayado//不知是什么鬼

4.FP-Trees

DHP(direct hashing and pruning) algorithm

现在的情况是，在k比较小得时候，对应的候选集非常大。举个例子，当L1=1000时，C2=C21000=500∗999L_1 = 1000时，C_2=C_{1000}^2=500*999

//别把C和L弄混了，一个是候选集，一个是。。怎么说呢。。。知道就行了

DHP的目的就是：

1.提高生成候选(就是CkC_k啊)的效率

2.把一些没用的Transaction给扔了

**基本思想：**Hash Filter

(Beim zählen des Supports der Elemente von CkC_k werden auch (k+1)-elementige Teilmengen jeder Transaktion betrachtet)//没懂？？？？

提高候选效率

当生成L1L_1时，算法同时还生成了每个Transaction对应的所有的2元itemset子集，并且还把他们hash到一个hash表中，并进行计数。

例子

/*这段表示理解不行，跳了吧

Transactions：

{1,4},{1,4},{1,7},{1,7},{2,8},{2},{2},{4},{4},{7},{7},{8},{8}

1.minsup = 2;

同个Transaction的值加起来再mod7，统计出现次数大于2的值。将这些组合起来用H1H_1表示，称为第一层哈希表，把所有哈希后的值在哈希表中候选集中,数数超过minsup则过，不足则删，他们即为L1L_1.

通过join生成L2L_2候选

H1:1,2,4,5,7H_1:{1,2,4,5,7}

L1:1,2,4,7,8L_1:{1,2,4,7,8}

候选：{1,2}{1,4}{1,7}{1,8}{2,4}{2,7}{2,8}{4,7}{4,8}{7,8}

2.调整哈希值，重复上面操作

s = a minimum support;
<Set all the buckets of H_2 to zero>
/*H_2 is hash table, i.e., array of int whose domain is the range of the hash function*/
forall transaction t in D do begin{
insert and count 1-items occurences in a hash-tree;
forall 2-subsets x of t do{
H_2[h_2(x)]++
}
}
L_1 = {c|c.count >= s, c is in a leaf node of the hash tree};

*/

//下面这段是从G.K.Gupta那盗过来的

/*

Introduction to Data Mining with Case Studies

Author:G.K.Gupta

Pretice Hall India, 2006

*/

TransactionID100200300400500ItemsBread,Cheese,Eggs,JuiceBread,Cheese,JuiceBread,Milk,YogurtBread,Juice,MilkCheese,Juice,Milk
\begin{array}{c|c}
\hline
Transaction ID&Items\\
\hline
100&Bread,Cheese,Eggs,Juice\\
\hline
200&Bread,Cheese,Juice\\
\hline
300&Bread,Milk,Yogurt\\
\hline
400&Bread,Juice,Milk\\
\hline
500&Cheese,Juice,Milk\\
\hline
\end{array}

下面这个表呈现了所有可能的2-itemsets

100200300400500(B,C)(B,E)(B,J)(C,E)(C,J)(E,J)(B,C)(B,J)(C,J)(B,M)(B,Y)(M,Y)(B,J)(B,M)(J,Y)(C,J)(C,M)(J,Y)
\begin{array}{c|c}
\hline
100&(B,C)(B,E)(B,J)(C,E)(C,J)(E,J)\\
\hline
200&(B,C)(B,J)(C,J)\\
\hline
300&(B,M)(B,Y)(M,Y)\\
\hline
400&(B,J)(B,M)(J,Y)\\
\hline
500&(C,J)(C,M)(J,Y)\\
\hline
\end{array}

现在把这个表里的内容hash到hash表中：最后一列纯粹为了观赏

Bitvector10000111Bucketnumber01234567Count31102333Pairs(C,J)(B,Y)(M,Y)(C,M)(E,J)(B,C)(B,E)(J,M)(B,J)(C,E)(B,M)C2(C,J)(J,M)(B,J)(B,M)
\begin{array}{c|c|c|c|c}
\hline
Bit vector&Bucket number&Count&Pairs&C_2\\
\hline
1&0&3&(C,J)(B,Y)(M,Y)&(C,J)\\
\hline
0&1&1&(C,M)\\
\hline
0&2&1&(E,J)\\
\hline
0&3&0\\
\hline
0&4&2&(B,C)\\
\hline
1&5&3&(B,E)(J,M)&(J,M)\\
\hline
1&6&3&(B,J)&(B,J)\\
\hline
1&7&3&(C,E)(B,M)&(B,M)\\
\hline
\end{array}

那么这个hash函数使怎么玩得呢？？

首先还是编码：

B=1,C=2,E=3,J=4,M=5,Y=6

那么现在每个itemset都可以表示成两个数据了，比如(B,E)就可以表示为13，同理(C,M)可以表示为26

接着把得到的数字进行mod 8处理，得到的结果就是对应的Bucket number了。count的含义就不说了。如果count的值大于最小Support那么把bit vector设为1，反之为0。

/*

存在问题， 按说Bucket number的Count应该是5才对，另外没有说明是怎么求出C的，是取最大那一个吗？？但也可能几个都是啊

*/

所有bit vector标为0的二元对都扔了

由上表也可以看出，随着hash函数参数的不同可能导致collision，上表中Bucket number为0的项对应的就有三个paar撞到了一起，这时候就应该进行额外的判断，来选出适合的C了。

/*

第一层的可以直接从Transaction中来，比较省事。但以后应该是从上一层的L中join得到的全部候选来hash了吧？？

*/

减少Transaction

中心思想是：所有不含有Frequent k-itemsets的Transaction，同时也不可能含有对应的Frequent (k+1)-itemsets。那么这个Transaction在这时就会被标记起来后者就直接扔了。

例子

TID001002003004005006007008009010ItemsboughtB,M,T,YB,MT,S,PA,B,C,DA,BT,Y,EA,B,MB,C,D,T,PD,T,SA,B,M
\begin{array}{c|c}
\hline
TID&Items bought\\
\hline
001&B,M,T,Y\\
\hline
002&B,M\\
\hline
003&T,S,P\\
\hline
004&A,B,C,D\\
\hline
005&A,B\\
\hline
006&T,Y,E\\
\hline
007&A,B,M\\
\hline
008&B,C,D,T,P\\
\hline
009&D,T,S\\
\hline
010&A,B,M\\
\hline
\end{array}

假设现在我们有L1=A,B,D,M,TL_1={A,B,D,M,T}，那么很遗憾我们并不能对这些Transaction做什么，因为每个Transaction都含有L1L_1中的其中一个元素，那么如果我们得到了C2C_2是{(A,B),(B,M)}呢

//所以在得到C的时候就可以对应的扔了一些Transaction了。因为L一定是对应的C的子集。

Sampling

在使用Apriori算法的时候，计算每层Itemset时都需要走一遍数据库，因此使用Apriori算法是的I/O消耗是很大的。

那么Sampling的思路就是，从数据库中取出一些样品(Sample)放倒主存里(最好尽量大点，使充满主存)，使绝大部分的计算针对这个样本进行。

通过这些Sample，我们的目的是找到Negative Border。

那么Negative Border是什么呢？我们知道当itemset的大小为空时，他支持所有的Transaction，而当itemset是所有元素的集合时，那么几乎不存在包含他的Transaction。因此可以看出itemset重最小到最大他对应的Frequent的数量应该是逐渐减少的。那么就存在一条线使得，当一个Frequent itemset再往上扩大一步的时候他就会变成非Frequent的。这条线我们就叫做Negative Border。

很明显Negative Border受minsup得影响。

在针对Sample进行操作的时候，我们可以通过取相对小一点的minsup，使得尽可能包括所有的Frequent itemset。相应的我们也可以通过上下浮动minsup来确定真实Negative Border的可能区域。

//插图 说明Negative Border

Apriori-B

目的：(Weitgehende)Vermeidung der Betrachtung von Frequent Itemsets, die nicht maximal sind.就是说避免观察不是最大的Frequent Itemset。(最大就是指Negative Border边上得Itemset)

思想：不再k++了，这回决定大步向前走

(Diese Idee ist insbesondere bei großen Itemsets sinnvoll.)//呵呵？？

举个例子：

从{1 2 3}{1 2 4} {1 2 5}{1 2 6}直接获得候选{1 2 3 4 5 6}

//如果都成那自然没事，但如果有一个不是fr，就可能导致漏选了，这时就该把这个不成的给细拆了。？？？

到目前为止学得基本上都是Apriori的变形，基本都是分两步走：建立候选，然后扫描数据库。那么能直接跳掉建立候选呢？？？

(Generate&Test-Paradigma???)

FP-Tree

全新的步骤，这回决定把整个Apriori给扔了：

1.把每个Transaction中的items按照出现的频率进行排序(1.5次扫描),如果两个item出现的次数相同，那么就按照字母表的顺序进行排序。另外如果一个item出现的次数直接小雨阀值了，那就直接删了把。换句话说就是只排序L1L_1

2.建立FP树(0.5次扫描)

3.从FP树(在主存中)抽象出Frequent Itemset

第一阶段

直接上图了。。。好吧是表来着的。。：

TID100200300400500Itemsf,a,c,d,g,i,m,pa,b,c,f,l,m,ob,c,h,j,ob,f,k,s,pa,f,c,e,i,p,m,n排序后的Itemsc,f,a,m,pc,f,a,b,mc,bf,b,pc,f,a,m,p
\begin{array}{c|c|c}
\hline
TID&Items&排序后的Items\\
\hline
100&f,a,c,d,g,i,m,p&c,f,a,m,p\\
\hline
200&a,b,c,f,l,m,o&c,f,a,b,m\\
\hline
300&b,c,h,j,o&c,b\\
\hline
400&b,f,k,s,p&f,b,p\\
\hline
500&a,f,c,e,i,p,m,n&c,f,a,m,p\\
\hline
\end{array}

(Man sieht:Manche Präfixe sind recht häufig,z.B. c,f,a)

第二阶段

FP树由两部分组成：

1.就是树了

2.Header-Tabel

Tree(Baum):

1.每个排序后的Transaction都是树上得一条路径

2.每个节点都包含一个Item-ID，以及经过这个节点的路径的数目

Header-Tabel：(在生成树的同时建立)

1.Tabel中的每个项(Item)都是一个指向一个链路的指针

2.Tabel中的项都按照频率排序

//插个图 明了一下

第三阶段

1.所有的Items，从从频率最小的开始，会被依次进行处理

2.每一个步骤都抽象出这么一个Frequent Itemset：他包含有当前正在处理的Item，但是它同时也不包含有到目前为止已经处理过的Item。

3.具体操作和Apriori差不多，但就是不用在扫描数据库了。

看一下具体操作：假设最小Support是3：

Item P:

首先建立所有含有p得路径

有两条：{<(c:4),(f:3),(a:3),(m:2),(p:2)>,<(f:1),(b:1),(p:1)>}

保留下以p结束的路径：

{<(c:4),(f:3),(a:3),(m:2),(p:2)>,<(f:1),(b:1),(p:1)>}

那么maximal Frequent Patterns是{fp}

把p从树上减了

FP树处理大型数据库数据

当数据库太大时，可能导致FP-tree太大而不能存储在主存中。这时我们可以通过对Transaction进行分区，然后逐个处理。

(Projected Databases-Ergebnis der Partitionierung)

那么应该怎么分区呢？？

1.首先还是要进行排序，比如排序后得到L=