文章目录
引言一、一些概念1.关联规则的一般形式2.最小支持度和最小置信度3.项集4.支持度计数二、Apriori算法：使用候选产生频繁项集1.Apriori的性质2.Apriori算法实现过程3.Apriori算法实现过程实例三、Apriori算法—python实现四、Apriori算法实现—有剪枝步五、封装好的apriori算法的调用第三章节是Apriori算法实现的阉割版(没有剪枝步)第四章节是完整版第五章节是直接调用封装好的apriori算法想了解第四部分完整背景的可以参考这个网址引言
关联规则分析是数据挖掘中最活跃的研究方法之一，目的是在一个数据集中找到各项之间的关联关系，而这种关系并没有在数据中直接体现出来。以超市的销售数据为例，当存在很多商品时，可能的商品组合数量达到了令人望而却步的程度，这是提取关联规则的最大困难。因此各种关联规则分析算法从不同方面入手减少可能的搜索空间大小以及减少扫描数据的次数。Apriori算法是最经典的挖掘频繁项集的算法，第一次实现在大数据集上的可行的关联规则提取，其核心思想是通过连接产生候选项及其支持度，然后通过剪枝生成频繁项集。
一、一些概念
1.关联规则的一般形式
关联规则的支持度(相对支持度)项集A、B同时发生的概率称为关联规则的支持度(相对支持度)。Support(A=>B)=P(A∪B)Support(A=>B)=P(A∪B)Support(A=>B)=P(A∪B)关联规则的置信度
项集A发生，则项集B发生的概率为关联规则的置信度。Confidence(A=>B)=P(B∣A)Confidence(A=>B)=P(B|A)Confidence(A=>B)=P(B∣A)
2.最小支持度和最小置信度
最小支持度是衡量支持度的一个阈值，表示项目集在统计意义上的最低重要性最小置信度是衡量置信度的一个阈值，表示关联规则的最低可靠性强规则是同时满足最小支持度阈值和最小置信度阈值的规则3.项集
项集是项的集合。包含kkk个项的集合称为kkk项集，如集合{牛奶，麦片，糖}是一个三项集项集出现的频率是所有包含项集的事务计数，又称为绝对支持度或支持度计数如果项集III的相对支持度满足预定义的最小支持度阈值，则III是频繁项集。如果有kkk项，记为LkL_kLk4.支持度计数
项集A的支持度计数是事务数据集中包含项集A的事务个数，简称项集的频率或计数一旦得到项集A、B和A∪BA、B和A∪BA、B和A∪B的支持度计数以及所有事务个数，就可以导出对应的关联规则A=>BA=>BA=>B和B=>AB=>AB=>A，并可以检查该规则是否为强规则。其中NNN表示总事务个数，σσσ表示计数
二、Apriori算法：使用候选产生频繁项集
Apriori算法的主要思想是找出存在于事务数据集中最大的频繁项集，再利用得到的最大频繁项集与预先设定的最小置信度阈值生成强关联规则。
1.Apriori的性质
频繁项集的所有非空子集一定是频繁项集。根据这一性质可以得出：向不是频繁项集III的项集中添加事务AAA，新的项集I∪AI∪AI∪A一定不是频繁项集。
2.Apriori算法实现过程
第一步：
找出所有频繁项集（支持度必须大于等于给定的最小支持度阈值），在这个过程中连接步与剪枝步相互融合，最终得到最大频繁项集LkL_kLk
连接步
连接步的目的是找到KKK项集。对于给定的最小支持度阈值，分别对1项候选集C1C_1C1，剔除小于该阈值的项集得到1项频繁集L1L_1L1;下一步由L1L_1L1自身连接产生2项候选集C2C_2C2，剔除小于该阈值的项集得到2项频繁集L2L_2L2；再下一步由L2和L1L_2和L_1L2和L1连接产生3项候选集C3C_3C3，剔除小于该阈值的项集得到3项频繁集L3L_3L3，这样循环下去，直至由Lk−1和L1L_{k-1}和L_1Lk−1和L1连接产生kkk项候选集CkC_kCk，剔除小于该阈值的项集得到最大频繁集LkL_kLk剪枝步
剪枝步紧接着连接步，在产生候选项CkC_kCk的过程中起到了减小搜索空间的目的。根据Apriori的性质：频繁项集的所有非空子集也必须是频繁项集，所以不满足该性质的项集将不会存在于CkC_kCk中，该过程就是剪枝
第二步：
由频繁项集产生强关联规则。由第一步可知，未超过预定的最小支持阈值的项集已被剔除，如果剩下的这些项集又满足了预定的最小置信度阈值，那么就挖掘出了强关联规则。
3.Apriori算法实现过程实例
以餐饮行业点餐数据为例，首先先将事务数据整理成关联规则模型所需的数据结构。设最小支持度为0.2，将菜品id编号
三、Apriori算法—python实现
数据集链接
import numpy as npimport pandas as pddef 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 rdef 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 = 0while len(column) > 1:k = k + 1print(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.0result[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 resultif __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)# 删除中间变脸bdel bsupport = 0.2 # 最小支持度confidence = 0.5 # 最小置信度find_rule(data, support, confidence)
转换原数据到0-1矩阵正在进行第1次搜索...数目：6...正在进行第2次搜索...数目：3...正在进行第3次搜索...数目：0...结果为：support confidencee-a 0.3 1.000000e-c 0.3 1.000000c-e-a0.3 1.000000a-e-c0.3 1.000000c-a 0.5 0.714286a-c 0.5 0.714286a-b 0.5 0.714286c-b 0.5 0.714286b-a 0.5 0.625000b-c 0.5 0.625000a-c-e0.3 0.600000b-c-a0.3 0.600000a-c-b0.3 0.600000a-b-c0.3 0.600000
其中，'e—a’表示e发生能够推出a发生，置信度为100%，支持度30%。搜索出的关联规则并不一定有实际意义，需要根据问题背景筛选适当的有意义的规则，并赋予合理的解释。
四、Apriori算法实现—有剪枝步
案例数据百度网盘链接-提取码：1234
import numpy as npimport pandas as pd# 测试数据集，用于debugdef 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_translationdef 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，否则返回Falseif j.issubset(i):# 再判断之前有没有统计过，没有统计过的话为1if j not in dict_sup:dict_sup[j] = 1else: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, supportDatadef 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 = 0for w in b:# 如果为True，说明是属于候选集，否则不属于候选集if w in Lk:t += 1# 如果它的子集都为频繁集，则a1是候选集if len(b) == t:reList.append(b[0] | b[1])return reListdef 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] = 1else:sscnt[can] += 1# 计算支持度numItem = len(D) # 事务总数reList = [] # 存储k项频繁集supportData = {} # 存储频繁集对应支持度for key in sscnt:support = sscnt[key] / numItemif support > minSupport:reList.insert(0, key) # 满足条件的加入Lk中supportData[key] = supportreturn reList, supportDatadef 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项候选集CkCk = aprioriGen(L[k - 2], k)# 计算候选k项集的支持度，剔除小于最小支持度的候选集，得到频繁k项集及其支持度Lk, supK = scanD(D, Ck, minSupport)# 将supK中的键值对添加到supportDatasupportData.update(supK)# 将第k项的频繁集添加到L中L.append(Lk) # L的最后一个值为空值k += 1del L[-1]# 返回频繁集及其对应的支持度；L为频繁项集，是一个列表，1,2，3项集分别为一个元素return L, supportDatadef 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 bigRuleListif __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.44216frozenset({'人造黄油'}) --> frozenset({'全脂牛奶'}) 支持度 0.024199 置信度： 0.413194 lift值为： 1.617098frozenset({'仁果类水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.030097 置信度： 0.397849 lift值为： 1.557043frozenset({'牛肉'}) --> frozenset({'全脂牛奶'}) 支持度 0.021251 置信度： 0.405039 lift值为： 1.58518frozenset({'冷冻蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.020437 置信度： 0.424947 lift值为： 1.663094frozenset({'本地蛋类'}) --> frozenset({'其他蔬菜'}) 支持度 0.022267 置信度： 0.350962 lift值为： 1.813824frozenset({'黄油'}) --> frozenset({'其他蔬菜'}) 支持度 0.01 置信度： 0.361468 lift值为： 1.868122frozenset({'本地蛋类'}) --> frozenset({'全脂牛奶'}) 支持度 0.029995 置信度： 0.472756 lift值为： 1.850203frozenset({'黑面包'}) --> frozenset({'全脂牛奶'}) 支持度 0.025216 置信度： 0.388715 lift值为： 1.521293frozenset({'糕点'}) --> frozenset({'全脂牛奶'}) 支持度 0.033249 置信度： 0.373714 lift值为： 1.462587frozenset({'酸奶油'}) --> frozenset({'其他蔬菜'}) 支持度 0.028876 置信度： 0.402837 lift值为： 2.081924frozenset({'猪肉'}) --> frozenset({'其他蔬菜'}) 支持度 0.021657 置信度： 0.375661 lift值为： 1.941476frozenset({'酸奶油'}) --> frozenset({'全脂牛奶'}) 支持度 0.032232 置信度： 0.449645 lift值为： 1.759754frozenset({'猪肉'}) --> frozenset({'全脂牛奶'}) 支持度 0.022166 置信度： 0.38448 lift值为： 1.504719frozenset({'根茎类蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.048907 置信度： 0.448694 lift值为： 1.756031frozenset({'根茎类蔬菜'}) --> frozenset({'其他蔬菜'}) 支持度 0.047382 置信度： 0.434701 lift值为： 2.246605frozenset({'凝乳'}) --> frozenset({'全脂牛奶'}) 支持度 0.026131 置信度： 0.490458 lift值为： 1.919481frozenset({'热带水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.042298 置信度： 0.403101 lift值为： 1.577595frozenset({'柑橘类水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.030503 置信度： 0.36855 lift值为： 1.442377frozenset({'黄油'}) --> frozenset({'全脂牛奶'}) 支持度 0.027555 置信度： 0.497248 lift值为： 1.946053frozenset({'酸奶'}) --> frozenset({'全脂牛奶'}) 支持度 0.056024 置信度： 0.401603 lift值为： 1.571735frozenset({'其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.074835 置信度： 0.386758 lift值为： 1.513634frozenset({'全脂牛奶', '酸奶'}) --> frozenset({'其他蔬菜'}) 支持度 0.022267 置信度： 0.397459 lift值为： 2.054131frozenset({'酸奶', '其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.022267 置信度： 0.512881 lift值为： 2.007235frozenset({'全脂牛奶', '根茎类蔬菜'}) --> frozenset({'其他蔬菜'}) 支持度 0.023183 置信度： 0.474012 lift值为： 2.44977frozenset({'根茎类蔬菜', '其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.023183 置信度： 0.48927 lift值为： 1.914833
五、封装好的apriori算法的调用
Frequent Itemsets via Apriori Algorithm案例数据百度网盘链接-提取码：1234import numpy as npimport pandas as pdimport xlrdfrom mlxtend.frequent_patterns import apriori # 生成频繁项集from mlxtend.frequent_patterns import association_rules # 生成强关联规则import warningswarnings.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_translationif __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 itemsets0 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 conviction0 (黑面包)(全脂牛奶) ... 0.008641 1.2178991 (猪肉)(全脂牛奶) ... 0.007435 1.2095202 (猪肉)(其他蔬菜) ... 0.010502 1.2917793 (牛肉)(全脂牛奶) ... 0.007845 1.2513154 (根茎类蔬菜)(全脂牛奶) ... 0.021056 1.3504015 (根茎类蔬菜)(其他蔬菜) ... 0.026291 1.4266936 (水果/蔬菜汁)(全脂牛奶) ... 0.008168 1.1789047(其他蔬菜)(全脂牛奶) ... 0.025394 1.2140138(人造黄油)(全脂牛奶) ... 0.009235 1.2687069 (凝乳)(全脂牛奶) ... 0.012517 1.46108510 (黄油)(全脂牛奶) ... 0.013395 1.48081711 (柑橘类水果)(全脂牛奶) ... 0.009355 1.17900812 (冷冻蔬菜)(全脂牛奶) ... 0.008149 1.29463613 (热带水果)(全脂牛奶) ... 0.015486 1.24725214(酸奶油)(全脂牛奶) ... 0.013916 1.35273515 (本地蛋类)(全脂牛奶) ... 0.013783 1.41203016 (酸奶)(全脂牛奶) ... 0.020379 1.24413217 (糕点)(全脂牛奶) ... 0.010516 1.18872918 (仁果类水果)(全脂牛奶) ... 0.010767 1.23637519 (黄油)(其他蔬菜) ... 0.009308 1.26306520(酸奶油)(其他蔬菜) ... 0.015006 1.35056521 (本地蛋类)(其他蔬菜) ... 0.009991 1.24261922 (根茎类蔬菜, 全脂牛奶)(其他蔬菜) ... 0.013719 1.5333 (根茎类蔬菜, 其他蔬菜)(全脂牛奶) ... 0.011076 1.45768724(全脂牛奶, 酸奶)(其他蔬菜) ... 0.011427 1.33851125(酸奶, 其他蔬菜)(全脂牛奶) ... 0.011174 1.528340[26 rows x 9 columns]
参考于《python数据分析与挖掘实战》，后面有时间的话，会基于《机器学习实战》学习一下FP-Tree关联规则分析
如果对您有帮助，麻烦点赞关注，这真的对我很重要！！！如果需要互关，请评论留言！
如果觉得《机器学习—关联规则分析之Apriori算法及其python实现》对你有帮助，请点赞、收藏，并留下你的观点哦！
