catniff 0.6.2 → 0.6.4

package/dist/core.d.ts

@@ -182,6 +182,8 @@ export declare class Tensor {
     mv(other: TensorValue | Tensor): Tensor;
     matmul(other: TensorValue | Tensor): Tensor;
     dropout(rate: number): Tensor;
+    triu(diagonal?: number): Tensor;
+    tril(diagonal?: number): Tensor;
     static full(shape: readonly number[], num: number, options?: TensorOptions): Tensor;
     static fullLike(tensor: Tensor, num: number, options?: TensorOptions): Tensor;
     static ones(shape?: readonly number[], options?: TensorOptions): Tensor;
@@ -194,8 +196,12 @@ export declare class Tensor {
     static randnLike(tensor: Tensor, options?: TensorOptions): Tensor;
     static randint(shape: readonly number[], low: number, high: number, options?: TensorOptions): Tensor;
     static randintLike(tensor: Tensor, low: number, high: number, options?: TensorOptions): Tensor;
+    static randperm(n: number, options?: TensorOptions): Tensor;
     static normal(shape: number[], mean: number, stdDev: number, options?: TensorOptions): Tensor;
     static uniform(shape: number[], low: number, high: number, options?: TensorOptions): Tensor;
+    static arange(start: number, stop?: number, step?: number, options?: TensorOptions): Tensor;
+    static linspace(start: number, stop: number, steps: number, options?: TensorOptions): Tensor;
+    static eye(n: number, m?: number, options?: TensorOptions): Tensor;
     backward(options?: {
         zeroGrad?: boolean;
     }): void;

package/dist/core.js

@@ -1417,6 +1417,54 @@ class Tensor {
         const mask = uniform.lt(keepRate);
         return this.mul(mask).div(keepRate);
     }
+    // Get the upper triangular part with respect to main diagonal
+    triu(diagonal = 0) {
+        if (this.shape.length < 2) {
+            throw new Error("triu requires at least 2 dimensions");
+        }
+        const maskShape = this.shape.slice(-2);
+        const maskStrides = Tensor.getStrides(maskShape);
+        const maskSize = Tensor.shapeToSize(maskShape);
+        const maskValue = new Array(maskSize).fill(1);
+        const [rows, cols] = maskShape;
+        for (let i = 0; i < rows; i++) {
+            const maxJ = Math.min(cols, i + diagonal);
+            for (let j = 0; j < maxJ; j++) {
+                maskValue[i * maskStrides[0] + j * maskStrides[1]] = 0;
+            }
+        }
+        const mask = new Tensor(maskValue, {
+            shape: maskShape,
+            strides: maskStrides,
+            numel: maskSize,
+            device: this.device
+        });
+        return this.mul(mask);
+    }
+    // Get the lower triangular part with respect to main diagonal
+    tril(diagonal = 0) {
+        if (this.shape.length < 2) {
+            throw new Error("triu requires at least 2 dimensions");
+        }
+        const maskShape = this.shape.slice(-2);
+        const maskStrides = Tensor.getStrides(maskShape);
+        const maskSize = Tensor.shapeToSize(maskShape);
+        const maskValue = new Array(maskSize).fill(0);
+        const [rows, cols] = maskShape;
+        for (let i = 0; i < rows; i++) {
+            const maxJ = Math.min(cols, i + diagonal + 1);
+            for (let j = 0; j < maxJ; j++) {
+                maskValue[i * maskStrides[0] + j * maskStrides[1]] = 1;
+            }
+        }
+        const mask = new Tensor(maskValue, {
+            shape: maskShape,
+            strides: maskStrides,
+            numel: maskSize,
+            device: this.device
+        });
+        return this.mul(mask);
+    }
     // Utility to create a new tensor filled with a number
     static full(shape, num, options = {}) {
         if (shape.length === 0)
@@ -1552,6 +1600,15 @@ class Tensor {
             ...options
         });
     }
+    // Utility to create a new tensor filled with integers from 0 to n, randomly shuffled
+    static randperm(n, options = {}) {
+        const outputValue = new Array(n);
+        for (let i = 0; i < n; i++) {
+            outputValue[i] = i;
+        }
+        (0, utils_1.fyShuffle)(outputValue);
+        return new Tensor(outputValue, { shape: [n], numel: n, ...options });
+    }
     // Utility to create a new tensor filled with a random number with normal distribution of custom mean and stddev
     static normal(shape, mean, stdDev, options = {}) {
         if (shape.length === 0)
@@ -1574,6 +1631,47 @@ class Tensor {
         }
         return new Tensor(outputValue, { shape, numel: outputSize, ...options });
     }
+    // Utility to create an 1D tensor from a range incrementing with "step"
+    static arange(start, stop, step = 1, options = {}) {
+        if (typeof stop === "undefined") {
+            stop = start;
+            start = 0;
+        }
+        const outputSize = Math.ceil((stop - start) / step);
+        const outputShape = [outputSize];
+        const outputValue = new Array(outputSize);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = start + step * index;
+        }
+        return new Tensor(outputValue, { shape: outputShape, numel: outputSize, ...options });
+    }
+    // Utility to create an 1D tensor from a range evenly spaced out with a given amount of steps
+    static linspace(start, stop, steps, options = {}) {
+        if (steps <= 0)
+            throw new Error("Steps must be positive");
+        if (steps === 1) {
+            return new Tensor([start], { shape: [1], numel: 1, ...options });
+        }
+        const step = (stop - start) / (steps - 1);
+        const outputValue = new Array(steps);
+        for (let index = 0; index < steps; index++) {
+            outputValue[index] = start + step * index;
+        }
+        // Ensure we hit the endpoint exactly (avoids floating point errors)
+        outputValue[steps - 1] = stop;
+        return new Tensor(outputValue, { shape: [steps], numel: steps, ...options });
+    }
+    // Utility to create a 2D tensor with its main diagonal filled with 1s and others with 0s
+    static eye(n, m = n, options = {}) {
+        const outputSize = n * m;
+        const outputShape = [n, m];
+        const outputStrides = Tensor.getStrides(outputShape);
+        const outputValue = new Array(outputSize).fill(0);
+        for (let i = 0; i < Math.min(n, m); i++) {
+            outputValue[i * outputStrides[0] + i * outputStrides[1]] = 1;
+        }
+        return new Tensor(outputValue, { shape: outputShape, strides: outputStrides, numel: outputSize, ...options });
+    }
     // Reverse-mode autodiff call
     backward(options = {}) {
         // Init

package/dist/utils.d.ts

@@ -4,3 +4,4 @@ export declare function erfinv(x: number): number;
 export declare function randUniform(low?: number, high?: number): number;
 export declare function randNormal(mean?: number, stdDev?: number): number;
 export declare function randInt(low: number, high: number): number;
+export declare function fyShuffle(array: any[]): void;

package/dist/utils.js

@@ -6,6 +6,7 @@ exports.erfinv = erfinv;
 exports.randUniform = randUniform;
 exports.randNormal = randNormal;
 exports.randInt = randInt;
+exports.fyShuffle = fyShuffle;
 // Error function using Abramowitz and Stegun approximation
 function erf(x) {
     const a1 = 0.254829592;
@@ -36,15 +37,26 @@ function erfinv(x) {
     const sign = x >= 0 ? 1 : -1;
     return sign * Math.sqrt(-part1 + Math.sqrt(part1 * part1 - part2));
 }
+// Generate a random number with uniform distribution
 function randUniform(low = 0, high = 1) {
     return Math.random() * (high - low) + low;
 }
+// Generate a random number with normal distribution
 function randNormal(mean = 0, stdDev = 1) {
     const u = 1 - Math.random();
     const v = 1 - Math.random();
     const z = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
     return z * stdDev + mean;
 }
+// Generate a random integer
 function randInt(low, high) {
     return Math.floor(Math.random() * (high - low) + low);
 }
+// Randomly shuffle an array with fisher-yates algorithm
+function fyShuffle(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+}
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catniff",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "A small Torch-like deep learning framework for Javascript",
   "main": "index.js",
   "scripts": {