FPGrowth的java实现

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;
import java.util.Map.Entry;


/**
 * <p>本类描述: 公共类</p>
 * <p>其他说明: </p>
 * @author Wang Haiyang
 * @date 2015-6-23 下午01:42:01
 */
public class Aprioris {


    /**
     * 方法描述：得到频繁1项集
     * @param D：事务数据库
     * @param min_sup：最小支持度阀值
     * @return
     */
    public static List<ArrayList<Integer>> getFrequent1Itemsets(List<ArrayList<Integer>> D, Integer min_sup, Map<ArrayList<Integer>, Integer> L) {
        List<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (ArrayList<Integer> d : D) {
            for (Integer g : d) {
                if (map.containsKey(g)) {
                    map.put(g, map.get(g) + 1);
                } else {
                    map.put(g, 1);
                }
            }
        }
        Set<Entry<Integer, Integer>> entrySet = map.entrySet();
        for (Entry<Integer, Integer> entry : entrySet) {
            if (entry.getValue() >= min_sup) {
                ArrayList<Integer> l = new ArrayList<Integer>();
                l.add(entry.getKey());
                results.add(l);
                L.put(l, entry.getValue());
            }
        }
        return results;
    }
    
    public static void displayAssociationRules(Map<String, Double> rules) {
        for (Entry<String, Double> entry : rules.entrySet()) {
            System.out.println(entry.getKey() + "：" + entry.getValue());
        }
    }
    
    /**
     * 方法描述：遍历频繁项集
     * @param L
     */
    public static void displayFrequentItemsets(Map<ArrayList<Integer>, Integer> L) {
        for (Entry<ArrayList<Integer>, Integer> entry : L.entrySet()) {
            System.out.print("(");
            for (Integer integer : entry.getKey()) {
                System.out.print(integer);
                System.out.print(",");
            }
            System.out.print(")");
            System.out.println();
        }
    }
    
    /**
     * 方法描述：产生关联规则
     * @param L
     * @param min_con
     * @return
     */
    public static Map<String, Double> produceAssociationRules(Map<ArrayList<Integer>, Integer> L, Double min_con) {
        Map<String, Double> result = new HashMap<String, Double>();
        for (Entry<ArrayList<Integer>, Integer> entry : L.entrySet()) {
            ArrayList<Integer> v = entry.getKey();
            if (v.size() > 1) {
                List<ArrayList<Integer>> lists = subList(v); // 得到给定list的所有非空真子集
                for (ArrayList<Integer> list : lists) {
                        List<Integer> exp = exceptList(v, list); // 得到除了list之外的子集
                        Integer integer1 = entry.getValue();
                        Integer integer2 = L.get(list);
                        if (integer1 != null && integer2 != null) {
                            Double per = Double.parseDouble(integer1 + "") / integer2;
                            if (per >= min_con) {
                                result.put(list.toString() + "=>" + exp.toString(), per);
                            }
                        }
                }
            }
        }
        return result;
    }
    
    /**
     * 方法描述：得到除了list之外的子集
     * @param key
     * @param list
     * @return
     */
    private static List<Integer> exceptList(ArrayList<Integer> key, ArrayList<Integer> list) {
        List<Integer> results = new ArrayList<Integer>();
        for (Integer l : key) {
            if (!list.contains(l)) {
                results.add(l);
            }
        }
        return results;
    }


    /**
     * 方法描述：得到给定list的所有非空真子集
     * @param key
     * @return
     */
    private static List<ArrayList<Integer>> subList(ArrayList<Integer> key) {
        List<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < key.size(); i++) {
            ArrayList<Integer> l = new ArrayList<Integer>();
            l.add(key.get(i));
            results.add(l);
        }
        
        for (int i = 0; i < key.size(); i++) {
            int keyi = key.get(i);
            for (int j = i + 1; j < key.size(); j++) {
                int keyj = key.get(j);
                ArrayList<Integer> l = new ArrayList<Integer>();
                l.add(keyi);
                l.add(keyj);
                Collections.sort(l);
                if (!l.containsAll(key)) {
                    if (!results.containsAll(l)) {
                        results.add(l);
                    }
                }
            }
        }
        return results;
    }
}

