CBA算法---基于关联规则进行分类的算法 CBA算法---基于关联规则进行分类的算法CBA算法---基于关联规则进行分类的算法...

关闭

CBA算法---基于关联规则进行分类的算法

标签：机器学习数据挖掘算法数据

2015-02-14 19:02 823人阅读 评论(0) 收藏 举报

分类：

算法（44） 数据挖掘（32） 机器学习（30）

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

更多数据挖掘算法：https://github.com/linyiqun/DataMiningAlgorithm

介绍

CBA算法全称是Classification base of Association，就是基于关联规则进行分类的算法，说到关联规则，我们就会想到Apriori和FP-Tree算法都是关联规则挖掘算法，而CBA算法正是利用了Apriori挖掘出的关联规则，然后做分类判断，所以在某种程度上说，CBA算法也可以说是一种集成挖掘算法。

算法原理

CBA算法作为分类算法，他的分类情况也就是给定一些预先知道的属性，然后叫你判断出他的决策属性是哪个值。判断的依据就是Apriori算法挖掘出的频繁项，如果一个项集中包含预先知道的属性，同时也包含分类属性值，然后我们计算此频繁项能否导出已知属性值推出决策属性值的关联规则，如果满足规则的最小置信度的要求，那么可以把频繁项中的决策属性值作为最后的分类结果。具体的算法细节如下：

1、输入数据记录，就是一条条的属性值。

2、对属性值做数字的替换(按照列从上往下寻找属性值)，就类似于Apriori中的一条条事务记录。

3、根据这个转化后的事务记录，进行Apriori算法计算，挖掘出频繁项集。

4、输入查询的属性值，找出符合条件的频繁项集(需要包含查询属性和分类决策属性)，如果能够推导出这样的关联规则，就算分类成功，输出分类结果。

这里以之前我做的CART算法的测试数据为CBA算法的测试数据，如下：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 113HighNoFairCLassNo
3. 211HighNoExcellentCLassNo
4. 325HighNoFairCLassYes
5. 445MediumNoFairCLassYes
6. 550LowYesFairCLassYes
7. 651LowYesExcellentCLassNo
8. 730LowYesExcellentCLassYes
9. 813MediumNoFairCLassNo
10. 99LowYesFairCLassYes
11. 1055MediumYesFairCLassYes
12. 1114MediumYesExcellentCLassYes
13. 1233MediumNoExcellentCLassYes
14. 1333HighYesFairCLassYes
15. 1441MediumNoExcellentCLassNo

属性值对应的数字替换图：

[java] view plain copy print ?

1. Medium=5,CLassYes=12,Excellent=10,Low=6,Fair=9,CLassNo=11,Young=1,Middle_aged=2,Yes=8,No=7,High=4,Senior=3

体会之后的数据变为了下面的事务项：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 1147911
3. 21471011
4. 3247912
5. 4357912
6. 5368912
7. 63681011
8. 72681012
9. 8157911
10. 9168912
11. 10358912
12. 111581012
13. 122571012
14. 13248912
15. 143571011

把每条记录看出事务项，就和Apriori算法的输入格式基本一样了，后面就是进行连接运算和剪枝步骤等Apriori算法的步骤了，在这里就不详细描述了，Apriori算法的实现可以 点击这里进行了解。

算法的代码实现

测试数据就是上面的内容。

