数据挖掘Apriori算法

数据挖掘Apriori算法

数据挖掘（Data Mining）就是从大量的、不完全的、有噪声的、模糊的、随机的实际应用数据中，提取隐含在其中的、人们事先不知道的、但又是潜在有用的信息和知识的过程。挖掘的原始数据可以是结构化的，如关系数据库中的数据；也可以是半结构化的，如文本、图形和图像数据；甚至是分布在网络上的异构型数据。

数据挖掘的几种主要形式:

规则挖掘： 

如果一个事务中含有X，则该事务中很可能含有Y。具体形式为{X}→{Y}，即通常可以描述为:当一个事务中顾客购买了一样东西{啤酒}(这里X=“啤酒”)则很可能他同时还购买了{尿布}(这里Y= "尿布")，这就是关联规则。

Apriori算法描述

Apriori算法采用的方法：首先产生频繁1项集L₁，然后用L₁经过自连接、剪枝生成L₂（频繁2-项集），然后L₂有生成L₃，依次迭代直到无法生成新的频繁项集为止。然后根据给定的最小可信度，利用生成的频繁项集产生强关联规则。

第一阶段：产生频繁项集 该过程通过以下步骤实现：

（1）所有单独的项都是候选项集C₁。任何支持度值比给定的最小支持度小的项都将从候选项集C₁中剔除，形成频繁1-项集L₁。

（2）两个通过自连接形成具有2个项的候选项集。通过再次扫描数据库确定这些候选项的支持度。保留大于之前设定的最小支持度阈值的候选项，形成频繁2-项集。

（3）下一步形成含有3个项的候选项集C₃，重复之前的操作直到无法生成新的频繁项集为止。

代码描述

# -*- coding: utf-8 -*-
"""
Apriori exercise.
Created on Fri Nov 27 11:09:03 2015
@author: alexChen
"""
def loadDataSet():
    '''创建一个用于测试的简单的数据集'''
    return [ [ 1, 3, 4 ], [ 2, 3, 5 ], [ 1, 2, 3, 5 ], [ 2, 5 ] ]
def createC1( dataSet ):
    '''
    构建初始候选项集的列表，即所有候选项集只包含一个元素，
    C1是大小为1的所有候选项集的集合
    '''
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if [ item ] not in C1:
                C1.append( [ item ] )
    C1.sort()
    return map( frozenset, C1 )
def scanD( D, Ck, minSupport ):
    '''
    计算Ck中的项集在数据集合D(记录或者transactions)中的支持度,
    返回满足最小支持度的项集的集合，和所有项集支持度信息的字典。
    '''
    ssCnt = {}
    for tid in D:
        # 对于每一条transaction
        for can in Ck:
            # 对于每一个候选项集can，检查是否是transaction的一部分
            # 即该候选can是否得到transaction的支持
            if can.issubset( tid ):
                ssCnt[ can ] = ssCnt.get( can, 0) + 1
    numItems = float( len( D ) )
    retList = []
    supportData = {}
    for key in ssCnt:
        # 每个项集的支持度
        support = ssCnt[ key ] / numItems
        # 将满足最小支持度的项集，加入retList
        if support >= minSupport:
            retList.insert( 0, key )
        # 汇总支持度数据
        supportData[ key ] = support
    return retList, supportData
if __name__ == '__main__':
    # 导入数据集
    myDat = loadDataSet()
    # 构建第一个候选项集列表C1
    C1 = createC1( myDat )

    # 构建集合表示的数据集 D
    D = map( set, myDat )
    # 选择出支持度不小于0.5 的项集作为频繁项集
    L, suppData = scanD( D, C1, 0.5 )

    print u"频繁项集L：", L
    print u"所有候选项集的支持度信息：", suppData

    # Aprior算法
