机器学习实战（Machine Learning in Action）学习笔记———

机器学习实战（Machine Learning in Action）学习笔记————07.使用Apriori算法进行关联分析

关键字：Apriori、关联规则挖掘、频繁项集
作者：米仓山下
时间：2018-11-2
机器学习实战（Machine Learning in Action,@author: Peter Harrington）
源码下载地址：https://www.manning.com/books/machine-learning-in-action
git@github.com:pbharrin/machinelearninginaction.git

*************************************************************
一、Apriori算法——生成频繁项集

Apriori算法原理：
原理：如果某个项集是频繁的，那么它所有的子集也是频繁的。反过来，如果一个项集是非频繁集，那么他所有的超集也是非频繁的
--------------------------------------------------------------
#创建测试数据集，包含四个列表的列表：[[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
loadDataSet()
#根据测试数据集生成第一个频繁项集，频繁项为单个
createC1(dataSet)
#根据给定的频繁项集Ck，支持度minSupport，计算在数据集D中Ck各频繁项的支持度，并返回支持度大于minSupport的频繁项（数组），及所有频繁项的支持度（频繁项为key，支持度为value的字典）
scanD(D, Ck, minSupport)
--------------------------------------------------------------
#根据给定频繁项集生成下Lk，通过集合并集运算，得到频繁项集Lk+1。

def aprioriGen(Lk, k): #creates CkretList = []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: #if first k-2 elements are equalretList.append(Lk[i] | Lk[j]) #set unionreturn retList

#注：这里强调一下为什么只比较前k-2元素，书中强调的原因是可以减少循环次数，但并没有进一步解释这样做的逻辑。示例数据中，两项的频繁项集为[{2,3}, {3,5}, {2,5}, {1,3}]，所有两两并集为[{2,3,5},{1,3,5}]。但是如果仅比较前k-2个元素相同的进行合并为[{2,3,5}]，之所以没有{1,3,5}是因为{1,5}不存在，即它不是频繁项集，按照Apriori的原理“某个子项集不是频繁的，那么它的超集也不是频繁的”。因此比较前k-2个元素既可以减少循环次数又不会漏掉频繁项。

--------------------------------------------------------------
#不断扫描数据集，由单元素频繁项不断合并，并求解它们的支持度，记录下符合条件的频繁项，以及频繁项的支持度

def apriori(dataSet, minSupport = 0.5):C1 = createC1(dataSet)                     #生成单元素频繁项集D = map(set, dataSet)L1, supportData = scanD(D, C1, minSupport) #计算单元素频繁项集的支持度，并筛选L = [L1]k = 2while (len(L[k-2]) > 0):                   #当最加入新频繁项集长度大于零Ck = aprioriGen(L[k-2], k)             #合并频繁项集形成新的候选集Lk, supK = scanD(D, Ck, minSupport)    #计算候选集的支持度，并筛选supportData.update(supK)               #更新存储频繁项支持度的词典L.append(Lk)                           #将最新得到的频繁项加入列表中k += 1return L, supportData

--------------------------------------------------------------
测试：

