以超市销售数据为例子，提取关联规则的最大困难在于当存在很多商品时，可能的商品的组合的数目会达到一种令人望而却步的程度。因而各种关联规则分析的算法从不同方面入手，以减少可能的搜索空间的大小以及减少扫描数据的次数。Apriori算法时经典的挖掘频繁项集的算法，第一次实现了再大数据集上可行的关联规则提取，其核心思想是通过连接产生候选项与其支持度，然后通过剪枝生成频繁项集。

1.关联规则的一般方式

项集A，B同时发生的概率称为关联规则的支持度 Support(A=>B) = P(AUB)

项集合A发生，则项集B发生的概率为关联规则的置信度 Confidence(A=>B) = P(B|A)

2.最小支持度与最小置信度

最小支持度使用户或专家定义的衡量支持度的一个阈值，表示项目集在统计意义上最低的重要性；最小置信度是用户或专家定义的衡量置信度的一个阈值，表示关联规则是的最低可靠性。同时满足最小支持度阈值和最小置信度和最小置信阈值的规则称强规则。

3.项集

项集是项的集合，包含K个项的集合，如集合{牛奶，麦片，糖}是一个3项集合。项集出现的频率是所有包含项集的事务计数，又称作绝对支持度或支持度计数。如果项集I的相对支持度满足预定义的最小支持度阈值，则I是频繁项集。

4.支持度计数

项集A的支持度计数是事务数据集中包含项集A的事务个数，简称为项集的频率或者计数。

已知项集的支持度计数，则规则A=>B的支持度和置信度很容易从所有事务计数，项集A和项集AUB的支持度计数推出：

也就是说，一旦得到所有事务个数，A，B和A并B的支持度计数，就可以导出对应的关联规则A=>B和B=>A，并可以检查该规则是否是强规则。

5.Apriori算法：使用候选项产生频繁项集

Apriori算法的主要思想是找出存在于事务数据集中的最大的频繁项集，在利用得到的最大频繁项集与预先设定的最小置信度阈值生成强关联规则。

（1）Apriori性质

频繁项集的所有非空子集也必须是频繁项集。根据该性质可以得出：向不是频繁项集I的项集中添加事务A，新的项集I U A一定也不是频繁项集。

（2）Apriori算法实现的两个过程如下

1）找出所有频繁项集。对给定的最小支持度阈值，分别对1项候选集C1，剔除小于该阈值的项集得到1项频繁集L1；下一步由L1自身连接产生2项候选集C2，保留C2中满足约束条件的项集得到2项频繁集，记为L2；再下一步由L2与L3连接产生3项候选集C3，保留C2中满足约束条件对的项集得到3项频繁数据集，记为L3......这样循环下去，得到最大频繁项集Lk。

剪枝步：

剪枝步紧接着连接步，在产生候选项Ck的过程中起到减少搜索空间的目的。由于Ck是Lk-1 与 L1连接产生的，根据Apriori的性质频繁项集的所有非空子集也必须是频繁项集，所以不满足该性质的项集不会存在于Ck中，该过程就是剪枝。

2）由频繁项集产生强关联规则：由过程1）可知超过预定的最小支持阈值的项集已被剔除，如果剩下这些规则又满足了预定最小置信阈值，那么就产生了强关联规则。

6.python代码实现

数据集：

在这里a,b,c,d,e可以看做是不同的商品，每一行代表客户所购买的商品的信息。

cal_apiori.py:

import pandas as pd
import os
from apriori import *

basedir = os.path.dirname(__file__)
inputfile = os.path.join(basedir, './data/menu_orders.xls')
outputfile = os.path.join(basedir, './data/apiori_rules.xls')

data = pd.read_excel(inputfile, header = None) # 读取数据

print(u'\n转换 原始数据至0-1矩阵....')
ct = lambda x : pd.Series(1, index=x[pd.notnull(x)]) # 转换0-1矩阵的过渡函数
b =  map(ct, data.as_matrix()) # 用map方式执行


data = pd.DataFrame(list(b)).fillna(0) # 实现矩阵转换，空值用0填充
print(u'\n转换完毕.')
del b # 删除中间变量，节省内存
 
support = 0.2 # 最小支持度
confidence = 0.5 # 最小置信度
ms = "---" # 连接符,默认'--',用来区分不同的元素,如A--B,许可要保证原始表格中不含有该字符