CBATool.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.IOException;
7. importjava.util.ArrayList;
8. importjava.util.HashMap;
9. importjava.util.regex.Matcher;
10. importjava.util.regex.Pattern;
12. importDataMining_CBA.AprioriTool.AprioriTool;
13. importDataMining_CBA.AprioriTool.FrequentItem;
15. /**
16. *CBA算法(关联规则分类)工具类
17. *
18. *@authorlyq
19. *
20. */
21. publicclassCBATool{
22. //年龄的类别划分
23. publicfinalStringAGE="Age";
24. publicfinalStringAGE_YOUNG="Young";
25. publicfinalStringAGE_MIDDLE_AGED="Middle_aged";
26. publicfinalStringAGE_Senior="Senior";
28. //测试数据地址
29. privateStringfilePath;
30. //最小支持度阈值率
31. privatedoubleminSupportRate;
32. //最小置信度阈值，用来判断是否能够成为关联规则
33. privatedoubleminConf;
34. //最小支持度
35. privateintminSupportCount;
36. //属性列名称
37. privateString[]attrNames;
38. //类别属性所代表的数字集合
39. privateArrayList<Integer>classTypes;
40. //用二维数组保存测试数据
41. privateArrayList<String[]>totalDatas;
42. //Apriori算法工具类
43. privateAprioriToolaprioriTool;
44. //属性到数字的映射图
45. privateHashMap<String,Integer>attr2Num;
46. privateHashMap<Integer,String>num2Attr;
48. publicCBATool(StringfilePath,doubleminSupportRate,doubleminConf){
49. this.filePath=filePath;
50. this.minConf=minConf;
51. this.minSupportRate=minSupportRate;
52. readDataFile();
53. }
55. /**
56. *从文件中读取数据
57. */
58. privatevoidreadDataFile(){
59. Filefile=newFile(filePath);
60. ArrayList<String[]>dataArray=newArrayList<String[]>();
62. try{
63. BufferedReaderin=newBufferedReader(newFileReader(file));
64. Stringstr;
65. String[]tempArray;
66. while((str=in.readLine())!=null){
67. tempArray=str.split("");
68. dataArray.add(tempArray);
69. }
70. in.close();
71. }catch(IOExceptione){
72. e.getStackTrace();
73. }
75. totalDatas=newArrayList<>();
76. for(String[]array:dataArray){
77. totalDatas.add(array);
78. }
79. attrNames=totalDatas.get(0);
80. minSupportCount=(int)(minSupportRate*totalDatas.size());
82. attributeReplace();
83. }
85. /**
86. *属性值的替换，替换成数字的形式，以便进行频繁项的挖掘
87. */
88. privatevoidattributeReplace(){
89. intcurrentValue=1;
90. intnum=0;
91. Strings;
92. //属性名到数字的映射图
93. attr2Num=newHashMap<>();
94. num2Attr=newHashMap<>();
95. classTypes=newArrayList<>();
97. //按照1列列的方式来，从左往右边扫描,跳过列名称行和id列
98. for(intj=1;j<attrNames.length;j++){
99. for(inti=1;i<totalDatas.size();i++){
100. s=totalDatas.get(i)[j];
101. //如果是数字形式的，这里只做年龄类别转换，其他的数字情况类似
102. if(attrNames[j].equals(AGE)){
103. num=Integer.parseInt(s);
104. if(num<=20&&num>0){
105. totalDatas.get(i)[j]=AGE_YOUNG;
106. }elseif(num>20&&num<=40){
107. totalDatas.get(i)[j]=AGE_MIDDLE_AGED;
108. }elseif(num>40){
109. totalDatas.get(i)[j]=AGE_Senior;
110. }
111. }
113. if(!attr2Num.containsKey(totalDatas.get(i)[j])){
114. attr2Num.put(totalDatas.get(i)[j],currentValue);
115. num2Attr.put(currentValue,totalDatas.get(i)[j]);
116. if(j==attrNames.length-1){
117. //如果是组后一列，说明是分类类别列，记录下来
118. classTypes.add(currentValue);
119. }
121. currentValue++;
122. }
123. }
124. }
126. //对原始的数据作属性替换，每条记录变为类似于事务数据的形式
127. for(inti=1;i<totalDatas.size();i++){
128. for(intj=1;j<attrNames.length;j++){
129. s=totalDatas.get(i)[j];
130. if(attr2Num.containsKey(s)){
131. totalDatas.get(i)[j]=attr2Num.get(s)+"";
132. }
133. }
134. }
135. }
137. /**
138. *Apriori计算全部频繁项集
139. *@return
140. */
141. privateArrayList<FrequentItem>aprioriCalculate(){
142. String[]tempArray;
143. ArrayList<FrequentItem>totalFrequentItems;
144. ArrayList<String[]>copyData=(ArrayList<String[]>)totalDatas.clone();
146. //去除属性名称行
147. copyData.remove(0);
148. //去除首列ID
149. for(inti=0;i<copyData.size();i++){
150. String[]array=copyData.get(i);
151. tempArray=newString[array.length-1];
152. System.arraycopy(array,1,tempArray,0,tempArray.length);
153. copyData.set(i,tempArray);
154. }
155. aprioriTool=newAprioriTool(copyData,minSupportCount);
156. aprioriTool.computeLink();
157. totalFrequentItems=aprioriTool.getTotalFrequentItems();
159. returntotalFrequentItems;
160. }
162. /**
163. *基于关联规则的分类
164. *
165. *@paramattrValues
166. *预先知道的一些属性
167. *@return
168. */
169. publicStringCBAJudge(StringattrValues){
170. intvalue=0;
171. //最终分类类别
172. StringclassType=null;
173. String[]tempArray;
174. //已知的属性值
175. ArrayList<String>attrValueList=newArrayList<>();
176. ArrayList<FrequentItem>totalFrequentItems;
178. totalFrequentItems=aprioriCalculate();
179. //将查询条件进行逐一属性的分割
180. String[]array=attrValues.split(",");
181. for(Stringrecord:array){
182. tempArray=record.split("=");
183. value=attr2Num.get(tempArray[1]);
184. attrValueList.add(value+"");
185. }
187. //在频繁项集中寻找符合条件的项
188. for(FrequentItemitem:totalFrequentItems){
189. //过滤掉不满足个数频繁项
190. if(item.getIdArray().length<(attrValueList.size()+1)){
191. continue;
192. }
194. //要保证查询的属性都包含在频繁项集中
195. if(itemIsSatisfied(item,attrValueList)){
196. tempArray=item.getIdArray();
197. classType=classificationBaseRules(tempArray);
199. if(classType!=null){
200. //作属性替换
201. classType=num2Attr.get(Integer.parseInt(classType));
202. break;
203. }
204. }
205. }
207. returnclassType;
208. }
210. /**
211. *基于关联规则进行分类
212. *
213. *@paramitems
214. *频繁项
215. *@return
216. */
217. privateStringclassificationBaseRules(String[]items){
218. StringclassType=null;
219. String[]arrayTemp;
220. intcount1=0;
221. intcount2=0;
222. //置信度
223. doubleconfidenceRate;
225. String[]noClassTypeItems=newString[items.length-1];
226. for(inti=0,k=0;i<items.length;i++){
227. if(!classTypes.contains(Integer.parseInt(items[i]))){
228. noClassTypeItems[k]=items[i];
229. k++;
230. }else{
231. classType=items[i];
232. }
233. }
235. for(String[]array:totalDatas){
236. //去除ID数字号
237. arrayTemp=newString[array.length-1];
238. System.arraycopy(array,1,arrayTemp,0,array.length-1);
239. if(isStrArrayContain(arrayTemp,noClassTypeItems)){
240. count1++;
242. if(isStrArrayContain(arrayTemp,items)){
243. count2++;
244. }
245. }
246. }
248. //做置信度的计算
249. confidenceRate=count1*1.0/count2;
250. if(confidenceRate>=minConf){
251. returnclassType;
252. }else{
253. //如果不满足最小置信度要求，则此关联规则无效
254. returnnull;
255. }
256. }
258. /**
259. *判断单个字符是否包含在字符数组中
260. *
261. *@paramarray
262. *字符数组
263. *@params
264. *判断的单字符
265. *@return
266. */
267. privatebooleanstrIsContained(String[]array,Strings){
268. booleanisContained=false;
270. for(Stringstr:array){
271. if(str.equals(s)){
272. isContained=true;
273. break;
274. }
275. }
277. returnisContained;
278. }
280. /**
281. *数组array2是否包含于array1中，不需要完全一样
282. *
283. *@paramarray1
284. *@paramarray2
285. *@return
286. */
287. privatebooleanisStrArrayContain(String[]array1,String[]array2){
288. booleanisContain=true;
289. for(Strings2:array2){
290. isContain=false;
291. for(Strings1:array1){
292. //只要s2字符存在于array1中，这个字符就算包含在array1中
293. if(s2.equals(s1)){
294. isContain=true;
295. break;
296. }
297. }
299. //一旦发现不包含的字符，则array2数组不包含于array1中
300. if(!isContain){
301. break;
302. }
303. }
305. returnisContain;
306. }
308. /**
309. *判断频繁项集是否满足查询
310. *
311. *@paramitem
312. *待判断的频繁项集
313. *@paramattrValues
314. *查询的属性值列表
315. *@return
316. */
317. privatebooleanitemIsSatisfied(FrequentItemitem,
318. ArrayList<String>attrValues){
319. booleanisContained=false;
320. String[]array=item.getIdArray();
322. for(Strings:attrValues){
323. isContained=true;
325. if(!strIsContained(array,s)){
326. isContained=false;
327. break;
328. }
330. if(!isContained){
331. break;
332. }
333. }
335. if(isContained){
336. isContained=false;
338. //还要验证是否频繁项集中是否包含分类属性
339. for(Integertype:classTypes){
340. if(strIsContained(array,type+"")){
341. isContained=true;
342. break;
343. }
344. }
345. }
347. returnisContained;
348. }
350. }

调用类Client.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.text.MessageFormat;
5. /**
6. *CBA算法--基于关联规则的分类算法
7. *@authorlyq
8. *
9. */
10. publicclassClient{
11. publicstaticvoidmain(String[]args){
12. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\input.txt";
13. StringattrDesc="Age=Senior,CreditRating=Fair";
14. Stringclassification=null;
16. //最小支持度阈值率
17. doubleminSupportRate=0.2;
18. //最小置信度阈值
19. doubleminConf=0.7;
21. CBATooltool=newCBATool(filePath,minSupportRate,minConf);
22. classification=tool.CBAJudge(attrDesc);
23. System.out.println(MessageFormat.format("{0}的关联分类结果为{1}",attrDesc,classification));
24. }
25. }

代码的结果为：

[java] view plain copy print ?

1. 频繁1项集：
2. {1,},{2,},{3,},{4,},{5,},{6,},{7,},{8,},{9,},{10,},{11,},{12,},
3. 频繁2项集：
4. {1,7,},{1,9,},{1,11,},{2,12,},{3,5,},{3,8,},{3,9,},{3,12,},{4,7,},{4,9,},{5,7,},{5,9,},{5,10,},{5,12,},{6,8,},{6,12,},{7,9,},{7,10,},{7,11,},{7,12,},{8,9,},{8,10,},{8,12,},{9,12,},{10,11,},{10,12,},
5. 频繁3项集：
6. {1,7,11,},{3,9,12,},{6,8,12,},{8,9,12,},
7. 频繁4项集：
9. 频繁5项集：
11. 频繁6项集：
13. 频繁7项集：
15. 频繁8项集：
17. 频繁9项集：
19. 频繁10项集：
21. 频繁11项集：
23. Age=Senior,CreditRating=Fair的关联分类结果为CLassYes

上面的有些项集为空说明没有此项集。Apriori算法类可以在 这里进行查阅，这里只展示了CBA算法的部分。

算法的分析

我在准备实现CBA算法的时候就预见到了这个算法就是对Apriori算法的一个包装，在于2点，输入数据的格式进行数字的转换，还有就是输出的时候做属性对数字的替换，核心还是在于Apriori算法的项集频繁挖掘。

程序实现时遇到的问题

在这期间遇到了一个bug就是频繁1项集在排序的时候出现了问题，后来发现原因是String.CompareTo()，原本应该是1，2，....11，12，用了前面这个方法后会变成1,10,2,。。就是10会比2小的情况，后来查了String.CompareTo()的比较规则，明白了他是一位位比较Ascall码值，因为10的1比2小，最后果断的改回了用Integer的比较方法了。这个问题别看是个小问题，1项集如果没有排好序，后面的连接操作可能会出现少情况的可能，这个之前吃过这样的亏了。

