Apriori算法--关联规则挖掘

我的数据挖掘算法代码：https://github.com/linyiqun/DataMiningAlgorithm

介绍

Apriori算法是一个经典的数据挖掘算法，Apriori的单词的意思是"先验的"，说明这个算法是具有先验性质的，就是说要通过上一次的结果推导出下一次的结果，这个如何体现将会在下面的分析中会慢慢的体现出来。Apriori算法的用处是挖掘频繁项集的，频繁项集粗俗的理解就是找出经常出现的组合，然后根据这些组合最终推出我们的关联规则。

Apriori算法原理

Apriori算法是一种逐层搜索的迭代式算法，其中k项集用于挖掘(k+1)项集，这是依靠他的先验性质的：

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

通过这个性质可以对候选集进行剪枝。用k项集如何生成(k+1)项集呢，这个是算法里面最难也是最核心的部分。

通过2个步骤

1、连接步，将频繁项自己与自己进行连接运算。

2、剪枝步，去除候选集项中的不符合要求的候选项，不符合要求指的是这个候选项的子集并非都是频繁项，要遵守上文提到的先验性质。

3、通过1,2步骤还不够，在后面还要根据支持度计数筛选掉不满足最小支持度数的候选集。

算法实例

首先是测试数据：

交易ID	商品ID列表
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

算法的步骤图：

最后我们可以看到频繁3项集的结果为{1, 2, 3}和{1， 2， 5},然后我们去后者{1， 2， 5}作为频繁项集来生产他的关联规则，但是在这之前得先知道一些概念，怎么样才能够成为一条关联规则，关有频繁项集还是不够的。

关联规则

confidence(置信度)

confidence的中文意思为自信的，在这里其实表示的是一种条件概率，当在A条件下，B发生的概率就可以表示为confidence(A->B)=p(B|A)，意为在A的情况下，推出B的概率。那么关联规则与有什么关系呢，请继续往下看。

最小置信度阈值

按照字面上的意思就是限制置信度值的一个限制条件嘛，这个很好理解。

强规则

强规则就是指的是置信度满足最小置信度(就是>=最小置信度)的推断就是一个强规则，也就是文中所说的关联规则了。这个在下面的程序中会有所体现。

算法的代码实现

我自己写的算法实现可能会让你有点晦涩难懂，不过重在理解算法的整个思路即可，尤其是连接步和剪枝步是最难点所在，可能还存在bug。

输入数据：

[java]view plaincopyprint?

1. T1125
2. T224
3. T323
4. T4124
5. T513
6. T623
7. T713
8. T81235
9. T9123

频繁项类：

[java]view plaincopyprint?

1. /**
2. *频繁项集
3. *
4. *@authorlyq
5. *
6. */
7. publicclassFrequentItemimplementsComparable<FrequentItem>{
8. //频繁项集的集合ID
9. privateString[]idArray;
10. //频繁项集的支持度计数
11. privateintcount;
12. //频繁项集的长度，1项集或是2项集，亦或是3项集
13. privateintlength;
15. publicFrequentItem(String[]idArray,intcount){
16. this.idArray=idArray;
17. this.count=count;
18. length=idArray.length;
19. }
21. publicString[]getIdArray(){
22. returnidArray;
23. }
25. publicvoidsetIdArray(String[]idArray){
26. this.idArray=idArray;
27. }
29. publicintgetCount(){
30. returncount;
31. }
33. publicvoidsetCount(intcount){
34. this.count=count;
35. }
37. publicintgetLength(){
38. returnlength;
39. }
41. publicvoidsetLength(intlength){
42. this.length=length;
43. }
45. @Override
46. publicintcompareTo(FrequentItemo){
47. //TODOAuto-generatedmethodstub
48. returnthis.getIdArray()[0].compareTo(o.getIdArray()[0]);
49. }
51. }

主程序类：

[java]view plaincopyprint?

