数据挖掘-关联分析-Apriori算法Java实现 支持度+置信度

apriori算法是最基本的发现频繁项集的算法，它的名字也体现了它的思想——先验，采用逐层搜索迭代的方法，挖掘任何可能的项集，k项集用于挖掘k+1项集。

先验性质

频繁项集的所有非空子集也一定是频繁的

该性质体现了项集挖掘中的反单调性，如果k项集不是频繁的，那么k+1项集一定也不是。基于这一点，算法的基本思想为：

step 1：连接

为了搜索k项集，将k-1项集自连接产生候选的k项集，称为候选集。

为了有效的实现连接，首先对每一项进行排序。其次，若满足连接的条件，则进行连接。

连接的条件，前k-2项相同，k-1项不同

step 2：剪枝

k项集的每一个k-1项子集都存在与k-1项集，并且支持度满足最小支持度阀值。

伪代码：

C<k>:candidata itemset of size k

L<k>:frequent itemset of size k

L<1>=frequent items

for(k=1;L<k>!=null;k++)

C<k+1>=candidates generated from L<k>

for transaction t in dataset

increment the count of all candidates in C<k+1> that are contained in t L<k+1>=candidates in C<k+1> with support>=min_support

return
Java代码实现方式：
抽象了一个项集实体类，并实现是否可以合并的方法，这个方法最初是使用TreeSet.headSet来实现的，但是在测试时发现性能瓶颈都产生在这个方法上，并造成OOM，很是费解，待研究清楚后总结一下。

/**
*
*/
package org.waitingfortime.datamining.association;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
* @author mazhiyuan
*
*/
public class Apriori {
private int minNum;// 最小支持数
private List<Set<Integer>> records;
private String output;
private List<List<ItemSet>> result = new ArrayList<List<ItemSet>>();

public Apriori(double minDegree, String input, String output) {
this.output = output;
init(input);
if (records.size() == 0) {
System.err.println("不符合计算条件。退出！");
System.exit(1);
}
minNum = (int) (minDegree * records.size());
}

private void init(String path) {
// TODO Auto-generated method stub
records = new ArrayList<Set<Integer>>();
try {
BufferedReader br = new BufferedReader(new FileReader(
new File(path)));

String line = null;
Set<Integer> record;
while ((line = br.readLine()) != null) {
if (!"".equals(line.trim())) {
record = new TreeSet<Integer>();
String[] items = line.split(" ");
for (String item : items) {
record.add(Integer.valueOf(item));
}
records.add(record);
}
}

br.close();
} catch (IOException e) {
System.err.println("读取事务文件失败。");
}
}

private List<ItemSet> first() {
// TODO Auto-generated method stub
List<ItemSet> first = new ArrayList<ItemSet>();
Map<Integer, Integer> _first = new HashMap<Integer, Integer>();
for (Set<Integer> si : records)
for (Integer i : si) {
if (_first.get(i) == null)
_first.put(i, 1);
else
_first.put(i, _first.get(i) + 1);
}

for (Integer i : _first.keySet())
if (_first.get(i) >= minNum)
first.add(new ItemSet(i, _first.get(i)));

return first;
}

private void loop(List<ItemSet> items) {
// TODO Auto-generated method stub
List<ItemSet> copy = new ArrayList<ItemSet>(items);
List<ItemSet> res = new ArrayList<ItemSet>();
int size = items.size();

// 连接
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (copy.get(i).isMerge(copy.get(j))) {
ItemSet is = new ItemSet(copy.get(i));
is.merge(copy.get(j).item.last());
res.add(is);
}
// 剪枝
pruning(copy, res);

if (res.size() != 0) {
result.add(res);
loop(res);
}
}

private void pruning(List<ItemSet> pre, List<ItemSet> res) {
// TODO Auto-generated method stub
// step 1 k项集的子集属于k-1项集
Iterator<ItemSet> ir = res.iterator();
while (ir.hasNext()) {
// 获取所有k-1项子集
ItemSet now = ir.next();
List<List<Integer>> ss = subSet(now);
// 判断是否在pre集中
boolean flag = false;
for (List<Integer> li : ss) {
if (flag)
break;
for (ItemSet pis : pre) {
if (pis.item.containsAll(li)) {
flag = false;
break;
}
flag = true;
}
}
if (flag) {
ir.remove();
continue;
}
// step 2 支持度
int i = 0;
for (Set<Integer> sr : records) {
if (sr.containsAll(now.item))
i++;

now.value = i;
}
if (now.value < minNum)
ir.remove();
}
}

private List<List<Integer>> subSet(ItemSet is) {
// TODO Auto-generated method stub
List<Integer> li = new ArrayList<Integer>(is.item);
List<List<Integer>> res = new ArrayList<List<Integer>>();
for (int i = 0, j = li.size(); i < j; i++) {
List<Integer> _li = new ArrayList<Integer>(li);
_li.remove(i);
res.add(_li);
}
return res;
}

private void output() throws FileNotFoundException {
if (result.size() == 0) {
System.err.println("无结果集。退出！");
return;
}
FileOutputStream out = new FileOutputStream(output);
PrintStream ps = new PrintStream(out);
for (List<ItemSet> li : result) {
ps.println("=============频繁"+li.get(0).item.size()+"项集=============");
for (ItemSet is : li)
ps.println(is.item + " : " + is.value);
ps.println("=====================================");
}
}

/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
// TODO Auto-generated method stub
long begin = System.currentTimeMillis();
Apriori apriori = new Apriori(0.25,
"/home/mazhiyuan/code/mushroom.dat",
"/home/mazhiyuan/code/mout.data");
// apriori.first();//频繁1项集
apriori.loop(apriori.first());
apriori.output();
System.out.println((System.currentTimeMillis()) - begin);
}
}

