数据挖掘Apriori算法python实现

使用此程序时，将可以自行编写一个输入函数，将你所需要输入的数据存储到DataSource对象中，该对象用的存储结构是python中的字典。

#设置最小支持度和最小置信度
min_sup=2
min_conf=0.5

#原始数据
class Datasource:
    def data_set(self,input):
        self.source=input
    def search_item(self,item):            #item是一个列表
        count=0
        for key in self.source:
            if set(item).issubset(set(self.source[key])):
                count=count+1
        return count
    

#进行迭代时由k-1项集产生k项集时产生的数据
class DataStorage:
    def store(self,iteration_prev):
        self.data_pre=iteration_prev
        self.candidateItemset={}
    #-----判断项item是否为data_pre的频繁项------#
    def item_in(self,item):       
        for key in self.data_pre:
            if set(item).issubset(set(key)):
                return True
        return False
    #-----对data_pre项集进行连接操作，将产生的候选新项集存入candidateItemset中-------#
    def connect(self):
        for key1 in self.data_pre:
            item_new=[]
            for key2 in self.data_pre:
                if key1!=key2:
                    if type(key1)==str:
                        key1=key1.split(',')
                        key2=key2.split(',')
                    item_new=key1
                    item_new.extend(key2)
                    item_new=set(item_new)
                    #print item_new
                    item_new=','.join(item_new)
                    self.candidateItemset[item_new]=0
                    item_new=[]

#求一个输入集合的全部子集（包括空集）的函数            
def all_subset(input_set):
    result=[input_set[0]]
    result.append('')
    for i in range(1,len(input_set)):
        for j in range(0,int(pow(2,i))):
            result.append(result[j]+'_'+input_set[i])
    for i in range(len(result)):
        result[i]=result[i].strip('_')
    return result

#输入两个集合，求两个集合的差集,从setA集合中减去setB集合
def minus(setA,setB):
    setA=set(setA)
    setB=set(setB)
    return list(setA-setB)
    
       

input={'T100':['I1','I2','I5'],
      'T200':['I2','I4'],
      'T300':['I2','I3'],
      'T400':['I1','I2','I4'],
      'T500':['I1','I3'],
      'T600':['I2','I3'],
      'T700':['I1','I3'],
      'T800':['I1','I2','I3','I5'],
      'T900':['I1','I2','I3']}
d1=Datasource()
d1.data_set(input)
print 'source data is:',d1.source,'\n'
                               
#产生1-项集
L=[]
for TID in d1.source:
    for n in d1.source[TID]:
        L.append(n)
L1_itemset=set(L)
L_1={}
for elem in L1_itemset:
    elem_count=d1.search_item([elem])
    if elem_count>=min_sup:
        L_1[elem]=elem_count
print '1-frequent itemset is:',L_1

t=1
#迭代
while True:
    L=DataStorage()
    L.store(L_1)
    L.connect()
    
    #--------利用先验性质删除候选项集中非频繁的候选----------#
    keys=L.candidateItemset.keys()
    for n in keys:
        temp=n.split(',')
        item_num=len(temp)
        for i in range(item_num):
            temp1=temp[:]
            temp2=temp1.pop(i)
            if not L.item_in(temp2):
                del L.candidateItemset[n]
                break
      
    #--------为新构造的候选项集计算支持度计数------------#
    keys=L.candidateItemset.keys()
    for elem in keys:       #此处elem是一个字符串
        elem=elem.split(',')       #把elem字符串分割为列表，因为去原始数据计算支持度的函数只接受列表参数
        elem_count=d1.search_item(elem)     #去原始数据对象中计算每一个项的支持度
        elem=','.join(elem)        #把elem列表转换为字符串，因为字典的关键字不能是列表
        if elem_count>=min_sup:
            L.candidateItemset[elem]=elem_count
        else:
            del L.candidateItemset[elem]
    
    #-------如果L为空，则退出循环，否则把L传递给L_1，进行下一轮迭代-------#
    if L.candidateItemset:
        t=t+1
        print '%s-frequent itemset is:'%t,L.candidateItemset
        L_1=L.candidateItemset
    else:
        break

print '\n'
#由频繁项集产生关联规则 频繁项集存储在字典L_1中
for frequent_item in L_1:
    frequent_item=frequent_item.split(',')
    #print frequent_item
    subsets=all_subset(list(frequent_item))
    subsets.remove('_'.join(frequent_item))
    subsets.remove('')
    #print subsets
    for set_item in subsets:
        set_item=set_item.split('_')
        confidence=float(d1.search_item(frequent_item))/float(d1.search_item(set_item))
        if confidence>=min_conf:
            set_minus=minus(frequent_item,set_item)
            print ''.join(set_item)+'--->'+''.join(set_minus)+', confidence = %.2f'%confidence