java实现fp-growth算法

最新推荐文章于 2021-03-04 13:57:44 发布
最新推荐文章于 2021-03-04 13:57:44 发布
阅读量836 收藏 1
点赞数 1
文章标签： java 数据库 开发工具
原文链接：http://www.cnblogs.com/a-du/p/9324262.html
版权

本文参考韩家炜《数据挖掘-概念与技术》一书第六章，前提条件要理解 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中。
   }
本人觉得要想更好的理解，或者有不明之处应该参考
这篇文章的这个地方，见下图。
  
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;
    }
}

 

 

转载于:https://www.cnblogs.com/a-du/p/9324262.html

清，纯一色
关注
java实现FP-Growth
08-11
java 实现FP-Growth算法
java fp-growth 算法包_java实现fp-growth算法
weixin_39776991的博客
02-16 93
package mysequence.machineleaning.association.fpgrowth;import java.io.BufferedReader;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStreamReader;import java.util.ArrayLi...
用java实现FP-growth算法
luohualiushui1的专栏
02-17 1268
首先我们得了解一下什么是FP-growth算法，如下： FP-Growth算法是韩嘉炜等人在2000年提出的关联分析算法，它采取如下分治策略：将提供频繁项集的数据库压缩到一棵频繁模式树（FP-tree），但仍保留项集关联信息。 在算法中使用了一种称为频繁模式树（Frequent Pattern Tree）的数据结构。FP-tree是一种特殊的前缀树，由频繁项头表和项前缀树构成。FP-Growt...
fpgrowth的java实现
03-20
fpgrowth的java实现，代码绝对没有问题，可以执行，而且有非常详细的注释，非本人实现的代码，如果有问题可以与作者联系，里面有作者的mail,(国人，不是老外)
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>...
java fp-growth 算法包_FP-Growth算法
weixin_28674303的博客
03-04 308
FP-Growth算法的目标是发现模式，其特点就是高效，因为可以通过设置发生频次直接过滤掉一些低频次的元素；而且秉承了和Apriori的思想，对于低频次的元素，其父级和子级的组合都是低频的。FP-Growth利用的树结构；在发现模式的过程就是一个不断构建树的过程。其核心组成是两部分，一个就是FPTree，另外一个是headTable；我们首先来说一下HeadTable，HeadTable的数据结构...
fpgrowth算法java源码
10-05
fp-growths算法的java源码，喜欢就请下载
FP-GROWTH算法的实现
10-26
FP-GROWTH算法的实现
FPTree 的java和C#实现
04-14
FPtree的java和C#的代码实现，是Aprior算法的改进版本，对于关联规则挖掘可以看看
单机和集群环境下的FP-Growth算法java实现(关联规则挖掘)
shimin520shimin的专栏
10-20 2926
1 FP-Growth简要描述      和Apriori算法一样，都是用于关联规则挖掘的算法。Apriori算法每生成一次k频繁项集都需要遍历一次事务数据库，当事务数据库很大时会有频繁的I/O操作，因此只适合找出小数据集的频繁项集；而FP-Growth算法整个过程中，只有两次扫描事务数据库，一次发生在数据预处理（包括去掉事务的ID编号、合并相同事务等），另一次发生在构造FP-Tree的头项
JAVA实现FP_Growth算法（附详细注释）
weixin_40020929的博客
01-01 4854
JAVA实现FP_Growth算法（附详细注释） 在学习数据挖掘的过程中，必然会接触到FP_Growth算法。 而FP_Growth算法需要使用大量的递归调用，比较难以理解和实践，作者在网上多番搜寻也没有找到一个完整详细解释的FP_Growth代码，可能是高手大多不屑于解释自己的代码，无奈只能自己动手，有不足之处请多谅解。 程序编写过程中部分参考了https://www.cnblogs.com/l...
FPGrowth的java实现
小海洋的专栏
06-23 2406
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
java fp-growth 算法包_GitHub - baiyyang/FP-growth: Java实现FP-growth算法
weixin_35020039的博客
02-16 202
FP-growth该项目是FP-growth算法的实现，该算法用于快速的寻找关联规则和频繁项集，只需要扫描两次数据库，设计很精妙。其中算法的伪代码给出如下：一、FP-Tree构造算法输入：事务数据集 D，最小支持度阈值 min_sup输出：FP-Tree(1) 　　扫描事务数据集 D 一次，获得频繁项的集合 F 和其中每个频繁项的支持度。对 F 中的所有频繁项按其支持度进行降序排序，结果为频繁项表...
数据挖掘FPGrowth算法JAVA实现
Lhw_666的博客
01-17 573
实验结果 最小支持度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
关联规则FpGrowth算法 Java实现
LiDadadaxu的博客
09-05 3059
关联规则算法有Apriori和FpGrowth，与Apriori相比，FpGrowth扫描数据库的次数更少，效率大大提高，FpGrowth算法通过构造一个树结构来压缩数据记录，使得挖掘频繁项集只需要扫描两次数据记录，而且该算法不需要生成候选集合1. 构造FpTreefpTree是一种树结构，定义数结构类 import java.util.ArrayList; import java.util.L
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值