感知器java實現簡略版

/** 
 * 感知器分類：隨機梯度下降算法求解。
 * 感知器是一個線性二分類器： y = (w)T·x + b  最優化可以求解w和b。
 * 
 * 損失函數：L(w,b) = 求和（I(yi != wT·xi + b) * yi(wT·xi + b)）
 * 
 * 輸入： double[m][n] data 每行表示一個樣本，每行是一個n維的特徵向量。總共有m個樣本。
 *       int[m] label 長度爲m的
 * 
 * 輸出：new Perceptron 
 *      
 * @author huangyongye
 *
 */

public  class Perceptron{

    private double[] w;
    private double b;
    private int maxStep;    // 最大迭代次數


    public Perceptron(int max) {
        maxStep = max;
    }

    /**
     * 模型訓練：通過梯度下降求解模型參數w向量和b
     * @param trian_datas ：輸入特徵矩陣 
     * @param labels ：訓練數據的類標 
     * @param alpha: 步長
     * @throws Exception 
     */
    public void train(double[][] train_datas, int[] labels, double alpha) throws Exception { // alpha 表示梯度下降的步長
        int m = train_datas.length;     // 樣本數量
        if(m == 0)
            throw new Exception("wrong data");
        int n = train_datas[0].length;  // 特徵維數
        // w和b初始化爲0
        w = new double[n];
        for(int i = 0; i < n; i++)
            w[i] = 0;
        b = 0;
        /* 
         * 循環終止條件：非常重要！設置最大的循環次數；或者設置兩次lost的差小於某個數時，停止迭代。
         * 假設樣本一定線性可分,不斷修改w和b的值,直到所有分開。
         */
        int step = 0;
        while(step < maxStep) {
            boolean flag = false;
            for(int i = 0; i < m; i++) {
                double dist = docMul(w, train_datas[i]) + b;
                // 若labels[i] * dist <= 0，說明分類錯誤，從而避免了dist爲0的情況。
                if(labels[i]*dist <= 0 ) {
                    step++;
                    update_w(w, train_datas[i], labels[i], alpha);
                    b = update_b(b, labels[i], alpha);
                    flag = true;
                    System.out.print("第" + step + "次迭代：\n\tw: ");
                    for(double d: w)
                        System.out.print(d + " ");
                    System.out.println("\n\tb: " + b);
                }
            }

            if(!flag) { // 對於線性可分的情況，如果沒有錯誤了，則直接退出，不再迭代
                System.out.println("\n一共迭代了" + step + "次");
                break;
            }
        }
    }


    /** 
     * sign函數
     * @param dist
     * @return
     */
    private int sign(double dist) {
        if(dist >= 0)
            return 1;
        return -1;
    }

    /**
     * 點乘
     * @param a
     * @param b
     * @return
     */
    private double docMul(double[] a, double[] b) throws Exception{
        if(a.length != b.length)
            throw new Exception("the length of these two vector is not the same!");
        double sum = 0;
        for(int i = 0; i < a.length; i++) {
            sum += (a[i]*(double)b[i]);
        }
        return sum;
    }


    private double update_b(double b, int labeli, double alpha) {
        b = b + alpha * labeli;
        return b;
    }

    private void update_w(double[] w, double[] ts, int labeli, double alpha) {
        for(int i = 0; i < w.length; i++) {
            w[i] = w[i] + alpha * (double)ts[i] * labeli;
        }
    }

    public int test_one(double[] test_data) throws Exception {
        if(test_data.length != w.length)
            throw new Exception("the length of the input data is wrong!");
        double dist = docMul(w, test_data) + b; 
        int label = sign(dist);
        return label;

    }

    public int[] test_list(double[][] test_datas) throws Exception {
        int[] labels = new int[test_datas.length];
        for(int i = 0; i < test_datas.length; i++) {
            labels[i] = test_one(test_datas[i]);
        }
        return labels;
    }

    public static void main(String[] args) throws Exception {
        /* 線性不可分的案例
        double[][] data = {{1,4}, {4,1}, {2,2}, {1,2}, {1,1}, {2,1}, {2,4}, {3,5}, {3.5,6.2}};
        int[] labels = {-1,-1,1,-1,-1,-1,1,1,1};
        */
        double[][] data = {{3,3},{4,3}, {1,1}};
        int[] labels = {1,1,-1};
        Perceptron ptest = new Perceptron(1000);
        double alpha = 0.1;
        ptest.train(data, labels, alpha);
        double[] w = ptest.w;
        System.out.print("parameter w is : ");
        for(double d: w)
            System.out.print(d + " ");
        System.out.println("\nparameter b: " + ptest.b + "\n");
        double[] test_case = {-1,-1}; // -1
        double[] test_case2 = {5,5}; // 1
        int label1 = ptest.test_one(test_case);
        System.out.println("label1: " + label1);
        int label2 = ptest.test_one(test_case2);
        System.out.println("label2: " + label2);
    }
}