中医证型关联规则挖掘

中医证型关联规则挖掘

数据从EXCEL中获取

# -*- coding: UTF-8 -*-
def loadDatadet(infile):
f=open(infile,'r')   # 只读模式打开
sourceInLine=f.readlines()
data_set=[]
for line in sourceInLine:
temp1=line.strip('\n')
temp2=temp1.split(',')
data_set.append(temp2)
return data_set
def create_C1(data_set):
"""
----------------------------------------
每个项都是候选1项集的集合C1的成员。算法扫描所有的事务，获得每个项，生成C1.
---------------------------------------
通过扫描数据集创建频繁的候选1项集C1。
Args:
data_set: 事务列表。每个事务包含多个项
Returns:
C1: 包含所有常见候选1项集的集合
"""
C1 = set()
for t in data_set:
for item in t:
item_set = frozenset([item])
C1.add(item_set)
return C1

def is_apriori(Ck_item, Lksub1):
"""
判断常用候选k项集是否满足Apriori属性。
Args:
Ck_item: ck中包含所有frequent的常用候选k - itemset
候选k项集。
Lksub1: LK - 1，包含所有常用候选（K - 1）项集的集合。
Returns:
True: 满足先验属性.
False: 不满足先验属性.
"""
for item in Ck_item:
sub_Ck = Ck_item - frozenset([item])
if sub_Ck not in Lksub1:
return False
return True

def create_Ck(Lksub1, k):
"""
---------------------------------------
对Lk-1的自身连接生成的集合执行剪枝策略产生候选k项集Ck
---------------------------------------
Create Ck, 由LK-1自己的连接操作包含所有频繁的候选k项集的集合。
Args:
Lksub1: LK-1，包含所有常用候选（K-1）项集的集合。
k: 频繁项目集的项目编号。
Return:
Ck: 包含所有常用候选k项集的集合。
"""
Ck = set()
len_Lksub1 = len(Lksub1)
list_Lksub1 = list(Lksub1)
for i in range(len_Lksub1):
for j in range(1, len_Lksub1):
l1 = list(list_Lksub1[i])
l2 = list(list_Lksub1[j])
l1.sort()
l2.sort()
if l1[0:k-2] == l2[0:k-2]:   # 若两个集合的前k-2个项相同时,则将两个集合合并
Ck_item = list_Lksub1[i] | list_Lksub1[j]   # 集并
# pruning修剪
if is_apriori(Ck_item, Lksub1):
Ck.add(Ck_item)
return Ck

def generate_Lk_by_Ck(data_set, Ck, min_support, support_data):
"""
---------------------------------------
扫描所有事务，对Ck中的每个项进行计数。然后根据最小支持度从Ck中删除不满足的项，从而获得频繁k项集。
---------------------------------------
通过从Ck执行删除策略生成Lk。
ARG:
data_set：事务列表。每个事务包含几个项。
Ck：包含所有频繁候选k项集的集合。
min_.：最小支持。
._data：字典。关键在于频繁项集，而价值在于支持。
返回：
Lk：包含所有频繁的k项集的集合。
"""
Lk = set()
item_count = {}
for t in data_set:
for item in Ck:
if item.issubset(t):
if item not in item_count:
item_count[item] = 1
else:
item_count[item] += 1
t_num = float(len(data_set))
for item in item_count:
if (item_count[item] / t_num) >= min_support:
Lk.add(item)
support_data[item] = item_count[item] / t_num
return Lk

def generate_L(data_set, k, min_support):
"""
生成所有的频繁项集。
参数：
data_set：交易_集列表。每个项目包含几个交易。
K：最大频繁项集的所有项目。
最小，最低_支持：支持。
return：
L：列表的路。
support_data：.最关键的是一项集是频繁和价值支持
"""
support_data = {}
C1 = create_C1(data_set)
L1 = generate_Lk_by_Ck(data_set, C1, min_support, support_data)
Lksub1 = L1.copy()
L = []
L.append(Lksub1)
for i in range(2, k+1):
Ci = create_Ck(Lksub1, i)
Li = generate_Lk_by_Ck(data_set, Ci, min_support, support_data)
Lksub1 = Li.copy()
L.append(Lksub1)
return L, support_data
def generate_big_rules(L, support_data, min_conf):
"""
从频繁的项集生成大规则。
ARG:
L：LK列表。
support_data：字典。键是频繁项集和支持度值
min_conf: 最小置信度。
Returns:
big_rule_list:包含所有强关联规则的列表。每个强关联规则都有作为一个三元组。
"""
big_rule_list = []
sub_set_list = []
for i in range(0, len(L)):
for freq_set in L[i]:
for sub_set in sub_set_list:
if sub_set.issubset(freq_set):
conf = support_data[freq_set] / support_data[freq_set - sub_set]
big_rule = (freq_set - sub_set, sub_set, conf)
if conf >= min_conf and big_rule not in big_rule_list:
# print freq_set-sub_set, " => ", sub_set, "conf: ", conf
big_rule_list.append(big_rule)
sub_set_list.append(freq_set)
return big_rule_list

if __name__ == "__main__":
"""
Test
"""

data_set = 'D:/pycharm/mydata/apriori.txt'
data_set = loadDatadet(data_set)
L, support_data = generate_L(data_set, k=4, min_support=0.06)
big_rules_list = generate_big_rules(L, support_data, min_conf=0.75)
for Lk in L:
print ("="*50)
print ("frequent " + str(len(list(Lk)[0])) + "-itemsets/t/tsupport")
print ("="*50)
for freq_set in Lk:
print (freq_set, support_data[freq_set])
print
print ("Big Rules")
for item in big_rules_list:
print( item[0], "=>", item[1], "conf: ", item[2])