复杂结构数据挖掘（三）关联规则挖掘实验

目录

[1. 数据集导入观察](#1. 数据集导入观察)

[2. Apriori算法、FP-Growth算法 使用方式](#2. Apriori算法、FP-Growth算法 使用方式)

[3. 朴素 brute-force](#3. 朴素 brute-force)

[4. grid_search 参数比较 + 三种算法比较](#4. grid_search 参数比较 + 三种算法比较)

[5. main 函数 与 报告生成](#5. main 函数 与 报告生成)

[6. 实验结果总结](#6. 实验结果总结)

---

-- 通过调整不同级别的支持度与置信度 ，比较 Apriori 算法、FP-Growth 算法以及一种进行穷举搜索的基准方法。

比较维度包括：生成的频繁项集数量、规则挖掘所用的存储空间、计算成本

-- 发现一些有趣的关联规则，并就这些规则所揭示的洞察进行讨论。

1. 数据集导入观察

表格读入&信息查看

import pandas as pd

# 加载数据集
df = pd.read_csv('Groceries.csv')

print('数据基本信息：')
df.info()

# 查看数据集行数和列数
rows, columns = df.shape

print(df.head().to_csv(sep='\t', na_rep='nan'))

item列数据 拆分为单项，并从大到小排序。

from collections import Counter

# 提取物品并统计
all_items = []
for item_str in df['items']:
    # 去除大括号，按逗号分割
    items = item_str.strip('{}').split(',')
    all_items.extend([item.strip() for item in items])

# 统计词频
item_counts = dict(Counter(all_items))

sorted_item_counts = dict(sorted(item_counts.items(), key=lambda x: x[1], reverse=True))

# 输出结果
sorted_item_counts

{'whole milk': 2513, 'other vegetables': 1903, 'rolls/buns': 1809, 'soda': 1715,

'yogurt': 1372, 'bottled water': 1087 ......}

2. Apriori算法、FP-Growth算法 使用方式

apriori 样例

fpgrowth 样例

rules 格式： A -> B 以及置信度 confidence。

（不输出支持度，因为支持度作为一个是否热门的阈值，关联性重点由置信度）

# pip install apriori_python
from apriori_python import apriori
itemSetList = [['eggs', 'bacon', 'soup'],
                ['eggs', 'bacon', 'apple'],
                ['soup', 'bacon', 'banana']]
freqItemSet, rules = apriori(itemSetList, minSup=0.5, minConf=0.5)
print(freqItemSet, rules)

# 输出频繁项 [{'eggs'}, {'eggs', 'bacon'}, {'soup'}, {'bacon', 'soup'}, {'bacon'}]
# 输出 P(Y|X) 置信度
# [[{'bacon'}, {'eggs'}, 0.6666], [{'bacon'}, {'soup'}, 0.6666], [{'eggs'}, {'bacon'}, 1.0], [{'soup'}, {'bacon'}, 1.0]]

# pip install fpgrowth_py
from fpgrowth_py import fpgrowth
itemSetList = [['eggs', 'bacon', 'soup'],
                ['eggs', 'bacon', 'apple'],
                ['soup', 'bacon', 'banana']]
freqItemSet, rules = fpgrowth(itemSetList, minSupRatio=0.5, minConf=0.5)
print(freqItemSet, rules)

对数据集初步用 fp_growth

0.074支持率阈值时，{'whole milk'}, {'other vegetables'} 互为关联。

from fpgrowth_py import fpgrowth
import pandas as pd

# 加载数据集
df = pd.read_csv('Groceries.csv')

# 提取物品
all_items = []
for item_str in df['items']:
    # 去除大括号，按逗号分割
    items = item_str.strip('{}').split(',')
    all_items.extend([[item.strip() for item in items]])

freqItemSet, rules = fpgrowth(all_items, minSupRatio=0.074, minConf=0)
print(freqItemSet)
print(rules)

\[{'whole milk'}, {'other vegetables'}, 0.293\], \[{'other vegetables'}, {'whole milk'}, 0.387\]

把 whole milk 记为 A，other vegetables 记为 B。

P(B|A) = 0.293 > 0.1935； P(A|B) = 0.387 > 0.256 均为促进作用。

3. 朴素 brute-force

1. 筛出频繁单项

def brute_force_bitset(transactions: List[List[Any]], minSupRatio: float, minConf: float):

    num_transactions = len(transactions)

    # Step 1: 统计单项支持度并按 minSupRatio 过滤
    # 使用向上取整来与常见库语义对齐（支持度 >= minSupRatio）
    min_support_count = max(1, math.ceil(minSupRatio * num_transactions))
    item_count: Dict[Any, int] = {}
    for tx in transactions:
        # 去重防止同一事务重复计数同一物品
        for item in set(tx):
            item_count[item] = item_count.get(item, 0) + 1

    # 筛选出频繁单项（达到最小支持度的物品）
    kept_items: List[Any] = sorted([it for it, c in item_count.items() if c >= min_support_count])
    if not kept_items:
        return [], []  # 如果没有频繁单项，直接返回空结果

2. 每个单项出现在哪些 transaction -> 交集支持度

每个单项 用长为 len(transaction) 的二进制表示出现在哪些小票上，多项就是与运算，"1"的个数。

因为前四名的商品出现频率 2513*1903*1809*1715/9835^4 = 0.0016

支持率不低于 0.0016时频繁项集只考虑大小为1、2、3.

    # Step 2: 只对保留的频繁单项建立索引与位集编码
    item_to_index: Dict[Any, int] = {item: idx for idx, item in enumerate(kept_items)}
    index_to_item: List[Any] = kept_items
    # 初始化位集列表，每个物品对应一个位集
    item_bitsets: List[int] = [0] * len(kept_items)
    for tx_idx, tx in enumerate(transactions):
        bit = 1 << tx_idx  # 为每个事务创建一个位掩码
        for item in tx:
            idx = item_to_index.get(item)
            if idx is not None:  # 只处理频繁物品
                item_bitsets[idx] |= bit  # 在位集中设置对应位

    # 用于缓存频繁项集的支持度计数
    freq_support_count: Dict[FrozenSet[int], int] = {}

    # 所有频繁单项的索引列表
    all_indices = list(range(len(kept_items)))

    # Step 3: 按项集大小枚举所有可能的组合
    # 从1项集开始，逐步增加到最大项集大小
    for k in range(1, 4):
        # 枚举所有k项组合
        for combo in itertools.combinations(all_indices, k):
            # 通过位集交集计算共同支持的事务
            bits = (1 << num_transactions) - 1  # 初始化为全1掩码，表示所有事务
            for idx in combo:
                bits &= item_bitsets[idx]  # 逐项求交集

            # '1'的数量支持度计数
            support_count = bits.bit_count()
            # 检查是否达到最小支持度比例（添加小量避免浮点误差）
            if (support_count / num_transactions) + 1e-12 >= minSupRatio:
                freq_support_count[frozenset(combo)] = support_count

3. 关联规则生成。2~3项的频繁项集，拆成两部分，算条件概率。

在上一步提前存了 每个频繁项集支持度大小。

    # Step 4: 关联规则生成
    rules: List[Tuple[Tuple[FrozenSet[Any], FrozenSet[Any]], float, float, float]] = []
    # 预计算所有频繁项集的支持度比例，用于快速查找
    idx_support_ratio: Dict[FrozenSet[int], float] = {
        idx_set: supp / num_transactions for idx_set, supp in freq_support_count.items()
    }

    # 遍历所有频繁项集（至少包含2个物品的项集才能生成规则）
    for idx_set, supp_ratio_union in idx_support_ratio.items():
        if len(idx_set) < 2:
            continue  # 单项集无法生成关联规则

        idx_list = list(idx_set)
        # 枚举所有非空真子集作为规则前件A
        for r in range(1, len(idx_list)):  # r从1到len-1，确保前后件都不为空
            for lhs_indices in itertools.combinations(idx_list, r):
                lhs = frozenset(lhs_indices)  # 规则前件A
                rhs = idx_set - lhs  # 规则后件B

                supp_lhs = idx_support_ratio[lhs]
                supp_rhs = idx_support_ratio[rhs]

                # 计算置信度 = P(B|A) = support(A∪B) / support(A)
                confidence = supp_ratio_union / supp_lhs
                if confidence + 1e-12 < minConf:  # 添加小量避免浮点误差
                    continue  # 置信度不达标，跳过

                # 计算提升度 = confidence / support(B) = P(B|A) / P(B)
                lift = confidence / supp_rhs if supp_rhs > 0 else 0.0

                # 将索引转换回原始物品
                lhs_items = frozenset(index_to_item[i] for i in lhs)
                rhs_items = frozenset(index_to_item[i] for i in rhs)

                # 添加到规则列表：((前件,后件), 支持度, 置信度, 提升度)
                rules.append(((lhs_items, rhs_items), supp_ratio_union, confidence, lift))

    return len(freq_support_count), rules

4. grid_search 参数比较 + 三种算法比较

初始化传入交易列表；

class AlgorithmComparator:
    """算法比较器"""

    def __init__(self, transactions):
        self.transactions = transactions
        self.results = []
        # 记录 Apriori 在不同支持度下的各项集大小计数
        self.apriori_k_rows = []

对给定支持度、置信度，跑三个算法，记录结果。

def grid_search(self, min_sup_ratios, min_confs):
    """执行网格搜索"""
    for min_sup_ratio in min_sup_ratios:
        for min_conf in min_confs:
            print(f"测试参数: min_sup_ratio={min_sup_ratio}, min_conf={min_conf}")

            # 测试FP-Growth算法
            fp_growth_result = self.test_algorithm('fpgrowth', min_sup_ratio, min_conf)

            # 测试Apriori算法
            apriori_result = self.test_algorithm('apriori', min_sup_ratio, min_conf)

            # 测试优化穷举（位集）算法
            bruteforce_result = self.test_algorithm('bruteforce', min_sup_ratio, min_conf)

            # 保存结果
            result = {
                'min_sup_ratio': min_sup_ratio,
                'min_conf': min_conf,
                'fp_growth': fp_growth_result,
                'apriori': apriori_result,
                'bruteforce': bruteforce_result
            }
            self.results.append(result)

每个算法需要传出来记录的参数：

algorithm、freq、rules、time、memory

tracemalloc 记录空间 、time.perf_counter() 计时

def test_algorithm(self, algorithm: str, min_sup_ratio: float, min_conf: float):

    # 1. 预处理：清理现有垃圾
    gc.collect()

    # 2. 开始内存追踪
    tracemalloc.start()
    start_time = time.perf_counter()

    try:
        if algorithm == 'fpgrowth':
            freq_item_set, rules = fpgrowth(self.transactions, minSupRatio=min_sup_ratio, minConf=min_conf)
            freq_itemsets_count = len(freq_item_set) if freq_item_set else 0
            rules_count = len(rules) if rules else 0
            print(f"FP-Growth 生成频繁项集数: {freq_itemsets_count}, 规则数: {rules_count}")

        elif algorithm == 'apriori':
            freq_item_set, rules = apriori(self.transactions, minSup=min_sup_ratio, minConf=min_conf)
            freq_itemsets_count = sum(len(itemsets) for itemsets in freq_item_set.values())
            rules_count = len(rules) if rules else 0

            # 收集Apriori特有的k项集数据
            for k, itemsets in freq_item_set.items():
                try:
                    k_int = int(k)
                except Exception:
                    k_int = k
                self.apriori_k_rows.append(
                    {'min_sup_ratio': min_sup_ratio, 'k': k_int, 'count': int(len(itemsets))})
            print(f"Apriori 生成频繁项集数: {freq_itemsets_count}, 规则数: {rules_count}")

        elif algorithm == 'bruteforce':
            freq_itemsets_count, rules = brute_force_bitset(self.transactions, minSupRatio=min_sup_ratio,
                                                            minConf=min_conf)
            rules_count = len(rules) if rules else 0
            print(f"BruteForce-Bitset 生成频繁项集数: {freq_itemsets_count}, 规则数: {rules_count}")

        else:
            raise ValueError(f"不支持的算法: {algorithm}")

    finally:
        # 计算执行时间和内存使用
        execution_time = time.perf_counter() - start_time
        current_memory, peak_memory = tracemalloc.get_traced_memory()
        tracemalloc.stop()
    return {
        'algorithm': algorithm,
        'freq_itemsets_count': freq_itemsets_count,
        'rules_count': rules_count,
        'execution_time': execution_time,
        'memory_usage': peak_memory / 1024 / 1024,  # 转换为MB
    }

5. main 函数 与 报告生成

原数据每个交易中，不同物品用逗号间隔，将其转换为列表形式。

（适合于apriori和fp-growth的输入）

def main():
    # 加载数据集
    df = pd.read_csv('Groceries.csv')

    # 提取物品
    all_items = []
    for item_str in df['items']:
        items = item_str.strip('{}').split(',')
        all_items.append([item.strip() for item in items])

    print(f"数据集大小: {len(all_items)} 条交易记录")
    print(f"示例交易: {all_items[:3]}")

不同的参数 grid_search 并生成

1. k-频繁项集数量 2. 三种算法结果比较

# 创建比较器
comparator = AlgorithmComparator(all_items)

# 定义参数网格
min_sup_ratios = [0.01, 0.02, 0.05, 0.074, 0.075]
min_confs = [0.0, 0.1, 0.25, 0.4, 0.55]

# 执行网格搜索
comparator.grid_search(min_sup_ratios, min_confs)

# 生成报告表格
report_df = comparator.generate_report()

# 保存到CSV文件
report_df.to_csv('algorithm_comparison_results.csv', index=False)

# 生成 Apriori 的各k计数表并保存
apriori_k_df = comparator.generate_apriori_k_report()
apriori_k_df.to_csv('apriori_k_size_breakdown.csv', index=False)

生成结果表格：

def generate_report(self):
    """生成结果表格"""
    report_data = []

    for result in self.results:
        row = {
            'min_sup_ratio': result['min_sup_ratio'],
            'min_conf': result['min_conf'],

            # FP-Growth 结果
            'FP_Growth_Freq_Itemsets': result['fp_growth']['freq_itemsets_count'],
            'FP_Growth_Rules': result['fp_growth']['rules_count'],
            'FP_Growth_Time(s)': round(result['fp_growth']['execution_time'], 4),
            'FP_Growth_Memory(MB)': round(result['fp_growth']['memory_usage'], 2),

            # Apriori 结果
            'Apriori_Freq_Itemsets': result['apriori']['freq_itemsets_count'],
            'Apriori_Rules': result['apriori']['rules_count'],
            'Apriori_Time(s)': round(result['apriori']['execution_time'], 4),
            'Apriori_Memory(MB)': round(result['apriori']['memory_usage'], 2),

            # BruteForce-Bitset 结果
            'BF_Freq_Itemsets': result['bruteforce']['freq_itemsets_count'],
            'BF_Rules': result['bruteforce']['rules_count'],
            'BF_Time(s)': round(result['bruteforce']['execution_time'], 4),
            'BF_Memory(MB)': round(result['bruteforce']['memory_usage'], 2),
        }
        report_data.append(row)

    # 创建DataFrame
    report_df = pd.DataFrame(report_data)

    # 按支持度和置信度排序
    report_df = report_df.sort_values(['min_sup_ratio', 'min_conf']).reset_index(drop=True)

    return report_df

def generate_apriori_k_report(self):
    return pd.DataFrame(self.apriori_k_rows)

6. 实验结果总结

1. 如何计时？

末 - 初 不行，因为中间会有空间的调度和释放。

中间采样找峰值不行，因为如果算法本身执行实际时间很短，没来得及采样。

**tracemalloc()**追踪 peak_memory。但是会影响运行速度，所以时间要分开记录。

2. 热门商品的核心关联模式

全脂牛奶（出现频率：2513次，占25.5%的交易）和其他蔬菜（出现频率：1903次，占19.3%的交易）作为数据集中最频繁的两个商品，在关联规则中占据主导地位。在置信度排名前31的规则中，规则的后件均为全脂牛奶或其他蔬菜。

3. 统计假象识别

需要谨慎区分真实的商业洞察与统计假象：

• 假关联案例：{soda} → {whole milk} (22.97%)的置信度低于 全脂牛奶本身的支持度(25.5%)，这表明该规则更多反映的是全脂牛奶的普遍性而非真实的关联关系。

• 基础商品效应：许多单商品指向全脂牛奶或其他蔬菜的高置信度规则，主要源于这两种商品在家用食材购买时，本身的高频次。

4. 有意义的关联规则识别 （排名较高，条件概率相对单项翻倍）

1）早餐组合模式：

• {sausage} → {rolls/buns} (32.58%)

2）膳食搭配模式：

• {whole milk, other vegetables} → {root vegetables} (30.98%)

• {whole milk, other vegetables} → {yogurt} (29.76%)

3）乳制品组合模式：

• {whipped/sour cream} → {yogurt} (28.94%)

4）水果组合模式：

• {tropical fruit} → {yogurt} (27.91%)

• {pip fruit} → {tropical fruit} (27.02%)

5. 算法效率评估

由于观察到 0.01 支持度下，只有98个单项，并且四项集的概率一定小于0.0016，所以应用位运算的枚举法效率很高。

FP-growth 相对于 Apriori算法 进行空间换时间。