频繁项集的产生—Apriori算法

Apriori算法用于从数据集中提取频繁项集，以购物篮事务为例说明其过程：

提取频繁项集的过程如下：

Apriori算法的伪码如下：

Apriori算法的Python实现

给出数据集：

data = [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]

提取1-项集

# 生成候选1-项集
def createC1(data):c1 = []for task in data:for item in task:if [item] not in c1:c1.append([item])# 排序是因为之后生产频繁k-项集是采用F(k-1)*F(k-1)方法c1.sort()# frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。return list(map(frozenset, c1))
# 候选1-项集的结果如下
c1 = createC1(data)
c1
[frozenset({1}),frozenset({2}),frozenset({3}),frozenset({4}),frozenset({5})]

提取频繁k-项集

基于支持度的剪枝原理可用下图表示：

其原理在于如果一个项集是频繁的，则它的所有子集一定也是频繁的。根据逆否命题可得：如果一个项集的某个子集是非频繁的，则该项集一定是非频繁的。

# 提取频繁k-项集
def scanData(data, C_k, minSupport):# 记录候选k-项集中项的支持度计数ssCnt = {}for task in data:for can in C_k:if can.issubset(task):ssCnt[can] = ssCnt.get(can, 0) + 1# 根据最小支持度计数提取频繁项集retlist = []F_k = {}for key in ssCnt:support = ssCnt[key] / len(data)if support >= minSupport:retlist.insert(0, key)F_k[key] = supportreturn retlist, F_k# F1_l记录频繁1-项集
# F_1记录频繁1-项集中各项集的支持度
F1_l, F_1 = scanData(data, c1, 0.5)
print(F1_l)
[frozenset({5}), frozenset({2}), frozenset({3}), frozenset({1})]
print(F_1)
{frozenset({1}): 0.5, frozenset({3}): 0.75, frozenset({2}): 0.75, frozenset({5}): 0.75}

对应伪码的第2步和第12步。

生成候选k-项集

生成候选k-项集采用F(k-1) * F(k-1)方法，其原理如下：

# 采用F(k-1)*F(k-1)法：通过频繁项集列表F_k-1生成候选项集列表C_k
def aprioriGen(F_l, k):C_l = []for i in range(len(F_l)-1):for j in range(i+1, len(F_l)):# 对于频繁k-1项集合并规则为：前k-2项相同第k-1项不同# 提取频繁k-1项集的前k-2项l1 = list(F_l[i])[:k-2]l2 = list(F_l[j])[:k-2]l1.sort()l2.sort()if l1 == l2:C_l.append(F_l[i] | F_l[j])return C_lC2_l = aprioriGen(F1_l, 2)
C2_l
[frozenset({2, 5}),frozenset({3, 5}),frozenset({1, 5}),frozenset({2, 3}),frozenset({1, 2}),frozenset({1, 3})]

对应伪码的第5步。

Apriori算法

def apriori(data, minsupport):# 生成候选1-项集C1 = createC1(data)# 提取频繁1-项集F1_l, F1 = scanData(data, C1, minsupport)# 返回频繁项集和频繁项集对应的支持度L = [F1_l] F = F1# 逐层迭代，直到不再生成新的频繁项集k = 2while len(L[k-2]) > 0: # 根据频繁k-1项集生成候选k-项集Ck_l = aprioriGen(L[k-2], k)# 从候选K-项集中提取频繁k-项集Fk_l, Fk = scanData(data, Ck_l, minsupport)L.append(Fk_l)F.update(Fk)k += 1return L, F
L, F = apriori(data, 0.2)
# 频繁项集
print(L)
[[frozenset({5}), frozenset({2}), frozenset({4}), frozenset({3}), frozenset({1})], [frozenset({1, 2}), frozenset({1, 5}), frozenset({2, 3}), frozenset({3, 5}), frozenset({2, 5}), frozenset({1, 3}), frozenset({1, 4}), frozenset({3, 4})], [frozenset({1, 3, 5}), frozenset({1, 2, 3}), frozenset({1, 2, 5}), frozenset({2, 3, 5}), frozenset({1, 3, 4})], [frozenset({1, 2, 3, 5})], []]
# 频繁项集何其对应的支持度
print(F)
{frozenset({1}): 0.5, frozenset({3}): 0.75, frozenset({4}): 0.25, frozenset({2}): 0.75, frozenset({5}): 0.75, frozenset({3, 4}): 0.25, frozenset({1, 4}): 0.25, frozenset({1, 3}): 0.5, frozenset({2, 5}): 0.75, frozenset({3, 5}): 0.5, frozenset({2, 3}): 0.5, frozenset({1, 5}): 0.25, frozenset({1, 2}): 0.25, frozenset({1, 3, 4}): 0.25, frozenset({2, 3, 5}): 0.5, frozenset({1, 2, 5}): 0.25, frozenset({1, 2, 3}): 0.25, frozenset({1, 3, 5}): 0.25, frozenset({1, 2, 3, 5}): 0.25}

