Apriori算法的Java实现

最新推荐文章于 2019-02-16 13:51:41 发布

czw

最新推荐文章于 2019-02-16 13:51:41 发布

阅读量425

点赞数

Apriori算法是数据挖掘中十分经典的算法，在使用MapReduce 对其进行之前，先试着用java写一个简单的程序。
1.算法流程及伪代码描述

1.1 从数据文件data.txt 中按照文件的格式读入数据
data.txt:
T100       I1       I2       I5
T200       I2       I4
T300       I2       I3
T400       I1       I2       I4
T500       I1       I3
T600       I2       I3
T700       I1       I3
T800       I1       I2       I3       I5
T900       I1       I2       I3

1.2 将每一个Item 作为一个项集，并统计出它在所有输入数据文件中出现的次数
即得到：

I1 : 6 ,  I2 : 6,  I3 : 6 , I4 ： 2 ， I5 : 2
上面的数据相当于是 C(k-1) 即，候选集 C k-1 :此处仅仅是抽象理解，以为这个是第一次读入数据，
不过要是泛化了思考的话，可以理解为在多次迭代中的第 C k-1 次，
这样的话，后续的步骤就是从 C k-1 -> L k-1 -> C k-> L k

其中C 代表的是候选集的描述，即 candidate ,
而L表示的是频繁项集。

1.3  然后，设定绝对支持度为 3，
这样的话，就可以将 I4 ，I5 它们在整个数据集中出现的次数是 2 要小于最小支持度，
所以在 Ck-1 -> Lk-1 (Lk-1 为第 k-1 次，筛选出来的频繁项集) 的时候，I4 , I5 是被排除的。

得到 Lk-1 :

I1: 6 , I2 : 6 , I3: 6

1.4
这一步骤中要进行的是，从Lk-1 -> Ck ，也就是对Lk-1 中的数据进行连接
然后连接后的集合就是第K次的候选项集了
但是这里的连接需要满足下面的条件才可以的。

比如说，将位于集合 Lk-1 中的两个集合  l1 , l2 进行连接的话，
l1 ,l2 必须满足下面的条件：
1.  Length(l1 ) = length (l2)
2. differentElementNumber( l1, l2 ) = 1
3. l1 + x => l3 (对这个操作的解释是：讲 l2 中唯一一个不同于 l1 的元素归并到 l1 中之后得到的新的集合 l3)
任意l3 的子集都必须属于 Lk-1 对应的集合中

这个地方举个例子说明一下：
就是假定 Lk-1 中的记录如下：
{I1, I2} ->l1
{I1,I3}->l2
{I1,I4}->l3
{I2,I3}->l4

l1 and l2 => l5:{l1,l2,l3}
l5 的所有子集集合为 {{l1}, {l2}, {l3},{l1,l2},{l2,l3}，{l2,l3} } 它们都是Lk-1 中的子集
当然 l5 中还有子集 {l1,l2,l3}这种情况我们不要考虑。

但是 l2 and l3 => l6:{ l1,l3,l4}
l6  中的所有子集的集合为（全集）{{l1},{l2},{l3}, {l1,l3}, {l1,l4} ,{l3,l4} }
l6 就不能够将其归纳入到 Ck 中，因为{l3,l4} 在 Lk-1 中是不存在的。

在这个地方用到的是先验规则，就是说: 出现在Lk-1 中的所有 itemset 都是 k-1次，
筛选出来的频繁相机，如果在Ck 中的 itemset 中的子集不在这个 k-1次的频繁itemset 中的话，
那么他一定不是频繁itemset ,因为子集不是 frequent set 的话，它的任意 super set 都不可能是
frequent set . 即便在Lk-1 到 Ck 这一步该itemset 会被保留下来，但是，
Ck 到 Lk 这一步，也会和原始的数据集进行比较由于支持度小于最小支持度而被删除，
提前一步删除的话，会降低
1. 生成过多的候选集合，
2，减小与原始数据连接而浪费的时间

这样的话，我们就得到了 Ck，然后再根据Ck中的项集在最初数据源中
出现的次数进行统计，统计出来结果之后，对比最小支持度进行记录的赛选就得到了
Lk,
按照上面的步骤一次迭代下去，直到求出的满足支持度的集合数目为0 程序停止。

根据老师共享的 <数据挖掘导论> 这本书中的介绍，伪代码描述如下

record = getDataSet ( data.txt ) ;

record\'s content :
I1       I2       I5
I2       I4
I2       I3
I1       I2       I4
I1       I3
I2       I3
I1       I3
I1       I2       I3       I5
I1       I2       I3

cItemset = getFirstCandidate () ; ----> get Ck-1
lItemset = getSupportedItemset( cItemset ) ; -----> get Lk-1 from Ck-1

while ( cItemset not null  )
{
ckItemset = getNextCandidate ( lItemset) ; -----> get Ck from Lk-1
lkItemset = getSupportedItemset ( ckItemset) ; -----> get Lk from Ck

cItemset = ckItemset ;
lItemset = lkItemset ; //for next loop
}

