catniff 0.8.6 → 0.8.8

package/dist/core.d.ts

@@ -99,6 +99,8 @@ export declare class Tensor {
     std(dims?: number[] | number, keepDims?: boolean): Tensor;
     softmax(dim?: number): Tensor;
     softmin(dim?: number): Tensor;
+    logsumexp(dim?: number): Tensor;
+    logSoftmax(dim?: number): Tensor;
     add(other: TensorValue | Tensor): Tensor;
     sub(other: TensorValue | Tensor): Tensor;
     subtract: (other: TensorValue | Tensor) => Tensor;

package/dist/core.js

@@ -700,7 +700,7 @@ class Tensor {
         }
         // If dimension out of bound, throw error
         if (dim >= this.shape.length || dim < 0) {
-            throw new Error("Dimension do not exist to chunk");
+            throw new Error("Dimension does not exist to chunk");
         }
         const sliceOpt = new Array(this.shape.length);
         for (let index = 0; index < sliceOpt.length; index++) {
@@ -944,7 +944,7 @@ class Tensor {
         }
         // If dimension out of bound, throw error
         if (dim >= this.shape.length || dim < 0) {
-            throw new Error("Dimension do not exist to sort");
+            throw new Error("Dimension does not exist to sort");
         }
         // Copy if not contiguous
         const outputSize = this.numel;
@@ -1032,7 +1032,7 @@ class Tensor {
         }
         // If dimension out of bound, throw error
         if (dim >= this.shape.length || dim < 0) {
-            throw new Error("Dimension do not exist to get topk");
+            throw new Error("Dimension does not exist to get topk");
         }
         const dimRanges = new Array(this.shape.length);
         for (let index = 0; index < dimRanges.length; index++) {
@@ -1207,7 +1207,7 @@ class Tensor {
     std(dims, keepDims = false) {
         return this.var(dims, keepDims).sqrt();
     }
-    // Tensor softmax
+    // Tensor (stable) softmax
     softmax(dim = -1) {
         if (this.shape.length === 0)
             return this;
@@ -1217,7 +1217,7 @@ class Tensor {
         }
         // If dimension out of bound, throw error
         if (dim >= this.shape.length || dim < 0) {
-            throw new Error("Dimension do not exist to apply softmax");
+            throw new Error("Dimension does not exist to apply softmax");
         }
         const maxVals = this.max(dim, true);
         const shifted = this.sub(maxVals);
@@ -1225,7 +1225,7 @@ class Tensor {
         const sumExp = expVals.sum(dim, true);
         return expVals.div(sumExp);
     }
-    // Tensor softmin
+    // Tensor (stable) softmin
     softmin(dim = -1) {
         if (this.shape.length === 0)
             return this;
@@ -1235,7 +1235,7 @@ class Tensor {
         }
         // If dimension out of bound, throw error
         if (dim >= this.shape.length || dim < 0) {
-            throw new Error("Dimension do not exist to apply softmin");
+            throw new Error("Dimension does not exist to apply softmin");
         }
         const maxVals = this.max(dim, true);
         const shifted = maxVals.sub(this);
@@ -1243,6 +1243,35 @@ class Tensor {
         const sumExp = expVals.sum(dim, true);
         return expVals.div(sumExp);
     }
+    // Tensor (stable) logsumexp
+    logsumexp(dim = -1) {
+        if (this.shape.length === 0)
+            return this;
+        // Handle negative indexing
+        if (dim < 0) {
+            dim += this.shape.length;
+        }
+        // If dimension out of bound, throw error
+        if (dim >= this.shape.length || dim < 0) {
+            throw new Error("Dimension does not exist to apply logsumexp");
+        }
+        const max = this.max(dim, true);
+        return max.add(this.sub(max).exp().sum(dim, true).log());
+    }
+    // Tensor (stable) logsumexp
+    logSoftmax(dim = -1) {
+        if (this.shape.length === 0)
+            return this;
+        // Handle negative indexing
+        if (dim < 0) {
+            dim += this.shape.length;
+        }
+        // If dimension out of bound, throw error
+        if (dim >= this.shape.length || dim < 0) {
+            throw new Error("Dimension does not exist to apply logsumexp");
+        }
+        return this.sub(this.logsumexp(dim));
+    }
     // Tensor element-wise addition
     add(other) {
         return this.elementWiseABDAG(other, (a, b) => a + b, (self, other, outGrad) => outGrad, (self, other, outGrad) => outGrad);

package/dist/nn.d.ts

@@ -64,6 +64,23 @@ export declare class BatchNorm {
     constructor(numFeatures: number, eps?: number, momentum?: number, affine?: boolean, trackRunningStats?: boolean, device?: string, dtype?: dtype);
     forward(input: Tensor): Tensor;
 }
+export declare class InstanceNorm {
+    weight?: Tensor;
+    bias?: Tensor;
+    eps: number;
+    numFeatures: number;
+    constructor(numFeatures: number, eps?: number, affine?: boolean, device?: string, dtype?: dtype);
+    forward(input: Tensor): Tensor;
+}
+export declare class GroupNorm {
+    weight?: Tensor;
+    bias?: Tensor;
+    eps: number;
+    numGroups: number;
+    numChannels: number;
+    constructor(numGroups: number, numChannels: number, eps?: number, affine?: boolean, device?: string, dtype?: dtype);
+    forward(input: Tensor): Tensor;
+}
 export declare class LayerNorm {
     weight?: Tensor;
     bias?: Tensor;
@@ -106,6 +123,8 @@ export declare const nn: {
     GRUCell: typeof GRUCell;
     LSTMCell: typeof LSTMCell;
     BatchNorm: typeof BatchNorm;
+    InstanceNorm: typeof InstanceNorm;
+    GroupNorm: typeof GroupNorm;
     LayerNorm: typeof LayerNorm;
     RMSNorm: typeof RMSNorm;
     Embedding: typeof Embedding;

package/dist/nn.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nn = exports.MultiheadAttention = exports.Embedding = exports.RMSNorm = exports.LayerNorm = exports.BatchNorm = exports.LSTMCell = exports.GRUCell = exports.RNNCell = exports.Linear = void 0;
+exports.nn = exports.MultiheadAttention = exports.Embedding = exports.RMSNorm = exports.LayerNorm = exports.GroupNorm = exports.InstanceNorm = exports.BatchNorm = exports.LSTMCell = exports.GRUCell = exports.RNNCell = exports.Linear = void 0;
 exports.scaledDotProductAttention = scaledDotProductAttention;
 const core_1 = require("./core");
 function linearTransform(input, weight, bias) {
@@ -226,6 +226,110 @@ class BatchNorm {
     }
 }
 exports.BatchNorm = BatchNorm;
+class InstanceNorm {
+    weight;
+    bias;
+    eps;
+    numFeatures;
+    constructor(numFeatures, eps = 1e-5, affine = true, device, dtype) {
+        this.numFeatures = numFeatures;
+        this.eps = eps;
+        if (affine) {
+            this.weight = core_1.Tensor.ones([numFeatures], { requiresGrad: true, device, dtype });
+            this.bias = core_1.Tensor.zeros([numFeatures], { requiresGrad: true, device, dtype });
+        }
+    }
+    forward(input) {
+        // Input should be at least 3D: [N, C, ...spatial dims]
+        if (input.shape.length < 3) {
+            throw new Error("InstanceNorm expects at least 3D input [N, C, ...spatial]");
+        }
+        if (input.shape[1] !== this.numFeatures) {
+            throw new Error(`Expected ${this.numFeatures} channels, got ${input.shape[1]}`);
+        }
+        // Normalize across spatial dimensions (all dims after channel dim)
+        const dims = [];
+        for (let i = 2; i < input.shape.length; i++) {
+            dims.push(i);
+        }
+        const mean = input.mean(dims, true);
+        const variance = input.sub(mean).pow(2).mean(dims, true);
+        let normalized = input.sub(mean).div(variance.add(this.eps).sqrt());
+        if (this.weight) {
+            // Reshape weight to [1, C, 1, 1, ...] for broadcasting
+            const weightShape = [1, this.numFeatures, ...Array(input.shape.length - 2).fill(1)];
+            const weightReshaped = this.weight.reshape(weightShape);
+            normalized = normalized.mul(weightReshaped);
+        }
+        if (this.bias) {
+            // Reshape bias to [1, C, 1, 1, ...] for broadcasting
+            const biasShape = [1, this.numFeatures, ...Array(input.shape.length - 2).fill(1)];
+            const biasReshaped = this.bias.reshape(biasShape);
+            normalized = normalized.add(biasReshaped);
+        }
+        return normalized;
+    }
+}
+exports.InstanceNorm = InstanceNorm;
+class GroupNorm {
+    weight;
+    bias;
+    eps;
+    numGroups;
+    numChannels;
+    constructor(numGroups, numChannels, eps = 1e-5, affine = true, device, dtype) {
+        if (numChannels % numGroups !== 0) {
+            throw new Error(`num_channels (${numChannels}) must be divisible by num_groups (${numGroups})`);
+        }
+        this.numGroups = numGroups;
+        this.numChannels = numChannels;
+        this.eps = eps;
+        if (affine) {
+            this.weight = core_1.Tensor.ones([numChannels], { requiresGrad: true, device, dtype });
+            this.bias = core_1.Tensor.zeros([numChannels], { requiresGrad: true, device, dtype });
+        }
+    }
+    forward(input) {
+        // Input should be at least 3D: [N, C, ...spatial dims]
+        if (input.shape.length < 3) {
+            throw new Error("GroupNorm expects at least 3D input [N, C, ...spatial]");
+        }
+        if (input.shape[1] !== this.numChannels) {
+            throw new Error(`Expected ${this.numChannels} channels, got ${input.shape[1]}`);
+        }
+        const N = input.shape[0];
+        const C = input.shape[1];
+        const spatialDims = input.shape.slice(2);
+        const channelsPerGroup = C / this.numGroups;
+        // Reshape: [N, C, ...spatial] -> [N, G, C//G, ...spatial]
+        const reshapedInput = input.reshape([N, this.numGroups, channelsPerGroup, ...spatialDims]);
+        // Normalize across (C//G, ...spatial) dimensions for each group
+        // That's dims [2, 3, 4, ...] in the reshaped tensor
+        const dims = [];
+        for (let i = 2; i < reshapedInput.shape.length; i++) {
+            dims.push(i);
+        }
+        const mean = reshapedInput.mean(dims, true);
+        const variance = reshapedInput.sub(mean).pow(2).mean(dims, true);
+        let normalized = reshapedInput.sub(mean).div(variance.add(this.eps).sqrt());
+        // Reshape back: [N, G, C//G, ...spatial] -> [N, C, ...spatial]
+        normalized = normalized.reshape(input.shape);
+        if (this.weight) {
+            // Reshape weight to [1, C, 1, 1, ...] for broadcasting
+            const weightShape = [1, this.numChannels, ...Array(spatialDims.length).fill(1)];
+            const weightReshaped = this.weight.reshape(weightShape);
+            normalized = normalized.mul(weightReshaped);
+        }
+        if (this.bias) {
+            // Reshape bias to [1, C, 1, 1, ...] for broadcasting
+            const biasShape = [1, this.numChannels, ...Array(spatialDims.length).fill(1)];
+            const biasReshaped = this.bias.reshape(biasShape);
+            normalized = normalized.add(biasReshaped);
+        }
+        return normalized;
+    }
+}
+exports.GroupNorm = GroupNorm;
 class LayerNorm {
     weight;
     bias;
@@ -461,6 +565,8 @@ exports.nn = {
     GRUCell,
     LSTMCell,
     BatchNorm,
+    InstanceNorm,
+    GroupNorm,
     LayerNorm,
     RMSNorm,
     Embedding,

package/package.json

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