机器学习关联规则分析:从Apriori到FP-Growth完整指南
1. 引言:为什么需要关联规则挖掘?
在当今数据爆炸的时代,我们每天都在产生海量的交易数据、用户行为数据和日志信息。如何从这些看似杂乱无章的数据中发现有价值的关联模式?这就是**关联规则挖掘(Association Rule Mining)**要解决的核心问题。
1.1 经典案例:啤酒与尿布
关联规则最著名的应用案例莫过于"啤酒与尿布"的故事。沃尔玛通过数据分析发现,周五下午购买尿布的年轻父亲往往也会购买啤酒。这一发现促使超市将这两种商品摆放在一起,结果两类商品的销量都显著提升。
这个案例揭示了一个重要洞察:数据中隐藏着人类行为之间的隐性关联,而关联规则算法正是发现这些关联的有力工具。
1.2 关联规则的应用场景
| 零售电商 | 购物篮分析、商品推荐 | 提升客单价和转化率 |
| 金融风控 | 欺诈检测、异常交易识别 | 降低风险损失 |
| 医疗诊断 | 症状关联分析、药物相互作用 | 辅助临床决策 |
| Web挖掘 | 页面推荐、用户行为分析 | 优化用户体验 |
| 生物信息学 | 基因关联分析、蛋白质交互 | 加速科研发现 |
2. 核心概念与数学基础
2.1 基本定义
事务(Transaction):一次购买或操作中包含的所有项的集合。例如 {面包, 牛奶, 黄油} 就是一个事务。
项集(Itemset):一组项目的集合。包含 k 个项目的项集称为 k-项集(k-itemset)。
关联规则:形如 X ⇒ Y 的蕴含表达式,其中 X 和 Y 是不相交的项集。X 称为前件(Antecedent),Y 称为后件(Consequent)。
2.2 三个关键度量指标
支持度(Support)
支持度衡量规则在所有事务中出现的频率:
Support(X⇒Y)=∣T(X∪Y)∣∣T∣Support(X \\Rightarrow Y) = \\frac{|T(X \\cup Y)|}{|T|}Support(X⇒Y)=∣T∣∣T(X∪Y)∣
其中 ∣T(X∪Y)∣|T(X \\cup Y)|∣T(X∪Y)∣ 是同时包含 X 和 Y 的事务数,∣T∣|T|∣T∣ 是总事务数。
置信度(Confidence)
置信度衡量在出现 X 的事务中,Y 也出现的条件概率:
Confidence(X⇒Y)=Support(X∪Y)Support(X)Confidence(X \\Rightarrow Y) = \\frac{Support(X \\cup Y)}{Support(X)}Confidence(X⇒Y)=Support(X)Support(X∪Y)
提升度(Lift)
提升度衡量 X 和 Y 出现的相关性,值大于 1 表示正相关:
Lift(X⇒Y)=Confidence(X⇒Y)Support(Y)Lift(X \\Rightarrow Y) = \\frac{Confidence(X \\Rightarrow Y)}{Support(Y)}Lift(X⇒Y)=Support(Y)Confidence(X⇒Y)
2.3 度量指标的直观理解
假设我们有1000笔交易:
- 购买面包的事务有200笔
- 购买牛奶的事务有150笔
- 同时购买面包和牛奶的事务有80笔
那么规则 面包 ⇒ 牛奶 的各项指标为:
- 支持度 = 80/1000 = 8%
- 置信度 = 80/200 = 40%
- 提升度 = (80/200) / (150/1000) = 0.4/0.15 ≈ 2.67
提升度为 2.67 > 1,说明买面包的人更倾向于买牛奶,这条规则是有价值的!
3. Apriori算法:关联规则的奠基者
3.1 算法核心思想
Apriori算法由Agrawal等人于1993年提出,是关联规则挖掘领域的里程碑式工作。其核心思想基于一个关键性质——Apriori性质(Apriori Property):
如果一个项集是频繁的,那么它的所有子集也必须是频繁的。
反之,如果一个项集是非频繁的,那么它的任何超集也一定是非频繁的。
这一性质使得我们可以通过**剪枝(Pruning)**大幅减少候选集的数量,避免暴力枚举所有可能的组合。
3.2 算法流程详解
Apriori算法流程:
┌─────────────────────────────────────┐
│ Step 1: 扫描数据库,统计每个项的支持度 │
│ Step 2: 过滤掉低于最小支持度的项 │
│ Step 3: 由频繁k-项集生成候选(k+1)-项集│
│ Step 4: 对候选集进行计数 │
│ Step 5: 再次过滤,得到频繁(k+1)-项集 │
│ Step 6: 重复Step 3-5直到无法生成更大项集│
│ Step 7: 由频繁项集生成关联规则 │
└─────────────────────────────────────┘
3.3 候选集生成策略
从频繁 k-项集生成候选 (k+1)-项集时,采用连接步(Join Step) + 剪枝步(Prune Step):
连接步:将两个只有最后一个元素不同的频繁 k-项集连接,生成候选 (k+1)-项集。
剪枝步:检查候选 (k+1)-项集的所有 k-子集是否都是频繁的,如果不是则删除该候选。
3.4 Python实现
from itertools import combinations
from collections import defaultdict
class Apriori:
def __init__(self, min_support=0.1, min_confidence=0.5):
self.min_support = min_support
self.min_confidence = min_confidence
def _get_support(self, itemset, transactions):
"""计算项集的支持度"""
count = sum(1 for t in transactions if itemset.issubset(t))
return count / len(transactions)
def _generate_candidates(self, freq_k_items, k):
"""由频繁k-项集生成候选(k+1)-项集"""
candidates = set()
items_list = list(freq_k_items)
for i in range(len(items_list)):
for j in range(i + 1, len(items_list)):
union = items_list[i] | items_list[j]
if len(union) == k + 1:
# 剪枝:检查所有子集是否频繁
all_subsets_freq = True
for subset in combinations(union, k):
if frozenset(subset) not in freq_k_items:
all_subsets_freq = False
break
if all_subsets_freq:
candidates.add(union)
return candidates
def fit(self, transactions):
"""执行Apriori算法"""
self.transactions = [set(t) for t in transactions]
n = len(transactions)
# 第一步:获取所有单项并计算支持度
item_counts = defaultdict(int)
for t in self.transactions:
for item in t:
item_counts[item] += 1
# 过滤非频繁单项
freq_items = {
frozenset([item]): count / n
for item, count in item_counts.items()
if count / n >= self.min_support
}
# 迭代生成更大的频繁项集
k = 1
all_freq_items = dict(freq_items)
while freq_items:
k += 1
candidates = self._generate_candidates(set(freq_items.keys()), k – 1)
if not candidates:
break
# 计算候选集支持度
candidate_counts = defaultdict(int)
for cand in candidates:
for t in self.transactions:
if cand.issubset(t):
candidate_counts[cand] += 1
# 过滤
freq_items = {
cand: count / n
for cand, count in candidate_counts.items()
if count / n >= self.min_support
}
all_freq_items.update(freq_items)
self.frequent_itemsets = all_freq_items
# 生成关联规则
rules = []
for itemset, support in all_freq_items.items():
if len(itemset) < 2:
continue
for i in range(1, len(itemset)):
for antecedent in combinations(itemset, i):
antecedent = frozenset(antecedent)
consequent = itemset – antecedent
ant_support = all_freq_items.get(antecedent, 0)
conf = support / ant_support if ant_support > 0 else 0
cons_support = all_freq_items.get(frozenset(consequent), 0)
lift = conf / cons_support if cons_support > 0 else 0
if conf >= self.min_confidence:
rules.append({
'antecedent': antecedent,
'consequent': consequent,
'support': support,
'confidence': conf,
'lift': lift
})
self.rules = sorted(rules, key=lambda x: (–x['lift'], –x['confidence']))
return self
# 使用示例
transactions = [
['牛奶', '面包', '黄油'],
['啤酒', '尿布'],
['牛奶', '尿布', '面包', '鸡蛋'],
['面包', '黄油', '牛奶'],
['啤酒', '可乐', '尿布'],
['牛奶', '尿布', '面包', '黄油'],
['面包', '牛奶', '尿布'],
['面包', '牛奶', '尿布', '黄油'],
]
model = Apriori(min_support=0.25, min_confidence=0.5)
model.fit(transactions)
print("发现的关联规则:")
for rule in model.rules[:10]:
print(f"{rule['antecedent']} => {rule['consequent']}")
print(f" 支持度: {rule['support']:.2%}, 置信度: {rule['confidence']:.2%}, 提升度: {rule['lift']:.2f}")
4. FP-Growth算法:效率的革命性突破
4.1 为什么需要FP-Growth?
虽然Apriori算法开创了关联规则挖掘的先河,但它存在明显的性能瓶颈:
FP-Growth算法(Frequent Pattern Growth)由Han等人在2000年提出,采用完全不同的思路——不需要生成候选集,而是将整个数据库压缩到一棵**FP树(Frequent Pattern Tree)**中,然后直接从树中挖掘频繁模式。
4.2 FP树的结构
FP树是一种紧凑的前缀树结构,具有以下特点:
- 每个节点代表一个项目及其在该路径上的计数
- 相同前缀的事务共享相同的路径(压缩存储)
- 通过**头表(Header Table)**维护各项目的链接列表
- 树的大小远小于原始数据库
4.3 算法两阶段
阶段一:构建FP树
构建FP树流程:
┌──────────────────────────────────┐
│ 1. 第一次扫描:统计各项支持度 │
│ 2. 删除非频繁项,按支持度降序排列 │
│ 3. 第二次扫描:逐条插入事务到FP树 │
│ 4. 共享前缀路径,累加节点计数 │
└──────────────────────────────────┘
阶段二:递归挖掘频繁项集
对头表中的每一项(按支持度从小到大):
4.4 FP-Growth完整实现
class FPNode:
"""FP树的节点"""
def __init__(self, item, count=1, parent=None):
self.item = item # 项目名(根节点为None)
self.count = count # 计数
self.parent = parent # 父节点
self.children = {} # 子节点字典
self.link = None # 同项节点的链表指针
def increment(self, count=1):
self.count += count
class FPTree:
"""FP树"""
def __init__(self):
self.root = FPNode(item=None) # 根节点
self.headers = {} # 头表:item -> [first_node, last_node]
def insert_transaction(self, transaction, count=1):
"""插入一条事务到FP树"""
current = self.root
for item in transaction:
if item in current.children:
current.children[item].increment(count)
else:
new_node = FPNode(item=item, count=count, parent=current)
current.children[item] = new_node
# 更新头表
if item not in self.headers:
self.headers[item] = [new_node, new_node]
else:
self.headers[item][1].link = new_node
self.headers[item][1] = new_node
current = current.children[item]
def is_single_path(self):
"""检查是否为单一路径"""
node = self.root
while node:
if len(node.children) > 1:
return False
if len(node.children) == 0:
return True
node = list(node.children.values())[0]
return True
def build_fp_tree(transactions, min_support):
"""构建FP树"""
from collections import Counter
n = len(transactions)
# 第一次扫描:统计各项频率
item_counts = Counter()
for trans in transactions:
item_counts.update(trans)
# 过滤非频繁项并排序
frequent_items = {
item: count / n
for item, count in item_counts.items()
if count / n >= min_support
}
# 按支持度降序排序
item_order = sorted(frequent_items.keys(),
key=lambda x: frequent_items[x], reverse=True)
# 第二次扫描:构建FP树
tree = FPTree()
for trans in transactions:
# 排序并过滤
ordered_trans = [item for item in item_order if item in trans]
if ordered_trans:
tree.insert_transaction(ordered_trans)
return tree, frequent_items, item_order
def mine_fp_tree(tree, suffix_set, min_support, frequent_items_dict):
"""从FP树中挖掘频繁项集"""
results = {}
# 按支持度从小到大处理(从底向上)
for item in reversed(sorted(tree.headers.keys(),
key=lambda x: frequent_items_dict[x])):
# 新的频繁项集
new_set = suffix_set | {item}
support = sum(
node.count for node in _get_linked_nodes(tree, item)
) / total_transactions # 需要外部传入总事务数
results[frozenset(new_set)] = support
# 构建条件模式基
conditional_patterns = []
counts = []
for node in _get_linked_nodes(tree, item):
path = []
curr = node.parent
while curr and curr.item is not None:
path.append(curr.item)
curr = curr.parent
if path:
conditional_patterns.append(path[::–1]) # 反转为正确顺序
counts.append(node.count)
# 构建条件FP树
cond_tree = FPTree()
for pattern, cnt in zip(conditional_patterns, counts):
cond_tree.insert_transaction(pattern, cnt)
# 递归挖掘
if cond_tree.headers and not cond_tree.is_single_path():
sub_results = mine_fp_tree(cond_tree, new_set, min_support, frequent_items_dict)
results.update(sub_results)
return results
def _get_linked_nodes(tree, item):
"""获取某项的所有节点"""
nodes = []
if item in tree.headers:
node = tree.headers[item][0]
while node:
nodes.append(node)
node = node.link
return nodes
5. 实战演练:真实数据集分析
5.1 数据准备
我们使用一个模拟的超市购物数据集来演示完整的关联规则挖掘流程。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from mlxtend.frequent_patterns import apriori, association_rules
from mlxtend.preprocessing import TransactionEncoder
# 设置中文显示
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei']
plt.rcParams['axes.unicode_minus'] = False
# 生成模拟购物数据
np.random.seed(42)
items = ['面包', '牛奶', '黄油', '鸡蛋', '啤酒', '尿布', '可乐', '苹果', '香蕉', '咖啡']
# 模拟500笔交易
n_transactions = 500
transactions = []
for _ in range(n_transactions):
n_items = np.random.randint(1, 6) # 每笔交易1-5个商品
# 不同商品有不同的被选概率(模拟真实偏好)
weights = [0.30, 0.35, 0.15, 0.20, 0.12, 0.08, 0.18, 0.22, 0.20, 0.10]
selected = np.random.choice(items, size=n_items, replace=False, p=np.array(weights)/sum(weights))
transactions.append(list(selected))
print(f"生成了 {len(transactions)} 笔交易记录")
print(f"示例交易: {transactions[:3]}")
5.2 数据编码与预处理
# 使用TransactionEncoder进行one-hot编码
te = TransactionEncoder()
te_ary = te.fit(transactions).transform(transactions)
df = pd.DataFrame(te_ary, columns=te.columns_)
print("编码后的数据形状:", df.shape)
print(df.head())
5.3 使用mlxtend进行关联规则挖掘
# 挖掘频繁项集
frequent_itemsets = apriori(df, min_support=0.05, use_colnames=True)
frequent_itemsets['length'] = frequent_itemsets['itemsets'].apply(lambda x: len(x))
print(f"发现 {len(frequent_itemsets)} 个频繁项集")
print("\\n支持度最高的10个频繁项集:")
print(frequent_itemsets.nlargest(10, 'support'))
# 生成关联规则
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.3)
rules = rules.sort_values(['lift', 'confidence'], ascending=[False, False])
print(f"\\n生成了 {len(rules)} 条关联规则")
print("\\nTop 10 关联规则(按提升度排序):")
print(rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']].head(10))
6. 可视化分析
6.1 支持度分布图
# 绘制频繁项集支持度分布
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# 按项集大小分组查看支持度
for length in sorted(frequent_itemsets['length'].unique()):
subset = frequent_itemsets[frequent_itemsets['length'] == length]['support']
axes[0].hist(subset, bins=15, alpha=0.6, label=f'{length}-项集')
axes[0].set_xlabel('支持度', fontsize=12)
axes[0].set_ylabel('频数', fontsize=12)
axes[0].set_title('频繁项集支持度分布', fontsize=14)
axes[0].legend()
# Top 15频繁项集
top15 = frequent_itemsets.nlargest(15, 'support')
labels = [str(list(x)) for x in top15['itemsets']]
values = top15['support'].values * 100
bars = axes[1].barh(range(len(labels)), values, color=plt.cm.Blues(np.linspace(0.4, 0.9, len(labels))))
axes[1].set_yticks(range(len(labels)))
axes[1].set_yticklabels(labels, fontsize=9)
axes[1].set_xlabel('支持度 (%)', fontsize=12)
axes[1].set_title('Top 15 频繁项集', fontsize=14)
axes[1].invert_yaxis()
plt.tight_layout()
plt.savefig('support_distribution.png', dpi=150, bbox_inches='tight')
plt.show()
6.2 规则散点图(支持度 vs 置信度 vs 提升度)
fig, ax = plt.subplots(figsize=(12, 8))
scatter = ax.scatter(
rules['support'] * 100,
rules['confidence'] * 100,
s=rules['lift'] * 50, # 用提升度控制点的大小
c=rules['lift'], # 用提升度控制颜色
cmap='RdYlGn',
alpha=0.7,
edgecolors='gray'
)
ax.set_xlabel('支持度 (%)', fontsize=13)
ax.set_ylabel('置信度 (%)', fontsize=13)
ax.set_title('关联规则分布:支持度 × 置信度(气泡大小=提升度)', fontsize=14)
# 添加颜色条
cbar = plt.colorbar(scatter)
cbar.set_label('提升度 (Lift)', fontsize=11)
# 标注Top 5规则
top5_rules = rules.nlargest(5, 'lift')
for idx, row in top5_rules.iterrows():
ax.annotate(
f"{list(row['antecedents'])}→{list(row['consequents'])}",
xy=(row['support']*100, row['confidence']*100),
xytext=(10, 5), textcoords='offset points',
fontsize=8, alpha=0.8,
arrowprops=dict(arrowstyle='->', color='gray', alpha=0.5)
)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('rules_scatter.png', dpi=150, bbox_inches='tight')
plt.show()
6.3 网络关系图
import networkx as nx
# 构建关联网络
G = nx.Graph()
# 取Top 20规则来绘制
top_rules = rules.head(20)
for _, row in top_rules.iterrows():
for a in row['antecedents']:
G.add_node(a, type='antecedent')
for c in row['consequents']:
G.add_node(c, type='consequent')
for a in row['antecedents']:
for c in row['consequents']:
G.add_edge(a, c, weight=row['lift'])
fig, ax = plt.subplots(figsize=(14, 10))
pos = nx.spring_layout(G, k=2, seed=42)
# 绘制边
edges = G.edges(data=True)
weights = [e[2]['weight'] for e in edges]
nx.draw_networkx_edges(G, pos, ax=ax, width=[w*0.5 for w in weights],
alpha=0.5, edge_color=weights, edge_cmap=plt.cm.Reds)
# 绘制节点
node_sizes = [G.degree(n, weight='weight') * 200 + 300 for n in G.nodes()]
nx.draw_networkx_nodes(G, pos, ax=ax, node_size=node_sizes,
node_color='lightblue', edgecolors='navy', linewidths=1.5)
nx.draw_networkx_labels(G, pos, ax=ax, font_size=11, font_family='SimHei')
ax.set_title('商品关联规则网络图\\n(节点大小=关联强度,边的粗细/颜色=提升度)', fontsize=14)
ax.axis('off')
plt.tight_layout()
plt.savefig('association_network.png', dpi=150, bbox_inches='tight')
plt.show()
7. 性能对比:Apriori vs FP-Growth
7.1 时间复杂度分析
| 数据库扫描次数 | O(k),k为最大频繁项集长度 | 2次 |
| 候选集生成 | 大量候选集(指数级) | 无需候选集 |
| 空间复杂度 | O(候选集总数) | O(FP树大小) |
| 最坏时间复杂度 | O(2^n) | O(2^n)但常数因子小得多 |
| 适用场景 | 小规模稀疏数据 | 大规模密集数据 |
7.2 实际运行时间对比
import time
from mlxtend.frequent_patterns import fpgrowth
# 测试不同数据量下的性能
data_sizes = [100, 500, 1000, 2000, 5000]
apriori_times = []
fpgrowth_times = []
for size in data_sizes:
# 生成数据
np.random.seed(size)
test_trans = [
list(np.random.choice(items, size=np.random.randint(1,5), replace=False, p=np.array(weights)/sum(weights)))
for _ in range(size)
]
te = TransactionEncoder()
te_ary = te.fit(test_trans).transform(test_trans)
test_df = pd.DataFrame(te_ary, columns=te.columns_)
# Apriori
start = time.time()
apriori(test_df, min_support=0.05, use_colnames=True)
apriori_times.append(time.time() – start)
# FP-Growth
start = time.time()
fpgrowth(test_df, min_support=0.05, use_colnames=True)
fpgrowth_times.append(time.time() – start)
# 绘制对比图
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(data_sizes, apriori_times, 'o-', linewidth=2, markersize=8, label='Apriori')
ax.plot(data_sizes, fpgrowth_times, 's-', linewidth=2, markersize=8, label='FP-Growth')
ax.set_xlabel('事务数量', fontsize=12)
ax.set_ylabel('运行时间 (秒)', fontsize=12)
ax.set_title('Apriori vs FP-Growth 性能对比', fontsize=14)
ax.legend(fontsize=12)
ax.grid(True, alpha=0.3)
for i, size in enumerate(data_sizes):
ax.annotate(f'{apriori_times[i]:.2f}s', (size, apriori_times[i]), textcoords="offset points", xytext=(0,8), ha='center', fontsize=9)
ax.annotate(f'{fpgrowth_times[i]:.2f}s', (size, fpgrowth_times[i]), textcoords="offset points", xytext=(0,–12), ha='center', fontsize=9)
plt.tight_layout()
plt.savefig('performance_comparison.png', dpi=150, bbox_inches='tight')
plt.show()
8. 进阶主题与优化技巧
8.1 参数调优指南
最小支持度(min_support)的选择:
- 过高 → 规则太少,可能遗漏有价值的信息
- 过低 → 规则爆炸,计算成本高且含大量噪声
- 经验值:0.01 ~ 0.1(根据数据密度调整)
最小置信度(min_confidence)的选择:
- 一般建议 ≥ 0.5,确保规则具有实际意义
- 对于高风险场景(如医疗),建议 ≥ 0.8
8.2 多层关联规则
在实际业务中,商品通常存在层次分类关系。例如:
- 食品 → 乳制品 → 牛奶 → 全脂牛奶
多层关联规则可以在不同粒度上发现关联模式,避免过于具体导致支持度过低的问题。
8.3 量化关联规则
传统关联规则处理的是布尔型数据(买/不买)。量化关联规则扩展到数值属性,如:
- 年龄 ∈ [25,35] ∧ 收入 ∈ [10k, 20k] ⇒ 购买高端手机(置信度85%)
- 价格 < 50 ⇒ 销量 > 1000(置信度72%)
8.4 动态关联规则
数据随时间变化,静态模型会逐渐失效。动态关联规则通过滑动窗口或增量更新机制,持续跟踪关联模式的演变趋势。
9. 工业级实践建议
9.1 数据预处理要点
9.2 结果评估方法
不要只看统计指标!有效的关联规则还需要:
- 业务可解释性:规则是否符合领域知识?
- 可操作性:能否基于规则采取行动?
- 时效性:当前规则是否仍然有效?
- 新颖性:是否发现了之前未知的模式?
9.3 常见陷阱与规避
| 虚假关联 | 统计显著但无因果关系 | 结合A/B测试验证 |
| 稀疏数据偏差 | 长尾项难以被发现 | 采用多层次挖掘 |
| 参数敏感 | 结果高度依赖阈值设定 | 多组参数交叉验证 |
| 计算爆炸 | 组合数爆炸导致超时 | 使用FP-Growth+采样 |
10. 总结与展望
10.1 核心要点回顾
本文系统介绍了关联规则挖掘的完整知识体系:
10.2 未来发展方向
关联规则挖掘仍在不断发展中:
- 深度学习结合:利用神经网络学习非线性关联
- 序列模式扩展:考虑时间维度的顺序关联
- 隐私保护挖掘:在加密数据上进行关联分析
- 实时流处理:面向无限数据流的在线关联挖掘
- 因果推断融合:从相关性走向因果性的探索
10.3 学习资源推荐
| 《Data Mining: Concepts and Techniques》 | 教材 | 经典权威教材 |
| Han et al., “Mining Frequent Patterns without Candidate Generation” | 论文 | FP-Growth原论文 |
| mlxtend库 | 工具 | Python生态最佳实现 |
| Kaggle Market Basket Analysis | 竞赛 | 实战练习平台 |
作者注:本文配套的完整代码和可视化图表已整理到GitHub仓库,欢迎Star和Issue交流。如果你在学习和实践中遇到问题,欢迎在评论区留言讨论!
关键词:关联规则、Apriori、FP-Growth、购物篮分析、机器学习、数据挖掘




![P11246 [GESP202409 六级] 小杨和整数拆分-171主机测评](https://www.171host.com/wp-content/uploads/2026/11/20261108100631-6af049a75855c-220x150.png)