数据挖掘经典算法——先验算法

算法描述

　　先验算法是实现频繁项挖掘的一种经典算法，利用关联式规则不断扩展频繁项子集以获得全部的频繁项集合。解释一下关联式规则，所谓关联式是指在大量的数据中找出的项与项之间的关系。例如消费者购买了产品A，一般都会购买产品B，这就是一条关联式。

　　先验算法被设计用来处理包含事务的数据库，这里的每一个事务都被当成是一组项集，给定一个阈值C，我们需要找出至少出现C次的事务子集（即子项）。这边这个C值就是最小支持度，规定了一个项集出现多少次才能被认为是一个频繁项。

　　先验算法的核心思想基于以下一个事实：一个项集是频繁项集，其所有子集一定是频繁项集；一个项集不是频繁项，其超集一定不是频繁项集。那么我们在寻找事务中的最大频繁项的过程中，只需要扩展是频繁项的子集，这就大大地缩减了搜索空间。下面是该算法的伪代码实现：

 

　　其中T代表的是事务集合，表示最小支持度，L_i对应的是第i次迭代得到的频繁项集，C_i表示对于第i次迭代的候选项集。伪代码的第一行遍历了事务中的所有项，统计每一项出现的频数，保留所有出现次数高于最小支持度的项。

算法的优缺点

优点：

• 　　算法简单，易于理解，对数据的要求度低；

缺点：

• 　　在选取较小的支持度选取时，可能带来较多的候选集，大量的集合操作会导致算法效率低下；
• 　　每一次迭代都需要重新扫描数据库，I/O开销比较大；

Apriori算法的Java实现

　　

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 这是一个简单的先验算法的实现，包含了如下假设：
 * 1.事务对应一个TID和一个项集合，每个项对应一个int类型的数值,保证同一个事务内部的项唯一
 * 2.算法在实现方式上还存在很多可以优化剪枝的部分，这里省略了优化，是结构更加清晰
 * 3.这只是一个样例程序
 * @author LuZhou
 * @email 448287076@qq.com
 */
public class Aprior {
    
    
    public static class TransactionItem {
        
        private Integer itemValue;
        
        public TransactionItem( int i ){
            itemValue = i;
        }
        
        @Override
        public boolean equals(Object obj) {
            TransactionItem it = (TransactionItem) obj;
            return this.itemValue == it.itemValue;
        }
        
        
        @Override
        public String toString() {
            return itemValue.toString();
        }
        
        @Override
        public int hashCode() {
            return itemValue % 31; 
        }
    }
    
    
    public static class ItemCollection{
        private Set<TransactionItem> items = new HashSet<Aprior.TransactionItem>();
        
        public ItemCollection(){
        }
        
        public ItemCollection(int[] items){
            for (int i = 0; i < items.length; i++) {
                this.add(new TransactionItem(items[i]));
            }
        }
        
        public boolean itemContains(Set<TransactionItem> sub){
            return items.containsAll(sub);
        }
        
        @Override
        public boolean equals(Object obj) {
            ItemCollection ic = (ItemCollection) obj;
            return ic.items.containsAll(items) && 
                    items.containsAll(ic.items);
        }
        
        @Override
        public int hashCode() {
            int v = 0;
            for (TransactionItem ts : items) {
                v =  ( v + ts.hashCode() ) % 31;
            }
            return v;
        }
        
        public boolean contains(ItemCollection sub){
            return items.containsAll(sub.items);
        }
        
        public boolean containItem(TransactionItem item){
            return items.contains(item);
        }
        
        public Set<TransactionItem> getItems(){
            return items;
        }
        
