神经网络实践项目——数字奇偶识别

怼烎@ 2023-03-04 08:15 5阅读 0赞

## 项目：奇偶识别 ##

将一个int型整数转化为32位二进制数作为BP人工神经网络的输入（例如，整数2为10前面加30个0，这32个数字分别为32个输入），0或1作为输出层的输出（该数为偶数，则预期输出d为0；该数为奇数，则预期输出d为1），以这样的模型（32个输入，隐含层16个神经元，输出层1个神经元，学习率参数r的值为0.1）训练1000个回合（训练一回合=训练一次训练集，训练一回合后，打乱训练集，再进行下一回合的训练），然后对测试集进行测试并统计奇偶识别率。  
训练集：1000个随机整数和1000个预期输出  
测试集：10000个随机整数

**注：这里的神经网络模型写的是关于二分类的问题，没有写通用的神经网络类**

**反向传播，随机梯度下降。**

**神经网络类：**

import java.util.Arrays;
    
    public class NeuralNetworks {
        
    
        int input_n; // 输入层结点数
        double[][] w1; // w1[0] 为偏置的权重
        int hidden_n; // 隐藏层结点数
        double[] hidden_layer; // 隐藏层
        double[][] w2; // w2[0] 为偏置的权重
        int output_n; // 输出层结点数
        double[] y; // 输出层
        double alpha; // 学习率
        double b; // 偏置
    
        public NeuralNetworks(int input_n, int hidden_n, int output_n, double alpha, double b) {
        
            this.input_n = input_n;
            this.hidden_n = hidden_n;
            this.output_n = output_n;
            this.alpha = alpha;
            this.b = b;
            initial();
        }
        // 初始化
        private void initial() {
        
            this.w1 = new double[input_n + 1][hidden_n];
            this.hidden_layer = new double[this.hidden_n];
            this.w2 = new double[hidden_n + 1][output_n];
            this.y = new double[output_n];
            initial_w(w1);
            initial_w(w2);
        }
        // 初始化权重
        private void initial_w(double[][] w) {
        
            for (int i = 0; i < w.length; i++) {
        
                for (int j = 0; j < w[0].length; j++) {
        
                    w[i][j] = Math.random();
                }
            }
        }
        // 训练模型
        public void train(double[] input_x, double[] t_y) {
        
            calculate_y(input_x); // 计算输出层
            double[] y_error = calculate_y_error(t_y); // 计算输出层误差
            double[] hidden_error = calculate_hidden_error(y_error); // 计算隐藏层误差
            reNewWeight(this.hidden_layer, this.w2, y_error); // 更新隐藏层到输出层权重
            reNewWeight(input_x, this.w1, hidden_error); // 更新输入层到隐藏层权重
        }
        // 预测
        public void predict(double[] x) {
        
            calculate_y(x);
            System.out.println(Arrays.toString(this.y));
            if (this.y[0] < 0.5) {
        
                System.out.println("偶数!!!");
            } else {
        
                System.out.println("奇数!!!");
            }
        }
        // 更新权重
        private void reNewWeight(double[] in, double[][] w, double[] error) {
        
            // 更新结点权重
            for (int i = 1; i < w.length; i++) {
        
                for (int j = 0; j < w[0].length; j++) {
        
                    w[i][j] += (this.alpha * error[j] * in[i - 1]);
                }
            }
            // 更新偏置的权重
            for (int j = 0; j < w[0].length; j++) {
        
                w[0][j] += (this.alpha * error[j] * this.b);
            }
        }
        // 计算隐藏层误差
        private double[] calculate_hidden_error(double[] y_error) {
        
            double sum;
            double[] hidden_error = new double[this.hidden_n];
            for (int i = 0; i < this.hidden_n; i++) {
        
                sum = 0;
                for (int j = 0; j < this.output_n; j++) {
        
                    sum += (y_error[j] * this.w2[i + 1][j]);
                }
                hidden_error[i] = sum * this.hidden_layer[i] * (1 - this.hidden_layer[i]);
            }
            return hidden_error;
        }
        // 计算输出层误差
        private double[] calculate_y_error(double[] t_y) {
        
            double[] y_error = new double[this.output_n];
            for (int i = 0; i < output_n; i++) {
        
                y_error[i] = (t_y[i] - this.y[i]) * this.y[i] * (1 - this.y[i]);
            }
            return y_error;
        }
        // 计算输出层值
        private void calculate_y(double[] input_x) {
        
            calculate_layer(input_x, this.w1, this.hidden_layer); // 计算隐藏层值
            calculate_layer(this.hidden_layer, this.w2, this.y); // 计算输出层值
        }
        // 计算该层的输出值
        private void calculate_layer(double[] in, double[][] w, double[] out) {
        
            double z;
            for (int i = 0; i < w[0].length; i++) {
        
                z = w[0][i] * this.b;
                for (int j = 1; j < w.length; j++) {
        
                    z += (w[j][i] * in[j - 1]);
                }
                out[i] = 1 / (1 + Math.exp(-z)); // sigmoid函数
            }
        }
    }

**主类：**

import java.util.ArrayList;
    import java.util.Random;
    import java.util.Scanner;
    
    public class Main {
        
        public static void main(String[] args) {
        
            Random random = new Random();
            NeuralNetworks bp = new NeuralNetworks(32,16,1,0.1,1);
            double[] t_y = new double[1];
            double[] x;
            ArrayList<Integer> train_datas = new ArrayList<>();
            // 随机生成训练集
            for(int i=0;i<1000;i++){
        
                train_datas.add(random.nextInt());
            }
    		// 训练模型
           for(int k=0;k<1000;k++){
        
               for(int i=0;i<train_datas.size();i++){
        
                   t_y[0] = (train_datas.get(i) & 1); // 预期输出
                   x = get_x(train_datas.get(i));
                   bp.train(x,t_y);
               }
           }
            System.out.println("训练完成!!!");
            Scanner in = new Scanner(System.in);
            int k;
            System.out.print("输入数字识别奇偶（输入0结束）:");
            while((k = in.nextInt()) != 0){
        
                x = get_x(k);
                bp.predict(x);
                System.out.print("输入数字识别奇偶（输入0结束）:");
            }
            in.close();
        }
        // 将10进制转换成2进制
        public static double[] get_x(int num){
        
            double[] x = new double[32];
            for(int i=31;i>=0;i--){
        
                x[i] = (num & 1);
                num >>>= 1;
            }
            return x;
        }
    }