Java BackPropLearning issue

public class Tester
{
    public static void main(String[] args)
    {
        double[][] inputs = {
            {0.547361, -2.04845, -2.71647},
            {1.9708, -1.16141, -0.0485735},
            {-3.18799, 2.97068, 0.26499},
            {-0.498425, -1.04703, 1.61744}
        };

        double[][] outputs = {
            {1.0, 0.0, 0.0, 0.0},
            {0.0, 1.0, 0.0, 0.0},
            {0.0, 0.0, 1.0, 0.0},
            {0.0, 0.0, 0.0, 1.0}
        };

        Example[] examples = new Example[inputs.length];
        for (int i = 0; i < examples.length; i++)
            examples[i] = new Example(inputs[i], outputs[i]);

        int[] hiddenLayers = {4,4};  // sizes of hidden layers
        Network net = new Network();

        net.backPropLearning(examples, hiddenLayers, 10000, 1.0);
    }
}


public class Network
{
    private Layer[] layers;
    static double reportMultiplier = -1.0;

    private void setLayer (Layer layer, int i)
    {
        layers[i] = layer;
    }

    private void createLayers (int numInputs, int numOutputs, int[] hiddenLayers)
    {
        layers = new Layer[hiddenLayers.length + 2];

        Layer inputLayer = new Layer(numInputs);
        setLayer(inputLayer, 0);

        for (int i = 0; i < hiddenLayers.length; i++)
            setLayer(new Layer(layers[i], hiddenLayers[i]), i + 1);

        Layer outputLayer = new Layer(layers[hiddenLayers.length], numOutputs);
        setLayer(outputLayer, layers.length - 1);

        for (int i = 0; i < layers.length; i++)
            layers[i].createNeurons();
    }

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

    private double activationDerivative (double x)
    {
        double exp = Math.exp(x);
        return exp / Math.pow((exp + 1.0), 2); // d/dx sigmoid
    }

    private void printReport (int n, Example[] examples)
    {
        String s = "";
        double errorSum = 0.0;
        int m = layers.length - 1;
        for (int i = 0; i < layers[m].getSize(); i++)
            for (int j = 0; j < examples.length; j++)
                errorSum += Math.abs(examples[j].getOutput(i) - (layers[m].getNeuron(i)).getOutput());

        s = "n:" + n;
        while (s.length() < 10)
            s += " ";

        s += "error:" + (float) errorSum;
        while (s.length() < 30)
            s += " ";

        System.out.print(s);

        if (reportMultiplier < 0)
            reportMultiplier = 50 / errorSum;

        for (int i = 0; i < errorSum * reportMultiplier; i++)
            System.out.print("|");

        System.out.println();
    }

    public void backPropLearning (Example[] examples, int[] hiddenLayers, int steps, double learningFactor)
    {
        createLayers(examples[0].numInputs(), examples[0].numOutputs(), hiddenLayers);
        int n = 0;
        int numPlots = 50;
        int plotStep = Math.max(1, steps / numPlots);

        while (n < steps) {
            for (int e = 0; e < examples.length; e++) {
                Example example = examples[e];

                // Propagate the inputs forward to compute the output
                for (int i = 0; i < layers[0].getSize(); i++)
                    layers[0].getNeuron(i).setOutput(example.getInput(i));

                for (int i = 1; i < layers.length; i++) {
                    for (int j = 0; j < layers[i].getSize(); j++) {
                        Neuron nj = layers[i].getNeuron(j);
                        double in = 0.0;
                        for (int k = 0; k < nj.numInputs(); k++) {
                            Axon akj = nj.getInput(k);
                            Neuron nk = akj.getStart();
                            in += akj.getWeight() * nk.getOutput();
                        }
                        nj.setInput(in);
                        nj.setOutput(activation(in));
                    }
                }

                // Propagate deltas backward from output to input layer
                int m = layers.length - 1;
                for (int i = 0; i < layers[m].getSize(); i++) {
                    Neuron ni = layers[m].getNeuron(i);
                    double errori = example.getOutput(i) - ni.getOutput();
                    ni.setDelta(activationDerivative(ni.getInput()) * errori);
                }

                for (int i = m - 1; i >= 0; i--) {
                    for (int j = 0; j < layers[i].getSize(); j++) {
                        Neuron nj = layers[i].getNeuron(j);
                        double delta = 0.0;
                        for (int k = 0; k < nj.numOutputs(); k++) {
                            Axon ajk = nj.getOutput(k);
                            Neuron nk = ajk.getEnd();
                            delta += ajk.getWeight() * nk.getDelta();
                        }
                        delta *= activationDerivative(nj.getInput());
                        nj.setDelta(delta);
                    }
                }

                // Update every weight in network using deltas
                for (int i = 0; i < layers.length - 1; i++) {
                    for (int j = 0; j < layers[i].getSize(); j++) {
                        Neuron nj = layers[i].getNeuron(j);

                        for (int k = 0; k < nj.numOutputs(); k++) {
                            Axon ajk = nj.getOutput(k);
                            Neuron nk = ajk.getEnd();
                            ajk.modifyWeight(learningFactor * nk.getDelta() * nj.getOutput());
                            ajk.modifyWeight(learningFactor * nj.getDelta() * nk.getOutput());
                        }
                    }
                }
            }

            if (n % plotStep == 0)
                printReport(n, examples);

            n++;
        }

        printReport(n, examples);
    }
}