我对CBA算法的理解

CBA算法和巧妙的利用了关联规则进行类别的分类，有别与其他的分类算法。他的算法好坏又会依靠Apriori算法的执行好坏。

关闭

CBA算法---基于关联规则进行分类的算法

标签：机器学习数据挖掘算法数据

2015-02-14 19:02 823人阅读 评论(0) 收藏 举报

分类：

算法（44） 数据挖掘（32） 机器学习（30）

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

更多数据挖掘算法：https://github.com/linyiqun/DataMiningAlgorithm

介绍

CBA算法全称是Classification base of Association，就是基于关联规则进行分类的算法，说到关联规则，我们就会想到Apriori和FP-Tree算法都是关联规则挖掘算法，而CBA算法正是利用了Apriori挖掘出的关联规则，然后做分类判断，所以在某种程度上说，CBA算法也可以说是一种集成挖掘算法。

算法原理

CBA算法作为分类算法，他的分类情况也就是给定一些预先知道的属性，然后叫你判断出他的决策属性是哪个值。判断的依据就是Apriori算法挖掘出的频繁项，如果一个项集中包含预先知道的属性，同时也包含分类属性值，然后我们计算此频繁项能否导出已知属性值推出决策属性值的关联规则，如果满足规则的最小置信度的要求，那么可以把频繁项中的决策属性值作为最后的分类结果。具体的算法细节如下：

1、输入数据记录，就是一条条的属性值。

2、对属性值做数字的替换(按照列从上往下寻找属性值)，就类似于Apriori中的一条条事务记录。

3、根据这个转化后的事务记录，进行Apriori算法计算，挖掘出频繁项集。

4、输入查询的属性值，找出符合条件的频繁项集(需要包含查询属性和分类决策属性)，如果能够推导出这样的关联规则，就算分类成功，输出分类结果。

这里以之前我做的CART算法的测试数据为CBA算法的测试数据，如下：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 113HighNoFairCLassNo
3. 211HighNoExcellentCLassNo
4. 325HighNoFairCLassYes
5. 445MediumNoFairCLassYes
6. 550LowYesFairCLassYes
7. 651LowYesExcellentCLassNo
8. 730LowYesExcellentCLassYes
9. 813MediumNoFairCLassNo
10. 99LowYesFairCLassYes
11. 1055MediumYesFairCLassYes
12. 1114MediumYesExcellentCLassYes
13. 1233MediumNoExcellentCLassYes
14. 1333HighYesFairCLassYes
15. 1441MediumNoExcellentCLassNo

属性值对应的数字替换图：

[java] view plain copy print ?

1. Medium=5,CLassYes=12,Excellent=10,Low=6,Fair=9,CLassNo=11,Young=1,Middle_aged=2,Yes=8,No=7,High=4,Senior=3

体会之后的数据变为了下面的事务项：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 1147911
3. 21471011
4. 3247912
5. 4357912
6. 5368912
7. 63681011
8. 72681012
9. 8157911
10. 9168912
11. 10358912
12. 111581012
13. 122571012
14. 13248912
15. 143571011

把每条记录看出事务项，就和Apriori算法的输入格式基本一样了，后面就是进行连接运算和剪枝步骤等Apriori算法的步骤了，在这里就不详细描述了，Apriori算法的实现可以 点击这里进行了解。

算法的代码实现

测试数据就是上面的内容。

