精华内容
下载资源
问答
  • 数据挖掘关联规则算法改进.pdf
  • 数据挖掘关联规则算法研究.pdf
  • 数据挖掘十大算法(四):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算法构建模型的全部内容,该算法不仅适用于零售行业,同样适用于相同技术的其他行业,如网站流量分析以及医药行业等。

     

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

    展开全文
  • 基于数据挖掘关联规则Apriori算法的优化对策分析.pdf
  • 数据挖掘关联规则挖掘算法分析研究.pdf
  • 基于中智模糊关联规则生成的大数据挖掘分析算法.pdf
  • 基于关联规则算法数据挖掘技术分析与研究.pdf
  • 基于关联规则的数据挖掘算法分析.pdf
  • 数据挖掘 关联分析

    2016-08-26 12:20:24
  • 关联规则下的数据挖掘算法分析.pdf
  • 数据挖掘关联规则算法的研究.pdf
  • 基于Copula连接函数的数据挖掘关联算法的设计.pdf
  • 从大规模数据集中寻找物品间的隐含关系被称作关联分析(association analysis)或者关联规则学习(association rule learning)。 2.关联分析中的关系 频繁项集(frequent item sets)是经常出现在一块的物品的集合...

    1.什么是关联分析?

    从大规模数据集中寻找物品间的隐含关系被称作关联分析(association analysis)或者关联规则学习(association rule learning)。
    

    2.关联分析中的关系

    频繁项集(frequent item sets)是经常出现在一块的物品的集合。用{}表示
    关联规则(association rules)暗示两种物品之间可能存在很强的关系。用{x} ➞ {y}表示
    

    3.如何评判这些关系

    支持度(support):数据集中包含该项集的记录所占的比例。如:{x,y}项集p(x,y)
    可信度或置信度(confidence)是针对一条诸如{x} ➞ {y}的关联规则来定义的。p(y|x)=p(x,y)/p(x)
    提升度(Lift)提升度表示含有X的条件下,同时含有Y的概率,与Y总体发生的概率之比。Lift(X→Y) = P(y|x) / P(y)=p(x,y)/p(x)*p(y)
    

    4.如何寻找数据集(所有物品)之间的关系

     构建数据集(所有物品)的项集,求出项集中的关联关系。
     如0,1,2,,3物品 有15次组合,包含N种物品的数据集共有2的N次方-1种项集组合。这样的话计算起来用时太多。
    

    项集

    5.Apriori算法

    如果某个项集是频繁的,那么它的所有子集也是频繁的。,但是如果反过来看就有用了,也就是说如果一个项集是非频繁集,那么它的所有超集也是非频繁的。 用Apriori这种方法来减少项集的数。
    Apriori算法的一般过程
    收集数据:使用任意方法。
    准备数据:任何数据类型都可以,因为我们只保存集合。
    分析数据:使用任意方法。
    训练算法:使用Apriori算法来找到频繁项集。
    测试算法:不需要测试过程。
    使用算法:用于发现频繁项集以及物品之间的关联规则。
    

    6.FP-growth 算法

    基于数据构建FP树
    从FP树种挖掘频繁项集
    

    案例:

    import pandas as pd
    pd.options.display.max_columns = 70  # 为了查看所有的属性
    from mlxtend.frequent_patterns import apriori
    from mlxtend.frequent_patterns import association_rules
    #电影关联性分析
    movies = pd.read_csv('movies.csv')
    # print(movies.head())
    # print(movies.shape)
    movies_ohe = movies.drop('genres',axis=1).join(movies['genres'].str.get_dummies('|'))
    # print(movies_ohe.head())
    # print(movies_ohe.shape)
    #设置电影的索引
    # print(movies_ohe.set_index(['movieId','title'],inplace=True))
    # print(movies_ohe.head())
    movies_ohe=movies_ohe.drop(['movieId','title'],axis=1)
    #进行关联分析
    frequent_itemsets_movies = apriori(movies_ohe,use_colnames=True, min_support=0.025)
    print(frequent_itemsets_movies)
    rules_movies =association_rules(frequent_itemsets_movies, metric='lift', min_threshold=1.25)
    print(rules_movies)
    print(rules_movies[(rules_movies.lift>4)].sort_values(by=['lift'], ascending=False))
    
    展开全文
  • 火电厂数据挖掘关联规则算法的应用.pdf
  • 数据挖掘中改进的Apriori关联规则算法分析.pdf
  • 数据挖掘关联规则算法浅析——以Apriori算法为例.pdf
  • 基于关联算法的水泥熟料生产数据挖掘分析.pdf
  • 关联分析是从大量数据中发现项集之间有趣的关联和相关联系。 •定义: 1、事务:每一条交易称为一个事务,如上图包含5个事务。 2、项:交易的每一个物品称为一个项,例如豆奶,啤酒等。  3、项集:包含零个或...

    •1.关联分析概念

    关联分析是从大量数据中发现项集之间有趣的关联和相关联系。

     

    •定义:
    1、事务:每一条交易称为一个事务,如上图包含5个事务。
    2、项:交易的每一个物品称为一个项,例如豆奶,啤酒等。 
    3、项集:包含零个或多个项的集合叫做项集,例如{尿布,啤酒}。
    4、k−项集:包含k个项的项集叫做k-项集,例如 {豆奶,橙汁}叫做2-项集。
    5、支持度计数:一个项集出现在几个事务当中,它的支持度计数就是几。例如{尿布, 啤酒}出现在事务002、003和005中,所以           它的支持度计数是3。
    6、支持度:支持度计数除于总的事务数。例如上例中总的事务数为5,{尿布, 啤酒}的支持度计数为3,所以它的支持度是                       3÷5=60%,说明有60%的人同时买了尿布, 啤酒。

    7、频繁项集:支持度大于或等于某个阈值的项集就叫做频繁项集。例如阈值设为50%时,因为{尿布,啤酒}的支持度是60%,所以        它是频繁项集。
    8、前件和后件:对于规则{尿布}→{啤酒},{Diaper}叫做前件,{啤酒}叫做后件。
    9、置信度:对于规则{尿布}→{啤酒},{尿布,啤酒}的支持度计数除于{尿布}的支持度计数,为这个规则的置信度。

           例如规则{尿布}→{啤酒}的置信度为3÷3=100%。说明买了尿布的人100%也买了 啤酒。

    10、强关联规则:大于或等于最小支持度阈值和最小置信度阈值的规则叫做强关联规则。

    •频繁项集(frequent item sets)是经常出现在一块儿的物品的集合.

    •关联规则(association rules)暗示两种物品之间可能存在很强的关系。

    •1)支持度

    •Surpport(A->B)= P(AB)  ,支持度表示事件A 和事件B 同时出现的概率。

    •2)置信度

    •Confidence(A->B) = P(B/A) = P(AB)/ P(A) ,置信度表示 A 事件出现时,B 事件出现的概率。

    •关联分析的最终目标就是要找出强关联规则。

     

    •2.Apriori算法原理

    •Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。算法的名字基于这样的事实:算法使用频繁项集性质的先验知识,正如我们将看到的。Apriori使用一种称作逐层搜索的迭代方法,k-项集用于探索(k+1)-项集。首先,找出频繁1-项集的集合。该集合记作L1。L1 用于找频繁2-项集的集合L2,而L2 用于找L3,如此下去,直到不能找到频繁k-项集。找每个Lk需要一次数据库扫描。

     

    先验定理:如果一个项集是频繁的,则它的所有子集一定也是频繁的。

    如图所示,假定{c,d,e}是频繁项集。显而易见,任何包含项集{c,d,e}的事务一定包含它的子集{c,d},{c,e},{d,e},{c},{d}和{e}。这样,如果{c,d,e}是频繁的,则它的所有子集一定也是频繁的。

    如果项集{a,b}是非频繁的,则它的所有超集也一定是非频繁的。即一旦发现{a,b}是非频繁的,则整个包含{a,b}超集的子图可以被立即剪枝。这种基于支持度度量修剪指数搜索空间的策略称为基于支持度的剪枝。 


    这种剪枝策略依赖于支持度度量的一个关键性质,即一个项集的支持度绝不会超过它的子集的支持度。这个性质也称支持度度量的反单调性

    参考博客有很详细的例子。

    Apriori算法 
    优点:易编码实现。’ 
    缺点:在大数据集上可能较慢。 
    适用数据类型:数值型或者标称型数据。

    3.算法实现:

    #coding=gbk
    # apriori算法的实现
    def load_dataset(): #定义数据集
        return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
    
    def create_C1(dataSet): #得到数据集中的每个数据,且进行排序
        C1 =[]
        for transantion in dataSet:
            for item in transantion:
                if not [item] in C1:
                    C1.append([item])   #储存 I1, I2,。。需要使其不重复
        C1.sort()
        #use frozen set so we can use it as a key in a dict
        #应该输出 1,2,3,4,5
        return list(map(frozenset, C1))  #  将C1中的每个集合映射为frozenset,之后可以作为字典的键,
    
    dataSet = load_dataset()
    ck = create_C1(dataSet)
    print(ck)        # 输出:[frozenset({1}), frozenset({2}), frozenset({3}), frozenset({4}), frozenset({5})]
    
    #测试代码
    # # map(function, sequence)
    # c2 = [[2,4],[5,8],[3]]
    # c2.sort()
    # a = list(map(frozenset, c2))
    # print(a)    #[frozenset({2, 4}), frozenset({3}), frozenset({8, 5})]
    # print(a[0]) # frozenset({2, 4})
    
    # Apriori算法首先构建集合 C1 ,然后扫描数据集判断这些只有一个元素的项集是否满足最小支持度的要求。那些满足最低要求的项集构成集合 L1 。
    # 而 L1 中的元素相互组合构成 C2 , C2 再进一步过滤变为 L2 。
    
    #该函数使 C1 生成L1,ck为全部的数据项
    def scanD(D, Ck, minSupport):   #参数D 为数据集, Ck为候选项列表, 最小支持度
        ssCnt= {}       #存储数据项1,2,。。及其出现的次数
        
        for tid in D:       #遍历数据集
            for can in Ck:  #遍历候选项 1,2,3,4,5,
                if can.issubset(tid):   #判断候选项是否含数据集中的各项
                    if not can in ssCnt:
                        ssCnt[can] =1
                    else:
                        ssCnt[can]+=1   #有则进行加一操作,   1,2,3,4,5 的数据项的个数, 为了计算支持度
        numItems = float(len(D))    #计算数据集大小
        retList = []        #使L1 初始化, 保存大于最小支持度的数据项
        supportData = {}    #使用字典记录支持度
        for key in ssCnt:
            support = ssCnt[key]/ numItems  #求得支持度
            if support >= minSupport:       #如果支持度大于用户给的最小支持度, 对小于的数据项进行去除。
                retList.insert(0,  key) #保存到列表中
            else:
                supportData[key]= support   #输出去除项的支持度
        return retList, supportData
    
    #测试:
    r, s = scanD(dataSet, ck, 0.5)
    print(r)    #[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]
    print(s)    #{frozenset({4}): 0.25}

    数据集为:总共有4 分

    1, 3, 4
    2, 3, 5
    1, 2, 3, 5
    2, 5
    C1出现次数
    1)2
    2)3
    3)3
    4)1
    5)3

    4)的支持度为 1/4 为 0.25  < 0.5  = minSupport  ,所以将其舍去

    整个Apriori算法的伪代码如下:

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

    #Apriori 算法实现
    # 输入参数为 频繁项集列表 Lk 与  项集元素个数 k , 输出为 Ck 
    def aprioriGen(Lk, k):  
        retList = []
        lenLk = len(Lk) 
        for i in range(lenLk):
            for j in range(i+1, lenLk): #两两组合遍历 (1,2,3,5)
                L1 = list(Lk[i])[:k-2]  
                L2 = list(Lk[j])[:k-2]  #用列表储存 k-2 项的项集
                L1.sort(); L2.sort()
                if L1 == L2:
                    retList.append(Lk[i] | Lk[j])   #若2个集合的前 k-2 个项相同时, 则将两个集合合并
        return retList
    
    def apriori(dataSet, minSupport =0.5):
        C1 = create_C1(dataSet)
        D = list(map(set, dataSet))
        L1, supportData = scanD(D, C1, minSupport)  #生成L1
        L =[L1]
        k =2 
        while (len(L[k-2]) > 0):        #创建 包含更多的项集的列表, 直到下一个项集为空 ,终止循环。 
            Ck = aprioriGen(L[k-2], k)
            Lk, supk = scanD(D, Ck, minSupport) #再次在数据库上扫描一遍
            supportData.update(supk)
            L.append(Lk)        #在1 -项集上增加 2-项集 
            k +=1
        return L, supportData 
    
    a= [1,2,3]
    a.append([[12],[13],[16]])
    print(a)    #[1, 2, 3, [[12], [13], [16]]]
    
    #apriori 测试
    print('------apriori test -------')
    dataSet = load_dataset()
    L, supportData = apriori(dataSet)
    
    print(L)#[[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})], [frozenset({3, 5}), frozenset({1, 3}), 
    # frozenset({2, 5}), frozenset({2, 3})], [frozenset({2, 3, 5})], []]
    
    print(L[0]) #  [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]
    print(L[1]) #  [frozenset({3, 5}), frozenset({1, 3}), frozenset({2, 5}), frozenset({2, 3})]
    print(L[2]) #[frozenset({2, 3, 5})]
    print(L[3]) # [] 频繁项集为空, 所以的出频繁项集 为{2,3,5} 
    
    #查看全部项集的支持度
    print(supportData)  # 部分输出:{frozenset({5}): 0.75, frozenset({3}): 0.75, frozenset({2, 3, 5}): 0.5,

    函数 aprioriGen() 的输入参数为频繁项集列表 Lk 与项集元素个数 k ,输出为 Ck 。举例来说,该函数以{0}、{1}、{2}作为输入,会生成{0,1}、{0,2}以及{1,2}。要完成这一点,首先创建一个空列表,然后计算 Lk 中的元素数目。通过循环来比较 Lk 中的每一个元素与其他元素,紧接着,取列表中的两个集合进行比较。如果这两个集合的前面 k-2 个元素都相等,那么就将这两个集合合成一个大小为 k 的集合 。这里使用集合的并操作来完成。

    apriori函数首先创建 C1 然后读入数据集将其转化为 D (集合列表)来完 
    成。程序中使用 map 函数将 set() 映射到 dataSet 列表中的每一项。scanD() 函数来创建 L1 ,并将 L1 放入列表 L 中。 L 会包含 L1 、 L2 、 L3 …。现在有了 L1 ,后面会继续找 L2 , L3 …,这可以通过 while 循环来完成,它创建包含更大项集的更大列表,直到下一个大的项集为空。Lk 列表被添加到 L ,同时增加 k 的值,增大项集个数,重复上述过程。最后,当 Lk 为空时,程序返回 L 并退出。

    参考blog

    从频繁项中挖掘关联规则

    #从频繁项集中挖掘关联规则
    
    #产生关联规则
    #参数为 L 为频繁项集, supportData 为全部项集的支持度, mincof 设置最小的置信度为 0.7
    def generateRules(L, supportData, minconf = 0.7):
        bigRuleList = []    #存储所有的关联规则
        for i in range(1,len(L)):   #只获取2 个或更多项集
            for freqSet in L[i]:
                #遍历L 中每一个频繁项集,对每个项集创建值包含单个元素的 列表 
                H1 = [frozenset([item]) for item in freqSet]
                #如果频繁项集数目超过2 个, 就对其进行进一步的合并
                if (i>1 ):
                    rulesFromConseq(freqSet, H1, supportData, bigRuleList, minconf)
                else:
                    #第一层时, 后件数为1
                    calcConf(freqSet, H1, supportData, bigRuleList, minconf)
        return bigRuleList
        
    #生成候选规则集合: 计算规则的置信度,以及找到满足最小置信度的规则
    def calcConf(freqSet, H1, supportData, brl, minconf=0.7):
        #针对项集只有2 个元素时, 计算置信度
        prunedH = []    #返回一个满足最小置信度的规则列表
        for conseq in H1:       #遍历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, H1, supportData, brl, minconf = 0.7):
        #参数:freqSet是频繁项, H 是可以出现在规则右边的列表  
        m = len(H1[0])
        if (len(freqSet) > (m+1)):  #如果 频繁项集元素数目大于单个集合的元素数      
            Hmp1 = aprioriGen(H1, m+1)  #  合并具有相同部分的集合
            Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minconf)   #计算置信度
            if (len(Hmp1) > 1):
                #使用递归进一步组合
                rulesFromConseq(freqSet, Hmp1, supportData, brl, minconf)
    
    #测试关联规则输出  
    print()
    print('-------generateRules test-------')      
    rules = generateRules(L, supportData, minconf=0.5)    
    print(rules)
    # -------generateRules test-------
    # frozenset({5}) --> frozenset({3}) conf: 0.6666666666666666
    # frozenset({3}) --> frozenset({5}) conf: 0.6666666666666666
    # frozenset({3}) --> frozenset({1}) conf: 0.6666666666666666
    # frozenset({1}) --> frozenset({3}) conf: 1.0
    # frozenset({5}) --> frozenset({2}) conf: 1.0
    # frozenset({2}) --> frozenset({5}) conf: 1.0
    # frozenset({3}) --> frozenset({2}) conf: 0.6666666666666666
    # frozenset({2}) --> frozenset({3}) conf: 0.6666666666666666
    # frozenset({5}) --> frozenset({2, 3}) conf: 0.6666666666666666
    # frozenset({3}) --> frozenset({2, 5}) conf: 0.6666666666666666
    # frozenset({2}) --> frozenset({3, 5}) conf: 0.6666666666666666
    # [(frozenset({5}), frozenset({3}), 0.6666666666666666),。。。。。。。

     

    4.FP-growth 算法原理:

    相比于apriori 算法, FP-growth 算法可高效发现 频繁项集 。

    FP-growth 算法例子可查看。

    python代码参考

     

    参考:https://blog.csdn.net/zhazhayaonuli/article/details/53322541

              https://www.cnblogs.com/qwertWZ/p/4510857.html

     

    项目推荐:

    2000多G的计算机各行业电子资源分享(持续更新)

    2020年微信小程序全栈项目之喵喵交友【附课件和源码】

    Spring Boot开发小而美的个人博客【附课件和源码】

    Java微服务实战296集大型视频-谷粒商城【附代码和课件】

    Java开发微服务畅购商城实战【全357集大项目】-附代码和课件

    最全最详细数据结构与算法视频-【附课件和源码】

    在这里插入图片描述

     

    展开全文
  • 数据挖掘关联规则算法的研究 (1).pdf
  • 关于数据挖掘关联规则算法的相关问题研究.pdf
  • 关联算法介绍; 利用关联模型可以对会员进行商品推荐在计算出关联模型后得到如下图所示结果如对会员ID为24864的顾客可以推荐啤酒推荐的把握程度是0.844 ;调整参数后关联规则结果图;结果应用;谢谢
  • 数据挖掘中的关联规则算法研究.pdf
  • 此篇的Microsoft关联规则算法就是用来挖掘关联关系的典型算法,闲言少叙,我们直接进入正题。 应用场景介绍 关联规则算法是在大量数据事例中挖掘项集之间的关联或相关联系,它典型的应用就是购物篮分析,通过关联...
    此篇的Microsoft关联规则算法就是用来挖掘关联关系的典型算法,闲言少叙,我们直接进入正题。 
    

    应用场景介绍

    关联规则算法是在大量数据事例中挖掘项集之间的关联或相关联系,它典型的应用就是购物篮分析,通过关联规则分析帮助我们发现交易数据库中不同的商品(项)之间的联系,找到顾客购买行为模式,如购买某一个商品对其它商品的影响。进而通过挖掘结果应用于我们的超市货品摆放、库存安排、电子商务网站的导航安排、产品分类、根据购买模式对用户进行分类,相关产品推荐等等。

    比较典型的为大家所熟知的就是:啤酒和尿布的故事

    其实很多电子商务网站中在我们浏览相关产品的时候,它的旁边都会有相关产品推荐,当然这些它们可能仅仅是利用了分类的原理,将相同类型的的产品根据浏览量进而推荐给你,这也是关联规则应用的一种较简单的方式,而关联规则算法是基于大量的数据事实,通过数据层面的挖掘来告诉你某些产品项存在关联,有可能这种关联关系有可能是自身的,比如:牙刷和牙膏、筷子和碗...有些本身就没有关联是通过外界因素所形成的关系,经典的就是:啤酒和尿布,前一种关系通过常识我们有时候可以获取,但后一种关系通过经验就不易获得,而我们的关联规则算法解决的就是这部分问题。

    技术准备

     (1)微软案例数据仓库(AdventureWorksDW208R2),这里我们应用到两张表:vAssocSeqLineItems 表和 vAssocSeqOrders 表,这两张表典型的“一对多”的关联关系,vAssocSeqOrders为订单表,vAssocSeqLineItems 表为订单明细表,两者通过OrderNumber关联,稍后的步骤我们会详细的分析这两张表内容

    (2)VS2008、SQL Server、 Analysis Services

    操作步骤

    (1)我们这里还是利用上一期的解决方案,然后数据源,然后数据源视图,很简单的步骤,不明白的可以看我们前面几篇文章,然后将这两张表的主外键关联上,我们来看图:

    很基础的东西,这里不做过多的解释,Orders为主表,Items为明细表,通过CustomerKey主键进行关联,下面我们浏览下这两张表里面的数据:

    vAssocSeqOrders表内容很简单:订单号(逻辑主键)、客户号(客户表的外键)、地区、收入类型,别的没啥可预览的,这种表是太基础的内容,来看另外一张表:

    vAssocSeqLineItems表,订单号(外键)、购买数量、购买产品,很简单的一张表

    (2)新建挖掘结构

     这里我们新建这个数据的挖掘模型,很简单的下一步、下一步就行,有不明白的可以参照我以前的内容或者私信我,我们来看几个关键的步骤:

    这里我们选择Microsoft关联规则算法,然后下一步:

     

    这里我们标示好事例表和嵌套表,下一步我们指定定型数据

    这这里面我们配置好键、和输入、输出预测列,然后起个名字:relevance

     至此,我们的Microsoft关联规则分析算法已经初步建立好了,下面一步我们来配置该算法几个关键属性值。

    (3)参数配置

    此种算法有两个参数比较重要,我们来看:

    Support:定义规则被视为有效前必须存在的事例百分比。也就是说作为关联规则筛选的事例可能性,比如设置成10%,也就是说在只要在所有事例中所占比为10%的时候才能进行挖掘。

    Probability:定义关联被视为有效前必须存在的可能性。该参数是作为结果筛选的一个预定参数,比如设置成10%,也就是说在预测结果中概率产生为10%以上的结果值才被展示。

    我们将该模型的两个参数设置为:

    MINIMUM_PROBABILITY = 0.2

    MINIMUM_SUPPORT = 0.01

    我们部署该模型,然后运行,我们来查看结果。

    结果分析

    部署完程序之后,我们通过“挖掘模型查看器”进行查看分析,不废话,我们直接看图:

    从上面的截图中我们可以看到,Microsoft关联规则算法有三个面板来展示结果:规则、项集、依赖关系网络

    下面我们分别来介绍这三个面板,第一个,规则:

    上面有几个条件筛选项,第一个就是设置最小概率值,也就是上面我们新建模型设置的参数,第二个是是筛选规则,通过它我们找到相应的产品方便我们查看,还有一个重要性的参数,同样的对于下面结果中的第二列可能性列,最大行数设置显示的行数。

    下面结果的表格中,第一列概率的值就是产品之前会产生关联的概率,按照概率从大到小排序,第二列为可能性,该度量规则的有用性。该值越大则意味着规则越有用,设置该规则的目的是避免只使用概率可能发生误导,比如有时候超市里举行促销活动会每个人都免费给一间物品,如果仅仅根据概率去推测,这件物品的概率将是1,但是这个规则是不准确的,因为它没有和其它商品发生任何关联,也就是说该值是无意义的,所以才出现了“重要性”列。

    第三列即为我们的挖掘出来的结果项,前面为已有的产品项,‘—>’后面的即为推测的产品项,我们举个例子,比如:

    经过排序可以看到,上图中的该条规则项为关联规则最强的一种组合:前面的为:山地自行车(Mountain-200)、山地自行车内胎(Mountain Tire Tube)然后关联关系最强的为:自行车轮胎(HL Mountain Tire)

    嗯,有道理的很呀,有了山地自行车了,然后同样也具备山地自行车内胎,剩下的就是需要自行车轮胎了。

    其它的也是同样的分析方法,这里我们就不分析了,有兴趣的可以自己分析,嘿..我看到上面的第三条:

    自行车(Road-750)、水壶(Water Bottle)->自行车水壶框(Road Bottle Cage)

    ....自行车、水壶,肯定得买个自行车水壶框了......

    这个水壶好有个性,下面我们来具体看看跟这个利器有关的商品有哪些....嘿嘿...我们来看图:

    我那个去....瞅瞅...第一个结果:水壶框(Road Bottle Cage、Mountain Bottle Cage)...下面我目测了下...我可以明确的告诉你,丫的..这个名字叫Water Bottle(水壶...嘿嘿原谅我的E文能力)的利器最相关的就是水壶框(Bottle Cage)了...

    超市里东西怎么摆放? 网站上该产品的相关推荐该推荐神马? 有一个顾客已经买了这个东西你推荐它啥懂了吧?......

    下面我们来看第二个面板能告诉我们什么,我们打开“项集”面板:

    这个面板也简单的很,上面有几个筛选框设置我们的最低支持数,最小的项集大小,最大行数,这个没啥说的,很简单,下面的结果集显示的为我们的数据集合中“支持”的事例集合个数、然后“大小”就是该规则下里面的项集的个数,第三列就是项集的详细了。

    我去...上面我们分析的水壶(Water Bottle)竟然排在了第一行,该行中的项集明细为:山地自行车(Mountain-200)、水壶(Water Bottle)、自行车水壶框(Road Bottle Cage),第二行也有,看来这厮看来很有分析价值,我们后续接着分析,嘿嘿

    我们进入第三个面板“依赖关系网络”,我们来看:

    这幅图已经很熟悉了吧,前几篇文章中均有介绍,分析各种产品之间的关联关系的强弱,拖动右侧的滑动条然后进行分析

    嘿嘿...我小心翼翼的拖动了这个滑动条...试图找找上面我们分析的哪款利器(Water Bottle):

    嘿嘿...找到了,上图中就标示了这玩意相关的商品,我们来看Mountain Bottle Cage、Road Bottle Cage这两个都是双向关联,然后Road-750、Cycling Cap、Hydration Pack...

    其它的商品也利用这种规则进行分析,有兴趣的可以自己分析。

    推测结果导出

    我们到此步骤直接将该模型的分析结果进行预测,暂且不验证其准确性,直接将结果导出,来看看该算法的应用项,我们进入“挖掘模型预测”:

    在下面的网格中设置我们的挖掘筛选规则,点击“源”,选择“预测函数”,选择PredictAssociation,将vAssocSeqLineItems,将其拖到网格中PredictAssociation 函数的“条件/参数”框。然后设置该参数为[Association].[v Assoc Seq Line Items],3

    我们点击运行,直接来查看结果:

    看,上面的Microsoft关联规则算法给我们推荐出来关联性最强的三种产品,分别为:Sport-100、Water Bottle、Patch kit...

    当然有时候我需要只查看某一种商品,不关系其它的产品有什么关联关系,我们来做单独查询,我们在菜单中的“挖掘模型”,然后选择“单独查询”:

    点击开单独筛选的条件框:

    “嵌套表输入”对话框中,选择“键列”窗格中的Touring Tire

    我们点击运行,来查看结果:

    可以看到这里我们只是筛选出了该商品的关联关系结果集,当然这里我们可以显示出该产品之间的关联的关系值,这里我们直接写语句:

    点击运行,我们来看结果:

    这里我们能看到,商品、支持的事例数,可能行、概率等明细值。

    对于Microsoft关联规则算法还有一种更有趣的应用就是,根据现有的顾客已经买的的产品,然后利用它自己的挖掘模型进行推测,推测出这个顾客将下一个买什么产品,比如上面的例子中,如果某个顾客已经买了山地自行车、自行车内胎,那么利用该模型它会自动推测出该顾客下一步将会买自行车轮胎,这个用法其实很关键,通过该方法预测已经能推测出顾客下一步的购买意向!...

    如果将该挖掘模型利用到电子商务网站...那么他们推荐的商品将更准确,同样所得到的精准销售也更到位...结果你懂的!

    我们来看步骤:

    我们来选择应用的事例表:

    我们来选择两者的关联关系,可以右键直接编辑:

    然后编辑筛选函数,直接看图:

    点击查看结果:

    可以看到,这个顾客编号为:18239的他将买优先买三个产品:Water Bottle、Road-750、Touring-1000,后面还列出他的概率和可能性...

    嘿嘿..我们打开数据库来看看这个顾客的情况:

    .....嘿嘿...这个顾客已经买了两个商品了,Road-250、Road Bottle Cage,根据上面的推算法则...这个顾客应该马上急需要买一个叫做Water Bottle的神器...用来喝水

    然后,我们将这个结果保存到数据库..一段简单的代码就能搞出那些顾客急需要什么商品...

    他们最可能买的商品有哪些....,剩下的工作你懂得!

    结语

    本篇文章到此结束了...结语就是我们后面还会继续分析其它的算法,有兴趣的童鞋可以提前关注。上面其实还有几部分需要补充,就是准确性验证和筛选条件挖掘,比如我想知道某些特定客户群体他们的购买的产品关联规则等等吧,后续文章继续分析这些问题。

    展开全文
  • 基于数据挖掘关联规则的微粒群算法.pdf
  • 全面解析电商数据挖掘关联算法

    千次阅读 2019-04-08 16:46:59
    所谓关联,反映的是一个事件和其他事件之间...其中前者主要用在互联网的内容和文档上,比如搜索引擎算法中文档之间的关联性,我们采用的词是relevance;而后者往往用在实际的事物之上,比如电子商务网站上的商品之间...
  • 数据挖掘关联规则算法的应用研究 摘要 随着计算机网络通讯等信息技术的高速发展产生了海量数据传统的数据分 析手段已无法有效地使用这些数据数据挖掘技术就是从大量的数据中提取隐含的有 用信息并找到尚未发现的...
  • 数据挖掘关联规则算法在教学评价系统中的研究.pdf
  • 数据挖掘关联规则算法在教学评价系统中的应用.pdf
  • 所谓关联,反映的是一个事件和其他事件之间...其中前者主要用在互联网的内容和文档上,比如搜索引擎算法中文档之间的关联性,我们采用的词是relevance;而后者往往用在实际的事物之上,比如电子商务网站上的商品之间

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,707
精华内容 15,482
关键字:

数据挖掘关联分析算法