AdaBoost的java實現

目前學了幾個ML的分類的經典算法，但是一直想着是否有一種能將這些算法集成起來的，今天看到了AdaBoost，也算是半個集成，感覺這個思路挺好，很像人的訓練過程，並且對決策樹是一個很好的補充，因為決策樹容易過擬合，用AdaBoost可以讓一棵很深的決策樹將其分開成多棵矮樹，后來發現原來這個想法和random forest比較相似，RF的代碼等下周有空的時候可以寫一下。

這個貌似挺厲害的，看那些專門搞學術的人說是一篇很牛逼的論文證明說可以把弱學習提升到強學習。我這種搞工程的，能知道他的原理，適用范圍，能自己寫一遍代碼，感覺還是比那些讀幾遍論文只能惶惶其談的要安心些。

關於AdaBoost的基本概念，通過《機器學習方法》來概要的說下。

bagging和boosting的區別

bagging：是指在原始數據上通過放回抽樣，抽出和原始數據大小相等的新數據集（這個性質說明新數據集存在重復的值，而原始數據部分數據值不會出現在新數據集中），並重復該過程選擇N個新數據集，這樣通過N個分類器對這個N個數據集進行分類，最后選擇分類器投票結果中最多類別作為最后的分類結果。

boosting：相比bagging，boosting像是一種串行，bagging是一種並行的，bagging可以對於N個數據集通過N個分類器同時進行分類，並且每個分類器的權重是一樣的，但是boosting則相反，boosting是利用一個數據集依次由每個分類器進行分類，而確定每個分類器的權重是加大正確率高的分類器的權重，減少正確率低的分類器的權重。同時為了提高准確率，每次會降低被正確分類的樣本的權重，提高沒有正確分類的樣本的權重。這樣做其實比較符合人的決策過程，就是要多訓練自己容易做錯的題型，並且要多聽取正確性高的老師的意見。

 

那么AdaBoost的主要的兩個過程就是提高錯誤分類的樣本權重和提高正確率高的分類器的權重。

算法的步驟：

輸入：訓練集T，弱學習分類器（這里是一個節點的決策樹）

輸出：最終的分類器G

1 先初始化樣本權重值，D1=｛W11...W1n｝W1i=1/n

2 根據樣本權重D1以及決策樹求分類誤差率，並求的最小的誤差率em，以及該決策樹

　　em=

3 計算該分類器的權重

　　 可以看出，誤差率越小的，其權重越大

4 更新各個樣本的權重，Dm+1,（用公式編輯器好麻煩。。。 ）

　　

其中Zm是規范化銀子：

　　

5 構建基本分類器

　　F(X)=

6 計算該分類器下的誤差率，如果小於某個閾值就停止，否則從第二步開始迭代

 

終於不用打公式了。。。。

附上代碼：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

class Stump{
    public int dim;
    public double thresh;
    public String condition;
    public double error;
    public ArrayList<Integer> labelList;
    double factor;
    
    public String toString(){
        return "dim is "+dim+"\nthresh is "+thresh+"\ncondition is "+condition+"\nerror is "+error+"\nfactor is "+factor+"\nlabel is "+labelList;
    }
}

class Utils{
    //加載數據集
    public static ArrayList<ArrayList<Double>> loadDataSet(String filename) throws IOException{
        ArrayList<ArrayList<Double>> dataSet=new ArrayList<ArrayList<Double>>();
        FileInputStream fis=new FileInputStream(filename);
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        BufferedReader br=new BufferedReader(isr);
        String line="";
        
        while((line=br.readLine())!=null){
            ArrayList<Double> data=new ArrayList<Double>();
            String[] s=line.split(" ");
            
            for(int i=0;i<s.length-1;i++){
                data.add(Double.parseDouble(s[i]));
            }
            dataSet.add(data);
        }
        return  dataSet;
    }
    
