1. 用途和原理

1.1 用途

用于关联分析，即在大规模数据中寻找有趣的关系，有两种形式：频繁项集和关联规则。频繁项集：指经常出现在一块的物品集合。关联规则：暗示两种物品之间可能存在很强的关系。典型一个案例便是：尿布与啤酒（感兴趣可以了解一下）。

1.2 原理

Apriori原理：如果某个项集是频繁的那么它的所有子集也是频繁的。反过来，如果某个项集非频繁，那么其所有的超集也非频繁。如下图，阴影部分 [2,3] 以及其超集均为为非频繁集。

两个概念：

支持度：一个项集的支持度定义为数据集中包含该项集的记录所占的比例。

可信度：针对关联规则所定义，如规则 A->B（可简单理解为 A 导致 B ），则该规则可信度=支持度{A,B}/支持度{A}

1.3 算法过程

  1. 收集数据

  2. 找出满足阈值条件的频繁项集

  3. 运用关联规则找出物品间关系

2. Python实现

2.1 构建频繁项集

伪代码如下：

当集合中项的个数大于0时：

  • 构建一个K个项组成的候选项集的列表
  • 检查数据以确认每个项集是频繁的（即观察支持度是否大于阈值）
  • 保留频繁项集并构建K+1项组成的候选项集列表

主要核心代码如下：

 1 # 创建候选项集Ck
 2 def aprioriGen(Lk,k):
 3     retList=[]
 4     lenLk=len(Lk)
 5     # 将每一个集合与其他所有集合遍历配对，每两个元素检查其前k-2个值是否相同，如果相同，合并之，减小配对时间
 6     for i in range(lenLk):
 7         for j in range(i+1,lenLk):
 8             # list[:k-2]返回的是前k-2个数
 9             L1=list(Lk[i])[:k-2]
10             L2=list(Lk[j])[:k-2]
11             L1.sort()
12             L2.sort()
13             if L1==L2:
14                 retList.append(Lk[i]|Lk[j])
15     return retList
16
17 # 创建频繁项集L,及其对应的支持度
18 def apriori(dataSet,minSupport=0.5):
19     C1=creatC1(dataSet)
20     D=list(map(set,dataSet))
21     L1,supportData=scanD(D,C1,minSupport)
22     L=[L1]
23     k=2
24     # 循环产生Lk，并放入列表中[L1,L2,.....Lk],直到Lk为空
25     while (len(L[k-2])>0):
26         Ck=aprioriGen(L[k-2],k)
27         Lk,supK=scanD(D,Ck,minSupport)
28         # 将新的集合支持度添加入支持度集合中去
29         supportData.update(supK)
30         L.append(Lk)
31         k+=1
32     return L,supportData

当我们输入一组数据时：[[1,3,4],[2,3,5],[1,2,3,5],[2,5]]，观察其构建的频繁项集。

完整代码如下：

 1 # 1.创建数据集
 2 def loadDataSet():
 3     return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
 4
 5 # 2.构建集合C1，C1是所有种类（大小为1）的集合
 6 def creatC1(dataSet):
 7     C1=[]
 8     for transaction in dataSet:
 9         for item in transaction:
