@reicek/neataptic-ts 0.1.0

package/test/methods/mutation.test.ts

@@ -0,0 +1,451 @@
+import { mutation } from '../../src/methods/mutation';
+import Activation from '../../src/methods/activation';
+
+describe('Mutation Methods', () => {
+  describe('ADD_NODE', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.ADD_NODE).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.ADD_NODE.name).toBe('ADD_NODE');
+      });
+    });
+  });
+
+  describe('SUB_NODE', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.SUB_NODE).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.SUB_NODE.name).toBe('SUB_NODE');
+      });
+    });
+    describe('Scenario: keep_gates property', () => {
+      it('should have keep_gates property', () => {
+        // Assert
+        expect(mutation.SUB_NODE.keep_gates).toBe(true);
+      });
+    });
+  });
+
+  describe('ADD_CONN', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.ADD_CONN).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.ADD_CONN.name).toBe('ADD_CONN');
+      });
+    });
+  });
+
+  describe('SUB_CONN', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.SUB_CONN).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.SUB_CONN.name).toBe('SUB_CONN');
+      });
+    });
+  });
+
+  describe('MOD_WEIGHT', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.MOD_WEIGHT).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.MOD_WEIGHT.name).toBe('MOD_WEIGHT');
+      });
+    });
+    describe('Scenario: min property', () => {
+      it('should have min property', () => {
+        // Assert
+        expect(mutation.MOD_WEIGHT.min).toBe(-1);
+      });
+    });
+    describe('Scenario: max property', () => {
+      it('should have max property', () => {
+        // Assert
+        expect(mutation.MOD_WEIGHT.max).toBe(1);
+      });
+    });
+  });
+
+  describe('MOD_BIAS', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.MOD_BIAS).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.MOD_BIAS.name).toBe('MOD_BIAS');
+      });
+    });
+    describe('Scenario: min property', () => {
+      it('should have min property', () => {
+        // Assert
+        expect(mutation.MOD_BIAS.min).toBe(-1);
+      });
+    });
+    describe('Scenario: max property', () => {
+      it('should have max property', () => {
+        // Assert
+        expect(mutation.MOD_BIAS.max).toBe(1);
+      });
+    });
+  });
+
+  describe('MOD_ACTIVATION', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.MOD_ACTIVATION).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.MOD_ACTIVATION.name).toBe('MOD_ACTIVATION');
+      });
+    });
+    describe('Scenario: mutateOutput property', () => {
+      it('should have mutateOutput property', () => {
+        // Assert
+        expect(mutation.MOD_ACTIVATION.mutateOutput).toBe(true);
+      });
+    });
+    describe('Scenario: allowed property', () => {
+      it('should have allowed property as an array', () => {
+        // Assert
+        expect(Array.isArray(mutation.MOD_ACTIVATION.allowed)).toBe(true);
+      });
+      describe('Scenario: Contains expected activation functions', () => {
+        const expectedActivations = [
+          Activation.logistic,
+          Activation.tanh,
+          Activation.relu,
+          Activation.identity,
+          Activation.step,
+          Activation.softsign,
+          Activation.sinusoid,
+          Activation.gaussian,
+          Activation.bentIdentity,
+          Activation.bipolar,
+          Activation.bipolarSigmoid,
+          Activation.hardTanh,
+          Activation.absolute,
+          Activation.inverse,
+          Activation.selu,
+          Activation.softplus,
+          Activation.swish,
+          Activation.gelu,
+          Activation.mish,
+        ];
+        expectedActivations.forEach((act) => {
+          it(`should contain ${act.name} in allowed`, () => {
+            // Assert
+            expect(mutation.MOD_ACTIVATION.allowed).toContain(act);
+          });
+        });
+        it('should have allowed property with correct length', () => {
+          // Assert
+          expect(mutation.MOD_ACTIVATION.allowed.length).toBe(
+            expectedActivations.length
+          );
+        });
+        it('should not contain unexpected activation functions', () => {
+          // Arrange
+          const notExpected: any[] = [];
+          // Assert
+          notExpected.forEach((act) => {
+            expect(mutation.MOD_ACTIVATION.allowed).not.toContain(act);
+          });
+        });
+      });
+    });
+  });
+
+  describe('ADD_SELF_CONN', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.ADD_SELF_CONN).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.ADD_SELF_CONN.name).toBe('ADD_SELF_CONN');
+      });
+    });
+  });
+
+  describe('SUB_SELF_CONN', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.SUB_SELF_CONN).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.SUB_SELF_CONN.name).toBe('SUB_SELF_CONN');
+      });
+    });
+  });
+
+  describe('ADD_GATE', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.ADD_GATE).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.ADD_GATE.name).toBe('ADD_GATE');
+      });
+    });
+  });
+
+  describe('SUB_GATE', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.SUB_GATE).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.SUB_GATE.name).toBe('SUB_GATE');
+      });
+    });
+  });
+
+  describe('ADD_BACK_CONN', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.ADD_BACK_CONN).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.ADD_BACK_CONN.name).toBe('ADD_BACK_CONN');
+      });
+    });
+  });
+
+  describe('SUB_BACK_CONN', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.SUB_BACK_CONN).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.SUB_BACK_CONN.name).toBe('SUB_BACK_CONN');
+      });
+    });
+  });
+
+  describe('SWAP_NODES', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        // Assert
+        expect(mutation.SWAP_NODES).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        // Assert
+        expect(mutation.SWAP_NODES.name).toBe('SWAP_NODES');
+      });
+    });
+    describe('Scenario: mutateOutput property', () => {
+      it('should have mutateOutput property', () => {
+        // Assert
+        expect(mutation.SWAP_NODES.mutateOutput).toBe(true);
+      });
+    });
+  });
+
+  describe('ADD_LSTM_NODE', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        expect(mutation.ADD_LSTM_NODE).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        expect(mutation.ADD_LSTM_NODE.name).toBe('ADD_LSTM_NODE');
+      });
+    });
+  });
+
+  describe('ADD_GRU_NODE', () => {
+    describe('Scenario: Existence', () => {
+      it('should exist', () => {
+        expect(mutation.ADD_GRU_NODE).toBeDefined();
+      });
+    });
+    describe('Scenario: Name property', () => {
+      it('should have correct name property', () => {
+        expect(mutation.ADD_GRU_NODE.name).toBe('ADD_GRU_NODE');
+      });
+    });
+  });
+
+  describe('ALL', () => {
+    describe('Scenario: Existence', () => {
+      describe('when mutation.ALL is defined', () => {
+        it('should be defined', () => {
+          // Assert
+          expect(mutation.ALL).toBeDefined();
+        });
+      });
+      describe('when mutation.ALL is an array', () => {
+        it('should be an array', () => {
+          // Assert
+          expect(Array.isArray(mutation.ALL)).toBe(true);
+        });
+      });
+    });
+    describe('Scenario: Contains all mutation methods', () => {
+      const expectedMethods = [
+        mutation.ADD_NODE,
+        mutation.SUB_NODE,
+        mutation.ADD_CONN,
+        mutation.SUB_CONN,
+        mutation.MOD_WEIGHT,
+        mutation.MOD_BIAS,
+        mutation.MOD_ACTIVATION,
+        mutation.ADD_GATE,
+        mutation.SUB_GATE,
+        mutation.ADD_SELF_CONN,
+        mutation.SUB_SELF_CONN,
+        mutation.ADD_BACK_CONN,
+        mutation.SUB_BACK_CONN,
+        mutation.SWAP_NODES,
+        mutation.REINIT_WEIGHT,
+        mutation.BATCH_NORM,
+        mutation.ADD_LSTM_NODE,
+        mutation.ADD_GRU_NODE,
+      ];
+      expectedMethods.forEach((method) => {
+        describe(`when ALL contains ${method.name}`, () => {
+          it(`should contain ${method.name}`, () => {
+            // Assert
+            expect(mutation.ALL).toContain(method);
+          });
+        });
+      });
+      it('should have correct length', () => {
+        // Assert
+        expect(mutation.ALL.length).toBe(18);
+      });
+      it('should not contain unexpected mutation methods', () => {
+        // Arrange
+        const notExpected: any[] = [];
+        // Assert
+        notExpected.forEach((method) => {
+          expect(mutation.ALL).not.toContain(method);
+        });
+      });
+    });
+  });
+
+  describe('FFW', () => {
+    describe('Scenario: Existence', () => {
+      describe('when mutation.FFW is defined', () => {
+        it('should be defined', () => {
+          // Assert
+          expect(mutation.FFW).toBeDefined();
+        });
+      });
+      describe('when mutation.FFW is an array', () => {
+        it('should be an array', () => {
+          // Assert
+          expect(Array.isArray(mutation.FFW)).toBe(true);
+        });
+      });
+    });
+    describe('Scenario: Contains only feedforward-compatible mutation methods', () => {
+      const expectedMethods = [
+        mutation.ADD_NODE,
+        mutation.SUB_NODE,
+        mutation.ADD_CONN,
+        mutation.SUB_CONN,
+        mutation.MOD_WEIGHT,
+        mutation.MOD_BIAS,
+        mutation.MOD_ACTIVATION,
+        mutation.SWAP_NODES,
+        mutation.REINIT_WEIGHT,
+        mutation.BATCH_NORM,
+      ];
+      expectedMethods.forEach((method) => {
+        describe(`when FFW contains ${method.name}`, () => {
+          it(`should contain ${method.name}`, () => {
+            // Assert
+            expect(mutation.FFW).toContain(method);
+          });
+        });
+      });
+      it('should have correct length', () => {
+        // Assert
+        expect(mutation.FFW.length).toBe(10);
+      });
+      describe('Scenario: Does not contain recurrent mutation methods', () => {
+        const recurrentMethods = [
+          mutation.ADD_GATE,
+          mutation.SUB_GATE,
+          mutation.ADD_SELF_CONN,
+          mutation.SUB_SELF_CONN,
+          mutation.ADD_BACK_CONN,
+          mutation.SUB_BACK_CONN,
+        ];
+        recurrentMethods.forEach((method) => {
+          describe(`when FFW does not contain ${method.name}`, () => {
+            it(`should not contain ${method.name}`, () => {
+              // Assert
+              expect(mutation.FFW).not.toContain(method);
+            });
+          });
+        });
+      });
+    });
+  });
+});

