AdaBoost装袋提升算法

参开资料：http://blog.csdn.net/haidao2009/article/details/7514787
更多挖掘算法：https://github.com/linyiqun/DataMiningAlgorithm

介绍

在介绍AdaBoost算法之前，需要了解一个类似的算法，装袋算法(bagging)，bagging是一种提高分类准确率的算法，通过给定组合投票的方式，获得最优解。比如你生病了，去n个医院看了n个医生，每个医生给你开了药方，最后的结果中，哪个药方的出现的次数多，那就说明这个药方就越有可能性是最由解，这个很好理解。而bagging算法就是这个思想。

算法原理

而AdaBoost算法的核心思想还是基于bagging算法，但是他又一点点的改进，上面的每个医生的投票结果都是一样的，说明地位平等，如果在这里加上一个权重，大城市的医生权重高点，小县城的医生权重低，这样通过最终计算权重和的方式，会更加的合理，这就是AdaBoost算法。AdaBoost算法是一种迭代算法，只有最终分类误差率小于阈值算法才能停止，针对同一训练集数据训练不同的分类器，我们称弱分类器，最后按照权重和的形式组合起来，构成一个组合分类器，就是一个强分类器了。算法的只要过程：

1、对D训练集数据训练处一个分类器Ci

2、通过分类器Ci对数据进行分类，计算此时误差率

3、把上步骤中的分错的数据的权重提高，分对的权重降低，以此凸显了分错的数据。为什么这么做呢，后面会做出解释。

完整的adaboost算法如下

最后的sign函数是符号函数，如果最后的值为正，则分为+1类，否则即使-1类。

我们举个例子代入上面的过程，这样能够更好的理解。

adaboost的实现过程：

　　图中，“+”和“-”分别表示两种类别，在这个过程中，我们使用水平或者垂直的直线作为分类器，来进行分类。

　　第一步：

　　根据分类的正确率，得到一个新的样本分布D_2­，一个子分类器h₁

　　其中划圈的样本表示被分错的。在右边的途中，比较大的“+”表示对该样本做了加权。

算法最开始给了一个均匀分布 D 。所以h1 里的每个点的值是0.1。ok，当划分后，有三个点划分错了，根据算法误差表达式得到 误差为分错了的三个点的值之和，所以ɛ1=(0.1+0.1+0.1)=0.3，而ɑ1 根据表达式的可以算出来为0.42. 然后就根据算法 把分错的点权值变大。如此迭代，最终完成adaboost算法。

　　第二步：

　　根据分类的正确率，得到一个新的样本分布D₃，一个子分类器h₂

　　第三步：

　　得到一个子分类器h₃

　　整合所有子分类器：

　　因此可以得到整合的结果，从结果中看，及时简单的分类器，组合起来也能获得很好的分类效果，在例子中所有的。后面的代码实现时，举出的也是这个例子，可以做对比，这里有一点比较重要，就是点的权重经过大小变化之后，需要进行归一化，确保总和为1.0,这个容易遗忘。

算法的代码实现

输入测试数据，与上图的例子相对应(数据格式：x坐标 y坐标 已分类结果)：

[java] view plain copy print ?

1. 151
2. 231
3. 31-1
4. 45-1
5. 561
6. 64-1
7. 671
8. 761
9. 87-1
10. 82-1

Point.java

[java] view plain copy print ?

1. packageDataMining_AdaBoost;
3. /**
4. *坐标点类
5. *
6. *@authorlyq
7. *
8. */
9. publicclassPoint{
10. //坐标点x坐标
11. privateintx;
12. //坐标点y坐标
13. privateinty;
14. //坐标点的分类类别
15. privateintclassType;
16. //如果此节点被划错，他的误差率，不能用个数除以总数，因为不同坐标点的权重不一定相等
17. privatedoubleprobably;
19. publicPoint(intx,inty,intclassType){
20. this.x=x;
21. this.y=y;
22. this.classType=classType;
23. }
25. publicPoint(Stringx,Stringy,StringclassType){
26. this.x=Integer.parseInt(x);
27. this.y=Integer.parseInt(y);
28. this.classType=Integer.parseInt(classType);
29. }
31. publicintgetX(){
32. returnx;
33. }
35. publicvoidsetX(intx){
36. this.x=x;
37. }
39. publicintgetY(){
40. returny;
41. }
43. publicvoidsetY(inty){
44. this.y=y;
45. }
47. publicintgetClassType(){
48. returnclassType;
49. }
51. publicvoidsetClassType(intclassType){
52. this.classType=classType;
53. }
55. publicdoublegetProbably(){
56. returnprobably;
57. }
59. publicvoidsetProbably(doubleprobably){
60. this.probably=probably;
61. }
62. }

