#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from numpy import *
def loadDataSet():
return [['a', 'c', 'e'], ['b', 'd'], ['b', 'c'], ['a', 'b', 'c', 'd'], ['a', 'b'], ['b', 'c'], ['a', 'b'],
['a', 'b', 'c', 'e'], ['a', 'b', 'c'], ['a', 'c', 'e']]
def createC1(dataSet):
C1 = []
for transaction in dataSet:
for item in transaction:
if not [item] in C1:
C1.append([item])
C1.sort()
# 映射為frozenset唯?性的，可使?其構造字典
return list(map(frozenset, C1))
# 從候選K項集到頻繁K項集（?持度計算）
def scanD(D, Ck, minSupport):
ssCnt = {}
for tid in D:
for can in Ck:
if can.issubset(tid):
if not can in ssCnt:
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 calSupport(D, Ck, min_support):
dict_sup = {}
for i in D:
for j in Ck:
if j.issubset(i):
if not j in dict_sup:
dict_sup[j] = 1
else:
dict_sup[j] += 1
sumCount = float(len(D))
supportData = {}
relist = []
for i in dict_sup:
temp_sup = dict_sup[i] / sumCount
if temp_sup >= min_support:
relist.append(i)
supportData[i] = temp_sup # 此處可設置返回全部的?持度數據（或者頻繁項集的?持度數據）return relist, supportData
# 改進剪枝算法
def aprioriGen(Lk, k): # 創建候選K項集 ##LK為頻繁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: # 前k-1項相等，則可相乘，這樣可防?重復項出現
# 進?剪枝（a1為k項集中的?個元素，b為它的所有k-1項?集）
a = Lk[i] | Lk[j] # a為frozenset()集合
a1 = list(a)
b = []
# 遍歷取出每?個元素，轉換為set，依次從a1中剔除該元素，並加?到b中
for q in range(len(a1)):
t = [a1[q]]
tt = frozenset(set(a1) - set(t))
b.append(tt)
t = 0
for w in b:
# 當b（即所有k-1項?集）都是Lk（頻繁的）的?集，則保留，否則刪除。
if w in Lk:
t += 1
if t == len(b):
retList.append(b[0] | b[1])
return retList
def apriori(dataSet, minSupport=0.2):
C1 = createC1(dataSet)
D = list(map(set, dataSet)) # 使?list()轉換為列表
L1, supportData = calSupport(D, C1, minSupport)
L = [L1] # 加列表框，使得1項集為?個單獨元素
k = 2
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)
L.append(Lk) # L最後?個值為空集
k += 1
del L[-1] # 刪除最後?個空集
return L, supportData # L為頻繁項集，為?個列表，1，2，3項集分別為?個元素。
# ?成集合的所有?集
def getSubset(fromList, toList):
for i in range(len(fromList)):
t = [fromList[i]]
tt = frozenset(set(fromList) - set(t))
if not tt in toList:
toList.append(tt)
tt = list(tt)
if len(tt) > 1:
getSubset(tt, toList)
def calcConf(freqSet, H, supportData, ruleList, minConf=0.7):
for conseq in H:
conf = supportData[freqSet] / supportData[freqSet - conseq] # 計算置信度
# 提升度lift計算lift = p(a & b) / p(a)*p(b)
lift = supportData[freqSet] / (supportData[conseq] * supportData[freqSet - conseq]) if conf >= minConf and lift > 1:
print(freqSet - conseq, '-->', conseq, '?持度', round(supportData[freqSet - conseq], 2), '置信度：', conf, 'lift值為：', round(lift, 2))
ruleList.append((freqSet - conseq, conseq, conf))
# ?成規則
def gen_rule(L, supportData, minConf=0.7):
bigRuleList = []
for i in range(1, len(L)): # 從?項集開始計算
for freqSet in L[i]: # freqSet為所有的k項集
# 求該三項集的所有?空?集，1項集，2項集，直到k-1項集，?H1表?，為list類型,?為frozenset類型，
H1 = list(freqSet)
all_subset = []
getSubset(H1, all_subset) # ?成所有的?集
calcConf(freqSet, all_subset, supportData, bigRuleList, minConf)
return bigRuleList
if__name__ == '__main__':
dataSet = loadDataSet()
L, supportData = apriori(dataSet, minSupport=0.2)
rule = gen_rule(L, supportData, minConf=0.7)
運?結果：
錄：1.關聯分析
關聯分析是?種在?規模數據集中尋找有趣關系的任務。這種關系表現為兩種形式：
1.頻繁項集(frequency item sets)：經常同時出現的?些元素的集合；
2.關聯規則(association rules): 意味著兩種元素之間存在很強的關系。
下?舉例來說明上?的兩個概念：
表1 ?個來?Hole Foods天?品店的
簡單交易清單
交易號碼商品
0?奶，萵苣
1萵苣，尿布，葡萄酒，甜菜
2萵苣，尿布，葡萄酒，橙汁
3萵苣，?奶，尿布，葡萄酒
4萵苣，?奶，尿布，橙汁
頻繁項集是指經常出現在?起的元素的集合，上表中的集合 {葡萄酒，尿布，?奶} 就是頻繁項集的?個例?。同樣可以找到如 “尿布 --> 葡萄酒”的關聯規則，意味著如果有?買了尿布，就很可能也會買葡萄酒。使?頻繁項集和關聯規則，商家可以更好地理解顧客的消費?為，所以?部分關聯規則分析?例來?零售業。
理解關聯分析?先需要搞清楚下?三個問題：
1.如何定義這些有?的關系？
2.這些關系的強弱程度?是如何定義？
3.頻繁的定義是什麽？
要回答上?的問題，最重要的是理解兩個概念：?持度和可信度。
持度：?個項集的?持度(support)被定義為數據集中包含該項集的記錄占總記錄的?例。從表1 可以看出項集 {?奶} 的?持度為 4/5可信度或置信度(confidence)：是針對?條諸如尿布?>葡萄酒
2. Apriori 原理
假設經營了?家雜貨店，於是我們對那些經常在?起購買的商品?常感興趣。假設我們只有 4 種商品：商品0，商品1，商品 2，商品3. 那麽
如何得可能被?起購買的商品的組合？
上圖顯?了物品之間所有可能的組合，從上往下?個集合是 ?
我們的?標是找到經常在?起購買的物品集合。這?使?集合的?持度來度量其出現的頻率。?個集合出現的?持度是指有多少?例的交易記錄包含該集合。例如，對於上圖，要計算 0,3
為了降低計算時間，研究?員發現了 Apriori
Apriori
即如果 {0,1} 是頻繁的，那麽 {0}, {1} 也?定是頻繁的。
這個原理直觀上沒有什麽?，但是反過來看就有?了，也就是說如果?個項集是?頻繁的，那麽它的所有超集也是?頻繁的。如下圖所?：
3. 使? Apriori 算法來發現頻繁集
上?提到，關聯分析的兩個?標：發現頻繁項集和發現關聯規則。?先需要找到頻繁項集，然後根據頻繁項集獲得關聯規則。?先來討論發現頻繁項集。Apriori 是發現頻繁項集的?種?法。
先會?成所有單個物品的項集列表；掃描交易記錄來查看哪些項集滿?最?持度要求，那些不滿?最?持度的集合會被去掉；
對剩下的集合進?組合以?成包含兩個元素的項集；
接下來重新掃描交易記錄，去掉不滿?最?持度的項集，重復進?直到所有項集都被去掉。數據集掃描的偽代碼：
對數據集中的每條交易記錄tran:
對每個候選項集can:
檢查?下can是否是tran的?集：
如果是，則增加can的計數值
對每個候選項集：
如果其?持度不低於最低值，則保留
返回所有頻繁項集列表
￥
5.9
百度文庫VIP限時優惠現在開通,立享6億+VIP內容
立即獲取
python3關聯規則Apriori代碼模版
python3關聯規則Apriori代碼模版
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from numpy import *
def loadDataSet():
return [['a', 'c', 'e'], ['b', 'd'], ['b', 'c'], ['a', 'b', 'c', 'd'], ['a', 'b'], ['b', 'c'], ['a', 'b'],
['a', 'b', 'c', 'e'], ['a', 'b', 'c'], ['a', 'c', 'e']]
def createC1(dataSet):
C1 = []
第 1 頁
for transaction in dataSet:
for item in transaction:
if not [item] in C1:
C1.append([item])
C1.sort()
# 映射為frozenset唯?性的，可使?其構造字典
return list(map(frozenset, C1))
# 從候選K項集到頻繁K項集（?持度計算）
def scanD(D, Ck, minSupport):