2、ConditionalPatternBase.java

package com.apriori.fpgrowth;


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


/**
 * <p>本类描述: t条件模式基</p>
 * <p>其他说明: </p>
 * @author Wang Haiyang
 * @date 2015-6-19 下午05:01:40
 */
public class ConditionalPatternBase {
    
    /**每个条件模式基*/
    private List<Integer> base = new ArrayList<Integer>();
   
    /**每个条件模式基的值*/
    private Integer value;


    public List<Integer> getBase() {
        return base;
    }


    public void setBase(List<Integer> base) {
        this.base = base;
    }


    public Integer getValue() {
        return value;
    }


    public void setValue(Integer value) {
        this.value = value;
    }
}

3、TreeNode

package com.apriori.fpgrowth;


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


public class TreeNode implements Comparable<TreeNode>{


    /**节点名字*/
    private Integer name;
    
    /**节点的出现次数*/
    private Integer value = 0;
    
    /**节点的孩子*/
    private List<TreeNode> child = new ArrayList<TreeNode>();
    
    /**节点的父亲*/
    private TreeNode parent;
    
    @Override
    public int compareTo(TreeNode o) {
        return o.getValue() - this.value;
    }
    
    public List<TreeNode> getChild() {
        return child;
    }


    public void setChild(List<TreeNode> child) {
        this.child = child;
    }


    public TreeNode getParent() {
        return parent;
    }


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


    public Integer getName() {
        return name;
    }


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


    public Integer getValue() {
        return value;
    }


    public void setValue(Integer value) {
        this.value = value;
    }


}

4、FPGrowth

package com.apriori.fpgrowth;


import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;


import com.apriori.common.Aprioris;


/**
 * <p>
 *     本类描述:
 *         本类主要完成找出频繁项集
 *  </p>
 * <p>
 *     主要步骤：
 *         1. 找出频繁1项集，并按照支持度递减排列
 *         2. 遍历项集D，按照频繁1项集的顺序构造频繁模式增长树
 *         3. 找出条件模式基
 *         4. 根据条件模式基找出频繁模式
 * </p>
 * @author Wang Haiyang
 * @date 2015-6-19 上午10:26:53
 */
public class FPGrowth {


    /**
     * 方法描述： 得到频繁模式集
     * @param D
     * @param min_sup
     * @return
     */
    public static Map<ArrayList<Integer>, Integer> getFrequentItemsets(List<ArrayList<Integer>> D, Integer min_sup) {
        Map<ArrayList<Integer>, Integer> L = new HashMap<ArrayList<Integer>, Integer>();
        Aprioris.getFrequent1Itemsets(D, min_sup, L); // 得到频繁1项集
        ArrayList<TreeNode> L1 = sortDes(L); // 降序排序频繁1项集
        TreeNode root = createFPTree(D, L1); // 得到频繁模式增长树
        getFrequentItemsetsByFPTree(D, min_sup, root, L, L1); // 得到频繁模式
        return L;
    }


    /**
     * 方法描述：得到频繁模式
     * @param D
     * @param min_sup
     * @param root
     * @param L
     */
    private static void getFrequentItemsetsByFPTree(List<ArrayList<Integer>> D, Integer min_sup, TreeNode root,
            Map<ArrayList<Integer>, Integer> L, ArrayList<TreeNode> L1) {
        List<TreeNode> nodes = getLeafs(root); // 得到树的叶子节点
        Map<Integer, ArrayList<ConditionalPatternBase>> map = getAllConditionalPatternBases(nodes); // 得到所有的条件模式基
        // 得到所有的频繁模式
       
        for (Entry<Integer, ArrayList<ConditionalPatternBase>> entry : map.entrySet()) { // 得到组合条件模式基
            ArrayList<ConditionalPatternBase> value = entry.getValue();
            TreeNode t = createFPTree(value, L1); // 得到组合条件模式基树
            List<TreeNode> n = new ArrayList<TreeNode>();
            getNodes(t, min_sup, n); // 得到满足min_sup的节点
            
            for (int i = 0; i < n.size(); i++) {
                ArrayList<Integer> l = new ArrayList<Integer>();
                l.add(n.get(i).getName());
                l.add(entry.getKey());
                L.put(l, n.get(i).getValue());
            }
            
            for (int i = 0; i < n.size(); i++) {
                int keyi = n.get(i).getName();
                for (int j = i + 1; j < n.size(); j++) {
                    int keyj = n.get(j).getName();
                    ArrayList<Integer> l = new ArrayList<Integer>();
                    l.add(keyi);
                    l.add(keyj);
                    l.add(entry.getKey());
                    L.put(l, n.get(j).getValue());
                }
            }
        }
        
        
    }


    /**
     * 方法描述：得到满足min_sup的节点
     * @param node
     * @param min_sup
     * @param results
     */
    private static void getNodes(TreeNode node, Integer min_sup, List<TreeNode> results) {
        List<TreeNode> childs = node.getChild();
        if (childs == null || childs.size() == 0) {
            return;
        } else {
            for (TreeNode child : childs) {
                if (child.getValue() >= min_sup) {
                    results.add(child);
                }
                getNodes(child, min_sup, results);
            }
        }
        return;
    }


    /**
     * 方法描述：得到所有的条件模式基
     * @param nodes
     * @return
     */
    private static Map<Integer, ArrayList<ConditionalPatternBase>> getAllConditionalPatternBases(List<TreeNode> nodes) {
        Map<Integer, ArrayList<ConditionalPatternBase>> results = new HashMap<Integer, ArrayList<ConditionalPatternBase>>();
        for (TreeNode leaf : nodes) {
            ConditionalPatternBase base = new ConditionalPatternBase();
            TreeNode parent = leaf.getParent();
            base.setValue(leaf.getValue());
            List<Integer> ins = new ArrayList<Integer>();
            while (parent != null && parent.getName() != null) {
                ins.add(parent.getName());
                parent = parent.getParent();
            }
            Collections.reverse(ins);
            base.setBase(ins);
            if (results.containsKey(leaf.getName())) {
                results.get(leaf.getName()).add(base);
            } else {
                ArrayList<ConditionalPatternBase> lists = new ArrayList<ConditionalPatternBase>();
                lists.add(base);
                results.put(leaf.getName(), lists);
            }
        }
        return results;
    }


    /**
     * 方法描述：得到指定树的所有叶子节点
     * @param root
     * @return
     */
    private static List<TreeNode> getLeafs(TreeNode root) {
        List<TreeNode> results = new ArrayList<TreeNode>();
        traverseTree(root, results);
        return results;
    }


    /**
     * 方法描述：递归遍整个树
     * @param node
     */
    private static void traverseTree(TreeNode node, List<TreeNode> results) {
        List<TreeNode> childs = node.getChild();
        if (childs == null || childs.size() == 0) {
            results.add(node);
        } else {
            for (TreeNode child : childs) {
                traverseTree(child, results);
            }
        }
    }


    /**
     * 方法描述： 得到频繁模式增长树
     * @param D
     * @param L1
     * @return
     */
    private static TreeNode createFPTree(List<ArrayList<Integer>> D, ArrayList<TreeNode> L1) {
        TreeNode root = new TreeNode();
        for (ArrayList<Integer> lists : D) {
            int flag = 0;
            for (TreeNode node : L1) { // 针对lists，按照L1的顺序排序
                if(lists.contains(node.getName())) {
                    int index = lists.indexOf(node.getName());
                    swap(lists, index, flag);
                    flag++;
                }
            }
            
            TreeNode node = root;
            for (Integer element : lists) { // 将lists放到result（即tree中）
                if(containsValue(node.getChild(), element)) {
                    int index = getIndexOf(node.getChild(), element);
                    node.getChild().get(index).setValue(node.getChild().get(index).getValue() + 1);
                    node.getChild().get(index).setParent(node);
                    node = node.getChild().get(index);
                } else {
                    TreeNode n = new TreeNode();
                    n.setName(element);
                    n.setValue(1);
                    node.getChild().add(n);
                    n.setParent(node);
                    node = n;
                }
            }
        }
        return root;
    }
    
