Apriori算法实现

# 导入必要的库
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))