文档章节

推荐系统(一):频繁模式挖掘的FPGrowth实现

阿拉德大陆的魔法师
 阿拉德大陆的魔法师
发布于 2016/04/08 14:51
字数 3032
阅读 383
收藏 11

    算法说明:FPGrowth算法是用来做购物车分析,说白了就是分析下什么商品和什么商品会被一同购买,还有一同购买的频次是多少,经常被一同购买的商品就可以放到一起做推荐了。

频繁模式挖掘关键词说明:

  • 挖掘数据机:购物篮数据

  • 频繁模式:频繁出现在数据集当中的模式:项集、子结构、子序列

  • 挖掘目标:频繁项集,频繁模式,关联规则

  • 关联规则:牛奶=>鸡蛋,[支持度=2%,置信度=60%]

  • 支持度:%2的购物车买了牛奶也买了鸡蛋,可用百分比也可用具体数字

  • 置信度:60%购买了牛奶的人同时买了鸡蛋

  • 最小支持度:支持度阀值

  • 项集:商品集合

  • K-项集:K个商品组成的集合

  • 频繁项集:满足最小支持度的项集

下面我们来看下如何通过FPGrowth算法来进行频繁模式挖掘:

1.我们要有一个购物车数据集

I1,I2,I4
I1,I2,I5
I2,I4
I2,I3
I1,I3
I2,I3
I1,I3
I1,I2,I3,I5
I1,I2,I3

2.定一个最小支持度计数,我们暂定为2。

3.下面我们要建立FPTree,FP树是对购物车数据集的一个重构,也是我们FPGrowth算法的基础。我们从韩家炜的书中,摘取出一副FPTree的构造图,然后来分析一下这棵树是如何建立的。首先对购物车的所有商品按支持度计数(在购物车中出线几次)排序,同时放弃支持度计数小于最小支持度计数的项,形成频繁项头链表。以频繁项头链表为基准,扫描每条购物车信息,排序并删除支持度计数过小的项。先建立null结点(FPTree根节点),读入一条购物车信息,按顺序建立树形结构,如果结点已存在直接增加该结点的支持度计数。同时在建立新结点的时候把该结点加入到频繁项头链表的结点链中。

    先来定义一下数据结构:

//购物车项信息:itemName为商品名称,supportCount为购物车中的商品数量
case class Item(val itemName: String, var supportCount: Int)

//FP树结点:nodeName为商品名称
class FPTreeNode(val nodeName: String) {
  var supportCount: Int = 0    //支持度计数
  var parent: Option[FPTreeNode] = None    //父结点
  var children: mutable.Map[String, FPTreeNode] = mutable.Map()    //孩子结点

  def increaseSupportCount(n: Int) = supportCount += n    //增加支持度计数

  def isLeaf = if (children.size == 0) true else false    //是否为叶子结点
}

//FP树结构
class FPTree(val name: String, val frequencyItems: List[FrequencyItem]) {
  //根节点
  val root = new FPTreeNode(name)

  //记录当前递归结点
  var currentNode = root

  def resumeCurrentNode {
    currentNode = root
  }

  /**
    * 判断当前FPTree是一棵单叉树
    *
    * @return
    */
  def isSingleTree: Boolean = {
    var treeNode = root

    while (!treeNode.isLeaf) {
      if (treeNode.children.size == 1) {
        treeNode = treeNode.children.head._2
      } else {
        return false
      }
    }

    return true
  }

  //空树
  def isNullTree: Boolean = {
    if (root.children.size == 0) return true
    else return false
  }
}

//频繁项集头列表
class FrequencyItem(val itemName: String, val supportCount: Int) {
  val treeNodes: mutable.ArrayBuffer[FPTreeNode] = mutable.ArrayBuffer()
}

首先扫描一遍购物车,构建frequencyItemIndex,用来对频繁项安支持度计数排序Map(频繁项,序号),序号小的靠前

val frequencyItemIndex = mutable.LinkedHashMap[String, Int]()

扫描购物车并建立FPTree

/**
  * 扫描购物车 生成FPTree
  *
  * @param fileName
  * @return
  */