print(data, support, confidence)

"""
    data的数据结构:
            a    c    e    b    d
        0  1.0  1.0  1.0  0.0  0.0
        1  0.0  0.0  0.0  1.0  1.0
        2  0.0  1.0  0.0  1.0  0.0
        3  1.0  1.0  0.0  1.0  1.0
        4  1.0  0.0  0.0  1.0  0.0
        5  0.0  1.0  0.0  1.0  0.0
        6  1.0  0.0  0.0  1.0  0.0
        7  1.0  1.0  1.0  1.0  0.0
        8  1.0  1.0  0.0  1.0  0.0
    support: 最小支持度阈值
    confidence: 最小置信度阈值
    ms: 连接符，用来区分不同的元素，如A---B,需要保证原始表格中不含有这种字符
"""
find_rule(data, support, confidence, ms).to_excel(outputfile) # 保存结果复制

apriori.py

import pandas as pd


def connect_string(x, ms):
    """
    定义连接函数,用于实现从L_{k-1} 到 C_k 的连接
    """
    x = list(map(lambda i: sorted(i.split(ms)), x)) # 频繁项集的个数
    print(x)
    l = len(x[0]) # 每个平凡项集合，属性的个数
    r = []
    for i in range(len(x)):
        for j in range(i, len(x)): # 这里可以看成是两个个二维表连接
            # 在进行连接的操作的时候，首先对其中的属性作了排序，所以这里只需要判断前面(l-1)个【多个元素比较】是否相同，如果相同&&最后一个元素不相同=>则进行连接操作
            if x[i][:l - 1] == x[j][:l - 1] and x[i][l - 1] != x[j][l - 1]:
                r.append(x[i][:l - 1] + sorted([x[j][l - 1], x[i][l - 1]])) # add:[[前l-1个元素]+sorted([原来的第l个元素+新增加的元素])]
    return r


def find_rule(d, support, confidence, ms=u'--'):
    """
    寻找关联规则的函数
    """
    result = pd.DataFrame(index=['support', 'confidence']) # 定义输出结果
    support_series = 1.0 * d.sum() / len(d) # 支持度序列(求每一列的的支持度)
    column = list(support_series[support_series > support].index) # 初步支持度筛选（大于最小支持度）,同时转化为list列表
    k = 0

    while len(column) > 1:
        k = k + 1 # 累加第几次
        print(u'\n正在进行第%s次搜索...' % k)

        column = connect_string(column, ms) # 使用连接函数进行连接（column:大于最小支持度的列的集合，ms:切割字符串）

        print(u'数目: %s...' % len(column))

        sf = lambda i: d[i].prod(axis = 1, numeric_only = True) # 新一批支持度的计算函数

        # 创建连接数据
        d_2 = pd.DataFrame(list(map(sf, column)), index=[ms.join(i) for i in column]).T 
        
        support_series_2 = 1.0 * d_2[[ms.join(i) for i in column]].sum() / len(d) # 计算连接后的支持度
        column = list(support_series_2[support_series_2 > support].index) # 新一轮支持度筛选
        support_series = support_series.append(support_series_2)
        column2 = []

        for i in column: # 遍历可能的推理, 如{A, B, C} 究竟是A+B-->C 还是 B+C-->A 还是C+A-->B
            i = i.split(ms)
            for j in range(len(i)):
                column2.append(i[:j] + i[j+1:] + i[j: j+1]) # 这三个位置分别为: (前j个元素不包括) + (后j+1个元素) --> (中间第j个元素)
        
        confidence_series = pd.Series(index=[ms.join(i) for i in column2]) # 定义置信度序列

        for i in column2: # 计算置信度序列 
            # 置信度 = support(a&b) / support(a) 其中这里a代表前件, b代表后件
            confidence_series[ms.join(i)] = support_series[ms.join(sorted(i))] / support_series[ms.join(i[:len(i) - 1])]

        for i in confidence_series[confidence_series > confidence].index: # 置信度筛选(筛选出置信度大于最小置信度阈值)
            result[i] = 0.0 # 清空
            result[i]['confidence'] = confidence_series[i] 
            result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))] 
        
    result = result.T.sort_values(['confidence', 'support'], ascending = False) # 结果整理输出
    print(u'\n 结果为:')
    print(result)

    return result复制

运行结果：