封装

class Apriori:def __init__(self, minsupport):self.minsupport = minsupportdef createC1(self, data):c1 = []for task in data:for item in task:if [item] not in c1:c1.append([item])# 排序是因为之后生产频繁k-项集是采用F(k-1)*F(k-1)方法c1.sort()# frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。return list(map(frozenset, c1))def scanData(self, data, C_k, minSupport):# 记录候选k-项集中项的支持度计数ssCnt = {}for task in data:for can in C_k:if can.issubset(task):ssCnt[can] = ssCnt.get(can, 0) + 1# 根据最小支持度计数提取频繁项集retlist = []F_k = {}for key in ssCnt:support = ssCnt[key] / len(data)if support >= minSupport:retlist.insert(0, key)F_k[key] = supportreturn retlist, F_kdef aprioriGen(self, F_l, k):C_l = []for i in range(len(F_l)-1):for j in range(i+1, len(F_l)):# 对于频繁k-1项集合并规则为：前k-2项相同第k-1项不同# 提取频繁k-1项集的前k-2项l1 = list(F_l[i])[:k-2]l2 = list(F_l[j])[:k-2]l1.sort()l2.sort()if l1 == l2:C_l.append(F_l[i] | F_l[j])return C_ldef apriori(self, data):minsupport = self.minsupport# 生成候选1-项集C1 = self.createC1(data)# 提取频繁1-项集F1_l, F1 = self.scanData(data, C1, minsupport)# 返回频繁项集和频繁项集对应的支持度L = [F1_l] F = F1# 逐层迭代，直到不再生成新的频繁项集k = 2while len(L[k-2]) > 0: # 根据频繁k-1项集生成候选k-项集Ck_l = self.aprioriGen(L[k-2], k)# 从候选K-项集中提取频繁k-项集Fk_l, Fk = self.scanData(data, Ck_l, minsupport)L.append(Fk_l)F.update(Fk)k += 1return L, F

关联分析——频繁项集的产生之Apriori算法相关推荐

关联分析/频繁项集挖掘：Apriori算法
简介 Apriori是一种流行的算法,用于在关联规则学习中提取频繁项集.Apriori算法被设计用于对包含交易的数据库进行操作,例如商店客户的购买.如果项目集满足用户指定的支持阈值,则该项目集被视为& ...
频繁项集的产生及经典算法
前言: 关联规则是数据挖掘中最活跃的研究方法之一, 是指搜索业务系统中的所有细节或事务,找出所有能把一组事件或数据项与另一组事件或数据项联系起来的规则,以获得存在于数据库中的不为人知的或不能确定的 ...
【大数据】六、频繁项集与关联规则（频繁项集、关联规则、A-Priori、PCY）
文章目录 1 定义 1.1 频繁项集 1.2 关联规则 2 A-Priori 算法 2.1 例题 3 更大数据集在内存中的处理 3.1 PCY 算法 3.2 多阶段算法 3.3 多哈希算法 4 有限扫 ...
关联分析（一）：频繁项集及规则产生
关联分析用于发现隐藏在大型数据集中有意义的联系,属于模式挖掘分析方法,其为人熟知的经典应用当属沃尔玛超市里"啤酒与尿布"的关系挖掘了.关联分析的应用领域非常多,当数据集类型比较复杂 ...
频繁项集挖掘算法——Apriori算法
前言关联规则就是在给定训练项集上频繁出现的项集与项集之间的一种紧密的联系.其中"频繁"是由人为设定的一个阈值即支持度 (support)来衡量,"紧密"也是由 ...
频繁项目集java实现_关联分析(2):Apriori产生频繁项集
在关联分析(1):概念及应用中,我们介绍了关联分析的应用场景.基本概念和规则产生思路.在本次的文章中,我们将介绍Apriori算法频繁项集产生的原理.文章中会涉及专有名词,不清楚概念的可在上一篇文章中 ...
fp算法例题_Kmeans算法找相似商品、FP树找频繁项集
第一题:用Kmeans处理数据集数据集下载地址运行环境 python3.7.PyCharm 2018.2.4 (Community Edition) 思路根据所给数据集及其说明可以看出数据集共有 ...
python 频繁项集_用FP-Growth算法找出销售数据中的频繁项集
运行环境 python3.7.PyCharm 2018.2.4 (Community Edition) 数据来源思路从所给数据及其说明文档可以看出此数据集是从购物数据中收集而来的,每行数据都是一条 ...
12使用FP-growth算法来高效发现频繁项集
第12章使用FP-growth算法来高效发现频繁项集一.背景大家都用过搜索引擎.当我们输入一个单词或单词的一份,搜索引擎就会自动补全查询词项.例如:当我们在百度输入"为什么" ...

关联分析——频繁项集的产生之Apriori算法