        public void add(TransactionItem item){
            items.add(item);
        }
        
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("{");
            for (TransactionItem item : getItems()) {
                sb.append( item.toString() );
                sb.append(",");
            }
            sb.append("}");
            return sb.toString();
        }

    }
    
    public static class Transaction{
        private int id;
        private ItemCollection ic;
        
        public Transaction(int id , ItemCollection itemCollection){
            this.id = id;
            this.ic  = itemCollection;
        }
        
        public boolean itemContains(ItemCollection sub){
            return ic.contains(sub);
        }
        
        public Set<TransactionItem> getItems(){
            return ic.getItems();
        }
        
    }
    
    private Set<TransactionItem> restItems = new HashSet<Aprior.TransactionItem>();
    private List<Transaction> transactions = new ArrayList<Aprior.Transaction>();
    
    //统计一项的出现次数
    private int itemsFrequency( ItemCollection sub ){
        int frequency = 0 ;
        
        for (Transaction t : transactions) {
            if(t.itemContains(sub)){
                frequency ++;
            }        
        }
        
        return frequency;
    }
    
    //确定扩展项是否为频繁项
    private Set< ItemCollection > filterWithThreadshold(
            Set< ItemCollection > items, int threadshold ){
        
        Set< ItemCollection > result = new HashSet<ItemCollection>();
        for (ItemCollection subItems : items) {
            if( threadshold <= itemsFrequency(subItems))
                result.add(subItems);
        }
        
        return result;
    }
    
    //根据现有的子项集获取所有的可能扩展
    private Set< ItemCollection > extendItems( Set< ItemCollection > current){
        Set< ItemCollection > extend = new HashSet<Aprior.ItemCollection>();
        
        //找出剩余的项集
        restItems.clear();
        for (ItemCollection ic : current) {
            for (TransactionItem item : ic.getItems()) {
                restItems.add(item);
            }
        }
        
        //需要找到当前频繁项子集
        for (ItemCollection itemCollection : current) {
            for (TransactionItem rest : restItems) {
                if( ! itemCollection.containItem(rest) ){
                    //找到一个b 不属于 频繁项集 A 但是存在于剩余项中 用其构造其余的子项
                    extend.add( buildCollection( itemCollection, rest ));
                }
            }
            
        }
        
        return extend;
    }
    
    //result = ic.items & item
    private ItemCollection buildCollection(ItemCollection ic,TransactionItem item){
        ItemCollection ex = new ItemCollection();
        
        Iterator<TransactionItem> it = ic.getItems().iterator();
        while(it.hasNext()){
            ex.add( it.next() );
        }
        
        ex.add(item);
        
        return ex;
    }
    
    
    //初始化剩余项
    private Set<ItemCollection> initCollection( int threadshold ){
        
        Map<TransactionItem , Integer> tc = new HashMap<Aprior.TransactionItem, Integer>();
        
        for ( Transaction t : transactions ) {
            
            for ( TransactionItem item : t.getItems() ) {
                
                if( !restItems.contains(item) ){
                    restItems.add(item);
                    tc.put(item, 1);
                }else
                    tc.put( item, 1 + tc.get(item) );
                
            }
        }
        
        
        Set<ItemCollection> collection = new HashSet<Aprior.ItemCollection>();
        
        Iterator< TransactionItem > it = tc.keySet().iterator();
        while( it.hasNext() ){
            TransactionItem item = it.next();
            if( threadshold <= tc.get( item ) ){
                ItemCollection ic = new ItemCollection();
                ic.add( item );
                collection.add( ic );
            }
        }
            
        return collection;
    }
    
    
    /**
     * 找出频繁项
     * @param threadshold 最小支持度
     * @return
     */
    public Set< ItemCollection > frequentItem( int threadshold ){
        
        Set< ItemCollection > current = initCollection( threadshold );
        Set< ItemCollection > result = new HashSet<Aprior.ItemCollection>();
        
        while( current.size() > 0 ){
            
            result.addAll( current );
            
            Set<ItemCollection> extendList = extendItems( current );
            
            current = filterWithThreadshold( extendList, threadshold );
            
        }
        
        
        return result;
    }
    
    public void addTransaction(Transaction ts){
        transactions.add(ts);
    }
    
    
    public static void main(String args[]){
        
        final int MINSUPPROT = 2;
        Aprior aprior = new Aprior();
        /**
         * 数据集包括
         * T1 {1,3,4}
         * T2 {2,3,5}
         * T3 {1,2,3,5}
         * T4 {2,5}
         * 最小支持度为2，请最大频繁项
         */
        aprior.addTransaction(new Transaction(1, new ItemCollection(new int[]{1,3,4})));
        aprior.addTransaction(new Transaction(2, new ItemCollection(new int[]{2,3,5})));
        aprior.addTransaction(new Transaction(3, new ItemCollection(new int[]{1,2,3,5})));
        aprior.addTransaction(new Transaction(4, new ItemCollection(new int[]{2,5})));
        
        System.out.println(aprior.frequentItem( MINSUPPROT ));
        
    }
    

}

参考资料

http://en.wikipedia.org/wiki/Apriori_algorithm

http://rakesh.agrawal-family.com/papers/vldb94apriori.pdf

http://www.cnblogs.com/gaizai/archive/2010/03/31/1701573.html