#!/usr/bin/env python
# encoding: utf-8
'''
<<机器学习实战>> 读书笔记 第11章 使用Apriori算法进行关联分析
关键:
1 关联分析
含义:从大规模数据集中寻找物品之间的隐含关系
主要问题: 暴力搜索物品的不同组合很困难
2 Apriori算法
优点: 容易编码实现
缺点: 在大数据集上可能较慢
适用数据类型: 数值型或标称型数据
关系形式: 频繁项集或者关联规则
频繁项集: 经常出现在一块的物品的集合
关联规则: 暗示两种物品之间可能存在很强的关系
例子:
交易号码 商品
0 豆奶，莴苣
1 莴苣，尿布，葡萄酒，甜菜
2 豆奶，尿布，葡萄酒，橙汁
3 莴苣，豆奶，尿布， 葡萄酒
4 莴苣，豆奶，尿布，橙汁
支持度: 数据集中包含该项集额记录所占的比例。
上述例子中，{豆奶}支持度为4/5
5条交易记录中有3条: {豆奶，尿布}，{豆奶，尿布}的支持度为3/5
支持度特点: 可定义最小支持度
可信度/置信度:
含义: 是指针对一条诸如{尿布}->{葡萄酒}的关联规则来定义的。
规则可信度被定义为: "支持度({尿布，葡萄酒})/支持度({尿布})
由于{尿布，葡萄酒}支持度为3/5, {尿布}支持度为4/5，
所以 尿布 -> 葡萄酒 的可信度=3/4=0.75
意味着，对于包含尿布的所有记录，我们的规则对其中75%的记录都适用。
3 Apriori原理
作用: 帮我们减少感兴趣的项集。
原理: 如果某个项集是频繁的，那么它的所有子集也是频繁的。
如果一个项集是非频繁集，那么它的所有超集也是非频繁的。
举个例子:如果{0, 1}是频繁的，那么{0}和{1}也一定是频繁的。
apriori: 来自以前 。 定义问题时，会使用先验知识或假设，这被称作是一个先验。
例如: 贝叶斯统计。
先验知识可能来自领域知识，先前的一些测量结果等。
我的理解: 实际Apriori的原理就是类似剪枝，减小搜索规模。
4 使用Apriori算法来发现频繁项集
关联分析的目标: 发现频繁项集和发现关联规则。
处理过程: 先发现频繁项集，然后获得关联规则。
本节只关注发现频繁项集。
Apriori算法:
作用: 发现频繁项集
算法思想:
步骤1: 生成所有单个物品的项集列表
步骤2：扫描交易记录来查看哪些项集满足最小支持度要求，过滤不满足的
步骤3: 对剩余集合进行组合来生成包含两个元素的项集
步骤4：重新扫描交易记录，去掉不满足最小支持度的项集。
步骤5： 重复上述步骤，直到所有项集被去掉。
5 完整的Apriori算法
思想:
当集合项中的个数大于0时
构建一个k个项组成的候选项集的列表
确保每个项集都是频繁的
保留频繁项集并构建k+1项组成的候选项集的列表
apriori算法完整过程:
输入参数: 数据集dataSet(是一个列表， 列表中每个元素是列表)； 最小支持度minSupport(浮点数)
返回结果: 频繁项集结果列表(该频繁项集结果列表中的每个元素是一个列表，列表中的每个元素是frozenset类型的结果)
每个频繁项集对应的支持度
算法:
步骤1: 获取长度为1的候选项列表C1，具体计算过程如下:
1.1 遍历数据集(实际是数组)中每个元素
1.1.1 构建每个元素组成的数组；
1.1.2 如果该数组不在结果数组中，就放入到结果数组中；
1.2 对结果数组进行排序，并转换为fronzenset并返回
步骤2: 根据C1，数据集和最小支持度计算出满足最小支持度的频繁项集L1,以及频繁项集的支持度信息,
具体从候选集计算得到频繁集的过程如下:
2.1: 先创建一个空字典ssCnt
2.2: 遍历数据集中的所有交易记录以及C1中的所有候选集。
2.2.1 如果C1中的集合是记录中的一部分，则增加字典中对应的计数值。
2.3: 构建一个空列表作为满足做小支持度的集合。
2.4: 遍历步骤2.1中的字典ssCnt中每个元素，计算其支持度。
2.4.1 如果支持度满足最小支持度要求，则将字典元素放到结果列表中
2.4.2 更新频繁项集的支持度字典
2.5: 返回频繁项集的结果列表，返回频繁项集的支持度信息
步骤3: 创建一个频繁项集结果列表L，设定k=2
步骤4: 只要L[k-2]的长度大于0，就进入步骤5；否则，算法结束，返回频繁项集列表L和频繁项集对应的支持度信息
步骤5：根据频繁项集列表L[k-2]和所要求出的频繁项集的长度k，计算得到候选项集Ck,具体计算过程如下:
5.1 每次遍历频繁项集列表中任意两个不同的频繁项集
5.2 如果这两个频繁项集的前k-2是相同的，则将这两个频繁项集合并，并添加到结果列表中
5.3 返回结果列表，即为Ck
步骤6: 根据Ck, 数据集和最小支持度计算出频繁项集Lk和Lk频繁项集的支持度信息，并更新总的频繁项集的支持度信息
步骤7: 向频繁项集总的结果列表L中加入当前频繁项集Lk, 并令k累加
总结:
根据候选集Ck,数据集，最小支持度 --> 频繁集Lk
根据频繁集Lk, 所要求出的频繁项的长度k+1 -> 候选集Ck+1
根据候选集Ck+1, 数据集，最小支持度 --> 频繁集Lk+1
'''
def loadDataSet():
return [ [1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5] ]
'''
作用: 创建大小为1的所有候选项集的集合
算法:
步骤1: 解析数组中每个元素
步骤2: 构建每个元素组成的数组；
2.1 如果该数组不在结果数组中，就放入到结果数组中；
步骤3: 对结果数组进行排序，并转换为fronzenset并返回
'''
def createC1(dataSet):
if not dataSet:
return frozenset()
result = []
for arr in dataSet:
for value in arr:
if [value] not in result:
result.append([value])
result.sort()
'''
之所以使用frozenset:冻结集合是因为，它们不可改变，需要将这些集合作为
字典键值使用。
'''
return map(frozenset, result)
'''
作用: 用于从C1生成L1。
输入参数: 数据集D, 候选项列表Ck, 感兴趣项集的最小支持度minSupport
返回值: 返回一个包含支持度的字典
算法:
步骤1: 先创建一个空字典ssCnt
步骤2: 遍历数据集中的所有交易记录以及C1中的所有候选集。
2.1 如果C1中的集合是记录中的一部分，则增加字典中对应的计数值。
步骤3: 构建一个空列表作为满足做小支持度的集合。
步骤4: 遍历步骤1中的字典ssCnt中每个元素，计算其支持度。
4.1 如果支持度满足最小支持度要求，则将字典元素放到结果列表中
4.2 更新频繁项集的支持度字典
步骤5: 返回频繁项集的结果列表，返回最频繁项集的支持度
总结: 扫描算法其实就是两个过程。
第一个过程就是根据候选项集找到包含候选项的超集，并统计该候选项集出现的次数
第二个过程就是根据候选项集的出现次数，计算候选项的支持度，将满足最小支持度的候选项加入到最终结果列表中。
'''
def scanD(D, Ck, minSupport):
if not D or not Ck:
print "D is empty or Ck is empty, D is: {D} , Ck is: {Ck}".format(D=D, Ck=Ck)
canToTimes = {}
for tid in D:
for can in Ck:
if can.issubset(tid):
if canToTimes.has_key(can):
canToTimes[can] += 1
else:
canToTimes[can] = 1
result = []
canToSupport = {}
length = len(D)
for can, times in canToTimes.iteritems():
support = float(times) / length
if support >= minSupport:
result.insert(0, can)
canToSupport[can] = support
return result, canToSupport
'''
作用:
输入参数: 频繁项集列表Lk, 项集元素个数k(是输入的频繁项集列表中任意元素的长度值+1)
返回结果: 输出Ck。
举例: 该函数以{0}, {1}，{2}作为输入，会生成{0, 1}, {0, 2}和{1,2}
算法:
步骤1: 每次遍历频繁项集列表中任意两个不同的频繁项集
步骤2: 如果这两个频繁项集的前k-2是相同的，则将这两个频繁项集合并，并添加到结果列表中
'''
def aprioriGen(Lk, k):
if not Lk or k < 2:
print "Lk is empty or k < 2, Lk: {Lk}, k: {k}".format(Lk=Lk, k=k)
return
length = len(Lk)
results = []
for i in range(length):
for j in range(i + 1, length):
list1 = list(Lk[i])[: k - 2]
list2 = list(Lk[j])[: k - 2]
list1.sort()
list2.sort()
if list1 == list2:
result = Lk[i] | Lk[j]
results.append(result)
return results
'''
作用:
输入参数: 数据集dataSet(是一个列表， 列表中每个元素是列表)； 最小支持度minSupport(浮点数)
返回结果: 频繁项集结果列表(该频繁项集结果列表中的每个元素是一个列表，列表中的每个元素是frozenset类型的结果)
每个频繁项集对应的支持度
算法:
步骤1: 获取长度为1的候选项列表C1，具体计算过程如下:
1.1 遍历数据集(实际是数组)中每个元素
1.1.1 构建每个元素组成的数组；
1.1.2 如果该数组不在结果数组中，就放入到结果数组中；
1.2 对结果数组进行排序，并转换为fronzenset并返回
步骤2: 根据C1，数据集和最小支持度计算出满足最小支持度的频繁项集L1,以及频繁项集的支持度信息,
具体从候选集计算得到频繁集的过程如下:
2.1: 先创建一个空字典ssCnt
2.2: 遍历数据集中的所有交易记录以及C1中的所有候选集。
2.2.1 如果C1中的集合是记录中的一部分，则增加字典中对应的计数值。
2.3: 构建一个空列表作为满足做小支持度的集合。
2.4: 遍历步骤2.1中的字典ssCnt中每个元素，计算其支持度。
2.4.1 如果支持度满足最小支持度要求，则将字典元素放到结果列表中
2.4.2 更新频繁项集的支持度字典
2.5: 返回频繁项集的结果列表，返回频繁项集的支持度信息
步骤3: 创建一个频繁项集结果列表L，设定k=2
步骤4: 只要L[k-2]的长度大于0，就进入步骤5；否则，算法结束，返回频繁项集列表L和频繁项集对应的支持度信息
步骤5：根据频繁项集列表L[k-2]和所要求出的频繁项集的长度k，计算得到候选项集Ck,具体计算过程如下:
5.1 每次遍历频繁项集列表中任意两个不同的频繁项集
5.2 如果这两个频繁项集的前k-2是相同的，则将这两个频繁项集合并，并添加到结果列表中
5.3 返回结果列表，即为Ck
步骤6: 根据Ck, 数据集和最小支持度计算出频繁项集Lk和Lk频繁项集的支持度信息，并更新总的频繁项集的支持度信息
步骤7: 向频繁项集总的结果列表L中加入当前频繁项集Lk, 并令k累加
总结:
根据候选集Ck,数据集，最小支持度 --> 频繁集Lk
根据频繁集Lk, 所要求出的频繁项的长度k+1 -> 候选集Ck+1
根据候选集Ck+1, 数据集，最小支持度 --> 频繁集Lk+1
...
'''
def apriori(dataSet, minSupport=0.5):
C1 = createC1(dataSet)
D = map(set, dataSet)
L1, supportDict = scanD(D, C1, minSupport)
L = [L1]
k = 2
while len(L[k - 2]) > 0:
Ck = aprioriGen(L[k-2], k)
Lk, partialSupportDict = scanD(D, Ck, minSupport)
supportDict.update(partialSupportDict)
# note, Lk may be empty, if Lk is empty, it needs to end this recycle
if not Lk:
break
L.append(Lk)
k += 1
return L, supportDict
def process():
dataSet = loadDataSet()
L, supportDict = apriori(dataSet)
print "频繁项集支持度信息: {supportDict}".format(
supportDict=supportDict
)
for i, arr in enumerate(L):
print "频繁项集长度为{length}的频繁项集如下: {arr} ".format(length=i+1, arr=arr)
# C1 = createC1(dataSet)
# print "C1: {C1}".format(C1=C1)
# D = map(set, dataSet)
# print "D: {D}".format(D=D)
# minSupport = 0.5
# L1, canToSupport = scanD(D, C1, minSupport)
# print "L1: {L1},canToSupport: {canToSupport}".format(L1=L1, canToSupport=canToSupport)
if __name__ == "__main__":
process()