10             if not [item] in C1:
11                 C1.append([item])
12     C1.sort()
13     # 与原文比有所修改
14     return list(map(frozenset,C1))
15
16 # 3.创建某一级频繁项集Lk
17 def scanD(D,Ck,minSupport):
18     ssCnt={}
19     for tid in D:
20         # print(tid)
21         for can in Ck:
22             # print(can)
23             # 判断tid中是否包含can
24             if can.issubset(tid):
25                 # 创建字典，key是can，值是次数
26                 # 与原文有所差别
27                 if not can in ssCnt:
28                     ssCnt[can]=1
29                 else:
30                     ssCnt[can]+=1
31     numItems=float(len(D))
32     retList=[]
33     supportData={}
34     for key in ssCnt:
35         # 计算每个key支持度
36         support=ssCnt[key]/numItems
37         # 如果支持度大于最小支持度，插入种类key，并添加入到关于支持度的字典
38         if support>=minSupport:
39             retList.insert(0,key)
40             supportData[key]=support
41     return retList,supportData
42
43 # 4.创建候选项集Ck
44 def aprioriGen(Lk,k):
45     retList=[]
46     lenLk=len(Lk)
47     # 将每一个集合与其他所有集合遍历配对，每两个元素检查其前k-2个值是否相同，如果相同，合并之，减小配对时间
48     for i in range(lenLk):
49         for j in range(i+1,lenLk):
50             # list[:k-2]返回的是前k-2个数
51             L1=list(Lk[i])[:k-2]
52             L2=list(Lk[j])[:k-2]
53             L1.sort()
54             L2.sort()
55             if L1==L2:
56                 retList.append(Lk[i]|Lk[j])
57     return retList
58
59 # 5.创建频繁项集L,及其对应的支持度
60 def apriori(dataSet,minSupport=0.5):
61     C1=creatC1(dataSet)
62     D=list(map(set,dataSet))
63     L1,supportData=scanD(D,C1,minSupport)
64     L=[L1]
65     k=2
66     # 循环产生Lk，并放入列表中[L1,L2,.....Lk],直到Lk为空
67     while (len(L[k-2])>0):
68         Ck=aprioriGen(L[k-2],k)
69         Lk,supK=scanD(D,Ck,minSupport)
70         # 将新的集合支持度添加入支持度集合中去
71         supportData.update(supK)
72         L.append(Lk)
73         k+=1
74     return L,supportData
75
76 dataSet=loadDataSet()
77 L,suppData=apriori(dataSet)
78 print(L)
79 print(suppData)

View Code

如图表达：

2.2 构建关联规则

　　主要用到的是分级法，可以首先从一个频繁项集开始，接着建立一个规则列表，其中规则右部只包含一个元素，测试这些规则，去掉不满足最低可信度条件的规则。接着再利用剩余的规则，合并，规则右边包含两个元素，一直往后延续。观察下面几个主要的程序更易理解。

 1 ''' freqSet--频繁项集
 2     H--频繁项集中的所有元素
 3 '''
 4 def generateRules(L,supportData,minConf=0.7):
 5     bigRuleList=[]
 6     for i in range(1,len(L)):
 7         for freqSet in L[i]:
 8             H1=[frozenset([item]) for item in freqSet]
 9             if (i>1):
10                 rulesFormConseq(freqSet,H1,supportData,bigRuleList,minConf)
11             else:
12                 calcConf(freqSet,H1,supportData,bigRuleList,minConf)
13     return bigRuleList
14
15 # 依次计算：【(freqSet-H中的单个元素)-->H中的单个元素】的可信度
16 def calcConf(freqSet,H,supportData,br1,minConf=0.7):
17     prunedH=[]
18     for conseq in H:
19         conf=supportData[freqSet]/supportData[freqSet-conseq]
20         # 如果大于最低可信度值，规则存入br1中，记录入prunedH
21         if conf>=minConf:
22             # print(freqSet-conseq,'-->',conseq,'conf:',conf)
23             br1.append((freqSet-conseq,conseq,conf))
24             prunedH.append(conseq)
25     return prunedH
26
27 # 建立某频繁集项的所有满足阈值条件的规则
28 def rulesFormConseq(freqSet,H,supportData,br1,minConf=0.7):
29     m=len(H[0])
30     # 分级法：右边是规则列表，从一个规则到两个规则到三个规则......
31     # 此处的 m+1 条件保证的是：创建最后一层级的规则不会使用所有频繁集项中的元素，即左边不会为空至少保证一个元素
32     if (len(freqSet)>(m+1)):
33         Hmp1=aprioriGen(H,m+1)
34         Hmp1=calcConf(freqSet,Hmp1,supportData,br1,minConf)
35         if (len(Hmp1)>1):
36             rulesFormConseq(freqSet,Hmp1,supportData,br1,minConf)

