1
public class NeuralNetwork {
2
    private int inputNodes;
3
    private int hiddenNodes;
4
    private int outputNodes;
5
    private double[][] weightsInputHidden;
6
    private double[][] weightsHiddenOutput;
7
    private double[] hiddenBias;
8
    private double[] outputBias;
9

10
    public NeuralNetwork(int inputNodes, int hiddenNodes, int outputNodes) {
11
        this.inputNodes = inputNodes;
12
        this.hiddenNodes = hiddenNodes;
13
        this.outputNodes = outputNodes;
14

15
        // Initialize weights with random values
16
        this.weightsInputHidden = new double[hiddenNodes][inputNodes];
17
        this.weightsHiddenOutput = new double[outputNodes][hiddenNodes];
18
        this.hiddenBias = new double[hiddenNodes];
19
        this.outputBias = new double[outputNodes];
20

21
        randomizeWeights(weightsInputHidden);
22
        randomizeWeights(weightsHiddenOutput);
23
        randomizeBiases(hiddenBias);
24
        randomizeBiases(outputBias);
25
    }
26

27
    private void randomizeWeights(double[][] weights) {
28
        for (int i = 0; i < weights.length; i++) {
29
            for (int j = 0; j < weights[i].length; j++) {
30
                weights[i][j] = Math.random() - 0.5;
31
            }
32
        }
33
    }
34

35
    private void randomizeBiases(double[] biases) {
36
        for (int i = 0; i < biases.length; i++) {
37
            biases[i] = Math.random() - 0.5;
38
        }
39
    }
40

41
    public double[] feedForward(double[] input) {
42
        double[] hiddenOutputs = new double[hiddenNodes];
43
        double[] finalOutputs = new double[outputNodes];
44

45
        // Calculate hidden layer outputs
46
        for (int i = 0; i < hiddenNodes; i++) {
47
            double sum = 0;
48
            for (int j = 0; j < inputNodes; j++) {
49
                sum += input[j] * weightsInputHidden[i][j];
50
            }
51
            sum += hiddenBias[i];
52
            hiddenOutputs[i] = sigmoid(sum);
53
        }
54

55
        // Calculate output layer outputs
56
        for (int i = 0; i < outputNodes; i++) {
57
            double sum = 0;
58
            for (int j = 0; j < hiddenNodes; j++) {
59
                sum += hiddenOutputs[j] * weightsHiddenOutput[i][j];
60
            }
61
            sum += outputBias[i];
62
            finalOutputs[i] = sigmoid(sum);
63
        }
64

65
        return finalOutputs;
66
    }
67

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

72
    private double sigmoidDerivative(double x) {
73
        return x * (1 - x);
74
    }
75

76
    public void train(double[] input, double[] target, double learningRate) {
77
        double[] hiddenOutputs = new double[hiddenNodes];
78
        double[] finalOutputs = new double[outputNodes];
79

80
        // Feed forward
81
        for (int i = 0; i < hiddenNodes; i++) {
82
            double sum = 0;
83
            for (int j = 0; j < inputNodes; j++) {
84
                sum += input[j] * weightsInputHidden[i][j];
85
            }
86
            sum += hiddenBias[i];
87
            hiddenOutputs[i] = sigmoid(sum);
88
        }
89

90
        for (int i = 0; i < outputNodes; i++) {
91
            double sum = 0;
92
            for (int j = 0; j < hiddenNodes; j++) {
93
                sum += hiddenOutputs[j] * weightsHiddenOutput[i][j];
94
            }
95
            sum += outputBias[i];
96
            finalOutputs[i] = sigmoid(sum);
97
        }
98

99
        // Backpropagation
100
        double[] outputErrors = new double[outputNodes];
101
        for (int i = 0; i < outputNodes; i++) {
102
            outputErrors[i] = target[i] - finalOutputs[i];
103
        }
104

105
        double[] hiddenErrors = new double[hiddenNodes];
106
        for (int i = 0; i < hiddenNodes; i++) {
107
            double error = 0;
108
            for (int j = 0; j < outputNodes; j++) {
109
                error += outputErrors[j] * weightsHiddenOutput[j][i];
110
            }
111
            hiddenErrors[i] = error;
112
        }
113

114
        // Update weights and biases for output layer
115
        for (int i = 0; i < outputNodes; i++) {
116
            for (int j = 0; j < hiddenNodes; j++) {
117
                weightsHiddenOutput[i][j] += learningRate * outputErrors[i] * sigmoidDerivative(finalOutputs[i]) * hiddenOutputs[j];
118
            }
119
            outputBias[i] += learningRate * outputErrors[i] * sigmoidDerivative(finalOutputs[i]);
120
        }
121

122
        // Update weights and biases for hidden layer
123
        for (int i = 0; i < hiddenNodes; i++) {
124
            for (int j = 0; j < inputNodes; j++) {
125
                weightsInputHidden[i][j] += learningRate * hiddenErrors[i] * sigmoidDerivative(hiddenOutputs[i]) * input[j];
126
            }
127
            hiddenBias[i] += learningRate * hiddenErrors[i] * sigmoidDerivative(hiddenOutputs[i]);
128
        }
129
    }
130
}

1
public class Main {
2
    public static void main(String[] args) {
3
        // Create a neural network with 2 input nodes, 3 hidden nodes, and 1 output node
4
        NeuralNetwork nn = new NeuralNetwork(2, 3, 1);
5

6
        // Training data (XOR problem)
7
        double[][] inputs = {
8
            {0, 0},
9
            {0, 1},
10
            {1, 0},
11
            {1, 1}
12
        };
13
        double[][] targets = {
14
            {0},
15
            {1},
16
            {1},
17
            {0}
18
        };
19

20
        // Train the network
21
        int epochs = 10000;
22
        double learningRate = 0.1;
23
        for (int i = 0; i < epochs; i++) {
24
            for (int j = 0; j < inputs.length; j++) {
25
                nn.train(inputs[j], targets[j], learningRate);
26
            }
27
        }
28

29
        // Test the network
30
        for (double[] input : inputs) {
31
            double[] output = nn.feedForward(input);
32
            System.out.println("Input: " + input[0] + ", " + input[1] + " Output: " + output[0]);
33
        }
34
    }
35
}