机器学习—关联规则分析之Apriori算法及其python实现

文章目录

- - 引言
  - 一、一些概念
  - - 1.关联规则的一般形式
    - 2.最小支持度和最小置信度
    - 3.项集
    - 4.支持度计数
  - 二、Apriori算法：使用候选产生频繁项集
  - - 的性质
    - 算法实现过程
    - 算法实现过程实例
  - 三、Apriori算法—python实现
  - 四、Apriori算法实现—有剪枝步
  - 五、封装好的apriori算法的调用

第三章节是Apriori算法实现的阉割版(没有剪枝步)
第四章节是完整版
第五章节是直接调用封装好的apriori算法
想了解第四部分完整背景的可以参考这个网址

引言

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

一、一些概念

1.关联规则的一般形式

关联规则的支持度(相对支持度)
项集A、B同时发生的概率称为关联规则的支持度(相对支持度)。 $S u p p o r t (A = > B) = P (A \cup B)$
关联规则的置信度
项集A发生，则项集B发生的概率为关联规则的置信度。 $C o n f i d e n c e (A = > B) = P (B ∣ A)$

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

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

3.项集

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

4.支持度计数

项集A的支持度计数是事务数据集中包含项集A的事务个数，简称项集的频率或计数
一旦得到项集 $A 、 B 和 A \cup B$ 的支持度计数以及所有事务个数，就可以导出对应的关联规则 $A = > B$ 和 $B = > A$ ，并可以检查该规则是否为强规则。

其中 $N$ 表示总事务个数， $σ$ 表示计数

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

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

的性质

频繁项集的所有非空子集一定是频繁项集。根据这一性质可以得出：向不是频繁项集 $I$ 的项集中添加事务 $A$ ，新的项集 $I \cup A$ 一定不是频繁项集。

算法实现过程

第一步：
找出所有频繁项集（支持度必须大于等于给定的最小支持度阈值），在这个过程中连接步与剪枝步相互融合，最终得到最大频繁项集 $L_k$

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

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

算法实现过程实例

以餐饮行业点餐数据为例，首先先将事务数据整理成关联规则模型所需的数据结构。设最小支持度为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/', 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算法的调用

Frequent Itemsets via Apriori Algorithm
案例数据百度网盘链接-提取码：1234

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/', 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('')

      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关联规则分析

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

秒客网