　　接着2.1中内容，找出关联规则，完整程序如下：

  1 # 1.创建数据集
  2 def loadDataSet():
  3     return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
  4
  5 # 2.构建集合C1，C1是所有种类（大小为1）的集合
  6 def creatC1(dataSet):
  7     C1=[]
  8     for transaction in dataSet:
  9         for item in transaction:
 10             if not [item] in C1:
 11                 C1.append([item])
 12     C1.sort()
 13     # 与原文比有所修改
 14     return list(map(frozenset,C1))
 15
 16 # 3.创建某一级频繁项集Lk
 17 def scanD(D,Ck,minSupport):
 18     ssCnt={}
 19     for tid in D:
 20         # print(tid)
 21         for can in Ck:
 22             # print(can)
 23             # 判断tid中是否包含can
 24             if can.issubset(tid):
 25                 # 创建字典，key是can，值是次数
 26                 # 与原文有所差别
 27                 if not can in ssCnt:
 28                     ssCnt[can]=1
 29                 else:
 30                     ssCnt[can]+=1
 31     numItems=float(len(D))
 32     retList=[]
 33     supportData={}
 34     for key in ssCnt:
 35         # 计算每个key支持度
 36         support=ssCnt[key]/numItems
 37         # 如果支持度大于最小支持度，插入种类key，并添加入到关于支持度的字典
 38         if support>=minSupport:
 39             retList.insert(0,key)
 40             supportData[key]=support
 41     return retList,supportData
 42
 43 # 4.创建候选项集Ck
 44 def aprioriGen(Lk,k):
 45     retList=[]
 46     lenLk=len(Lk)
 47     # 将每一个集合与其他所有集合遍历配对，每两个元素检查其前k-2个值是否相同，如果相同，合并之，减小配对时间
 48     for i in range(lenLk):
 49         for j in range(i+1,lenLk):
 50             # list[:k-2]返回的是前k-2个数
 51             L1=list(Lk[i])[:k-2]
 52             L2=list(Lk[j])[:k-2]
 53             L1.sort()
 54             L2.sort()
 55             if L1==L2:
 56                 retList.append(Lk[i]|Lk[j])
 57     return retList
 58
 59 # 5.创建频繁项集L,及其对应的支持度
 60 def apriori(dataSet,minSupport=0.5):
 61     C1=creatC1(dataSet)
 62     D=list(map(set,dataSet))
 63     L1,supportData=scanD(D,C1,minSupport)
 64     L=[L1]
 65     k=2
 66     # 循环产生Lk，并放入列表中[L1,L2,.....Lk],直到Lk为空
 67     while (len(L[k-2])>0):
 68         Ck=aprioriGen(L[k-2],k)
 69         Lk,supK=scanD(D,Ck,minSupport)
 70         # 将新的集合支持度添加入支持度集合中去
 71         supportData.update(supK)
 72         L.append(Lk)
 73         k+=1
 74     return L,supportData
 75
 76 ''' freqSet--频繁项集
 77     H--频繁项集中的所有元素
 78 '''
 79 def generateRules(L,supportData,minConf=0.7):
 80     bigRuleList=[]
 81     for i in range(1,len(L)):
 82         for freqSet in L[i]:
 83             H1=[frozenset([item]) for item in freqSet]
 84             if (i>1):
 85                 rulesFormConseq(freqSet,H1,supportData,bigRuleList,minConf)
 86             else:
 87                 calcConf(freqSet,H1,supportData,bigRuleList,minConf)
 88     return bigRuleList
 89
 90 # 依次计算：【(freqSet-H中的单个元素)-->H中的单个元素】的可信度
 91 def calcConf(freqSet,H,supportData,br1,minConf=0.7):
 92     prunedH=[]
 93     for conseq in H:
 94         conf=supportData[freqSet]/supportData[freqSet-conseq]
 95         # 如果大于最低可信度值，规则存入br1中，记录入prunedH
 96         if conf>=minConf:
 97             # print(freqSet-conseq,'-->',conseq,'conf:',conf)
 98             br1.append((freqSet-conseq,conseq,conf))
 99             prunedH.append(conseq)
