Apriori算法进行关联分析（1）

最新推荐文章于 2024-04-04 14:12:14 发布
最新推荐文章于 2024-04-04 14:12:14 发布
阅读量1.4k 收藏 8
点赞数 4
分类专栏： 机器学习实战 文章标签： apriori算法 关联规则 支持度 可信度 频繁项集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lilong117194/article/details/78493120
版权

1. 使用Apriori算法来发现频繁集

1.1 关联分析

关联分析：是一种在大规模数据集中寻找有趣关系的任务。这些关系可以有两种形式：频繁项集或者关联规则。频繁项集（frequent item sets)是经常出现在一块的物品的集合，关联规则(association rules)暗示两种物品之间可能存在很强的关系。

这里写图片描述

而有趣、频繁、有趣的关系这些量化的工具就是支持度和可信度。

  • 一个项集的支持度(support)：被定义为数据集中包含该项集的记录所占的比例。支持度是针对项集来说的，因此可以定义一个最小支持度，而只保留满足最小支持度的项集。
  • 可信度或置信度（confidence)：是针对一条关联规则来定义的。这条规则的可信度被定义为“支持度({尿布，葡萄酒})/支持度({尿布})”。

1.2 Apriori原理

这里写图片描述

对于上图的集合数目，会发现即使对于仅有4种物品的集合，也需要遍历数据15次。而随着物品数目的增加遍历次数会急剧增长。对于包含—物品的数据集共有 2N−1 种项集组合，需要很长的时间才能完成运算。

为了降低所需的计算时间，有了Apriori原理，Apriori原理是说如果某个项集是频繁的，那么它的所有子集也是频繁的。如果反过来就是说如果一个项集是非频繁集，那么它的所有超集也是非频繁的。

关联分析的目标包括两项：发现频繁项集和发现关联规则。首先需要找到频繁项集，然后才能获得关联规则。
生成候选集：

对数据集中的每条交易记录tran
对每个候选项集can：
检查一下can是否是tran的子集：
如果是，则增加can的计数值
对每个候选项集：
如果其支持度不低于最小值，则保留该项集
返回所有频繁项集列表。

完整的Apriori算法：

当集合中项的个数大于0时
构建一个k个项组成的候选项集的列表
检查数据以确认每个项集都是频繁的
保留频繁项集并构建k+1项组成的候选项集的列表

代码：

# -*- coding: utf-8 -*-
"""
Created on Thu Nov 09 13:16:21 2017
"""
from numpy import *

 # 用于测试的简单数据集列表
def loadDataSet():
    return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]

# 构建第一个候选子集
def createC1(dataSet):
    C1 = [] # 用来存储所有不重复的项值
    for transaction in dataSet: # 遍历数据集的每一次交易记录
        for item in transaction: # 遍历每一记录的每一项
            if not [item] in C1: 
                C1.append([item]) # 添加只包含该物品项的一个列表
                print 'list_C1:',C1         # 打印该列表
    C1.sort() # 对列表进行排序
    frozenset_C1=map(frozenset, C1) # 这里把C1的每个元素映射到frozenset()
    return frozenset_C1  # 返回frozenset的列表

# 从Ck生成Lk
def scanD(D, Ck, minSupport): # 三个参数：数据集，候选项集列表，感兴趣项集的最小支持度 
    ssCnt = {}
    for tid in D: # 遍历数据集的每一交易记录
        for can in Ck: # 遍历每一候选项集
            if can.issubset(tid): # 判断该集合是否是记录的一部分
                if not ssCnt.has_key(can): # 如果没有,该集合就把该集合增加到字典中
                    ssCnt[can]=1 # 这里字典的键就是该项集
                else: ssCnt[can] += 1 # 如果已经有了键，就计数加1
    numItems = float(len(D)) # 变为浮点数
    retList = [] # 该列表包含满足最小支持度要求的集合
    supportData = {}
    for key in ssCnt: # 遍历字典的每个元素
        support = ssCnt[key]/numItems # 计算支持度(分母是所有的交易记录)
        if support >= minSupport: # 如果满足最小支持度
            retList.insert(0,key) # 则将字典元素添加到retlist列表
            print 'retList:',retList
            supportData[key] = support  # 返回所有项集的支持度
    return retList, supportData # 返回频繁项集的支持度