class ItemSet {
TreeSet<Integer> item;
int value;

ItemSet(ItemSet is) {
this.item = new TreeSet<Integer>(is.item);
}

ItemSet() {
item = new TreeSet<Integer>();
}

ItemSet(int i, int v) {
this();
merge(i);
setValue(v);
}

void setValue(int i) {
this.value = i;
}

void merge(int i) {
item.add(i);
}

boolean isMerge(ItemSet other) {
if (other == null || other.item.size() != item.size())
return false;
// 前k-1项相同，最后一项不同，满足连接条件
/*
* Iterator<Integer> i = item.headSet(item.last()).iterator();
* Iterator<Integer> o =
* other.item.headSet(other.item.last()).iterator(); while (i.hasNext() &&
* o.hasNext()) if (i.next() != o.next()) return false;
*/
Iterator<Integer> i = item.iterator();
Iterator<Integer> o = other.item.iterator();
int n = item.size();
while (i.hasNext() && o.hasNext() && --n > 0)
if (i.next() != o.next())
return false;

return !(item.last() == other.item.last());
}
}

使用mushroom数据集，整个运行时间只有大概6s，性能还算满意。
这个代码只是计算了频繁项集，还没有计算关联规则和置信度，稍后补上。

=========补充了关联规则的生成======== 比想象的要麻烦一点

关联规则可以是双向的，confidence(A-->B)=P(A|B)=support(A&B)/support(A)

所以在计算k项集的关联规则时，其分母都是k项集的支持度，分子为k-1项集的支持度，以及对应1项集的支持度

/**
*
*/
package org.waitingfortime.datamining.association;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
* @author mazhiyuan
*
*/
public class Apriori {
private int minNum;// 最小支持数
private double minCon;// 最小置信度
private List<Set<Integer>> records;// 原始数据
private String output;// 输出路径
private List<List<ItemSet>> result = new ArrayList<List<ItemSet>>();// 频繁项集结果
private List<ItemSet> fth;// 频繁1项集

public Apriori(double minDegree, double minCon, String input, String output) {
this.output = output;
this.minCon = minCon;
init(input);
if (records.size() == 0) {
System.err.println("不符合计算条件。退出！");
System.exit(1);
}
minNum = (int) (minDegree * records.size());
}

private void init(String path) {
// TODO Auto-generated method stub
records = new ArrayList<Set<Integer>>();
try {
BufferedReader br = new BufferedReader(new FileReader(
new File(path)));

String line = null;
Set<Integer> record;
while ((line = br.readLine()) != null) {
if (!"".equals(line.trim())) {
record = new TreeSet<Integer>();
String[] items = line.split(" ");
for (String item : items) {
record.add(Integer.valueOf(item));
}
records.add(record);
}
}

br.close();
} catch (IOException e) {
System.err.println("读取事务文件失败。");
}
}

private void first() {
// TODO Auto-generated method stub
fth = new ArrayList<ItemSet>();
Map<Integer, Integer> first = new HashMap<Integer, Integer>();
for (Set<Integer> si : records)
for (Integer i : si) {
if (first.get(i) == null)
first.put(i, 1);
else
first.put(i, first.get(i) + 1);
}

for (Integer i : first.keySet())
if (first.get(i) >= minNum)
fth.add(new ItemSet(i, first.get(i)));

}

private void loop(List<ItemSet> items) {
// TODO Auto-generated method stub
List<ItemSet> copy = new ArrayList<ItemSet>(items);
List<ItemSet> res = new ArrayList<ItemSet>();
int size = items.size();

// 连接
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++)
if (copy.get(i).isMerge(copy.get(j))) {
ItemSet is = new ItemSet(copy.get(i));
is.merge(copy.get(j).item.last());
res.add(is);
}
// 剪枝
pruning(copy, res);

if (res.size() != 0) {
result.add(res);
loop(res);
}
}

