精华内容
下载资源
问答
  • 【机器学习】四、关联规则原理及实例
    千次阅读
    2019-07-09 18:09:46

    一、关联规则简介
    关联规则(Apriori算法),又称为关联分析。其目的是找出,一堆事物中具有关联的事物。
    关联规则最经典的案例就是“啤酒与尿布”,沃尔玛拥有世界上最大的数据仓库系统,为了能够准确了解顾客在其门店的购买习惯,沃尔玛对其顾客的购物行为进行购物篮分析,想知道顾客经常一起购买的商品有哪些。沃尔玛数据仓库里集中了其各门店的详细原始交易数据。在这些原始交易数据的基础上,沃尔玛利用数据挖掘方法对这些数据进行分析和挖掘。码字不易,喜欢请点赞!!!
    在这里插入图片描述
    一个意外的发现是:"跟尿布一起购买最多的商品竟是啤酒!经过大量实际调查和分析,揭示了一个隐藏在"尿布与啤酒"背后的美国人的一种行为模式:在美国,一些年轻的父亲下班后经常要到超市去买婴儿尿布,而他们中有30%~40%的人同时也为自己买一些啤酒。产生这一现象的原因是:美国的太太们常叮嘱她们的丈夫下班后为小孩买尿布,而丈夫们在买尿布后又随手带回了他们喜欢的啤酒。

    二、关联规则
    关联规则最重要的就是支持度Support和置信度Confidence。

    1. 支持度的计算方法:
    #下面式中XY表示XY同时发生的次数,N表示总事物数
    support(X->Y) = XY/N
    
    1. 置信度的计算方法:
    confidence(X->Y) = support(X->Y) / support(X)
    <=>
    #XY表示XY同时发生的次数,X表示X发生的次数
    confidence(X->Y) = XY/X
    

    最终找到的规则,要满足支持度和置信度即可。

    三、关联规则使用
    关联规则的使用可以看我下面这篇博客,是一个公司机器学习岗位的笔试题。
    https://blog.csdn.net/Asher117/article/details/87745195

    更多相关内容
  • #资源达人分享计划#
  • 频繁模式和关联规则原理与简述

    千次阅读 2016-10-13 09:14:15
    频繁模式和关联规则: “啤酒与尿布”故事: 这是一个几乎被举烂的例子,“啤酒与尿布”的故事产生于20世纪90年代的美国沃尔玛超市中,沃尔玛的超市管理人员分析销售数据时发现了一个令人难于理解的现象:在某些特定...

    频繁模式和关联规则:

    “啤酒与尿布”故事:

    这是一个几乎被举烂的例子,“啤酒与尿布”的故事产生于20世纪90年代的美国沃尔玛超市中,沃尔玛的超市管理人员分析销售数据时发现了一个令人难于理解的现象:在某些特定的情况下,“啤酒”与“尿布”两件看上去毫无关系的商品会经常出现在同一个购物篮中,这种独特的销售现象引起了管理人员的注意,经过后续调查发现,这种现象出现在年轻的父亲身上。
    在美国有婴儿的家庭中,一般是母亲在家中照看婴儿,年轻的父亲前去超市购买尿布。父亲在购买尿布的同时,往往会顺便为自己购买啤酒,这样就会出现啤酒与尿布这两件看上去不相干的商品经常会出现在同一个购物篮的现象。如果这个年轻的父亲在卖场只能买到两件商品之一,则他很有可能会放弃购物而到另一家商店,直到可以一次同时买到啤酒与尿布为止。沃尔玛发现了这一独特的现象,开始在卖场尝试将啤酒与尿布摆放在相同的区域,让年轻的父亲可以同时找到这两件商品,并很快地完成购物;而沃尔玛超市也可以让这些客户一次购买两件商品、而不是一件,从而获得了很好的商品销售收入,这就是“啤酒与尿布”故事的由来。
    当然“啤酒与尿布”的故事必须具有技术方面的支持。1993年美国学者Agrawal 提出通过分析购物篮中的商品集合,从而找出商品之间关联关系的关联算法,并根据商品之间的关系,找出客户的购买行为。艾格拉沃从数学及计算机算法角度提出了商品关联关系的计算方法——A prior算法。沃尔玛从上个世纪90年代尝试将Aprior算法引入到POS机数据分析中,并获得了成功,于是产生了“啤酒与尿布”的故事。


    频繁项集基本概念:

    频繁模式主要作用是寻找到数据集中频繁出现的项集、序列或子结构。

    1.项集(itemset):

    最基本的模式是项集,它是指若干个项的集合。如上图,{Beer,Nuts,Diaper}就是一个项集。


    2.K-项集(K-itemset):

    包含K个项的项集

    3.数据集:

    典型的数据集是事物的集合,每一个事物是一个非空项集,并拥有一个标识TID。如上图,上图就是一个数据集。

    4.绝对支持度(Absolute Support):

    数据集中包含项集X的事物数。如上图,含Beer的TID为10,20,30,因此绝对支持度就是3。

    5.相对支持度(Relative Support):

    项集X的绝对支持度与数据集事物总数的比值。如上图,Beer的绝对支持度为3,相对支持度为60%。

    6.频繁项集(Frequent Itemset):

    项集X的支持度超过最小支持度阀值(min_sup)时,称X为频繁项集。min_sup大部分情况下由需求而定,如上图,如果min_sup=50%,则Beer为频繁项集,如果min_sup=70%,则Beer不是频繁项集。

    关联规则(Association Rules):

    光是知道频繁项集,并不能带来什么,因此我们需要引入关联规则的概念。


    1.支持度(Support):

    可以理解为上方的相对支持度。通常需要一个最小支持度阀值(min_sup)或者其他相应的筛选规则(比如,销量最高的前20个)来进行筛选。

    2.置信度(Confidence):

    反映了规则的确定性。置信度是一个事物在包含X的同时也包含Y的条件概率。置信度作用于多个项的项集,因此所有置信度都是单项的,也就是X->Y与Y->X的置信度不同。如上图,{Beer,Diaper}这个项集的绝对支持度是3,Beer->Diaper的置信度为3/3(Beer的绝对支持度)=100%,而Diaper->Beer的置信度为3/4(Diaper的绝对支持度)=75%。同样,置信度也会有最小置信度阈值。

    同时满足最小支持度阈值和最小置信度阈值的规则称为强规则
    一般而言,关联规则的挖掘分为两步:
    1.找出所有频繁项集,即候选规则
    2. 对所有候选规则计算置信度,找出其中的强规则

    3.提升值(Lift):

    以度量此规则是否可用。描述的是相对于不用规则,使用规则可以提高多少。
    lift(A->B) = P(AB)/(P(A)P(B))
    lift > 1  则不是偶然现象,有较强的关联度。
    lift<=1 的规则不做参考

    频繁项集的压缩:

    频繁项集里存在着较多的冗余,因此人们又引入了频繁闭项集和最大频繁集的概念。


    1.频繁闭项集(Closed Patterns):

    当项集X是频繁项集,且数据集D中不存在X的真超集Y,使得X和Y的支持度相等,则X是闭频繁项集。闭频繁项集的表示是无损压缩,不会丢失支持度的信息。通过闭频繁项集可以反推出所有的频繁项集以及相应的支持度。
    完全看不懂吧,还是来举个栗子(( ̄︶ ̄)↗)。
    因为项集{Beer,Diaper}出现在TID为10,20,30的事务中,所以{Beer,Diaper}的绝对支持度为3。而{Beer,Diaper}的直接超集:{Beer,Nuts,Diaper},{Beer,Coffee,Diaper},{Beer,Diaper,Eggs}的支持度计数分别为1,1,1,都不等于{Beer,Diaper}的支持度计数3,所以{Beer,Diaper}为闭项集,如果其支持度超过阈值,则{Beer,Diaper}为闭频繁项集。

    2.最大频繁项集(Max-Patterns):

    当项集X是频繁项集,且数据集D中不存在X的真超集Y,使得Y是频繁项集,则X是最大频繁项集。极大频繁项集的表示是有损压缩,失去了频繁项集的支持度信息,我们可以根据极大频繁项集判断任意项集是否是频繁的,但无法得到相应的支持度。
    理论什么的看着就头大,还是来举个栗子吧~(~ ̄▽ ̄)~。
    如果,{Beer,Nuts,Diaper}大于最小阀值(别看支持度什么的都很低,但是阀值是人定的,讲不定就大于阀值呢。),那{Beer,Nuts,Diaper}就是个最大频繁项集,因为没有包含{Beer,Nuts,Diaper}并且比它更大的集合了。


    频繁项集挖掘算法:

    1.Apriori :(Agrawal & Srikant@VLDB’94)
    2.Eclat (Zaki, Parthasarathy, Ogihara, Li @KDD’97)
    3.FP-Growth (Han, Pei, Yin @SIGMOD’00)

    展开全文
  • 一、关联规则原理: 1、概述: 关联规则算法是在一堆数据集中寻找数据之间的某种关联,通过该算法我们可以对数据集做关联分析——在大规模的数据中寻找有趣关系的任务。这些关系可以有两种形式:频繁项集、关联...

    一、关联规则原理:

    1、概述:

    关联规则算法是在一堆数据集中寻找数据之间的某种关联,通过该算法我们可以对数据集做关联分析——在大规模的数据中寻找有趣关系的任务。这些关系可以有两种形式:频繁项集、关联规则。

    • 频繁项集:经常出现在一块的物品的集合。
    • 关联规则:暗示两种物品之间可能存在很强的关系。

    关联分析典型的例子,沃尔玛超市啤酒于尿不湿的关联分析。例如:购物篮数据

    订单编号购买商品集合
    001羽毛球拍,羽毛球
    002羽毛球,球网,纸巾,矿泉水
    003羽毛球拍,球网,纸巾,红牛
    004羽毛球,羽毛球拍,球网,纸巾
    005羽毛球,羽毛球拍,球网,红牛

    名词定义:

    • 事物:每一个订单被称为一个事物,上表包含5个事物;
    • 项:订单中的每一个物品被称为一个项;
    • 项集:包含0个或多个项的集合被称为项集,如:{羽毛球拍,羽毛球};
    • k-项集:包含k个项的项集被称为K项集,如{羽毛球拍,羽毛球}称为2-项集;
    • 前件与后件:对于规则{羽毛球拍}-->{羽毛球},{羽毛球拍}叫做前件,{羽毛球}叫做后件。

    2、频繁项集的评估标准:

    频繁项集:经常出现在一块的物品的集合,当数据量非常大的时候,我们不可能通过人工去算,所以催生了关联规则的算法,如:Apriori、prefixSpan、CBA等。有了计算方法,那么常常出现在一块多少次的物品集合才算频繁项集,则还需要一个评估频繁项集的标准。评估标准有支持度,置信度、和提升度等,需要自定义一个阈值来衡量判别。

    • 支持度(support):几个关联的数据集中出现的次数占总数据集的比重,或者说几个数据关联出现的概率。上例中:Support(羽毛球,球网,纸巾)= 2/5.。一般来说支持度高不一定是频繁项集,但支持度低一定不能构成频繁项集,所以可设定一个最低的支持度来进行过滤。
    • 置信度(confidence):一个数据出现后,另一个数据出现的概率,或者说是数据的条件概率。定量评估一个频繁项集的置信度(即准确度)的统计量。Confidence(y-->x)=P(X|Y)=P(XY)/P(Y)。针对如{羽毛球拍}->{羽毛球}这样的关联规则来定义的。计算为 支持度{羽毛球拍,羽毛球}/支持度{羽毛球拍},其中{羽毛球拍,羽毛球}的支持度为3/5,{羽毛球拍}的支持度为4/5,所以“羽毛球拍->羽毛球”的置信度为3/4=0.75,这意味着羽毛球拍的记录中,我们的规则有75%都适用。从关联规则的可信程度角度来看,“购买羽毛球拍的顾客会购买羽毛球”这个商业推测,有75%的可能性是成立的,也可以理解为做这种商业决策,可以获得75%的回报率期望。同理:Confidence(yz-->x)=p(x|yz)=p(xyz)/p(yz)。
    • 提升度(lift):表示含有Y的条件下同时含有X的概率,与x总体发生的概率之比,也就是说x对y的提升度与x总体发生的概率之比,即Lift(y-->x)=p(x|y)/p(x)=Confidence(y-->x)/p(x)。提升度大于1 有效的强关联规则,小于1 无效的强关联规则,等于1 x与y独立。

    3.关联规则发现

    给定事务的集合T,关联规则发现是指找出支持度大于等于阈值,并且置信度大于等于阈值的所有规则。挖掘关联规则的一种原始方法是:计算每个可能规则的支持度和置信度,但可以从数据集提取的规则的数目达指数级,更具体地说,从包含d个项的数据集提取的可能规则的总数为:。上面的案例中就有3^6-2^7+1种可能的关联规则。

    当数据量增加的时候,计算非常庞大,所以往往我们会采取剪枝策略,即设定支持度、置信度的阈值,没有达到阈值的项集将不必再进行后续的计算。

    于是将关联规则分为2个主要的子任务:

    • 1.频繁项集的产生:发现满足最小支持度阈值的所有项集,把这些项集称作频繁项集。
    • 2.规则       的产生:从频繁项集中提取高置信度的规则,把这些规则称作强规则。

    优化计算开销:通常频繁项集的产生计算开销远远大于规则产生所需要的计算开销。

    • 1.减少候选项集数目M。
    • 2.减少比较次数。替代将每个候选项集与每个事物相匹配,可以使用更高级的数据结构,或者存储候选项集或者压缩数据集,来减少比较次数。具体体现看Apriori算法。

    二、Apriori算法

    先验原理:如果一个项集是频繁的,则它的所有子集一定也是频繁的。如果一个项集是非频繁的,则它的所有超集都是非平凡的。这样找到一个非频繁项集后,就可以把它的超集进行剪枝处理了。

    如下图,假如0,1,2,3分别表示4类商品,其中我们假定123为频繁项集,则12,13,23,1,2,3都是频繁的。

    反而言之,如果012是非频繁项集,那么他的超集0123也是非频繁的。

    Apriori算法过程:

    • 1、数据集-->设定最低支持度阈值-->获取1-项集-->过滤出频繁项集(剪枝非频繁)-->获取2-项集-->过滤出频繁项集(剪枝非频繁)--->......
    • 2、设定置信度阈值-->从频繁项集中提取高置信度的规则

    三、代码案例

    # pip install apriori
    # pip install MLxtend
    
    import pandas as pd
    import xlrd
    from mlxtend.frequent_patterns import apriori
    from mlxtend.frequent_patterns import association_rules
    
    import warnings
    warnings.filterwarnings("ignore") #用于排除警告
    #读取sheet_name='table1'的数据
    df=pd.read_excel('e:\glgz.xlsx') #根据表的名称
    display(df)#默认读取前5行的数据
     订单编号面膜洗面奶美白霜补水霜洁面乳
    0111100
    1201111
    2300011
    3411010
    4510101
    5611111
    6710000
    7800111
    8911011
    # 调用apriori算法,并且设定最小支持度
    frequent_itemsets = apriori(df[['面膜', '洗面奶', '美白霜', '补水霜', '洁面乳' ]],min_support=0.4, use_colnames=True)
    # frequent_itemsets = apriori(df.drop("订单编号",1),min_support=0.4,use_colnames=True)
    display(frequent_itemsets)

    # 生成关联规则二维表,min_threshold=1表示最少是两种产品的关联规则
    rules = association_rules(frequent_itemsets,metric="lift",min_threshold=1)
    display(rules)

    注意:antecedent support:前置支持度(由前面一个产品到后面一个产品的支持度);consequent support:后置支持度(由后面一个产品到前面一个产品的支持度);support:综合支持度;confidence:置信度;lift:提示度。

    其中support太小的话,则表示该关联规则在整体样本中出现的概率较低,对整体来说分析价值会降低(整体贡献度不够);confidence太低,则说明该组产品组合的价值不高,没有组合价值;lift提升度大于1 有效的强关联规则,小于1 无效的强关联规则,等于1 x与y独立。

    #筛选出提升度和置信度满足条件的关联规则
    rules[ ( rules["lift"] > 1) & (rules["confidence"] > 0.8) ]

    结论:在支持度大于等于0.4,置信度大于0.8且提升度大于1的条件下,关联产品组合有洁面乳和补水霜,且是双侧关联。即可以将这两个产品进行组合售卖,会提高收益。

    展开全文
  • 目录 关联规则挖掘介绍 Apriori算法介绍 FP-growth算法介绍 强规则关联与相关分析 什么是关联规则挖掘? 关联规则挖掘: 从事务数据库,关系数据库和其他信息存储中的大 量数据的项集之间发现有趣的频繁出现的模式 关联...
  • 关联规则算法详细说明,入门级人士看完此文档就能掌握该算法了。
  • 第三章 关联规则挖掘理论和算法 内容提要;关联规则挖掘Association Rule Mining是数据挖掘中研究较早而且至今仍活跃的研究方法之一 最早是由Agrawal等人提出的1993最初提出的动机是针对购物篮分析Basket Analysis...
  • 这八个定义包含了关联规则相关的几个重要基本概念,关联规则挖掘主要有两个问题: 找出交易数据库中所有大于或等于用户指定的最小支持度的频繁项集。 利用频繁项集生成所需要的关联规则,根据用户设定的最小可信度...

    概念

    定义一:设I={i1,i2,…,im},是m个不同的项目的集合,每个ik称为一个项目。项目的集合I称为项集。其元素的个数称为项集的长度,长度为k的项集称为k-项集。引例中每个商品就是一个项目,项集为I={bread, beer, cake,cream, milk, tea},I的长度为6。
    定义二:每笔交易T是项集I的一个子集。对应每一个交易有一个唯一标识交易号,记作TID。交易全体构成了交易数据库D,|D|等于D中交易的个数。引例中包含10笔交易,因此|D|=10。

    定义三:对于项集X,设定count(X⊆T)为交易集D中包含X的交易的数量,则项集X的支持度为:

    support(X)=count(X⊆T)/|D|

    引例中X={bread, milk}出现在T1,T2,T5,T9和T10中,所以支持度为0.5。

    定义四:最小支持度是项集的最小支持阀值,记为SUPmin,代表了用户关心的关联规则的最低重要性。支持度不小于SUPmin 的项集称为频繁集,长度为k的频繁集称为k-频繁集。如果设定SUPmin为0.3,引例中{bread, milk}的支持度是0.5,所以是2-频繁集。

    定义五:关联规则是一个蕴含式:

    R:X⇒Y

    其中X⊂I,Y⊂I,并且X∩Y=⌀。表示项集X在某一交易中出现,则导致Y以某一概率也会出现。用户关心的关联规则,可以用两个标准来衡量:支持度和可信度。

    定义六:关联规则R的支持度是交易集同时包含X和Y的交易数与|D|之比。即:

    support(X⇒Y)=count(X⋃Y)/|D|

    支持度反映了X、Y同时出现的概率。关联规则的支持度等于频繁集的支持度。

    定义七:对于关联规则R,可信度是指包含X和Y的交易数与包含X的交易数之比。即:

    confidence(X⇒Y)=support(X⇒Y)/support(X)

    可信度反映了如果交易中包含X,则交易包含Y的概率。一般来说,只有支持度和可信度较高的关联规则才是用户感兴趣的。

    定义八:设定关联规则的最小支持度和最小可信度为SUPmin和CONFmin。规则R的支持度和可信度均不小于SUPmin和CONFmin ,则称为强关联规则。关联规则挖掘的目的就是找出强关联规则,从而指导商家的决策。

    这八个定义包含了关联规则相关的几个重要基本概念,关联规则挖掘主要有两个问题:

    找出交易数据库中所有大于或等于用户指定的最小支持度的频繁项集。
    利用频繁项集生成所需要的关联规则,根据用户设定的最小可信度筛选出强关联规则。
    

    目前研究人员主要针对第一个问题进行研究,找出频繁集是比较困难的,而有了频繁集再生成强关联规则就相对容易了。

    理论基础

    首先来看一个频繁集的性质。

    定理:如果项目集X是频繁集,那么它的非空子集都是频繁集。

    根据定理,已知一个k-频繁集的项集X,X的所有k-1阶子集都肯定是频繁集,也就肯定可以找到两个k-1频繁集的项集,它们只有一项不同,且连接后等于X。这证明了通过连接k-1频繁集产生的k-候选集覆盖了k-频繁集。同时,如果k-候选集中的项集Y,包含有某个k-1阶子集不属于k-1频繁集,那么Y就不可能是频繁集,应该从候选集中裁剪掉。Apriori算法就是利用了频繁集的这个性质。

    算法实现过程

    连接以及修剪依据关联规则实现过程算法核心及其瓶颈

    代码实现

    def local_data(file_path):
        import pandas as pd
    
        dt = pd.read_excel(file_path)
        data = dt['con']
        locdata = []
        for i in data:
            locdata.append(str(i).split(","))
    
       # print(locdata)  # change to [[1,2,3],[1,2,3]]
        length = []
        for i in locdata:
            length.append(len(i))  # 计算长度并存储
       # print(length)
        ki = length[length.index(max(length))]
       # print(length[length.index(max(length))])  # length.index(max(length)读取最大值的位置,然后再定位取出最大值
    
        return locdata,ki
    
    def create_C1(data_set):
        """
        Create frequent candidate 1-itemset C1 by scaning data set.
        Args:
            data_set: A list of transactions. Each transaction contains several items.
        Returns:
            C1: A set which contains all frequent candidate 1-itemsets
        """
        C1 = set()
        for t in data_set:
            for item in t:
                item_set = frozenset([item])
                C1.add(item_set)
        return C1
    
    
    def is_apriori(Ck_item, Lksub1):
        """
        Judge whether a frequent candidate k-itemset satisfy Apriori property.
        Args:
            Ck_item: a frequent candidate k-itemset in Ck which contains all frequent
                     candidate k-itemsets.
            Lksub1: Lk-1, a set which contains all frequent candidate (k-1)-itemsets.
        Returns:
            True: satisfying Apriori property.
            False: Not satisfying Apriori property.
        """
        for item in Ck_item:
            sub_Ck = Ck_item - frozenset([item])
            if sub_Ck not in Lksub1:
                return False
        return True
    
    
    def create_Ck(Lksub1, k):
        """
        Create Ck, a set which contains all all frequent candidate k-itemsets
        by Lk-1's own connection operation.
        Args:
            Lksub1: Lk-1, a set which contains all frequent candidate (k-1)-itemsets.
            k: the item number of a frequent itemset.
        Return:
            Ck: a set which contains all all frequent candidate k-itemsets.
        """
        Ck = set()
        len_Lksub1 = len(Lksub1)
        list_Lksub1 = list(Lksub1)
        for i in range(len_Lksub1):
            for j in range(1, len_Lksub1):
                l1 = list(list_Lksub1[i])
                l2 = list(list_Lksub1[j])
                l1.sort()
                l2.sort()
                if l1[0:k-2] == l2[0:k-2]:
                    Ck_item = list_Lksub1[i] | list_Lksub1[j]
                    # pruning
                    if is_apriori(Ck_item, Lksub1):
                        Ck.add(Ck_item)
        return Ck
    
    
    def generate_Lk_by_Ck(data_set, Ck, min_support, support_data):
        """
        Generate Lk by executing a delete policy from Ck.
        Args:
            data_set: A list of transactions. Each transaction contains several items.
            Ck: A set which contains all all frequent candidate k-itemsets.
            min_support: The minimum support.
            support_data: A dictionary. The key is frequent itemset and the value is support.
        Returns:
            Lk: A set which contains all all frequent k-itemsets.
        """
        Lk = set()
        item_count = {}
        for t in data_set:
            for item in Ck:
                if item.issubset(t):
                    if item not in item_count:
                        item_count[item] = 1
                    else:
                        item_count[item] += 1
        t_num = float(len(data_set))
        for item in item_count:
            if (item_count[item] / t_num) >= min_support:
                Lk.add(item)
                support_data[item] = item_count[item] / t_num
        return Lk
    
    
    def generate_L(data_set, k, min_support):
        """
        Generate all frequent itemsets.
        Args:
            data_set: A list of transactions. Each transaction contains several items.
            k: Maximum number of items for all frequent itemsets.
            min_support: The minimum support.
        Returns:
            L: The list of Lk.
            support_data: A dictionary. The key is frequent itemset and the value is support.
        """
        support_data = {}
        C1 = create_C1(data_set)
        L1 = generate_Lk_by_Ck(data_set, C1, min_support, support_data)
        Lksub1 = L1.copy()
        L = []
        L.append(Lksub1)
        for i in range(2, k+1):
            Ci = create_Ck(Lksub1, i)
            Li = generate_Lk_by_Ck(data_set, Ci, min_support, support_data)
            Lksub1 = Li.copy()
            L.append(Lksub1)
        return L, support_data
    
    
    def generate_big_rules(L, support_data, min_conf):
        """
        Generate big rules from frequent itemsets.
        Args:
            L: The list of Lk.
            support_data: A dictionary. The key is frequent itemset and the value is support.
            min_conf: Minimal confidence.
        Returns:
            big_rule_list: A list which contains all big rules. Each big rule is represented
                           as a 3-tuple.
        """
        big_rule_list = []
        sub_set_list = []
        for i in range(0, len(L)):
            for freq_set in L[i]:
                for sub_set in sub_set_list:
                    if sub_set.issubset(freq_set):
                        conf = support_data[freq_set] / support_data[freq_set - sub_set]
                        big_rule = (freq_set - sub_set, sub_set, conf)
                        if conf >= min_conf and big_rule not in big_rule_list:
                            # print freq_set-sub_set, " => ", sub_set, "conf: ", conf
                            big_rule_list.append(big_rule)
                sub_set_list.append(freq_set)
        return big_rule_list
    
    
    if __name__ == "__main__":
        """
        Test
        """
        file_path = "test_aa.xlsx"
      
        data_set,k = local_data(file_path)
        L, support_data = generate_L(data_set, k, min_support=0.2)
        big_rules_list = generate_big_rules(L, support_data, min_conf=0.4)
        print(L)
        for Lk in L:
            if len(list(Lk)) == 0:
                break
            print("="*50)
            print("frequent " + str(len(list(Lk)[0])) + "-itemsets\t\tsupport")
            print("="*50)
            for freq_set in Lk:
                print(freq_set, support_data[freq_set])
        print()
        print("Big Rules")
        for item in big_rules_list:
            print(item[0], "=>", item[1], "conf: ", item[2])
    

    本文原博客链接

    https://www.cnblogs.com/shizhenqiang/p/8251213.html

    展开全文
  • 关联规则Apriori算法

    千次阅读 2020-10-20 09:13:30
    参考《【机器学习实战-python3】使用Apriori算法进行关联 分析》,《 使用Apriori进行关联...关联规则的目的在于分析出经常出现在一起的物品的集合之间的关系。Apriori算法本质由两部分组成,分别是 频繁项集(frequ.
  • 关联规则可以说得上是数据挖掘领域最广为人知的一类算法了,起码对于我来说是这样的,在大三时候第一次接触数据挖掘领域就是Apriori算法了,后来又断断续续地接触到了FP Tree算法。现在因为工作的原因,需要进一步...
  • 关联规则推荐算法的原理及实现

    千次阅读 2017-04-28 14:34:38
    关联规则用来发现数据间潜在的关联,最典型的应用是电商网站的购物车分析。本文将通过一个简单的例子来说明关联规则中各个术语的含义以及具体的计算方法。 这是一些用户的购物数据,uid是用户的ID,后面是每个...
  • 数据挖掘之关联规则(Apriori算法)

    万次阅读 多人点赞 2021-02-18 17:12:33
    关联规则想必大家都是听说过 尿布和啤酒的故事; 在一家超市里,有一个有趣的现象:尿布和啤酒赫然摆在一起出售。但是这个奇怪的举措却使尿布和啤酒的销量双双增加了。这不是一个笑话,而是发生在美国沃尔玛连锁店...
  • 关联规则挖掘算法apriori算法的实现
  • 关联规则的评价中 ,对评价参数的...对获取的参数值 ,利用扩散原理计算参数在数据库上的分布 ,通过分布实现对规则的评价和取舍 ,从而实现关联规则的自动评价和取舍 ,以及最大程度的自动知识获取 ,并具有实时查询特性。
  • 为系统分析矿工的不安全行为背后的致因构成,基于行为致因的复杂性,研究不安全行为在时间、地点、行为分类、部门、岗位和违章程度多个维度的分布特征,采用Apriori算法原理从矿工不安全行为的众多关联规则中发现强关联...
  • 关联规则python实现-mlxtend

    千次阅读 2020-05-21 11:01:26
    之前介绍了关联规则原理:传送门 发现一个专门进行关联规则分析的python库:mlxtend 下面进行简单的演示 简单数据实现 我们自己简单构造几个数据熟悉下 retail_shopping_basket = {'ID':[1,2,3,4,5,6], 'Basket':...
  • 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第10章 关联规则.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第11章 粗糙集理论.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第12章 神经网络....
  • 第3章 关联规则挖掘 ;3.1 基 本 概 念 ; 一个事务数据库中的关联规则挖掘可以描述如下 设I= {i1, i2, , im} 是一个项目集合 事务数据 库D= {t1, t2, , tn} 是由一系列具有惟一标识的TID事务组成 每一个事务ti (i=1, ...
  • 数据挖掘算法----关联规则

    千次阅读 2018-07-22 22:03:48
    关联规则作为机器学习算法中的一个分类,其目的是在数据集中找出两个变量之间的关联关系,且这种相关关系在数据集中不能直观展现出来。 关联规则的分类 1、按处理的变量 布尔型:买啤酒=&gt;买尿布 数值型:...
  • 提出一种基于免疫原理的人工免疫算法,用于模糊关联规则的挖掘.该算法通过借鉴生物免疫系统中的克隆选择原理来实施优化操作,它直接从给出的数据中,通过优化机制自动确定每个属性对应的模糊集合,使推导出的满足...
  • 1. 关联规则 关联规则是形如X=>Y的蕴含式,其中X、Y分别是一事务的真子集,且X∩Y=Φ。X称为规则的前提,Y称为规则的结果。关联规则反映出X中的项目在事务中出现时,Y中的项目也跟着出现的规律。 2.支持度 关联...
  • 商务智能原理与基础之关联规则PPT学习教案.pptx
  • 提出一种基于Ap rTidRec算法的分布式关联规则挖掘算法,并通过实验验证了算法运行的有效性。给出基于局部2 全局通信模式的分布式关联规则挖掘方案,并在此方案基础之上进行了系统实现。
  • 关联规则算法总结

    千次阅读 2021-08-12 15:35:32
    关联规则算法总结 文章目录一、Apriori、FP Growth算法原理:1.1 Apriori算法原理1.2 FP Growth(Frequent Pattern Growth)算法原理二、Apriori、FP Growth算法的实现三、实际应用 一、Apriori、FP Growth算法原理...
  • 文章目录一、 问题背景与意义:二、 问题定义三、 经典的关联规则挖掘算法四、 关联规则的应用五、 总结与展望六、 参考文献 一、 问题背景与意义: 数据挖掘作为一种从数据中获取信息的有效方法,越来越受到人们的...
  • 关于Weka的数据关联规则分析实验 班级 市场091 姓名 杨超 学号 200916012106 实验基本原理及目的 关联规则的定义 假设I是项的集合给定一个交易数据库其中每个事务(Transaction)t是I的非空子集即每一个交易都与一个...
  • 机器学习——关联规则

    千次阅读 2019-08-10 21:49:38
    机器学习——关联规则(一)关联规则原理(二)关联规则代码实现 (一)关联规则原理 在美国,一些年轻的父亲下班后经常要到超市去买婴儿尿布,超市也因此发现了一个规律,在购买婴儿尿布的年轻父亲们中,有30%~...
  • 针对分布式数据挖掘需要节点间进行大量数据交换的缺点,根据张春生,宋琳琳提出的关联规则局部性原理,不进行数据交换,通过节点挖掘,直接得到局部性全局关联规则,通过各节点间规则的合并,直接得到非局部全局关联...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,205
精华内容 50,482
关键字:

关联规则的原理