数据挖掘-关联分析频繁模式挖掘Apriori、FP-Growth及Eclat算法的JAVA及C++实现

(update 2012.12.28 关于本项目下载及运行的常见问题 FAQ见 newsgroup18828文本分类器、文本聚类器、关联分析频繁模式挖掘算法的Java实现工程下载及运行FAQ )

一、Apriori算法

Apriori是非常经典的关联分析频繁模式挖掘算法，其思想简明，实现方便，只是效率很低，可以作为频繁模式挖掘的入门算法。其主要特点是

1、k-1项集连接规律：若有两个k-1项集，每个项集保证有序，如果两个k-1项集的前k-2个项相同，而最后一个项不同，则证明它们是可连接的，可连接生成k项集。
2、反单调性。如果一个项集是频繁的，那么它的所有子集都是频繁的。即若一个项集的子集不是频繁项集，则该项集肯定也不是频繁项集。

主要算法流程：
1. 扫描数据库，生成候选1项集和频繁1项集。

2. 从2项集开始循环，由频繁k-1项集生成频繁频繁k项集。

2.1 频繁k-1项集两两组合，判定是否可以连接，若能则连接生成k项集。

2.2 对k项集中的每个项集检测其子集是否频繁，舍弃掉子集不是频繁项集即 不在频繁k-1项集中的项集。

2.3 扫描数据库，计算2.3步中过滤后的k项集的支持度，舍弃掉支持度小于阈值的项集，生成频繁k项集。

3. 若当前k项集中只有一个项集时循环结束。
伪代码如下：



JAVA实现代码

[java] view
plaincopy





package com.pku.yangliu;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

/**频繁模式挖掘算法Apriori实现

*

*/