AdaBoost.java

[java] view plain copy print ?

1. packageDataMining_AdaBoost;
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.HashMap;
10. importjava.util.Map;
12. /**
13. *AdaBoost提升算法工具类
14. *
15. *@authorlyq
16. *
17. */
18. publicclassAdaBoostTool{
19. //分类的类别，程序默认为正类1和负类-1
20. publicstaticfinalintCLASS_POSITIVE=1;
21. publicstaticfinalintCLASS_NEGTIVE=-1;
23. //事先假设的3个分类器(理论上应该重新对数据集进行训练得到)
24. publicstaticfinalStringCLASSIFICATION1="X=2.5";
25. publicstaticfinalStringCLASSIFICATION2="X=7.5";
26. publicstaticfinalStringCLASSIFICATION3="Y=5.5";
28. //分类器组
29. publicstaticfinalString[]ClASSIFICATION=newString[]{
30. CLASSIFICATION1,CLASSIFICATION2,CLASSIFICATION3};
31. //分类权重组
32. privatedouble[]CLASSIFICATION_WEIGHT;
34. //测试数据文件地址
35. privateStringfilePath;
36. //误差率阈值
37. privatedoubleerrorValue;
38. //所有的数据点
39. privateArrayList<Point>totalPoint;
41. publicAdaBoostTool(StringfilePath,doubleerrorValue){
42. this.filePath=filePath;
43. this.errorValue=errorValue;
44. readDataFile();
45. }
47. /**
48. *从文件中读取数据
49. */
50. privatevoidreadDataFile(){
51. Filefile=newFile(filePath);
52. ArrayList<String[]>dataArray=newArrayList<String[]>();
54. try{
55. BufferedReaderin=newBufferedReader(newFileReader(file));
56. Stringstr;
57. String[]tempArray;
58. while((str=in.readLine())!=null){
59. tempArray=str.split("");
60. dataArray.add(tempArray);
61. }
62. in.close();
63. }catch(IOExceptione){
64. e.getStackTrace();
65. }
67. Pointtemp;
68. totalPoint=newArrayList<>();
69. for(String[]array:dataArray){
70. temp=newPoint(array[0],array[1],array[2]);
71. temp.setProbably(1.0/dataArray.size());
72. totalPoint.add(temp);
73. }
74. }
76. /**
77. *根据当前的误差值算出所得的权重
78. *
79. *@paramerrorValue
80. *当前划分的坐标点误差率
81. *@return
82. */
83. privatedoublecalculateWeight(doubleerrorValue){
84. doublealpha=0;
85. doubletemp=0;
87. temp=(1-errorValue)/errorValue;
88. alpha=0.5*Math.log(temp);
90. returnalpha;
91. }
93. /**
94. *计算当前划分的误差率
95. *
96. *@parampointMap
97. *划分之后的点集
98. *@paramweight
99. *本次划分得到的分类器权重
100. *@return
101. */
102. privatedoublecalculateErrorValue(
103. HashMap<Integer,ArrayList<Point>>pointMap){
104. doubleresultValue=0;
105. doubletemp=0;
106. doubleweight=0;
107. inttempClassType;
108. ArrayList<Point>pList;
109. for(Map.Entryentry:pointMap.entrySet()){
110. tempClassType=(int)entry.getKey();
112. pList=(ArrayList<Point>)entry.getValue();
113. for(Pointp:pList){
114. temp=p.getProbably();
115. //如果划分类型不相等，代表划错了
116. if(tempClassType!=p.getClassType()){
117. resultValue+=temp;
118. }
119. }
120. }
122. weight=calculateWeight(resultValue);
123. for(Map.Entryentry:pointMap.entrySet()){
124. tempClassType=(int)entry.getKey();
126. pList=(ArrayList<Point>)entry.getValue();
127. for(Pointp:pList){
128. temp=p.getProbably();
129. //如果划分类型不相等，代表划错了
130. if(tempClassType!=p.getClassType()){
131. //划错的点的权重比例变大
132. temp*=Math.exp(weight);
133. p.setProbably(temp);
134. }else{
135. //划对的点的权重比减小
136. temp*=Math.exp(-weight);
137. p.setProbably(temp);
138. }
139. }
140. }
142. //如果误差率没有小于阈值，继续处理
143. dataNormalized();
145. returnresultValue;
146. }
148. /**
149. *概率做归一化处理
150. */
151. privatevoiddataNormalized(){
152. doublesumProbably=0;
153. doubletemp=0;
155. for(Pointp:totalPoint){
156. sumProbably+=p.getProbably();
157. }
159. //归一化处理
160. for(Pointp:totalPoint){
161. temp=p.getProbably();
162. p.setProbably(temp/sumProbably);
163. }
164. }
166. /**
167. *用AdaBoost算法得到的组合分类器对数据进行分类
168. *
169. */
170. publicvoidadaBoostClassify(){
171. doublevalue=0;
172. Pointp;
174. calculateWeightArray();
175. for(inti=0;i<ClASSIFICATION.length;i++){
176. System.out.println(MessageFormat.format("分类器{0}权重为：{1}",(i+1),CLASSIFICATION_WEIGHT[i]));
177. }
179. for(intj=0;j<totalPoint.size();j++){
180. p=totalPoint.get(j);
181. value=0;
183. for(inti=0;i<ClASSIFICATION.length;i++){
184. value+=1.0*classifyData(ClASSIFICATION[i],p)
185. *CLASSIFICATION_WEIGHT[i];
186. }
188. //进行符号判断
189. if(value>0){
190. System.out
191. .println(MessageFormat.format(
192. "点({0},{1})的组合分类结果为：1，该点的实际分类为{2}",p.getX(),p.getY(),
193. p.getClassType()));
194. }else{
195. System.out.println(MessageFormat.format(
196. "点({0},{1})的组合分类结果为：-1，该点的实际分类为{2}",p.getX(),p.getY(),
197. p.getClassType()));
198. }
199. }
200. }
202. /**
203. *计算分类器权重数组
204. */
205. privatevoidcalculateWeightArray(){
206. inttempClassType=0;
207. doubleerrorValue=0;
208. ArrayList<Point>posPointList;
209. ArrayList<Point>negPointList;
210. HashMap<Integer,ArrayList<Point>>mapList;
211. CLASSIFICATION_WEIGHT=newdouble[ClASSIFICATION.length];
213. for(inti=0;i<CLASSIFICATION_WEIGHT.length;i++){
214. mapList=newHashMap<>();
215. posPointList=newArrayList<>();
216. negPointList=newArrayList<>();
218. for(Pointp:totalPoint){
219. tempClassType=classifyData(ClASSIFICATION[i],p);
221. if(tempClassType==CLASS_POSITIVE){
222. posPointList.add(p);
223. }else{
224. negPointList.add(p);
225. }
226. }
228. mapList.put(CLASS_POSITIVE,posPointList);
229. mapList.put(CLASS_NEGTIVE,negPointList);
231. if(i==0){
232. //最开始的各个点的权重一样，所以传入0，使得e的0次方等于1
233. errorValue=calculateErrorValue(mapList);
234. }else{
235. //每次把上次计算所得的权重代入，进行概率的扩大或缩小
236. errorValue=calculateErrorValue(mapList);
237. }
239. //计算当前分类器的所得权重
240. CLASSIFICATION_WEIGHT[i]=calculateWeight(errorValue);
241. }
242. }
244. /**
245. *用各个子分类器进行分类
246. *
247. *@paramclassification
248. *分类器名称
249. *@paramp
250. *待划分坐标点
251. *@return
252. */
253. privateintclassifyData(Stringclassification,Pointp){
254. //分割线所属坐标轴
255. Stringposition;
256. //分割线的值
257. doublevalue=0;
258. doubleposProbably=0;
259. doublenegProbably=0;
260. //划分是否是大于一边的划分
261. booleanisLarger=false;
262. String[]array;
263. ArrayList<Point>pList=newArrayList<>();
265. array=classification.split("=");
266. position=array[0];
267. value=Double.parseDouble(array[1]);
269. if(position.equals("X")){
270. if(p.getX()>value){
271. isLarger=true;
272. }
274. //将训练数据中所有属于这边的点加入
275. for(Pointpoint:totalPoint){
276. if(isLarger&&point.getX()>value){
277. pList.add(point);
278. }elseif(!isLarger&&point.getX()<value){
279. pList.add(point);
280. }
281. }
282. }elseif(position.equals("Y")){
283. if(p.getY()>value){
284. isLarger=true;
285. }
287. //将训练数据中所有属于这边的点加入
288. for(Pointpoint:totalPoint){
289. if(isLarger&&point.getY()>value){
290. pList.add(point);
291. }elseif(!isLarger&&point.getY()<value){
292. pList.add(point);
293. }
294. }
295. }
297. for(Pointp2:pList){
298. if(p2.getClassType()==CLASS_POSITIVE){
299. posProbably++;
300. }else{
301. negProbably++;
302. }
303. }
305. //分类按正负类数量进行划分
306. if(posProbably>negProbably){
307. returnCLASS_POSITIVE;
308. }else{
309. returnCLASS_NEGTIVE;
310. }
311. }
313. }