package/test/methods/optimizers.advanced.test.ts

@@ -0,0 +1,80 @@
+import Network from '../../src/architecture/network';
+
+// Helper to build tiny network (1 input -> 1 output) for deterministic gradient on identity activation
+function buildNet() {
+  const net = new Network(1, 1);
+  // Force deterministic weights/bias
+  net.connections.forEach((c) => (c.weight = 0.5));
+  net.nodes.filter((n) => n.type !== 'input').forEach((n) => (n.bias = 0));
+  return net;
+}
+
+// Simple dataset: y = 2x so gradient direction is clear
+const data = Array.from({ length: 5 }, (_, i) => ({
+  input: [i],
+  output: [2 * i],
+}));
+
+// Run few iterations and collect first weight change sign/magnitude
+function trainWith(net: Network, opt: any) {
+  const before = net.connections[0].weight;
+  net.train(data, {
+    iterations: 3,
+    rate: 0.01,
+    error: 0,
+    cost: {
+      fn: (t: number[], o: number[]) => (o[0] - t[0]) ** 2,
+      calculate: (t: number[], o: number[]) => (o[0] - t[0]) ** 2,
+    },
+    optimizer: opt,
+    batchSize: 1,
+  });
+  const after = net.connections[0].weight;
+  return { before, after, delta: after - before };
+}
+
+describe('Advanced optimizers', () => {
+  describe('adamax', () => {
+    const { delta } = trainWith(buildNet(), { type: 'adamax' });
+    it('updates weight (non-zero delta)', () => {
+      expect(delta).not.toBe(0);
+    });
+  });
+  describe('nadam', () => {
+    const { delta } = trainWith(buildNet(), { type: 'nadam' });
+    it('applies nesterov style update (delta non-zero)', () => {
+      expect(delta).not.toBe(0);
+    });
+  });
+  describe('radam', () => {
+    const { delta } = trainWith(buildNet(), { type: 'radam' });
+    it('performs rectified adaptive update (delta non-zero)', () => {
+      expect(delta).not.toBe(0);
+    });
+  });
+  describe('lion', () => {
+    const { delta } = trainWith(buildNet(), { type: 'lion' });
+    it('uses sign-based update (delta non-zero)', () => {
+      expect(delta).not.toBe(0);
+    });
+  });
+  describe('adabelief', () => {
+    const { delta } = trainWith(buildNet(), { type: 'adabelief' });
+    it('adapts with belief variance (delta non-zero)', () => {
+      expect(delta).not.toBe(0);
+    });
+  });
+});
+
+describe('Lookahead wrapper', () => {
+  const net = buildNet();
+  const result = trainWith(net, {
+    type: 'lookahead',
+    baseType: 'adam',
+    la_k: 2,
+    la_alpha: 0.5,
+  });
+  it('applies lookahead blended update (delta non-zero)', () => {
+    expect(result.delta).not.toBe(0);
+  });
+});

