java实现fp-growth算法

最新推荐文章于 2021-06-15 01:06:00 发布
最新推荐文章于 2021-06-15 01:06:00 发布
阅读量586 收藏 2
点赞数
分类专栏： java 数据挖掘 文章标签： 算法 数据挖掘



本文参考韩家炜《数据挖掘-概念与技术》一书第六章，前提条件要理解 apriori算法。

另外一篇写得较好的文章在此推荐：

http://hi.baidu.com/nefzpohtpndhovr/item/9d5c371ba2dbdc0ed1d66dca 

0.实验数据集：

user2items.csv  
I1,I2,I5
I2,I4
I2,I3
I1,I2,I4 
I1,I3 
I2,I3
I1,I3
I1,I2,I3,I5
I1,I2,I3

1.算法原理

构造FPTree 
    1、首先读取数据库中所有种类的项和这些项的支持度计数。存入到itTotal链表中。 
    2、将itTotal链表按照支持度计数从大到小排序      
    3、将itTotal链表插入到ItemTb表中 
    4、第二便读取数据库中的事务，将事务中的项按照支持度计数由大到小的顺序插入到树中。   
    5、遍历树，将属于同一项的结点通过bnode指针连接起来。 
    本程序中，FP-tree中存储了所有的项集，没有考虑最小支持度。只是在FP-growth中挖掘频繁项集时考虑最小支持度 
/**
   * 
   * @param records 构建树的记录,如I1,I2,I3
   * @param header 韩书中介绍的表头
   * @return 返回构建好的树
   */
  public TreeNode2 builderFpTree(LinkedList<LinkedList<String>> records,List<TreeNode2> header){
    
       TreeNode2 root;
       if(records.size()<=0){
         return null;
       }
       root=new TreeNode2();
       for(LinkedList<String> items:records){
         itemsort(items,header);
        addNode(root,items,header);
      }
    String dd="dd";	
    String test=dd;
    return root;
  }
  //当已经有分枝存在的时候，判断新来的节点是否属于该分枝的某个节点，或全部重合，递归
  public  TreeNode2 addNode(TreeNode2 root,LinkedList<String> items,List<TreeNode2> header){
    if(items.size()<=0)return null;
    String item=items.poll();
    //当前节点的孩子节点不包含该节点，那么另外创建一支分支。
    TreeNode2 node=root.findChild(item);
    if(node==null){
  node=new TreeNode2();
      node.setName(item);
      node.setCount(1);
      node.setParent(root);
      root.addChild(node);
      
      //加将各个同名的节点加到链头中 
      for(TreeNode2 head:header){
        if(head.getName().equals(item)){
          while(head.getNextHomonym()!=null){
            head=head.getNextHomonym();
          }
          head.setNextHomonym(node);
          break;
        }
      }
      //加将各个节点加到链头中
    }else{
      node.setCount(node.getCount()+1);
    }
 
    addNode(node,items,header);
    return root;
  }

FP_growth算法： 
   从一棵FPTree的ItemTb表中取得第一个项I1。如果该项的支持度计数满足最小支持度计数{ 
     1、把该项I1加入到存储挖掘到的频繁项集的数据结构ItemSet中 
     2、得到该项I1在目前FPTree中的条件模式基，即该项在树中的结点的前缀路径（路径中不再包括该项）。 
         注意该项I1的条件模式基中各个项的支持度计数相等，等于该项I1的支持度计数 
     3、每条路径看作一个事务，用这些路径建造该项的条件FPTree，然后递归调用FP_growth算法。 
         在递归调用FP_growth算法时，那些大于支持度计数的项作为项I1的孩子结点存储在ItemSet中。 
   } 

本人觉得要想更好的理解，或者有不明之处应该参考

http://hi.baidu.com/nefzpohtpndhovr/item/9d5c371ba2dbdc0ed1d66dca 

这篇文章的这个地方，见下图。