# 创建候选项集CK
def aprioriGen(Lk, k): # 参数分别是：频繁项集列表LK，项集元素个数K
    print 'LK_1:',Lk
    retList = []
    lenLk = len(Lk)
    for i in range(lenLk): # 遍历LK中的每一个元素
        for j in range(i+1, lenLk): # 和后面的元素逐一比较
            L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2] # 取列表的两个集合进行比较
            L1.sort(); L2.sort() 
            print 'L1 and L2:',L1,L2
            if L1==L2: # 如果两个集合的前k-2个元素相同，那么就合并此两个集合为大小k的集合
                print 'here !'
                retList.append(Lk[i] | Lk[j]) # 这里用python中集合的并操作“|”
    return retList

def apriori(dataSet, minSupport = 0.5):
    C1 = createC1(dataSet)  # C1是候选项集列表
    print 'C1:',C1
    D = map(set, dataSet)
    print 'D:',D
    L1, supportData = scanD(D, C1, minSupport) # L1是得到的是满足最小支持度的项集构成的集合
    print 'L1:',L1
    print 'supportData:',supportData
    L = [L1] # L1放入列表中
    print 'L:',L
    k = 2
    while (len(L[k-2]) > 0): # 直到下一个大的项集为空
        Ck = aprioriGen(L[k-2], k)  # ck是非重复的项集，即候选项集列表
        print 'CK:',Ck
        Lk, supK = scanD(D, Ck, minSupport) # 得到Lk，即得到满足最小支持度的项集
        print 'Lk_2:',Lk
        print 'supK:',supK
        supportData.update(supK) # 这里是更新supportData字典，即加入supk，得到总的支持度字典
        print 'supportData_2:',supportData
        L.append(Lk) # 得到总的满足支持度要求的项集集合
        print 'L_2:',L
        k += 1
    return L, supportData



# 主函数
dataSet=loadDataSet()
L,suppData=apriori(dataSet)
print 'L:',L

运行结果：

list_C1: [[1]]
list_C1: [[1], [3]]
list_C1: [[1], [3], [4]]
list_C1: [[1], [3], [4], [2]]
list_C1: [[1], [3], [4], [2], [5]]
C1: [frozenset([1]), frozenset([2]), frozenset([3]), frozenset([4]), frozenset([5])]
D: [set([1, 3, 4]), set([2, 3, 5]), set([1, 2, 3, 5]), set([2, 5])]
retList: [frozenset([5])]
retList: [frozenset([2]), frozenset([5])]
retList: [frozenset([3]), frozenset([2]), frozenset([5])]
retList: [frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]
L1: [frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]
supportData: {frozenset([5]): 0.75, frozenset([2]): 0.75, frozenset([3]): 0.75, frozenset([1]): 0.5}
L: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]]
LK_1: [frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
CK: [frozenset([1, 3]), frozenset([1, 2]), frozenset([1, 5]), frozenset([2, 3]), frozenset([3, 5]), frozenset([2, 5])]
retList: [frozenset([3, 5])]
retList: [frozenset([2, 3]), frozenset([3, 5])]
retList: [frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
retList: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
Lk_2: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
supK: {frozenset([1, 3]): 0.5, frozenset([2, 3]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 5]): 0.75}
supportData_2: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L_2: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]]
LK_1: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
L1 and L2: [1] [2]
L1 and L2: [1] [2]
L1 and L2: [1] [3]
L1 and L2: [2] [2]
here !
L1 and L2: [2] [3]
L1 and L2: [2] [3]
CK: [frozenset([2, 3, 5])]
retList: [frozenset([2, 3, 5])]
Lk_2: [frozenset([2, 3, 5])]
supK: {frozenset([2, 3, 5]): 0.5}
supportData_2: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L_2: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])]]
LK_1: [frozenset([2, 3, 5])]
CK: []
Lk_2: []
supK: {}
supportData_2: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L_2: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]
L: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]

