第六章 Apriori演算法

apriori演算法是agrawal和r.srikant於2023年提出的，為布林關聯規則挖掘頻繁項集的原創性演算法。演算法的名字基於這樣的事實：演算法使用頻繁項集性質的先驗知識。

apriori演算法使用一種稱為逐層搜尋的迭代演算法，其中k項集用於探索（k+1）項集。首先，通過掃瞄資料庫，累計每個項的計數，並收集滿足最小支援度的項，找出頻繁1項集的集合，該集合記為l1。然後，使用l1找出頻繁2項集的集合l2，使用l2找出l3，如此下去，直到不能再找到頻繁k-項集。找出每個lk需要一次資料庫的完整掃瞄。

為了提高頻繁項集逐層產生的效率，一種稱為先驗性質的重要性質用於壓縮搜尋空間。先驗性質：頻繁項集的所有非空子集也一定是頻繁的。

「如何在演算法中使用先驗性質？」為理解這一點，我們考察如何使用lk-1找出lk，其中k>=2。下面的兩步過程由連線步和剪枝步組成。

（1）連線步：為找出lk，通過將lk-1與自身連線產生候選k項集的集合。該候選項集的集合記為ck。設l1

和l2是lk-1的項集，為了有效的實現，apriori演算法假定事務或項集中的項按字典序排序。兩個項集連線的條件：前k-2項相同，第乙個項集的k-1項小於第乙個項集的k-1項（為了確保不產生重複）。

（2）剪枝步：為了壓縮ck，可以使用先驗性質。任何非頻繁的（k-1）項集都不是頻繁k項集的子集。注意，由於apriori演算法使用逐層搜尋技術，給定候選k項集後，只需檢查它們的（k-1）項所有子集是否頻繁。

上圖為某商場的交易記錄，共有9個事務，利用apriori演算法尋找所有的頻繁項集的過程如下（最小支援度計數為2）:

該過程的中間步驟是遞迴形式：先自連線、再剪枝、最後再支援度計數。

一旦由資料庫d中的事務找出頻繁項集，就可以直接由它們產生強關聯規則。對於置信度，可以用下式計算：

confidence(a=>b)=p(b|a)=support_count(ab)/support_count(a)

關聯規則產生步驟如下：

1）對於每個頻繁項集l，產生其所有非空真子集；

2）對於每個非空真子集s,如果support_count(l)/support_count(s)>=min_conf，則輸出規則s=>(l-s)，其中，min_conf是最小置信度閾值。

例如，在上述例子中，針對頻繁集。可以產生哪些關聯規則？該頻繁集的非空真子集有，，，，和，對應置信度如下：

=>i5

confidence=2/4=50%

=>i2

confidence=2/2=100%

=>i1

confidence=2/2=100%

i1=>

confidence=2/6=33%

i2=>

confidence=2/7=29%

i5=>

confidence=2/2=100%

如果min_conf=70%,則強規則有=>i2，=>i1，i5=>。

from numpy import *
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]]
def createc1(dataset): # 構建集合c1
c1 = 
for transaction in dataset:
for item in transaction:
if not [item] in c1:
c1.sort()  # c1中的元素進行排序，生成[[1],[2],[3],[4],[5]]
return map(frozenset, c1)  # 把每個單元列表對映到frozenset()， frozenset是指被「冰凍」的
# 集合，就是說它們是不可改變的，這裡不能用set，因為之後必須要將
# 這些集合作為字典鍵值使用。
def scand(d, ck, minsupport): # 用於從ck生成lk，並返回乙個包含支援度值的字典supportdata以備後用
sscnt = {}
for tid in d:
for can in ck:
if can.issubset(tid): # 計數
if not sscnt.has_key(can): sscnt[can]=1
else: sscnt[can] += 1
numitems = float(len(d))
retlist = 
supportdata = {}
for key in sscnt:
support = sscnt[key]/numitems
if support >= minsupport:
retlist.insert(0,key)  # 列表的首位置插入字典的關鍵字
supportdata[key] = support
return retlist, supportdata
def apriorigen(lk, k): # 其實這裡是用lk-1生成ck，但這裡的lk-1都直接使用lk來代替了
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: # 前k-2個項相同時，將兩個集合lk[i]和lk[j]合併
return retlist
def apriori(dataset, minsupport = 0.22):  # 主函式
c1 = createc1(dataset)
d = map(set, dataset)
l1, supportdata = scand(d, c1, minsupport)
l = [l1]
k = 2 # 先從l1構建c2開始
while (len(l[k-2]) > 0):
ck = apriorigen(l[k-2], k)
lk, supk = scand(d, ck, minsupport) # scan db to get lk
supportdata.update(supk) # 更新supportdata
k += 1
return l, supportdata

執行結果：

>>> ******************************== restart ******************************==
>>> 
>>> dataset=loaddataset()
>>> dataset
[[1, 2, 5], [2, 4], [2, 3], [1, 2, 4], [1, 3], [2, 3], [1, 3], [1, 2, 3, 5], [1, 2, 3]]
>>> l, supportdata=apriori(dataset)
>>> l
[[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5]), frozenset([4])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([1, 5]), frozenset([1, 2]), frozenset([2, 4])], [frozenset([1, 2, 5]), frozenset([1, 2, 3])], ]
>>> l[0]  # 頻繁1項集
[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5]), frozenset([4])]
>>> l[1]  # 頻繁2項集
[frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([1, 5]), frozenset([1, 2]), frozenset([2, 4])]
>>> l[2]  # 頻繁3項集
[frozenset([1, 2, 5]), frozenset([1, 2, 3])]
>>> l[3]  # 頻繁4項集

第六章 Apriori演算法

mysql第六章第六章 mysql日誌

第六章指標

第六章總結

第六章 Apriori演算法

mysql第六章 第六章 mysql日誌

第六章 指標

第六章總結

相關推薦

mysql第六章第六章 mysql日誌

第六章指標