public void fpgrowth(LinkedList<LinkedList<String>> records,String item){
    //保存新的条件模式基的各个记录，以重新构造FP-tree
    LinkedList<LinkedList<String>> newrecords=new LinkedList<LinkedList<String>>();
    //构建链头
    LinkedList<TreeNode2> header=buildHeaderLink(records);
    //创建FP-Tree
    TreeNode2 fptree= builderFpTree(records,header);
    //结束递归的条件
    if(header.size()<=0||fptree==null){
      System.out.println("-----------------");
      return;
    }
    //打印结果,输出频繁项集
    if(item!=null){
      //寻找条件模式基,从链尾开始
      for(int i=header.size()-1;i>=0;i--){
        TreeNode2 head=header.get(i);
        String itemname=head.getName();
        Integer count=0;
        while(head.getNextHomonym()!=null){
          head=head.getNextHomonym();
          //叶子count等于多少，就算多少条记录
          count=count+head.getCount();
          
        }
        //打印频繁项集
        System.out.println(head.getName()+","+item+"\t"+count);
      }
    }
    //寻找条件模式基,从链尾开始
    for(int i=header.size()-1;i>=0;i--){
      TreeNode2 head=header.get(i);
      String itemname;
      //再组合
      if(item==null){
        itemname=head.getName();
      }else{
        itemname=head.getName()+","+item;
      }
      
      while(head.getNextHomonym()!=null){
        head=head.getNextHomonym();
        //叶子count等于多少，就算多少条记录
        Integer count=head.getCount();
        for(int n=0;n<count;n++){
           LinkedList<String> record=new LinkedList<String>();
           toroot(head.getParent(),record);
           newrecords.add(record);
        }
      }
      //System.out.println("-----------------");
      //递归之,以求子FP-Tree
      fpgrowth(newrecords,itemname);
    }
    }

2.tree的结构

    private String name; // 节点名称 
    private Integer count; // 计数 
    private TreeNode2 parent; // 父节点 
    private List<TreeNode2> children; // 子节点 
    private TreeNode2 nextHomonym; // 下一个同名节点

详见下面的TreeNode2类

3.完整的源码：

共两份.java文件，直接贴到eclipse中即可以执行。

package mysequence.machineleaning.association.fpgrowth;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;



