【机器学习】 关联规则Apriori和mlxtend——推荐算法

引入：

啤酒与尿布的故事
关联规律挖掘：从交易数据中发现：买了X 还会买Y 的规则
关联规律挖掘‘购物篮分析’Market Basket Analysis（MBA）
关联规律->应用于推荐系统

1. 关联规则代码演示

使用的是mlxtend.frequent_patterns.Apriori()

import numpy as np
import pandas as pd

from mlxtend.frequent_patterns import apriori,association_rules
#TransactionEncoder 事务，编码
#事务：表示事件
#（比如每次去商场购买东西是一次事务，而实际购买到的东西就是项集）
from mlxtend.preprocessing import TransactionEncoder 
te = TransactionEncoder()
X =te.fit_transform(data)
colmns = te.columns_
df = pd.DataFrame(X,columns=colmns)
df.astype(np.uint8)

	尿布	橙汁	甜菜	莴苣	葡萄酒	豆奶
0	0	0	0	1	0	1
1	1	0	1	1	1	0
2	1	1	0	0	1	1
3	1	0	0	1	1	1
4	1	1	0	1	0	1

data=[['豆奶','莴苣'],
     ['莴苣','尿布','葡萄酒','甜菜'],
     ['豆奶','尿布','葡萄酒','橙汁'],
     ['莴苣','豆奶','尿布','葡萄酒'],
     ['莴苣','豆奶','尿布','橙汁']]
  
result =apriori(df,min_support=0.6,use_colnames=True)
result 

	support	itemsets
0	0.8	(尿布)
1	0.8	(莴苣)
2	0.6	(葡萄酒)
3	0.8	(豆奶)
4	0.6	(尿布, 莴苣)
5	0.6	(尿布, 葡萄酒)
6	0.6	(尿布, 豆奶)
7	0.6	(莴苣, 豆奶)

关联规则

条目 —》另一些条目之间有关联的

根据关联性强，进行推荐

推荐系统（小公司：分类，）

关联规则的三个计算:
支持度 support
置信度 confidence
提升度 lift

公式计算如下：

association_rules(result,min_threshold=0.5)

	antecedents	consequents	antecedent support	consequent support	support	confidence	lift	leverage	conviction
0	(尿布)	(莴苣)	0.8	0.8	0.6	0.75	0.9375	-0.04	0.8
1	(莴苣)	(尿布)	0.8	0.8	0.6	0.75	0.9375	-0.04	0.8
2	(尿布)	(葡萄酒)	0.8	0.6	0.6	0.75	1.2500	0.12	1.6
3	(葡萄酒)	(尿布)	0.6	0.8	0.6	1.00	1.2500	0.12	inf
4	(尿布)	(豆奶)	0.8	0.8	0.6	0.75	0.9375	-0.04	0.8
5	(豆奶)	(尿布)	0.8	0.8	0.6	0.75	0.9375	-0.04	0.8
6	(莴苣)	(豆奶)	0.8	0.8	0.6	0.75	0.9375	-0.04	0.8
7	(豆奶)	(莴苣)	0.8	0.8	0.6	0.75	0.9375	-0.04	0.8

探究关联规则的原始代码

import numpy as np 
def createC1(dataSet):
   C1 = []
   for transaction in dataSet:
       for item in transaction:
           if not [item] in C1:
               C1.append([item]) #store all the item unrepeatly

   C1.sort()
   #return map(frozenset, C1)#frozen set, user can't change it.
   return list(map(frozenset, C1))

def scanD(D,Ck,minSupport):
#参数：数据集、候选项集列表 Ck以及感兴趣项集的最小支持度 minSupport
   ssCnt={}
   for tid in D:#遍历数据集
       for can in Ck:#遍历候选项
           if can.issubset(tid):#判断候选项中是否含数据集的各项
               #if not ssCnt.has_key(can): # python3 can not support
               if not can in ssCnt:
                   ssCnt[can]=1 #不含设为1
               else: ssCnt[can]+=1#有则计数加1
   numItems=float(len(D))#数据集大小
   retList = []#L1初始化
   supportData = {}#记录候选项中各个数据的支持度
   for key in ssCnt:
       support = ssCnt[key]/numItems#计算支持度
       if support >= minSupport:
           retList.insert(0,key)#满足条件加入L1中
       supportData[key] = support
   return retList, supportData

def aprioriGen(Lk, k): #组合，向上合并
   #creates Ck 参数：频繁项集列表 Lk 与项集元素个数 k
   retList = []
   lenLk = len(Lk)
   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()
           if L1==L2: #若两个集合的前k-2个项相同时,则将两个集合合并
               retList.append(Lk[i] | Lk[j]) #set union
   return retList


def apriori(dataSet, minSupport = 0.5):
   C1 = createC1(dataSet)
   D = list(map(set, dataSet)) #python3
   L1, supportData = scanD(D, C1, minSupport)#单项最小支持度判断 0.5，生成L1
   L = [L1]
   k = 2
   while (len(L[k-2]) > 0):#创建包含更大项集的更大列表,直到下一个大的项集为空
       Ck = aprioriGen(L[k-2], k)#Ck
       Lk, supK = scanD(D, Ck, minSupport)#get Lk
       supportData.update(supK)
       L.append(Lk)
       k += 1
   return L, supportData

