Add BackPropagationConfig and update creature activation and propagat…

…ion (#312)

Co-authored-by: Nigel Leck <[email protected]>

bench/Activate.ts

@@ -1,4 +1,5 @@
 import { Creature } from "../src/Creature.ts";
+import { BackPropagationConfig } from "../src/architecture/BackPropagation.ts";
 
 /**
  * benchmark      time (avg)        iter/s             (min … max)       p75       p99      p995
@@ -16,9 +17,11 @@ creature.clearState();
 const inputs = makeInputs(creature);
 
 export function perform() {
+  const config = new BackPropagationConfig();
   for (let i = 0; i < 10000; i++) {
     const input = inputs[i % inputs.length];
-    creature.activate(input);
+    creature.activateAndTrace(input);
+    creature.propagate([i % 2], config);
   }
 }
 

src/Creature.ts

@@ -217,9 +217,9 @@ export class Creature implements CreatureInternal {
     this.state.clear();
   }
 
-  getActivation(indx: number) {
-    return this.state.activations[indx];
-  }
+  // getActivation(indx: number) {
+  //   return this.state.activations[indx];
+  // }
 
   /**
    * Activates the creature

src/architecture/CreatureState.ts

@@ -98,7 +98,7 @@ export class CreatureState {
   private nodeMap;
   private connectionMap;
   private network;
-  public activations: number[] = [];
+  public activations: Float32Array = new Float32Array(0);
   public propagated = false;
 
   constructor(network: Creature) {
@@ -139,21 +139,17 @@ export class CreatureState {
   }
 
   makeActivation(input: number[], feedbackLoop: boolean) {
-    if (this.activations.length == 0 || feedbackLoop == false) {
-      this.activations = input.slice();
-      this.activations.length = this.network.neurons.length;
-      this.activations.fill(0, input.length);
-    } else if (feedbackLoop) {
-      /** Leave the results from last run */
-      const rightArray = this.activations.slice(input.length);
-      this.activations = input.concat(rightArray);
+    if (feedbackLoop == false || this.activations.length == 0) {
+      this.activations = new Float32Array(this.network.neurons.length);
     }
+
+    this.activations.set(input);
   }
 
   clear() {
     this.nodeMap.clear();
     this.connectionMap.clear();
-    this.activations.length = 0;
+    this.activations = new Float32Array(0);
     this.propagated = false;
   }
 }

src/architecture/Neuron.ts

