复杂结构数据挖掘（三）关联规则挖掘实验
目录
1. 数据集导入观察
2. Apriori算法、FP-Growth算法 使用方式
3. 朴素 brute-force
4. grid_search 参数比较 + 三种算法比较
5. main 函数 与 报告生成
6. 实验结果总结
– 通过调整不同级别的支持度与置信度，比较 Apriori 算法、FP-Growth 算法以及一种进行穷举搜索的基准方法。
比较维度包括：生成的频繁项集数量、规则挖掘所用的存储空间、计算成本
– 发现一些有趣的关联规则，并就这些规则所揭示的洞察进行讨论。
1. 数据集导入观察
表格读入&信息查看
import pandas as pd# 加载数据集
df = pd.read_csv('Groceries.csv')print('数据基本信息：')
df.info()# 查看数据集行数和列数
rows, columns = df.shapeprint(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_count3. 关联规则生成。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)# 枚举所有非空真子集作为规则前件Afor r in range(1, len(idx_list)): # r从1到len-1，确保前后件都不为空for lhs_indices in itertools.combinations(idx_list, r):lhs = frozenset(lhs_indices) # 规则前件Arhs = idx_set - lhs # 规则后件Bsupp_lhs = idx_support_ratio[lhs]supp_rhs = idx_support_ratio[rhs]# 计算置信度 = P(B|A) = support(A∪B) / support(A)confidence = supp_ratio_union / supp_lhsif 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), rules4. grid_search 参数比较 + 三种算法比较
初始化传入交易列表；
class AlgorithmComparator:"""算法比较器"""def __init__(self, transactions):self.transactions = transactionsself.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 0rules_count = len(rules) if rules else 0print(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 = kself.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 0print(f"BruteForce-Bitset 生成频繁项集数: {freq_itemsets_count}, 规则数: {rules_count}")else:raise ValueError(f"不支持的算法: {algorithm}")finally:# 计算执行时间和内存使用execution_time = time.perf_counter() - start_timecurrent_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)# 创建DataFramereport_df = pd.DataFrame(report_data)# 按支持度和置信度排序report_df = report_df.sort_values(['min_sup_ratio', 'min_conf']).reset_index(drop=True)return report_dfdef 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算法 进行空间换时间。