JavaApriori算法

Posted 2023-01-25 yongh701

Apriori算法是一种最基本的根据事务记录求解关联的算法。在1994年已经由Agrawal和Srikant提出。也就是那个成功在一大堆顾客的购买记录中，求解出买完啤酒还要买尿布的结论的著名数据挖掘算法。现在关联算法已经发展得多种多样，无数学术论文的产生，让关联求解更加多样化，但都是依据这个Apriori作进一步发展。

利用Java完成Apriori算法其实很简单，在贴代码之前，首先讲解Apriori算法的基本思想。假如有如下的事务记录：

也就是说，现在有4个人，一个买了I1 I2 I3 I4商品，或者到了我们店里面享受了I1 I2 I3 I4服务，或者在某一时间段，做了I1 I2 I3 I4之类的，然后又有一个人，买了I1 I2 I3商品……以此类推，我们现在要根据所有用户的购买/服务/事件记录，也就是所谓的事务数据库D，求解某个人，做完某事之后很可能做什么？

Apriori算法就是做这件事，其根据一个事件序列在整个事务数据库D出现的概率多少，判断大家是否很可能同时会做这个事件序列。然后再从这个事件序列的子集当中，推断之间的关联性，具体如下：

一、对项目集C和候选集L进行初始化

初始化过程是求解各个独立事件的支持度support。所谓的支持度support就是 该独立事件在一条事件数出现的次数 除以 事务数据库D事务的总数。

比如I1事件，他在第1、2、4条都出现了，共3次，而D中的事务总数共4条，那么，其支持度则为3/4，75%。所谓的“出现”也就是，I1是否为该事件序列的子集。

初始化后，项目集C如下：

这个C可以在Java中，用HashMap<ArrayList<String>, Double> C表示，这里的key是ArrayList<String>而不是String，是因为后续的事件还要进一步扩大，变成I1 I2，这是后话了。

之后我们要设计一个最小支持度min_support，这里定为0.5，用于淘汰在事务数据中出现过少的事件，比如I5。因为这事做得人少，肯定代表大家是不怎么愿意做他，也不会成为关联事件序列的候选事件了。

在项目集C淘汰支持度过少的事件之后，形成候选集L，如下：

这也是所谓的“剪枝步”

二、迭代求最终的项目集C和候选集L

上述的C与L并不足以支持我们得到最后的结论，我们需要进一步细化这个C与L。

此乃一个迭代的步骤，分为连接步和剪枝步，剪枝步是C形成一个新的L的过程，同初始化的剪枝步。需要详细说明的是连接步，这是根据L形成一个新的C的过程，具体如下：

我们需要根据L中存在的项，两两求并集，比如上述的L有4项，求出来的并集肯定有个，但对于求出来的并集，我们必须判断其所有的非空真子集，是否存在于L当中，不存在则要淘汰这个并集，比如上述求出来的一项[I1,I2]的非空真子集[I1]、[I2]都在L能找到，这个[I1,I2]才能压入新的C当中，成为新C的一项。

同时计算出[I1,I2]在D中出现的个数与D的事务之比，也就是[I1,I2]支持度。纪录到C当中。

之后再经历一次剪枝步，剔除支持度少于最小支持度的项，由C形成L。

如此循环，一旦经历完剪枝步之后L为空，上一循环的L则为我们需要的L，具体如下：

三、根据最终的候选集L得出最后的结论

在最终的候选集L中，对里面所有事件进行分析，对其所有互补子集对进行关联分析。比如上述I3,I1,I2的一个互补子集对，[I1,I2],[I3]。我们分别求出其支持度，[I1,I2]的支持度为0.75，[I3]为0.75。这个支持度肯定能从上面的迭代过程的L中得知。

之后如果要判断诸如[I1,I2]->[I3]是否是关联事件，则拿前项的支持度除以后项的支持度，这就是这个事件的置信度。比如[I1,I2]->[I3]的置信度就是1。如果这个置信度大于我们设定的最小置信度，那么它就是一个关联事件。

置信度的意义，如同条件概率，说明前事件在后事件发生时的概率。因为支持度就基本等于该事件发生的概率。Apriori算法的意义就是将一些小概率剔除，逐步淘汰，得到最终的大概率事件。

这里我们设置最小置信度为0.7，那么就能得到一系列关联事件，如下图所示：