CBATool.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.IOException;
7. importjava.util.ArrayList;
8. importjava.util.HashMap;
9. importjava.util.regex.Matcher;
10. importjava.util.regex.Pattern;
12. importDataMining_CBA.AprioriTool.AprioriTool;
13. importDataMining_CBA.AprioriTool.FrequentItem;
15. /**
16. *CBA算法(关联规则分类)工具类
17. *
18. *@authorlyq
19. *
20. */
21. publicclassCBATool{
22. //年龄的类别划分
23. publicfinalStringAGE="Age";
24. publicfinalStringAGE_YOUNG="Young";
25. publicfinalStringAGE_MIDDLE_AGED="Middle_aged";
26. publicfinalStringAGE_Senior="Senior";
28. //测试数据地址
29. privateStringfilePath;
30. //最小支持度阈值率
31. privatedoubleminSupportRate;
32. //最小置信度阈值，用来判断是否能够成为关联规则
33. privatedoubleminConf;
34. //最小支持度
35. privateintminSupportCount;
36. //属性列名称
37. privateString[]attrNames;
38. //类别属性所代表的数字集合
39. privateArrayList<Integer>classTypes;
40. //用二维数组保存测试数据
41. privateArrayList<String[]>totalDatas;
42. //Apriori算法工具类
43. privateAprioriToolaprioriTool;
44. //属性到数字的映射图
45. privateHashMap<String,Integer>attr2Num;
46. privateHashMap<Integer,String>num2Attr;
48. publicCBATool(StringfilePath,doubleminSupportRate,doubleminConf){
49. this.filePath=filePath;
50. this.minConf=minConf;
51. this.minSupportRate=minSupportRate;
52. readDataFile();
53. }
55. /**
56. *从文件中读取数据
57. */
58. privatevoidreadDataFile(){
59. Filefile=newFile(filePath);
60. ArrayList<String[]>dataArray=newArrayList<String[]>();
62. try{
63. BufferedReaderin=newBufferedReader(newFileReader(file));
64. Stringstr;
65. String[]tempArray;
66. while((str=in.readLine())!=null){
67. tempArray=str.split("");
68. dataArray.add(tempArray);
69. }
70. in.close();
71. }catch(IOExceptione){
72. e.getStackTrace();
73. }
75. totalDatas=newArrayList<>();
76. for(String[]array:dataArray){
77. totalDatas.add(array);
78. }
79. attrNames=totalDatas.get(0);
80. minSupportCount=(int)(minSupportRate*totalDatas.size());
82. attributeReplace();
83. }
85. /**
86. *属性值的替换，替换成数字的形式，以便进行频繁项的挖掘
87. */
88. privatevoidattributeReplace(){
89. intcurrentValue=1;
90. intnum=0;
91. Strings;
92. //属性名到数字的映射图
93. attr2Num=newHashMap<>();
94. num2Attr=newHashMap<>();
95. classTypes=newArrayList<>();
97. //按照1列列的方式来，从左往右边扫描,跳过列名称行和id列
98. for(intj=1;j<attrNames.length;j++){
99. for(inti=1;i<totalDatas.size();i++){
100. s=totalDatas.get(i)[j];
101. //如果是数字形式的，这里只做年龄类别转换，其他的数字情况类似
102. if(attrNames[j].equals(AGE)){
103. num=Integer.parseInt(s);
104. if(num<=20&&num>0){
105. totalDatas.get(i)[j]=AGE_YOUNG;
106. }elseif(num>20&&num<=40){
107. totalDatas.get(i)[j]=AGE_MIDDLE_AGED;
108. }elseif(num>40){
109. totalDatas.get(i)[j]=AGE_Senior;
110. }
111. }
113. if(!attr2Num.containsKey(totalDatas.get(i)[j])){
114. attr2Num.put(totalDatas.get(i)[j],currentValue);
115. num2Attr.put(currentValue,totalDatas.get(i)[j]);
116. if(j==attrNames.length-1){
117. //如果是组后一列，说明是分类类别列，记录下来
118. classTypes.add(currentValue);
119. }
121. currentValue++;
122. }
123. }
124. }
126. //对原始的数据作属性替换，每条记录变为类似于事务数据的形式
127. for(inti=1;i<totalDatas.size();i++){
128. for(intj=1;j<attrNames.length;j++){
129. s=totalDatas.get(i)[j];
130. if(attr2Num.containsKey(s)){
131. totalDatas.get(i)[j]=attr2Num.get(s)+"";
132. }
133. }
134. }
135. }
137. /**
138. *Apriori计算全部频繁项集
139. *@return
140. */
141. privateArrayList<FrequentItem>aprioriCalculate(){
142. String[]tempArray;
143. ArrayList<FrequentItem>totalFrequentItems;
144. ArrayList<String[]>copyData=(ArrayList<String[]>)totalDatas.clone();
146. //去除属性名称行
147. copyData.remove(0);
148. //去除首列ID
149. for(inti=0;i<copyData.size();i++){
150. String[]array=copyData.get(i);
151. tempArray=newString[array.length-1];
152. System.arraycopy(array,1,tempArray,0,tempArray.length);
153. copyData.set(i,tempArray);
154. }
155. aprioriTool=newAprioriTool(copyData,minSupportCount);
156. aprioriTool.computeLink();
157. totalFrequentItems=aprioriTool.getTotalFrequentItems();
159. returntotalFrequentItems;
160. }
162. /**
163. *基于关联规则的分类
164. *
165. *@paramattrValues
166. *预先知道的一些属性
167. *@return
168. */
169. publicStringCBAJudge(StringattrValues){
170. intvalue=0;
171. //最终分类类别
172. StringclassType=null;
173. String[]tempArray;
174. //已知的属性值
175. ArrayList<String>attrValueList=newArrayList<>();
176. ArrayList<FrequentItem>totalFrequentItems;
178. totalFrequentItems=aprioriCalculate();
179. //将查询条件进行逐一属性的分割
180. String[]array=attrValues.split(",");
181. for(Stringrecord:array){
182. tempArray=record.split("=");
183. value=attr2Num.get(tempArray[1]);
184. attrValueList.add(value+"");
185. }
187. //在频繁项集中寻找符合条件的项
188. for(FrequentItemitem:totalFrequentItems){
189. //过滤掉不满足个数频繁项
190. if(item.getIdArray().length<(attrValueList.size()+1)){
191. continue;
192. }
194. //要保证查询的属性都包含在频繁项集中
195. if(itemIsSatisfied(item,attrValueList)){
196. tempArray=item.getIdArray();
197. classType=classificationBaseRules(tempArray);
199. if(classType!=null){
200. //作属性替换
201. classType=num2Attr.get(Integer.parseInt(classType));
202. break;
203. }
204. }
205. }
207. returnclassType;
208. }
210. /**
211. *基于关联规则进行分类
212. *
213. *@paramitems
214. *频繁项
215. *@return
216. */
217. privateStringclassificationBaseRules(String[]items){
218. StringclassType=null;
219. String[]arrayTemp;
220. intcount1=0;
221. intcount2=0;
222. //置信度
223. doubleconfidenceRate;
225. String[]noClassTypeItems=newString[items.length-1];
226. for(inti=0,k=0;i<items.length;i++){
227. if(!classTypes.contains(Integer.parseInt(items[i]))){
228. noClassTypeItems[k]=items[i];
229. k++;
230. }else{
231. classType=items[i];
232. }
233. }
235. for(String[]array:totalDatas){
236. //去除ID数字号
237. arrayTemp=newString[array.length-1];
238. System.arraycopy(array,1,arrayTemp,0,array.length-1);
239. if(isStrArrayContain(arrayTemp,noClassTypeItems)){
240. count1++;
242. if(isStrArrayContain(arrayTemp,items)){
243. count2++;
244. }
245. }
246. }
248. //做置信度的计算
249. confidenceRate=count1*1.0/count2;
250. if(confidenceRate>=minConf){
251. returnclassType;
252. }else{
253. //如果不满足最小置信度要求，则此关联规则无效
254. returnnull;
255. }
256. }
258. /**
259. *判断单个字符是否包含在字符数组中
260. *
261. *@paramarray
262. *字符数组
263. *@params
264. *判断的单字符
265. *@return
266. */
267. privatebooleanstrIsContained(String[]array,Strings){
268. booleanisContained=false;
270. for(Stringstr:array){
271. if(str.equals(s)){
272. isContained=true;
273. break;
274. }
275. }
277. returnisContained;
278. }
280. /**
281. *数组array2是否包含于array1中，不需要完全一样
282. *
283. *@paramarray1
284. *@paramarray2
285. *@return
286. */
287. privatebooleanisStrArrayContain(String[]array1,String[]array2){
288. booleanisContain=true;
289. for(Strings2:array2){
290. isContain=false;
291. for(Strings1:array1){
292. //只要s2字符存在于array1中，这个字符就算包含在array1中
293. if(s2.equals(s1)){
294. isContain=true;
295. break;
296. }
297. }
299. //一旦发现不包含的字符，则array2数组不包含于array1中
300. if(!isContain){
301. break;
302. }
303. }
305. returnisContain;
306. }
308. /**
309. *判断频繁项集是否满足查询
310. *
311. *@paramitem
312. *待判断的频繁项集
313. *@paramattrValues
314. *查询的属性值列表
315. *@return
316. */
317. privatebooleanitemIsSatisfied(FrequentItemitem,
318. ArrayList<String>attrValues){
319. booleanisContained=false;
320. String[]array=item.getIdArray();
322. for(Strings:attrValues){
323. isContained=true;
325. if(!strIsContained(array,s)){
326. isContained=false;
327. break;
328. }
330. if(!isContained){
331. break;
332. }
333. }
335. if(isContained){
336. isContained=false;
338. //还要验证是否频繁项集中是否包含分类属性
339. for(Integertype:classTypes){
340. if(strIsContained(array,type+"")){
341. isContained=true;
342. break;
343. }
344. }
345. }
347. returnisContained;
348. }
350. }

调用类Client.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.text.MessageFormat;
5. /**
6. *CBA算法--基于关联规则的分类算法
7. *@authorlyq
8. *
9. */
10. publicclassClient{
11. publicstaticvoidmain(String[]args){
12. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\input.txt";
13. StringattrDesc="Age=Senior,CreditRating=Fair";
14. Stringclassification=null;
16. //最小支持度阈值率
17. doubleminSupportRate=0.2;
18. //最小置信度阈值
19. doubleminConf=0.7;
21. CBATooltool=newCBATool(filePath,minSupportRate,minConf);
22. classification=tool.CBAJudge(attrDesc);
23. System.out.println(MessageFormat.format("{0}的关联分类结果为{1}",attrDesc,classification));
24. }
25. }

代码的结果为：

[java] view plain copy print ?

1. 频繁1项集：
2. {1,},{2,},{3,},{4,},{5,},{6,},{7,},{8,},{9,},{10,},{11,},{12,},
3. 频繁2项集：
4. {1,7,},{1,9,},{1,11,},{2,12,},{3,5,},{3,8,},{3,9,},{3,12,},{4,7,},{4,9,},{5,7,},{5,9,},{5,10,},{5,12,},{6,8,},{6,12,},{7,9,},{7,10,},{7,11,},{7,12,},{8,9,},{8,10,},{8,12,},{9,12,},{10,11,},{10,12,},
5. 频繁3项集：
6. {1,7,11,},{3,9,12,},{6,8,12,},{8,9,12,},
7. 频繁4项集：
9. 频繁5项集：
11. 频繁6项集：
13. 频繁7项集：
15. 频繁8项集：
17. 频繁9项集：
19. 频繁10项集：
21. 频繁11项集：
23. Age=Senior,CreditRating=Fair的关联分类结果为CLassYes

上面的有些项集为空说明没有此项集。Apriori算法类可以在 这里进行查阅，这里只展示了CBA算法的部分。

算法的分析

我在准备实现CBA算法的时候就预见到了这个算法就是对Apriori算法的一个包装，在于2点，输入数据的格式进行数字的转换，还有就是输出的时候做属性对数字的替换，核心还是在于Apriori算法的项集频繁挖掘。

程序实现时遇到的问题

在这期间遇到了一个bug就是频繁1项集在排序的时候出现了问题，后来发现原因是String.CompareTo()，原本应该是1，2，....11，12，用了前面这个方法后会变成1,10,2,。。就是10会比2小的情况，后来查了String.CompareTo()的比较规则，明白了他是一位位比较Ascall码值，因为10的1比2小，最后果断的改回了用Integer的比较方法了。这个问题别看是个小问题，1项集如果没有排好序，后面的连接操作可能会出现少情况的可能，这个之前吃过这样的亏了。