    //加載類別
    public static ArrayList<Integer> loadLabelSet(String filename) throws NumberFormatException, IOException{
        ArrayList<Integer> labelSet=new ArrayList<Integer>();
        
        FileInputStream fis=new FileInputStream(filename);
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        BufferedReader br=new BufferedReader(isr);
        String line="";
        
        while((line=br.readLine())!=null){
            String[] s=line.split(" ");
            labelSet.add(Integer.parseInt(s[s.length-1]));
        }
        return labelSet;
    }
    //測試用的
    public static void showDataSet(ArrayList<ArrayList<Double>> dataSet){
        for(ArrayList<Double> data:dataSet){
            System.out.println(data);
        }
    }
    //獲取最大值，用於求步長
    public static double getMax(ArrayList<ArrayList<Double>> dataSet,int index){
        double max=-9999.0;
        for(ArrayList<Double> data:dataSet){
            if(data.get(index)>max){
                max=data.get(index);
            }
        }
        return max;
    }
    //獲取最小值，用於求步長
    public static double getMin(ArrayList<ArrayList<Double>> dataSet,int index){
        double min=9999.0;
        for(ArrayList<Double> data:dataSet){
            if(data.get(index)<min){
                min=data.get(index);
            }
        }
        return min;
    }
    
    //獲取數據集中以該feature為特征，以thresh和conditions為value的葉子節點的決策樹進行划分后得到的預測類別
    public static ArrayList<Integer> getClassify(ArrayList<ArrayList<Double>> dataSet,int feature,double thresh,String condition){
        ArrayList<Integer> labelList=new ArrayList<Integer>();
        if(condition.compareTo("lt")==0){
            for(ArrayList<Double> data:dataSet){
                if(data.get(feature)<=thresh){
                    labelList.add(1);
                }else{
                    labelList.add(-1);
                }
            }
        }else{
            for(ArrayList<Double> data:dataSet){
                if(data.get(feature)>=thresh){
                    labelList.add(1);
                }else{
                    labelList.add(-1);
                }
            }
        }
        return labelList;
    }
    //求預測類別與真實類別的加權誤差
    public static double getError(ArrayList<Integer> fake,ArrayList<Integer> real,ArrayList<Double> weights){
        double error=0;
        
        int n=real.size();

        for(int i=0;i<fake.size();i++){
            if(fake.get(i)!=real.get(i)){
                error+=weights.get(i);

            }
        }
        
        return error;
    }
    //構造一棵單節點的決策樹，用一個Stump類來存儲這些基本信息。
    public static Stump buildStump(ArrayList<ArrayList<Double>> dataSet,ArrayList<Integer> labelSet,ArrayList<Double> weights,int n){
        int featureNum=dataSet.get(0).size();
        
        int rowNum=dataSet.size();
        Stump stump=new Stump();
        double minError=999.0;
        System.out.println("第"+n+"次迭代");
        for(int i=0;i<featureNum;i++){
            double min=getMin(dataSet,i);
            double max=getMax(dataSet,i);    
            double step=(max-min)/(rowNum);
            for(double j=min-step;j<=max+step;j=j+step){
                String[] conditions={"lt","gt"};//如果是lt，表示如果小於閥值則為真類，如果是gt，表示如果大於閥值則為正類
                for(String condition:conditions){
                    ArrayList<Integer> labelList=getClassify(dataSet,i,j,condition);
                    
                    double error=Utils.getError(labelList,labelSet,weights);
                    if(error<minError){
                        minError=error;
                        stump.dim=i;
                        stump.thresh=j;
                        stump.condition=condition;
                        stump.error=minError;
                        stump.labelList=labelList;
                        stump.factor=0.5*(Math.log((1-error)/error));
                    }
                    
                }
            }
            
        }
        
        return stump;
    }
    