这就说明，用户在做完I1的情况下很可能会I2与I3同时做，或者是同时做完I1与I2情况下，会去做I3。

因此，Java的代码如下编写：

import java.io.*;
import java.util.*;

public class Apriori 

	static String filePath = "d:\\\\1.txt";
	static ArrayList<ArrayList<String>> D = new ArrayList<ArrayList<String>>();// 事务数据库
	static HashMap<ArrayList<String>, Double> C = new HashMap<ArrayList<String>, Double>();// 项目集
	static HashMap<ArrayList<String>, Double> L = new HashMap<ArrayList<String>, Double>();// 候选集
	static double min_support = 0.5;// 最小支持度
	static double min_confident = 0.7;// 最小置信度

	// 用于存取候选集每次计算结果，最后计算关联规则，就不用再次遍历事务数据库，这么麻烦了。
	static HashMap<ArrayList<String>, Double> L_ALL = new HashMap<ArrayList<String>, Double>();

	/**
	 * 将txt中的二维表读入T中
	 * 
	 * @param filePath
	 *            TXT的文件路径，注意文件路径分隔符必须写成\\\\
	 * @return ArrayList<ArrayList<String>>，存放每行元素List的List
	 */
	public static ArrayList<ArrayList<String>> readTable(String filePath) 
		ArrayList<ArrayList<String>> T = new ArrayList<ArrayList<String>>();
		Scanner scanner;
		try 
			scanner = new Scanner(new File(filePath));// 指定读入文件
			while (scanner.hasNext()) 
				T.add(new ArrayList<String>(Arrays.asList(scanner.nextLine()
						.split(" "))));
			
			scanner.close();// 必须关闭这个流，否则有警告。
		 catch (FileNotFoundException e) 
			System.out.println("文件不存在！请检查路径。");
		
		return T;
	

	// 剪枝步，删去C少于最小支持度的元素，形成L
	public static void pruning(HashMap<ArrayList<String>, Double> C,
			HashMap<ArrayList<String>, Double> L) 
		L.clear();
		// 根据项目集生成候选集
		L.putAll(C);
		// 删除少于最小支持度的元素
		ArrayList<ArrayList<String>> delete_key = new ArrayList<ArrayList<String>>();
		for (ArrayList<String> key : L.keySet()) 
			if (L.get(key) < min_support) 
				delete_key.add(key);
			
		
		for (int i = 0; i < delete_key.size(); i++) 
			L.remove(delete_key.get(i));
		
	

	/**
	 * 初始化事务数据库、项目集、候选集
	 */
	public static void init() 
		D = readTable(filePath);

		// 扫描事务数据库。生成项目集，支持度=改元素在事务数据库出现的次数/事务数据库的事务数
		for (int i = 0; i < D.size(); i++) 
			for (int j = 0; j < D.get(i).size(); j++) 
				String[] e =  D.get(i).get(j) ;
				ArrayList<String> item = new ArrayList<String>(Arrays.asList(e));
				if (!C.containsKey(item)) 
					C.put(item, 1.0 / D.size());
				 else 
					C.put(item, C.get(item) + 1.0 / D.size());
				
			
		

		pruning(C, L);// 剪枝

		L_ALL.putAll(L);

	

	// 两个整数集求并集
	public static ArrayList<String> arrayListUnion(
			ArrayList<String> arraylist1, ArrayList<String> arraylist2) 
		ArrayList<String> arraylist = new ArrayList<String>();
		arraylist.addAll(arraylist1);
		arraylist.addAll(arraylist2);
		arraylist = new ArrayList<String>(new HashSet<String>(arraylist));
		return arraylist;
	

	/**
	 * 迭代求出最终的候选频繁集
	 * 
	 * @param C
	 *            完成初始化的项目集
	 * @param L
	 *            完成初始化的候选集
	 * @return 最终的候选频繁集
	 */
	public static HashMap<ArrayList<String>, Double> iteration(
			HashMap<ArrayList<String>, Double> C,
			HashMap<ArrayList<String>, Double> L) 
		HashMap<ArrayList<String>, Double> L_temp = new HashMap<ArrayList<String>, Double>();// 用于判断是否结束剪枝的临时变量

		int t = 1;// 迭代次数
		while (L.size() > 0) // 一旦被剪枝后剪干净，剪枝之前则是最终要求的结果。
			t++;
			L_temp.clear();
			L_temp.putAll(L);
			// 一、连接步
			C.clear();
			// 1.将L中的项以一定的规则两两匹配
			ArrayList<ArrayList<String>> L_key = new ArrayList<ArrayList<String>>(
					L.keySet());
			for (int i = 0; i < L_key.size(); i++) 
				for (int j = i + 1; j < L_key.size(); j++) 
					ArrayList<String> C_item = new ArrayList<String>();
					C_item = new ArrayList<String>(arrayListUnion(L_key.get(i),
							L_key.get(j)));
					if (C_item.size() == t) 
						C.put(C_item, 0.0);// 频繁项集的所有非空子集都必须是频繁的
					
				
			
			// 2.通过扫描D，计算此项的支持度
			for (ArrayList<String> key : C.keySet()) 
				for (int i = 0; i < D.size(); i++) 
					if (D.get(i).containsAll(key)) 
						C.put(key, C.get(key) + 1.0 / D.size());
					
				
			
			// System.out.println(C);
			// 二、剪枝步
			pruning(C, L);
			// System.out.println(L);
			// System.out.println("===");

			L_ALL.putAll(L);
		

		return L_temp;
	

	// 求一个集合的所有子集
	public static ArrayList<ArrayList<String>> getSubset(ArrayList<String> L) 
		if (L.size() > 0) 
			ArrayList<ArrayList<String>> result = new ArrayList<ArrayList<String>>();
			for (int i = 0; i < Math.pow(2, L.size()); i++) // 集合子集个数=2的该集合长度的乘方
				ArrayList<String> subSet = new ArrayList<String>();
				int index = i;// 索引从0一直到2的集合长度的乘方-1
				for (int j = 0; j < L.size(); j++) 
					// 通过逐一位移，判断索引那一位是1，如果是，再添加此项
					if ((index & 1) == 1) // 位与运算，判断最后一位是否为1
						subSet.add(L.get(j));
					
					index >>= 1;// 索引右移一位
				
				result.add(subSet); // 把子集存储起来
			
			return result;
		 else 
			return null;
		
	

	// 判断两个集合相交是否为空
	public static boolean intersectionIsNull(ArrayList<String> l1,
			ArrayList<String> l2) 
		Set<String> s1 = new HashSet<String>(l1);
		Set<String> s2 = new HashSet<String>(l2);

		s1.retainAll(s2);
		if (s1.size() > 0) 
			return false;
		 else 
			return true;
		
	

	/**
	 * 根据最终的关联集，根据公式计算出各个关联事件
	 */
	public static void connection() 
		for (ArrayList<String> key : L.keySet()) // 对最终的关联集各个事件进行判断
			ArrayList<ArrayList<String>> key_allSubset = getSubset(key);
			// System.out.println(key_allSubset);
			for (int i = 0; i < key_allSubset.size(); i++) 
				ArrayList<String> item_pre = key_allSubset.get(i);
				if (0 < item_pre.size() && item_pre.size() < key.size()) // 求其非空真子集
					// 各个非空互补真子集之间形成关联事件
					double item_pre_support = L_ALL.get(item_pre);
					for (int j = 0; j < key_allSubset.size(); j++) 
						ArrayList<String> item_post = key_allSubset.get(j);
						if (0 < item_post.size()
								&& item_post.size() < key.size()
								&& arrayListUnion(item_pre, item_post).equals(
										key)
								&& intersectionIsNull(item_pre, item_post)) 
							double item_post_support = L_ALL.get(item_post);// 互补真子集的支持度比则是事件的置信度
							double confident = item_pre_support
									/ item_post_support; // 事件的置信度
							if (confident > min_confident) // 如果事件的置信度大于最小置信度
								System.out
										.println(item_pre + "==>" + item_post);// 则是一个关联事件
								// System.out.println(item_pre_support + "==>" +
								// item_post_support);
							
						

					
				
			
		
	

	public static void main(String[] args) 

		init();
		/*
		 * System.out.println(D); System.out.println(C); System.out.println(L);
		 * System.out.println("===");
		 */
		L = iteration(C, L);
		/*
		 * System.out.println(L); System.out.println(L_ALL);
		 * System.out.println("===");
		 */
		connection();

	

其中，读入的txt用到《【Java】一行代码读完记事本中的二维表》（ 点击打开链接）中所提到的东西。