Python金融数据挖掘 第八章 第2节 代码实例 （3）

 def loadDataSet():#函数，基础知识

    
     return[[1,2,5],[2,4],[2,3],[1,2,4],[1,3],[2,3],[1,3],[1,2,3,5],[1,2,3]]
    
 D=loadDataSet()
    
 print(D)

 def createC1(dataSet):

    
     C=[] #单项提取出来，for循环
    
     for transaction in dataSet:
    
     for item in transaction:
    
         if [item] not in C:
    
             C.append([item])
    
     C.sort()
    
 #调用frozenset函数将单项集列表冻结，返回冻结单项集列表，固定
    
     return list(map(frozenset,C))
    
 C1=createC1(D)
    
 print('C1:',C1)

 def scanD(D,Ck,minSupport):

    
     ssCnt={}
    
 #对于每一个候选项集can,检查是否是D的一部分，即该候选can是否得到transcaction的支持
    
     for tid in D:
    
     for can in Ck:
    
         if can.issubset(tid):
    
             ssCnt[can]=ssCnt.get(can,0)+1
    
     numItems=float(len(D))
    
     retList=[]
    
     supportData={}
    
     for key in ssCnt:
    
 #每个项集的支持度
    
     support=ssCnt[key]/numItems
    
 #将满足最小支持度的项集，加入retList中
    
     if support>=minSupport:
    
         retList.insert(0,key) #嵌入，参数，输出数据表现，关键参数
    
 #汇总支持度数据
    
     supportData[key]=support
    
     return retList,supportData
    
  
    
 ret1,suD=scanD(loadDataSet(),createC1(loadDataSet()),0.22)
    
 print('ret1:',ret1)
    
 print('suD:',suD)

 def aprioriGen(Ck,k):

    
     retList=[]
    
     lenCk=len(Ck)
    
 #以下的Ck[i]与Ck[j]均包含k-1个项，如果它们的前k-2项相同 
    
 #则通过或运算将其拼接为一个包含k项的列表元素，加入到retList中
    
     for i in range(lenCk):
    
     for j in range(i+1,lenCk):
    
         L1=list(Ck[i])[:k-2] #前k-1项相同 Ck-1 Ck k-2项相同 机器语言理解
    
         L2=list(Ck[j])[:k-2]
    
         L1.sort()
    
         L2.sort()
    
         if L1 == L2:
    
             retList.append(Ck[i]|Ck[j])  #连接操作，位运算符，“或”运算，二进制数据连接
    
     return retList
    
 #频繁1-项集，连接操作，C2，2-项集
    
 ret2=aprioriGen(C1,2)
    
 print('ret2:',ret2)
    
 L5=[ret1]
    
 L6=L5[0]
    
 #L7=L5[1]

 L5=[ret1]

    
 L6=L5[0]
    
 #L7=L5[1]

 def apriori(D,minSupport):

    
     C1=createC1(D)
    
     L1,suppData=scanD(D,C1,minSupport)
    
     L=[L1]
    
 #最初的L1中的每个项集含有一个元素
    
 #新生成的项集应该含有2个元素，所以k=2
    
     k=2
    
     while(len(L[k-2])>0):
    
     Ck=aprioriGen(L[k-2],k)
    
     Lk,supK=scanD(D,Ck,minSupport)
    
 #将新的项集的支持度数据加入原来的总支持度字典中
    
     suppData.update(supK)
    
 #将符合最小支持度要求的项集加入L
    
     L.append(Lk)
    
 #新生成的项集中的元素个数应不断增加
    
     k+=1
    
 #返回所有满足条件的频繁项集的列表和所有候选项集的支持度信息
    
     return L,suppData
    
  
    
 L1,suD2=apriori(D,0.22) #L1所有的频繁项集，suD2所有可能项集的支持度
    
 print('L1:',L1)
    
 print('suD2:',suD2)

 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)
    
     return prunedH

 def rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7):

    
     m=len(H[0])
    
 #检查频繁项集是否大到移除大小为m的子集
    
     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): #minConf最小置信度

    
     bigRuleList=[]
    
     for i in range(1,len(L)):
    
     for freqSet in L[i]:
    
 #对于每一个频繁项集的集合freqSet
    
         H1=[frozenset([item]) for item in freqSet]
    
 #如果频繁项集中的元素个数大于2，需要进一步合并
    
         if i>1:
    
             rulesFromConseq(freqSet,H1,supportData,bigRuleList,minConf)
    
         else:
    
             calcConf(freqSet,H1,supportData,bigRuleList,minConf)
    
     return bigRuleList
    
  
    
 bRlist=generateRules(L1,suD2,0.1)
    
 print('bRlist:',bRlist)