BackPropagation.java

package backpropagation;

import java.util.Arrays;

class Sigmoid {

    public static double output(double x) {
        return 1.0 / (1.0 + Math.exp(-x));
    }

    public static double derivative(double x) {
        return x * (1 - x);
    }
}

class Neuron {

    Neuron(int n) {

        inputs = new double[n];
        weights = new double[n];
    }

    Neuron() {

    }
    double inputs[];
    double weights[];
    double net = 0;
    double bias;
    double out;
    double error;

    void calculateNet() {

        for (int i = 0; i < inputs.length; i++) {
            net += inputs[i] * weights[i];
        }
        net += bias;
    }

    void calculateOut() {

        out = Sigmoid.output(net);
    }

    void randomizeWeights() {

        for (int i = 0; i < weights.length; i++) {
            weights[i] = Math.random();
        }
        bias = Math.random();
    }

    public void adjustWeights() {
        for (int i = 0; i < weights.length; i++) {
            double ed = 0;
            for (int j = 0; j < inputs.length; j++) {
                ed += error * inputs[i];
            }
            weights[i] += ed * 0.1;
        }
        // weights[0] += (error * inputs[0]);
        // weights[1] += (error * inputs[1]);
        bias += error;
    }

}

public class BackPropagation {

    public static double learningRate = 0.01;




    public static void main(String[] args) {
        double inputs[][] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
        double[] results = {0, 1, 1, 0};
        // TODO code application logic here
        Neuron hiddenNeurons[] = new Neuron[2];
        hiddenNeurons[0] = new Neuron(2);
        hiddenNeurons[1] = new Neuron(2);
        Neuron outputNeuron = new Neuron(2);
        outputNeuron.randomizeWeights();
        for (int i = 0; i < hiddenNeurons.length; i++) {
            hiddenNeurons[i].randomizeWeights();
            System.out.println("Weights for " + i + " is " + Arrays.toString(hiddenNeurons[i].weights));
        }
        int epoch = 0;
        while (epoch++ != 1000) {
          //  System.out.println(" Inside while ");
            for (int i = 0; i < 4; i++) {

               // System.out.println(" Inside for ");
                for (int j = 0; j < hiddenNeurons.length; j++) {

                    hiddenNeurons[j].inputs = inputs[i];
                    hiddenNeurons[j].calculateNet();
                    hiddenNeurons[j].calculateOut();
                   // System.out.println(" Inside hidden forward ");
                }
                for (int j = 0; j < outputNeuron.inputs.length; j++) {
                    outputNeuron.inputs[j] = hiddenNeurons[j].out;
                   // System.out.println(" Inside output forward ");

                }
                outputNeuron.calculateNet();
                outputNeuron.calculateOut();
                System.out.println("Epoch No. " + epoch);
                System.out.println("Output for " + i + " is " + outputNeuron.out);
                //System.out.println("Output for " + i + " is " + Arrays.toString(outputNeuron.weights));

                outputNeuron.error = (outputNeuron.out - results[i]) * Sigmoid.derivative(outputNeuron.out);
              /*  for (int j = 0; j < outputNeuron.weights.length; j++) {
                    outputNeuron.weights[j] -= outputNeuron.error * hiddenNeurons[j].out * learningRate;
                }
                outputNeuron.bias += outputNeuron.error;*/

                for (int j = 0; j < hiddenNeurons.length; j++) {
                    hiddenNeurons[j].error = outputNeuron.error * outputNeuron.weights[j] * Sigmoid.derivative(hiddenNeurons[j].out);
                    /*for (int k = 0; k < hiddenNeurons[j].weights.length; k++) {
                        hiddenNeurons[j].weights[k] -= hiddenNeurons[j].error * hiddenNeurons[j].inputs[k] *learningRate;
                    }
                    hiddenNeurons[j].bias += hiddenNeurons[j].error;
                   // System.out.println("Hidden layer for " + i + " is " + Arrays.toString(hiddenNeurons[j].weights));
                    System.out.println("Weights for " + j + " is " + Arrays.toString(hiddenNeurons[j].weights));*/
                }

            }

        }

    }

}