@ -1,8 +1,10 @@
# 8.3 动手实现Apriori
# 8.3 动手实现Apriori
```python
想要从数据中挖掘出关联规则，就需要先能够寻找频繁项集，所以首先我们可以实现一些用于寻找频繁项集的函数。
# 寻找频繁项集部分 Begin
频繁项集来源于项集，所以首先需要构建只有一个元素的项集，再构建只有两个元素的项集，...，一直到有 K 个元素的项集。因此首先需要构建只有一个元素的项集，构建的函数实现如下：
```python
# 构建只有一个元素的项集， 假设dataSet为[[1, 2], [0, 1]. [3, 4]]
# 构建只有一个元素的项集， 假设dataSet为[[1, 2], [0, 1]. [3, 4]]
# 那么该项集为frozenset({0}), frozenset({1}), frozenset({2}),frozenset({3}), frozenset({4})
# 那么该项集为frozenset({0}), frozenset({1}), frozenset({2}),frozenset({3}), frozenset({4})
def createC1(dataSet):
def createC1(dataSet):
@ -13,6 +15,11 @@ def createC1(dataSet):
C1.append([item])
C1.append([item])
C1.sort()
C1.sort()
return map(frozenset, C1)
return map(frozenset, C1)
```
有了从无到有之后，接下来需要从 1 到 K。不过需要注意的是， ：
```python
# 从只有k个元素的项集， ，
# 从只有k个元素的项集， ，
# D为数据集， ，
# D为数据集， ，
@ -35,7 +42,11 @@ def scanD(D, ck, minsupport):
supportData[key] = support
supportData[key] = support
#reList 为有k+1个元素的频繁项集，
#reList 为有k+1个元素的频繁项集，
return reList, supportData
return reList, supportData
```
这就完了吗？还没有，我们还需要一个能够实现构建含有 K 个元素的频繁项集的函数。实现代码如下：
```python
#构建含有k个元素的频繁项集
#构建含有k个元素的频繁项集
#如输入为{0},{1},{2}会生成{0,1},{0, 2},{1,2}
#如输入为{0},{1},{2}会生成{0,1},{0, 2},{1,2}
def aprioriGen(Lk, k):
def aprioriGen(Lk, k):
@ -48,7 +59,11 @@ def aprioriGen(Lk, k):
if L1 == L2:
if L1 == L2:
relist.append(Lk[i] | Lk[j])
relist.append(Lk[i] | Lk[j])
return reList
return reList
```
有了以上的函数之后，我们就可以根据生成候选频繁项集的流程，使用这些函数来实现这个功能了。代码如下：
```python
#生成候选的频繁项集列表，以及候选频繁项集的支持度，因为在算可信度时要用到
#生成候选的频繁项集列表，以及候选频繁项集的支持度，因为在算可信度时要用到
def apriori(dataSet, minsupport=0.5):
def apriori(dataSet, minsupport=0.5):
C1 = creatC1(dataSet)
C1 = creatC1(dataSet)
@ -62,12 +77,14 @@ def apriori(dataSet, minsupport=0.5):
supportData.update(supK)
supportData.update(supK)
L.append(Lk)
L.append(Lk)
k += 1
k += 1
# L为候选频繁项集列表，
return L, supportData
return L, supportData
```
# 寻找频繁项集部分 End 有了候选频繁项集和它的支持度之后，就可以开始着手挖掘关联规则了。在挖掘关联规则时，需要排除可信度比较小的关联规则，所以首先需要实现计算关联规则的可信度的功能。代码实现如下：
# 挖掘关联规则部分 Begin
```python
# 计算关联规则的可信度，并排除可信度小于最小可信度的关联规则
# 计算关联规则的可信度，并排除可信度小于最小可信度的关联规则
# freqSet为频繁项集， ， ， ，
# freqSet为频繁项集， ， ， ，
def calcConf(freqSet, H, supportData, brl, minConf = 0.7):
def calcConf(freqSet, H, supportData, brl, minConf = 0.7):
@ -78,7 +95,11 @@ def calcConf(freqSet, H, supportData, brl, minConf = 0.7):
brl.append((freqSet - conseq, conseq, conf))
brl.append((freqSet - conseq, conseq, conf))
prunedH.append(conseq)
prunedH.append(conseq)
return prunedH
return prunedH
```
接下来就需要实现从频繁项集中生成关联规则的功能了，若已经忘记了算法流程，可以翻看一下上一节的内容，实现如下：
```python
# 从频繁项集中生成关联规则
# 从频繁项集中生成关联规则
# freqSet为频繁项集， ， ， ，
# freqSet为频繁项集， ， ， ，
def ruleFromConseq(freqSet, H, supportData, brl, minConf = 0.7):
def ruleFromConseq(freqSet, H, supportData, brl, minConf = 0.7):
@ -88,7 +109,11 @@ def ruleFromConseq(freqSet, H, supportData, brl, minConf = 0.7):
Hmp1 = calcConf(freqSet, Hmp1, supporData, brl, minConf)
Hmp1 = calcConf(freqSet, Hmp1, supporData, brl, minConf)
if len(Hmp1) > 1:
if len(Hmp1) > 1:
ruleFromConseq(freqSet, Hmp1, supportData, brl, minConf)
ruleFromConseq(freqSet, Hmp1, supportData, brl, minConf)
```
由于使用`apriori`函数后得到的是一个候选频繁项集的列表，所以需要遍历整个候选频繁项集的列表来挖掘关联规则，所以代码实现如下：
```python
# 从频繁项集中挖掘关联规则
# 从频繁项集中挖掘关联规则
# L为频繁项集， ，
# L为频繁项集， ，
def generateRules(L, supportData, minConf = 0.7):
def generateRules(L, supportData, minConf = 0.7):
@ -105,4 +130,6 @@ def generateRules(L, supportData, minConf = 0.7):
return digRuleList
return digRuleList
# 挖掘关联规则部分 End
# 挖掘关联规则部分 End
```
```
到这里，我们已经实现了`Apriori`算法和关联规则挖掘算法。接下来，将介绍如何使用刚刚实现的算法来挖掘毒蘑菇的共性特征。
