Apriori算法实现

一、关联规则挖掘定义

        大多数关联规则挖掘算法通常采用的一种策略是，将关联规则挖掘任务分解为如下两个主要的子任务：
        ①频繁项集产生（Frequent Itemset Generation），其目标是发现满足最小支持度阈值的所有项集，这些项集称作频繁项集。
        ②规则的产生（Rule Generation），其目标是从上一步发现的频繁项集中提取所有高置信度的规则，这些规则称作强规则。

        关联分析的目标：发现频繁项集和由频繁项集产生强关联规则，这些规则必须大于或等于最小支持度和最小置信度。

二、Apriori算法

Apriori算法的原理

①通过限制候选产生发现频发项集

1. 扫描数据集，得到所有出现过的数据，作为候选1项集
2. 挖掘频繁k项集
           扫描计算候选k项集的支持度,剪枝去掉候选k项集中支持度低于最小支持度α的数据集，得到频繁k项集。如果频繁k项集为空，则返回频繁k-1项集的集合作为算法结果，算法结束。最后基于频繁k项集，链接生成候选k+1项集
3. 利用步骤2，迭代得到k=k+1项集结果

②由频繁项集产生关联规则
产生关规则的过程如下：

1. 对于每个频繁项集I，产生I的所有非空子集
2. 对于I的每个非空子集s，如果support(l)/support(s) ≥min_conf,则输出规则“s(l-s)”。其中，min_conf是最小置信度阈值。

• 支持度(support)：support(A->B) = P(A∪B)，表示A和B同时出现的概率。
• 置信度(confidence)：Confidence(A->B)=support(A∪B) / support(A)，表示A和B同时出现的概率占A出现概率的比值。

Apriori算法的重要性质

性质1：频繁项集的子集必为频繁项集
如果{B，C}是频繁的，那么{B}，{C}也一定是频繁的

性质2：非频繁项集的超集一定是非频繁的
如果{A, B}是非频繁的，那么{A, B, C}，{A, B, C, D}也一定是频繁的

三、实现算法，并进行调试运行

        Apriori算法，用于挖掘频繁项集和关联规则。通过生成逐渐增加大小的候选项集来工作，从单个项开始并组合它们以形成更大的项集。然后，算法计算每个候选项集的支持度，并仅保留满足最小支持阈值的那些项集。从这些频繁项集中，算法通过考虑每个项集的所有可能子集并计算其置信度来生成关联规则，只有满足最小置信阈值的规则才会被输出。

• 参数:
  • transactions (list): 事务数据，每一行表示一个事务，事务中的项用列表表示
  • min_support (float): 最小支持度阈值
  • min_confidence (float): 最小置信度阈值
• 返回值:
  • frequent_itemsets (dict): 频繁项集和对应的支持度，键为项集的元组，值为支持度
  • rules (list): 关联规则，每一条规则表示为一个元组 (X, Y)，其中X为前项集合，Y为后项集合

代码：

# 导入必要的库
from itertools import combinations

# 定义Apriori算法函数
def apriori(transactions, min_support, min_confidence):
    """
    Apriori算法实现，用于挖掘频繁项集和关联规则

    参数:
    transactions (list): 事务数据，每一行表示一个事务，事务中的项用列表表示
    min_support (float): 最小支持度阈值
    min_confidence (float): 最小置信度阈值

    返回:
    frequent_itemsets (dict): 频繁项集和对应的支持度，键为项集的元组，值为支持度
    rules (list): 关联规则，每一条规则表示为一个元组 (X, Y)，其中X为前项集合，Y为后项集合
    """

    # 统计每个项的支持度
    item_support = {}
    for transaction in transactions:
        for item in transaction:
            if item not in item_support:
                item_support[item] = 0
            item_support[item] += 1

    # 计算总事务数
    total_transactions = len(transactions)

    # 计算频繁项集
    frequent_itemsets = {}
    for item, support in item_support.items():
        if support / total_transactions >= min_support:
            frequent_itemsets[(item,)] = support / total_transactions

    # 生成候选项集并迭代生成频繁项集
    k = 2
    while True:
        candidates = set()
        for itemset in frequent_itemsets.keys():
            for item in itemset:
                candidates.add(item)

        # 生成候选项集
        candidates = list(combinations(candidates, k))

        # 统计候选项集的支持度
        candidate_support = {}
        for transaction in transactions:
            for candidate in candidates:
                if set(candidate).issubset(set(transaction)):
                    if candidate not in candidate_support:
                        candidate_support[candidate] = 0
                    candidate_support[candidate] += 1

        # 更新频繁项集
        frequent_itemsets_k = {}
        for candidate, support in candidate_support.items():
            if support / total_transactions >= min_support:
                frequent_itemsets_k[candidate] = support / total_transactions

        # 如果没有频繁项集则停止迭代
        if not frequent_itemsets_k:
            break

        frequent_itemsets.update(frequent_itemsets_k)
        k += 1

    # 生成关联规则
    rules = []
    for itemset in frequent_itemsets.keys():
        if len(itemset) >= 2:
            for i in range(1, len(itemset)):
                for combination in combinations(itemset, i):
                    X = combination
                    Y = tuple(set(itemset) - set(combination))
                    confidence = frequent_itemsets[itemset] / frequent_itemsets[X]
                    if confidence >= min_confidence:
                        rules.append((X, Y, frequent_itemsets[itemset], confidence))

    return frequent_itemsets, rules