public class Myfptree2 {
  public static final int  support = 2; // 设定最小支持频次为2 
  //保存第一次的次序
  public Map<String,Integer> ordermap=new HashMap<String,Integer>();
  public LinkedList<LinkedList<String>> readF1() throws IOException {      
    LinkedList<LinkedList<String>> records=new LinkedList<LinkedList<String>>();
    //String filePath="scripts/clustering/canopy/canopy.dat";
    String filePath="datafile/association/user2items.csv";
    BufferedReader br = new BufferedReader(new InputStreamReader(
  new FileInputStream(filePath)));
  for (String line = br.readLine(); line != null; line = br.readLine()) {
      if(line.length()==0||"".equals(line))continue;
    String[] str=line.split(",");   
    LinkedList<String> litm=new LinkedList<String>();
    for(int i=0;i<str.length;i++){
      litm.add(str[i].trim());
    }
      records.add(litm);	     
  }
  br.close();
  return records;
    }
  //创建表头链
  public LinkedList<TreeNode2> buildHeaderLink(LinkedList<LinkedList<String>> records){
    LinkedList<TreeNode2> header=null;
    if(records.size()>0){
      header=new LinkedList<TreeNode2>();
    }else{
      return null;
    }
    Map<String, TreeNode2> map = new HashMap<String, TreeNode2>();
    for(LinkedList<String> items:records){
      
      for(String item:items){
        //如果存在数量增1，不存在则新增
        if(map.containsKey(item)){
          map.get(item).Sum(1);
        }else{
          TreeNode2 node=new TreeNode2();
          node.setName(item);
          node.setCount(1);
          map.put(item, node);
        }
       }
    }
     // 把支持度大于（或等于）minSup的项加入到F1中
  Set<String> names = map.keySet();
  for (String name : names) {
      TreeNode2 tnode = map.get(name);
      if (tnode.getCount() >= support) {
      	header.add(tnode);
      }
  }
  sort(header);
    
  String test="ddd";
    return header;
  }
  //选择法排序,如果次数相等，则按名字排序,字典顺序,先小写后大写
  public List<TreeNode2> sort(List<TreeNode2> list){
    int len=list.size();
    for(int i=0;i<len;i++){
      
      for(int j=i+1;j<len;j++){
        TreeNode2 node1=list.get(i);
        TreeNode2 node2=list.get(j);
        if(node1.getCount()<node2.getCount()){
          TreeNode2 tmp=new TreeNode2();
          tmp=node2;
          list.remove(j);
          //list指定位置插入，原来的>=j元素都会往下移，不会删除,所以插入前要删除掉原来的元素
          list.add(j,node1);
          list.remove(i);
          list.add(i,tmp);
        }
        //如果次数相等，则按名字排序,字典顺序,先小写后大写
        if(node1.getCount()==node2.getCount()){
          String name1=node1.getName();
          String name2=node2.getName();
          int flag=name1.compareTo(name2);
          if(flag>0){
            TreeNode2 tmp=new TreeNode2();
            tmp=node2;
            list.remove(j);
            //list指定位置插入，原来的>=j元素都会往下移，不会删除,所以插入前要删除掉原来的元素
            list.add(j,node1);
            list.remove(i);
            list.add(i,tmp);
          }
          

        }
      }
    }
    
    return list;
  }
  //选择法排序，降序,如果同名按L 中的次序排序
  public   List<String> itemsort(LinkedList<String> lis,List<TreeNode2> header){
    //List<String> list=new ArrayList<String>();
    //选择法排序
    int len=lis.size();
    for(int i=0;i<len;i++){
      for(int j=i+1;j<len;j++){
        String key1=lis.get(i);
        String key2=lis.get(j);
        Integer value1=findcountByname(key1,header);
        if(value1==-1)continue;
        Integer value2=findcountByname(key2,header);
        if(value2==-1)continue;
        if(value1<value2){
          String tmp=key2;
          lis.remove(j);
          lis.add(j,key1);
          lis.remove(i);
          lis.add(i,tmp);
        }
        if(value1==value2){
          int v1=ordermap.get(key1);
          int v2=ordermap.get(key2);
          if(v1>v2){
            String tmp=key2;
            lis.remove(j);
            lis.add(j,key1);
            lis.remove(i);
            lis.add(i,tmp);
          }
        }
         }
    }
    return lis;
  }
  public Integer findcountByname(String itemname,List<TreeNode2> header){
    Integer count=-1;
    for(TreeNode2 node:header){
      if(node.getName().equals(itemname)){
        count= node.getCount();
      }
    }
    return count;
  }
  
