Significantly increased speed by converting from Groovy to Java

Author: Zomis

src/main/groovy/net/zomis/machlearn/neural/Backpropagation.java

@@ -89,7 +89,7 @@ public NeuralNetwork backPropagationLearning(Collection<LearningData> examples,
                     for (int nodei = 0; nodei < layer.size(); nodei++) {
                         Neuron neuron = layer.getNeurons().get(nodei);
                         double sum = neuron.getOutputs().stream().mapToDouble(link ->
-                            link.getWeight() * deltas[layerIdx][link.getTo().getIndexInLayer()]
+                            link.getWeight() * deltas[layerIdx][link.getTo().indexInLayer]
                         ).sum();
                         double gPrim = neuron.getOutput() * (1 - neuron.getOutput());
                         double delta = sum * gPrim;

src/main/groovy/net/zomis/machlearn/neural/DummyConnection.groovy

@@ -0,0 +1,32 @@
+package net.zomis.machlearn.neural;
+
+class DummyConnection implements NeuronLink {
+
+    private double weight = 1;
+
+    @Override
+    public double calculateInput() {
+        return getInputValue() * this.weight;
+    }
+
+    @Override
+    public double getInputValue() {
+        return 1;
+    }
+
+    @Override
+    public double getWeight() {
+        return this.weight;
+    }
+
+    @Override
+    public void setWeight(double value) {
+        this.weight = value;
+    }
+
+    @Override
+    public String toString() {
+        return "w0 $weight";
+    }
+
+}

src/main/groovy/net/zomis/machlearn/neural/DummyConnection.java

@@ -0,0 +1,34 @@
+package net.zomis.machlearn.neural;
+
+import java.util.Arrays;
+
+public class LearningData {
+
+    public final double[] inputs;
+    public final double[] outputs;
+
+    public LearningData(double[] inputs, double[] outputs) {
+        this.inputs = inputs;
+        this.outputs = outputs;
+    }
+
+    public double getInput(int i) {
+        return inputs[i];
+    }
+
+    @Override
+    public String toString() {
+        return "LearningData{" +
+                "inputs=" + Arrays.toString(inputs) +
+                ", outputs=" + Arrays.toString(outputs) +
+                '}';
+    }
+
+    public double[] getOutputs() {
+        return outputs;
+    }
+
+    public double[] getInputs() {
+        return inputs;
+    }
+}

src/main/groovy/net/zomis/machlearn/neural/LearningData.groovy

@@ -0,0 +1,139 @@
+package net.zomis.machlearn.neural;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class NeuralNetwork {
+
+    public List<NeuronLayer> layers = new ArrayList<>();
+
+    public List<NeuronLayer> getLayers() {
+        return layers;
+    }
+
+    public NeuronLayer getInputLayer() {
+        return getLayer(0);
+    }
+
+    public NeuronLayer getOutputLayer() {
+        return getLayer(layers.size() - 1);
+    }
+
+    public NeuronLayer getLayer(int layerIndex) {
+        return layers.get(layerIndex);
+    }
+
+    public NeuronLayer createLayer(String name) {
+        NeuronLayer layer = new NeuronLayer(name);
+        this.layers.add(layer);
+        return layer;
+    }
+
+    public int getLayerCount() {
+        return layers.size();
+    }
+
+    public Stream<NeuronLink> links() {
+        return this.layers.stream()
+            .skip(1)
+            .flatMap(it -> it.neurons.stream())
+            .flatMap(it -> it.inputs.stream());
+    }
+
+    public void printAll() {
+        System.out.println("$layerCount layers:");
+        layers.stream().forEach(it -> {
+            it.printNodes();
+            System.out.println();
+        });
+        System.out.println();
+    }
+
+    void save(OutputStream output) {
+        try (DataOutputStream it = new DataOutputStream(output)) {
+            it.writeInt(this.getLayerCount());
+            for (NeuronLayer layer : layers) {
+                it.writeInt(layer.size());
+                it.writeInt(layer.name.length());
+                it.writeBytes(layer.name);
+            }
+            for (NeuronLayer layer : layers) {
+                for (Neuron neuron : layer) {
+                    for (NeuronLink link : neuron.inputs) {
+                        it.writeDouble(link.getWeight());
+                    }
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    static NeuralNetwork load(InputStream input) {
+        NeuralNetwork network = new NeuralNetwork();
+        try (DataInputStream it = new DataInputStream(input)) {
+            int layers = it.readInt();
+            for (int i = 0; i < layers; i++) {
+                int size = it.readInt();
+                int nameLength = it.readInt();
+                StringBuilder name = new StringBuilder();
+                for (int nameIndex = 0; nameIndex < nameLength; nameIndex++) {
+                    name.append((char) it.readByte());
+                }
+                NeuronLayer layer = network.createLayer(name.toString());
+                for (int j = 0; j < size; j++) {
+                    layer.createNeuron();
+                }
+            }
+            for (int i = 0; i < layers; i++) {
+                NeuronLayer layer = network.getLayer(i);
+                if (i > 0) {
+                    final int ii = i;
+                    layer.neurons.forEach(it2 -> it2.addInputs(network.getLayer(ii - 1)));
+                }
+                for (Neuron neuron : layer) {
+                    for (NeuronLink link : neuron.inputs) {
+                        link.setWeight(it.readDouble());
+                    }
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return network;
+    }
+
+    public double[] run(double[] input) {
+        double[] output = new double[getOutputLayer().size()];
+        assert input.length == getInputLayer().size();
+        for (int i = 0; i < getInputLayer().size(); i++) {
+            getInputLayer().neurons.get(i).output = input[i];
+        }
+
+        int layerIndex = 0;
+        for (NeuronLayer layer : layers) {
+            if (layerIndex++ == 0) {
+                // Do not process input layer
+                continue;
+            }
+            for (Neuron node : layer) {
+                node.process();
+            }
+        }
+        for (int i = 0; i < getOutputLayer().size(); i++) {
+            output[i] = getOutputLayer().neurons.get(i).output;
+        }
+/*        for (int i = 0; i < inputLayer.size(); i++) {
+            inputLayer.getNeurons().get(i).output = 1
+        }*/
+
+        return output;
+    }
+
+    public NeuronLayer getLastLayer() {
+        return getLayer(layers.size() - 1);
+    }
+
+}