2.Apriori类中的各个模块方法描述

我将 Ck-1 Ck 也就是相应的候选集使用数据结构
List<List<String>> 来对其进行表示，
这样的话对于一个 {I1， I2 ,I5} {I1, I3} 就可以存储成： List<<<I1>, <I2> ,<I5>>, <<I1>,<I3>>的数据格式了。

将频繁itemset 使用 Map<List<String>, Integer> 来对其进行表示，
这样， itemset {I1, I2 , I5 } 在record 出现的次数为 4 次的话，就可以表示成：

<<<I1>,<I2>,<I5>> , 4> 这样的数据类型了。

List<List<String>> : getFirstCandidate () : 用于直接从record中读取 1项集对应出现的次数以及项集对应的名字

Map<List<String>, Integer> :ｇetSupportedItemset( List<List<String>> cItemset) :
这个方法是从 Ck-1 中获取支持度满足最小支持度的集合，

List<List<String>> : getNextCandidate( Map<List<String>,Integer>）
这个方法，是从Lk-1 中获取 Ck 的方法。

package myApriori;
//Aprioiri
import java.util.Iterator;
import java.util.List ;
import java.util.Map ;
import java.util.ArrayList ;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class myApriori {
static private boolean endTag = false ;
static private List<List<String>> cItemset ;
static private List<List<String>> ckItemset ;
static private Map<List<String>, Integer> lItemset ;
static private Map<List<String>,Integer> lkItemset ;
static List<List<String>> record = new ArrayList<List<String>> () ;
final static double MIN_SUPPORT = 2 ;
static Map<List<String>, Double > confItemset = new HashMap<List<String>,Double >() ;
public static List<List<String>> getDataSet ()
{
return FileReader.getDatabase();
}
public static List<List<String>> getFirstCandidate ()
{
List<List<String>> cItemset = new ArrayList<List<String>> () ;
List<String> tempLine = new ArrayList<String>() ;
for( int i = 0 ; i < record.size() ; i++ )
{
for (int j = 0 ; j < record.get(i).size(); j++)
{
if(tempLine.contains(record.get(i).get(j))) ;
else
{
tempLine.add(record.get(i).get(j)) ;
}
}
}
for ( int i = 0 ; i < tempLine.size() ;i++)
{
List<String> str = new ArrayList<String>() ;
str.add(tempLine.get(i));
cItemset.add(str) ;
}
return cItemset ;
}
static Map<List<String>,Integer> getSupportedItemset( List<List<String>> cItemset )
{
Map<List<String>,Integer> supportedItemset = new HashMap<List<String>,Integer> () ;
boolean end = true ;
for( int i = 0 ; i < cItemset.size(); i++ )
{
int count = countFrequent ( cItemset.get(i)) ;
if( count >= MIN_SUPPORT )
{
supportedItemset.put(cItemset.get(i), count) ;
end = false ;
}
}
endTag = end ;
//System.out.println(\"value of the endTag here !!!\"+endTag);
return supportedItemset ;
}
static int countFrequent ( List<String> list)
{
int count = 0 ;
for ( int i = 1 ; i < record.size() ; i++ )
{
boolean curRecordLineNotHave = false ;
for ( int k = 0 ; k < list.size(); k++)
{
if(!record.get(i).contains(list.get(k)))
{
curRecordLineNotHave = true ;
break ;
}
}
if(curRecordLineNotHave == false )
{
count++ ;
}
}
return count ;
}
/**
* method following is the getNextCandidata usually can be known as
* get Ck from Lk-1
* */
private static List<List<String>> getNextCandidate ( Map<List<String>,Integer> lItemset )
{
List<List<String>> nextItemset = new ArrayList<List<String>>() ;
List<List<String>> preItemset = getLItemset(lItemset ) ;
int count = 0 ;
for ( int i = 0 ; i < preItemset.size() ; i++ )
{
List<String> tempLine = new ArrayList<String> () ;
tempLine.addAll(preItemset.get(i)) ;
for( int j = i+1 ; j < preItemset.size(); j++)
{
if( preItemset.get(i).size() == preItemset.get(j).size())
{
if( 1 == differElemNum(preItemset.get(i),preItemset.get(j)))
{
int index = getDifferIndex ( preItemset.get(i), preItemset.get(j)) ;
tempLine.add(preItemset.get(j).get(index)) ;
if( isSubSets ( tempLine, preItemset))
{
List<String> aLine = new ArrayList() ;
for(int m = 0 ; m < tempLine.size() ;m++)
{
aLine.add(tempLine.get(m));
}
if( nextItemSetNotHave( aLine, nextItemset ))
nextItemset.add(aLine) ;
}
}
}//outer if
tempLine.remove(tempLine.size()-1 ) ;
}//for j
}
return nextItemset ;
}
private static boolean nextItemSetNotHave( List<String> aLine , List<List<String>> nextItemset )
{
boolean notHave = true ;
for( int i = 0 ; i < nextItemset.size(); i++ )
{
if(aLine.equals(nextItemset.get(i)))
{
notHave = false ;
}
}
return notHave ;
}
private static int getDifferIndex ( List<String> list1 , List<String> list2)
{
int index = -1 ;
for ( int i = 0 ; i < list1.size() ; i++ )
{
for( int j = 0 ; j < list1.size(); j++ )
{
if ( !list1.get(i).equals(list2.get(j)))
{
index = j ;
}
}
if ( index != -1 )
break ;
}
return index ;
}
private static int differElemNum ( List<String> list1, List<String>list2 )
{
int count = 0 ;
boolean flag ;
for( int i = 0 ; i < list1.size() ; i++ )
{
flag = true ;
for(int j = 0 ; j < list1.size(); j++ )
{
if(list1.get(i).equals(list2.get(j)))
{
flag = false ;
break;
}
}
if( flag == true )
{
count++ ;
}
}
return count ;
}
/**
* method following is used to justice whether
* @param tempList all subsets except itself is the subsets of
* @param lItemset
*
* @return boolean true : all subsets of tempList are all in
* lItemset\'s set
* */
private static boolean isSubSets ( List<String> tempList , List<List<String>> lItemset)
{
boolean flag = false ;
for ( int i = 0 ; i < tempList.size() ; i++ )
{
List<String> testLine = new ArrayList() ;
for (int j = 0 ; j < tempList.size(); j++ )
{
if (i!= j )
{
testLine.add(tempList.get(j)) ;
}
}
for ( int k = 0 ; k < lItemset.size() ; k++ )
{
if ( testLine.equals(lItemset.get(k)))
{
flag = true ;
break ;
}
}
if ( flag == false )
{
return false ;
}
}
return flag ; //return true ;
}
private static List<List<String>> getLItemset ( Map<List<String>, Integer> lItemset )
{
List<List<String>> itemset = new ArrayList<List<String>> () ;
Iterator<Map.Entry<List<String>, Integer>> iterator = lItemset.entrySet().iterator();
Entry<List<String>, Integer> entry ;
while ( iterator.hasNext() )
{
entry = iterator.next();
List<String> key = entry.getKey() ;
itemset.add(key) ;
}
return itemset ;
}
public static void main ( String [] args ) throws Exception
{
record =getDataSet() ;
cItemset = getFirstCandidate() ;
lItemset = getSupportedItemset( cItemset ) ;
printfLKitemset ( lItemset) ;
while ( endTag != true )
{
ckItemset = getNextCandidate(lItemset ) ;
lkItemset = getSupportedItemset ( ckItemset ) ;
if(lkItemset.size() != 0 )
printfLKitemset ( lkItemset) ;
cItemset = ckItemset ;
lItemset = lkItemset ;
}
System.out.println(\"finish \") ;
}
private static void printfLKitemset ( Map<List<String> , Integer> lkItemset )
{
Iterator<Entry<List<String>,Integer>> iterator = lkItemset.entrySet().iterator();
Entry<List<String>,Integer> entry ;
while ( iterator.hasNext() )
{
entry = iterator.next() ;
List<String> key = entry.getKey() ;
Integer value = entry.getValue() ;
System.out.println(\"the key : \");
for ( int i = 0 ; i < key.size() ; i++ )
{
System.out.print(key.get(i));
System.out.print(\" \");
}
System.out.println(\"the value : \"+ value.intValue());
}
}
}

复制代码

//reader.java

package myApriori;
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileInputStream ;
import java.io.InputStreamReader;
import java.util.ArrayList ;
import java.util.List ;
public class FileReader
{
public static List<List<String>> getDatabase()
{
List<List<String>> db = new ArrayList<List<String>>() ;
try
{
File file = new File(\"data.txt\") ;
if ( file.isFile() && file.exists())
{
InputStreamReader read = new InputStreamReader
(
new FileInputStream(file)
) ;
BufferedReader reader = new BufferedReader( read ) ;
String line = null ;
while ( (line = reader.readLine())!= null )
{
String [] strToknizer = line.split(\" \") ;
List<String> tmpLine = new ArrayList<String>() ;
for ( int i = 1 ; i < strToknizer.length ; i++ )
{
tmpLine.add(strToknizer[i]) ;
}
db.add(tmpLine) ;
}
reader.close();
}
else
{
System.out.println(\"fail to find target file !\");
}
}
catch (Exception e)
{
System.out.println(\"fail in reading file\'s content \");
e.printStackTrace();
}
return db ;
}
}

复制代码

myApriori.zip (10.68 KB)

3.出处：这个算法的源代码是来自： http://www.cnblogs.com/fengfenggirl/p/associate_apriori.html#2752667
LZ在拜读他的代码之后，对其中的一些地方进行了修改得出的这个算法的代码，
通过阅读他的 github 上面的代码，学习到了很多东西，博主的很多关于数据挖掘的算法文章都是相当好的，极力推荐一下。
本算法，不是十分的严谨与完善，没有涉及到关于置信度那个地方的知识，
也希望起到一个抛砖引玉的作用，
有同学实现了的话，可以将代码贴上一起分享一下。