精华内容
下载资源
问答
  • python实现关联规则分析Apriori算法

    千次阅读 2017-09-16 00:27:19
    Apriori其实是为了降低搜索空间以及提高搜索速度而设计的一种算法,本文采用python实现,彻底理解“频繁项集的所有非空子集一定是频繁的”这句话,并实现连接步、剪枝步、规则生成、提升度计算等。 本节代码参考...

    代码写了好久了,今天搬上来。
    Apriori算法介绍:
    这里写图片描述
    这里写图片描述
    Apriori其实是为了降低搜索空间以及提高搜索速度而设计的一种算法,本文采用python实现,彻底理解“频繁项集的所有非空子集一定是频繁的”这句话,并实现连接步、剪枝步、规则生成、提升度计算等。
    本节代码参考了《机器学习实战》第十一章中的代码,也参考了R语言的arules包,该包没有实现一对多的规则,因此,在以上基础上进行了改进,包括实现剪枝步,规则生成(一对一,一对多,多对一,多对多),增加提升度Lift评估。

    整体代码实现过程如下:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    from numpy import *
    
    def loadDataSet():
        return [['a', 'c', 'e'], ['b', 'd'], ['b', 'c'], ['a', 'b', 'c', 'd'], ['a', 'b'], ['b', 'c'], ['a', 'b'],
                ['a', 'b', 'c', 'e'], ['a', 'b', 'c'], ['a', 'c', 'e']]
    
    
    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))      
    
    
    # 从候选K项集到频繁K项集(支持度计算)
    def scanD(D, Ck, minSupport):
        ssCnt = {}
        for tid in D:
            for can in Ck:
                if can.issubset(tid):
                    if not can in ssCnt:
                        ssCnt[can] = 1
                    else:
                        ssCnt[can] += 1
        numItems = float(len(D))
        retList = []
        supportData = {}
        for key in ssCnt:
            support = ssCnt[key] / numItems
            if support >= minSupport:
                retList.insert(0, key)
                supportData[key] = support  
        return retList, supportData
    
    
    def calSupport(D, Ck, min_support):
        dict_sup = {}
        for i in D:
            for j in Ck:
                if j.issubset(i):
                    if not j in dict_sup:
                        dict_sup[j] = 1
                    else:
                        dict_sup[j] += 1
        sumCount = float(len(D))
        supportData = {}
        relist = []
        for i in dict_sup:
            temp_sup = dict_sup[i] / sumCount
            if temp_sup >= min_support:
                relist.append(i)
                supportData[i] = temp_sup  # 此处可设置返回全部的支持度数据(或者频繁项集的支持度数据)
        return relist, supportData
    
    
    # 改进剪枝算法
    def aprioriGen(Lk, k):  # 创建候选K项集 ##LK为频繁K项集
        retList = []
        lenLk = len(Lk)
        for i in range(lenLk):
            for j in range(i + 1, lenLk):
                L1 = list(Lk[i])[:k - 2]
                L2 = list(Lk[j])[:k - 2]
                L1.sort()
                L2.sort()
                if L1 == L2:  # 前k-1项相等,则可相乘,这样可防止重复项出现
                    #  进行剪枝(a1为k项集中的一个元素,b为它的所有k-1项子集)
                    a = Lk[i] | Lk[j]  # a为frozenset()集合
                    a1 = list(a)
                    b = []
                    # 遍历取出每一个元素,转换为set,依次从a1中剔除该元素,并加入到b中
                    for q in range(len(a1)):
                        t = [a1[q]]
                        tt = frozenset(set(a1) - set(t))
                        b.append(tt)
                    t = 0
                    for w in b:
                        # 当b(即所有k-1项子集)都是Lk(频繁的)的子集,则保留,否则删除。
                        if w in Lk:
                            t += 1
                    if t == len(b):
                        retList.append(b[0] | b[1])
        return retList
    
    
    def apriori(dataSet, minSupport=0.2):
        C1 = createC1(dataSet)
        D = list(map(set, dataSet))  # 使用list()转换为列表
        L1, supportData = calSupport(D, C1, minSupport)
        L = [L1]  # 加列表框,使得1项集为一个单独元素
        k = 2
        while (len(L[k - 2]) > 0):
            Ck = aprioriGen(L[k - 2], k)
            Lk, supK = scanD(D, Ck, minSupport)  # scan DB to get Lk
            supportData.update(supK)
            L.append(Lk)  # L最后一个值为空集
            k += 1
        del L[-1]  # 删除最后一个空集
        return L, supportData  # L为频繁项集,为一个列表,1,2,3项集分别为一个元素。
    
    
    # 生成集合的所有子集
    def getSubset(fromList, toList):
        for i in range(len(fromList)):
            t = [fromList[i]]
            tt = frozenset(set(fromList) - set(t))
            if not tt in toList:
                toList.append(tt)
                tt = list(tt)
                if len(tt) > 1:
                    getSubset(tt, toList)
    
    
    def calcConf(freqSet, H, supportData, ruleList, minConf=0.7):
        for conseq in H:
            conf = supportData[freqSet] / supportData[freqSet - conseq]  # 计算置信度
            # 提升度lift计算lift = p(a & b) / p(a)*p(b)
            lift = supportData[freqSet] / (supportData[conseq] * supportData[freqSet - conseq])
    
            if conf >= minConf and lift > 1:
                print(freqSet - conseq, '-->', conseq, '支持度', round(supportData[freqSet - conseq], 2), '置信度:', conf,
                      'lift值为:', round(lift, 2))
                ruleList.append((freqSet - conseq, conseq, conf))
    
    # 生成规则
    def gen_rule(L, supportData, minConf=0.7):
        bigRuleList = []
        for i in range(1, len(L)):  # 从二项集开始计算
            for freqSet in L[i]:  # freqSet为所有的k项集
                # 求该三项集的所有非空子集,1项集,2项集,直到k-1项集,用H1表示,为list类型,里面为frozenset类型,
                H1 = list(freqSet)
                all_subset = []
                getSubset(H1, all_subset)  # 生成所有的子集
                calcConf(freqSet, all_subset, supportData, bigRuleList, minConf)
        return bigRuleList
    
    
    if __name__ == '__main__':
        dataSet = loadDataSet()
        L, supportData = apriori(dataSet, minSupport=0.2)
        rule = gen_rule(L, supportData, minConf=0.7)

    结果如下所示(更完善):
    这里写图片描述
    R语言运行结果(存在不足):
    这里写图片描述
    R语言实现中,去掉第1-3条涉及空集的规则,删除Lift小于1的情况(第7条和第10条),剩余7条规则。与上图本文实现相比较,少了“一对多”的情况,也就是少了“e—–a,c”这条规则。

    大功告成,代码实现比较好懂,功能都实现了,较R语言结果展现有了明显的改进(自动删除涉及空集的规则,自定义筛选Lift>1),但是看起来比较乱,有时间重新封装下,先写到这里,睡觉。

    展开全文
  •   关联规则分析是数据挖掘中最活跃的研究方法之一,目的是在一个数据集中找到各项之间的关联关系,而这种关系并没有在数据中直接体现出来。以超市的销售数据为例,当存在很多商品时,可能的商品组合数量达到了令人...



    引言

      关联规则分析是数据挖掘中最活跃的研究方法之一,目的是在一个数据集中找到各项之间的关联关系,而这种关系并没有在数据中直接体现出来。以超市的销售数据为例,当存在很多商品时,可能的商品组合数量达到了令人望而却步的程度,这是提取关联规则的最大困难。因此各种关联规则分析算法从不同方面入手减少可能的搜索空间大小以及减少扫描数据的次数。Apriori算法是最经典的挖掘频繁项集的算法,第一次实现在大数据集上的可行的关联规则提取,其核心思想是通过连接产生候选项及其支持度,然后通过剪枝生成频繁项集。

    一、一些概念

    1.关联规则的一般形式

    1. 关联规则的支持度(相对支持度)
      项集A、B同时发生的概率称为关联规则的支持度(相对支持度)。 S u p p o r t ( A = > B ) = P ( A ∪ B ) Support(A=>B)=P(A∪B) Support(A=>B)=P(AB)
    2. 关联规则的置信度
      项集A发生,则项集B发生的概率为关联规则的置信度。 C o n f i d e n c e ( A = > B ) = P ( B ∣ A ) Confidence(A=>B)=P(B|A) Confidence(A=>B)=P(BA)

    2.最小支持度和最小置信度

    1. 最小支持度是衡量支持度的一个阈值,表示项目集在统计意义上的最低重要性
    2. 最小置信度是衡量置信度的一个阈值,表示关联规则的最低可靠性
    3. 强规则是同时满足最小支持度阈值和最小置信度阈值的规则

    3.项集

    1. 项集是项的集合。包含 k k k个项的集合称为 k k k项集,如集合{牛奶,麦片,糖}是一个三项集
    2. 项集出现的频率是所有包含项集的事务计数,又称为绝对支持度或支持度计数
    3. 如果项集 I I I的相对支持度满足预定义的最小支持度阈值,则 I I I频繁项集。如果有 k k k项,记为 L k L_k Lk

    4.支持度计数

    • 项集A的支持度计数是事务数据集中包含项集A的事务个数,简称项集的频率或计数
    • 一旦得到项集 A 、 B 和 A ∪ B A、B和A∪B ABAB的支持度计数以及所有事务个数,就可以导出对应的关联规则 A = > B A=>B A=>B B = > A B=>A B=>A,并可以检查该规则是否为强规则。
      在这里插入图片描述
      其中 N N N表示总事务个数, σ σ σ表示计数

    二、Apriori算法:使用候选产生频繁项集

      Apriori算法的主要思想是找出存在于事务数据集中最大的频繁项集,再利用得到的最大频繁项集与预先设定的最小置信度阈值生成强关联规则。

    1.Apriori的性质

      频繁项集的所有非空子集一定是频繁项集。根据这一性质可以得出:向不是频繁项集 I I I的项集中添加事务 A A A,新的项集 I ∪ A I∪A IA一定不是频繁项集。

    2.Apriori算法实现过程

    第一步:
    找出所有频繁项集(支持度必须大于等于给定的最小支持度阈值),在这个过程中连接步与剪枝步相互融合,最终得到最大频繁项集 L k L_k Lk

    • 连接步
      连接步的目的是找到 K K K项集。对于给定的最小支持度阈值,分别对1项候选集 C 1 C_1 C1,剔除小于该阈值的项集得到1项频繁集 L 1 L_1 L1;下一步由 L 1 L_1 L1自身连接产生2项候选集 C 2 C_2 C2,剔除小于该阈值的项集得到2项频繁集 L 2 L_2 L2;再下一步由 L 2 和 L 1 L_2和L_1 L2L1连接产生3项候选集 C 3 C_3 C3,剔除小于该阈值的项集得到3项频繁集 L 3 L_3 L3,这样循环下去,直至由 L k − 1 和 L 1 L_{k-1}和L_1 Lk1L1连接产生 k k k项候选集 C k C_k Ck,剔除小于该阈值的项集得到最大频繁集 L k L_k Lk
    • 剪枝步
      剪枝步紧接着连接步,在产生候选项 C k C_k Ck的过程中起到了减小搜索空间的目的。根据Apriori的性质:频繁项集的所有非空子集也必须是频繁项集,所以不满足该性质的项集将不会存在于 C k C_k Ck中,该过程就是剪枝

    第二步:
    由频繁项集产生强关联规则。由第一步可知,未超过预定的最小支持阈值的项集已被剔除,如果剩下的这些项集又满足了预定的最小置信度阈值,那么就挖掘出了强关联规则。

    3.Apriori算法实现过程实例

      以餐饮行业点餐数据为例,首先先将事务数据整理成关联规则模型所需的数据结构。设最小支持度为0.2,将菜品id编号
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    三、Apriori算法—python实现

    数据集链接

    import numpy as np
    import pandas as pd
    
    
    def connect_string(x, ms):
        """
        与1项频繁集连接生成新的项集
        :param x: 项集
        :param ms:
        :return: 新的项集
        """
        x = list(map(lambda i: sorted(i.split(ms)), x))
        l = len(x[0])
        r = []
        for i in range(len(x)):
            for j in range(i, len(x)):
                if x[i][:l - 1] == x[j][:l - 1] and x[i][l - 1] != x[j][l - 1]:
                    r.append(x[i][:l - 1] + sorted([x[j][l - 1], x[i][l - 1]]))
        return r
    
    
    def find_rule(d, support, confidence, ms=u'-'):
        """
        寻找关联规则
        :param d: 数据集
        :param support: 最小支持度
        :param confidence: 最小置信度
        :param ms: 项集之间连接符号
        :return: 强关联规则以及其支持度与置信度
        """
        # 存储输出结果
        result = pd.DataFrame(index=['support', 'confidence'])
    
        # 1项集的支持度序列
        support_series = 1.0 * d.sum(axis=0) / d.shape[0]
        # 基于给定的最小支持度进行筛选,得到1项频繁集
        column = list(support_series[support_series > support].index)
    
        # 当1项频繁集个数大于1时
        k = 0
        while len(column) > 1:
            k = k + 1
            print(u'\n正在进行第%s次搜索...' % k)
            column = connect_string(column, ms)
            print(u'数目:%s...' % len(column))
            # 乘积为1表示两个项集同时发生,乘积为0表示不同发生
            sf = lambda i: d[i].prod(axis=1, numeric_only=True)  # 新一批支持度的计算函数
    
            # 创建连接数据,这一步耗时、耗内存最严重。当数据集较大时,可以考虑并行运算优化。
            d_2 = pd.DataFrame(list(map(sf, column)), index=[ms.join(i) for i in column]).T
    
            # 计算连接后的支持度
            support_series_2 = 1.0 * d_2[[ms.join(i) for i in column]].sum() / len(d)
            column = list(support_series_2[support_series_2 > support].index)  # 新一轮支持度筛选
            support_series = support_series.append(support_series_2)
    
            column2 = []
            # 遍历可能的推理,如{A,B,C}究竟是A+B-->C还是B+C-->A还是C+A-->B?
            for i in column:
                i = i.split(ms)
                for j in range(len(i)):
                    column2.append(i[:j] + i[j + 1:] + i[j:j + 1])
    
            # 定义置信度序列
            cofidence_series = pd.Series(index=[ms.join(i) for i in column2])
            # 计算置信度序列
            for i in column2:
                cofidence_series[ms.join(i)] = support_series[ms.join(sorted(i))] / support_series[ms.join(i[:len(i) - 1])]
    
            for i in cofidence_series[cofidence_series > confidence].index:  # 置信度筛选
                result[i] = 0.0
                result[i]['confidence'] = cofidence_series[i]
                result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))]
    
        result = result.T.sort_values(['confidence', 'support'], ascending=False)  # 结果整理,输出
        print(u'\n结果为:')
        print(result)
        return result
    
    
    if __name__ == '__main__':
        # 加载数据
        data = pd.read_excel('../data/menu_orders.xls', header=None)
        print('转换原数据到0-1矩阵')
        ct = lambda x: pd.Series(1, index=x[pd.notnull(x)])
        b = map(ct, data.values)
        data = pd.DataFrame(list(b)).fillna(0)
        # 删除中间变脸b
        del b
    
        support = 0.2  # 最小支持度
        confidence = 0.5  # 最小置信度
    
        find_rule(data, support, confidence)
    
    转换原数据到0-1矩阵
    
    正在进行第1次搜索...
    数目:6...
    
    正在进行第2次搜索...
    数目:3...
    
    正在进行第3次搜索...
    数目:0...
    
    结果为:
           support  confidence
    e-a        0.3    1.000000
    e-c        0.3    1.000000
    c-e-a      0.3    1.000000
    a-e-c      0.3    1.000000
    c-a        0.5    0.714286
    a-c        0.5    0.714286
    a-b        0.5    0.714286
    c-b        0.5    0.714286
    b-a        0.5    0.625000
    b-c        0.5    0.625000
    a-c-e      0.3    0.600000
    b-c-a      0.3    0.600000
    a-c-b      0.3    0.600000
    a-b-c      0.3    0.600000
    

    其中,'e—a’表示e发生能够推出a发生,置信度为100%,支持度30%。搜索出的关联规则并不一定有实际意义,需要根据问题背景筛选适当的有意义的规则,并赋予合理的解释。

    四、Apriori算法实现—有剪枝步

    案例数据百度网盘链接-提取码:1234

    import numpy as np
    import pandas as pd
    
    # 测试数据集,用于debug
    def loadDataSet():
        return [['a', 'c', 'e'], ['b', 'd'], ['b', 'c'], ['a', 'b', 'c', 'd'], ['a', 'b'], ['b', 'c'], ['a', 'b'],
                ['a', 'b', 'c', 'e'], ['a', 'b', 'c'], ['a', 'c', 'e']]
    
    
    def loaddata():
        order_data = pd.read_csv('data/GoodsOrder.csv', header=0, encoding='gbk')
        # 转换数据格式
        order_data['Goods'] = order_data['Goods'].apply(lambda x: "," + x)
        order_data = order_data.groupby('id').sum().reset_index()
        order_data['Goods'] = order_data['Goods'].apply(lambda x: [x[1:]])
        order_data_list = list(order_data['Goods'])
        # print(order_data_list)
        # 分割商品名为每一个元素
        data_translation = []
        for i in order_data_list:
            # 列表中元素为1个字符串,所以用0索引
            p = i[0].split(",")
            data_translation.append(p)
        return data_translation
    
    
    def creatC1(data):
        """
        找到1项候选集C1
        :param data: 数据集
        :return: 1项候选集C1
        """
        C1 = []
        for row in dataSet:
            for item in row:
                if [item] not in C1:
                    C1.append([item])
        # 中文字符串升序排序
        C1.sort()
        # frozenset()返回一个冻结的集合,冻结后集合不能再添加或删除任何元素
        return list(map(frozenset, C1))
    
    
    def calSupport(D, C, minSupport):
        """
        计算1项候选集的支持度,剔除小于最小支持度的项集,
        :param D: 数据集
        :param C1: 候选集
        :param minSupport: 最小支持度
        :return: 返回1项频繁集及其支持度
        """
        dict_sup = {}  # 中间储存变量,用于计数
        # 迭代每一条数据,对项集中的每一项进行计数
        for i in D:
            for j in C:
                # 集合j是否是集合i的子集,如果是返回True,否则返回False
                if j.issubset(i):
                    # 再判断之前有没有统计过,没有统计过的话为1
                    if j not in dict_sup:
                        dict_sup[j] = 1
                    else:
                        dict_sup[j] += 1
        # 事务总数
        sumCount = float(len(D))
        # 计算支持度,支持度 = 项集的计数/事务总数
        supportData = {}  # 用于存储频繁集的支持度
        relist = []  # 用于存储频繁集
        for i in dict_sup:
            temp_sup = dict_sup[i] / sumCount
            # 将剔除后的频繁项集及其对应支持度保存起来
            if temp_sup > minSupport:
                relist.append(i)
                supportData[i] = temp_sup
        # 返回1项频繁项集及其对应支持度
        return relist, supportData
    
    
    def aprioriGen(Lk, k):
        """
        改良了剪枝步,原来的Ck是由L1与L(k-1)来连接产生的,这里采用了新的连接方式
        使用剪枝算法,减少了候选集空间,找到k项候选集
        :param Lk: k-1项频繁集
        :param k: 第k项
        :return: 第k项候选集
        """
        reList = []  # 用来存储第k项候选集
        lenLk = len(Lk)  # 第k-1项频繁集的长度
        # 两两组合遍历
        for i in range(lenLk):
            for j in range(i + 1, lenLk):
                L1 = list(Lk[i])[:k - 2]
                L2 = list(Lk[j])[:k - 2]
                L1.sort()
                L2.sort()
                # 前k-1项相等,则可相乘,这样可以防止重复项出现
                if L1 == L2:
                    a = Lk[i] | Lk[j]  # a为frozenset集合
                    # 进行剪枝
                    a1 = list(a)  # a1为k项集中的一个元素
                    b = []  # b为它的所有k-1项子集
                    # 构造b:遍历取出每一个元素,转换为set,依次从a1中剔除该元素,并加入到b中
                    for q in range(len(a1)):
                        t = [a1[q]]
                        tt = frozenset(set(a1) - set(t))
                        b.append(tt)
    
                    # 当b都是频繁集时,则保留a1,否则,删除
                    t = 0
                    for w in b:
                        # 如果为True,说明是属于候选集,否则不属于候选集
                        if w in Lk:
                            t += 1
                    # 如果它的子集都为频繁集,则a1是候选集
                    if len(b) == t:
                        reList.append(b[0] | b[1])
    
        return reList
    
    
    def scanD(D, Ck, minSupport):
        """
        计算候选k项集的支持度,剔除小于最小支持度的候选集,得到频繁k项集及其支持度
        :param D: 数据集
        :param Ck: 候选k项集
        :param minSupport: 最小支持度
        :return: 返回频繁k项集及其支持度
        """
        sscnt = {}  # 存储支持度
        for tid in D:  # 遍历数据集
            for can in Ck:  # 遍历候选项
                if can.issubset(tid):  # 判断数据集中是否含有候选集各项
                    if can not in sscnt:
                        sscnt[can] = 1
                    else:
                        sscnt[can] += 1
    
        # 计算支持度
        numItem = len(D)  # 事务总数
        reList = []  # 存储k项频繁集
        supportData = {}  # 存储频繁集对应支持度
        for key in sscnt:
            support = sscnt[key] / numItem
            if support > minSupport:
                reList.insert(0, key)  # 满足条件的加入Lk中
                supportData[key] = support
        return reList, supportData
    
    
    def apriori(dataSet, minSupport=0.2):
        """
        apriori关联规则算法
        :param data: 数据集
        :param minSupport: 最小支持度
        :return: 返回频繁集及对应的支持度
        """
        # 首先,找到1项候选集
        C1 = creatC1(dataSet)
        # 使用list()转化为列表,用于支持度计算
        D = list(map(set, dataSet))
        # 计算1项候选集的支持度,剔除小于最小支持度的项集,返回1项频繁集及其支持度
        L1, supportData = calSupport(D, C1, minSupport)
        L = [L1]  # 加列表框,使得1项频繁集称为一个单独的元素
    
        k = 2  # k项
        # 跳出循环的条件是没有候选集
        while len(L[k - 2]) > 0:
            # 产生k项候选集Ck
            Ck = aprioriGen(L[k - 2], k)
            # 计算候选k项集的支持度,剔除小于最小支持度的候选集,得到频繁k项集及其支持度
            Lk, supK = scanD(D, Ck, minSupport)
            # 将supK中的键值对添加到supportData
            supportData.update(supK)
            # 将第k项的频繁集添加到L中
            L.append(Lk)  # L的最后一个值为空值
            k += 1
        del L[-1]
        # 返回频繁集及其对应的支持度;L为频繁项集,是一个列表,1,2,3项集分别为一个元素
        return L, supportData
    
    
    def getSubset(fromList, totalList):
        """
        生成集合的所有子集
        :param fromList:
        :param totalList:
        """
        for i in range(len(fromList)):
            t = [fromList[i]]
            tt = frozenset(set(fromList) - set(t))  # k-1项子集
    
            if tt not in totalList:
                totalList.append(tt)
                tt = list(tt)
                if len(tt) > 1:
                    getSubset(tt, totalList)  # 所有非1项子集
    
    
    def calcConf(freqSet, H, supportData, ruleList, minConf):
        """
        计算置信度,并剔除小于最小置信度的数据,这里利用了提升度概念
        :param freqSet: k项频繁集
        :param H: k项频繁集对应的所有子集
        :param supportData: 支持度
        :param RuleList: 强关联规则
        :param minConf: 最小置信度
        """
        # 遍历freqSet中的所有子集并计算置信度
        for conseq in H:
            conf = supportData[freqSet] / supportData[freqSet - conseq]  # 相当于把事务总数抵消了
    
            # 提升度lift计算lift=p(a&b)/p(a)*p(b)
            lift = supportData[freqSet] / (supportData[conseq] * supportData[freqSet - conseq])
            if conf >= minConf and lift > 1:
                print(freqSet - conseq, '-->', conseq, '支持度', round(supportData[freqSet], 6), '置信度:', round(conf, 6),
                      'lift值为:', round(lift, 6))
                ruleList.append((freqSet - conseq, conseq, conf))
    
    
    def get_rule(L, supportData, minConf=0.7):
        """
        生成强关联规则:频繁项集中满足最小置信度阈值,就会生成强关联规则
        :param L: 频繁集
        :param supportData: 支持度
        :param minConf: 最小置信度
        :return: 返回强关联规则
        """
        bigRuleList = []  # 存储强关联规则
        # 从2项频繁集开始计算置信度
        for i in range(1, len(L)):
            for freqSet in L[i]:
                H1 = list(freqSet)
                all_subset = []  # 存储H1的所有子集
                # 生成所有子集
                getSubset(H1, all_subset)
                # print(all_subset)
                # 计算置信度,并剔除小于最小置信度的数据
                calcConf(freqSet, all_subset, supportData, bigRuleList, minConf)
        return bigRuleList
    
    
    if __name__ == '__main__':
        dataSet = loaddata()
        # 返回频繁集及其对应的支持度
        L, supportData = apriori(dataSet, minSupport=0.02)
        # 生成强关联规则
        rule = get_rule(L, supportData, minConf=0.35)
    

    生成的强关联规则如下:

    frozenset({'水果/蔬菜汁'}) --> frozenset({'全脂牛奶'}) 支持度 0.02664 置信度: 0.368495 lift值为: 1.44216
    frozenset({'人造黄油'}) --> frozenset({'全脂牛奶'}) 支持度 0.024199 置信度: 0.413194 lift值为: 1.617098
    frozenset({'仁果类水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.030097 置信度: 0.397849 lift值为: 1.557043
    frozenset({'牛肉'}) --> frozenset({'全脂牛奶'}) 支持度 0.021251 置信度: 0.405039 lift值为: 1.58518
    frozenset({'冷冻蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.020437 置信度: 0.424947 lift值为: 1.663094
    frozenset({'本地蛋类'}) --> frozenset({'其他蔬菜'}) 支持度 0.022267 置信度: 0.350962 lift值为: 1.813824
    frozenset({'黄油'}) --> frozenset({'其他蔬菜'}) 支持度 0.020031 置信度: 0.361468 lift值为: 1.868122
    frozenset({'本地蛋类'}) --> frozenset({'全脂牛奶'}) 支持度 0.029995 置信度: 0.472756 lift值为: 1.850203
    frozenset({'黑面包'}) --> frozenset({'全脂牛奶'}) 支持度 0.025216 置信度: 0.388715 lift值为: 1.521293
    frozenset({'糕点'}) --> frozenset({'全脂牛奶'}) 支持度 0.033249 置信度: 0.373714 lift值为: 1.462587
    frozenset({'酸奶油'}) --> frozenset({'其他蔬菜'}) 支持度 0.028876 置信度: 0.402837 lift值为: 2.081924
    frozenset({'猪肉'}) --> frozenset({'其他蔬菜'}) 支持度 0.021657 置信度: 0.375661 lift值为: 1.941476
    frozenset({'酸奶油'}) --> frozenset({'全脂牛奶'}) 支持度 0.032232 置信度: 0.449645 lift值为: 1.759754
    frozenset({'猪肉'}) --> frozenset({'全脂牛奶'}) 支持度 0.022166 置信度: 0.38448 lift值为: 1.504719
    frozenset({'根茎类蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.048907 置信度: 0.448694 lift值为: 1.756031
    frozenset({'根茎类蔬菜'}) --> frozenset({'其他蔬菜'}) 支持度 0.047382 置信度: 0.434701 lift值为: 2.246605
    frozenset({'凝乳'}) --> frozenset({'全脂牛奶'}) 支持度 0.026131 置信度: 0.490458 lift值为: 1.919481
    frozenset({'热带水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.042298 置信度: 0.403101 lift值为: 1.577595
    frozenset({'柑橘类水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.030503 置信度: 0.36855 lift值为: 1.442377
    frozenset({'黄油'}) --> frozenset({'全脂牛奶'}) 支持度 0.027555 置信度: 0.497248 lift值为: 1.946053
    frozenset({'酸奶'}) --> frozenset({'全脂牛奶'}) 支持度 0.056024 置信度: 0.401603 lift值为: 1.571735
    frozenset({'其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.074835 置信度: 0.386758 lift值为: 1.513634
    frozenset({'全脂牛奶', '酸奶'}) --> frozenset({'其他蔬菜'}) 支持度 0.022267 置信度: 0.397459 lift值为: 2.054131
    frozenset({'酸奶', '其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.022267 置信度: 0.512881 lift值为: 2.007235
    frozenset({'全脂牛奶', '根茎类蔬菜'}) --> frozenset({'其他蔬菜'}) 支持度 0.023183 置信度: 0.474012 lift值为: 2.44977
    frozenset({'根茎类蔬菜', '其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.023183 置信度: 0.48927 lift值为: 1.914833
    

    五、封装好的apriori算法的调用

    import numpy as np
    import pandas as pd
    import xlrd
    from mlxtend.frequent_patterns import apriori  # 生成频繁项集
    from mlxtend.frequent_patterns import association_rules  # 生成强关联规则
    import warnings
    
    warnings.filterwarnings("ignore")  # 用于排除警告
    
    
    def loaddata():
        order_data = pd.read_csv('data/GoodsOrder.csv', header=0, encoding='gbk')
        # 转换数据格式
        order_data['Goods'] = order_data['Goods'].apply(lambda x: "," + x)
        order_data = order_data.groupby('id').sum().reset_index()
        order_data['Goods'] = order_data['Goods'].apply(lambda x: [x[1:]])
        order_data_list = list(order_data['Goods'])
        # print(order_data_list)
        # 分割商品名为每一个元素
        data_translation = []
        for i in order_data_list:
            # 列表中元素为1个字符串,所以用0索引
            p = i[0].split(",")
            data_translation.append(p)
        return data_translation
    
    
    if __name__ == '__main__':
        dataSet = loaddata()
        column_list = []
        for var in dataSet:
            column_list = set(column_list) | set(var)
        print('转换原数据到0-1矩阵')
        data = pd.DataFrame(np.zeros((len(dataSet), 169)), columns=column_list)
        for i in range(len(dataSet)):
            for j in dataSet[i]:
                data.loc[i, j] += 1
        # apriori算法
        frequent_itemsets = apriori(data, min_support=0.02, use_colnames=True)
        print(pd.DataFrame(frequent_itemsets))
        pd.DataFrame(frequent_itemsets).to_csv('frequent_itemsets.csv')
        # 生成关联准则
        rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.35)
        print(pd.DataFrame(rules))
        pd.DataFrame(rules).to_csv('rules.csv')
    
          support             itemsets
    0    0.038434                (威化饼)
    1    0.026029               (一般饮料)
    2    0.025826               (一般肉类)
    3    0.033452           (超高温杀菌的牛奶)
    4    0.064870                (黑面包)
    ..        ...                  ...
    117  0.024301             (香肠, 苏打)
    118  0.027351             (苏打, 酸奶)
    119  0.021047             (苏打, 糕点)
    120  0.023183  (根茎类蔬菜, 全脂牛奶, 其他蔬菜)
    121  0.022267     (酸奶, 全脂牛奶, 其他蔬菜)
    
    [122 rows x 2 columns]
          antecedents consequents  ...  leverage  conviction
    0           (黑面包)      (全脂牛奶)  ...  0.008641    1.217899
    1            (猪肉)      (全脂牛奶)  ...  0.007435    1.209520
    2            (猪肉)      (其他蔬菜)  ...  0.010502    1.291779
    3            (牛肉)      (全脂牛奶)  ...  0.007845    1.251315
    4         (根茎类蔬菜)      (全脂牛奶)  ...  0.021056    1.350401
    5         (根茎类蔬菜)      (其他蔬菜)  ...  0.026291    1.426693
    6        (水果/蔬菜汁)      (全脂牛奶)  ...  0.008168    1.178904
    7          (其他蔬菜)      (全脂牛奶)  ...  0.025394    1.214013
    8          (人造黄油)      (全脂牛奶)  ...  0.009235    1.268706
    9            (凝乳)      (全脂牛奶)  ...  0.012517    1.461085
    10           (黄油)      (全脂牛奶)  ...  0.013395    1.480817
    11        (柑橘类水果)      (全脂牛奶)  ...  0.009355    1.179008
    12         (冷冻蔬菜)      (全脂牛奶)  ...  0.008149    1.294636
    13         (热带水果)      (全脂牛奶)  ...  0.015486    1.247252
    14          (酸奶油)      (全脂牛奶)  ...  0.013916    1.352735
    15         (本地蛋类)      (全脂牛奶)  ...  0.013783    1.412030
    16           (酸奶)      (全脂牛奶)  ...  0.020379    1.244132
    17           (糕点)      (全脂牛奶)  ...  0.010516    1.188729
    18        (仁果类水果)      (全脂牛奶)  ...  0.010767    1.236375
    19           (黄油)      (其他蔬菜)  ...  0.009308    1.263065
    20          (酸奶油)      (其他蔬菜)  ...  0.015006    1.350565
    21         (本地蛋类)      (其他蔬菜)  ...  0.009991    1.242619
    22  (根茎类蔬菜, 全脂牛奶)      (其他蔬菜)  ...  0.013719    1.533320
    23  (根茎类蔬菜, 其他蔬菜)      (全脂牛奶)  ...  0.011076    1.457687
    24     (全脂牛奶, 酸奶)      (其他蔬菜)  ...  0.011427    1.338511
    25     (酸奶, 其他蔬菜)      (全脂牛奶)  ...  0.011174    1.528340
    [26 rows x 9 columns]
    
    

    参考于《python数据分析与挖掘实战》,后面有时间的话,会基于《机器学习实战》学习一下FP-Tree关联规则分析


    如果对您有帮助,麻烦点赞关注,这真的对我很重要!!!如果需要互关,请评论留言!
    在这里插入图片描述


    展开全文
  • 关联规则分析

    千次阅读 2017-11-27 17:22:00
    关联规则是形如X→Y的蕴涵式,其中, X和Y分别称为关联规则的先导(antecedent或left-hand-side, LHS)和后继(consequent或right-hand-side, RHS) 故事   在描述有关关联规则的一些细节之前,先来看一个有趣的...

           关联规则是形如X→Y的蕴涵式,其中,X和Y分别称为关联规则的先导(antecedent或left-hand-side, LHS)和后继(consequent或right-hand-side, RHS)


    故事 

           在描述有关关联规则的一些细节之前,先来看一个有趣的故事: "尿布与啤酒"的故事。在一家超市里,有一个有趣的现象:尿布和啤酒赫然摆在一起出售。但是这个奇怪的举措却使尿布和啤酒的销量双双增加了。这不是一个笑话,而是发生在美国沃尔玛连锁店超市的真实案例,并一直为商家所津津乐道。沃尔玛拥有世界上最大的数据仓库系统,为了能够准确了解顾客在其门店的购买习惯,沃尔玛对其顾客的购物行为进行购物篮分析,想知道顾客经常一起购买的商品有哪些。沃尔玛数据仓库里集中了其各门店的详细原始交易数据。在这些原始交易数据的基础上,沃尔玛利用数据挖掘方法对这些数据进行分析和挖掘。一个意外的发现是:"跟尿布一起购买最多的商品竟是啤酒!经过大量实际调查和分析,揭示了一个隐藏在"尿布与啤酒"背后的美国人的一种行为模式:在美国,一些年轻的父亲下班后经常要到超市去买婴儿尿布,而他们中有30%~40%的人同时也为自己买一些啤酒。产生这一现象的原因是:美国的太太们常叮嘱她们的丈夫下班后为小孩买尿布,而丈夫们在买尿布后又随手带回了他们喜欢的啤酒。

    按常规思维,尿布与啤酒风马牛不相及,若不是借助数据挖掘技术对海量交易数据进行挖掘和分析,沃尔玛是不可能发现数据内在这一有价值的规律的。


    定义

           根据韩家炜等观点,关联规则定义为:假设I是项的集合。给定一个交易数据库D,其中每个事务(Transaction)t是I的非空子集,即,每一个交易都与一个唯一的标识符TID(Transaction ID)对应。关联规则在D中的支持度(support)是D中事务同时包含X、Y的百分比,即概率置信度(confidence)是D中事物已经包含X的情况下,包含Y的百分比,即条件概率。如果满足最小支持度阈值和最小置信度阈值。这些阈值是根据挖掘需要人为设定。


    例子

          基本概念表1:关联规则的简单例子

    TID

    网球拍

    网 球

    运动鞋

    羽毛球

    1

    1

    1

    1

    0

    2

    1

    1

    0

    0

    3

    1

    0

    0

    0

    4

    1

    0

    1

    0

    5

    0

    1

    1

    1

    6

    1

    1

    0

    0

           用一个简单的例子说明。表1是顾客购买记录的数据库D,包含6个事务。项集I={网球拍,网球,运动鞋,羽毛球}。考虑关联规则(频繁二项集):网球拍与网球,事务1,2,3,4,6包含网球拍,事务1,2,6同时包含网球拍和网球,X^Y=3, D=6,支持度(X^Y)/D=0.5;X=5, 置信度(X^Y)/X=0.6。若给定最小支持度α = 0.5,最小置信度β = 0.6,认为购买网球拍和购买网球之间存在关联。


    挖掘过程

    两个阶段

    关联规则挖掘过程主要包含两个阶段:

    第一阶段必须先从资料集合中找出所有的高频项目组(Frequent Itemsets),

    第二阶段再由这些高频项目组中产生关联规则(Association Rules)。

          关联规则挖掘的第一阶段必须从原始资料集合中,找出所有高频项目组(Large Itemsets)。高频的意思是指某一项目组出现的频率相对于所有记录而言,必须达到某一水平。一项目组出现的频率称为支持度(Support),以一个包含A与B两个项目的2-itemset为例,我们可以经由公式(1)求得包含{A,B}项目组的支持度,若支持度大于等于所设定的最小支持度(Minimum Support)门槛值时,则{A,B}称为高频项目组。一个满足最小支持度的k-itemset,则称为高频k-项目组(Frequent k-itemset),一般表示为Large k或Frequent k。算法并从Large k的项目组中再产生Large k+1,直到无法再找到更长的高频项目组为止。

          关联规则挖掘的第二阶段是要产生关联规则(Association Rules)。从高频项目组产生关联规则,是利用前一步骤的高频k-项目组来产生规则,在最小信赖度(Minimum Confidence)的条件门槛下,若一规则所求得的信赖度满足最小信赖度,称此规则为关联规则。例如:经由高频k-项目组{A,B}所产生的规则AB,其信赖度可经由公式(2)求得,若信赖度大于等于最小信赖度,则称AB为关联规则。


    案例分析

          就沃尔马案例而言,使用关联规则挖掘技术,对交易资料库中的纪录进行资料挖掘,首先必须要设定最小支持度与最小信赖度两个门槛值,在此假设最小支持度min_support=5% 且最小信赖度min_confidence=70%。因此符合此该超市需求的关联规则将必须同时满足以上两个条件。若经过挖掘过程所找到的关联规则「尿布,啤酒」,满足下列条件,将可接受「尿布,啤酒」的关联规则。用公式可以描述Support(尿布,啤酒)>=5%且Confidence(尿布,啤酒)>=70%。其中,Support(尿布,啤酒)>=5%于此应用范例中的意义为:在所有的交易纪录资料中,至少有5%的交易呈现尿布与啤酒这两项商品被同时购买的交易行为。Confidence(尿布,啤酒)>=70%于此应用范例中的意义为:在所有包含尿布的交易纪录资料中,至少有70%的交易会同时购买啤酒。因此,今后若有某消费者出现购买尿布的行为,超市将可推荐该消费者同时购买啤酒。这个商品推荐的行为则是根据「尿布,啤酒」关联规则,因为就该超市过去的交易纪录而言,支持了“大部份购买尿布的交易,会同时购买啤酒”的消费行为。

    从上面的介绍还可以看出,关联规则挖掘通常比较适用与记录中的指标取离散值的情况。如果原始数据库中的指标值是取连续的数据,则在关联规则挖掘之前应该进行适当的数据离散化(实际上就是将某个区间的值对应于某个值),数据的离散化是数据挖掘前的重要环节,离散化的过程是否合理将直接影响关联规则的挖掘结果。


    分类

    按照不同情况,关联规则可以进行分类如下:

    1.基于规则中处理的变量的类别:

           关联规则处理的变量可以分为布尔型和数值型。布尔型关联规则处理的值都是离散的、种类化的,它显示了这些变量之间的关系;而数值型关联规则可以和多维关联或多层关联规则结合起来,对数值型字段进行处理,将其进行动态的分割,或者直接对原始的数据进行处理,当然数值型关联规则中也可以包含种类变量。例如:性别=“女”=>职业=“秘书” ,是布尔型关联规则;性别=“女”=>avg(收入)=2300,涉及的收入是数值类型,所以是一个数值型关联规则。

    2.基于规则中数据的抽象层次:

          基于规则中数据的抽象层次,可以分为单层关联规则和多层关联规则。在单层的关联规则中,所有的变量都没有考虑到现实的数据是具有多个不同的层次的;而在多层的关联规则中,对数据的多层性已经进行了充分的考虑。例如:IBM台式机=>Sony打印机,是一个细节数据上的单层关联规则;台式机=>Sony打印机,是一个较高层次和细节层次之间的多层关联规则。

    3.基于规则中涉及到的数据的维数:

         关联规则中的数据,可以分为单维的和多维的。在单维的关联规则中,我们只涉及到数据的一个维,如用户购买的物品;而在多维的关联规则中,要处理的数据将会涉及多个维。换成另一句话,单维关联规则是处理单个属性中的一些关系;多维关联规则是处理各个属性之间的某些关系。例如:啤酒=>尿布,这条规则只涉及到用户的购买的物品;性别=“女”=>职业=“秘书”,这条规则就涉及到两个字段的信息,是两个维上的一条关联规则。


    相关算法

    Apriori算法:使用候选项集找频繁项集

         Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。其核心是基于两阶段频集思想的递推算法。该关联规则在分类上属于单维、单层、布尔关联规则。在这里,所有支持度大于最小支持度的项集称为频繁项集,简称频集。

    该算法的基本思想是:首先找出所有的频集,这些项集出现的频繁性至少和预定义的最小支持度一样。然后由频集产生强关联规则,这些规则必须满足最小支持度和最小可信度。然后使用第1步找到的频集产生期望的规则,产生只包含集合的项的所有规则,其中每一条规则的右部只有一项,这里采用的是中规则的定义。一旦这些规则被生成,那么只有那些大于用户给定的最小可信度的规则才被留下来。为了生成所有频集,使用了递推的方法。

    可能产生大量的候选集,以及可能需要重复扫描数据库,是Apriori算法的两大缺点。


    基于划分的算法

           Savasere等设计了一个基于划分的算法。这个算法先把数据库从逻辑上分成几个互不相交的块,每次单独考虑一个分块并对它生成所有的频集,然后把产生的频集合并,用来生成所有可能的频集,最后计算这些项集的支持度。这里分块的大小选择要使得每个分块可以被放入主存,每个阶段只需被扫描一次。而算法的正确性是由每一个可能的频集至少在某一个分块中是频集保证的。该算法是可以高度并行的,可以把每一分块分别分配给某一个处理器生成频集。产生频集的每一个循环结束后,处理器之间进行通信来产生全局的候选k-项集。通常这里的通信过程是算法执行时间的主要瓶颈;而另一方面,每个独立的处理器生成频集的时间也是一个瓶颈。


    FP-树频集算法

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


    应用

         关联规则挖掘技术已经被广泛应用在西方金融行业企业中,它可以成功预测银行客户需求。一旦获得了这些信息,银行就可以改善自身营销。银行天天都在开发新的沟通客户的方法。各银行在自己的ATM机上就捆绑了顾客可能感兴趣的本行产品信息,供使用本行ATM机的用户了解。如果数据库中显示,某个高信用限额的客户更换了地址,这个客户很有可能新近购买了一栋更大的住宅,因此会有可能需要更高信用限额,更高端的新信用卡,或者需要一个住房改善贷款,这些产品都可以通过信用卡账单邮寄给客户。当客户打电话咨询的时候,数据库可以有力地帮助电话销售代表。销售代表的电脑屏幕上可以显示出客户的特点,同时也可以显示出顾客会对什么产品感兴趣。

    同时,一些知名的电子商务站点也从强大的关联规则挖掘中的受益。这些电子购物网站使用关联规则中规则进行挖掘,然后设置用户有意要一起购买的捆绑包。也有一些购物网站使用它们设置相应的交叉销售,也就是购买某种商品的顾客会看到相关的另外一种商品的广告。

    但是在我国,“数据海量,信息缺乏”是商业银行在数据大集中之后普遍所面对的尴尬。金融业实施的大多数数据库只能实现数据的录入、查询、统计等较低层次的功能,却无法发现数据中存在的各种有用的信息,譬如对这些数据进行分析,发现其数据模式及特征,然后可能发现某个客户、消费群体或组织的金融和商业兴趣,并可观察金融市场的变化趋势。可以说,关联规则挖掘的技术在我国的研究与应用并不是很广泛深入。


    研究

         由于许多应用问题往往比超市购买问题更复杂,大量研究从不同的角度对关联规则做了扩展,将更多的因素集成到关联规则挖掘方法之中,以此丰富关联规则的应用领域,拓宽支持管理决策的范围。如考虑属性之间的类别层次关系,时态关系,多表挖掘等。围绕关联规则的研究主要集中于两个方面,即扩展经典关联规则能够解决问题的范围,改善经典关联规则挖掘算法效率和规则兴趣性。



    展开全文
  • 调用apriori进行关联规则分析,具体代码如下,其中数据集选取本博客 “机器学习算法——关联规则” 中的例子,可进行参考,设置最小支持度(min_support)为0.4,最小置信度(min_threshold)为0.1, 最小提升度...
  • 数据挖掘之关联规则分析

    万次阅读 2018-08-12 14:01:18
    关联规则分析也称为购物篮分析,最早是为了发现超市销售数据库中不同的商品之间的关联关系。 用于寻找数据集中各项之间的关联关系。根据所挖掘的关联关系,可以从一个属性的信息来推断另一个属性的信息。当置信度...

    关联规则分析也称为购物篮分析,最早是为了发现超市销售数据库中不同的商品之间的关联关系。

    用于寻找数据集中各项之间的关联关系。根据所挖掘的关联关系,可以从一个属性的信息来推断另一个属性的信息。当置信度达到某一阈值时,可以认为规则成立。

    常用的关联规则算法

    算法名称算法描述
    Apriori

    关联规则最常用、最经典的挖掘频繁项集的算法,核心思想是通过连接产生候选项及其支持度,然后通过剪枝生成频繁项集

    无法处理连续型数值变量,往往分析之前需要对数据进行离散化。

    FP-Tree

    针对Apriori算法固有的多次扫描事务数据集的缺陷,提出的不产生候选频繁项集的方法。

    Apriori和FP-Tree都是寻找频繁项集的算法

    Eclat算法一种深度优先算法,采用垂直数据表示形式,在概念格理论的基础上利用基于前缀的等价关系将搜索空间划分为较小的子空间
    灰色关联法分析和确定各因素之间的影响程度,或是若干个子因素(子序列)对主因素(母序列)的贡献度而进行的一种分析方法

    本文介绍最常用的Apriori算法。

    项集:项的集合。包含k个项的项集成为k项集,如集合{牛奶、麦片、糖}是一个3项集

    频繁项集:如果项集I的相对支持度满足预定义的最小支持度阈值,则I是频繁项集

    支持度(相对支持度):项集A、B同时发生的概率。

    置信度:项集A发生,则项集B发生的概率。

    最小支持度:用户或专家定义的衡量支持度的一个阈值,表示项集在统计意义上的最低重要性。

    最小置信度:用户或专家定义的衡量置信度的一个阈值,表示关联规则的最低可靠性。同时满足最小支持度阈值和最小置信度阈值的规则成为强规则。

    目前,设置最小支持度和最小置信度,大部分根据业务经验设置初始值,然后经过多次调整,获取与业务相符的关联规则结果。


    举例1:

    R语言实现:

    1、创建稀疏矩阵

    tr <- read.transactions("menu_orders.txt",format="basket",sep=",") #读入源数据并创建稀疏矩阵
    #format=c("basket", "single")用于注明源数据的格式。如果源数据每行内容就是一条交易购买的商品列表(类似于一行就是一个购物篮)那么使用basket;如果每行内容是交易号+单个商品,那么使用single。
    summary(tr) #查看数据集相关的统计汇总信息
    
    inspect(tr) #查看稀疏矩阵的内容

    输出如下:

    2、采用Apriori算法建模

    rule0 = apriori(tr,parameter = list(support=0.2,confidence = 0.5)) #设定支持度为0.2,置信度为0.5

    3、输出模型结果

    inspect(rule0)

    输出结果如下:

    结果分析(以结果第12条为例):

    a、b同时发生的概率是50%。

    a发生,则b发生的概率是71.42857%。

    这样就可以进行智能推荐了。


    举例2:

    trans = as(a,"transactions") #将数据转换成transactions属性
    
    inspect(trans[1:5]) #观察前五行的数据
    
    rules = apriori(trans,parameter = list(support=0.06,confidence = 0.75)) #调用Apriori算法,最小支持度为0.06,最小置信度为0.75
    
    rules #显示rules中关联规则条数
    
    inspect(rules) #观测rules中的关联规则

    输出结果如下:

    结果分析(以结果第2条为例):

    A4、F3~H4的支持度最大,为7.85%,置信度为87.96%。说明当A4、F3的条件满足时,H4的可能性为87.96%,而这种情况发生的可能性为7.85%。

     

    Python实现:

    import pandas as pd 
    from apriori import * 导入自己编写的Apriori函数
    data = pd.read_excel("menu_orders.xls",header=None)
    
    print(u'\n转换原始数据为0-1矩阵')
    ct = lambda x:pd.Series(1,index=x[pd.notnull(x)]) #转换0-1矩阵的过渡函数
    b = map(ct,data.as_matrix()) #用map方式执行
    data = pd.DataFrame(list(b)).fillna(0) #实现矩阵转换,空值用0填充
    print(u'\n转换完毕。')
    del b #删除中间变量b,节省内存
    
    support = 0.2 #最小支持度
    confidence = 0.5 #最小置信度
    ms = '---' #连接符
    find_rule(data,support,confidence,ms).to_excel('1.xls')

    输出结果如下:

    展开全文
  • 使用Apriori关联规则算法实现购物篮分析

    千次阅读 多人点赞 2020-11-19 15:19:26
    本章使用Apriori关联规则算法实现购物篮分析,发现超市不同商品之间的关联关系,并根据商品之间的关联规则制定销售策略。 1背景与挖掘目标 现代商品种类繁多,顾客往往会由于需要购买的商品众多而变得疲于选择,且...
  • 关联规则(Association Rules)是反映一个事物与其他事物之间的相互依存性和关联性,如果两个或多个事物之间存在一定的关联关系,那么,其中一个事物就能通过其他事物预测到。关联规则是数据挖掘的一个...
  • 1.关联规则浅谈  关联规则(Association Rules)是反映一个事物与其他事物之间的相互依存性和关联性,如果两个或多个事物之间存在一定的关联关系,那么,其中一个事物就能通过其他事物预测到。关联规则是数据挖掘...
  • 关于关联规则分析算法的规则见基于关联规则分析的推荐算法,这里只是基于以上理论,给出实现的代码: #!/usr/bin/env python # coding: utf-8 # File Name: Apriori_update.py # Author : john # Mail : keyue...
  • r语言实现关联分析关联规则挖掘 关联分析: 引子: 我们一般把一件事情发生,对另一间事情也会产生影响的关系叫做关联。而关联分析就是在大量数据中发现项集之间有趣的关联和相关联系(形如“由于某些事件的发生而...
  • MS关联规则分析算法

    2017-07-08 17:12:13
    MS关联规则分析算法 属于建议引擎算法,可根据已购买的商品推测出可能要购买的商品。 关联规则是在大量数据事例中挖掘项集之间的关联或相关联系。典型如购物篮分析,就是购买了某一商品的用户是否会去购买另一商品。...
  • R语言实现关联规则 笔者前言:以前在网上遇到很多很好的关联规则的案例,最近看到一个更好的,于是便学习一下,写个学习笔记。 推荐算法中 物品-物品用关联规则; 人物-物品用协同过滤; 人-人用社会...
  • Spark实现关联分析

    2019-12-11 16:32:53
    市场购物篮分析的结果是一组指定商品之间关系模式的关联规则,一个典型的规则可以表述为: {花生酱,果酱} –> {面包} 这个关联规则用通俗易懂的语言来表达就是:如果购买了花生酱和果酱,那么也很有可能会购买...
  • 关联规则(Association Rules)原理分析及实例python实现

    万次阅读 多人点赞 2018-10-16 20:35:02
    1.关联规则  2.常见案例  3.置信度与支持度  什么是规则?   (3) 支持度  (4) 置信度   (5) 最小支持度与频繁集  (6) 关联规则 (7) 强关联规则  (8) Apriori算法挖掘频繁项集
  • 提出利用叠置分析和面积计算实现空间关联规则挖掘的算法I-Apriori及其改进算法FI-Apriori,这两种算法不依赖于空间数据的事务化,可以直接从矢量多边形图层中提取所有强关联规则。采用实际数据对两种算法进行了检验...
  • C++简单实现关联规则挖掘中Apriori算法
  • 本篇继续我们的微软挖掘算法系列总结,前几篇我们分别介绍了:Microsoft决策树分析算法、Microsoft聚类分析算法、Microsoft Naive Bayes 算法、Microsoft 时序算法,后续还补充了二篇结果预测篇、Microsoft 时序...
  • 关联规则算法java实现代码

    热门讨论 2011-07-28 13:16:16
    关联规则算法java实现代码,以完成关联规则提取、预测及归纳
  • 1. 关联规则大家可能听说过用于宣传数据挖掘的一个案例:啤酒和尿布;据说是沃尔玛超市在分析顾客的购买记录时,发现许多客户购买啤酒的同时也会购买婴儿尿布,于是超市调整了啤酒和尿布的货架摆放,...
  • Hadoop实现关联规则算法--二项集挖掘

    千次阅读 2012-11-08 10:20:15
    近期看mahout的关联规则源码,颇为头痛,本来打算写一个系列分析关联规则的源码的,但是后面看到有点乱了,可能是稍微有点复杂吧,所以就打算先实现最简单的二项集关联规则。 算法的思想还是参考上次的图片: 这里...
  • 怎么用clementine做关联规则分析

    万次阅读 多人点赞 2015-11-30 18:00:24
    不要怕,小迪来教了怎么用clementine做关联规则分析。 1、首先你得在你的电脑上安装clementine,安装方法我在另一篇博文上做出过说明。详情请见:http://blog.csdn.net/u014374031/article/details/50082941 这里再...
  • 转载:关联规则算法Apriori的学习与SQL简单实现购物篮分析   关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。 关联规则揭示了数据项间的未知的依赖关系,根据所挖掘的关联关系,可以从一个数据...
  • 文章目录关联规则分析数据介绍基本原理介绍基本概念:Apriori算法有意义的关联规则案例分析总结反思学习其他同学的代码参考代码这其实跟前面排序是等价的查看分析结果inspect函数逐条查看关联规则by="lift"指定按...
  • 【数据挖掘】关联规则之灰色关联分析

    千次阅读 多人点赞 2019-01-24 17:52:39
    灰色关联分析法 利用灰色关联分析的九个步骤: 1.根据分析目的确定分析指标体系,收集分析数据。  设n个数据序列形成如下矩阵:   其中m为指标的个数, 2.确定参考数据列 参考数据列应该是一个理想的比较...
  • 聚类分析算法和关联规则在客户细分中一种研究与实现,谢燕,,本论文具体介绍了一种聚类分析的算法,并把他它运用于商场客户分析中。具体包括选取样本数据,进行数据的变量结构调整,计算相异
  • PDF格式的基于关联规则挖掘算法的分析型CRM的设计与实现(参考1)论文!
  • 基于R语言的关联规则分析项目

    千次阅读 2018-06-04 13:24:12
    在完成两周的关联规则自主学习后,我们开展了为期半个月的团队第一个合作分析项目——消费者购买情况的关联分析。项目的数据来自于团队成员贡献的某公司2013年至2014年客户交易明细数据。根据商品...
  • 如果用P(A)表示使用A事务的比例,那么Support=P(A&B) 苍天不负有心人啊,我玩了两三个周的文本关联规则挖掘,终于实现了,我心甚慰!!!甚慰 好啦,废话不多说,上干货 置信度 Confidence(可信度):表示使用包含A...
  • 1.关联规则分析的定义 关联分析(Association Analysis)用于发现隐藏在大型数据集中的令人感兴趣的联系。联系的表示方式一般为关联规则或频繁项集,例:{尿布}→{啤酒}。 2.关联规则分析的基本概念 项集:项的集合...
  • #FuzzyFCA Java库实现了形式概念分析(FCA)算法的模糊扩展,以提取模糊晶格和关联规则。 该实现扩展了实现FCA算法的colibri-java库,可在以下位置找到: : #概念分析形式概念分析是二元关系的代数理论。 每个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 153,222
精华内容 61,288
关键字:

怎样实现关联规则分析