使用python挖掘频繁项集
本实验包含以下内容：
学习挖掘频繁项集，掌握apriori算法
1.实现用apriori算法挖掘频繁项集（最小支持度计数2）
2.分析你所实现的apriori算法的缺点
3. 数据集：
| TID | 项集 |
|---|---|
| T100 | I1,I2,I5 |
| T200 | I2,I4 |
| T300 | I2,I3 |
| T400 | I1,I2,I4 |
| T500 | I1,I3 |
| T600 | I2,I3 |
| T700 | I1,I3 |
| T800 | I1,I2,I3,I5 |
| T900 | I1,I2,I3 |
代码如下:
# 录入数据
def data_fetch():
data = [['l1', 'l2', 'l5'],
['l2', 'l4'],
['l2', 'l3'],
['l1', 'l2', 'l4'],
['l1', 'l3'],
['l2', 'l3'],
['l1', 'l3'],
['l1', 'l2', 'l3', 'l5'],
['l1', 'l2', 'l3']]
return data
# 根据项目，寻找支持度计数
def xunzhao(s, L):
k = len(s) - 1 # 根据项目长度，决定在频繁几项集中寻找
if k < 0: # s为空的情况
print(s, '不是有效输入')
# 标志变量，如果s中的项目有和当前比较的不同的，就置0；
t = 0
for i in range(len(L[k])): # 遍历频繁k项集
t = 1
for j in range(k + 1): # 开始比较是不是该项目
if L[k][i][0][j] != s[j]:
t = 0
break
if t:
return L[k][i][1] # 是的话，返回该项目的支持度计数
print('未找到') # 遍历结束的话说明未找到
return -1 # 返回 -1 (无)
# 得到划分，并顺便求出置信度
def huafen(L, l, conf): # 划分得到置信度
X = l[0] # 需要划分的列表
lx = len(X) # 长度
# 用二进制的性质求真子集
for i in range(1, 2 ** lx - 1):
s1 = []
s2 = []
for j in range(lx):
# 二进制末尾是0就进s1,否则就进s2达到划分目的
if (i >> j) % 2:
s1.append(X[j])
else:
s2.append(X[j])
conf[str(s1), '->', str(s2)] = l[1] / xunzhao(s1, L)
# 判断s中的数据在data中的数目
def jishu(s, data):
c = 0 # 记录出现数目
# 标志变量，如果s中的数据有在data这一行不存在的，就置0；
t = 0
for ii in data: # 数据每一行
t = 1
for jj in s: # 对于 s 中的每一个项
if not (jj in ii):
t = 0
break
c += t # 如果 s 在这一行存在，c++
return c
# 输入频繁k-1项集，支持度计数，数据，输出频繁k项集
def Apriori(L, N, data):
if not L:
return L
L_ = [] # 频繁k项集
L = [i[0] for i in L] # k-1项集包含哪些
k = len(L[0]) + 1 # 几项集
L_len = len(L)
up = k - 2 # 拼接同项长度
i = 0
while i < L_len - 1: # 只剩最后一个时肯定没法拼
A = L[i][0:up] # 拼接前项
c = i # 记录走到那个前项了
i += 1 # i 到下一个
for j in range(c + 1, L_len):
if L[j][0:up] != A: # 前几项不一致就停止
i = j # i 快进到发现新键值的地方
break
else: # 前几项一致时
s = L[c] + L[j][up:] # 生成预选项
t = jishu(s, data) # 得到 s 的支持度计数
if t >= N: # 支持度计数大于N
L_.append([s, t]) # 添加到频繁项集中
return L_
data = data_fetch() # 生成数据，存到data
N = 2 # 支持度计数
L = {} # 储存一项集
for i in data: # 得到所有的一项集
for j in i:
if j in L:
L[j] += 1
else:
L[j] = 1
L_1 = [] # 储存频繁一项集
for i in L.keys(): # 取其中所有的频繁集
if L[i] >= N:
L_1.append([[i], L[i]])
L = [] # 频繁1~4项集
L.append(sorted(L_1, key=lambda x: x[0])) # 按键值排序转为列表
print('频繁 1 项集', L[0])
for i in range(3):
L.append(Apriori(L[i], N, data)) # 求频繁2项集
print('频繁', i + 2, '项集', L[i + 1])
# 置信度计算 ===============================================
conf = {} # 储存置信度
# 对每一个k项集分析
print('置信度：============================================')
for i in L[1:len(L)]: # 频繁1项集不用看
for j in i:
huafen(L, j, conf) # 划分得到置信度
for key in conf:
print(key,conf[key]*100,'%')结果示例：
频繁 1 项集 [[['l1'], 6], [['l2'], 7], [['l3'], 6], [['l4'], 2], [['l5'], 2]]
频繁 2 项集 [[['l1', 'l2'], 4], [['l1', 'l3'], 4], [['l1', 'l5'], 2], [['l2', 'l3'], 4], [['l2', 'l4'], 2], [['l2', 'l5'], 2]]
频繁 3 项集 [[['l1', 'l2', 'l3'], 2], [['l1', 'l2', 'l5'], 2]]
频繁 4 项集 []
置信度：============================================
("['l1']", '->', "['l2']") 66.66666666666666 %
("['l2']", '->', "['l1']") 57.14285714285714 %
("['l1']", '->', "['l3']") 66.66666666666666 %
("['l3']", '->', "['l1']") 66.66666666666666 %
("['l1']", '->', "['l5']") 33.33333333333333 %
("['l5']", '->', "['l1']") 100.0 %
("['l2']", '->', "['l3']") 57.14285714285714 %
("['l3']", '->', "['l2']") 66.66666666666666 %
("['l2']", '->', "['l4']") 28.57142857142857 %
("['l4']", '->', "['l2']") 100.0 %
("['l2']", '->', "['l5']") 28.57142857142857 %
("['l5']", '->', "['l2']") 100.0 %
("['l1']", '->', "['l2', 'l3']") 33.33333333333333 %
("['l2']", '->', "['l1', 'l3']") 28.57142857142857 %
("['l1', 'l2']", '->', "['l3']") 50.0 %
("['l3']", '->', "['l1', 'l2']") 33.33333333333333 %
("['l1', 'l3']", '->', "['l2']") 50.0 %
("['l2', 'l3']", '->', "['l1']") 50.0 %
("['l1']", '->', "['l2', 'l5']") 33.33333333333333 %
("['l2']", '->', "['l1', 'l5']") 28.57142857142857 %
("['l1', 'l2']", '->', "['l5']") 50.0 %
("['l5']", '->', "['l1', 'l2']") 100.0 %
("['l1', 'l5']", '->', "['l2']") 100.0 %
("['l2', 'l5']", '->', "['l1']") 100.0 %
进程已结束，退出代码为 0
总结：
生成备选频繁项集时，没有充分利用频繁项集的子集也属于频繁项集的性质，导致有一些冗余。