@reicek/neataptic-ts 0.1.0

package/test/methods/optimizers.formula.test.ts

@@ -0,0 +1,89 @@
+import Network from '../../src/architecture/network';
+
+// Deterministic tiny dataset y=2x
+const data = Array.from({ length: 3 }, (_, i) => ({
+  input: [i + 1],
+  output: [2 * (i + 1)],
+}));
+
+function buildNet() {
+  const net = new Network(1, 1);
+  net.connections.forEach((c) => (c.weight = 0.5));
+  net.nodes.filter((n) => n.type !== 'input').forEach((n) => (n.bias = 0));
+  return net;
+}
+
+// Utility to run one iteration and capture internal optimizer state
+function trainSteps(net: Network, opt: any, iterations: number, rate = 0.01) {
+  net.train(data, {
+    iterations,
+    rate,
+    optimizer: opt,
+    batchSize: 1,
+    error: 0,
+    cost: {
+      fn: (t: number[], o: number[]) => (o[0] - t[0]) ** 2,
+      calculate: (t: number[], o: number[]) => (o[0] - t[0]) ** 2,
+    },
+  });
+}
+
+describe('Optimizer formula characteristics', () => {
+  describe('adamax infinity norm vs adam second moment', () => {
+    const netA = buildNet();
+    const netB = buildNet();
+    trainSteps(netA, { type: 'adamax' }, 2);
+    trainSteps(netB, { type: 'adam' }, 2);
+    const connA: any = netA.connections[0];
+    const connB: any = netB.connections[0];
+    it('maintains opt_u (infinity norm) different from sqrt(v)', () => {
+      expect(connA.opt_u).not.toBeUndefined();
+    });
+  });
+
+  describe('nadam nesterov lookahead produces larger early step than adam', () => {
+    const netN = buildNet();
+    const netA = buildNet();
+    trainSteps(netN, { type: 'nadam' }, 1); // single step
+    trainSteps(netA, { type: 'adam' }, 1);
+    const deltaN = netN.connections[0].weight - 0.5;
+    const deltaA = netA.connections[0].weight - 0.5;
+    it('has different first step magnitude from adam', () => {
+      expect(Math.abs(deltaN - deltaA)).toBeGreaterThan(0);
+    });
+  });
+
+  describe('radam early unrectified vs later rectified variance', () => {
+    const netEarly = buildNet();
+    const netLate = buildNet();
+    trainSteps(netEarly, { type: 'radam' }, 1);
+    trainSteps(netLate, { type: 'radam' }, 10);
+    const earlyDelta = Math.abs(netEarly.connections[0].weight - 0.5);
+    const lateDelta = Math.abs(netLate.connections[0].weight - 0.5);
+    it('late step magnitude differs from very early step', () => {
+      expect(Math.abs(lateDelta - earlyDelta)).toBeGreaterThan(0);
+    });
+  });
+
+  describe('adabelief variance differs from adam given same gradients', () => {
+    const netBelief = buildNet();
+    const netAdam = buildNet();
+    trainSteps(netBelief, { type: 'adabelief' }, 2);
+    trainSteps(netAdam, { type: 'adam' }, 2);
+    const cB: any = netBelief.connections[0];
+    const cA: any = netAdam.connections[0];
+    it('maintains distinct second moment estimate', () => {
+      expect(cB.opt_v).not.toBe(cA.opt_v);
+    });
+  });
+
+  describe('lookahead defaults', () => {
+    const net = buildNet();
+    // Provide only type to trigger default baseType and params
+    trainSteps(net, { type: 'lookahead' }, 3);
+    const conn: any = net.connections[0];
+    it('creates shadow weight with default params', () => {
+      expect(conn._la_shadowWeight).toBeDefined();
+    });
+  });
+});

package/test/methods/rate.cosineWarmRestarts.test.ts

