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

目录

根据以上分析，针对表 8-1的理财产品购买例子，为了方便程序实现，我们将商品用数字来代替：{1：开X存、2：飞X宝、3：新X利、4：友X盈、5：安X盈}.

1、构建数据集，数据对象

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)

#数学表达，卷面上
#关联规则，生成项集，1-项集，频繁1-项集，连接操作，C2，2-项集，最小支持度，L2，频繁2-项集，最小支持度，2-项集，python实现，理论模型，做作业、考试
#扫描loadDataSet返回的事务集，将所有的单项放入C中，构造成单项集
#参数：dataset-List列表，事务集
#返回值：List-冻结后的单项集列表

 2、产生1-项集函数，输入为交易记录D，输出为1-项集C1

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)

#根据minSupport参数设定的最小支持度，计算Ck的项集在原始记录D中的支持度
#返回满足最小支持度的项集集合，以及所有项集支持度的字典
#参数：D-List列表，事务集
#Ck-List列表，候选项集
#minSupport-浮点数，最小支持度阈值
#返回值：retList-List列表，满足最小支持度要求的项集,1-项集C1
#supportData-Dict字典，项集对应的支持度
#频繁1-项集产生函数，及支持度计算函数；输入为交易记录D、1-项集C1、最小支持度minSupport；

3、输出为频繁1-项集ret1、所有1-项集的支持度suD

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)

#由初始候选项集的集合Ck生成新的候选项集,一开始是C1，1-项集，因此生成2-项集
#参数：Ck-List列表，k-1项集，k-整数，要生成的候选项集中的每项包含的元素个数
#返回值：retList-List列表，新生成的候选k-项集

4、拼接函数，输入为Ck-1、K参数，表示生成k-项集

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]

#根据minSupport参数设定的最小支持度，返回所有满足最小支持度的项集
#参数：D-List列表，事务集
#minSupport-浮点数，最小支持度阈值
#返回值：L-List列表，所有满足最小支持度要求的项集
#supportData-Dict字典，项集对应的支持度
#最小支持度，频繁项集，置信度，关联规则

5、循环中关键数据L解析

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

6、输入为交易记录D，及最小支持度参数minSupport

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)

7、计算规则的置信度

#参数：freqSet-frozenset不可变集合，频繁项集
#H-不可变集合，频繁项集中所有的元素
#supportData-dic字典，频繁项集中所有元素的支持度
#brl-tuple元组,满足可信度条件的关联规则
#minConf-浮点数，最小置信度阈值，默认值0.7
#返回值：prunedH-List列表，满足最小置信度要求的规则

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

8、对频繁项集中元素超过2的项集进行合并

#参数：freqSet-frozenset不可变集合，频繁项集
#H-不可变集合，频繁项集中所有的元素
#supportData-dic字典，频繁项集中所有元素的支持度
#brl-tuple元组，满足可信度条件的关联规则
#minConf-浮点数，最小置信度阈值，默认值0.7、

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)

9、频繁项集和最小可信度生成规则

#参数：L-List，列表，频繁项集
#supportData-dict字典，所有项集（不仅仅是频繁项集）的支持度
#minConf-浮点数，最小置信度阈值，默认值0.7
#返回值：bigRuleList-List列表，满足最小置信度要求的规则

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)