public class AprioriFPMining {

private int minSup;//最小支持度

private static List<Set<String>> dataTrans;//以List<Set<String>>格式保存的事物数据库,利用Set的有序性

public int getMinSup() {

return minSup;

}

public void setMinSup(int minSup) {

this.minSup = minSup;

}

/**

* @param args

*/

public static void main(String[] args) throws IOException {

AprioriFPMining apriori = new AprioriFPMining();

double [] threshold = {0.25, 0.20, 0.15, 0.10, 0.05};

String srcFile = "F:/DataMiningSample/FPmining/Mushroom.dat";

String shortFileName = srcFile.split("/")[3];

String targetFile = "F:/DataMiningSample/FPmining/" + shortFileName.substring(0, shortFileName.indexOf("."))+"_fp_threshold";

dataTrans = apriori.readTrans(srcFile);

for(int k = 0; k < threshold.length; k++){

System.out.println(srcFile + " threshold: " + threshold[k]);

long totalItem = 0;

long totalTime = 0;

FileWriter tgFileWriter = new FileWriter(targetFile + (threshold[k]*100));

apriori.setMinSup((int)(dataTrans.size() * threshold[k]));//原始蘑菇的数据0.25只需要67秒跑出结果

long startTime = System.currentTimeMillis();

Map<String, Integer> f1Set = apriori.findFP1Items(dataTrans);

long endTime = System.currentTimeMillis();

totalTime += endTime - startTime;

//频繁1项集信息得加入支持度

Map<Set<String>, Integer> f1Map = new HashMap<Set<String>, Integer>();

for(Map.Entry<String, Integer> f1Item : f1Set.entrySet()){

Set<String> fs = new HashSet<String>();

fs.add(f1Item.getKey());

f1Map.put(fs, f1Item.getValue());

}

totalItem += apriori.printMap(f1Map, tgFileWriter);

Map<Set<String>, Integer> result = f1Map;

do {

startTime = System.currentTimeMillis();

result = apriori.genNextKItem(result);

endTime = System.currentTimeMillis();

totalTime += endTime - startTime;

totalItem += apriori.printMap(result, tgFileWriter);

} while(result.size() != 0);

tgFileWriter.close();

System.out.println("共用时：" + totalTime + "ms");

System.out.println("共有" + totalItem + "项频繁模式");

}

}

/**由频繁K-1项集生成频繁K项集

* @param preMap 保存频繁K项集的map

* @param tgFileWriter 输出文件句柄

* @return int 频繁i项集的数目

* @throws IOException

*/

private Map<Set<String>, Integer> genNextKItem(Map<Set<String>, Integer> preMap) {

// TODO Auto-generated method stub

Map<Set<String>, Integer> result = new HashMap<Set<String>, Integer>();

//遍历两个k-1项集生成k项集

List<Set<String>> preSetArray = new ArrayList<Set<String>>();

for(Map.Entry<Set<String>, Integer> preMapItem : preMap.entrySet()){

preSetArray.add(preMapItem.getKey());

}

int preSetLength = preSetArray.size();

for (int i = 0; i < preSetLength - 1; i++) {

for (int j = i + 1; j < preSetLength; j++) {

String[] strA1 = preSetArray.get(i).toArray(new String[0]);

String[] strA2 = preSetArray.get(j).toArray(new String[0]);

if (isCanLink(strA1, strA2)) { // 判断两个k-1项集是否符合连接成k项集的条件　

Set<String> set = new TreeSet<String>();

for (String str : strA1) {

set.add(str);

}

set.add((String) strA2[strA2.length - 1]); // 连接成k项集

// 判断k项集是否需要剪切掉，如果不需要被cut掉，则加入到k项集列表中

if (!isNeedCut(preMap, set)) {//由于单调性，必须保证k项集的所有k-1项子集都在preMap中出现，否则就该剪切该k项集

result.put(set, 0);

}

}

}

}

return assertFP(result);//遍历事物数据库，求支持度，确保为频繁项集

}

/**检测k项集是否该剪切。由于单调性，必须保证k项集的所有k-1项子集都在preMap中出现，否则就该剪切该k项集

* @param preMap k-1项频繁集map

* @param set 待检测的k项集

* @return boolean 是否该剪切

* @throws IOException

*/

private boolean isNeedCut(Map<Set<String>, Integer> preMap, Set<String> set) {

// TODO Auto-generated method stub

boolean flag = false;

List<Set<String>> subSets = getSubSets(set);

for(Set<String> subSet : subSets){

if(!preMap.containsKey(subSet)){

flag = true;

break;

}

}

return flag;

}

/**获取k项集set的所有k-1项子集

* @param set 频繁k项集

* @return List<Set<String>> 所有k-1项子集容器

* @throws IOException

*/

private List<Set<String>> getSubSets(Set<String> set) {

// TODO Auto-generated method stub

String[] setArray = set.toArray(new String[0]);

List<Set<String>> result = new ArrayList<Set<String>>();

for(int i = 0; i < setArray.length; i++){

Set<String> subSet = new HashSet<String>();

for(int j = 0; j < setArray.length; j++){

if(j != i) subSet.add(setArray[j]);

}

result.add(subSet);

}

return result;

}

/**遍历事物数据库，求支持度，确保为频繁项集

* @param allKItem 候选频繁k项集

* @return Map<Set<String>, Integer> 支持度大于阈值的频繁项集和支持度map

* @throws IOException

*/

private Map<Set<String>, Integer> assertFP(

Map<Set<String>, Integer> allKItem) {

// TODO Auto-generated method stub

Map<Set<String>, Integer> result = new HashMap<Set<String>, Integer>();

for(Set<String> kItem : allKItem.keySet()){

for(Set<String> data : dataTrans){

boolean flag = true;

for(String str : kItem){

if(!data.contains(str)){

flag = false;

break;

}

}

if(flag) allKItem.put(kItem, allKItem.get(kItem) + 1);

}

if(allKItem.get(kItem) >= minSup) {

result.put(kItem, allKItem.get(kItem));

}

}

return result;

}

/**检测两个频繁K项集是否可以连接，连接条件是只有最后一个项不同

* @param strA1 k项集1

* @param strA1 k项集2

* @return boolean 是否可以连接

* @throws IOException

*/

private boolean isCanLink(String[] strA1, String[] strA2) {

// TODO Auto-generated method stub

boolean flag = true;

if(strA1.length != strA2.length){

return false;

}else {

for(int i = 0; i < strA1.length - 1; i++){

if(!strA1[i].equals(strA2[i])){

flag = false;

break;

}

}

if(strA1[strA1.length -1].equals(strA2[strA1.length -1])){

flag = false;

}

}

return flag;

}

/**将频繁i项集的内容及支持度输出到文件 格式为 模式:支持度

* @param f1Map 保存频繁i项集的容器<i项集 , 支持度>

* @param tgFileWriter 输出文件句柄

* @return int 频繁i项集的数目

* @throws IOException

*/

private int printMap(Map<Set<String>, Integer> f1Map, FileWriter tgFileWriter) throws IOException {

// TODO Auto-generated method stub

for(Map.Entry<Set<String>, Integer> f1MapItem : f1Map.entrySet()){

for(String p : f1MapItem.getKey()){

tgFileWriter.append(p + " ");

}

tgFileWriter.append(": " + f1MapItem.getValue() + "\n");

}

tgFileWriter.flush();

return f1Map.size();

}

/**生成频繁1项集

* @param fileDir 事务文件目录

* @return Map<String, Integer> 保存频繁1项集的容器<1项集 , 支持度>

* @throws IOException

*/

private Map<String, Integer> findFP1Items(List<Set<String>> dataTrans) {

// TODO Auto-generated method stub

Map<String, Integer> result = new HashMap<String, Integer>();

Map<String, Integer> itemCount = new HashMap<String, Integer>();

for(Set<String> ds : dataTrans){

for(String d : ds){

if(itemCount.containsKey(d)){

itemCount.put(d, itemCount.get(d) + 1);

} else {

itemCount.put(d, 1);

}

}

}

for(Map.Entry<String, Integer> ic : itemCount.entrySet()){

if(ic.getValue() >= minSup){

result.put(ic.getKey(), ic.getValue());

}

}

return result;

}

/**读取事务数据库

* @param fileDir 事务文件目录

* @return List<String> 保存事务的容器

* @throws IOException

*/

private List<Set<String>> readTrans(String fileDir) {

// TODO Auto-generated method stub

List<Set<String>> records = new ArrayList<Set<String>>();

try {

FileReader fr = new FileReader(new File(fileDir));

BufferedReader br = new BufferedReader(fr);

String line = null;

while ((line = br.readLine()) != null) {

if (line.trim() != "") {

Set<String> record = new HashSet<String>();

String[] items = line.split(" ");

for (String item : items) {

record.add(item);

}

records.add(record);

}

}

} catch (IOException e) {

System.out.println("读取事务文件失败。");

System.exit(-2);

}

return records;

}

}

