Web数据挖掘笔记（一）

为什么80%的码农都做不了架构师？>>>   

---

1. 关联规则的基本概念：

   设 I = { i₁，i₂，...，i_m }是一个项目集合（即项集），T={ t₁，t₂，...，t_n }是一个事务集合，其中每一个事务 t_i 是一个项目集合并满足 t_i⊆I。

   关联规则是一种蕴含关系：X->Y，其中X ⊂ I，Y ⊂ I且 X ∩ Y= Ø，X、Y都是项集，X为前件，Y为后件。

   t_i包含X：项集X是事务t_i∈T的一个子集

   X在T中的支持计数（Support Count）X.count是T中包含X的事务数目。

   X->Y的支持度（Support）：T中包含X∪Y的事务的百分比，即表示规则在事务集合T中使用的频繁程度。设n为T中事务的数目，则规则X->Y支持度=（（X∪Y）.count）/n

   X->Y的置信度（Confidence）：既包含了X又包含了Y的事务的数量占所有包含了X的事务的百分比。规则X->Y的置信度=（（X∪Y）.count）/ X.count，置信度决定了可预测度（Predictability）

   目标：给定一个事务集合T，关联规则挖掘是指“找出T中所有满足支持度和置信度分别高于一个用户指定的最小支持度minsup和最小置信度minconf的关联规则”

2. Apriori算法：

   1. 生成所有频繁项目集（Frequent ItemSet，是一个支持度高于minsup的项集）：

      1. Aprior算法基于演绎（Aprior）原理（即向下封闭属性：如果一个项目集满足某个最小支持度的要求，那么这个项集的任何非空子集必须满足这个最小支持度）。

      2. Aprior算法的用于频繁项目集生成部分的算法是基于逐级搜索（Level-wise Search）的思想。

Algorithm Apriori(T)C1 <- init-pass(T) //对事务集进行第一轮搜索
F1 <- {f|f∈C1,f.count/n >= minsup}; //n是T中事务的数目
for(k=2;Fk-1≠Ø;k++) do //随后的各轮依次搜索    
    Ck <- candidate-gen(Fk-1); //产生候选项集集合Ck    
    for each transaction t∈T do //对所有事物扫描一遍        
        for each candidate c∈Ck do //计算每一个候选项集的支持计数            
            if c is contained in t then c.count++;        
        endfor    
    endfor    
    Fk <- {c∈Ck|c.count/n >= minsup}//删除不符合要求的候选项集
endfor
return F <- UkFk;

其中candidate-gen函数可以分成两步：合并（3~7行）和剪枝（9-12行）