100     return prunedH
101
102 # 建立某频繁集项的所有满足阈值条件的规则
103 def rulesFormConseq(freqSet,H,supportData,br1,minConf=0.7):
104     m=len(H[0])
105     # 分级法：右边是规则列表，从一个规则到两个规则到三个规则......
106     # 此处的 m+1 条件保证的是：创建最后一层级的规则不会使用所有频繁集项中的元素，即左边不会为空至少保证一个元素
107     if (len(freqSet)>(m+1)):
108         Hmp1=aprioriGen(H,m+1)
109         Hmp1=calcConf(freqSet,Hmp1,supportData,br1,minConf)
110         if (len(Hmp1)>1):
111             rulesFormConseq(freqSet,Hmp1,supportData,br1,minConf)
112
113 dataSet=loadDataSet()
114 L,suppData=apriori(dataSet)
115 rules=generateRules(L,suppData,minConf=0.5)
116 print(L)
117 print(suppData)
118 print(rules)

View Code

3.示例：毒蘑菇

　　完整程序：

  1 # 1.创建数据集
  2 def loadDataSet():
  3     return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
  4
  5 # 2.构建集合C1，C1是所有种类（大小为1）的集合
  6 def creatC1(dataSet):
  7     C1=[]
  8     for transaction in dataSet:
  9         for item in transaction:
 10             if not [item] in C1:
 11                 C1.append([item])
 12     C1.sort()
 13     # 与原文比有所修改
 14     return list(map(frozenset,C1))
 15
 16 # 3.创建某一级频繁项集Lk
 17 def scanD(D,Ck,minSupport):
 18     ssCnt={}
 19     for tid in D:
 20         # print(tid)
 21         for can in Ck:
 22             # print(can)
 23             # 判断tid中是否包含can
 24             if can.issubset(tid):
 25                 # 创建字典，key是can，值是次数
 26                 # 与原文有所差别
 27                 if not can in ssCnt:
 28                     ssCnt[can]=1
 29                 else:
 30                     ssCnt[can]+=1
 31     numItems=float(len(D))
 32     retList=[]
 33     supportData={}
 34     for key in ssCnt:
 35         # 计算每个key支持度
 36         support=ssCnt[key]/numItems
 37         # 如果支持度大于最小支持度，插入种类key，并添加入到关于支持度的字典
 38         if support>=minSupport:
 39             retList.insert(0,key)
 40             supportData[key]=support
 41     return retList,supportData
 42
 43 # 4.创建候选项集Ck
 44 def aprioriGen(Lk,k):
 45     retList=[]
 46     lenLk=len(Lk)
 47     # 将每一个集合与其他所有集合遍历配对，每两个元素检查其前k-2个值是否相同，如果相同，合并之，减小配对时间
 48     for i in range(lenLk):
 49         for j in range(i+1,lenLk):
 50             # list[:k-2]返回的是前k-2个数
 51             L1=list(Lk[i])[:k-2]
 52             L2=list(Lk[j])[:k-2]
 53             L1.sort()
 54             L2.sort()
 55             if L1==L2:
 56                 retList.append(Lk[i]|Lk[j])
 57     return retList
 58
 59 # 5.创建频繁项集L,及其对应的支持度
 60 def apriori(dataSet,minSupport=0.5):
 61     C1=creatC1(dataSet)
 62     D=list(map(set,dataSet))
 63     L1,supportData=scanD(D,C1,minSupport)
 64     L=[L1]
 65     k=2
 66     # 循环产生Lk，并放入列表中[L1,L2,.....Lk],直到Lk为空
 67     while (len(L[k-2])>0):
 68         Ck=aprioriGen(L[k-2],k)
 69         Lk,supK=scanD(D,Ck,minSupport)
 70         # 将新的集合支持度添加入支持度集合中去
 71         supportData.update(supK)
 72         L.append(Lk)
 73         k+=1
 74     return L,supportData
 75
 76 ''' freqSet--频繁项集
 77     H--频繁项集中的所有元素
 78 '''
 79 def generateRules(L,supportData,minConf=0.7):
 80     bigRuleList=[]
 81     for i in range(1,len(L)):
 82         for freqSet in L[i]:
 83             H1=[frozenset([item]) for item in freqSet]
 84             if (i>1):
 85                 rulesFormConseq(freqSet,H1,supportData,bigRuleList,minConf)
 86             else:
 87                 calcConf(freqSet,H1,supportData,bigRuleList,minConf)
 88     return bigRuleList
 89
 90 # 依次计算：【(freqSet-H中的单个元素)-->H中的单个元素】的可信度
 91 def calcConf(freqSet,H,supportData,br1,minConf=0.7):
 92     prunedH=[]
 93     for conseq in H:
 94         conf=supportData[freqSet]/supportData[freqSet-conseq]
 95         # 如果大于最低可信度值，规则存入br1中，记录入prunedH
 96         if conf>=minConf:
 97             print(freqSet-conseq,'-->',conseq,'conf:',conf)
 98             br1.append((freqSet-conseq,conseq,conf))
 99             prunedH.append(conseq)