从运行结果可以看出具体的运行过程，结合下图理解。

这里写图片描述

注意：

  • frozenset是指被“冰冻”的集合，就是说它们是不可改变的，即用户不能修改它们。这里必须要使用frozenset而不是set类型，因为之后必须要将这些集合作为字典键值使用，使用frozenset可以实现这一点，而set却做不到。
  • Python不能创建只有一个整数的集合，因此这里实现必须使用列表。这就是我们使用一个由单物品列表组成的大列表的原因。最后，对大列表进行排序并将其中的每个单元素列表映射到frozenset（），最后返回frozenset的列表。
  • 上面的k-2有点让人疑惑。接下来再进一步讨论细节。当利用{0}、{1}、{2}构建{0,1}、{0，2}、{1，2}时，这实际上是将单个项组合到一块。现在如果想利用{0,1}、{0,2}、{1，2}来创建三元素项集应该怎么做？如果将每两个集合合并，就会得到{0,1,2}、{0，1，2}、{0,l,2}。也就是说，同样的结果集合会重复3次。接下来需要扫描三元素项集列表来得到非重复结果，我们要做的是确保遍历列表的次数最少。现在，如果比较集合{0,1}、{0,2},{1,2}的第1个元素并只对第1个元素相同的集合求并操作，又会得到什么结果？{0,l,2},而且只有一次操作！这样就不需要遍历列表来寻找非重复值。
  • 将两个集合合成一个大小为k的集合。这里使用集合的并操作来完成，在python中对应操作符 |

2. 从频繁项集中挖掘关联规则

这里要首先明白的而是可信的计算方式：
一条规则P—>H的可信度定义为 Support(P|H)/support(P) 中，操作符丨表示集合的并操作，而数学上集合并的符号是 ⋃ 。 P|H 是指所有出现在集合 P 或者集合H中的元素。前面一节已经计算了所有频繁项集支持度。现在想获得可信度，所需要做的只是取出那些支持度值做一次除法运算。

这里写图片描述

类似于上面的频繁项集生成，我们可以为每个频繁项集产生许多关联规则。如果能够减少规则数目来确保问题的可解性，那么计算起来就会好很多。可以观察到，如果某条规则并不满足最小可信度要求，那么该规则的所有子集也不会满足最小可信度要求。上图中，假设规则 0,1,2—>3 并不满足最小可信度要求，那么就知道任何左部为 0，1，2 子集的规则也不会满足最小可信度要求。上图中这些规则上都加了阴影来表示。所以可以利用关联规则的上述性质属性来减少需要测试的规则数目。

代码：

# -*- coding: utf-8 -*-
"""
Created on Thu Nov 09 20:52:41 2017
"""
from numpy import *

def loadDataSet():
    return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]


# 生成候选规则集合(计算可信度值)
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
    prunedH = []   # 空列表保存满足最小可信度要求的规则列表
    for conseq in H: # 遍历H中的所有项集，并计算他们的可信度值
        # supportData[freqSet]是频繁集的值，也就是支持度，freqSet是相应的键，freqSet-conseq集合相减
        print 'P -->H:',freqSet-conseq,'-->',conseq
        conf = supportData[freqSet]/supportData[freqSet-conseq] # 得到可信度
        print 'conf:',conf
        if conf >= minConf: # 如果满足最小可信度值
            print freqSet-conseq,'-->',conseq,'conf:',conf  # 打印出来
            brl.append((freqSet-conseq, conseq, conf)) # 规则添加到列表中
            prunedH.append(conseq)
    return prunedH


