神经网络反向传播法代码java代码实现

下面是一个简单的神经网络反向传播法的Java代码实现：

public class NeuralNetwork {
    private int inputNodes;
    private int hiddenNodes;
    private int outputNodes;
    private double[][] weightsInputHidden;
    private double[][] weightsHiddenOutput;
    private double[][] activationInput;
    private double[][] activationHidden;
    private double[][] output;
    private double[][] target;

    public NeuralNetwork(int inputNodes, int hiddenNodes, int outputNodes) {
        this.inputNodes = inputNodes;
        this.hiddenNodes = hiddenNodes;
        this.outputNodes = outputNodes;
        this.weightsInputHidden = new double[inputNodes][hiddenNodes];
        this.weightsHiddenOutput = new double[hiddenNodes][outputNodes];
        this.activationInput = new double[1][inputNodes];
        this.activationHidden = new double[1][hiddenNodes];
        this.output = new double[1][outputNodes];
        this.target = new double[1][outputNodes];
        initializeWeights();
    }

    private void initializeWeights() {
        for (int i = 0; i < inputNodes; i++) {
            for (int j = 0; j < hiddenNodes; j++) {
                weightsInputHidden[i][j] = Math.random() - 0.5;
            }
        }
        for (int i = 0; i < hiddenNodes; i++) {
            for (int j = 0; j < outputNodes; j++) {
                weightsHiddenOutput[i][j] = Math.random() - 0.5;
            }
        }
    }

    private void forwardPropagation(double[] input) {
        for (int i = 0; i < inputNodes; i++) {
            activationInput[0][i] = input[i];
        }
        for (int i = 0; i < hiddenNodes; i++) {
            double sum = 0;
            for (int j = 0; j < inputNodes; j++) {
                sum += activationInput[0][j] * weightsInputHidden[j][i];
            }
            activationHidden[0][i] = sigmoid(sum);
        }
        for (int i = 0; i < outputNodes; i++) {
            double sum = 0;
            for (int j = 0; j < hiddenNodes; j++) {
                sum += activationHidden[0][j] * weightsHiddenOutput[j][i];
            }
            output[0][i] = sigmoid(sum);
        }
    }

    private void backwardPropagation(double[] target) {
        for (int i = 0; i < outputNodes; i++) {
            double error = target[i] - output[0][i];
            double delta = error * sigmoidDerivative(output[0][i]);
            for (int j = 0; j < hiddenNodes; j++) {
                weightsHiddenOutput[j][i] += delta * activationHidden[0][j];
            }
        }
        for (int i = 0; i < hiddenNodes; i++) {
            double error = 0;
            for (int j = 0; j < outputNodes; j++) {
                error += weightsHiddenOutput[i][j] * (target[j] - output[0][j]);
            }
            double delta = error * sigmoidDerivative(activationHidden[0][i]);
            for (int j = 0; j < inputNodes; j++) {
                weightsInputHidden[j][i] += delta * activationInput[0][j];
            }
        }
    }

    public void train(double[][] inputs, double[][] targets, int epochs, double learningRate) {
        for (int i = 0; i < epochs; i++) {
            for (int j = 0; j < inputs.length; j++) {
                forwardPropagation(inputs[j]);
                backwardPropagation(targets[j]);
            }
        }
    }

    public double[] predict(double[] input) {
        forwardPropagation(input);
        return output[0];
    }

    private double sigmoid(double x) {
        return 1 / (1 + Math.exp(-x));
    }

    private double sigmoidDerivative(double x) {
        return x * (1 - x);
    }
}

这个实现使用了sigmoid函数作为激活函数，并且使用了随机初始化权重的方法来避免陷入局部最优解。它包含了前向传播和反向传播方法，并且可以接收训练数据和目标数据进行训练。最后，它还包含了一个预测方法，可以使用训练后的神经网络进行预测。