def generateRules(L, supportData, minConf=0.7):
   #频繁项集列表、包含那些频繁项集支持数据的字典、最小可信度阈值
   bigRuleList = [] #存储所有的关联规则
   for i in range(1, len(L)):  #只获取有两个或者更多集合的项目，从1,即第二个元素开始，L[0]是单个元素的
       # 两个及以上的才可能有关联一说，单个元素的项集不存在关联问题
       for freqSet in L[i]:
           H1 = [frozenset([item]) for item in freqSet]
           #该函数遍历L中的每一个频繁项集并对每个频繁项集创建只包含单个元素集合的列表H1
           if (i > 1):
           #如果频繁项集元素数目超过2,那么会考虑对它做进一步的合并
               rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
           else:#第一层时，后件数为1
               calcConf(freqSet, H1, supportData, bigRuleList, minConf)# 调用函数2
   return bigRuleList

def calcConf(freqSet, H, supportData, brl, minConf=0.7):
   #针对项集中只有两个元素时，计算可信度
   prunedH = []#返回一个满足最小可信度要求的规则列表
   for conseq in H:#后件，遍历 H中的所有项集并计算它们的可信度值
       conf = supportData[freqSet]/supportData[freqSet-conseq] #可信度计算，结合支持度数据
       if conf >= minConf:
           print (freqSet-conseq,'-->',conseq,'conf:',conf)
           #如果某条规则满足最小可信度值,那么将这些规则输出到屏幕显示
           brl.append((freqSet-conseq, conseq, conf))#添加到规则里，brl 是前面通过检查的 bigRuleList
           prunedH.append(conseq)#同样需要放入列表到后面检查
   return prunedH


def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
   #参数:一个是频繁项集,另一个是可以出现在规则右部的元素列表 H
   m = len(H[0])
   if (len(freqSet) > (m + 1)): #频繁项集元素数目大于单个集合的元素数
       Hmp1 = aprioriGen(H, m+1)#存在不同顺序、元素相同的集合，合并具有相同部分的集合
       Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)#计算可信度
       if (len(Hmp1) > 1):    
       #满足最小可信度要求的规则列表多于1,则递归来判断是否可以进一步组合这些规则
           rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf) 
data=[['豆奶','莴苣'],
    ['莴苣','尿布','葡萄酒','甜菜'],
    ['豆奶','尿布','葡萄酒','橙汁'],
    ['莴苣','豆奶','尿布','葡萄酒'],
    ['莴苣','豆奶','尿布','橙汁']] 
L, supportData = apriori(data,minSupport = 0.5)
# 频繁项集
display(L)
#计算
display(supportData)

[[frozenset({‘葡萄酒’}), frozenset({‘尿布’}), frozenset({‘豆奶’}), frozenset({‘莴苣’})],
[frozenset({‘尿布’, ‘豆奶’}),
frozenset({‘尿布’, ‘莴苣’}),
frozenset({‘尿布’, ‘葡萄酒’}),
frozenset({‘莴苣’, ‘豆奶’})],
[]]

{frozenset({‘莴苣’}): 0.8,
frozenset({‘豆奶’}): 0.8,
frozenset({‘尿布’}): 0.8,
frozenset({‘甜菜’}): 0.2,
frozenset({‘葡萄酒’}): 0.6,
frozenset({‘橙汁’}): 0.4,
frozenset({‘莴苣’, ‘豆奶’}): 0.6,
frozenset({‘尿布’, ‘葡萄酒’}): 0.6,
frozenset({‘莴苣’, ‘葡萄酒’}): 0.4,
frozenset({‘尿布’, ‘莴苣’}): 0.6,
frozenset({‘葡萄酒’, ‘豆奶’}): 0.4,
frozenset({‘尿布’, ‘豆奶’}): 0.6,
frozenset({‘尿布’, ‘莴苣’, ‘豆奶’}): 0.4}

 generateRules(L,supportData,minConf=0.8)

[(frozenset({‘葡萄酒’}), frozenset({‘尿布’}), 1.0)]

核心思想简单来说就是 ：
1、发现频繁项集过程为
①扫描（扫描所有数据）
②计数（计算各个候选集的支持度）
③比较（选出适合条件的频繁项集）
④产生频繁集
⑤连接、再剪枝产生候选集

2、产生关联规则。过程：根据前面提到的置信度的定义，关联规则的产生如下：
①对于每个频繁项集L，产生L的所有非空子集。
②对于L的每个非空子集S，如果P（L）/P（S）>=min_conf，则输出规则“Sa L-S”。（L-S表示在项集中除去S子集的项集。）

Apriori缺点：
①由频繁k-1项集进行自连接生成的候选频繁k项集数量巨大
②在验证候选频繁k项集的时候需要对整个数据库进行扫描，非常耗时。

扫描二维码关注公众号，回复： 8511966 查看本文章

更多推荐算法参考：
史上最全机器学习算法（源于逼乎）