调用类Client.java：

[java] view plain copy print ?

1. /**
2. *AdaBoost提升算法调用类
3. *@authorlyq
4. *
5. */
6. publicclassClient{
7. publicstaticvoidmain(String[]agrs){
8. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\input.txt";
9. //误差率阈值
10. doubleerrorValue=0.2;
12. AdaBoostTooltool=newAdaBoostTool(filePath,errorValue);
13. tool.adaBoostClassify();
14. }
15. }

输出结果：

[java] view plain copy print ?

1. 分类器1权重为：0.424
2. 分类器2权重为：0.65
3. 分类器3权重为：0.923
4. 点(1,5)的组合分类结果为：1，该点的实际分类为1
5. 点(2,3)的组合分类结果为：1，该点的实际分类为1
6. 点(3,1)的组合分类结果为：-1，该点的实际分类为-1
7. 点(4,5)的组合分类结果为：-1，该点的实际分类为-1
8. 点(5,6)的组合分类结果为：1，该点的实际分类为1
9. 点(6,4)的组合分类结果为：-1，该点的实际分类为-1
10. 点(6,7)的组合分类结果为：1，该点的实际分类为1
11. 点(7,6)的组合分类结果为：1，该点的实际分类为1
12. 点(8,7)的组合分类结果为：-1，该点的实际分类为-1
13. 点(8,2)的组合分类结果为：-1，该点的实际分类为-1

我们可以看到，如果3个分类单独分类，都没有百分百分对，而尽管组合结果之后，全部分类正确。

我对AdaBoost算法的理解

到了算法的末尾，有必要解释一下每次分类自后需要把错的点的权重增大，正确的减少的理由了，加入上次分类之后，(1,5)已经分错了，如果这次又分错，由于上次的权重已经提升，所以误差率更大，则代入公式ln(1-误差率/误差率)所得的权重越小，也就是说，如果同个数据，你分类的次数越多，你的权重越小，所以这就造成整体好的分类器的权重会越大，内部就会同时有各种权重的分类器，形成了一种互补的结果，如果好的分类器结果分错 ，可以由若干弱一点的分类器进行弥补。

AdaBoost算法的应用

可以运用在诸如特征识别，二分类的一些应用上，与单个模型相比，组合的形式能显著的提高准确率。