# 生成更多的关联规则
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7): # H是频繁项集的拆分
    m = len(H[0]) # 首先计算拆分的频繁项集的大小
    print 'm:',m
    if (len(freqSet) > (m + 1)): # 尝试进一步合并
        Hmp1 = aprioriGen(H, m+1) # 创建Hm+1条新候选规则，生成H中元素的无重复组合
        print 'Hmp1:',Hmp1
        Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
        print 'Hmp1_2:',Hmp1 
        if (len(Hmp1) > 1):    # 使用hmp迭代调用函数rulesFromConseq()来判断是否可以进一步组合规则
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)

# 关联规则生成函数
def generateRules(L, supportData, minConf=0.7):  #频繁项集列表，包含频繁项集支持数据的字典，最小可信度阈值
    bigRuleList = []
    for i in range(1, len(L)): # 遍历每一个频繁项集，从第二个项集开始
        for freqSet in L[i]:   # 为每个频繁项集创建只包含单个元素集合的列表H1
            print 'L[i]:',L[i]
            print 'freqSet:',freqSet
            H1 = [frozenset([item]) for item in freqSet] # 列表推导式
            print 'H1:',H1
            if (i > 1):
                print 'i=%d...' % i
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
            else: # i=1表示频繁项集的元素数目为2
                print 'i=1.....'
                calcConf(freqSet, H1, supportData, bigRuleList, minConf)
            print 'bigRuleList:',bigRuleList  # 对应的是calcConf函数中的brl参数
    return bigRuleList # 返回一个包含可信度的规则列表            

# 构建第一个候选子集
def createC1(dataSet):
    C1 = [] # 用来存储所有不重复的项值
    for transaction in dataSet: # 遍历数据集的每一次交易记录
        for item in transaction: # 遍历每一记录的每一项
            if not [item] in C1: 
                C1.append([item]) # 添加只包含该物品项的一个列表               
    C1.sort() # 对列表进行排序
    frozenset_C1=map(frozenset, C1) # 这里把C1的每个元素映射到frozenset()
    return frozenset_C1  # 返回frozenset的列表

# 从Ck生成Lk
def scanD(D, Ck, minSupport): # 三个参数：数据集，候选项集列表，感兴趣项集的最小支持度 
    ssCnt = {}
    for tid in D: # 遍历数据集的每一交易记录
        for can in Ck: # 遍历每一候选项集
            if can.issubset(tid): # 判断该集合是否是记录的一部分
                if not ssCnt.has_key(can): # 如果没有,该集合就把该集合增加到字典中
                    ssCnt[can]=1 # 这里字典的键就是该项集
                else: ssCnt[can] += 1 # 如果已经有了键，就计数加1
    numItems = float(len(D)) # 变为浮点数
    retList = [] # 该列表包含满足最小支持度要求的集合
    supportData = {}
    for key in ssCnt: # 遍历字典的每个元素
        support = ssCnt[key]/numItems # 计算支持度(分母是所有的交易记录)
        if support >= minSupport: # 如果满足最小支持度
            retList.insert(0,key) # 则将字典元素添加到retlist列表           
            supportData[key] = support  # 返回所有项集的支持度
    return retList, supportData # 返回频繁项集的支持度

# 创建候选项集CK
def aprioriGen(Lk, k): # 参数分别是：频繁项集列表LK，项集元素个数K
    retList = []
    lenLk = len(Lk)
    for i in range(lenLk): # 遍历LK中的每一个元素
        for j in range(i+1, lenLk): # 和后面的元素逐一比较
            L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2] # 取列表的两个集合进行比较
            L1.sort(); L2.sort() 
            if L1==L2: # 如果两个集合的前k-2个元素相同，那么就合并此两个集合为大小k的集合                
                retList.append(Lk[i] | Lk[j]) # 这里用python中集合的并操作“|”
    return retList

def apriori(dataSet, minSupport = 0.5):
    C1 = createC1(dataSet)  # C1是候选项集列表
    D = map(set, dataSet)   
    L1, supportData = scanD(D, C1, minSupport) # L1是得到的是满足最小支持度的项集构成的集合
    L = [L1] # L1放入列表中
    k = 2
    while (len(L[k-2]) > 0): # 直到下一个大的项集为空
        Ck = aprioriGen(L[k-2], k)  # ck是非重复的项集，即候选项集列表       
        Lk, supK = scanD(D, Ck, minSupport) # 得到Lk，即得到满足最小支持度的项集        
        supportData.update(supK) # 这里是更新supportData字典，即加入supk，得到总的支持度字典       
        L.append(Lk) # 得到总的满足支持度要求的项集集合       
        k += 1
    return L, supportData

