关联规则分析是数据挖掘中最活跃的研究方法之一，目的是在一个数据集中找到各项之间的关联关系，而这种关系并没有在数据中直接体现出来。以超市的销售数据为例，当存在很多商品时，可能的商品组合数量达到了令人望而却步的程度，这是提取关联规则的最大困难。因此各种关联规则分析算法从不同方面入手减少可能的搜索空间大小以及减少扫描数据的次数。Apriori算法是最经典的挖掘频繁项集的算法，第一次实现在大数据集上的可行的关联规则提取，其核心思想是通过连接产生候选项及其支持度，然后通过剪枝生成频繁项集。
Apriori算法的主要思想是找出存在于事务数据集中最大的频繁项集，再利用得到的最大频繁项集与预先设定的最小置信度阈值生成强关联规则。
频繁项集的所有非空子集一定是频繁项集。根据这一性质可以得出：向不是频繁项集 I I I的项集中添加事务 A A A，新的项集 I ∪ A I∪A I∪A一定不是频繁项集。
第一步：
找出所有频繁项集（支持度必须大于等于给定的最小支持度阈值），在这个过程中连接步与剪枝步相互融合，最终得到最大频繁项集
L
k
L_k
Lk
第二步：
由频繁项集产生强关联规则。由第一步可知，未超过预定的最小支持阈值的项集已被剔除，如果剩下的这些项集又满足了预定的最小置信度阈值，那么就挖掘出了强关联规则。
以餐饮行业点餐数据为例，首先先将事务数据整理成关联规则模型所需的数据结构。设最小支持度为0.2，将菜品id编号
import numpy as np
import pandas as pd
def connect_string(x, ms):
"""
与1项频繁集连接生成新的项集
:param x: 项集
:param ms:
:return: 新的项集
"""
x = list(map(lambda i: sorted(i.split(ms)), x))
l = len(x[0])
r = []
for i in range(len(x)):
for j in range(i, len(x)):
if x[i][:l - 1] == x[j][:l - 1] and x[i][l - 1] != x[j][l - 1]:
r.append(x[i][:l - 1] + sorted([x[j][l - 1], x[i][l - 1]]))
return r
def find_rule(d, support, confidence, ms=u'-'):
"""
寻找关联规则
:param d: 数据集
:param support: 最小支持度
:param confidence: 最小置信度
:param ms: 项集之间连接符号
:return: 强关联规则以及其支持度与置信度
"""
# 存储输出结果
result = pd.DataFrame(index=['support', 'confidence'])
# 1项集的支持度序列
support_series = 1.0 * d.sum(axis=0) / d.shape[0]
# 基于给定的最小支持度进行筛选,得到1项频繁集
column = list(support_series[support_series > support].index)
# 当1项频繁集个数大于1时
k = 0
while len(column) > 1:
k = k + 1
print(u'\n正在进行第%s次搜索...' % k)
column = connect_string(column, ms)
print(u'数目：%s...' % len(column))
# 乘积为1表示两个项集同时发生，乘积为0表示不同发生
sf = lambda i: d[i].prod(axis=1, numeric_only=True) # 新一批支持度的计算函数
# 创建连接数据，这一步耗时、耗内存最严重。当数据集较大时，可以考虑并行运算优化。
d_2 = pd.DataFrame(list(map(sf, column)), index=[ms.join(i) for i in column]).T
# 计算连接后的支持度
support_series_2 = 1.0 * d_2[[ms.join(i) for i in column]].sum() / len(d)
column = list(support_series_2[support_series_2 > support].index) # 新一轮支持度筛选
support_series = support_series.append(support_series_2)
column2 = []
# 遍历可能的推理，如{A,B,C}究竟是A+B-->C还是B+C-->A还是C+A-->B？
for i in column:
i = i.split(ms)
for j in range(len(i)):
column2.append(i[:j] + i[j + 1:] + i[j:j + 1])
# 定义置信度序列
cofidence_series = pd.Series(index=[ms.join(i) for i in column2])
# 计算置信度序列
for i in column2:
cofidence_series[ms.join(i)] = support_series[ms.join(sorted(i))] / support_series[ms.join(i[:len(i) - 1])]
for i in cofidence_series[cofidence_series > confidence].index: # 置信度筛选
result[i] = 0.0
result[i]['confidence'] = cofidence_series[i]
result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))]
result = result.T.sort_values(['confidence', 'support'], ascending=False) # 结果整理，输出
print(u'\n结果为：')
print(result)
return result
if __name__ == '__main__':
# 加载数据
data = pd.read_excel('../data/menu_orders.xls', header=None)
print('转换原数据到0-1矩阵')
ct = lambda x: pd.Series(1, index=x[pd.notnull(x)])
b = map(ct, data.values)
data = pd.DataFrame(list(b)).fillna(0)
# 删除中间变脸b
del b
support = 0.2 # 最小支持度
confidence = 0.5 # 最小置信度
find_rule(data, support, confidence)
转换原数据到0-1矩阵
正在进行第1次搜索...
数目：6...
正在进行第2次搜索...
数目：3...
正在进行第3次搜索...
数目：0...
结果为：
support confidence
e-a 0.3 1.000000
e-c 0.3 1.000000
c-e-a 0.3 1.000000
a-e-c 0.3 1.000000
c-a 0.5 0.714286
a-c 0.5 0.714286
a-b 0.5 0.714286
c-b 0.5 0.714286
b-a 0.5 0.625000
b-c 0.5 0.625000
a-c-e 0.3 0.600000
b-c-a 0.3 0.600000
a-c-b 0.3 0.600000
a-b-c 0.3 0.600000
其中，'e—a’表示e发生能够推出a发生，置信度为100%，支持度30%。搜索出的关联规则并不一定有实际意义，需要根据问题背景筛选适当的有意义的规则，并赋予合理的解释。
import numpy as np
import pandas as pd
# 测试数据集，用于debug
def loadDataSet():
return [['a', 'c', 'e'], ['b', 'd'], ['b', 'c'], ['a', 'b', 'c', 'd'], ['a', 'b'], ['b', 'c'], ['a', 'b'],
['a', 'b', 'c', 'e'], ['a', 'b', 'c'], ['a', 'c', 'e']]
def loaddata():
order_data = pd.read_csv('data/GoodsOrder.csv', header=0, encoding='gbk')
# 转换数据格式
order_data['Goods'] = order_data['Goods'].apply(lambda x: "," + x)
order_data = order_data.groupby('id').sum().reset_index()
order_data['Goods'] = order_data['Goods'].apply(lambda x: [x[1:]])
order_data_list = list(order_data['Goods'])
# print(order_data_list)
# 分割商品名为每一个元素
data_translation = []
for i in order_data_list:
# 列表中元素为1个字符串，所以用0索引
p = i[0].split(",")
data_translation.append(p)
return data_translation
def creatC1(data):
"""
找到1项候选集C1
:param data: 数据集
:return: 1项候选集C1
"""
C1 = []
for row in dataSet:
for item in row:
if [item] not in C1:
C1.append([item])
# 中文字符串升序排序
C1.sort()
# frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
return list(map(frozenset, C1))
def calSupport(D, C, minSupport):
"""
计算1项候选集的支持度,剔除小于最小支持度的项集，
:param D: 数据集
:param C1: 候选集
:param minSupport: 最小支持度
:return: 返回1项频繁集及其支持度
"""
dict_sup = {} # 中间储存变量，用于计数
# 迭代每一条数据，对项集中的每一项进行计数
for i in D:
for j in C:
# 集合j是否是集合i的子集，如果是返回True，否则返回False
if j.issubset(i):
# 再判断之前有没有统计过，没有统计过的话为1
if j not in dict_sup:
dict_sup[j] = 1
else:
dict_sup[j] += 1
# 事务总数
sumCount = float(len(D))
# 计算支持度，支持度 = 项集的计数/事务总数
supportData = {} # 用于存储频繁集的支持度
relist = [] # 用于存储频繁集
for i in dict_sup:
temp_sup = dict_sup[i] / sumCount
# 将剔除后的频繁项集及其对应支持度保存起来
if temp_sup > minSupport:
relist.append(i)
supportData[i] = temp_sup
# 返回1项频繁项集及其对应支持度
return relist, supportData
def aprioriGen(Lk, k):
"""
改良了剪枝步，原来的Ck是由L1与L(k-1)来连接产生的，这里采用了新的连接方式
使用剪枝算法，减少了候选集空间，找到k项候选集
:param Lk: k-1项频繁集
:param k: 第k项
:return: 第k项候选集
"""
reList = [] # 用来存储第k项候选集
lenLk = len(Lk) # 第k-1项频繁集的长度
# 两两组合遍历
for i in range(lenLk):
for j in range(i + 1, lenLk):
L1 = list(Lk[i])[:k - 2]
L2 = list(Lk[j])[:k - 2]
L1.sort()
L2.sort()
# 前k-1项相等，则可相乘，这样可以防止重复项出现
if L1 == L2:
a = Lk[i] | Lk[j] # a为frozenset集合
# 进行剪枝
a1 = list(a) # a1为k项集中的一个元素
b = [] # b为它的所有k-1项子集
# 构造b:遍历取出每一个元素，转换为set，依次从a1中剔除该元素，并加入到b中
for q in range(len(a1)):
t = [a1[q]]
tt = frozenset(set(a1) - set(t))
b.append(tt)
# 当b都是频繁集时，则保留a1,否则，删除
t = 0
for w in b:
# 如果为True，说明是属于候选集，否则不属于候选集
if w in Lk:
t += 1
# 如果它的子集都为频繁集，则a1是候选集
if len(b) == t:
reList.append(b[0] | b[1])
return reList
def scanD(D, Ck, minSupport):
"""
计算候选k项集的支持度，剔除小于最小支持度的候选集，得到频繁k项集及其支持度
:param D: 数据集
:param Ck: 候选k项集
:param minSupport: 最小支持度
:return: 返回频繁k项集及其支持度
"""
sscnt = {} # 存储支持度
for tid in D: # 遍历数据集
for can in Ck: # 遍历候选项
if can.issubset(tid): # 判断数据集中是否含有候选集各项
if can not in sscnt:
sscnt[can] = 1
else:
sscnt[can] += 1
# 计算支持度
numItem = len(D) # 事务总数
reList = [] # 存储k项频繁集
supportData = {} # 存储频繁集对应支持度
for key in sscnt:
support = sscnt[key] / numItem
if support > minSupport:
reList.insert(0, key) # 满足条件的加入Lk中
supportData[key] = support
return reList, supportData
def apriori(dataSet, minSupport=0.2):
"""
apriori关联规则算法
:param data: 数据集
:param minSupport: 最小支持度
:return: 返回频繁集及对应的支持度
"""
# 首先，找到1项候选集
C1 = creatC1(dataSet)
# 使用list()转化为列表，用于支持度计算
D = list(map(set, dataSet))
# 计算1项候选集的支持度,剔除小于最小支持度的项集，返回1项频繁集及其支持度
L1, supportData = calSupport(D, C1, minSupport)
L = [L1] # 加列表框，使得1项频繁集称为一个单独的元素
k = 2 # k项
# 跳出循环的条件是没有候选集
while len(L[k - 2]) > 0:
# 产生k项候选集Ck
Ck = aprioriGen(L[k - 2], k)
# 计算候选k项集的支持度，剔除小于最小支持度的候选集，得到频繁k项集及其支持度
Lk, supK = scanD(D, Ck, minSupport)
# 将supK中的键值对添加到supportData
supportData.update(supK)
# 将第k项的频繁集添加到L中
L.append(Lk) # L的最后一个值为空值
k += 1
del L[-1]
# 返回频繁集及其对应的支持度；L为频繁项集，是一个列表，1,2，3项集分别为一个元素
return L, supportData
def getSubset(fromList, totalList):
"""
生成集合的所有子集
:param fromList:
:param totalList:
"""
for i in range(len(fromList)):
t = [fromList[i]]
tt = frozenset(set(fromList) - set(t)) # k-1项子集
if tt not in totalList:
totalList.append(tt)
tt = list(tt)
if len(tt) > 1:
getSubset(tt, totalList) # 所有非1项子集
def calcConf(freqSet, H, supportData, ruleList, minConf):
"""
计算置信度，并剔除小于最小置信度的数据,这里利用了提升度概念
:param freqSet: k项频繁集
:param H: k项频繁集对应的所有子集
:param supportData: 支持度
:param RuleList: 强关联规则
:param minConf: 最小置信度
"""
# 遍历freqSet中的所有子集并计算置信度
for conseq in H:
conf = supportData[freqSet] / supportData[freqSet - conseq] # 相当于把事务总数抵消了
# 提升度lift计算lift=p(a&b)/p(a)*p(b)
lift = supportData[freqSet] / (supportData[conseq] * supportData[freqSet - conseq])
if conf >= minConf and lift > 1:
print(freqSet - conseq, '-->', conseq, '支持度', round(supportData[freqSet], 6), '置信度：', round(conf, 6),
'lift值为：', round(lift, 6))
ruleList.append((freqSet - conseq, conseq, conf))
def get_rule(L, supportData, minConf=0.7):
"""
生成强关联规则：频繁项集中满足最小置信度阈值，就会生成强关联规则
:param L: 频繁集
:param supportData: 支持度
:param minConf: 最小置信度
:return: 返回强关联规则
"""
bigRuleList = [] # 存储强关联规则
# 从2项频繁集开始计算置信度
for i in range(1, len(L)):
for freqSet in L[i]:
H1 = list(freqSet)
all_subset = [] # 存储H1的所有子集
# 生成所有子集
getSubset(H1, all_subset)
# print(all_subset)
# 计算置信度，并剔除小于最小置信度的数据
calcConf(freqSet, all_subset, supportData, bigRuleList, minConf)
return bigRuleList
if __name__ == '__main__':
dataSet = loaddata()
# 返回频繁集及其对应的支持度
L, supportData = apriori(dataSet, minSupport=0.02)
# 生成强关联规则
rule = get_rule(L, supportData, minConf=0.35)
生成的强关联规则如下：
frozenset({'水果/蔬菜汁'}) --> frozenset({'全脂牛奶'}) 支持度 0.02664 置信度： 0.368495 lift值为： 1.44216
frozenset({'人造黄油'}) --> frozenset({'全脂牛奶'}) 支持度 0.024199 置信度： 0.413194 lift值为： 1.617098
frozenset({'仁果类水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.030097 置信度： 0.397849 lift值为： 1.557043
frozenset({'牛肉'}) --> frozenset({'全脂牛奶'}) 支持度 0.021251 置信度： 0.405039 lift值为： 1.58518
frozenset({'冷冻蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.020437 置信度： 0.424947 lift值为： 1.663094
frozenset({'本地蛋类'}) --> frozenset({'其他蔬菜'}) 支持度 0.022267 置信度： 0.350962 lift值为： 1.813824
frozenset({'黄油'}) --> frozenset({'其他蔬菜'}) 支持度 0.020031 置信度： 0.361468 lift值为： 1.868122
frozenset({'本地蛋类'}) --> frozenset({'全脂牛奶'}) 支持度 0.029995 置信度： 0.472756 lift值为： 1.850203
frozenset({'黑面包'}) --> frozenset({'全脂牛奶'}) 支持度 0.025216 置信度： 0.388715 lift值为： 1.521293
frozenset({'糕点'}) --> frozenset({'全脂牛奶'}) 支持度 0.033249 置信度： 0.373714 lift值为： 1.462587
frozenset({'酸奶油'}) --> frozenset({'其他蔬菜'}) 支持度 0.028876 置信度： 0.402837 lift值为： 2.081924
frozenset({'猪肉'}) --> frozenset({'其他蔬菜'}) 支持度 0.021657 置信度： 0.375661 lift值为： 1.941476
frozenset({'酸奶油'}) --> frozenset({'全脂牛奶'}) 支持度 0.032232 置信度： 0.449645 lift值为： 1.759754
frozenset({'猪肉'}) --> frozenset({'全脂牛奶'}) 支持度 0.022166 置信度： 0.38448 lift值为： 1.504719
frozenset({'根茎类蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.048907 置信度： 0.448694 lift值为： 1.756031
frozenset({'根茎类蔬菜'}) --> frozenset({'其他蔬菜'}) 支持度 0.047382 置信度： 0.434701 lift值为： 2.246605
frozenset({'凝乳'}) --> frozenset({'全脂牛奶'}) 支持度 0.026131 置信度： 0.490458 lift值为： 1.919481
frozenset({'热带水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.042298 置信度： 0.403101 lift值为： 1.577595
frozenset({'柑橘类水果'}) --> frozenset({'全脂牛奶'}) 支持度 0.030503 置信度： 0.36855 lift值为： 1.442377
frozenset({'黄油'}) --> frozenset({'全脂牛奶'}) 支持度 0.027555 置信度： 0.497248 lift值为： 1.946053
frozenset({'酸奶'}) --> frozenset({'全脂牛奶'}) 支持度 0.056024 置信度： 0.401603 lift值为： 1.571735
frozenset({'其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.074835 置信度： 0.386758 lift值为： 1.513634
frozenset({'全脂牛奶', '酸奶'}) --> frozenset({'其他蔬菜'}) 支持度 0.022267 置信度： 0.397459 lift值为： 2.054131
frozenset({'酸奶', '其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.022267 置信度： 0.512881 lift值为： 2.007235
frozenset({'全脂牛奶', '根茎类蔬菜'}) --> frozenset({'其他蔬菜'}) 支持度 0.023183 置信度： 0.474012 lift值为： 2.44977
frozenset({'根茎类蔬菜', '其他蔬菜'}) --> frozenset({'全脂牛奶'}) 支持度 0.023183 置信度： 0.48927 lift值为： 1.914833
import numpy as np
import pandas as pd
import xlrd
from mlxtend.frequent_patterns import apriori # 生成频繁项集
from mlxtend.frequent_patterns import association_rules # 生成强关联规则
import warnings
warnings.filterwarnings("ignore") # 用于排除警告
def loaddata():
order_data = pd.read_csv('data/GoodsOrder.csv', header=0, encoding='gbk')
# 转换数据格式
order_data['Goods'] = order_data['Goods'].apply(lambda x: "," + x)
order_data = order_data.groupby('id').sum().reset_index()
order_data['Goods'] = order_data['Goods'].apply(lambda x: [x[1:]])
order_data_list = list(order_data['Goods'])
# print(order_data_list)
# 分割商品名为每一个元素
data_translation = []
for i in order_data_list:
# 列表中元素为1个字符串，所以用0索引
p = i[0].split(",")
data_translation.append(p)
return data_translation
if __name__ == '__main__':
dataSet = loaddata()
column_list = []
for var in dataSet:
column_list = set(column_list) | set(var)
print('转换原数据到0-1矩阵')
data = pd.DataFrame(np.zeros((len(dataSet), 169)), columns=column_list)
for i in range(len(dataSet)):
for j in dataSet[i]:
data.loc[i, j] += 1
# apriori算法
frequent_itemsets = apriori(data, min_support=0.02, use_colnames=True)
print(pd.DataFrame(frequent_itemsets))
pd.DataFrame(frequent_itemsets).to_csv('frequent_itemsets.csv')
# 生成关联准则
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.35)
print(pd.DataFrame(rules))
pd.DataFrame(rules).to_csv('rules.csv')
support itemsets
0 0.038434 (威化饼)
1 0.026029 (一般饮料)
2 0.025826 (一般肉类)
3 0.033452 (超高温杀菌的牛奶)
4 0.064870 (黑面包)
.. ... ...
117 0.024301 (香肠, 苏打)
118 0.027351 (苏打, 酸奶)
119 0.021047 (苏打, 糕点)
120 0.023183 (根茎类蔬菜, 全脂牛奶, 其他蔬菜)
121 0.022267 (酸奶, 全脂牛奶, 其他蔬菜)
[122 rows x 2 columns]
antecedents consequents ... leverage conviction
0 (黑面包) (全脂牛奶) ... 0.008641 1.217899
1 (猪肉) (全脂牛奶) ... 0.007435 1.209520
2 (猪肉) (其他蔬菜) ... 0.010502 1.291779
3 (牛肉) (全脂牛奶) ... 0.007845 1.251315
4 (根茎类蔬菜) (全脂牛奶) ... 0.021056 1.350401
5 (根茎类蔬菜) (其他蔬菜) ... 0.026291 1.426693
6 (水果/蔬菜汁) (全脂牛奶) ... 0.008168 1.178904
7 (其他蔬菜) (全脂牛奶) ... 0.025394 1.214013
8 (人造黄油) (全脂牛奶) ... 0.009235 1.268706
9 (凝乳) (全脂牛奶) ... 0.012517 1.461085
10 (黄油) (全脂牛奶) ... 0.013395 1.480817
11 (柑橘类水果) (全脂牛奶) ... 0.009355 1.179008
12 (冷冻蔬菜) (全脂牛奶) ... 0.008149 1.294636
13 (热带水果) (全脂牛奶) ... 0.015486 1.247252
14 (酸奶油) (全脂牛奶) ... 0.013916 1.352735
15 (本地蛋类) (全脂牛奶) ... 0.013783 1.412030
16 (酸奶) (全脂牛奶) ... 0.020379 1.244132
17 (糕点) (全脂牛奶) ... 0.010516 1.188729
18 (仁果类水果) (全脂牛奶) ... 0.010767 1.236375
19 (黄油) (其他蔬菜) ... 0.009308 1.263065
20 (酸奶油) (其他蔬菜) ... 0.015006 1.350565
21 (本地蛋类) (其他蔬菜) ... 0.009991 1.242619
22 (根茎类蔬菜, 全脂牛奶) (其他蔬菜) ... 0.013719 1.533320
23 (根茎类蔬菜, 其他蔬菜) (全脂牛奶) ... 0.011076 1.457687
24 (全脂牛奶, 酸奶) (其他蔬菜) ... 0.011427 1.338511
25 (酸奶, 其他蔬菜) (全脂牛奶) ... 0.011174 1.528340
[26 rows x 9 columns]
参考于《python数据分析与挖掘实战》，后面有时间的话，会基于《机器学习实战》学习一下FP-Tree关联规则分析
如果对您有帮助，麻烦点赞关注，这真的对我很重要！！！如果需要互关，请评论留言！
