1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

package org.shapelogic.machinelearning;

import java.util.ArrayList;

import org.shapelogic.calculation.Calc1;

/** Feed Forward Neural Network with external training. <br />
 *
 * The bias is considered the zeroth element of the synaptic weight.
 *
 * @author Sami Badawi
 */
public class FFNeuralNetwork implements Calc1<double[], double[]>
{

    final public int nInputNodes;
    final public int nOutputNodes;
    protected ArrayList<Integer> _layerNodes = new ArrayList();
    protected ArrayList<double[]> _layerWeights = new ArrayList();
    protected String _message;

    /** There is not agreement about whether the bias should be 1 or -1.<br />
     * <br />
     * In Joone it seems to be 1, so for now it is set to 1 here. <br />
     * <br />
     * It might be changed to be ajudstable.<br />
     */
    protected int _biasWeight = 1;

    public FFNeuralNetwork(int nInput, int nOutput) {
        nInputNodes = nInput;
        nOutputNodes = nOutput;
        _layerNodes.add(nInput);
        _layerWeights.add(new double[0]);
    }

    public double[] invoke(double[] input) {
        if (getLayerNodesInTopLayer() != nOutputNodes)
            return null;
        if (input.length != nInputNodes)
            return null;
        double[] lastResult = input;
        double[] result = null;
        for (int i = 1; i < _layerNodes.size(); i++) {
            result = calcLayer(lastResult, i);
            lastResult = result;
        }
        return result;
    }

    public double[] calcLayer(double[] lastResult,
            int layerNumber)
    {
        int currentNumberOfNodes = _layerNodes.get(layerNumber);
        double[] result = new double[currentNumberOfNodes];
        double[] currentWeights = _layerWeights.get(layerNumber);
        for (int i = 0; i < result.length; i++) {
            result[i] += currentWeights[i] * _biasWeight;
            for (int j = 0; j < lastResult.length; j++) {
                int index = i + (j+1)*currentNumberOfNodes;
                result[i] += currentWeights[index] * lastResult[j];
            }
            result[i] = transform(result[i]);
        }
        return result;
    }

    public boolean addLayer(double[] layer) {
        int lastNumberOfNodes = _layerNodes.get(_layerNodes.size()-1);
        int currentNumberOfNodes = layer.length / (lastNumberOfNodes+1);
        _layerWeights.add(layer);
        _layerNodes.add(currentNumberOfNodes);
        if (layer.length % lastNumberOfNodes != 0)
            _message = "Error number of weights for a layer = " +
                    "(1 + nodes in last) * (nodes in current)\n" +
                    "Values found \n" +
                    "number of weight in layer = " + layer.length +
                    "\nnumber of nodes in last layer = " + lastNumberOfNodes;
        return true;
    }

    public boolean addLayers(double[][] layers) {
        for (double[] layer: layers) {
            if  (!addLayer(layer))
                return false;
        }
        return true;
    }

    public double transform(double input) {
        return 1 / (1 + Math.exp(-input));
    }

//=============== Getters and setters ===============
    public ArrayList<Integer> getLayerNodes() {
        return _layerNodes;
    }

    public int getLayerNodesInTopLayer() {
        return _layerNodes.get(_layerNodes.size()-1);
    }

    public ArrayList<double[]> getLayerWeights() {
        return _layerWeights;
    }

    public String getMessage() {
        return _message;
    }
}