add: 关联分析

Author: chgl16

README.md

@@ -1,4 +1,41 @@
 # 数据挖掘算法
-1. 关联分析Apriori算法
-2. 数据分类决策树算法
-3. 数据聚类K-means算法
+1. [关联分析Apriori算法](#关联分析Apriori算法)  
+2. [数据分类决策树算法](#数据分类决策树算法)
+3. [数据聚类K-means算法](#数据聚类K-means算法)
+  
+
+<hr>
+
+## 关联分析Apriori算法
+### 1. 数据集  
+以超市交易为数据集，所有商品的项集为        
+*I = {bread, beer, cake, cream, milk, tea}*  
+某条交易如  
+*Ti = {bread, beer, milk}*   
+简化为  
+*Ti = {a, b, d}*  
+data.txt数据集样本如下
+```bash
+a, d, e,f
+a, d, e
+c, e
+e, f
+...
+```
+
+### 2. 算法实现
+使用经典的Apriori算法，依次扫描交易记录集，计算出 *k-候选集Ck* 然后去除**支持度sup**小的项集获得 *k-频繁集Lk*， 只计算到 *3-频繁集* 
+> 第k个候选集只会从k-1频繁集中的各项目组合连接，然后扫描记录集，以获取Ck中各项集的支持度。    
+
+![输出结果](https://i.loli.net/2019/06/16/5d05ad0e8f2e762317.png)
+
+
+## 数据分类决策树算法
+
+
+
+
+
+
+
+## 数据聚类K-means算法

关联分析（Apriori）/correlation_analysis.py

@@ -0,0 +1,124 @@
+# -*- coding: UTF-8 -*-
+"""
+关联分析-Apriori算法
+"""
+
+'''
+从外部文件data.txt导入数据集，一个交易的集合
+'''
+def load_data_set():
+    data_set = []
+    fd = file("data.txt", "r")
+    for line in fd.readlines():
+        line = line.strip('\n')
+        data_set.append(list(map(None, line.split(', '))))
+    return data_set
+
+'''
+直接从数据集构造1-候选集
+'''
+def create_C1(data_set):
+    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):
+    for item in Ck_item:
+        sub_Ck = Ck_item - frozenset([item])
+        if sub_Ck not in Lksub1:
+            return False
+    return True
+
+'''
+生成各个候选集Ck
+'''
+def create_Ck(Lksub1, 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]:
+                Ck_item = list_Lksub1[i] | list_Lksub1[j]
+                if is_apriori(Ck_item, Lksub1):
+                    Ck.add(Ck_item)
+    return Ck
+
+'''
+通过候选集Ck生成频繁集Lk
+'''
+def generate_Lk_by_Ck(data_set, Ck, min_support, support_data):
+    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
+
+'''
+生成各阶频繁集，最小支持度为0.2
+'''
+def generate_L(data_set, k, min_support):
+    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):
+    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:
+                        big_rule_list.append(big_rule)
+            sub_set_list.append(freq_set)
+    return big_rule_list
+
+if __name__ == "__main__":
+    data_set = load_data_set()
+    L, support_data = generate_L(data_set, k=3, min_support=0.2)
+    big_rules_list = generate_big_rules(L, support_data, min_conf=0.7)
+    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])