100     return prunedH
101
102 # 建立某频繁集项的所有满足阈值条件的规则
103 def rulesFormConseq(freqSet,H,supportData,br1,minConf=0.7):
104     m=len(H[0])
105     # 分级法：右边是规则列表，从一个规则到两个规则到三个规则......
106     # 此处的 m+1 条件保证的是：创建最后一层级的规则不会使用所有频繁集项中的元素，即左边不会为空至少保证一个元素
107     if (len(freqSet)>(m+1)):
108         Hmp1=aprioriGen(H,m+1)
109         Hmp1=calcConf(freqSet,Hmp1,supportData,br1,minConf)
110         if (len(Hmp1)>1):
111             rulesFormConseq(freqSet,Hmp1,supportData,br1,minConf)
112
113
114 mushDatSet=[line.split() for line in open('mushroom.dat').readlines()]
115 print(mushDatSet)
116 L,suppData=apriori(mushDatSet,minSupport=0.3)
117 rules=generateRules(L,suppData,minConf=0.7)
118 for item in L[3]:
119     if item.intersection('2'):
120         print(item)
121 print(rules)
122 print(L)

View Code

转载于:https://www.cnblogs.com/Ray-0808/p/10953648.html

机器学习实战8-Apriori算法相关推荐

  1. 机器学习实战——密度聚类算法

    机器学习实战--密度聚类算法 1 密度聚类 2 sklearn中的实现 1 密度聚类 密度聚类假设聚类结构能够通过样本分布的密集程度确定,通常情形下,密度聚类算法从样本密度的角度来考察样本之间的可连接 ...

  2. 机器学习实战——层次聚类算法

    机器学习实战--层次聚类算法 1 层次聚类概述 2 sklearn中的实现 1 层次聚类概述 层次聚类试图在不同层次对数据集进行划分,从而形成树形的聚类结构. 数据集的划分可采用"自底向上& ...

  3. 机器学习-关联之Apriori算法原理及实战

    Apriori算法 前言 关联分析是一种无监督的机器学习方法,主要用于发现大规模数据集中事物之间的依存性和关联性.挖掘数据中隐藏的有价值的关系(如频繁项集.关联规则),有利于对相关事物进行预测,也能帮 ...

  4. 机器学习---实战---K-近邻算法--笔记

    参考:机器学习实战 一.概念重梳理 二.使用K-近邻算法改进约会网站的匹配效果关键要点 数据归一化:   转载于:https://www.cnblogs.com/qing1991/p/10163901 ...

  5. 算法代码[置顶] 机器学习实战之KNN算法详解

    改章节笔者在深圳喝咖啡的时候突然想到的...之前就有想写几篇关于算法代码的文章,所以回家到以后就奋笔疾书的写出来发表了     前一段时间介绍了Kmeans聚类,而KNN这个算法刚好是聚类以后经常使用 ...

  6. 【机器学习实战】KNN算法

    机器学习作为人工智能的重要分支,同时也是数据挖掘中不可或缺的算法支撑.本人接触时间不短,但研究尚浅.我计划用python来实现机器学习中较为常见的算法. 看透了自己,便无须小看别人. (老舍) 机器学 ...

  7. 【机器学习实战】KNN算法的两个经典例子(电影类型判断，约会网站的改进)

    KNN算法的两个常用实际例子 一.使用K-邻近算法来对电影的类型进行判断 1.实验思路: 2.代码实现: 3.运行截图: 4.完整代码展示: 二.在约会网站上使用KNN算法 (一)准备数据:从文本文件 ...

  8. 《机器学习实战》KNN算法实现

    本系列都是参考<机器学习实战>这本书,只对学习过程一个记录,不做详细的描述! 注释:看了一段时间Ng的机器学习视频,感觉不能光看不练,现在一边练习再一边去学习理论! KNN很早就之前就看过 ...

  9. 机器学习实战—使用FP-growth算法来高效发现频繁项集

    FP-growth算法基于Apriori构建,但采用了高级的数据结构减少扫描次数,大大加快了算法速度.FP-growth算法只需要对数据库进行两次扫描,而Apriori算法对于每个潜在的频繁项集都会扫 ...

  10. 模式识别和机器学习实战-K近邻算法（KNN）- Python实现 - 约会网站配对效果判断和手写数字识别

    文章目录 前言 一. k-近邻算法(KNN) 1.算法介绍 2.举个例子--电影分类 3.步骤描述 4.来了--代码实现 二.实战之约会网站配对效果判断 1.导入数据 2.分析数据 3.数据归一化 4 ...

