summary:
- 关联分析是用于发现大数据集中元素间有趣关系的一个工具集，可以采用两种方式来量化这些有趣的关系。第一种方式是频繁项集，它会给出经常出现在一起的元素项；第二种方式是关联规则，每条关联规则意味着元素项之间“如果……那么”的关系。
- 发现元素项间不同的组合是个十分耗时的任务，不可避免需要大量昂贵的计算资源，这就需要更智能的方法在合理时间范围内找到频繁项集。
- 使用Apriori原理可以减少在数据库上进行检查的集合的数目。Apriori算法从单元素项集开始，通过组合满足最小支持度要求的项集来形成更大的集合。
- 缺点：每次增加频繁集的大学，Apriori算法都会重新扫描整个数据集。
- 准备数据：标称型或数值型数据类型都可以，因为我们只保存集合。
from numpy import *
def loadDataSet():
return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
dataSet=loadDataSet()
dataSet
def createC1(dataSet): #生成只包含一个元素的项集的集合C1
C1 = []
for transaction in dataSet:
for item in transaction:
if not [item] in C1:
C1.append([item])
C1.sort()
return map(frozenset, C1)#use frozen set so we
#can use it as a key in a dict
C1=createC1(dataSet)
C1
D=map(set,dataSet)
D
#计算Ck的项集的在数据集D中的支持度support,并检查数据确保每个项集都是频繁的
def scanD(D, Ck, minSupport):
"""
D:Lst[frozenset]
Ck:Lst[frozenset]
minSupport:int
"""
ssCnt = {} #统计Ck中的项在D中的项中出现的次数
for tid in D:
for can in Ck:
if can.issubset(tid): #如果can是tid的子集
ssCnt[can]=ssCnt.get(can,0)+1
# if can.issubset(tid):
# if not ssCnt.has_key(can): ssCnt[can]=1
# else: ssCnt[can] += 1
numItems = float(len(D)) #D中共有多少条记录
retList = []
supportData = {}
for key in ssCnt:
support = ssCnt[key]/numItems #计算支持度：数据集中包含该项集的记录所占的比例
if support >= minSupport:
retList.append(key)
# retList.insert(0,key)
supportData[key] = support
return retList, supportData
L1,suppData0=scanD(D,C1,0.5)
print(L1)
print(suppData0)
def aprioriGen(Lk, k): #creates Ck：这里k表示一个项集中包含几个元素
"""
Lk: List(frozenset)
"""
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: #if first k-2 elements are equal
retList.append(Lk[i] | Lk[j]) #set union
"""
判断Lk集合的前k-2个元素相同，然后将Lk[i],Lk[j]合并
这就能保证后面生成的L(k+1)集合中的项集中的元素个数为k+1
这里k-2用于定位，举个栗子，当k=3，Lk=[{1,2},{1,3},{1,5},{2,3},{2,5},{3,5}]
此时就判断Lk[i][1]和Lk[][1]即项集的第1个元素是否相等来决定是否将它们合并
从而retList=[{1,2,3},{1,3,5},{1,2,5},{2,3,5}]
若k=4，就判断Lk[i]和Lk[j]的前2个元素是否相等，
Lk是输入，所有项集的元素都是k-1个
因为我们要生成含有k个元素的所有项集的集合retList
所以需要前k-2个元素相等，最后一个元素不相等，这样合并起来刚好有k个元素
"""
return retList
def apriori(dataSet, minSupport = 0.5):
C1 = createC1(dataSet)
D = map(set, dataSet)
L1, supportData = scanD(D, C1, minSupport)
L = [L1]
k = 2
#下面利用L(k-1)来构建L(k),并添加新支持度字典数据
while (len(L[k-2]) > 0): #当集合中项的个数大于0时
Ck = aprioriGen(L[k-2], k) #构建一个k个项组成的候选项集的列表
Lk, supK = scanD(D, Ck, minSupport)#scan DB to get Lk
supportData.update(supK) #将生成的新的支持度的字典添加进原来的包含支持度的字典中
L.append(Lk) #
k += 1 #k用于定位到相应的L的位置上，即当计算L2时定位到L[0],因为L[0]表示的是L1
return L, supportData
L,suppData=apriori(dataSet,minSupport = 0.5)
print(L)
print(suppData)
aprioriGen(L[0], 2)
L,suppData=apriori(dataSet,minSupport=0.7)
print(L)
print(suppData)
def generateRules(L, supportData, minConf=0.7): #supportData is a dict coming from scanD
bigRuleList = []
for i in range(1, len(L)):#only get the sets with two or more items
i=2
for freqSet in L[i]:
H = [frozenset([item]) for item in freqSet]
if (i > 1):
rulesFromConseq(freqSet, H, supportData, bigRuleList, minConf)
"""
当项集中的元素个数大于2时，调用rulesFromConseq
rulesFromConseq：
调用aprioriGen来生成conseq，便于生成不重复的关联规则
根据关联规则调用calcConf计算conf
"""
else:
calcConf(freqSet, H, supportData, bigRuleList, minConf)
"""
当项集中的元素个数等于2时，调用calcConf(筛选大于minconf的项集)
"""
return bigRuleList
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
prunedH = [] #create new list to return
for conseq in H:
conf = supportData[freqSet]/supportData[freqSet-conseq] #calc confidence
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)): #try further merging
Hmp1 = aprioriGen(H, m+1)#create Hm+1 new candidates
Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
if (len(Hmp1) > 1): #need at least two sets to merge
#再对大于1个元素的频繁项集再细分计算关联规则
rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
def pntRules(ruleList, itemMeaning):
for ruleTup in ruleList:
for item in ruleTup[0]:
print itemMeaning[item]
print " -------->"
for item in ruleTup[1]:
print itemMeaning[item]
print "confidence: %f" % ruleTup[2]
print #print a blank line
L,suppData=apriori(dataSet,minSupport = 0.5)
rules=generateRules(L,suppData,minConf=0.7)
算法介绍
算法利用Apriori原理，第1步，得到频繁集（计算支持度）；第2步，从频繁集中挖掘关联规则（计算可信度）。
- 支持度support：数据集中包含该项集的记录占总记录的比例，即用于度量一个集合在原始数据种出现的频率
- 可信度confidence：一条规则P→H的可信度的计算公式为 support({P,H})/support({P})
- 频繁集frequent item sets：是指经常出现在一块的物品的集合
- 关联规则association rules：是指两个物品间可能存在很强的关系
Apriori原理是指，一个项集是频繁的，那么这个项集的子集也是频繁的；反过来，一个项集是非频繁的，那么包含这个项集的超级也是非频繁的。利用Apriori原理可以减少在数据库上进行检查的集合的数目。
应用于购物（比如关联分析中著名的例子是啤酒与尿布，说的是美国中西部的一家连锁店发现，男人们会在周四购买尿布和啤酒），还可以应用于搜索引擎中的查询词之间的关联规则。
示例：发现毒蘑菇的相似特征
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
1 3 10 15 23 25 34 36 38 41 52 54 59 63 67 76 85 86 90 93 98 107 113
2 3 9 16 24 28 34 37 39 40 53 54 59 63 67 76 85 86 90 94 99 109 114
第1个特征的值为1和2分别表示有毒和无毒 。下一个特征是蘑菇伞的形状，有六种可能的值，分别用整数3-8表示。
为了找到毒蘑菇中存在的公共特征，可以运用Apriori算法来寻找包含特征值为2的频繁项集。
mushDatSet=[line.split() for line in open(‘mushroom.dat‘).readlines()]
L,suppData=apriori.apriori(mushDatSet,minSupport=0.3)
for item in L[1]:
if item.intersection(‘2‘):print(item) #查看与特征值2相交的item
结果如下：
frozenset([‘2‘, ‘59‘]) frozenset([‘39‘, ‘2‘]) frozenset([‘2‘, ‘67‘]) frozenset([‘2‘, ‘34‘]) frozenset([‘2‘, ‘23‘]) frozenset([‘2‘, ‘86‘]) frozenset([‘76‘, ‘2‘]) frozenset([‘90‘, ‘2‘]) frozenset([‘2‘, ‘53‘]) frozenset([‘93‘, ‘2‘]) frozenset([‘63‘, ‘2‘]) frozenset([‘2‘, ‘28‘]) frozenset([‘2‘, ‘85‘]) frozenset([‘2‘, ‘36‘])
接下来你需要观察这些特征，以便了解毒蘑菇的哪些方面，如果看到其中任何一个特征就不要吃这些蘑菇了。当然，尽管上述这些特征在毒蘑菇中很普遍，但是没有这些特征并不意味着该蘑菇就是无毒可食用的。
示例：发现国会投票中的模式（略）
需要注册自己的key，故略去。
注：
- python中frozenset类型，是指被“冰冻”的集合，就是说它们是不可改变的，用户不能修改它们。frozenset和set的还有个区别是frozenset可以作为字典的键值使用。
- python中的List.append(obj)，List.extend(obj)，List.insert(index,obj)之间的区别是，append是在列表末尾添加一个新元素obj，extend是在列表末尾添加obj中的所有元素，inset是在特定的位置添加一个新元素。
- 参照该页面了解votesmart包。
- 有一个组织（致力于将政府数据公开化的组织）是智能投票工程Project Vote Smart，它提供了一个公共的API，可以方便我们从votesmart.org获取数据。第一，安装python-votesmart，第二，获得API key（需要在http://votesmart.org/share/api/register申请自己的key），这样就可以使用votesmartAPI了。
- python中set集合运算
原文地址：https://www.cnblogs.com/pandas-blue/p/11628398.html
时间： 2024-08-10 04:00:56