def scanCartList(fileName: String): FPTree = {
  val itemsList = mutable.ListBuffer[List[Item]]()

  //第一次扫描购物车购物车
  for (line <- Source.fromFile(fileName).getLines()) {
    //分别统计每哥购物车的频繁项支持度和所有购物车频繁项支持度
    val cartItemMap = collection.mutable.Map[String, Int]()
    for (itemName <- line.split(",")) {
      cartItemMap.get(itemName) match {
        case Some(_supportCount) => cartItemMap.put(itemName, _supportCount + 1)
        case None => cartItemMap += (itemName -> 1)
      }
      frequencyItemIndex.get(itemName) match {
        case Some(_supportCount) => frequencyItemIndex.put(itemName, _supportCount + 1)
        case None => frequencyItemIndex += (itemName -> 1)
      }
    }

    itemsList += (for (cartItem <- cartItemMap.toList) yield new Item(cartItem._1, cartItem._2))
  }

  //移除支持度计数过小的频繁项
  frequencyItemIndex.foreach(x => {
    if (x._2 < minSupportCount) frequencyItemIndex -= x._1
  })

  //生成频繁项头链表
  val frequencyItemHeadList = frequencyItemIndex
    .toList
    .sortWith((x, y) => x._2 > y._2)
    .map(x => new FrequencyItem(x._1, x._2))

  println("开是构建FPTree...")
  print("\t打印频繁模式项头:")
  frequencyItemHeadList.foreach(x => printf("%s:%d ", x.itemName, x.supportCount))
  println("")

  val fpTree = new FPTree("root", frequencyItemHeadList.toList)

  for (i <- 0 until frequencyItemHeadList.size) {
    frequencyItemIndex.put(frequencyItemHeadList(i).itemName, i)
  }

  for (items <- itemsList) {
    val _items = items
      .filter(item => frequencyItemIndex.isDefinedAt(item.itemName))
      .sortWith((x, y) => frequencyItemIndex(x.itemName) < frequencyItemIndex(y.itemName))

    print("\t扫描频繁项集合:")
    _items.foreach(x => printf("%s:%d ", x.itemName, x.supportCount))
    println("")

    insertTree(_items, fpTree)

    fpTree.resumeCurrentNode
  }

  fpTree
}

递归建树方法:

/**
  * 插入构建FP树
  *
  * @param items  购物篮信息(频繁模式项集)
  * @param fPTree FP树
  */
def insertTree(items: List[Item], fPTree: FPTree) {
  for (item <- items) {
    fPTree.currentNode.children.get(item.itemName) match {
      case Some(child) => {
        child.increaseSupportCount(item.supportCount)
        printf("\t\t增加支持度计数:%s up to %d\n", child.nodeName, child.supportCount)
      }
      case None => {
        val child = new FPTreeNode(item.itemName)
        child.increaseSupportCount(item.supportCount)
        child.parent = Some(fPTree.currentNode)
        fPTree.currentNode.children += (child.nodeName -> child)
        printf("\t\t在%s下面增加新结点%s:%d\n", fPTree.currentNode.nodeName, child.nodeName, child.supportCount)

        fPTree.frequencyItems.find(x => x.itemName == child.nodeName) match {
          case Some(frequencyItem) => {
            frequencyItem.treeNodes += child
            printf("\t\t\t把新结点%s:%d,加入频繁模式头链表\n", child.nodeName, child.supportCount)
          }
          case None => println("[ERROR]:丢失频繁模式项头信息!!!!!!!!")
        }
      }
    }

    fPTree.currentNode = fPTree.currentNode.children(item.itemName)
  }
}

看下打印的建树信息

