关联规则挖掘

一、基本概念

概念

关联规则挖掘(Association rules mining)

在数据集中找到各项数据之间的关联关系。

项目(Item)

ID Items bought
10 A,B,D
20 A,C,D
30 A,D,E

ID	Items bought
10	A,B,D
20	A,C,D
30	A,D,E

支持度(support)

项集 ${x,y\}$ 在总项集中出现的概率( $x, y$ 同时出现)
$Support(x\to y)=\frac{P(x,y)}{P(I)}=\frac{P(xUy)}{P(I)}$

置信度(Confidence)

当 $x$ 出现时， $y$ 也一起出现的概率，表示为 $x, y$ 同时出现的概率占 $x$ 出现的概率
$Confidence(x\to y)=P(y|x)=\frac{P(xy)}{P(x)}$

提升度(Lift)

$x, y$ 同时出现的频率，但是还需要再考虑二者各自出现的概率，从而表现出二者的相关性。提升度=1表示没有相关性(独立)，高于一正相关，低于一负相关。
$Lift(x\to y)=\frac{Confidence}{P(y)}=\frac{P(xy)}{P(x)P(y)}$

一般来说，我们评估一个规则是否合理，会设置一定的最小支持度或者最小置信度阈值，大于这个阈值的规则，我们认为是感兴趣的。

举个例子

ID	Items
1	A,B
2	A,B,C
3	A,D
4	A,B,C
5	B,C
6	B,D

这个表格中， $A$ 的出现次数为 $4$ ， $A B$ 的出现次数为 $3$ ，其支持度 $A\to B$ 为: $3 / 8$ ，而置信度 $A\to B$ 为 $3 / 4$ ，提升度为 $3 * 6 / (4 * 5)$ .

布尔型与数值型关联规则

布尔型一般只关注买没买，例如 $Apple\to Milk$
数值型一般还要关注数值属性，例如 $Apple\to 115元,Apple\to 100-105元$

一般来说，关联规则的挖掘可以看做以下两步的过程：

找出所有频繁项集，该项集的每一个出现的支持度计数都大于等于最小支持度阈值
由频繁项集产生强关联规则，即满足最小支持度和最小置信度的规则

由于第二步的开销远小于第一步，所有总体性能是由第一步决定的。例如：

一个长度为100的频繁项集，包含了
$C_{100}^1+C_{100}^2+...+C_{100}^{100}-1=1.27^{30}$
这么多个频繁项

二、频繁项集挖掘方法

1️⃣ Apriori算法

Apriori算法由Agrawal和Strikant在1994年提出，是布尔关联规则挖掘的原创性算法，通过限制候选产生发现频繁项集。Apriori算法使用一种称为逐层搜索的迭代方式，其中 $k$ 项集用于生成 $(k + 1)$ 项集。

Apriori算法假定频繁项集的所有非空子集都是频繁的，这是一个先验性质，可以进一步过滤掉很多项集。其算法的核心分为两步：剪枝和连接

连接步

通过 $L_{k-1}$ 与自身连接产生 $k$ 项候选集，Apriori算法假定事务或者项集中的项按照字典序排序，如果 $L_{k-1}$ 的元素可连接，那么要求他们的前 $k - 2$ 个项相同

剪枝步

每一次扫描，都会将候选集中的非频繁项集删除，因为他们的子项集必定是非频繁项集

关联规则

置信度
- $Confidence(A\to B)=\frac{Support(AUB)}{Support(A)}\ge minC$

由于规则由频繁项集产生，因此每个规则都自动地满足最小支持度。他们的支持度可以预先放在散列表中。

栗子

ID	Items
1	I1,I2,I5
2	I2,I4
3	I2,I3
4	I1,I2,I4
5	I1,I3
6	I2,I3
7	I1,I3
8	I1,I2,I3,I5
9	I1,I2,I3

最小支持度为40%

第一次迭代：

Items	Support
I1	6/9
I2	7/9
I3	6/9
I4	2/9
I5	2/9

此时，I4,I5小于最小支持度，应该被剪枝

剩下的集合为

Items	Support
I1	6/9
I2	7/9
I3	6/9

他们之间可以生成下一项：

Items	Support
I1,I2	4/9
I1,I3	4/9
I2,I3	4/9

没有需要剪枝的，再进行下一步

Items	Support
I1,I2,I3	1/9

并不算频繁规则，所以最后的频繁项集为：{I1,I2,I3,{I1,I2},{I2,I3},{I1,I2}}

然后是置信度方面，置信度的计算可以表示为：
$A\to B,Confidence=\frac{support(B|A)}{support(A)}$
说人话就是发生A的条件下，有多少次是带着B玩。

Apriori算法的挑战与改进

挑战

需要多次扫描数据库
产生大量候选集
工作乏味

改进

减少事务数据库扫描的传递次数
缩小候选集数量
改进对候选集的支持度统计

实现

import math
import numpy as np
from collections import defaultdict

d=np.array(["milk,water,juice","milk,water","milk,rice,water","water","tomato,juice","juice,cucumber"])

