精华内容
下载资源
问答
  • 电路分析中的参考方向

    千次阅读 2015-10-27 22:19:07
    1.明确前提:公式依据于事实 2.实际问题:欧姆定律i=u/v 功率公式p=ui 问题来源:功率公式分析时,不论是关联参考方向还是非关联,都的同一个公式;  欧姆定律分析时,

    1.明确前提:公式依据于事实

    2.实际问题:欧姆定律i=u/r

    功率公式p=ui

    问题来源:功率公式分析时,不论是关联参考方向还是非关联,都用的同一个公式;

                        欧姆定律分析时,明确说,因为实际电流方向由高电位流向低电位,所以公式为i=-u/r;

    3.解决办法:按照由一般到抽象的规律分析;

    1)由上面发现公式依据于事实:功率实际上就有吸收释放(同向吸收,异向释放)两种情况,如电阻和电源,为了表达这种实际情况,用一个公式正好枚举了四种情况:关联&实际。p.s.这就像一个公式,怎么得出来的不是我们考虑的,稍加验证即可。


    理想情况  
    p=ui p>0,ui>0,u,i同向,吸收
    p=-ui p>0,ui<0,u,i同向,吸收
    有点类似于“负负得正”

    同理实际电流方向由高电位流向低电位这个事实 ,要用两个公式。


    展开全文
  • 1.2 电流和电压的参考方向

    千次阅读 2019-02-15 20:18:59
    1、电流的参考方向 电流 :带电粒子规则的定向运动 电流强度:单位时间内通过导体横截面的电荷量 单位:A(安培)、kA、mA、A 方向 :规定正电荷的运动方向为电流的实际方向 元件(导线)中电流流动的实际方向...

    1、电流的参考方向

    • 电流 :带电粒子有规则的定向运动
    • 电流强度:单位时间内通过导体横截面的电荷量
      在这里插入图片描述
    • 单位:A(安培)、kA、mA、A
      在这里插入图片描述
    • 方向 :规定正电荷的运动方向为电流的实际方向
      元件(导线)中电流流动的实际方向只有两种可能:
      在这里插入图片描述
      对于复杂电路或电路中的电流随时间变化时,电流的实际方向往往很难事先判断。
    • 参考方向 :任意假定一个正电荷运动的方向即为电流的参考方向。
      在这里插入图片描述在这里插入图片描述

    2、电压的参考方向

    • 电位φ:单位正电荷q 从电路中一点移至参考点(=0)时电场力做功的大小。
    • 电压U:单位正电荷q 从电路中一点移至另一点时电场力做功(W)的大小。
      在这里插入图片描述
    • 实际电压方向:电位真正降低的方向。
    • 单位:V (伏)、kV、mV、μV
      在这里插入图片描述在这里插入图片描述
    • 电压(降)的参考方向:假设高电位指向低电位的方向。
      在这里插入图片描述
      在这里插入图片描述

    3、关联参考方向

    元件或支路的u,i 采用相同的参考方向称之为关联参考方向。反之,称为非关联参考方向。
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 关联规则挖掘

    千次阅读 2014-10-17 22:44:21
    关联规则是数据挖掘技术的一个活跃的研究方向之一,其反映出项目集之间意义的关联关系。关联规则可以广泛地应用于各个领域,既可以检验行业内长期形成的知识模式,也能够发现隐藏的新规律。有效地发现、理解和运用...

     一、初步理解  

    关联规则是数据挖掘技术的一个活跃的研究方向之一,其反映出项目集之间有意义的关联关系。关联规则可以广泛地应用于各个领域,既可以检验行业内长期形成的知识模式,也能够发现隐藏的新规律。有效地发现、理解和运用关联规则是数据挖掘任务的一个重要手段。

    在处理大量数据时,很重要的一点是要理解不同实体间相互关联的规律。通常,发现这些规律是个极为复杂的过程。关联规则是一种十分简单却功能强大的、描述数据集的规则,这是因为关联规则表达了哪些实体能同时发生。

    关联规则的传统应用多见于零售业(适用于线下而非线上)。关联规则挖掘的一个典型例子是购物篮分析。该过程通过发现顾客放入其购物篮中不同商品之间的联系,分析顾客的购买习惯。通过了解哪些商品频繁地被顾客同时购买,这种关联的发现可以帮助零售商指定营销策略。例如,在同一次去超市,如果顾客购买牛奶,他也购买面包(包括什么类型的面包)的可能性有多大?通过帮助零售商有选择地经销和安排货架,这种信息可以引导销售。例如,将牛奶和面包尽可能放近一些,可以进一步的刺激一次去商店同时购买这些商品。全球最大的零售商沃尔玛(Walmart)通过对顾客购物清单的数据挖掘发现了“尿布→啤酒”的关联规则,后来沃尔玛就把尿布和啤酒摆放在一起,从而双双促进了尿布和啤酒的销量。

    关联规则的另一应用领域是健康医疗,利用关联规则找出经常同时发生的健康问题,以便诊断出患一种疾病的患者还可能进行额外的检查,从而判断该患者是否存在其他与此疾病经常连带发生的身体问题。

            其他应用领域还包括入侵检查、web日志分析、数据库访问模式、文档抄袭检测等等。

    二、关联规则的概念

    是项的集合。设任务相关的数据D是数据库事务的集合,其中每个事务T是项的集合,使得。每个事务有一个标识符,称作TID。

    2.1 相关定义

    支持度定义:假设有个支持度阀指(support threshold) s。 如果A是一个项集,A的支持度是指包含I的事务数目。或者是包含I的事务数目与总事务数的百分比。如果支持度不小于s,则称A是频繁项集(frequent itemset)。

      A的支持度(support)= 包含A的事务数 或者 包含A的事务数/总的事务数

    2.2 关联规则(association rule)定义

    关联规则的形式为A->j,其中A是一个项集,而j是一个项。该关联规则的意义为,如果A中所有项出现在某个事务中的话,那么j“有可能”也出现在这一事务中。

    这个“有可能”可以通过定义规则的可信度/置信度(confidence)来形式化的给出。

    A->j的可信度(confidence) = A∪j 的支持度/A的支持度

    但是如果包含A的购物篮中包含j的概率等于所有购物篮中包含j的概率, 比较极端的是实际上所有的购物篮(事务)都包含j,那么即使A包含j的概率为100% 也是没有意义的,为了区分出这种A对j的兴趣度衡量。

        A->j的兴趣度(interest) = A->j的可信度 - j的支持度

    当这个值很高或者是绝对值很大的负值都是具有意义的。前者意味着购物篮中A的存在在某种程度上促进了j的存在,而后者意味着A的存在会抑制j的存在。

            同时满足最小支持度阈值(min_sup)和最小置信度阈值(min_conf)的规则称作强规则。

            项的集合称为项集(itemset)。包含k个项的项集称为k-项集。集合{computer,financial_management_software}是一个2-项集。

           识别有用的关联规则并不比发现频繁项集难很多,以为他都是以支持度为基础的。实际当中,对于传统的零售商店的销售而言,“相当地高”大概相当于所有购物篮的1%左右。

    三、预选算法与数据结构的数学分析

    我们假定购物篮组成的文件太大以至于无法在内存中存放。因此,任何算法的主要时间开销都集中在将购物篮或者事务从磁盘读入内存这个过程。。

    3.2 项集计数中内存使用

       当对数据进行一遍扫描时,所有的频繁项集算法要求我们必须在内存中维护很多不同的计数值。例如,我们必须要记录每两个项咋购物篮中出现次数。如果没有足够内存来存放这些数字,那么随机对其中的一个数字加1都很有可能需要将一个页面从磁盘载入到内存,如果这样,算法就会发生内存抖动现象。从而运行速度可能会比从内存中直接找到这些数字慢好几个数量级。所以结论是,我们不能对不能放入内存的任何对象计数。因此,每个算法必须有个能处理的项数目的上限。
    例如:假定项目总数目n, 并且算法会计算所有项对的数目。因此,我们需要空间存储(n 2)及C2 20 = n的平方/2个整数,如果每个整数需要4字节,总共需要2n pow 2个字节。如果我们的机器有2GB即2 pow 31字节内存,那么必须要求n<=2pow 15。
    如果项是字符串,可以表示为1-n上的整数。如果项没有采用这种表示方法,我们就需要哈希表将他们从文件中的表示形式转化为整数。如果该项已经存在,那么就可以从哈希表中获得其对应的整数码,如果不存在,那么就将下一个可用的数字赋给它,并将项及其整数码放入到哈希表中。(当然简单一点,并且可以通过哈希函数映射到不同的连续的整数空间上,这个哈希表不需要实际的存在,因为哈希函数的规则能够正确帮助我们找到这个整数码,这个整数码也就转换为项对的存放地址)
    哈希表1 如bread-0
            apple-1
            beer -2......

    3.2.1 三角矩阵方法(triangular matrix)

        在将项都编码成整数之后,我们可以使用三角矩阵来存放计数结果,i<j,a[i,j]。对每一个对需要空间一个integer = 4 bytes

       但是这种策略会使得数组的一般元素都没有使用。一个更节省空间的方法是使用一个一维的三角数组(trangular array)
    有1<=i<=j<=n,k=(i-1)(n-i/2)+(j-i)。即{i,j}对应为a[k]。这种布局相当于将所有的项对按照字典顺序排序,即一开始是{1,2},{1,3},。。。,{1,n},{2,3},{2,4},。。。{2,n}。。。{n-1,n}。
      这种当时分配的空间是已经确定的,为n-1+n-2+.....+1

    3.2.2 三元组方法

      另一种有可能更加适合的存储计数值的方法为三元组[i,j,c],即对{i,j}对的计数值c(i<j)。对每一个对需要空间3*integer =12 bytes
    具体操作为采用类似哈希表的数据结构,其中i,j是搜索键值,这样就能确定对于给定的i,j是否存在对应的三元组,如果是则快速定位。这种方式我们称为存储数值的三元组方式(triples method)
    与三角矩阵的方式不同,如果某个项对(候选项对)的计数值为0,则三元组方式可以不用存储这个值,即只有C>0的才需要分配空间去存储。
       结论如下:
    如果所有可能出现的(n 2)个项对中有至少1/3出现在购物篮的情况下,三角矩阵方式更优。而如果出现的比例显著小于1/3,那么就要考虑使用三元组方式。

    3.2.3 二元组计数

    实际当中可能很大的计算复杂性都在二元组,可能二元组的数目更多,所以上面的方法都是用来处理二元组。

    四、A-Priori算法

     关联规则中最著名的算法当数Apriori算法。

       

    图1、Apriori算法的内存的使用情况,左边为第一步时的内存情况,右图为第二步时内存的使用情况

    五、A-Priori算法的改进

    下面具体介绍几个Apriori算法的改进算法,这些算法可以用在海量数据上的关联规则挖掘中。

    1)基于hash的方法。一个高效地产生频集的基于杂凑(hash)的算法由Park[3]提出来。通过实验可以发现寻找频集主要的计算是在生成频繁2-项集Lk上,Park等就是利用了这个性质引入杂凑技术来改进产生频繁2-项集的方法

    2)基于划分的方法。Savasere[2]设计了一个基于划分(partition)的算法. 这个算法先把数据库从逻辑上分成几个互不相交的块,每次单独考虑一个分块并对它生成所有的频集,然后把产生的频集合并,用来生成所有可能的频集,最后计算这些项集的支持度。这里分块的大小选择要使得每个分块可以被放入主存,每个阶段只需被扫描一次。而算法的正确性是由每一个可能的频集至少在某一个分块中是频集保证的。

    3)基于采样的方法。基于前一遍扫描得到的信息,对此仔细地作组合分析,可以得到一个改进的算法,Mannila[4]先考虑了这一点,他们认为采样是发现规则的一个有效途径。

    5.1 基于hash的方法

            首先是基于哈希的算法。基于哈希的算法仍是将所有所有数据放入内存的方法。只要在计算的过程中能够满足算法对内存的大量需求,Apriori算法能够很好的执行。但在计算候选项集时特别是在计算候选项对C2时需要消耗大量内存。针对C2候选项对过大,一些算法提出用来减少C2的大小。这里我们首先考虑PCY算法,这个算法使用了在Apriori算法的第一步里大量没使用的内存。接着,我们考虑Multistage算法,这个算法使用PCY的技巧,但插入了额外的步骤来更多的减少C2的大小。

      Park,Chen,Yu(PCY)算法[3]:

            这个算法我们叫PCY算法,取自它的作者名字缩写。该算法关注在频繁项集挖掘中的第一步有许多内存空间没被利用的情况。如果有数以亿计的项,和以G计的内存,在使用关联规则的第一步里我们将会仅仅使用不到10%的内存空间,会有很多内存空闲。因为在第一步里,我们只需要两个表,一个用来保存项的名字到一个整数的映射,用这些整数值代表项,一个数组来计数这些整数,如图1PCY算法使用这些空闲的内存来保存一个整数数组。其思想显示如图2.将这个数组看做一个哈希表,表的桶中装的是整数值而不是一组key值。项对被哈希到这些桶中。在第一步扫描篮子的处理中,我们不但将这些项对加一,并且通过两步循环,我们创造出所有的项对。我们将项对哈希到哈希表中,并且将哈希到的位置加一。注意,项本身不会进入桶,项对的加入只是影响桶中的整数值。

            在第一步的结尾,每个桶中装有一个数字,这个数字表达了桶中的项对的数目。如果桶中数字大于支持度阈值s,这个桶被称为频繁桶。对于频繁桶,我们不能确定其项对是否为频繁项对,但有可能是。但是,对于阈值低于s的桶,我们知道其中的项对肯定不是频繁项对,即使项对是由两个频繁项组成。这个事实给我们在第二部处理带来很大的方便。我们可以定义候选集C2为这样的项对{i, j}

    1.      ij是频繁项

    2.      {ij}哈希到一个频繁桶

            第二个条件是PCY算法与A-Priori算法的区别所在。

            在步骤1中使用hash表可能并不能带来好处,这取决于数据大小和空闲内存大小。在最坏的情形下,所有的桶都是频繁的,PCY计算的项对与A-priori是一样的。然而,在通常的情况下,大多数的桶都是非频繁的。这种情况下,PCY算法降低了第二步内存的使用。

            假设我们有1G的内存可用来在第一步做hash表存放,并假设数据文件包含在10亿篮子,每个篮子10个项。一个桶为一个整数,通常定义为4个字节,于是我们可以保存2.5亿个桶。所有篮子的项对的数量总数为个。这个数量也是桶中计数的总和。这样,每个桶的平均计数为,或180个。所以,如果支持度阈值s180附近,或更小,可能只有很少的桶是非频繁的。然而,当s足够大,比方说1000,这样会使大部分的桶成为非频繁的。这样最大可能的频繁桶数为,或450亿个频繁桶。

            在PCY算法中,在其第二步操作前,哈希表被压缩为bitmap,在这里,每一个bit用作一个桶。若桶为频繁桶,则位置1,否则置0。这样32bit的整数被压缩为只有1bit。然后再PCY的第二步操作中,bitmap只占了原来所用空间的1/32,如图2所示。如果大部分的桶都是非频繁桶,我们可以预料,在第二步的项对计数后产生的频繁项集会更小。这样,PCY算法就能直接在内存中处理这些数据集而不会耗尽内存。

            虽然在寻找频繁项对时,PCY算法与Apriori算法相差很大,但是,在三元对和更多元时,他们的方法又为相同了。

     

    图2、使用PCY算法的内存组织形式,左图为步骤1的内存使用情况,右图为步骤2的内存使用情况

    5.2 Mutistage 算法:

            Multistage算法是在PCY算法的基础上使用一些连续的哈希表来进一步降低候选项对。相应的,Multistage需要不止两步来寻找频繁项对。Multistage算法的框图描述在图3中。

           Multistage的第一步跟PCY的第一步相同。在第一步后,频繁桶集也被压缩为bitmap,这也和PCY相同。但是在第二步,Multistage不计数候选项对。而是使用空闲主存来存放另一个哈希表,并使用另一个哈希函数。因为第一个哈希表的bitmap只占了1/32的空闲内存,第二个哈希表可以使用几乎跟第一个哈希表一样多的桶。

           Multistage的第二步,我们同样是需要遍历篮子文件。只是这步不需要再数项了,因为已经在第一步做了。但是,我必须保留那些项是频繁项的信息,因为我们需要它在第二步和第三步中。在第二步中,我们哈希哈希某些项对到第二个哈希表的桶中。一个对被哈希仅当它满足一下两条条件,即:如果ij都是频繁的且它们在第一步被哈希到频繁桶中。这样,第二个哈希表中的计数总数将比第一步明显减少。

    因此,即便是在第二步是由于第一步的bitmap占据了1/32的空闲空间,剩下的空间也照样够第二步的hash表使用。

            在第二步完成后,第二个hash表同样被压缩成bitmap。该bitmap也同样保存在内存中。这时,两个bitmap加起来也只占到不到空闲内存的1/16,还有相当的内存可用来做第三步的计算候选频繁项对的处理。一个相对{ij}C2中,当且仅当满足:

    1、  ij都是频繁项

    2、  {ij}在第一步哈希时被哈希到频繁桶中

    3、  {ij}在第二步哈希时被哈希到频繁桶中

            第三条是Multistage方法和PCY方法的主要区别。

            很显然,在算法中可用在第一步和最后一步中添加任意多的中间步骤。这里的限制就是在每一步中必须用一个bitmap来保存前一步的结果。最终这里会使得没有足够的内存来做计数。不管我们使用多少步骤,真正的频繁项对总是被哈希到一个频繁桶中,所以,这里没有方式来避免对它们计数。

     

    3Multistage算法使用额外的哈希表来减少候选项对,左图为第一步内存使用情况,中图为第二步内存使用情况,右图为第三步内存使用情况

    5.3 Multihash 算法

            有时我们从multistage算法的额外的步骤中获取好处。这个PCY的变形叫做Multihash[7]算法。不同于在连续的两个步骤中使用两个哈希表,该算法在一步中使用两个哈希算法和两个分离的哈希表。如表6.7所述。

            在同一步里使用两个hash表的危险是每个哈希表仅有PCY算法的一半的桶。只要PCY算法的桶的平均计数比支持度阈值低,我们就可以预见大部分的桶都是非频繁桶,并可以在这两个只有一半大小的哈希表上操作完成。在这种情形下,我们选择multihash方法。

            对Multihash的第二步,每个hash表也会被转换为一个bitmap。注意,在图6.7中,两个bitmap占据的空间只有PCY算法的一个bitmap的大小。项对{ij}被放入候选集C2的条件同multistageij必须是频繁的,且{ij}对在两个哈希表中必须被hash到频繁桶。

            正如Multistage算法,在Multihash算法中,我们也可以不用限制只使用两个hash表。在Multihash算法的第一步中,我们也可以使用多个hash表。不过风险是桶的平均计数会超过阈值。在这种情况下,这里会只有很少的非频繁桶在每个hash表中。即使这样,一个项对必须被hash到每个hash表的频繁桶中并计数,并且,我们会发现,一个非频繁项对作为一个候选的概率将上升,而不是下降,无利反而有害。

     

     

    图3、Multihash算法使用多个hash表在第一步中,左图为第一步处理,右图为第二步处理

           使用两个哈希表的危险是在第一步,每个哈希表仅有PCY哈希表的一半的桶容量。只要PCY桶的平均数目比支持的阈值低,我们就能操作两个一半大小的哈希表,其期望哈希表的大多数桶不是频繁的。这样,在这种情形下,我们可以选择multihash方法。

    5.4 基于采样的方法

           前面所讨论的频繁项都是在一次能处理的情况。如果数据量过大超过了主存的大小,这就不可避免的得使用k步来计算频繁项集。这里有许多应用并不需要发现所有的频繁项。比方说在超市,我们只要找到大部分的销售频繁关联项就够了,而不必找出所有的频繁项。

            在这一节,我们介绍几种算法来找到所有或大部分的项集使用两步。我们首先从使用一个简单的数据样本开始,而不是整个数据集。一个算法叫做SON,使用两步,得到精确结果,并使得它能够在map-reduce和其他并行处理的框架下运行。最后,Toivonen的算法平均使用两步获取精确结果,但是,可能但不是经常不能在给定的时间内完成。

    一个简单的随机算法

            不是使用整个文件或篮子,我们使用篮子的一个子集并加装他们是整个数据集。我们必须调整支持度的阈值来适应我们的小篮子。例如,我们针对完整数据集的支持度阈值为s,当我们选择1%的样本时,我们可以在支持度阈值为s/100的度量上测试。

            最安全的抽样方式是读入整个数据集,然后对于每个篮子,使用相同的概率p选择样品。假设这有m个篮子在整个文件中。在最后,我们需要选择的样品的数量接近pm个篮子的样品数。如果我们事先知道这些篮子本身在文件中就是随机放置的,那么我们就可以不用读入整个文件了,而是只接选择前面的pm个篮子作为样品就可以了。或在,如果文件是分布式文件系统,我们可以选择第一个随机块作为样品。

           当我们的样品选择完成,我们可以使用部分的主存来放置这些篮子。剩下的主存用来执行前面的AprioriPCYMultistageMultihash算法。当然这些算法必须运行所有的样品,在每个频繁集上,直到找不到频繁集为止。这个方法在执行读取样品时不需要磁盘操作,因为它是驻留在内存的。当每个频繁项被发现,它们就可以写到磁盘上了;这个操作和最初的读样品到内存是唯一的两次磁盘操作。当然若读入样品后剩下的内存不够执行之前所说的算法时,这种方法会失败。当然,可以选择在算法的每步完成后写到磁盘再仅从磁盘调入下步所需的数据。因为样品的数量相比与整个文件是很小的,所以,I/O操作的代价还是很小的。

     

    避免错误的抽样算法

            我们需要知道在简单抽样方法中可能出现错误。因为我们使用的是抽样,所有就可能存在是频繁项的没有放进频繁集,也存在非频繁项的放入了频繁集。

            当样本足够大时,问题变得不是那么严重了。这时,那些支持度远大于阈值的项集即使在样本中其支持度也会很高,所有误分的可能性不大。但是那些支持度在阈值附近的就不好说了。很有可能由于抽样使得支持度稍微改变而改变对其是否是频繁集的判断

            我们可以通过一遍对整个数据集的扫描,计算所有样品中频繁项集的支持度,保留那些在样品中和在数据集上支持度都高于阈值的频繁项集。以此避免非频繁项集被判为频繁项集的错误。值得注意的,这种方法不能避免那些是频繁集却被当做非频繁项集的情况。

            我们不能消除那些是频繁项集却没有在样品中找出的情况,但是我们可以减少它们的数量如果内存的数量允许。我们设想如果s是支持阈值,且样品相对于整个数据集的大小为p,这样我们可以使用ps作为支持阈值。然而我们可以使用比这个值稍微小点的值作为阈值,如0.9ps。使用更低的阈值的好处是能使更多的项进入到频繁集中,这样就可以降低这种错误,然后再以这些频繁项集到整个数据集中计算支持度,除去那些非频繁项集,这样我们就可以消除非频繁项集当成频繁项集的错误,同时最大化的减少了频繁项集被当做了非频繁项集。

    Toivonen的算法[8]

            这个算法给出另一种不同的随机抽样算法。Toivonen算法在给出足够内存的情况下,在小样本上进行一步处理,接着再整个数据上进行一步处理。这个算法不会带来false negatives,也不会带来false positives,但是这里存在一个小的概率使得算法会产生不了任何结构。这种情况下算法需要重复直至找到一个结果,虽然如此,得到最终频繁项集的处理的平均步数不会太大。

            Toivonen算法由从输入数据集中选择一个小的样品开始,并从中找到候选频繁项集,找的过程同Apriori算法,不过很重要的一点不同是阈值的设置的比样品比例的阈值小。即,当整个数据集上的支持度阈值为s,该样品所占数据集的比例为p,则该阈值可以设置为0.9ps或0.8ps。越小的阈值,就意味着在处理样本时,越多的内存在计算频繁项集时需要使用;但是也就越大的可能性避免算法不能产生结果。

            当样本的频繁项集被构造完成后,我们的下一步是构造negative border。这是样品的一个非频繁项集合,但是这些项集的任意去掉一个项后就是频繁集了。

            考虑项为{A,B,C,D,E},而且我们找到频繁项集为{A},{B},{C},{D},{B,C},{C,D}。注意,只要篮子数不比阈值小,Φ也是频繁的,但是我们忽略它。首先,{E}是在negative border中的,因为{E}本身不是频繁项集,但是从中去任意项后就变成Φ了,就成了频繁项集,所有包含在negative border中。

            还有{A,B},{A,C},{A,D}和{B,D}都在negative border中。因为它们都不是频繁项集,但是除掉一个项的子集都是频繁项集。如{A,B}的子集{A}和{B}都是频繁集。剩下的六个二元项集不在negative border中。{B,C}和{C,D}因为它们本身是频繁项集,所有就不是negative border的元素了,而其他四个虽然不是频繁项集,但是因为包含了项E,而子集{E}不是频繁项集

            没有任何三元的或更大的项集在negative border中了。例如{B,C,D}不在negative border中,因为它有一个立即子集{B,D},而{B,D}不是频繁项集。这样,negative border由下面五个集合组成:{E},{A,B},{A,C},{A,D}和{B,D}。

            为了完成Toivonen算法,我们需要一步在整个数据集上的处理,算出所有在样品中的频繁项集或negative border中的所有项集。这步会产生的可能输出为:

    1、  negative border中没有一个项集在整个数据集上计算为频繁项集。这种情况下,正确的频繁项集就为样本中的频繁项集。

    2、  某些在negative border中的项集在整个数据集中计算是频繁项集。这时,我们不能确定是否存在更大的项集,这个项集既不在样本的negative border中,也不在它的频繁项集中,但是是整个数据集的频繁项集。这样,我们在此次的抽样中得不到结果,算法只能在重新抽样,继续重复上面的步骤,直到出现满足输出情形1时停止。

    为什么Toivonen算法可以奏效

            显然 Toivonen算法不会产生false positive,因为它仅仅将在样本中是频繁项并在整个数据集上计算确实为频繁项集的项集作为频繁项集。为讨论该算法能够不产生false negative,我们需要注意,在Toivonen算法中,没有negativeborder中的项集是频繁项集。所有,无论如何,不存在在整个数据集上是频繁的,而在样本中既不出现在频繁集中,也不出现在negative border中。

            给个反例。假设这里有个集合S在数据集上是频繁项集,但是既不在样本的negative border中,也不是样本的频繁项集。那么在Toivonen算法的一步结束后,产生结果,并且结果中的频繁项集合中没有S。由频繁项集的单调性知,S的所有子集都是整个数据集的频繁项集。假设T是S的一个在样本中不属于频繁项集的最小子集。

            我们说,T一定在negative border中。当然,T满足在negative border中的条件:它自己不是样本的频繁项集。而它的直接子集是样布的频繁项集,因为若不是,则T不是S的在样本中不属于频繁项集的最小子集,产生矛盾。

            这里我们可以发现T即是数据集的频繁项集,又在样本的negative border中。所有,我们对这种情况的Toivonen算法,让其不能产生结果。

    5.5 基于划分的方法

            使用划分的方法是处理海量数据的管理规则的另一个有效的方法。不同于基于采样的方法,该方法能够对数据集上所有数据进行处理。

    Savasere,Omiecinski, and Navathe算法[2]

            我们的下一个算法同时避免了false negatives和false positives,所带来的代价是需要两个完全的步骤。该算法叫做SON算法,为三个作者名字的简称。其思想是将输入文件划分成块(chunks)。将每个文件块作为一个样本,并执行Apriori算法在其块上。同样的使用ps作为其阈值。将每个块找到的频繁项集放到磁盘上。

            一旦所有的块按此方式被处理,将那些在一个或多个块中被选中的频繁项集收集起来作为候选频繁项集。注意,如果一个项集在所有的块中都不是频繁项集,即它在每个块中的支持度都低于ps。因为块数位1/p,所以,整体的支持度也就低于(1/p)ps=s。这样,每个频繁项集必然会出现在至少一个块的频繁项集中,于是,我们可以确定,真正的频繁项一定全在候选频繁项集中,因此这里没有false negatives。

            当我们读每个块并处理它们后,我们完成一次处理。在第二步处理中,我们计算所有的候选频繁项集,选择那些支持度至少为s的作为频繁项集。

     

    SON算法与Map-Reduce

            SON算法使得它很适合在并行计算的环境下发挥功效。每个块可以并行的处理,然后每个块的频繁集合并形成候选集。我们可以将候选分配到多个处理器上,在每个处理器上,这些处理器只需要在一个“购物篮”子集处理这些发过来的候选频繁项集,最后将这些候选集合并得到最终的在整个数据集上的支持度。这个过程不必应用map-reduce,但是,这种两步处理的过程可以表达成map-reduce的处理。下面将介绍这种map-reduce-map-reduce流程。

            FirstMap Function:分配篮子子集,并在子集上使用Apriori算法找出每个项集的频繁度。将支持阈值降从s降低到ps,如果每个Map任务分得的部分占总文件的比例为p。map的输出为key-value对(F,1),这里F为该样本的频繁项集。值总是为1,这个值是无关紧要的。

            FirstReduce Function:每个reduce任务被分配为一组key,这组key实际就为项集,其中的value被忽略,reduce任务简单产生这些出现过一次或多次的项集,将其作为候选频繁项集作为输出。

            SecondMap Function:第二步的map任务将第一步的reduce的所有输出和输入文件的一部分作为输入,每个Map任务计算在分配的那块输入文件中每个候选频繁项集的出现次数。这步的输出为键值对(C,v),这里,C是一个候选集,v是其在该Map任务中的支持度。

            SecondReduce Function:此步的Reduce任务将在每个候选频繁项集各个Map中的候选集的支持度相加。相加的结果就为整个文件上的支持度,这些支持度若大于s,则保留在频繁项集中,否则剔除。

    5.6 其他的频集挖掘方法

            上面我们介绍的都是基于Apriori的频集方法。即使进行了优化,但是Apriori方法一些固有的缺陷还是无法克服:

    1. 可能产生大量的候选集。当长度为1的频集有10000个的时候,长度为2的候选集个数将会超过10M。还有就是如果要生成一个很长的规则的时候,要产生的中间元素也是巨大量的。
    2. 无法对稀有信息进行分析。由于频集使用了参数minsup,所以就无法对小于minsup的事件进行分析;而如果将minsup设成一个很低的值,那么算法的效率就成了一个很难处理的问题。

            下面将介绍两种方法,分别用于解决以上两个问题。

            针对问题一,J.Han等在[5]中提出了不产生候选挖掘频繁项集的方法:FP-树频集算法。他们采用了分而治之的策略,在经过了第一次的扫描之后,把数据库中的频集压缩进一棵频繁模式树(FP-tree),同时依然保留其中的关联信息。随后我们再将FP-tree分化成一些条件库,每个库和一个长度为1的频集相关。然后再对这些条件库分别进行挖掘。当原始数据量很大的时候,也可以结合划分的方法,使得一个FP-tree可以放入主存中。实验表明,FP-growth对不同长度的规则都有很好的适应性,同时在效率上较之apriori算法有巨大的提高。

            第二个问题是基于这个的一个想法:apriori算法得出的关系都是频繁出现的,但是在实际的应用中,我们可能需要寻找一些高度相关的元素,即使这些元素不是频繁出现的。在apriori算法中,起决定作用的是支持度,而我们现在将把可信度放在第一位,挖掘一些具有非常高可信度的规则。Edith Cohen[6]中介绍了对于这个问题的一个解决方法。整个算法基本上分成三个步骤:计算特征、生成候选集、过滤候选集。在三个步骤中,关键的地方就是在计算特征时Hash方法的使用。在考虑方法的时候,有几个衡量好坏的指数:时空效率、错误率和遗漏率。基本的方法有两类:Min_Hashing(MH)Locality_Sensitive_Hashing(LSH)Min_Hashing的基本想法是:将一条记录中的头k个为1的字段的位置作为一个Hash函数。Locality_Sentitive_Hashing的基本想法是:将整个数据库用一种基于概率的方法进行分类,使得相似的列在一起的可能性更大,不相似的列在一起的可能性较小。我们再对这两个方法比较一下。MH的遗漏率为零,错误率可以由k严格控制,但是时空效率相对的较差。LSH的遗漏率和错误率是无法同时降低的,但是它的时空效率却相对的好很多。所以应该视具体的情况而定。最后的实验数据也说明这种方法的确能产生一些有用的规则。

    参考文献

    1 R. Agrawal, T. Imielinski, and A. Swami. Mining association rules between sets of items in large databases. Proceedings of the ACM SIGMOD Conference on Management of data, pp. 207-216, 1993.

    2 A. Savasere, E. Omiecinski, and S. Navathe. An efficient algorithm for mining association rules in large databases. Proceedings of the 21st International Conference on Very large Database, 1995
    3 J. S. Park, M. S. Chen, and P. S. Yu. An effective hash-based algorithm for mining association rules. Proceedings of ACM SIGMOD International Conference on Management of Data, pages 175-186, San Jose, CA, May 1995.
    4 H. Mannila, H. Toivonen, and A. Verkamo. Efficient algorithm for discovering association  rules. AAAI Workshop on Knowledge Discovery in Databases, 1994, pp. 181-192.
    5 J.Han,J.Pei,and Y.Yin.Mining frequent patterns without candidate generation.In Proc.2000 ACM-SIGMOD Int.Conf.Management of Data(SIGMOD’00),Dalas,TX,May 2000.
    6 Edith Cohen, Mayur Datar, Shinji Fujiwara, Aristides Gionis, Piotr Indyk, Rajeev Motwani, Jeffrey D.Ullman, Cheng Yang. Finding Interesting Associations without Support Pruning. 1999
    7 M. Fang, N. Shivakumar, H. Garcia-Molina, R. Motwani, and J. D. Ullman, “Computing iceberg queries efficiently,” Intl. Conf. on Very Large Databases, pp. 299-310, 1998.
    8 H. Toivonen, “Sampling large databases for association rules,” Intl. Conf. on Very Large Databases, pp. 134–145, 1996.




    展开全文
  • 关联规则

    千次阅读 2018-04-18 09:40:56
    1.概念1.1 引论关联规则(AssociationRules)是无监督的机器学习方法,用于知识发现,而非预测。关联规则的学习器(learner)无需事先对训练数据进行打标签,因为无监督学习没有训练这个步骤。缺点是很难对关联规则...


    1.概念

    1.1 引论

    关联规则(AssociationRules)是无监督的机器学习方法,用于知识发现,而非预测。

    关联规则的学习器(learner)无需事先对训练数据进行打标签,因为无监督学习没有训练这个步骤。缺点是很难对关联规则学习器进行模型评估,一般都可以通过肉眼观测结果是否合理。

     

    关联规则主要用来发现Pattern,最经典的应用是购物篮分析,当然其他类似于购物篮交易数据的案例也可以应用关联规则进行模式发现,如电影推荐、约会网站或者药物间的相互副作用。

     

    1.2 例子 - 源数据

    点击流数据。

    不同的Session访问的新闻版块,如下所示:

    Session ID

    List of media categories accessed

    1

    {News, Finance}

    2

    {News, Finance}

    3

    {Sports, Finance, News}

    4

    {Arts}

    5

    {Sports, News, Finance}

    6

    {News, Arts, Entertainment}

     

    1.3数据格式

    关联规则需要把源数据的格式转换为稀疏矩阵。

    把上表转化为稀疏矩阵,1表示访问,0表示未访问。

    Session IDNewsFinanceEntertainmentSports
    11100
    21100
    31101
    40000
    51101
    61010


    1.4术语和度量

    1.4.1项集 ItemSet

    这是一条关联规则:

     

    括号内的Item集合称为项集。如上例,{News, Finance}是一个项集,{Sports}也是一个项集。

    这个例子就是一条关联规则:基于历史记录,同时看过News和Finance版块的人很有可能会看Sports版块。

     

    {News,Finance} 是这条规则的Left-hand-side (LHS or Antecedent)

    {Sports}是这条规则的Right-hand-side (RHS or Consequent)

     

    LHS(Left Hand Side)的项集和RHS(Right Hand Side)的项集不能有交集。

     

    下面介绍衡量关联规则强度的度量。

    1.4.2支持度 Support

    项集的支持度就是该项集出现的次数除以总的记录数(交易数)。

    Support({News}) = 5/6 = 0.83

    Support({News, Finance}) = 4/6 =0.67

    Support({Sports}) = 2/6 = 0.33

    支持度的意义在于度量项集在整个事务集中出现的频次。我们在发现规则的时候,希望关注频次高的项集。

    1.4.3置信度 Confidence

    关联规则 X -> Y 的置信度 计算公式 

    规则的置信度的意义在于项集{X,Y}同时出现的次数占项集{X}出现次数的比例。发生X的条件下,又发生Y的概率。



    表示50%的人  访问过{News, Finance},同时也会访问{Sports}

    1.4.4提升度 Lift

    当右手边的项集(consequent)的支持度已经很显著时,即时规则的Confidence较高,这条规则也是无效的。

    举个例子:

    在所分析的10000个事务中,6000个事务包含计算机游戏,7500个包含游戏机游戏,4000个事务同时包含两者。

    关联规则(计算机游戏,游戏机游戏) 支持度为0.4,看似很高,但其实这个关联规则是一个误导。

    在用户购买了计算机游戏后有 (4000÷6000)0.667 的概率的去购买游戏机游戏,而在没有任何前提条件时,用户反而有(7500÷10000)0.75的概率去购买游戏机游戏,也就是说设置了购买计算机游戏这样的条件反而会降低用户去购买游戏机游戏的概率,所以计算机游戏和游戏机游戏是相斥的。

     

     

    所以要引进Lift这个概念,Lift(X->Y)=Confidence(X->Y)/Support(Y)

    规则的提升度的意义在于度量项集{X}和项集{Y}的独立性。即,Lift(X->Y)= 1 表面 {X},{Y}相互独立。[注:P(XY)=P(X)*P(Y),if X is independent of Y]

     

    如果该值=1,说明两个条件没有任何关联,如果<1,说明A条件(或者说A事件的发生)与B事件是相斥的,一般在数据挖掘中当提升度大于3时,我们才承认挖掘出的关联规则是有价值的。


    最后,lift(X->Y) = lift(Y->X)


    1.4.5出错率 Conviction

    Conviction的意义在于度量规则预测错误的概率。表示X出现而Y不出现的概率。



    1conf(XY)

    例子:


    表面这条规则的出错率是32%。

     

    1.5生成规则

    一般两步:

    • 第一步,找出频繁项集。n个item,可以产生2^n- 1 个项集(itemset)。所以,需要指定最小支持度,用于过滤掉非频繁项集。
    • 第二部,找出第一步的频繁项集中的规则。n个item,总共可以产生3^n - 2^(n+1) + 1条规则。所以,需要指定最小置信度,用于过滤掉弱规则。

    第一步的计算量比第二部的计算量大。

    2.Apriori算法

     Apriori Principle

    如果项集A是频繁的,那么它的子集都是频繁的。如果项集A是不频繁的,那么所有包括它的父集都是不频繁的。

    例子:{X, Y}是频繁的,那么{X},{Y}也是频繁的。如果{Z}是不频繁的,那么{X,Z}, {Y, Z}, {X, Y, Z}都是不频繁的。


    生成频繁项集

    给定最小支持度Sup,计算出所有大于等于Sup的项集。

    第一步,计算出单个item的项集,过滤掉那些不满足最小支持度的项集。

    第二步,基于第一步,生成两个item的项集,过滤掉那些不满足最小支持度的项集。

    第三步,基于第二步,生成三个item的项集,过滤掉那些不满足最小支持度的项集。


     如下例子:

    One-Item SetsSupport CountSupport
    {News}50.83
    {Finance}40.67
    {Entertainment}10.17
    {Sports}20.33
    Two-Item SetsSupport CountSupport
    {News, Finance}40.67
    {News, Sports}20.33
    {Finance, Sports}20.33
    Three-Item SetsSupport CountSupport
    {News, Finance, Sports}20.33

    规则生成

    给定Confidence、Lift 或者 Conviction,基于上述生成的频繁项集,生成规则,过滤掉那些不满足目标度量的规则。因为规则相关的度量都是通过支持度计算得来,所以这部分过滤的过程很容易完成。


    Apriori案例分析(R语言)

    1. 关联规则的包

    arules是用来进行关联规则分析的R语言包。

    [java] view plain copy
    1. library(arules)   

    2. 加载数据集

    源数据groceries 数据集,每一行代表一笔交易所购买的产品(item)

    数据转换:创建稀疏矩阵,每个Item一列,每一行代表一个transaction。1表示该transaction购买了该item,0表示没有购买。当然,data frame是比较直观的一种数据结构,但是一旦item比较多的时候,这个data frame的大多数单元格的值为0,大量浪费内存。所以,R引入了特殊设计的稀疏矩阵,仅存1,节省内存。arules包的函数read.transactions可以读入源数据并创建稀疏矩阵。

    [java] view plain copy
    1. groceries <- read.transactions("groceries.csv", format="basket", sep=",")  
    参数说明:

    format=c("basket", "single")用于注明源数据的格式。如果源数据每行内容就是一条交易购买的商品列表(类似于一行就是一个购物篮)那么使用basket;如果每行内容是交易号+单个商品,那么使用single。

    cols=c("transId", "ItemId") 对于single格式,需要指定cols,二元向量(数字或字符串)。如果是字符串,那么文件的第一行是表头(即列名)。第一个元素是交易号的字段名,第二个元素是商品编号的字段名。如果是数字,那么无需表头。对于basket,一般设置为NULL,缺省也是NULL,所以不用指定。

    signle format的数据格式如下所示,与此同时,需要设定cols=c(1, 2)

    1001,Fries

    1001,Coffee

    1001,Milk

    1002,Coffee

    1002,Fries


    rm.duplicates=FALSE:表示对于同一交易,是否需要删除重复的商品。


    接下来,查看数据集相关的统计汇总信息,以及数据集本身。

    [java] view plain copy
    1. summary(groceries)  
    2. transactions as itemMatrix in sparse format with  
    3.  9835 rows (elements/itemsets/transactions) and  
    4.  169 columns (items) and a density of 0.02609146   
    5.   
    6. most frequent items:  
    7.       whole milk other vegetables       rolls/buns             soda   
    8.             2513             1903             1809             1715   
    9.           yogurt          (Other)   
    10.             1372            34055   
    11.   
    12. element (itemset/transaction) length distribution:  
    13. sizes  
    14.    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   
    15. 2159 1643 1299 1005  855  645  545  438  350  246  182  117   78   77   55   
    16.   16   17   18   19   20   21   22   23   24   26   27   28   29   32   
    17.   46   29   14   14    9   11    4    6    1    1    1    1    3    1   
    18.   
    19.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    20.   1.000   2.000   3.000   4.409   6.000  32.000   
    21.   
    22. includes extended item information - examples:  
    23.             labels  
    24. 1 abrasive cleaner  
    25. 2 artif. sweetener  
    26. 3   baby cosmetics  
    summary的含义:

    第一段:总共有9835条交易记录transaction,169个商品item。density=0.026表示在稀疏矩阵中1的百分比。
    第二段:最频繁出现的商品item,以及其出现的次数。可以计算出最大支持度。

    第三段:每笔交易包含的商品数目,以及其对应的5个分位数和均值的统计信息。如:2159条交易仅包含了1个商品,1643条交易购买了2件商品,一条交易购买了32件商品。那段统计信息的含义是:第一分位数是2,意味着25%的交易包含不超过2个item。中位数是3表面50%的交易购买的商品不超过3件。均值4.4表示所有的交易平均购买4.4件商品。

    第四段:如果数据集包含除了Transaction Id 和 Item之外的其他的列(如,发生交易的时间,用户ID等等),会显示在这里。这个例子,其实没有新的列,labels就是item的名字。


    进一步查看数据集的信息

    [java] view plain copy
    1. class(groceries)  
    2. [1"transactions"  
    3. attr(,"package")  
    4. [1"arules"  
    5. > groceries  
    6. transactions in sparse format with  
    7.  9835 transactions (rows) and  
    8.  169 items (columns)  
    9. > dim(groceries)  
    10. [19835  169  
    11. > colnames(groceries)[1:5]  
    12. [1"abrasive cleaner" "artif. sweetener" "baby cosmetics"   "baby food"        "bags"              
    13. > rownames(groceries)[1:5]  
    14. [1"1" "2" "3" "4" "5"  


    basketSize表示每个transaction包含item的数目,是row level。而ItemFrequency是这个item的支持度,是column level。

    [java] view plain copy
    1. > basketSize<-size(groceries)  
    2. > summary(basketSize)  
    3.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    4.   1.000   2.000   3.000   4.409   6.000  32.000   
    5. > sum(basketSize) #count of all 1s in the sparse matrix  
    6. [143367  
    7. > itemFreq <- itemFrequency(groceries)  
    8. > itemFreq[1:5]  
    9. abrasive cleaner artif. sweetener   baby cosmetics        baby food             bags   
    10.     0.0035587189     0.0032536858     0.0006100661     0.0001016777     0.0004067107   
    11. > sum(itemFreq) #本质上代表"平均一个transaction购买的item个数"  
    12. [14.409456  

    可以查看basketSize的分布:密度曲线(TO ADD HERE)


    itemCount表示每个item出现的次数。Support(X) = Xs / N, N是总的交易数,Xs就是Item X的count。

    itemXCount = N * itemXFreq = (ItemXFreq / sum(itemFreq)) * sum(basketSize)

    [java] view plain copy
    1. > itemCount <- (itemFreq/sum(itemFreq))*sum(basketSize)  
    2. > summary(itemCount)  
    3.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    4.     1.0    38.0   103.0   256.6   305.0  2513.0   
    5. > orderedItem <- sort(itemCount, decreasing = )  
    6. > orderedItem <- sort(itemCount, decreasing = T)  
    7. > orderedItem[1:10]  
    8.       whole milk other vegetables       rolls/buns             soda           yogurt    bottled water   
    9.             2513             1903             1809             1715             1372             1087   
    10.  root vegetables   tropical fruit    shopping bags          sausage   
    11.             1072             1032              969              924   

    当然,也可以把支持度itemFrequency排序,查看支持度的最大值

    [java] view plain copy
    1. > orderedItemFreq <- sort(itemFrequency(groceries), decreasing=T)  
    2. > orderedItemFreq[1:10]  
    3.       whole milk other vegetables       rolls/buns             soda           yogurt    bottled water   
    4.       0.25551601       0.19349263       0.18393493       0.17437722       0.13950178       0.11052364   
    5.  root vegetables   tropical fruit    shopping bags          sausage   
    6.       0.10899847       0.10493137       0.09852567       0.09395018   

    如果要切一块子集出来计算支持度,可以对数据集进行矩阵行列下标操作。

    如下例,切除第100行到800行,计算第1列到第3列的支持度。也就是说,数据集通过向量的下标按行切,也可以通过矩阵下标按行列切。

    [java] view plain copy
    1. > itemFrequency(groceries[100:800,1:3])  
    2. abrasive cleaner artif. sweetener   baby cosmetics   
    3.      0.005706134      0.001426534      0.001426534   

    可以通过图形更直观观测。

    按最小支持度查看。

    [java] view plain copy
    1. > itemFrequencyPlot(groceries, support=0.1)  


    按照排序查看。

    [java] view plain copy
    1. > itemFrequencyPlot(groceries, topN=10, horiz=T)  



    最后,可以根据业务对数据集进行过滤,获得进一步规则挖掘的数据集。如下例,只关心购买两件商品以上的交易。

    [java] view plain copy
    1. > groceries_use <- groceries[basketSize > 1]  
    2. > dim(groceries_use)  
    3. [17676  169  

    查看数据

    [java] view plain copy
    1. inspect(groceries[1:5])  
    2.   items                       
    3. 1 {citrus fruit,              
    4.    margarine,                 
    5.    ready soups,               
    6.    semi-finished bread}       
    7. 2 {coffee,                    
    8.    tropical fruit,            
    9.    yogurt}                    
    10. 3 {whole milk}                
    11. 4 {cream cheese,              
    12.    meat spreads,              
    13.    pip fruit,                 
    14.    yogurt}                    
    15. 5 {condensed milk,            
    16.    long life bakery product,  
    17.    other vegetables,          
    18.    whole milk}           

    也可以通过图形更直观观测数据的稀疏情况。一个点代表在某个transaction上购买了item。

    [java] view plain copy
    1. > image(groceries[1:10])  

    当数据集很大的时候,这张稀疏矩阵图是很难展现的,一般可以用sample函数进行采样显示。

    [java] view plain copy
    1. > image(sample(groceries,100))  


    这个矩阵图虽然看上去没有包含很多信息,但是它对于直观地发现异常数据或者比较特殊的Pattern很有效。比如,某些item几乎每个transaction都会买。比如,圣诞节都会买糖果礼物。那么在这幅图上会显示一根竖线,在糖果这一列上。


    给出一个通用的R函数,用于显示如上所有的指标:


    [plain] view plain copy
    1. library(arules)  # association rules  
    2. library(arulesViz)  # data visualization of association rules  
    3. library(RColorBrewer)  # color palettes for plots  

    3. 进行规则挖掘

    为了进行规则挖掘,第一步是设定一个最小支持度,这个最小支持度可以由具体的业务规则确定。

    介绍apriori函数的用法:


    这里需要说明下parameter:

    默认的support=0.1, confidence=0.8, minlen=1, maxlen=10

    对于minlen,maxlen这里指规则的LHS+RHS的并集的元素个数。所以minlen=1,意味着 {} => {beer}是合法的规则。我们往往不需要这种规则,所以需要设定minlen=2。

    [java] view plain copy
    1. > groceryrules <- apriori(groceries, parameter = list(support =  
    2. +                                                         0.006, confidence = 0.25, minlen = 2))  
    3.   
    4. Parameter specification:  
    5.  confidence minval smax arem  aval originalSupport support minlen maxlen target   ext  
    6.        0.25    0.1    1 none FALSE            TRUE   0.006      2     10  rules FALSE  
    7.   
    8. Algorithmic control:  
    9.  filter tree heap memopt load sort verbose  
    10.     0.1 TRUE TRUE  FALSE TRUE    2    TRUE  
    11.   
    12. apriori - find association rules with the apriori algorithm  
    13. version 4.21 (2004.05.09)        (c) 1996-2004   Christian Borgelt  
    14. set item appearances ...[0 item(s)] done [0.00s].  
    15. set transactions ...[169 item(s), 9835 transaction(s)] done [0.00s].  
    16. sorting and recoding items ... [109 item(s)] done [0.00s].  
    17. creating transaction tree ... done [0.00s].  
    18. checking subsets of size 1 2 3 4 done [0.01s].  
    19. writing ... [463 rule(s)] done [0.00s].  
    20. creating S4 object  ... done [0.00s].  
    从返回的结果看,总共有463条规则生成。


    评估模型

    使用summary函数查看规则的汇总信息

    [java] view plain copy
    1. > summary(groceryrules)  
    2. set of 463 rules  
    3.   
    4. rule length distribution (lhs + rhs):sizes  
    5.   2   3   4   
    6. 150 297  16   
    7.   
    8.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    9.   2.000   2.000   3.000   2.711   3.000   4.000   
    10.   
    11. summary of quality measures:  
    12.     support           confidence          lift         
    13.  Min.   :0.006101   Min.   :0.2500   Min.   :0.9932    
    14.  1st Qu.:0.007117   1st Qu.:0.2971   1st Qu.:1.6229    
    15.  Median :0.008744   Median :0.3554   Median :1.9332    
    16.  Mean   :0.011539   Mean   :0.3786   Mean   :2.0351    
    17.  3rd Qu.:0.012303   3rd Qu.:0.4495   3rd Qu.:2.3565    
    18.  Max.   :0.074835   Max.   :0.6600   Max.   :3.9565    
    19.   
    20. mining info:  
    21.       data ntransactions support confidence  
    22.  groceries          9835   0.006       0.25  
    第一部分:规则的长度分布:就是minlen到maxlen之间的分布。如上例,len=2有150条规则,len=3有297,len=4有16。同时,rule length的五数分布+均值。

    第二部分:quality measure的统计信息。

    第三部分:挖掘的相关信息。


    使用inpect查看具体的规则

    [java] view plain copy
    1. > inspect(groceryrules[1:5])  
    2.   lhs                rhs                    support confidence     lift  
    3. 1 {potted plants} => {whole milk}       0.006914082  0.4000000 1.565460  
    4. 2 {pasta}         => {whole milk}       0.006100661  0.4054054 1.586614  
    5. 3 {herbs}         => {root vegetables}  0.007015760  0.4312500 3.956477  
    6. 4 {herbs}         => {other vegetables} 0.007727504  0.4750000 2.454874  
    7. 5 {herbs}         => {whole milk}       0.007727504  0.4750000 1.858983  

    4. 评估规则

    规则可以划分为3大类:

    • Actionable
      • 这些rule提供了非常清晰、有用的洞察,可以直接应用在业务上。
    • Trivial
      • 这些rule显而易见,很清晰但是没啥用。属于common sense,如 {尿布} => {婴儿食品}。
    • Inexplicable
      • 这些rule是不清晰的,难以解释,需要额外的研究来判定是否是有用的rule。

    接下来,我们讨论如何发现有用的rule。


    按照某种度量,对规则进行排序。

    [java] view plain copy
    1. > ordered_groceryrules <- sort(groceryrules, by="lift")  
    2. > inspect(ordered_groceryrules[1:5])  
    3.   lhs                   rhs                      support confidence     lift  
    4. 1 {herbs}            => {root vegetables}    0.007015760  0.4312500 3.956477  
    5. 2 {berries}          => {whipped/sour cream} 0.009049314  0.2721713 3.796886  
    6. 3 {other vegetables,                                                          
    7.    tropical fruit,                                                            
    8.    whole milk}       => {root vegetables}    0.007015760  0.4107143 3.768074  
    9. 4 {beef,                                                                      
    10.    other vegetables} => {root vegetables}    0.007930859  0.4020619 3.688692  
    11. 5 {other vegetables,                                                          
    12.    tropical fruit}   => {pip fruit}          0.009456024  0.2634561 3.482649  


    搜索规则

    [java] view plain copy
    1. > yogurtrules <- subset(groceryrules, items %in% c("yogurt"))  
    2. > inspect(yogurtrules)  
    3.     lhs                        rhs                    support confidence     lift  
    4. 1   {cat food}              => {yogurt}           0.006202339  0.2663755 1.909478  
    5. 2   {hard cheese}           => {yogurt}           0.006405694  0.2614108 1.873889  
    6. 3   {butter milk}           => {yogurt}           0.008540925  0.3054545 2.189610  
    7. ......  
    8. 18  {cream cheese,                                                                 
    9.      yogurt}                => {whole milk}       0.006609049  0.5327869 2.085141  
    10. ......  
    11. 121 {other vegetables,                                                             
    12.      whole milk}            => {yogurt}           0.022267412  0.2975543 2.132979  

    items %in% c("A", "B")表示 lhs+rhs的项集并集中,至少有一个item是在c("A", "B")。  item = Aor item = B

    如果仅仅想搜索lhs或者rhs,那么用lhs或rhs替换items即可。如:lhs %in% c("yogurt")


    %in%是精确匹配

    %pin%是部分匹配,也就是说只要item like '%A%' or item like '%B%'

    %ain%是完全匹配,也就是说itemset has ’A' and itemset has ‘B'


    同时可以通过 条件运算符(&, |, !) 添加 support, confidence, lift的过滤条件。

    例子如下:

    [java] view plain copy
    1. > fruitrules <- subset(groceryrules, items %pin% c("fruit"))  
    2. > inspect(fruitrules)  
    3.     lhs                        rhs                    support confidence     lift  
    4. 1   {grapes}                => {tropical fruit}   0.006100661  0.2727273 2.599101  
    5. 2   {fruit/vegetable juice} => {soda}             0.018403660  0.2545710 1.459887  
    [java] view plain copy
    1. > byrules <- subset(groceryrules, items %ain% c("berries""yogurt"))  
    2. > inspect(byrules)  
    3.   lhs          rhs         support confidence     lift  
    4. 1 {berries} => {yogurt} 0.01057448  0.3180428 2.279848  
    [java] view plain copy
    1. > fruitrules <- subset(groceryrules, items %pin% c("fruit") & lift > 2)  
    2. > inspect(fruitrules)  
    3.    lhs                        rhs                    support confidence     lift  
    4. 1  {grapes}                => {tropical fruit}   0.006100661  0.2727273 2.599101  
    5. 2  {pip fruit}             => {tropical fruit}   0.020437214  0.2701613 2.574648  
    6. 3  {tropical fruit}        => {yogurt}           0.029283172  0.2790698 2.000475  
    7. 4  {curd,                                                                         
    8.     tropical fruit}        => {whole milk}       0.006507372  0.6336634 2.479936  
    9. 5  {butter,                                                                       
    10.     tropical fruit}        => {whole milk}       0.006202339  0.6224490 2.436047  

    查看其它的quality measure

    [java] view plain copy
    1. <span style="font-family: sans-serif; background-color: rgb(255, 255, 255);"></span><pre name="code" class="java">> qualityMeasures <- interestMeasure(groceryrules, method=c("coverage","fishersExactTest","conviction""chiSquared"), transactions=groceries)  
    2. > summary(qualityMeasures)  
    3.     coverage        fishersExactTest      conviction       chiSquared        
    4.  Min.   :0.009964   Min.   :0.0000000   Min.   :0.9977   Min.   :  0.0135    
    5.  1st Qu.:0.018709   1st Qu.:0.0000000   1st Qu.:1.1914   1st Qu.: 32.1179    
    6.  Median :0.024809   Median :0.0000000   Median :1.2695   Median : 58.4354    
    7.  Mean   :0.032608   Mean   :0.0057786   Mean   :1.3245   Mean   : 70.4249    
    8.  3rd Qu.:0.035892   3rd Qu.:0.0000001   3rd Qu.:1.4091   3rd Qu.: 97.1387    
    9.  Max.   :0.255516   Max.   :0.5608331   Max.   :2.1897   Max.   :448.5699    
    10. > quality(groceryrules) <- cbind(quality(groceryrules), qualityMeasures)  
    11. > inspect(head(sort(groceryrules, by = "conviction", decreasing = F)))  
    12.   lhs                      rhs              support confidence      lift conviction chiSquared   coverage fishersExactTest  
    13. 1 {bottled beer}        => {whole milk} 0.020437214  0.2537879 0.9932367  0.9976841 0.01352288 0.08052872        0.5608331  
    14. 2 {bottled water,                                                                                                           
    15.    soda}                => {whole milk} 0.007524148  0.2596491 1.0161755  1.0055826 0.02635700 0.02897814        0.4586202  
    16. 3 {beverages}           => {whole milk} 0.006812405  0.2617188 1.0242753  1.0084016 0.05316028 0.02602949        0.4329533  
    17. 4 {specialty chocolate} => {whole milk} 0.008032537  0.2642140 1.0340410  1.0118214 0.12264445 0.03040163        0.3850343  
    18. 5 {candy}               => {whole milk} 0.008235892  0.2755102 1.0782502  1.0275976 0.63688634 0.02989324        0.2311769  
    19. 6 {sausage,                                                                                                                 
    20.    soda}                => {whole milk} 0.006710727  0.2761506 1.0807566  1.0285068 0.54827850 0.02430097        0.2508610  

    第三个参数transactions:一般情况下都是原来那个数据集,但也有可能是其它数据集,用于检验这些rules在其他数据集上的效果。所以,这也是评估rules的一种方法:在其它数据集上计算这些规则的quality measure用以评估效果。

    fishersExactTest 的p值大部分都是很小的(p < 0.05),这就说明这些规则反应出了真实的用户的行为模式。

    coverage从0.01 ~ 0.26,相当于覆盖到了多少范围的用户。

    ChiSquared: 考察该规则的LHS和RHS是否独立?即LHS与RHS的列联表的ChiSquare Test。p<0.05表示独立,否则表示不独立。

    限制挖掘的item

    可以控制规则的左手边或者右手边出现的item,即appearance。但尽量要放低支持度和置信度。

    [java] view plain copy
    1. > berriesInLHS <- apriori(groceries, parameter = list( support = 0.001, confidence = 0.1 ), appearance = list(lhs = c("berries"), default="rhs"))  
    2.   
    3. Parameter specification:  
    4.  confidence minval smax arem  aval originalSupport support minlen maxlen target   ext  
    5.         0.1    0.1    1 none FALSE            TRUE   0.001      1     10  rules FALSE  
    6.   
    7. Algorithmic control:  
    8.  filter tree heap memopt load sort verbose  
    9.     0.1 TRUE TRUE  FALSE TRUE    2    TRUE  
    10.   
    11. apriori - find association rules with the apriori algorithm  
    12. version 4.21 (2004.05.09)        (c) 1996-2004   Christian Borgelt  
    13. set item appearances ...[1 item(s)] done [0.00s].  
    14. set transactions ...[169 item(s), 9835 transaction(s)] done [0.00s].  
    15. sorting and recoding items ... [157 item(s)] done [0.00s].  
    16. creating transaction tree ... done [0.00s].  
    17. checking subsets of size 1 2 done [0.00s].  
    18. writing ... [26 rule(s)] done [0.00s].  
    19. creating S4 object  ... done [0.00s].  
    20. > summary(berriesInLHS)  
    21. set of 26 rules  
    22.   
    23. rule length distribution (lhs + rhs):sizes  
    24.  1  2   
    25.  8 18   
    26.   
    27.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    28.   1.000   1.000   2.000   1.692   2.000   2.000   
    29.   
    30. summary of quality measures:  
    31.     support           confidence          lift        
    32.  Min.   :0.003660   Min.   :0.1049   Min.   :1.000    
    33.  1st Qu.:0.004601   1st Qu.:0.1177   1st Qu.:1.000    
    34.  Median :0.007016   Median :0.1560   Median :1.470    
    35.  Mean   :0.053209   Mean   :0.1786   Mean   :1.547    
    36.  3rd Qu.:0.107982   3rd Qu.:0.2011   3rd Qu.:1.830    
    37.  Max.   :0.255516   Max.   :0.3547   Max.   :3.797    
    38.   
    39. mining info:  
    40.       data ntransactions support confidence  
    41.  groceries          9835   0.001        0.1  
    42. > inspect(berriesInLHS)  
    43.    lhs          rhs                         support confidence     lift  
    44. 1  {}        => {bottled water}         0.110523640  0.1105236 1.000000  
    45. 2  {}        => {tropical fruit}        0.104931368  0.1049314 1.000000  
    46. 3  {}        => {root vegetables}       0.108998475  0.1089985 1.000000  
    47. 4  {}        => {soda}                  0.174377224  0.1743772 1.000000  
    48. 5  {}        => {yogurt}                0.139501779  0.1395018 1.000000  
    49. 6  {}        => {rolls/buns}            0.183934926  0.1839349 1.000000  
    50. 7  {}        => {other vegetables}      0.193492628  0.1934926 1.000000  
    51. 8  {}        => {whole milk}            0.255516014  0.2555160 1.000000  
    52. 9  {berries} => {beef}                  0.004473818  0.1345566 2.564659  
    53. 10 {berries} => {butter}                0.003762074  0.1131498 2.041888  
    54. 11 {berries} => {domestic eggs}         0.003863752  0.1162080 1.831579  
    55. 12 {berries} => {fruit/vegetable juice} 0.003660397  0.1100917 1.522858  
    56. 13 {berries} => {whipped/sour cream}    0.009049314  0.2721713 3.796886  
    57. 14 {berries} => {pip fruit}             0.003762074  0.1131498 1.495738  
    58. 15 {berries} => {pastry}                0.004270463  0.1284404 1.443670  
    59. 16 {berries} => {citrus fruit}          0.005388917  0.1620795 1.958295  
    60. 17 {berries} => {shopping bags}         0.004982206  0.1498471 1.520894  
    61. 18 {berries} => {sausage}               0.004982206  0.1498471 1.594963  
    62. 19 {berries} => {bottled water}         0.004067107  0.1223242 1.106769  
    63. 20 {berries} => {tropical fruit}        0.006710727  0.2018349 1.923494  
    64. 21 {berries} => {root vegetables}       0.006609049  0.1987768 1.823666  
    65. 22 {berries} => {soda}                  0.007320793  0.2201835 1.262685  
    66. 23 {berries} => {yogurt}                0.010574479  0.3180428 2.279848  
    67. 24 {berries} => {rolls/buns}            0.006609049  0.1987768 1.080691  
    68. 25 {berries} => {other vegetables}      0.010269446  0.3088685 1.596280  
    69. 26 {berries} => {whole milk}            0.011794611  0.3547401 1.388328  

    既然lhs都是一样的,那么只查看rhs的itemset即可,可以如下:

    [java] view plain copy
    1. > inspect(head(<strong>rhs(berriesInLHS)</strong>, n=5))  
    2.   items              
    3. 1 {bottled water}    
    4. 2 {tropical fruit}   
    5. 3 {root vegetables}  
    6. 4 {soda}             
    7. 5 {yogurt}       


    当然,还可以使用subset进行进一步的过滤,例如,不希望看到rhs包含"root vegetables" 或 "whole milk"

    [java] view plain copy
    1. > berrySub <- subset(berriesInLHS, subset = !(rhs %in% c("root vegetables""whole milk")))  
    2. > inspect(head(rhs(sort(berrySub, by="confidence")), n=5))  
    3.   items                 
    4. 1 {yogurt}              
    5. 2 {other vegetables}    
    6. 3 {whipped/sour cream}  
    7. 4 {soda}                
    8. 5 {tropical fruit}      
    9. > berrySub  
    10. set of 22 rules   

    保存挖掘的结果

    有两种使用场景。

    第一,保存到文件。可以与外部程序进行交换。

    [java] view plain copy
    1. > write(groceryrules, file="groceryrules.csv", sep=",", quote=TRUE, row.names=FALSE)  

    第二,转换为data frame,然后再进行进一步的处理。处理完的结果可以保存到外部文件或者数据库。

    [java] view plain copy
    1. > groceryrules_df <- as(groceryrules, "data.frame")  
    2. > str(groceryrules_df)  
    3. 'data.frame':   463 obs. of  8 variables:  
    4.  $ rules           : Factor w/ 463 levels "{baking powder} => {other vegetables}",..: 340 302 207 206 208 341 402 21 139 140 ...  
    5.  $ support         : num  0.00691 0.0061 0.00702 0.00773 0.00773 ...  
    6.  $ confidence      : num  0.4 0.405 0.431 0.475 0.475 ...  
    7.  $ lift            : num  1.57 1.59 3.96 2.45 1.86 ...  
    8.  $ conviction      : num  1.24 1.25 1.57 1.54 1.42 ...  
    9.  $ chiSquared      : num  19 17.7 173.9 82.6 41.2 ...  
    10.  $ coverage        : num  0.0173 0.015 0.0163 0.0163 0.0163 ...  
    11.  $ fishersExactTest: num  2.20e-05 4.13e-05 6.17e-26 4.56e-16 1.36e-09 ...  

    关于关联规则挖掘的进阶部分

    1. 带有Hierarchy的item

    这里我们使用arules自带的数据集Groceries。该数据集不仅包含购物篮的item信息,而且还包含每个item对于的类别,总共有两层类别。如下所示:

    [java] view plain copy
    1. > data(Groceries)  # grocery transactions object from arules package  
    2. >   
    3. > summary(Groceries)  
    4. transactions as itemMatrix in sparse format with  
    5.  9835 rows (elements/itemsets/transactions) and  
    6.  169 columns (items) and a density of 0.02609146   
    7.   
    8. most frequent items:  
    9.       whole milk other vegetables       rolls/buns             soda           yogurt          (Other)   
    10.             2513             1903             1809             1715             1372            34055   
    11.   
    12. element (itemset/transaction) length distribution:  
    13. sizes  
    14.    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   26   27   28   29   32   
    15. 2159 1643 1299 1005  855  645  545  438  350  246  182  117   78   77   55   46   29   14   14    9   11    4    6    1    1    1    1    3    1   
    16.   
    17.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    18.   1.000   2.000   3.000   4.409   6.000  32.000   
    19.   
    20. includes extended item information - examples:  
    21.        labels  <strong><span style="color:#ff0000;">level2           level1</span></strong>  
    22. 1 frankfurter sausage meet and sausage  
    23. 2     sausage sausage meet and sausage  
    24. 3  liver loaf sausage meet and sausage  
    在summary的最后一部分,我们发现除了labels(即item)之外,还有两个字段,level2和level1。我们可以通过itemInfo进行查看level1和level2的详细信息,如下所示:

    [java] view plain copy
    1. > print(levels(itemInfo(Groceries)[["level1"]]))  
    2.  [1"canned food"          "detergent"            "drinks"               "fresh products"       "fruit and vegetables" "meet and sausage"     "non-food"              
    3.  [8"perfumery"            "processed food"       "snacks and candies"    
    4. > print(levels(itemInfo(Groceries)[["level2"]]))   
    5.  [1"baby food"                       "bags"                            "bakery improver"                 "bathroom cleaner"                 
    6.  [5"beef"                            "beer"                            "bread and backed goods"          "candy"                            
    7.  [9"canned fish"                     "canned fruit/vegetables"         "cheese"                          "chewing gum"                      
    8. [13"chocolate"                       "cleaner"                         "coffee"                          "condiments"                       
    9. [17"cosmetics"                       "dairy produce"                   "delicatessen"                    "dental care"                      
    10. [21"detergent/softener"              "eggs"                            "fish"                            "frozen foods"                     
    11. [25"fruit"                           "games/books/hobby"               "garden"                          "hair care"                        
    12. [29"hard drinks"                     "health food"                     "jam/sweet spreads"               "long-life bakery products"        
    13. [33"meat spreads"                    "non-alc. drinks"                 "non-food house keeping products" "non-food kitchen"                 
    14. [37"packaged fruit/vegetables"       "perfumery"                       "personal hygiene"                "pet food/care"                    
    15. [41"pork"                            "poultry"                         "pudding powder"                  "sausage"                          
    16. [45"seasonal products"               "shelf-stable dairy"              "snacks"                          "soap"                             
    17. [49"soups/sauces"                    "staple foods"                    "sweetener"                       "tea/cocoa drinks"                 
    18. [53"vegetables"                      "vinegar/oils"                    "wine"     


    一般来说,如果商品有类别信息,可以尝试在类别上进行关联规则的挖掘,毕竟成千上百个商品之间的规则挖掘要困难得多。可以先从高粒度上进行挖掘实验,然后再进行细粒度的挖掘实验。本例中,因为Level1包含的类别信息太少,关联规则的挖掘没有意义,而Level2有55个,可以使用Level2。在R中,可以用aggregate函数把item替换为它对应的category,如下所示:(可以把aggregate看成transform的过程)

    [java] view plain copy
    1. > inspect(Groceries[1:3])  
    2.   items                  
    3. 1 {citrus fruit,         
    4.    semi-finished bread,  
    5.    margarine,            
    6.    ready soups}          
    7. 2 {tropical fruit,       
    8.    yogurt,               
    9.    coffee}               
    10. 3 {whole milk}        
    11. > <strong>groceries <- aggregate(Groceries, itemInfo(Groceries)[["level2"]])  </strong>  
    12. > inspect(groceries[1:3])  
    13.   items                     
    14. 1 {bread and backed goods,  
    15.    fruit,                   
    16.    soups/sauces,            
    17.    vinegar/oils}            
    18. 2 {coffee,                  
    19.    dairy produce,           
    20.    fruit}                   
    21. 3 {dairy produce}    

    我们可以对比一下在aggregate前后的itemFrequency图。

    [java] view plain copy
    1. itemFrequencyPlot(Groceries, support = 0.025, cex.names=0.8, xlim = c(0,0.3),  
    2.   type = "relative", horiz = TRUE, col = "dark red", las = 1,  
    3.   xlab = paste("Proportion of Market Baskets Containing Item",  
    4.     "\n(Item Relative Frequency or Support)"))  
    [java] view plain copy
    1. horiz=TRUE: 让柱状图水平显示  
    [java] view plain copy
    1. cex.names=0.8:item的label(这个例子即纵轴)的大小乘以的系数。  
    [java] view plain copy
    1. las=1: 表示刻度的方向,1表示总是水平方向。  
    [java] view plain copy
    1. type="relative": 即support的值(百分比)。如果type=absolute表示显示该item的count,而非support。默认就是relative。  



    2. 规则的图形展现

    假设我们有这样一个规则集合:

    [java] view plain copy
    1. > second.rules <- apriori(groceries,   
    2. +                         parameter = list(support = 0.025, confidence = 0.05))  
    3.   
    4. Parameter specification:  
    5.  confidence minval smax arem  aval originalSupport support minlen maxlen target   ext  
    6.        0.05    0.1    1 none FALSE            TRUE   0.025      1     10  rules FALSE  
    7.   
    8. Algorithmic control:  
    9.  filter tree heap memopt load sort verbose  
    10.     0.1 TRUE TRUE  FALSE TRUE    2    TRUE  
    11.   
    12. apriori - find association rules with the apriori algorithm  
    13. version 4.21 (2004.05.09)        (c) 1996-2004   Christian Borgelt  
    14. set item appearances ...[0 item(s)] done [0.00s].  
    15. set transactions ...[55 item(s), 9835 transaction(s)] done [0.02s].  
    16. sorting and recoding items ... [32 item(s)] done [0.00s].  
    17. creating transaction tree ... done [0.00s].  
    18. checking subsets of size 1 2 3 4 done [0.00s].  
    19. writing ... [344 rule(s)] done [0.00s].  
    20. creating S4 object  ... done [0.00s].  
    21. > print(summary(second.rules))  
    22. set of 344 rules  
    23.   
    24. rule length distribution (lhs + rhs):sizes  
    25.   1   2   3   4   
    26.  21 162 129  32   
    27.   
    28.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    29.     1.0     2.0     2.0     2.5     3.0     4.0   
    30.   
    31. summary of quality measures:  
    32.     support          confidence           lift         
    33.  Min.   :0.02542   Min.   :0.05043   Min.   :0.6669    
    34.  1st Qu.:0.03030   1st Qu.:0.18202   1st Qu.:1.2498    
    35.  Median :0.03854   Median :0.39522   Median :1.4770    
    36.  Mean   :0.05276   Mean   :0.37658   Mean   :1.4831    
    37.  3rd Qu.:0.05236   3rd Qu.:0.51271   3rd Qu.:1.7094    
    38.  Max.   :0.44301   Max.   :0.79841   Max.   :2.4073    
    39.   
    40. mining info:  
    41.       data ntransactions support confidence  
    42.  groceries          9835   0.025       0.05  

    2.1 Scatter Plot

    [java] view plain copy
    1. > plot(second.rules,   
    2. +      control=list(jitter=2, col = rev(brewer.pal(9"Greens")[4:9])),  
    3. +      shading = "lift")     

    shading = "lift": 表示在散点图上颜色深浅的度量是lift。当然也可以设置为support 或者Confidence。

    jitter=2:增加抖动值

    col: 调色板,默认是100个颜色的灰色调色板。

    brewer.pal(n, name): 创建调色板:n表示该调色板内总共有多少种颜色;name表示调色板的名字(参考help)。

    这里使用Green这块调色板,引入9中颜色。


    这幅散点图表示了规则的分布图:大部分规则的support在0.1以内,Confidence在0-0.8内。每个点的颜色深浅代表了lift的值。

    2.2 Grouped Matrix

    [java] view plain copy
    1. > plot(second.rules, method="grouped",     
    2. +      control=list(col = rev(brewer.pal(9"Greens")[4:9])))  

    Grouped matrix-based visualization. 

    Antecedents (columns) in the matrix are grouped using clustering. Groups are represented as balloons in the matrix.


    2.3 Graph

    Represents the rules (or itemsets) as a graph

    [java] view plain copy
    1. <strong>> plot(top.vegie.rules, measure="confidence", method="graph",   
    2. +      control=list(type="items"),   
    3. +      shading = "lift")</strong>  
    type=items表示每个圆点的入度的item的集合就是LHS的itemset

    measure定义了圈圈大小,默认是support

    颜色深浅有shading控制


    关联规则挖掘小结

    1. 关联规则是发现数据间的关系:可能会共同发生的那些属性co-occurrence

    2. 一个好的规则可以用lift或者FishersExact Test进行校验。

    3. 当属性(商品)越多的时候,支持度会比较低。

    4. 关联规则的发掘是交互式的,需要不断的检查、优化。

    FP-Growth

    TO ADD Here

    eclat

    arules包中有一个eclat算法的实现,用于发现频繁项集。

    例子如下:

    [java] view plain copy
    1. > groceryrules.eclat <- eclat(groceries, parameter = list(support=0.05, minlen=2))  
    2.   
    3. parameter specification:  
    4.  tidLists support minlen maxlen            target   ext  
    5.     FALSE    0.05      2     10 frequent itemsets FALSE  
    6.   
    7. algorithmic control:  
    8.  sparse sort verbose  
    9.       7   -2    TRUE  
    10.   
    11. eclat - find frequent item sets with the eclat algorithm  
    12. version 2.6 (2004.08.16)         (c) 2002-2004   Christian Borgelt  
    13. create itemset ...   
    14. set transactions ...[169 item(s), 9835 transaction(s)] done [0.01s].  
    15. sorting and recoding items ... [28 item(s)] done [0.00s].  
    16. creating sparse bit matrix ... [28 row(s), 9835 column(s)] done [0.00s].  
    17. writing  ... [3 set(s)] done [0.00s].  
    18. Creating S4 object  ... done [0.00s].  
    19. > summary(groceryrules.eclat)  
    20. set of 3 itemsets  
    21.   
    22. most frequent items:  
    23.       whole milk other vegetables       rolls/buns           yogurt abrasive cleaner          (Other)   
    24.                3                1                1                1                0                0   
    25.   
    26. element (itemset/transaction) length distribution:sizes  
    27. 2   
    28. 3   
    29.   
    30.    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.   
    31.       2       2       2       2       2       2   
    32.   
    33. summary of quality measures:  
    34.     support         
    35.  Min.   :0.05602    
    36.  1st Qu.:0.05633    
    37.  Median :0.05663    
    38.  Mean   :0.06250    
    39.  3rd Qu.:0.06573    
    40.  Max.   :0.07483    
    41.   
    42. includes transaction ID lists: FALSE   
    43.   
    44. mining info:  
    45.       data ntransactions support  
    46.  groceries          9835    0.05  
    47. > inspect(groceryrules.eclat)  
    48.   items                 support  
    49. 1 {whole milk,                   
    50.    yogurt}           0.05602440  
    51. 2 {rolls/buns,                   
    52.    whole milk}       0.05663447  
    53. 3 {other vegetables,             
    54.    whole milk}       0.07483477  

    参考文献

    1. Vijay Kotu; Bala Deshpande, Predictive Analytics and Data Mining(理论)

    2. Brett Lantz, Machine Learning with R (案例:购物篮)

    3. Nina Zumel and John Mount, Practical Data Science with R (案例:其他)

    4. Modeling Techniques in Predictive Analytics (案例:购物篮)

    5. http://michael.hahsler.net/SMU/EMIS7332/ (理论和案例)


    作者:https://blog.csdn.net/gjwang1983/article/details/45015203



    展开全文
  • 灰色关联分析

    万次阅读 2016-10-16 22:50:20
    对于两个系统之间的因素,其随时间或不同对象而变化的关联性大小的量度,称为关联度。在系统发展过程中,若两个因素变化的趋势具有一致性,即同步变化程度较高,即可谓二者关联程度较高;反之,则较低。因此,灰色...
  • SPSS Modeler——超市商品购买关联分析

    万次阅读 多人点赞 2018-10-31 11:21:09
    摘要 关联分析,用于发现隐藏在大型数据集中的意义的联系。这种联系反映一个事物与其他事物之间的相互依存性和关联性。...本次试验主要两个分析方向,分别是分析商品之间的潜在联系和分析顾客可能还会购...
  • 关联规则1:关联规则的应用场景

    千次阅读 2020-08-03 11:33:30
    关联规则,作为十大机器学习算法之一,应用非常广泛。最经典的例子当然是“啤酒”和“尿布” 的故事。 这个故事的背景是什么呢?
  • 关联分析的基本概念

    千次阅读 2018-01-04 13:39:53
    关联分析也是人的一种认知模式,这种关联规则和人的反射类似,就是在认识事物的过程中在认知中建立的关联规则。关联分析是数据挖掘里很重要的部分。1. 频繁模式例如一个超市每天很多的购物记录,而且消费者的购买...
  • UML关联关系

    千次阅读 2012-07-06 10:49:53
    UML中的关联关系其内在意思就是has a ...当然,关联关系中也双相关联     关联又分为组合,聚合   对应的代码如下: 设计模式中的关联关系 代码如下: 1: //工作经历 2: class WorkExperience
  • R语言 关联规则

    千次阅读 2016-05-15 22:17:36
    R语言 关联规则 igraph包
  • 一文详解SQL关联子查询

    千次阅读 2021-03-30 13:42:20
    简介:本文主要介绍什么关联子查询以及如何将关联子查询改写为普通语义的sql查询。...关联子查询是指和外部查询有关联的子查询,具体来说就是在这个子查询里使用了外部查询包含的列。 因为这种可以使用.
  • hibernate多表关联配置

    千次阅读 2014-12-02 13:02:05
    单向关联参考Hibernate Reference Documentation) 一、多对一(many-to-one) 单向 many-to-one 关联是最常见的单向关联关系。 column="addressId" not-null="true"/>
  • 如何优化多数据集关联报表

    千次阅读 2018-11-12 11:42:52
    多数据集关联报表是很常见的报表形式,它允许开发者分别从不同的来源(表或数据库)分别准备数据形成不同的数据集,在报表端(模板)通过表达式描述数据集间的关系完成关联。这样可以避免在数据准备时写过于复杂的 ...
  • 关联分析(一):频繁项集及规则产生

    万次阅读 多人点赞 2018-09-28 15:46:10
    关联分析用于发现隐藏在大型数据集中意义的联系,属于模式挖掘分析方法,其为人熟知的经典应用当属沃尔玛超市里“啤酒与尿布”的关系挖掘了。关联分析的应用领域非常多,当数据集类型比较复杂时,进行关联分析采用...
  • R语言 | 关联规则

    万次阅读 多人点赞 2015-04-12 22:48:05
    关联规则(AssociationRules)是无监督的机器学习方法,用于知识发现,而非预测。 关联规则的学习器(learner)无需事先对训练数据进行打标签,因为无监督学习没有训练这个步骤。缺点是很难对关联规则学习器进行模型...
  • 互感的方向

    千次阅读 2018-12-03 19:08:07
    注意:d图电流都是离开同名端,互感对右边产生的电压同参考方向相反 自感的正负号只同关联方向有关,与同名端无关。... b:被激励源电流方向是否同被激励源的电压参考方向关联(由此决定正负号)  ...
  • ORM框架Hibernate (四) 一对一单向、双向关联映射

    千次阅读 热门讨论 2013-08-25 21:26:22
    记得在Java编程思想上第一句话是“一切皆对象”,生活中的所有事物都是对象,这种一一对应的关系也体现在了对象上,但是在对象上了些区别这和对象的特性关系,方向性,拿人和身份证来说他们是两个对象,如果...
  • 关联规则挖掘算法综述

    千次阅读 2005-10-07 21:42:00
    摘 要 本文介绍了关联规则的基本概念和分类方法,列举了一些关联规则挖掘算法并简要分析了典型算法,展望了关联规则挖掘的未来研究方向。 1 引言 关联规则挖掘发现大量数据中项集之间有趣的关联或相关联系。它在数据...
  • 灰色关联分析法 (附代码)

    千次阅读 2020-05-14 03:59:28
    灰色关联分析是指对一个系统发展变化态势的定量描述和比较的方法,其基本思想是通过确定参考数据列和若干个比较数据列的几何形状相似程度来判断其联系是否紧密,它反映了曲线间的关联程度。 简介: 灰色系统理论是...
  • Hibernate关联映射及配置

    千次阅读 2013-04-06 20:18:52
    ORM,即对象关系映射,其中对象指应用程序中的实体对象,关系指关系型数据库。ORM框架的核心功能,就是通过操作对象的... 对象之间存在多种关联关系,而且大部分关联关系在Hibernate中都不止一种映射方式。在重温了
  • 何为关联规则学习 关联规则学习是一种基于规则的机器学习方法,用于发现大型数据库中变量之间的有趣关系。它旨在使用一些有趣的度量来识别在数据库中发现的强规则。这种基于规则的方法在分析更多数据时也会生成新...
  • 上篇《数据基础设施创新如火如荼,主要方向有哪些(上)》介绍了数据基础设施领域近期创新的总体情况及前三个典型创新领域,这是下篇,继续介绍后两个创新领域及创新背后的技术和需求驱动因素。
  • 最近接触了一个推荐系统的建设项目,于是我顺便回顾了一下之前零星学到的推荐知识,把一些困惑很久的问题弄明白了,所以来总结一下。...关联规则是数据挖掘中的典型问题之一,又被称为购物篮分析,这是因为传统的关联
  • 关联规则Java实现

    千次阅读 2015-09-06 15:46:11
    * 首先List<List<String>>类型的record将矩阵形式的数据读入内存; * *程序先求出k-1备选集,由备选集和数据库记录record求得满足支持度的k-1级集合,在满足支持度集合中求出满足自信度的集合, *若满足置信...
  • LTE中的参考信号

    千次阅读 2016-10-27 15:50:45
    LTE信道结构可参考博文:...方向 参考符号(缩写) 参考符号 参考符号(中文) 作用 下行 CRS Cell-specific reference signals 小区专有参考符号 公共参考符号,所有UE都可以使用。用于PDSCH测量 UE
  • 关联规则——FP-Tree算法

    千次阅读 2015-09-07 10:33:25
    关联规则挖掘领域最经典的算法法是Apriori,其致命的缺点是需要多次扫描事务数据库。于是人们提出了各种裁剪(prune)数据集的方法以减少I/O开支,韩嘉炜老师的FP-Tree算法就是其中非常高效的一种。 支持度和...
  • 数学建模学习笔记:灰色关联分析

    千次阅读 2020-04-22 21:28:01
    本次笔记内容内容来自清风老师的课程整理,增加了一些拓展资源以及自己的见解,如侵权请联系删除。清风老师的数学建模课程可以在B站搜索到。 本文给出了excel和matlab两种计算灰色关联度的过程详解。 灰色关联...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,176
精华内容 32,070
关键字:

关联参考方向有什么用