catniff 0.1.8 → 0.1.9

package/dist/autograd.d.ts

@@ -45,8 +45,10 @@ export declare enum OP {
     SIGMOID = 42,
     TANH = 43,
     T = 44,
-    MM = 45,
-    DOT = 46
+    DOT = 45,
+    MM = 46,
+    MV = 47,
+    MATMUL = 48
 }
 export declare class Node {
     value: Tensor;
@@ -56,26 +58,26 @@ export declare class 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;
-    ge(other: Node | number): Node;
-    le(other: Node | number): Node;
-    gt(other: Node | number): Node;
-    lt(other: Node | number): Node;
-    eq(other: Node | number): Node;
-    logicalAnd(other: Node | number): Node;
-    logicalOr(other: Node | number): Node;
-    logicalXor(other: Node | number): Node;
+    add(other: Node | Tensor): Node;
+    sub(other: Node | Tensor): Node;
+    mul(other: Node | Tensor): Node;
+    pow(other: Node | Tensor): Node;
+    div(other: Node | Tensor): Node;
+    ge(other: Node | Tensor): Node;
+    le(other: Node | Tensor): Node;
+    gt(other: Node | Tensor): Node;
+    lt(other: Node | Tensor): Node;
+    eq(other: Node | Tensor): Node;
+    logicalAnd(other: Node | Tensor): Node;
+    logicalOr(other: Node | Tensor): Node;
+    logicalXor(other: Node | Tensor): Node;
     logicalNot(): Node;
-    bitwiseAnd(other: Node | number): Node;
-    bitwiseOr(other: Node | number): Node;
-    bitwiseXor(other: Node | number): Node;
+    bitwiseAnd(other: Node | Tensor): Node;
+    bitwiseOr(other: Node | Tensor): Node;
+    bitwiseXor(other: Node | Tensor): Node;
     bitwiseNot(): Node;
-    bitwiseLeftShift(other: Node | number): Node;
-    bitwiseRightShift(other: Node | number): Node;
+    bitwiseLeftShift(other: Node | Tensor): Node;
+    bitwiseRightShift(other: Node | Tensor): Node;
     neg(): Node;
     abs(): Node;
     sign(): Node;
@@ -100,9 +102,11 @@ export declare class Node {
     sigmoid(): Node;
     tanh(): Node;
     t(): Node;
-    mm(other: Node | number): Node;
-    dot(other: Node | number): Node;
+    dot(other: Node | Tensor): Node;
+    mm(other: Node | Tensor): Node;
+    mv(other: Node | Tensor): Node;
+    matmul(other: Node | Tensor): Node;
     backward(): void;
-    static forceNode(value: Node | number): Node;
+    static forceNode(value: Node | Tensor): Node;
     static addGrad(node: Node, accumGrad: Tensor): void;
 }

package/dist/autograd.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = exports.OP = void 0;
 const tensor_1 = require("./tensor");
-const { add, sub, mul, pow, div, gt, lt, ge, le, eq, logicalAnd, logicalOr, logicalXor, logicalNot, bitwiseAnd, bitwiseOr, bitwiseXor, bitwiseNot, bitwiseLeftShift, bitwiseRightShift, neg, abs, sign, sin, cos, tan, asin, acos, atan, sinh, cosh, asinh, acosh, atanh, sqrt, exp, log, log2, log10, log1p, relu, sigmoid, tanh, t, mm, dot } = tensor_1.TensorMath;
+const { add, sub, mul, pow, div, gt, lt, ge, le, eq, logicalAnd, logicalOr, logicalXor, logicalNot, bitwiseAnd, bitwiseOr, bitwiseXor, bitwiseNot, bitwiseLeftShift, bitwiseRightShift, neg, abs, sign, sin, cos, tan, asin, acos, atan, sinh, cosh, asinh, acosh, atanh, sqrt, exp, log, log2, log10, log1p, relu, sigmoid, tanh, t, dot, mm, mv, matmul } = tensor_1.TensorMath;
 var OP;
 (function (OP) {
     OP[OP["NONE"] = 0] = "NONE";
@@ -50,8 +50,10 @@ var OP;
     OP[OP["SIGMOID"] = 42] = "SIGMOID";
     OP[OP["TANH"] = 43] = "TANH";
     OP[OP["T"] = 44] = "T";
-    OP[OP["MM"] = 45] = "MM";
-    OP[OP["DOT"] = 46] = "DOT";
+    OP[OP["DOT"] = 45] = "DOT";
+    OP[OP["MM"] = 46] = "MM";
+    OP[OP["MV"] = 47] = "MV";
+    OP[OP["MATMUL"] = 48] = "MATMUL";
 })(OP || (exports.OP = OP = {}));
 class Node {
     value;
@@ -439,6 +441,15 @@ class Node {
         };
         return out;
     }
+    dot(other) {
+        other = Node.forceNode(other);
+        const out = new Node(dot(this.value, other.value), [this, other], OP.DOT);
+        out.feedBackward = () => {
+            Node.addGrad(this, mul(out.grad, other.value));
+            Node.addGrad(other, mul(out.grad, this.value));
+        };
+        return out;
+    }
     mm(other) {
         other = Node.forceNode(other);
         const out = new Node(mm(this.value, other.value), [this, other], OP.MM);
@@ -448,15 +459,46 @@ class Node {
         };
         return out;
     }
-    dot(other) {
+    mv(other) {
         other = Node.forceNode(other);
-        const out = new Node(dot(this.value, other.value), [this, other], OP.DOT);
+        const out = new Node(mv(this.value, other.value), [this, other], OP.MV);
         out.feedBackward = () => {
-            Node.addGrad(this, mul(out.grad, other.value));
-            Node.addGrad(other, mul(out.grad, this.value));
+            const outGradMat = out.grad.map(el => [el]);
+            Node.addGrad(this, mm(outGradMat, [other.value]));
+            Node.addGrad(other, mv(t(this.value), out.grad));
         };
         return out;
     }
+    matmul(other) {
+        other = Node.forceNode(other);
+        const out = new Node(matmul(this.value, other.value), [this, other], OP.MATMUL);
+        if (this.shape.length === 1 && other.shape.length === 1) {
+            out.feedBackward = () => {
+                Node.addGrad(this, mul(out.grad, other.value));
+                Node.addGrad(other, mul(out.grad, this.value));
+            };
+        }
+        else if (this.shape.length === 1 && other.shape.length === 2) {
+            out.feedBackward = () => {
+                Node.addGrad(this, matmul(out.grad, t(other.value)));
+                Node.addGrad(other, mm(t([this.value]), [out.grad]));
+            };
+        }
+        else if (this.shape.length === 2 && other.shape.length === 1) {
+            out.feedBackward = () => {
+                const outGradMat = out.grad.map(el => [el]);
+                Node.addGrad(this, mm(outGradMat, [other.value]));
+                Node.addGrad(other, mv(t(this.value), out.grad));
+            };
+        }
+        else if (this.shape.length === 2 && other.shape.length === 2) {
+            out.feedBackward = () => {
+                Node.addGrad(this, mm(out.grad, t(other.value)));
+                Node.addGrad(other, mm(t(this.value), out.grad));
+            };
+        }
+        return out;
+    }
     backward() {
         // Build topological order
         const topo = [];

package/dist/tensor.d.ts

@@ -53,6 +53,8 @@ export declare class TensorMath {
     static sumAxis(tA: Tensor, axis: number): Tensor;
     static sum(tA: Tensor, dims?: number[] | number, keepDims?: boolean): Tensor;
     static t(tA: Tensor): Tensor;
-    static mm(tA: Tensor, tB: Tensor): Tensor;
     static dot(tA: Tensor, tB: Tensor): Tensor;
+    static mm(tA: Tensor, tB: Tensor): Tensor;
+    static mv(tA: Tensor, tB: Tensor): Tensor;
+    static matmul(tA: Tensor, tB: Tensor): Tensor;
 }

package/dist/tensor.js

@@ -266,6 +266,20 @@ class TensorMath {
         }
         return matATranspose;
     }
+    static dot(tA, tB) {
+        const shapeA = TensorMath.getShape(tA);
+        const shapeB = TensorMath.getShape(tB);
+        if (shapeA.length !== 1 || shapeB.length !== 1 || shapeA[0] !== shapeB[0])
+            throw new Error("Inputs are not 1D tensors");
+        const vectLen = shapeA[0];
+        const vectA = tA;
+        const vectB = tB;
+        let sum = 0;
+        for (let index = 0; index < vectLen; index++) {
+            sum += vectA[index] * vectB[index];
+        }
+        return sum;
+    }
     static mm(tA, tB) {
         const shapeA = TensorMath.getShape(tA);
         const shapeB = TensorMath.getShape(tB);
@@ -289,19 +303,32 @@ class TensorMath {
         }
         return matC;
     }
-    static dot(tA, tB) {
+    static mv(tA, tB) {
         const shapeA = TensorMath.getShape(tA);
         const shapeB = TensorMath.getShape(tB);
-        if (shapeA.length !== 1 || shapeB.length !== 1 || shapeA[0] !== shapeB[0])
-            throw new Error("Inputs are not 1D tensors");
-        const vectLen = shapeA[0];
-        const vectA = tA;
-        const vectB = tB;
-        let sum = 0;
-        for (let index = 0; index < vectLen; index++) {
-            sum += vectA[index] * vectB[index];
+        if (shapeA.length !== 2 || shapeB.length !== 1)
+            throw new Error("Input is not a 2D and 1D tensor pair");
+        const matA = tA;
+        const matB = tB.map(el => [el]); // Turn the 1D tensor into a nx1 matrix (vector)
+        return TensorMath.mm(matA, matB).map(el => el[0]);
+    }
+    static matmul(tA, tB) {
+        const shapeA = TensorMath.getShape(tA);
+        const shapeB = TensorMath.getShape(tB);
+        if (shapeA.length === 1 && shapeB.length === 1) {
+            return TensorMath.dot(tA, tB);
         }
-        return sum;
+        else if (shapeA.length === 1 && shapeB.length === 2) {
+            return TensorMath.mm([tA], tB)[0];
+        }
+        else if (shapeA.length === 2 && shapeB.length === 1) {
+            return TensorMath.mv(tA, tB);
+        }
+        else if (shapeA.length === 2 && shapeB.length === 2) {
+            return TensorMath.mm(tA, tB);
+        }
+        // Batched matmul will come when general nD transpose is done
+        throw new Error(`Shapes [] and [] are not supported`);
     }
 }
 exports.TensorMath = TensorMath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catniff",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "A cute autograd engine for Javascript",
   "main": "index.js",
   "scripts": {