Merge pull request #12 from aika-algorithm/synapse-relations

Synapse relations

Author: aika-algorithm

src/main/java/org/aika/AbstractNode.java renamed to src/main/java/network/aika/AbstractNode.java

@@ -14,12 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.aika;
+package network.aika;
 
-import org.aika.lattice.Node;
-import org.aika.lattice.NodeActivation;
-import org.aika.neuron.INeuron;
-import org.aika.neuron.Neuron;
+import network.aika.lattice.Node;
+import network.aika.lattice.NodeActivation;
+import network.aika.neuron.INeuron;
+import network.aika.neuron.Neuron;
 
 import java.io.DataInput;
 import java.io.IOException;

src/main/java/network/aika/ActivationFunction.java

@@ -0,0 +1,25 @@
+package network.aika;
+
+
+public enum ActivationFunction {
+
+    RECTIFIED_SCALED_LOGISTIC_SIGMOID(x -> Math.max(0.0, (2.0 * Utils.sigmoid(x)) - 1.0)),
+    RECTIFIED_HYPERBOLIC_TANGENT(x -> Math.max(0.0, Math.tanh(x))),
+    RECTIFIED_LINEAR_UNIT(x -> Math.max(0.0, x));
+
+    Function f;
+
+    ActivationFunction(Function f) {
+        this.f = f;
+    }
+
+    public double f(double x) {
+        return f.f(x);
+    }
+
+
+    interface Function {
+        double f(double x);
+    }
+
+}

src/main/java/org/aika/Converter.java renamed to src/main/java/network/aika/Converter.java

@@ -14,48 +14,53 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.aika;
+package network.aika;
 
-import org.aika.lattice.AndNode;
-import org.aika.lattice.InputNode;
-import org.aika.lattice.Node;
-import org.aika.lattice.OrNode;
-import org.aika.neuron.INeuron;
-import org.aika.neuron.Synapse;
+import network.aika.lattice.AndNode;
+import network.aika.lattice.Node;
+import network.aika.lattice.OrNode;
+import network.aika.neuron.INeuron;
+import network.aika.neuron.relation.Relation;
+import network.aika.neuron.Synapse;
 
 import java.util.*;
 