def aprioriGen( Lk, k ):
    '''
    由初始候选项集的集合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:
                retList.append( Lk[ i ] | Lk[ j ] )
    return retList
def apriori( dataSet, minSupport = 0.5 ):
    # 构建初始候选项集C1
    C1 = createC1( dataSet )
    # 将dataSet集合化，以满足scanD的格式要求
    D = map( set, dataSet )
    # 构建初始的频繁项集，即所有项集只有一个元素
    L1, suppData = scanD( D, C1, minSupport )
    L = [ L1 ]
    # 最初的L1中的每个项集含有一个元素，新生成的
    # 项集应该含有2个元素，所以 k=2
    k = 2
    while ( len( L[ k - 2 ] ) > 0 ):
        Ck = aprioriGen( L[ k - 2 ], k )
        Lk, supK = scanD( D, Ck, minSupport )
        # 将新的项集的支持度数据加入原来的总支持度字典中
        suppData.update( supK )
        # 将符合最小支持度要求的项集加入L
        L.append( Lk )
        # 新生成的项集中的元素个数应不断增加
        k += 1
    # 返回所有满足条件的频繁项集的列表，和所有候选项集的支持度信息
    return L, suppData

第二阶段：产生关联规则

从事务数据库 D 中挖掘出频繁所有的频繁项集后，就可以比较容易的获得相应的关联规则，即满足可信度> min_conf 的频繁项集产生强关联规则。由于规则是由频繁项集产生，所以每个规则自动满足最小支持度min_sup。使用频繁项集X生成关联规则。

代码描述如下：

# 规则生成与评价  
def calcConf( freqSet, H, supportData, brl, minConf=0.7 ):
  '''
  计算规则的可信度，返回满足最小可信度的规则。
  freqSet(frozenset):频繁项集
  H(frozenset):频繁项集中所有的元素
  supportData(dic):频繁项集中所有元素的支持度
  brl(tuple):满足可信度条件的关联规则
  minConf(float):最小可信度
  '''
  prunedH = []
  for conseq in H:
    conf = supportData[ freqSet ] / supportData[ freqSet - conseq ]
    if conf >= minConf:
      print freqSet - conseq, '-->', conseq, 'conf:', conf
      brl.append( ( freqSet - conseq, conseq, conf ) )
      prunedH.append( conseq )
  return prunedH
def rulesFromConseq( freqSet, H, supportData, brl, minConf=0.7 ):
  '''
  对频繁项集中元素超过2的项集进行合并。
  freqSet(frozenset):频繁项集
  H(frozenset):频繁项集中的所有元素，即可以出现在规则右部的元素
  supportData(dict):所有项集的支持度信息
  brl(tuple):生成的规则
  '''
  m = len( H[ 0 ] )
  # 查看频繁项集是否大到移除大小为 m 的子集
  if len( freqSet ) > m + 1:
    Hmp1 = aprioriGen( H, m + 1 )
    Hmp1 = calcConf( freqSet, Hmp1, supportData, brl, minConf )
    # 如果不止一条规则满足要求，进一步递归合并
    if len( Hmp1 ) > 1:
      rulesFromConseq( freqSet, Hmp1, supportData, brl, minConf )
def generateRules( L, supportData, minConf=0.7 ):
  '''
  根据频繁项集和最小可信度生成规则。
  L(list):存储频繁项集
  supportData(dict):存储着所有项集（不仅仅是频繁项集）的支持度
  minConf(float):最小可信度
  '''
  bigRuleList = []
  for i in range( 1, len( L ) ):
    for freqSet in L[ i ]:
      # 对于每一个频繁项集的集合freqSet
      H1 = [ frozenset( [ item ] ) for item in freqSet ]
      # 如果频繁项集中的元素个数大于2，需要进一步合并
      if i > 1:
        rulesFromConseq( freqSet, H1, supportData, bigRuleList, minConf )
      else:
        calcConf( freqSet, H1, supportData, bigRuleList, minConf )
  return bigRuleList

第三阶段，测试：

if __name__ == '__main__':
    # 导入数据集
    myDat = loadDataSet()
    # 选择频繁项集
    L, suppData = apriori( myDat, 0.5 )

    rules = generateRules( L, suppData, minConf=0.7 )
    print 'rules:\n', rules