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)

文章出处登录后可见!

已经登录?立即刷新

共计人评分,平均

到目前为止还没有投票!成为第一位评论此文章。

(0)
上一篇 2022年5月21日 下午1:42
下一篇 2022年5月21日 下午1:47

相关推荐

本站注重文章个人版权,不会主动收集付费或者带有商业版权的文章,如果出现侵权情况只可能是作者后期更改了版权声明,如果出现这种情况请主动联系我们,我们看到会在第一时间删除!本站专注于人工智能高质量优质文章收集,方便各位学者快速找到学习资源,本站收集的文章都会附上文章出处,如果不愿意分享到本平台,我们会第一时间删除!