精华内容
下载资源
问答
  • # 生成关联规则 def generateRules ( L , supportData , minConf = 0.7 ) : bigRuleList = [ ] for i in range ( 1 , len ( L ) ) : for freqSet in L [ i ] : H1 = [ frozenset ( ...
    # 模拟生成示例数据
    def loadDataSet():
        return [[1, 2, 3], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
    
    
    # 生成候选项
    def createC1(dataSet):
        C1 = []
        for transaction in dataSet:
            for item in transaction:
                if not [item] in C1:
                    C1.append([item])
        C1.sort()
        return list(map(frozenset, C1))
    
    
    # 生成频繁项
    def scanD(D, Ck, minSupport):
        ssCnt = {}
        for tid in D:
            for can in Ck:
                if can.issubset(tid):
                    if can not in (ssCnt.keys()):
                        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 aprioriGen(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:
                    retList.append(Lk[i] | Lk[j])
        return retList
    
    
    def apriori(dataSet, minSupport=0.5):
        C1 = createC1(dataSet)
        D = list(map(set, dataSet))
        L1, supportData = scanD(D, C1, minSupport)
        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)
            k += 1
        return L, supportData
    
    
    # 生成关联规则
    def generateRules(L, supportData, minConf=0.7):
        bigRuleList = []
        for i in range(1, len(L)):
            for freqSet in L[i]:
                H1 = [frozenset([item]) for item in freqSet]
                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:
                rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
    
    
    #测试
    if __name__ == '__main__':
        dataSet_1 = loadDataSet()
        L,suppData = apriori(dataSet_1)
        print(L)
        print('\n--------------------\n')
        print(suppData)
    
        rules = generateRules(L,suppData,minConf=0.7)
        print(rules)
    
    展开全文
  • 1.Apriori关联分析的介绍 这一部分可以看我的上一篇博文,里面主要介绍了关联分析的原理。 链接: python机器学习之关联分析(Apriori). 2.案例背景与分析过程 现代商品种类繁多,顾客往往会纠结选择买啥,尤其对于...

    1.Apriori关联分析的介绍

    这一部分可以看我的上一篇博文,里面主要介绍了关联分析的原理。
    链接: python机器学习之关联分析(Apriori).

    2.案例背景与分析过程

    现代商品种类繁多,顾客往往会纠结选择买啥,尤其对于选择困难症的顾客来说,选择商品更是难上加难。繁杂的选购往往会给顾客带来疲惫的购物体验。对于部分商品,比如面包和牛奶,薯片和可乐等,是顾客经常同时购买的东西,当这些东西距离十分遥远时,就会减小顾客的购买欲望。因此,为了获取最大销售利润,我们需要了解销售什么样的商品、采用什么样的促销手段、商品在货架上如何摆放以及了解顾客购买习惯和偏好等对销售商尤其重要。
    分析目的:

    • 构建商品的Apriori模型,分析商品之间的关联关系。
    • 根据模型结果给出销售策略。
    优化
    源数据
    某商品的零售企业购物车数据
    数据预处理
    Apriori关联分析
    模型应用
    分析结束

    具体步骤如下:

    1. 查看原始数据的形式。
    2. 对原始数据进行数据的预处理,转换数据形式,使其满足Apriori关联分析的要求。
    3. 建立Apriori模型,调整超参数。
    4. 对模型结果进行分析。提供销售建议。

    3.数据的初步处理

    对本案例的数据先要有个大致的了解,本案例一共有9835个购物篮数据,一共有两个表,它主要包括3个属性:

    表名属性值描述
    Goods Orderid商品所属类别的编号
    Goods具体的商品名称
    Goods TypesGoods具体的商品名称
    Type商品类别
    用python读取数据并查看数据特征。
    #此文件是Apriori模型的主要文件
    import pandas as pd
    file_path=open("....这里自己填文件路径//GoodsOrder.csv")
    data=pd.read_csv(file_path)
    data.info()
    des=pd.DataFrame(data.describe()).T 
    print(des)#查看信息描述
    

    在这里插入图片描述
    一共有43367个观测值,不存在缺失值id最大值为9835,说明一共有9835个购物篮信息。
    在这里插入图片描述
    查看销量占比:

    #销量占比
    data_nums = data.shape[0]
    for idnex, row in sorted[:10].iterrows():#iterrows就是pd的相当于enumerate依次数pd的行索引和数据
        print(row['Goods'],row['id'],row['id']/data_nums)
    

    在这里插入图片描述

    4.对商品进一步分析

    在步骤3中,我们分析了一些具体的商品,这样的分类对后续决策的执行存在一定的困难,我们应该将这些具体的商品和自己所属的大类联系起来。我们通过Good Types表中的数据找出对应商品所属的大类,就相当于数据库中的相关联。

    #各类别商品的销量及其占比
    import pandas as pd
    inputfile1 =open("C://Users//Administrator//Desktop//python-code//《Python数据分析与挖掘实战(第2版)》源数据和代码//《Python数据分析与挖掘实战(第2版)》源数据和代码-各章节//chapter8//demo//data//GoodsOrder.csv")
    inputfile2 =open("C://Users//Administrator//Desktop//python-code//《Python数据分析与挖掘实战(第2版)》源数据和代码//《Python数据分析与挖掘实战(第2版)》源数据和代码-各章节//chapter8//demo//data//GoodsTypes.csv")
    data = pd.read_csv(inputfile1)
    types = pd.read_csv(inputfile2)  # 读入数据
    
    group = data.groupby(['Goods']).count().reset_index()
    sort = group.sort_values('id',ascending = False).reset_index()
    data_nums = data.shape[0]  # 总量
    #print(sort)
    del sort['index']
    
    sort_links = pd.merge(sort,types)  # 合并两个datafreame 根据两表中相同的type
    # 根据类别求和,每个商品类别的总量,并排序
    sort_link = sort_links.groupby(['Types']).sum().reset_index()
    sort_link = sort_link.sort_values('id',ascending = False).reset_index()
    del sort_link['index']  # 删除“index”列
    
    # 求百分比,然后更换列名,最后输出到文件
    sort_link['count'] = sort_link.apply(lambda line: line['id']/data_nums,axis=1)
    sort_link.rename(columns = {'count':'percent'},inplace = True)
    print('各类别商品的销量及其占比:\n',sort_link)
    
    # 画饼图展示每类商品销量占比
    import matplotlib.pyplot as plt
    data = sort_link['percent']
    labels = sort_link['Types']
    plt.figure(figsize=(8, 6))  # 设置画布大小   
    plt.pie(data,labels=labels,autopct='%1.2f%%')
    plt.rcParams['font.sans-serif'] = 'SimHei'
    plt.title('每类商品销量占比')  # 设置标题
    #plt.savefig('../tmp/persent.png')  # 把图片以.png格式保存
    plt.show()
    

    将每个商品具体分类后,得到如下的大分类表。
    在这里插入图片描述
    根据我们的分析,非酒精类饮料占比最高,为17.51%,为销售的大军,所以我们对非酒精类饮料的商品结构进行分析。

    selected = sort_links.loc[sort_links['Types'] == '非酒精饮料']  # 挑选商品类别为“非酒精饮料”并排序
    child_nums = selected['id'].sum()  # 对所有的“非酒精饮料”求和
    selected['child_percent'] = selected.apply(lambda line: line['id']/child_nums,axis = 1)  # 求百分比
    selected.rename(columns = {'id':'count'},inplace = True)
    print('非酒精饮料内部商品的销量及其占比:\n',selected)
    # outfile2 = '../tmp/child_percent.csv'
    # sort_link.to_csv(outfile2,index = False,header = True,encoding='gbk')  # 输出结果
    
    # 画饼图展示非酒精饮品内部各商品的销量占比
    import matplotlib.pyplot as plt
    data = selected['child_percent']
    labels = selected['Goods']
    plt.figure(figsize = (8,6))  # 设置画布大小 
    explode = (0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.08,0.3,0.1,0.3)  # 设置每一块分割出的间隙大小
    plt.pie(data,explode = explode,labels = labels,autopct = '%1.2f%%',
            pctdistance = 1.1,labeldistance = 1.2)
    plt.rcParams['font.sans-serif'] = 'SimHei'
    plt.title("非酒精饮料内部各商品的销量占比")  # 设置标题
    plt.axis('equal')
    # plt.savefig('../tmp/child_persent.png')  # 保存图形
    plt.show()  # 展示图形
    

    在这里插入图片描述
    在这里插入图片描述
    这里我们在做一下数据转化,以前的数据每一行代表每一件商品,以及对应的id。

    import pandas as pd
    inputfile =open("C://Users//Administrator//Desktop//python-code//《Python数据分析与挖掘实战(第2版)》源数据和代码//《Python数据分析与挖掘实战(第2版)》源数据和代码-各章节//chapter8//demo//data//GoodsOrder.csv")
    data = pd.read_csv(inputfile)
    
    # 根据id对“Goods”列合并,并使用“,”将各商品隔开
    data['Goods'] = data['Goods'].apply(lambda x:','+x)
    print(data.head(10))
    
    data = data.groupby('id').sum().reset_index()
    print(data.head(10))
    
    # 对合并的商品列转换数据格式
    data['Goods'] = data['Goods'].apply(lambda x :[x[1:]])#转化为数组
    data_list = list(data['Goods'])
    
    # 分割商品名为每个元素
    data_translation = []
    for i in data_list:
        p = i[0].split(',')
        data_translation.append(p)
    print('数据转换结果的前5个元素:\n', data_translation[0:5])
    

    原数据:
    在这里插入图片描述
    转换后的数据:
    即将id为1的顾客所买的所有商品转换成一个列表。同理,id为2的顾客买的…
    在这里插入图片描述

    5.关联分析

    5.1建模实现的步骤:
    • 首先设置Apriori的最小支持度、最小置信度、输入建模样本数据
    • 采用Apriori关联分析算法对建模样本数据进行分析,以模型设置的参数作为条件和目标
      目前如何设置最小支持度与最小置信度设置并没有统一的大小的标准,大部分都是通过设置初始值,然后通过不断的调整,获取与业务相符的关联结果。本文输入的模型参数为:最小支持度0.02,最小置信度为0.35。
    # -*- coding: utf-8 -*-
    
    # 代码8-6 构建关联规则模型
    
    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  # 不含设为1
                    else:
                        ssCnt[can] += 1  # 有则计数加1
        numItems = float(len(D))  # 数据集大小
        retList = []  # L1初始化
        supportData = {}  # 记录候选项中各个数据的支持度
        for key in ssCnt:
            support = ssCnt[key] / numItems  # 计算支持度
            if support >= minSupport:
                retList.insert(0, key)  # 满足条件加入L1中
                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):
        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):
    # 前3条语句是对计算查找单个元素中的频繁项集
        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)  # 把supk的键值对添加到supportData里
            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:  #遍历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 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 = data_translation
        L, supportData = apriori(dataSet, minSupport = 0.02)
        rule = gen_rule(L, supportData, minConf = 0.35)
    
    
    

    结果如下:
    在这里插入图片描述
    我们对输出的结果进行解释:就拿第一条吧:
    在这里插入图片描述
    这说明同时购买(果汁/蔬菜汁)和(全脂牛奶)这两件商品的概率为36.85%,这种情况发生的可能性大小为2.66%
    后续的结果可以进行相同的解释

    根据模型的结果,我们发现大多购物者 买的东西主要为食品,随着生活水平的提高和健康意识的增加,其他蔬菜、根茎类蔬菜和全脂牛奶为现代家庭每日饮食所需品,因此,其他类、根茎类蔬菜和全脂牛奶同时购买的概率较高,符合现在人们的生活健康意识。

    6.模型应用

    以上模型结果表明:顾客购买其他商品的时候会同时购买全脂牛奶,因此商场应该根据实际情况将全脂牛奶放在顾客的必经之路上,或是显眼的地方,以便顾客拿取。同时,顾客购买其他蔬菜、根茎类蔬菜、酸牛奶、猪肉、黄油、本地蛋类和多种水果概率较高,因此商场可以考虑捆绑销售,或者调整商品布局,将这些商品距离尽量拉近,从而提升顾客的购物体验。

    参考资料

    链接: 机器学习—关联规则分析之Apriori算法.
    书籍:《python数据分析与挖掘实战》
    实验菜品数据集: 数据百度网盘下载,提取码7hwd.

    展开全文
  • 运用灰色关联理论对未来的订单作出预测判断,结合具体实例进行分析
  • 主要介绍了Laravel5.1 框架模型多态关联用法,结合实例形式分析了laravel5.1框架模型多态关联具体实现、使用方法与操作注意事项,需要的朋友可以参考下
  • 关联度分析法-灰色关联分析

    千次阅读 2020-09-14 16:50:14
    本文介绍了利用灰色关联分析方法分析了数据之间的关联度。

    灰色关联分析介绍

    对于两个系统之间的因素,其随时间或不同对象而变化的关联性大小的量度,称为关联度。在系统发展过程中,若两个因素变化的趋势具有一致性,即同步变化程度较高,即可谓二者关联程度较高;反之,则较低。因此,灰色关联分析方法,是根据因素之间发展趋势的相似或相异程度,亦即“灰色关联度”,作为衡量因素间关联程度的一种方法。
    通常可以运用此方法来分析各个因素对于结果的影响程度,也可以运用此方法解决随时间变化的综合评价类问题。

    灰色关联分析的步骤

    灰色系统关联分析的具体计算步骤如下:

    1. 确定反映系统行为特征的参考数列和影响系统行为的比较数列。
      反映系统行为特征的数据序列,称为参考数列(可以理解为因变量)。影响系统行为的因素组成的数据序列,称比较数列(可以理解为自变量)。
    2. 对参考数列和比较数列进行无量纲化处理。
      由于系统中各因素的物理意义不同,导致数据的量纲也不一定相同,不便于比较,或在比较时难以得到正确的结论。因此在进行灰色关联度分析时,一般都要进行无量纲化的数据处理。
    3. 求参考数列与比较数列的灰色关联系数ξ(Xi)
      所谓关联程度,实质上是曲线间几何形状的差别程度。因此曲线间差值大小,可作为关联程度的衡量尺度。对于一个参考数列X0有若干个比较数列X1, X2,…, Xn,各比较数列与参考数列在各个时刻(即曲线中的各点)的关联系数ξ(Xi)可由下列公式算出:

    在这里插入图片描述
    其中 ρ为分辨系数,ρ>0,ρ越小,分辨力越大,一般ρ的取值区间为(0,1),具体取值可视情况而定。通常取0.5。
    minmin是第二级最小差,记为Δmin。 maxmax是两级最大差,记为Δmax。
    在这里插入图片描述
    为各比较数列Xi曲线上的每一个点与参考数列X0曲线上的每一个点的绝对差值,记为Δoi(k)。
    所以关联系数ξ(Xi)也可简化如下列公式:
    在这里插入图片描述

    1. 求关联度ri
      因为关联系数是比较数列与参考数列在各个时刻(即曲线中的各点)的关联程度值,所以它的数不止一个,而信息过于分散不便于进行整体性比较。因此有必要将各个时刻(即曲线中的各点)的关联系数集中为一个值,即求其平均值,作为比较数列与参考数列间关联程度的数量表示,关联度ri公式如下:
      在这里插入图片描述

    2. 关联度排序
      因素间的关联程度,主要是用关联度的大小次序描述,而不仅是关联度的大小。将m个子序列对同一母序列的关联度按大小顺序排列起来,便组成了关联序,记为{x},它反映了对于母序列来说各子序列的“优劣”关系。若r0i>r0j,则称{xi}对于同一母序列{x0}优于{xj},记为{xi}>{xj} ;若r0i表1 代表旗县参考数列、比较数列特征值。

    实例

    #灰色关联度分析
    import pandas as p
    import numpy as np
    from numpy import *
    import matplotlib.pyplot as plt
    %matplotlib inline
    
    # 从硬盘读取数据进入内存
    wine = pd.read_csv("...\\是.csv",encoding="ANSI")
    wine.head()
    wine=wine.dropna()
    wine.dropna()
    # 无量纲化()
    newDataFrame=pd.DataFrame(index=wine.index)
    columns=wine.columns.tolist()
    for c in columns:
            d = wine[c]
            MAX = d.max()
            MIN = d.min()
            MEAN = d.mean()
            newDataFrame[c] = ((d - MEAN) / (MAX - MIN)).tolist()
    print(newDataFrame)
    # 提取参考队列和比较队列
    newDataFrame=newDataFrame.iloc[:,1:].T
    ck=newDataFrame.iloc[0,:]
    cp=newDataFrame.iloc[1:,:]#比较
    #比较队列与参考列相减
    t=pd.DataFrame()
    for j in range(cp.index.size):
        temp=pd.Series(cp.iloc[j,:]-ck)
        t=t.append(temp,ignore_index=True)
    #求最大差和最小差
    mmax=t.abs().max().max()
    mmin=t.abs().min().min()
    rho=0.5
    #求关联系数
    ksi=((mmin+rho*mmax)/(abs(t)+rho*mmax))
    pd.DataFrame(ksi)
    # 灰色关联结果矩阵可视化
    import seaborn as sns
    def ShowGRAHeatMap(DataFrame):
        colormap = plt.cm.RdBu
        ylabels = DataFrame.columns.values.tolist()
        f, ax = plt.subplots(figsize=(14, 14))
        ax.set_title('GRA HeatMap')    
        # 设置展示一半,如果不需要注释掉mask即可
        #mask = np.zeros_like(DataFrame)
        #mask[np.triu_indices_from(mask)] = True
        
        with sns.axes_style("white"):
            sns.heatmap(DataFrame,
                        cmap="rainbow",
                        annot=True,
                        #mask=mask,
                       )
       
        plt.rcParams['font.sans-serif']='SimHei'
        plt.show()
    data=pd.DataFrame(ksi)
    ShowGRAHeatMap(data)
    
    #求关联度
    r=ksi.sum(axis=1)/ksi.columns.size
    print("关联度为:\n",r)
    #关联度排序,
    result=r.sort_values(ascending=False)
    print("关联度排序结果为:\n",result)
    

    关联系数矩阵:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 灰色关联分析

    千次阅读 2020-02-09 23:09:20
    一、灰色关联分析概述 1、它可以用来作综合评价和系统分析 对于系统分析的方法,数理统计中有回归分析、方差分析、主成分分析等,但他们有以下缺点: ...二、灰色关联分析的应用实例(进行系统分析...

    一、灰色关联分析概述

    1、它可以用来作综合评价和系统分析

       对于系统分析的方法,数理统计中有回归分析、方差分析、主成分分析等,但他们有以下缺点:

    • 要求的数据量大,例如回归
    • 要求样本服从某个典型分布
    • 可能出现量化结果与定性的结果不符合

     而灰色关联恰好解决了这些问题。

    2、灰色关联的基本思想

    根据序列几何形状的相似程度来判断其联系是否紧密

    二、灰色关联分析的应用实例(进行系统分析和综合评价)

    1、分析哪一产业对GDP总量影响最大

    年份国内生产总值第一产业第二产业第三产业
    20001988386839763
    20012061408846808
    20022335422960953
    2003275048212581010
    2004335651115771268
    2005380656118931352

    a.画出excel图,并对图作简要分析

    • 四个因素都是上升趋势
    • 第二产业相比而言上升趋势要更明显
    • 第二产业和第三产业在后三年相差更大
    • 第二产业在三个产业占比最重

    b.确定分析数列

    1. 母序列:类似于本例中的GDP
    2. 子序列:类似于本例中的第一二三产业

    c.对变量进行预处理(目的:去量纲、缩小变量范围)

    具体操作:对母序列和子序列中的每个指标求出均值,再用该指标中的每个元素除以其均值(用excel操作)

    d.建立子序列各个指标与母序列的关联系数

    找两级最小差和两级最大差

     

     

     

     

    展开全文
  • 使用python实现灰色关联分析及其可视化 在这里总结一下的数学建模常用的几种模型评估方法,这里讲的是使用python的Pandas库和高效的Numpy科学计算库实现。如果想看用Python实现的模型的灵敏度分析,可以看我上一篇...
  • 本文实例讲述了Yii2.0表关联查询的方法。分享给大家供大家参考,具体如下: 你可以使用 ActiveRecord 来进行关联查询(比如,从A表读取数据时把关联的B表数据也一起读出来), 在Active Record中,获取关联数据可以像...
  • 关联分析(Association Analysis):在大规模数据集中寻找有趣的关系。 频繁项集(Frequent Item Sets):经常出现在一块的物品的集合,即包含0个或者多个项的集合称为项集。 支持度(Support):数据集中包含该项...
  • 灰色关联分析步骤

    千次阅读 2021-03-09 18:19:22
    什么是灰色关联分析 灰色关联分析是指对一个系统发展变化态势的定量描述和比较的方法,其基本思想是通过确定参考数据列和若干个比较数据列的几何形状相似程度来判断其...灰色关联分析具体计算步骤如下: 第一步:确
  • 灰色关联分析(GRA)的理论及应用(matlab和python)

    万次阅读 多人点赞 2018-08-26 21:48:11
    什么是灰色关联分析 灰色关联分析是指对一个系统发展变化态势的定量描述和比较的方法,其基本思想是通过确定参考数据列和若干个比较数据列的几何形状相似程度来判断其联系是否紧密,它反映了曲线间的关联程度。 ...
  • 本文实例分析了js中hash和ico的一些关联。分享给大家供大家参考。具体如下: 近期测试提出一个bug,说某几个页面中的ico不显示,于是针对此问题排查原因。 首先,确保页面中的link已引入favicon.ico。经查看,发现是...
  • 本文实例讲述了Laravel5.1 框架关联模型之后操作。分享给大家供大家参考,具体如下: 之前写过关于模型关联的笔记,但是模型关联好后的一些使用没有介绍,今天补上 1 写入关联模型 1.1 使用Save方法(一对多) 我们...
  • 使用Python进行数据关联分析

    万次阅读 多人点赞 2018-03-01 14:43:21
    关联分析 选择函数包 关联分析属于数据挖掘的一大类。我发现的python语言实现的包有两个: pymining:根据Apriori算法进行关联规则挖掘 Orange3的关联规则库:根据FP-growth算法进行关联规则挖掘 ...
  • 用R实现关联分析

    2017-04-12 16:53:00
    关联分析 多年前,新的互联网销售开始在网上卖书,随着时间的推移,积累了一些关于客户购买书籍的信息。使用关联分析,可以识别一些客户有相似兴趣的书,使用用户购买信息,建立相应的推荐系统。 关联分析是发现...
  • 给出了灰关联空间分解和灰色趋势关联分析的基本概念和方法 ,总结了用灰色趋势关联度进行系统分析的一般步骤 ,通过两个具体实例研究分析了该方法的优越性和实用性.
  • Apriori算法--关联分析算法(一)

    万次阅读 多人点赞 2017-10-16 15:49:49
    在实际生产生活我们经常会遇到一些“关联分析”(Association Analyse)的任务。举几个实际例子。1.人们的购物清单里面的各个商品有没有什么关联呢?就像下面这个购物清单写的那样子,右边是各个顾客所买的东西。 有...
  • 使用Apriori算法进行关联分析

    千次阅读 2016-03-02 21:39:52
    从规模数据集中寻找物品间的隐含关系被称作关联分析或者关联规则学习。下面首先详细讨论关联分析,然后讨论Apriori原理,Apriori算法正式基于该原理得到的。接下来创建函数频繁项集高效发现的函数,然后从频繁项集中...
  • 关联规则(Association Rules)原理分析实例python实现

    万次阅读 多人点赞 2018-10-16 20:35:02
    目录   1.关联规则  ...2.常见案例  3.置信度与支持度  什么是规则?   (3) 支持度  (4) 置信度   (5) 最小支持度与频繁集  (6) 关联规则 (7) 强关联规则  (8) Apriori算法挖掘频繁项集
  • 关联分析的基本概念 关联分析(Association Analysis):在大规模数据集中寻找有趣的关系。 频繁项集(Frequent Item Sets):经常出现在一块的物品的集合,即包含0个或者多个项的集合称为项集。 支持度(Support...
  • 关联规则分析

    万次阅读 多人点赞 2017-11-27 17:11:03
    数据挖掘是指以某种方式分析数据源,从中发现一些潜在的有用的信息,所以数据挖掘又称作知识发现,而关联规则挖掘则是数据挖掘中的一个很重要的课题,顾名思义,它是从数据背后发现事物之间可能存在的关联或者联系。...
  • 数据挖掘之关联分析

    千次阅读 2015-10-04 16:33:13
    数据挖掘之关联分析 1、基本概念 (1)通常认为项在事物中出现比不出现更重要,因此项是非对称二元变量。 (2)关联规则是形如X->Y的蕴涵表达式,其中X和Y是不相交的项集,即X交Y=空。 (3)由关联规则...
  • 关联分析(一)

    千次阅读 2016-10-11 10:19:01
    关联分析是数据挖掘中很重要的一类技术,其实就是挖掘事物之间的联系。关联分析研究的关系有两种:简单关联关系和序列关联关系。简单关联关系经典的购物篮分析中有个例子说,购买面包的顾客中80%会购买牛奶。面包和...
  • 灰色关联分析法灰色关联分析“交响曲”乐谱概要演奏开始灰色关联分析的前奏灰色关联分析的高潮灰色关联分析的尾声参考函数代码参考文献 灰色关联分析“交响曲” 乐谱概要 1、确定比较对象(评价对象)和参考数列; 2...
  • 文章目录1 什么是灰色关联分析2 灰色关联分析的步骤3 灰色关联分析实例4 灰色关联分析matlab的实现5 灰色关联分析python的实现 1 什么是灰色关联分析 灰色关联分析是指对一个系统发展变化态势的定量描述和比较的...
  • R语言关联分析之啤酒和尿布

    千次阅读 2018-01-12 16:58:17
    关联分析 概述 啤酒和尿布的故事,我估计大家都听过,这是数据挖掘里面最经典的案例之一。它分析的方法就关联分析关联分析,顾名思义,就是研究不同商品之前的关系。这里就发现了啤酒和尿布这两个看起来...
  • 本文实例讲述了CakePHP框架Model关联对象。分享给大家供大家参考,具体如下: CakePHP 提供关联数据表间的映射,共有4种类型的关联: hasOne,hasMany,belongTo,hasAndBelongsToMany. 设定了Model间的关联关系定义,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,974
精华内容 66,389
关键字:

关联分析具体案例