def Apriori(data,min_spport=2,min_confidence=0.5):

    FP=[]
    Data=[]
    # 初始化项集
    I=[]
    # 因为字符串不好做运算，所以我们映射成数组
    str2num=defaultdict(int)
    cnt=0

    for i in data:
        for j in i.split(","):
            if j not in str2num.keys():
                str2num[j]=cnt
                cnt+=1

    for i in data:
        t=[]
        for j in i.split(","):
            I.append(j)
            t.append(str2num[j])
        Data.append(set(t))
    I=[[i] for i in set(I)]

    def scan(setI):
        tem=defaultdict(int)
        for i in setI:
            for j in Data:
                # 做个映射
                for k in i:
                    if str2num[k] not in j:
                        break
                else:
                    tem[",".join(i)]+=1
        return [[i,j] for i,j in tem.items() if j>=min_spport]


    def comb(setI):
        # 记录
        FP.append(setI)
        # 按字典序排序
        I=[sorted([i[0]]) for i in setI]
        T=[]
        for i,v in enumerate(I):
            for j in I[i+1:]:
                if len(v)>1 and v[:-1]==j[:-1]:
                    T.append(v[:-1]+v[-1]+j[-1])
                elif len(v)==1:
                    T.append(v+j)

        return [set(i) for i in T]

    while 1:
        # 每次都需要扫描
        I=scan(I)
        # 这个I是已经进行剪枝后的了
        # 然后要进行连接步，要求前K-2项相同
        if I==[]:
            return FP
        I=comb(I)



print(Apriori(d))

2️⃣ Partition: Scan Database Only Twice

首次提出：

A. Savasere, E. Omiecinski, and S. Navathe. An efficient algorithm for mining association in large databases. In VLDB’95.

分区技术

将数据分为 $N$ 个小的区域
阶段一：在当前数据区内寻找并记录频繁项集
阶段二：整合所有子区域内的频繁项集，并扫描整个数据库

思想

任何数据集中的频繁项集，必须在至少一个子区域内频繁(很简单就可以推出，如果任一分区都不频繁，那么同时加起来后依旧是不频繁的 $\frac{\sum a}{\sum n}$ )

细节

每个分区都可以放入内存中
扫描数据库只有两次！降低I/O成本！
线性执行时间尺度
适合用于非常大规模的数据库
适用于并行/分布式计算系统

3️⃣ DHP: Reduce the Number of Candidates

首次提出

J. Park, M. Chen, and P. Yu. An effective hash-based algorithm for mining association rules. In SIGMOD’95

基于哈希思想的技术

当扫描事务以生成频繁的k项集时， $L_k$ 会为每个事务生成所有（k+1）项集
将所有（k+1）项集分成桶，增加桶计数
如果一个（k+1）项集桶计数低于min_sup，它必须从（k+1）候选项集中删除

思想

对应的哈希桶计数低于阈值的k项集不能频繁出现

在这里插入图片描述

4️⃣ DIC算法

基本思想：把数据库分成若干块，每一块都有一个开始点（start point）,在每一个开始点处都可以加入新的候选项集。一旦确定所有子集都是频繁的，就可以在任何起点添加新的候选项。

目的：减少数据库的查找次数

在这里插入图片描述

如上图所示，初始时，加入所有的一项集，然后扫描B1，得到一项集在B1中的支持度，选出频繁一项集组成的候选二项集，在B2的start point位置加入，然后扫描B2，给候选项集里的项集计数，然后再生成新的频繁项集，在B1的start point上加入。重复这个过程，直到没有新的频繁项集生成。

5️⃣频繁模式增长算法(Frequent Pattern Growth, FP-Growth)

优势

直接挖掘频繁项集，无须产生候选集和检查的过程

算法步骤

一、创建FP树

第一次扫描数据库时，导出频繁项的集合，并按照频繁项支持度计数进行降序排序。例如：

在这里插入图片描述

接着，再次扫描数据库，构建FP树。算法描述如下：

创建树的根节点，并为每个事务创建一个分支
- 沿着根节点向下生长，当节点存在当前分支时，共同前缀计数+1
- 当不存在当前节点，开辟一个新的节点
创建一个项表头，使得每项都能通过一个节点链得到它在树中的位置。

下面是FP树的生成实现

class FPTree:

    def __init__(self,name="NULL"):
        self.children=[]
        self.val={} # name:[val,loc]
        self.cnt=0
        self.n=self,name

    def growth(self,items):
        node=self
        for i in items:
            if i in node.val.keys():
                node.val[i][0]+=1
            else:
                node.val[i]=[1,node.cnt]
                node.cnt+=1
                node.children.append(FPTree(i))

            node = node.children[node.val[i][1]]

    def __str__(self):
        return str(self.n)

    def getFPTree(self):
        tem=list(zip(list(self.val.items()),self.children))
        while tem:
            a=tem.pop()
            print("Node: %s"%a[0][0],"val: %d"%a[0][1][0])
            tem+=list((zip(list(a[1].val.items()),a[1].children)))



A=FPTree()
A.growth(["a","b","c","d"])
A.growth(["a","b","c","e"])
A.getFPTree()

Node: a val: 2
Node: b val: 2
Node: c val: 2
Node: e val: 1
Node: d val: 1