python使用Apriori算法進行關聯(lián)性解析

更新時間：2017年12月21日 11:16:02 作者：開貳錘

這篇文章主要為大家分享了python使用Apriori算法進行關聯(lián)性的解析，具有一定的參考價值，感興趣的小伙伴們可以參考一下

從大規(guī)模數(shù)據(jù)集中尋找物品間的隱含關系被稱作關聯(lián)分析或關聯(lián)規(guī)則學習。過程分為兩步：1.提取頻繁項集。2.從頻繁項集中抽取出關聯(lián)規(guī)則。

頻繁項集是指經(jīng)常出現(xiàn)在一塊的物品的集合。
關聯(lián)規(guī)則是暗示兩種物品之間可能存在很強的關系。
一個項集的支持度被定義為數(shù)據(jù)集中包含該項集的記錄所占的比例，用來表示項集的頻繁程度。支持度定義在項集上。
可信度或置信度是針對一條諸如{尿布}->{葡萄酒}的關聯(lián)規(guī)則來定義的。這條規(guī)則的可信度被定義為“支持度({尿布，葡萄酒})/支持度({尿布})”。

尋找頻繁項集

Apriori原理：如果某個項集是頻繁的，那么它的所有子集也是頻繁的。反過來，如果一個項集是非頻繁項集，那么它的所有超集也是非頻繁的。

Apriori算法是發(fā)現(xiàn)頻繁項集的方法。該算法首先生成所有單個物品的項集列表，接著掃描交易記錄來查看哪些項集滿足最小支持度要求，那些不滿足最小支持度的項集會被去除掉。然后對剩下來的集合進行組合以生成包含兩個元素的項集。接下來重新掃描交易記錄，去掉不滿足最小支持度的項集，該過程重復進行直到所有項集都被去掉。
Apriori偽代碼

當列表中項的個數(shù)大于0時：
檢查數(shù)據(jù)以確認每個項集都是頻繁的
保留頻繁項集并構建k+1項組成的候選項集的列表

從頻繁項集中挖掘關聯(lián)規(guī)則

當可信度大于最小可信度時，可以認為是含有關聯(lián)規(guī)則的。可以觀察到，如果某條規(guī)則不滿足最小可信度要求，那么該規(guī)則的所有子集也不會滿足最小可信度要求。
可以首先從一個頻繁項集開始，接著創(chuàng)建一個規(guī)則列表，其中規(guī)則右部只包含一個元素，然后對這些規(guī)則進行測試，接下來合并，通過合并所有剩余規(guī)則右部來創(chuàng)建新的規(guī)則列表，其中規(guī)則右部包含兩個元素，以此類推。

每個頻繁項集：
    while(len(L)>1)
        (k規(guī)則列表)
        滿足最小置信度
        創(chuàng)建k+1規(guī)則

整體代碼：

import numpy as np
def loadDataSet():
  return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]

def createC1(dateSet):
  c1 = []
  for line in dateSet:
    for item in line:
      if not [item] in c1:
        c1.append([item])
  c1.sort()
  return list(map(frozenset,c1))

def scanData(data,ck,minSupport):#尋找滿足最小支持度的項集
  ssCnt = {}
  for tid in data:
    for can in ck:
      if can.issubset(tid):
        if can not in ssCnt.keys():
          ssCnt[can] = 0
        ssCnt[can] += 1
  numItems = len(data)
  retList = []
  supportData = {}
  for key in ssCnt.keys():
    support = ssCnt[key]/numItems
    if support >= minSupport:
      retList.append(key)
    supportData[key] = support
  return retList,supportData


def aprioriGen(Lk,k): #根據(jù)k-1項集生成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:
        retList.append(Lk[i] | Lk[j])
  return retList

def apriori(dataSet,minSupport = 0.5):#生成頻繁項集
  c1 = createC1(dataSet)
  D = list(map(set,dataSet))
  l1,supportData = scanData(D,c1,minSupport)
  L = [l1]
  k = 2
  while(len(L[k-2])>0):
    ck = aprioriGen(L[k-2],k)
    lk,supk = scanData(D,ck,minSupport)
    k = k + 1
    L.append(lk)
    supportData.update(supk)
  return L,supportData
def generaterRules(L,supportData,minConf=0.7):#生成規(guī)則
  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
def calcConf(freqSet,H,suppurtData,brl,minConf = 0.7):#計算滿足置信度的規(guī)則
  prunedH = []
  for conseq in H:
    conf = suppurtData[freqSet]/suppurtData[freqSet-conseq]
    if conf > minConf:
      brl.append((freqSet-conseq,conseq,conf))
      prunedH.append(conseq)
  return prunedH

def rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7):#遞歸生成規(guī)則
  m = len(H[0])
  if len(freqSet)>=(m+1):
    Hmp1 = calcConf(freqSet,H,supportData,brl,minConf)
    if (len(Hmp1) > 1):
      Hmp1 = aprioriGen(Hmp1,m+1)
      rulesFromConseq(freqSet,Hmp1,supportData,brl,minConf)




data = [line.split() for line in open('mushroom.dat').readlines()]
L,support = apriori(data,minSupport=0.3)
for i in range(len(L)):
  for item in L[i]:
    if item & {'2'}:
      print(item)

代碼及數(shù)據(jù)集下載：Apriori

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: