FPGrowth的java实现

最新推荐文章于 2021-02-27 09:52:15 发布

小海洋why

最新推荐文章于 2021-02-27 09:52:15 发布

阅读量2.3k

点赞数

分类专栏：数据挖掘

本文链接：https://blog.csdn.net/aa20132413013/article/details/46604927

版权

本文介绍了FPGrowth算法的Java实现，包括公共类`Aprioris`、条件模式基类`ConditionalPatternBase`和树节点类`TreeNode`。通过`getFrequentItemsets`方法获取频繁项集，使用`FPTree`构建频繁模式增长树，进而找出所有条件模式基，最终生成关联规则。

摘要由CSDN通过智能技术生成

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(ArrayLis