>>> import apriori
>>> data=apriori.loadDataSet()
>>> data
[[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
>>> L,supportData=apriori.apriori(data)
>>> L
[[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]
>>> supportData
{frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([1, 2]): 0.25, frozenset([1, 5]): 0.25, frozenset([3, 5]): 0.5, frozenset([4]): 0.25, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
>>>

*************************************************************
二、Apriori算法——从频繁项集中挖掘关联规则

置信度：
　　置信度(confidence)揭示了A出现时B是否一定出现，如果出现，则出现的概率是多大。如果A->B的置信度是100%，则说明A出现时B一定会出现（返回来不一定）。用公式表示是，物品A->B的置信度=物品{A,B}的支持度 / 物品{A}的支持度：（A称为前件，B称为后件）
Confidence(A->B) = support({A,B}) / support({A}) = P(B|A)

如果某条规则不满足最小可信度要求，那么该规则的所有子集也不会满足最小置信度要求。假设{0,1,2}->{3}不满足最小可信度的要求。那么任何{0,1,2}的子集也不会满足最小可信度的要求。可以利用该性质来减少需要测试的规则数目。

--------------------------------------------------------------
#规则生成函数

def generateRules(L, supportData, minConf=0.7):  #supportData is a dict coming from scanDbigRuleList = []           #存储关联规则的列表for i in range(1, len(L)): #取出两个或更多元素的频繁项集，L[0]为单元素频繁项集，遍历for freqSet in L[i]:   #遍历频繁项集L[i]中的频繁项H1 = [frozenset([item]) for item in freqSet]  #某个频繁项中的元素列表if (i > 1):        #元素大于两个的频繁项，将频繁项中的元素进行组合成后件（规则）
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)else:              #i=1，两个元素的频繁项
                calcConf(freqSet, H1, supportData, bigRuleList, minConf)return bigRuleList

--------------------------------------------------------------
#计算可信度
#输入：freqSet——频繁项, H——频繁项元素列表, supportData——频繁项支持度列表, brl——存储关联规则的列表, minConf——最小可信度
#输出：brl——频繁项freqSet中存在的关联规则，prunedH——返回关联规则中的后件列表

def calcConf(freqSet, H, supportData, brl, minConf=0.7):prunedH = []     #关联规则中的后件列表for conseq in H: #遍历频繁项中的元素，conseq为元素conf = supportData[freqSet]/supportData[freqSet-conseq] #可信度(freq-conseq)->conseqif conf >= minConf:                                     #可信度>minConfprint freqSet-conseq,'-->',conseq,'conf:',conf      #打印关联规则及可信度brl.append((freqSet-conseq, conseq, conf))          #保存关联规则及可信度prunedH.append(conseq)    #保存后件（规则），为后面准备。注：不满足规则的后件，在该元素基础下添加也不会满足return prunedH

--------------------------------------------------------------
#最初的规则生成更多的规则
#输入：freqSet——频繁项, H——频繁项元素列表；输出：brl——频繁项freqSet中存在的关联规则

def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):m = len(H[0])if (len(freqSet) > (m + 1)):     #频繁项元素数目>后件（候选规则）的元素数，一直执行。例如{1，2，3，4}当{1}-{2,3,4}以后此时H[0]长度为3Hmp1 = aprioriGen(H, m+1)    #合并候选后件（规则），由Hm生成Hm+1。注：不满足规则的后件，在该元素基础下添加也不会满足Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)  #返回规则后件（规则）列表if (len(Hmp1) > 1):          #返回后件（规则）列表包含1个以上后件（规则），递归进一步组合这些规则rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)

--------------------------------------------------------------
测试：

>>> reload(apriori)
<module 'apriori' from 'apriori.py'>
>>> L, supportData=apriori.apriori(data)
>>> L
[[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]
>>> supportData
{frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([1, 2]): 0.25, frozenset([1, 5]): 0.25, frozenset([3, 5]): 0.5, frozenset([4]): 0.25, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
>>> rules=generateRules(L, supportData, minConf=0.6)
frozenset([3]) --> frozenset([1]) conf: 0.666666666667
frozenset([1]) --> frozenset([3]) conf: 1.0
frozenset([5]) --> frozenset([2]) conf: 1.0
frozenset([2]) --> frozenset([5]) conf: 1.0
frozenset([3]) --> frozenset([2]) conf: 0.666666666667
frozenset([2]) --> frozenset([3]) conf: 0.666666666667
frozenset([5]) --> frozenset([3]) conf: 0.666666666667
frozenset([3]) --> frozenset([5]) conf: 0.666666666667
frozenset([5]) --> frozenset([2, 3]) conf: 0.666666666667
frozenset([3]) --> frozenset([2, 5]) conf: 0.666666666667
frozenset([2]) --> frozenset([3, 5]) conf: 0.666666666667
>>>
>>> rules=generateRules(L, supportData, minConf=0.7)
frozenset([1]) --> frozenset([3]) conf: 1.0 #出现1集合中一定出现了3
frozenset([5]) --> frozenset([2]) conf: 1.0 #出现5集合中一定出现了2
frozenset([2]) --> frozenset([5]) conf: 1.0 #出现2集合中一定出现了5
>>>
>>> rules
[(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
>>>

*************************************************************
三、示例：发现毒蘑菇的相似特征
数据集：mushroom.dat
说明：mushroom数据集是关于肋形蘑菇的23种特征的数据集，每个特征都包含一个标称数据值。
mushroom.dat前几列数据为：
1 3 9 13 23 25 34 36 38 40 52 54 59 63 67 76 85 86 90 93 98 107 113
2 3 9 14 23 26 34 36 39 40 52 55 59 63 67 76 85 86 90 93 99 108 114
2 4 9 15 23 27 34 36 39 41 52 55 59 63 67 76 85 86 90 93 99 108 115
第一个特征表示有毒(2)或则可食用(1),下一特征为蘑菇伞的形状，六种可能的值3-8表示。

#将数据读取转换为集合
>>> mushDataSet=[line.split() for line in open('mushroom.dat').readlines()]
>>> mushDataSet[0]
['1', '3', '9', '13', '23', '25', '34', '36', '38', '40', '52', '54', '59', '63', '67', '76', '85', '86', '90', '93', '98', '107', '113']
>>> len(mushDataSet)
8124#生成频繁项集
>>> L, supportData=apriori.apriori(mushDataSet,minSupport = 0.3)
>>> len(L)
10
>>> L[9]
[]
>>> L[8]
[frozenset(['39', '59', '23', '36', '34', '2', '93', '86', '85']), frozenset(['39', '59', '23', '36', '34', '90', '93', '86', '85']), frozenset(['59', '23', '36', '34', '63', '90', '93', '86', '85']), frozenset(['39', '59', '23', '36', '34', '63', '2', '86', '85'])]
>>>#所有特征的标称性数值并不重复，打印长度为8的所有有毒(2)的频繁项
>>> for item in L[7]:
...   if item.intersection('2'):print item
...
frozenset(['39', '59', '23', '36', '34', '2', '93', '85'])
frozenset(['39', '59', '36', '34', '63', '2', '86', '85'])
frozenset(['39', '59', '23', '34', '63', '2', '86', '85'])
frozenset(['39', '59', '36', '34', '2', '93', '86', '85'])
frozenset(['39', '59', '23', '36', '34', '2', '93', '86'])
frozenset(['39', '59', '23', '36', '2', '93', '86', '85'])
frozenset(['59', '23', '34', '2', '90', '93', '86', '85'])
frozenset(['39', '28', '53', '34', '2', '90', '86', '85'])
frozenset(['59', '23', '36', '34', '63', '2', '86', '85'])
frozenset(['59', '23', '36', '34', '2', '93', '86', '85'])
frozenset(['39', '59', '23', '36', '34', '2', '86', '85'])
frozenset(['39', '59', '23', '36', '34', '63', '2', '86'])
frozenset(['59', '36', '34', '2', '90', '93', '86', '85'])
frozenset(['39', '23', '36', '34', '2', '93', '86', '85'])
frozenset(['39', '59', '23', '36', '63', '2', '86', '85'])
frozenset(['39', '59', '23', '34', '2', '93', '86', '85'])
frozenset(['39', '59', '23', '36', '34', '63', '2', '85'])
frozenset(['39', '23', '36', '34', '63', '2', '86', '85'])
>>>

#这样就可以看到有哪些特征的蘑菇大概率是毒蘑菇。但：并不表示没有这些特诊的蘑菇就没有毒

*************************************************************
四、总结
关联分析用于发现大规模数据集中元素间有趣关系。通过两种两种方式量化这些有趣关系：第一种是使用频繁项集，给出经常一起出现的元素项；第二种是关联规则，每条关联规则意味着元素之间“如果……那么”的关系。

减少扫描频繁项统计扫描次数的方法就是Apriori。Apriori原理是说如果一个元素项是不频繁的那么包含该元素的超集也是不频繁的。Apriori算法从单元素项集合开始，通过组合满足最小支持度要求的项集来形成更大的集合。支持度用来度量一个集合在原始数据中出现的频率。

原始数据中每条数据是集合，但并不要求每条数据具有相同的长度

缺点：每次增加频繁项集的大小，Apriori算法都会扫描整个数据集。数据集很大时会降低频繁项集发现的速度。相比，12章中FPgrowth算法只需要对数据库进行两次扫描，能够显著加快频繁项集发现速度

参考文献：
https://blog.csdn.net/wanghao109/article/details/39452303
https://www.cnblogs.com/bigmonkey/p/7405555.html
https://blog.csdn.net/zllnau66/article/details/81534368

转载于:https://www.cnblogs.com/Micang/p/9900850.html

机器学习实战（Machine Learning in Action）学习笔记————07.使用Apriori算法进行关联分析...相关推荐

决策树（chap3）Machine Learning In Action学习笔记
优点:计算复杂度不高,输出结果易于理解,对中间值的缺失不敏感,可以处理不相关特征数据. 缺点:可能会产生过度匹配问题. 适用数据类型:数值型(必须离散化)和标称型. 决策树创建分支的伪代码函数crea ...
大数据学习笔记之三十七数据挖掘算法之关联分析
数据挖掘中算法分为三种:关联分析.聚类分析和预测模型,本篇主要是为了介绍关联分析相关的知识
Machine Learning in Action 读书笔记---第5章 Logistic回归
Machine Learning in Action 读书笔记第5章 Logistic回归文章目录 Machine Learning in Action 读书笔记一.Logistic回归 1.L ...
Machine Learning in Action 读书笔记---第3章决策树
Machine Learning in Action 读书笔记第3章决策树文章目录 Machine Learning in Action 读书笔记一.决策树算法简介 1 决策树的构造 2 决策 ...
Machine Learning in Action 读书笔记---第4章基于概率论的分类方法：朴素贝叶斯
Machine Learning in Action 读书笔记第4章基于概率论的分类方法:朴素贝叶斯文章目录 Machine Learning in Action 读书笔记一.基于贝叶斯决策理 ...
Machine Learning in Action 读书笔记---第8章预测数值型数据：回归
Machine Learning in Action 读书笔记第8章预测数值型数据:回归文章目录 Machine Learning in Action 读书笔记一.回归 1.回归的一般过程 2 ...
机器学习实战---读书笔记：第11章使用Apriori算法进行关联分析---2---从频繁项集中挖掘关联规则
#!/usr/bin/env python # encoding: utf-8''' <<机器学习实战>> 读书笔记第11章使用Apriori算法进行关联分析---从频繁项 ...
【机器学习】Apriori 算法进行关联分析和FP-growth算法
[机器学习]Apriori 算法进行关联分析和FP-growth算法文章目录 1 关联分析 2 FP-growth算法理解和实现 3 FP增长算法的频繁项集产生 4 FP-Growth关联分析算法在 ...
机器学习（Machine Learning）——深度学习(Deep Learning)
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/abcjennifer/article/ ...
《机器学习实战》之十一——使用Apriori算法进行关联分析
Apriori算法目录一.前言二.关联分析三.Apriori原理四.利用Apriori算法来发现频繁集 1.Apriori算法及实例描述 2.生成候选项集 2.组织完整的Apriori算法五 ...

机器学习实战（Machine Learning in Action）学习笔记————07.使用Apriori算法进行关联分析...

机器学习实战（Machine Learning in Action）学习笔记————07.使用Apriori算法进行关联分析...相关推荐

最新文章

热门文章