Function candidate-gen(Fk-1)ck <- Ø;//初始化候选项集集合
forall f1,f2∈Fk-1//找出所所有的只有最后一项不同的频繁项集对(f1,f2)
with f1={i1,...,ik-2,ik-1}and  f2={i1,...,ik-2,i'k-1}
and  ik-1<i'k-1 do//根据字典顺序将f1和f2合并    
    c <- {i1,...,ik-2,ik-1,i'k-1};    
    Ck <- Ck∪{c};//将新候选项集加入候选项集集合    
    for each (k-1)-subset s of c do//如果存在c的(k-1）-子集不是频繁项集，则将c从Ck中删除 
    if(s ∉ Fk-1)then delete c from Ck    
    endfor
endfor
return Ck;//返回生成的候选项集集合

备注：

1. 设 I 中项目的数目是m，则整个项集集合空间的规模将达到O（2^m）。
   

2. 这个算法不会把整个数据集一次性装入内存中，所以它可以应用于规模巨大的数据集中。

3. 这个算法逐级搜索，所以能很方便的在某一轮搜索完成以后就停止。

4. 一旦给定了一个事务集、一个最小支持度minsup和一个最小置信度minconf，则T中的频繁项目集集合就被唯一确定了。

从频繁项目集中生成所有可信关联原则（Confident Association Rule）：

设 α 为 f 任一非空子集，则可生成如下的一条关联规则：（f - α）-> α 

置信度= f . count /（f - α ) . count ≥ mincof

Algorithm genRules(F)//F为所有频繁项集的集合
for each frequent k-itemset fk in F , k ≥ 2 do //将所有频繁项集取出    
    output every 1-item consequent rule of fk with confidence ≥ mincof and support <- fk.count/n //得到所有高于最小支持度的只有一项的关联规则，并赋予H1    
    H1 <- {consequents of all 1-item consequent rules derives from fk above}    ap-    genRules(fk,H1); 
endfor

Procedure ap-genRules(fk,Hm) //Hm 是 m-后件的集合    
if(k > m+1) AND (Hm ≠ Ø) then //规则的前件至少要有一个项目    
    Hm+1 <- candidate-gen ( Hm ); //得到所有高于最小支持度的关联规则    
    for each hm+1 in Hm+1 do //将所有的关联规则取出计算置信度        
        conf <-fk.count/(fk-hm+1).count;
        if(conf >= mincof ) then //如果置信度高于最小置信度，则删除
          output the rule ( fk - hm+1 ) -> hm+1 with congfidence = conf anf support =fk.count/n;

        else 
         delete hm+1 from Hm+1；    
    endfor    
   ap-genRules(fk,Hm+1);//计算后件+1的关联规则endif

多最小支持度的关联规则挖掘

最小项目支持度（minimum item support，MIS）：‍一条规则R为 i₁，i₂，...，i_k -> i_k+1，...，i_r，它的最小支持度为min（MIS（i1）,MIS（i2），...，MIS（ir））

这里不再满足向下封闭属性，所以引入‍支持度差别限制（Support Difference Constaint）‍‍：设sup（i）是项目 i 在数据集中的真实支持度。对于每个项集s，支持度差别限制定义为：

max_i∈s{ sup ( i ) - min_i∈s{ sup ( i ) } ≤ Φ，其中 0 ≤ Φ ≤ 1 为用户指定的最大支持度差别（Maximum Support Difference）。

MS-Aprior算法

Algorithm MS-Apriori(T,MS,Φ)
M <- sort(I,MS); //按照最小支持度对项目进行排序
L <- init-pass(M,T);//计算每个项目的支持计数，找出第一个满足i.count≥MIS(i)项目加入L中,i之后的每个项目j都只需满足j.count≥MIS(i)即可加入L
F1 <- {{ l }| l ∈ L , l.count / n ≥ MIS( l )};//将从L中得到所有满足l.count/n≥MIS(l)的1-频繁项目集
for(k=2 ; Fk-1≠Ø;k++) do
    if k=2 then Ck <- level2-candidate-gen(L,Φ);
    else Ck <- MScandidate-gen(Fk-1,Φ);
    endif;
    for each transaction t ∈ T do
        for each candidate c ∈ Ck do
            if c is contained in t then c.count++;
           if c-{c[1]} is contained in t then (c-{c[1]}).count++;
       endfor
   endfor
   Fk <- {c ∈ Ck|c.count/n ≥ MIS(C[1])}
endfor
return F <- UkFk;

Function level2-candidate-gen(L,Φ)
c2 <- Φ；//初始化候选项集集合
for each item l in the same order do
    if l.count/n ≥ MIS(l) then //如果该项大于其最小支持度
        for each item h in L that is after l do //h为l后一项,后一项的真实支持度大于l的最小支持度
            if h.count/n ≥ MIS(l) and |sup(h)-sup(l)| ≤ Φ then C2 <- C2∪{{l,h}}//如果h的支持度大于l的最小支持度，那么就将h加入候选项集集合C2

Function MScandidate-gen(Fk-1,Φ)
Ck <- Φ;
forall f1,f2 ∈ Fk with f1={i1,...,ik-2,ik-1} and f2={i1,...,ik-2,i'k-1} and ik-1<i'k-1 and |sup(ik-1)-sup(i'k-1)| ≤ Φ do
    c <- {i1,...,ik-1,i'k-1}
    Ck <- Ck ∪ {c}
    for each (k-1)-subject s of c do
        if(c[1] ∈ s) or (MIS(c[2])=MIS(C[1])) then 
            if(s∉Fk-1) then
                delete c from Ck;
    endfor
endfor
return Ck;

分类关联规则挖掘（Class Association Rules，CAR）

设T是一个含有 n 个事务的事务数据集，每个事务标有一个分类 y 。设 I 为 T 中所有项目的集合，Y 为所有分类标识（Class Labels），且 I ∩ Y = Ø。CAR是指如下的蕴含关系：X -> y，其中X ∈ I，y ∈Y。

CAR的关联规则和一般的关联规则的区别：

1. CAR后件只有一个项目

2. CAR后件y只能从标识集合Y中选取

CAR的关键操作是找出所有支持度高于最小支持度阀值的规则项（Ruleitem）

    规则项（condset，y），其中condset ⊆ I 为条件集，y ∈ Y 是一个类标。

    条件集支持计数condsetCount是T中包含该条件集的事务的数量。

    规则支持计数rulesupCount是T中包含条件集condest且类标为y的事务的数量。

CAR与多最小支持度挖掘概念的融合：

1. 多最小分类支持度（Multiple Minimum Class Supports）

2. 多最小项目支出度（Multiple Minimum Item Supports）

序列模式的基本概念

序列是一个排过序的项集列表，表示为<a₁a₂...a_r>，其中a_i是一个序列的一个元素（项集）。

一个项目在序列的某个元素中只能出现一次，但可以出现在多个不同的元素中。

基数：一个序列中元素的个数

长度：一个序列中项目的个数，长度为k的序列被称为k-序列

对于两个序列s₁，s₂，如果存在整数1≤j₁<j₂<...<j_r-1<j_r≤v，使得a₁⊆b_j1，a₂⊆b_j2，...，a_r⊆b_jr，则称s₁为s₂的子序列，而s₂是s₁的超序列，或者s₂包含s₁。

基于GSP（Generalized Sequential Pattern）挖掘序列模式（广度优先搜素）

GSP算法思想基本和Apriori算法一样。最大不同处在于候选生成函数candidate-gen-SPM（）。

Function candidate-gen-SPM(Fk-1)
1. 合并。将Fk-1和Fk-1合并成候选序列。对于两个序列s1、s2，如果将s1的第一个项目去掉后得到的余串和将s2的最后一个项目去掉后的余串相同，则将s1和s2合并。简而言之，就是把s2的末尾项目添加到s1末尾这有两种情况：
    (1) 如果s2的最后一个项目是一个单独的元素，则将这个项目以一个单独元素的形式加到s1的末尾。
    (2) 否则这个项目作为s1最后一个元素的一部分并入s1。
2. 剪枝。如果一个候选序列的任何(k-1）-子序列是非频繁的，则这个候选序列将被剪枝。

        多最小支持度挖掘：

        当序列s₁的第一个项目或者序列s₂的最后一个项目是各自序列中唯一的MIS值最小的项目（即其它项目的MIS值都要大于这个最小MIS值），就会出现可能的频繁序列不被生成的问题。下面就是解决这个问题的MScandidate-gen-SPM（）函数：

Function MScandidate-gen-SPM（Fk-1）
1. 合并。将Fk-1和Fk-1合并生成候选序列。
2. If 一个序列s1的第一个项目的MIS值要比s1中的其他每个项目的MIS值小 then 如果满足：
    (1) 将s1的第二个项目和s2的最后一个项目删除之后得到的两个子序列是相同的
    (2) s2的最后一个项目的MIS值要比s1的第一个项目的MIS值大，则s1和s2合并。将s2的最后一个项目扩展到s1尾部生成候选序列：
        i.If s2的最后一个项目l是一个独立的元素 then 将{l}以一个单独元素的形式扩展到s1的末尾，生成候选序列c1。
            If s1的长度和基数都是2 AND s2的最后一个项目要比s1的最后一个项目大 then 将l加入到s1最后的元素的末尾生成候选序列c2
          else if s1的长度是2且基数为1 AND s2的最后一个项目要比s1最后一个项目大 or s1的长度大于2 then
            s2的最后一个项目加入到s1最后元素的末尾生成候选序列c2
3. else if一个序列s2最后一个项目的MIS值要比s2中的其他项目要小，then 上述方法相反
4. else 采用合并。
5. 剪枝。在一个k候选序列的(k-1)-子序列中，如果除了唯一的不包含具有最小的MIS值的项目的子序列之外，其他子序列都是非频繁的，则这个候选序列将被剪枝。

基于PrefixSpan算法的序列模式挖掘（深度优先搜索）

(1) 通过扫描一遍序列数据库，算法找出所有频繁项目

(2) 算法采取逐个在前缀后扩展项目的方式得到所有含有该前缀的序列模式。每个项目都有两种可能的扩展方式，一是将x加入前缀的最后一个项集，而是将x以单独元素的方式加入前缀。算法首先形成前缀-映射数据库，然后在这个数据库中找出所有属于这两种类型的情况。

从序列模式中产生规则

1. 序列规则（Sequential Rules，SR）：是指一个形如X -> Y 的蕴含关系，其中Y是一个序列，X是Y的真子序列（Proper Subsequnence）。

   一个序列规则X -> Y 在一个序列数据库S中的支持度为S中含有Y的序列比率。

   一个序列规则X -> Y 在S中的置信度为 S中既包含X又包含Y的的序列在只包含X的序列中的比例。

2. 标签序列规则（Label SR）：是指一个形如X -> Y 的蕴含关系，其中Y是一个序列，X是一个将Y中的一些项目替换成通配符*所得到的序列。

3. 分类序列规则（Class SR）：是指一个形如如下形式的蕴含关系：X -> y，其中X是一个序列，y ∈ Y 对于一个数据实例（s_i，y_i），如果X是s_i的一个子序列，则称（s_i，y_i）覆盖X  -> y；如果X是s_i的一个子序列且y_i=y则称（s_i，y_i）满足这个CSR。
   

转载于:https://my.oschina.net/shou1156226/blog/387564