1. packageDataMining_Apriori;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.IOException;
7. importjava.text.MessageFormat;
8. importjava.util.ArrayList;
9. importjava.util.Collections;
10. importjava.util.HashMap;
11. importjava.util.Map;
13. /**
14. *apriori算法工具类
15. *
16. *@authorlyq
17. *
18. */
19. publicclassAprioriTool{
20. //最小支持度计数
21. privateintminSupportCount;
22. //测试数据文件地址
23. privateStringfilePath;
24. //每个事务中的商品ID
25. privateArrayList<String[]>totalGoodsIDs;
26. //过程中计算出来的所有频繁项集列表
27. privateArrayList<FrequentItem>resultItem;
28. //过程中计算出来频繁项集的ID集合
29. privateArrayList<String[]>resultItemID;
31. publicAprioriTool(StringfilePath,intminSupportCount){
32. this.filePath=filePath;
33. this.minSupportCount=minSupportCount;
34. readDataFile();
35. }
37. /**
38. *从文件中读取数据
39. */
40. privatevoidreadDataFile(){
41. Filefile=newFile(filePath);
42. ArrayList<String[]>dataArray=newArrayList<String[]>();
44. try{
45. BufferedReaderin=newBufferedReader(newFileReader(file));
46. Stringstr;
47. String[]tempArray;
48. while((str=in.readLine())!=null){
49. tempArray=str.split("");
50. dataArray.add(tempArray);
51. }
52. in.close();
53. }catch(IOExceptione){
54. e.getStackTrace();
55. }
57. String[]temp=null;
58. totalGoodsIDs=newArrayList<>();
59. for(String[]array:dataArray){
60. temp=newString[array.length-1];
61. System.arraycopy(array,1,temp,0,array.length-1);
63. //将事务ID加入列表吧中
64. totalGoodsIDs.add(temp);
65. }
66. }
68. /**
69. *判读字符数组array2是否包含于数组array1中
70. *
71. *@paramarray1
72. *@paramarray2
73. *@return
74. */
75. publicbooleaniSStrContain(String[]array1,String[]array2){
76. if(array1==null||array2==null){
77. returnfalse;
78. }
80. booleaniSContain=false;
81. for(Strings:array2){
82. //新的字母比较时，重新初始化变量
83. iSContain=false;
84. //判读array2中每个字符，只要包括在array1中，就算包含
85. for(Strings2:array1){
86. if(s.equals(s2)){
87. iSContain=true;
88. break;
89. }
90. }
92. //如果已经判断出不包含了，则直接中断循环
93. if(!iSContain){
94. break;
95. }
96. }
98. returniSContain;
99. }
101. /**
102. *项集进行连接运算
103. */
104. privatevoidcomputeLink(){
105. //连接计算的终止数，k项集必须算到k-1子项集为止
106. intendNum=0;
107. //当前已经进行连接运算到几项集,开始时就是1项集
108. intcurrentNum=1;
109. //商品，1频繁项集映射图
110. HashMap<String,FrequentItem>itemMap=newHashMap<>();
111. FrequentItemtempItem;
112. //初始列表
113. ArrayList<FrequentItem>list=newArrayList<>();
114. //经过连接运算后产生的结果项集
115. resultItem=newArrayList<>();
116. resultItemID=newArrayList<>();
117. //商品ID的种类
118. ArrayList<String>idType=newArrayList<>();
119. for(String[]a:totalGoodsIDs){
120. for(Strings:a){
121. if(!idType.contains(s)){
122. tempItem=newFrequentItem(newString[]{s},1);
123. idType.add(s);
124. resultItemID.add(newString[]{s});
125. }else{
126. //支持度计数加1
127. tempItem=itemMap.get(s);
128. tempItem.setCount(tempItem.getCount()+1);
129. }
130. itemMap.put(s,tempItem);
131. }
132. }
133. //将初始频繁项集转入到列表中，以便继续做连接运算
134. for(Map.Entryentry:itemMap.entrySet()){
135. list.add((FrequentItem)entry.getValue());
136. }
137. //按照商品ID进行排序，否则连接计算结果将会不一致，将会减少
138. Collections.sort(list);
139. resultItem.addAll(list);
141. String[]array1;
142. String[]array2;
143. String[]resultArray;
144. ArrayList<String>tempIds;
145. ArrayList<String[]>resultContainer;
146. //总共要算到endNum项集
147. endNum=list.size()-1;
149. while(currentNum<endNum){
150. resultContainer=newArrayList<>();
151. for(inti=0;i<list.size()-1;i++){
152. tempItem=list.get(i);
153. array1=tempItem.getIdArray();
154. for(intj=i+1;j<list.size();j++){
155. tempIds=newArrayList<>();
156. array2=list.get(j).getIdArray();
157. for(intk=0;k<array1.length;k++){
158. //如果对应位置上的值相等的时候，只取其中一个值，做了一个连接删除操作
159. if(array1[k].equals(array2[k])){
160. tempIds.add(array1[k]);
161. }else{
162. tempIds.add(array1[k]);
163. tempIds.add(array2[k]);
164. }
165. }
166. resultArray=newString[tempIds.size()];
167. tempIds.toArray(resultArray);
169. booleanisContain=false;
170. //过滤不符合条件的的ID数组，包括重复的和长度不符合要求的
171. if(resultArray.length==(array1.length+1)){
172. isContain=isIDArrayContains(resultContainer,
173. resultArray);
174. if(!isContain){
175. resultContainer.add(resultArray);
176. }
177. }
178. }
179. }
181. //做频繁项集的剪枝处理，必须保证新的频繁项集的子项集也必须是频繁项集
182. list=cutItem(resultContainer);
183. currentNum++;
184. }
186. //输出频繁项集
187. for(intk=1;k<=currentNum;k++){
188. System.out.println("频繁"+k+"项集：");
189. for(FrequentItemi:resultItem){
190. if(i.getLength()==k){
191. System.out.print("{");
192. for(Stringt:i.getIdArray()){
193. System.out.print(t+",");
194. }
195. System.out.print("},");
196. }
197. }
198. System.out.println();
199. }
200. }
202. /**
203. *判断列表结果中是否已经包含此数组
204. *
205. *@paramcontainer
206. *ID数组容器
207. *@paramarray
208. *待比较数组
209. *@return
210. */
211. privatebooleanisIDArrayContains(ArrayList<String[]>container,
212. String[]array){
213. booleanisContain=true;
214. if(container.size()==0){
215. isContain=false;
216. returnisContain;
217. }
219. for(String[]s:container){
220. //比较的视乎必须保证长度一样
221. if(s.length!=array.length){
222. continue;
223. }
225. isContain=true;
226. for(inti=0;i<s.length;i++){
227. //只要有一个id不等，就算不相等
228. if(s[i]!=array[i]){
229. isContain=false;
230. break;
231. }
232. }
234. //如果已经判断是包含在容器中时，直接退出
235. if(isContain){
236. break;
237. }
238. }
240. returnisContain;
241. }
243. /**
244. *对频繁项集做剪枝步骤，必须保证新的频繁项集的子项集也必须是频繁项集
245. */
246. privateArrayList<FrequentItem>cutItem(ArrayList<String[]>resultIds){
247. String[]temp;
248. //忽略的索引位置，以此构建子集
249. intigNoreIndex=0;
250. FrequentItemtempItem;
251. //剪枝生成新的频繁项集
252. ArrayList<FrequentItem>newItem=newArrayList<>();
253. //不符合要求的id
254. ArrayList<String[]>deleteIdArray=newArrayList<>();
255. //子项集是否也为频繁子项集
256. booleanisContain=true;
258. for(String[]array:resultIds){
259. //列举出其中的一个个的子项集，判断存在于频繁项集列表中
260. temp=newString[array.length-1];
261. for(igNoreIndex=0;igNoreIndex<array.length;igNoreIndex++){
262. isContain=true;
263. for(intj=0,k=0;j<array.length;j++){
264. if(j!=igNoreIndex){
265. temp[k]=array[j];
266. k++;
267. }
268. }
270. if(!isIDArrayContains(resultItemID,temp)){
271. isContain=false;
272. break;
273. }
274. }
276. if(!isContain){
277. deleteIdArray.add(array);
278. }
279. }
281. //移除不符合条件的ID组合
282. resultIds.removeAll(deleteIdArray);
284. //移除支持度计数不够的id集合
285. inttempCount=0;
286. for(String[]array:resultIds){
287. tempCount=0;
288. for(String[]array2:totalGoodsIDs){
289. if(isStrArrayContain(array2,array)){
290. tempCount++;
291. }
292. }
294. //如果支持度计数大于等于最小最小支持度计数则生成新的频繁项集，并加入结果集中
295. if(tempCount>=minSupportCount){
296. tempItem=newFrequentItem(array,tempCount);
297. newItem.add(tempItem);
298. resultItemID.add(array);
299. resultItem.add(tempItem);
300. }
301. }
303. returnnewItem;
304. }
306. /**
307. *数组array2是否包含于array1中，不需要完全一样
308. *
309. *@paramarray1
310. *@paramarray2
311. *@return
312. */
313. privatebooleanisStrArrayContain(String[]array1,String[]array2){
314. booleanisContain=true;
315. for(Strings2:array2){
316. isContain=false;
317. for(Strings1:array1){
318. //只要s2字符存在于array1中，这个字符就算包含在array1中
319. if(s2.equals(s1)){
320. isContain=true;
321. break;
322. }
323. }
325. //一旦发现不包含的字符，则array2数组不包含于array1中
326. if(!isContain){
327. break;
328. }
329. }
331. returnisContain;
332. }
334. /**
335. *根据产生的频繁项集输出关联规则
336. *
337. *@paramminConf
338. *最小置信度阈值
339. */
340. publicvoidprintAttachRule(doubleminConf){
341. //进行连接和剪枝操作
342. computeLink();
344. intcount1=0;
345. intcount2=0;
346. ArrayList<String>childGroup1;
347. ArrayList<String>childGroup2;
348. String[]group1;
349. String[]group2;
350. //以最后一个频繁项集做关联规则的输出
351. String[]array=resultItem.get(resultItem.size()-1).getIdArray();
352. //子集总数，计算的时候除去自身和空集
353. inttotalNum=(int)Math.pow(2,array.length);
354. String[]temp;
355. //二进制数组，用来代表各个子集
356. int[]binaryArray;
357. //除去头和尾部
358. for(inti=1;i<totalNum-1;i++){
359. binaryArray=newint[array.length];
360. numToBinaryArray(binaryArray,i);
362. childGroup1=newArrayList<>();
363. childGroup2=newArrayList<>();
364. count1=0;
365. count2=0;
366. //按照二进制位关系取出子集
367. for(intj=0;j<binaryArray.length;j++){
368. if(binaryArray[j]==1){
369. childGroup1.add(array[j]);
370. }else{
371. childGroup2.add(array[j]);
372. }
373. }
375. group1=newString[childGroup1.size()];
376. group2=newString[childGroup2.size()];
378. childGroup1.toArray(group1);
379. childGroup2.toArray(group2);
381. for(String[]a:totalGoodsIDs){
382. if(isStrArrayContain(a,group1)){
383. count1++;
385. //在group1的条件下，统计group2的事件发生次数
386. if(isStrArrayContain(a,group2)){
387. count2++;
388. }
389. }
390. }
392. //{A}-->{B}的意思为在A的情况下发生B的概率
393. System.out.print("{");
394. for(Strings:group1){
395. System.out.print(s+",");
396. }
397. System.out.print("}-->");
398. System.out.print("{");
399. for(Strings:group2){
400. System.out.print(s+",");
401. }
402. System.out.print(MessageFormat.format(
403. "},confidence(置信度)：{0}/{1}={2}",count2,count1,count2
404. *1.0/count1));
405. if(count2*1.0/count1<minConf){
406. //不符合要求，不是强规则
407. System.out.println("由于此规则置信度未达到最小置信度的要求，不是强规则");
408. }else{
409. System.out.println("为强规则");
410. }
411. }
413. }
415. /**
416. *数字转为二进制形式
417. *
418. *@parambinaryArray
419. *转化后的二进制数组形式
420. *@paramnum
421. *待转化数字
422. */
423. privatevoidnumToBinaryArray(int[]binaryArray,intnum){
424. intindex=0;
425. while(num!=0){
426. binaryArray[index]=num%2;
427. index++;
428. num/=2;
429. }
430. }
432. }

