catniff 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
-## Catniff
+# Catniff
 
-Catniff is a small, experimental autograd engine inspired by [micrograd](https://github.com/karpathy/micrograd). The name is a play on "catnip" and "differentiation".
+Catniff is a small and experimental tensor library and autograd engine inspired by [micrograd](https://github.com/karpathy/micrograd). The name is a play on "catnip" and "differentiation".
 
 ## Setup
 
@@ -16,20 +16,59 @@ Here is a little demo of a quadratic function:
 const { Node } = require("catniff");
 
 const x = new Node(2);
-const L = x.pow(2).add(x)
+const L = x.pow(2).add(x); // x^2 + x
 
 L.backward();
-console.log(x.grad, L.grad);
+console.log(x.grad); // 5
 ```
 
-All available APIs are in `./src/core.ts`.
+## Tensors
+
+Tensors in Catniff are either numbers (scalars/0-D tensors) or multidimensional number arrays (n-D tensors).
+
+There is a built-in `TensorMath` class to help with Tensor arithmetic, for example:
+```js
+const { TensorMath } = require("catniff");
+
+const A = [ 1, 2, 3 ];
+const B = 3
+console.log(TensorMath.add(A, B));
+```
+
+All available APIs are in `./src/tensor.ts`.
+
+## Autograd
+
+To compute the gradient of our mathematical expression, we use the `Node` class to dynamically build our DAG:
+```js
+const { Node } = require("../index");
+
+const X = new Node([
+    [ 0.5, -1.0 ],
+    [ 2.0,  0.0 ]
+]);
+
+const Y = new Node([
+    [ 1.0, -2.0 ],
+    [ 0.5,  1.5 ]
+]);
+
+const D = X.sub(Y);
+const E = D.exp();
+const F = E.add(1);
+const G = F.log();
+
+G.backward();
+
+console.log(X.grad, Y.grad);
+```
+
+All available APIs are in `./src/autograd.ts`.
 
 ## Todos
 
 I'm mostly just learning and playing with this currently, so there are no concrete plans yet, but here are what I currently have in mind:
 
-* A built-in Tensor maths lib.
-* Support for Tensors in the autograd engine.
 * GPU acceleration.
 * Some general neural net APIs.
 

package/dist/{core.d.ts → autograd.d.ts}

@@ -1,24 +1,28 @@
+import { Tensor } from "./tensor";
 export declare enum OP {
     NONE = 0,
     ADD = 1,
-    MUL = 2,
-    POW = 3,
-    DIV = 4,
-    NEG = 5,
-    EXP = 6,
-    LOG = 7,
-    RELU = 8,
-    SIGMOID = 9,
-    TANH = 10
+    SUB = 2,
+    MUL = 3,
+    POW = 4,
+    DIV = 5,
+    NEG = 6,
+    EXP = 7,
+    LOG = 8,
+    RELU = 9,
+    SIGMOID = 10,
+    TANH = 11
 }
 export declare class Node {
-    value: number;
-    grad: number;
+    value: Tensor;
+    shape: number[];
+    grad: Tensor;
     children: Node[];
-    feedBackward: Function;
     op: OP;
-    constructor(value: number, children?: Node[], op?: OP);
+    feedBackward: Function;
+    constructor(value: Tensor, children?: Node[], op?: OP);
     add(other: Node | number): Node;
+    sub(other: Node | number): Node;
     mul(other: Node | number): Node;
     pow(other: Node | number): Node;
     div(other: Node | number): Node;

package/dist/autograd.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = exports.OP = void 0;
+const tensor_1 = require("./tensor");
+const { add, sub, mul, pow, div, neg, exp, log, relu, sigmoid, tanh, ge } = tensor_1.TensorMath;
+var OP;
+(function (OP) {
+    OP[OP["NONE"] = 0] = "NONE";
+    OP[OP["ADD"] = 1] = "ADD";
+    OP[OP["SUB"] = 2] = "SUB";
+    OP[OP["MUL"] = 3] = "MUL";
+    OP[OP["POW"] = 4] = "POW";
+    OP[OP["DIV"] = 5] = "DIV";
+    OP[OP["NEG"] = 6] = "NEG";
+    OP[OP["EXP"] = 7] = "EXP";
+    OP[OP["LOG"] = 8] = "LOG";
+    OP[OP["RELU"] = 9] = "RELU";
+    OP[OP["SIGMOID"] = 10] = "SIGMOID";
+    OP[OP["TANH"] = 11] = "TANH";
+})(OP || (exports.OP = OP = {}));
+class Node {
+    value;
+    shape;
+    grad;
+    children;
+    op;
+    feedBackward;
+    constructor(value, children = [], op = OP.NONE) {
+        this.value = value;
+        this.shape = tensor_1.TensorMath.getShape(value);
+        this.grad = tensor_1.TensorMath.create(0, this.shape);
+        this.children = children;
+        this.op = op;
+        this.feedBackward = () => { };
+    }
+    add(other) {
+        other = this.forceNode(other);
+        const out = new Node(add(this.value, other.value), [this, other], OP.ADD);
+        out.feedBackward = () => {
+            // x + y d/dx = 1, note that we apply the chain rule continuously so out.grad is multiplied into our derivative
+            this.grad = add(this.grad, out.grad);
+            // x + y d/dy = 1
+            other.grad = add(other.grad, out.grad);
+        };
+        return out;
+    }
+    sub(other) {
+        other = this.forceNode(other);
+        const out = new Node(sub(this.value, other.value), [this, other], OP.SUB);
+        out.feedBackward = () => {
+            // x - y d/dx = 1
+            this.grad = add(this.grad, out.grad);
+            // x - y d/dy = -1
+            other.grad = add(other.grad, neg(out.grad));
+        };
+        return out;
+    }
+    mul(other) {
+        other = this.forceNode(other);
+        const out = new Node(mul(this.value, other.value), [this, other], OP.MUL);
+        out.feedBackward = () => {
+            // x * y d/dx = y
+            this.grad = add(this.grad, mul(out.grad, other.value));
+            // x + y d/dy = x
+            other.grad = add(other.grad, mul(out.grad, this.value));
+        };
+        return out;
+    }
+    pow(other) {
+        if (other instanceof Node) {
+            const out = new Node(pow(this.value, other.value), [this, other], OP.POW);
+            out.feedBackward = () => {
+                // x^a d/dx = a*x^(a-1)
+                this.grad = add(this.grad, mul(out.grad, mul(other.value, pow(this.value, sub(other.value, 1)))));
+                // x^a d/da = x^a*lnx
+                other.grad = add(other.grad, mul(out.grad, mul(pow(this.value, other.value), log(this.value))));
+            };
+            return out;
+        }
+        const out = new Node(pow(this.value, other), [this], OP.POW);
+        out.feedBackward = () => {
+            this.grad = add(this.grad, mul(out.grad, mul(other, pow(this.value, sub(other, 1)))));
+        };
+        return out;
+    }
+    div(other) {
+        other = this.forceNode(other);
+        const out = new Node(div(this.value, other.value), [this, other], OP.DIV);
+        out.feedBackward = () => {
+            // x/y d/dx = 1/y
+            this.grad = add(this.grad, div(out.grad, other.value));
+            // x/y d/dy = -x/y^2
+            other.grad = add(other.grad, mul(out.grad, div(neg(this.value), pow(other.value, 2))));
+        };
+        return out;
+    }
+    neg() {
+        const out = new Node(neg(this.value), [this], OP.NEG);
+        out.feedBackward = () => {
+            // -x d/dx = -1
+            this.grad = add(this.grad, neg(out.grad));
+        };
+        return out;
+    }
+    exp() {
+        const expResult = exp(this.value);
+        const out = new Node(expResult, [this], OP.EXP);
+        out.feedBackward = () => {
+            // e^x d/dx = e^x
+            this.grad = add(this.grad, mul(out.grad, expResult));
+        };
+        return out;
+    }
+    log() {
+        const out = new Node(log(this.value), [this], OP.LOG);
+        out.feedBackward = () => {
+            // lnx d/dx = 1/x
+            this.grad = add(this.grad, div(out.grad, this.value));
+        };
+        return out;
+    }
+    relu() {
+        const out = new Node(relu(this.value), [this], OP.RELU);
+        out.feedBackward = () => {
+            this.grad = add(this.grad, mul(out.grad, ge(this.value, 0)));
+        };
+        return out;
+    }
+    sigmoid() {
+        const sigmoidResult = sigmoid(this.value);
+        const out = new Node(sigmoidResult, [this], OP.SIGMOID);
+        out.feedBackward = () => {
+            this.grad = add(this.grad, mul(mul(out.grad, sigmoidResult), sub(1, sigmoidResult)));
+        };
+        return out;
+    }
+    tanh() {
+        const tanhResult = tanh(this.value);
+        const out = new Node(tanhResult, [this], OP.TANH);
+        out.feedBackward = () => {
+            this.grad = add(this.grad, mul(out.grad, sub(1, mul(tanhResult, tanhResult))));
+        };
+        return out;
+    }
+    backward() {
+        // Build topological order
+        const topo = [];
+        const visited = new Set();
+        function build(node) {
+            if (!visited.has(node)) {
+                visited.add(node);
+                node.grad = tensor_1.TensorMath.create(0, node.shape);
+                for (let child of node.children)
+                    build(child);
+                topo.push(node);
+            }
+        }
+        build(this);
+        // Feed backward to calculate gradient
+        this.grad = tensor_1.TensorMath.create(1, this.shape); // Derivative of itself with respect to itself
+        for (let index = topo.length - 1; index > -1; index--) {
+            topo[index].feedBackward();
+        }
+    }
+    forceNode(value) {
+        if (value instanceof Node)
+            return value;
+        return new Node(value);
+    }
+}
+exports.Node = Node;

package/dist/tensor.d.ts

@@ -0,0 +1,21 @@
+export type Tensor = number | Tensor[];
+export declare class TensorMath {
+    static create(num: number, shape: number[]): Tensor;
+    static getShape(tA: Tensor): number[];
+    static add(tA: Tensor, tB: Tensor): Tensor;
+    static sub(tA: Tensor, tB: Tensor): Tensor;
+    static mul(tA: Tensor, tB: Tensor): Tensor;
+    static pow(tA: Tensor, tB: Tensor): Tensor;
+    static div(tA: Tensor, tB: Tensor): Tensor;
+    static gt(tA: Tensor, tB: Tensor): Tensor;
+    static lt(tA: Tensor, tB: Tensor): Tensor;
+    static ge(tA: Tensor, tB: Tensor): Tensor;
+    static le(tA: Tensor, tB: Tensor): Tensor;
+    static eq(tA: Tensor, tB: Tensor): Tensor;
+    static neg(tA: Tensor): Tensor;
+    static exp(tA: Tensor): Tensor;
+    static log(tA: Tensor): Tensor;
+    static relu(tA: Tensor): Tensor;
+    static sigmoid(tA: Tensor): Tensor;
+    static tanh(tA: Tensor): Tensor;
+}

package/dist/tensor.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TensorMath = void 0;
+class TensorMath {
+    static create(num, shape) {
+        if (shape.length === 0) {
+            return num;
+        }
+        const [dim, ...rest] = shape;
+        const out = [];
+        for (let i = 0; i < dim; i++) {
+            out.push(TensorMath.create(num, rest));
+        }
+        return out;
+    }
+    static getShape(tA) {
+        const shape = [];
+        let subA = tA;
+        while (Array.isArray(subA)) {
+            shape.push(subA.length);
+            subA = subA[0];
+        }
+        return shape;
+    }
+    static add(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA + tB;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.add(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.add(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.add(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static sub(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA - tB;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.sub(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.sub(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.sub(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static mul(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA * tB;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.mul(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.mul(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.mul(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static pow(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA ** tB;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.pow(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.pow(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.pow(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static div(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA / tB;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.div(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.div(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.div(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static gt(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA > tB ? 1 : 0;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.gt(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.gt(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.gt(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static lt(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA < tB ? 1 : 0;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.lt(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.lt(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.lt(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static ge(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA >= tB ? 1 : 0;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.ge(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.ge(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.ge(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static le(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA <= tB ? 1 : 0;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.le(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.le(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.le(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static eq(tA, tB) {
+        if (typeof tA === "number" && typeof tB === "number") {
+            return tA === tB ? 1 : 0;
+        }
+        else if (Array.isArray(tA) && Array.isArray(tB)) {
+            const outLen = Math.max(tA.length, tB.length);
+            if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
+                throw new Error("Inputs are incompatible tensors");
+            }
+            const result = [];
+            for (let i = 0; i < outLen; i++) {
+                const subA = tA[tA.length === 1 ? 0 : i];
+                const subB = tB[tB.length === 1 ? 0 : i];
+                result.push(TensorMath.eq(subA, subB));
+            }
+            return result;
+        }
+        else if (Array.isArray(tA) && typeof tB === "number") {
+            return tA.map(subA => TensorMath.eq(subA, tB));
+        }
+        else if (typeof tA === "number" && Array.isArray(tB)) {
+            return tB.map(subB => TensorMath.eq(tA, subB));
+        }
+        throw new Error("Inputs are not tensors");
+    }
+    static neg(tA) {
+        if (typeof tA === "number") {
+            return -tA;
+        }
+        else {
+            return tA.map(subA => TensorMath.neg(subA));
+        }
+    }
+    static exp(tA) {
+        if (typeof tA === "number") {
+            return Math.exp(tA);
+        }
+        else {
+            return tA.map(subA => TensorMath.exp(subA));
+        }
+    }
+    static log(tA) {
+        if (typeof tA === "number") {
+            return Math.log(tA);
+        }
+        else {
+            return tA.map(subA => TensorMath.log(subA));
+        }
+    }
+    static relu(tA) {
+        if (typeof tA === "number") {
+            return Math.max(tA, 0);
+        }
+        else {
+            return tA.map(subA => TensorMath.relu(subA));
+        }
+    }
+    static sigmoid(tA) {
+        if (typeof tA === "number") {
+            return 1 / (1 + Math.exp(-tA));
+        }
+        else {
+            return tA.map(subA => TensorMath.sigmoid(subA));
+        }
+    }
+    static tanh(tA) {
+        if (typeof tA === "number") {
+            return Math.tanh(tA);
+        }
+        else {
+            return tA.map(subA => TensorMath.tanh(subA));
+        }
+    }
+}
+exports.TensorMath = TensorMath;

package/index.js

@@ -1 +1,4 @@
-module.exports = require("./dist/core");
+module.exports = {
+    ...require("./dist/autograd"),
+    ...require("./dist/tensor")
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catniff",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A cute autograd engine for Javascript",
   "main": "index.js",
   "scripts": {
@@ -18,7 +18,8 @@
     "dl",
     "ai",
     "maths",
-    "gradient"
+    "gradient",
+    "tensors"
   ],
   "author": "nguyenphuminh",
   "license": "GPL-3.0",
@@ -28,5 +29,12 @@
   "homepage": "https://github.com/nguyenphuminh/catniff#readme",
   "devDependencies": {
     "typescript": "^5.8.3"
-  }
+  },
+  "files": [
+    "dist/",
+    "index.d.ts",
+    "index.js",
+    "LICENSE",
+    "README.md"
+  ]
 }

package/dist/core.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Node = exports.OP = void 0;
-var OP;
-(function (OP) {
-    OP[OP["NONE"] = 0] = "NONE";
-    OP[OP["ADD"] = 1] = "ADD";
-    OP[OP["MUL"] = 2] = "MUL";
-    OP[OP["POW"] = 3] = "POW";
-    OP[OP["DIV"] = 4] = "DIV";
-    OP[OP["NEG"] = 5] = "NEG";
-    OP[OP["EXP"] = 6] = "EXP";
-    OP[OP["LOG"] = 7] = "LOG";
-    OP[OP["RELU"] = 8] = "RELU";
-    OP[OP["SIGMOID"] = 9] = "SIGMOID";
-    OP[OP["TANH"] = 10] = "TANH";
-})(OP || (exports.OP = OP = {}));
-class Node {
-    // Only scalars are supported for now
-    value;
-    grad;
-    children;
-    feedBackward;
-    op;
-    constructor(value, children = [], op = OP.NONE) {
-        this.value = value;
-        this.grad = 0;
-        this.children = children;
-        this.op = op;
-        this.feedBackward = () => { };
-    }
-    add(other) {
-        other = this.forceNode(other);
-        const out = new Node(this.value + other.value, [this, other], OP.ADD);
-        out.feedBackward = () => {
-            this.grad += out.grad;
-            other.grad += out.grad;
-        };
-        return out;
-    }
-    mul(other) {
-        other = this.forceNode(other);
-        const out = new Node(this.value * other.value, [this, other], OP.MUL);
-        out.feedBackward = () => {
-            this.grad += out.grad * other.value;
-            other.grad += out.grad * this.value;
-        };
-        return out;
-    }
-    pow(other) {
-        if (other instanceof Node) {
-            const out = new Node(this.value ** other.value, [this, other], OP.POW);
-            out.feedBackward = () => {
-                this.grad += out.grad * other.value * this.value ** (other.value - 1);
-                other.grad += out.grad * this.value ** other.value * Math.log(this.value);
-            };
-            return out;
-        }
-        const out = new Node(this.value ** other, [this], OP.POW);
-        out.feedBackward = () => {
-            this.grad += out.grad * other * this.value ** (other - 1);
-        };
-        return out;
-    }
-    div(other) {
-        other = this.forceNode(other);
-        const out = new Node(this.value / other.value, [this, other], OP.DIV);
-        out.feedBackward = () => {
-            this.grad += out.grad * (1 / other.value);
-            other.grad += out.grad * -this.value / other.value ** 2;
-        };
-        return out;
-    }
-    neg() {
-        const out = new Node(-this.value, [this], OP.NEG);
-        out.feedBackward = () => {
-            this.grad += -out.grad;
-        };
-        return out;
-    }
-    exp() {
-        const exp = Math.exp(this.value);
-        const out = new Node(exp, [this], OP.EXP);
-        out.feedBackward = () => {
-            this.grad += exp;
-        };
-        return out;
-    }
-    log() {
-        const out = new Node(Math.log(this.value), [this], OP.LOG);
-        out.feedBackward = () => {
-            this.grad += 1 / this.value;
-        };
-        return out;
-    }
-    relu() {
-        const out = new Node(Math.max(this.value, 0), [this], OP.RELU);
-        out.feedBackward = () => {
-            this.grad += out.grad * (this.value < 0 ? 0 : 1);
-        };
-        return out;
-    }
-    sigmoid() {
-        const sigmoid = 1 / (1 + Math.exp(-this.value));
-        const out = new Node(sigmoid, [this], OP.SIGMOID);
-        out.feedBackward = () => {
-            this.grad += out.grad * sigmoid * (1 - sigmoid);
-        };
-        return out;
-    }
-    tanh() {
-        const tanh = Math.tanh(this.value);
-        const out = new Node(tanh, [this], OP.TANH);
-        out.feedBackward = () => {
-            this.grad += out.grad * (1 - tanh * tanh);
-        };
-        return out;
-    }
-    backward() {
-        // Build topological order
-        const topo = [];
-        const visited = new Set();
-        function build(node) {
-            if (!visited.has(node)) {
-                visited.add(node);
-                node.grad = 0;
-                for (let child of node.children)
-                    build(child);
-                topo.push(node);
-            }
-        }
-        build(this);
-        // Feed backward to calculate gradient
-        this.grad = 1; // Derivative of itself with respect to itself
-        for (let index = topo.length - 1; index > -1; index--) {
-            topo[index].feedBackward();
-        }
-    }
-    forceNode(value) {
-        if (value instanceof Node)
-            return value;
-        return new Node(value);
-    }
-}
-exports.Node = Node;

package/examples/quadratic.js

@@ -1,7 +0,0 @@
-const { Node } = require("../index");
-
-const x = new Node(2);
-const L = x.pow(2).add(x)
-
-L.backward();
-console.log(x.grad, L.grad);

package/src/core.ts

@@ -1,180 +0,0 @@
-export enum OP {
-    NONE,
-    ADD,
-    MUL,
-    POW,
-    DIV,
-    NEG,
-    EXP,
-    LOG,
-    RELU,
-    SIGMOID,
-    TANH
-}
-
-export class Node {
-    // Only scalars are supported for now
-    public value: number;
-    public grad: number;
-    public children: Node[];
-    public feedBackward: Function;
-    public op: OP;
-
-    constructor(value: number, children: Node[] = [], op: OP = OP.NONE) {
-        this.value = value;
-        this.grad = 0;
-        this.children = children;
-        this.op = op;
-        this.feedBackward = () => {};
-    }
-
-    add(other: Node | number): Node {
-        other = this.forceNode(other);
-        const out = new Node(this.value + other.value, [this, other], OP.ADD);
-
-        out.feedBackward = () => {
-            this.grad += out.grad;
-            other.grad += out.grad;
-        }
-
-        return out;
-    }
-
-    mul(other: Node | number): Node {
-        other = this.forceNode(other);
-        const out = new Node(this.value * other.value, [this, other], OP.MUL);
-
-        out.feedBackward = () => {
-            this.grad += out.grad * other.value;
-            other.grad += out.grad * this.value;
-        }
-
-        return out;
-    }
-
-    pow(other: Node | number): Node {
-        if (other instanceof Node) {
-            const out = new Node(this.value ** other.value, [this, other], OP.POW);
-
-            out.feedBackward = () => {
-                this.grad += out.grad * other.value * this.value ** (other.value - 1);
-                other.grad += out.grad * this.value ** other.value * Math.log(this.value);
-            }
-
-            return out;
-        }
-
-        const out = new Node(this.value ** other, [this], OP.POW);
-
-        out.feedBackward = () => {
-            this.grad += out.grad * other * this.value ** (other - 1);
-        }
-
-        return out;
-    }
-
-    div(other: Node | number): Node {
-        other = this.forceNode(other);
-        const out = new Node(this.value / other.value, [this, other], OP.DIV);
-
-        out.feedBackward = () => {
-            this.grad += out.grad / other.value;
-            other.grad += out.grad * -this.value / other.value**2;
-        }
-
-        return out;
-    }
-
-    neg(): Node {
-        const out = new Node(-this.value, [this], OP.NEG);
-
-        out.feedBackward = () => {
-            this.grad += -out.grad;
-        }
-
-        return out;
-    }
-
-    exp(): Node {
-        const exp = Math.exp(this.value);
-        const out = new Node(exp, [this], OP.EXP);
-
-        out.feedBackward = () => {
-            this.grad += out.grad * exp;
-        }
-
-        return out;
-    }
-
-    log(): Node {
-        const out = new Node(Math.log(this.value), [this], OP.LOG);
-
-        out.feedBackward = () => {
-            this.grad += out.grad / this.value;
-        }
-
-        return out;
-    }
-
-    relu(): Node {
-        const out = new Node(Math.max(this.value, 0), [this], OP.RELU);
-        out.feedBackward = () => {
-            this.grad += out.grad * (this.value < 0 ? 0 : 1);
-        };
-
-        return out;
-    }
-
-    sigmoid(): Node {
-        const sigmoid = 1 / (1 + Math.exp(-this.value));
-
-        const out = new Node(sigmoid, [this], OP.SIGMOID);
-        out.feedBackward = () => {
-            this.grad += out.grad * sigmoid * (1 - sigmoid);
-        };
-
-        return out;
-    }
-
-    tanh(): Node {
-        const tanh = Math.tanh(this.value);
-
-        const out = new Node(tanh, [this], OP.TANH);
-        out.feedBackward = () => {
-            this.grad += out.grad * (1 - tanh * tanh);
-        };
-
-        return out;
-    }
-
-    backward() {
-        // Build topological order
-        const topo: Node[] = [];
-        const visited: Set<Node> = new Set();
-
-        function build(node: Node) {
-            if (!visited.has(node)) {
-                visited.add(node);
-                node.grad = 0;
-
-                for (let child of node.children) build(child);
-                topo.push(node);
-            }
-        }
-
-        build(this);
-
-        // Feed backward to calculate gradient
-        this.grad = 1; // Derivative of itself with respect to itself
-
-        for (let index = topo.length - 1; index > -1; index--) {
-            topo[index].feedBackward();
-        }
-    }
-
-    forceNode(value: Node | number): Node {
-        if (value instanceof Node) return value;
-
-        return new Node(value);
-    }
-}

package/tsconfig.json

@@ -1,108 +0,0 @@
-{
-    "include": [
-        "src/**/*"
-    ],
-    "compilerOptions": {
-        /* Visit https://aka.ms/tsconfig to read more about this file */
-        /* Projects */
-        // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-        // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-        // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-        // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-        // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-        // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-        /* Language and Environment */
-        "target": "esnext", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-        // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-        // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-        // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
-        // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
-        // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-        // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-        // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-        // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-        // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-        // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-        // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-        /* Modules */
-        "module": "commonjs", /* Specify what module code is generated. */
-        "rootDir": "./src/", /* Specify the root folder within your source files. */
-        "moduleResolution": "node10", /* Specify how TypeScript looks up a file from a given module specifier. */
-        "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */
-        //"paths": {
-        //  "*": [
-        //    "node_modules/*"
-        //  ]
-        //},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-        // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-        // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-        // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-        // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-        // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-        // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
-        // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
-        // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
-        // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-        // "resolveJsonModule": true,                        /* Enable importing .json files. */
-        // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
-        // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-        /* JavaScript Support */
-        "allowJs": true, /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-        // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-        // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-        /* Emit */
-        "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-        // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-        // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-        // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-        // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-        // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-        "outDir": "./dist", /* Specify an output folder for all emitted files. */
-        // "removeComments": true,                           /* Disable emitting comments. */
-        // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-        // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-        // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-        // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-        // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-        // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-        // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-        // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-        // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-        // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-        // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-        // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-        // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-        // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-        // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-        /* Interop Constraints */
-        // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-        // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
-        // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-        "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-        // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-        "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
-        /* Type Checking */
-        "strict": true, /* Enable all strict type-checking options. */
-        // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-        // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-        // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-        // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-        // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-        // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-        // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-        // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-        // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-        // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-        // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-        // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-        // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-        // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-        // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-        // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-        // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-        // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-        /* Completeness */
-        // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-        "skipLibCheck": true /* Skip type checking all .d.ts files. */
-    }
-}