Fixes issue 160

package.json

@@ -1,7 +1,7 @@
 {
   "name": "brain.js",
   "description": "Neural network library",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "author": "Heather Arthur <[email protected]>",
   "repository": {
     "type": "git",

src/neural-network.js

@@ -331,6 +331,7 @@ export default class NeuralNetwork {
   _getTrainOptsJSON() {
     return Object.keys(NeuralNetwork.trainDefaults)
       .reduce((opts, opt) => {
+        if (opt === 'timeout' && this.trainOpts[opt] === Infinity) return opts;
         if (this.trainOpts[opt]) opts[opt] = this.trainOpts[opt];
         if (opt === 'log') opts.log = typeof opts.log === 'function';
         return opts;

test/base/json.js

@@ -27,7 +27,12 @@ describe('JSON', () => {
   trainingOpts.log = true;
 
   const serialized = originalNet.toJSON();
-  const serializedNet = new NeuralNetwork().fromJSON(serialized);
+  const serializedNet = new NeuralNetwork()
+    .fromJSON(
+      JSON.parse(
+        JSON.stringify(serialized)
+      )
+    );
 
   const input = {'0' : Math.random(), b: Math.random()};
   describe('.toJSON()', () => {
@@ -71,39 +76,39 @@ describe('JSON', () => {
 
     describe('.trainOpts', () => {
       it('training options iterations', () => {
-        assert.equal(trainingOpts.iterations, serialized.trainOpts.iterations, `trainingOpts.are: ${trainingOpts.iterations} serialized should be the same but are: ${serialized.trainOpts.iterations}`);
+        assert.equal(trainingOpts.iterations, serialized.trainOpts.iterations, `trainingOpts are: ${trainingOpts.iterations} serialized should be the same but are: ${serialized.trainOpts.iterations}`);
       });
 
       it('training options errorThresh', () => {
-        assert.equal(trainingOpts.errorThresh, serialized.trainOpts.errorThresh, `trainingOpts.are: ${trainingOpts.errorThresh} serialized should be the same but are: ${serialized.trainOpts.errorThresh}`);
+        assert.equal(trainingOpts.errorThresh, serialized.trainOpts.errorThresh, `trainingOpts are: ${trainingOpts.errorThresh} serialized should be the same but are: ${serialized.trainOpts.errorThresh}`);
       });
 
       it('training options log', () => {
         assert.equal(trainingOpts.log, serialized.trainOpts.log, `log are: ${trainingOpts.log} serialized should be the same but are: ${serialized.trainOpts.log}`);
       });
 
       it('training options logPeriod', () => {
-        assert.equal(trainingOpts.logPeriod, serialized.trainOpts.logPeriod, `trainingOpts.are: ${trainingOpts.logPeriod} serialized should be the same but are: ${serialized.trainOpts.logPeriod}`);
+        assert.equal(trainingOpts.logPeriod, serialized.trainOpts.logPeriod, `trainingOpts are: ${trainingOpts.logPeriod} serialized should be the same but are: ${serialized.trainOpts.logPeriod}`);
       });
 
       it('training options learningRate', () => {
-        assert.equal(trainingOpts.learningRate, serialized.trainOpts.learningRate, `trainingOpts.are: ${trainingOpts.learningRate} serialized should be the same but are: ${serialized.trainOpts.learningRate}`);
+        assert.equal(trainingOpts.learningRate, serialized.trainOpts.learningRate, `trainingOpts are: ${trainingOpts.learningRate} serialized should be the same but are: ${serialized.trainOpts.learningRate}`);
       });
 
       it('training options momentum', () => {
-        assert.equal(trainingOpts.momentum, serialized.trainOpts.momentum, `trainingOpts.are: ${trainingOpts.momentum} serialized should be the same but are: ${serialized.trainOpts.momentum}`);
+        assert.equal(trainingOpts.momentum, serialized.trainOpts.momentum, `trainingOpts are: ${trainingOpts.momentum} serialized should be the same but are: ${serialized.trainOpts.momentum}`);
       });
 
       it('training options callback', () => {
-        assert.equal(trainingOpts.callback, serialized.trainOpts.callback, `trainingOpts.are: ${trainingOpts.callback} serialized should be the same but are: ${serialized.trainOpts.callback}`);
+        assert.equal(trainingOpts.callback, serialized.trainOpts.callback, `trainingOpts are: ${trainingOpts.callback} serialized should be the same but are: ${serialized.trainOpts.callback}`);
       });
 
       it('training options callbackPeriod', () => {
-        assert.equal(trainingOpts.callbackPeriod, serialized.trainOpts.callbackPeriod, `trainingOpts.are: ${trainingOpts.callbackPeriod} serialized should be the same but are: ${serialized.trainOpts.callbackPeriod}`);
+        assert.equal(trainingOpts.callbackPeriod, serialized.trainOpts.callbackPeriod, `trainingOpts are: ${trainingOpts.callbackPeriod} serialized should be the same but are: ${serialized.trainOpts.callbackPeriod}`);
       });
 
       it('training options timeout', () => {
-        assert.equal(trainingOpts.timeout, serialized.trainOpts.timeout, `trainingOpts.are: ${trainingOpts.timeout} serialized should be the same but are: ${serialized.trainOpts.timeout}`);
+        assert.equal(trainingOpts.timeout, serialized.trainOpts.timeout, `trainingOpts are: ${trainingOpts.timeout} serialized should be the same but are: ${serialized.trainOpts.timeout}`);
       });
     });
 
@@ -137,11 +142,11 @@ describe('JSON', () => {
 
       describe('.trainOpts', () => {
         it('training options iterations', () => {
-          assert.equal(trainingOpts.iterations, serializedNet.trainOpts.iterations, `trainingOpts.are: ${trainingOpts.iterations} serializedNet should be the same but are: ${serializedNet.trainOpts.iterations}`);
+          assert.equal(trainingOpts.iterations, serializedNet.trainOpts.iterations, `trainingOpts are: ${trainingOpts.iterations} serializedNet should be the same but are: ${serializedNet.trainOpts.iterations}`);
         });
 
         it('training options errorThresh', () => {
-          assert.equal(trainingOpts.errorThresh, serializedNet.trainOpts.errorThresh, `trainingOpts.are: ${trainingOpts.errorThresh} serializedNet should be the same but are: ${serializedNet.trainOpts.errorThresh}`);
+          assert.equal(trainingOpts.errorThresh, serializedNet.trainOpts.errorThresh, `trainingOpts are: ${trainingOpts.errorThresh} serializedNet should be the same but are: ${serializedNet.trainOpts.errorThresh}`);
         });
 
         it('training options log', () => {
@@ -150,27 +155,27 @@ describe('JSON', () => {
         });
 
         it('training options logPeriod', () => {
-          assert.equal(trainingOpts.logPeriod, serializedNet.trainOpts.logPeriod, `trainingOpts.are: ${trainingOpts.logPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.logPeriod}`);
+          assert.equal(trainingOpts.logPeriod, serializedNet.trainOpts.logPeriod, `trainingOpts are: ${trainingOpts.logPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.logPeriod}`);
         });
 
         it('training options learningRate', () => {
-          assert.equal(trainingOpts.learningRate, serializedNet.trainOpts.learningRate, `trainingOpts.are: ${trainingOpts.learningRate} serializedNet should be the same but are: ${serializedNet.trainOpts.learningRate}`);
+          assert.equal(trainingOpts.learningRate, serializedNet.trainOpts.learningRate, `trainingOpts are: ${trainingOpts.learningRate} serializedNet should be the same but are: ${serializedNet.trainOpts.learningRate}`);
         });
 
         it('training options momentum', () => {
-          assert.equal(trainingOpts.momentum, serializedNet.trainOpts.momentum, `trainingOpts.are: ${trainingOpts.momentum} serializedNet should be the same but are: ${serializedNet.trainOpts.momentum}`);
+          assert.equal(trainingOpts.momentum, serializedNet.trainOpts.momentum, `trainingOpts are: ${trainingOpts.momentum} serializedNet should be the same but are: ${serializedNet.trainOpts.momentum}`);
         });
 
         it('training options callback', () => {
-          assert.equal(trainingOpts.callback, serializedNet.trainOpts.callback, `trainingOpts.are: ${trainingOpts.callback} serializedNet should be the same but are: ${serializedNet.trainOpts.callback}`);
+          assert.equal(trainingOpts.callback, serializedNet.trainOpts.callback, `trainingOpts are: ${trainingOpts.callback} serializedNet should be the same but are: ${serializedNet.trainOpts.callback}`);
         });
 
         it('training options callbackPeriod', () => {
-          assert.equal(trainingOpts.callbackPeriod, serializedNet.trainOpts.callbackPeriod, `trainingOpts.are: ${trainingOpts.callbackPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.callbackPeriod}`);
+          assert.equal(trainingOpts.callbackPeriod, serializedNet.trainOpts.callbackPeriod, `trainingOpts are: ${trainingOpts.callbackPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.callbackPeriod}`);
         });
 
         it('training options timeout', () => {
-          assert.equal(trainingOpts.timeout, serializedNet.trainOpts.timeout, `trainingOpts.are: ${trainingOpts.timeout} serializedNet should be the same but are: ${serializedNet.trainOpts.timeout}`);
+          assert.equal(trainingOpts.timeout, serializedNet.trainOpts.timeout, `trainingOpts are: ${trainingOpts.timeout} serializedNet should be the same but are: ${serializedNet.trainOpts.timeout}`);
         });
       });
     });
@@ -192,3 +197,85 @@ describe('JSON', () => {
     })
   });
 });
+
+
+describe('default net json', () => {
+  const originalNet = new NeuralNetwork();
+
+  originalNet.train([
+    {
+      input: {'0': Math.random(), b: Math.random()},
+      output: {c: Math.random(), '0': Math.random()}
+    }, {
+      input: {'0': Math.random(), b: Math.random()},
+      output: {c: Math.random(), '0': Math.random()}
+    }
+  ]);
+
+  const serialized = originalNet.toJSON();
+  const serializedNet = new NeuralNetwork()
+    .fromJSON(
+      JSON.parse(
+        JSON.stringify(serialized)
+      )
+    );
+
+  const input = {'0' : Math.random(), b: Math.random()};
+
+  describe('.trainOpts', () => {
+    it('training options iterations', () => {
+      assert.equal(originalNet.trainOpts.iterations, serializedNet.trainOpts.iterations, `originalNet.trainOpts are: ${originalNet.trainOpts.iterations} serializedNet should be the same but are: ${serializedNet.trainOpts.iterations}`);
+    });
+
+    it('training options errorThresh', () => {
+      assert.equal(originalNet.trainOpts.errorThresh, serializedNet.trainOpts.errorThresh, `originalNet.trainOpts are: ${originalNet.trainOpts.errorThresh} serializedNet should be the same but are: ${serializedNet.trainOpts.errorThresh}`);
+    });
+
+    it('training options log', () => {
+      // Should have inflated to console.log
+      assert.equal(originalNet.trainOpts.log, serializedNet.trainOpts.log, `log are: ${originalNet.trainOpts.log} serializedNet should be the same but are: ${serializedNet.trainOpts.log}`);
+    });
+
+    it('training options logPeriod', () => {
+      assert.equal(originalNet.trainOpts.logPeriod, serializedNet.trainOpts.logPeriod, `originalNet.trainOpts are: ${originalNet.trainOpts.logPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.logPeriod}`);
+    });
+
+    it('training options learningRate', () => {
+      assert.equal(originalNet.trainOpts.learningRate, serializedNet.trainOpts.learningRate, `originalNet.trainOpts are: ${originalNet.trainOpts.learningRate} serializedNet should be the same but are: ${serializedNet.trainOpts.learningRate}`);
+    });
+
+    it('training options momentum', () => {
+      assert.equal(originalNet.trainOpts.momentum, serializedNet.trainOpts.momentum, `originalNet.trainOpts are: ${originalNet.trainOpts.momentum} serializedNet should be the same but are: ${serializedNet.trainOpts.momentum}`);
+    });
+
+    it('training options callback', () => {
+      assert.equal(originalNet.trainOpts.callback, serializedNet.trainOpts.callback, `originalNet.trainOpts are: ${originalNet.trainOpts.callback} serializedNet should be the same but are: ${serializedNet.trainOpts.callback}`);
+    });
+
+    it('training options callbackPeriod', () => {
+      assert.equal(originalNet.trainOpts.callbackPeriod, serializedNet.trainOpts.callbackPeriod, `originalNet.trainOpts are: ${originalNet.trainOpts.callbackPeriod} serializedNet should be the same but are: ${serializedNet.trainOpts.callbackPeriod}`);
+    });
+
+    it('training options timeout', () => {
+      console.log(originalNet.trainOpts.timeout);
+      console.log(serializedNet.trainOpts.timeout);
+      assert.equal(originalNet.trainOpts.timeout, serializedNet.trainOpts.timeout, `originalNet.trainOpts are: ${originalNet.trainOpts.timeout} serializedNet should be the same but are: ${serializedNet.trainOpts.timeout}`);
+    });
+  });
+
+  it('can run originalNet, and serializedNet, with same output', () => {
+    const output1 = originalNet.run(input);
+    const output2 = serializedNet.run(input);
+    assert.deepEqual(output2, output1,
+      'loading json serialized network failed');
+  });
+
+  it('if json.trainOpts is not set, ._updateTrainingOptions() is not called and activation defaults to sigmoid', () => {
+    const net = new NeuralNetwork();
+    net._updateTrainingOptions = () => {
+      throw new Error('_updateTrainingOptions was called');
+    };
+    net.fromJSON({ sizes: [], layers: [] });
+    assert(net.activation === 'sigmoid');
+  })
+})