  /**
   * 
   * @param records 构建树的记录,如I1,I2,I3
   * @param header 韩书中介绍的表头
   * @return 返回构建好的树
   */
  public TreeNode2 builderFpTree(LinkedList<LinkedList<String>> records,List<TreeNode2> header){
    
       TreeNode2 root;
       if(records.size()<=0){
         return null;
       }
       root=new TreeNode2();
       for(LinkedList<String> items:records){
         itemsort(items,header);
        addNode(root,items,header);
      }
    String dd="dd";	
    String test=dd;
    return root;
  }
  //当已经有分枝存在的时候，判断新来的节点是否属于该分枝的某个节点，或全部重合，递归
  public  TreeNode2 addNode(TreeNode2 root,LinkedList<String> items,List<TreeNode2> header){
    if(items.size()<=0)return null;
    String item=items.poll();
    //当前节点的孩子节点不包含该节点，那么另外创建一支分支。
    TreeNode2 node=root.findChild(item);
    if(node==null){
      node=new TreeNode2();
      node.setName(item);
      node.setCount(1);
      node.setParent(root);
      root.addChild(node);
      
      //加将各个节点加到链头中 
      for(TreeNode2 head:header){
        if(head.getName().equals(item)){
          while(head.getNextHomonym()!=null){
            head=head.getNextHomonym();
          }
          head.setNextHomonym(node);
          break;
        }
      }
      //加将各个节点加到链头中
    }else{
      node.setCount(node.getCount()+1);
    }
 
    addNode(node,items,header);
    return root;
  }
  //从叶子找到根节点，递归之
  public void toroot(TreeNode2 node,LinkedList<String> newrecord){
    if(node.getParent()==null)return;
    String name=node.getName();
    newrecord.add(name);
    toroot(node.getParent(),newrecord);
  }
  //对条件FP-tree树进行组合，以求出频繁项集
  public void combineItem(TreeNode2 node,LinkedList<String> newrecord,String Item){
    if(node.getParent()==null)return;
    String name=node.getName();
    newrecord.add(name);
    toroot(node.getParent(),newrecord);
  }
  //fp-growth
  public void fpgrowth(LinkedList<LinkedList<String>> records,String item){
    //保存新的条件模式基的各个记录，以重新构造FP-tree
    LinkedList<LinkedList<String>> newrecords=new LinkedList<LinkedList<String>>();
    //构建链头
    LinkedList<TreeNode2> header=buildHeaderLink(records);
    //创建FP-Tree
    TreeNode2 fptree= builderFpTree(records,header);
    //结束递归的条件
    if(header.size()<=0||fptree==null){
      System.out.println("-----------------");
      return;
    }
    //打印结果,输出频繁项集
    if(item!=null){
      //寻找条件模式基,从链尾开始
      for(int i=header.size()-1;i>=0;i--){
        TreeNode2 head=header.get(i);
        String itemname=head.getName();
        Integer count=0;
        while(head.getNextHomonym()!=null){
          head=head.getNextHomonym();
          //叶子count等于多少，就算多少条记录
          count=count+head.getCount();
          
        }
        //打印频繁项集
        System.out.println(head.getName()+","+item+"\t"+count);
      }
    }
    //寻找条件模式基,从链尾开始
    for(int i=header.size()-1;i>=0;i--){
      TreeNode2 head=header.get(i);
      String itemname;
      //再组合
      if(item==null){
        itemname=head.getName();
      }else{
        itemname=head.getName()+","+item;
      }
      
      while(head.getNextHomonym()!=null){
        head=head.getNextHomonym();
        //叶子count等于多少，就算多少条记录
        Integer count=head.getCount();
        for(int n=0;n<count;n++){
           LinkedList<String> record=new LinkedList<String>();
           toroot(head.getParent(),record);
           newrecords.add(record);
        }
      }
      //System.out.println("-----------------");
      //递归之,以求子FP-Tree
      fpgrowth(newrecords,itemname);
    }
    }
  //保存次序，此步也可以省略，为了减少再加工结果的麻烦而加
  public void orderF1(LinkedList<TreeNode2> orderheader){
    for(int i=0;i<orderheader.size();i++){
      TreeNode2 node=orderheader.get(i);
      ordermap.put(node.getName(), i);
    }
    
  }
  public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    /*String s1="i1";
    int flag=s1.compareTo("I1");
    System.out.println(flag);*/
    //读取数据
    Myfptree2 fpg=new Myfptree2();
    LinkedList<LinkedList<String>> records=fpg.readF1();
    LinkedList<TreeNode2> orderheader=fpg.buildHeaderLink(records);
    fpg.orderF1(orderheader);
  fpg.fpgrowth(records,null);
  }

}
树的结构： 
package mysequence.machineleaning.association.fpgrowth;

import java.util.ArrayList;
import java.util.List;



public class TreeNode2 implements Comparable<TreeNode2>{