@@ -219,10 +219,11 @@ export class Neuron implements TagsInterface, NeuronInternal {
         const toList = this.creature.inwardConnections(this.index);
         let value = this.bias;
 
+        const activations = this.creature.state.activations;
         for (let i = toList.length; i--;) {
           const c = toList[i];
 
-          const fromActivation = this.creature.getActivation(c.from);
+          const fromActivation = activations[c.from];
 
           value += fromActivation * c.weight;
         }
@@ -348,9 +349,9 @@ export class Neuron implements TagsInterface, NeuronInternal {
       this,
       requestedActivation,
     );
-    const momentum = 1;
+
     let targetActivation = activation +
-      (rangeLimitedActivation - activation) * momentum;
+      (rangeLimitedActivation - activation);
 
     const ns = this.creature.state.node(this.index);
     if (Math.abs(activation - targetActivation) < config.plankConstant) {

src/methods/activations/aggregate/HYPOT.ts

@@ -24,10 +24,11 @@ export class HYPOT implements NeuronActivationInterface {
   activate(node: Neuron) {
     const toList = node.creature.inwardConnections(node.index);
     const values: number[] = new Array(toList.length);
+    const activations = node.creature.state.activations;
     for (let i = toList.length; i--;) {
       const c = toList[i];
 
-      values[i] = node.creature.getActivation(c.from) * c.weight;
+      values[i] = activations[c.from] * c.weight;
     }
 
     const value = Math.hypot(...values);

src/methods/activations/aggregate/IF.ts

@@ -157,12 +157,12 @@ export class IF implements NeuronActivationInterface, ApplyLearningsInterface {
     let negative = 0;
     let positive = 0;
 
+    const activations = node.creature.state.activations;
     const toList = node.creature.inwardConnections(node.index);
     for (let i = toList.length; i--;) {
       const c = toList[i];
 
-      const value = node.creature.getActivation(c.from) *
-        c.weight;
+      const value = activations[c.from] * c.weight;
 
       switch (c.type) {
         case "condition":
@@ -207,12 +207,12 @@ export class IF implements NeuronActivationInterface, ApplyLearningsInterface {
     let negative = 0;
     let positive = 0;
 
+    const activations = node.creature.state.activations;
     const toList = node.creature.inwardConnections(node.index);
     for (let i = toList.length; i--;) {
       const c = toList[i];
 
-      const value = limitActivation(node.creature.getActivation(c.from)) *
-        c.weight;
+      const value = limitActivation(activations[c.from]) * c.weight;
 
       switch (c.type) {
         case "condition":
@@ -291,12 +291,11 @@ export class IF implements NeuronActivationInterface, ApplyLearningsInterface {
     let condition = 0;
     let negativeCount = 0;
     let positiveCount = 0;
-
+    const activations = node.creature.state.activations;
     for (let i = toList.length; i--;) {
       const c = toList[i];
 
-      const value = limitActivation(node.creature.getActivation(c.from)) *
-        c.weight;
+      const value = limitActivation(activations[c.from]) * c.weight;
 
       switch (c.type) {
         case "condition":

src/methods/activations/aggregate/MAXIMUM.ts

@@ -25,11 +25,11 @@ export class MAXIMUM
 
   activate(node: Neuron) {
     const toList = node.creature.inwardConnections(node.index);
-    let maxValue = Infinity * -1;
+    let maxValue = Number.NEGATIVE_INFINITY;
+    const activations = node.creature.state.activations;
     for (let i = toList.length; i--;) {
       const c = toList[i];
-      const value = node.creature.getActivation(c.from) *
-        c.weight;
+      const value = activations[c.from] * c.weight;
       if (value > maxValue) {
         maxValue = value;
       }
@@ -42,13 +42,13 @@ export class MAXIMUM
     const toList = node.creature.inwardConnections(node.index);
     let maxValue = Infinity * -1;
     let usedConnection: SynapseInternal | null = null;
+    const activations = node.creature.state.activations;
     for (let i = toList.length; i--;) {
       const c = toList[i];
       const cs = node.creature.state.connection(c.from, c.to);
       if (cs.used == undefined) cs.used = false;
 
-      const value = node.creature.getActivation(c.from) *
-        c.weight;
+      const value = activations[c.from] * c.weight;
       if (value > maxValue) {
         maxValue = value;
         usedConnection = c;

src/methods/activations/aggregate/MEAN.ts

@@ -27,7 +27,8 @@ export class MEAN implements NeuronActivationInterface {
     const toList = node.creature.inwardConnections(node.index);
     for (let i = toList.length; i--;) {
       const c = toList[i];
-      const fromActivation = node.creature.getActivation(c.from);
+      const fromActivation = //node.creature.getActivation(c.from);
+        node.creature.state.activations[c.from];
       const activation = limitActivation(fromActivation);
 
       sum += activation * c.weight;

src/methods/activations/aggregate/MINIMUM.ts

@@ -26,10 +26,10 @@ export class MINIMUM
   activate(node: Neuron): number {
     const toList = node.creature.inwardConnections(node.index);
     let minValue = Infinity;
+    const activations = node.creature.state.activations;
     for (let i = toList.length; i--;) {
       const c = toList[i];
-      const value = node.creature.getActivation(c.from) *
-        c.weight;
+      const value = activations[c.from] * c.weight;
       if (value < minValue) {
         minValue = value;
       }
@@ -42,13 +42,13 @@ export class MINIMUM
     const toList = node.creature.inwardConnections(node.index);
     let minValue = Infinity;
     let usedConnection: SynapseInternal | null = null;
+    const activations = node.creature.state.activations;
     for (let i = toList.length; i--;) {
       const c = toList[i];
       const cs = node.creature.state.connection(c.from, c.to);
       if (cs.used == undefined) cs.used = false;
 
-      const value = node.creature.getActivation(c.from) *
-        c.weight;
+      const value = activations[c.from] * c.weight;
       if (value < minValue) {
         minValue = value;
         usedConnection = c;