# 主函数

dataSet=loadDataSet()
L,suppData=apriori(dataSet,minSupport = 0.5)
print 'L:',L
print 'suppData:',suppData           
rules=generateRules(L, suppData, minConf=0.7)       
print 'rules:',rules

运行结果：

L: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]
suppData: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([1, 3])
H1: [frozenset([1]), frozenset([3])]
i=1.....
P -->H: frozenset([3]) --> frozenset([1])
conf: 0.666666666667
P -->H: frozenset([1]) --> frozenset([3])
conf: 1.0
frozenset([1]) --> frozenset([3]) conf: 1.0
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0)]
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([2, 5])
H1: [frozenset([2]), frozenset([5])]
i=1.....
P -->H: frozenset([5]) --> frozenset([2])
conf: 1.0
frozenset([5]) --> frozenset([2]) conf: 1.0
P -->H: frozenset([2]) --> frozenset([5])
conf: 1.0
frozenset([2]) --> frozenset([5]) conf: 1.0
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([2, 3])
H1: [frozenset([2]), frozenset([3])]
i=1.....
P -->H: frozenset([3]) --> frozenset([2])
conf: 0.666666666667
P -->H: frozenset([2]) --> frozenset([3])
conf: 0.666666666667
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([3, 5])
H1: [frozenset([3]), frozenset([5])]
i=1.....
P -->H: frozenset([5]) --> frozenset([3])
conf: 0.666666666667
P -->H: frozenset([3]) --> frozenset([5])
conf: 0.666666666667
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
L[i]: [frozenset([2, 3, 5])]
freqSet: frozenset([2, 3, 5])
H1: [frozenset([2]), frozenset([3]), frozenset([5])]
i=2...
m: 1
Hmp1: [frozenset([2, 3]), frozenset([2, 5]), frozenset([3, 5])]
P -->H: frozenset([5]) --> frozenset([2, 3])
conf: 0.666666666667
P -->H: frozenset([3]) --> frozenset([2, 5])
conf: 0.666666666667
P -->H: frozenset([2]) --> frozenset([3, 5])
conf: 0.666666666667
Hmp1_2: []
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
rules: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]

结果中给出三条规则： 1—>3、5—>2及2—>5 可以看到，后两条包含2和5的规则可以互换前件和后件，但是前一条包含1和3的规则不行。

3. 笔记：

（1）Python List insert()方法：

list.insert(index, obj)：
insert() 函数用于将指定对象插入列表的指定位置。该方法没有返回值，但会在列表指定位置插入对象。
index – 对象 obj 需要插入的索引位置。
obj – 要插入列表中的对象。

示例：

>>> aList = [123, 'xyz', 'zara', 'abc']
>>> aList.insert( 3, 2009)
>>> aList
[123, 'xyz', 'zara', 2009, 'abc']
>>>

（2） if can.issubset(tid):

In [54]: frozenset([1]).issubset(set([1, 3, 4]))
Out[54]: True

（3）

if not [item] in C1: 
    C1.append([item])

得到：

[[1]]   # 每次的运行效果
[[1], [3]]
[[1], [3], [4]]
[[1], [3], [4], [2]]
[[1], [3], [4], [2], [5]]

In [21]: C1 # 最后的c1
Out[21]: 
[frozenset({1}),
 frozenset({2}),
 frozenset({3}),
 frozenset({4}),
 frozenset({5})]

（4）L1 = list(Lk[i])[:k-2]

In [38]: L1
Out[38]: [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]

In [39]: L=[L1]

In [40]: L
Out[40]: [[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]]

In [41]: L[0]
Out[41]: [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]

In [42]: LK=L[0]