    public static ArrayList<Double> getInitWeights(int n){
        double weight=1.0/n;
        ArrayList<Double> weights=new ArrayList<Double>();
        for(int i=0;i<n;i++){
            weights.add(weight);
        }
        return weights;
    }
    //更新樣本權值
    public static ArrayList<Double> updateWeights(Stump stump,ArrayList<Integer> labelList,ArrayList<Double> weights){
        double Z=0;
        ArrayList<Double> newWeights=new ArrayList<Double>();
        int row=labelList.size();
        double e=Math.E;
        double factor=stump.factor;
        for(int i=0;i<row;i++){
            Z+=weights.get(i)*Math.pow(e,-factor*labelList.get(i)*stump.labelList.get(i));
        }
        
        
        for(int i=0;i<row;i++){
            double weight=weights.get(i)*Math.pow(e,-factor*labelList.get(i)*stump.labelList.get(i))/Z;
            newWeights.add(weight);
        }
        return newWeights;
    }
    //對加權誤差累加
    public static ArrayList<Double> InitAccWeightError(int n){
        ArrayList<Double> accError=new ArrayList<Double>();
        for(int i=0;i<n;i++){
            accError.add(0.0);
        }
        return accError;
    }
    
    public static ArrayList<Double> accWeightError(ArrayList<Double> accerror,Stump stump){
        ArrayList<Integer> t=stump.labelList;
        double factor=stump.factor;
        ArrayList<Double> newAccError=new ArrayList<Double>();
        for(int i=0;i<t.size();i++){
            double a=accerror.get(i)+factor*t.get(i);
            newAccError.add(a);
        }
        return newAccError;
    }
    
    public static double calErrorRate(ArrayList<Double> accError,ArrayList<Integer> labelList){
        ArrayList<Integer> a=new ArrayList<Integer>();
        int wrong=0;
        for(int i=0;i<accError.size();i++){
            if(accError.get(i)>0){
                if(labelList.get(i)==-1){
                    wrong++;
                }
            }else if(labelList.get(i)==1){
                wrong++;
            }
        }
        double error=wrong*1.0/accError.size();
        return error;
    }
    
    public static void showStumpList(ArrayList<Stump> G){
        for(Stump s:G){
            System.out.println(s);
            System.out.println(" ");
        }
    }
}


public class Adaboost {

    /**
     * @param args
     * @throws IOException 
     */
    
    public static ArrayList<Stump> AdaBoostTrain(ArrayList<ArrayList<Double>> dataSet,ArrayList<Integer> labelList){
        int row=labelList.size();
        ArrayList<Double> weights=Utils.getInitWeights(row);
        ArrayList<Stump> G=new ArrayList<Stump>();
        ArrayList<Double> accError=Utils.InitAccWeightError(row);
        int n=1;
        while(true){
            Stump stump=Utils.buildStump(dataSet,labelList,weights,n);//求一棵誤差率最小的單節點決策樹
            G.add(stump);
            weights=Utils.updateWeights(stump,labelList,weights);//更新權值
            accError=Utils.accWeightError(accError,stump);//將加權誤差累加，因為這樣不用再利用分類器再求了
            double error=Utils.calErrorRate(accError,labelList);
            if(error<0.001){
                break;
            }
            n++;
        }
        return G;
    }
    
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String file="C:/Users/Administrator/Desktop/upload/AdaBoost1.txt";
        ArrayList<ArrayList<Double>> dataSet=Utils.loadDataSet(file);
        ArrayList<Integer> labelSet=Utils.loadLabelSet(file);
        ArrayList<Stump> G=AdaBoostTrain(dataSet,labelSet);
        Utils.showStumpList(G);
        System.out.println("finished");
    }

}

這里的數據采用的是統計學習方法中的數據

0 1
1 1
2 1
3 -1
4 -1
5 -1
6 1
7 1
8 1
9 -1

這里是單個特征的，也可以是多維數據，例如

1.0 2.1 1
2.0 1.1 1
1.3 1.0 -1
1.0 1.0 -1
2.0 1.0 1