关联分析-Apriori算法Java实现支持度+置信度（1）

最新推荐文章于 2020-11-19 11:36:48 发布

呼啦圈521

最新推荐文章于 2020-11-19 11:36:48 发布

阅读量3.5k

点赞数 1

分类专栏：数据挖掘文章标签：算法数据

数据挖掘专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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());
 
    }
 
}