我对CBA算法的理解

CBA算法和巧妙的利用了关联规则进行类别的分类，有别与其他的分类算法。他的算法好坏又会依靠Apriori算法的执行好坏。

更多数据挖掘算法：https://github.com/linyiqun/DataMiningAlgorithm

介绍

CBA算法全称是Classification base of Association，就是基于关联规则进行分类的算法，说到关联规则，我们就会想到Apriori和FP-Tree算法都是关联规则挖掘算法，而CBA算法正是利用了Apriori挖掘出的关联规则，然后做分类判断，所以在某种程度上说，CBA算法也可以说是一种集成挖掘算法。

算法原理

CBA算法作为分类算法，他的分类情况也就是给定一些预先知道的属性，然后叫你判断出他的决策属性是哪个值。判断的依据就是Apriori算法挖掘出的频繁项，如果一个项集中包含预先知道的属性，同时也包含分类属性值，然后我们计算此频繁项能否导出已知属性值推出决策属性值的关联规则，如果满足规则的最小置信度的要求，那么可以把频繁项中的决策属性值作为最后的分类结果。具体的算法细节如下：

1、输入数据记录，就是一条条的属性值。

2、对属性值做数字的替换(按照列从上往下寻找属性值)，就类似于Apriori中的一条条事务记录。

3、根据这个转化后的事务记录，进行Apriori算法计算，挖掘出频繁项集。

4、输入查询的属性值，找出符合条件的频繁项集(需要包含查询属性和分类决策属性)，如果能够推导出这样的关联规则，就算分类成功，输出分类结果。

这里以之前我做的CART算法的测试数据为CBA算法的测试数据，如下：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 113HighNoFairCLassNo
3. 211HighNoExcellentCLassNo
4. 325HighNoFairCLassYes
5. 445MediumNoFairCLassYes
6. 550LowYesFairCLassYes
7. 651LowYesExcellentCLassNo
8. 730LowYesExcellentCLassYes
9. 813MediumNoFairCLassNo
10. 99LowYesFairCLassYes
11. 1055MediumYesFairCLassYes
12. 1114MediumYesExcellentCLassYes
13. 1233MediumNoExcellentCLassYes
14. 1333HighYesFairCLassYes
15. 1441MediumNoExcellentCLassNo

属性值对应的数字替换图：

[java] view plain copy print ?

1. Medium=5,CLassYes=12,Excellent=10,Low=6,Fair=9,CLassNo=11,Young=1,Middle_aged=2,Yes=8,No=7,High=4,Senior=3

体会之后的数据变为了下面的事务项：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 1147911
3. 21471011
4. 3247912
5. 4357912
6. 5368912
7. 63681011
8. 72681012
9. 8157911
10. 9168912
11. 10358912
12. 111581012
13. 122571012
14. 13248912
15. 143571011

把每条记录看出事务项，就和Apriori算法的输入格式基本一样了，后面就是进行连接运算和剪枝步骤等Apriori算法的步骤了，在这里就不详细描述了，Apriori算法的实现可以 点击这里进行了解。

算法的代码实现

测试数据就是上面的内容。

