catniff 0.2.11 → 0.2.12

package/README.md

@@ -87,6 +87,9 @@ I'm mostly just learning and playing with this currently, so there are no concre
 * Proper documentation.
 * GPU acceleration.
 * Some general neural net APIs.
+* Refactor code.
+* Proper tests.
+* Option to load more backends.
 
 ## Copyrights and License
 

package/dist/core.d.ts

@@ -41,6 +41,8 @@ export declare class Tensor {
     sum(dims?: number[] | number, keepDims?: boolean): Tensor;
     prod(dims?: number[] | number, keepDims?: boolean): Tensor;
     mean(dims?: number[] | number, keepDims?: boolean): Tensor;
+    max(dims?: number[] | number, keepDims?: boolean): Tensor;
+    min(dims?: number[] | number, keepDims?: boolean): Tensor;
     add(other: TensorValue | Tensor): Tensor;
     sub(other: TensorValue | Tensor): Tensor;
     subtract: (other: TensorValue | Tensor) => Tensor;

package/dist/core.js

@@ -252,7 +252,7 @@ class Tensor {
     // Tensor squeeze
     squeeze(dims) {
         if (typeof this.value === "number")
-            return new Tensor(this.value);
+            return this;
         if (typeof dims === "number") {
             dims = [dims];
         }
@@ -300,10 +300,9 @@ class Tensor {
     }
     // Tensor unsqueeze - adds dimension of size 1 at specified position
     unsqueeze(dim) {
-        if (typeof this.value === "number")
-            return new Tensor([this.value]);
-        if (dim < 0 || dim > this.shape.length) {
-            throw new Error(`Invalid dimension ${dim} for unsqueeze`);
+        let thisValue = this.value;
+        if (typeof thisValue === "number") {
+            thisValue = [thisValue];
         }
         // Insert size-1 dimension at specified position
         const newShape = [...this.shape];
@@ -320,7 +319,7 @@ class Tensor {
             newDimStride = this.strides[dim] * this.shape[dim];
         }
         newStrides.splice(dim, 0, newDimStride);
-        const out = new Tensor(this.value, { shape: newShape, strides: newStrides });
+        const out = new Tensor(thisValue, { shape: newShape, strides: newStrides });
         // Set up gradient if needed
         if (this.requiresGrad) {
             out.requiresGrad = true;
@@ -334,7 +333,7 @@ class Tensor {
     // Tensor sum reduction
     sum(dims, keepDims = false) {
         if (typeof this.value === "number")
-            return new Tensor(this.value);
+            return this;
         if (typeof dims === "number") {
             dims = [dims];
         }
@@ -364,6 +363,7 @@ class Tensor {
             const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
             // Accumulate, outFlatIndex should match multiple realFlatIndexes
             const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
+            // Add into sum
             outputValue[outFlatIndex] += this.value[realFlatIndex];
             // Mark for gradient if needed
             if (this.requiresGrad) {
@@ -388,7 +388,7 @@ class Tensor {
     // Tensor product reduction
     prod(dims, keepDims = false) {
         if (typeof this.value === "number")
-            return new Tensor(this.value);
+            return this;
         if (typeof dims === "number") {
             dims = [dims];
         }
@@ -401,14 +401,6 @@ class Tensor {
         const outputSize = Tensor.shapeToSize(outputShape);
         const outputValue = new Array(outputSize).fill(1);
         const originalSize = Tensor.shapeToSize(this.shape);
-        // Gradient data
-        let gradShape, gradStrides, gradValue = [];
-        // Allocate gradient data only when needed
-        if (this.requiresGrad) {
-            gradShape = this.shape;
-            gradStrides = this.strides;
-            gradValue = new Array(originalSize).fill(0);
-        }
         // Calculate new value after multiplying
         for (let index = 0; index < originalSize; index++) {
             const coords = Tensor.indexToCoords(index, this.strides);
@@ -418,6 +410,7 @@ class Tensor {
             const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
             // Accumulate, outFlatIndex should match multiple realFlatIndexes
             const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
+            // Multiply into product
             outputValue[outFlatIndex] *= this.value[realFlatIndex];
         }
         const out = new Tensor(outputValue, {
@@ -426,7 +419,7 @@ class Tensor {
         });
         // Set up gradient if needed
         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
+            const gradShape = this.shape, gradStrides = this.strides, gradValue = new Array(originalSize).fill(0);
             for (let index = 0; index < originalSize; index++) {
                 const coords = Tensor.indexToCoords(index, this.strides);
                 // Force 0 on reduced axes to collapse into size-1 dims
@@ -435,7 +428,7 @@ class Tensor {
                 const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
                 // Accumulate, outFlatIndex should match multiple realFlatIndexes
                 const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
-                // Calculate gradient at position
+                // Grad is the product of other elements of the same axis, which is product of all els divided by the current value
                 gradValue[realFlatIndex] = outputValue[outFlatIndex] / this.value[realFlatIndex];
             }
             out.requiresGrad = true;
@@ -450,7 +443,7 @@ class Tensor {
     // Tensor mean reduction
     mean(dims, keepDims = false) {
         if (typeof this.value === "number")
-            return new Tensor(this.value);
+            return this;
         if (typeof dims === "number") {
             dims = [dims];
         }
@@ -464,14 +457,6 @@ class Tensor {
         const outputValue = new Array(outputSize).fill(0);
         const outputFeeders = new Array(outputSize).fill(0);
         const originalSize = Tensor.shapeToSize(this.shape);
-        // Gradient data
-        let gradShape, gradStrides, gradValue = [];
-        // Allocate gradient data only when needed
-        if (this.requiresGrad) {
-            gradShape = this.shape;
-            gradStrides = this.strides;
-            gradValue = new Array(originalSize).fill(0);
-        }
         // Calculate sums and how many elements contribute to specific positions
         for (let index = 0; index < originalSize; index++) {
             const coords = Tensor.indexToCoords(index, this.strides);
@@ -481,6 +466,7 @@ class Tensor {
             const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
             // Accumulate, outFlatIndex should match multiple realFlatIndexes
             const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
+            // Calculate sum and contributors to the sum
             outputValue[outFlatIndex] += this.value[realFlatIndex];
             outputFeeders[outFlatIndex]++;
         }
@@ -494,7 +480,8 @@ class Tensor {
         });
         // Set up gradient if needed
         if (this.requiresGrad) {
-            // Calculate grad by assiging 1 divide by the number of contributors to the position
+            const gradShape = this.shape, gradStrides = this.strides, gradValue = new Array(originalSize).fill(0);
+            // Calculate grad by assigning 1 divided by the number of contributors to the position
             for (let index = 0; index < originalSize; index++) {
                 const coords = Tensor.indexToCoords(index, this.strides);
                 // Force 0 on reduced axes to collapse into size-1 dims
@@ -515,6 +502,120 @@ class Tensor {
         }
         return keepDims ? out : out.squeeze(dims);
     }
+    // Tensor maximum reduction
+    max(dims, keepDims = false) {
+        if (typeof this.value === "number")
+            return this;
+        if (typeof dims === "number") {
+            dims = [dims];
+        }
+        if (typeof dims === "undefined") {
+            dims = Array.from({ length: this.shape.length }, (_, index) => index);
+        }
+        // Dims that are reduced now have size-1
+        const outputShape = this.shape.map((dim, i) => dims.includes(i) ? 1 : dim);
+        const outputStrides = Tensor.getStrides(outputShape);
+        const outputSize = Tensor.shapeToSize(outputShape);
+        const outputValue = new Array(outputSize).fill(-Infinity);
+        const originalSize = Tensor.shapeToSize(this.shape);
+        // Calculate maximum values of axes
+        for (let index = 0; index < originalSize; index++) {
+            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
+            const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
+            // Accumulate, outFlatIndex should match multiple realFlatIndexes
+            const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
+            // Get max over time
+            if (this.value[realFlatIndex] > outputValue[outFlatIndex]) {
+                outputValue[outFlatIndex] = this.value[realFlatIndex];
+            }
+        }
+        const out = new Tensor(outputValue, {
+            shape: outputShape,
+            strides: outputStrides
+        });
+        // Set up gradient if needed
+        if (this.requiresGrad) {
+            const gradShape = this.shape, gradStrides = this.strides, gradValue = new Array(originalSize).fill(0);
+            for (let index = 0; index < originalSize; index++) {
+                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
+                const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
+                // Accumulate, outFlatIndex should match multiple realFlatIndexes
+                const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
+                // Calculate grad by checking if a positon holds a value equal to the max value
+                gradValue[realFlatIndex] = outputValue[outFlatIndex] === this.value[realFlatIndex] ? 1 : 0;
+            }
+            out.requiresGrad = true;
+            out.children.push(this);
+            out.gradFn = () => {
+                const localGrad = new Tensor(gradValue, { shape: gradShape, strides: gradStrides });
+                Tensor.addGrad(this, out.grad.withGrad(false).mul(localGrad));
+            };
+        }
+        return keepDims ? out : out.squeeze(dims);
+    }
+    // Tensor minimum reduction
+    min(dims, keepDims = false) {
+        if (typeof this.value === "number")
+            return this;
+        if (typeof dims === "number") {
+            dims = [dims];
+        }
+        if (typeof dims === "undefined") {
+            dims = Array.from({ length: this.shape.length }, (_, index) => index);
+        }
+        // Dims that are reduced now have size-1
+        const outputShape = this.shape.map((dim, i) => dims.includes(i) ? 1 : dim);
+        const outputStrides = Tensor.getStrides(outputShape);
+        const outputSize = Tensor.shapeToSize(outputShape);
+        const outputValue = new Array(outputSize).fill(Infinity);
+        const originalSize = Tensor.shapeToSize(this.shape);
+        // Calculate minimum values of axes
+        for (let index = 0; index < originalSize; index++) {
+            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
+            const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
+            // Accumulate, outFlatIndex should match multiple realFlatIndexes
+            const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
+            // Get min over time
+            if (this.value[realFlatIndex] < outputValue[outFlatIndex]) {
+                outputValue[outFlatIndex] = this.value[realFlatIndex];
+            }
+        }
+        const out = new Tensor(outputValue, {
+            shape: outputShape,
+            strides: outputStrides
+        });
+        // Set up gradient if needed
+        if (this.requiresGrad) {
+            const gradShape = this.shape, gradStrides = this.strides, gradValue = new Array(originalSize).fill(0);
+            for (let index = 0; index < originalSize; index++) {
+                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
+                const outFlatIndex = Tensor.coordsToIndex(outCoords, outputStrides);
+                // Accumulate, outFlatIndex should match multiple realFlatIndexes
+                const realFlatIndex = Tensor.coordsToIndex(coords, this.strides);
+                // Calculate grad by checking if a positon holds a value equal to the min value
+                gradValue[realFlatIndex] = outputValue[outFlatIndex] === this.value[realFlatIndex] ? 1 : 0;
+            }
+            out.requiresGrad = true;
+            out.children.push(this);
+            out.gradFn = () => {
+                const localGrad = new Tensor(gradValue, { shape: gradShape, strides: gradStrides });
+                Tensor.addGrad(this, out.grad.withGrad(false).mul(localGrad));
+            };
+        }
+        return keepDims ? out : out.squeeze(dims);
+    }
     // Tensor element-wise addition
     add(other) {
         return this.elementWiseABDAG(other, (a, b) => a + b, (self, other, outGrad) => outGrad, (self, other, outGrad) => outGrad);

package/package.json

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