catniff 0.2.8 → 0.2.10

package/dist/core.d.ts

@@ -26,7 +26,7 @@ export declare class Tensor {
         readonly number[]
     ];
     static broadcastShapes(shapeA: readonly number[], shapeB: readonly number[]): readonly number[];
-    static indexToCoords(index: number, shape: readonly number[], strides: readonly number[]): number[];
+    static indexToCoords(index: number, strides: readonly number[]): number[];
     static coordsToUnbroadcastedIndex(coords: number[], shape: readonly number[], strides: readonly number[]): number;
     static coordsToIndex(coords: number[], strides: readonly number[]): number;
     static shapeToSize(shape: readonly number[]): number;
@@ -43,14 +43,25 @@ export declare class Tensor {
     mean(dims?: number[] | number, keepDims?: boolean): Tensor;
     add(other: TensorValue | Tensor): Tensor;
     sub(other: TensorValue | Tensor): Tensor;
+    subtract: (other: TensorValue | Tensor) => Tensor;
     mul(other: TensorValue | Tensor): Tensor;
+    multiply: (other: TensorValue | Tensor) => Tensor;
     pow(other: TensorValue | Tensor): Tensor;
     div(other: TensorValue | Tensor): Tensor;
+    divide: (other: TensorValue | Tensor) => Tensor;
+    remainder(other: TensorValue | Tensor): Tensor;
     ge(other: TensorValue | Tensor): Tensor;
+    greaterEqual: (other: TensorValue | Tensor) => Tensor;
     le(other: TensorValue | Tensor): Tensor;
+    lessEqual: (other: TensorValue | Tensor) => Tensor;
     gt(other: TensorValue | Tensor): Tensor;
+    greater: (other: TensorValue | Tensor) => Tensor;
     lt(other: TensorValue | Tensor): Tensor;
+    less: (other: TensorValue | Tensor) => Tensor;
     eq(other: TensorValue | Tensor): Tensor;
+    equal: (other: TensorValue | Tensor) => Tensor;
+    ne(other: TensorValue | Tensor): Tensor;
+    notEqual: (other: TensorValue | Tensor) => Tensor;
     logicalAnd(other: TensorValue | Tensor): Tensor;
     logicalOr(other: TensorValue | Tensor): Tensor;
     logicalXor(other: TensorValue | Tensor): Tensor;
@@ -62,21 +73,38 @@ export declare class Tensor {
     bitwiseLeftShift(other: TensorValue | Tensor): Tensor;
     bitwiseRightShift(other: TensorValue | Tensor): Tensor;
     neg(): Tensor;
+    negative: () => Tensor;
+    reciprocal(): Tensor;
+    square(): Tensor;
     abs(): Tensor;
+    absolute: () => Tensor;
     sign(): Tensor;
     sin(): Tensor;
     cos(): Tensor;
     tan(): Tensor;
     asin(): Tensor;
+    arcsin: () => Tensor;
     acos(): Tensor;
+    arccos: () => Tensor;
     atan(): Tensor;
+    arctan: () => Tensor;
+    atan2(other: TensorValue | Tensor): Tensor;
+    arctan2: (other: TensorValue | Tensor) => Tensor;
     sinh(): Tensor;
     cosh(): Tensor;
     asinh(): Tensor;
+    arcsinh: () => Tensor;
     acosh(): Tensor;
+    arccosh: () => Tensor;
     atanh(): Tensor;
+    arctanh: () => Tensor;
+    deg2rad(): Tensor;
+    rad2deg(): Tensor;
     sqrt(): Tensor;
+    rsqrt(): Tensor;
     exp(): Tensor;
+    exp2(): Tensor;
+    expm1(): Tensor;
     log(): Tensor;
     log2(): Tensor;
     log10(): Tensor;
@@ -84,7 +112,17 @@ export declare class Tensor {
     relu(): Tensor;
     sigmoid(): Tensor;
     tanh(): Tensor;
+    round(): Tensor;
+    floor(): Tensor;
+    ceil(): Tensor;
+    trunc(): Tensor;
+    fix: () => Tensor;
+    frac(): Tensor;
+    clip(min: number, max: number): Tensor;
+    clamp: (min: number, max: number) => Tensor;
     transpose(dim1: number, dim2: number): Tensor;
+    swapaxes: (dim1: number, dim2: number) => Tensor;
+    swapdims: (dim1: number, dim2: number) => Tensor;
     t(): Tensor;
     dot(other: TensorValue | Tensor): Tensor;
     mm(other: TensorValue | Tensor): Tensor;

package/dist/core.js

@@ -94,12 +94,10 @@ class Tensor {
         return newShape;
     }
     // Utility to convert flat index to array of coordinates
-    static indexToCoords(index, shape, strides) {
-        const coords = new Array(shape.length);
+    static indexToCoords(index, strides) {
+        const coords = new Array(strides.length);
         let remaining = index;
-        // Sort dimensions by stride (largest first) for correct decomposition
-        const sortedDims = shape.map((_, i) => i).sort((a, b) => strides[b] - strides[a]);
-        for (const dim of sortedDims) {
+        for (let dim = 0; dim < strides.length; dim++) {
             coords[dim] = Math.floor(remaining / strides[dim]);
             remaining %= strides[dim];
         }
@@ -152,7 +150,7 @@ class Tensor {
         const outputValue = new Array(outputSize);
         for (let i = 0; i < outputSize; i++) {
             // Get coordinates from 1D index
-            const coordsOutput = Tensor.indexToCoords(i, outputShape, outputStrides);
+            const coordsOutput = Tensor.indexToCoords(i, outputStrides);
             // Convert the coordinates to 1D index of flattened A with respect to A's shape
             const indexA = Tensor.coordsToUnbroadcastedIndex(coordsOutput, paddedAShape, paddedAStrides);
             // Convert the coordinates to 1D index of flattened B with respect to B's shape
@@ -267,14 +265,19 @@ class Tensor {
             }
         }
         // Remove size-1 dims only
-        const outShape = this.shape.filter((dim, i) => {
-            const shouldSqueeze = dims.includes(i);
-            if (shouldSqueeze && dim !== 1)
-                throw new Error(`Can not squeeze dim with size ${dim}`);
-            return !shouldSqueeze;
-        });
-        // Remove strides of size-1 dims
-        const outStrides = this.strides.filter((stride, i) => !dims.includes(i));
+        const outShape = [], outStrides = [];
+        for (let index = 0; index < this.shape.length; index++) {
+            const dim = this.shape[index];
+            const stride = this.strides[index];
+            if (dims.includes(index)) {
+                if (dim !== 1)
+                    throw new Error(`Can not squeeze dim with size ${dim}`);
+            }
+            else {
+                outShape.push(dim);
+                outStrides.push(stride);
+            }
+        }
         const outValue = outShape.length === 0 ? this.value[0] : this.value;
         const out = new Tensor(outValue, {
             shape: outShape,
@@ -353,7 +356,7 @@ class Tensor {
         }
         // Calculate new value after sum
         for (let index = 0; index < originalSize; index++) {
-            const coords = Tensor.indexToCoords(index, this.shape, this.strides);
+            const coords = Tensor.indexToCoords(index, this.strides);
             // Force 0 on reduced axes to collapse into size-1 dims
             const outCoords = coords.map((val, i) => dims.includes(i) ? 0 : val);
             // Convert output coordinates to flat index
@@ -407,7 +410,7 @@ class Tensor {
         }
         // Calculate new value after multiplying
         for (let index = 0; index < originalSize; index++) {
-            const coords = Tensor.indexToCoords(index, this.shape, this.strides);
+            const coords = Tensor.indexToCoords(index, this.strides);
             // Force 0 on reduced axes to collapse into size-1 dims
             const outCoords = coords.map((val, i) => dims.includes(i) ? 0 : val);
             // Convert output coordinates to flat index
@@ -424,7 +427,7 @@ class Tensor {
         if (this.requiresGrad) {
             // Grad is the product of other elements of the same axis, which is product of all els divided by the current value
             for (let index = 0; index < originalSize; index++) {
-                const coords = Tensor.indexToCoords(index, this.shape, this.strides);
+                const coords = Tensor.indexToCoords(index, this.strides);
                 // Force 0 on reduced axes to collapse into size-1 dims
                 const outCoords = coords.map((val, i) => dims.includes(i) ? 0 : val);
                 // Convert output coordinates to flat index
@@ -470,7 +473,7 @@ class Tensor {
         }
         // Calculate sums and how many elements contribute to specific positions
         for (let index = 0; index < originalSize; index++) {
-            const coords = Tensor.indexToCoords(index, this.shape, this.strides);
+            const coords = Tensor.indexToCoords(index, this.strides);
             // Force 0 on reduced axes to collapse into size-1 dims
             const outCoords = coords.map((val, i) => dims.includes(i) ? 0 : val);
             // Convert output coordinates to flat index
@@ -492,7 +495,7 @@ class Tensor {
         if (this.requiresGrad) {
             // Calculate grad by assiging 1 divide by the number of contributors to the position
             for (let index = 0; index < originalSize; index++) {
-                const coords = Tensor.indexToCoords(index, this.shape, this.strides);
+                const coords = Tensor.indexToCoords(index, this.strides);
                 // Force 0 on reduced axes to collapse into size-1 dims
                 const outCoords = coords.map((val, i) => dims.includes(i) ? 0 : val);
                 // Convert output coordinates to flat index
@@ -519,10 +522,12 @@ class Tensor {
     sub(other) {
         return this.elementWiseABDAG(other, (a, b) => a - b, (self, other, outGrad) => outGrad, (self, other, outGrad) => outGrad.neg());
     }
+    subtract = this.sub;
     // Tensor element-wise multiplication
     mul(other) {
         return this.elementWiseABDAG(other, (a, b) => a * b, (self, other, outGrad) => outGrad.mul(other), (self, other, outGrad) => outGrad.mul(self));
     }
+    multiply = this.mul;
     // Tensor element-wise power
     pow(other) {
         return this.elementWiseABDAG(other, (a, b) => a ** b, (self, other, outGrad) => outGrad.mul(other.mul(self.pow(other.sub(1)))), (self, other, outGrad) => outGrad.mul(self.pow(other).mul(self.log())));
@@ -531,26 +536,41 @@ class Tensor {
     div(other) {
         return this.elementWiseABDAG(other, (a, b) => a / b, (self, other, outGrad) => outGrad.div(other), (self, other, outGrad) => outGrad.mul(self.neg().div(other.pow(2))));
     }
+    divide = this.div;
+    // Tensor element-wise modulo
+    remainder(other) {
+        return this.elementWiseABDAG(other, (a, b) => a % b);
+    }
     // Tensor element-wise greater or equal comparison
     ge(other) {
         return this.elementWiseABDAG(other, (a, b) => a >= b ? 1 : 0);
     }
+    greaterEqual = this.ge;
     // Tensor element-wise less or equal comparison
     le(other) {
         return this.elementWiseABDAG(other, (a, b) => a <= b ? 1 : 0);
     }
+    lessEqual = this.le;
     // Tensor element-wise greater-than comparison
     gt(other) {
         return this.elementWiseABDAG(other, (a, b) => a > b ? 1 : 0);
     }
+    greater = this.gt;
     // Tensor element-wise less-than comparison
     lt(other) {
         return this.elementWiseABDAG(other, (a, b) => a < b ? 1 : 0);
     }
+    less = this.lt;
     // Tensor element-wise equality comparison
     eq(other) {
         return this.elementWiseABDAG(other, (a, b) => a === b ? 1 : 0);
     }
+    equal = this.eq;
+    // Tensor element-wise not equality comparison
+    ne(other) {
+        return this.elementWiseABDAG(other, (a, b) => a !== b ? 1 : 0);
+    }
+    notEqual = this.ne;
     // Tensor element-wise logical and
     logicalAnd(other) {
         return this.elementWiseABDAG(other, (a, b) => a === 1 && b === 1 ? 1 : 0);
@@ -595,10 +615,20 @@ class Tensor {
     neg() {
         return this.elementWiseSelfDAG((a) => -a, (self, outGrad) => outGrad.mul(-1));
     }
+    negative = this.neg;
+    // Tensor element-wise reciprocal
+    reciprocal() {
+        return this.elementWiseSelfDAG((a) => 1 / a, (self, outGrad) => outGrad.mul(self.neg().pow(-2)));
+    }
+    // Tensor element-wise square
+    square() {
+        return this.elementWiseSelfDAG((a) => a * a, (self, outGrad) => outGrad.mul(self.mul(2)));
+    }
     // Tensor element-wise absolute
     abs() {
         return this.elementWiseSelfDAG((a) => Math.abs(a), (self, outGrad) => outGrad.mul(self.sign()));
     }
+    absolute = this.abs;
     // Tensor element-wise sign function
     sign() {
         return this.elementWiseSelfDAG((a) => Math.sign(a));
@@ -619,14 +649,22 @@ class Tensor {
     asin() {
         return this.elementWiseSelfDAG((a) => Math.asin(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1).sqrt()));
     }
+    arcsin = this.asin;
     // Tensor element-wise acos
     acos() {
         return this.elementWiseSelfDAG((a) => Math.acos(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1).sqrt()).neg());
     }
+    arccos = this.acos;
     // Tensor element-wise atan
     atan() {
         return this.elementWiseSelfDAG((a) => Math.atan(a), (self, outGrad) => outGrad.div(self.pow(2).add(1)));
     }
+    arctan = this.atan;
+    // Tensor element-wise atan2
+    atan2(other) {
+        return this.elementWiseABDAG(other, (a, b) => Math.atan2(a, b), (self, other, outGrad) => outGrad.mul(other.div(self.square().add(other.square()))), (self, other, outGrad) => outGrad.mul(self.neg().div(self.square().add(other.square()))));
+    }
+    arctan2 = this.atan2;
     // Tensor element-wise sinh
     sinh() {
         return this.elementWiseSelfDAG((a) => Math.sinh(a), (self, outGrad) => outGrad.mul(self.cosh()));
@@ -639,22 +677,45 @@ class Tensor {
     asinh() {
         return this.elementWiseSelfDAG((a) => Math.asinh(a), (self, outGrad) => outGrad.div(self.pow(2).add(1).sqrt()));
     }
+    arcsinh = this.asinh;
     // Tensor element-wise acosh
     acosh() {
         return this.elementWiseSelfDAG((a) => Math.acosh(a), (self, outGrad) => outGrad.div(self.add(1).sqrt().mul(self.sub(1).sqrt())));
     }
+    arccosh = this.acosh;
     // Tensor element-wise atanh
     atanh() {
         return this.elementWiseSelfDAG((a) => Math.atanh(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1)));
     }
+    arctanh = this.atanh;
+    // Tensor element-wise degree to radian
+    deg2rad() {
+        return this.elementWiseSelfDAG((a) => a * (Math.PI / 180), (self, outGrad) => outGrad.mul(Math.PI / 180));
+    }
+    // Tensor element-wise radian to degree
+    rad2deg() {
+        return this.elementWiseSelfDAG((a) => a / (Math.PI / 180), (self, outGrad) => outGrad.div(Math.PI / 180));
+    }
     // Tensor element-wise square root
     sqrt() {
         return this.elementWiseSelfDAG((a) => Math.sqrt(a), (self, outGrad) => outGrad.div(self.sqrt().mul(2)));
     }
+    // Tensor element-wise reciprocal of square root
+    rsqrt() {
+        return this.elementWiseSelfDAG((a) => 1 / Math.sqrt(a), (self, outGrad) => outGrad.mul(self.pow(-1.5).mul(-0.5)));
+    }
     // Tensor element-wise e^x
     exp() {
         return this.elementWiseSelfDAG((a) => Math.exp(a), (self, outGrad) => outGrad.mul(self.exp()));
     }
+    // Tensor element-wise 2^x
+    exp2() {
+        return this.elementWiseSelfDAG((a) => 2 ** a, (self, outGrad) => outGrad.mul(self.exp2().mul(Math.log(2))));
+    }
+    // Tensor element-wise e^x - 1
+    expm1() {
+        return this.elementWiseSelfDAG((a) => Math.expm1(a), (self, outGrad) => outGrad.mul(self.exp()));
+    }
     // Tensor element-wise natural log
     log() {
         return this.elementWiseSelfDAG((a) => Math.log(a), (self, outGrad) => outGrad.div(self));
@@ -686,6 +747,32 @@ class Tensor {
     tanh() {
         return this.elementWiseSelfDAG((a) => Math.tanh(a), (self, outGrad) => outGrad.mul(self.tanh().pow(2).neg().add(1)));
     }
+    // Tensor element-wise round
+    round() {
+        return this.elementWiseSelfDAG((a) => Math.round(a));
+    }
+    // Tensor element-wise floor
+    floor() {
+        return this.elementWiseSelfDAG((a) => Math.floor(a));
+    }
+    // Tensor element-wise ceil
+    ceil() {
+        return this.elementWiseSelfDAG((a) => Math.ceil(a));
+    }
+    // Tensor element-wise truncation
+    trunc() {
+        return this.elementWiseSelfDAG((a) => Math.trunc(a));
+    }
+    fix = this.trunc;
+    // Tensor element-wise fraction portion
+    frac() {
+        return this.elementWiseSelfDAG((a) => a - Math.floor(a));
+    }
+    // Tensor element-wise clip and clamp
+    clip(min, max) {
+        return this.elementWiseSelfDAG((a) => Math.max(min, Math.min(max, a)), (self, outGrad) => outGrad.mul(self.ge(min).mul(self.le(max))));
+    }
+    clamp = this.clip;
     // Transpose
     transpose(dim1, dim2) {
         // If dimension out of bound, throw error
@@ -713,6 +800,8 @@ class Tensor {
         }
         return out;
     }
+    swapaxes = this.transpose;
+    swapdims = this.transpose;
     // Transpose 2D
     t() {
         // Verify matrix shape

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catniff",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "A cute autograd engine for Javascript",
   "main": "index.js",
   "scripts": {
@@ -26,7 +26,9 @@
     "neural-network",
     "machine-learning",
     "deep-learning",
-    "micrograd"
+    "micrograd",
+    "torch",
+    "pytorch"
   ],
   "author": "nguyenphuminh",
   "license": "GPL-3.0",