+import static network.aika.neuron.activation.Range.Mapping.NONE;
+
 /**
  * Converts the synapse weights of a neuron into a boolean logic representation of this neuron.
  *
  * @author Lukas Molzberger
  */
 public class Converter {
 
-    public static int MAX_AND_NODE_SIZE = 4;
+    public static int MAX_AND_NODE_SIZE = 6;
 
 
     public static Comparator<Synapse> SYNAPSE_COMP = (s1, s2) -> {
-        int r = Double.compare(s2.weight, s1.weight);
+        int r = Boolean.compare(
+                s2.key.rangeOutput.begin != NONE || s2.key.rangeOutput.end != NONE || s2.key.identity,
+                s1.key.rangeOutput.begin != NONE || s1.key.rangeOutput.end != NONE || s1.key.identity
+        );
+        if (r != 0) return r;
+        r = Double.compare(s2.weight, s1.weight);
         if (r != 0) return r;
-        return Synapse.INPUT_SYNAPSE_COMP.compare(s1, s2);
+        return Integer.compare(s1.id, s2.id);
     };
 
-    private Model model;
     private int threadId;
     private INeuron neuron;
     private Document doc;
     private OrNode outputNode;
     private Collection<Synapse> modifiedSynapses;
 
 
-    public static boolean convert(Model m, int threadId, Document doc, INeuron neuron, Collection<Synapse> modifiedSynapses) {
-        return new Converter(m, threadId, doc, neuron, modifiedSynapses).convert();
+    public static boolean convert(int threadId, Document doc, INeuron neuron, Collection<Synapse> modifiedSynapses) {
+        return new Converter(threadId, doc, neuron, modifiedSynapses).convert();
     }
 
 
-    private Converter(Model model, int threadId, Document doc, INeuron neuron, Collection<Synapse> modifiedSynapses) {
-        this.model = model;
+    private Converter(int threadId, Document doc, INeuron neuron, Collection<Synapse> modifiedSynapses) {
         this.doc = doc;
         this.neuron = neuron;
         this.threadId = threadId;
@@ -70,19 +75,13 @@ private boolean convert() {
 
         if(neuron.biasSum + neuron.posDirSum + neuron.posRecSum <= 0.0) {
             neuron.requiredSum = neuron.posDirSum + neuron.posRecSum;
-            outputNode.removeParents(threadId, false);
+            outputNode.removeParents(threadId);
             return false;
         }
 
-        TreeSet<Synapse> tmp = new TreeSet<>(SYNAPSE_COMP);
-        for(Synapse s: neuron.inputSynapses.values()) {
-            if(!s.isNegative() && !s.key.isRecurrent && !s.inactive) {
-                tmp.add(s);
-            }
-        }
+        List<Synapse> candidates = prepareCandidates();
 
-        Integer offset = null;
-        Node requiredNode = null;
+        NodeContext nodeContext = null;
         boolean noFurtherRefinement = false;
         TreeSet<Synapse> reqSyns = new TreeSet<>(Synapse.INPUT_SYNAPSE_COMP);
         double sum = 0.0;
@@ -91,7 +90,7 @@ private boolean convert() {
         if(neuron.numDisjunctiveSynapses == 0) {
             double remainingSum = neuron.posDirSum;
             int i = 0;
-            for (Synapse s : tmp) {
+            for (Synapse s : candidates) {
                 final boolean isOptionalInput = sum + remainingSum - s.weight + neuron.posRecSum + neuron.biasSum > 0.0;
                 final boolean maxAndNodesReached = i >= MAX_AND_NODE_SIZE;
                 if (isOptionalInput || maxAndNodesReached) {
@@ -102,8 +101,11 @@ private boolean convert() {
                 neuron.requiredSum += s.weight;
                 reqSyns.add(s);
 
-                requiredNode = getNextLevelNode(offset, requiredNode, s);
-                offset = Utils.nullSafeMin(s.key.relativeRid, offset);
+                NodeContext nlNodeContext = expandNode(nodeContext, s);
+                if(nlNodeContext == null) {
+                    break;
+                }
+                nodeContext = nlNodeContext;
 
                 i++;
 
@@ -114,45 +116,76 @@ private boolean convert() {
                     noFurtherRefinement = true;
                     break;
                 }
-            }
 
-            outputNode.removeParents(threadId, false);
-            if (requiredNode != outputNode.requiredNode) {
-                outputNode.requiredNode = requiredNode;
             }
 
+            outputNode.removeParents(threadId);
+
             if (noFurtherRefinement || i == MAX_AND_NODE_SIZE) {
-                outputNode.addInput(offset, threadId, requiredNode, false);
+                outputNode.addInput(nodeContext.getSynapseIds(), threadId, nodeContext.node);
             } else {
-                for (Synapse s : tmp) {
+                for (Synapse s : candidates) {
                     boolean belowThreshold = sum + s.weight + remainingSum + neuron.posRecSum + neuron.biasSum <= 0.0;
                     if (belowThreshold) {
                         break;
                     }
 
                     if (!reqSyns.contains(s)) {
-                        Node nln;
-                        nln = getNextLevelNode(offset, requiredNode, s);
-
-                        Integer nOffset = Utils.nullSafeMin(s.key.relativeRid, offset);
-                        outputNode.addInput(nOffset, threadId, nln, false);
-                        remainingSum -= s.weight;
+                        NodeContext nlNodeContext = expandNode(nodeContext, s);
+                        if(nlNodeContext != null) {
+                            outputNode.addInput(nlNodeContext.getSynapseIds(), threadId, nlNodeContext.node);
+                            remainingSum -= s.weight;
+                        }
                     }
                 }
             }
         } else {
             for (Synapse s : modifiedSynapses) {
                 if (s.weight + neuron.posRecSum + neuron.biasSum > 0.0) {
-                    Node nln = s.inputNode.get();
-                    offset = s.key.relativeRid;
-                    outputNode.addInput(offset, threadId, nln, false);
+                    NodeContext nlNodeContext = expandNode(nodeContext, s);
+                    outputNode.addInput(nlNodeContext.getSynapseIds(), threadId, nlNodeContext.node);
                 }
             }
         }
 
         return true;
     }
 
+    private List<Synapse> prepareCandidates() {
+        Synapse syn = getBestSynapse(neuron.inputSynapses.values());
+
+        TreeSet<Integer> alreadyCollected = new TreeSet<>();
+        ArrayList<Synapse> selectedCandidates = new ArrayList<>();
+        TreeMap<Integer, Synapse> relatedSyns = new TreeMap<>();
+        while(syn != null && selectedCandidates.size() < MAX_AND_NODE_SIZE) {
+            relatedSyns.remove(syn.id);
+            selectedCandidates.add(syn);
+            alreadyCollected.add(syn.id);
+            for(Integer synId: syn.relations.keySet()) {
+                if(!alreadyCollected.contains(synId)) {
+                    relatedSyns.put(synId, syn.output.getSynapseById(synId));
+                }
+            }
+
+            syn = getBestSynapse(relatedSyns.values());
+        }
+
+        return selectedCandidates;
+    }
+
+
+    private Synapse getBestSynapse(Collection<Synapse> synapses) {
+        Synapse maxSyn = null;
+        for(Synapse s: synapses) {
+            if(!s.isNegative() && !s.key.isRecurrent && !s.inactive) {
+                if(maxSyn == null || SYNAPSE_COMP.compare(maxSyn, s) > 0) {
+                    maxSyn = s;
+                }
+            }
+        }
+        return maxSyn;
+    }
+
 
     public static final int DIRECT = 0;
     public static final int RECURRENT = 1;
@@ -171,14 +204,6 @@ private void initInputNodesAndComputeWeightSums() {
             INeuron in = s.input.get();
             in.lock.acquireWriteLock();
             try {
-                if (s.inputNode == null) {
-                    InputNode iNode = InputNode.add(model, s.key.createInputNodeKey(), s.input.get());
-                    iNode.setModified();
-                    iNode.setSynapse(s);
-                    iNode.postCreate(doc);
-                    s.inputNode = iNode.provider;
-                }
-
                 if (!s.inactive) {
                     sumDelta[s.key.isRecurrent ? RECURRENT : DIRECT][s.isNegative() ? NEGATIVE : POSITIVE] -= s.weight;
                     sumDelta[s.key.isRecurrent ? RECURRENT : DIRECT][s.getNewWeight() <= 0.0 ? NEGATIVE : POSITIVE] += s.getNewWeight();
@@ -225,13 +250,53 @@ private void initInputNodesAndComputeWeightSums() {
     }
 
 
-    private Node getNextLevelNode(Integer offset, Node requiredNode, Synapse s) {
-        Node nln;
-        if (requiredNode == null) {
-            nln = s.inputNode.get();
+    private NodeContext expandNode(NodeContext nc, Synapse s) {
+        if (nc == null) {
+            NodeContext nln = new NodeContext();
+            nln.node = s.input.get().outputNode.get();
+            nln.offsets = new Synapse[] {s};
+            return nln;
         } else {
-            nln = AndNode.createNextLevelNode(model, threadId, doc, requiredNode, new AndNode.Refinement(s.key.relativeRid, offset, s.inputNode), null);
+            Relation[] relations = new Relation[nc.offsets.length];
+            for(int i = 0; i < nc.offsets.length; i++) {
+                Synapse linkedSynapse = nc.offsets[i];
+                relations[i] = s.relations.get(linkedSynapse.id);
+            }
+
+            NodeContext nln = new NodeContext();
+            nln.offsets = new Synapse[nc.offsets.length + 1];
+            AndNode.Refinement ref = new AndNode.Refinement(new AndNode.RelationsMap(relations), s.input.get().outputNode);
+            AndNode.RefValue rv = nc.node.extend(threadId, doc, ref);
+            if(rv == null) {
+                return null;
+            }
+
+            nln.node = rv.child.get(doc);
+
+            for (int i = 0; i < nc.offsets.length; i++) {
+                nln.offsets[rv.offsets[i]] = nc.offsets[i];
+            }
+            for (int i = 0; i < nln.offsets.length; i++) {
+                if (nln.offsets[i] == null) {
+                    nln.offsets[i] = s;
+                }
+            }
+            return nln;
+        }
+    }
+
+
+    private class NodeContext {
+        Node node;
+
+        Synapse[] offsets;
+
+        int[] getSynapseIds() {
+            int[] result = new int[offsets.length];
+            for(int i = 0; i < result.length; i++) {
+                result[i] = offsets[i].id;
+            }
+            return result;
         }
-        return nln;
     }
 }

src/main/java/network/aika/DistanceFunction.java

@@ -0,0 +1,26 @@
+package network.aika;
+
+
+import network.aika.neuron.activation.Activation;
+
+public enum DistanceFunction {
+
+    NONE((iAct, oAct) -> 1.0),
+    DEGRADING((iAct, oAct) -> 1.0 / ((double) (1 + Math.abs(oAct.range.begin - iAct.range.begin))));
+
+    Function f;
+
+    DistanceFunction(Function f) {
+        this.f = f;
+    }
+
+    public double f(Activation iAct, Activation oAct) {
+        return f.f(iAct, oAct);
+    }
+
+
+    interface Function {
+        double f(Activation iAct, Activation oAct);
+    }
+
+}