ErrorBackPropagation

package faceplus;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

/**
 *
 * @author sandesh
 */
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 {

    static double lr = 0.3;
    static int len;

    Neuron(int x) {
        len = x;
    }

    Neuron() {

    }

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

    private double biasWeight;

    //private Random r = new Random();
    public double output() {

        double outSignal = 0;
        for (int i = 0; i < weights.length; i++) {
            outSignal += weights[i] * inputs[i];
        }
        return Sigmoid.output(outSignal + biasWeight);
    }

    public void randomizeWeights() {
        for (int i = 0; i < weights.length; i++) {
            weights[i] = Math.random();
        }
        biasWeight = 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 * lr;
        }
        // weights[0] += (error * inputs[0]);
        // weights[1] += (error * inputs[1]);
        biasWeight += error;
    }
}

public class ErrorBackProp {
   // public static int inputLength = 0;

    static Neuron hiddenNeuron[];

    static void createNeuron(int n, int x) {
        new Neuron(x);
        hiddenNeuron = new Neuron[n];
        for (int i = 0; i < n; i++) {
            hiddenNeuron[i] = new Neuron();
        }
    }

    static void randomWeightsForNeurons() {

        for (int i = 0; i < hiddenNeuron.length; i++) {
            hiddenNeuron[i].randomizeWeights();
        }
    }

    static void train() throws Exception {
         double inputs[][] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
        double[] results = {0, 1, 1, 0};
        /*double inputs[][] = new double[14][166];
        try (BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\sandesh\\Documents\\NetBeansProjects\\FacePlus\\src\\faceplus\\dataset.txt"))) {
        String line;
        int i=0;
        while ((line = br.readLine()) != null) {
        String numbers[] = line.split(",");
        for(int x = 0 ; x < numbers.length ; x ++) {
            inputs[i][x] = Double.parseDouble(numbers[x]);
        }
        i++;
    }
}

        for(int p = 0 ; p < inputs.length ; p ++) {

        System.out.println(Arrays.toString(inputs[p]));
        }*/


        // the input values
      //  double[] results = {0.1, 0.99, 0.1, 0.99, 0.1, 0.99, 0.1, 0.99, 0.1, 0.99, 0.1, 0.99, 0.1, 0.99};
        int inputLength = inputs[0].length;
        createNeuron(2, inputLength);
        randomWeightsForNeurons();
        // desired results
        // 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 != 100000) {
            double error1 = 0 ;
            for (int i = 0; i < 4; i++) {

                for (int j = 0; j < hiddenNeuron.length; j++) {
                    hiddenNeuron[j].inputs = inputs[i];
                }
                //   hiddenNeuron1.inputs = inputs[i];
                //   hiddenNeuron2.inputs = inputs[i];
                for (int j = 0; j < outputNeuron.inputs.length; j++) {
                    outputNeuron.inputs[j] = hiddenNeuron[j].output();
                }
                //outputNeuron.inputs[0] = hiddenNeuron1.output();
                // outputNeuron.inputs[1] = hiddenNeuron2.output();
                System.out.println("Epoch No. "+iter);
                System.out.println("Output for "+i+" is " + outputNeuron.output());
                outputNeuron.error = Sigmoid.derivative(outputNeuron.output()) * (results[i] - outputNeuron.output());
                error1 += (results[i] - outputNeuron.output())*(results[i] - outputNeuron.output());
                outputNeuron.adjustWeights();
                for (int j = 0; j < hiddenNeuron.length; j++) {
                    hiddenNeuron[j].error = Sigmoid.derivative(hiddenNeuron[j].output()) * outputNeuron.error * outputNeuron.weights[j];
                }
                //hiddenNeuron1.error = Sigmoid.derivative(hiddenNeuron1.output()) * outputNeuron.error * outputNeuron.weights[0];
                //hiddenNeuron2.error = Sigmoid.derivative(hiddenNeuron2.output()) * outputNeuron.error * outputNeuron.weights[1];

                for (int j = 0; j < hiddenNeuron.length; j++) {
                    hiddenNeuron[j].adjustWeights();
                }

            }
            double MSE = (1.00/56.00)*error1;
            System.out.println("MSE: "+MSE);
            iter++;
        }
    }

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

}