开是构建FPTree...
	打印频繁模式项头:I2:7 I1:6 I3:6 I4:2 I5:2 
	扫描频繁项集合:I2:1 I1:1 I4:1 
		在root下面增加新结点I2:1
			把新结点I2:1,加入频繁模式头链表
		在I2下面增加新结点I1:1
			把新结点I1:1,加入频繁模式头链表
		在I1下面增加新结点I4:1
			把新结点I4:1,加入频繁模式头链表
	扫描频繁项集合:I2:1 I1:1 I5:1 
		增加支持度计数:I2 up to 2
		增加支持度计数:I1 up to 2
		在I1下面增加新结点I5:1
			把新结点I5:1,加入频繁模式头链表
	扫描频繁项集合:I2:1 I4:1 
		增加支持度计数:I2 up to 3
		在I2下面增加新结点I4:1
			把新结点I4:1,加入频繁模式头链表
	扫描频繁项集合:I2:1 I3:1 
		增加支持度计数:I2 up to 4
		在I2下面增加新结点I3:1
			把新结点I3:1,加入频繁模式头链表
	扫描频繁项集合:I1:1 I3:1 
		在root下面增加新结点I1:1
			把新结点I1:1,加入频繁模式头链表
		在I1下面增加新结点I3:1
			把新结点I3:1,加入频繁模式头链表
	扫描频繁项集合:I2:1 I3:1 
		增加支持度计数:I2 up to 5
		增加支持度计数:I3 up to 2
	扫描频繁项集合:I1:1 I3:1 
		增加支持度计数:I1 up to 2
		增加支持度计数:I3 up to 2
	扫描频繁项集合:I2:1 I1:1 I3:1 I5:1 
		增加支持度计数:I2 up to 6
		增加支持度计数:I1 up to 3
		在I1下面增加新结点I3:1
			把新结点I3:1,加入频繁模式头链表
		在I3下面增加新结点I5:1
			把新结点I5:1,加入频繁模式头链表
	扫描频繁项集合:I2:1 I1:1 I3:1 
		增加支持度计数:I2 up to 7
		增加支持度计数:I1 up to 4
		增加支持度计数:I3 up to 2

建树完毕,开始挖掘,这次是今天我重点要说的,先来看下书上给出的算法:

实在是没办法按这个写出来代码,这只能算是一个指导方向,我来重写一份看看

FP_growth(FP_tree, _CPI)
(1)if FP_tree 只有一条路径P && _CPI不空
(2)for b <- p的所有组合
(3)产生频繁模式bp,support_count=bp中最小的support_count
(4)else for frequencyItem <- FP_tree的频繁项头链表.逆序
(5)if frequencyItem 的结点链只有一个结点 && _CPI不空
(6)for b <- frequencyItem.结点开始上溯到根结点组成的路径P
(7)产生频繁模式bp,support_count=bp中最小的support_count
(8)else frequencyItem 的结点链只有多个结点
(9)for p <- frequencyItem.结点链
(10)根据P路径构造条件模式基集合_CPBs
(11)使用_CPBs建立FP树_FP_tree
(12)if _FP_tree != null 
(13)frequencyItem并上_CPI,support_count=frequencyItem.support_count
(14)if _CPI 不为空 生成频繁模式 frequencyItem_CPI:frequencyItem.support_count
(15)FP_growth(_FP_tree, frequencyItem_CPI:frequencyItem.support_count)

/**
  * 挖掘频繁模式
  *
  * @param fPTree FPTree: FP树 CPTree:条件模式树
  * @param _CPI   条件模式项
  */