  private String name; // 节点名称
  private Integer count; // 计数
  private TreeNode2 parent; // 父节点
  private List<TreeNode2> children; // 子节点
  private TreeNode2 nextHomonym; // 下一个同名节点
  
  public TreeNode2() {
  
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getCount() {
    return count;
  }

  public void setCount(Integer count) {
    this.count = count;
  }
  public void Sum(Integer count) {
    this.count =this.count+count;
  }
  public TreeNode2 getParent() {
    return parent;
  }

  public void setParent(TreeNode2 parent) {
    this.parent = parent;
  }

  public List<TreeNode2> getChildren() {
    return children;
  }

  public void setChildren(List<TreeNode2> children) {
    this.children = children;
  }

  public TreeNode2 getNextHomonym() {
    return nextHomonym;
  }

  public void setNextHomonym(TreeNode2 nextHomonym) {
    this.nextHomonym = nextHomonym;
  }
  /**
   * 添加一个节点
   * @param child
   */
  public void addChild(TreeNode2 child) {
    if (this.getChildren() == null) {
      List<TreeNode2> list = new ArrayList<TreeNode2>();
      list.add(child);
      this.setChildren(list);
    } else {
      this.getChildren().add(child);
    }
  }
  /**
  *  是否存在着该节点,存在返回该节点，不存在返回空
  * @param name
  * @return
  */
  public TreeNode2 findChild(String name) {
    List<TreeNode2> children = this.getChildren();
    if (children != null) {
      for (TreeNode2 child : children) {
        if (child.getName().equals(name)) {
          return child;
        }
      }
    }
    return null;
  }


  @Override
  public int compareTo(TreeNode2 arg0) {
    // TODO Auto-generated method stub
    int count0 = arg0.getCount();
    // 跟默认的比较大小相反，导致调用Arrays.sort()时是按降序排列
    return count0 - this.count;
  }
}
liqiuguo
关注
专栏目录
java实现FP-Growth
08-11
java 实现FP-Growth算法
关联规则FpGrowth算法 Java实现
LiDadadaxu的博客
09-05 3035
关联规则算法有Apriori和FpGrowth，与Apriori相比，FpGrowth扫描数据库的次数更少，效率大大提高，FpGrowth算法通过构造一个树结构来压缩数据记录，使得挖掘频繁项集只需要扫描两次数据记录，而且该算法不需要生成候选集合1. 构造FpTreefpTree是一种树结构，定义数结构类 import java.util.ArrayList; import java.util.L
fp growth java代码_FP-Growth挖掘频繁项，java实现
weixin_42300424的博客
02-27 308
FP-Growth主要是用来进行挖掘频繁项，使用场景是发现事物之间的相关性，其中用支持度表示相关性的大小，可以通过设置支持度来筛选相关性小的事物的联系。相比较于Apriori算法需要扫描多次数据，严重受到IO的影响。FP-Growth只需要扫描两次数据集，可以提高算法运行效率。下图是论文中的图： 左边表示初始的数据集，表示原始的相关关系。然后遍历左边数据集，统计每个元素的出现次数，然后按照出现次数...
用java实现FP-growth算法
luohualiushui1的专栏
02-17 1242
首先我们得了解一下什么是FP-growth算法，如下： FP-Growth算法是韩嘉炜等人在2000年提出的关联分析算法，它采取如下分治策略：将提供频繁项集的数据库压缩到一棵频繁模式树（FP-tree），但仍保留项集关联信息。 在算法中使用了一种称为频繁模式树（Frequent Pattern Tree）的数据结构。FP-tree是一种特殊的前缀树，由频繁项头表和项前缀树构成。FP-Growt...
Java实现FP-growth算法.zip
最新发布
03-14
到处运行（Write Once, Run Anywhere）”，这意味着开发者可以使用Java编写应用程序，并在支持Java的任何平台上无需重新编译即可运行，这得益于其独特的跨平台性，通过Java虚拟机（JVM）实现不同操作系统上的兼容。...
fpgrowth:FPGrowth 算法的 Java 实现
07-03
FPGrowth 算法的 Java 实现 用法 创建一个 jar 并运行它： git clone git@github.com:relekang/fpgrowth.git && cd fpgrowth mvn assembly:assembly java -jar target/FPGrowth-jar-with-dependencies.jar < path>...
FP-GROWTH算法的实现
10-26
在fp-growth-crf3这个压缩包中，很可能包含了实现FP-GROWTH算法的Java源代码，包括上述类和其他辅助类。代码可能提供了读取数据、设置支持度阈值、运行挖掘过程以及输出结果的功能。 使用这个Java实现，你可以处理...
java fp-growth 算法包_java实现fp-growth算法
weixin_42521649的博客
02-13 236
构造FPTree1、首先读取数据库中全部种类的项和这些项的支持度计数。存入到itTotal链表中。2、将itTotal链表依照支持度计数从大到小排序3、将itTotal链表插入到ItemTb表中4、第二便读取数据库中的事务，将事务中的项依照支持度计数由大到小的顺序插入到树中。5、遍历树，将属于同一项的结点通过bnode指针连接起来。本程序中，FP-tree中存储了全部的项集，没有考虑最小支持度。仅...
fpgrowth的java实现
03-20
fpgrowth的java实现，代码绝对没有问题，可以执行，而且有非常详细的注释，非本人实现的代码，如果有问题可以与作者联系，里面有作者的mail,(国人，不是老外)
fpgrowth算法java源码
10-05
fp-growths算法的java源码，喜欢就请下载
数据挖掘之关联规则挖掘FP-Growth算法
11-16
本算法为数据挖掘之关联规则挖掘的其中一种方法，可以此方法为基本进行算法的优化操作。
java版FPgrowth
04-15
点击test.bat直接运行，数据集在sample.txt中 绝对好使
基于FP-Tree的关联规则FP-Growth推荐算法Java实现
jmxlht的专栏
10-27 3106
fp-tree fp-growth java代码
JAVA实现FP_Growth算法（附详细注释）
weixin_40020929的博客
01-01 4822
JAVA实现FP_Growth算法（附详细注释） 在学习数据挖掘的过程中，必然会接触到FP_Growth算法。 而FP_Growth算法需要使用大量的递归调用，比较难以理解和实践，作者在网上多番搜寻也没有找到一个完整详细解释的FP_Growth代码，可能是高手大多不屑于解释自己的代码，无奈只能自己动手，有不足之处请多谅解。 程序编写过程中部分参考了https://www.cnblogs.com/l...
FPGrowth的java实现
小海洋的专栏
06-23 2394
1、公共类 package com.apriori.common; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; imp
数据挖掘FPGrowth算法JAVA实现
Lhw_666的博客
01-17 559
实验结果 最小支持度0.001条件下可以得到准确结果，仅用1.6s 最小可以支持最小支持度为0.0003的计算 代码 package com.company; import java.io.*; import java.util.*; class FPNode { String name; int count = 0; FPNode brother = null, parent = null; ArrayList<FPNode> children = new
FP-Growth算法的Java实现+具体实现思路+代码
Kid
06-15 2245
前言 学校里的实验，要求实现FP-Growth算法。FP-Growth算法比Apriori算法快很多（但是却比不上时间，how time slipped away）。 在网上搜索后发现Java实现的FP-Growth算法很少，且大多数不太能理解):太菜。所以就自己实现了一下。这篇文章重点介绍一下我的Java实现。 FP-Growth算法原理 其他大佬的讲解 FP-Growth算法详解 FP-Growth算法的Java实现 这篇文章重点讲一下实现。 如果看了上述给的讲解，可知，需要两次扫描来构建FP树 第一次
帮我用java写FP-growth算法
05-10
好的，下面是一个简单的Java实现FP-growth算法的代码，仅供参考： ```java import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class FPGrowth { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值