In [43]: LK
Out[43]: [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]

In [44]: list(LK[0])
Out[44]: [1]

In [45]: list(LK[0])[:0]
Out[45]: []

（5）list(Lk[i])[:k-2]

In [47]: bb=[1,2,3]

In [48]: bb[:]
Out[48]: [1, 2, 3]

In [49]: bb[:1]
Out[49]: [1]

In [50]: bb[0]
Out[50]: 1

In [51]: bb[0:2]
Out[51]: [1, 2]

In [52]: bb[0:3]
Out[52]: [1, 2, 3]

In [53]: bb[:2]
Out[53]: [1, 2]

（6）H1 = [frozenset([item]) for item in freqSet]

In [66]: L[1]
Out[66]: [frozenset({1, 3}), frozenset({2, 5}), frozenset({2, 3}), frozenset({3, 5})]

In [67]: [frozenset([item]) for item in frozenset({1, 3})] # 列表推到
Out[67]: [frozenset({1}), frozenset({3})]

In [68]: [[item] for item in frozenset({1, 3})]  
Out[68]: [[1], [3]]

In [69]: [item for item in frozenset({1, 3})]  
Out[69]: [1, 3]

In [71]: supportData_2={frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}

In [72]: supportData_2[frozenset({1, 3})]
Out[72]: 0.5

In [74]: supportData_2[frozenset({1, 3})-frozenset({1})] 
Out[74]: 0.75