# 示例数据集
transactions = [    ['A', 'B', 'C'],
    ['B', 'C', 'D'],
    ['A', 'C', 'D'],
    ['A', 'C', 'E'],
    ['B', 'D', 'E']
]

# 设置最小支持度和最小置信度阈值
min_support = 0.3
min_confidence = 0.6

# 调用Apriori算法函数
frequent_itemsets, rules = apriori(transactions, min_support, min_confidence)

# 输出频繁项集和支持度
print("频繁项集和对应的支持度：")
for itemset, support in frequent_itemsets.items():
    print("{}: Support = {:.2f}".format(itemset, support))

# 输出关联规则和置信度
print("\n关联规则和置信度：")
for X, Y, support, confidence in rules:
    print("{} => {}: Support = {:.2f}, Confidence = {:.2f}".format(X, Y, support, confidence))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

数据集：

最小支持度和最小置信度阈值：

运行结果：

四、结合样例（数据集）对算法进行分析

        本文用的Apriori算法是一种在数据集中查找频繁项集和挖掘关联规则的算法。代码接受一个数据集和两个阈值参数：最小支持度和最小置信度。它输出频繁项集及其对应的支持值，以及发现的关联规则及其支持和置信度值。

        Apriori算法通过生成逐渐增加大小的候选项集来工作，从单个项开始并组合它们以形成更大的项集。然后，算法计算每个候选项集的支持度，并仅保留满足最小支持阈值的那些项集。从这些频繁项集中，算法通过考虑每个项集的所有可能子集并计算其置信度来生成关联规则，只有满足最小置信阈值的规则才会被输出。

        具体来说，对于每个事务中出现的项，我们记录它们出现的次数，并计算它们的支持度。支持度是指包含该项的事务占总事务数的比例。然后，根据用户设置的最小支持度阈值，生成初始的频繁项集。这些频繁项集只包含单个项，并且它们的支持度均大于等于最小支持度阈值。接着，从2开始迭代生成更高阶的候选项集，统计它们的支持度。如果候选项集的支持度不足最小支持度阈值，则该候选项集被过滤掉。否则，将其加入到新一轮的频繁项集中。重复此过程直到没有更多的频繁项集可以生成为止。

        在得到频繁项集之后，我们对每个频繁项集找到其中所有可能的项组合，将它们分成前项集和后项集。接着，计算每个关联规则的支持度和置信度。具体来说，对于每条关联规则，我们先计算它的支持度，即该规则的前项集和后项集同时出现的事务占总事务数的比例。然后，我们根据支持度计算置信度，即该规则中后项集出现的条件下，前项集也出现的概率。如果该关联规则的置信度不足最小置信度阈值，则该规则被过滤掉。否则，将其加入到最终的关联规则集合中。

        在示例数据集中，我们首先统计了每个项的支持度，并根据最小支持度阈值得到了初始的频繁项集。然后，通过迭代生成候选项集和支持度计算，得到了更高阶的频繁项集。接着，对于每个频繁项集，我们找到其中所有可能的项组合，计算它们的支持度和置信度。最终，我们根据最小置信度阈值筛选出符合要求的关联规则，并输出了频繁项集和关联规则的结果。具体过程如下图所示。

数据集频繁项集的挖掘过程以及对应的支持度的计算如下：

数据集关联规则和置信度的计算如下：

小结

        Apriori算法的核心思想是基于频繁项集理论的递归方法，采用逐层搜索的迭代方法挖掘出在目标事务数据库中所有频繁项集，直至找到最高阶频繁项集即止，最后通过对获得的频繁项集进行计算得到强关联规则。

        Apriori算法通过生成逐渐增加大小的候选项集来工作，从单个项开始并组合它们以形成更大的项集。然后，算法计算每个候选项集的支持度，并仅保留满足最小支持阈值的那些项集。从这些频繁项集中，算法通过考虑每个项集的所有可能子集并计算其置信度来生成关联规则，只有满足最小置信阈值的规则才会被输出。而关联分析的目标或者说是关键在于：发现频繁项集和由频繁项集产生强关联规则，这些规则必须大于或等于最小支持度和最小置信度。

        Aprioi算法采用逐层搜索的迭代方法，算法简单明了，没有复杂的理论推导，也易于实现。但我们都知道事物都有双面性，Aprioi算法适合稀疏数据集，适合事务数据库的关联规则挖掘。但是缺点也很明显，它可能产生庞大的候选集，而且算法需多次遍历数据集，算法效率低，耗时。