CBATool.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.IOException;
7. importjava.util.ArrayList;
8. importjava.util.HashMap;
9. importjava.util.regex.Matcher;
10. importjava.util.regex.Pattern;
12. importDataMining_CBA.AprioriTool.AprioriTool;
13. importDataMining_CBA.AprioriTool.FrequentItem;
15. /**
16. *CBA算法(关联规则分类)工具类
17. *
18. *@authorlyq
19. *
20. */
21. publicclassCBATool{
22. //年龄的类别划分
23. publicfinalStringAGE="Age";
24. publicfinalStringAGE_YOUNG="Young";
25. publicfinalStringAGE_MIDDLE_AGED="Middle_aged";
26. publicfinalStringAGE_Senior="Senior";
28. //测试数据地址
29. privateStringfilePath;
30. //最小支持度阈值率
31. privatedoubleminSupportRate;
32. //最小置信度阈值，用来判断是否能够成为关联规则
33. privatedoubleminConf;
34. //最小支持度
35. privateintminSupportCount;
36. //属性列名称
37. privateString[]attrNames;
38. //类别属性所代表的数字集合
39. privateArrayList<Integer>classTypes;
40. //用二维数组保存测试数据
41. privateArrayList<String[]>totalDatas;
42. //Apriori算法工具类
43. privateAprioriToolaprioriTool;
44. //属性到数字的映射图
45. privateHashMap<String,Integer>attr2Num;
46. privateHashMap<Integer,String>num2Attr;
48. publicCBATool(StringfilePath,doubleminSupportRate,doubleminConf){
49. this.filePath=filePath;
50. this.minConf=minConf;
51. this.minSupportRate=minSupportRate;
52. readDataFile();
53. }
55. /**
56. *从文件中读取数据
57. */
58. privatevoidreadDataFile(){
59. Filefile=newFile(filePath);
60. ArrayList<String[]>dataArray=newArrayList<String[]>();
62. try{
63. BufferedReaderin=newBufferedReader(newFileReader(file));
64. Stringstr;
65. String[]tempArray;
66. while((str=in.readLine())!=null){
67. tempArray=str.split("");
68. dataArray.add(tempArray);
69. }
70. in.close();
71. }catch(IOExceptione){
72. e.getStackTrace();
73. }
75. totalDatas=newArrayList<>();
76. for(String[]array:dataArray){
77. totalDatas.add(array);
78. }
79. attrNames=totalDatas.get(0);
80. minSupportCount=(int)(minSupportRate*totalDatas.size());
82. attributeReplace();
83. }
85. /**
86. *属性值的替换，替换成数字的形式，以便进行频繁项的挖掘
87. */
88. privatevoidattributeReplace(){
89. intcurrentValue=1;
90. intnum=0;
91. Strings;
92. //属性名到数字的映射图
93. attr2Num=newHashMap<>();
94. num2Attr=newHashMap<>();
95. classTypes=newArrayList<>();
97. //按照1列列的方式来，从左往右边扫描,跳过列名称行和id列
98. for(intj=1;j<attrNames.length;j++){
99. for(inti=1;i<totalDatas.size();i++){
100. s=totalDatas.get(i)[j];
101. //如果是数字形式的，这里只做年龄类别转换，其他的数字情况类似
102. if(attrNames[j].equals(AGE)){
103. num=Integer.parseInt(s);
104. if(num<=20&&num>0){
105. totalDatas.get(i)[j]=AGE_YOUNG;
106. }elseif(num>20&&num<=40){
107. totalDatas.get(i)[j]=AGE_MIDDLE_AGED;
108. }elseif(num>40){
109. totalDatas.get(i)[j]=AGE_Senior;
110. }
111. }
113. if(!attr2Num.containsKey(totalDatas.get(i)[j])){
114. attr2Num.put(totalDatas.get(i)[j],currentValue);
115. num2Attr.put(currentValue,totalDatas.get(i)[j]);
116. if(j==attrNames.length-1){
117. //如果是组后一列，说明是分类类别列，记录下来
118. classTypes.add(currentValue);
119. }
121. currentValue++;
122. }
123. }
124. }
126. //对原始的数据作属性替换，每条记录变为类似于事务数据的形式
127. for(inti=1;i<totalDatas.size();i++){
128. for(intj=1;j<attrNames.length;j++){
129. s=totalDatas.get(i)[j];
130. if(attr2Num.containsKey(s)){
131. totalDatas.get(i)[j]=attr2Num.get(s)+"";
132. }
133. }
134. }
135. }
137. /**
138. *Apriori计算全部频繁项集
139. *@return
140. */
141. privateArrayList<FrequentItem>aprioriCalculate(){
142. String[]tempArray;
143. ArrayList<FrequentItem>totalFrequentItems;
144. ArrayList<String[]>copyData=(ArrayList<String[]>)totalDatas.clone();
146. //去除属性名称行
147. copyData.remove(0);
148. //去除首列ID
149. for(inti=0;i<copyData.size();i++){
150. String[]array=copyData.get(i);
151. tempArray=newString[array.length-1];
152. System.arraycopy(array,1,tempArray,0,tempArray.length);
153. copyData.set(i,tempArray);
154. }
155. aprioriTool=newAprioriTool(copyData,minSupportCount);
156. aprioriTool.computeLink();
157. totalFrequentItems=aprioriTool.getTotalFrequentItems();
159. returntotalFrequentItems;
160. }
162. /**
163. *基于关联规则的分类
164. *
165. *@paramattrValues
166. *预先知道的一些属性
167. *@return
168. */
169. publicStringCBAJudge(StringattrValues){
170. intvalue=0;
171. //最终分类类别
172. StringclassType=null;
173. String[]tempArray;
174. //已知的属性值
175. ArrayList<String>attrValueList=newArrayList<>();
176. ArrayList<FrequentItem>totalFrequentItems;
178. totalFrequentItems=aprioriCalculate();
179. //将查询条件进行逐一属性的分割
180. String[]array=attrValues.split(",");
181. for(Stringrecord:array){
182. tempArray=record.split("=");
183. value=attr2Num.get(tempArray[1]);
184. attrValueList.add(value+"");
185. }
187. //在频繁项集中寻找符合条件的项
188. for(FrequentItemitem:totalFrequentItems){
189. //过滤掉不满足个数频繁项
190. if(item.getIdArray().length<(attrValueList.size()+1)){
191. continue;
192. }
194. //要保证查询的属性都包含在频繁项集中
195. if(itemIsSatisfied(item,attrValueList)){
196. tempArray=item.getIdArray();
197. classType=classificationBaseRules(tempArray);
199. if(classType!=null){
200. //作属性替换
201. classType=num2Attr.get(Integer.parseInt(classType));
202. break;
203. }
204. }
205. }
207. returnclassType;
208. }
210. /**
211. *基于关联规则进行分类
212. *
213. *@paramitems
214. *频繁项
215. *@return
216. */
217. privateStringclassificationBaseRules(String[]items){
218. StringclassType=null;
219. String[]arrayTemp;
220. intcount1=0;
221. intcount2=0;
222. //置信度
223. doubleconfidenceRate;
225. String[]noClassTypeItems=newString[items.length-1];
226. for(inti=0,k=0;i<items.length;i++){
227. if(!classTypes.contains(Integer.parseInt(items[i]))){
228. noClassTypeItems[k]=items[i];
229. k++;
230. }else{
231. classType=items[i];
232. }
233. }
235. for(String[]array:totalDatas){
236. //去除ID数字号
237. arrayTemp=newString[array.length-1];
238. System.arraycopy(array,1,arrayTemp,0,array.length-1);
239. if(isStrArrayContain(arrayTemp,noClassTypeItems)){
240. count1++;
242. if(isStrArrayContain(arrayTemp,items)){
243. count2++;
244. }
245. }
246. }
248. //做置信度的计算
249. confidenceRate=count1*1.0/count2;
250. if(confidenceRate>=minConf){
251. returnclassType;
252. }else{
253. //如果不满足最小置信度要求，则此关联规则无效
254. returnnull;
255. }
256. }
258. /**
259. *判断单个字符是否包含在字符数组中
260. *
261. *@paramarray
262. *字符数组
263. *@params
264. *判断的单字符
265. *@return
266. */
267. privatebooleanstrIsContained(String[]array,Strings){
268. booleanisContained=false;
270. for(Stringstr:array){
271. if(str.equals(s)){
272. isContained=true;
273. break;
274. }
275. }
277. returnisContained;
278. }
280. /**
281. *数组array2是否包含于array1中，不需要完全一样
282. *
283. *@paramarray1
284. *@paramarray2
285. *@return
286. */
287. privatebooleanisStrArrayContain(String[]array1,String[]array2){
288. booleanisContain=true;
289. for(Strings2:array2){
290. isContain=false;
291. for(Strings1:array1){
292. //只要s2字符存在于array1中，这个字符就算包含在array1中
293. if(s2.equals(s1)){
294. isContain=true;
295. break;
296. }
297. }
299. //一旦发现不包含的字符，则array2数组不包含于array1中
300. if(!isContain){
301. break;
302. }
303. }
305. returnisContain;
306. }
308. /**
309. *判断频繁项集是否满足查询
310. *
311. *@paramitem
312. *待判断的频繁项集
313. *@paramattrValues
314. *查询的属性值列表
315. *@return
316. */
317. privatebooleanitemIsSatisfied(FrequentItemitem,
318. ArrayList<String>attrValues){
319. booleanisContained=false;
320. String[]array=item.getIdArray();
322. for(Strings:attrValues){
323. isContained=true;
325. if(!strIsContained(array,s)){
326. isContained=false;
327. break;
328. }
330. if(!isContained){
331. break;
332. }
333. }
335. if(isContained){
336. isContained=false;
338. //还要验证是否频繁项集中是否包含分类属性
339. for(Integertype:classTypes){
340. if(strIsContained(array,type+"")){
341. isContained=true;
342. break;
343. }
344. }
345. }
347. returnisContained;
348. }
350. }

调用类Client.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.text.MessageFormat;
5. /**
6. *CBA算法--基于关联规则的分类算法
7. *@authorlyq
8. *
9. */
10. publicclassClient{
11. publicstaticvoidmain(String[]args){
12. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\input.txt";
13. StringattrDesc="Age=Senior,CreditRating=Fair";
14. Stringclassification=null;
16. //最小支持度阈值率
17. doubleminSupportRate=0.2;
18. //最小置信度阈值
19. doubleminConf=0.7;
21. CBATooltool=newCBATool(filePath,minSupportRate,minConf);
22. classification=tool.CBAJudge(attrDesc);
23. System.out.println(MessageFormat.format("{0}的关联分类结果为{1}",attrDesc,classification));
24. }
25. }

代码的结果为：

[java] view plain copy print ?

1. 频繁1项集：
2. {1,},{2,},{3,},{4,},{5,},{6,},{7,},{8,},{9,},{10,},{11,},{12,},
3. 频繁2项集：
4. {1,7,},{1,9,},{1,11,},{2,12,},{3,5,},{3,8,},{3,9,},{3,12,},{4,7,},{4,9,},{5,7,},{5,9,},{5,10,},{5,12,},{6,8,},{6,12,},{7,9,},{7,10,},{7,11,},{7,12,},{8,9,},{8,10,},{8,12,},{9,12,},{10,11,},{10,12,},
5. 频繁3项集：
6. {1,7,11,},{3,9,12,},{6,8,12,},{8,9,12,},
7. 频繁4项集：
9. 频繁5项集：
11. 频繁6项集：
13. 频繁7项集：
15. 频繁8项集：
17. 频繁9项集：
19. 频繁10项集：
21. 频繁11项集：
23. Age=Senior,CreditRating=Fair的关联分类结果为CLassYes

上面的有些项集为空说明没有此项集。Apriori算法类可以在 这里进行查阅，这里只展示了CBA算法的部分。

算法的分析

我在准备实现CBA算法的时候就预见到了这个算法就是对Apriori算法的一个包装，在于2点，输入数据的格式进行数字的转换，还有就是输出的时候做属性对数字的替换，核心还是在于Apriori算法的项集频繁挖掘。

程序实现时遇到的问题

在这期间遇到了一个bug就是频繁1项集在排序的时候出现了问题，后来发现原因是String.CompareTo()，原本应该是1，2，....11，12，用了前面这个方法后会变成1,10,2,。。就是10会比2小的情况，后来查了String.CompareTo()的比较规则，明白了他是一位位比较Ascall码值，因为10的1比2小，最后果断的改回了用Integer的比较方法了。这个问题别看是个小问题，1项集如果没有排好序，后面的连接操作可能会出现少情况的可能，这个之前吃过这样的亏了。

我对CBA算法的理解

CBA算法和巧妙的利用了关联规则进行类别的分类，有别与其他的分类算法。他的算法好坏又会依靠Apriori算法的执行好坏。

