EBPTA

package javaapplication1;
import java.util.Random;

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 {

    public double[] inputs = new double[2];
    public double[] weights = new double[2];
    public double error;

    private double biasWeight;

    //private Random r = new Random();
    public double output() {
        return Sigmoid.output(weights[0] * inputs[0] + weights[1] * inputs[1] + biasWeight);
    }

    public void randomizeWeights() {
        weights[0] = Math.random();
        weights[1] = Math.random();
        biasWeight = Math.random();
    }

    public void adjustWeights() {
        weights[0] += (error * inputs[0]);
        weights[1] += (error * inputs[1]);
        biasWeight += error;
    }
}

public class ErrorBackProp {

    static void train() {
        // the input values
        double inputs[][] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};

        // desired results
        double[] results = {0, 1, 1, 0};

        // creating the neurons
        Neuron hiddenNeuron1 = new Neuron();
        Neuron hiddenNeuron2 = new Neuron();
        Neuron outputNeuron = new Neuron();

        // random weights
        hiddenNeuron1.randomizeWeights();
        hiddenNeuron2.randomizeWeights();
        outputNeuron.randomizeWeights();

        int iter = 0;

        while (iter != 1000) {
            for (int i = 0; i < 4; i++) {
                hiddenNeuron1.inputs = inputs[i];
                hiddenNeuron2.inputs = inputs[i];

                outputNeuron.inputs[0] = hiddenNeuron1.output();
                outputNeuron.inputs[1] = hiddenNeuron2.output();
                System.out.println(" " + inputs[i][0] + " XOR " + inputs[i][1] + " = " + outputNeuron.output());
                outputNeuron.error = Sigmoid.derivative(outputNeuron.output()) * (results[i] - outputNeuron.output());

                outputNeuron.adjustWeights();
                hiddenNeuron1.error = Sigmoid.derivative(hiddenNeuron1.output()) * outputNeuron.error * outputNeuron.weights[0];
                hiddenNeuron2.error = Sigmoid.derivative(hiddenNeuron2.output()) * outputNeuron.error * outputNeuron.weights[1];

                hiddenNeuron1.adjustWeights();

                hiddenNeuron2.adjustWeights();
            }
            iter++;
        }
    }

    public static void main(String args[]) {
        train();
    }

}
/*
 0.0 XOR 0.0 = 0.08062228800032477
 0.0 XOR 1.0 = 0.9132704801375265
 1.0 XOR 0.0 = 0.913499390340217
 1.0 XOR 1.0 = 0.10087040324942716
 */