硬件环境：Intel Core 2 Duo CPU T5750 2GHZ, 2G内存

实验结果

F:/DataMiningSample/FPmining/Mushroom.dat threshold: 0.25

共用时：54015ms

共有5545项频繁模式

F:/DataMiningSample/FPmining/Mushroom.dat threshold: 0.2

共用时：991610ms

共有53663项频繁模式

F:/DataMiningSample/FPmining/Mushroom.dat threshold: 0.15
结论：对Mushroom.dat挖掘出来的频繁模式及支持度、频繁模式总数正确，但是算法速度很慢，对大数据量如T10I4D100K低阈值挖掘时间太长

解决办法：改用C++写FP-Growth算法做频繁模式挖掘！

二、FP-Growth算法
FP-Growth算法由数据挖掘界大牛Han Jiawei教授于SIGMOD 00‘大会提出，提出根据事物数据库构建FP-Tree，然后基于FP-Tree生成频繁模式集。主要算法流程如下
Step1 读取数据库，构造频繁1项集及FP-tree



Step2 遍历FP-tree的头表，对于每个频繁项x，累积项x的所有前缀路径形成x的条件模式库CPB



Step3 对CPB上每一条路径的节点更新计数为x的计数，根据CPB构造条件FP-tree

Step4 从条件FP-tree中找到所有长路径，对该路径上的节点找出所有组合方式，然后合并计数

