Apriori 算法代码 python

以下是 Python 实现的 Apriori 算法的代码：

# 计算项集的支持度
def calculate_support(data, itemset, min_support):
    count = {}
    for transaction in data:
        for item in itemset:
            if item.issubset(transaction):
                count[item] = count.get(item, 0) + 1

    num_items = float(len(data))
    ret_list = []
    support_data = {}
    for key in count:
        support = count[key] / num_items
        if support >= min_support:
            ret_list.append(key)
        support_data[key] = support

    return ret_list, support_data

# 生成新的项集
def generate_new_itemset(itemset, k):
    ret_list = []
    num_items = len(itemset)
    for i in range(num_items):
        for j in range(i+1, num_items):
            l1 = list(itemset[i])[:k-2]
            l2 = list(itemset[j])[:k-2]
            l1.sort()
            l2.sort()
            if l1 == l2:
                ret_list.append(itemset[i] | itemset[j])

    return ret_list

# Apriori 算法主函数
def apriori(data, min_support=0.5):
    itemset, support_data = calculate_support(data, [frozenset([item]) for item in data], min_support)
    all_itemset = [itemset]
    k = 2
    while len(itemset) > 0:
        itemset = generate_new_itemset(itemset, k)
        new_itemset, new_support_data = calculate_support(data, itemset, min_support)
        support_data.update(new_support_data)
        itemset = new_itemset
        all_itemset.append(itemset)
        k += 1

    return all_itemset, support_data

其中，`data` 是一个包含多个事务的列表，每个事务是一个集合。`min_support` 是最小支持度阈值，用于筛选频繁项集。

在函数中，首先使用 `calculate_support()` 函数计算所有单个项的支持度，并且根据 `min_support` 筛选出频繁项集。然后，使用 `generate_new_itemset()` 函数生成新的项集，直到没有新的频繁项集产生为止。最后，返回所有的频繁项集及其支持度。

可以通过以下代码调用 Apriori 算法：

data = [
    {'A', 'B', 'C', 'E'},
    {'B', 'E'},
    {'C', 'D', 'E'},
    {'A', 'C', 'D'},
    {'A', 'C', 'E'}
]
all_itemset, support_data = apriori(data, min_support=0.4)
print(all_itemset)
print(support_data)

输出的结果包含所有的频繁项集及其支持度。