1基本概念
购物篮事务（market basket transaction),如下表，表中每一行对应一个事务，包含唯一标识TID,和购买的商品集合。本文介绍一种成为关联分析(association analysis)的方法，这种方法，可以从下表可以提取出，{尿布}—>牛奶.
两个关键问题：1大型数据计算量很大。2发现的某种模式可能是虚假，偶然发生的。
2问题定义
把数据可以转换为如下表的二元表示，非二元不在本文讨论范围
项集
项集的支持度计数：
关联规则：
我们要发现，满足最小支持度与最小置信度的规则。
l 频繁项集(frequent itemset):发现满足最小支持度阈值的所有项集，这些项集成为频繁项集。
l 规则的产生：从上一步发现的频繁项集中提取所有高置信度的规则，这些规则成为强规则(strong rule)
频繁项集的产生
穷举法：
利用格结构（lattice structure）产生所有候选项集（candidate itemset）.
利用穷举法，计算每个候选项集的支持度计数。但是该方法计算量太大。
先验(apriori)原理：
如果一个项集是频繁的，则的所有子集一定是频繁的。若某项集是非频繁的，则其所有的超级也一定是非频繁的。
如下图，若{c,d,e}是频繁项集，则它的子集一定是频繁项集。
项集{a,b}是非频繁的，则其所有的超级也一定是非频繁的,如下图。
Aprior算法的频繁项集产生
1. 确定每个1-项集的支持度计数，删除不满足最小支持度的1-项集。（步骤1,2）
2. 迭代：使用频繁(k-1)项集，产生新的候选k项集（步骤5）
3. 为了对候选k项集计算支持度计数，再次扫描数据(6-10)
4. 删去支持度小于最小支持度（minsup）的候选集
5. 当Fk=NULL,结束。
6. 候选集是所有频繁i项集的交际。i=1,2…
方法：产生
(频繁k-项集)。(step5)
函数aprior-gen的候选产生过程，合并一对频繁k-1项集，仅当他们前k-2个项都相同时，即
图例：
Python代码：
def aprioriGen(Lk,k):#create ck(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:#比较i,j前k-1个项若相同，和合并它俩 retList.append(Lk[i] | Lk[j])#加入新的k项集 | stanf for union return retList
支持度计数：算法(6-12)代码
Python代码：
def scanD(D,ck,minSupport):#dataset,a list of candidate set,最小支持率 ssCnt={} for tid in D: for can in ck: if can.issubset(tid): if not ssCnt.has_key(can): ssCnt[can]=1 else: ssCnt[can]+=1 numItem=float(len(D)) retList=[] supportData={} for key in ssCnt: support=ssCnt[key]/numItem if support>=minSupport: retList.insert(0,key) supportData[key]=support return retList,supportData#返回频繁k项集，相应支持度
频繁项集的产生：
def apriori(dataSet,minSupport=0.5): C1=createC1(dataSet) D=map(set,dataSet) L1,supportData=scanD(D,C1,minSupport)#利用k项集生成频繁k项集（即满足最小支持率的k项集） L=[L1]#L保存所有频繁项集 k=2 while(len(L[k-2])>0):#直到频繁k-1项集为空 Ck=aprioriGen(L[k-2],k)#利用频繁k-1项集 生成k项集 Lk,supK= scanD(D,Ck,minSupport) supportData.update(supK)#保存新的频繁项集与其支持度 L.append(Lk)#保存频繁k项集 k+=1 return L,supportData#返回所有频繁项集，与其相应的支持率
规则产生(mining rules)
定理：
例如下：若bcd ->a是低置信度的，则它的子代都是低置信度的。利用此定理可以避免不必要的计算，减少运算复杂度。
![clip_image004[4]](https://images0.cnblogs.com/blog/550043/201312/09112552-34c45fa0f7d04c2d93d73b9f052b1b60.jpg "clip_image004[4]")
算法流程如下：![clip_image006[4]](https://images0.cnblogs.com/blog/550043/201312/09112556-3539c45d0a9c4479a5d88aa0fa88694a.jpg "clip_image006[4]")
![clip_image008[4]](https://images0.cnblogs.com/blog/550043/201312/09112600-709ef78a604b4b9793eb54a0664a02cd.jpg "clip_image008[4]")
python代码：
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)#添加入被修剪过的H中 return prunedH def rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7): m=len(H[0])#H是一系列后件长度相同的规则，所以取H0的长度即可 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) def generateRules(L,supportData,minConf=0.7): import pdb pdb.set_trace() 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
整个prior算法的python代码
算法函数：
# -*- coding: utf-8 -*- """ Created on Wed Dec 04 22:25:57 2013 @author: Administrator """ def loadDataSet(): return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]] def createC1(dataSet):#产生单个item的集合 C1=[] for transaction in dataSet: for item in transaction: if not [item] in C1: C1.append([item]) C1.sort() return map(frozenset,C1)#给C1.list每个元素执行函数 def scanD(D,ck,minSupport):#dataset,a list of candidate set,最小支持率 ssCnt={} for tid in D: for can in ck: if can.issubset(tid): if not ssCnt.has_key(can): ssCnt[can]=1 else: ssCnt[can]+=1 numItem=float(len(D)) retList=[] supportData={} for key in ssCnt: support=ssCnt[key]/numItem if support>=minSupport: retList.insert(0,key) supportData[key]=support return retList,supportData#返回频繁k项集，相应支持度 def aprioriGen(Lk,k):#create ck(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:#比较i,j前k-1个项若相同，和合并它俩 retList.append(Lk[i] | Lk[j])#加入新的k项集 | stanf for union return retList def apriori(dataSet,minSupport=0.5): C1=createC1(dataSet) D=map(set,dataSet) L1,supportData=scanD(D,C1,minSupport)#利用k项集生成频繁k项集（即满足最小支持率的k项集） L=[L1]#L保存所有频繁项集 k=2 while(len(L[k-2])>0):#直到频繁k-1项集为空 Ck=aprioriGen(L[k-2],k)#利用频繁k-1项集 生成k项集 Lk,supK= scanD(D,Ck,minSupport) supportData.update(supK)#保存新的频繁项集与其支持度 L.append(Lk)#保存频繁k项集 k+=1 return L,supportData#返回所有频繁项集，与其相应的支持率 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)#添加入被修剪过的H中 return prunedH def rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7): m=len(H[0])#H是一系列后件长度相同的规则，所以取H0的长度即可 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) 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
测试代码：
import apriori dataSet=apriori.loadDataSet() C1=apriori.createC1(dataSet) D=map(set,dataSet) L1,suppData0=apriori.scanD(D,C1,0.5) L,suppData=apriori.apriori(dataSet) print L rules=apriori.generateRules(L,suppData,minConf=0.5)
参数文献：
1数据挖掘导论
2machine learning in action