    private static TreeNode createFPTree(ArrayList<ConditionalPatternBase> value, ArrayList<TreeNode> L1) {
        TreeNode root = new TreeNode();
        for (ConditionalPatternBase c : value) {
           ArrayList<Integer> lists = (ArrayList<Integer>)c.getBase();
           int v = c.getValue();
            int flag = 0;
            for (TreeNode node : L1) { // 针对lists，按照L1的顺序排序
                if(lists.contains(node.getName())) {
                    int index = lists.indexOf(node.getName());
                    swap(lists, index, flag);
                    flag++;
                }
            }
            
            TreeNode node = root;
            for (Integer element : lists) { // 将lists放到result（即tree中）
                if(containsValue(node.getChild(), element)) {
                    int index = getIndexOf(node.getChild(), element);
                    node.getChild().get(index).setValue(node.getChild().get(index).getValue() + v);
                    node.getChild().get(index).setParent(node);
                    node = node.getChild().get(index);
                } else {
                    TreeNode n = new TreeNode();
                    n.setName(element);
                    n.setValue(v);
                    node.getChild().add(n);
                    n.setParent(node);
                    node = n;
                }
            }
        }
        return root;
    }
    
    /**
     * 方法描述： 交换
     * @param lists
     * @param index
     * @param flag
     */
    private static void swap(ArrayList<Integer> lists, int index, int flag) {
        int temp = lists.get(index);
        lists.set(index, lists.get(flag));
        lists.set(flag, temp);
    }


    /**
     * 方法描述：按照出现次数降序排序频繁1项集
     * @param L
     * @return
     */
    private static ArrayList<TreeNode> sortDes(Map<ArrayList<Integer>, Integer> L) {
        ArrayList<TreeNode> results = new ArrayList<TreeNode>();
        for (Entry<ArrayList<Integer>, Integer> enttry : L.entrySet()) {
            TreeNode node = new TreeNode();
            node.setName(enttry.getKey().get(0));
            node.setValue(enttry.getValue());
            results.add(node);
        }
        Collections.sort(results);
        return results;
    }
    
    private static int getIndexOf(List<TreeNode> child, Integer element) {
        for (int i = 0; i < child.size(); i++) {
            if(child.get(i).getName() == element) {
                return i;
            }
        }
        return 0;
    }


    private static boolean containsValue(List<TreeNode> child, Integer element) {
        for (TreeNode node : child) {
            if(node.getName() == element) {
                return true;
            }
        }
        return false;
    }
    
    public static void main(String[] args) {
        List<ArrayList<Integer>> D = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(5);
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        list2.add(2);
        list2.add(4);
        ArrayList<Integer> list3 = new ArrayList<Integer>();
        list3.add(2);
        list3.add(3);
        ArrayList<Integer> list4 = new ArrayList<Integer>();
        list4.add(1);
        list4.add(2);
        list4.add(4);
        ArrayList<Integer> list5 = new ArrayList<Integer>();
        list5.add(1);
        list5.add(3);
        ArrayList<Integer> list6 = new ArrayList<Integer>();
        list6.add(2);
        list6.add(3);
        ArrayList<Integer> list7 = new ArrayList<Integer>();
        list7.add(1);
        list7.add(3);
        ArrayList<Integer> list8 = new ArrayList<Integer>();
        list8.add(1);
        list8.add(2);
        list8.add(3);
        list8.add(5);
        ArrayList<Integer> list9 = new ArrayList<Integer>();
        list9.add(1);
        list9.add(2);
        list9.add(3);
        D.add(list1);
        D.add(list2);
        D.add(list3);
        D.add(list4);
        D.add(list5);
        D.add(list6);
        D.add(list7);
        D.add(list8);
        D.add(list9);
        Integer min_sup = 2;
        Double min_con = 0.7;
        Map<ArrayList<Integer>, Integer> L = getFrequentItemsets(D, min_sup);
        Aprioris.displayFrequentItemsets(L); // 打印频繁项集
        Map<String, Double> rules = Aprioris.produceAssociationRules(L, min_con); // 产生关联规则
        Aprioris.displayAssociationRules(rules); // 打印关联规则
    }
}