精华内容
下载资源
问答
  • #Python中的关联规则挖掘 文件描述: apriori.py:apriori算法Python实现。 此代码读取用户指定的事务数据库文件,并根据用户指定的支持和置信度值生成频繁的项目集和关联规则。 DataSetx.txt:(x:1,2,3,4,5)...
  • 西电数据挖掘作业——关联规则aprior算法python实现,我自己在python3.6已经能够成功实现,没有问题
  • 机器学习之关联规则挖掘Apriori算法

    对于一个算法的讲解,我的习惯是从一个比较小的例子或者从背景开始讲起,所以前面是引入,对机器学习有一点了解的可以跳过前奏,直接看算法部分,希望我的讲解对大家有所帮助:

    - 案例
    -“啤酒与尿布”的故事产生于20世纪90年代的美国沃尔玛超市中,沃尔玛的超市管理人员分析销售数据时发现了一个令人难于理解的现象:在某些特定的情况下,“啤酒”与“尿布”两件看上去毫无关系的商品会经常出现在同一个购物篮中,这种独特的销售现象引起了管理人员的注意,经过后续调查发现,这种现象出现在年轻的父亲身上。
    这里写图片描述
    那么,这个结论是如何得出的呢?下面我们先简单介绍几个相关概念
    关联分析:从大规模数据集中寻找物品间的隐含关系被称作关联分析或者关 联规则学习。这些关系可以有两种形式:频繁项集或者关联规则。
    频繁项集:经常出现在一块的物品的集合,也就是所有支持度大于最小支持度的项集称为频繁项集。
    关联规则:暗示两种物品之间可能存在很强的关系,形如A->B的表达式,A、B均为某子集,且A与B的交集为空。
    通过一个简单的例子认识一下概念:
    这里写图片描述
    {葡萄酒,尿布,豆奶}这个集合就是频繁项集。尿布—>葡萄酒就是一个关联规则。
    寻找频繁项集时,频繁定义是什么???
    再引入两个概念
    支持度:定义为数据集中包含该项集的记录所占比例。
    {豆奶}的支持度为4/5。
    {豆奶,尿布}的支持度为3/5。、
    置信度(可信度):针对一条诸如{尿布}—>{葡萄酒}的关联规则来定义的。
    这条规则定义为支持度({尿布,葡萄酒})/支持度({尿布})=(3/5)/(4/5)=75%
    支持度和可信度是用来量化关联分析是否成功的方法,那么,假设想要找到支持度大于某个值的所有项集,如何做???
    (最简单的办法就是生成物品所有可能清单,对每一种组合计算其频繁程度。但当物品种类众多时呢???)
    下面我们正式进入Apriori算法:
    这里写图片描述

    原理: 如果某个项集是频繁的,那么它的所有子集也是频繁的,换句话说,如果一个项集是非频繁集,那么它的所有超集也是非频繁的。
    图中,若已知阴影项集{2,3}是非频繁的。利用Apriori原理,项集{0,2,3},{1,2,3},{0,1,2,3}也是非频繁的。也就是说,一旦计算出了{2,3}的支持度,知道它是非频繁集厚,就不需要再计算{0,2,3},{1,2,3},{0,1,2,3}的支持度了,避免了项集数目的指数增长。
    算法流程图:
    这里写图片描述
    输入: 数据集[[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
    最小支持度0.5

    步骤1:候选集C1为{[1],[2],[3],[4],[5]}
    支持度分别为0.5,0.75,0.75,0.25,0.75

    步骤2:频繁集L1为{[1],[2],[3],[5]}

    步骤3:候选集C2为{[1,2],[1,3],[1,5],[2,3],[2,5],[3,5]}
    支持度分别为0.25,0.5,0.25,0.25,0.5,0.75,0.5

    步骤4:频繁集L2为{[1,3],[2,3],[2,5],[3,5]}

    步骤5:候选集C3为{[1,3,5],[2,3,5]}
    支持度分别为0.25,0.5

    步骤6:频繁集L3为{[2,3,5]}

    步骤7:候选集C4为{[]}

    结束。
    从频繁项集中挖取关联规则
    这里写图片描述
    一条规则P→H的可信度定义为support(P∪H)/support(P)
    类似于频繁项集的生成,可以为每个频繁项集产生许多关联规则。根据Apriori原理,如果某条规则并不满足最小可信度要求,那么该规则的所有子集也不会满足最小可信度要求。 对于右图,如果0,1,2→3不满足最小可信度要求,那么左部{0,1,2}的所有子集的规则也不会满足。
    关联规则生成函数简介
    类似于Apriori算法,可以首先从一个频繁项集开始,接着创建一个规则列表,其中规则右部只包含一个元素,对这些规则进行测试。
    接下来合并所有剩余规则来创建一个新的列表规则,其中规则右部包含两个元素。
    - 代码
    - `#!/usr/bin/python
    # coding=utf-8
    import numpy as np
    import time
    import csv
    import os

    fp = []
    def loadDataSet():
    with open(‘fp.csv’, ‘rb’) as f:
    reader = csv.reader(f)
    for row in reader:
    fp.append(row)
    return fp

    def createDataset(fileName):
    fr = open(fileName)
    read_line = fr.readlines()
    support =[]
    for line in read_line:
    line = line.strip().replace(‘,’,’ ‘).strip()
    splitLine = line.split(’ ‘)
    m =len(splitLine)
    data_Mat = np.zeros((1,m))
    data_Mat[:]=splitLine[:]
    support.append(data_Mat[0,: ])
    return support

    def createC1(dataSet):
    # 构建所有候选项集的集合
    C1 = []
    for transaction in dataSet:
    for item in transaction:
    if not [item] in C1:
    C1.append([item])
    # C1添加的是列表,对于每一项进行添加,{1},{3},{4},{2},{5}
    C1.sort()
    return map(frozenset, C1)
    # 使用frozenset,被“冰冻”的集合,为后续建立字典key-value使用。
    def scanD(D, Ck, minSupport):
    # 由候选项集生成符合最小支持度的项集L。参数分别为数据集、候选项集列表,最小支持度
    ssCnt = {}
    for tid in D: # 对于数据集里的每一条记录
    for can in Ck: # 每个候选项集can
    if can.issubset(tid):
    # 若是候选集can是作为记录的子集,那么其值+1,对其计数
    if not ssCnt.has_key(can):
    #ssCnt[can] = ssCnt.get(can,0)+1一句可破,没有的时候为0,加上1,有的时候用get取出,加1
    ssCnt[can] = 1
    else:
    ssCnt[can] += 1
    numItems = float(len(D))
    retList = []
    supportData = {}
    for key in ssCnt:
    support = ssCnt[key] / numItems # 除以总的记录条数,即为其支持度
    if support >= minSupport:
    retList.insert(0, key) # 超过最小支持度的项集,将其记录下来。
    supportData[key] = support
    return retList, supportData

    def aprioriGen(Lk, k): # 创建符合置信度的项集Ck,
    retList = []
    lenLk = len(Lk)
    for i in range(lenLk):
    for j in range(i + 1,lenLk):
    # k=3时,[:k-2]即取[0],对{0,1},{0,2},{1,2}这三个项集来说,L1=0,L2=0,
    # 将其合并得{0,1,2},当L1=0,L2=1不添加,
    L1 = list(Lk[i])[:k - 2]
    L2 = list(Lk[j])[:k - 2]
    L1.sort()
    L2.sort()
    if L1 == L2:
    retList.append(Lk[i] | Lk[j])
    return retList

    def apriori(dataSet, minSupport):
    C1 = createC1(dataSet)
    D = map(set, dataSet)
    L1, supportData = scanD(D, C1, minSupport)
    L = [L1] # L将包含满足最小支持度,即经过筛选的所有频繁n项集,这里添加频繁1项集
    k = 2
    while (len(L[k - 2]) > 0): # k=2开始,由频繁1项集生成频繁2项集,
    # 直到下一个打的项集为空
    Ck = aprioriGen(L[k - 2], k)
    Lk, supK = scanD(D, Ck, minSupport)
    supportData.update(supK) # supportData为字典,存放每个项集的支持度,
    # 并以更新的方式加入新的supK
    L.append(Lk)
    k += 1
    return L, supportData

    #< span style = “font-size:18px;” > # ===============关联规则生成函数==================

    def generateRules(L, supportData, minConf):
    bigRuleList = [] # 规则存放在bigRuleList列表中
    for i in range(1, len(L)):
    for freqSet in L[i]: # L0是频繁1项集,没关联规则
    H1 = [frozenset([item]) for item in freqSet]
    # H1存放频繁i项集的某个频繁项集的单个元素集合,
    # 频繁3项集的{0,1,2}的{{0},{1},{2}
    if i > 1:
    rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
    # 从频繁3项集开始,从置信度算出关联规则
    else:
    calcConf(freqSet, H1, supportData, bigRuleList, minConf)
    # 对频繁2项集,计算置信度
    return bigRuleList

    def calcConf(freqSet, H, supportData, br1, minConf):
    # 计算置信度函数,conf为最小可信度
    prunedH = []
    for conseq in H:
    conf = supportData[freqSet] / supportData[freqSet - conseq] # conf({2}) = s({{0},{1},{2}})/s({{0},{1},{2}}-{2})
    if conf >= minConf:
    try:
    tra = open(“result.txt”,’a’)
    except:
    print “Error”
    tra.write(str(freqSet - conseq))
    tra.write(“–>”)
    tra.write(str(conseq))
    tra.write(“conf:”)
    tra.write(str(conf))
    tra.write(“\n”)
    print(str(conf))
    print freqSet - conseq, “——>”, conseq, “conf:”, conf
    # 那么有{{0},{1}}——>{{2}}
    br1.append((freqSet - conseq, conseq, conf))
    prunedH.append(conseq)
    return prunedH

    def rulesFromConseq(freqSet, H, supportData, br1, minConf):
    m = len(H[0]) # m,频繁m项集
    if (len(freqSet)) > (m + 1):
    Hmp1 = aprioriGen(H, m + 1) # 由H,创建m+1项集
    Hmp1 = calcConf(freqSet, Hmp1, supportData, br1, minConf)
    # 保留符合置信度的m+1项集,Hmp1 = prunedH
    if (len(Hmp1) > 1):
    rulesFromConseq(freqSet, Hmp1, supportData, br1, minConf)

    if name ==”main“:
    #os.remove(‘result.txt’)

    start = time.clock()
    dataSet = createDataset('fp.csv')
    #print "数据集D:\n", D
    #print "所有候选1项集C1:\n", C1
    #L1, supportData0 = scanD(D, C1, 0.0025)
    #print '符合最小支持度的频繁1项集L1:\n', L1
    #L, suppData = apriori(dataSet)
    #print "所有符合最小支持度0.029的项集L:\n", L
    #print "频繁2项集:\n", aprioriGen(L[0], 2)
    #L, suppData = apriori(dataSet, minSupport=0.7)
    #print "所有符合最小支持度为0.7的项集L:\n", L
    L, suppData = apriori(dataSet, minSupport=0.015)
    #print "最小可信度阈值为0.8"
    print(L)
    try:
        da = open('result.txt',"a")
    except:
        print "Error"
    
    da.write(str(L))
    rules = generateRules(L, suppData, minConf=0.7)
    print rules
    end =time.clock()
    print "程序运行时间为:",end,"s"
    #print("最小可信度阈值为0.5")
    #rules = generateRules(L, suppData, minConf=0.5)
    #print rules #< / span >
    

    实验数据:
    IT类招聘能力需求信息
    [10,13,44,45]
    [5]
    [3]
    [13,44,45]
    [3,11,16,17,43,44,45,68,74]
    [3,9,17,63,64]
    [3,12,16,43,45,63,69,74]
    [3,8,9,10,12,15,16,17,19,26,32,43,44,45,46,47,48,49,51,57,63,65,66,67,72]
    [47]
    [2,3,5,8,9,10,11,13,14,15,16,17,19,32,33,37,43,44,45,46,49,51,56,58,59,62,67,68,71,74,76]
    [3,5,8,9,10,12,15,16,17,18,19,27,43,44,45,46,47,49,51,65,66,67,73]
    [3,43]
    [66]
    [62]
    … …
    实验结果
    支持度是:2.9%(一项集支持度的平均值)
    频繁一项集:
    [[(PHP), (Ajax), (JavaScript), (CSS), (Photoshop), (Oracle), (AI), (Tomcat), (Linux), (python), (数据挖掘), (C++), (机器学习), (单片机), (Spring), (JAVA), (HTML5), (Android), (HTML), (MySQL), (iOS), (图像处理), (hibernate), (socket)]
    频繁二项集:
    [([Linux, JAVA]), ([JavaScript, CSS]), ([JavaScript, HTML]), ([JAVA, CSS]), ([JAVA, JavaScript]), ([JAVA, PHP]), ([HTML5, HTML]), ([JAVA, HTML]), ([Spring, hibernate]), ([Linux, MySQL]), ([Oracle, JAVA]), ([MySQL, Oracle]), ([python, JAVA]), ([JAVA, Spring]), ([HTML, CSS]), ([MySQL, JAVA])]
    频繁三项集:
    [([JavaScript, HTML, CSS]), ([JAVA, HTML, CSS]), ([JavaScript, JAVA, CSS]), ([JavaScript, JAVA, HTML])]
    频繁四项集:
    [([JAVA, JavaScript, HTML, CSS])], []]

    可信度是:0.5
    (JavaScript) ————> (HTML) 可信度:0.563352826511
    (JavaScript) ————> (JAVA) 可信度:1.0
    (HTML5) ————> (HTML) 可信度:1.0
    (hibernate) ————> (Spring) 可信度:0.735380116959
    (Spring) ————> (JAVA) 可信度:0.558576371725
    (CSS) ————> (HTML) 可信度:0.666278731452
    (HTML) ————> (CSS) 可信度:0.564178369056
    (JavaScript) ————> ([JAVA, HTML]) 可信度:0.563352826511
    ([JavaScript, CSS]) ————> ([JAVA, HTML]) 可信度:0.856103476152
    ([JavaScript, HTML]) ————> ([JAVA, CSS]) 可信度:0.732871972318
    ([JAVA, CSS]) ————> ([JavaScript, HTML]) 可信度:0.657355679702
    ([JAVA, HTML]) ————> ([JavaScript, CSS]) 可信度:0.523738872404

    可信度是:0.7
    (JavaScript) ————> (JAVA) 可信度:1.0
    (HTML5) ————> (HTML) 可信度:1.0
    (hibernate) ————> (Spring) 可信度:0.735380116959
    ([JavaScript, CSS]) ————> ([JAVA, HTML]) 可信度:0.856103476152
    ([JavaScript, HTML]) ————> ([JAVA, CSS]) 可信度:0.732871972318
    希望对大家有所帮助,如有错误,还需大家指正。

    展开全文
  • 关联规则挖掘是一种识别不同项目之间潜在关系的技术。以超级市场为例,客户可以在这里购买各种商品。通常,客户购买的商品有一种模式。例如,有婴儿的母亲购买婴儿产品,如牛奶和尿布。少女可以购买化妆品,而单身汉...

    关联规则挖掘是一种识别不同项目之间潜在关系的技术。以超级市场为例,客户可以在这里购买各种商品。通常,客户购买的商品有一种模式。例如,有婴儿的母亲购买婴儿产品,如牛奶和尿布。少女可以购买化妆品,而单身汉可以购买啤酒和薯条等。总之,交易涉及一种模式。如果可以识别在不同交易中购买的物品之间的关系,则可以产生更多的利润。

    例如,如果项目A和项目B的购买频率更高,则可以采取几个步骤来增加利润。例如:A和B可以放在一起,这样,当客户购买其中一种产品时,他不必走很远就可以购买另一种产品。

    购买某一种产品的人可以通过广告活动来定位以购买另一种产品。

    如果客户购买了这两种产品,则可以在这些产品上提供折扣。

    A和B都可以包装在一起。

    识别产品之间的关联的过程称为关联规则挖掘。

    关联规则挖掘的Apriori算法

    已经开发出不同的统计算法来实现关联规则挖掘,而Apriori就是这样一种算法。在本文中,我们将研究Apriori算法背后的理论,稍后将在Python中实现Apriori算法。

    先验算法理论

    支持度

    支持是指商品的默认受欢迎程度,可以通过查找包含特定商品的交易数量除以交易总数来计算。假设我们想找到对项目B的支持。可以将其计算为:Support(B) = (Transactions containing (B))/(Total Transactions)

    例如,如果在1000个事务中,有100个事务包含Ketchup,则对项目Ketchup的支持可以计算为:Support(Ketchup) = (Transactions containingKetchup)/(Total Transactions) Support(Ketchup) = 100/1000 = 10%

    置信度

    置信度是指如果购买了商品A,也购买了商品B的可能性。可以通过找到一起购买A和B的交易数量除以购买A的交易总数来计算。从数学上讲,它可以表示为:Confidence(A→B) = (Transactions containing both (A and B))/(Transactions containing A)

    回到我们的问题,我们有50笔交易,汉堡和番茄酱是一起购买的。在150笔交易中,会购买汉堡。然后我们可以发现购买汉堡时购买番茄酱的可能性可以表示为Burger-> Ketchup的置信度,并且可以用数学公式写成:Confidence(Burger→Ketchup) = (Transactions containing both (Burger and Ketchup))/(Transactions containing A) Confidence(Burger→Ketchup) = 50/150 = 33.3%

    提升度

    Lift(A -> B)指当出售A时B的出售比例的增加。提升(A –> B)可以通过除Confidence(A -> B)以来计算Support(B)。从数学上讲,它可以表示为:Lift(A→B) = (Confidence (A→B))/(Support (B))

    回到我们的汉堡和番茄酱问题,Lift(Burger -> Ketchup)可以计算为:Lift(Burger→Ketchup) = (Confidence (Burger→Ketchup))/(Support (Ketchup)) Lift(Burger→Ketchup) = 33.3/10 = 3.33

    Lift基本上告诉我们,一起购买汉堡和番茄酱的可能性是仅购买番茄酱的可能性的3.33倍。

    Apriori算法涉及的步骤

    对于大量数据,成千上万的交易中可能有数百个项目。Apriori算法尝试为每种可能的项目组合提取规则。例如,可以为项目1和项目2,项目1和项目3,项目1和项目4,然后是项目2和项目3,项目2和项目4,然后是项目1,项目2和项目3的组合计算提升。项目3;类似地,项目1,项目2和项目4,依此类推。

    用Python实现Apriori算法

    从理论上讲,现在是时候看看Apriori算法了。在本节中,我们将使用Apriori算法查找规则,这些规则描述了在法国零售商店一周进行7500次交易的不同产品之间的关联。

    另一个有趣的一点是,我们不需要编写脚本来为所有可能的项目组合计算支撑度,置信度和提升度。我们将使用一个现成的库,其中所有代码都已实现。

    我指的是apyori库,可以在这里找到源。我建议您在继续之前,在Python库的默认路径中下载并安装该库。

    注意:本文中的所有脚本均已使用Spyder IDE for Python 执行。

    请按照以下步骤在Python中实现Apriori算法:

    导入库

    与往常一样,第一步是导入所需的库。

    导入数据集

    现在,我们导入数据集执行以下脚本:store_data = pd.read_csv('D:\\Datasets\\store_data.csv')

    让我们调用该head()函数以查看数据集:store_data.head()

    185800202_1_20200319115040163.png

    上面的屏幕快照中显示了数据集的摘要。如果仔细查看数据,我们可以看到标题实际上是第一个事务。每行对应一个交易,每列对应于在该特定交易中购买的商品。在NaN告诉我们,列所代表的项目在具体的交易没有购买。

    在此数据集中没有标题行。 如下所示:store_data = pd.read_csv('D:\\Datasets\\store_data.csv', header=None)

    现在执行head()函数:store_data.head()

    185800202_2_20200319115040366现在,我们将使用Apriori算法来找出哪些商品通常一起出售,以便商店所有者可以采取行动将相关商品放在一起或一起做广告 。

    数据处理

    我们将要使用的Apriori库要求我们的数据集采用列表列表的形式,其中整个数据集是一个大列表,而数据集中的每个事务都是外部大列表中的一个内部列表。

    应用

    下一步是将Apriori算法应用于数据集。为此,我们可以使用apriori从apyori库导入的类。

    在第二行中,我们将apriori类找到的规则转换为,list因为这样更容易查看结果。

    查看结果

    首先让我们找到apriori该类挖掘的规则总数。执行以下脚本:上面的脚本应返回48。每个项目对应一个规则。

    让我们打印association_rules列表中的第一项以查看第一条规则。执行以下脚本:输出应如下所示:RelationRecord(items=frozenset({'light cream', 'chicken'}), support=0.004532728969470737, ordered_statistics[OrderedStatistic(items_base=frozenset({'light cream'}), items_add=frozenset({'chicken'}), confidence=0.29059829059829057, lift=4.84395061728395)])

    列表中的第一项是包含三项的列表本身。列表的第一项显示规则中的杂货项目。

    例如,从第一项开始,我们可以看到淡奶油和鸡肉通常一起购买。这是有道理的,因为购买淡奶油的人对自己吃的东西很谨慎,因此他们更有可能购买鸡肉即白肉而不是红肉即牛肉。或这可能意味着淡奶油通常用于鸡肉食谱中。

    第一条规则的支持值为0.0045。该数字是通过将含淡奶油的交易次数除以交易总数得出的。该规则的置信度为0.2905,这表明在所有包含轻奶油的交易中,29.05%的交易也包含鸡肉。最终,提升4.84告诉我们,与默认销售鸡肉的可能性相比,购买淡奶油的顾客购买鸡肉的可能性高4.84倍。

    以下脚本以更清晰的方式显示每个规则的规则,支撑,置信度和提升:如果执行上述脚本,您将看到apriori该类返回的所有规则。apriori该类返回的前四个规则如下所示:Rule: light cream -> chicken Support: 0.004532728969470737 Confidence: 0.29059829059829057 Lift: 4.84395061728395 ===================================== Rule: mushroom cream sauce -> escalope Support: 0.005732568990801126 Confidence: 0.3006993006993007 Lift: 3.790832696715049 ===================================== Rule: escalope -> pasta Support: 0.005865884548726837 Confidence: 0.3728813559322034 Lift: 4.700811850163794 ===================================== Rule: ground beef -> herb & pepper Support: 0.015997866951073192 Confidence: 0.3234501347708895 Lift: 3.2919938411349285 =====================================

    我们已经讨论了第一条规则。现在让我们讨论第二条规则。第二条规则指出,经常购买蘑菇奶油酱和无骨牛排。蘑菇奶油酱的支持量是0.0057。

    结论

    关联规则挖掘算法(例如Apriori)对于查找数据项之间的简单关联非常有用。它们易于实现并且具有很高的解释能力。

    展开全文
  • 运行 FP-Growth 算法 ./main input_file minsup minconf 输出 该程序首先打印频繁模式: { frequent itemset } (support of the frequent item set) 例如。 { a } ( 3 ) { a c } ( 3 ) { a c f } ( 3 ) { a f }...
  • 详解python实现FP-TREE进行关联规则挖掘 python3.2实现,可以生成每一步fp树的图片(需要安装PIL)
  • Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。 该算法的基本思想是:首先找出所有的频集,这些项集出现的频繁性至少和预定义的最小支持...
  • 等价类转换关联规则挖掘算法Python实现 我在无聊的时候写了这篇文章,并希望找到一个很好的算法来加快Cython的速度。 不幸的是,这个问题并不能轻易实现优化(而频繁模式挖掘的FP-tree方法要快得多)。 该算法在...
  • #寻找关联规则的函数 def find_rule(d, support, confidence, ms = u'--'): result = pd.DataFrame(index=['support', 'confidence']) #定义输出结果 support_series = 1.0*d.sum()/len(d) #支持度序列 ...
  • 关联规则Apriori算法Python实现带数据集,Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。
  • 关联规则挖掘中有几个经典算法,Apriori算法因为其效率比较低,时间复杂度很高,因此韩佳伟改进了该算法,附件是fp-growth的python实现。
  • B)苍天不负有心人啊,我玩了两三个周的文本挖掘,终于实现了,我心甚慰!!!甚慰一开始参考的别人的代码,数据只能分析一个字符的字符串,我这个可以分析多少个字符的字符串都没得问题啦,美滋滋,下面的代码直接...

    支持度

    Support(支持度):表示同时包含A和B的事务占所有事务的比例。如果用P(A)表示使用A事务的比例,那么Support=P(A&B)

    苍天不负有心人啊,我玩了两三个周的文本挖掘,终于实现了,我心甚慰!!!甚慰

    一开始参考的别人的代码,数据只能分析一个字符的字符串,我这个可以分析多少个字符的字符串都没得问题啦,美滋滋,下面的代码直接复制可能会有个别缩进问题,这个是因为我网络不好,所有只能一段一段代码复制,一下子全复制上去会卡死

    好啦,废话不多说,上干货

    置信度

    Confidence(可信度):表示使用包含A的事务中同时包含B事务的比例,即同时包含A和B的事务占包含A事务的比例

    实现代码

    import random

    import numpy as np

    class Association_rules:

    def __init__(self,minSupport=0.2,minConfidence=0.5):

    '''

    minSuport:最小支持度

    minConfidence:最小置信度

    dataset:数据集

    count:存放frequent itemsets 以及 support

    associationRules:满足minConfidence的关联规则

    num:元素数量

    threshold = num*minSupport:由num和minSupport算出的阈值

    '''

    self.minSupport = minSupport

    self.minConfidence = minConfidence

    self.dataset = None

    self.count = None

    self.associationRules = None

    self.num = 0

    展开全文
  • 关联规则挖掘算法

    千次阅读 2018-08-31 20:06:08
    关联规则挖掘是一种基于规则的机器学习算法,该算法可以在大数据库中发现感兴趣的关系。它的目的是利用一些度量指标来分辨数据库中存在的强规则。也即是说关联规则挖掘是用于知识发现,而非预测,所以是属于无监督的...

    关联规则挖掘是一种基于规则的机器学习算法,该算法可以在大数据库中发现感兴趣的关系。它的目的是利用一些度量指标来分辨数据库中存在的强规则。也即是说关联规则挖掘是用于知识发现,而非预测,所以是属于无监督的机器学习方法。

    “尿布与啤酒”是一个典型的关联规则挖掘的例子,沃尔玛为了能够准确了解顾客在其门店的购买习惯,对其顾客的购物行为进行购物篮分析,想知道顾客经常一起购买的商品有哪些。沃尔玛利用所有用户的历史购物信息来进行挖掘分析,一个意外的发现是:"跟尿布一起购买最多的商品竟是啤酒!

    关联规则挖掘算法不仅被应用于购物篮分析,还被广泛的应用于网页浏览偏好挖掘,入侵检测,连续生产和生物信息学领域。

    与序列挖掘算法不同的是,传统的关联规则挖掘算法通常不考虑事务内或者事件之间的顺序

    支持度和置信度

    那么我们如何能够从所有可能规则的集合中选择感兴趣的规则呢?需要利用一些度量方法来筛选和过滤,比较有名的度量方法是最小支持度(minimum support)最小置信度(minimum confidence)

    假定我们一个数据库包含5条事务,每行表示一个购物记录,1 表示购买,0 表示没有购买,如下图表格所示:

    ID | milk | bread | butter | beer | diapers
    ----|------|------|------|----
    1 | 1| 1 | 0 | 0 | 0
    2| 0| 0| 1| 0| 0
    3| 0| 0| 0| 1| 1
    4| 1| 1| 1| 0| 0
    5| 0| 1| 0| 0| 0

    让 X,Y 各表示为一个 item-set, X ⇒ Y 表示为一条规则(尿布 ⇒ 啤酒 就是一条规则),用 T 表示为事务数据库(并不是说只局限于事务数据库)。

    支持度(Support)

    支持度表示 item-set 在整个 T 中出现的频率。假定 T 中含有 N 条数据,那么支持度的计算公式为:

    譬如在上面的示例数据库中,{beer, diaper} 的支持度为 1/5 = 0.2。5 条事务中只有一条事务同事包含 beer和 diaper ,实际使用中我们会设置一个最低的支持度(minimum support),那些大于或等于最低支持度的 X 称之为频繁的 item-set 。

    置信度(Confidence)

    置信度表示为规则 X ⇒ Y 在整个 T 中出现的频率。而置信度的值表示的意思是在包含了 X 的条件下,还含有 Y 的事务占总事务的比例。同样假定 T 中含有 N 条数据,那么置信度的计算公式为:

    譬如再上面的示例数据库中,{beer, diaper} 的置信度为 0.2/0.2 = 1。表面在所有包含 beer 的事务中都会一定包含 diaper。同样的,在实际使用中我们会设置一个最低置信度,那些大于或等于最小置信度的规则我们称之为是有意义的规则。

    相关性度量

    有时候使用支持度和置信度挖掘到的规则可能是无效的。

    举个例子:

    10000 个事务中, 6000 个事务包含计算机游戏, 7500 个包含游戏机游戏, 4000 个事务同时包含两者。关联规则(计算机游戏 ⇒ 游戏机游戏) 支持度为 0.4 ,看似很高,但其实这个关联规则是一个误导。在用户购买了计算机游戏后有 (4000÷6000) = 0.667 的概率的去购买游戏机游戏,而在没有任何前提条件时,用户反而有 (7500÷10000) = 0.75的概率去购买游戏机游戏,也就是说设置了购买计算机游戏这样的前置条件反而会降低用户去购买游戏机游戏的概率,所以计算机游戏和游戏机游戏是相斥的,也即表明是独立的。

    因此我们可以通过下面的一些相关性度量方法来筛选挖掘到的规则。

    提升度(Lift)

    提升度可以用来判断规则 X ⇒ Y 中的 X 和 Y 是否独立,如果独立,那么这个规则是无效的。

    计算提升度的公式如下:

    如果该值等于 1 ,说明两个条件没有任何关联。如果小于 1 ,说明 X 与 Y 是负相关的关系,意味着一个出现可能导致另外一个不出现。大于 1 才表示具有正相关的关系。一般在数据挖掘中当提升度大于 3 时,我们才承认挖掘出的关联规则是有价值的。

    他可以用来评估一个出现提升另外一个出现的程度。

    提升度是一种比较简单的判断手法,实际中受零事务(也即不包含 X 也不包含 Y 的事务)的影响比较大。所以如果数据中含有的零事务数量较大,该度量则不合适使用。

    全置信度 和 最大置信度

    给定两个项集 X 和 Y ,其全置信度为

    不难知道,最大置信度为

    全置信度和最大置信度的取值都是从 0 ~ 1 ,值越大,联系越大。

    该度量是不受零事务影响的。

    KULC 度量 + 不平衡比(IR)

    给定两个项集 X 和 Y,其 Kulczynski(Kulc) 度量定义为:

    可以看做是两个置信度的平均值,同样取值也是从 0 ~ 1,值越大,联系越大,关系越大。

    该度量同样也是不受零事务影响的。

    Apriori 算法

    在执行算法之前,用户需要先给定最小的支持度和最小的置信度。
    生成关联规则一般被划分为如下两个步骤:
    1、利用最小支持度从数据库中找到频繁项集。

    给定一个数据库 D ,寻找频繁项集流程如下图所示

    频繁项集的流程示意图

    C1 中 {1} 的支持度为 2/4 = 0.5 表示在 D 中的 4 条事务中,{1} 出现在其中的两条事务中,以后几个步骤的支持度计算方式也是类似的。假定给定的最小支持度为 0.5,那么最后我们可以得到一个包含 3 个项的频繁项集 {2 3 5}。

    另外,从图中我们可以看到 itemset 中所包含的 item 是从 1 增长到 3 的。并且每次增长都是利用上一个 itemset 中满足支持度的 item 来生成的,这个过程称之为候选集生成(candidate generation)。譬如说 C2 里就不包含 C1 中的 4 。

    2、利用最小置信度从频繁项集中找到关联规则。

    同样假定最小的置信度为 0.5 ,从频繁项集 {2 3 5} 中我们可以发现规则 {2 3} ⇒ {5} 的置信度为 1 > 0.5 ,所以我们可以说 {2 3} ⇒ {5} 是一个可能感兴趣的规则。

    从第一步中我们看出每次计算支持度都需要扫描数据库,这会造成很大的 I/O 开销,所以有很多变种的算法都会在该问题上进行优化(FP-Growth)。此外如何有效的生成候选集也是很多变种算法优化的问题之一(Apriori-all)。

    总结

    • 关联规则是无监督的学习算法,能够很好的用于知识的发现。
    • 缺点是很难严重算法的有效性,一般只能够通过肉眼观察结果是否合理。



    作者:曾梓华
    链接:https://www.jianshu.com/p/7d459ace31ab
    來源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • Apriori算法介绍:Apriori其实是为了降低搜索空间以及提高搜索速度而设计的一种算法,本文采用python实现,彻底理解“频繁项集的所有非空子集一定是频繁的”这句话,并实现连接步、剪枝步、规则生成、提升度计算等。...
  • 首先导入包含apriori算法的mlxtend库,pip install mlxtend调用apriori进行关联规则分析,具体代码如下,其中数据集选取本博客 “机器学习算法——关联规则” 中的例子,可进行参考,设置最小支持度(min_support)为...
  • 本资源包含5个文件夹,分别包含了Apripri、FPgrowth、ORAR、Eclat关联规则算法python实现代码和实验结果,其中Eclat有俩个文件夹,分别用了俩个数据集来实现。
  • 关联规则挖掘(Association rule mining)是数据挖掘中最活跃的研究方法之一,可以用来发现事情之间的联系,最早是为了发现超市交易数据库中不同的商品之间的关系。(啤酒与尿布) 基本概念 1、支持度的定义:support...
  • 这里写目录标题实验要求实验内容实现方法(代码)实验结果结论分析...关联规则发现是机器学习和数据挖掘中重要的算法之一,有许多版本变种和应用场景。关联规则发现算法的基础算法之一是Apriori算法 希望你能按照算法
  • Apriori 核心思想:通过连接产生候选项与其支持度,然后通过剪枝生成频繁项集。 关键概念: 项集:项的集合。... 最小置信度:关联规则的最低可靠性。 同时满足最小支持度阈值和最小置信度阈值的规则称作...
  • 挖掘建模③—关联规则python实现关联规则常用关联算法Apriori算法 关联规则 关联规则分析是数据挖掘中最活跃的研究方法之一,目的是在一个数据集中找出各项之间的关联关系,而这种关系并没有在数据中直接表示出来...
  • 关联规则算法是在一堆数据集中寻找数据之间的某种关联,通过该算法我们可以对数据集做关联分析——在大规模的数据中寻找有趣关系的任务。这些关系可以有两种形式:频繁项集、关联规则。 频繁项集:经常出现在一块的...
  • 关联规则挖掘算法之Apriori算法

    千次阅读 2020-10-07 20:33:35
    关联规则挖掘算法之Apriori算法一.关联规则挖掘中的几个概念二.关联规则算法   数据挖掘是指以某种方式分析数据源,从中发现一些潜在的有用的信息,其中关联规则挖掘是数据挖掘中的一个重要课题,它是从数据背后...
  • 关联规则Apriori算法及实现(python

    千次阅读 2018-08-12 17:39:53
    这八个定义包含了关联规则相关的几个重要基本概念,关联规则挖掘主要有两个问题: 找出交易数据库中所有大于或等于用户指定的最小支持度的频繁项集。 利用频繁项集生成所需要的关联规则,根据用户设定的最小...
  • 关联规则挖掘——Apriori及其优化关联规则挖掘基本介绍研究方向Apriori算法理论介绍代码实现手动编写Apriori(超级精炼版)使用Apyori包的Apriori方法FP-Growth算法关联规则挖掘基本介绍关联规则的概念最早是在Agrawal...
  • Python数据挖掘:概念、方法与实践。Megan Squire著,姚军译,机械工业出版社,2017年。笔记中有些内容直接引用原书。================================================================2.1 什么是频繁项集频繁项集...
  • 1、关联规则挖掘算法关联规则挖掘算法可以实现从两种经典算法Apriori或FP-Growth中任意选取算法,输出各个频繁项集和强关联规则。输入文件由本地导入,可自行设置最小支持度计数和最小置信度参数值。2、 Apriori算法...
  • 环境python版本:3.5数据来源数据来自51CTO网站的分享,点此下载关联规则所谓关联规则,就是指现实中同时发生两种不同事情之间的相关联程度,具体分析可以参考这篇博客,讲的很清晰数据分析这是数据文件数据文件其中...
  • 关联规则,Apriori算法python实现

    万次阅读 2017-06-03 21:41:26
    Apriori算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,897
精华内容 2,758
关键字:

关联规则挖掘算法python

python 订阅