更多数据挖掘算法：https://github.com/linyiqun/DataMiningAlgorithm

介绍

CBA算法全称是Classification base of Association，就是基于关联规则进行分类的算法，说到关联规则，我们就会想到Apriori和FP-Tree算法都是关联规则挖掘算法，而CBA算法正是利用了Apriori挖掘出的关联规则，然后做分类判断，所以在某种程度上说，CBA算法也可以说是一种集成挖掘算法。

算法原理

CBA算法作为分类算法，他的分类情况也就是给定一些预先知道的属性，然后叫你判断出他的决策属性是哪个值。判断的依据就是Apriori算法挖掘出的频繁项，如果一个项集中包含预先知道的属性，同时也包含分类属性值，然后我们计算此频繁项能否导出已知属性值推出决策属性值的关联规则，如果满足规则的最小置信度的要求，那么可以把频繁项中的决策属性值作为最后的分类结果。具体的算法细节如下：

1、输入数据记录，就是一条条的属性值。

2、对属性值做数字的替换(按照列从上往下寻找属性值)，就类似于Apriori中的一条条事务记录。

3、根据这个转化后的事务记录，进行Apriori算法计算，挖掘出频繁项集。

4、输入查询的属性值，找出符合条件的频繁项集(需要包含查询属性和分类决策属性)，如果能够推导出这样的关联规则，就算分类成功，输出分类结果。

这里以之前我做的CART算法的测试数据为CBA算法的测试数据，如下：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 113HighNoFairCLassNo
3. 211HighNoExcellentCLassNo
4. 325HighNoFairCLassYes
5. 445MediumNoFairCLassYes
6. 550LowYesFairCLassYes
7. 651LowYesExcellentCLassNo
8. 730LowYesExcellentCLassYes
9. 813MediumNoFairCLassNo
10. 99LowYesFairCLassYes
11. 1055MediumYesFairCLassYes
12. 1114MediumYesExcellentCLassYes
13. 1233MediumNoExcellentCLassYes
14. 1333HighYesFairCLassYes
15. 1441MediumNoExcellentCLassNo

属性值对应的数字替换图：

[java] view plain copy print ?

1. Medium=5,CLassYes=12,Excellent=10,Low=6,Fair=9,CLassNo=11,Young=1,Middle_aged=2,Yes=8,No=7,High=4,Senior=3

体会之后的数据变为了下面的事务项：

[java] view plain copy print ?

1. RidAgeIncomeStudentCreditRatingBuysComputer
2. 1147911
3. 21471011
4. 3247912
5. 4357912
6. 5368912
7. 63681011
8. 72681012
9. 8157911
10. 9168912
11. 10358912
12. 111581012
13. 122571012
14. 13248912
15. 143571011

把每条记录看出事务项，就和Apriori算法的输入格式基本一样了，后面就是进行连接运算和剪枝步骤等Apriori算法的步骤了，在这里就不详细描述了，Apriori算法的实现可以 点击这里进行了解。

算法的代码实现

测试数据就是上面的内容。

