Merge pull request #11 from will-newmarch/release-0.6.0

Release 0.6.0

package.json

@@ -1,6 +1,6 @@
 {
   "name": "intuitive-neural-network",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "description": "An intuitive, object-orientated approach to a Neural Network library.",
   "main": "src/Network.js",
   "scripts": {

src/Synapse.js

@@ -48,6 +48,10 @@ class Synapse {
 		this.weight -= learningRate * this.error;
 	}
 
+	mapActivation(signal,count) {
+		this.input.mapActivation(signal * this.weight,count);
+	}
+
 	toObject() {
 		return {
 			type: this.constructor.name,

src/neuron/Neuron.js

@@ -51,6 +51,36 @@ class Neuron {
 		throw 'backPropagate method must be overidden!';
 	}
 
+	/**
+	 * Uses activation maximisation to discover the path of activation 
+	 * needed to activate this neuron to the supplied signal
+	 * @param {float} signal
+	 * @param {integer} count
+	 */
+	mapActivation(signal,count = null) {
+		if(!this.hasOwnProperty('mappedSignals')) this.mappedSignals = [];
+		this.mappedSignals.push(signal);
+		if(count === null || this.mappedSignals.length === count) {	
+			this.activation = this.mappedSignals.reduce((a,s) => a+s,0);
+			const expectedCount = count === null ? 1 : this.outputs[0].output.inputs.length;
+			for(let input of this.inputs) {
+				input.mapActivation(this.activation,expectedCount);
+			}
+			delete this.mappedSignals;
+		}
+	}
+
+	backPropagate(backSignal) {
+		this.outputSignals.push(backSignal);
+		if(this.outputSignals.length == this.outputs.length) {
+			const signal = this.outputSignals.reduce((a,s) => a+s,0);
+			this.error = signal + this.derivativeFunc(this.activation);
+			for (var i = 0; i < this.inputs.length; i++) {
+				this.inputs[i].backPropagate(this.error);
+			}
+		}
+	}
+
 	toObject() {
 		return {
 			type: this.constructor.name,

tests/activation-mapping.test.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const Network = require('../src/Network.js');
+
+test('library maps activation', () => {
+
+    // Build the network...
+    var network = new Network({
+        layers: [2,1],
+        bias: false
+    });
+
+    var data = [
+        {x: [1,0], y: [1]},
+        {x: [1,1], y: [3]}
+    ];
+
+    // Training the network...
+    var epochs = 10000;
+    var learningRate = 0.01;
+
+    for (var h = 0; h < epochs; h++) {
+
+        for (var i = 0; i < data.length; i++) {
+
+            let index = Math.floor(Math.random() * data.length);
+
+            network
+                .fire(data[index].x)
+                .backPropagate(data[index].y)
+                .applyError(learningRate)
+                .reset();
+
+        }
+    }
+    // Done.
+
+    // Testing the trained network...
+    network.layers[network.layers.length-1].neurons[0].mapActivation([1]);
+
+    expect(Math.round(network.layers[0].neurons[0].activation)).toBe(1);
+    expect(Math.round(network.layers[0].neurons[1].activation)).toBe(2);
+    // Done.
+
+});
+