In [75]: frozenset({1, 3})-frozenset({1})   # 集合相减
Out[75]: frozenset({3})
lilong117194
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Apriori算法，关联规则挖掘算法，人工智能
06-05
Apriori算法是一种常见的关联规则挖掘算法，用于发现数据集中的频繁项集。在市场营销和产品推荐等领域中，它被广泛应用，以帮助企业根据客户购买模式制定更加精准的营销策略。 Apriori算法基于以下两个假设： 如果一个项集是频繁的，则其所有子集也必须是频繁的。 如果一个项集是 infrequent（不频繁）的，则其所有超集也必须是 infrequent 的。 Apriori算法的基本思想是通过迭代找出所有频繁项集。首先，在数据集中查找单个项的所有频繁项集，这些项集只包含一个元素。然后，利用这些频繁项集产生新的候选项集，并计算它们的支持度。通过支持度阈值，去除不满足要求的项集，并在剩下的项集中查找所有的频繁项集。这个过程会重复多次，每次迭代都会产生更大的候选项集，直到没有更多的频繁项集为止。
python商品关联_【Python】商品关联分析-Apriori算法——东北大学数据挖掘实训二...
weixin_39749243的博客
11-21 398
假设我们经营一家商品种类并不多的杂货店，我们对那些经常在一起被购买的商品组合感兴趣。设我们只有5种商品：商品1，商品2，商品3，商品4和商品5 。（1）通过Apriori算法实现从交易记录中找到商品的频繁项集。（2）通过（1）中计算的频繁项集，挖掘关联规则设交易清单为[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]，这里的数字代表商品；设最小支持度为0.5；最小...
【星海随笔】关联规则(二) python实现
weixin_41997073的博客
05-26 420
def loadDataSet(): return [[1,2,5],[2,4],[2,3],[1,2,4],[1,3],[2,3],[1,3],[1,2,3,5],[1,2,3]] #1.构建候选1项集C1 def createC1(dataSet): C1 = [] for transaction in dataSet: for item in transaction: if not [item] in C1:
机器学习之关联分析算法Apriori
最新发布
m0_67510277的博客
04-04 670
MLxtend是一个专为Python设计的机器学习库，它提供了一系列实用的工具和扩展，旨在增强机器学习工程师和数据科学家的工作流程的功能和效率。MLxtend的功能覆盖了机器学习的不同方面，包括但不限于特征选择、模型评估、集成学习、关联规则挖掘和数据可视化等。Apriori算法是一种关联规则学习的经典算法，主要用于在大型数据库中发现项集之间的有趣关联关系。Apriori算法的核心思想是利用频繁项集的性质来减少搜索空间，从而提高算法的效率。(三). 函数——将数据转换成适合进行关联规则挖掘的格式。
数据挖掘-关联分析与Apriori算法详解
04-03
数据挖掘|关联分析与Apriori算法详解
Apriori算法对购物篮进行关联分析-Apriori算法进行购物篮关联分析.rar
08-12
Apriori算法对购物篮进行关联分析-Apriori算法进行购物篮关联分析.rar 大家好，出来乍到，看到好多高手分享自己的程序，我也想分享一下，做出自己的贡献。 虽然学MATLAB已经一年有余，但是一直忙着数学建模，对程序设计研究的不是特别深，不足之处请大家指教，谢谢。 这是以前我做过的一个题，《大型超市购物栏分析》，详细的题目、数据、MATLAB源程序、以及Apriori算法的简介和流程 都在压缩包里面，在这里我就不再赘述了。 Apriori算法进行购物篮关联分析.rar
Apriori（关联分析算法）
热门推荐
weixin_44757834的博客
06-21 1万+
关联分析又称关联挖掘，就是在交易数据、关系数据或其他信息载体中，查找存在于项目集合或对象集合之间的频繁模式、关联、相关性或因果结构。
数据挖掘——关联分析算法
张小鱼的博客
05-31 2171
本文主要介绍关联分析算法简介以及相关的案例举例说明与代码解释关联分析算法是一种用于挖掘大规模数据集中有趣关系的方法。其目标是找出数据集中频繁出现的item集合，以及item之间的关联规则。1. 数据预处理：读取数据集，计算每个item的出现次数，并按照出现次数从高到低排序。2. 生成候选项集：从单个item开始，逐步生成包含多个item的项集。3. 计算项集的支持度：对于每个项集，计算其在数据集中出现的支持度，即项集中所有item在数据集中同时出现的次数。
《数据分析实战》总结三之关联分析算法Apriori+连接分析算法PageRank+常用的数据挖掘算法逻辑回归
10-27 2721
1 关联分析算法：Apriori 关联规则挖掘的重要算法：Apriori 关联规则挖掘可以让我们从数据集中发现项与项（item 与 item）之间的关系 概念： 支持度：指的是某个物品在组合中出现的次数与总次数之间的比例。支持度越高，代表这个组合出现的频率越大。 置信度：指的是在 A 发生的情况下，B 发生的概率是多少。 提升度：指的是A的发生对B的发生概率提升的程度。 公式：提升度 (A→B)...
机器学习算法（八）：关联分析
weixin_39910711的博客
04-11 3439
目录 1 关联分析相关概念 2 Apriori算法 2.1 基本概念 2.2 例子 2.3 缺点 2.4 改进 3 FP-growth算法 3.1 基本概念 3.2 例子 3.2.1构建FP-tree 3.2.2从FP-tree中挖掘频繁模式（Frequent Patterns） 1 关联分析相关概念 关联分析又称关...
python使用Apriori算法进行关联性解析
12-23
从大规模数据集中寻找物品间的隐含关系被称作关联分析或关联规则学习。过程分为两步：1.提取频繁项集。2.从频繁项集中抽取出关联规则。 频繁项集是指经常出现在一块的物品的集合。 关联规则是暗示两种物品之间可能存在很强的关系。 一个项集的支持度被定义为数据集中包含该项集的记录所占的比例，用来表示项集的频繁程度。支持度定义在项集上。 可信度或置信度是针对一条诸如{尿布}->{葡萄酒}的关联规则来定义的。这条规则的可信度被定义为“支持度({尿布，葡萄酒})/支持度({尿布})”。 寻找频繁项集 Apriori原理：如果某个项集是频繁的，那么它的所有子集也是频繁的。反过来，如果一个项集是非频繁项
apriori.rar_Apriori_Apriori算法_apriori code_关联分析_关联规则
07-14
apriori算法MATLAB源码，用于处理多数据的关联规则分析
使用Apriori算法进行关联规则挖掘的实验报告与代码实现
04-06
电子科技大学数据挖掘课程 第二次实验 关联规则挖掘 实验报告及代码实现 包括频繁项集获取过程 关联规则获取过程 自认为理解&写得还是很透彻的哈哈哈 没看懂可以来找我~
头歌（educoder）机器学习实践：超市商品购买关联规则分析
qq_46023503的博客
12-05 2370
超市购物清单关联规则分析
【数据挖掘 | 关联性分析】万字长文详解关联性分析，详解Apriori算法为例，确定不来看看？
计算机魔术师的blog
10-25 2733
【数据挖掘 | 关联性分析】万字长文详解关联性分析，详解Apriori算法为例，确定不来看看？
关联分析的算法介绍以及案例实现
DWNMD的博客
05-10 8952
概念介绍 关联分析又称关联挖掘：发现存在于大量数据集中的关联性或相关性，进行智能推荐。 事务 相当于用户的篮子，篮子里面可能是1项集，也可能是4项集。 项集 篮子里所有的物品构成一个集合。在关联分析中，包含0个或者多个项的集合被称为项集（itemset）。 频繁项集 满足最小支持阈值的所有项集 支持度(support) 项集X的支持度：s(X)=σ(X)/N 规则X==>Y表示前提项目X对结果项目Y的支持度，也就是前提项目X和结果项目Y同时出现的概率 support(X—>Y)=P（XY）
推荐算法——Apriori算法原理
sz1125218970的博客
09-28 1335
首先名字别读错：an pu ruo ao rui 【拼音发音】Apriori是一种推荐算法推荐系统：从海量数据中，帮助用户进行信息的过滤和选择。主要推荐方法有：基于内容的推荐、协同过滤推荐、基于关联规则的推荐、基于知识的推荐、混合推荐。关联分析：是一种在大规模数据集中寻找有趣关系的非监督学习算法，是利用一些有趣性的量度来识别数据库中发现的强规则。
数据挖掘-关联分析 Apriori算法和FP-growth 算法
mike_jun的博客
07-12 7028
•1.关联分析概念 关联分析是从大量数据中发现项集之间有趣的关联和相关联系。 •定义： 1、事务：每一条交易称为一个事务，如上图包含5个事务。 2、项：交易的每一个物品称为一个项，例如豆奶，啤酒等。　 3、项集：包含零个或多个项的集合叫做项集，例如{尿布，啤酒}。 4、k−项集：包含k个项的项集叫做k-项集，例如 {豆奶，橙汁}叫做2-项集。 5、支持度计数：一个项集出现在几个事务当...
Apriori算法进行关联分析
09-09
Apriori算法是一种用于关联分析的经典算法。它通过扫描数据集多次来发现频繁项集，并基于频繁项集生成关联规则。 关联分析是一种数据挖掘技术，用于发现数据中的关联关系。在关联分析中，频繁项集和关联规则是核心概念。 频繁项集是指在数据集中经常同时出现的项目的集合。Apriori算法通过扫描数据集多次来确定频繁项集。它采用了一个重要的性质，即如果一个项集是频繁的，那么它的所有子集也是频繁的。这个性质称为Apriori性质。 Apriori算法的工作流程如下： 1. 扫描数据集，统计每个项的支持度（出现的频率）。 2. 根据设定的最小支持度阈值，找出满足条件的频繁项集。 3. 使用频繁项集生成候选项集。 4. 过滤候选项集，去除不满足Apriori性质的项集。 5. 重复步骤2到4，直到无法再生成新的频繁项集为止。 一旦得到频繁项集，就可以生成关联规则。关联规则是由频繁项集推导出来的条件语句，形如"A -> B"，表示项集A出现时，项集B也经常出现。关联规则的度量指标包括支持度、置信度和提升度等，用于评估规则的可靠性和有用性。 通过Apriori算法进行关联分析，可以帮助我们发现数据中的隐藏关系，例如购物篮分析、市场篮子分析等。它在市场营销、推荐系统、商品陈列优化等领域有着广泛的应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值