单层感知器--JAVA实现

单层感知器，对两种类型进行线性分类。

对于可以线性划分的数据，算法收敛与学习率无关，所以设为1，学习率用于帮助算法快速收敛。

train_X属于训练内容，train_T属于标记。
test_X是待预测数据，test_T是实际值。

这个例子属于有监督学习。
训练过程是一个不断调整w权重过程。
预测就是使用训练后的权重对 待预测数据运算求和，然后使用激活函数得出结果，与实际值比较。
激活函数用于对结果进行分类，这里大于0就是1，小于0就是-1

public class Perceptrons {
    int nIn = 2;//输入数据的维度
    double[]  w;//权重

    public Perceptrons(int nIn){
        this.nIn = nIn;
        w=new double[nIn];
    }
    public int train(double[] x,int t,double learningRate){
        int classified = 0;
        double c=0.;
        for(int i = 0;i<nIn;i++){
            c+= w[i]*x[i]*t;
        }
        if (c>0){
            classified =1 ;
        }else {
            for (int i=0;i<nIn;i++){
                w[i] += learningRate* x[i]*t;
            }
        }
        return classified;
    }
    public int predict(double[] x){
        double preActivation = 0;
        for (int i=0;i<nIn;i++){
            preActivation +=w[i]*x[i];
        }
        return ActivationFunction.step(preActivation);
    }


    public static void main(String[] args) {
        final int train_N = 1000;//输入数据的数量
        final int test_N = 200; //测试数据的数量
        final int nIn = 2;//输入数据的维度

        double[][] train_X = new double[train_N][nIn]; //训练数据的输入
        int[] train_T = new int[train_N]; //用于训练的输出数据

        double[][] test_X = new double[test_N][nIn]; //测试数据
        int[] test_T = new int[test_N];//用于测试的数据实际标记

        int[] predicted_T = new int[test_N];//预测值

        final int epochs = 2000; //最大迭代次数
        final double learningRate = 1 ;//感知器的学习率

        final Random rng = new Random(1234);
        GaussianDistribution g1 = new GaussianDistribution(-2.0,1.0,rng);
        GaussianDistribution g2 = new GaussianDistribution(2.0,1.0,rng);

        for (int i=0;i<train_N/2-1;i++){
            train_X[i][0]=g1.random();
            train_X[i][1]=g2.random();
            train_T[i]=1;
        }
        for (int i=0;i<test_N/2-1;i++){
            test_X[i][0]=g1.random();
            test_X[i][1]=g2.random();
            test_T[i]=1;
        }
        for (int i = train_N/2; i < train_N; i++) {
            train_X[i][0] = g2.random();
            train_X[i][1] = g1.random();
            train_T[i] = -1;
        }
        for (int i = test_N/2; i < test_N; i++) {
            test_X[i][0] = g2.random();
            test_X[i][1] = g1.random();
            test_T[i] = -1;
        }
        Perceptrons perceptrons = new Perceptrons(nIn);
        int epoch =0;
        while (true){
            int classified=0;

            for (int i =0;i<train_N;i++){
                classified += perceptrons.train(train_X[i],train_T[i],learningRate);
            }
            if (classified==train_N)
                break;
            epoch++;
            if (epoch>epochs)
                break;
        }

        for (int i=0;i<test_N;i++){
            predicted_T[i] = perceptrons.predict(test_X[i]);
        }
        int[][] confusionMatrix = new int[2][2];
        double accuracy =0 ;
        double precision = 0;
        double recall = 0;

        for (int i =0;i<test_N;i++){
            if (predicted_T[i]>0){
                if (test_T[i]>0){
                    accuracy+=1;
                    precision+=1;
                    recall+=1;
                    confusionMatrix[0][0]+=1;
                }else {
                    confusionMatrix[1][0]+=1;
                }
            }else {
                if (test_T[i]>0){
                    confusionMatrix[0][1]+=1;
                }else {
                    accuracy+=1;
                    confusionMatrix[1][1]+=1;
                }
            }
        }
        accuracy /= test_N;
        precision /=confusionMatrix[0][0]+confusionMatrix[1][0];
        recall /= confusionMatrix[0][0]+confusionMatrix[0][1];

        System.out.println("----------------------------");
        System.out.println("Perceptrons model evaluation");
        System.out.println("----------------------------");
        System.out.printf("Accuracy:  %.1f %%\n", accuracy * 100);
        System.out.printf("Precision: %.1f %%\n", precision * 100);
        System.out.printf("Recall:    %.1f %%\n", recall * 100);

    }
}

public final  class ActivationFunction {
    public static int step(double x){
        if (x>0){
            return 1;
        }else {
            return -1;
        }
    }

}

public final class GaussianDistribution {
    private final double mean;
    private final double var;
    private final Random random;

    public GaussianDistribution(double mean,double var,Random random){
        if (var<0.0){
            throw new IllegalArgumentException("var 必须是非负值");
        }
        this.mean = mean;
        this.var =var;
        if (random==null){
            random = new Random();
        }
        this.random =random;
    }

    public double random(){
        double r = 0.0;
        while (r == 0.0){
            r = random.nextDouble();
        }
        double c = Math.sqrt(-2.0*Math.log(r));
        if (random.nextDouble()<0.5){
            return c*Math.sin(2.0*Math.PI*random.nextDouble())*var+mean;
        }
        return c*Math.cos(2.0*Math.PI*random.nextDouble())*var+mean;
    }
}