Step5 将Step4中的频繁项集与x合并，得到包含x的频繁项集

Step2-5 循环，直到遍历头表中的所有项



由于时间关系，主要基于芬兰教授Bart Goethals的开源代码实现，源码下载见点击打开链接 ，文件结构及运行结果如下



对Mushroom.dat，accidents.dat和T10I4D100K.dat三个数据集做频繁模式挖掘的结果如下







三、Eclat算法

Eclat算法加入了倒排的思想，加快频繁集生成速度，其算法思想是 由频繁k项集求交集，生成候选k+1项集 。对候选k+1项集做裁剪，生成频繁k+1项集，再求交集生成候选k+2项集。如此迭代，直到项集归一。

算法过程：

1.一次扫描数据库，获得初始数据。包括频繁1项集，数据库包含的所有items，事务总数（行）transNum，最小支持度minsup=limitValue*trans。

2.二次扫描数据库，获得频繁2项集。

3.按照Eclat算法，对频繁2项集迭代求交集，做裁剪，直到项集归一。

JAVA实现如下

[java] view
plaincopy





package com.pku.yhf;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.BitSet;

import java.util.Iterator;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

public class EclatRelease {

private File file=new File("D:/mushroom.dat.txt");

private float limitValue=0.25f;

private int transNum=0;

private ArrayList<HeadNode> array=new ArrayList<HeadNode>();

private HashHeadNode[] hashTable;//存放临时生成的频繁项集，作为重复查询的备选集合

public long newItemNum=0;

private File tempFile=null;

private BufferedWriter bw=null;

public static long modSum=0;

/**

* 第一遍扫描数据库，确定Itemset,根据阈值计算出支持度数

*/

public void init()

{

Set itemSet=new TreeSet();

MyMap<Integer,Integer> itemMap=new MyMap<Integer,Integer>();

int itemNum=0;

Set[][] a;

try {

FileInputStream fis=new FileInputStream(file);

BufferedReader br=new BufferedReader(new InputStreamReader(fis));

String str=null;

//第一次扫描数据集合

while((str=br.readLine()) != null)

{

transNum++;

String[] line=str.split(" ");

for(String item:line)

{

itemSet.add(Integer.parseInt(item));

itemMap.add(Integer.parseInt((item)));

}

}

br.close();

// System.out.println("itemMap lastKey:"+itemMap.lastKey());

// System.out.println("itemsize:"+itemSet.size());

// System.out.println("trans: "+transNum);

//ItemSet.limitSupport=(int)Math.ceil(transNum*limitValue);//上取整

ItemSet.limitSupport=(int)Math.floor(transNum*limitValue);//下取整

ItemSet.ItemSize=(Integer)itemMap.lastKey();

ItemSet.TransSize=transNum;

hashTable=new HashHeadNode[ItemSet.ItemSize*3];//生成项集hash表

for(int i=0;i<hashTable.length;i++)

{

hashTable[i]=new HashHeadNode();

}

// System.out.println("limitSupport:"+ItemSet.limitSupport);

tempFile=new File(file.getParent()+"/"+file.getName()+".dat");

if(tempFile.exists())

{

tempFile.delete();

}

tempFile.createNewFile();

bw=new BufferedWriter(new FileWriter(tempFile));

Set oneItem=itemMap.keySet();

int countOneItem=0;

for(Iterator it=oneItem.iterator();it.hasNext();)

{

int key=(Integer)it.next();

int value=(Integer)itemMap.get(key);

if(value >= ItemSet.limitSupport)

{

bw.write(key+" "+":"+" "+value);

bw.write("\n");

countOneItem++;

}

}

bw.flush();

modSum+=countOneItem;

itemNum=(Integer)itemMap.lastKey();

a=new TreeSet[itemNum+1][itemNum+1];

array.add(new HeadNode());//空项

for(short i=1;i<=itemNum;i++)

{

HeadNode hn=new HeadNode();

// hn.item=i;

array.add(hn);

}

BufferedReader br2=new BufferedReader(new FileReader(file));

//第二次扫描数据集合,形成2-项候选集

int counter=0;//事务

int max=0;

while((str=br2.readLine()) != null)

{max++;

String[] line=str.split(" ");

counter++;

for(int i=0;i<line.length;i++)

{

int sOne=Integer.parseInt(line[i]);

for(int j=i+1;j<line.length;j++)

{

int sTwo=Integer.parseInt(line[j]);

if(a[sOne][sTwo] == null)

{

Set set=new TreeSet();

set.add(counter);

a[sOne][sTwo]=set;

}

else{

a[sOne][sTwo].add(counter);

}

}

}

}

//将数组集合转换为链表集合

for(int i=1;i<=itemNum;i++)

{

HeadNode hn=array.get(i);

for(int j=i+1;j<=itemNum;j++)

{

if(a[i][j] != null && a[i][j].size() >= ItemSet.limitSupport)

{

hn.items++;

ItemSet is=new ItemSet(true);

is.item=2;

is.items.set(i);

is.items.set(j);

is.supports=a[i][j].size();

bw.write(i+" "+j+" "+": "+is.supports);

bw.write("\n");

//统计频繁2-项集的个数

modSum++;

for(Iterator it=a[i][j].iterator();it.hasNext();)

{

int value=(Integer)it.next();

is.trans.set(value);

}

if( hn.first== null)

{

hn.first=is;

hn.last=is;

}

else{

hn.last.next=is;

hn.last=is;

}

}

}

}

bw.flush();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

public void start()

{

boolean flag=true;

//TreeSet ts=new TreeSet();//临时存储项目集合，防止重复项集出现，节省空间

int count=0;

ItemSet shareFirst=new ItemSet(false);

while(flag)

{

flag=false;

//System.out.println(++count);

for(int i=1;i<array.size();i++)

{

HeadNode hn=array.get(i);

if(hn.items > 1 )//项集个数大于1

{

generateLargeItemSet(hn,shareFirst);

flag=true;

}

clear(hashTable);

}

}try {

bw.close();

} catch (IOException e) {

e.printStackTrace();

}

}

public void generateLargeItemSet(HeadNode hn,ItemSet shareFirst){

BitSet bsItems=new BitSet(ItemSet.ItemSize);//存放链两个k-1频繁项集的ItemSet交

BitSet bsTrans=new BitSet(ItemSet.TransSize);//存放两个k-1频繁项集的Trans交

BitSet containItems=new BitSet(ItemSet.ItemSize);//存放两个k-1频繁项集的ItemSet的并

BitSet bsItems2=new BitSet(ItemSet.ItemSize);//临时存放容器BitSet

ItemSet oldCurrent=null,oldNext=null;

oldCurrent=hn.first;

long countItems=0;

ItemSet newFirst=new ItemSet(false),newLast=newFirst;

while(oldCurrent != null)

{

oldNext=oldCurrent.next;

while(oldNext != null)

{

//生成k—项候选集，由两个k-1项频繁集生成

bsItems.clear();

bsItems.or(oldCurrent.items);

bsItems.and(oldNext.items);

if(bsItems.cardinality() < oldCurrent.item-1)

{

break;

}

//新合并的项集是否已经存在

containItems.clear();

containItems.or(oldCurrent.items);//将k-1项集合并

containItems.or(oldNext.items);

if(!containItems(containItems,bsItems2,newFirst)){

bsTrans.clear();

bsTrans.or(oldCurrent.trans);

bsTrans.and(oldNext.trans);

if(bsTrans.cardinality() >= ItemSet.limitSupport)

{

ItemSet is=null;

if(shareFirst.next == null)//没有共享ItemSet链表

{

is=new ItemSet(true);

newItemNum++;

}

else

{

is=shareFirst.next;

shareFirst.next=shareFirst.next.next;

is.items.clear();

is.trans.clear();

is.next=null;

}

is.item=(oldCurrent.item+1);//生成k—项候选集，由两个k-1项频繁集生成

is.items.or(oldCurrent.items);//将k-1项集合并

is.items.or(oldNext.items);//将k-1项集合并

is.trans.or(oldCurrent.trans);//将bs1的值复制到bs中

is.trans.and(oldNext.trans);

is.supports=is.trans.cardinality();

writeToFile(is.items,is.supports);//将频繁项集及其支持度写入文件

countItems++;

modSum++;

newLast.next=is;

newLast=is;

}

}

oldNext=oldNext.next;

}

oldCurrent=oldCurrent.next;

}

ItemSet temp1=hn.first;

ItemSet temp2=hn.last;

temp2.next=shareFirst.next;

shareFirst.next=temp1;

hn.first=newFirst.next;

hn.last=newLast;

hn.items=countItems;

}

public boolean containItems(BitSet containItems,BitSet bsItems2,ItemSet first)

{

long size=containItems.cardinality();//项集数目

int itemSum=0;

int temp=containItems.nextSetBit(0);

while(true)

{

itemSum+=temp;

temp=containItems.nextSetBit(temp+1);

if(temp == -1)

{

break;

}

}

int hash=itemSum%(ItemSet.ItemSize*3);

HashNode hn=hashTable[hash].next;

Node pre=hashTable[hash];

while(true)

{

if(hn == null)//不包含containItems

{

HashNode node=new HashNode();

node.bs.or(containItems);

pre.next=node;

return false;

}

if(hn.bs.isEmpty())

{

hn.bs.or(containItems);

return false;

}

bsItems2.clear();

bsItems2.or(containItems);

bsItems2.and(hn.bs);

if(bsItems2.cardinality() == size)

{

return true;

}

pre=hn;

hn=hn.next;

}

}

public void clear(HashHeadNode[] hashTable)

{

for(int i=0;i<hashTable.length;i++)

{

HashNode node=hashTable[i].next;

while(node != null)

{

node.bs.clear();

node=node.next;

}

}

}

public void writeToFile(BitSet items,int supports)

{

StringBuilder sb=new StringBuilder();

//sb.append("<");

int temp=items.nextSetBit(0);

sb.append(temp);

while(true)

{

temp=items.nextSetBit(temp+1);

if(temp == -1)

{

break;

}

//sb.append(",");

sb.append(" ");

sb.append(temp);

}

sb.append(" :"+" "+supports);

try {

bw.write(sb.toString());

bw.write("\n");

} catch (IOException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

EclatRelease e=new EclatRelease();

long begin=System.currentTimeMillis();

e.init();

e.start();

long end=System.currentTimeMillis();

double time=(double)(end-begin)/1000;

System.out.println("共耗时"+time+"秒");

System.out.println("频繁模式数目:"+EclatRelease.modSum);

}

}

class MyMap<T,E> extends TreeMap

{

public void add(T obj)

{

if(this.containsKey(obj))

{

int value=(Integer)this.get(obj);

this.put(obj, value+1);

}

else

this.put(obj, 1);

}

}

ItemSet类如下

[java] view
plaincopy





package com.pku.yhf;

import java.util.BitSet;

public class ItemSet {

public static int limitSupport;//根据阈值计算出的最小支持度数

public static int ItemSize;//Items数目

public static int TransSize; //事务数目

public boolean flag=true; //true，表示作为真正的ItemSet,false只作为标记节点，只在HashTabel中使用

public int item=0;// 某项集

public int supports=0;//项集的支持度

public BitSet items=null;

public BitSet trans=null;

//public TreeSet items=new TreeSet();//项集

//public TreeSet trans=new TreeSet();//事务集合

public ItemSet next=null;//下一个项集

public ItemSet(boolean flag)

{

this.flag=flag;

if(flag)

{

item=0;// 某项集

supports=0;//项集的支持度

items=new BitSet(ItemSize+1);

trans=new BitSet(TransSize+1);

}

}

}

对mushroom.dat的频繁模式挖掘结果如下



后期打算实现北大邓志鸿老师提出的PPV-Tree算法(基于节点列表的频繁模式挖掘算法)，挖掘速度超过Han Jiawei教授的FP-Growth算法，敬请关注:)