精华内容
下载资源
问答
  • 基于关联规则的推荐有三方法:Apriori关联规则算法FP Tree关联规则算法;PrefixSpan关联规则算法;关联规则挖掘推荐算法:关联规则挖掘是一在大规模交易中识别类似规则关系模式的通用技术,可以应用到推荐系统中...

    基于关联规则的推荐有三种方法:Apriori关联规则算法FP Tree关联规则算法;PrefixSpan关联规则算法;

    关联规则挖掘推荐算法:

    关联规则挖掘是一种在大规模交易中识别类似规则关系模式的通用技术,可以应用到推荐系统中。交易T是所有有效产品集合P={p 1 ,p 2 ,...,p n }的子集,表示被一起购买的产品集合,关联规则X=>Y表示只要交易T中包含了X里面的元素,那么认为Y里面的元素也有可能被T包含。常见的规则挖掘算法是Apriori算法,关联规则的衡量指标是:支持度(support)和可信度(confidence)。将关联规则应用到推荐系统的主要问题就是需要将评分转换为交易,一般情况把所有的向前(正向)的评分集合<可以是做过去均值化操作后的评分矩阵>或者用户的购买行为可以看做一次交易。

    Apriori算法概述:

    Apriori算法是常用的用于挖掘出数据关联规则的算法,它用来找出数据值中频繁出现的数据集合,这些找出的集合有助于我们的业务决策,同时我们也可以认为这些频繁出现的数据集合中的数据项存在一定的关联性,简而言之,可以认为这些数据项之间存在某种“相似性”。比如在电商的网购数据中,如果发现某一些商品经常一起被购买,那么我们可以认为这些商品之间存在某种“相似性”,从而我们可以优化网站中这些商品的排列位置、优化商品的仓库位置或者将这些“相似”的物品推荐给正在浏览对应物品的客户,从而可以达到增加经济效益、节约成本的目的。

    交易集:包含所有数据的一个数据集合,数据集合中的每条数据都是一笔交易;项:交易集中的每个商品被成为一个项;模式/项集(ItemSet):项组合被成为模式/项集;支持度(Support):一个项集在在整个交易集中出现的次数/出现的频度,比如:Support({A,C})=2表示A和C同时出现的次数是2次;最小支持度:交易次数达到最小支持度的情况下,该项集才会被计算;频繁项集:如果项集的支持度大于等于最小支持度,那么该项集被成为频繁项集;置信度(Confidence):关联规则左件和右件同时出现的频繁程度,该值越大,表示同时出现的几率越大;关联规则:LHS  RHS(confidence) -----> 如果客户购买了左件(LHS),也可能购买右件(RHS),购买的置信度为confidence

    311c50e2e2e6e525fc98a4ab27f055cb.png

    Apriori算法原理:

    Apriori算法本质的作用是找出购物数据集中的最频繁的K项集;Apriori算法采用了迭代的方法,先搜索出候选1项集及对应的支持度,剪枝去掉低于最小支持度的1项集,得到频繁1项集。然后对剩下的频繁1项集进行连接,得到候选的频繁2项集,筛选去掉低于最小支持度的候选频繁2项集,得到频繁2项集,以此类推,迭代下去,直到无法找到频繁k+1项集为止,对应的频繁k项集的集合即为算法的输出结果。

    173c2b94e37dafa026e3bc5aebdb883b.png

    输入:数据集合D,支持度阈值α;输出:最大的频繁K项集

    1. 扫描整个数据集,得到所有出现过的1项集,得到候选频繁1项集。2. 令k = 1;3. 挖掘频繁k项集;扫描数据计算候选频繁k项集的支持度去除候选频繁k项集中支持度低于阈值的数据集,得到频繁k项集。如果得到的频繁k项集为空,则直接返回频繁k-1项集的集合作为算法结果,算法结束。如果得到的频繁k项集只有一项,则直接返回频繁k项集的集合作为算法结果,算法结束。基于频繁k项集和频繁1项集,连接生成候选频繁k+1项集。4. k=k+1,转入步骤3。

    Apriori算法总结:

    priori算法是一种非常经典的频繁项集的挖掘算法,很多算法都是基于Apriori算法的一种扩展,比如:FP-Tree、GSP、CBA等等。理解掌握Apriori算法原理,对于对数据挖掘相关算法的学习具有非常好的作用。不过,现在一般很少直接使用Aprior算法来进行数据挖掘了,原因是:Apriori算法的数据挖掘效率比较低。

    FP Tree算法概述:

    Apriori算法作为挖掘频繁项集的算法,需要多次扫描数据,I/O瓶颈比较高,为了解决这个问题,提出了FP-Tree算法,也称为FP Growth算法;在FP Tree算法中,不管存在多少数据量,只需要扫描两次数据集,因此提高了算法的运行效率。FP Tree算法改进了Apriori算法的I/O瓶颈,类似BIRCH聚类,利用树结构来提高算法的执行效率,是一种利用空间换时间的一种算法效率提升方式。备注:FP Tree是我们在生产环境中常用的一种数据挖掘频繁项集的算法。

    FP Tree算法原理:

    为了减少I/O次数,FP Tree算法引入了一些数据结构来临时存储数据,主要包含

    三个部分:

    1. 项头表:记录所有的1项频繁集以及出现的次数,按照次数降序排列。2. FP Tree:将原始数据集映射到内存中的一棵FP树。3. 节点链表:基于项头表保存的在FP Tree中对应的项的存储位置的一个链表。FP Tree算法可以分为一下两个过程:1. 项头表和FP Tree的构建2. FP Tree的挖掘

    9f0d02c0d0aa7cf64b4be0b5c32ededc.png

    FP-Tree算法原理之项头表构建:

    扫描所有数据,得到所有一项集的支持度,然后删除支持度低于阈值的项,得到频繁一项集,将所有频繁一项集按照支持度降序排列,放入项头表中。

    FP-Tree算法原理之FP Tree构建:

    FP Tree树的构建是FP-Tree算法的关键点,主要分为两个过程:

    1. 扫描数据,对于每条数据删除非频繁的1项集,并按照支持度降序排列,得到排序后的数据集。

    2. 基于排序好的数据集构建FP Tree。初始状态FP树是空的,建立FP树时我们一条条的读入排序后的数据集,插入FP树,插入时按照排序后的顺序,插入FP树中,排序靠前的节点是祖先节点,而靠后的是子孙节点。如果有共用的祖先,则对应的公用祖先节点计数加1。插入后,如果有新节点出现,则项头表对应的节点会通过节点链表链接上新节点。直到所有的数据都插入到FP树后,FP树的建立完成。

    FP-Tree算法原理之FP Tree挖掘:

    当构建好FP树、项头表以及节点链表后,就可以开始进行频繁项集的挖掘了。首先从项头表的底部项依次向上挖掘,对于项头表对应于FP树的每一项,找出对应的条件模式基,所谓条件模式基是以我们要挖掘的节点作为叶子节点所对应的FP子树,得到这个FP子树,我们将子树中每个节点的的计数设置为叶子节点的计数,并删除计数低于支持度的节点。从这个条件模式基,我们就可以递归挖掘得到频繁项集了。

    寻找F节点的条件模式基;我们很容易得到F的频繁2项集为{A:2,F:2}、{C:2,F:2}、{E:2,F:2}、{B:2,F:2}。递归合并二项集,得到频繁三项集为{A:2,C:2,F:2}、{A:2,E:2,F:2},...。当然一直递归下去,最大的频繁项集为频繁5项集,为{A:2,C:2,E:2,B:2,F:2}

    7017dc7910be7085413a7809cbe0e315.png

    FP-Tree算法总结归纳:

    FP-Tree算法流程主要包括一下几步:扫描数据,得到所有的频繁1项集的计数,然后删除支持度低于阈值的项,将1项频繁集放入项头表,并按照支持度降序排列。读取数据集中的数据,将数据中的非频繁1项集删除,并按照支持度排序排列后将数据插入到FP树中,插入时按照排序后的顺序插入,并计算当前节点的后序子孙节点的数目。直到所有数据均插入到FP树后,FP树构建完成。从项头表的底部项依次向上找到项头表项对应的条件模式基。从条件模式基递归挖掘得到项头表项项的频繁项集。如果不限制频繁项集的项数,则返回上一步骤的所有的频繁项集,否则只返回满足项数要求的频繁项集。

    PrefixSpan算法概述:
    PrefixSpan全称Prefix-Projected Pattern Growth(即前缀投影的模式挖掘),是用于挖掘频繁序列的数据挖掘算法,和Apriori算法以及FP Tree算法的挖掘目标稍有不同。PrefixSpan算法是生产中常用的一种频繁序列模式挖掘算法。备注:序列中的项集是具有时间上的先后关系的。

    2279d7d0cf21d24e0b1baba02ec9ef6c.png

    子序列:如果某个序列A所有的项集在序列B中都可以找到,则A是B的子序列。

    eed202df8f77228c0aa1ec9f8dc5d08f.png

    频繁序列:出现频次超过支持度的子序列就叫做频繁序列。

    前缀序列:即序列前面部分的子序列。

    33d4e6c96042d5d40fd7d715f8b04bce.png

    669c3cc68bec9947a28da64a1454a012.png

    后缀序列:即序列中位于前缀序列之后的子序列就叫做后缀序列。

    前缀投影:即投影数据库,即序列数据库S中所有相对于前缀的后缀序列的集合

    PrefixSpan算法原理:

    类似Apriori算法,先找出所有子序列中长度为1的前缀开始挖掘序列模型(并且删除原始序列中非频繁的长度为1的序列),搜索对应的投影数据库得到长度为1的前缀对应的频繁序列,然后递归的挖掘长度为2的前缀所对应的频繁序列,。。。以此类推,一直递归到不能挖掘到更长的前缀挖掘为止。

    6e29d457a59c93e06f787f23890774c0.png

    PrefixSpan算法流程:

    输入:序列数据库S和支持度阈值α 输出:所有满足支持度要求的频繁序列集

    步骤:(备注:所找到的前缀即频繁序列)

    1. 找出所有子序列中长度为1的前缀以及对应的投影数据库;2. 对于长度为1的前缀进行计数,将支持度低于阈值α的前缀对应的项从序列数据库;S中删除,同时得到所有的频繁1项序列。3. 对于每个长度为i满足支持度的前缀进行递归挖掘:

    a. 找出前缀对应的投影数据库,如果投影数据库为空,则递归返回;b. 统计对应投影数据库中各项的支持度计数,如果所有项的支持度计数都低于阈值α,则递归返回。;c. 将满足支持度计数的各个单项和当前的前缀进行合并,得到若干新的前缀。;d. 令i=i+1,前缀为合并单项后的各个前缀,分别递归执行第三步。

    协同过滤各种方式总结:

    广义的协同过滤算法主要包括三种算法:基于用户(UserCF)的协同过滤算法;基于物品(ItemCF)的协同过滤算法;基于模型(ModelCF)的协同过滤算法;

    使用关联规则的协同过滤;使用聚类算法的协同过滤;使用分类算法的协同过滤;使用回归的协同过滤;使用矩阵分解/隐语义模型的协同过滤;使用神经网络的协同过滤;

    展开全文
  • 基于关联规则的推荐有三方法:Apriori关联规则算法FP Tree关联规则算法;PrefixSpan关联规则算法;关联规则挖掘推荐算法:关联规则挖掘是一在大规模交易中识别类似规则关系模式的通用技术,可以应用到推荐系统中...

    基于关联规则的推荐有三种方法:Apriori关联规则算法FP Tree关联规则算法;PrefixSpan关联规则算法;

    关联规则挖掘推荐算法:

    关联规则挖掘是一种在大规模交易中识别类似规则关系模式的通用技术,可以应用到推荐系统中。交易T是所有有效产品集合P={p 1 ,p 2 ,...,p n }的子集,表示被一起购买的产品集合,关联规则X=>Y表示只要交易T中包含了X里面的元素,那么认为Y里面的元素也有可能被T包含。常见的规则挖掘算法是Apriori算法,关联规则的衡量指标是:支持度(support)和可信度(confidence)。将关联规则应用到推荐系统的主要问题就是需要将评分转换为交易,一般情况把所有的向前(正向)的评分集合<可以是做过去均值化操作后的评分矩阵>或者用户的购买行为可以看做一次交易。

    Apriori算法概述:

    Apriori算法是常用的用于挖掘出数据关联规则的算法,它用来找出数据值中频繁出现的数据集合,这些找出的集合有助于我们的业务决策,同时我们也可以认为这些频繁出现的数据集合中的数据项存在一定的关联性,简而言之,可以认为这些数据项之间存在某种“相似性”。比如在电商的网购数据中,如果发现某一些商品经常一起被购买,那么我们可以认为这些商品之间存在某种“相似性”,从而我们可以优化网站中这些商品的排列位置、优化商品的仓库位置或者将这些“相似”的物品推荐给正在浏览对应物品的客户,从而可以达到增加经济效益、节约成本的目的。

    交易集:包含所有数据的一个数据集合,数据集合中的每条数据都是一笔交易;项:交易集中的每个商品被成为一个项;模式/项集(ItemSet):项组合被成为模式/项集;支持度(Support):一个项集在在整个交易集中出现的次数/出现的频度,比如:Support({A,C})=2表示A和C同时出现的次数是2次;最小支持度:交易次数达到最小支持度的情况下,该项集才会被计算;频繁项集:如果项集的支持度大于等于最小支持度,那么该项集被成为频繁项集;置信度(Confidence):关联规则左件和右件同时出现的频繁程度,该值越大,表示同时出现的几率越大;关联规则:LHS  RHS(confidence) -----> 如果客户购买了左件(LHS),也可能购买右件(RHS),购买的置信度为confidence

    e7b4e55df4102158bdfa682c3db478fa.png

    Apriori算法原理:

    Apriori算法本质的作用是找出购物数据集中的最频繁的K项集;Apriori算法采用了迭代的方法,先搜索出候选1项集及对应的支持度,剪枝去掉低于最小支持度的1项集,得到频繁1项集。然后对剩下的频繁1项集进行连接,得到候选的频繁2项集,筛选去掉低于最小支持度的候选频繁2项集,得到频繁2项集,以此类推,迭代下去,直到无法找到频繁k+1项集为止,对应的频繁k项集的集合即为算法的输出结果。

    c1427021b285a73aaf0b7ac33a8c270f.png

    输入:数据集合D,支持度阈值α;输出:最大的频繁K项集

    1. 扫描整个数据集,得到所有出现过的1项集,得到候选频繁1项集。2. 令k = 1;3. 挖掘频繁k项集;扫描数据计算候选频繁k项集的支持度去除候选频繁k项集中支持度低于阈值的数据集,得到频繁k项集。如果得到的频繁k项集为空,则直接返回频繁k-1项集的集合作为算法结果,算法结束。如果得到的频繁k项集只有一项,则直接返回频繁k项集的集合作为算法结果,算法结束。基于频繁k项集和频繁1项集,连接生成候选频繁k+1项集。4. k=k+1,转入步骤3。

    Apriori算法总结:

    priori算法是一种非常经典的频繁项集的挖掘算法,很多算法都是基于Apriori算法的一种扩展,比如:FP-Tree、GSP、CBA等等。理解掌握Apriori算法原理,对于对数据挖掘相关算法的学习具有非常好的作用。不过,现在一般很少直接使用Aprior算法来进行数据挖掘了,原因是:Apriori算法的数据挖掘效率比较低。

    FP Tree算法概述:

    Apriori算法作为挖掘频繁项集的算法,需要多次扫描数据,I/O瓶颈比较高,为了解决这个问题,提出了FP-Tree算法,也称为FP Growth算法;在FP Tree算法中,不管存在多少数据量,只需要扫描两次数据集,因此提高了算法的运行效率。FP Tree算法改进了Apriori算法的I/O瓶颈,类似BIRCH聚类,利用树结构来提高算法的执行效率,是一种利用空间换时间的一种算法效率提升方式。备注:FP Tree是我们在生产环境中常用的一种数据挖掘频繁项集的算法。

    FP Tree算法原理:

    为了减少I/O次数,FP Tree算法引入了一些数据结构来临时存储数据,主要包含

    三个部分:

    1. 项头表:记录所有的1项频繁集以及出现的次数,按照次数降序排列。2. FP Tree:将原始数据集映射到内存中的一棵FP树。3. 节点链表:基于项头表保存的在FP Tree中对应的项的存储位置的一个链表。FP Tree算法可以分为一下两个过程:1. 项头表和FP Tree的构建2. FP Tree的挖掘

    dd4029e9ca11d909af3a1be61879a100.png

    FP-Tree算法原理之项头表构建:

    扫描所有数据,得到所有一项集的支持度,然后删除支持度低于阈值的项,得到频繁一项集,将所有频繁一项集按照支持度降序排列,放入项头表中。

    FP-Tree算法原理之FP Tree构建:

    FP Tree树的构建是FP-Tree算法的关键点,主要分为两个过程:

    1. 扫描数据,对于每条数据删除非频繁的1项集,并按照支持度降序排列,得到排序后的数据集。

    2. 基于排序好的数据集构建FP Tree。初始状态FP树是空的,建立FP树时我们一条条的读入排序后的数据集,插入FP树,插入时按照排序后的顺序,插入FP树中,排序靠前的节点是祖先节点,而靠后的是子孙节点。如果有共用的祖先,则对应的公用祖先节点计数加1。插入后,如果有新节点出现,则项头表对应的节点会通过节点链表链接上新节点。直到所有的数据都插入到FP树后,FP树的建立完成。

    FP-Tree算法原理之FP Tree挖掘:

    当构建好FP树、项头表以及节点链表后,就可以开始进行频繁项集的挖掘了。首先从项头表的底部项依次向上挖掘,对于项头表对应于FP树的每一项,找出对应的条件模式基,所谓条件模式基是以我们要挖掘的节点作为叶子节点所对应的FP子树,得到这个FP子树,我们将子树中每个节点的的计数设置为叶子节点的计数,并删除计数低于支持度的节点。从这个条件模式基,我们就可以递归挖掘得到频繁项集了。

    寻找F节点的条件模式基;我们很容易得到F的频繁2项集为{A:2,F:2}、{C:2,F:2}、{E:2,F:2}、{B:2,F:2}。递归合并二项集,得到频繁三项集为{A:2,C:2,F:2}、{A:2,E:2,F:2},...。当然一直递归下去,最大的频繁项集为频繁5项集,为{A:2,C:2,E:2,B:2,F:2}

    df6c340ecb9a397c95e41570d85de197.png

    FP-Tree算法总结归纳:

    FP-Tree算法流程主要包括一下几步:扫描数据,得到所有的频繁1项集的计数,然后删除支持度低于阈值的项,将1项频繁集放入项头表,并按照支持度降序排列。读取数据集中的数据,将数据中的非频繁1项集删除,并按照支持度排序排列后将数据插入到FP树中,插入时按照排序后的顺序插入,并计算当前节点的后序子孙节点的数目。直到所有数据均插入到FP树后,FP树构建完成。从项头表的底部项依次向上找到项头表项对应的条件模式基。从条件模式基递归挖掘得到项头表项项的频繁项集。如果不限制频繁项集的项数,则返回上一步骤的所有的频繁项集,否则只返回满足项数要求的频繁项集。

    PrefixSpan算法概述:
    PrefixSpan全称Prefix-Projected Pattern Growth(即前缀投影的模式挖掘),是用于挖掘频繁序列的数据挖掘算法,和Apriori算法以及FP Tree算法的挖掘目标稍有不同。PrefixSpan算法是生产中常用的一种频繁序列模式挖掘算法。备注:序列中的项集是具有时间上的先后关系的。

    d369fd52874cd9a2aafcd603ee611a88.png

    子序列:如果某个序列A所有的项集在序列B中都可以找到,则A是B的子序列。

    20b9afdaa05bf506d02bdfc42c10887b.png

    频繁序列:出现频次超过支持度的子序列就叫做频繁序列。

    前缀序列:即序列前面部分的子序列。

    19b7852e1754213350c2978089ab8cba.png

    8288a38d280a7f9214b244b797dc6192.png

    后缀序列:即序列中位于前缀序列之后的子序列就叫做后缀序列。

    前缀投影:即投影数据库,即序列数据库S中所有相对于前缀的后缀序列的集合

    PrefixSpan算法原理:

    类似Apriori算法,先找出所有子序列中长度为1的前缀开始挖掘序列模型(并且删除原始序列中非频繁的长度为1的序列),搜索对应的投影数据库得到长度为1的前缀对应的频繁序列,然后递归的挖掘长度为2的前缀所对应的频繁序列,。。。以此类推,一直递归到不能挖掘到更长的前缀挖掘为止。

    5bfdbbc113a33408cb3d15c8f5af9a87.png

    PrefixSpan算法流程:

    输入:序列数据库S和支持度阈值α 输出:所有满足支持度要求的频繁序列集

    步骤:(备注:所找到的前缀即频繁序列)

    1. 找出所有子序列中长度为1的前缀以及对应的投影数据库;2. 对于长度为1的前缀进行计数,将支持度低于阈值α的前缀对应的项从序列数据库;S中删除,同时得到所有的频繁1项序列。3. 对于每个长度为i满足支持度的前缀进行递归挖掘:

    a. 找出前缀对应的投影数据库,如果投影数据库为空,则递归返回;b. 统计对应投影数据库中各项的支持度计数,如果所有项的支持度计数都低于阈值α,则递归返回。;c. 将满足支持度计数的各个单项和当前的前缀进行合并,得到若干新的前缀。;d. 令i=i+1,前缀为合并单项后的各个前缀,分别递归执行第三步。

    协同过滤各种方式总结:

    广义的协同过滤算法主要包括三种算法:基于用户(UserCF)的协同过滤算法;基于物品(ItemCF)的协同过滤算法;基于模型(ModelCF)的协同过滤算法;

    使用关联规则的协同过滤;使用聚类算法的协同过滤;使用分类算法的协同过滤;使用回归的协同过滤;使用矩阵分解/隐语义模型的协同过滤;使用神经网络的协同过滤;

    展开全文
  • 个人开发一个数据挖掘软件,集成了关联规则、k-均值聚类、模糊聚类、k-中心点聚类四种算法; 数据源存储在Microsoft Access 数据库中,将相应表中数据换成你数据,就可以直接进行挖掘。 DataMining软件...
  • 数据挖掘十大算法):Apriori(关联分析算法

    万次阅读 多人点赞 2018-08-29 21:38:50
    这里主要介绍是叫做Apriori‘一个先验’算法,通过该算法我们可以对数据集做关联分析——在大规模数据中寻找有趣关系任务,本文主要介绍使用Apriori算法发现数据(频繁项集、关联规则)。 这些关系可以有...

    终于到了机器学习实战的第十一章了,这也是继K-均值后的第二个无监督学习算法了。同样的该算法也是在一堆数据集中寻找数据之间的某种关联,这里主要介绍的是叫做Apriori‘一个先验’算法,通过该算法我们可以对数据集做关联分析——在大规模的数据中寻找有趣关系的任务,本文主要介绍使用Apriori算法发现数据的(频繁项集、关联规则)。

    这些关系可以有两种形式:频繁项集、关联规则

            频繁项集:经常出现在一块的物品的集合

            关联规则:暗示两种物品之间可能存在很强的关系

    一个具体的例子:

    频繁项集是指那些经常出现在一起的物品,例如上图的{葡萄酒、尿布、豆奶},从上面的数据集中也可以找到尿布->葡萄酒的关联规则,这意味着有人买了尿布,那很有可能他也会购买葡萄酒。那如何定义和表示频繁项集和关联规则呢?这里引入支持度和可信度(置信度)。

    支持度:一个项集的支持度被定义为数据集中包含该项集的记录所占的比例,上图中,豆奶的支持度为4/5,(豆奶、尿布)为3/5。支持度是针对项集来说的,因此可以定义一个最小支持度,只保留最小支持度的项集。

    可信度(置信度):针对如{尿布}->{葡萄酒}这样的关联规则来定义的。计算为 支持度{尿布,葡萄酒}/支持度{尿布},其中{尿布,葡萄酒}的支持度为3/5,{尿布}的支持度为4/5,所以“尿布->葡萄酒”的可行度为3/4=0.75,这意味着尿布的记录中,我们的规则有75%都适用。

    有了可以量化的计算方式,我们却还不能立刻运算,这是因为如果我们直接运算所有的数据,运算量极其的大,很难实现,这里说明一下,假设我们只有 4 种商品:商品0,商品1,商品 2,商品3. 那么如何得可能被一起购买的商品的组合?

    上图显示了物品之间所有可能的组合,从上往下一个集合是 Ø,表示不包含任何物品的空集,物品集合之间的连线表明两个或者更多集合可以组合形成一个更大的集合。我们的目标是找到经常在一起购买的物品集合。这里使用集合的支持度来度量其出现的频率。一个集合出现的支持度是指有多少比例的交易记录包含该集合。例如,对于上图,要计算 0,3 的支持度,直接的想法是遍历每条记录,统计包含有 0 和 3 的记录的数量,使用该数量除以总记录数,就可以得到支持度。而这只是针对单个集合 0,3. 要获得每种可能集合的支持度就需要多次重复上述过程。对于上图,虽然仅有4中物品,也需要遍历数据15次。随着物品数目的增加,遍历次数会急剧增加,对于包含 N 种物品的数据集共有 2^N−1 种项集组合。为了降低计算时间,研究人员发现了 Apriori 原理,可以帮我们减少感兴趣的频繁项集的数目。

    Apriori 的原理:如果某个项集是频繁项集,那么它所有的子集也是频繁的。即如果 {0,1} 是频繁的,那么 {0}, {1} 也一定是频繁的。

    这个原理直观上没有什么用,但是反过来看就有用了,也就是说如果一个项集是非频繁的,那么它的所有超集也是非频繁的。如下图所示:

    频繁项集:

    主要步骤:

        首先会生成所有单个物品的项集列表
        扫描交易记录来查看哪些项集满足最小支持度要求,那些不满足最小支持度的集合会被去掉
        对剩下的集合进行组合以生成包含两个元素的项集
        接下来重新扫描交易记录,去掉不满足最小支持度的项集,重复进行直到所有项集都被去掉

    代码(代码中有详细注释):

    from numpy import *
    
    # 构造数据
    def loadDataSet():
        return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
    
    # 将所有元素转换为frozenset型字典,存放到列表中
    def createC1(dataSet):
        C1 = []
        for transaction in dataSet:
            for item in transaction:
                if not [item] in C1:
                    C1.append([item])
        C1.sort()
        # 使用frozenset是为了后面可以将这些值作为字典的键
        return list(map(frozenset, C1))  # frozenset一种不可变的集合,set可变集合
    
    # 过滤掉不符合支持度的集合
    # 返回 频繁项集列表retList 所有元素的支持度字典
    def scanD(D, Ck, minSupport):
        ssCnt = {}
        for tid in D:
            for can in Ck:
                if can.issubset(tid):   # 判断can是否是tid的《子集》 (这里使用子集的方式来判断两者的关系)
                    if can not in ssCnt:    # 统计该值在整个记录中满足子集的次数(以字典的形式记录,frozenset为键)
                        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 # 排除不符合支持度元素后的元素 每个元素支持度
    
    # 生成所有可以组合的集合
    # 频繁项集列表Lk 项集元素个数k  [frozenset({2, 3}), frozenset({3, 5})] -> [frozenset({2, 3, 5})]
    def aprioriGen(Lk, k):
        retList = []
        lenLk = len(Lk)
        for i in range(lenLk): # 两层循环比较Lk中的每个元素与其它元素
            for j in range(i+1, lenLk):
                L1 = list(Lk[i])[:k-2]  # 将集合转为list后取值
                L2 = list(Lk[j])[:k-2]
                L1.sort(); L2.sort()        # 这里说明一下:该函数每次比较两个list的前k-2个元素,如果相同则求并集得到k个元素的集合
                if L1==L2:
                    retList.append(Lk[i] | Lk[j]) # 求并集
        return retList  # 返回频繁项集列表Ck
    
    # 封装所有步骤的函数
    # 返回 所有满足大于阈值的组合 集合支持度列表
    def apriori(dataSet, minSupport = 0.5):
        D = list(map(set, dataSet)) # 转换列表记录为字典  [{1, 3, 4}, {2, 3, 5}, {1, 2, 3, 5}, {2, 5}]
        C1 = createC1(dataSet)      # 将每个元素转会为frozenset字典    [frozenset({1}), frozenset({2}), frozenset({3}), frozenset({4}), frozenset({5})]
        L1, supportData = scanD(D, C1, minSupport)  # 过滤数据
        L = [L1]
        k = 2
        while (len(L[k-2]) > 0):    # 若仍有满足支持度的集合则继续做关联分析
            Ck = aprioriGen(L[k-2], k)  # Ck候选频繁项集
            Lk, supK = scanD(D, Ck, minSupport) # Lk频繁项集
            supportData.update(supK)    # 更新字典(把新出现的集合:支持度加入到supportData中)
            L.append(Lk)
            k += 1  # 每次新组合的元素都只增加了一个,所以k也+1(k表示元素个数)
        return L, supportData
    
    dataSet = loadDataSet()
    L,suppData = apriori(dataSet)
    print(L)
    print(suppData)

    返回频繁项集与支持度

    上面代码获取数据的频繁项集,下面通过其他函数来获得关联规则。

    关联规则:

    # 获取关联规则的封装函数
    def generateRules(L, supportData, minConf=0.7):  # supportData 是一个字典
        bigRuleList = []
        for i in range(1, len(L)):  # 从为2个元素的集合开始
            for freqSet in L[i]:
                # 只包含单个元素的集合列表
                H1 = [frozenset([item]) for item in freqSet]    # frozenset({2, 3}) 转换为 [frozenset({2}), frozenset({3})]
                # 如果集合元素大于2个,则需要处理才能获得规则
                if (i > 1):
                    rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf) # 集合元素 集合拆分后的列表 。。。
                else:
                    calcConf(freqSet, H1, supportData, bigRuleList, minConf)
        return bigRuleList
    
    # 对规则进行评估 获得满足最小可信度的关联规则
    def calcConf(freqSet, H, supportData, brl, minConf=0.7):
        prunedH = []  # 创建一个新的列表去返回
        for conseq in H:
            conf = supportData[freqSet]/supportData[freqSet-conseq]  # 计算置信度
            if conf >= minConf:
                print(freqSet-conseq,'-->',conseq,'conf:',conf)
                brl.append((freqSet-conseq, conseq, conf))
                prunedH.append(conseq)
        return prunedH
    
    # 生成候选规则集合
    def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
        m = len(H[0])
        if (len(freqSet) > (m + 1)): # 尝试进一步合并
            Hmp1 = aprioriGen(H, m+1) # 将单个集合元素两两合并
            Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
            if (len(Hmp1) > 1):    #need at least two sets to merge
                rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
    
    dataSet = loadDataSet()
    L,suppData = apriori(dataSet,minSupport=0.5)
    rules = generateRules(L,suppData,minConf=0.7)
    # rules = generateRules(L,suppData,minConf=0.5)
    print(rules)

    返回关联规则:

    上面的函数稍微有点复杂,因为使用的数据结构有点多,可能会搞混,所以下面说明一下函数意义。(由于我个人叙述可能不太清楚,所以这里引用作者的原话我觉得更好理解一点,稍微有点详细):

    以上便是引用作者对这三个函数的详细描述,在函数中的具体代码,我也有相关的注释,慢慢来应该能够理解的。

    下面对一个毒蘑菇的例子进行运算,检查一下在实际数据中的反应:

    第一个特征表示有毒或者可以使用。如果有毒则为2,可以食用为1。下一个特征蘑菇形状,有3-8六种可能,下面我们找出毒蘑菇中存在的公共特征:

    mushDatSet = [line.split() for line in open('mushroom.dat').readlines()]
    L,suppData = apriori(mushDatSet,minSupport=0.3)
    print(L)
    for item in L[1]:   # 只查看两个元素的集合
        if(item.intersection('2')): # intersection交集(选出毒蘑菇)
            print(item)

    输出了频繁项集和与毒蘑菇相关的特征:

    以上为Apriori算法构建模型的全部内容,该算法不仅适用于零售行业,同样适用于相同技术的其他行业,如网站流量分析以及医药行业等。

     

    参考书籍:《机器学习实战》

    展开全文
  • 关联规则之子图模式 文章的目的: 了解子图模式在什么...  首先我们要明白这样一个事情,在这么多关联规则的方法中,我们为什么要使用子图模式。这种子图模式在什么领域应用? 图1   由上图1我们可以...

    关联规则之子图模式

    文章目的

    1. 了解子图模式在什么情况下使用
    2. 理解子图模式的概念和原理
    3. 学习子图模式的两种算法
    4. 研究子图模式的算法应用

    基本概念

      首先我们要明白这样一个事情,在这么多关联规则的方法中,我们为什么要使用子图模式。这种子图模式在什么领域应用?
    在这里插入图片描述
    图1
      由上图1我们可以看到,有顶点有边。假设这是一个蛋白质的图,图中的顶点就代表了氨基酸,图中的边代表了氨基酸与氨基酸之间的化合作用,在这种情况下,由于常用氨基酸只有20种,所以图中的顶点必定会重复。但是,如果使用的是频繁项集的表示方法,由于项在项集中最多出现一次,且无法表示出图中顶点的关系,显然就无法完整地通过频繁项集把类似于图1表示出来。所以我们需要引入一种方法来表示这样的结构关系,那就是频繁子图。
    另外,可以看到子图模式的实际应用领域,如下表所示。
    在这里插入图片描述
      通过前面的引入,我们对子图模式有一个直观的理解。接下来就介绍一下子图模式的基本概念。
      子图:图G′=(V′,E′) 是另一个图G=(V,E) 的子图,如果它的顶点集V’是V的子集,并且它的边集E’是E的子集,子图关系记做G′⊆sG
    支持度:给定图的集族ς, 子图g的支持度定义为包含它的所有图所占的百分比。
    在这里插入图片描述

      由于支持度是我们算法输入的一个参数,我们需要对支持度进一步说明该公式是什么意思,如下图2所示,g1是G1、G3、G4和G5的子图,支持度=4/5=80%。
    在这里插入图片描述
    图2
      到此,子图模式的基本概念,我们能够理解。接下来学习子图模式的类apriori方法和gspan算法。

    类apriori方法

      首先明确我们的目标是频繁子图挖掘。那么频繁子图挖掘怎么判断是频繁呢?我们来看一下概念。频繁子图挖掘 :给定集合ς和支持度阈值minsup,频繁子图挖掘的目标是找出使得所有s(g)≥minsup的子图g。

    具体的步骤分为以下四步:

    1. 候选产生
    2. 候选剪枝
    3. 支持度计数
    4. 候选删除

      我们来看候选产生,候选产生有两种常用方法,分别为顶点增长和边增长。顶点增长:通过添加一个新的结点到已经存在的一个频繁子图上来产生候选。可以使用邻接矩阵来表示图,每一项M(i,j)为链接vi和vj的边或者0。如下图3所示,顶点增长方法可以看作合并一对(k-1)X(k-1)的邻接矩阵,产生K x K邻接矩阵的过程。
    图3在这里插入图片描述
    图3
      在上图3中,G1 和G2都含有4个顶点和4条边。合并之后,图G3有5个顶点,但G3边的数目取决于顶点d和e是否相连。如果d和e时不相连的,则G3有5条边,并且(d,e)对应的矩阵项为0;否则,G3有6条边,并且(d,e)的矩阵项对应与新创建的边的标号。由于该边的标号未知,我们需要对(d,e)考虑所有可能的边标号,从而大大增加了候选子图的个数。

      通过边增长产生候选,边增长将一个新的边插入一个已经存在的频繁子图中,与顶点增长不同,结果子图的顶点个数不一定增加,如下图4所示。
    图3
    图4
      由上图显示了通过边增长策略合并G1和G2得到的来给你个可能的候选子图。第一个候选子图G3多了一个顶点,而第二个候选子图G4的顶点个数与原来的图一样。

    候选剪枝
      产生候选k子图后,需要减去(k-1)子图非频繁的候选。候选简直可以通过如下步骤实现:相继从k子图中删除一条边,并检查对应的(k-1)子图是否连通且频繁。如果不是,则该候选k子图可以丢弃。意思是一次删除一条,总共有k个子图要检测。
      为了检查(k-1)-子图是否频繁,需要将它和其他频繁(k-1)-子图匹配,判定两个图是否拓扑等价称为图同构问题。图同构是什么意思呢?即若图的顶点可以任意移动,边是弹性的,只要在不拉断的条件下,一个图可以变形为另一个图。如下图5所示,这两个图是同构的。
    图5
    图5

      此时,我们可以知道图是同构的,又由于图的表示从不同顶点开始建立的邻接矩阵是不一样的,也就是说一个图的邻接矩阵表示有很多个。我们就需要对于每个图建立一个唯一的表示。也称为规范标号。若图是同构的,则规范标号相同,通过比较规范标号来检查图同构。那么如何构造图的规范标号呢?步骤如下:

    1. 找出图的邻接矩阵表示,利用矩阵中基本矩阵进行行列互换
    2. 确定每个矩阵的串表示,由于邻接矩阵是对称的,因此只需要根据矩阵的上三角部分构造。
    3. 比较图的所有串表示,并选出具有最小(最大)字典序值的串,确保每个图的串表达式唯一

      当我们剪枝完成之后,将剪枝后剩余的候选图进行支持度计算,将其中大于支持度阈值的候选图记为满足条件的频繁子图。下面公式为计算支持度的公式。
    在这里插入图片描述
      至此,类apriori方法介绍完毕,但是在每一层频繁子图的挖掘过程中,Apriori算法都会产生大量的非频繁的候选子图。然后对候选的频繁子图执行支持度计数。对于所有频繁的候选子图,还需要进行图的同构测试,以减除重复的频繁候选子图。因为图的同构测试是一种NP完全问题,所以对于大规模的频繁子图进行图的同构测试是一个开销很大的过程,甚至是不可能完成的任务。因此,大量生成的候选子图和图的同构测试的巨大开销是Apriori类方法的性能瓶颈。

    gSpan算法

      所以,接下来介绍另外一种算法,gspan算法。gSpan算法通过执行最右扩展的策略减少了重复的产生,同时也保证了搜索结果的完备性。gSpan算法设计出一种新式的图的规范标号,将图的同构测试与重复图的检测结合到一块,避免了在已经获得的频繁子图集合中搜索重复图。

    DFS编码

      为了遍历图,gSpan算法采用深度优先搜索。初始,随机选择一个起始顶点,并且对图中访问过的顶点做标记。被访问过的顶点集合反复扩展,直到建立一个完全的深度优先搜索 (DFS) 树。这种新式的规范标号就是dfs编码。如下图所示,对于每个加下标的图, 可以将其转换成边序列。
    在这里插入图片描述
    在这里插入图片描述

    最右扩展

      给定图G 和G 的DFS树T ,一条新边e 可以添加到最右节点和最右路径上另一个节点之间(后向扩展);或者可以引进一个新的节点并且连接到最右路径上的节点(前向扩展)。由于这两种扩展都发生在最右路径上,因此称为最右扩展。
    在这里插入图片描述
      如上图所示,图b是扩展时候第一优先级,如果第一优先级的子图是不符合规则的或者在所有子图中是不频繁的,那么进入第二优先级c。途中从b到f分别是优先级从第一到第五。
    因此,了解基本概念的dfs编码和最右扩展后,下面以一个具体例子进行说明。
    首先,当我们拿到这样的图输入。可以看到
    在这里插入图片描述
      图里共有有7个alpha(α)顶点,8个beta(β)顶点和14个lambda(λ)顶点。有15个边缘为纯蓝色,13个为双红色,8个为绿色点缀。然后将最高计数的顶点和边开始降序排列标号。
    在这里插入图片描述
      标号好后,查看各个边(例如:A,b,A),看是否满足最小支持阈值。比如,(B,a,C)可以在四个图中找到,所以支持数量为4,同理查找所有边。
    在这里插入图片描述
      查找结果如上图所示,假设最小支持度为3,最后能够得到的边为(0,1,A,b,B)、(0,1,A,c,C)、(0,1,B,a,C),这三条边为频繁子图开始,以其中一条边开始扩展,后面在频繁子图出现的边也必须是这三条边中的一条,因为这些才是频繁的。
    在这里插入图片描述
    在这里插入图片描述
    首先从(0,1,A,b,B)开始扩展,遇到(1,2B,aC)支持度为4,说明可以从这个边开始继续扩展,下面并列的(0,2A,c,C)待定。
    在这里插入图片描述
    在这里插入图片描述
    接下来又找到了(2,0,C,c,A)作为扩展边,支持度为4.然后继续按照最有扩展规则进行扩展。
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述在这里插入图片描述
    此时,找到(1,3,B,a,C)符合规则,可以得到到现在为止,我们的扩展的图是;
    在这里插入图片描述
    接下来,基于优先级规则,将顶点3链接到顶点0,如上图所示,仅存在一个,所以进入下一个优先级,但是顶点3和顶点1已经链接,因此需要添加顶点。
    在这里插入图片描述
    此时添加(C,a,B),但只存在一个。又尝试添加 (C,c,A),但在图中找不到。所以需要从根‘A’增长,可以使用(A,b,B)或(A,c,C).
    在这里插入图片描述
    从添加(A,b,B)开始,得到如右图所示子图,但在原图集中找不到。
    在这里插入图片描述
    从添加(A,c,C)开始,得到如右图所示子图,但在原图集中找不到。
    在这里插入图片描述
    此时,回到最近一个待定状态(1,3,B,b,A),其support<3,继续回到(0,3,A,c,C)support<3,继续回到上一个待定状态(0,2,A,c,C),可得图上图所示。
    在这里插入图片描述
    在这里插入图片描述
    从C节点扩展,我们的两个选项是(2,3,C,a,B)和(2,3,C,c,A)分别添加后,如上图所示。
    此时,第一条边(0,1,A,b,B)扩展结束,接下来同理扩展第二条边(0,1,A,c,C),并且在原图中删除(A,b,B)边,原图变为:

    在这里插入图片描述
    从上图中继续扩展(0,1,A,c,C),最终通过三条边的扩展可以得到频繁子图:
    在这里插入图片描述
    至此,gspan算法挖掘结束。接下来探索一下实验研究。

    实验研究

    首先我们先来看一下gspan算法的输入和输出。
    在这里插入图片描述
    当我们有上面图集,首先需要将其抽象成数字进行输入。如下所示,
    T # 0 表示这是图形的第一行,文件中第0个图
    V 0 10 表示当前图形的第0个顶点,带有标签10
    E 0 1 20 表示第0个顶点和第1个顶点,边的标签是20

    在这里插入图片描述
    然后经过算法的运算执行,可以得到输出为:
    在这里插入图片描述
    T # 0 * 3 表示文件中第0个图,支持度为3
    V 0 10 表示第0个顶点,标签为10
    x 0 1 2 表示在包含当前子图的所有图的标签。

    如上所示,不同频繁子图是不同的氨基酸结构, 氨基酸结构(T # 0 * 3)是促使长高蛋白质,氨基酸结构(T # 1 * 3)是促使长帅蛋白质。原图即不同的蛋白质,不同的氨基酸结构会影响蛋白质的功能.那么我们是否可以找到又高又帅的蛋白质呢?

    因此,我们拿到频繁子图和对应的图集,也就是拿到氨基酸结构和对应的蛋白质。我们是否可以从这些筛选出来的蛋白质中再进行挖掘,运用apriori方法,从这些蛋白质中找到又高又帅的蛋白质。
    在这里插入图片描述
    这是我们的运行结果,340个图的真实数据集,设置支持度为30%,即具有该频繁子图的蛋白质占所有蛋白质的30%,输出75个频繁子图。
    在这里插入图片描述
    然后75个频繁子图对应的原图序号,就是apriori算法的输入(这里设定阈值为90%)。最终找到某些蛋白质中包含的氨基酸结构是最多的,也就是包含频繁子图是最多的。那么这个就是我们所要研究的蛋白质。然后把这个蛋白质的所有的氨基酸结构给画出来。
    在这里插入图片描述
    最终得到的结果如上图所示,12号、23号和38号蛋白质具备的频繁子图最多,可以理解为这就是我们要找的又高又帅的蛋白质。该蛋白质如下图所示:
    在这里插入图片描述

    参考博客

    https://blog.csdn.net/weidai00/article/details/85245217
    https://www.cnblogs.com/wbwang/p/7535307.html#_Toc482375353
    http://www.philippe-fournier-viger.com/spmf/index.php?link=FAQ.php
    http://blog.sina.com.cn/s/blog_6fb7db430100ve2w.html
    https://www.cnblogs.com/zhang293/p/9427988.html

    参考文献

    [1]宋美娜,金远平.一个基于DFS编码的图形匹配算法[J].计算机与数字工程,2009,37(09):72-75.
    [2]郭玉林,刘勇.频繁子图挖掘算法gSpan的设计与实现[J].智能计算机与应用,2011,1(05):55-57.
    [3]吴卫江. Apriori算法思想在频繁子图挖掘中应用的研究[C]. 中国仪器仪表学会.第六届全国信息获取与处理学术会议论文集(2).中国仪器仪表学会:《仪器仪表学报》杂志社,2008:172-175.
    [4]王艳辉,吴斌,王柏.频繁子图挖掘算法综述[J].计算机科学,2005(10):193-196+250.
    [5]鲁慧民,冯博琴,宋擒豹.频繁子图挖掘研究综述[J].微电子学与计算机,2009,26(03):156-161.
    [6]gSpan: Graph-Based Substructure Pattern Mining(原作者文章)

    展开全文
  • 数据挖掘相对于机器学习范围更广泛 ...1、关联规则简介 数据挖掘是一项从大量记录数据中提取有价值、人们感兴趣知识,这些知识是隐含、事先未知有用信息,提取知识一般可 表示为概念(Concepts)...
  • Apriori算法是著名的关联规则挖掘算法。 假如我们在经营一家商品种类并不多杂货店,我们对哪些经常在一起被购买商品非常感兴趣。我们只有四种商品:商品0、商品1、商品2、商品3。那么所有可能被一起购买商品...
  • 频繁闭项集的挖掘是发现数据项之间关联规则的有效方式.当前以MapReduce模式为基础的云计算平台为解决海量数据中的关联规则挖掘问题提供新的解决思路.文中提出并实现一基于Hadoop云计算平台的频繁闭项集的并行...
  • Apriori算法目录一、前言二、关联分析三、Apriori原理、利用Apriori算法来发现频繁集1、Apriori算法及实例描述2、生成候选项集2、组织完整Apriori算法五、从频繁项集中挖掘关联规则六、示例1:发现国会投票中...
  • Apriori算法是一用于关联规则挖掘(Association rule mining)代表性算法关联规则挖掘是数据挖掘中一个非常重要研究方向,也是一个由来已久话题,它主要任务就是设法发现事物之间...
  • 繁闭项集的挖掘是发现数据项之间关联规则的有效方式.当前以MapReduce模式为基础的云计算 平台为解决海量数据中的关联规则挖掘问题提供新的解决思路.文中提出并实现一基于I-ladoop云计算平台的频 繁闭项集的...
  • 目录 1. FP-growth简介 ...FP-growth也是一经典的频繁项集和关联规则的挖掘算法,在较大数据集上Apriori需要花费大量的运算开销,而FP-growth却不会有这个问题。因为FP-growth只扫描整个数据库两次。由...
  • 1. FP-growth简介FP-growth也是一经典的频繁项集和关联规则的挖掘算法,在较大数据集上Apriori需要花费大量的运算开销,而FP-growth却不会有这个问题。因为FP-growth只扫描整个数据库两次。由于FP-growth算法比较...
  • 2、发现关联规则,即计算不小于人为设定最小支持度集合置信度,找到不小于认为设定最小置信度规则。 关联分析关系:简单关联关系和序列关联关系 简单关联关系: 简单关联关系可以从经典购物中...
  • java实现apriori算法

    2016-12-15 15:43:53
    实验描述: 对指定数据集进行关联规则挖掘,选择适当的挖掘算法,编写程序实现,提交程序和结果报告。 数据集: retail.txt ,根据数据集中的数据利用合适的挖掘...表示一个顾客购买了ID为38、39、47、48的四种商品。
  • Apriori算法是著名的关联规则挖掘算法。 假如我们在经营一家商品种类并不多杂货店,我们对哪些经常在一起被购买商品非常感兴趣。我们只有四种商品:商品0、商品1、商品2、商品3。那么所有可能被一起购买商品...
  • 主要内容: 一.关联分析 二.Apriori原理 三.使用Apriori算法生成频繁项集 .从频繁项集中生成关联规则 ...一....1.关联分析是一在大规模...3.关联规则暗示两个元素集合之间可能存在很强关系。形式为:A——>...
  • 引言: PrefixSpan算法的全称是Prefix-Projected Pattern Growth,即前缀投影模式挖掘,也是一种关联规则挖掘算法,就像Apriori算法,Fp-Growth算法一样,它们都是挖掘某个出现次数频繁东西。Apriori和FpGrowth...
  • 积分图像是Crow在1984年首次提出,是为了在多尺度透视投影中提高渲染速度,是一快速计算图像区域和与平方和的算法。其核心思想是对每个图像建立自己积分图查找表,在图像积分处理计算阶段根据预先建立积分图...
  • 自从毕业后,你多久没有进行过考试了?如果再给你一次重新考试机会,你会怎么考?今天分享给大家是python数据挖掘试题十道,文末有答案,但...以下两描述分别对应哪两对分类算法的评价标准?(a)警察抓小偷...
  • 1.10 书写程序时应遵循的规则 1.11 C语言字符集 1.12 C语言词汇 1.13 Turbo C 2.0 集成开发环境使用 1.13.1 Turbo C 2.0 简介和启动 1.13.2 Turbo C 2.0 集成开发环境 1.13.3 File菜单 1.13.4 Edit 菜单 ...
  • 1.10 书写程序时应遵循的规则 1.11 C语言字符集 1.12 C语言词汇 1.13 Turbo C 2.0 集成开发环境使用 1.13.1 Turbo C 2.0 简介和启动 1.13.2 Turbo C 2.0 集成开发环境 1.13.3 File菜单 1.13.4 Edit 菜单 ...
  • 在数据挖掘中,我们常用到数据模型有以下几类:分类与预测 (有监督)聚类分析 (无监督)关联规则时序模式偏差检验下面主要对前三类型中常用的算法和Python中函数实现进行总结。1分类与预测分类和预测都是...
  • 自从毕业后,你多久没有进行过考试了?如果再给你一次重新考试机会,你会怎么考?今天分享给大家是python数据挖掘试题十道,文末有答案,但希望你从接受...2.以下两描述分别对应哪两对分类算法的评价标准? ...
  • 以下两描述分别对应哪两对分类算法的评价标准?(a)警察抓小偷,描述警察抓人中有多少个是小偷标准。(b)描述有多少比例小偷给警察抓了标准。A.Precision,RecallB.Recall,PrecisionC.Prec...
  • 接下来将要面对数组和简单的算法 JAVA基本数据类型之间运算规则 自动类型提升 当容量小数据类型变量与容量大数据类型变量做运算时,结果会自动提升到容量大数据类型 特别:当byte、char、short三...
  •  C++是在C语言基础上开发集面向对象编程、通用编程和传统过程化编程于一体编程语言, 是C语言超集。本书是根据2003年ISO/ANSI C++标准编写,通过大量短小精悍程序详细而全面地阐 述了C++基本...

空空如也

空空如也

1 2 3 4 5
收藏数 99
精华内容 39
关键字:

关联规则的四种算法