CBATool.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.IOException;
7. importjava.util.ArrayList;
8. importjava.util.HashMap;
9. importjava.util.regex.Matcher;
10. importjava.util.regex.Pattern;
12. importDataMining_CBA.AprioriTool.AprioriTool;
13. importDataMining_CBA.AprioriTool.FrequentItem;
15. /**
16. *CBA算法(关联规则分类)工具类
17. *
18. *@authorlyq
19. *
20. */
21. publicclassCBATool{
22. //年龄的类别划分
23. publicfinalStringAGE="Age";
24. publicfinalStringAGE_YOUNG="Young";
25. publicfinalStringAGE_MIDDLE_AGED="Middle_aged";
26. publicfinalStringAGE_Senior="Senior";
28. //测试数据地址
29. privateStringfilePath;
30. //最小支持度阈值率
31. privatedoubleminSupportRate;
32. //最小置信度阈值，用来判断是否能够成为关联规则
33. privatedoubleminConf;
34. //最小支持度
35. privateintminSupportCount;
36. //属性列名称
37. privateString[]attrNames;
38. //类别属性所代表的数字集合
39. privateArrayList<Integer>classTypes;
40. //用二维数组保存测试数据
41. privateArrayList<String[]>totalDatas;
42. //Apriori算法工具类
43. privateAprioriToolaprioriTool;
44. //属性到数字的映射图
45. privateHashMap<String,Integer>attr2Num;
46. privateHashMap<Integer,String>num2Attr;
48. publicCBATool(StringfilePath,doubleminSupportRate,doubleminConf){
49. this.filePath=filePath;
50. this.minConf=minConf;
51. this.minSupportRate=minSupportRate;
52. readDataFile();
53. }
55. /**
56. *从文件中读取数据
57. */
58. privatevoidreadDataFile(){
59. Filefile=newFile(filePath);
60. ArrayList<String[]>dataArray=newArrayList<String[]>();
62. try{
63. BufferedReaderin=newBufferedReader(newFileReader(file));
64. Stringstr;
65. String[]tempArray;
66. while((str=in.readLine())!=null){
67. tempArray=str.split("");
68. dataArray.add(tempArray);
69. }
70. in.close();
71. }catch(IOExceptione){
72. e.getStackTrace();
73. }
75. totalDatas=newArrayList<>();
76. for(String[]array:dataArray){
77. totalDatas.add(array);
78. }
79. attrNames=totalDatas.get(0);
80. minSupportCount=(int)(minSupportRate*totalDatas.size());
82. attributeReplace();
83. }
85. /**
86. *属性值的替换，替换成数字的形式，以便进行频繁项的挖掘
87. */
88. privatevoidattributeReplace(){
89. intcurrentValue=1;
90. intnum=0;
91. Strings;
92. //属性名到数字的映射图
93. attr2Num=newHashMap<>();
94. num2Attr=newHashMap<>();
95. classTypes=newArrayList<>();
97. //按照1列列的方式来，从左往右边扫描,跳过列名称行和id列
98. for(intj=1;j<attrNames.length;j++){
99. for(inti=1;i<totalDatas.size();i++){
100. s=totalDatas.get(i)[j];
101. //如果是数字形式的，这里只做年龄类别转换，其他的数字情况类似
102. if(attrNames[j].equals(AGE)){
103. num=Integer.parseInt(s);
104. if(num<=20&&num>0){
105. totalDatas.get(i)[j]=AGE_YOUNG;
106. }elseif(num>20&&num<=40){
107. totalDatas.get(i)[j]=AGE_MIDDLE_AGED;
108. }elseif(num>40){
109. totalDatas.get(i)[j]=AGE_Senior;
110. }
111. }
113. if(!attr2Num.containsKey(totalDatas.get(i)[j])){
114. attr2Num.put(totalDatas.get(i)[j],currentValue);
115. num2Attr.put(currentValue,totalDatas.get(i)[j]);
116. if(j==attrNames.length-1){
117. //如果是组后一列，说明是分类类别列，记录下来
118. classTypes.add(currentValue);
119. }
121. currentValue++;
122. }
123. }
124. }
126. //对原始的数据作属性替换，每条记录变为类似于事务数据的形式
127. for(inti=1;i<totalDatas.size();i++){
128. for(intj=1;j<attrNames.length;j++){
129. s=totalDatas.get(i)[j];
130. if(attr2Num.containsKey(s)){
131. totalDatas.get(i)[j]=attr2Num.get(s)+"";
132. }
133. }
134. }
135. }
137. /**
138. *Apriori计算全部频繁项集
139. *@return
140. */
141. privateArrayList<FrequentItem>aprioriCalculate(){
142. String[]tempArray;
143. ArrayList<FrequentItem>totalFrequentItems;
144. ArrayList<String[]>copyData=(ArrayList<String[]>)totalDatas.clone();
146. //去除属性名称行
147. copyData.remove(0);
148. //去除首列ID
149. for(inti=0;i<copyData.size();i++){
150. String[]array=copyData.get(i);
151. tempArray=newString[array.length-1];
152. System.arraycopy(array,1,tempArray,0,tempArray.length);
153. copyData.set(i,tempArray);
154. }
155. aprioriTool=newAprioriTool(copyData,minSupportCount);
156. aprioriTool.computeLink();
157. totalFrequentItems=aprioriTool.getTotalFrequentItems();
159. returntotalFrequentItems;
160. }
162. /**
163. *基于关联规则的分类
164. *
165. *@paramattrValues
166. *预先知道的一些属性
167. *@return
168. */
169. publicStringCBAJudge(StringattrValues){
170. intvalue=0;
171. //最终分类类别
172. StringclassType=null;
173. String[]tempArray;
174. //已知的属性值
175. ArrayList<String>attrValueList=newArrayList<>();
176. ArrayList<FrequentItem>totalFrequentItems;
178. totalFrequentItems=aprioriCalculate();
179. //将查询条件进行逐一属性的分割
180. String[]array=attrValues.split(",");
181. for(Stringrecord:array){
182. tempArray=record.split("=");
183. value=attr2Num.get(tempArray[1]);
184. attrValueList.add(value+"");
185. }
187. //在频繁项集中寻找符合条件的项
188. for(FrequentItemitem:totalFrequentItems){
189. //过滤掉不满足个数频繁项
190. if(item.getIdArray().length<(attrValueList.size()+1)){
191. continue;
192. }
194. //要保证查询的属性都包含在频繁项集中
195. if(itemIsSatisfied(item,attrValueList)){
196. tempArray=item.getIdArray();
197. classType=classificationBaseRules(tempArray);
199. if(classType!=null){
200. //作属性替换
201. classType=num2Attr.get(Integer.parseInt(classType));
202. break;
203. }
204. }
205. }
207. returnclassType;
208. }
210. /**
211. *基于关联规则进行分类
212. *
213. *@paramitems
214. *频繁项
215. *@return
216. */
217. privateStringclassificationBaseRules(String[]items){
218. StringclassType=null;
219. String[]arrayTemp;
220. intcount1=0;
221. intcount2=0;
222. //置信度
223. doubleconfidenceRate;
225. String[]noClassTypeItems=newString[items.length-1];
226. for(inti=0,k=0;i<items.length;i++){
227. if(!classTypes.contains(Integer.parseInt(items[i]))){
228. noClassTypeItems[k]=items[i];
229. k++;
230. }else{
231. classType=items[i];
232. }
233. }
235. for(String[]array:totalDatas){
236. //去除ID数字号
237. arrayTemp=newString[array.length-1];
238. System.arraycopy(array,1,arrayTemp,0,array.length-1);
239. if(isStrArrayContain(arrayTemp,noClassTypeItems)){
240. count1++;
242. if(isStrArrayContain(arrayTemp,items)){
243. count2++;
244. }
245. }
246. }
248. //做置信度的计算
249. confidenceRate=count1*1.0/count2;
250. if(confidenceRate>=minConf){
251. returnclassType;
252. }else{
253. //如果不满足最小置信度要求，则此关联规则无效
254. returnnull;
255. }
256. }
258. /**
259. *判断单个字符是否包含在字符数组中
260. *
261. *@paramarray
262. *字符数组
263. *@params
264. *判断的单字符
265. *@return
266. */
267. privatebooleanstrIsContained(String[]array,Strings){
268. booleanisContained=false;
270. for(Stringstr:array){
271. if(str.equals(s)){
272. isContained=true;
273. break;
274. }
275. }
277. returnisContained;
278. }
280. /**
281. *数组array2是否包含于array1中，不需要完全一样
282. *
283. *@paramarray1
284. *@paramarray2
285. *@return
286. */
287. privatebooleanisStrArrayContain(String[]array1,String[]array2){
288. booleanisContain=true;
289. for(Strings2:array2){
290. isContain=false;
291. for(Strings1:array1){
292. //只要s2字符存在于array1中，这个字符就算包含在array1中
293. if(s2.equals(s1)){
294. isContain=true;
295. break;
296. }
297. }
299. //一旦发现不包含的字符，则array2数组不包含于array1中
300. if(!isContain){
301. break;
302. }
303. }
305. returnisContain;
306. }
308. /**
309. *判断频繁项集是否满足查询
310. *
311. *@paramitem
312. *待判断的频繁项集
313. *@paramattrValues
314. *查询的属性值列表
315. *@return
316. */
317. privatebooleanitemIsSatisfied(FrequentItemitem,
318. ArrayList<String>attrValues){
319. booleanisContained=false;
320. String[]array=item.getIdArray();
322. for(Strings:attrValues){
323. isContained=true;
325. if(!strIsContained(array,s)){
326. isContained=false;
327. break;
328. }
330. if(!isContained){
331. break;
332. }
333. }
335. if(isContained){
336. isContained=false;
338. //还要验证是否频繁项集中是否包含分类属性
339. for(Integertype:classTypes){
340. if(strIsContained(array,type+"")){
341. isContained=true;
342. break;
343. }
344. }
345. }
347. returnisContained;
348. }
350. }

调用类Client.java:

[java] view plain copy print ?

1. packageDataMining_CBA;
3. importjava.text.MessageFormat;
5. /**
6. *CBA算法--基于关联规则的分类算法
7. *@authorlyq
8. *
9. */
10. publicclassClient{
11. publicstaticvoidmain(String[]args){
12. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\input.txt";
13. StringattrDesc="Age=Senior,CreditRating=Fair";
14. Stringclassification=null;
16. //最小支持度阈值率
17. doubleminSupportRate=0.2;
18. //最小置信度阈值
19. doubleminConf=0.7;
21. CBATooltool=newCBATool(filePath,minSupportRate,minConf);
22. classification=tool.CBAJudge(attrDesc);
23. System.out.println(MessageFormat.format("{0}的关联分类结果为{1}",attrDesc,classification));
24. }
25. }

代码的结果为：

[java] view plain copy print ?

1. 频繁1项集：
2. {1,},{2,},{3,},{4,},{5,},{6,},{7,},{8,},{9,},{10,},{11,},{12,},
3. 频繁2项集：
4. {1,7,},{1,9,},{1,11,},{2,12,},{3,5,},{3,8,},{3,9,},{3,12,},{4,7,},{4,9,},{5,7,},{5,9,},{5,10,},{5,12,},{6,8,},{6,12,},{7,9,},{7,10,},{7,11,},{7,12,},{8,9,},{8,10,},{8,12,},{9,12,},{10,11,},{10,12,},
5. 频繁3项集：
6. {1,7,11,},{3,9,12,},{6,8,12,},{8,9,12,},
7. 频繁4项集：
9. 频繁5项集：
11. 频繁6项集：
13. 频繁7项集：
15. 频繁8项集：
17. 频繁9项集：
19. 频繁10项集：
21. 频繁11项集：
23. Age=Senior,CreditRating=Fair的关联分类结果为CLassYes

上面的有些项集为空说明没有此项集。Apriori算法类可以在 这里进行查阅，这里只展示了CBA算法的部分。

算法的分析

我在准备实现CBA算法的时候就预见到了这个算法就是对Apriori算法的一个包装，在于2点，输入数据的格式进行数字的转换，还有就是输出的时候做属性对数字的替换，核心还是在于Apriori算法的项集频繁挖掘。

程序实现时遇到的问题

在这期间遇到了一个bug就是频繁1项集在排序的时候出现了问题，后来发现原因是String.CompareTo()，原本应该是1，2，....11，12，用了前面这个方法后会变成1,10,2,。。就是10会比2小的情况，后来查了String.CompareTo()的比较规则，明白了他是一位位比较Ascall码值，因为10的1比2小，最后果断的改回了用Integer的比较方法了。这个问题别看是个小问题，1项集如果没有排好序，后面的连接操作可能会出现少情况的可能，这个之前吃过这样的亏了。

我对CBA算法的理解

CBA算法和巧妙的利用了关联规则进行类别的分类，有别与其他的分类算法。他的算法好坏又会依靠Apriori算法的执行好坏。