调用类：

[java]view plaincopyprint?

1. /**
2. *apriori关联规则挖掘算法调用类
3. *@authorlyq
4. *
5. */
6. publicclassClient{
7. publicstaticvoidmain(String[]args){
8. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\testInput.txt";
10. AprioriTooltool=newAprioriTool(filePath,2);
11. tool.printAttachRule(0.7);
12. }
13. }

输出的结果：

[java]view plaincopyprint?

1. 频繁1项集：
2. {1,},{2,},{3,},{4,},{5,},
3. 频繁2项集：
4. {1,2,},{1,3,},{1,5,},{2,3,},{2,4,},{2,5,},
5. 频繁3项集：
6. {1,2,3,},{1,2,5,},
7. 频繁4项集：
9. {1,}-->{2,5,},confidence(置信度)：2/6=0.333由于此规则置信度未达到最小置信度的要求，不是强规则
10. {2,}-->{1,5,},confidence(置信度)：2/7=0.286由于此规则置信度未达到最小置信度的要求，不是强规则
11. {1,2,}-->{5,},confidence(置信度)：2/4=0.5由于此规则置信度未达到最小置信度的要求，不是强规则
12. {5,}-->{1,2,},confidence(置信度)：2/2=1为强规则
13. {1,5,}-->{2,},confidence(置信度)：2/2=1为强规则
14. {2,5,}-->{1,},confidence(置信度)：2/2=1为强规则

程序算法的问题和技巧

在实现Apiori算法的时候，碰到的一些问题和待优化的点特别要提一下：

1、首先程序的运行效率不高，里面有大量的for嵌套循环叠加上循环，当然这有本身算法的原因(连接运算所致)还有我的各个的方法选择，很多一部分用来比较字符串数组。

2、这个是我觉得会是程序的一个漏洞，当生成的候选项集加入resultItemId时，会出现{1, 2, 3}和{3, 2, 1}会被当成不同的侯选集，未做顺序的判断。

3、程序的调试过程中由于未按照从小到大的排序，导致，生成的候选集与真实值不一致的情况，所以这里必须在频繁1项集的时候就应该是有序的。

4、在输出关联规则的时候，用到了数字转二进制数组的形式，输出他的各个非空子集，然后最出关联规则的判断。

Apriori算法的缺点

此算法的的应用非常广泛，但是他在运算的过程中会产生大量的侯选集，而且在匹配的时候要进行整个数据库的扫描，因为要做支持度计数的统计操作，在小规模的数据上操作还不会有大问题，如果是大型的数据库上呢，他的效率还是有待提高的。