最新文章

  1. linux 浏览器源码下载,Android开发：图片浏览器源码
  2. iangularjs 模板_AngularJS中的模板安全与作用域绑定
  3. Linux内核网络丢包查看工具dropwatch的安装和使用
  4. oracle数据库是db还是dbnms,Oracle数据库中各种类型的文件损坏与修复过程详解(2)...
  5. Redis添加密码认证Cacti监控读取Redis状态值为 -1 的最快速解决方案
  6. 使用xml及java代码混合的方式来设置图形界面
  7. vue笔记（四）注册组件，路由，vuex
  8. python 图形_Python图形数据
  9. 实战 | WebMagic 爬取某保险经纪人网站经纪人列表之网站列表爬取
  10. 为GridView-Delete列添加确认对话框（2种方法）
  11. ERP项目实施记录06
  12. python禁用键盘鼠标_在Python中禁用或锁定鼠标和键盘？
  13. HDU1290 重建希望小学【递推+打表】
  14. 1012 数字分类 (20 分)—PAT (Basic Level) Practice （中文）
  15. 1.1顺序表的初始化及基本操作（菜单实现）
  16. 上海项目危机经历与感想
  17. RemObjects Elements Crack,用途软件开发工具链
  18. jmeter配置远程运行
  19. 网络学习(一)--基本模型学习
  20. js-键盘事件案例-小人快跑

热门文章

  1. java集合框架介绍_Java集合框架全面介绍(一)
  2. [运维]PowerShell简体中文编码转换
  3. 抖音昵称html,抖音名字600个
  4. s5原生android 5.0,三星Galaxy S5/S4吃上原生安卓5.0棒棒糖
  5. java怎么对用户做自定义模版打印_Printing tools 自定义模板打印的实现
  6. 推荐模块︱apple.Turicreate个性化推荐recommender（五）
  7. saltstack系列~第四篇
  8. Java EnumMap工作原理及实现
  9. Android人脸检测类FaceDetector
  10. C++：在堆上创建对象，还是在栈上？