def fp_growth(fPTree: FPTree, _CPI: Option[Item]): Unit = {
  if (fPTree.isSingleTree && _CPI != None) {
    _CPI match {
      case Some(cpItem) => {
        val _CPB = fPTree.frequencyItems.map(x => Item(x.itemName, x.supportCount))
        if (_CPB.size > 0) {
          println()
          printf("挖掘%s:%d的频繁模式:", _CPI.get.itemName, _CPI.get.supportCount)
          generateFrequencyPattern(_CPB, cpItem)
          println()
        }
      }
      case None => {

      }
    }
  } else {
    fPTree.frequencyItems.reverse.foreach(frequencyItem => {
      if (frequencyItem.treeNodes.size == 1 && _CPI != None) {
        val _CPB = mutable.ListBuffer[Item]()

        val treeNode = frequencyItem.treeNodes(0)

        _CPB += Item(treeNode.nodeName, treeNode.supportCount)

        var parentNode = treeNode.parent

        while (parentNode != None && parentNode.get.nodeName != "root") {
          _CPB += Item(parentNode.get.nodeName, treeNode.supportCount)
          parentNode = parentNode.get.parent
        }
        println()
        printf("挖掘%s:%d的频繁模式:", _CPI.get.itemName, _CPI.get.supportCount)
        if (_CPB.size > 0) {
          generateFrequencyPattern(_CPB.toList, _CPI.get)
          println()
        }
      } else {
        var itemName = frequencyItem.itemName

        if (_CPI != None) {
          itemName = itemName + "," + _CPI.get.itemName
          printf("挖掘%s:%d的频繁模式:{%s:%d}", _CPI.get.itemName, _CPI.get.supportCount, itemName, frequencyItem.supportCount)
        }

        println()
        printf("建立%s:%d的条件模式树:\n", itemName, frequencyItem.supportCount)

        val _fpTree = buileConditionPatternFree(frequencyItem)
        if (!fPTree.isNullTree) fp_growth(_fpTree, Some(Item(itemName, frequencyItem.supportCount)))
      }
    })
  }
  
  /**
  * 构造条件模式树
  *
  * @param frequencyItem
  * @return
  */
def buileConditionPatternFree (frequencyItem: FrequencyItem): FPTree = {
  val _CPBs = mutable.ListBuffer[List[Item]]()
  val frequencyItemMap = mutable.Map[String, Int]()

  for (treeNode <- frequencyItem.treeNodes) {
    val _CPB = mutable.ListBuffer[Item]()

    var parentNode = treeNode.parent

    while (parentNode != None && parentNode.get.nodeName != "root") {
      val item = Item(parentNode.get.nodeName, treeNode.supportCount)

      frequencyItemMap.get(item.itemName) match {
        case Some(supportCount) => frequencyItemMap.put(item.itemName, supportCount + item.supportCount)
        case None => frequencyItemMap += (item.itemName -> item.supportCount)
      }

      _CPB += item

      parentNode = parentNode.get.parent
    }

    _CPBs += _CPB.toList
  }

  frequencyItemMap.foreach(x => {
    if (x._2 < minSupportCount) frequencyItemMap -= x._1
  })

  val frequencyItems = frequencyItemMap
    .toList
    .map(x => new FrequencyItem(x._1, x._2))
    .sortWith((x,y) => frequencyItemIndex(x.itemName) < frequencyItemIndex(y.itemName))

  val fpTree = new FPTree("root", frequencyItems)

  println("开是构建FPTree...")
  if (frequencyItems.size > 0) {
    print("\t打印频繁模式项头:")
    frequencyItems.foreach(x => printf("%s:%d ", x.itemName, x.supportCount))
    println("")

    for (_CPB <- _CPBs) {
      val _items = _CPB
        .filter(x => frequencyItemMap.isDefinedAt(x.itemName))
        .sortWith((x, y) => frequencyItemIndex(x.itemName) < frequencyItemIndex(y.itemName))

      print("\t扫描频繁项集合:")
      _items.foreach(x => printf("%s:%d ", x.itemName, x.supportCount))
      println("")

      insertTree(_items, fpTree)

      fpTree.resumeCurrentNode
    }
  } else {
    print("\t没有可用条件模式基...")
  }

  fpTree
}

  打印挖掘过程

开启频繁模式挖掘...

建立I5:2的条件模式树:
开是构建FPTree...
	打印频繁模式项头:I2:2 I1:2 
	扫描频繁项集合:I2:1 I1:1 
		在root下面增加新结点I2:1
			把新结点I2:1,加入频繁模式头链表
		在I2下面增加新结点I1:1
			把新结点I1:1,加入频繁模式头链表
	扫描频繁项集合:I2:1 I1:1 
		增加支持度计数:I2 up to 2
		增加支持度计数:I1 up to 2

挖掘I5:2的频繁模式:{I2,I5:2} {I2,I1,I5:2} {I1,I5:2} 

建立I4:2的条件模式树:
开是构建FPTree...
	打印频繁模式项头:I2:2 
	扫描频繁项集合:I2:1 
		在root下面增加新结点I2:1
			把新结点I2:1,加入频繁模式头链表
	扫描频繁项集合:I2:1 
		增加支持度计数:I2 up to 2

挖掘I4:2的频繁模式:{I2,I4:2} 

建立I3:6的条件模式树:
开是构建FPTree...
	打印频繁模式项头:I2:4 I1:4 
	扫描频繁项集合:I2:2 
		在root下面增加新结点I2:2
			把新结点I2:2,加入频繁模式头链表
	扫描频繁项集合:I1:2 
		在root下面增加新结点I1:2
			把新结点I1:2,加入频繁模式头链表
	扫描频繁项集合:I2:2 I1:2 
		增加支持度计数:I2 up to 4
		在I2下面增加新结点I1:2
			把新结点I1:2,加入频繁模式头链表
挖掘I3:6的频繁模式:{I1,I3:4}
建立I1,I3:4的条件模式树:
开是构建FPTree...
	打印频繁模式项头:I2:2 
	扫描频繁项集合:
	扫描频繁项集合:I2:2 
		在root下面增加新结点I2:2
			把新结点I2:2,加入频繁模式头链表

挖掘I1,I3:4的频繁模式:{I2,I1,I3:2} 

挖掘I3:6的频繁模式:{I2,I3:4} 

建立I1:6的条件模式树:
开是构建FPTree...
	打印频繁模式项头:I2:4 
	扫描频繁项集合:I2:4 
		在root下面增加新结点I2:4
			把新结点I2:4,加入频繁模式头链表
	扫描频繁项集合:

挖掘I1:6的频繁模式:{I2,I1:4} 

建立I2:7的条件模式树:
开是构建FPTree...
	没有可用条件模式基...




© 著作权归作者所有

阿拉德大陆的魔法师
粉丝 27
博文 91
码字总数 83019
作品 0
西城
程序员
私信 提问
Spark数据挖掘-FPGrowth算法

Spark数据挖掘-FPGrowth算法 主要内容 什么是关联规则挖掘? 关联规则有哪些术语? 什么是FP-Growth算法? 1.1 FPGrowth算法 1.1.1 基本概念 关联规则挖掘的一个典型例子是购物篮分析。关联规...

clebeg
2015/11/03
707
0
【spark】41.Spark Mlib:FPGrowth算法

简介 FP-Growth算法是韩嘉炜等人在2000年提出的关联分析算法,它采取如下分治策略:将提供频繁项集的数据库压缩到一棵频繁模式树(FP-tree),但仍保留项集关联信息。 在算法中使用了一种称为...

Areya
02/21
31
0
Mahout 频繁模式挖掘

大家好 我用mahout 0,6关联规则推荐算法 代码如下: int minSupport = 2; int maxHeapSize = 100; String input = "./models/casestudy-en/lda.dat"; String output = "output"; FPGrowth ......

y000n520
2014/10/30
547
5
SLS机器学习介绍(04):规则模式挖掘

文章系列链接 SLS机器学习介绍(01):时序统计建模 SLS机器学习介绍(02):时序聚类建模 SLS机器学习介绍(03):时序异常检测建模 SLS机器学习介绍(04):规则模式挖掘 SLS机器学习最佳实...

悟冥
2018/12/22
0
0
FP-Growth|高效挖掘频繁项集

01 搜索引擎如何联想的? 在使用搜索引擎时,你应该会发现一个现象:当我们在搜索框输入一个字符时,它就会帮你联想补全后面的搜索内容。 比如,你想搜索“西瓜”,当你输入“西”时,搜索引...

邓莎
02/20
0
0

没有更多内容

加载失败,请刷新页面

加载更多

redis 内存信息解析

used_memory:由 Redis 分配器分配的内存总量,包含了redis进程内部的开销和数据占用的内存,以字节(byte)为单位 used_memory_rss:向操作系统申请的内存大小。与 top 、 ps等命令的输出一...

Canaan_
31分钟前
4
0
windows 下 python3 安装 pip setuptools

本文链接:https://blog.csdn.net/huzuxing/article/details/80807744 最近在家使用python的时候,总是报setuptools 模块未找到,于是在网上搜索了相关解决办法,但是都没有解决问题。 于是去...

开源中国首席CYO
37分钟前
4
0
数据库添加索引

mysql索引添加 navicat 步骤 - 选择表 -> 设计表 ->索引

以谁为师
47分钟前
6
0
java7与java9中的try-finally关闭资源

1.java7中的try 在java7之前,对于一些需要使用finally关闭资源的操作,会显得很臃肿. try{//}catch(Exception e){//}finally{if(xxxx != null){xxxx.close();}} 在jav...

Blueeeeeee
49分钟前
4
0
字节序转换详解

在跨平台和网络编程中我们经常会提到网络字节序和主机字节序,如果没有正确对两者进行转换,从而导致两方产生了不同的解释,就会出现意想不到的bug。 目录 0x01 概念 0x02 分类 0x03 两种字节...

无心的梦呓
59分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部