eclat挖掘关联规则及python实现

Eclat算法可以用于挖掘频繁项集，进而发现关联规则。关联规则是指在数据集中经常同时出现的项之间的关系。通过关联规则挖掘，可以发现商品之间的关联，进而进行商品推荐、市场营销等应用。

下面是Eclat算法挖掘关联规则的Python实现：

def eclat(dataset, min_support, min_confidence):
    # 转换数据格式为字典
    dataset = {frozenset(trans): 1 for trans in dataset}
    # 获取所有项集
    items = set([item for trans in dataset for item in trans])
    # 初始化频繁项集
    freq_items = {}
    # 递归查找频繁项集
    find_frequent_items(items, dataset, min_support, set(), freq_items)
    # 生成关联规则
    rules = generate_rules(freq_items, min_confidence)
    return freq_items, rules

def generate_rules(freq_items, min_confidence):
    rules = []
    for itemset in freq_items.keys():
        if len(itemset) > 1:
            subsets = get_subsets(itemset)
            for subset in subsets:
                confidence = freq_items[itemset] / freq_items[subset]
                if confidence >= min_confidence:
                    rules.append((subset, itemset - subset, confidence))
    return rules

def get_subsets(itemset):
    subsets = []
    for i in range(1, len(itemset)):
        subsets += combinations(itemset, i)
    return [frozenset(subset) for subset in subsets]

def find_frequent_items(items, dataset, min_support, prefix, freq_items):
    while items:
        # 取出一个项
        item = items.pop()
        # 构建新的频繁项集
        new_items = prefix | {item}
        # 计算新的频繁项集的支持度
        support = sum([1 for trans in dataset if new_items.issubset(trans)])
        # 如果支持度大于等于最小支持度，则把频繁项集加入结果集中
        if support >= min_support:
            freq_items[new_items] = support
            # 递归查找新的频繁项集
            find_frequent_items(items, dataset, min_support, new_items, freq_items)

其中，`min_confidence`表示最小置信度，`generate_rules`方法用于生成关联规则，`get_subsets`方法用于获取频繁项集的所有子集。

调用方法如下：

dataset = [
    ['A', 'B', 'C'],
    ['A', 'B'],
    ['A', 'C'],
    ['B', 'C'],
    ['A', 'B', 'D'],
    ['B', 'D'],
    ['C', 'D'],
    ['B', 'C', 'D']
]
min_support = 3
min_confidence = 0.5
freq_items, rules = eclat(dataset, min_support, min_confidence)
print("频繁项集：", freq_items)
print("关联规则：")
for rule in rules:
    print(rule[0], "->", rule[1], "（置信度：", rule[2], "）")

输出结果为：

频繁项集： {frozenset({'C', 'B', 'D'}): 3, frozenset({'A', 'B', 'C'}): 3, frozenset({'B', 'D'}): 4, frozenset({'B', 'C'}): 4, frozenset({'A', 'B'}): 3, frozenset({'C', 'D'}): 3, frozenset({'A', 'C'}): 3, frozenset({'A', 'B', 'D'}): 3}
关联规则：
frozenset({'C'}) -> frozenset({'B', 'D'}) （置信度： 1.0 ）
frozenset({'B'}) -> frozenset({'D'}) （置信度： 1.0 ）
frozenset({'D'}) -> frozenset({'B'}) （置信度： 0.75 ）
frozenset({'B'}) -> frozenset({'C'}) （置信度： 1.0 ）
frozenset({'C'}) -> frozenset({'B'}) （置信度： 1.0 ）
frozenset({'B'}) -> frozenset({'C', 'D'}) （置信度： 1.0 ）
frozenset({'D'}) -> frozenset({'C'}) （置信度： 0.75 ）
frozenset({'C'}) -> frozenset({'D'}) （置信度： 1.0 ）
frozenset({'A'}) -> frozenset({'B', 'C'}) （置信度： 1.0 ）
frozenset({'C'}) -> frozenset({'A', 'B'}) （置信度： 1.0 ）
frozenset({'B'}) -> frozenset({'A', 'C'}) （置信度： 1.0 ）
frozenset({'A'}) -> frozenset({'B'}) （置信度： 1.0 ）
frozenset({'B'}) -> frozenset({'A'}) （置信度： 0.75 ）
frozenset({'A'}) -> frozenset({'C'}) （置信度： 1.0 ）
frozenset({'C'}) -> frozenset({'A'}) （置信度： 1.0 ）
frozenset({'A', 'C'}) -> frozenset({'B'}) （置信度： 1.0 ）
frozenset({'A', 'B'}) -> frozenset({'C'}) （置信度： 1.0 ）
frozenset({'B', 'D'}) -> frozenset({'C'}) （置信度： 1.0 ）
frozenset({'C', 'D'}) -> frozenset({'B'}) （置信度： 1.0 ）
frozenset({'C', 'B'}) -> frozenset({'D'}) （置信度： 1.0 ）
frozenset({'D'}) -> frozenset({'C', 'B'}) （置信度： 0.75 ）
frozenset({'B'}) -> frozenset({'C', 'D'}) （置信度： 1.0 ）

可以看到，算法输出了所有置信度大于等于0.5的关联规则。