用Python写一个apriori算法计算关联规则

好的，以下是一个简单的 Python 实现：

def apriori(transactions, min_support, min_confidence):
    """
    transactions: 一个包含所有事务的列表，每个事务是一个集合
    min_support: 最小支持度
    min_confidence: 最小置信度
    """
    # 计算候选项集 C1（单个物品）
    item_counts = {}
    for transaction in transactions:
        for item in transaction:
            if item in item_counts:
                item_counts[item] += 1
            else:
                item_counts[item] = 1
    n = len(transactions)
    candidate_items = [(item, count/n) for item, count in item_counts.items()]
    frequent_items = [item for item, support in candidate_items if support >= min_support]
    frequent_sets = [frozenset([item]) for item in frequent_items]
    # 计算频繁项集
    k = 2
    while len(frequent_sets[k-2]) > 0:
        candidate_sets = generate_candidates(frequent_sets[k-2], k)
        item_counts = count_items(candidate_sets, transactions)
        candidate_items = [(item, count/n) for item, count in item_counts.items()]
        frequent_items = [item for item, support in candidate_items if support >= min_support]
        frequent_sets += [itemset for itemset in candidate_sets if itemset in frequent_items]
        k += 1
    # 计算关联规则
    rules = []
    for itemset in frequent_sets:
        for item in itemset:
            antecedent = frozenset([item])
            consequent = itemset - antecedent
            if len(consequent) > 0:
                confidence = count_items([itemset], transactions)[itemset] / count_items([antecedent], transactions)[antecedent]
                if confidence >= min_confidence:
                    rules.append((antecedent, consequent, confidence))
    return rules


def generate_candidates(itemsets, k):
    """
    生成候选项集 Ck
    """
    candidates = set()
    for itemset1 in itemsets:
        for itemset2 in itemsets:
            if len(itemset1.union(itemset2)) == k:
                candidates.add(itemset1.union(itemset2))
    return candidates


def count_items(itemsets, transactions):
    """
    计算项集在事务中出现的次数
    """
    item_counts = {}
    for transaction in transactions:
        for itemset in itemsets:
            if itemset.issubset(transaction):
                if itemset in item_counts:
                    item_counts[itemset] += 1
                else:
                    item_counts[itemset] = 1
    return item_counts

这个算法接受一个包含所有事务的列表（每个事务是一个集合）以及最小支持度和最小置信度作为参数，并返回一个关联规则的列表。