java AdaBoost算法

由于对AdaBoost算法的弱分类器不是很了解，没明白算法描述里的“在权值分布的训练集上，取阈值使得分类误差率最小，然后就得到基本分类器”这句话。不是很明白怎么根据权值分布得到的阈值？提供的代码是直接给出了弱分类器，不知道是不是这样，有问题请提出，谢谢。一起学习。由于被弱分类器搞的郁闷，所以代码中没有添加注释，但是步骤1.2.3是根据李航的算法描述1.2.3进行编写的。

import java.util.ArrayList;
import java.util.List;

public class AdaBoost {
    public static void main(String[] args){
        TestPoint[] testpoint = new TestPoint[10];
        testpoint[0] = new TestPoint(0,1);
        testpoint[1] = new TestPoint(1,1);
        testpoint[2] = new TestPoint(2,1);
        testpoint[3] = new TestPoint(3,-1);
        testpoint[4] = new TestPoint(4,-1);
        testpoint[5] = new TestPoint(5,-1);
        testpoint[6] = new TestPoint(6,1);
        testpoint[7] = new TestPoint(7,1);
        testpoint[8] = new TestPoint(8,1);
        testpoint[9] = new TestPoint(9,-1);
        
        List<List<Integer>> G = new ArrayList<List<Integer>>();
        double[] v = {2.5,8.5,5.5};
        double[] D = new double[testpoint.length];
        List<Double> A = new ArrayList<Double>();
        
        D = first(D,testpoint);
        for(int i=0;i<v.length;i++){
            second(testpoint,D,v[i],G,A,i);
        }
        third(A,G);
    }

    private static void third(List<Double> a, List<List<Integer>> g) {
        System.out.print("所得函数：    sign[");
        for(int i=0;i<a.size();i++){
            System.out.print(a.get(i) + " * " + "g[" + i + "]");
            if(i<a.size()-1){
                System.out.print(" + ");
            }
        }
        System.out.println("]");
    }

    private static List<List<Integer>> second(TestPoint[] testpoint, double[] D, double v, List<List<Integer>> G, List<Double> A,int index) {
        double Z = 0;
        double error = 0.0;
        double a = 0;
        
        int[] GTemp = new int[testpoint.length];
        List<Integer> LTemp = new ArrayList<Integer>();
        
        for(int i=0;i<testpoint.length;i++){
            if(v != 5.5){    
                if(testpoint[i].getX() < v){
                    GTemp[i] = 1;
                }
                else{
                    GTemp[i] = -1;
                }
            }
            else{
                if(testpoint[i].getX() < v){
                    GTemp[i] = -1;
                }
                else{
                    GTemp[i] = 1;
                }
            }
        }

        for(int i=0;i<GTemp.length;i++){
            LTemp.add(GTemp[i]);
        }
        G.add(LTemp);
        
        for(int i=0;i<testpoint.length;i++){
            if(testpoint[i].getY() != GTemp[i]){
                error += D[i] * 1;
            }
        }
        
        System.out.println("         错误率e" + (index + 1) + ":" +error);
        
        a = 0.5 * Math.log((1-error)/error);
        A.add(a);
        
        for(int i=0;i<testpoint.length;i++){
            Z += D[i] * Math.exp((-a) * testpoint[i].getY() * GTemp[i]);
        }
        
        System.out.print("权值分布D" + (index +1) + ":" ); 
        for(int i=0;i<testpoint.length;i++){
            D[i] = (D[i]/Z) * Math.exp((-a) * testpoint[i].getY() * GTemp[i]);
            System.out.print(D[i] + "  ");
        }
        System.out.println();
        
        return G;
    }
    
    private static double[] first(double[] D, TestPoint[] testpoint) {
        for(int i=0;i<testpoint.length;i++){
            D[i] = 1.0/testpoint.length;
        }
        return D;
    }
}

//训练数据点，x为数据，y为类别
public class TestPoint {
    private double x;
    private double y;

    public TestPoint(double i,double y){
        this.x = i;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }
    public void setX(int x) {
        this.x = x;
    }
    
    public void setY(int y) {
        this.y = y;
    }
    
    public String toString(double x ,double y){
        return x + " " + y;
    }
}

运行结果：

错误率e1:0.30000000000000004
权值分布D1:0.07142857142857142 0.07142857142857142 0.07142857142857142 0.07142857142857142 0.07142857142857142 0.07142857142857142 0.16666666666666663 0.16666666666666663 0.16666666666666663 0.07142857142857142
错误率e2:0.21428571428571427
权值分布D2:0.04545454545454546 0.04545454545454546 0.04545454545454546 0.1666666666666667 0.1666666666666667 0.1666666666666667 0.10606060606060605 0.10606060606060605 0.10606060606060605 0.04545454545454546
错误率e3:0.18181818181818185
权值分布D3:0.12499999999999997 0.12499999999999997 0.12499999999999997 0.10185185185185185 0.10185185185185185 0.10185185185185185 0.0648148148148148 0.0648148148148148 0.0648148148148148 0.12499999999999997
所得函数： sign[0.4236489301936017 * g[0] + 0.6496414920651304 * g[1] + 0.752038698388137 * g[2]]