@@ -0,0 +1,44 @@
+import Rate from '../../src/methods/rate';
+
+describe('Rate.cosineAnnealingWarmRestarts', () => {
+  const base = 0.1;
+  const period = 5;
+  const min = 0.001;
+  const tMult = 2;
+  const fn = Rate.cosineAnnealingWarmRestarts(period, min, tMult);
+
+  describe('First cycle peak at iteration 0', () => {
+    const value = fn(base, 0);
+    it('returns ~base at start of first cycle', () => {
+      expect(value).toBeCloseTo(base, 10);
+    });
+  });
+
+  describe('First cycle mid (iteration 2)', () => {
+    const value = fn(base, 2);
+    it('returns value between min and base', () => {
+      expect(value).toBeLessThan(base);
+    });
+  });
+
+  describe('End of first cycle (iteration 4)', () => {
+    const value = fn(base, 4);
+    it('returns near min at end of cycle', () => {
+      expect(value).toBeLessThanOrEqual(base * 0.51); // rough check downward
+    });
+  });
+
+  describe('Start of second (restart) cycle (iteration 5)', () => {
+    const value = fn(base, 5);
+    it('resets close to base after restart', () => {
+      expect(value).toBeCloseTo(base, 2);
+    });
+  });
+
+  describe('Within second (longer) cycle (iteration 8)', () => {
+    const value = fn(base, 8);
+    it('still between min and base mid second cycle', () => {
+      expect(value).toBeGreaterThan(min);
+    });
+  });
+});

package/test/methods/rate.linearWarmupDecay.test.ts

@@ -0,0 +1,41 @@
+import Rate from '../../src/methods/rate';
+
+describe('Rate.linearWarmupDecay', () => {
+  const base = 0.2;
+  const fn = Rate.linearWarmupDecay(20, 5, 0.01);
+
+  describe('Warmup start (iter 0)', () => {
+    const value = fn(base, 0);
+    it('starts near 0', () => {
+      expect(value).toBeCloseTo(0, 5);
+    });
+  });
+
+  describe('Warmup mid (iter 3)', () => {
+    const value = fn(base, 3);
+    it('increases during warmup', () => {
+      expect(value).toBeGreaterThan(0);
+    });
+  });
+
+  describe('End warmup (iter 5)', () => {
+    const value = fn(base, 5);
+    it('reaches base at end warmup', () => {
+      expect(value).toBeCloseTo(base, 5);
+    });
+  });
+
+  describe('Decay mid (iter 10)', () => {
+    const value = fn(base, 10);
+    it('decays after warmup', () => {
+      expect(value).toBeLessThan(base);
+    });
+  });
+
+  describe('Final step (iter 20)', () => {
+    const value = fn(base, 20);
+    it('hits endRate at totalSteps', () => {
+      expect(value).toBeCloseTo(0.01, 5);
+    });
+  });
+});

package/test/methods/rate.reduceOnPlateau.test.ts

@@ -0,0 +1,45 @@
+import Rate from '../../src/methods/rate';
+
+describe('Rate.reduceOnPlateau', () => {
+  const base = 0.05;
+  const rop = Rate.reduceOnPlateau({
+    patience: 2,
+    factor: 0.5,
+    minRate: 0.005,
+  });
+
+  // simulate sequence of errors
+  const seq = [0.5, 0.45, 0.46, 0.47, 0.4, 0.41, 0.41, 0.39];
+  const rates: number[] = [];
+  seq.forEach((err, i) => {
+    rates.push(rop(base, i, err));
+  });
+
+  describe('Initial rate (iter 0)', () => {
+    const value = rates[0];
+    it('starts at base', () => {
+      expect(value).toBeCloseTo(base, 10);
+    });
+  });
+
+  describe('No reduction before patience (iter 1)', () => {
+    const value = rates[1];
+    it('unchanged early', () => {
+      expect(value).toBe(base);
+    });
+  });
+
+  describe('Reduction triggered after patience (iter 3)', () => {
+    const value = rates[3];
+    it('reduced after plateau', () => {
+      expect(value).toBeLessThan(base);
+    });
+  });
+
+  describe('Further improvement resets wait (iter 4)', () => {
+    const value = rates[4];
+    it('stays at reduced rate until new plateau', () => {
+      expect(value).toBe(rates[3]);
+    });
+  });
+});