private void pruning(List<ItemSet> pre, List<ItemSet> res) {
// TODO Auto-generated method stub
// step 1 k项集的子集属于k-1项集
Iterator<ItemSet> ir = res.iterator();
while (ir.hasNext()) {
// 获取所有k-1项子集
ItemSet now = ir.next();
Map<Integer, List<Integer>> ss = subSet(now);
// 判断是否在pre集中
boolean flag = false;
for (List<Integer> li : ss.values()) {
if (flag)
break;
for (ItemSet pis : pre) {
if (pis.item.containsAll(li)) {
flag = false;
break;
}
flag = true;
}
}
if (flag) {
ir.remove();
continue;
}
// step 2 支持度
int i = 0;
for (Set<Integer> sr : records) {
if (sr.containsAll(now.item))
i++;

now.support = i;
}
if (now.support < minNum) {
ir.remove();
continue;
}
// 产生关联规则
double deno = now.support;
for (Map.Entry<Integer, List<Integer>> me : ss.entrySet()) {
ItemCon ic = new ItemCon(me.getKey(), me.getValue());
int nume = 0;

for (ItemSet f : fth)
if (f.item.contains(me.getKey())) {
nume = f.support;
break;
}
if (deno / nume > minCon) {
now.calcon(ic);
ic.setC1(deno / nume);
}
for (ItemSet pis : pre)
if (pis.item.size() == me.getValue().size()
&& pis.item.containsAll(me.getValue())) {
nume = pis.support;
break;
}
if (deno / nume > minCon)
ic.setC2(deno / nume);
}
}
}

private Map<Integer, List<Integer>> subSet(ItemSet is) {
// TODO Auto-generated method stub
List<Integer> li = new ArrayList<Integer>(is.item);
Map<Integer, List<Integer>> res = new HashMap<Integer, List<Integer>>();
for (int i = 0, j = li.size(); i < j; i++) {
List<Integer> _li = new ArrayList<Integer>(li);
_li.remove(i);
res.put(li.get(i), _li);
}
return res;
}

private void output() throws FileNotFoundException {
if (result.size() == 0) {
System.err.println("无结果集。退出！");
return;
}
FileOutputStream out = new FileOutputStream(output);
PrintStream ps = new PrintStream(out);
for (List<ItemSet> li : result) {
ps.println("=============频繁" + li.get(0).item.size()
+ "项集=============");
for (ItemSet is : li) {
ps.println(is.item + " : " + is.support);
ps.println();
if (is.ics.size() != 0) {
ps.println("******关联规则******");
for (ItemCon ic : is.ics) {
ps.println(ic.i + " ---> " + ic.li + " con: "
+ ic.confidence1);
if (ic.confidence2 > minCon)
ps.println(ic.li + " ---> " + ic.i + " con: "
+ ic.confidence2);
}
ps.println("******************");
ps.println();
}
}
ps.println("=====================================");
}

ps.close();
}

/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
// TODO Auto-generated method stub
long begin = System.currentTimeMillis();
Apriori apriori = new Apriori(0.25, 0.5,
"/home/mazhiyuan/code/mushroom.dat",
"/home/mazhiyuan/code/mout.data");
// apriori.first();//频繁1项集
apriori.first();
apriori.loop(apriori.fth);

apriori.output();
System.out.println("共耗时:" + ((System.currentTimeMillis()) - begin)
+ "ms");
}
}

class ItemSet {
TreeSet<Integer> item;
int support;
List<ItemCon> ics = new ArrayList<ItemCon>(); // 关联规则结果

ItemSet(ItemSet is) {
this.item = new TreeSet<Integer>(is.item);
}

ItemSet() {
item = new TreeSet<Integer>();
}

ItemSet(int i, int v) {
this();
merge(i);
setValue(v);
}

void setValue(int i) {
this.support = i;
}

void merge(int i) {
item.add(i);
}

void calcon(ItemCon ic) {
ics.add(ic);
}

boolean isMerge(ItemSet other) {
if (other == null || other.item.size() != item.size())
return false;
// 前k-1项相同，最后一项不同，满足连接条件
/*
* Iterator<Integer> i = item.headSet(item.last()).iterator();
* Iterator<Integer> o =
* other.item.headSet(other.item.last()).iterator(); while (i.hasNext()
* && o.hasNext()) if (i.next() != o.next()) return false;
*/
Iterator<Integer> i = item.iterator();
Iterator<Integer> o = other.item.iterator();
int n = item.size();
while (i.hasNext() && o.hasNext() && --n > 0)
if (i.next() != o.next())
return false;

return !(item.last() == other.item.last());
}
}

class ItemCon {
Integer i;
List<Integer> li;
double confidence1;
double confidence2;

ItemCon(Integer i, List<Integer> li) {
this.i = i;
this.li = li;
}

void setC1(double c1) {
this.confidence1 = c1;
}

void setC2(double c2) {
this.confidence2 = c2;
}
}

Apriori算法本身的性能就是一大问题，产生太多的候选集，FP-TREE算法规避了这一问题，使得频繁项集的挖掘性能提高了至少一个量级，下一篇重点介绍这个算法。