public class Layer
{
    private Neuron[] neurons;
    private Layer previous;
    private Layer next;

    public Layer (int n)
    {
        neurons = new Neuron[n];
    }

    public Layer (Layer l, int n)
    {
        this(n);

        previous = l;
        previous.next = this;
    }

    public void createNeurons ()
    {
        int n = previous == null ? 0 : previous.neurons.length;
        int m = next == null ? 0 : next.neurons.length;

        for (int i = 0; i < neurons.length; i++) {
            neurons[i] = new Neuron(n, m);
            for (int j = 0; j < n; j++)
                neurons[i].addInput(previous.neurons[j]);
        }
    }

    public int getSize ()
    {
        return neurons.length;
    }

    public Neuron getNeuron (int i)
    {
        return neurons[i];
    }
}


public class Neuron
{
    private Axon[] inputs;
    private Axon[] outputs;
    private double input;
    private double output;
    private double delta;

    public Neuron () // dummy constructor
    {
        inputs = new Axon[0];
        outputs = new Axon[1];
        input = 1.0;
        output = 1.0;
        delta = 0.0;
    }

    public Neuron (int n, int m)
    {
        this();
        n += 1; // add the dummy input
        inputs = new Axon[n];
        outputs = new Axon[m];

        Neuron dummy = new Neuron();
        addInput(dummy);
    }

    private void append (Axon[] arr, Axon a)
    {
        int i = 0;
        while (i < arr.length && arr[i] != null)
            i++;
        if (i < arr.length)
            arr[i] = a;
    }

    private void addOutput (Axon a)
    {
        append(outputs, a);
    }

    public void addInput (Neuron n)
    {
        Axon a = new Axon(n, this);
        append(inputs, a);
        n.addOutput(a);
    }

    public double getInput ()
    {
        return input;
    }

    public void setInput (double in)
    {
        input = in;
    }

    public double getOutput ()
    {
        return output;
    }

    public void setOutput (double out)
    {
        output = out;
    }

    public double getDelta ()
    {
        return delta;
    }

    public void setDelta (double newDelta)
    {
        delta = newDelta;
    }

    public int numInputs ()
    {
        return inputs.length;
    }

    public int numOutputs ()
    {
        return outputs.length;
    }

    public Axon getInput (int i)
    {
        return inputs[i];
    }

    public Axon getOutput (int i)
    {
        return outputs[i];
    }
}


public class Axon
{
    private double weight;
    private Neuron start;
    private Neuron end;

    public Axon (Neuron s, Neuron e)
    {
        start = s;
        end = e;
        weight = 2.0 * Math.random() - 1.0; // random initial weight between -1 and 1
    }

    public Neuron getStart ()
    {
        return start;
    }

    public Neuron getEnd ()
    {
        return end;
    }

    public double getWeight ()
    {
        return weight;
    }

    public void modifyWeight (double x)
    {
        weight += x;
    }
}

public class Example
{
    double[] inputs;
    double[] outputs;

    public Example (double[] in, double[] out)
    {
        inputs = in;
        outputs = out;
    }

    public double getInput (int i)
    {
        return inputs[i];
    }

    public double getOutput (int i)
    {
        return outputs[i];
    }

    public int numInputs ()
    {
        return inputs.length;
    }

    public int numOutputs ()
    {
        return outputs.length;
    }
}