scalar-autograd 0.1.0 → 0.1.3

package/Losses.ts

@@ -12,133 +12,134 @@ function checkLengthMatch(outputs: Value[], targets: Value[]): void {
   }
 }
 
-/**
- * Computes mean squared error (MSE) loss between outputs and targets.
- * @param outputs Array of Value predictions.
- * @param targets Array of Value targets.
- * @returns Mean squared error as a Value.
- */
-export function mse(outputs: Value[], targets: Value[]): Value {
-  checkLengthMatch(outputs, targets);
-  if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('mse expects Value[] for both arguments.');
-  if (!outputs.length) return new Value(0);
-  const diffs = outputs.map((out, i) => out.sub(targets[i]).square());
-  return Value.mean(diffs);
-}
-
-/**
- * Computes mean absolute error (MAE) loss between outputs and targets.
- * @param outputs Array of Value predictions.
- * @param targets Array of Value targets.
- * @returns Mean absolute error as a Value.
- */
-export function mae(outputs: Value[], targets: Value[]): Value {
-  checkLengthMatch(outputs, targets);
-  if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('mae expects Value[] for both arguments.');
-  if (!outputs.length) return new Value(0);
-  const diffs = outputs.map((out, i) => out.sub(targets[i]).abs());
-  return Value.mean(diffs);
-}
+export class Losses {
+  /**
+   * Computes mean squared error (MSE) loss between outputs and targets.
+   * @param outputs Array of Value predictions.
+   * @param targets Array of Value targets.
+   * @returns Mean squared error as a Value.
+   */
+  public static mse(outputs: Value[], targets: Value[]): Value {
+    checkLengthMatch(outputs, targets);
+    if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('mse expects Value[] for both arguments.');
+    if (!outputs.length) return new Value(0);
+    const diffs = outputs.map((out, i) => out.sub(targets[i]).square());
+    return Value.mean(diffs);
+  }
 
-const EPS = 1e-12;
+  /**
+   * Computes mean absolute error (MAE) loss between outputs and targets.
+   * @param outputs Array of Value predictions.
+   * @param targets Array of Value targets.
+   * @returns Mean absolute error as a Value.
+   */
+  public static mae(outputs: Value[], targets: Value[]): Value {
+    checkLengthMatch(outputs, targets);
+    if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('mae expects Value[] for both arguments.');
+    if (!outputs.length) return new Value(0);
+    const diffs = outputs.map((out, i) => out.sub(targets[i]).abs());
+    return Value.mean(diffs);
+  }
 
-/**
- * Computes binary cross-entropy loss between predicted outputs and targets (after sigmoid).
- * @param outputs Array of Value predictions (expected in (0,1)).
- * @param targets Array of Value targets (typically 0 or 1).
- * @returns Binary cross-entropy loss as a Value.
- */
-export function binaryCrossEntropy(outputs: Value[], targets: Value[]): Value {
-  checkLengthMatch(outputs, targets);
-  if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('binaryCrossEntropy expects Value[] for both arguments.');
-  if (!outputs.length) return new Value(0);
-  const eps = EPS;
-  const one = new Value(1);
-  const losses = outputs.map((out, i) => {
-    const t = targets[i];
-    const outClamped = out.clamp(eps, 1 - eps); // sigmoid should output (0,1)
-    return t.mul(outClamped.log()).add(one.sub(t).mul(one.sub(outClamped).log()));
-  });
-  return Value.mean(losses).mul(-1);
-}
+  static EPS = 1e-12;
 
-/**
- * Computes categorical cross-entropy loss between outputs (logits) and integer target classes.
- * @param outputs Array of Value logits for each class.
- * @param targets Array of integer class indices (0-based, one per sample).
- * @returns Categorical cross-entropy loss as a Value.
- */
-export function categoricalCrossEntropy(outputs: Value[], targets: number[]): Value {
-  // targets: integer encoded class indices
-  if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('categoricalCrossEntropy expects Value[] and number[].');
-  if (!outputs.length || !targets.length) return new Value(0);
-  if (targets.some(t => typeof t !== 'number' || !isFinite(t) || t < 0 || t >= outputs.length || Math.floor(t) !== t)) {
-    throw new Error('Target indices must be valid integers in [0, outputs.length)');
+  /**
+   * Computes binary cross-entropy loss between predicted outputs and targets (after sigmoid).
+   * @param outputs Array of Value predictions (expected in (0,1)).
+   * @param targets Array of Value targets (typically 0 or 1).
+   * @returns Binary cross-entropy loss as a Value.
+   */
+  public static binaryCrossEntropy(outputs: Value[], targets: Value[]): Value {
+    checkLengthMatch(outputs, targets);
+    if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('binaryCrossEntropy expects Value[] for both arguments.');
+    if (!outputs.length) return new Value(0);
+    const eps = Losses.EPS;
+    const one = new Value(1);
+    const losses = outputs.map((out, i) => {
+      const t = targets[i];
+      const outClamped = out.clamp(eps, 1 - eps); // sigmoid should output (0,1)
+      return t.mul(outClamped.log()).add(one.sub(t).mul(one.sub(outClamped).log()));
+    });
+    return Value.mean(losses).mul(-1);
   }
-  const eps = EPS;
-  const maxLogit = outputs.reduce((a, b) => a.data > b.data ? a : b);
-  const exps = outputs.map(out => out.sub(maxLogit).exp());
-  const sumExp = Value.sum(exps).add(eps);
-  const softmax = exps.map(e => e.div(sumExp));
-  const tIndices = targets.map((t, i) => softmax[t]);
-  return Value.mean(tIndices.map(sm => sm.add(eps).log().mul(-1)));
-}
 
-/**
- * Computes Huber loss between outputs and targets.
- * Combines quadratic loss for small residuals and linear loss for large residuals.
- * @param outputs Array of Value predictions.
- * @param targets Array of Value targets.
- * @param delta Threshold at which to switch from quadratic to linear (default: 1.0).
- * @returns Huber loss as a Value.
- */
-export function huber(outputs: Value[], targets: Value[], delta = 1.0): Value {
-  checkLengthMatch(outputs, targets);
-  if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('huber expects Value[] for both arguments.');
-  if (!outputs.length) return new Value(0);
-  
-  const deltaValue = new Value(delta);
-  const half = new Value(0.5);
-  
-  const losses = outputs.map((out, i) => {
-    const residual = V.abs(V.sub(out, targets[i]));
-    const condition = V.lt(residual, deltaValue);
+  /**
+   * Computes categorical cross-entropy loss between outputs (logits) and integer target classes.
+   * @param outputs Array of Value logits for each class.
+   * @param targets Array of integer class indices (0-based, one per sample).
+   * @returns Categorical cross-entropy loss as a Value.
+   */
+  public static categoricalCrossEntropy(outputs: Value[], targets: number[]): Value {
+    // targets: integer encoded class indices
+    if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('categoricalCrossEntropy expects Value[] and number[].');
+    if (!outputs.length || !targets.length) return new Value(0);
+    if (targets.some(t => typeof t !== 'number' || !isFinite(t) || t < 0 || t >= outputs.length || Math.floor(t) !== t)) {
+      throw new Error('Target indices must be valid integers in [0, outputs.length)');
+    }
+    const eps = Losses.EPS;
+    const maxLogit = outputs.reduce((a, b) => a.data > b.data ? a : b);
+    const exps = outputs.map(out => out.sub(maxLogit).exp());
+    const sumExp = Value.sum(exps).add(eps);
+    const softmax = exps.map(e => e.div(sumExp));
+    const tIndices = targets.map((t, i) => softmax[t]);
+    return Value.mean(tIndices.map(sm => sm.add(eps).log().mul(-1)));
+  }
 
-    const quadraticLoss = V.mul(half, V.square(residual));
-    const linearLoss = V.mul(deltaValue, V.sub(residual, V.mul(half, deltaValue)));
+  /**
+   * Computes Huber loss between outputs and targets.
+   * Combines quadratic loss for small residuals and linear loss for large residuals.
+   * @param outputs Array of Value predictions.
+   * @param targets Array of Value targets.
+   * @param delta Threshold at which to switch from quadratic to linear (default: 1.0).
+   * @returns Huber loss as a Value.
+   */
+  public static huber(outputs: Value[], targets: Value[], delta = 1.0): Value {
+    checkLengthMatch(outputs, targets);
+    if (!Array.isArray(outputs) || !Array.isArray(targets)) throw new TypeError('huber expects Value[] for both arguments.');
+    if (!outputs.length) return new Value(0);
+    
+    const deltaValue = new Value(delta);
+    const half = new Value(0.5);
+    
+    const losses = outputs.map((out, i) => {
+      const residual = V.abs(V.sub(out, targets[i]));
+      const condition = V.lt(residual, deltaValue);
 
-    return V.ifThenElse(condition, quadraticLoss, linearLoss);
-  });
+      const quadraticLoss = V.mul(half, V.square(residual));
+      const linearLoss = V.mul(deltaValue, V.sub(residual, V.mul(half, deltaValue)));
 
-  return V.mean(losses);
-}
+      return V.ifThenElse(condition, quadraticLoss, linearLoss);
+    });
 
+    return V.mean(losses);
+  }
 
-/**
- * Computes Tukey loss between outputs and targets.
- * This robust loss function saturates for large residuals.
- * 
- * @param outputs Array of Value predictions.
- * @param targets Array of Value targets.
- * @param c Threshold constant (typically 4.685).
- * @returns Tukey loss as a Value.
- */
-export function tukey(outputs: Value[], targets: Value[], c: number = 4.685): Value {
-  checkLengthMatch(outputs, targets);
-  const c2_over_6 = (c * c) / 6;
-  const cValue = V.C(c);
-  const c2_over_6_Value = V.C(c2_over_6);
+  /**
+   * Computes Tukey loss between outputs and targets.
+   * This robust loss function saturates for large residuals.
+   * 
+   * @param outputs Array of Value predictions.
+   * @param targets Array of Value targets.
+   * @param c Threshold constant (typically 4.685).
+   * @returns Tukey loss as a Value.
+   */
+  public static tukey(outputs: Value[], targets: Value[], c: number = 4.685): Value {
+    checkLengthMatch(outputs, targets);
+    const c2_over_6 = (c * c) / 6;
+    const cValue = V.C(c);
+    const c2_over_6_Value = V.C(c2_over_6);
 
-  const losses = outputs.map((out, i) => {
-    const diff = V.abs(V.sub(out, targets[i]));
-    const inlier = V.lte(diff, cValue);
-    const rc = V.div(diff, cValue);
-    const rc2 = V.square(rc);
-    const oneMinusRC2 = V.sub(1, rc2);
-    const inner = V.pow(oneMinusRC2, 3);
-    const inlierLoss = V.mul(c2_over_6_Value, V.sub(1, inner));
-    const loss = V.ifThenElse(inlier, inlierLoss, c2_over_6_Value);
-    return loss;
-  });
-  return V.mean(losses);
+    const losses = outputs.map((out, i) => {
+      const diff = V.abs(V.sub(out, targets[i]));
+      const inlier = V.lte(diff, cValue);
+      const rc = V.div(diff, cValue);
+      const rc2 = V.square(rc);
+      const oneMinusRC2 = V.sub(1, rc2);
+      const inner = V.pow(oneMinusRC2, 3);
+      const inlierLoss = V.mul(c2_over_6_Value, V.sub(1, inner));
+      const loss = V.ifThenElse(inlier, inlierLoss, c2_over_6_Value);
+      return loss;
+    });
+    return V.mean(losses);
+}
 }

package/Optimizers.ts

@@ -53,7 +53,7 @@ export abstract class Optimizer {
  * @property weightDecay: L2 regularization multiplier (default 0). Ignored for plain SGD.
  * @property gradientClip: Maximum absolute value for gradient updates (default 0: no clipping).
  */
-interface OptimizerOptions {
+export interface OptimizerOptions {
   learningRate?: number;
   weightDecay?: number;
   gradientClip?: number;
@@ -96,7 +96,7 @@ export class SGD extends Optimizer {
  * @property beta2: Exponential decay rate for 2nd moment (default 0.999).
  * @property epsilon: Numerical stability fudge factor (default 1e-8).
  */
-interface AdamOptions extends OptimizerOptions {
+export interface AdamOptions extends OptimizerOptions {
   beta1?: number;
   beta2?: number;
   epsilon?: number;

package/README.md

@@ -101,6 +101,7 @@ This pattern—forward pass, backward for gradients, and calling `optimizer.step
 
 All API operations work with both `Value` and raw number inputs (numbers are automatically wrapped as non-grad constants).
 
+
 ## Testing
 
 To run the test suite and verify the correctness of ScalarAutograd, execute the following command in your project directory:
@@ -109,5 +110,12 @@ To run the test suite and verify the correctness of ScalarAutograd, execute the
 npm run test
 ```
 
+## Deploy to npm
+
+Start "Git Bash" terminal
+Type ./release.sh
+
+---
+
 ## License
 MIT

package/Value.losses-edge-cases.spec.ts

@@ -1,32 +1,32 @@
 import { Value } from "./Value";
-import { mse, mae, binaryCrossEntropy, categoricalCrossEntropy } from "./Losses";
+import { Losses } from "./Losses";
 
 describe('Loss function edge cases', () => {
   it('handles empty arrays', () => {
-    expect(mse([], []).data).toBe(0);
-    expect(mae([], []).data).toBe(0);
-    expect(binaryCrossEntropy([], []).data).toBe(0);
-    expect(categoricalCrossEntropy([], []).data).toBe(0);
+    expect(Losses.mse([], []).data).toBe(0);
+    expect(Losses.mae([], []).data).toBe(0);
+    expect(Losses.binaryCrossEntropy([], []).data).toBe(0);
+    expect(Losses.categoricalCrossEntropy([], []).data).toBe(0);
   });
 
   it('throws on mismatched lengths', () => {
     const a = [new Value(1)];
     const b = [new Value(1), new Value(2)];
-    expect(() => mse(a, b)).toThrow();
+    expect(() => Losses.mse(a, b)).toThrow();
   });
 
   it('handles extreme values in binary cross entropy', () => {
     const out = new Value(0.999999, 'out', true);
     const target = new Value(1);
-    const loss = binaryCrossEntropy([out], [target]);
+    const loss = Losses.binaryCrossEntropy([out], [target]);
     expect(loss.data).toBeGreaterThan(0);
     expect(loss.data).toBeLessThan(0.1);
   });
 
   it('throws on invalid class indices in categorical cross entropy', () => {
     const outputs = [new Value(1), new Value(2)];
-    expect(() => categoricalCrossEntropy(outputs, [2])).toThrow();
-    expect(() => categoricalCrossEntropy(outputs, [-1])).toThrow();
-    expect(() => categoricalCrossEntropy(outputs, [1.5])).toThrow();
+    expect(() => Losses.categoricalCrossEntropy(outputs, [2])).toThrow();
+    expect(() => Losses.categoricalCrossEntropy(outputs, [-1])).toThrow();
+    expect(() => Losses.categoricalCrossEntropy(outputs, [1.5])).toThrow();
   });
 });

package/Value.nn.spec.ts

@@ -1,6 +1,6 @@
 import { Value } from "./Value";
 import { SGD, Adam } from "./Optimizers";
-import { mse, binaryCrossEntropy } from "./Losses";
+import { Losses } from "./Losses";
 
 describe("can train scalar neural networks on minimal problems", () => {
 
@@ -22,7 +22,7 @@ describe("can train scalar neural networks on minimal problems", () => {
         preds.push(pred);
         targets.push(new Value(ex.y));
       }
-      let loss = mse(preds, targets);
+      let loss = Losses.mse(preds, targets);
       if (loss.data < 1e-4) break;
       w.grad = 0; b.grad = 0;
       loss.backward();
@@ -53,7 +53,7 @@ describe("can train scalar neural networks on minimal problems", () => {
         preds.push(pred);
         targets.push(new Value(ex.y));
       }
-      let loss = mse(preds, targets);
+      let loss = Losses.mse(preds, targets);
       if (loss.data < 1e-4) break;
       a.grad = 0; b.grad = 0; c.grad = 0;
       loss.backward();

package/Value.ts

@@ -1,7 +1,11 @@
-type BackwardFn = () => void;
+export type BackwardFn = () => void;
+export { V } from './V';
+export { Optimizer, SGD, Adam, AdamW, OptimizerOptions, AdamOptions } from './Optimizers';
+export { Losses } from './Losses';
 
 const EPS = 1e-12;
 
+
 import { ValueTrig } from './ValueTrig';
 import { ValueActivation } from './ValueActivation';
 import { ValueArithmetic } from './ValueArithmetic';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalar-autograd",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Scalar-based reverse-mode automatic differentiation in TypeScript.",
   "main": "Value.js",
   "types": "Value.d.ts",