package/test/methods/optimizers.behavior.test.ts

@@ -0,0 +1,105 @@
+import Network from '../../src/architecture/network';
+
+// Deterministic small dataset y = 2x
+const data = Array.from({ length: 4 }, (_, i) => ({
+  input: [i + 1],
+  output: [2 * (i + 1)],
+}));
+
+function buildNet() {
+  const net = new Network(1, 1);
+  // set fixed weights
+  net.connections.forEach((c) => (c.weight = 0.5));
+  net.nodes.filter((n) => n.type !== 'input').forEach((n) => (n.bias = 0));
+  return net;
+}
+
+describe('Optimizer specific behaviors', () => {
+  describe('adamw', () => {
+    const net = buildNet();
+    const before = net.connections[0].weight;
+    net.train(data, {
+      iterations: 5,
+      rate: 0.01,
+      optimizer: { type: 'adamw', weightDecay: 0.1 },
+    });
+    const after = net.connections[0].weight;
+    it('applies decoupled weight decay (weight decreased)', () => {
+      expect(after).toBeLessThan(before);
+    });
+  });
+
+  describe('lion', () => {
+    const net = buildNet();
+    const before = net.connections[0].weight;
+    net.train(data, {
+      iterations: 5,
+      rate: 0.01,
+      optimizer: { type: 'lion', beta1: 0.9, beta2: 0.99 },
+    });
+    const after = net.connections[0].weight;
+    it('updates weight (changed from before)', () => {
+      expect(after).not.toBe(before);
+    });
+    // Bound magnitude in separate single-expectation test
+    it('produces bounded cumulative magnitude (|delta| < 0.25)', () => {
+      expect(Math.abs(after - before)).toBeLessThan(0.25);
+    });
+  });
+
+  describe('lookahead sync', () => {
+    const net = buildNet();
+    net.train(data, {
+      iterations: 6,
+      rate: 0.01,
+      optimizer: {
+        type: 'lookahead',
+        baseType: 'adam',
+        la_k: 3,
+        la_alpha: 0.5,
+      },
+    });
+    const conn: any = net.connections[0];
+    it('creates shadow weight', () => {
+      expect(conn._la_shadowWeight).toBeDefined();
+    });
+    it('synchronizes weight to shadow on k-multiple', () => {
+      const conn: any = net.connections[0];
+      expect(conn.weight).toBeCloseTo(conn._la_shadowWeight, 10);
+    });
+  });
+
+  describe('string optimizer normalization', () => {
+    const net = buildNet();
+    net.train(data, { iterations: 1, rate: 0.01, optimizer: 'adam' });
+    const conn: any = net.connections[0];
+    it('creates first moment', () => {
+      expect(conn.opt_m).toBeDefined();
+    });
+    it('creates second moment', () => {
+      expect(conn.opt_v).toBeDefined();
+    });
+  });
+
+  describe('invalid optimizer name', () => {
+    it('throws error', () => {
+      const net = buildNet();
+      expect(() =>
+        net.train(data, { iterations: 1, rate: 0.01, optimizer: 'nope' as any })
+      ).toThrow('Unknown optimizer type');
+    });
+  });
+
+  describe('nested lookahead rejection', () => {
+    it('throws error', () => {
+      const net = buildNet();
+      expect(() =>
+        net.train(data, {
+          iterations: 1,
+          rate: 0.01,
+          optimizer: { type: 'lookahead', baseType: 'lookahead' },
+        })
+      ).toThrow('Nested lookahead');
+    });
+  });
+});