Merge pull request #14 from aika-algorithm/conflict-refactoring

Conflict refactoring

Author: aika-algorithm

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

@@ -1,6 +1,9 @@
 package network.aika;
 
-
+/**
+ *
+ * @author Lukas Molzberger
+ */
 public enum ActivationFunction {
 
     NULL_FUNCTION(x -> 0.0),

src/main/java/network/aika/Document.java

@@ -24,21 +24,23 @@
 import network.aika.neuron.INeuron;
 import network.aika.neuron.Synapse;
 import network.aika.neuron.activation.Activation;
-import network.aika.neuron.activation.Activation.Option;
 import network.aika.neuron.activation.Activation.OscillatingActivationsException;
-import network.aika.neuron.activation.Candidate;
 import network.aika.neuron.activation.Position;
-import network.aika.neuron.activation.SearchNode;
-import network.aika.neuron.activation.SearchNode.TimeoutException;
+import network.aika.neuron.activation.link.Linker;
+import network.aika.neuron.activation.search.Option;
+import network.aika.neuron.activation.search.SearchNode;
+import network.aika.neuron.activation.search.SearchNode.TimeoutException;
 import network.aika.neuron.activation.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static network.aika.neuron.activation.SearchNode.Decision.SELECTED;
-import static network.aika.neuron.activation.SearchNode.Decision.UNKNOWN;
+import static network.aika.neuron.INeuron.Type.*;
+import static network.aika.neuron.activation.Activation.CANDIDATE_COMP;
+import static network.aika.neuron.activation.search.Decision.SELECTED;
+import static network.aika.neuron.activation.search.Decision.UNKNOWN;
 
 
 /**
@@ -57,11 +59,6 @@ public class Document implements Comparable<Document> {
     public static int MAX_ROUND = 20;
     public static int ROUND_LIMIT = -1;
 
-    /**
-     * Experimental code: not working yet!
-     */
-    public static boolean INCREMENTAL_MODE = false;
-
     private final int id;
     private final StringBuilder content;
 
@@ -109,8 +106,6 @@ public class Document implements Comparable<Document> {
 
     private TreeMap<Integer, Activation> activationsById = new TreeMap<>();
 
-    private int lastProcessedActivationId = -1;
-
     private static class ActKey {
         int slot;
         Position pos;
@@ -130,7 +125,7 @@ public ActKey(int slot, Position pos, INeuron neuron, int actId) {
 
 
     public SearchNode selectedSearchNode;
-    public ArrayList<Candidate> candidates = new ArrayList<>();
+    public ArrayList<Activation> candidates = new ArrayList<>();
 
     public long createV;
 
@@ -369,36 +364,30 @@ public void propagate() {
 
 
     public void generateCandidates() throws CyclicDependencyException {
-        TreeSet<Candidate> tmp = new TreeSet<>();
+        TreeSet<Activation> tmp = new TreeSet<>(CANDIDATE_COMP);
         int i = 0;
 
-        if(!INCREMENTAL_MODE) {
-            candidates.clear();
-        }
-
-        for(Activation act: activationsById.subMap(INCREMENTAL_MODE ? lastProcessedActivationId : -1, false, Integer.MAX_VALUE, true).values()) {
-            if (act.getDecision() == UNKNOWN && act.getUpperBound() > 0.0) {
-                SearchNode.invalidateCachedDecision(act);
-                tmp.add(new Candidate(act, i++));
-
-                lastProcessedActivationId = Math.max(lastProcessedActivationId, act.getId());
+        for (Activation act : activationsById.values()) {
+            if (act.getType() == EXCITATORY && act.getDecision() == UNKNOWN && act.getUpperBound() > 0.0) {
+                act.setCandidateId(i++);
+                tmp.add(act);
             }
         }
 
         long v = visitedCounter++;
         for(Activation act: inputNeuronActivations) {
-            act.markedHasCandidate = v;
+            act.markHasCandidate(v);
         }
 
         while (!tmp.isEmpty()) {
             int oldSize = tmp.size();
-            for (Candidate c : tmp) {
-                if (c.checkDependenciesSatisfied(v)) {
-                    tmp.remove(c);
-                    c.setId(candidates.size());
-                    candidates.add(c);
+            for (Activation act : tmp) {
+                if (act.checkDependenciesSatisfied(v)) {
+                    tmp.remove(act);
+                    act.setCandidateId(candidates.size());
+                    candidates.add(act);
 
-                    c.getActivation().markedHasCandidate = v;
+                    act.markHasCandidate(v);
                     break;
                 }
             }
@@ -423,15 +412,17 @@ public void process() throws TimeoutException, CyclicDependencyException, Oscill
     public void process(Long timeoutInMilliSeconds) throws TimeoutException, CyclicDependencyException, OscillatingActivationsException {
         linker.lateLinking();
 
-        inputNeuronActivations.forEach(act -> valueQueue.propagateActivationValue(0, act));
+        inputNeuronActivations.forEach(act -> {
+            valueQueue.propagateActivationValue(act, null, true, true);
+        });
 
         generateCandidates();
 
-        SearchNode rootNode = null;
-        if(selectedSearchNode == null || !INCREMENTAL_MODE) {
-            selectedSearchNode = new SearchNode(this, null, null, 0);
-            rootNode = selectedSearchNode;
-        }
+        selectedSearchNode = new SearchNode(this, null, null, 0);
+        selectedSearchNode.updateActivations(this);
+        storeFinalState();
+
+        SearchNode rootNode = selectedSearchNode;
 
         SearchNode.search(this, selectedSearchNode, visitedCounter++, timeoutInMilliSeconds);
 
@@ -448,30 +439,23 @@ public void process(Long timeoutInMilliSeconds) throws TimeoutException, CyclicD
     }
 
 
-    private void computeSoftMax() {
-        for (Activation act : activationsById.values()) {
-            double offset = Double.MAX_VALUE;
-            for (Option option : act.getOptions()) {
-                offset = Math.min(offset, Math.log(option.cacheFactor) + option.weight);
-            }
+    public void storeFinalState() {
+        for(Activation act: activationsById.values()) {
+            act.finalOption = act.currentOption;
+        }
+    }
 
-            double norm = 0.0;
-            for (Option option : act.getOptions()) {
-                norm += Math.exp(Math.log(option.cacheFactor) + option.weight - offset);
-            }
 
-            for (Option option : act.getOptions()) {
-                if (option.decision == SELECTED) {
-                    option.p = Math.exp(Math.log(option.cacheFactor) + option.weight - offset) / norm;
-                }
-            }
+    private void computeSoftMax() {
+        for (Activation act : activationsById.values()) {
+            act.computeSoftMax();
         }
     }
 
 
     public void dumpDebugCandidateStatistics() {
-        for (Candidate c : candidates) {
-            log.info(c.toString());
+        for (Activation act : candidates) {
+            log.info(act.searchStateToString());
         }
     }
 
@@ -605,20 +589,6 @@ public String activationsToString() {
     }
 
 
-    public String dumpOscillatingActivations() {
-        StringBuilder sb = new StringBuilder();
-        activatedNeurons.stream()
-                .flatMap(n -> n.getActivations(this, false))
-                .filter(act -> act.isOscillating())
-                .forEach(act -> {
-                    sb.append(act.getId() + " " + act.slotsToString() + " " + act.getDecision() + "\n");
-                    sb.append(act.linksToString() + "\n");
-                    sb.append("\n");
-                });
-        return sb.toString();
-    }
-
-
     public static class CyclicDependencyException extends RuntimeException {
 
         public CyclicDependencyException() {

src/main/java/network/aika/Model.java

@@ -23,8 +23,7 @@
 import network.aika.neuron.Neuron;
 import network.aika.Provider.SuspensionMode;
 import network.aika.neuron.Synapse;
-import network.aika.neuron.activation.Linker;
-import network.aika.neuron.activation.SearchNode;
+import network.aika.neuron.activation.search.SearchNode;
 
 import java.io.DataInput;
 import java.io.DataOutput;
@@ -34,8 +33,6 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
-import static network.aika.neuron.INeuron.Type.INPUT;
-
 
 /**
  * The model consists of two layers. The first layer is the actual neural network consisting of neurons and synapses.
@@ -57,8 +54,6 @@ public class Model {
 
     public SuspensionHook suspensionHook;
 
-    public SearchNode.SkipSelectStep skipSelectStep = (act) -> false;
-
     public AtomicInteger docIdCounter = new AtomicInteger(0);
     public AtomicInteger currentId = new AtomicInteger(0);
 
@@ -99,15 +94,6 @@ public void setSuspensionHook(SuspensionHook suspensionHook) {
     }
 
 
-    public SearchNode.SkipSelectStep getSkipSelectStep() {
-        return skipSelectStep;
-    }
-
-    public void setSkipSelectStep(SearchNode.SkipSelectStep skipSelectStep) {
-        this.skipSelectStep = skipSelectStep;
-    }
-
-
     public Neuron createNeuron(Type type) {
         return createNeuron(null, type);
     }

src/main/java/network/aika/PassiveInputFunction.java

@@ -3,6 +3,10 @@
 import network.aika.neuron.Synapse;
 import network.aika.neuron.activation.Activation;
 
+/**
+ *
+ * @author Lukas Molzberger
+ */
 public interface PassiveInputFunction {
 
     double getActivationValue(Synapse s, Activation outputActivation);

src/main/java/network/aika/Provider.java

@@ -6,7 +6,10 @@
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;
 
-
+/**
+ *
+ * @author Lukas Molzberger
+ */
 public class Provider<T extends AbstractNode> implements Comparable<Provider<?>> {
 
     protected Model model;

src/main/java/network/aika/Utils.java

@@ -37,4 +37,22 @@ public static String collapseText(String txt, int length) {
         }
     }
 
+
+    public static String addPadding(String s, int targetSize) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(s);
+        for(int i = s.length(); i < targetSize; i++) {
+            sb.append(' ');
+        }
+
+        return sb.toString();
+    }
+
+
+    public static Integer max(Integer a, Integer b) {
+        if(a == null) return b;
+        if(b == null) return a;
+
+        return Math.max(a, b);
+    }
 }